Allen Webster
16 KiB
//////////////////////////////// //~ Basic Unicode string types.
@struct MD_String8: { str: *MD_u8, size: MD_u64, };
@struct MD_String16: { str: *MD_u16, size: MD_u64, };
@struct MD_String32: { str: *MD_u32, size: MD_u64, };
@struct MD_String8Node: { next: MD_String8Node, string: MD_String8, };
@struct MD_String8List: { node_count: MD_u64, total_size: MD_u64, first: *MD_String8Node, last: *MD_String8Node, };
@prefix(MD_StringMatchFlag) @base_type(MD_u32) @flags MD_StringMatchFlags: { CaseInsensitive, RightSideSloppy, FindLast, SlashInsensitive, };
@struct MD_UnicodeConsume: { codepoint: MD_u32, advance: MD_u32, };
@enum MD_WordStyle: { UpperCamelCase, LowerCamelCase, UpperCase, LowerCase, };
//////////////////////////////// //~ Node types that are used to build all ASTs.
@enum MD_NodeKind: { Nil, File, Namespace, Label, Tag, MAX, };
@prefix(MD_NodeFlag) @base_type(MD_u32) @flags MD_NodeFlags: { ParenLeft, ParenRight, BracketLeft, BracketRight, BraceLeft, BraceRight,
BeforeSemicolon, BeforeComma,
AfterSemicolon, AfterComma,
Numeric, Identifier, StringLiteral, CharLiteral, };
@prefix(MD_NodeMatchFlag) @base_type(MD_u32) @flags MD_NodeMatchFlags: { MD_NodeMatchFlag_Tags, MD_NodeMatchFlag_TagArguments, };
@struct MD_Node: { next: *MD_Node, prev: *MD_Node, parent: *MD_Node, first_child: *MD_Node, last_child: *MD_Node,
// Tag list. first_tag: *MD_Node, last_tag: *MD_Node,
// Node info. kind: MD_NodeKind, flags: MD_NodeFlags, string: MD_String8, whole_string: MD_String8, string_hash: MD_u64,
// Comments. comment_before: MD_String8, comment_after: MD_String8,
// Source code location information. filename: MD_String8, file_contents: *MD_u8, at: *MD_u8, };
//////////////////////////////// //~ Code Location Info.
@struct MD_CodeLoc: { filename: MD_String8, line: MD_u32, column: MD_u32, };
//////////////////////////////// //~ Message Levels
@enum MD_MessageKind: { None, Warning, Error, }
//////////////////////////////// //~ String-To-Node table
@enum MD_MapCollisionRule: { Chain, Overwrite, }
@struct MD_MapSlot: { next: *MD_MapSlot, hash: MD_u64, key: *void; value: *void; };
@struct MD_Map: { table_size: MD_u64, table: **MD_MapSlot, };
//////////////////////////////// //~ Tokens
@enum MD_TokenKind: { Nil,
RegularMin,
// A group of characters that begins with an underscore or alphabetic character, // and consists of numbers, alphabetic characters, or underscores after that. Identifier,
// A group of characters beginning with a numeric character or a '-', and then // consisting of only numbers, alphabetic characters, or '.'s after that. NumericLiteral,
// A group of arbitrary characters, grouped together by a " character, OR by a // """ symbol at the beginning and end of the group. String literals beginning with // " are to only be specified on a single line, but """ strings can exist across // many lines. StringLiteral,
// A group of arbitrary characters, grouped together by a ' character at the // beginning, and a ' character at the end. CharLiteral,
// A group of symbolic characters. The symbolic characters are:
// ~!@#$%^&()-+=[{]}:;<>,./?|
//
// Groups of multiple characters are only allowed in specific circumstances. Most of these
// are only 1 character long, but some groups are allowed:
//
// "<<", ">>", "<=", ">=", "+=", "-=", "=", "/=", "::", ":=", "==", "&=", "|=", "->"
Symbol,
RegularMax,
Comment,
WhitespaceMin, Whitespace, Newline, WhitespaceMax,
MD_TokenKind_BadCharacter,
MAX, };
@struct MD_Token: { kind: MD_TokenKind, string: MD_String8, outer_string: MD_String8, };
@prefix(MD_TokenGroup) @base_type(MD_u32) @flags MD_TokenGroups: { Comment, Whitespace, Regular, };
//////////////////////////////// //~ Parsing State
@struct MD_Error: { next: *MD_Error, string: MD_String8, filename: MD_String8, node: *MD_Node, catastrophic: MD_b32, location: MD_CodeLoc, };
@struct MD_ParseCtx: { first_root: *MD_Node, last_root: *MD_Node, first_error: *MD_Error, last_error: *MD_Error, at: *MD_u8, filename: MD_String8, file_contents: MD_String8, namespace_table: MD_Map, selected_namespace: *MD_Node, catastrophic_error: MD_b32, };
@struct MD_ParseResult: { node: *MD_Node; first_error: *MD_Error; bytes_parse: MD_u64; };
//////////////////////////////// //~ Expression and Type-Expression parser helper types.
// VERY_IMPORTANT_NOTE(rjf): If this enum is ever changed, ensure that // it is kept in-sync with the MD_ExprPrecFromExprKind function.
@enum MD_ExprKind: { Nil,
// NOTE(rjf): Atom Atom,
// NOTE(rjf): Access Dot, Arrow, Call, Subscript, Dereference, Reference,
// NOTE(rjf): Arithmetic Add, Subtract, Multiply, Divide, Mod,
// NOTE(rjf): Comparison IsEqual, IsNotEqual, LessThan, GreaterThan, LessThanEqualTo, GreaterThanEqualTo,
// NOTE(rjf): Bools BoolAnd, BoolOr, BoolNot,
// NOTE(rjf): Bitwise BitAnd, BitOr, BitNot, BitXor, LeftShift, RightShift,
// NOTE(rjf): Unary numeric Negative,
// NOTE(rjf): Type Pointer, Array, Volatile, Const,
MAX, };
@typedef(MD_i32) MD_ExprPrec;
@struct MD_Expr: { node: *MD_Node, kind: MD_ExprKind, parent: *MD_Expr, sub: [2]*MD_Expr, };
//////////////////////////////// //~ Command line parsing helper types.
@struct MD_CommandLine: { arguments: *MD_String8; argument_count: MD_u32; };
//////////////////////////////// //~ File system access types.
@prefix(MD_FileFlag) @base_type(MD_u32) @flags MD_FileFlags: { Directory, };
@struct MD_FileInfo: { flags: MD_FileFlags; filename: MD_String8; file_size: MD_u64; };
@opaque @struct MD_FileIter: {};
//////////////////////////////// //~ Basic Utilities
@macro MD_Assert: { c, };
@macro MD_StaticAssert: { c, };
@macro MD_ArrayCount: { a, };
//////////////////////////////// //~ Characters
@func MD_CharIsAlpha: { c: MD_u8, return: MD_b32, };
@func MD_CharIsAlphaUpper: { c: MD_u8, return: MD_b32, };
@func MD_CharIsAlphaLower: { c: MD_u8, return: MD_b32, };
@func MD_CharIsDigit: { c: MD_u8, return: MD_b32, };
@func MD_CharIsSymbol: { c: MD_u8, return: MD_b32, };
@func MD_CharIsReservedSymbol: { c: MD_u8, return: MD_b32, };
@func MD_CharIsSpace: { c: MD_u8, return: MD_b32, };
@func MD_CharToUpper: { c: MD_u8, return: MD_u8, };
@func MD_CharToLower: { c: MD_u8, return: MD_u8, };
@func MD_CorrectSlash: { c: MD_u8, return: MD_u8, };
//////////////////////////////// //~ Strings
@func MD_S8: { str: *MD_u8, size: MD_u64, return: MD_String8, };
@macro MD_S8CString: { s, };
@macro MD_S8Lit: { s, };
@func MD_S8Range: { str: *MD_u8, opl: *MD_u8, return: MD_String8, };
@func MD_StringSubstring: { str: MD_String8, min: MD_u64, max: MD_u64 return: MD_String8, };
@func MD_StringSkip: { str: MD_String8, min: MD_u64, return: MD_String8, };
@func MD_StringChop: { str: MD_String8, nmax: MD_u64, return: MD_String8, };
@func MD_StringPrefix: { str: MD_String8, size: MD_u64, return: MD_String8, };
@func MD_StringSuffix: { str: MD_String8, size: MD_u64, return: MD_String8, };
@func MD_StringMatch: { a: MD_String8, b: MD_String8, flags: MD_StringMatchFlags, return: MD_b32, };
@func MD_FindSubstring: { str: MD_String8, substring: MD_String8, start_pos: MD_u64, flags: MD_StringMatchFlags, return: MD_u64, };
@func MD_FindLastSubstring: { str: MD_String8, substring: MD_String8, flags: MD_StringMatchFlags, return: MD_u64, };
@func MD_ChopExtension: { string: MD_String8, return: MD_String8, };
@func MD_SkipFolder: { string: MD_String8, return: MD_String8, };
@func MD_ExtensionFromPath: { string: MD_String8, return: MD_String8, };
@func MD_FolderFromPath: { string: MD_String8, return: MD_String8, };
@func MD_PushStringCopy: { string: MD_String8, return: MD_String8, };
@func MD_PushStringFV: { fmt: *char, args: va_list, return: MD_String8, };
@func MD_PushStringF: { fmt: *char, "...", return: MD_String8, };
@macro MD_StringExpand: { s, }
@func MD_PushStringToList: { list: *MD_String8List, string: MD_String8, };
@func MD_PushStringListToList: { list: *MD_String8List, to_push: *MD_String8List, };
@func MD_SplitString: { string: MD_String8, split_count: MD_u32, splits: *MD_String8, return: MD_String8List };
@func MD_JoinStringList: { list: MD_String8List, return: MD_String8, };
@func MD_JoinStringListWithSeparator: { list: MD_String8List, separator: MD_String8 return: MD_String8, };
@func MD_I64FromString: { string: MD_String8, radix: MD_u32, return: MD_i64, };
@func MD_F64FromString: { string: MD_String8, return: MD_f64, };
@func MD_HashString: { string: MD_String8, return: MD_u64, };
@func MD_CalculateCStringLength: { cstr: *char, return: MD_u64, };
@func MD_StyledStringFromString: { string: MD_String8, word_style: MD_WordStyle, separator: MD_String8, return: MD_String8 };
//////////////////////////////// //~ Enum/Flag Strings
@func MD_StringFromNodeKind: { kind: MD_NodeKind, return: MD_String8, };
@func MD_StringListFromNodeFlags: { flags: MD_NodeFlags, return: MD_String8List, };
//////////////////////////////// //~ Unicode Conversions
@func MD_CodepointFromUtf8: { str: MD_u8, max: MD_u64, return: MD_UnicodeConsume, };
@func MD_CodepointFromUtf16: { str: *MD_u16, max: MD_u64, return: MD_UnicodeConsume, };
@func MD_Utf8FromCodepoint: { out: *MD_u8, codepoint: MD_u32, return: MD_u32, };
@func MD_Utf16FromCodepoint: { out: *MD_u16, codepoint: MD_u32, return: MD_u32, };
@func MD_S8FromS16: { str: MD_String16, return: MD_String8, };
@func MD_S16FromS8: { str: MD_String8, return: MD_String16, };
@func MD_S8FromS32: { str: MD_String32, return: MD_String8, };
@func MD_S32FromS8: { str: MD_String8, return: MD_String32, };
//////////////////////////////// //~ String-To-Node-List Table
@func MD_Map_Lookup: { table: *MD_Map, string: MD_String8, return: *MD_MapSlot, };
@func MD_Map_Insert: { table: *MD_Map, collision_rule: MD_MapCollisionRule, string: MD_String8, node: *MD_Node, return: MD_b32, };
//////////////////////////////// //~ Parsing
@func MD_TokenKindIsWhitespace: { kind: MD_TokenKind, return: MD_b32, };
@func MD_TokenKindIsComment: { kind: MD_TokenKind, return: MD_b32, };
@func MD_TokenKindIsRegular: { kind: MD_TokenKind, return: MD_b32, };
@func MD_Parse_InitializeCtx: { filename: MD_String8, contents: MD_String8, return: MD_ParseCtx, };
@func MD_Parse_Bump: { ctx: *MD_ParseCtx, token: MD_Token, };
@func MD_Parse_BumpNext: { ctx: *MD_ParseCtx, };
@func MD_Parse_LexNext: { ctx: *MD_ParseCtx, return: MD_Token, };
@func MD_Parse_PeekSkipSome: { ctx: *MD_ParseCtx, skip_groups: MD_TokenGroups, return: MD_Token, };
@func MD_Parse_TokenMatch: { token: MD_Token, string: MD_String8, flags: MD_StringMatchFlags, return: MD_b32, };
@func MD_Parse_Require: { ctx: *MD_ParseCtx, string: MD_String8, return: MD_b32, };
@func MD_Parse_RequireKind: { ctx: *MD_ParseCtx, kind: MD_TokenKind, out_token: *MD_Token, return: MD_b32, };
@func MD_ParseOneNode: { filename: MD_String8, contents: MD_String8, return: MD_ParseResult, };
@func MD_ParseWholeString: { filename: MD_String8, contents: MD_String8, return: MD_ParseResult, };
@func MD_ParseWholeFile: { filename: MD_String8, return: MD_ParseResult, };
//////////////////////////////// //~ Tree/List Building
@func MD_NodeIsNil: { node: *MD_Node, return: MD_b32, };
@func MD_NilNode: { return: *MD_Node, };
@func MD_MakeNodeFromToken: { kind: MD_NodeKind, filename: MD_String8, file: *MD_u8, at: *MD_u8, token: MD_Token, return: *MD_Node, };
@func MD_MakeNodeFromString: { kind: MD_NodeKind, filename: MD_String8, file: *MD_u8, at: *MD_u8, string: MD_String8 return: *MD_Node, };
@func MD_PushSibling: { first: **MD_Node, last: **MD_Node, parent: *MD_Node, new_sibling: *MD_Node, };
@func MD_PushChild: { parent: *MD_Node, new_child: *MD_Node, };
@func MD_PushTag: { node: *MD_Node, tag: *MD_Node, };
//////////////////////////////// //~ Introspection Helpers
@func MD_NodeFromString: { first: *MD_Node, last: *MD_Node, string: MD_String8, return: *MD_Node, };
@func MD_NodeFromIndex: { first: *MD_Node, last: *MD_Node, n: int, return: *MD_Node, };
@func MD_IndexFromNode: { node: *MD_Node, return: int, };
@func MD_NextNodeSibling: { last: *MD_Node, string: MD_String8, return: *MD_Node, };
@func MD_ChildFromString: { node: *MD_Node, child_string: MD_String8, return: *MD_Node, };
@func MD_TagFromString: { node: *MD_Node, tag_string: MD_String8, return: *MD_Node, };
@func MD_ChildFromIndex: { node: *MD_Node, n: int, return: *MD_Node, };
@func MD_TagFromIndex: { node: *MD_Node, n: int, return: *MD_Node, };
@func MD_TagArgFromIndex: { node: *MD_Node, tag_string: MD_String8, n: int, return: *MD_Node, };
@func MD_NodeHasTag: { node: *MD_Node, tag_string: MD_String8, return: MD_b32, };
@func MD_CodeLocFromNode: { node: *MD_Node, return: MD_CodeLoc, };
@func MD_ChildCountFromNode: { node: *MD_Node, return: MD_i64, };
@func MD_TagCountFromNode: { node: *MD_Node, return: MD_i64, };
@macro MD_EachNode: { it, first, };
//////////////////////////////// //~ Error/Warning Helpers
@func MD_NodeMessage: { node: *MD_Node, kind: MD_MessageKind, str: MD_String8, };
@func MD_NodeMessageF: { node: *MD_Node, kind: MD_MessageKind, fmt: *char, "..." };
//////////////////////////////// //~ Tree Comparison/Verification
@func MD_NodeMatch: { a: *MD_Node, b: *MD_Node, str_flags: MD_StringMatchFlags, node_flags: MD_NodeMatchFlags, return: MD_b32, };
@func MD_NodeDeepMatch: { a: *MD_Node, b: *MD_Node, str_flags: MD_StringMatchFlags, node_flags: MD_NodeMatchFlags, return: MD_b32, };
//////////////////////////////// //~ Expression and Type-Expression Helper
@func MD_NilExpr: { return: *MD_Expr, };
@func MD_ExprIsNil: { expr: *MD_Expr, return: MD_b32, };
@func MD_PreUnaryExprKindFromNode: { node: *MD_Node, return: MD_ExprKind, };
@func MD_BinaryExprKindFromNode: { node: *MD_Node, return: MD_ExprKind, };
@func MD_ExprPrecFromExprKind: { kind: MD_ExprKind, return: MD_ExprPrec, };
@func MD_MakeExpr: { node: *MD_Node, kind: MD_ExprKind, left: *MD_Expr, right: *MD_Expr, return: *MD_Expr, };
@func MD_ParseAsExpr: { first: *MD_Node, last: *MD_Node, return: *MD_Expr, };
@func MD_ParseAsType: { first: *MD_Node, last: *MD_Node, return: *MD_Expr, };
@func MD_EvaluateExpr_I64: { expr: *MD_Expr, return: MD_i64, };
@func MD_EvaluateExpr_F64: { expr: *MD_Expr, return: MD_f64, };
@func MD_ExprMatch: { a: *MD_Expr, b: *MD_Expr, str_flags: MD_StringMatchFlags, return: MD_b32, };
@func MD_ExprDeepMatch: { a: *MD_Expr, b: *MD_Expr, str_flags: MD_StringMatchFlags, return: MD_b32, };
//////////////////////////////// //~ Generation
@func MD_OutputTree: { file: *FILE, node: *MD_Node, };
//////////////////////////////// //~ C Language Generation
@func MD_OutputTree_C_String: { file: *FILE, node: *MD_Node, };
@func MD_OutputTree_C_Struct: { file: *FILE, node: *MD_Node, };
@func MD_OutputTree_C_Decl: { file: *FILE, node: *MD_Node, };
@func MD_Output_C_DeclByNameAndType: { file: *FILE, name: MD_String8, type: *MD_Expr, };
@func MD_OutputExpr: { file: *FILE, expr: *MD_Expr, };
@func MD_OutputExpr_C: { file: *FILE, expr: *MD_Expr, };
@func MD_OutputType: { file: *FILE, type: *MD_Expr, };
@func MD_OutputType_C_LHS: { file: *FILE, type: *MD_Expr, };
@func MD_OutputType_C_RHS: { file: *FILE, type: *MD_Expr, };
//////////////////////////////// //~ Command Line Argument Helper
@func MD_CommandLine_Start: { argument_count: int, arguments: **char, return: MD_CommandLine, };
@func MD_CommandLine_Flag: { cmdln: *MD_CommandLine, string: MD_String8, return: MD_b32, };
@func MD_CommandLine_FlagStrings: { cmdln: *MD_CommandLine, string: MD_String8, out_count: int, out: *MD_String8, return: MD_b32, };
@func MD_CommandLine_FlagIntegers: { cmdln: *MD_CommandLine, string: MD_String8, out_count: int, out: *MD_i64, return: MD_b32, };
@func MD_CommandLine_FlagString: { cmdln: *MD_CommandLine, string: MD_String8, out: *MD_String8, return: MD_b32, };
@func MD_CommandLine_FlagInteger: { cmdln: *MD_CommandLine, string: MD_String8, out: *MD_i64, return: MD_b32, };
@func MD_CommandLine_Increment: { cmdln: *MD_CommandLine, string_ptr: **MD_String8, return: MD_b32, };
//////////////////////////////// //~ File System
@func MD_LoadEntireFile: { filename: MD_String8, return: MD_String8, };
@func MD_FileIterIncrement: { it: *MD_FileIter, path: MD_String8, out_info: *MD_FileInfo, return: MD_b32, };