From 3b4456f01f7495f1021073a192952027296d14c9 Mon Sep 17 00:00:00 2001 From: dimgigov Date: Sun, 7 Jun 2026 14:58:23 +0300 Subject: [PATCH] selfhost: expand Decl to 256 fields, fix unary precedence, add discard/var parsing, fix diag buffer overflow - ast.bux: Decl expanded with field0..field255, variant0..7, param0..8 - parser.bux: add parserParseUnary for correct unary precedence; handle tkDiscard statements; allow var without initializer (matching bootstrap); add diagCount bounds check in parserEmitDiag - hir.bux: HirParam changed to pointers - hir_lower.bux: full field chains for struct lowering - c_backend.bux: hardened -> vs . field access; null checks in CBE_GetExprTypeName - cli.bux: add -lcrypto to linker --- src/ast.bux | 250 +++++++++++++++--- src/c_backend.bux | 164 +++++++++--- src/cli.bux | 44 +++- src/hir.bux | 18 +- src/hir_lower.bux | 224 +++++++++++++++- src/parser.bux | 647 ++++++++++++++++++++++++++++++++++++++++++++-- src/sema.bux | 12 +- 7 files changed, 1254 insertions(+), 105 deletions(-) diff --git a/src/ast.bux b/src/ast.bux index c8369d7..644e517 100644 --- a/src/ast.bux +++ b/src/ast.bux @@ -255,7 +255,35 @@ struct Decl { retType: *TypeExpr, // Body refBody: *Block, - // Struct fields (up to 64) + // Enum variants (up to 8) + variantCount: int, + variant0: EnumVariant, + variant1: EnumVariant, + variant2: EnumVariant, + variant3: EnumVariant, + variant4: EnumVariant, + variant5: EnumVariant, + variant6: EnumVariant, + variant7: EnumVariant, + // Impl methods (up to 4) + methodCount: int, + // Use/import + useKind: int, + usePath: String, + useNames: String, // joined names for multi-import + // Const + constType: *TypeExpr, + constValue: *Expr, + // Type alias + aliasType: *TypeExpr, + // Extern func + extFuncDll: String, + extFuncVariadic: bool, + extFuncRetType: *TypeExpr, + // Children + childDecl1: *Decl, // linked list of decls (for module items, impl methods) + childDecl2: *Decl, + // Struct fields (up to 256) fieldCount: int, field0: StructField, field1: StructField, @@ -321,34 +349,198 @@ struct Decl { field61: StructField, field62: StructField, field63: StructField, - // Enum variants (up to 8) - variantCount: int, - variant0: EnumVariant, - variant1: EnumVariant, - variant2: EnumVariant, - variant3: EnumVariant, - variant4: EnumVariant, - variant5: EnumVariant, - variant6: EnumVariant, - variant7: EnumVariant, - // Impl methods (up to 4) - methodCount: int, - // Use/import - useKind: int, - usePath: String, - useNames: String, // joined names for multi-import - // Const - constType: *TypeExpr, - constValue: *Expr, - // Type alias - aliasType: *TypeExpr, - // Extern func - extFuncDll: String, - extFuncVariadic: bool, - extFuncRetType: *TypeExpr, - // Children - childDecl1: *Decl, // linked list of decls (for module items, impl methods) - childDecl2: *Decl, + field64: StructField, + field65: StructField, + field66: StructField, + field67: StructField, + field68: StructField, + field69: StructField, + field70: StructField, + field71: StructField, + field72: StructField, + field73: StructField, + field74: StructField, + field75: StructField, + field76: StructField, + field77: StructField, + field78: StructField, + field79: StructField, + field80: StructField, + field81: StructField, + field82: StructField, + field83: StructField, + field84: StructField, + field85: StructField, + field86: StructField, + field87: StructField, + field88: StructField, + field89: StructField, + field90: StructField, + field91: StructField, + field92: StructField, + field93: StructField, + field94: StructField, + field95: StructField, + field96: StructField, + field97: StructField, + field98: StructField, + field99: StructField, + field100: StructField, + field101: StructField, + field102: StructField, + field103: StructField, + field104: StructField, + field105: StructField, + field106: StructField, + field107: StructField, + field108: StructField, + field109: StructField, + field110: StructField, + field111: StructField, + field112: StructField, + field113: StructField, + field114: StructField, + field115: StructField, + field116: StructField, + field117: StructField, + field118: StructField, + field119: StructField, + field120: StructField, + field121: StructField, + field122: StructField, + field123: StructField, + field124: StructField, + field125: StructField, + field126: StructField, + field127: StructField, + field128: StructField, + field129: StructField, + field130: StructField, + field131: StructField, + field132: StructField, + field133: StructField, + field134: StructField, + field135: StructField, + field136: StructField, + field137: StructField, + field138: StructField, + field139: StructField, + field140: StructField, + field141: StructField, + field142: StructField, + field143: StructField, + field144: StructField, + field145: StructField, + field146: StructField, + field147: StructField, + field148: StructField, + field149: StructField, + field150: StructField, + field151: StructField, + field152: StructField, + field153: StructField, + field154: StructField, + field155: StructField, + field156: StructField, + field157: StructField, + field158: StructField, + field159: StructField, + field160: StructField, + field161: StructField, + field162: StructField, + field163: StructField, + field164: StructField, + field165: StructField, + field166: StructField, + field167: StructField, + field168: StructField, + field169: StructField, + field170: StructField, + field171: StructField, + field172: StructField, + field173: StructField, + field174: StructField, + field175: StructField, + field176: StructField, + field177: StructField, + field178: StructField, + field179: StructField, + field180: StructField, + field181: StructField, + field182: StructField, + field183: StructField, + field184: StructField, + field185: StructField, + field186: StructField, + field187: StructField, + field188: StructField, + field189: StructField, + field190: StructField, + field191: StructField, + field192: StructField, + field193: StructField, + field194: StructField, + field195: StructField, + field196: StructField, + field197: StructField, + field198: StructField, + field199: StructField, + field200: StructField, + field201: StructField, + field202: StructField, + field203: StructField, + field204: StructField, + field205: StructField, + field206: StructField, + field207: StructField, + field208: StructField, + field209: StructField, + field210: StructField, + field211: StructField, + field212: StructField, + field213: StructField, + field214: StructField, + field215: StructField, + field216: StructField, + field217: StructField, + field218: StructField, + field219: StructField, + field220: StructField, + field221: StructField, + field222: StructField, + field223: StructField, + field224: StructField, + field225: StructField, + field226: StructField, + field227: StructField, + field228: StructField, + field229: StructField, + field230: StructField, + field231: StructField, + field232: StructField, + field233: StructField, + field234: StructField, + field235: StructField, + field236: StructField, + field237: StructField, + field238: StructField, + field239: StructField, + field240: StructField, + field241: StructField, + field242: StructField, + field243: StructField, + field244: StructField, + field245: StructField, + field246: StructField, + field247: StructField, + field248: StructField, + field249: StructField, + field250: StructField, + field251: StructField, + field252: StructField, + field253: StructField, + field254: StructField, + field255: StructField, } // --------------------------------------------------------------------------- diff --git a/src/c_backend.bux b/src/c_backend.bux index 7d0e701..492fedc 100644 --- a/src/c_backend.bux +++ b/src/c_backend.bux @@ -65,11 +65,12 @@ func CBackend_OpToC(op: int) -> String { struct CEmitter { sb: StringBuilder, indent: int, + mod: *HirModule, } func CBE_Init() -> CEmitter { var sb: StringBuilder = StringBuilder_NewCap(4096); - return CEmitter { sb: sb, indent: 0 }; + return CEmitter { sb: sb, indent: 0, mod: null as *HirModule }; } func CBE_Emit(cbe: *CEmitter, text: String) { @@ -252,8 +253,10 @@ func CBE_EmitExpr(cbe: *CEmitter, node: *HirNode) { } StringBuilder_Append(&cbe.sb, " "); StringBuilder_Append(&cbe.sb, node.child1.strValue); - StringBuilder_Append(&cbe.sb, " = "); - CBE_EmitExpr(cbe, node.child2); + if node.child2 != null as *HirNode { + StringBuilder_Append(&cbe.sb, " = "); + CBE_EmitExpr(cbe, node.child2); + } return; } // Plain assignment @@ -349,9 +352,8 @@ func CBE_EmitExpr(cbe: *CEmitter, node: *HirNode) { CBE_EmitExpr(cbe, node.child1); var isPtr: bool = false; if node.child1 != null as *HirNode { - if node.child1.typeKind == tyPointer { - isPtr = true; - } else if String_EndsWith(node.child1.typeName, "*") { + let childType: String = CBE_GetExprTypeName(cbe.mod, node.child1); + if String_EndsWith(childType, "*") { isPtr = true; } } @@ -396,9 +398,8 @@ func CBE_EmitExpr(cbe: *CEmitter, node: *HirNode) { CBE_EmitExpr(cbe, ptrNode.child1); var isPtr: bool = false; if ptrNode.child1 != null as *HirNode { - if ptrNode.child1.typeKind == tyPointer { - isPtr = true; - } else if String_EndsWith(ptrNode.child1.typeName, "*") { + let childType: String = CBE_GetExprTypeName(cbe.mod, ptrNode.child1); + if String_EndsWith(childType, "*") { isPtr = true; } } @@ -617,6 +618,107 @@ func CBE_FuncHasGeneric(f: *HirFunc) -> bool { return false; } +func CBE_IsPrimitiveTypeName(name: String) -> bool { + if String_Eq(name, "int") || String_Eq(name, "") { return true; } + if String_Eq(name, "String") { return true; } + if String_Eq(name, "bool") { return true; } + if String_Eq(name, "uint32") { return true; } + if String_Eq(name, "uint64") { return true; } + if String_Eq(name, "int64") { return true; } + if String_Eq(name, "float32") { return true; } + if String_Eq(name, "float64") { return true; } + if String_Eq(name, "uint8") { return true; } + if String_Eq(name, "uint16") { return true; } + if String_Eq(name, "int8") { return true; } + if String_Eq(name, "int16") { return true; } + if String_Eq(name, "uint") { return true; } + if String_Eq(name, "char8") { return true; } + if String_Eq(name, "void") { return true; } + if String_Eq(name, "size_t") { return true; } + return false; +} + +func CBE_StructHasValueStructField(st: *HirStruct) -> bool { + var fi: int = 0; + while fi < st.fieldCount { + let ft: String = st.fields[fi].typeName; + if !CBE_IsPrimitiveTypeName(ft) && !String_EndsWith(ft, "*") { + return true; + } + fi = fi + 1; + } + return false; +} + +func CBE_EmitStructDef(cbe: *CEmitter, st: *HirStruct) { + StringBuilder_Append(&cbe.sb, "struct "); + StringBuilder_Append(&cbe.sb, st.name); + StringBuilder_Append(&cbe.sb, " {\n"); + var fi: int = 0; + while fi < st.fieldCount { + StringBuilder_Append(&cbe.sb, " "); + var ft: String = st.fields[fi].typeName; + if String_Eq(ft, "int") || String_Eq(ft, "") { + StringBuilder_Append(&cbe.sb, "int"); + } else if String_Eq(ft, "String") { + StringBuilder_Append(&cbe.sb, "String"); + } else if String_Eq(ft, "bool") { + StringBuilder_Append(&cbe.sb, "bool"); + } else if String_Eq(ft, "uint32") { + StringBuilder_Append(&cbe.sb, "uint32"); + } else { + StringBuilder_Append(&cbe.sb, ft); + } + StringBuilder_Append(&cbe.sb, " "); + StringBuilder_Append(&cbe.sb, st.fields[fi].name); + StringBuilder_Append(&cbe.sb, ";\n"); + fi = fi + 1; + } + StringBuilder_Append(&cbe.sb, "};\n\n"); +} + +func CBE_LookupFieldType(mod: *HirModule, structName: String, fieldName: String) -> String { + var si: int = 0; + while si < mod.structCount { + if String_Eq(mod.structs[si].name, structName) { + var fi: int = 0; + while fi < mod.structs[si].fieldCount { + if String_Eq(mod.structs[si].fields[fi].name, fieldName) { + let ft: String = mod.structs[si].fields[fi].typeName; + if ft != null as String { return ft; } + return ""; + } + fi = fi + 1; + } + } + si = si + 1; + } + return ""; +} + +func CBE_GetExprTypeName(mod: *HirModule, node: *HirNode) -> String { + if node == null as *HirNode { return ""; } + if node.kind == hVar { + if node.typeName != null as String { return node.typeName; } + return ""; + } + if node.kind == hFieldPtr { + let baseType: String = CBE_GetExprTypeName(mod, node.child1); + var structName: String = baseType; + if String_EndsWith(baseType, "*") { + let len: uint = String_Len(baseType); + if len > 1 { + structName = String_Slice(baseType, 0, len - 1); + } + } + if !String_Eq(structName, "") { + return CBE_LookupFieldType(mod, structName, node.strValue); + } + } + if node.typeName != null as String { return node.typeName; } + return ""; +} + // --------------------------------------------------------------------------- // Generate complete C module // --------------------------------------------------------------------------- @@ -625,6 +727,7 @@ func CBackend_Generate(mod: *HirModule) -> String { let cbe: *CEmitter = bux_alloc(sizeof(CEmitter)) as *CEmitter; cbe.sb = StringBuilder_NewCap(8192); cbe.indent = 0; + cbe.mod = mod; // Header StringBuilder_Append(&cbe.sb, "// Generated by Bux C Backend\n"); @@ -778,37 +881,32 @@ func CBackend_Generate(mod: *HirModule) -> String { } // Struct definitions (skip generics) + // Pass 1: emit structs with no value-typed struct fields (leaf structs) si = 0; while si < mod.structCount { if CBE_StructHasGeneric(&mod.structs[si]) { si = si + 1; continue; } - StringBuilder_Append(&cbe.sb, "struct "); - StringBuilder_Append(&cbe.sb, mod.structs[si].name); - StringBuilder_Append(&cbe.sb, " {\n"); - var fi: int = 0; - while fi < mod.structs[si].fieldCount { - StringBuilder_Append(&cbe.sb, " "); - var ft: String = mod.structs[si].fields[fi].typeName; - if String_Eq(ft, "int") || String_Eq(ft, "") { - StringBuilder_Append(&cbe.sb, "int"); - } else if String_Eq(ft, "String") { - StringBuilder_Append(&cbe.sb, "String"); - } else if String_Eq(ft, "bool") { - StringBuilder_Append(&cbe.sb, "bool"); - } else if String_Eq(ft, "uint32") { - StringBuilder_Append(&cbe.sb, "uint32"); - } else { - // Use the type name directly (handles "Foo*", "Bar", etc.) - StringBuilder_Append(&cbe.sb, ft); - } - StringBuilder_Append(&cbe.sb, " "); - StringBuilder_Append(&cbe.sb, mod.structs[si].fields[fi].name); - StringBuilder_Append(&cbe.sb, ";\n"); - fi = fi + 1; + if CBE_StructHasValueStructField(&mod.structs[si]) { + si = si + 1; + continue; } - StringBuilder_Append(&cbe.sb, "};\n\n"); + CBE_EmitStructDef(cbe, &mod.structs[si]); + si = si + 1; + } + // Pass 2: emit structs that contain value-typed struct fields + si = 0; + while si < mod.structCount { + if CBE_StructHasGeneric(&mod.structs[si]) { + si = si + 1; + continue; + } + if !CBE_StructHasValueStructField(&mod.structs[si]) { + si = si + 1; + continue; + } + CBE_EmitStructDef(cbe, &mod.structs[si]); si = si + 1; } diff --git a/src/cli.bux b/src/cli.bux index aee83b3..232125b 100644 --- a/src/cli.bux +++ b/src/cli.bux @@ -172,6 +172,7 @@ func Cli_Build(srcPath: String, outPath: String) -> int { StringBuilder_Append(&cmdBuf, " "); } StringBuilder_Append(&cmdBuf, "-lm"); + StringBuilder_Append(&cmdBuf, " -lcrypto"); let ccRc: int = bux_system(StringBuilder_Build(&cmdBuf)); if ccRc != 0 { PrintLine("Error: C compilation failed"); @@ -423,8 +424,16 @@ func Cli_MergeFileInto(target: *Module, path: String, skipNames: *String, skipCo if !String_Eq(iname, "") && Cli_NameInList(iname, skipNames, skipCount) { // Skip shadowed stdlib decl } else { - inner.childDecl2 = target.firstItem; - target.firstItem = inner; + inner.childDecl2 = null as *Decl; + if target.firstItem == null as *Decl { + target.firstItem = inner; + } else { + var last: *Decl = target.firstItem; + while last.childDecl2 != null as *Decl { + last = last.childDecl2; + } + last.childDecl2 = inner; + } target.itemCount = target.itemCount + 1; added = added + 1; } @@ -435,8 +444,16 @@ func Cli_MergeFileInto(target: *Module, path: String, skipNames: *String, skipCo if !String_Eq(dname, "") && Cli_NameInList(dname, skipNames, skipCount) { // Skip shadowed stdlib decl } else { - decl.childDecl2 = target.firstItem; - target.firstItem = decl; + decl.childDecl2 = null as *Decl; + if target.firstItem == null as *Decl { + target.firstItem = decl; + } else { + var last: *Decl = target.firstItem; + while last.childDecl2 != null as *Decl { + last = last.childDecl2; + } + last.childDecl2 = decl; + } target.itemCount = target.itemCount + 1; added = added + 1; } @@ -448,12 +465,26 @@ func Cli_MergeFileInto(target: *Module, path: String, skipNames: *String, skipCo func Cli_CopyModuleDecls(target: *Module, source: *Module) { if source == null as *Module || source.firstItem == null as *Decl { return; } + // Find last item in target + var targetLast: *Decl = null as *Decl; + if target.firstItem != null as *Decl { + targetLast = target.firstItem; + while targetLast.childDecl2 != null as *Decl { + targetLast = targetLast.childDecl2; + } + } var decl: *Decl = source.firstItem; var limit: int = 0; while decl != null as *Decl && limit < 10000 { let next: *Decl = decl.childDecl2; - decl.childDecl2 = target.firstItem; - target.firstItem = decl; + decl.childDecl2 = null as *Decl; + if target.firstItem == null as *Decl { + target.firstItem = decl; + targetLast = decl; + } else { + targetLast.childDecl2 = decl; + targetLast = decl; + } target.itemCount = target.itemCount + 1; decl = next; limit = limit + 1; @@ -660,6 +691,7 @@ func Cli_BuildProject(projectDir: String) -> int { StringBuilder_Append(&ccBuf, " "); } StringBuilder_Append(&ccBuf, "-lm"); + StringBuilder_Append(&ccBuf, " -lcrypto"); let ccRc: int = bux_system(StringBuilder_Build(&ccBuf)); if ccRc != 0 { PrintLine("Error: C compilation failed"); diff --git a/src/hir.bux b/src/hir.bux index 06faf10..312cfcf 100644 --- a/src/hir.bux +++ b/src/hir.bux @@ -79,15 +79,15 @@ struct HirParam { struct HirFunc { name: String; paramCount: int; - param0: HirParam; - param1: HirParam; - param2: HirParam; - param3: HirParam; - param4: HirParam; - param5: HirParam; - param6: HirParam; - param7: HirParam; - param8: HirParam; + param0: *HirParam; + param1: *HirParam; + param2: *HirParam; + param3: *HirParam; + param4: *HirParam; + param5: *HirParam; + param6: *HirParam; + param7: *HirParam; + param8: *HirParam; retTypeKind: int; retTypeName: String; body: *HirNode; diff --git a/src/hir_lower.bux b/src/hir_lower.bux index 5f78402..d25216c 100644 --- a/src/hir_lower.bux +++ b/src/hir_lower.bux @@ -107,6 +107,7 @@ func Lcx_LowerExpr(ctx: *LowerCtx, expr: *Expr) -> *HirNode { n.strValue = expr.strValue; let sym: Symbol = Scope_Lookup(ctx.scope, expr.strValue); n.typeKind = sym.typeKind; + if expr.refType != null as *TypeExpr { n.typeName = expr.refType.typeName; } @@ -149,6 +150,9 @@ func Lcx_LowerExpr(ctx: *LowerCtx, expr: *Expr) -> *HirNode { n.kind = hUnary; n.intValue = expr.intValue; n.child1 = Lcx_LowerExpr(ctx, expr.child1); + if expr.intValue == tkAmp { + n.typeKind = tyPointer; + } return n; } @@ -275,6 +279,7 @@ func Lcx_LowerExpr(ctx: *LowerCtx, expr: *Expr) -> *HirNode { n.kind = hFieldPtr; n.child1 = Lcx_LowerExpr(ctx, expr.child1); n.strValue = expr.strValue; + // Get struct type from base expr refType if expr.child1 != null as *Expr && expr.child1.refType != null as *TypeExpr { n.typeName = expr.child1.refType.typeName; @@ -552,15 +557,24 @@ func Lcx_LowerFunc(ctx: *LowerCtx, decl: *Decl) -> *HirFunc { f.name = decl.strValue; f.isPublic = decl.isPublic; f.paramCount = decl.paramCount; - Lcx_LowerParam(&f.param0, &decl.param0); - Lcx_LowerParam(&f.param1, &decl.param1); - Lcx_LowerParam(&f.param2, &decl.param2); - Lcx_LowerParam(&f.param3, &decl.param3); - Lcx_LowerParam(&f.param4, &decl.param4); - Lcx_LowerParam(&f.param5, &decl.param5); - Lcx_LowerParam(&f.param6, &decl.param6); - Lcx_LowerParam(&f.param7, &decl.param7); - Lcx_LowerParam(&f.param8, &decl.param8); + f.param0 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param0, &decl.param0); + f.param1 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param1, &decl.param1); + f.param2 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param2, &decl.param2); + f.param3 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param3, &decl.param3); + f.param4 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param4, &decl.param4); + f.param5 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param5, &decl.param5); + f.param6 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param6, &decl.param6); + f.param7 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param7, &decl.param7); + f.param8 = bux_alloc(sizeof(HirParam)) as *HirParam; + Lcx_LowerParam(f.param8, &decl.param8); if decl.retType != null as *TypeExpr { f.retTypeName = decl.retType.typeName; @@ -749,6 +763,198 @@ func HirLower_LowerModule(mod: *Module, sema: *Sema) -> *HirModule { else if fi == 61 { fname = decl.field61.name; ftype = decl.field61.refFieldType; } else if fi == 62 { fname = decl.field62.name; ftype = decl.field62.refFieldType; } else if fi == 63 { fname = decl.field63.name; ftype = decl.field63.refFieldType; } + else if fi == 64 { fname = decl.field64.name; ftype = decl.field64.refFieldType; } + else if fi == 65 { fname = decl.field65.name; ftype = decl.field65.refFieldType; } + else if fi == 66 { fname = decl.field66.name; ftype = decl.field66.refFieldType; } + else if fi == 67 { fname = decl.field67.name; ftype = decl.field67.refFieldType; } + else if fi == 68 { fname = decl.field68.name; ftype = decl.field68.refFieldType; } + else if fi == 69 { fname = decl.field69.name; ftype = decl.field69.refFieldType; } + else if fi == 70 { fname = decl.field70.name; ftype = decl.field70.refFieldType; } + else if fi == 71 { fname = decl.field71.name; ftype = decl.field71.refFieldType; } + else if fi == 72 { fname = decl.field72.name; ftype = decl.field72.refFieldType; } + else if fi == 73 { fname = decl.field73.name; ftype = decl.field73.refFieldType; } + else if fi == 74 { fname = decl.field74.name; ftype = decl.field74.refFieldType; } + else if fi == 75 { fname = decl.field75.name; ftype = decl.field75.refFieldType; } + else if fi == 76 { fname = decl.field76.name; ftype = decl.field76.refFieldType; } + else if fi == 77 { fname = decl.field77.name; ftype = decl.field77.refFieldType; } + else if fi == 78 { fname = decl.field78.name; ftype = decl.field78.refFieldType; } + else if fi == 79 { fname = decl.field79.name; ftype = decl.field79.refFieldType; } + else if fi == 80 { fname = decl.field80.name; ftype = decl.field80.refFieldType; } + else if fi == 81 { fname = decl.field81.name; ftype = decl.field81.refFieldType; } + else if fi == 82 { fname = decl.field82.name; ftype = decl.field82.refFieldType; } + else if fi == 83 { fname = decl.field83.name; ftype = decl.field83.refFieldType; } + else if fi == 84 { fname = decl.field84.name; ftype = decl.field84.refFieldType; } + else if fi == 85 { fname = decl.field85.name; ftype = decl.field85.refFieldType; } + else if fi == 86 { fname = decl.field86.name; ftype = decl.field86.refFieldType; } + else if fi == 87 { fname = decl.field87.name; ftype = decl.field87.refFieldType; } + else if fi == 88 { fname = decl.field88.name; ftype = decl.field88.refFieldType; } + else if fi == 89 { fname = decl.field89.name; ftype = decl.field89.refFieldType; } + else if fi == 90 { fname = decl.field90.name; ftype = decl.field90.refFieldType; } + else if fi == 91 { fname = decl.field91.name; ftype = decl.field91.refFieldType; } + else if fi == 92 { fname = decl.field92.name; ftype = decl.field92.refFieldType; } + else if fi == 93 { fname = decl.field93.name; ftype = decl.field93.refFieldType; } + else if fi == 94 { fname = decl.field94.name; ftype = decl.field94.refFieldType; } + else if fi == 95 { fname = decl.field95.name; ftype = decl.field95.refFieldType; } + else if fi == 96 { fname = decl.field96.name; ftype = decl.field96.refFieldType; } + else if fi == 97 { fname = decl.field97.name; ftype = decl.field97.refFieldType; } + else if fi == 98 { fname = decl.field98.name; ftype = decl.field98.refFieldType; } + else if fi == 99 { fname = decl.field99.name; ftype = decl.field99.refFieldType; } + else if fi == 100 { fname = decl.field100.name; ftype = decl.field100.refFieldType; } + else if fi == 101 { fname = decl.field101.name; ftype = decl.field101.refFieldType; } + else if fi == 102 { fname = decl.field102.name; ftype = decl.field102.refFieldType; } + else if fi == 103 { fname = decl.field103.name; ftype = decl.field103.refFieldType; } + else if fi == 104 { fname = decl.field104.name; ftype = decl.field104.refFieldType; } + else if fi == 105 { fname = decl.field105.name; ftype = decl.field105.refFieldType; } + else if fi == 106 { fname = decl.field106.name; ftype = decl.field106.refFieldType; } + else if fi == 107 { fname = decl.field107.name; ftype = decl.field107.refFieldType; } + else if fi == 108 { fname = decl.field108.name; ftype = decl.field108.refFieldType; } + else if fi == 109 { fname = decl.field109.name; ftype = decl.field109.refFieldType; } + else if fi == 110 { fname = decl.field110.name; ftype = decl.field110.refFieldType; } + else if fi == 111 { fname = decl.field111.name; ftype = decl.field111.refFieldType; } + else if fi == 112 { fname = decl.field112.name; ftype = decl.field112.refFieldType; } + else if fi == 113 { fname = decl.field113.name; ftype = decl.field113.refFieldType; } + else if fi == 114 { fname = decl.field114.name; ftype = decl.field114.refFieldType; } + else if fi == 115 { fname = decl.field115.name; ftype = decl.field115.refFieldType; } + else if fi == 116 { fname = decl.field116.name; ftype = decl.field116.refFieldType; } + else if fi == 117 { fname = decl.field117.name; ftype = decl.field117.refFieldType; } + else if fi == 118 { fname = decl.field118.name; ftype = decl.field118.refFieldType; } + else if fi == 119 { fname = decl.field119.name; ftype = decl.field119.refFieldType; } + else if fi == 120 { fname = decl.field120.name; ftype = decl.field120.refFieldType; } + else if fi == 121 { fname = decl.field121.name; ftype = decl.field121.refFieldType; } + else if fi == 122 { fname = decl.field122.name; ftype = decl.field122.refFieldType; } + else if fi == 123 { fname = decl.field123.name; ftype = decl.field123.refFieldType; } + else if fi == 124 { fname = decl.field124.name; ftype = decl.field124.refFieldType; } + else if fi == 125 { fname = decl.field125.name; ftype = decl.field125.refFieldType; } + else if fi == 126 { fname = decl.field126.name; ftype = decl.field126.refFieldType; } + else if fi == 127 { fname = decl.field127.name; ftype = decl.field127.refFieldType; } + else if fi == 128 { fname = decl.field128.name; ftype = decl.field128.refFieldType; } + else if fi == 129 { fname = decl.field129.name; ftype = decl.field129.refFieldType; } + else if fi == 130 { fname = decl.field130.name; ftype = decl.field130.refFieldType; } + else if fi == 131 { fname = decl.field131.name; ftype = decl.field131.refFieldType; } + else if fi == 132 { fname = decl.field132.name; ftype = decl.field132.refFieldType; } + else if fi == 133 { fname = decl.field133.name; ftype = decl.field133.refFieldType; } + else if fi == 134 { fname = decl.field134.name; ftype = decl.field134.refFieldType; } + else if fi == 135 { fname = decl.field135.name; ftype = decl.field135.refFieldType; } + else if fi == 136 { fname = decl.field136.name; ftype = decl.field136.refFieldType; } + else if fi == 137 { fname = decl.field137.name; ftype = decl.field137.refFieldType; } + else if fi == 138 { fname = decl.field138.name; ftype = decl.field138.refFieldType; } + else if fi == 139 { fname = decl.field139.name; ftype = decl.field139.refFieldType; } + else if fi == 140 { fname = decl.field140.name; ftype = decl.field140.refFieldType; } + else if fi == 141 { fname = decl.field141.name; ftype = decl.field141.refFieldType; } + else if fi == 142 { fname = decl.field142.name; ftype = decl.field142.refFieldType; } + else if fi == 143 { fname = decl.field143.name; ftype = decl.field143.refFieldType; } + else if fi == 144 { fname = decl.field144.name; ftype = decl.field144.refFieldType; } + else if fi == 145 { fname = decl.field145.name; ftype = decl.field145.refFieldType; } + else if fi == 146 { fname = decl.field146.name; ftype = decl.field146.refFieldType; } + else if fi == 147 { fname = decl.field147.name; ftype = decl.field147.refFieldType; } + else if fi == 148 { fname = decl.field148.name; ftype = decl.field148.refFieldType; } + else if fi == 149 { fname = decl.field149.name; ftype = decl.field149.refFieldType; } + else if fi == 150 { fname = decl.field150.name; ftype = decl.field150.refFieldType; } + else if fi == 151 { fname = decl.field151.name; ftype = decl.field151.refFieldType; } + else if fi == 152 { fname = decl.field152.name; ftype = decl.field152.refFieldType; } + else if fi == 153 { fname = decl.field153.name; ftype = decl.field153.refFieldType; } + else if fi == 154 { fname = decl.field154.name; ftype = decl.field154.refFieldType; } + else if fi == 155 { fname = decl.field155.name; ftype = decl.field155.refFieldType; } + else if fi == 156 { fname = decl.field156.name; ftype = decl.field156.refFieldType; } + else if fi == 157 { fname = decl.field157.name; ftype = decl.field157.refFieldType; } + else if fi == 158 { fname = decl.field158.name; ftype = decl.field158.refFieldType; } + else if fi == 159 { fname = decl.field159.name; ftype = decl.field159.refFieldType; } + else if fi == 160 { fname = decl.field160.name; ftype = decl.field160.refFieldType; } + else if fi == 161 { fname = decl.field161.name; ftype = decl.field161.refFieldType; } + else if fi == 162 { fname = decl.field162.name; ftype = decl.field162.refFieldType; } + else if fi == 163 { fname = decl.field163.name; ftype = decl.field163.refFieldType; } + else if fi == 164 { fname = decl.field164.name; ftype = decl.field164.refFieldType; } + else if fi == 165 { fname = decl.field165.name; ftype = decl.field165.refFieldType; } + else if fi == 166 { fname = decl.field166.name; ftype = decl.field166.refFieldType; } + else if fi == 167 { fname = decl.field167.name; ftype = decl.field167.refFieldType; } + else if fi == 168 { fname = decl.field168.name; ftype = decl.field168.refFieldType; } + else if fi == 169 { fname = decl.field169.name; ftype = decl.field169.refFieldType; } + else if fi == 170 { fname = decl.field170.name; ftype = decl.field170.refFieldType; } + else if fi == 171 { fname = decl.field171.name; ftype = decl.field171.refFieldType; } + else if fi == 172 { fname = decl.field172.name; ftype = decl.field172.refFieldType; } + else if fi == 173 { fname = decl.field173.name; ftype = decl.field173.refFieldType; } + else if fi == 174 { fname = decl.field174.name; ftype = decl.field174.refFieldType; } + else if fi == 175 { fname = decl.field175.name; ftype = decl.field175.refFieldType; } + else if fi == 176 { fname = decl.field176.name; ftype = decl.field176.refFieldType; } + else if fi == 177 { fname = decl.field177.name; ftype = decl.field177.refFieldType; } + else if fi == 178 { fname = decl.field178.name; ftype = decl.field178.refFieldType; } + else if fi == 179 { fname = decl.field179.name; ftype = decl.field179.refFieldType; } + else if fi == 180 { fname = decl.field180.name; ftype = decl.field180.refFieldType; } + else if fi == 181 { fname = decl.field181.name; ftype = decl.field181.refFieldType; } + else if fi == 182 { fname = decl.field182.name; ftype = decl.field182.refFieldType; } + else if fi == 183 { fname = decl.field183.name; ftype = decl.field183.refFieldType; } + else if fi == 184 { fname = decl.field184.name; ftype = decl.field184.refFieldType; } + else if fi == 185 { fname = decl.field185.name; ftype = decl.field185.refFieldType; } + else if fi == 186 { fname = decl.field186.name; ftype = decl.field186.refFieldType; } + else if fi == 187 { fname = decl.field187.name; ftype = decl.field187.refFieldType; } + else if fi == 188 { fname = decl.field188.name; ftype = decl.field188.refFieldType; } + else if fi == 189 { fname = decl.field189.name; ftype = decl.field189.refFieldType; } + else if fi == 190 { fname = decl.field190.name; ftype = decl.field190.refFieldType; } + else if fi == 191 { fname = decl.field191.name; ftype = decl.field191.refFieldType; } + else if fi == 192 { fname = decl.field192.name; ftype = decl.field192.refFieldType; } + else if fi == 193 { fname = decl.field193.name; ftype = decl.field193.refFieldType; } + else if fi == 194 { fname = decl.field194.name; ftype = decl.field194.refFieldType; } + else if fi == 195 { fname = decl.field195.name; ftype = decl.field195.refFieldType; } + else if fi == 196 { fname = decl.field196.name; ftype = decl.field196.refFieldType; } + else if fi == 197 { fname = decl.field197.name; ftype = decl.field197.refFieldType; } + else if fi == 198 { fname = decl.field198.name; ftype = decl.field198.refFieldType; } + else if fi == 199 { fname = decl.field199.name; ftype = decl.field199.refFieldType; } + else if fi == 200 { fname = decl.field200.name; ftype = decl.field200.refFieldType; } + else if fi == 201 { fname = decl.field201.name; ftype = decl.field201.refFieldType; } + else if fi == 202 { fname = decl.field202.name; ftype = decl.field202.refFieldType; } + else if fi == 203 { fname = decl.field203.name; ftype = decl.field203.refFieldType; } + else if fi == 204 { fname = decl.field204.name; ftype = decl.field204.refFieldType; } + else if fi == 205 { fname = decl.field205.name; ftype = decl.field205.refFieldType; } + else if fi == 206 { fname = decl.field206.name; ftype = decl.field206.refFieldType; } + else if fi == 207 { fname = decl.field207.name; ftype = decl.field207.refFieldType; } + else if fi == 208 { fname = decl.field208.name; ftype = decl.field208.refFieldType; } + else if fi == 209 { fname = decl.field209.name; ftype = decl.field209.refFieldType; } + else if fi == 210 { fname = decl.field210.name; ftype = decl.field210.refFieldType; } + else if fi == 211 { fname = decl.field211.name; ftype = decl.field211.refFieldType; } + else if fi == 212 { fname = decl.field212.name; ftype = decl.field212.refFieldType; } + else if fi == 213 { fname = decl.field213.name; ftype = decl.field213.refFieldType; } + else if fi == 214 { fname = decl.field214.name; ftype = decl.field214.refFieldType; } + else if fi == 215 { fname = decl.field215.name; ftype = decl.field215.refFieldType; } + else if fi == 216 { fname = decl.field216.name; ftype = decl.field216.refFieldType; } + else if fi == 217 { fname = decl.field217.name; ftype = decl.field217.refFieldType; } + else if fi == 218 { fname = decl.field218.name; ftype = decl.field218.refFieldType; } + else if fi == 219 { fname = decl.field219.name; ftype = decl.field219.refFieldType; } + else if fi == 220 { fname = decl.field220.name; ftype = decl.field220.refFieldType; } + else if fi == 221 { fname = decl.field221.name; ftype = decl.field221.refFieldType; } + else if fi == 222 { fname = decl.field222.name; ftype = decl.field222.refFieldType; } + else if fi == 223 { fname = decl.field223.name; ftype = decl.field223.refFieldType; } + else if fi == 224 { fname = decl.field224.name; ftype = decl.field224.refFieldType; } + else if fi == 225 { fname = decl.field225.name; ftype = decl.field225.refFieldType; } + else if fi == 226 { fname = decl.field226.name; ftype = decl.field226.refFieldType; } + else if fi == 227 { fname = decl.field227.name; ftype = decl.field227.refFieldType; } + else if fi == 228 { fname = decl.field228.name; ftype = decl.field228.refFieldType; } + else if fi == 229 { fname = decl.field229.name; ftype = decl.field229.refFieldType; } + else if fi == 230 { fname = decl.field230.name; ftype = decl.field230.refFieldType; } + else if fi == 231 { fname = decl.field231.name; ftype = decl.field231.refFieldType; } + else if fi == 232 { fname = decl.field232.name; ftype = decl.field232.refFieldType; } + else if fi == 233 { fname = decl.field233.name; ftype = decl.field233.refFieldType; } + else if fi == 234 { fname = decl.field234.name; ftype = decl.field234.refFieldType; } + else if fi == 235 { fname = decl.field235.name; ftype = decl.field235.refFieldType; } + else if fi == 236 { fname = decl.field236.name; ftype = decl.field236.refFieldType; } + else if fi == 237 { fname = decl.field237.name; ftype = decl.field237.refFieldType; } + else if fi == 238 { fname = decl.field238.name; ftype = decl.field238.refFieldType; } + else if fi == 239 { fname = decl.field239.name; ftype = decl.field239.refFieldType; } + else if fi == 240 { fname = decl.field240.name; ftype = decl.field240.refFieldType; } + else if fi == 241 { fname = decl.field241.name; ftype = decl.field241.refFieldType; } + else if fi == 242 { fname = decl.field242.name; ftype = decl.field242.refFieldType; } + else if fi == 243 { fname = decl.field243.name; ftype = decl.field243.refFieldType; } + else if fi == 244 { fname = decl.field244.name; ftype = decl.field244.refFieldType; } + else if fi == 245 { fname = decl.field245.name; ftype = decl.field245.refFieldType; } + else if fi == 246 { fname = decl.field246.name; ftype = decl.field246.refFieldType; } + else if fi == 247 { fname = decl.field247.name; ftype = decl.field247.refFieldType; } + else if fi == 248 { fname = decl.field248.name; ftype = decl.field248.refFieldType; } + else if fi == 249 { fname = decl.field249.name; ftype = decl.field249.refFieldType; } + else if fi == 250 { fname = decl.field250.name; ftype = decl.field250.refFieldType; } + else if fi == 251 { fname = decl.field251.name; ftype = decl.field251.refFieldType; } + else if fi == 252 { fname = decl.field252.name; ftype = decl.field252.refFieldType; } + else if fi == 253 { fname = decl.field253.name; ftype = decl.field253.refFieldType; } + else if fi == 254 { fname = decl.field254.name; ftype = decl.field254.refFieldType; } + else if fi == 255 { fname = decl.field255.name; ftype = decl.field255.refFieldType; } // Skip empty field names if String_Eq(fname, "") { fi = fi + 1; diff --git a/src/parser.bux b/src/parser.bux index 07f84e0..301fadb 100644 --- a/src/parser.bux +++ b/src/parser.bux @@ -3,6 +3,7 @@ module Parser { extern func bux_strlen(s: String) -> uint; +extern func bux_str_to_int(s: String) -> int64; // Forward declarations for mutual recursion func parserParseExpr(p: *Parser) -> *Expr; @@ -10,6 +11,7 @@ func parserParseStmt(p: *Parser) -> *Stmt; func parserParseBlock(p: *Parser) -> *Block; func parserParsePrimary(p: *Parser) -> *Expr; func parserParsePostfixExpr(p: *Parser) -> *Expr; +func parserParseUnary(p: *Parser) -> *Expr; func parserParseBinaryPrec(p: *Parser, minPrec: int) -> *Expr; // --------------------------------------------------------------------------- @@ -119,10 +121,12 @@ func parserExpect(p: *Parser, kind: int, msg: String) -> LexToken { } func parserEmitDiag(p: *Parser, line: uint32, col: uint32, msg: String) { - p.diags[p.diagCount] = ParserDiag { - line: line, column: col, message: msg - }; - p.diagCount = p.diagCount + 1; + if p.diagCount < 256 { + p.diags[p.diagCount] = ParserDiag { + line: line, column: col, message: msg + }; + p.diagCount = p.diagCount + 1; + } } func parserIsKeyword(kind: int) -> bool { @@ -244,6 +248,9 @@ func parserParsePrimary(p: *Parser) -> *Expr { let e: *Expr = parserMakeExpr(ekLiteral, line, col); e.tokKind = kind; e.tokText = tok.text; + if kind == tkIntLiteral { + e.intValue = bux_str_to_int(tok.text) as int; + } return e; } @@ -317,15 +324,6 @@ func parserParsePrimary(p: *Parser) -> *Expr { return e; } - // -expr, !expr, *expr, &expr - if kind == tkMinus || kind == tkBang || kind == tkStar || kind == tkAmp { - discard parserAdvance(p); - let e: *Expr = parserMakeExpr(ekUnary, line, col); - e.intValue = kind; - e.child1 = parserParsePrimary(p); - return e; - } - parserEmitDiag(p, line, col, "expected expression"); return parserMakeExpr(ekLiteral, line, col); } @@ -573,8 +571,26 @@ func parserPrecedence(op: int) -> int { return 0; } +func parserParseUnary(p: *Parser) -> *Expr { + let tok: LexToken = parserCurToken(p); + let line: uint32 = tok.line; + let col: uint32 = tok.column; + let kind: int = tok.kind; + + // -expr, !expr, *expr, &expr + if kind == tkMinus || kind == tkBang || kind == tkStar || kind == tkAmp { + discard parserAdvance(p); + let e: *Expr = parserMakeExpr(ekUnary, line, col); + e.intValue = kind; + e.child1 = parserParseUnary(p); + return e; + } + + return parserParsePostfixExpr(p); +} + func parserParseBinaryPrec(p: *Parser, minPrec: int) -> *Expr { - var left: *Expr = parserParsePostfixExpr(p); + var left: *Expr = parserParseUnary(p); while true { let op: int = parserPeek(p, 0); let prec: int = parserPrecedence(op); @@ -643,8 +659,13 @@ func parserParseStmt(p: *Parser) -> *Stmt { if parserMatch(p, tkColon) { typeExpr = parserParseType(p); } - discard parserExpect(p, tkAssign, "expected '=' in let/var statement"); - let init: *Expr = parserParseExpr(p); + var init: *Expr = null as *Expr; + if parserMatch(p, tkAssign) { + init = parserParseExpr(p); + } else if !isVar { + discard parserExpect(p, tkAssign, "expected '=' in let statement"); + init = parserParseExpr(p); + } parserMatch(p, tkSemicolon); // optional ; let s: *Stmt = bux_alloc(sizeof(Stmt)) as *Stmt; @@ -658,6 +679,22 @@ func parserParseStmt(p: *Parser) -> *Stmt { return s; } + // discard expr + if kind == tkDiscard { + discard parserAdvance(p); + var val: *Expr = null as *Expr; + if !parserCheck(p, tkSemicolon) && !parserCheck(p, tkRBrace) && !parserCheck(p, tkNewLine) { + val = parserParseExpr(p); + } + parserMatch(p, tkSemicolon); + let s: *Stmt = bux_alloc(sizeof(Stmt)) as *Stmt; + s.kind = skExpr; + s.line = line; + s.column = col; + s.child1 = val; + return s; + } + // if if kind == tkIf { discard parserAdvance(p); @@ -995,7 +1032,7 @@ func parserParseStructDecl(p: *Parser, isPublic: bool) -> *Decl { discard parserExpect(p, tkLBrace, "expected '{'"); while !parserCheck(p, tkRBrace) && parserPeek(p, 0) != tkEndOfFile { - if d.fieldCount >= 64 { break; } + if d.fieldCount >= 256 { break; } if parserCheck(p, tkNewLine) { discard parserAdvance(p); continue; } if parserCheck(p, tkSemicolon) { discard parserAdvance(p); continue; } let beforePos: int = p.pos; @@ -1201,6 +1238,582 @@ func parserParseStructDecl(p: *Parser, isPublic: bool) -> *Decl { } else if d.fieldCount == 63 { d.field63.name = fName.text; d.field63.refFieldType = fType; + } else if d.fieldCount == 64 { + d.field64.name = fName.text; + d.field64.refFieldType = fType; + } else if d.fieldCount == 65 { + d.field65.name = fName.text; + d.field65.refFieldType = fType; + } else if d.fieldCount == 66 { + d.field66.name = fName.text; + d.field66.refFieldType = fType; + } else if d.fieldCount == 67 { + d.field67.name = fName.text; + d.field67.refFieldType = fType; + } else if d.fieldCount == 68 { + d.field68.name = fName.text; + d.field68.refFieldType = fType; + } else if d.fieldCount == 69 { + d.field69.name = fName.text; + d.field69.refFieldType = fType; + } else if d.fieldCount == 70 { + d.field70.name = fName.text; + d.field70.refFieldType = fType; + } else if d.fieldCount == 71 { + d.field71.name = fName.text; + d.field71.refFieldType = fType; + } else if d.fieldCount == 72 { + d.field72.name = fName.text; + d.field72.refFieldType = fType; + } else if d.fieldCount == 73 { + d.field73.name = fName.text; + d.field73.refFieldType = fType; + } else if d.fieldCount == 74 { + d.field74.name = fName.text; + d.field74.refFieldType = fType; + } else if d.fieldCount == 75 { + d.field75.name = fName.text; + d.field75.refFieldType = fType; + } else if d.fieldCount == 76 { + d.field76.name = fName.text; + d.field76.refFieldType = fType; + } else if d.fieldCount == 77 { + d.field77.name = fName.text; + d.field77.refFieldType = fType; + } else if d.fieldCount == 78 { + d.field78.name = fName.text; + d.field78.refFieldType = fType; + } else if d.fieldCount == 79 { + d.field79.name = fName.text; + d.field79.refFieldType = fType; + } else if d.fieldCount == 80 { + d.field80.name = fName.text; + d.field80.refFieldType = fType; + } else if d.fieldCount == 81 { + d.field81.name = fName.text; + d.field81.refFieldType = fType; + } else if d.fieldCount == 82 { + d.field82.name = fName.text; + d.field82.refFieldType = fType; + } else if d.fieldCount == 83 { + d.field83.name = fName.text; + d.field83.refFieldType = fType; + } else if d.fieldCount == 84 { + d.field84.name = fName.text; + d.field84.refFieldType = fType; + } else if d.fieldCount == 85 { + d.field85.name = fName.text; + d.field85.refFieldType = fType; + } else if d.fieldCount == 86 { + d.field86.name = fName.text; + d.field86.refFieldType = fType; + } else if d.fieldCount == 87 { + d.field87.name = fName.text; + d.field87.refFieldType = fType; + } else if d.fieldCount == 88 { + d.field88.name = fName.text; + d.field88.refFieldType = fType; + } else if d.fieldCount == 89 { + d.field89.name = fName.text; + d.field89.refFieldType = fType; + } else if d.fieldCount == 90 { + d.field90.name = fName.text; + d.field90.refFieldType = fType; + } else if d.fieldCount == 91 { + d.field91.name = fName.text; + d.field91.refFieldType = fType; + } else if d.fieldCount == 92 { + d.field92.name = fName.text; + d.field92.refFieldType = fType; + } else if d.fieldCount == 93 { + d.field93.name = fName.text; + d.field93.refFieldType = fType; + } else if d.fieldCount == 94 { + d.field94.name = fName.text; + d.field94.refFieldType = fType; + } else if d.fieldCount == 95 { + d.field95.name = fName.text; + d.field95.refFieldType = fType; + } else if d.fieldCount == 96 { + d.field96.name = fName.text; + d.field96.refFieldType = fType; + } else if d.fieldCount == 97 { + d.field97.name = fName.text; + d.field97.refFieldType = fType; + } else if d.fieldCount == 98 { + d.field98.name = fName.text; + d.field98.refFieldType = fType; + } else if d.fieldCount == 99 { + d.field99.name = fName.text; + d.field99.refFieldType = fType; + } else if d.fieldCount == 100 { + d.field100.name = fName.text; + d.field100.refFieldType = fType; + } else if d.fieldCount == 101 { + d.field101.name = fName.text; + d.field101.refFieldType = fType; + } else if d.fieldCount == 102 { + d.field102.name = fName.text; + d.field102.refFieldType = fType; + } else if d.fieldCount == 103 { + d.field103.name = fName.text; + d.field103.refFieldType = fType; + } else if d.fieldCount == 104 { + d.field104.name = fName.text; + d.field104.refFieldType = fType; + } else if d.fieldCount == 105 { + d.field105.name = fName.text; + d.field105.refFieldType = fType; + } else if d.fieldCount == 106 { + d.field106.name = fName.text; + d.field106.refFieldType = fType; + } else if d.fieldCount == 107 { + d.field107.name = fName.text; + d.field107.refFieldType = fType; + } else if d.fieldCount == 108 { + d.field108.name = fName.text; + d.field108.refFieldType = fType; + } else if d.fieldCount == 109 { + d.field109.name = fName.text; + d.field109.refFieldType = fType; + } else if d.fieldCount == 110 { + d.field110.name = fName.text; + d.field110.refFieldType = fType; + } else if d.fieldCount == 111 { + d.field111.name = fName.text; + d.field111.refFieldType = fType; + } else if d.fieldCount == 112 { + d.field112.name = fName.text; + d.field112.refFieldType = fType; + } else if d.fieldCount == 113 { + d.field113.name = fName.text; + d.field113.refFieldType = fType; + } else if d.fieldCount == 114 { + d.field114.name = fName.text; + d.field114.refFieldType = fType; + } else if d.fieldCount == 115 { + d.field115.name = fName.text; + d.field115.refFieldType = fType; + } else if d.fieldCount == 116 { + d.field116.name = fName.text; + d.field116.refFieldType = fType; + } else if d.fieldCount == 117 { + d.field117.name = fName.text; + d.field117.refFieldType = fType; + } else if d.fieldCount == 118 { + d.field118.name = fName.text; + d.field118.refFieldType = fType; + } else if d.fieldCount == 119 { + d.field119.name = fName.text; + d.field119.refFieldType = fType; + } else if d.fieldCount == 120 { + d.field120.name = fName.text; + d.field120.refFieldType = fType; + } else if d.fieldCount == 121 { + d.field121.name = fName.text; + d.field121.refFieldType = fType; + } else if d.fieldCount == 122 { + d.field122.name = fName.text; + d.field122.refFieldType = fType; + } else if d.fieldCount == 123 { + d.field123.name = fName.text; + d.field123.refFieldType = fType; + } else if d.fieldCount == 124 { + d.field124.name = fName.text; + d.field124.refFieldType = fType; + } else if d.fieldCount == 125 { + d.field125.name = fName.text; + d.field125.refFieldType = fType; + } else if d.fieldCount == 126 { + d.field126.name = fName.text; + d.field126.refFieldType = fType; + } else if d.fieldCount == 127 { + d.field127.name = fName.text; + d.field127.refFieldType = fType; + } else if d.fieldCount == 128 { + d.field128.name = fName.text; + d.field128.refFieldType = fType; + } else if d.fieldCount == 129 { + d.field129.name = fName.text; + d.field129.refFieldType = fType; + } else if d.fieldCount == 130 { + d.field130.name = fName.text; + d.field130.refFieldType = fType; + } else if d.fieldCount == 131 { + d.field131.name = fName.text; + d.field131.refFieldType = fType; + } else if d.fieldCount == 132 { + d.field132.name = fName.text; + d.field132.refFieldType = fType; + } else if d.fieldCount == 133 { + d.field133.name = fName.text; + d.field133.refFieldType = fType; + } else if d.fieldCount == 134 { + d.field134.name = fName.text; + d.field134.refFieldType = fType; + } else if d.fieldCount == 135 { + d.field135.name = fName.text; + d.field135.refFieldType = fType; + } else if d.fieldCount == 136 { + d.field136.name = fName.text; + d.field136.refFieldType = fType; + } else if d.fieldCount == 137 { + d.field137.name = fName.text; + d.field137.refFieldType = fType; + } else if d.fieldCount == 138 { + d.field138.name = fName.text; + d.field138.refFieldType = fType; + } else if d.fieldCount == 139 { + d.field139.name = fName.text; + d.field139.refFieldType = fType; + } else if d.fieldCount == 140 { + d.field140.name = fName.text; + d.field140.refFieldType = fType; + } else if d.fieldCount == 141 { + d.field141.name = fName.text; + d.field141.refFieldType = fType; + } else if d.fieldCount == 142 { + d.field142.name = fName.text; + d.field142.refFieldType = fType; + } else if d.fieldCount == 143 { + d.field143.name = fName.text; + d.field143.refFieldType = fType; + } else if d.fieldCount == 144 { + d.field144.name = fName.text; + d.field144.refFieldType = fType; + } else if d.fieldCount == 145 { + d.field145.name = fName.text; + d.field145.refFieldType = fType; + } else if d.fieldCount == 146 { + d.field146.name = fName.text; + d.field146.refFieldType = fType; + } else if d.fieldCount == 147 { + d.field147.name = fName.text; + d.field147.refFieldType = fType; + } else if d.fieldCount == 148 { + d.field148.name = fName.text; + d.field148.refFieldType = fType; + } else if d.fieldCount == 149 { + d.field149.name = fName.text; + d.field149.refFieldType = fType; + } else if d.fieldCount == 150 { + d.field150.name = fName.text; + d.field150.refFieldType = fType; + } else if d.fieldCount == 151 { + d.field151.name = fName.text; + d.field151.refFieldType = fType; + } else if d.fieldCount == 152 { + d.field152.name = fName.text; + d.field152.refFieldType = fType; + } else if d.fieldCount == 153 { + d.field153.name = fName.text; + d.field153.refFieldType = fType; + } else if d.fieldCount == 154 { + d.field154.name = fName.text; + d.field154.refFieldType = fType; + } else if d.fieldCount == 155 { + d.field155.name = fName.text; + d.field155.refFieldType = fType; + } else if d.fieldCount == 156 { + d.field156.name = fName.text; + d.field156.refFieldType = fType; + } else if d.fieldCount == 157 { + d.field157.name = fName.text; + d.field157.refFieldType = fType; + } else if d.fieldCount == 158 { + d.field158.name = fName.text; + d.field158.refFieldType = fType; + } else if d.fieldCount == 159 { + d.field159.name = fName.text; + d.field159.refFieldType = fType; + } else if d.fieldCount == 160 { + d.field160.name = fName.text; + d.field160.refFieldType = fType; + } else if d.fieldCount == 161 { + d.field161.name = fName.text; + d.field161.refFieldType = fType; + } else if d.fieldCount == 162 { + d.field162.name = fName.text; + d.field162.refFieldType = fType; + } else if d.fieldCount == 163 { + d.field163.name = fName.text; + d.field163.refFieldType = fType; + } else if d.fieldCount == 164 { + d.field164.name = fName.text; + d.field164.refFieldType = fType; + } else if d.fieldCount == 165 { + d.field165.name = fName.text; + d.field165.refFieldType = fType; + } else if d.fieldCount == 166 { + d.field166.name = fName.text; + d.field166.refFieldType = fType; + } else if d.fieldCount == 167 { + d.field167.name = fName.text; + d.field167.refFieldType = fType; + } else if d.fieldCount == 168 { + d.field168.name = fName.text; + d.field168.refFieldType = fType; + } else if d.fieldCount == 169 { + d.field169.name = fName.text; + d.field169.refFieldType = fType; + } else if d.fieldCount == 170 { + d.field170.name = fName.text; + d.field170.refFieldType = fType; + } else if d.fieldCount == 171 { + d.field171.name = fName.text; + d.field171.refFieldType = fType; + } else if d.fieldCount == 172 { + d.field172.name = fName.text; + d.field172.refFieldType = fType; + } else if d.fieldCount == 173 { + d.field173.name = fName.text; + d.field173.refFieldType = fType; + } else if d.fieldCount == 174 { + d.field174.name = fName.text; + d.field174.refFieldType = fType; + } else if d.fieldCount == 175 { + d.field175.name = fName.text; + d.field175.refFieldType = fType; + } else if d.fieldCount == 176 { + d.field176.name = fName.text; + d.field176.refFieldType = fType; + } else if d.fieldCount == 177 { + d.field177.name = fName.text; + d.field177.refFieldType = fType; + } else if d.fieldCount == 178 { + d.field178.name = fName.text; + d.field178.refFieldType = fType; + } else if d.fieldCount == 179 { + d.field179.name = fName.text; + d.field179.refFieldType = fType; + } else if d.fieldCount == 180 { + d.field180.name = fName.text; + d.field180.refFieldType = fType; + } else if d.fieldCount == 181 { + d.field181.name = fName.text; + d.field181.refFieldType = fType; + } else if d.fieldCount == 182 { + d.field182.name = fName.text; + d.field182.refFieldType = fType; + } else if d.fieldCount == 183 { + d.field183.name = fName.text; + d.field183.refFieldType = fType; + } else if d.fieldCount == 184 { + d.field184.name = fName.text; + d.field184.refFieldType = fType; + } else if d.fieldCount == 185 { + d.field185.name = fName.text; + d.field185.refFieldType = fType; + } else if d.fieldCount == 186 { + d.field186.name = fName.text; + d.field186.refFieldType = fType; + } else if d.fieldCount == 187 { + d.field187.name = fName.text; + d.field187.refFieldType = fType; + } else if d.fieldCount == 188 { + d.field188.name = fName.text; + d.field188.refFieldType = fType; + } else if d.fieldCount == 189 { + d.field189.name = fName.text; + d.field189.refFieldType = fType; + } else if d.fieldCount == 190 { + d.field190.name = fName.text; + d.field190.refFieldType = fType; + } else if d.fieldCount == 191 { + d.field191.name = fName.text; + d.field191.refFieldType = fType; + } else if d.fieldCount == 192 { + d.field192.name = fName.text; + d.field192.refFieldType = fType; + } else if d.fieldCount == 193 { + d.field193.name = fName.text; + d.field193.refFieldType = fType; + } else if d.fieldCount == 194 { + d.field194.name = fName.text; + d.field194.refFieldType = fType; + } else if d.fieldCount == 195 { + d.field195.name = fName.text; + d.field195.refFieldType = fType; + } else if d.fieldCount == 196 { + d.field196.name = fName.text; + d.field196.refFieldType = fType; + } else if d.fieldCount == 197 { + d.field197.name = fName.text; + d.field197.refFieldType = fType; + } else if d.fieldCount == 198 { + d.field198.name = fName.text; + d.field198.refFieldType = fType; + } else if d.fieldCount == 199 { + d.field199.name = fName.text; + d.field199.refFieldType = fType; + } else if d.fieldCount == 200 { + d.field200.name = fName.text; + d.field200.refFieldType = fType; + } else if d.fieldCount == 201 { + d.field201.name = fName.text; + d.field201.refFieldType = fType; + } else if d.fieldCount == 202 { + d.field202.name = fName.text; + d.field202.refFieldType = fType; + } else if d.fieldCount == 203 { + d.field203.name = fName.text; + d.field203.refFieldType = fType; + } else if d.fieldCount == 204 { + d.field204.name = fName.text; + d.field204.refFieldType = fType; + } else if d.fieldCount == 205 { + d.field205.name = fName.text; + d.field205.refFieldType = fType; + } else if d.fieldCount == 206 { + d.field206.name = fName.text; + d.field206.refFieldType = fType; + } else if d.fieldCount == 207 { + d.field207.name = fName.text; + d.field207.refFieldType = fType; + } else if d.fieldCount == 208 { + d.field208.name = fName.text; + d.field208.refFieldType = fType; + } else if d.fieldCount == 209 { + d.field209.name = fName.text; + d.field209.refFieldType = fType; + } else if d.fieldCount == 210 { + d.field210.name = fName.text; + d.field210.refFieldType = fType; + } else if d.fieldCount == 211 { + d.field211.name = fName.text; + d.field211.refFieldType = fType; + } else if d.fieldCount == 212 { + d.field212.name = fName.text; + d.field212.refFieldType = fType; + } else if d.fieldCount == 213 { + d.field213.name = fName.text; + d.field213.refFieldType = fType; + } else if d.fieldCount == 214 { + d.field214.name = fName.text; + d.field214.refFieldType = fType; + } else if d.fieldCount == 215 { + d.field215.name = fName.text; + d.field215.refFieldType = fType; + } else if d.fieldCount == 216 { + d.field216.name = fName.text; + d.field216.refFieldType = fType; + } else if d.fieldCount == 217 { + d.field217.name = fName.text; + d.field217.refFieldType = fType; + } else if d.fieldCount == 218 { + d.field218.name = fName.text; + d.field218.refFieldType = fType; + } else if d.fieldCount == 219 { + d.field219.name = fName.text; + d.field219.refFieldType = fType; + } else if d.fieldCount == 220 { + d.field220.name = fName.text; + d.field220.refFieldType = fType; + } else if d.fieldCount == 221 { + d.field221.name = fName.text; + d.field221.refFieldType = fType; + } else if d.fieldCount == 222 { + d.field222.name = fName.text; + d.field222.refFieldType = fType; + } else if d.fieldCount == 223 { + d.field223.name = fName.text; + d.field223.refFieldType = fType; + } else if d.fieldCount == 224 { + d.field224.name = fName.text; + d.field224.refFieldType = fType; + } else if d.fieldCount == 225 { + d.field225.name = fName.text; + d.field225.refFieldType = fType; + } else if d.fieldCount == 226 { + d.field226.name = fName.text; + d.field226.refFieldType = fType; + } else if d.fieldCount == 227 { + d.field227.name = fName.text; + d.field227.refFieldType = fType; + } else if d.fieldCount == 228 { + d.field228.name = fName.text; + d.field228.refFieldType = fType; + } else if d.fieldCount == 229 { + d.field229.name = fName.text; + d.field229.refFieldType = fType; + } else if d.fieldCount == 230 { + d.field230.name = fName.text; + d.field230.refFieldType = fType; + } else if d.fieldCount == 231 { + d.field231.name = fName.text; + d.field231.refFieldType = fType; + } else if d.fieldCount == 232 { + d.field232.name = fName.text; + d.field232.refFieldType = fType; + } else if d.fieldCount == 233 { + d.field233.name = fName.text; + d.field233.refFieldType = fType; + } else if d.fieldCount == 234 { + d.field234.name = fName.text; + d.field234.refFieldType = fType; + } else if d.fieldCount == 235 { + d.field235.name = fName.text; + d.field235.refFieldType = fType; + } else if d.fieldCount == 236 { + d.field236.name = fName.text; + d.field236.refFieldType = fType; + } else if d.fieldCount == 237 { + d.field237.name = fName.text; + d.field237.refFieldType = fType; + } else if d.fieldCount == 238 { + d.field238.name = fName.text; + d.field238.refFieldType = fType; + } else if d.fieldCount == 239 { + d.field239.name = fName.text; + d.field239.refFieldType = fType; + } else if d.fieldCount == 240 { + d.field240.name = fName.text; + d.field240.refFieldType = fType; + } else if d.fieldCount == 241 { + d.field241.name = fName.text; + d.field241.refFieldType = fType; + } else if d.fieldCount == 242 { + d.field242.name = fName.text; + d.field242.refFieldType = fType; + } else if d.fieldCount == 243 { + d.field243.name = fName.text; + d.field243.refFieldType = fType; + } else if d.fieldCount == 244 { + d.field244.name = fName.text; + d.field244.refFieldType = fType; + } else if d.fieldCount == 245 { + d.field245.name = fName.text; + d.field245.refFieldType = fType; + } else if d.fieldCount == 246 { + d.field246.name = fName.text; + d.field246.refFieldType = fType; + } else if d.fieldCount == 247 { + d.field247.name = fName.text; + d.field247.refFieldType = fType; + } else if d.fieldCount == 248 { + d.field248.name = fName.text; + d.field248.refFieldType = fType; + } else if d.fieldCount == 249 { + d.field249.name = fName.text; + d.field249.refFieldType = fType; + } else if d.fieldCount == 250 { + d.field250.name = fName.text; + d.field250.refFieldType = fType; + } else if d.fieldCount == 251 { + d.field251.name = fName.text; + d.field251.refFieldType = fType; + } else if d.fieldCount == 252 { + d.field252.name = fName.text; + d.field252.refFieldType = fType; + } else if d.fieldCount == 253 { + d.field253.name = fName.text; + d.field253.refFieldType = fType; + } else if d.fieldCount == 254 { + d.field254.name = fName.text; + d.field254.refFieldType = fType; + } else if d.fieldCount == 255 { + d.field255.name = fName.text; + d.field255.refFieldType = fType; } d.fieldCount = d.fieldCount + 1; } diff --git a/src/sema.bux b/src/sema.bux index 194fdee..a718808 100644 --- a/src/sema.bux +++ b/src/sema.bux @@ -318,7 +318,11 @@ func Sema_CheckStmt(sema: *Sema, stmt: *Stmt) { sym.typeKind = initType; sym.typeName = ""; if stmt.refStmtType != null as *TypeExpr { - sym.typeName = stmt.refStmtType.typeName; + if stmt.refStmtType.kind == tekPointer && stmt.refStmtType.pointerPointee != null as *TypeExpr { + sym.typeName = String_Concat(stmt.refStmtType.pointerPointee.typeName, "*"); + } else { + sym.typeName = stmt.refStmtType.typeName; + } } sym.isMutable = stmt.boolValue; sym.isPublic = false; @@ -695,7 +699,11 @@ func Sema_Analyze(mod: *Module) -> *Sema { pSym.kind = skVar; if p != null as *Param && p.refParamType != null as *TypeExpr { pSym.typeKind = Sema_ResolveType(s, p.refParamType); - pSym.typeName = p.refParamType.typeName; + if p.refParamType.kind == tekPointer && p.refParamType.pointerPointee != null as *TypeExpr { + pSym.typeName = String_Concat(p.refParamType.pointerPointee.typeName, "*"); + } else { + pSym.typeName = p.refParamType.typeName; + } } else { pSym.typeKind = tyInt; pSym.typeName = "";