Code-X Framework

Since there is no operator overloading in Code-X, all binary expressions must evaluate to bool, char, int8, int16, int32, int64, float32, float64 or an enumeration type.

"A" + "B" (1)

Pointer variables of type IntPtr are translated to void*, which does not allow pointer arithmetic.

IntPtr p = ...;
...
p += 1234; (1)

C# properties may get translated to getter and/or setter methods, which prohibits the use of assignment operators.

SomeClass o = ...;
...
o.SomeProperty += 1234; (1)

The member name X is not allowed, because is violates one or more of the following rules:

The local variable, loop variable or parameter name X is not allowed, because it violates one or more of the rules for member names, except that it may end with an underscore (_).

A non-struct type parameter has a base interface that is annotated with StaticTemplateAttribute.

[StaticTemplate]
interface IMyInterface
{
  ...
}
...
class MyClass1<T> where T : IMyInterface (1)
class MyClass2<T> where T : class,
                            IMyInterface (1)

A struct type parameter has a base interface that is neither IEquatable nor IComparable and is not annotated with StaticTemplateAttribute.

interface IMyInterface
{
  ...
}
...
class MyClass<T> where T : struct,
                           IMyInterface (1)

An expression implicitly causes a non-object value to be boxed as an object, which is not allowed. Use Boxed for explicit boxing of non-object values.

object o;
o = 1234; (1)
o = "1234"; (1)
o = new int[1234]; (1)

A native code region is named incorrectly and will not be recognized by the code generator.

#region Natively {00000000-0000-0000-0000-000000000000} (1)
...
#endregion

The default branch of a switch statement is not the last one, which is not allowed: code generation must be able to convert any switch statement to a sequence of if statements, without having to perform non-trivial code refactoring.

switch(...)
{
  default: (1)
    break;

  case ...:
    break;
}

A delegate refers back to itself via its parameter ist and/or its return type, which is not allowed: such constructs cannot be converted to all Code-X targets.

delegate void MyDelegate(MyDelegate arg); (1)
delegate MyDelegate MyDelegate(); (1)

There are two or more native code regions that have the same GUID.

#region Native {01234567-0000-0000-0000-000000000000} (1)
...
#endregion

#region Native {01234567-0000-0000-0000-000000000000} (1)
...
#endregion

Two or more type declarations have the same type ID. The ID of a type is defined as the hash (see HashUtil.Str) of the fully-qualified type name (see FullName of CxDeclaration).

Two or more types within the same project have the same non-qualified name, which is not allowed.

namespace A
{
  class C { ... } (1)
}

namespace B
{
  class C { ... } (1)
}

Code-X treats exceptions as values. Assigning an exception value to a base type in C++ will slice the object, which must be avoided.

class BoomException : Exception { ... }

Exception Boom()
{
  return new BoomException(); (1)
}

The evaluation order of expressions is fully defined by the C# specification. However, this is not necessarily the case for all Code-X targets. To compensate for this, multiple nested expressions with side-effects are not allowed (see PureAttribute).

int[] a = ...;
int b = 0;

a[b++] = a[--b]; (1)
SomeMethod(b++, --b); (1)

The declaration of an extension method is not located in the same namespace as its target type.

namespace A
{
  static class MyExtensions
  {
    static void MyMethod(this MyClass obj) { ... } (1)
  }
}

namespace B
{
  class MyClass { ... }
}

A constants with a string or non-primitive value type refers to another constant in its initializer expression. The creates a dependency on the order of initialization, which cannot be guaranteed for all Code-X targets.

const string A = "...";
const string B = A + "!"; (1)

static readonly IntPtr A = IntPtr.Zero;
static readonly IntPtr B = A + 1; (1)

In Code-X, arrays cannot be treated as objects, as it is possible in C#.

int[] a = ...;
object o = ...;

if (a == o) (1)
  ...;

A method with the [Assertion] attribute does not have the required form:

[Assertion]
class MyException : Exception
{
  public static ExceptionA Boom() { ... }
}
...
[Assertion]
void AssertTrue(bool value)
{
  if (!value)
    throw MyException.Boom();
}

A static and readonly field does not have an initializer expression or it is none of the following: an array creation expression, an expression of object, struct or delegate type.

An assertion method does not return void.

[Assertion]
bool AssertTrue() { ... }

An object or array creation expression is used as an initializer for a field that is not static and readonly.

class MyClass
{
  int[] A = new ...; (1)
  object B = new ...; (1)
  static int[] C = new ...; (1)
  static object D = new ...; (1)
  readonly int[] E = new ...; (1)
  readonly object F = new ...; (1)
}

In Code-X, exceptions may only carry error information from the throw statement to the catch block, which limits their allowed usages throw and return statements.

A case in a switch statement declares a local variable, which is not allowed by Code-X. Instead, a block statement may be used as case body.

switch (...)
{
  case ...:
    int a; (1)
    break;

  case ...:
  {
    int b;
    break;
  }
}

A member has the same name as its enclosing type declaration. Although valid in C#, this is not supported in all Code-X targets and thus not allowed. Property members are an exception, they may have the same name.

The modulo operator % behaves differently across Code-X targets and is thus not allowed.

float a = ...;
float b = ...;
float c;

c = a % b; (1)

For some Code-X targets, properties must be output as separate getter and setter methods. An existing member has a conflicting name.

int Value { get; set; }
void SetValue(); (1)
void GetValue(); (1)

An expression that sets a property value is not an expression statement, which is not allowed. Such expressions need to be translated into calls to a setter method, which returns void.

int Value { get; set; }
...
int a = Value = 100; (1)

A field uses an array creation expression (with length) as initializer but is not both static and readonly.

readonly int[] A = new int[100]; (1)
static int[] A = new int[100]; (1)
static readonly int[] A = new int[100];

An array creation expression (with value list) is used in a context that is not a field initializer.

int[] a;
a = new int[] { 1, 2, 3 }; (1)

An array creation expression (with value list) is used in a nested expression, which is not allowed.

MyMethod(new int[] { 1, 2, 3 }); (1)

Type and member declarations may be annotated with the BetaAttribute attribute, in order to tag them as experimental. Per convention, regular code must not break when all experimental code is removed. In consequence, a non-beta node must not reference a beta node.

[Beta]
class MyClass { ... }
...
class MyClass2 : MyClass { ... } (1)
...
[Beta]
void MyMethod() { ... }
...
void MyMethod2()
{
  MyMethod(); (1)
}

Semantics of global initialization of static fields differ between Code-X targets. To get well-defined behaviour, static non-readonly fields may only be initialized to their default value and further initialization must be performed by code, after global initialization has completed.

static readonly Vec3I OneTwoThree = new Vec3I(1, 2, 3);
...
static Vec3I SomeValue;
...
static Vec3I SomeValue = new Vec3I(1, 2, 3); (1)

Within a group of equally named methods that have the same number of parameters, there are two or more signatures that have a delegate parameter, which is not allowed by Code-X:

delegate void MyDelegate1();
delegate void MyDelegate2();
...
void MyMethod(int argument);
void MyMethod(MyDelegate1 func); (1)
void MyMethod(MyDelegate2 func); (1)

The finally block of a try statement uses internal or private members, which is not allowed by Code-X:

public void Cleanup1() { ... }
internal void Cleanup2() { ... }
...
try { ... }
finally
{
  Cleanup1();
  Cleanup2(); (1)
}

The finally block of a try statement may only target local variables, field members or type declarations:

public class MyClass
{
  public static Cleanup() { ... }
}
...
Begin();
try { ... }
finally
{
  End(); // Begin/End pair is ok.
}
...
End();
try { ... }
finally
{
  Begin(); // End/Begin pair is ok.
}
...
try { ... }
finally
{
  Dispose(); // Dispose is ok.
}
...
try { ... }
finally
{
  MyClass.Cleanup(); // Static calls are ok.
}
...
// <T> is a local variable, a field member or a type declaration.
// <Call> is Begin, End or Dispose.
// <E?> is a name expression.
try { ... }
finally
{
  <T>.<Call>(); // Ok
  <T>.<E1>.<Call>(); // Ok
  <T>.<E1>.<E2>.<Call>(); // Ok
  <T>.<E1>...<En>.<Call>(); // Ok
}

The [Raw] attribute is used by some methods in an override chain, but not by all of them:

public virtual void MethodA([Raw] int[] values) { ... }
...
public override void MethodA(int[] values) { ... } (1)

A readonly instance field has not been initialized in the constructor:

class MyClass
{
  readonly Vec3I a;
  readonly Vec3I b; (1)

  MyClass(Vec3I a)
  {
    this.a = a;
  }
}

A readonly instance field is initialized more than once in the constructor:

class MyClass
{
  readonly int a; (1)
  readonly int b; (1)
  readonly int c;
  readonly int d;

  MyClass(int a, int b, int c, int d)
  {
    int temp;

    this.a = a;
    this.a += b;

    if (b < 0)
      this.b = -b;
    else
      this.b = b;

    this.c = c < 0 ? -c : c;

    if (d < 0)
      temp = -d;
    else
      temp = d;

    this.d = temp;
  }
}

For some Code-X targets, method parameters with reference types are passed as plain pointers, instead of using smart pointer wrapper objects. Assigning another reference to such a plain pointer would break the reference-counting logic:

void Method(object o)
{
  o = new object(); (1)
}

Safe-cast and instance-of expressions on generic types are only allowed when referring to the enclosing generic type declaration:

class MyClass<T1, T2>
{
  void Method(object o)
  {
    MyClass<?, ?> a;
    MyClass<T1, T2> b;

    a = (MyClass<?, ?>) o; // Ok

    if (o is MyClass<T1, T2>) ... // Ok

    b = o as MyClass<T1, T2> // Ok

    if (o is MyClass<T2, T1>) ... (1)

    if (o is MyClass<int, int>) ... (1)
  }
}

A 32-bit integer value is shifted leftwards by 32 bits or more, which effectively produces zero:

int a = 1 << 32; (1)
int b = 1L << 32;

A static readonly field does not have an initializer expression:

A static readonly field has a compile-time constant value and must be declared as a constant:

public static readonly int Zero = 0; (1)
public const int One = 1;

A class implements an interface that is annotated with StaticTemplateAttribute, which is not allowed.

[StaticTemplate]
interface ITrait { ... }

class MyClass : ITrait (1)
{ ... }

A struct type implements a prohibited interface. Allowed interfaces are StaticTemplateAttribute, IEquatable and IComparable.

[StaticTemplate]
interface ITrait { ... }

struct MyStruct : IInterface (1)
{ ... }

struct MyStruct : ITrait
{ ... }

struct MyStruct : IEquatable<MyStruct>
{ ... }

struct MyStruct : IComparable<MyStruct>
{ ... }

For some Code-X targets, method parameters with struct types are passed as constant references, instead of value copies. Assigning values to such a constant reference would cause compilation errors:

void Method(Vec3I v)
{
  v = new Vec3I(1, 2, 3); (1)
}

A variable of an Exception type may only be accessed in specific ways:

For some Code-X targets, Code-X translates try-finally statements to alternative code constructs, for example RAII for C++. To be able to define precise semantics for this translation, only the following finally block flavours are allowed:

...
// See IDisposable
finally { Dispose(); }
finally { <expr>.Dispose(); }
...
// See IBeginEnd
finally { Begin(); }
finally { End(); }
finally { <expr>.Begin(); }
finally { <expr>.End(); }
...
// Static method call
finally { <Type>.<Name>(); }

A type has a prohibited name suffix:

// Reserved for non-Code-X native code.
class MyClassNative (1)
{ ... }

// Reserved for unit-test code.
class MyClassTest (1)
{ ... }

The dependencies within the given set of types would have cycles when being output to C, for example:

struct MyStructA (1)
{
  public MyStructB ToB() { ... }
}
...
struct MyStructB (1)
{
  public MyStructA ToA() { ... }
}

A constructor of a non-sealed class calls an effectively virtual method, which is not allowed in all Code-X targets:

class MyBase
{
  protected virtual DoSomething1() { ... }
}
...
class MyClass : MyBase
{
  protected override sealed DoSomething1() { ... }

  protected virtual DoSomething2() { ... }

  protected DoSomething3() { ... }

  public MyClass()
  {
    DoSomething1();
    DoSomething2(); (1)
    DoSomething3();
  }
}

An array-typed method parameter may only be used to access the array elements:

void Method([Raw] int[] a)
{
  int v;

  v = a[0];
  v += a[a.Length - 1]; (1)
}

The code element indicated by X contains an unresolved reference or is otherwise incomplete.

A statement that performs an assertion or a precondition check is not wrapped in a conditional DEBUG preprocessor-block:

class MyType : Disposable
{
  void MyMethod()
  {
    #if DEBUG
    this.AssertValid("MyType.MyMethod");
    #endif

    this.AssertValid("MyType.MyMethod"); (1)
  }
}

For some Code-X targets, struct values are passed by-reference, to avoid copying. Allowing modification of field values would break the pass-by-value semantic. Because of this, Code-X requires that all fields of a struct are readonly:

struct
{
  int A; (1)
  readonly int B;
}

The statement throws an assertion exception but is not wrapped in an assertion method:

[Assertion]
void AssertTrue(string source, bool value)
{
  if (!value)
    throw FailedAssertionException.BadState(source, "not true");
}
...
void MyMethod(bool value)
{
#if DEBUG
  AssertTrue(value);

  if (!value)
    throw FailedAssertionException.BadState(source, "not true"); (1)
#endif
}

A field with ownership is set to null, without a prior call to Dispose.

class MyClass : IDisposable
{
  [Owner]
  MyClass next;

  void ClearOk()
  {
    next.Dispose();
    next = null;
  }

  void ClearBad()
  {
    next = null; (1)
  }
}

The value of a ref / out method parameter is used for multiple arguments of an invocation expression, having both by-value and by-reference semantic. Code-X does not allow that, in order to be able to pass values via immutable references.

void MethodA(ref Vec3I value)
{
  MethodB(value, value); (1)
}

void MethodB(Vec3I a, ref Vec3I b)
{
  b = a.Add(b);
}

A disposable class has one ore more fields of a reference type. Such fields must be cleared upon disposal, but the class does not define a disposal method.

class MyClass1 : Disposable (1)
{
  object o;
}
...
class MyClass2 : Disposable (1)
{
  object o;

  void Dispose()
  {
    o = null;
  }
}

Each native code region must be preceded by a single-line comment in the form // NATIVE: …​, which may optionally be followed by a // THROWS: TException single-line comment, which indicates that the native code block may throw exceptions of type TException.

#region Native {...} (1)
...
#endregion

// NATIVE: Short description of native code block
// THROWS: MyException

#region Native {...}
...
#endregion

For some Code-X targets, types cannot be declared as non-public. To make sure that constructors of non-public types are not used inadvertently, Code-X requires that the constructors themselves are declared as non-public.

public class MyClass1
{
  public void MyClass1() { ... }
}
...
internal class MyClass1
{
  public void MyClass1() { ... } (1)
}

A disposable class overrides the Dispose method of its base class but does not call base.Dispose(), which breaks disposal.

A field with ownership is disposed, without a subsequent clear to null.

class MyClass : IDisposable
{
  [Owner]
  MyClass next;

  void ClearOk()
  {
    next.Dispose();
    next = null;
  }

  void ClearBad()
  {
    next.Dispose(); (1)
  }
}

The statement that calls the dispose method (see DisposeAttribute) is not an expression statement.

IDisposable[] d = ...;

for (int i = 0; i < d.Length; d[i].Dispose(), ++i); (1)

for (int i = 0; i < d.Length; ++i)
  d[i].Dispose();

The dispose method of a disposable class does not clear its instance field named X.

class MyClass : Disposable
{
  int a;
  object b;
  string c; (1)

  void Dispose()
  {
    b = null;
  }
}

An expression tries to perform an invalid ownership transfer. See OwnerAttribute for details.

The method or property preconditions are invalid. For details on how to write valid preconditions, please refer to InvalidArgumentException and Precondition.

The Serializer field of a struct does not have the required form:

struct A
{
  public static readonly ITypeSerializer<A> Serializer = ...;
}

struct B
{
  public static readonly ITypeSerializerEx<B> Serializer = ...;
}

The last item of an enumeration that is annotated with FlagsAttribute is required to contain all defined flags. The values X or Y may be used to correct the code.

[Flags]
enum MyEnum (1)
{
  None = 0,
  One = 1,
  Two = 2,
  All = 1 // X = 3
}

[Flags]
enum MyEnum (2)
{
  None = 0,
  One = 1,
  Two = 2,
  Four = 4 // X = 3, Y = 7
}

A member is annotated with [Internal] but is not declared as public.

[Internal]
protected void MyMethod() { ... } (1)

Code-X requires enum declaration to have an item with the ordinal value 0, in order to have a well-defined default value in all targets.

enum MyEnum (1)
{
  One = 1,
  Two = 2
}

A throw statement throws an assertion exception but is not wrapped in a DEBUG preprocessor-block.

#if DEBUG
throw FailedAssertionException.BadState(...);
#endif

throw FailedAssertionException.BadState(...); (1)

The member X is non-public but is referenced from the public code element Y in a way that would make it visible in the public scope.

A DEBUG preprocessor block contains a statement that is neither an assertion nor a precondition check.

#if DEBUG
// Assertion is ok.
Assert(...);

// Precondition check is ok.
if (...)
  throw InvalidArgumentException.Custom(...);

Console.Write("not ok"); (1)
#endif

A method parameter uses ref or out semantic but does not have a struct type.

void MyMethod(ref int a, out string b) { ... } (1)

An expression with ownership is assigned to a target without ownership (see OwnerAttribute), so the ownership transfer is not possible.

Disposable a;
Disposable b; // [!]
Disposable c;

a = new Disposable(); (1)
c = b = new Disposable();

Along the chain of overriding methods, the [Owner*] attributes must only be present on the root member.

After initialization, the value of a static readonly field will not change. Regarding ownership, this would mean that the owned object will never be disposed.

A non-disposable type declares an instance field with ownership. This is only allowed in disposable types, to make sure that all ownership rules are obeyed.

The last name part of a name with multiple parts resolved to a different type. For example: MyStuff.TerrainDecal resolves to an application-specific class, where as TerrainDecal refers to TerrainDecal.

The result of an object creation expression is not stored in a variable.

MyClass a;
MyClass b;

a = new MyClass(...);
b = ... ? new MyClass(...) : new MyClass(...); (1)

The result of an array creation expression is not stored in a variable.

int[] a;
int[] b;

a = new int[10];
b = ... ? new int[10] : new [20]; (1)

A method is part of the global shutdown sequence (see ShutdownAttribute) but is not declared as public and static.

class MyClass
{
  [Shutdown]
  public static void ProperShutdown() { ... }

  [Shutdown]
  static void PrivateShutdown() { ... } (1)

  [Shutdown]
  public void InstanceShutdown() { ... } (1)
}

A static readonly field with on object or delegate type is declared without being annotated with ShutdownSurviveAttribute.

An instance field with a struct value is not initialized in the type constructor. This does not apply to constructors annotated with [Internal].

class MyClass
{
  Vec3I a;
  Vec3I b; (1)

  [Internal]
  MyClass() { }

  MyClass(Vec3I a) (1)
  {
    this.a = a;
  }
}

The target of an invocation expression that calls a dispose method does not have ownership.

class MyClass : Disposable
{
  [Owner]
  MyDisposable a;

  MyDisposable b;

  void Dispose()
  {
    a.Dispose();
    b.Dispose(); (1)
  }
}

The // THROWS: comment of a native code block cannot be resolved into an Exception type.

// NATIVE: ...
// THROWS: UnresolvableException (1)

#region Native {...}
...
#endregion

The [Assertion] attribute is present on a method that is not an assertion method.

A method performs an assertion but is not annotated as an assertion method:

[Assertion]
static void AssertTrue(string source, bool value)
{
  if (!value)
    throw FailedAssertionException.BadState(source, "not true");
}

static void AssertFalse(string source, bool value) (1)
{
  if (value)
    throw FailedAssertionException.BadState(source, "not false");
}

A property with a getter but not setter must have a name that starts with a question word:

The catch block of a try statement tries to catch an exception type that is never thrown.

try
{
  int a = 10;
}
catch(IOException e) (1)
{
  ...
}

Each native code block must be preceded by a single-line comment that starts with // NATIVE:.

// NATIVELY: ... (1)

#region Native {...}
...
#endregion

The parameters of a delegate should not have precondition constraints (see InvalidArgumentException), because these will not be checked by Code-X.

An exception is documented as being thrown by a member, but the member body never actually throws it.

/// <summary>
///   Summary
/// </summary>
/// <exception cref="BadException">If something bad happens.</exception> (1)
int Add(int a, int b)
{
  return a + b;
}

The [ShutdownSurvive] annotation is present both on the field and the type.

[ShutdownSurvive]
class MyType { ... }

class MyOtherType
{
  [ShutdownSurvive]
  static MyType Surviver = new MyType(); (1)
}

The items of an enumeration that is annotated with neither FlagsAttribute nor SemanticEnumAttribute should have contiguous ordinal values, to avoid undefined values when iterating over the value range.

enum MyEnum (1)
{
  Zero = 0,
  Two = 2
}

[Flags]
enum MyEnum
{
  Zero = 0,
  Two = 2
}

[PersistentEnum]
enum MyEnum
{
  Zero = 0,
  Two = 2
}

In a chain of overriding members, only the root member may be documented, because only the root member provides the full specification for its implementation. Implementing and overriding members must adhere to this specification.

The member documentation contains a documentation entry for an implicit exception:

Error source tags (see TinmanError.ErrorSource) are used as a minimalistic stacktrace facility that acts as fallback when the native stacktrace information is not available. Error source tags break easily during refactoring, so this warning makes sure that they stay up-to-date.

A factory method that creates an exception for throwing must accept an error source tag (see TinmanError.ErrorSource) as first parameter.

static MyException Boom(string source)
{
  return new MyException(source);
}

A member does not have a documentation comment.

The default Code-X coding guidelines indicate that the member name should be lowercase.

The default Code-X coding guidelines indicate that the member name should be uppercase.

The documentation of a method does not document the return value.

The documentation comment of a method contains an element for the return value, but the method returns void.

Overriding method must use the same parameter names as the root member.

This is the opposite of 'Boolean-getter property must start with a question word'.

An array is passed to a method that only uses the array elements and should therefore be passed as [Raw], which will allow raw pointers to be passed instead of an array wrapper object for some Code-X targets.

The documentation of the member parameters is incomplete or incorrect.

The documentation of a property does not document the property value.

The [Raw] attribute is used in an invalid context.

A struct type is not marked with [NotSerializable] (and thus serializable) but does not declare a Serializer field.

For each static field, the behaviour during global shutdown must be specified by using one of the [Shutdown*] attributes.

The Serializer of a struct type must be a public and static field.

Code-X does not allow automatic boxing of value types into objects, so a struct type must not override any method of object, except GetHashCode and ToString.

The body of a member throws an exception which is not included in the documentation of the root member.

A type declaration has no documentation comment.

A method is assigned to a delegate variable which may throw an exception that is not allowed by the delegate declaration.

A native code block is incomplete for one or more Code-X targets. A block is considered incomplete in any of the following cases:

A word in a code comment is spelled incorrectly. To resolve, add the word to one of the word lists of the dictionary when running the Code-X Processor.

The fully-qualified name of the type declaration in the code unit does not start with the common name prefix that has been configured for the GPU code module.

The code unit does not match any of the processable flavours, for example a constant buffer, shader resources or shader code.

The code construct X is not supported.

abstract, as, base, bool, break, byte, case, catch, char, checked, class, const, continue, decimal, default, delegate, do, double, else, enum, event, explicit, extern, false, finally, fixed, float, for, foreach, goto, if, implicit, in, int, interface, internal, is, lock, long, namespace, new, null, object, operator, out, override, params, private, protected, public, readonly, ref, return, sbyte, sealed, short, sizeof, stackalloc, static, string, struct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort, using, virtual, void, volatile, while

alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break, case, catch, char, char8_t, char16_t, char32_t, class, compl, concept, const, consteval, constexpr, constinit, const_cast, continue, co_await, co_return, co_yield, decltype, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, noexcept, not, not_eq, nullptr, operator, or, or_eq, private, protected, public, register, reinterpret_cast, requires, return, short, signed, sizeof, static, static_assert, static_cast, struct, switch, template, this, thread_local, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while, xor, xor_eq

abstract, continue, for, new, switch, assert, default, goto, package, synchronized, boolean, do, if, private, this, break, double, implements, protected, throw, byte, else, import, public, throws, case, enum, instanceof, return, transient, catch, extends, int, short, try, char, final, interface, static, void, class, finally, long, strictfp, volatile, const, float, native, super, while

id

CSTRING, NATIVE_BLOCK_BEGIN, NATIVE_BLOCK_END, NATIVE_INCLUDE_BEGIN, NATIVE_INCLUDE_END, NATIVE_REGION_BEGIN, NATIVE_REGION_END, ZCHAR, ZSTRING, float32, float64, int16, int32, int64, int8, ptr, uint64, zchar