corelang/test.cc

Thing :: const: *U32 = 0;
CONST_VAL::const = 185210591;
new_function::(Thing:[32]U32): U32;

@test(size = 4096)
OpenGL :: struct{
  glVertexAttribPointer: (GLuint, GLint, GLenum, GLboolean, GLsizei, *GLvoid);
  glBindTexture: (GLenum, GLuint);
  glDrawArrays: (GLenum, GLint, GLsizei);
  
  test_array: [10]*int;
  
  thing    : *Things; 
  thing_cap: S64;
  thing_len: S64;
}

OS_Memory::struct{
  data: *void;
  commit: SizeU;
  reserve: SizeU;
}

Arena::struct{
  @using memory: OS_Memory;
  len: U64;
  alignment: U64;
}

String::struct{
  str: *U8;
  len: S64;
}
Intern_String::typedef = String;
//CONST_VALUE::const = 121591;

@stringify
@prefix="TK_"
Token_Kind::enum{
  @str="End of stream" End,
  @str="*" Mul,
  @str="/" Div,
  @str="+" Add,
  @str="-" Sub,
  @str="%" Mod,
  @str="&" BitAnd,
  @str="|" BitOr,
  @str="^" BitXor,
  @str="~" Neg,
  @str="!" Not,
  @str="(" OpenParen,
  @str=" " CloseParen,
  @str="{" OpenBrace,
  @str="}" CloseBrace,
  @str="[" OpenBracket,
  @str="]" CloseBracket,
  @str="," Comma,
  @str="#" Pound,
  @str="?" Question,
  @str="..." ThreeDots,
  @str=";" Semicolon,
  @str="." Dot,
  @str="<" LesserThen,
  @str=">" GreaterThen,
  @str=":" Colon,
  @str="=" Assign,
  @str="/=" DivAssign,
  @str="*=" MulAssign,
  @str="%=" ModAssign,
  @str="-=" SubAssign,
  @str="+=" AddAssign,
  @str="&=" AndAssign,
  @str="|=" OrAssign,
  @str="^=" XorAssign,
  @str="<<=" LeftShiftAssign,
  @str=">>=" RightShiftAssign,
  @str="::" DoubleColon,
  @str="@" At,
  @str="--" Decrement,
  @str="++" Increment,
  @str="--" PostDecrement,
  @str="++" PostIncrement,
  @str="<=" LesserThenOrEqual,
  @str=">=" GreaterThenOrEqual,
  @str="==" Equals,
  @str="&&" And,
  @str="||" Or,
  @str="!=" NotEquals,
  @str="<<" LeftShift,
  @str=">>" RightShift,
  @str="->" Arrow,
  @str="sizeof" ExprSizeof,
  DocComment,
  Comment,
  Identifier,
  StringLit,
  U8Lit,
  Character,
  Error,
  Float,
  Int,
  Keyword,
}

@array(type=block)
Token::struct{
  kind:Token_Kind;
  @using string:String;
  union{
    integer_val:S64;
    error_val:String;
    intern_val:Intern_String;
  }
  file:String;
  line:S64;
  line_begin:*U8;
}

Lex_Stream::struct{
  stream:     *U8;
  line_begin: *U8;
  filename:   String;
  line:       S64;
}

@prefix="EK_"
Expr_Kind::enum{
  None,
  Atom,
  Unary, 
  Binary, 
  Ternary,
  Cast,
  List, 
  Call, 
  Index,
}

Expr:: struct{
  kind: Expr_Kind;
  token: *Token;
  next : *Expr;
  union{
    cast_val: struct{
      type: *AST_Node;
      expr: *Expr;
    }
    list: struct{
      first: *Expr;
      last: *Expr;
    }
    call: struct{
      atom: *Expr;
      list: *Expr;
    }
    index: struct{
      atom: *Expr;
      index: *Expr;
    }
    unary: struct{
      expr: *Expr ;
    }
    binary: struct{
      left: *Expr ;
      right: *Expr ;
    }
    ternary: struct{
      cond: *Expr ;
      on_true: *Expr;
      on_false: *Expr;
    }
  }
}

@prefix="AK_"
AST_Kind::enum{
  None,
  BaseType,
  Typedef,
  Enum,
  Struct,
  Union,
  Note,
  List,
  Pointer,
  Array,
  Function,
  Variable,
  EnumChild,
}

AST_Node::struct{
  kind: AST_Kind;
  pos : *Token;
  name: Intern_String;
  
  next: *AST_Node;
  next_scope: *AST_Node;
  
  first_note: *AST_Node;
  last_note: *AST_Node;
  
  first_child: *AST_Node;
  last_child: *AST_Node;
  union{
    base_type_size: SizeU;
    pointer: *AST_Node;
    typedef_type: *AST_Node;
    variable_type: *AST_Node;
    func_return_type: *AST_Node;
  }
}

Parser_Error :: struct{
  next: *Parser_Error;
  message: String;
  token  : *Token;
}

Scope :: struct{
  next : *Scope;
  first: *AST_Node;
  last : *AST_Node;
}


Parser :: struct{
  main_arena: Arena;
  intern_table_arena: Arena;
  symbol_table_arena: Arena;
  
  scope_free_list: Scope;
  scope_stack: Scope;
  global_scope: Scope;
  
  symbols_inserted: S64;
  symbols_count: S64;
  symbols: AST_Node;
  
  interns: Intern_String;
  interns_in_bytes: S64;
  interns_inserted: S64;
  interns_count: S64;
  
  first_keyword: U8;
  last_keyword:  U8;
  
  //@map(type="sparse") symbols: AST_Node;
  
  // @Todo(Krzosa): This adds default to function name currently
  // And it's hard to anything else sort of except adding
  // a variable of _var_name_lower_with_ or something
  @sllqueue default: Parser_Error;
  
  // This works ok
  @sllqueue error: Parser_Error;
  //@using token_array: Tokens;
}


function_test::(a:U32, b:U32):*U32{
  scratch := get_scratch();
  defer{release_scratch(scratch);} 
  if a > 10 {
    c := b + 10;
    b = c;
  }
  else if a == 20 {
    d := 1241215;
    b = d;
  }
  else {
    c := b+20;
    b = c;
  }
  
  for {
    c: U32 = b + 1;
  }
  
  for i:=0; i < 10; i++ {
    print(i);
  }
  
  return *b;
}