Commit e3fa18242be2594d98757106fd586d7eada65c97 | zig

author	xackus <14938807+xackus@users.noreply.github.com> 2021-06-14 10:14:11+02:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2021-06-15 12:14:03+02:00
log	e3fa18242be2594d98757106fd586d7eada65c97
tree	790d35121465eaa867cb2e9060518d1245613dd9
parent	eb7cfe9de6fcc87d84227c945f397a538303e55e

translate-c: remove old code i forgot in last pr

1 files changed, 21 insertions(+), 42 deletions(-)

src
- translate_c.zig

src/translate_c.zig+21-42

 @@ -5331,7 +5331,7 @@ fn parseCPrimaryExprInner(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!N
             // for handling type macros (EVIL)
             // TODO maybe detect and treat type macros as typedefs in parseCSpecifierQualifierList?
             m.i -= 1;
-            if (try parseCTypeName(c, m, scope)) |type_name| {
+            if (try parseCTypeName(c, m, scope, true)) |type_name| {
                 return type_name;
             }
             try m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(tok)});
 @@ -5543,33 +5543,9 @@ fn parseCMulExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
     while (true) {
         switch (m.next().?) {
             .Asterisk => {
-                const next = m.peek().?;
+                const lhs = try macroBoolToInt(c, node);
-                if (next == .RParen or next == .Nl or next == .Eof) {
+                const rhs = try macroBoolToInt(c, try parseCCastExpr(c, m, scope));
-                    // type *)
+                node = try Tag.mul.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
-                    // last token of `node`
-                    const prev_id = m.list[m.i - 1].id;
-                    if (prev_id == .Keyword_void) {
-                        const ptr = try Tag.single_pointer.create(c.arena, .{
-                            .is_const = false,
-                            .is_volatile = false,
-                            .elem_type = node,
-                        });
-                        return Tag.optional_type.create(c.arena, ptr);
-                    } else {
-                        return Tag.c_pointer.create(c.arena, .{
-                            .is_const = false,
-                            .is_volatile = false,
-                            .elem_type = node,
-                        });
-                    }
-                } else {
-                    // expr * expr
-                    const lhs = try macroBoolToInt(c, node);
-                    const rhs = try macroBoolToInt(c, try parseCCastExpr(c, m, scope));
-                    node = try Tag.mul.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
-                }
             },
             .Slash => {
                 const lhs = try macroBoolToInt(c, node);
 @@ -5592,7 +5568,7 @@ fn parseCMulExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
 fn parseCCastExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
     switch (m.next().?) {
         .LParen => {
-            if (try parseCTypeName(c, m, scope)) |type_name| {
+            if (try parseCTypeName(c, m, scope, true)) |type_name| {
                 if (m.next().? != .RParen) {
                     try m.fail(c, "unable to translate C expr: expected ')'", .{});
                     return error.ParseError;
 @@ -5611,19 +5587,21 @@ fn parseCCastExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
     return parseCUnaryExpr(c, m, scope);
 }
-fn parseCTypeName(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!?Node {
+// allow_fail is set when unsure if we are parsing a type-name
-    if (try parseCSpecifierQualifierList(c, m, scope)) |node| {
+fn parseCTypeName(c: *Context, m: *MacroCtx, scope: *Scope, allow_fail: bool) ParseError!?Node {
+    if (try parseCSpecifierQualifierList(c, m, scope, allow_fail)) |node| {
         return try parseCAbstractDeclarator(c, m, scope, node);
     } else {
         return null;
     }
 }
-fn parseCSpecifierQualifierList(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!?Node {
+fn parseCSpecifierQualifierList(c: *Context, m: *MacroCtx, scope: *Scope, allow_fail: bool) ParseError!?Node {
-    switch (m.next().?) {
+    const tok = m.next().?;
+    switch (tok) {
         .Identifier => {
             const mangled_name = scope.getAlias(m.slice());
-            if (c.typedefs.contains(mangled_name)) {
+            if (!allow_fail or c.typedefs.contains(mangled_name)) {
                 return try Tag.identifier.create(c.arena, builtin_typedef_map.get(mangled_name) orelse mangled_name);
             }
         },
 @@ -5657,8 +5635,13 @@ fn parseCSpecifierQualifierList(c: *Context, m: *MacroCtx, scope: *Scope) ParseE
         else => {},
     }
-    m.i -= 1;
+    if (allow_fail) {
-    return null;
+        m.i -= 1;
+        return null;
+    } else {
+        try m.fail(c, "unable to translate C expr: unexpected token .{s}", .{@tagName(tok)});
+        return error.ParseError;
+    }
 }
 fn parseCNumericType(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
 @@ -5934,9 +5917,7 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
         .Keyword_sizeof => {
             const operand = if (m.peek().? == .LParen) blk: {
                 _ = m.next();
-                // C grammar says this should be 'type-name' but we have to
+                const inner = (try parseCTypeName(c, m, scope, false)).?;
-                // use parseCMulExpr to correctly handle pointer types.
-                const inner = try parseCMulExpr(c, m, scope);
                 if (m.next().? != .RParen) {
                     try m.fail(c, "unable to translate C expr: expected ')'", .{});
                     return error.ParseError;
 @@ -5953,9 +5934,7 @@ fn parseCUnaryExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
                 try m.fail(c, "unable to translate C expr: expected '('", .{});
                 return error.ParseError;
             }
-            // C grammar says this should be 'type-name' but we have to
+            const operand = (try parseCTypeName(c, m, scope, false)).?;
-            // use parseCMulExpr to correctly handle pointer types.
-            const operand = try parseCMulExpr(c, m, scope);
             if (m.next().? != .RParen) {
                 try m.fail(c, "unable to translate C expr: expected ')'", .{});
                 return error.ParseError;