BUILD_KIND_NEWLINE_MARKER :: Build_Kind{}

MAX_FIX_COUNT :: 10

Build_Kind :: Build_Kind

Build_Target :: Build_Target

Error_Handler :: Error_Handler

Expr_And_Flags :: Expr_And_Flags

File_Tags :: File_Tags

Flag :: Flag

Flags :: distinct Flags

Import_Decl_Kind :: Import_Decl_Kind

Parser :: Parser

Private_Flag :: Private_Flag

Stmt_Allow_Flag :: Stmt_Allow_Flag

Stmt_Allow_Flags :: distinct Stmt_Allow_Flags

Warning_Handler :: Warning_Handler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

empty_selector_expr :: proc(tok: Token, operand: ^Expr) -> ^Selector_Expr {…}

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

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

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

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

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

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

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

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

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

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

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

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

@(require_results)

get_build_arch_from_string :: proc(str: string) -> Odin_Arch_Type {…}

@(require_results)

get_build_os_from_string :: proc(str: string) -> (found_os: Odin_OS_Type, found_subtarget: Odin_Platform_Subtarget_Type) {…}

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

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

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

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

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

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

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

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

@(require_results)

match_build_tags :: proc(file_tags: File_Tags, target: Build_Target) -> bool {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@(require_results)

parse_file_tags :: proc(file: File, allocator := context.allocator) -> (tags: File_Tags) {…}

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

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

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

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

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

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

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

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

parse_inlining_or_tailing_operand :: proc(p: ^Parser, lhs: bool, tok: Token) -> ^Expr {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

peek_token_kind :: proc(p: ^Parser, kind: 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) -> Proc_Calling_Convention {…}

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

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

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