authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2019-12-13 14:55:36+02:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2019-12-13 15:07:10+02:00
logeb057ef41c8a5482586fc39bab11c280e261ea94
tree2d2b3564a10210644bee16a6647b8961017e0db7
parent0795f17db23fff5aada41008348a63cbc9e0321b
signature Commit is signed but in an unrecognized format.

translate-c-2 dont eval init expr

5 files changed, 183 insertions(+), 165 deletions(-)

src-self-hosted/clang.zig+6-5
......@@ -74,6 +74,7 @@ pub const struct_ZigClangVarDecl = @OpaqueType();
7474pub const struct_ZigClangWhileStmt = @OpaqueType();
7575pub const struct_ZigClangFunctionType = @OpaqueType();
7676pub const struct_ZigClangPredefinedExpr = @OpaqueType();
77pub const struct_ZigClangInitListExpr = @OpaqueType();
7778
7879pub const ZigClangBO = extern enum {
7980 PtrMemD,
......@@ -755,11 +756,12 @@ pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_ZigClangStmt) bool;
755756pub extern fn ZigClangExpr_getStmtClass(self: ?*const struct_ZigClangExpr) ZigClangStmtClass;
756757pub extern fn ZigClangExpr_getType(self: ?*const struct_ZigClangExpr) struct_ZigClangQualType;
757758pub extern fn ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation;
759pub extern fn ZigClangInitListExpr_getInit(self: ?*const struct_ZigClangInitListExpr, i: c_uint) *const ZigClangExpr;
760pub extern fn ZigClangInitListExpr_getArrayFiller(self: ?*const struct_ZigClangInitListExpr) *const ZigClangExpr;
761pub extern fn ZigClangInitListExpr_getNumInits(self: ?*const struct_ZigClangInitListExpr) c_uint;
758762pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind;
759763pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) ?*const struct_ZigClangAPSInt;
760764pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
761pub extern fn ZigClangAPValue_getArrayInitializedElt(self: ?*const struct_ZigClangAPValue, i: c_uint) *const struct_ZigClangAPValue;
762pub extern fn ZigClangAPValue_getArrayFiller(self: ?*const struct_ZigClangAPValue) *const struct_ZigClangAPValue;
763765pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint;
764766pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase;
765767pub extern fn ZigClangAPSInt_isSigned(self: ?*const struct_ZigClangAPSInt) bool;
......@@ -867,6 +869,7 @@ pub const ZigClangVarDecl = struct_ZigClangVarDecl;
867869pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
868870pub const ZigClangFunctionType = struct_ZigClangFunctionType;
869871pub const ZigClangPredefinedExpr = struct_ZigClangPredefinedExpr;
872pub const ZigClangInitListExpr = struct_ZigClangInitListExpr;
870873
871874pub const struct_ZigClangSourceLocation = extern struct {
872875 ID: c_uint,
......@@ -921,9 +924,8 @@ pub extern fn ZigClangDeclStmt_decl_begin(self: *const ZigClangDeclStmt) ZigClan
921924pub extern fn ZigClangDeclStmt_decl_end(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
922925
923926pub extern fn ZigClangVarDecl_getLocation(self: *const struct_ZigClangVarDecl) ZigClangSourceLocation;
924pub extern fn ZigClangVarDecl_hasExternalStorage(self: *const struct_ZigClangVarDecl) bool;
925pub extern fn ZigClangVarDecl_isFileVarDecl(self: *const struct_ZigClangVarDecl) bool;
926927pub extern fn ZigClangVarDecl_hasInit(self: *const struct_ZigClangVarDecl) bool;
928pub extern fn ZigClangVarDecl_getStorageClass(self: *const ZigClangVarDecl) ZigClangStorageClass;
927929pub extern fn ZigClangVarDecl_getType(self: ?*const struct_ZigClangVarDecl) struct_ZigClangQualType;
928930pub extern fn ZigClangVarDecl_getInit(*const ZigClangVarDecl) ?*const ZigClangExpr;
929931pub extern fn ZigClangVarDecl_getTLSKind(self: ?*const struct_ZigClangVarDecl) ZigClangVarDecl_TLSKind;
......@@ -964,7 +966,6 @@ pub const struct_ZigClangExprEvalResult = extern struct {
964966 Val: ZigClangAPValue,
965967};
966968
967pub extern fn ZigClangVarDecl_evaluateValue(self: *const struct_ZigClangVarDecl) ?*const ZigClangAPValue;
968969pub const struct_ZigClangAPValue = extern struct {
969970 Kind: ZigClangAPValueKind,
970971 Data: if (builtin.os == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
src-self-hosted/translate_c.zig+139-160
......@@ -305,54 +305,83 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
305305fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl) Error!void {
306306 if (try c.decl_table.put(@ptrToInt(var_decl), {})) |_| return; // Avoid processing this decl twice
307307 const rp = makeRestorePoint(c);
308 const visib_tok = try appendToken(c, .Keyword_pub, "pub");
309
310 const thread_local_token = if (ZigClangVarDecl_getTLSKind(var_decl) == .None)
311 null
312 else
313 try appendToken(c, .Keyword_threadlocal, "threadlocal");
314
308315 var scope = &c.global_scope.base;
309316 const var_name = try c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, var_decl)));
310317 const var_decl_loc = ZigClangVarDecl_getLocation(var_decl);
311318
312 switch (ZigClangVarDecl_getTLSKind(var_decl)) {
313 .None => {},
314 .Static => return failDecl(c, var_decl_loc, var_name, "static thread local storage not supported", .{}),
315 .Dynamic => return failDecl(c, var_decl_loc, var_name, "dynamic thread local storag not supported", .{}),
316 }
317
318 const qual_type = ZigClangVarDecl_getType(var_decl);
319 const is_extern = ZigClangVarDecl_hasExternalStorage(var_decl);
320 const is_static = ZigClangVarDecl_isFileVarDecl(var_decl);
319 const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl);
320 const storage_class = ZigClangVarDecl_getStorageClass(var_decl);
321321 const is_const = ZigClangQualType_isConstQualified(qual_type);
322322
323 var var_node = try transCreateNodeVarDecl(c, true, is_extern, is_const, var_name);
323 const extern_tok = if (storage_class == .Extern)
324 try appendToken(c, .Keyword_extern, "extern")
325 else if (storage_class != .Static)
326 try appendToken(c, .Keyword_export, "export")
327 else
328 null;
329
330 const mut_tok = if (is_const)
331 try appendToken(c, .Keyword_const, "const")
332 else
333 try appendToken(c, .Keyword_var, "var");
324334
325 _ = try appendToken(rp.c, .Colon, ":");
326 var_node.type_node = transQualType(rp, qual_type, var_decl_loc) catch |err| switch (err) {
335 const name_tok = try appendToken(c, .Identifier, var_name);
336
337 _ = try appendToken(c, .Colon, ":");
338 const type_node = transQualType(rp, qual_type, var_decl_loc) catch |err| switch (err) {
327339 error.UnsupportedType => {
328340 return failDecl(c, var_decl_loc, var_name, "unable to resolve variable type", .{});
329341 },
330342 error.OutOfMemory => |e| return e,
331343 };
332344
333 if (is_static and !is_extern) {
334 const eq_tok = try appendToken(c, .Equal, "=");
335 const init_node = if (ZigClangVarDecl_hasInit(var_decl)) blk: {
336 const ap_value = ZigClangVarDecl_evaluateValue(var_decl) orelse
337 return failDecl(c, var_decl_loc, var_name, "unable to evaluate initializer", .{});
338 break :blk transApValue(rp, ap_value, qual_type, var_decl_loc) catch |err| switch (err) {
345 var eq_tok: ast.TokenIndex = undefined;
346 var init_node: ?*ast.Node = null;
347
348 if (ZigClangVarDecl_hasInit(var_decl)) {
349 eq_tok = try appendToken(c, .Equal, "=");
350 init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr| blk: {
351 var res = transExpr(rp, &c.global_scope.base, expr, .used, .r_value) catch |err| switch (err) {
339352 error.UnsupportedTranslation,
340353 error.UnsupportedType,
341354 => {
342 return failDecl(c, var_decl_loc, var_name, "unable to evaluate initializer", .{});
355 return failDecl(c, var_decl_loc, var_name, "unable to translate initializer", .{});
343356 },
344357 error.OutOfMemory => |e| return e,
345358 };
359 break :blk res.node;
346360 } else
347361 try transCreateNodeUndefinedLiteral(c);
348 var_node.eq_token = eq_tok;
349 var_node.init_node = init_node;
350 } else if (!is_extern) {
351 return failDecl(c, var_decl_loc, var_name, "non-extern, non-static variable not supported", .{});
362 } else if (storage_class != .Extern) {
363 return failDecl(c, var_decl_loc, var_name, "non-extern variable has no initializer", .{});
352364 }
353365
354 var_node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
355 return addTopLevelDecl(c, var_name, &var_node.base);
366 const node = try c.a().create(ast.Node.VarDecl);
367 node.* = ast.Node.VarDecl{
368 .base = ast.Node{ .id = .VarDecl },
369 .doc_comments = null,
370 .visib_token = visib_tok,
371 .thread_local_token = thread_local_token,
372 .name_token = name_tok,
373 .eq_token = eq_tok,
374 .mut_token = mut_tok,
375 .comptime_token = null,
376 .extern_export_token = extern_tok,
377 .lib_name = null,
378 .type_node = type_node,
379 .align_node = null,
380 .section_node = null,
381 .init_node = init_node,
382 .semicolon_token = try appendToken(c, .Semicolon, ";"),
383 };
384 return addTopLevelDecl(c, var_name, &node.base);
356385}
357386
358387const ResultUsed = enum {
......@@ -384,6 +413,7 @@ fn transStmt(
384413 .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const ZigClangReturnStmt, stmt)),
385414 .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used),
386415 .ParenExprClass => return transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), result_used, lrvalue),
416 .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const ZigClangInitListExpr, stmt), result_used),
387417 else => {
388418 return revertAndWarn(
389419 rp,
......@@ -635,7 +665,7 @@ fn transDeclStmt(rp: RestorePoint, parent_scope: *Scope, stmt: *const ZigClangDe
635665 const init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr|
636666 (try transExpr(rp, scope, expr, .used, .r_value)).node
637667 else
638 try transCreateNodeUndefinedLiteral(rp.c);
668 try transCreateNodeUndefinedLiteral(c);
639669 const semicolon_token = try appendToken(c, .Semicolon, ";");
640670
641671 const node = try c.a().create(ast.Node.VarDecl);
......@@ -725,7 +755,7 @@ fn transImplicitCastExpr(
725755 .FunctionToPointerDecay, .ArrayToPointerDecay => {
726756 return maybeSuppressResult(rp, scope, result_used, sub_expr_node);
727757 },
728 .LValueToRValue => {
758 .LValueToRValue, .NoOp => {
729759 return transExpr(rp, scope, sub_expr, .used, .r_value);
730760 },
731761 else => |kind| return revertAndWarn(
......@@ -906,6 +936,88 @@ fn transExpr(
906936 return transStmt(rp, scope, @ptrCast(*const ZigClangStmt, expr), used, lrvalue);
907937}
908938
939fn transInitListExpr(
940 rp: RestorePoint,
941 scope: *Scope,
942 expr: *const ZigClangInitListExpr,
943 used: ResultUsed,
944) TransError!TransResult {
945 // TODO use anon literals once they work properly
946 const qt = getExprQualType(rp.c, @ptrCast(*const ZigClangExpr, expr));
947 const qual_type = ZigClangQualType_getTypePtr(qt);
948 const source_loc = ZigClangExpr_getBeginLoc(@ptrCast(*const ZigClangExpr, expr));
949 const arr_type = ZigClangType_getAsArrayTypeUnsafe(qual_type);
950 const child_qt = ZigClangArrayType_getElementType(arr_type);
951 const init_count = ZigClangInitListExpr_getNumInits(expr);
952 const all_count = 200; //ZigClangArrayType_getSize(arr_type);
953 const leftover_count = all_count - init_count;
954
955 var init_node: *ast.Node.SuffixOp = undefined;
956 var cat_tok: ast.TokenIndex = undefined;
957 if (init_count != 0) {
958 var type_node = try transQualType(rp, qt, source_loc);
959 init_node = try transCreateNodeArrayInitializer(rp.c, type_node);
960 var i: c_uint = 0;
961 while (i < init_count) : (i += 1) {
962 const elem_expr = ZigClangInitListExpr_getInit(expr, i);
963 try init_node.op.ArrayInitializer.push((try transExpr(rp, scope, elem_expr, .used, .r_value)).node);
964 _ = try appendToken(rp.c, .Comma, ",");
965 }
966 init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
967 if (leftover_count == 0) {
968 return TransResult{
969 .node = &init_node.base,
970 .child_scope = scope,
971 .node_scope = scope,
972 };
973 }
974 cat_tok = try appendToken(rp.c, .PlusPlus, "++");
975 }
976
977 var filler_type_node = try transQualType(rp, qt, source_loc);
978 var filler_init_node = try transCreateNodeArrayInitializer(rp.c, filler_type_node);
979 const filler_val_expr = ZigClangInitListExpr_getArrayFiller(expr);
980 try filler_init_node.op.ArrayInitializer.push((try transExpr(rp, scope, filler_val_expr, .used, .r_value)).node);
981 filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
982
983 const rhs_node = if (leftover_count == 1)
984 &filler_init_node.base
985 else blk: {
986 const mul_tok = try appendToken(rp.c, .AsteriskAsterisk, "**");
987 const mul_node = try rp.c.a().create(ast.Node.InfixOp);
988 mul_node.* = .{
989 .base = .{ .id = .InfixOp },
990 .op_token = mul_tok,
991 .lhs = &filler_init_node.base,
992 .op = .ArrayMult,
993 .rhs = try transCreateNodeInt(rp.c, leftover_count),
994 };
995 break :blk &mul_node.base;
996 };
997
998 if (init_count == 0) {
999 return TransResult{
1000 .node = rhs_node,
1001 .child_scope = scope,
1002 .node_scope = scope,
1003 };
1004 }
1005
1006 const cat_node = try rp.c.a().create(ast.Node.InfixOp);
1007 cat_node.* = .{
1008 .base = .{ .id = .InfixOp },
1009 .op_token = cat_tok,
1010 .lhs = &init_node.base,
1011 .op = .ArrayCat,
1012 .rhs = rhs_node,
1013 };
1014 return TransResult{
1015 .node = &cat_node.base,
1016 .child_scope = scope,
1017 .node_scope = scope,
1018 };
1019}
1020
9091021fn findBlockScope(inner: *Scope) *Scope.Block {
9101022 var scope = inner;
9111023 while (true) : (scope = scope.parent orelse unreachable) {
......@@ -1295,51 +1407,6 @@ fn transCreateNodeArrayInitializer(c: *Context, type_node: *ast.Node) !*ast.Node
12951407 return node;
12961408}
12971409
1298fn transCreateNodeVarDecl(
1299 c: *Context,
1300 is_pub: bool,
1301 is_extern: bool,
1302 is_const: bool,
1303 var_name: []const u8,
1304) !*ast.Node.VarDecl {
1305 const visb_tok = if (is_pub)
1306 try appendToken(c, .Keyword_pub, "pub")
1307 else
1308 null;
1309
1310 const extern_tok = if (is_extern)
1311 try appendToken(c, .Keyword_extern, "extern")
1312 else
1313 null;
1314
1315 const mut_tok = if (is_const)
1316 try appendToken(c, .Keyword_const, "const")
1317 else
1318 try appendToken(c, .Keyword_var, "var");
1319
1320 const name_tok = try appendToken(c, .Identifier, var_name);
1321
1322 const node = try c.a().create(ast.Node.VarDecl);
1323 node.* = ast.Node.VarDecl{
1324 .base = ast.Node{ .id = .VarDecl },
1325 .doc_comments = null,
1326 .visib_token = visb_tok,
1327 .thread_local_token = null,
1328 .name_token = name_tok,
1329 .eq_token = undefined, // set by caller
1330 .mut_token = mut_tok,
1331 .comptime_token = null,
1332 .extern_export_token = extern_tok,
1333 .lib_name = null,
1334 .type_node = null,
1335 .align_node = null,
1336 .section_node = null,
1337 .init_node = null,
1338 .semicolon_token = undefined, // set by caller
1339 };
1340 return node;
1341}
1342
13431410fn transCreateNodeInt(c: *Context, int: var) !*ast.Node {
13441411 const token = try appendToken(c, .IntegerLiteral, try std.fmt.allocPrint(c.a(), "{}", .{int}));
13451412 const node = try c.a().create(ast.Node.IntegerLiteral);
......@@ -1474,94 +1541,6 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
14741541 }
14751542}
14761543
1477fn transApValue(rp: RestorePoint, ap_value: *const ZigClangAPValue, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) TransError!*ast.Node {
1478 switch (ZigClangAPValue_getKind(ap_value)) {
1479 .None => return transCreateNodeUndefinedLiteral(rp.c),
1480 .Int => return transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(ap_value)),
1481 .Array => {
1482 // TODO evaluateValue is null for Array init for some reason
1483 // TODO use anon literals once they work properly
1484 const init_count = ZigClangAPValue_getArrayInitializedElts(ap_value);
1485 const all_count = ZigClangAPValue_getArraySize(ap_value);
1486 const leftover_count = all_count - init_count;
1487 const qt_type = ZigClangQualType_getTypePtr(qt);
1488 const child_qt = ZigClangArrayType_getElementType(ZigClangType_getAsArrayTypeUnsafe(qt_type));
1489
1490 var init_node: *ast.Node.SuffixOp = undefined;
1491 var cat_tok: ast.TokenIndex = undefined;
1492 if (init_count != 0) {
1493 var type_node = try transQualType(rp, qt, source_loc);
1494 init_node = try transCreateNodeArrayInitializer(rp.c, type_node);
1495 var i: c_uint = 0;
1496 while (i < init_count) : (i += 1) {
1497 const elem_ap_val = ZigClangAPValue_getArrayInitializedElt(ap_value, i);
1498 try init_node.op.ArrayInitializer.push(try transApValue(rp, elem_ap_val, child_qt, source_loc));
1499 _ = try appendToken(rp.c, .Comma, ",");
1500 }
1501 init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
1502 if (leftover_count == 0) {
1503 return &init_node.base;
1504 }
1505 cat_tok = try appendToken(rp.c, .PlusPlus, "++");
1506 }
1507
1508 var filler_type_node = try transQualType(rp, qt, source_loc);
1509 var filler_init_node = try transCreateNodeArrayInitializer(rp.c, filler_type_node);
1510 const filler_ap_val = ZigClangAPValue_getArrayFiller(ap_value);
1511 try filler_init_node.op.ArrayInitializer.push(try transApValue(rp, filler_ap_val, child_qt, source_loc));
1512 filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
1513
1514 const rhs_node = if (leftover_count == 1)
1515 &filler_init_node.base
1516 else blk: {
1517 const mul_tok = try appendToken(rp.c, .AsteriskAsterisk, "**");
1518 const mul_node = try rp.c.a().create(ast.Node.InfixOp);
1519 mul_node.* = .{
1520 .base = .{ .id = .InfixOp },
1521 .op_token = mul_tok,
1522 .lhs = &filler_init_node.base,
1523 .op = .ArrayMult,
1524 .rhs = try transCreateNodeInt(rp.c, leftover_count),
1525 };
1526 break :blk &mul_node.base;
1527 };
1528
1529 if (init_count == 0) {
1530 return rhs_node;
1531 }
1532
1533 const cat_node = try rp.c.a().create(ast.Node.InfixOp);
1534 cat_node.* = .{
1535 .base = .{ .id = .InfixOp },
1536 .op_token = cat_tok,
1537 .lhs = &init_node.base,
1538 .op = .ArrayCat,
1539 .rhs = rhs_node,
1540 };
1541 return &cat_node.base;
1542 },
1543 .LValue => {
1544 const lval_base = ZigClangAPValue_getLValueBase(ap_value);
1545 const expr = ZigClangAPValueLValueBase_dyn_cast_Expr(lval_base);
1546 if (expr) |e| {
1547 return (try transExpr(rp, &rp.c.global_scope.base, e, .used, .r_value)).node;
1548 }
1549 try emitWarning(rp.c, source_loc, "TODO handle initializer LValue ValueDecl", .{});
1550 },
1551 .Float => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Float", .{}),
1552 .ComplexInt => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: ComplexInt", .{}),
1553 .ComplexFloat => try emitWarning(rp.c, source_loc, "Tunsupported initializer value kind: ComplexFloat", .{}),
1554 .Vector => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Vector", .{}),
1555 .Struct => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Struct", .{}),
1556 .Union => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Union", .{}),
1557 .MemberPointer => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: MemberPointer", .{}),
1558 .AddrLabelDiff => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: AddrLabelDiff", .{}),
1559 .Indeterminate => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Indeterminate", .{}),
1560 .FixedPoint => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: FixedPoint", .{}),
1561 }
1562 return error.UnsupportedTranslation;
1563}
1564
15651544const FnDeclContext = struct {
15661545 fn_name: []const u8,
15671546 has_body: bool,
src/zig_clang.cpp+22
......@@ -1825,6 +1825,23 @@ bool ZigClangExpr_EvaluateAsConstantExpr(const ZigClangExpr *self, ZigClangExprE
18251825 return true;
18261826}
18271827
1828const ZigClangExpr *ZigClangInitListExpr_getInit(const ZigClangInitListExpr *self, unsigned i) {
1829 auto casted = reinterpret_cast<const clang::InitListExpr *>(self);
1830 const clang::Expr *result = casted->getInit(i);
1831 return reinterpret_cast<const ZigClangExpr *>(result);
1832}
1833
1834const ZigClangExpr *ZigClangInitListExpr_getArrayFiller(const ZigClangInitListExpr *self) {
1835 auto casted = reinterpret_cast<const clang::InitListExpr *>(self);
1836 const clang::Expr *result = casted->getArrayFiller();
1837 return reinterpret_cast<const ZigClangExpr *>(result);
1838}
1839
1840unsigned ZigClangInitListExpr_getNumInits(const ZigClangInitListExpr *self) {
1841 auto casted = reinterpret_cast<const clang::InitListExpr *>(self);
1842 return casted->getNumInits();
1843}
1844
18281845ZigClangAPValueKind ZigClangAPValue_getKind(const ZigClangAPValue *self) {
18291846 auto casted = reinterpret_cast<const clang::APValue *>(self);
18301847 return (ZigClangAPValueKind)casted->getKind();
......@@ -2065,6 +2082,11 @@ const ZigClangAPValue * ZigClangVarDecl_evaluateValue(const struct ZigClangVarDe
20652082 return reinterpret_cast<const ZigClangAPValue *>(result);
20662083}
20672084
2085enum ZigClangStorageClass ZigClangVarDecl_getStorageClass(const struct ZigClangVarDecl *self) {
2086 auto casted = reinterpret_cast<const clang::VarDecl *>(self);
2087 return (ZigClangStorageClass)casted->getStorageClass();
2088}
2089
20682090enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBuiltinType *self) {
20692091 auto casted = reinterpret_cast<const clang::BuiltinType *>(self);
20702092 return (ZigClangBuiltinTypeKind)casted->getKind();
src/zig_clang.h+6
......@@ -144,6 +144,7 @@ struct ZigClangUnaryOperator;
144144struct ZigClangValueDecl;
145145struct ZigClangVarDecl;
146146struct ZigClangWhileStmt;
147struct ZigClangInitListExpr;
147148
148149typedef struct ZigClangStmt *const * ZigClangCompoundStmt_const_body_iterator;
149150typedef struct ZigClangDecl *const * ZigClangDeclStmt_const_decl_iterator;
......@@ -904,6 +905,7 @@ ZIG_EXTERN_C bool ZigClangVarDecl_isFileVarDecl(const struct ZigClangVarDecl *);
904905ZIG_EXTERN_C bool ZigClangVarDecl_hasInit(const struct ZigClangVarDecl *);
905906ZIG_EXTERN_C const struct ZigClangAPValue *ZigClangVarDecl_evaluateValue(const struct ZigClangVarDecl *);
906907ZIG_EXTERN_C struct ZigClangQualType ZigClangVarDecl_getTypeSourceInfo_getType(const struct ZigClangVarDecl *);
908ZIG_EXTERN_C enum ZigClangStorageClass ZigClangVarDecl_getStorageClass(const struct ZigClangVarDecl *self);
907909
908910ZIG_EXTERN_C bool ZigClangSourceLocation_eq(struct ZigClangSourceLocation a, struct ZigClangSourceLocation b);
909911
......@@ -939,6 +941,10 @@ ZIG_EXTERN_C bool ZigClangExpr_EvaluateAsFloat(const struct ZigClangExpr *self,
939941ZIG_EXTERN_C bool ZigClangExpr_EvaluateAsConstantExpr(const struct ZigClangExpr *,
940942 struct ZigClangExprEvalResult *, ZigClangExpr_ConstExprUsage, const struct ZigClangASTContext *);
941943
944ZIG_EXTERN_C const ZigClangExpr *ZigClangInitListExpr_getInit(const ZigClangInitListExpr *, unsigned);
945ZIG_EXTERN_C const ZigClangExpr *ZigClangInitListExpr_getArrayFiller(const ZigClangInitListExpr *);
946ZIG_EXTERN_C unsigned ZigClangInitListExpr_getNumInits(const ZigClangInitListExpr *);
947
942948ZIG_EXTERN_C enum ZigClangAPValueKind ZigClangAPValue_getKind(const struct ZigClangAPValue *self);
943949ZIG_EXTERN_C const struct ZigClangAPSInt *ZigClangAPValue_getInt(const struct ZigClangAPValue *self);
944950ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const struct ZigClangAPValue *self);
test/translate_c.zig+10
......@@ -98,6 +98,16 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
9898 \\pub extern fn d() void;
9999 });
100100
101 cases.add_2("variable declarations",
102 \\extern char arr0[] = "hello";
103 \\static char arr1[] = "hello";
104 \\char arr2[] = "hello";
105 , &[_][]const u8{
106 \\pub extern var arr0: [*c]u8 = "hello";
107 \\pub var arr1: [*c]u8 = "hello";
108 \\pub export var arr2: [*c]u8 = "hello";
109 });
110
101111 /////////////// Cases for only stage1 which are TODO items for stage2 ////////////////
102112
103113 cases.add("typedef of function in struct field",