C* - Revision history

Alexander: /* Value cucking / new section; / Control flow hierarchy / new section; / Conditional statement operator */ new section

2024-12-22T20:56:42Z

Value cucking: new section; Control flow hierarchy: new section; Conditional statement operator: new section

@@ Line 475: / Line 475: @@
 ====extern ABI====
 While C* provides the <code>extern</code> linkage modifier as it exists in C, and implies it onto non-<code>static</code> functions as C does, it also provides a C++-like ABI specifier suffix to this keyword as well. Not only does this allow implementations to expose different symbol mangling regimes opaquely to the programmer, in C* it also serves as the veneer to incorporate long foreign symbols into C*'s constraints and, depending on the API design at hand, its domain module system. <code>extern</code> ABI symbols are exempted from the identifier limits imposed in the rest of the language; they can be as long as the compiling machine's memory permits. At the minimum, conforming compilers must support the <code>extern "C"</code> ABI, but may opt to support other ones such as their default C++ ABIs.
 ==Work to be done==

Alexander: we got mangling lol

2024-12-21T22:31:27Z

we got mangling lol

← Older revision		Revision as of 22:31, 21 December 2024
Line 41:		Line 41:

	* nested subroutine declarations		* nested subroutine declarations
	* symbol namespaces and their mangling
	* object-oriented programming facilities, including		* object-oriented programming facilities, including
	** classes (or any form of non-POD structure really)		** classes (or any form of non-POD structure really)
Line 90:		Line 89:

	==Law & order==		==Law & order==

	===Laws===		===Laws===
	C* provides law & order through a few new keywords and a key concept. First among these is, of course, the <code>law</code> keyword, which defines and optionally names constraints to be used on data types. This is semantically accomplished through a series of boolean expressions, like so:		C* provides law & order through a few new keywords and a key concept. First among these is, of course, the <code>law</code> keyword, which defines and optionally names constraints to be used on data types. This is semantically accomplished through a series of boolean expressions, like so:

Alexander: /* Segment routines / new section, and / Identifier limits */ new section

2024-11-14T11:01:54Z

Segment routines: new section, and Identifier limits: new section

@@ Line 314: / Line 314: @@
 The main danger of domains is obfuscation of interface – for this reason, C* disallows <code>using</code> statements outside of block scope, and additionally forbids any form of "wildcard" selectors in <code>using</code> statements entirely. Since the above feature of soft contextualisation applies to all identifiers in a given domain, the application of <code>using</code> statements as a general "decluttering" is avoided and refitted solely as a tool for bringing desired subroutines into scope. In this spirit, C* mandates that <code>using</code> statements are hoisted to the top of the block scope, before all variable declarations.
 ===Flexible anonymous typing===
@@ Line 418: / Line 435: @@
 ===Source encoding===
 The language requires all source code to be ASCII compliant in its raw form. No other encodings of source text are supported, although there is the doc comment exception. This basically means that inside of what C* considers doc comments—that is, comments that begin with <code>/**</code> and end with <code>*/</code>—non-ASCII octets are permitted and will be ignored like the rest of the content of the comment. This makes it possible to encode UTF-8 text in comments, for example, which is important for non-English languages.
 ==Work to be done==

Alexander: fix many typos; /* Statement suites / new section; / Domains */ new section

2024-10-09T20:09:26Z

fix many typos; Statement suites: new section; Domains: new section

Show changes

Alexander: /* Concrete enumerations */ elaborate on semantics and behaviour

2024-06-08T19:28:06Z

Concrete enumerations: elaborate on semantics and behaviour

← Older revision		Revision as of 19:28, 8 June 2024
Line 128:		Line 128:

	<div class="mw-code"><span style="color:hsl(212,60%,40%)">enum</span> <span style="color:rgba(24,24,24,0.667)">:</span> <span style="color:hsl(155,45%,55%)">u32</span><br/><span style="color:rgba(24,24,24,0.667)">{</span><br/> <span style="color:hsl(200,20%,45%)">PRIMA</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">SECUNDA</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">MAX_MYENUM</span><br/><span style="color:rgba(24,24,24,0.667)">}</span><br/><span style="color:rgba(24,24,24,0.333)">/* all of the above enum identifiers are u32s */</span></div>		<div class="mw-code"><span style="color:hsl(212,60%,40%)">enum</span> <span style="color:rgba(24,24,24,0.667)">:</span> <span style="color:hsl(155,45%,55%)">u32</span><br/><span style="color:rgba(24,24,24,0.667)">{</span><br/> <span style="color:hsl(200,20%,45%)">PRIMA</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">SECUNDA</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">MAX_MYENUM</span><br/><span style="color:rgba(24,24,24,0.667)">}</span><br/><span style="color:rgba(24,24,24,0.333)">/* all of the above enum identifiers are u32s */</span></div>

			Concrete enumerations have a set of anonymous members that fill in every possible number representable by their underlying type not already named. They are semantically interchangeable with each other so long as they have the same underlying type, unless they are also legal enumerations.

	====Legal enumerations====		====Legal enumerations====

Alexander: /* Concrete enumerations / new section / New operators */ add three-way comparison operator

2024-06-05T18:31:40Z

Concrete enumerations: new section New operators: add three-way comparison operator

← Older revision		Revision as of 18:31, 5 June 2024
Line 123:		Line 123:
	===Enumerations===		===Enumerations===
	Enumerations have received comparatively modest treatment in the design of C. They still behave as they do in C, with one major conceptual difference: enumerations do not have an implicit typing of <code>int</code> (or any implicit typing at all for that matter). Instead, the values of enumerations in C hold fully arbitrary integers and floating-point numbers, using a big integer implementation for the former and a {{wp\|Unum (number format)#Type I Unum\|Type I Unum}} implementation for the latter. This is made practical by the architecture of the [[Oración]] assembler backend that the [[Sirius C*]] compiler will use. Enumerations do not have a C♯ style "namespacing" effect, so they put their symbols into the main symbol namespace like everything else does in a C compilation unit.		Enumerations have received comparatively modest treatment in the design of C. They still behave as they do in C, with one major conceptual difference: enumerations do not have an implicit typing of <code>int</code> (or any implicit typing at all for that matter). Instead, the values of enumerations in C hold fully arbitrary integers and floating-point numbers, using a big integer implementation for the former and a {{wp\|Unum (number format)#Type I Unum\|Type I Unum}} implementation for the latter. This is made practical by the architecture of the [[Oración]] assembler backend that the [[Sirius C*]] compiler will use. Enumerations do not have a C♯ style "namespacing" effect, so they put their symbols into the main symbol namespace like everything else does in a C compilation unit.

			====Concrete enumerations====
			Since enums in C* are ephemeral by default, it is useful then to have a non-ephemeral enum variant that does indeed carry a concrete type (ergo, a definite size). We call these '''concrete enumerations''' and they are denoted in a familiar syntax borrowed from C++:

			<div class="mw-code"><span style="color:hsl(212,60%,40%)">enum</span> <span style="color:rgba(24,24,24,0.667)">:</span> <span style="color:hsl(155,45%,55%)">u32</span><br/><span style="color:rgba(24,24,24,0.667)">{</span><br/> <span style="color:hsl(200,20%,45%)">PRIMA</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">SECUNDA</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">MAX_MYENUM</span><br/><span style="color:rgba(24,24,24,0.667)">}</span><br/><span style="color:rgba(24,24,24,0.333)">/* all of the above enum identifiers are u32s */</span></div>

	====Legal enumerations====		====Legal enumerations====
Line 128:		Line 133:

	<div class="mw-code"><span style="color:hsl(212,60%,40%)">enum law</span> types<br/><span style="color:rgba(24,24,24,0.667)">{</span><br/> <span style="color:hsl(200,20%,45%)">FIRST</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">SECOND</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">THIRD</span><br/><span style="color:rgba(24,24,24,0.667)">};</span><br/><br/><span style="color:hsl(212,60%,40%)">enum law</span> err<br/><span style="color:rgba(24,24,24,0.667)">{</span><br/> <span style="color:rgba(24,24,24,0.333)">/* Not legal: /</span><br/> <span style="color:hsl(200,20%,45%)">FIRST</span> <span style="color:rgba(24,24,24,0.667)">=</span> <span style="color:hsl(212,55%,55%)">0</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:rgba(24,24,24,0.333)">/ also not legal: /</span><br/> <span style="color:hsl(200,20%,45%)">FOOBAR</span> <span style="color:rgba(24,24,24,0.667)">=</span> <span style="color:hsl(212,55%,55%)">42</span><br/> <span style="color:rgba(24,24,24,0.333)">/ legal enums cannot have their members set to arbitrary values /</span><br/><span style="color:rgba(24,24,24,0.667)">};</span><br/><br/><span style="color:rgba(24,24,24,0.333)">/ this gives you the common pattern of a final enum member MAX_* /<br/>/ sizeof(enum law types) == 3 */</span></div>		<div class="mw-code"><span style="color:hsl(212,60%,40%)">enum law</span> types<br/><span style="color:rgba(24,24,24,0.667)">{</span><br/> <span style="color:hsl(200,20%,45%)">FIRST</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">SECOND</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:hsl(200,20%,45%)">THIRD</span><br/><span style="color:rgba(24,24,24,0.667)">};</span><br/><br/><span style="color:hsl(212,60%,40%)">enum law</span> err<br/><span style="color:rgba(24,24,24,0.667)">{</span><br/> <span style="color:rgba(24,24,24,0.333)">/* Not legal: /</span><br/> <span style="color:hsl(200,20%,45%)">FIRST</span> <span style="color:rgba(24,24,24,0.667)">=</span> <span style="color:hsl(212,55%,55%)">0</span><span style="color:rgba(24,24,24,0.667)">,</span><br/> <span style="color:rgba(24,24,24,0.333)">/ also not legal: /</span><br/> <span style="color:hsl(200,20%,45%)">FOOBAR</span> <span style="color:rgba(24,24,24,0.667)">=</span> <span style="color:hsl(212,55%,55%)">42</span><br/> <span style="color:rgba(24,24,24,0.333)">/ legal enums cannot have their members set to arbitrary values /</span><br/><span style="color:rgba(24,24,24,0.667)">};</span><br/><br/><span style="color:rgba(24,24,24,0.333)">/ this gives you the common pattern of a final enum member MAX_* /<br/>/ sizeof(enum law types) == 3 */</span></div>

			Legal enumerations can also be combined with concrete enumerations to further aid the transient variable lifetime analyser and achieve more comprehensive law enforcement.

	===Structures===		===Structures===
Line 316:		Line 323:
	! style="background-color:rgba(184,184,184,0.75);padding:4px" \| Variant		! style="background-color:rgba(184,184,184,0.75);padding:4px" \| Variant
	! style="background-color:rgba(184,184,184,0.75);padding:4px" \| Notes		! style="background-color:rgba(184,184,184,0.75);padding:4px" \| Notes
			\|-
			\| style="background-color:rgba(224,224,224,0.75);padding:4px" \| three-way compare
			\| style="background-color:rgba(224,224,224,0.75);padding:4px;text-align:center" \| <tt><=></tt>
			\| style="background-color:rgba(224,224,224,0.75);padding:4px;text-align:center" \|
			\| style="background-color:rgba(224,224,224,0.75);padding:4px" \| the return value of this comparator is balanced tri-state logic represented as an ephemeral enumeration of <math>(-1, 0, 1)</math>, corresponding to open (high-Z), low and high circuit states respectively
	\|-		\|-
	\| style="background-color:rgba(224,224,224,0.75);padding:4px" \| minimum		\| style="background-color:rgba(224,224,224,0.75);padding:4px" \| minimum

Alexander: repair unmatched span closing tag

2024-02-06T22:47:57Z

repair unmatched span closing tag

← Older revision		Revision as of 22:47, 6 February 2024
Line 366:		Line 366:
	C* also overloads the meaning of both the division operator <code>/</code> and the modulus operator <code>%</code> in a way that maintains semantic compatibility with C. It uses the multiple return values feature of C* borrowed from Go to make the following semantic equivalences:		C* also overloads the meaning of both the division operator <code>/</code> and the modulus operator <code>%</code> in a way that maintains semantic compatibility with C. It uses the multiple return values feature of C* borrowed from Go to make the following semantic equivalences:

	<div class="mw-code"><span style="color:rgba(24,24,24,0.333)">/* these all have the same effect */</span><br/>a <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">/</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>a<span style="color:rgba(24,24,24,0.667)">,</span> _ <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">/</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>b <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">%</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>b<span style="color:rgba(24,24,24,0.667)">,</span> _ <span style="color:rgba(24,24,24,0.667)">=</span> x %</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/><br/>a<span style="color:rgba(24,24,24,0.667)">,</span> b <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">/</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>b<span style="color:rgba(24,24,24,0.667)">,</span> a <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">%</span> y<span style="color:rgba(24,24,24,0.667)">;</span></div>		<div class="mw-code"><span style="color:rgba(24,24,24,0.333)">/* these all have the same effect */</span><br/>a <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">/</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>a<span style="color:rgba(24,24,24,0.667)">,</span> _ <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">/</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>b <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">%</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>b<span style="color:rgba(24,24,24,0.667)">,</span> _ <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">%</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/><br/>a<span style="color:rgba(24,24,24,0.667)">,</span> b <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">/</span> y<span style="color:rgba(24,24,24,0.667)">;</span><br/>b<span style="color:rgba(24,24,24,0.667)">,</span> a <span style="color:rgba(24,24,24,0.667)">=</span> x <span style="color:rgba(24,24,24,0.667)">%</span> y<span style="color:rgba(24,24,24,0.667)">;</span></div>

	This was done because it is virtually universal that division is performed as a single operation with two output values (the quotient and the remainder). It is prudent to have the language reflect that mechanical reality.		This was done because it is virtually universal that division is performed as a single operation with two output values (the quotient and the remainder). It is prudent to have the language reflect that mechanical reality.

Alexander: perform manual syntax highlighting for remaining codeblocks

2024-02-05T16:14:41Z

perform manual syntax highlighting for remaining codeblocks

@@ Line 84: / Line 84: @@
 C* provides law &amp; order through a few new keywords and a key concept. First among these is, of course, the <code>law</code> keyword, which defines and optionally names constraints to be used on data types. This is semantically accomplished through a series of boolean expressions, like so:
-<pre>/* anonymous law applied to type */
+<div class="mw-code"><span style="color:rgba(24,24,24,0.333)">/* anonymous law applied to type */</span><br/><span style="color:hsl(212,60%,40%)">law</span> <span style="color:rgba(24,24,24,0.667)">:</span> <span style="color:hsl(155,45%,55%)">s32</span><br/><span style="color:rgba(24,24,24,0.667)">{</span><br/>&#9;_ <span style="color:rgba(24,24,24,0.667)">&gt;=</span> <span style="color:hsl(212,55%,55%)">0</span><span style="color:rgba(24,24,24,0.667)">;</span><br/>&#9;_ <span style="color:rgba(24,24,24,0.667)">&lt;</span> <span style="color:hsl(212,55%,55%)">1000</span><span style="color:rgba(24,24,24,0.667)">;<br/>};</span><br/><br/><span style="color:rgba(24,24,24,0.333)">/* named law */</span><br/><span style="color:hsl(212,60%,40%)">law</span> leet</span><br/><span style="color:rgba(24,24,24,0.667)">{</span><br/>&#9;_ <span style="color:rgba(24,24,24,0.667)">==</span> <span style="color:hsl(212,55%,55%)">1337</span><span style="color:rgba(24,24,24,0.667)">;<br/>};</span><br/><br/><span style="color:rgba(24,24,24,0.333)">/* applying previously declared law */</span><br/><span style="color:hsl(212,60%,40%)">law</span> leet</span> <span style="color:rgba(24,24,24,0.667)">:</span> <span style="color:hsl(155,45%,55%)">u16</span><span style="color:rgba(24,24,24,0.667)">;</span></div>
 These laws are enforced upon the data types they apply to at compile time through an exhaustive program analysis. The compiler works backwards to create a control flow tree representing a transient variable lifetime, and exhaustively validates the initialisation and modifications of that transient variable against the laws enacted upon it. This is made practical by formalising the boundaries of the compilation unit as a border between "native" and "foreign" code, which in the essay is called the total system. Data which is confined to this total system gains the performance benefit of fully arbitrary validity checking at compile time.
@@ Line 105: / Line 91: @@
 To deal with foreign code, C* provides a mechanism called '''marshalling'''. This is a definition of marshalling expanded from {{wp|Marshalling (computer science)|its current meaning}} in computer science as a synonym for serialisation, to also include the act of validating data being serialised according to arbitrary schemas, or in the case of C*, arbitrary ''laws.'' All subroutines that are callable from outside the total system must provide marshalling blocks for validating their variables, like so:
-<pre>typedef u8 mybyte;
+<div class="mw-code"><span style="color:hsl(212,60%,40%)">typedef</span> <span style="color:hsl(155,55%,40%)">bit</span><span style="color:rgba(24,24,24,0.667)">[</span><span style="color:hsl(212,55%,55%)">8</span><span style="color:rgba(24,24,24,0.667)">]</span> <span style="color:hsl(155,45%,55%)">mybyte</span><span style="color:rgba(24,24,24,0.667)">;</span><br/><span style="color:hsl(212,60%,40%)">typedef</span> <span style="color:hsl(155,55%,40%)">bit</span><span style="color:rgba(24,24,24,0.667)">[</span><span style="color:hsl(212,55%,55%)">32</span><span style="color:rgba(24,24,24,0.667)">]</span> <span style="color:hsl(155,45%,55%)">u32</span><span style="color:rgba(24,24,24,0.667)">;</span><br/><br/><span style="color:hsl(212,60%,40%)">law</span> <span style="color:rgba(24,24,24,0.667)">:</span> <span style="color:hsl(155,45%,55%)">mybyte</span><br/><span style="color:rgba(24,24,24,0.667)">{</span><br/>&#9;_ <span style="color:rgba(24,24,24,0.667)">&lt;</span> <span style="color:hsl(212,55%,55%)">255</span><span style="color:rgba(24,24,24,0.667)">;</span><br/>&#9;_ <span style="color:rgba(24,24,24,0.667)">!=</span> <span style="color:hsl(212,55%,55%)">0</span><span style="color:rgba(24,24,24,0.667)">;<br/>};</span><br/><br/><span style="color:hsl(155,55%,40%)">void</span> <span style="color:hsl(86,35%,55%)">foo</span><span style="color:rgba(24,24,24,0.667)">(</span> <span style="color:hsl(155,45%,55%)">mybyte</span> a<span style="color:rgba(24,24,24,0.667)">,</span> <span style="color:hsl(155,45%,55%)">u32</span> c <span style="color:rgba(24,24,24,0.667)">)<br/>{</span><br/>&#9;<span style="color:rgba(24,24,24,0.333)">/* marshalling happens one parameter at a time */</span><br/>&#9;<span style="color:hsl(212,60%,40%)">marshal</span> a<br/>&#9;<span style="color:rgba(24,24,24,0.667)">{</span><br/>&#9;&#9;<span style="color:hsl(212,60%,40%)">if</span><span style="color:rgba(24,24,24,0.667)">(</span>a <span style="color:rgba(24,24,24,0.667)">==</span> <span style="color:hsl(212,55%,55%)">0</span><span style="color:rgba(24,24,24,0.667)">)<br/>&#9;&#9;{</span><br/>&#9;&#9;&#9;<span style="color:rgba(24,24,24,0.333)">/* a MUST be set to a valid value through marshalling<br/>&#9;&#9;&#9; * but, we can check around that, smartly */</span><br/>&#9;&#9;&#9;a <span style="color:rgba(24,24,24,0.667)">=</span> <span style="color:hsl(212,55%,55%)">1</span><span style="color:rgba(24,24,24,0.667)">;</span><br/>&#9;&#9;&#9;<span style="color:hsl(212,60%,40%)">break</span><span style="color:rgba(24,24,24,0.667)">;<br/>&#9;&#9;}</span><br/><br/>&#9;&#9;<span style="color:rgba(24,24,24,0.333)">/* exit the function otherwise */</span><br/>&#9;&#9;<span style="color:hsl(212,60%,40%)">return</span><span style="color:rgba(24,24,24,0.667)">;<br/>&#9;}</span><br/><br/>&#9;<span style="color:rgba(24,24,24,0.333)">/* this is the minimum required<br/>&#9; * if ANY laws enacted upon u32, this will fail to compile */</span><br/>&#9;<span style="color:hsl(212,60%,40%)">marshal</span> c<br/>&#9;<span style="color:rgba(24,24,24,0.667)">{ }</span><br/><br/>&#9;<span style="color:rgba(24,24,24,0.333)">/* alternatively, this minimal marshalling will do law checks<br/>&#9; * and return upon any failures, since marshal blocks are only<br/>&#9; * entered when the runtime checks for the laws fail */</span><br/>&#9;<span style="color:hsl(212,60%,40%)">marshal</span> c<br/>&#9;<span style="color:rgba(24,24,24,0.667)">{</span><br/>&#9;&#9;<span style="color:hsl(212,60%,40%)">return</span><span style="color:rgba(24,24,24,0.667)">;<br/>&#9;}<br/>}</span></div>
 Marshal blocks can only reference the parameter they are marshalling. They may declare and modify local variables with automatic storage duration, and may only call pure functions with such parameters.

Alexander: Complete rewrite

2024-02-05T13:12:50Z

Complete rewrite

Show changes

Alexander: /* New enum semantics /, / Struct synonyms / and / Enumerated unions */ new sections

2024-01-30T09:11:26Z

New enum semantics: , Struct synonyms: and Enumerated unions: new sections

@@ Line 119: / Line 119: @@
 : Memory that may be accessed, created and/or destroyed outside of the total system. All laws enacted on a type of object in foreign memory do not apply; instead, the user must apply pacts and marshalling code to validate such data. Use of either the extern or volatile storage modifiers declares a variable as residing in foreign memory.
 |}
 ===New struct semantics===
@@ Line 212: / Line 235: @@
 The value of these semantics is obvious, as it makes it possible to avoid the indirection of having pointers, without requiring abuse of the preprocessor or template/macro metaprogramming. The number, being a compile-time constant, is simply worked into the final definition of the type as if it were present in the struct body itself, dictating its ultimate size and the resulting ABI requirements.
 ===New union semantics===
 C* also provides several new semantic features for unions, most of which help achieve common high-performance optimisation patterns that C programmers would ordinarily be forced to rely on messy CPP macros to achieve.
 ====Union alignment====

C* - Revision history

Alexander: /* Value cucking */ new section; /* Control flow hierarchy */ new section; /* Conditional statement operator */ new section