Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

translate-c-2 dont eval init expr

Browse Source
This commit is contained in:
Vexu 2019-12-13 14:55:36 +02:00
parent 0795f17db2
commit eb057ef41c
No known key found for this signature in database
GPG Key ID: 59AEB8936E16A6AC
5 changed files with 183 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src-self-hosted/clang.zig
View File

@ -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,

299
src-self-hosted/translate_c.zig
View File

@ -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;
_ = try appendToken(rp.c, .Colon, ":");
var_node.type_node = transQualType(rp, qual_type, var_decl_loc) catch |err| switch (err) {
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);
_ = 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,

22
src/zig_clang.cpp
View File

@ -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();

6
src/zig_clang.h
View File

@ -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);

10
test/translate_c.zig
View File

@ -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",