baraba/bux-lang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

selfhost: expand Decl to 256 fields, fix unary precedence, add discard/var parsing, fix diag buffer overflow

Browse Source 
- 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
This commit is contained in:
dimgigov
2026-06-07 14:58:23 +03:00
parent 0bdef58182
commit 3b4456f01f
7 changed files with 1254 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ast.bux
+221 -29
View File
@@ -255,7 +255,35 @@ struct Decl {
retType: *TypeExpr, retType: *TypeExpr,
// Body // Body
refBody: *Block, 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, fieldCount: int,
field0: StructField, field0: StructField,
field1: StructField, field1: StructField,
@@ -321,34 +349,198 @@ struct Decl {
field61: StructField, field61: StructField,
field62: StructField, field62: StructField,
field63: StructField, field63: StructField,
// Enum variants (up to 8) field64: StructField,
variantCount: int, field65: StructField,
variant0: EnumVariant, field66: StructField,
variant1: EnumVariant, field67: StructField,
variant2: EnumVariant, field68: StructField,
variant3: EnumVariant, field69: StructField,
variant4: EnumVariant, field70: StructField,
variant5: EnumVariant, field71: StructField,
variant6: EnumVariant, field72: StructField,
variant7: EnumVariant, field73: StructField,
// Impl methods (up to 4) field74: StructField,
methodCount: int, field75: StructField,
// Use/import field76: StructField,
useKind: int, field77: StructField,
usePath: String, field78: StructField,
useNames: String, // joined names for multi-import field79: StructField,
// Const field80: StructField,
constType: *TypeExpr, field81: StructField,
constValue: *Expr, field82: StructField,
// Type alias field83: StructField,
aliasType: *TypeExpr, field84: StructField,
// Extern func field85: StructField,
extFuncDll: String, field86: StructField,
extFuncVariadic: bool, field87: StructField,
extFuncRetType: *TypeExpr, field88: StructField,
// Children field89: StructField,
childDecl1: *Decl, // linked list of decls (for module items, impl methods) field90: StructField,
childDecl2: *Decl, 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,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
src/c_backend.bux
+128 -30
View File
@@ -65,11 +65,12 @@ func CBackend_OpToC(op: int) -> String {
struct CEmitter { struct CEmitter {
sb: StringBuilder, sb: StringBuilder,
indent: int, indent: int,
mod: *HirModule,
} }
func CBE_Init() -> CEmitter { func CBE_Init() -> CEmitter {
var sb: StringBuilder = StringBuilder_NewCap(4096); 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) { 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, " ");
StringBuilder_Append(&cbe.sb, node.child1.strValue); StringBuilder_Append(&cbe.sb, node.child1.strValue);
if node.child2 != null as *HirNode {
StringBuilder_Append(&cbe.sb, " = "); StringBuilder_Append(&cbe.sb, " = ");
CBE_EmitExpr(cbe, node.child2); CBE_EmitExpr(cbe, node.child2);
}
return; return;
} }
// Plain assignment // Plain assignment
@@ -349,9 +352,8 @@ func CBE_EmitExpr(cbe: *CEmitter, node: *HirNode) {
CBE_EmitExpr(cbe, node.child1); CBE_EmitExpr(cbe, node.child1);
var isPtr: bool = false; var isPtr: bool = false;
if node.child1 != null as *HirNode { if node.child1 != null as *HirNode {
if node.child1.typeKind == tyPointer { let childType: String = CBE_GetExprTypeName(cbe.mod, node.child1);
isPtr = true; if String_EndsWith(childType, "*") {
} else if String_EndsWith(node.child1.typeName, "*") {
isPtr = true; isPtr = true;
} }
} }
@@ -396,9 +398,8 @@ func CBE_EmitExpr(cbe: *CEmitter, node: *HirNode) {
CBE_EmitExpr(cbe, ptrNode.child1); CBE_EmitExpr(cbe, ptrNode.child1);
var isPtr: bool = false; var isPtr: bool = false;
if ptrNode.child1 != null as *HirNode { if ptrNode.child1 != null as *HirNode {
if ptrNode.child1.typeKind == tyPointer { let childType: String = CBE_GetExprTypeName(cbe.mod, ptrNode.child1);
isPtr = true; if String_EndsWith(childType, "*") {
} else if String_EndsWith(ptrNode.child1.typeName, "*") {
isPtr = true; isPtr = true;
} }
} }
@@ -617,6 +618,107 @@ func CBE_FuncHasGeneric(f: *HirFunc) -> bool {
return false; 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 // Generate complete C module
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@@ -625,6 +727,7 @@ func CBackend_Generate(mod: *HirModule) -> String {
let cbe: *CEmitter = bux_alloc(sizeof(CEmitter)) as *CEmitter; let cbe: *CEmitter = bux_alloc(sizeof(CEmitter)) as *CEmitter;
cbe.sb = StringBuilder_NewCap(8192); cbe.sb = StringBuilder_NewCap(8192);
cbe.indent = 0; cbe.indent = 0;
cbe.mod = mod;
// Header // Header
StringBuilder_Append(&cbe.sb, "// Generated by Bux C Backend\n"); StringBuilder_Append(&cbe.sb, "// Generated by Bux C Backend\n");
@@ -778,37 +881,32 @@ func CBackend_Generate(mod: *HirModule) -> String {
} }
// Struct definitions (skip generics) // Struct definitions (skip generics)
// Pass 1: emit structs with no value-typed struct fields (leaf structs)
si = 0; si = 0;
while si < mod.structCount { while si < mod.structCount {
if CBE_StructHasGeneric(&mod.structs[si]) { if CBE_StructHasGeneric(&mod.structs[si]) {
si = si + 1; si = si + 1;
continue; continue;
} }
StringBuilder_Append(&cbe.sb, "struct "); if CBE_StructHasValueStructField(&mod.structs[si]) {
StringBuilder_Append(&cbe.sb, mod.structs[si].name); si = si + 1;
StringBuilder_Append(&cbe.sb, " {\n"); continue;
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, " "); CBE_EmitStructDef(cbe, &mod.structs[si]);
StringBuilder_Append(&cbe.sb, mod.structs[si].fields[fi].name); si = si + 1;
StringBuilder_Append(&cbe.sb, ";\n");
fi = fi + 1;
} }
StringBuilder_Append(&cbe.sb, "};\n\n"); // 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; si = si + 1;
} }
src/cli.bux
+35 -3
View File
@@ -172,6 +172,7 @@ func Cli_Build(srcPath: String, outPath: String) -> int {
StringBuilder_Append(&cmdBuf, " "); StringBuilder_Append(&cmdBuf, " ");
} }
StringBuilder_Append(&cmdBuf, "-lm"); StringBuilder_Append(&cmdBuf, "-lm");
StringBuilder_Append(&cmdBuf, " -lcrypto");
let ccRc: int = bux_system(StringBuilder_Build(&cmdBuf)); let ccRc: int = bux_system(StringBuilder_Build(&cmdBuf));
if ccRc != 0 { if ccRc != 0 {
PrintLine("Error: C compilation failed"); 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) { if !String_Eq(iname, "") && Cli_NameInList(iname, skipNames, skipCount) {
// Skip shadowed stdlib decl // Skip shadowed stdlib decl
} else { } else {
inner.childDecl2 = target.firstItem; inner.childDecl2 = null as *Decl;
if target.firstItem == null as *Decl {
target.firstItem = inner; 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; target.itemCount = target.itemCount + 1;
added = added + 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) { if !String_Eq(dname, "") && Cli_NameInList(dname, skipNames, skipCount) {
// Skip shadowed stdlib decl // Skip shadowed stdlib decl
} else { } else {
decl.childDecl2 = target.firstItem; decl.childDecl2 = null as *Decl;
if target.firstItem == null as *Decl {
target.firstItem = 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; target.itemCount = target.itemCount + 1;
added = added + 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) { func Cli_CopyModuleDecls(target: *Module, source: *Module) {
if source == null as *Module || source.firstItem == null as *Decl { return; } 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 decl: *Decl = source.firstItem;
var limit: int = 0; var limit: int = 0;
while decl != null as *Decl && limit < 10000 { while decl != null as *Decl && limit < 10000 {
let next: *Decl = decl.childDecl2; let next: *Decl = decl.childDecl2;
decl.childDecl2 = target.firstItem; decl.childDecl2 = null as *Decl;
if target.firstItem == null as *Decl {
target.firstItem = decl; target.firstItem = decl;
targetLast = decl;
} else {
targetLast.childDecl2 = decl;
targetLast = decl;
}
target.itemCount = target.itemCount + 1; target.itemCount = target.itemCount + 1;
decl = next; decl = next;
limit = limit + 1; limit = limit + 1;
@@ -660,6 +691,7 @@ func Cli_BuildProject(projectDir: String) -> int {
StringBuilder_Append(&ccBuf, " "); StringBuilder_Append(&ccBuf, " ");
} }
StringBuilder_Append(&ccBuf, "-lm"); StringBuilder_Append(&ccBuf, "-lm");
StringBuilder_Append(&ccBuf, " -lcrypto");
let ccRc: int = bux_system(StringBuilder_Build(&ccBuf)); let ccRc: int = bux_system(StringBuilder_Build(&ccBuf));
if ccRc != 0 { if ccRc != 0 {
PrintLine("Error: C compilation failed"); PrintLine("Error: C compilation failed");
src/hir.bux
+9 -9
View File
@@ -79,15 +79,15 @@ struct HirParam {
struct HirFunc { struct HirFunc {
name: String; name: String;
paramCount: int; paramCount: int;
param0: HirParam; param0: *HirParam;
param1: HirParam; param1: *HirParam;
param2: HirParam; param2: *HirParam;
param3: HirParam; param3: *HirParam;
param4: HirParam; param4: *HirParam;
param5: HirParam; param5: *HirParam;
param6: HirParam; param6: *HirParam;
param7: HirParam; param7: *HirParam;
param8: HirParam; param8: *HirParam;
retTypeKind: int; retTypeKind: int;
retTypeName: String; retTypeName: String;
body: *HirNode; body: *HirNode;
src/hir_lower.bux
+215 -9
View File
@@ -107,6 +107,7 @@ func Lcx_LowerExpr(ctx: *LowerCtx, expr: *Expr) -> *HirNode {
n.strValue = expr.strValue; n.strValue = expr.strValue;
let sym: Symbol = Scope_Lookup(ctx.scope, expr.strValue); let sym: Symbol = Scope_Lookup(ctx.scope, expr.strValue);
n.typeKind = sym.typeKind; n.typeKind = sym.typeKind;
if expr.refType != null as *TypeExpr { if expr.refType != null as *TypeExpr {
n.typeName = expr.refType.typeName; n.typeName = expr.refType.typeName;
} }
@@ -149,6 +150,9 @@ func Lcx_LowerExpr(ctx: *LowerCtx, expr: *Expr) -> *HirNode {
n.kind = hUnary; n.kind = hUnary;
n.intValue = expr.intValue; n.intValue = expr.intValue;
n.child1 = Lcx_LowerExpr(ctx, expr.child1); n.child1 = Lcx_LowerExpr(ctx, expr.child1);
if expr.intValue == tkAmp {
n.typeKind = tyPointer;
}
return n; return n;
} }
@@ -275,6 +279,7 @@ func Lcx_LowerExpr(ctx: *LowerCtx, expr: *Expr) -> *HirNode {
n.kind = hFieldPtr; n.kind = hFieldPtr;
n.child1 = Lcx_LowerExpr(ctx, expr.child1); n.child1 = Lcx_LowerExpr(ctx, expr.child1);
n.strValue = expr.strValue; n.strValue = expr.strValue;
// Get struct type from base expr refType // Get struct type from base expr refType
if expr.child1 != null as *Expr && expr.child1.refType != null as *TypeExpr { if expr.child1 != null as *Expr && expr.child1.refType != null as *TypeExpr {
n.typeName = expr.child1.refType.typeName; n.typeName = expr.child1.refType.typeName;
@@ -552,15 +557,24 @@ func Lcx_LowerFunc(ctx: *LowerCtx, decl: *Decl) -> *HirFunc {
f.name = decl.strValue; f.name = decl.strValue;
f.isPublic = decl.isPublic; f.isPublic = decl.isPublic;
f.paramCount = decl.paramCount; f.paramCount = decl.paramCount;
Lcx_LowerParam(&f.param0, &decl.param0); f.param0 = bux_alloc(sizeof(HirParam)) as *HirParam;
Lcx_LowerParam(&f.param1, &decl.param1); Lcx_LowerParam(f.param0, &decl.param0);
Lcx_LowerParam(&f.param2, &decl.param2); f.param1 = bux_alloc(sizeof(HirParam)) as *HirParam;
Lcx_LowerParam(&f.param3, &decl.param3); Lcx_LowerParam(f.param1, &decl.param1);
Lcx_LowerParam(&f.param4, &decl.param4); f.param2 = bux_alloc(sizeof(HirParam)) as *HirParam;
Lcx_LowerParam(&f.param5, &decl.param5); Lcx_LowerParam(f.param2, &decl.param2);
Lcx_LowerParam(&f.param6, &decl.param6); f.param3 = bux_alloc(sizeof(HirParam)) as *HirParam;
Lcx_LowerParam(&f.param7, &decl.param7); Lcx_LowerParam(f.param3, &decl.param3);
Lcx_LowerParam(&f.param8, &decl.param8); 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 { if decl.retType != null as *TypeExpr {
f.retTypeName = decl.retType.typeName; 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 == 61 { fname = decl.field61.name; ftype = decl.field61.refFieldType; }
else if fi == 62 { fname = decl.field62.name; ftype = decl.field62.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 == 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 // Skip empty field names
if String_Eq(fname, "") { if String_Eq(fname, "") {
fi = fi + 1; fi = fi + 1;
src/parser.bux
+626 -13
View File
@@ -3,6 +3,7 @@
module Parser { module Parser {
extern func bux_strlen(s: String) -> uint; extern func bux_strlen(s: String) -> uint;
extern func bux_str_to_int(s: String) -> int64;
// Forward declarations for mutual recursion // Forward declarations for mutual recursion
func parserParseExpr(p: *Parser) -> *Expr; func parserParseExpr(p: *Parser) -> *Expr;
@@ -10,6 +11,7 @@ func parserParseStmt(p: *Parser) -> *Stmt;
func parserParseBlock(p: *Parser) -> *Block; func parserParseBlock(p: *Parser) -> *Block;
func parserParsePrimary(p: *Parser) -> *Expr; func parserParsePrimary(p: *Parser) -> *Expr;
func parserParsePostfixExpr(p: *Parser) -> *Expr; func parserParsePostfixExpr(p: *Parser) -> *Expr;
func parserParseUnary(p: *Parser) -> *Expr;
func parserParseBinaryPrec(p: *Parser, minPrec: int) -> *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) { func parserEmitDiag(p: *Parser, line: uint32, col: uint32, msg: String) {
if p.diagCount < 256 {
p.diags[p.diagCount] = ParserDiag { p.diags[p.diagCount] = ParserDiag {
line: line, column: col, message: msg line: line, column: col, message: msg
}; };
p.diagCount = p.diagCount + 1; p.diagCount = p.diagCount + 1;
}
} }
func parserIsKeyword(kind: int) -> bool { func parserIsKeyword(kind: int) -> bool {
@@ -244,6 +248,9 @@ func parserParsePrimary(p: *Parser) -> *Expr {
let e: *Expr = parserMakeExpr(ekLiteral, line, col); let e: *Expr = parserMakeExpr(ekLiteral, line, col);
e.tokKind = kind; e.tokKind = kind;
e.tokText = tok.text; e.tokText = tok.text;
if kind == tkIntLiteral {
e.intValue = bux_str_to_int(tok.text) as int;
}
return e; return e;
} }
@@ -317,15 +324,6 @@ func parserParsePrimary(p: *Parser) -> *Expr {
return e; 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"); parserEmitDiag(p, line, col, "expected expression");
return parserMakeExpr(ekLiteral, line, col); return parserMakeExpr(ekLiteral, line, col);
} }
@@ -573,8 +571,26 @@ func parserPrecedence(op: int) -> int {
return 0; 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 { func parserParseBinaryPrec(p: *Parser, minPrec: int) -> *Expr {
var left: *Expr = parserParsePostfixExpr(p); var left: *Expr = parserParseUnary(p);
while true { while true {
let op: int = parserPeek(p, 0); let op: int = parserPeek(p, 0);
let prec: int = parserPrecedence(op); let prec: int = parserPrecedence(op);
@@ -643,8 +659,13 @@ func parserParseStmt(p: *Parser) -> *Stmt {
if parserMatch(p, tkColon) { if parserMatch(p, tkColon) {
typeExpr = parserParseType(p); typeExpr = parserParseType(p);
} }
discard parserExpect(p, tkAssign, "expected '=' in let/var statement"); var init: *Expr = null as *Expr;
let init: *Expr = parserParseExpr(p); 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 ; parserMatch(p, tkSemicolon); // optional ;
let s: *Stmt = bux_alloc(sizeof(Stmt)) as *Stmt; let s: *Stmt = bux_alloc(sizeof(Stmt)) as *Stmt;
@@ -658,6 +679,22 @@ func parserParseStmt(p: *Parser) -> *Stmt {
return s; 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
if kind == tkIf { if kind == tkIf {
discard parserAdvance(p); discard parserAdvance(p);
@@ -995,7 +1032,7 @@ func parserParseStructDecl(p: *Parser, isPublic: bool) -> *Decl {
discard parserExpect(p, tkLBrace, "expected '{'"); discard parserExpect(p, tkLBrace, "expected '{'");
while !parserCheck(p, tkRBrace) && parserPeek(p, 0) != tkEndOfFile { 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, tkNewLine) { discard parserAdvance(p); continue; }
if parserCheck(p, tkSemicolon) { discard parserAdvance(p); continue; } if parserCheck(p, tkSemicolon) { discard parserAdvance(p); continue; }
let beforePos: int = p.pos; let beforePos: int = p.pos;
@@ -1201,6 +1238,582 @@ func parserParseStructDecl(p: *Parser, isPublic: bool) -> *Decl {
} else if d.fieldCount == 63 { } else if d.fieldCount == 63 {
d.field63.name = fName.text; d.field63.name = fName.text;
d.field63.refFieldType = fType; 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; d.fieldCount = d.fieldCount + 1;
} }
src/sema.bux
+8
View File
@@ -318,8 +318,12 @@ func Sema_CheckStmt(sema: *Sema, stmt: *Stmt) {
sym.typeKind = initType; sym.typeKind = initType;
sym.typeName = ""; sym.typeName = "";
if stmt.refStmtType != null as *TypeExpr { if stmt.refStmtType != null as *TypeExpr {
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.typeName = stmt.refStmtType.typeName;
} }
}
sym.isMutable = stmt.boolValue; sym.isMutable = stmt.boolValue;
sym.isPublic = false; sym.isPublic = false;
sym.decl = null as *Decl; sym.decl = null as *Decl;
@@ -695,7 +699,11 @@ func Sema_Analyze(mod: *Module) -> *Sema {
pSym.kind = skVar; pSym.kind = skVar;
if p != null as *Param && p.refParamType != null as *TypeExpr { if p != null as *Param && p.refParamType != null as *TypeExpr {
pSym.typeKind = Sema_ResolveType(s, p.refParamType); pSym.typeKind = Sema_ResolveType(s, p.refParamType);
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; pSym.typeName = p.refParamType.typeName;
}
} else { } else {
pSym.typeKind = tyInt; pSym.typeKind = tyInt;
pSym.typeName = ""; pSym.typeName = "";