package core:odin/parser

Source

Error_Handler :: proc(pos: odin_tokenizer.Pos, fmt: string, .. args: ..any)

Expr_And_Flags :: struct {
	expr:  ^odin_ast.Expr,
	flags: odin_ast.Field_Flags,
}

Flag :: enum u32 {
	Optional_Semicolons, 
}

Flags :: distinct bit_set[Flag; u32]

Import_Decl_Kind :: enum int {
	Standard, 
	Using, 
}

Parser :: struct {
	file:             ^odin_ast.File,
	tok:              odin_tokenizer.Tokenizer,
	// If .Optional_Semicolons is true, semicolons are completely as statement terminators
	// different to .Insert_Semicolon in tok.flags
	flags:            Flags,
	warn:             Warning_Handler,
	err:              Error_Handler,
	prev_tok:         odin_tokenizer.Token,
	curr_tok:         odin_tokenizer.Token,
	// >= 0: In Expression
	// <  0: In Control Clause
	// NOTE(bill): Used to prevent type literals in control clauses
	expr_level:       int,
	allow_range:      bool,
	// NOTE(bill): Ranges are only allowed in certain cases
	allow_in_expr:    bool,
	// NOTE(bill): in expression are only allowed in certain cases
	in_foreign_block: bool,
	allow_type:       bool,
	lead_comment:     ^odin_ast.Comment_Group,
	line_comment:     ^odin_ast.Comment_Group,
	curr_proc:        ^odin_ast.Node,
	error_count:      int,
	fix_count:        int,
	fix_prev_pos:     odin_tokenizer.Pos,
	peeking:          bool,
}

Stmt_Allow_Flag :: enum int {
	In, 
	Label, 
}

Stmt_Allow_Flags :: distinct bit_set[Stmt_Allow_Flag]

Warning_Handler :: proc(pos: odin_tokenizer.Pos, fmt: string, .. args: ..any)

MAX_FIX_COUNT :: 10

advance_token :: proc(p: ^Parser) -> odin_tokenizer.Token {…}

allow_token :: proc(p: ^Parser, kind: odin_tokenizer.Token_Kind) -> bool {…}

check_field_flag_prefixes :: proc(p: ^Parser, name_count: int, allowed_flags, set_flags: odin_ast.Field_Flags) -> (flags: odin_ast.Field_Flags) {…}

check_procedure_name_list :: proc(p: ^Parser, names: []^odin_ast.Expr) -> bool {…}

collect_package :: proc(path: string) -> (pkg: ^odin_ast.Package, success: bool) {…}

consume_comment :: proc(p: ^Parser) -> (tok: odin_tokenizer.Token, end_line: int) {…}

consume_comment_group :: proc(p: ^Parser, n: int) -> (comments: ^odin_ast.Comment_Group, end_line: int) {…}

consume_comment_groups :: proc(p: ^Parser, prev: odin_tokenizer.Token) {…}

convert_stmt_to_body :: proc(p: ^Parser, stmt: ^odin_ast.Stmt) -> ^odin_ast.Stmt {…}

convert_stmt_to_expr :: proc(p: ^Parser, stmt: ^odin_ast.Stmt, kind: string) -> ^odin_ast.Expr {…}

convert_to_ident_list :: proc(p: ^Parser, list: []Expr_And_Flags, ignore_flags, allow_poly_names: bool) -> []^odin_ast.Expr {…}

default_error_handler :: proc(pos: odin_tokenizer.Pos, msg: string, .. args: ..any) {…}

default_parser :: proc(flags: Flags = Flags{.Optional_Semicolons}) -> Parser {…}

default_warning_handler :: proc(pos: odin_tokenizer.Pos, msg: string, .. args: ..any) {…}

end_of_line_pos :: proc(p: ^Parser, tok: odin_tokenizer.Token) -> odin_tokenizer.Pos {…}

end_pos :: proc(tok: odin_tokenizer.Token) -> odin_tokenizer.Pos {…}

error :: proc(p: ^Parser, pos: odin_tokenizer.Pos, msg: string, .. args: ..any) {…}

expect_closing_brace_of_field_list :: proc(p: ^Parser) -> odin_tokenizer.Token {…}

expect_closing_parentheses_of_field_list :: proc(p: ^Parser) -> odin_tokenizer.Token {…}

expect_closing_token_of_field_list :: proc(p: ^Parser, closing_kind: odin_tokenizer.Token_Kind, msg: string) -> odin_tokenizer.Token {…}

expect_operator :: proc(p: ^Parser) -> odin_tokenizer.Token {…}

expect_semicolon :: proc(p: ^Parser, node: ^odin_ast.Node) -> bool {…}

expect_semicolon_newline_error :: proc(p: ^Parser, token: odin_tokenizer.Token, s: ^odin_ast.Node) {…}

expect_token :: proc(p: ^Parser, kind: odin_tokenizer.Token_Kind) -> odin_tokenizer.Token {…}

expect_token_after :: proc(p: ^Parser, kind: odin_tokenizer.Token_Kind, msg: string) -> odin_tokenizer.Token {…}

fix_advance_to_next_stmt :: proc(p: ^Parser) {…}

is_blank_ident_node :: proc(node: ^odin_ast.Node) -> bool {…}

is_blank_ident_string :: proc(str: string) -> bool {…}

is_blank_ident_token :: proc(tok: odin_tokenizer.Token) -> bool {…}

is_literal_type :: proc(expr: ^odin_ast.Expr) -> bool {…}

is_non_inserted_semicolon :: proc(tok: odin_tokenizer.Token) -> bool {…}

is_package_name_reserved :: proc(name: string) -> bool {…}

is_semicolon_optional_for_node :: proc(p: ^Parser, node: ^odin_ast.Node) -> bool {…}

is_token_field_prefix :: proc(p: ^Parser) -> odin_ast.Field_Flag {…}

new_ast_field :: proc(names: []^odin_ast.Expr, type: ^odin_ast.Expr, default_value: ^odin_ast.Expr) -> ^odin_ast.Field {…}

new_blank_ident :: proc(p: ^Parser, pos: odin_tokenizer.Pos) -> ^odin_ast.Ident {…}

next_token0 :: proc(p: ^Parser) -> bool {…}

parse_atom_expr :: proc(p: ^Parser, value: ^odin_ast.Expr, lhs: bool) -> (operand: ^odin_ast.Expr) {…}

parse_attribute :: proc(p: ^Parser, tok: odin_tokenizer.Token, open_kind, close_kind: odin_tokenizer.Token_Kind, docs: ^odin_ast.Comment_Group) -> ^odin_ast.Stmt {…}

parse_binary_expr :: proc(p: ^Parser, lhs: bool, prec_in: int) -> ^odin_ast.Expr {…}

parse_block_stmt :: proc(p: ^Parser, is_when: bool) -> ^odin_ast.Stmt {…}

parse_body :: proc(p: ^Parser) -> ^odin_ast.Block_Stmt {…}

parse_call_expr :: proc(p: ^Parser, operand: ^odin_ast.Expr) -> ^odin_ast.Expr {…}

parse_case_clause :: proc(p: ^Parser, is_type_switch: bool) -> ^odin_ast.Case_Clause {…}

parse_control_statement_semicolon_separator :: proc(p: ^Parser) -> bool {…}

parse_elem_list :: proc(p: ^Parser) -> []^odin_ast.Expr {…}

parse_expr :: proc(p: ^Parser, lhs: bool) -> ^odin_ast.Expr {…}

parse_expr_list :: proc(p: ^Parser, lhs: bool) -> []^odin_ast.Expr {…}

parse_field_list :: proc(p: ^Parser, follow: odin_tokenizer.Token_Kind, allowed_flags: odin_ast.Field_Flags) -> (field_list: ^odin_ast.Field_List, total_name_count: int) {…}

parse_field_prefixes :: proc(p: ^Parser) -> (flags: odin_ast.Field_Flags) {…}

parse_file :: proc(p: ^Parser, file: ^odin_ast.File) -> bool {…}

parse_for_stmt :: proc(p: ^Parser) -> ^odin_ast.Stmt {…}

parse_foreign_block :: proc(p: ^Parser, tok: odin_tokenizer.Token) -> ^odin_ast.Foreign_Block_Decl {…}

parse_foreign_block_decl :: proc(p: ^Parser) -> ^odin_ast.Stmt {…}

parse_foreign_decl :: proc(p: ^Parser) -> ^odin_ast.Decl {…}

parse_ident :: proc(p: ^Parser) -> ^odin_ast.Ident {…}

parse_ident_list :: proc(p: ^Parser, allow_poly_names: bool) -> []^odin_ast.Expr {…}

parse_if_stmt :: proc(p: ^Parser) -> ^odin_ast.If_Stmt {…}

parse_import_decl :: proc(p: ^Parser, kind: Import_Decl_Kind = Import_Decl_Kind.Standard) -> ^odin_ast.Import_Decl {…}

parse_inlining_operand :: proc(p: ^Parser, lhs: bool, tok: odin_tokenizer.Token) -> ^odin_ast.Expr {…}

parse_lhs_expr_list :: proc(p: ^Parser) -> []^odin_ast.Expr {…}

parse_literal_value :: proc(p: ^Parser, type: ^odin_ast.Expr) -> ^odin_ast.Comp_Lit {…}

parse_operand :: proc(p: ^Parser, lhs: bool) -> ^odin_ast.Expr {…}

parse_package :: proc(pkg: ^odin_ast.Package, p: ^Parser = nil) -> bool {…}

parse_package_from_path :: proc(path: string, p: ^Parser = nil) -> (pkg: ^odin_ast.Package, ok: bool) {…}

parse_proc_tags :: proc(p: ^Parser) -> (tags: odin_ast.Proc_Tags) {…}

parse_proc_type :: proc(p: ^Parser, tok: odin_tokenizer.Token) -> ^odin_ast.Proc_Type {…}

parse_results :: proc(p: ^Parser) -> (list: ^odin_ast.Field_List, diverging: bool) {…}

parse_rhs_expr_list :: proc(p: ^Parser) -> []^odin_ast.Expr {…}

parse_simple_stmt :: proc(p: ^Parser, flags: Stmt_Allow_Flags) -> ^odin_ast.Stmt {…}

parse_stmt :: proc(p: ^Parser) -> ^odin_ast.Stmt {…}

parse_stmt_list :: proc(p: ^Parser) -> []^odin_ast.Stmt {…}

parse_switch_stmt :: proc(p: ^Parser) -> ^odin_ast.Stmt {…}

parse_type :: proc(p: ^Parser) -> ^odin_ast.Expr {…}

parse_type_or_ident :: proc(p: ^Parser) -> ^odin_ast.Expr {…}

parse_unary_expr :: proc(p: ^Parser, lhs: bool) -> ^odin_ast.Expr {…}

parse_unrolled_for_loop :: proc(p: ^Parser, inline_tok: odin_tokenizer.Token) -> ^odin_ast.Stmt {…}

parse_value :: proc(p: ^Parser) -> ^odin_ast.Expr {…}

parse_value_decl :: proc(p: ^Parser, names: []^odin_ast.Expr, docs: ^odin_ast.Comment_Group) -> ^odin_ast.Decl {…}

parse_var_type :: proc(p: ^Parser, flags: odin_ast.Field_Flags) -> ^odin_ast.Expr {…}

parse_when_stmt :: proc(p: ^Parser) -> ^odin_ast.When_Stmt {…}

peek_token :: proc(p: ^Parser, lookahead: int = 0) -> (tok: odin_tokenizer.Token) {…}

peek_token_kind :: proc(p: ^Parser, kind: odin_tokenizer.Token_Kind, lookahead: int = 0) -> (ok: bool) {…}

skip_possible_newline :: proc(p: ^Parser) -> bool {…}

skip_possible_newline_for_literal :: proc(p: ^Parser) -> bool {…}

string_to_calling_convention :: proc(s: string) -> odin_ast.Proc_Calling_Convention {…}

token_precedence :: proc(p: ^Parser, kind: odin_tokenizer.Token_Kind) -> int {…}

warn :: proc(p: ^Parser, pos: odin_tokenizer.Pos, msg: string, .. args: ..any) {…}

is_blank_ident :: proc{
	is_blank_ident_string,
	is_blank_ident_token,
	is_blank_ident_node,
}