Loyc.Ecs.EcsCodeSymbols Class Reference

A list of symbols that are very specific to C# or Enhanced C#. Note: many symbols Loyc.Syntax.CodeSymbols should be in this class instead, but this class was created very belatedly. More...

---

Source file:

• /Main/Ecs/EcsCodeSymbols.cs

Inheritance diagram for Loyc.Ecs.EcsCodeSymbols:

Remarks

A list of symbols that are very specific to C# or Enhanced C#. Note: many symbols Loyc.Syntax.CodeSymbols should be in this class instead, but this class was created very belatedly.

Public static fields
static new readonly Symbol	PtrArrow = GSymbol.Get("'->")
	"'->": a->b <=> &lsquo;’->`(a, b)
static new readonly Symbol	Async = GSymbol.Get("#async")
	[#async] Task Foo(); <=> async Task Foo();
static new readonly Symbol	Await = GSymbol.Get("await")
	await(x); <=> await x; (TENTATIVE: should this be changed to #await?)
static new readonly Symbol	DictionaryInitAssign = GSymbol.Get("'[]=")
	&lsquo;’[]=‘(0, 1, x) <=> [0,1]=x (only supported in 'new’ initializer blocks)
static readonly Symbol	ForwardPipeArrow = GSymbol.Get("'|>")
	&lsquo;’|>`(a, b) <=> a |> b
static readonly Symbol	NullForwardPipeArrow = GSymbol.Get("'?|>")
	&lsquo;’?|>`(a, b) <=> a ?|> b
static new readonly Symbol	TriviaCsRawText = GSymbol.Get("%C#RawText")
	"%C#RawText" - C#RawText("stuff") - Raw text that is only printed by the C# printer (not printers for other languages)
static new readonly Symbol	TriviaCsPPRawText = GSymbol.Get("%C#PPRawText")
	"%C#PPRawText" - C#PPRawText("#stuff") - Raw text that is guaranteed to be preceded by a newline and is only printed by the C# printer
static new readonly Symbol	CsRawText = GSymbol.Get("#C#RawText")
static new readonly Symbol	CsPPRawText = GSymbol.Get("#C#PPRawText")
	"#C#PPRawText" - Preprocessor raw text: always printed on separate line
static readonly Symbol	PPNullable = GSymbol.Get("##nullable")
static readonly Symbol	CsiReference = GSymbol.Get("##reference")
static readonly Symbol	CsiLoad = GSymbol.Get("##load")
static readonly Symbol	CsiCls = GSymbol.Get("##cls")
static readonly Symbol	CsiClear = GSymbol.Get("##clear")
static readonly Symbol	CsiHelp = GSymbol.Get("##help")
static readonly Symbol	CsiReset = GSymbol.Get("##reset")
Public static fields inherited from Loyc.Syntax.CodeSymbols
static readonly Symbol	Mul = GSymbol.Get("'*")
	"*" Multiplication (or dereference)
static readonly Symbol	Div = GSymbol.Get("'/")
	"/" Division
static readonly Symbol	Add = GSymbol.Get("'+")
	"+" Addition or unary +
static readonly Symbol	Sub = GSymbol.Get("'-")
	"-" Subtraction or unary -
static readonly Symbol	_Dereference = GSymbol.Get("'*")
	Alias for Mul.
static readonly Symbol	_Pointer = GSymbol.Get("'*")
	Alias for Mul.
static readonly Symbol	_UnaryPlus = GSymbol.Get("'+")
	Alias for Add.
static readonly Symbol	_Negate = GSymbol.Get("'-")
	Alias for Sub. Infix and prefix operators use same symbol.
static readonly Symbol	PreInc = GSymbol.Get("'++")
	"++" Unary prefix increment
static readonly Symbol	PreDec = GSymbol.Get("'--")
	"--" Unary prefix decrement
static readonly Symbol	PostInc = GSymbol.Get("'suf++")
	"suf++" Unary suffix increment
static readonly Symbol	PostDec = GSymbol.Get("'suf--")
	"suf--" Unary suffix decrement
static readonly Symbol	Mod = GSymbol.Get("'%")
	"%" Remainder operator
static readonly Symbol	And = GSymbol.Get("'&&")
	"&&" Logical short-circuit 'and' operator
static readonly Symbol	Or = GSymbol.Get("'||")
	"||" Logical short-circuit 'or' operator
static readonly Symbol	Xor = GSymbol.Get("'^^")
	"^^" Logical 'xor' operator (tentative–this operator is redundant, "!=" is equivalent)
static readonly Symbol	Eq = GSymbol.Get("'==")
	"==" Equality test operator
static readonly Symbol	NotEq = GSymbol.Get("'!=")
	"!=" Inequality test operator
static readonly Symbol	Neq = GSymbol.Get("'!=")
	"!=" Inequality test operator
static readonly Symbol	GT = GSymbol.Get("'>")
	">" Greater-than operator
static readonly Symbol	GE = GSymbol.Get("'>=")
	">=" Greater-than-or-equal-to operator
static readonly Symbol	LT = GSymbol.Get("'<")
	"<" Less-than operator
static readonly Symbol	LE = GSymbol.Get("'<=")
	"<=" Less-than-or-equal-to operator
static readonly Symbol	Matches = GSymbol.Get("'=~")
	"=~" Pattern match test operator
static readonly Symbol	Compare = GSymbol.Get("'<=>")
	"<=>" Three-way comparison a.k.a. shaceship operator
static readonly Symbol	Shr = GSymbol.Get("'>>")
	">>" Right-shift operator
static readonly Symbol	Shl = GSymbol.Get("'<<")
	"<<" Left-shift operator
static readonly Symbol	Not = GSymbol.Get("'!")
	"!" Logical 'not' operator
static readonly Symbol	Assign = GSymbol.Get("'=")
	"=" Assignment operator
static readonly Symbol	ForwardAssign = GSymbol.Get("'|=>")
	Assignment operator with reversed argument order (designed to resemble the pipe operator |>)
static readonly Symbol	ForwardNullCoalesceAssign = GSymbol.Get("'?|=>")
	Null-coalescing assignment with reversed argument order.
static readonly Symbol	OrBits = GSymbol.Get("'|")
	"|" Bitwise or operator
static readonly Symbol	AndBits = GSymbol.Get("'&")
	"&" Bitwise and operator. Also, address-of (unary &)
static readonly Symbol	_AddressOf = GSymbol.Get("'&")
	Alias for AndBits.
static readonly Symbol	NotBits = GSymbol.Get("'~")
	Unary bitwise inversion operator.
static readonly Symbol	_Concat = GSymbol.Get("'~")
	Alias for NotBits. Concat operator in D.
static readonly Symbol	_Destruct = GSymbol.Get("'~")
	Alias for NotBits.
static readonly Symbol	XorBits = GSymbol.Get("'^")
	"^" Bitwise exclusive-or operator
static readonly Symbol	Braces = GSymbol.Get("'{}")
	"{}" Creates a scope.
static readonly Symbol	IndexBracks = GSymbol.Get("'suf[]")
static readonly Symbol	Array = GSymbol.Get("'[]")
	Used for list/array literals. Not used for attributes.
static readonly Symbol	_Bracks = Array
	Synonym for Array (‘’[]`)
static readonly Symbol	TwoDimensionalArray = GSymbol.Get("'[,]")
	int[,] <=> @'of(&lsquo;’[,]`, int)
static readonly Symbol	Async = GSymbol.Get("#async")
	[#async] Task Foo(); <=> async Task Foo();
static readonly Symbol	Await = GSymbol.Get("await")
	await(x); <=> await x; (TENTATIVE: should this be changed to #await?)
static readonly Symbol	NullIndexBracks = GSymbol.Get("'?[]")
	<tt>?[](foo, #(1, A)) <=> foo?[1, A] (TENTATIVE, may be changed later) More...
static readonly Symbol	InitializerAssignment = GSymbol.Get("'[]=")
	&lsquo;’[]=`(0, 1, x) <=> [0,1]=x
static readonly Symbol	AltList = GSymbol.Get("#")
	# is used for lists of things in definition constructs, e.g. #class(Derived, #(Base, IEnumerable), {...}). For a time, 'tuple was used for this purpose; the problem is that a find-and-replace operation intended to find run-time tuples could accidentally match one of these lists. So I decided to dedicate # for use inside special constructs; its meaning depends on context. More...
static readonly Symbol	_HashMark = GSymbol.Get("#")
static readonly Symbol	QuestionMark = GSymbol.Get("'?")
	"'?" Conditional operator. (a?b:c) <=> &lsquo;’?(a,b,c) and int? <=> @'of(@'?`, int)
static readonly Symbol	Of = GSymbol.Get("'of")
	"'of" for giving generic arguments. @'of(List,int) <=> List<int>
static readonly Symbol	Dot = GSymbol.Get("'.")
	"'." binary dot operator, e.g. string.Join
static readonly Symbol	NamedArg = GSymbol.Get("'::=")
	"'::=" Named argument e.g. ‘’::=`(x, 0) <=> x: 0
static readonly Symbol	New = GSymbol.Get("'new")
	"'new": new Foo(x) { a } <=> <tt>'new(Foo(x), a); new[] { ... } <=> <tt>'new(<tt>[](), ...)
static readonly Symbol	NewAttribute = GSymbol.Get("#new")
	"#new": public new void Foo() {} <=> [#public, #new] #fn(#void, Foo, #(), {})
static readonly Symbol	Out = GSymbol.Get("#out")
	"#out": out x <=> [#out] x
static readonly Symbol	Ref = GSymbol.Get("#ref")
	"#ref": ref int x <=> [#ref] #var(#int, x)
static readonly Symbol	Sizeof = GSymbol.Get("'sizeof")
	"'sizeof" sizeof(int) <=> @'sizeof(int)
static readonly Symbol	Typeof = GSymbol.Get("'typeof")
static readonly Symbol	As = GSymbol.Get("'as")
	"'as": @'as(x,string) <=> x as string <=> x(as string)
static readonly Symbol	Is = GSymbol.Get("'is")
	"'is": @'is(x,string) <=> x is string, @'is(x,#var(Foo,v),#(y,z)) <=> x is Foo v(y, z)
static readonly Symbol	Cast = GSymbol.Get("'cast")
	"'cast": @'cast(x,int) <=> (int)x <=> x(-> int)
static readonly Symbol	NullCoalesce = GSymbol.Get("'??")
	"'??": a ?? b <=> &lsquo;’??`(a, b)
static readonly Symbol	PtrArrow = GSymbol.Get("'->")
static readonly Symbol	ColonColon = GSymbol.Get("'::")
	"'::" Scope resolution operator in many languages
static readonly Symbol	Lambda = GSymbol.Get("'=>")
	"'=>" used to define an anonymous function
static readonly Symbol	Default = GSymbol.Get("'default")
	"'default" for the default(T) pseudofunction in C#
static readonly Symbol	IS = GSymbol.Get("'IS")
	Backquoted suffixes in LES3 use this: xbytes <=> 'IS(x, bytes)
static readonly Symbol	NullCoalesceAssign = GSymbol.Get("'??=")
	"'??=": a ??= b means a = a ?? b
static readonly Symbol	MulAssign = GSymbol.Get("'*=")
	"'*=" multiply-and-set operator
static readonly Symbol	DivAssign = GSymbol.Get("'/=")
	"'/=" divide-and-set operator
static readonly Symbol	ModAssign = GSymbol.Get("'%=")
	"'%=" set-to-remainder operator
static readonly Symbol	SubAssign = GSymbol.Get("'-=")
	"'-=" subtract-and-set operator
static readonly Symbol	AddAssign = GSymbol.Get("'+=")
	"'+=" add-and-set operator
static readonly Symbol	ConcatAssign = GSymbol.Get("'~=")
	"'~=" concatenate-and-set operator
static readonly Symbol	ShrAssign = GSymbol.Get("'>>=")
	"'>>=" shift-right-by operator
static readonly Symbol	ShlAssign = GSymbol.Get("'<<=")
	"'<<=" shift-left-by operator
static readonly Symbol	ExpAssign = GSymbol.Get("'**=")
	"'**=" raise-to-exponent-and-set operator
static readonly Symbol	XorBitsAssign = GSymbol.Get("'^=")
	"'^=" bitwise-xor-by operator
static readonly Symbol	AndBitsAssign = GSymbol.Get("'&=")
	"'&=" bitwise-and-with operator
static readonly Symbol	OrBitsAssign = GSymbol.Get("'|=")
	"'|=" set-bits operator
static readonly Symbol	If = GSymbol.Get("#if")
	e.g. #if(c,x,y) and #if(c,x); I wanted it to be the conditional operator too, but the semantics are a bit different
static readonly Symbol	DoWhile = GSymbol.Get("#doWhile")
	e.g. #doWhile(x++, condition); <=> do x++; while(condition);
static readonly Symbol	While = GSymbol.Get("#while")
	e.g. #while(condition,{...}); <=> while(condition) {...}
static readonly Symbol	UsingStmt = GSymbol.Get("#using")
	e.g. #using(expr, {...}); <=> using(expr) {...} (note: use #import or CodeSymbols.Import for a using directive)
static readonly Symbol	For = GSymbol.Get("#for")
	e.g. #for(int i = 0, i < Count, i++, {...}); <=> for(int i = 0; i < Count; i++) {...}
static readonly Symbol	ForEach = GSymbol.Get("#foreach")
	e.g. #foreach(#var(@``, n), list, {...}); <=> foreach(var n in list) {...}
static readonly Symbol	Label = GSymbol.Get("#label")
	e.g. #label(success) <=> success:
static readonly Symbol	Case = GSymbol.Get("#case")
	e.g. #case(10, 20) <=> case 10, 20:
static readonly Symbol	Return = GSymbol.Get("#return")
	e.g. #return(x); <=> return x; [#yield] #return(x) <=> yield return x;
static readonly Symbol	Continue = GSymbol.Get("#continue")
	e.g. #continue(); <=> continue;
static readonly Symbol	Break = GSymbol.Get("#break")
	e.g. #break(); <=> break;
static readonly Symbol	Goto = GSymbol.Get("#goto")
	e.g. #goto(label) <=> goto label;
static readonly Symbol	GotoCase = GSymbol.Get("#gotoCase")
	e.g. #gotoCase(expr) <=> goto case expr;
static readonly Symbol	Throw = GSymbol.Get("#throw")
	e.g. #throw(expr); <=> throw expr;
static readonly Symbol	Checked = GSymbol.Get("#checked")
	e.g. #checked({ stmt; }); <=> checked { stmt; }
static readonly Symbol	Unchecked = GSymbol.Get("#unchecked")
	e.g. #unchecked({ stmt; }); <=> unchecked { stmt; }
static readonly Symbol	Fixed = GSymbol.Get("#fixed")
	e.g. #fixed(#var(@'of(&lsquo;’*`, #int32), x = &y), stmt); <=> fixed(int* x = &y) stmt;
static readonly Symbol	Lock = GSymbol.Get("#lock")
	e.g. #lock(obj, stmt); <=> lock(obj) stmt;
static readonly Symbol	Switch = GSymbol.Get("#switch")
static readonly Symbol	SwitchStmt = GSymbol.Get("#switch")
	e.g. #switch(n, { ... }); <=> switch(n) { ... }
static readonly Symbol	SwitchExpr = GSymbol.Get("'switch")
	e.g. @'switch(x, { ... }); <=> x switch { ... }
static readonly Symbol	Try = GSymbol.Get("#try")
	e.g. #try({...}, #catch(<tt>, @, {...})); <=> try {...} catch {...}
static readonly Symbol	Catch = GSymbol.Get("#catch")
	"#catch" catch clause of #try statement: #catch(#var(Exception,e), whenExpr, {...})
static readonly Symbol	Finally = GSymbol.Get("#finally")
	"#finally" finally clause of #try statement: #finally({...})
static readonly Symbol	Class = GSymbol.Get("#class")
	e.g. #class(Foo, #(IFoo), { }); <=> class Foo : IFoo { }
static readonly Symbol	Struct = GSymbol.Get("#struct")
	e.g. #struct(Foo, #(IFoo), { }); <=> struct Foo : IFoo { }
static readonly Symbol	Trait = GSymbol.Get("#trait")
	e.g. #trait(Foo, #(IFoo), { }); <=> trait Foo : IFoo { }
static readonly Symbol	Enum = GSymbol.Get("#enum")
	e.g. #enum(Foo, #(byte), { }); <=> enum Foo : byte { }
static readonly Symbol	Alias = GSymbol.Get("#alias")
static readonly Symbol	Interface = GSymbol.Get("#interface")
	e.g. #interface(IB, #(IA), { }); <=> interface IB : IA { }
static readonly Symbol	Namespace = GSymbol.Get("#namespace")
	e.g. #namespace(NS, @``, { }); <=> namespace NS { }
static readonly Symbol	Var = GSymbol.Get("#var")
	e.g. #var(#int32, x = 0, y = 1, z); #var(@``, x = 0) <=> var x = 0;
static readonly Symbol	Event = GSymbol.Get("#event")
	e.g. #event(EventHandler, Click, { }) <=> event EventHandler Click { }
static readonly Symbol	Delegate = GSymbol.Get("#delegate")
	e.g. #delegate(#int32, Foo, @'tuple()); <=> delegate int Foo();
static readonly Symbol	Property = GSymbol.Get("#property")
	e.g. #property(#int32, Foo, @``, { get; }) <=> int Foo { get; }
static readonly Symbol	Where = GSymbol.Get("#where")
	"#where" e.g. class Foo<T> where T:class, Foo {} <=> #class(@'of(Foo, [#where(#class, Foo)] T), #(), {});
static readonly Symbol	This = GSymbol.Get("#this")
	"#this" e.g. this.X <=> #this.X; this(arg) <=> #this(arg).
static readonly Symbol	Base = GSymbol.Get("#base")
	"#base" e.g. base.X <=> #base.X; base(arg) <=> #base(arg).
static readonly Symbol	Operator = GSymbol.Get("#operator")
	e.g. #fn(#bool, [#operator] &lsquo;’==`, #(Foo a, Foo b))
static readonly Symbol	Implicit = GSymbol.Get("#implicit")
	e.g. [#implicit] #fn(#int32, [#operator] #cast, (Foo a,))
static readonly Symbol	Explicit = GSymbol.Get("#explicit")
	e.g. [#explicit] #fn(#int32, [#operator] #cast, (Foo a,))
static readonly Symbol	Missing = GSymbol.Empty
	Indicates that a syntax element was omitted, e.g. Foo(, y) => Foo(@``, y)
static readonly Symbol	Splice = GSymbol.Get("#splice")
	When a macro returns #splice(a, b, c), the argument list (a, b, c) is spliced into the surrounding code.
static readonly Symbol	Assembly = GSymbol.Get("#assembly")
	e.g. [assembly: Foo] <=> #assembly(Foo);
static readonly Symbol	Module = GSymbol.Get("#module")
	e.g. [module: Foo] <=> [Foo] #module;
static readonly Symbol	Import = GSymbol.Get("#import")
	#import is used instead of #using because the using(...) {...} statement already uses #using More...
static readonly Symbol	Partial = GSymbol.Get("#partial")
static readonly Symbol	Yield = GSymbol.Get("#yield")
	e.g. #return(x); <=> return x; [#yield] #return(x) <=> yield return x;
static readonly Symbol	ArrayInit = GSymbol.Get("#arrayInit")
	C# e.g. int[] x = {1,2} <=> int[] x = #arrayInit(1, 2)
static readonly Symbol	StackAlloc = GSymbol.Get("#stackalloc")
	#stackalloc for C# stackalloc (TODO)