#if 0


@register
@param_expr(size)
@param_type(Type)
test::struct{
  Array_Block::struct{
    next: Array_Block*;
    data: Type[size];
  }
  
  @inline Array::struct{
    first: Array_Block;
    last : Array_Block*;
    block: S64;
    len  : S64;
  }
  
  array_make::(arena: Arena*) Type {
    thing: Test_Type;
    result: Type;
    result.arena = arena;
    result.last = &result.first;
    return result;
  }
  
  array_push::(array: Array*, item: Type*){
    if array->len+1 > size{
      assert(array->len);
      block: Array_Block* = cast(Thing)arena_push_struct(array->arena, sizeof(:Array_Block));
      array->last = array->last.next = block;
      array->len = 0;
      array->block += 1;
    }
    array->last.data[array->len++] = *item;
  }
}

@test(size = 4096)
OpenGL :: struct{
  glVertexAttribPointer: (GLuint, GLint, GLenum, GLboolean, GLsizei, GLvoid*);
  glBindTexture: (GLenum, GLuint);
  glDrawArrays: (GLenum, GLint, GLsizei);
  
  test_array: int*[10];
  
  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;

@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;
}

/*

@register_tag(sllqueue)
@params(next=next,last=last,first=first)
function void
struct_type_lower_var_name_lower_push(struct_type *parent, var_type *child){
  if(parent->first == 0){
    - parent->first = parent->last = child;
  }
  else{
    - parent->last = parent->last->next = child;
  }
}
*/

#endif