Commit eb057ef41c
Changed files (5)
src/zig_clang.cpp
@@ -1825,6 +1825,23 @@ bool ZigClangExpr_EvaluateAsConstantExpr(const ZigClangExpr *self, ZigClangExprE
return true;
}
+const ZigClangExpr *ZigClangInitListExpr_getInit(const ZigClangInitListExpr *self, unsigned i) {
+ auto casted = reinterpret_cast<const clang::InitListExpr *>(self);
+ const clang::Expr *result = casted->getInit(i);
+ return reinterpret_cast<const ZigClangExpr *>(result);
+}
+
+const ZigClangExpr *ZigClangInitListExpr_getArrayFiller(const ZigClangInitListExpr *self) {
+ auto casted = reinterpret_cast<const clang::InitListExpr *>(self);
+ const clang::Expr *result = casted->getArrayFiller();
+ return reinterpret_cast<const ZigClangExpr *>(result);
+}
+
+unsigned ZigClangInitListExpr_getNumInits(const ZigClangInitListExpr *self) {
+ auto casted = reinterpret_cast<const clang::InitListExpr *>(self);
+ return casted->getNumInits();
+}
+
ZigClangAPValueKind ZigClangAPValue_getKind(const ZigClangAPValue *self) {
auto casted = reinterpret_cast<const clang::APValue *>(self);
return (ZigClangAPValueKind)casted->getKind();
@@ -2065,6 +2082,11 @@ const ZigClangAPValue * ZigClangVarDecl_evaluateValue(const struct ZigClangVarDe
return reinterpret_cast<const ZigClangAPValue *>(result);
}
+enum ZigClangStorageClass ZigClangVarDecl_getStorageClass(const struct ZigClangVarDecl *self) {
+ auto casted = reinterpret_cast<const clang::VarDecl *>(self);
+ return (ZigClangStorageClass)casted->getStorageClass();
+}
+
enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBuiltinType *self) {
auto casted = reinterpret_cast<const clang::BuiltinType *>(self);
return (ZigClangBuiltinTypeKind)casted->getKind();
src/zig_clang.h
@@ -144,6 +144,7 @@ struct ZigClangUnaryOperator;
struct ZigClangValueDecl;
struct ZigClangVarDecl;
struct ZigClangWhileStmt;
+struct ZigClangInitListExpr;
typedef struct ZigClangStmt *const * ZigClangCompoundStmt_const_body_iterator;
typedef struct ZigClangDecl *const * ZigClangDeclStmt_const_decl_iterator;
@@ -904,6 +905,7 @@ ZIG_EXTERN_C bool ZigClangVarDecl_isFileVarDecl(const struct ZigClangVarDecl *);
ZIG_EXTERN_C bool ZigClangVarDecl_hasInit(const struct ZigClangVarDecl *);
ZIG_EXTERN_C const struct ZigClangAPValue *ZigClangVarDecl_evaluateValue(const struct ZigClangVarDecl *);
ZIG_EXTERN_C struct ZigClangQualType ZigClangVarDecl_getTypeSourceInfo_getType(const struct ZigClangVarDecl *);
+ZIG_EXTERN_C enum ZigClangStorageClass ZigClangVarDecl_getStorageClass(const struct ZigClangVarDecl *self);
ZIG_EXTERN_C bool ZigClangSourceLocation_eq(struct ZigClangSourceLocation a, struct ZigClangSourceLocation b);
@@ -939,6 +941,10 @@ ZIG_EXTERN_C bool ZigClangExpr_EvaluateAsFloat(const struct ZigClangExpr *self,
ZIG_EXTERN_C bool ZigClangExpr_EvaluateAsConstantExpr(const struct ZigClangExpr *,
struct ZigClangExprEvalResult *, ZigClangExpr_ConstExprUsage, const struct ZigClangASTContext *);
+ZIG_EXTERN_C const ZigClangExpr *ZigClangInitListExpr_getInit(const ZigClangInitListExpr *, unsigned);
+ZIG_EXTERN_C const ZigClangExpr *ZigClangInitListExpr_getArrayFiller(const ZigClangInitListExpr *);
+ZIG_EXTERN_C unsigned ZigClangInitListExpr_getNumInits(const ZigClangInitListExpr *);
+
ZIG_EXTERN_C enum ZigClangAPValueKind ZigClangAPValue_getKind(const struct ZigClangAPValue *self);
ZIG_EXTERN_C const struct ZigClangAPSInt *ZigClangAPValue_getInt(const struct ZigClangAPValue *self);
ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const struct ZigClangAPValue *self);
src-self-hosted/clang.zig
@@ -74,6 +74,7 @@ pub const struct_ZigClangVarDecl = @OpaqueType();
pub const struct_ZigClangWhileStmt = @OpaqueType();
pub const struct_ZigClangFunctionType = @OpaqueType();
pub const struct_ZigClangPredefinedExpr = @OpaqueType();
+pub const struct_ZigClangInitListExpr = @OpaqueType();
pub const ZigClangBO = extern enum {
PtrMemD,
@@ -755,11 +756,12 @@ pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_ZigClangStmt) bool;
pub extern fn ZigClangExpr_getStmtClass(self: ?*const struct_ZigClangExpr) ZigClangStmtClass;
pub extern fn ZigClangExpr_getType(self: ?*const struct_ZigClangExpr) struct_ZigClangQualType;
pub extern fn ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation;
+pub extern fn ZigClangInitListExpr_getInit(self: ?*const struct_ZigClangInitListExpr, i: c_uint) *const ZigClangExpr;
+pub extern fn ZigClangInitListExpr_getArrayFiller(self: ?*const struct_ZigClangInitListExpr) *const ZigClangExpr;
+pub extern fn ZigClangInitListExpr_getNumInits(self: ?*const struct_ZigClangInitListExpr) c_uint;
pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind;
pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) ?*const struct_ZigClangAPSInt;
pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
-pub extern fn ZigClangAPValue_getArrayInitializedElt(self: ?*const struct_ZigClangAPValue, i: c_uint) *const struct_ZigClangAPValue;
-pub extern fn ZigClangAPValue_getArrayFiller(self: ?*const struct_ZigClangAPValue) *const struct_ZigClangAPValue;
pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint;
pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase;
pub extern fn ZigClangAPSInt_isSigned(self: ?*const struct_ZigClangAPSInt) bool;
@@ -867,6 +869,7 @@ pub const ZigClangVarDecl = struct_ZigClangVarDecl;
pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
pub const ZigClangFunctionType = struct_ZigClangFunctionType;
pub const ZigClangPredefinedExpr = struct_ZigClangPredefinedExpr;
+pub const ZigClangInitListExpr = struct_ZigClangInitListExpr;
pub const struct_ZigClangSourceLocation = extern struct {
ID: c_uint,
@@ -921,9 +924,8 @@ pub extern fn ZigClangDeclStmt_decl_begin(self: *const ZigClangDeclStmt) ZigClan
pub extern fn ZigClangDeclStmt_decl_end(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
pub extern fn ZigClangVarDecl_getLocation(self: *const struct_ZigClangVarDecl) ZigClangSourceLocation;
-pub extern fn ZigClangVarDecl_hasExternalStorage(self: *const struct_ZigClangVarDecl) bool;
-pub extern fn ZigClangVarDecl_isFileVarDecl(self: *const struct_ZigClangVarDecl) bool;
pub extern fn ZigClangVarDecl_hasInit(self: *const struct_ZigClangVarDecl) bool;
+pub extern fn ZigClangVarDecl_getStorageClass(self: *const ZigClangVarDecl) ZigClangStorageClass;
pub extern fn ZigClangVarDecl_getType(self: ?*const struct_ZigClangVarDecl) struct_ZigClangQualType;
pub extern fn ZigClangVarDecl_getInit(*const ZigClangVarDecl) ?*const ZigClangExpr;
pub extern fn ZigClangVarDecl_getTLSKind(self: ?*const struct_ZigClangVarDecl) ZigClangVarDecl_TLSKind;
@@ -964,7 +966,6 @@ pub const struct_ZigClangExprEvalResult = extern struct {
Val: ZigClangAPValue,
};
-pub extern fn ZigClangVarDecl_evaluateValue(self: *const struct_ZigClangVarDecl) ?*const ZigClangAPValue;
pub const struct_ZigClangAPValue = extern struct {
Kind: ZigClangAPValueKind,
Data: if (builtin.os == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
src-self-hosted/translate_c.zig
@@ -305,54 +305,83 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl) Error!void {
if (try c.decl_table.put(@ptrToInt(var_decl), {})) |_| return; // Avoid processing this decl twice
const rp = makeRestorePoint(c);
+ const visib_tok = try appendToken(c, .Keyword_pub, "pub");
+
+ const thread_local_token = if (ZigClangVarDecl_getTLSKind(var_decl) == .None)
+ null
+ else
+ try appendToken(c, .Keyword_threadlocal, "threadlocal");
+
var scope = &c.global_scope.base;
const var_name = try c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, var_decl)));
const var_decl_loc = ZigClangVarDecl_getLocation(var_decl);
- switch (ZigClangVarDecl_getTLSKind(var_decl)) {
- .None => {},
- .Static => return failDecl(c, var_decl_loc, var_name, "static thread local storage not supported", .{}),
- .Dynamic => return failDecl(c, var_decl_loc, var_name, "dynamic thread local storag not supported", .{}),
- }
-
- const qual_type = ZigClangVarDecl_getType(var_decl);
- const is_extern = ZigClangVarDecl_hasExternalStorage(var_decl);
- const is_static = ZigClangVarDecl_isFileVarDecl(var_decl);
+ const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl);
+ const storage_class = ZigClangVarDecl_getStorageClass(var_decl);
const is_const = ZigClangQualType_isConstQualified(qual_type);
- var var_node = try transCreateNodeVarDecl(c, true, is_extern, is_const, var_name);
+ const extern_tok = if (storage_class == .Extern)
+ try appendToken(c, .Keyword_extern, "extern")
+ else if (storage_class != .Static)
+ try appendToken(c, .Keyword_export, "export")
+ else
+ null;
+
+ const mut_tok = if (is_const)
+ try appendToken(c, .Keyword_const, "const")
+ else
+ try appendToken(c, .Keyword_var, "var");
- _ = try appendToken(rp.c, .Colon, ":");
- var_node.type_node = transQualType(rp, qual_type, var_decl_loc) catch |err| switch (err) {
+ const name_tok = try appendToken(c, .Identifier, var_name);
+
+ _ = try appendToken(c, .Colon, ":");
+ const type_node = transQualType(rp, qual_type, var_decl_loc) catch |err| switch (err) {
error.UnsupportedType => {
return failDecl(c, var_decl_loc, var_name, "unable to resolve variable type", .{});
},
error.OutOfMemory => |e| return e,
};
- if (is_static and !is_extern) {
- const eq_tok = try appendToken(c, .Equal, "=");
- const init_node = if (ZigClangVarDecl_hasInit(var_decl)) blk: {
- const ap_value = ZigClangVarDecl_evaluateValue(var_decl) orelse
- return failDecl(c, var_decl_loc, var_name, "unable to evaluate initializer", .{});
- break :blk transApValue(rp, ap_value, qual_type, var_decl_loc) catch |err| switch (err) {
+ var eq_tok: ast.TokenIndex = undefined;
+ var init_node: ?*ast.Node = null;
+
+ if (ZigClangVarDecl_hasInit(var_decl)) {
+ eq_tok = try appendToken(c, .Equal, "=");
+ init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr| blk: {
+ var res = transExpr(rp, &c.global_scope.base, expr, .used, .r_value) catch |err| switch (err) {
error.UnsupportedTranslation,
error.UnsupportedType,
=> {
- return failDecl(c, var_decl_loc, var_name, "unable to evaluate initializer", .{});
+ return failDecl(c, var_decl_loc, var_name, "unable to translate initializer", .{});
},
error.OutOfMemory => |e| return e,
};
+ break :blk res.node;
} else
try transCreateNodeUndefinedLiteral(c);
- var_node.eq_token = eq_tok;
- var_node.init_node = init_node;
- } else if (!is_extern) {
- return failDecl(c, var_decl_loc, var_name, "non-extern, non-static variable not supported", .{});
+ } else if (storage_class != .Extern) {
+ return failDecl(c, var_decl_loc, var_name, "non-extern variable has no initializer", .{});
}
- var_node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
- return addTopLevelDecl(c, var_name, &var_node.base);
+ const node = try c.a().create(ast.Node.VarDecl);
+ node.* = ast.Node.VarDecl{
+ .base = ast.Node{ .id = .VarDecl },
+ .doc_comments = null,
+ .visib_token = visib_tok,
+ .thread_local_token = thread_local_token,
+ .name_token = name_tok,
+ .eq_token = eq_tok,
+ .mut_token = mut_tok,
+ .comptime_token = null,
+ .extern_export_token = extern_tok,
+ .lib_name = null,
+ .type_node = type_node,
+ .align_node = null,
+ .section_node = null,
+ .init_node = init_node,
+ .semicolon_token = try appendToken(c, .Semicolon, ";"),
+ };
+ return addTopLevelDecl(c, var_name, &node.base);
}
const ResultUsed = enum {
@@ -384,6 +413,7 @@ fn transStmt(
.ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const ZigClangReturnStmt, stmt)),
.StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used),
.ParenExprClass => return transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), result_used, lrvalue),
+ .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const ZigClangInitListExpr, stmt), result_used),
else => {
return revertAndWarn(
rp,
@@ -635,7 +665,7 @@ fn transDeclStmt(rp: RestorePoint, parent_scope: *Scope, stmt: *const ZigClangDe
const init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr|
(try transExpr(rp, scope, expr, .used, .r_value)).node
else
- try transCreateNodeUndefinedLiteral(rp.c);
+ try transCreateNodeUndefinedLiteral(c);
const semicolon_token = try appendToken(c, .Semicolon, ";");
const node = try c.a().create(ast.Node.VarDecl);
@@ -725,7 +755,7 @@ fn transImplicitCastExpr(
.FunctionToPointerDecay, .ArrayToPointerDecay => {
return maybeSuppressResult(rp, scope, result_used, sub_expr_node);
},
- .LValueToRValue => {
+ .LValueToRValue, .NoOp => {
return transExpr(rp, scope, sub_expr, .used, .r_value);
},
else => |kind| return revertAndWarn(
@@ -906,6 +936,88 @@ fn transExpr(
return transStmt(rp, scope, @ptrCast(*const ZigClangStmt, expr), used, lrvalue);
}
+fn transInitListExpr(
+ rp: RestorePoint,
+ scope: *Scope,
+ expr: *const ZigClangInitListExpr,
+ used: ResultUsed,
+) TransError!TransResult {
+ // TODO use anon literals once they work properly
+ const qt = getExprQualType(rp.c, @ptrCast(*const ZigClangExpr, expr));
+ const qual_type = ZigClangQualType_getTypePtr(qt);
+ const source_loc = ZigClangExpr_getBeginLoc(@ptrCast(*const ZigClangExpr, expr));
+ const arr_type = ZigClangType_getAsArrayTypeUnsafe(qual_type);
+ const child_qt = ZigClangArrayType_getElementType(arr_type);
+ const init_count = ZigClangInitListExpr_getNumInits(expr);
+ const all_count = 200; //ZigClangArrayType_getSize(arr_type);
+ const leftover_count = all_count - init_count;
+
+ var init_node: *ast.Node.SuffixOp = undefined;
+ var cat_tok: ast.TokenIndex = undefined;
+ if (init_count != 0) {
+ var type_node = try transQualType(rp, qt, source_loc);
+ init_node = try transCreateNodeArrayInitializer(rp.c, type_node);
+ var i: c_uint = 0;
+ while (i < init_count) : (i += 1) {
+ const elem_expr = ZigClangInitListExpr_getInit(expr, i);
+ try init_node.op.ArrayInitializer.push((try transExpr(rp, scope, elem_expr, .used, .r_value)).node);
+ _ = try appendToken(rp.c, .Comma, ",");
+ }
+ init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
+ if (leftover_count == 0) {
+ return TransResult{
+ .node = &init_node.base,
+ .child_scope = scope,
+ .node_scope = scope,
+ };
+ }
+ cat_tok = try appendToken(rp.c, .PlusPlus, "++");
+ }
+
+ var filler_type_node = try transQualType(rp, qt, source_loc);
+ var filler_init_node = try transCreateNodeArrayInitializer(rp.c, filler_type_node);
+ const filler_val_expr = ZigClangInitListExpr_getArrayFiller(expr);
+ try filler_init_node.op.ArrayInitializer.push((try transExpr(rp, scope, filler_val_expr, .used, .r_value)).node);
+ filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
+
+ const rhs_node = if (leftover_count == 1)
+ &filler_init_node.base
+ else blk: {
+ const mul_tok = try appendToken(rp.c, .AsteriskAsterisk, "**");
+ const mul_node = try rp.c.a().create(ast.Node.InfixOp);
+ mul_node.* = .{
+ .base = .{ .id = .InfixOp },
+ .op_token = mul_tok,
+ .lhs = &filler_init_node.base,
+ .op = .ArrayMult,
+ .rhs = try transCreateNodeInt(rp.c, leftover_count),
+ };
+ break :blk &mul_node.base;
+ };
+
+ if (init_count == 0) {
+ return TransResult{
+ .node = rhs_node,
+ .child_scope = scope,
+ .node_scope = scope,
+ };
+ }
+
+ const cat_node = try rp.c.a().create(ast.Node.InfixOp);
+ cat_node.* = .{
+ .base = .{ .id = .InfixOp },
+ .op_token = cat_tok,
+ .lhs = &init_node.base,
+ .op = .ArrayCat,
+ .rhs = rhs_node,
+ };
+ return TransResult{
+ .node = &cat_node.base,
+ .child_scope = scope,
+ .node_scope = scope,
+ };
+}
+
fn findBlockScope(inner: *Scope) *Scope.Block {
var scope = inner;
while (true) : (scope = scope.parent orelse unreachable) {
@@ -1295,51 +1407,6 @@ fn transCreateNodeArrayInitializer(c: *Context, type_node: *ast.Node) !*ast.Node
return node;
}
-fn transCreateNodeVarDecl(
- c: *Context,
- is_pub: bool,
- is_extern: bool,
- is_const: bool,
- var_name: []const u8,
-) !*ast.Node.VarDecl {
- const visb_tok = if (is_pub)
- try appendToken(c, .Keyword_pub, "pub")
- else
- null;
-
- const extern_tok = if (is_extern)
- try appendToken(c, .Keyword_extern, "extern")
- else
- null;
-
- const mut_tok = if (is_const)
- try appendToken(c, .Keyword_const, "const")
- else
- try appendToken(c, .Keyword_var, "var");
-
- const name_tok = try appendToken(c, .Identifier, var_name);
-
- const node = try c.a().create(ast.Node.VarDecl);
- node.* = ast.Node.VarDecl{
- .base = ast.Node{ .id = .VarDecl },
- .doc_comments = null,
- .visib_token = visb_tok,
- .thread_local_token = null,
- .name_token = name_tok,
- .eq_token = undefined, // set by caller
- .mut_token = mut_tok,
- .comptime_token = null,
- .extern_export_token = extern_tok,
- .lib_name = null,
- .type_node = null,
- .align_node = null,
- .section_node = null,
- .init_node = null,
- .semicolon_token = undefined, // set by caller
- };
- return node;
-}
-
fn transCreateNodeInt(c: *Context, int: var) !*ast.Node {
const token = try appendToken(c, .IntegerLiteral, try std.fmt.allocPrint(c.a(), "{}", .{int}));
const node = try c.a().create(ast.Node.IntegerLiteral);
@@ -1474,94 +1541,6 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
}
}
-fn transApValue(rp: RestorePoint, ap_value: *const ZigClangAPValue, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) TransError!*ast.Node {
- switch (ZigClangAPValue_getKind(ap_value)) {
- .None => return transCreateNodeUndefinedLiteral(rp.c),
- .Int => return transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(ap_value)),
- .Array => {
- // TODO evaluateValue is null for Array init for some reason
- // TODO use anon literals once they work properly
- const init_count = ZigClangAPValue_getArrayInitializedElts(ap_value);
- const all_count = ZigClangAPValue_getArraySize(ap_value);
- const leftover_count = all_count - init_count;
- const qt_type = ZigClangQualType_getTypePtr(qt);
- const child_qt = ZigClangArrayType_getElementType(ZigClangType_getAsArrayTypeUnsafe(qt_type));
-
- var init_node: *ast.Node.SuffixOp = undefined;
- var cat_tok: ast.TokenIndex = undefined;
- if (init_count != 0) {
- var type_node = try transQualType(rp, qt, source_loc);
- init_node = try transCreateNodeArrayInitializer(rp.c, type_node);
- var i: c_uint = 0;
- while (i < init_count) : (i += 1) {
- const elem_ap_val = ZigClangAPValue_getArrayInitializedElt(ap_value, i);
- try init_node.op.ArrayInitializer.push(try transApValue(rp, elem_ap_val, child_qt, source_loc));
- _ = try appendToken(rp.c, .Comma, ",");
- }
- init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
- if (leftover_count == 0) {
- return &init_node.base;
- }
- cat_tok = try appendToken(rp.c, .PlusPlus, "++");
- }
-
- var filler_type_node = try transQualType(rp, qt, source_loc);
- var filler_init_node = try transCreateNodeArrayInitializer(rp.c, filler_type_node);
- const filler_ap_val = ZigClangAPValue_getArrayFiller(ap_value);
- try filler_init_node.op.ArrayInitializer.push(try transApValue(rp, filler_ap_val, child_qt, source_loc));
- filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
-
- const rhs_node = if (leftover_count == 1)
- &filler_init_node.base
- else blk: {
- const mul_tok = try appendToken(rp.c, .AsteriskAsterisk, "**");
- const mul_node = try rp.c.a().create(ast.Node.InfixOp);
- mul_node.* = .{
- .base = .{ .id = .InfixOp },
- .op_token = mul_tok,
- .lhs = &filler_init_node.base,
- .op = .ArrayMult,
- .rhs = try transCreateNodeInt(rp.c, leftover_count),
- };
- break :blk &mul_node.base;
- };
-
- if (init_count == 0) {
- return rhs_node;
- }
-
- const cat_node = try rp.c.a().create(ast.Node.InfixOp);
- cat_node.* = .{
- .base = .{ .id = .InfixOp },
- .op_token = cat_tok,
- .lhs = &init_node.base,
- .op = .ArrayCat,
- .rhs = rhs_node,
- };
- return &cat_node.base;
- },
- .LValue => {
- const lval_base = ZigClangAPValue_getLValueBase(ap_value);
- const expr = ZigClangAPValueLValueBase_dyn_cast_Expr(lval_base);
- if (expr) |e| {
- return (try transExpr(rp, &rp.c.global_scope.base, e, .used, .r_value)).node;
- }
- try emitWarning(rp.c, source_loc, "TODO handle initializer LValue ValueDecl", .{});
- },
- .Float => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Float", .{}),
- .ComplexInt => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: ComplexInt", .{}),
- .ComplexFloat => try emitWarning(rp.c, source_loc, "Tunsupported initializer value kind: ComplexFloat", .{}),
- .Vector => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Vector", .{}),
- .Struct => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Struct", .{}),
- .Union => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Union", .{}),
- .MemberPointer => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: MemberPointer", .{}),
- .AddrLabelDiff => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: AddrLabelDiff", .{}),
- .Indeterminate => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: Indeterminate", .{}),
- .FixedPoint => try emitWarning(rp.c, source_loc, "unsupported initializer value kind: FixedPoint", .{}),
- }
- return error.UnsupportedTranslation;
-}
-
const FnDeclContext = struct {
fn_name: []const u8,
has_body: bool,
test/translate_c.zig
@@ -98,6 +98,16 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub extern fn d() void;
});
+ cases.add_2("variable declarations",
+ \\extern char arr0[] = "hello";
+ \\static char arr1[] = "hello";
+ \\char arr2[] = "hello";
+ , &[_][]const u8{
+ \\pub extern var arr0: [*c]u8 = "hello";
+ \\pub var arr1: [*c]u8 = "hello";
+ \\pub export var arr2: [*c]u8 = "hello";
+ });
+
/////////////// Cases for only stage1 which are TODO items for stage2 ////////////////
cases.add("typedef of function in struct field",