#if 0

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,
}

Token::struct{
  kind:Token_Kind;
  @using string:String;
  val: union{
    integer:S64;
    error:String;
    intern:Intern_String;
  };
  file:String;
  line:S64;
  line_begin:U8*;
}

Tokens::struct{
  @array tokens: Token*;
  iter  : S64;
}

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