authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-01-07 23:25:38+02:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2020-01-07 23:25:38+02:00
log83b4163591982e66e7abeb2816706f0cd537633f
tree1b8a4d6e639cc589e216c8d4c4c8558ff633310e
parent8b713ce88959a953c6d41b5d1372e9b3e666512f
signaturelock-open Commit is signed but in an unrecognized format.

std-c parser declaratorIsFunction and small fixes

2 files changed, 58 insertions(+), 17 deletions(-)

lib/std/c/ast.zig+6
......@@ -435,6 +435,12 @@ pub const Node = struct {
435435 pub const DeclaratorList = Root.DeclList;
436436 };
437437
438 pub const RecordDeclarator = struct {
439 base: Node = Node{ .id = .RecordField },
440 declarator: *Declarator,
441 // bit_field_expr: ?*Expr,
442 };
443
438444 pub const TypeQual = struct {
439445 @"const": ?TokenIndex = null,
440446 atomic: ?TokenIndex = null,
lib/std/c/parse.zig+52-17
......@@ -124,7 +124,7 @@ const Parser = struct {
124124 return null;
125125 }
126126
127 fn declareSymbol(parser: *Parser, decl_spec: *Node.DeclSpec, dr: *Node.Declarator) Error!void {
127 fn declareSymbol(parser: *Parser, type_spec: Node.TypeSpec, dr: *Node.Declarator) Error!void {
128128 return; // TODO
129129 }
130130
......@@ -185,7 +185,7 @@ const Parser = struct {
185185 const dr = @fieldParentPtr(Node.Declarator, "base", (try parser.declarator(.Must)) orelse return parser.err(.{
186186 .ExpectedDeclarator = .{ .token = parser.it.index },
187187 }));
188 try parser.declareSymbol(&ds, dr);
188 try parser.declareSymbol(ds.type_spec, dr);
189189 try node.declarators.push(&dr.base);
190190 if (parser.eatToken(.Comma)) |_| {} else break;
191191 }
......@@ -196,7 +196,7 @@ const Parser = struct {
196196 var first_dr = try parser.declarator(.Must);
197197 if (first_dr != null and declaratorIsFunction(first_dr.?)) {
198198 const dr = @fieldParentPtr(Node.Declarator, "base", first_dr.?);
199 try parser.declareSymbol(&ds, dr);
199 try parser.declareSymbol(ds.type_spec, dr);
200200 var old_decls = Node.FnDecl.OldDeclList.init(parser.arena);
201201 const body = if (parser.eatToken(.Semicolon)) |_|
202202 null
......@@ -263,7 +263,7 @@ const Parser = struct {
263263 }
264264 var dr = @fieldParentPtr(Node.Declarator, "base", first_dr.?);
265265 while (true) {
266 try parser.declareSymbol(&ds, dr);
266 try parser.declareSymbol(ds.type_spec, dr);
267267 if (parser.eatToken(.Equal)) |tok| {
268268 try node.initializers.push((try parser.initializer(dr)) orelse return parser.err(.{
269269 .ExpectedInitializer = .{ .token = parser.it.index },
......@@ -280,8 +280,27 @@ const Parser = struct {
280280 }
281281 }
282282
283 fn declaratorIsFunction(dr: *Node) bool {
284 return false; // TODO
283 fn declaratorIsFunction(node: *Node) bool {
284 if (node.id != .Declarator) return false;
285 assert(node.id == .Declarator);
286 const dr = @fieldParentPtr(Node.Declarator, "base", node);
287 if (dr.suffix != .Fn) return false;
288 switch (dr.prefix) {
289 .None, .Identifer => return true,
290 .Complex => |inner| {
291 var inner_node = inner.inner;
292 while (true) {
293 if (inner_node.id != .Declarator) return false;
294 assert(inner_node.id == .Declarator);
295 const inner_dr = @fieldParentPtr(Node.Declarator, "base", inner_node);
296 if (inner_dr.pointer != null) return false;
297 switch (inner_dr.prefix) {
298 .None, .Identifer => return true,
299 .Complex => |c| inner_node = c.inner,
300 }
301 }
302 },
303 }
285304 }
286305
287306 /// StaticAssert <- Keyword_static_assert LPAREN ConstExpr COMMA STRINGLITERAL RPAREN SEMICOLON
......@@ -292,12 +311,11 @@ const Parser = struct {
292311 _ = try parser.expectToken(.Comma);
293312 const str = try parser.expectToken(.StringLiteral);
294313 _ = try parser.expectToken(.RParen);
295 const semicolon = try parser.expectToken(.Semicolon);
296314 const node = try parser.arena.create(Node.StaticAssert);
297315 node.* = .{
298316 .assert = tok,
299317 .expr = const_expr,
300 .semicolon = semicolon,
318 .semicolon = try parser.expectToken(.Semicolon),
301319 };
302320 return &node.base;
303321 }
......@@ -761,6 +779,8 @@ const Parser = struct {
761779 .ty = ty,
762780 });
763781 if (parser.eatToken(.LBrace)) |lbrace| {
782 const scope = parser.pushScope();
783 defer parser.popScope(scope);
764784 var fields = Node.RecordType.FieldList.init(parser.arena);
765785 while (true) {
766786 if (parser.eatToken(.RBrace)) |rbrace| {
......@@ -796,7 +816,9 @@ const Parser = struct {
796816 .semicolon = undefined,
797817 };
798818 while (true) {
799 try node.declarators.push(try parser.recordDeclarator());
819 const rdr = try parser.recordDeclarator();
820 try parser.declareSymbol(type_spec, rdr.declarator);
821 try node.declarators.push(&rdr.base);
800822 if (parser.eatToken(.Comma)) |_| {} else break;
801823 }
802824
......@@ -836,16 +858,19 @@ const Parser = struct {
836858 /// / LPAREN Declarator RPAREN
837859 /// / (none) // if named != .Must
838860 /// DeclaratorSuffix
839 /// <. DeclaratorPrefix (LBRACKET ArrayDeclarator? RBRACKET)*
861 /// <- DeclaratorPrefix (LBRACKET ArrayDeclarator? RBRACKET)*
840862 /// / DeclaratorPrefix LPAREN (ParamDecl (COMMA ParamDecl)* (COMMA ELLIPSIS)?)? RPAREN
841863 fn declarator(parser: *Parser, named: Named) Error!?*Node {
842864 const ptr = try parser.pointer();
843865 var node: *Node.Declarator = undefined;
866 var inner_fn = false;
867
844868 // prefix
845869 if (parser.eatToken(.LParen)) |lparen| {
846870 const inner = (try parser.declarator(named)) orelse return parser.err(.{
847871 .ExpectedDeclarator = .{ .token = lparen + 1 },
848872 });
873 inner_fn = declaratorIsFunction(inner);
849874 node = try parser.arena.create(Node.Declarator);
850875 node.* = .{
851876 .pointer = ptr,
......@@ -885,6 +910,10 @@ const Parser = struct {
885910 }
886911 // suffix
887912 if (parser.eatToken(.LParen)) |lparen| {
913 if (inner_fn)
914 return parser.err(.{
915 .InvalidDeclarator = .{ .token = lparen },
916 });
888917 node.suffix = .{
889918 .Fn = .{
890919 .lparen = lparen,
......@@ -894,11 +923,16 @@ const Parser = struct {
894923 };
895924 try parser.paramDecl(node);
896925 node.suffix.Fn.rparen = try parser.expectToken(.RParen);
897 } else {
898 while (try parser.arrayDeclarator()) |arr| {
899 if (node.suffix == .None)
900 node.suffix = .{ .Array = Node.Declarator.Arrays.init(parser.arena) };
901 try node.suffix.Array.push(arr);
926 } else if (parser.eatToken(.LBracket)) |tok| {
927 if (inner_fn)
928 return parser.err(.{
929 .InvalidDeclarator = .{ .token = tok },
930 });
931 node.suffix = .{ .Array = Node.Declarator.Arrays.init(parser.arena) };
932 var lbrace = tok;
933 while (true) {
934 try node.suffix.Array.push(try parser.arrayDeclarator(lbrace));
935 if (parser.eatToken(.LBracket)) |t| lbrace = t else break;
902936 }
903937 }
904938 if (parser.eatToken(.LParen) orelse parser.eatToken(.LBracket)) |tok|
......@@ -914,8 +948,7 @@ const Parser = struct {
914948 /// / TypeQual+ (ASTERISK / Keyword_static AssignmentExpr)
915949 /// / TypeQual+ AssignmentExpr?
916950 /// / AssignmentExpr
917 fn arrayDeclarator(parser: *Parser) !?*Node.Array {
918 const lbracket = parser.eatToken(.LBracket) orelse return null;
951 fn arrayDeclarator(parser: *Parser, lbracket: TokenIndex) !*Node.Array {
919952 const arr = try parser.arena.create(Node.Array);
920953 arr.* = .{
921954 .lbracket = lbracket,
......@@ -1046,6 +1079,8 @@ const Parser = struct {
10461079
10471080 /// CompoundStmt <- LBRACE (Declaration / Stmt)* RBRACE
10481081 fn compoundStmt(parser: *Parser) Error!?*Node {
1082 const scope = parser.pushScope();
1083 defer parser.popScope(scope);
10491084 const lbrace = parser.eatToken(.LBrace) orelse return null;
10501085 const body_node = try parser.arena.create(Node.CompoundStmt);
10511086 body_node.* = .{