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

Merge branch 'stage-2-cimport' of https://github.com/Vexu/zig into Vexu-stage-2-cimport

master
Andrew Kelley 2019-12-31 16:55:41 -05:00
parent c8c65b0168 950eb81304
commit 39ee3bc0ec
No known key found for this signature in database
GPG Key ID: 7C5F548F728501A9
19 changed files with 840 additions and 7707 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -448,7 +448,6 @@ set(ZIG_SOURCES
"${CMAKE_SOURCE_DIR}/src/bigfloat.cpp"
"${CMAKE_SOURCE_DIR}/src/bigint.cpp"
"${CMAKE_SOURCE_DIR}/src/buffer.cpp"
"${CMAKE_SOURCE_DIR}/src/c_tokenizer.cpp"
"${CMAKE_SOURCE_DIR}/src/cache_hash.cpp"
"${CMAKE_SOURCE_DIR}/src/codegen.cpp"
"${CMAKE_SOURCE_DIR}/src/compiler.cpp"
@ -465,7 +464,6 @@ set(ZIG_SOURCES
"${CMAKE_SOURCE_DIR}/src/range_set.cpp"
"${CMAKE_SOURCE_DIR}/src/target.cpp"
"${CMAKE_SOURCE_DIR}/src/tokenizer.cpp"
"${CMAKE_SOURCE_DIR}/src/translate_c.cpp"
"${CMAKE_SOURCE_DIR}/src/util.cpp"
"${ZIG_SOURCES_MEM_PROFILE}"
)

95
lib/std/zig/ast.zig
View File

@ -13,6 +13,7 @@ pub const Tree = struct {
root_node: *Node.Root,
arena_allocator: std.heap.ArenaAllocator,
errors: ErrorList,
generated: bool = false,
pub const TokenList = SegmentedList(Token, 64);
pub const ErrorList = SegmentedList(Error, 0);
@ -58,6 +59,8 @@ pub const Tree = struct {
.line_start = start_index,
.line_end = self.source.len,
};
if (self.generated)
return loc;
const token_start = token.start;
for (self.source[start_index..]) |c, i| {
if (i + start_index == token_start) {
@ -581,7 +584,7 @@ pub const Node = struct {
}
pub const Root = struct {
base: Node = Node {.id = .Root},
base: Node = Node{ .id = .Root },
decls: DeclList,
eof_token: TokenIndex,
@ -604,7 +607,7 @@ pub const Node = struct {
};
pub const VarDecl = struct {
base: Node = Node {.id = .VarDecl},
base: Node = Node{ .id = .VarDecl },
doc_comments: ?*DocComment,
visib_token: ?TokenIndex,
thread_local_token: ?TokenIndex,
@ -661,7 +664,7 @@ pub const Node = struct {
};
pub const Use = struct {
base: Node = Node {.id = .Use},
base: Node = Node{ .id = .Use },
doc_comments: ?*DocComment,
visib_token: ?TokenIndex,
use_token: TokenIndex,
@ -688,7 +691,7 @@ pub const Node = struct {
};
pub const ErrorSetDecl = struct {
base: Node = Node {.id = .ErrorSetDecl},
base: Node = Node{ .id = .ErrorSetDecl },
error_token: TokenIndex,
decls: DeclList,
rbrace_token: TokenIndex,
@ -714,7 +717,7 @@ pub const Node = struct {
};
pub const ContainerDecl = struct {
base: Node = Node {.id = .ContainerDecl},
base: Node = Node{ .id = .ContainerDecl },
layout_token: ?TokenIndex,
kind_token: TokenIndex,
init_arg_expr: InitArg,
@ -801,7 +804,7 @@ pub const Node = struct {
};
pub const ErrorTag = struct {
base: Node = Node {.id = .ErrorTag},
base: Node = Node{ .id = .ErrorTag },
doc_comments: ?*DocComment,
name_token: TokenIndex,
@ -826,7 +829,7 @@ pub const Node = struct {
};
pub const Identifier = struct {
base: Node = Node {.id = .Identifier},
base: Node = Node{ .id = .Identifier },
token: TokenIndex,
pub fn iterate(self: *Identifier, index: usize) ?*Node {
@ -843,7 +846,7 @@ pub const Node = struct {
};
pub const FnProto = struct {
base: Node = Node {.id = .FnProto},
base: Node = Node{ .id = .FnProto },
doc_comments: ?*DocComment,
visib_token: ?TokenIndex,
fn_token: TokenIndex,
@ -925,7 +928,7 @@ pub const Node = struct {
};
pub const AnyFrameType = struct {
base: Node = Node {.id = .AnyFrameType},
base: Node = Node{ .id = .AnyFrameType },
anyframe_token: TokenIndex,
result: ?Result,
@ -956,7 +959,7 @@ pub const Node = struct {
};
pub const ParamDecl = struct {
base: Node = Node {.id = .ParamDecl},
base: Node = Node{ .id = .ParamDecl },
doc_comments: ?*DocComment,
comptime_token: ?TokenIndex,
noalias_token: ?TokenIndex,
@ -989,7 +992,7 @@ pub const Node = struct {
};
pub const Block = struct {
base: Node = Node {.id = .Block},
base: Node = Node{ .id = .Block },
label: ?TokenIndex,
lbrace: TokenIndex,
statements: StatementList,
@ -1020,7 +1023,7 @@ pub const Node = struct {
};
pub const Defer = struct {
base: Node = Node {.id = .Defer},
base: Node = Node{ .id = .Defer },
defer_token: TokenIndex,
expr: *Node,
@ -1043,7 +1046,7 @@ pub const Node = struct {
};
pub const Comptime = struct {
base: Node = Node {.id = .Comptime},
base: Node = Node{ .id = .Comptime },
doc_comments: ?*DocComment,
comptime_token: TokenIndex,
expr: *Node,
@ -1067,7 +1070,7 @@ pub const Node = struct {
};
pub const Payload = struct {
base: Node = Node {.id = .Payload},
base: Node = Node{ .id = .Payload },
lpipe: TokenIndex,
error_symbol: *Node,
rpipe: TokenIndex,
@ -1091,7 +1094,7 @@ pub const Node = struct {
};
pub const PointerPayload = struct {
base: Node = Node {.id = .PointerPayload},
base: Node = Node{ .id = .PointerPayload },
lpipe: TokenIndex,
ptr_token: ?TokenIndex,
value_symbol: *Node,
@ -1116,7 +1119,7 @@ pub const Node = struct {
};
pub const PointerIndexPayload = struct {
base: Node = Node {.id = .PointerIndexPayload},
base: Node = Node{ .id = .PointerIndexPayload },
lpipe: TokenIndex,
ptr_token: ?TokenIndex,
value_symbol: *Node,
@ -1147,7 +1150,7 @@ pub const Node = struct {
};
pub const Else = struct {
base: Node = Node {.id = .Else},
base: Node = Node{ .id = .Else },
else_token: TokenIndex,
payload: ?*Node,
body: *Node,
@ -1176,7 +1179,7 @@ pub const Node = struct {
};
pub const Switch = struct {
base: Node = Node {.id = .Switch},
base: Node = Node{ .id = .Switch },
switch_token: TokenIndex,
expr: *Node,
@ -1208,7 +1211,7 @@ pub const Node = struct {
};
pub const SwitchCase = struct {
base: Node = Node {.id = .SwitchCase},
base: Node = Node{ .id = .SwitchCase },
items: ItemList,
arrow_token: TokenIndex,
payload: ?*Node,
@ -1243,7 +1246,7 @@ pub const Node = struct {
};
pub const SwitchElse = struct {
base: Node = Node {.id = .SwitchElse},
base: Node = Node{ .id = .SwitchElse },
token: TokenIndex,
pub fn iterate(self: *SwitchElse, index: usize) ?*Node {
@ -1260,7 +1263,7 @@ pub const Node = struct {
};
pub const While = struct {
base: Node = Node {.id = .While},
base: Node = Node{ .id = .While },
label: ?TokenIndex,
inline_token: ?TokenIndex,
while_token: TokenIndex,
@ -1319,7 +1322,7 @@ pub const Node = struct {
};
pub const For = struct {
base: Node = Node {.id = .For},
base: Node = Node{ .id = .For },
label: ?TokenIndex,
inline_token: ?TokenIndex,
for_token: TokenIndex,
@ -1370,7 +1373,7 @@ pub const Node = struct {
};
pub const If = struct {
base: Node = Node {.id = .If},
base: Node = Node{ .id = .If },
if_token: TokenIndex,
condition: *Node,
payload: ?*Node,
@ -1413,7 +1416,7 @@ pub const Node = struct {
};
pub const InfixOp = struct {
base: Node = Node {.id = .InfixOp},
base: Node = Node{ .id = .InfixOp },
op_token: TokenIndex,
lhs: *Node,
op: Op,
@ -1646,7 +1649,7 @@ pub const Node = struct {
};
pub const FieldInitializer = struct {
base: Node = Node {.id = .FieldInitializer},
base: Node = Node{ .id = .FieldInitializer },
period_token: TokenIndex,
name_token: TokenIndex,
expr: *Node,
@ -1670,7 +1673,7 @@ pub const Node = struct {
};
pub const SuffixOp = struct {
base: Node = Node {.id = .SuffixOp},
base: Node = Node{ .id = .SuffixOp },
lhs: Lhs,
op: Op,
rtoken: TokenIndex,
@ -1771,7 +1774,7 @@ pub const Node = struct {
};
pub const GroupedExpression = struct {
base: Node = Node {.id = .GroupedExpression},
base: Node = Node{ .id = .GroupedExpression },
lparen: TokenIndex,
expr: *Node,
rparen: TokenIndex,
@ -1795,7 +1798,7 @@ pub const Node = struct {
};
pub const ControlFlowExpression = struct {
base: Node = Node {.id = .ControlFlowExpression},
base: Node = Node{ .id = .ControlFlowExpression },
ltoken: TokenIndex,
kind: Kind,
rhs: ?*Node,
@ -1861,7 +1864,7 @@ pub const Node = struct {
};
pub const Suspend = struct {
base: Node = Node {.id = .Suspend},
base: Node = Node{ .id = .Suspend },
suspend_token: TokenIndex,
body: ?*Node,
@ -1890,7 +1893,7 @@ pub const Node = struct {
};
pub const IntegerLiteral = struct {
base: Node = Node {.id = .IntegerLiteral},
base: Node = Node{ .id = .IntegerLiteral },
token: TokenIndex,
pub fn iterate(self: *IntegerLiteral, index: usize) ?*Node {
@ -1907,7 +1910,7 @@ pub const Node = struct {
};
pub const EnumLiteral = struct {
base: Node = Node {.id = .EnumLiteral},
base: Node = Node{ .id = .EnumLiteral },
dot: TokenIndex,
name: TokenIndex,
@ -1925,7 +1928,7 @@ pub const Node = struct {
};
pub const FloatLiteral = struct {
base: Node = Node {.id = .FloatLiteral},
base: Node = Node{ .id = .FloatLiteral },
token: TokenIndex,
pub fn iterate(self: *FloatLiteral, index: usize) ?*Node {
@ -1942,7 +1945,7 @@ pub const Node = struct {
};
pub const BuiltinCall = struct {
base: Node = Node {.id = .BuiltinCall},
base: Node = Node{ .id = .BuiltinCall },
builtin_token: TokenIndex,
params: ParamList,
rparen_token: TokenIndex,
@ -1968,7 +1971,7 @@ pub const Node = struct {
};
pub const StringLiteral = struct {
base: Node = Node {.id = .StringLiteral},
base: Node = Node{ .id = .StringLiteral },
token: TokenIndex,
pub fn iterate(self: *StringLiteral, index: usize) ?*Node {
@ -1985,7 +1988,7 @@ pub const Node = struct {
};
pub const MultilineStringLiteral = struct {
base: Node = Node {.id = .MultilineStringLiteral},
base: Node = Node{ .id = .MultilineStringLiteral },
lines: LineList,
pub const LineList = SegmentedList(TokenIndex, 4);
@ -2004,7 +2007,7 @@ pub const Node = struct {
};
pub const CharLiteral = struct {
base: Node = Node {.id = .CharLiteral},
base: Node = Node{ .id = .CharLiteral },
token: TokenIndex,
pub fn iterate(self: *CharLiteral, index: usize) ?*Node {
@ -2021,7 +2024,7 @@ pub const Node = struct {
};
pub const BoolLiteral = struct {
base: Node = Node {.id = .BoolLiteral},
base: Node = Node{ .id = .BoolLiteral },
token: TokenIndex,
pub fn iterate(self: *BoolLiteral, index: usize) ?*Node {
@ -2038,7 +2041,7 @@ pub const Node = struct {
};
pub const NullLiteral = struct {
base: Node = Node {.id = .NullLiteral},
base: Node = Node{ .id = .NullLiteral },
token: TokenIndex,
pub fn iterate(self: *NullLiteral, index: usize) ?*Node {
@ -2055,7 +2058,7 @@ pub const Node = struct {
};
pub const UndefinedLiteral = struct {
base: Node = Node {.id = .UndefinedLiteral},
base: Node = Node{ .id = .UndefinedLiteral },
token: TokenIndex,
pub fn iterate(self: *UndefinedLiteral, index: usize) ?*Node {
@ -2072,7 +2075,7 @@ pub const Node = struct {
};
pub const AsmOutput = struct {
base: Node = Node {.id = .AsmOutput},
base: Node = Node{ .id = .AsmOutput },
lbracket: TokenIndex,
symbolic_name: *Node,
constraint: *Node,
@ -2117,7 +2120,7 @@ pub const Node = struct {
};
pub const AsmInput = struct {
base: Node = Node {.id = .AsmInput},
base: Node = Node{ .id = .AsmInput },
lbracket: TokenIndex,
symbolic_name: *Node,
constraint: *Node,
@ -2149,7 +2152,7 @@ pub const Node = struct {
};
pub const Asm = struct {
base: Node = Node {.id = .Asm},
base: Node = Node{ .id = .Asm },
asm_token: TokenIndex,
volatile_token: ?TokenIndex,
template: *Node,
@ -2184,7 +2187,7 @@ pub const Node = struct {
};
pub const Unreachable = struct {
base: Node = Node {.id = .Unreachable},
base: Node = Node{ .id = .Unreachable },
token: TokenIndex,
pub fn iterate(self: *Unreachable, index: usize) ?*Node {
@ -2201,7 +2204,7 @@ pub const Node = struct {
};
pub const ErrorType = struct {
base: Node = Node {.id = .ErrorType},
base: Node = Node{ .id = .ErrorType },
token: TokenIndex,
pub fn iterate(self: *ErrorType, index: usize) ?*Node {
@ -2235,7 +2238,7 @@ pub const Node = struct {
};
pub const DocComment = struct {
base: Node = Node {.id = .DocComment},
base: Node = Node{ .id = .DocComment },
lines: LineList,
pub const LineList = SegmentedList(TokenIndex, 4);
@ -2254,7 +2257,7 @@ pub const Node = struct {
};
pub const TestDecl = struct {
base: Node = Node {.id = .TestDecl},
base: Node = Node{ .id = .TestDecl },
doc_comments: ?*DocComment,
test_token: TokenIndex,
name: *Node,

2
lib/std/zig/render.zig
View File

@ -643,7 +643,7 @@ fn renderExpression(
},
.ArrayAccess => |index_expr| {
const lbracket = tree.prevToken(index_expr.firstToken());
const lbracket = tree.nextToken(suffix_op.lhs.node.lastToken());
const rbracket = tree.nextToken(index_expr.lastToken());
try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs.node, Space.None);

287
src-self-hosted/c_tokenizer.zig
View File

@ -8,7 +8,7 @@ pub const TokenList = std.SegmentedList(CToken, 32);
pub const CToken = struct {
id: Id,
bytes: []const u8,
bytes: []const u8 = "",
num_lit_suffix: NumLitSuffix = .None,
pub const Id = enum {
@ -17,20 +17,33 @@ pub const CToken = struct {
NumLitInt,
NumLitFloat,
Identifier,
Plus,
Minus,
Slash,
LParen,
RParen,
Eof,
Dot,
Asterisk,
Bang,
Tilde,
Shl,
Lt,
Asterisk, // *
Ampersand, // &
And, // &&
Assign, // =
Or, // ||
Bang, // !
Tilde, // ~
Shl, // <<
Shr, // >>
Lt, // <
Lte, // <=
Gt, // >
Gte, // >=
Eq, // ==
Ne, // !=
Increment, // ++
Decrement, // --
Comma,
Fn,
Arrow,
Arrow, // ->
LBrace,
RBrace,
Pipe,
@ -225,7 +238,14 @@ fn zigifyEscapeSequences(ctx: *Context, loc: ZigClangSourceLocation, name: []con
fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:0]const u8, i: *usize) !CToken {
var state: enum {
Start,
GotLt,
SawLt,
SawGt,
SawPlus,
SawMinus,
SawAmpersand,
SawPipe,
SawBang,
SawEq,
CharLit,
OpenComment,
Comment,
@ -235,7 +255,7 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
Identifier,
Decimal,
Octal,
GotZero,
SawZero,
Hex,
Bin,
Float,
@ -246,7 +266,6 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
NumLitIntSuffixL,
NumLitIntSuffixLL,
NumLitIntSuffixUL,
Minus,
Done,
} = .Start;
@ -267,7 +286,7 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
.Hex,
.Bin,
.Octal,
.GotZero,
.SawZero,
.Float,
.FloatExp,
=> {
@ -275,13 +294,19 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
return result;
},
.Start,
.Minus,
.SawMinus,
.Done,
.NumLitIntSuffixU,
.NumLitIntSuffixL,
.NumLitIntSuffixUL,
.NumLitIntSuffixLL,
.GotLt,
.SawLt,
.SawGt,
.SawPlus,
.SawAmpersand,
.SawPipe,
.SawBang,
.SawEq,
=> {
return result;
},
@ -333,7 +358,7 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
begin_index = i.*;
},
'0' => {
state = .GotZero;
state = .SawZero;
result.id = .NumLitInt;
begin_index = i.*;
},
@ -343,7 +368,11 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
},
'<' => {
result.id = .Lt;
state = .GotLt;
state = .SawLt;
},
'>' => {
result.id = .Gt;
state = .SawGt;
},
'(' => {
result.id = .LParen;
@ -357,18 +386,26 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
result.id = .Asterisk;
state = .Done;
},
'+' => {
result.id = .Plus;
state = .SawPlus;
},
'-' => {
state = .Minus;
result.id = .Minus;
state = .SawMinus;
},
'!' => {
result.id = .Bang;
state = .Done;
state = .SawBang;
},
'~' => {
result.id = .Tilde;
state = .Done;
},
'=' => {
result.id = .Assign;
state = .SawEq;
},
',' => {
result.id = .Comma;
state = .Done;
@ -383,7 +420,11 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
},
'|' => {
result.id = .Pipe;
state = .Done;
state = .SawPipe;
},
'&' => {
result.id = .Ampersand;
state = .SawAmpersand;
},
'?' => {
result.id = .QuestionMark;
@ -400,26 +441,88 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
}
},
.Done => return result,
.Minus => {
.SawMinus => {
switch (c) {
'>' => {
result.id = .Arrow;
state = .Done;
},
else => {
return result;
'-' => {
result.id = .Decrement;
state = .Done;
},
else => return result,
}
},
.GotLt => {
.SawPlus => {
switch (c) {
'+' => {
result.id = .Increment;
state = .Done;
},
else => return result,
}
},
.SawLt => {
switch (c) {
'<' => {
result.id = .Shl;
state = .Done;
},
else => {
return result;
'=' => {
result.id = .Lte;
state = .Done;
},
else => return result,
}
},
.SawGt => {
switch (c) {
'>' => {
result.id = .Shr;
state = .Done;
},
'=' => {
result.id = .Gte;
state = .Done;
},
else => return result,
}
},
.SawPipe => {
switch (c) {
'|' => {
result.id = .Or;
state = .Done;
},
else => return result,
}
},
.SawAmpersand => {
switch (c) {
'&' => {
result.id = .And;
state = .Done;
},
else => return result,
}
},
.SawBang => {
switch (c) {
'=' => {
result.id = .Ne;
state = .Done;
},
else => return result,
}
},
.SawEq => {
switch (c) {
'=' => {
result.id = .Eq;
state = .Done;
},
else => return result,
}
},
.Float => {
@ -454,7 +557,7 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
'0'...'9' => {
state = .FloatExp;
},
else => {
else => {
try failDecl(ctx, loc, name, "macro tokenizing failed: expected a digit or '+' or '-'", .{});
return error.TokenizingFailed;
},
@ -514,7 +617,7 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
},
}
},
.GotZero => {
.SawZero => {
switch (c) {
'x', 'X' => {
state = .Hex;
@ -726,76 +829,114 @@ fn next(ctx: *Context, loc: ZigClangSourceLocation, name: []const u8, chars: [*:
unreachable;
}
fn expectTokens(tl: *TokenList, src: [*:0]const u8, expected: []CToken) void {
// these can be undefined since they are only used for error reporting
tokenizeCMacro(undefined, undefined, undefined, tl, src) catch unreachable;
var it = tl.iterator(0);
for (expected) |t| {
var tok = it.next().?;
std.testing.expectEqual(t.id, tok.id);
if (t.bytes.len > 0) {
//std.debug.warn(" {} = {}\n", .{tok.bytes, t.bytes});
std.testing.expectEqualSlices(u8, tok.bytes, t.bytes);
}
if (t.num_lit_suffix != .None) {
std.testing.expectEqual(t.num_lit_suffix, tok.num_lit_suffix);
}
}
std.testing.expect(it.next() == null);
tl.shrink(0);
}
test "tokenize macro" {
var tl = TokenList.init(std.heap.page_allocator);
defer tl.deinit();
const src = "TEST(0\n";
try tokenizeCMacro(&tl, src);
var it = tl.iterator(0);
expect(it.next().?.id == .Identifier);
expect(it.next().?.id == .Fn);
expect(it.next().?.id == .LParen);
expect(std.mem.eql(u8, it.next().?.bytes, "0"));
expect(it.next().?.id == .Eof);
expect(it.next() == null);
tl.shrink(0);
expectTokens(&tl, "TEST(0\n", &[_]CToken{
.{ .id = .Identifier, .bytes = "TEST" },
.{ .id = .Fn },
.{ .id = .LParen },
.{ .id = .NumLitInt, .bytes = "0" },
.{ .id = .Eof },
});
const src2 = "__FLT_MIN_10_EXP__ -37\n";
try tokenizeCMacro(&tl, src2);
it = tl.iterator(0);
expect(std.mem.eql(u8, it.next().?.bytes, "__FLT_MIN_10_EXP__"));
expect(it.next().?.id == .Minus);
expect(std.mem.eql(u8, it.next().?.bytes, "37"));
expect(it.next().?.id == .Eof);
expect(it.next() == null);
tl.shrink(0);
expectTokens(&tl, "__FLT_MIN_10_EXP__ -37\n", &[_]CToken{
.{ .id = .Identifier, .bytes = "__FLT_MIN_10_EXP__" },
.{ .id = .Minus },
.{ .id = .NumLitInt, .bytes = "37" },
.{ .id = .Eof },
});
const src3 = "__llvm__ 1\n#define";
try tokenizeCMacro(&tl, src3);
it = tl.iterator(0);
expect(std.mem.eql(u8, it.next().?.bytes, "__llvm__"));
expect(std.mem.eql(u8, it.next().?.bytes, "1"));
expect(it.next().?.id == .Eof);
expect(it.next() == null);
tl.shrink(0);
expectTokens(&tl, "__llvm__ 1\n#define", &[_]CToken{
.{ .id = .Identifier, .bytes = "__llvm__" },
.{ .id = .NumLitInt, .bytes = "1" },
.{ .id = .Eof },
});
const src4 = "TEST 2";
try tokenizeCMacro(&tl, src4);
it = tl.iterator(0);
expect(it.next().?.id == .Identifier);
expect(std.mem.eql(u8, it.next().?.bytes, "2"));
expect(it.next().?.id == .Eof);
expect(it.next() == null);
tl.shrink(0);
expectTokens(&tl, "TEST 2", &[_]CToken{
.{ .id = .Identifier, .bytes = "TEST" },
.{ .id = .NumLitInt, .bytes = "2" },
.{ .id = .Eof },
});
const src5 = "FOO 0ull";
try tokenizeCMacro(&tl, src5);
it = tl.iterator(0);
expect(it.next().?.id == .Identifier);
expect(std.mem.eql(u8, it.next().?.bytes, "0"));
expect(it.next().?.id == .Eof);
expect(it.next() == null);
tl.shrink(0);
expectTokens(&tl, "FOO 0ull", &[_]CToken{
.{ .id = .Identifier, .bytes = "FOO" },
.{ .id = .NumLitInt, .bytes = "0", .num_lit_suffix = .LLU },
.{ .id = .Eof },
});
}
test "tokenize macro ops" {
var tl = TokenList.init(std.heap.page_allocator);
defer tl.deinit();
expectTokens(&tl, "ADD A + B", &[_]CToken{
.{ .id = .Identifier, .bytes = "ADD" },
.{ .id = .Identifier, .bytes = "A" },
.{ .id = .Plus },
.{ .id = .Identifier, .bytes = "B" },
.{ .id = .Eof },
});
expectTokens(&tl, "ADD (A) + B", &[_]CToken{
.{ .id = .Identifier, .bytes = "ADD" },
.{ .id = .LParen },
.{ .id = .Identifier, .bytes = "A" },
.{ .id = .RParen },
.{ .id = .Plus },
.{ .id = .Identifier, .bytes = "B" },
.{ .id = .Eof },
});
expectTokens(&tl, "ADD (A) + B", &[_]CToken{
.{ .id = .Identifier, .bytes = "ADD" },
.{ .id = .LParen },
.{ .id = .Identifier, .bytes = "A" },
.{ .id = .RParen },
.{ .id = .Plus },
.{ .id = .Identifier, .bytes = "B" },
.{ .id = .Eof },
});
}
test "escape sequences" {
var buf: [1024]u8 = undefined;
var alloc = std.heap.FixedBufferAllocator.init(buf[0..]);
const a = &alloc.allocator;
expect(std.mem.eql(u8, (try zigifyEscapeSequences(a, .{
// these can be undefined since they are only used for error reporting
expect(std.mem.eql(u8, (try zigifyEscapeSequences(undefined, undefined, undefined, a, .{
.id = .StrLit,
.bytes = "\\x0077",
})).bytes, "\\x77"));
expect(std.mem.eql(u8, (try zigifyEscapeSequences(a, .{
expect(std.mem.eql(u8, (try zigifyEscapeSequences(undefined, undefined, undefined, a, .{
.id = .StrLit,
.bytes = "\\24500",
})).bytes, "\\xa500"));
expect(std.mem.eql(u8, (try zigifyEscapeSequences(a, .{
expect(std.mem.eql(u8, (try zigifyEscapeSequences(undefined, undefined, undefined, a, .{
.id = .StrLit,
.bytes = "\\x0077 abc",
})).bytes, "\\x77 abc"));
expect(std.mem.eql(u8, (try zigifyEscapeSequences(a, .{
expect(std.mem.eql(u8, (try zigifyEscapeSequences(undefined, undefined, undefined, a, .{
.id = .StrLit,
.bytes = "\\045abc",
})).bytes, "\\x25abc"));

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

@ -43,6 +43,7 @@ pub const struct_ZigClangImplicitCastExpr = @OpaqueType();
pub const struct_ZigClangIncompleteArrayType = @OpaqueType();
pub const struct_ZigClangIntegerLiteral = @OpaqueType();
pub const struct_ZigClangMacroDefinitionRecord = @OpaqueType();
pub const struct_ZigClangMacroExpansion = @OpaqueType();
pub const struct_ZigClangMacroQualifiedType = @OpaqueType();
pub const struct_ZigClangMemberExpr = @OpaqueType();
pub const struct_ZigClangNamedDecl = @OpaqueType();
@ -889,6 +890,7 @@ pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr;
pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType;
pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral;
pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord;
pub const ZigClangMacroExpansion = struct_ZigClangMacroExpansion;
pub const ZigClangMacroQualifiedType = struct_ZigClangMacroQualifiedType;
pub const ZigClangMemberExpr = struct_ZigClangMemberExpr;
pub const ZigClangNamedDecl = struct_ZigClangNamedDecl;
@ -1058,6 +1060,8 @@ pub extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const ZigClang
pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
pub extern fn ZigClangMacroExpansion_getDefinition(*const ZigClangMacroExpansion) *const ZigClangMacroDefinitionRecord;
pub extern fn ZigClangIfStmt_getThen(*const ZigClangIfStmt) *const ZigClangStmt;
pub extern fn ZigClangIfStmt_getElse(*const ZigClangIfStmt) ?*const ZigClangStmt;
pub extern fn ZigClangIfStmt_getCond(*const ZigClangIfStmt) *const ZigClangStmt;

10
src-self-hosted/link.zig
View File

@ -119,11 +119,11 @@ fn linkDiagCallbackErrorable(ctx: *Context, msg: []const u8) !void {
fn toExternObjectFormatType(ofmt: ObjectFormat) c.ZigLLVM_ObjectFormatType {
return switch (ofmt) {
.unknown => c.ZigLLVM_UnknownObjectFormat,
.coff => c.ZigLLVM_COFF,
.elf => c.ZigLLVM_ELF,
.macho => c.ZigLLVM_MachO,
.wasm => c.ZigLLVM_Wasm,
.unknown => .ZigLLVM_UnknownObjectFormat,
.coff => .ZigLLVM_COFF,
.elf => .ZigLLVM_ELF,
.macho => .ZigLLVM_MachO,
.wasm => .ZigLLVM_Wasm,
};
}

44
src-self-hosted/llvm.zig
View File

@ -226,24 +226,24 @@ pub const PrintMessageAction = VerifierFailureAction.LLVMPrintMessageAction;
pub const ReturnStatusAction = VerifierFailureAction.LLVMReturnStatusAction;
pub const VerifierFailureAction = c.LLVMVerifierFailureAction;
pub const CodeGenLevelNone = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelNone;
pub const CodeGenLevelLess = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelLess;
pub const CodeGenLevelDefault = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelDefault;
pub const CodeGenLevelAggressive = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelAggressive;
pub const CodeGenLevelNone = CodeGenOptLevel.LLVMCodeGenLevelNone;
pub const CodeGenLevelLess = CodeGenOptLevel.LLVMCodeGenLevelLess;
pub const CodeGenLevelDefault = CodeGenOptLevel.LLVMCodeGenLevelDefault;
pub const CodeGenLevelAggressive = CodeGenOptLevel.LLVMCodeGenLevelAggressive;
pub const CodeGenOptLevel = c.LLVMCodeGenOptLevel;
pub const RelocDefault = c.LLVMRelocMode.LLVMRelocDefault;
pub const RelocStatic = c.LLVMRelocMode.LLVMRelocStatic;
pub const RelocPIC = c.LLVMRelocMode.LLVMRelocPIC;
pub const RelocDynamicNoPic = c.LLVMRelocMode.LLVMRelocDynamicNoPic;
pub const RelocDefault = RelocMode.LLVMRelocDefault;
pub const RelocStatic = RelocMode.LLVMRelocStatic;
pub const RelocPIC = RelocMode.LLVMRelocPIC;
pub const RelocDynamicNoPic = RelocMode.LLVMRelocDynamicNoPic;
pub const RelocMode = c.LLVMRelocMode;
pub const CodeModelDefault = c.LLVMCodeModel.LLVMCodeModelDefault;
pub const CodeModelJITDefault = c.LLVMCodeModel.LLVMCodeModelJITDefault;
pub const CodeModelSmall = c.LLVMCodeModel.LLVMCodeModelSmall;
pub const CodeModelKernel = c.LLVMCodeModel.LLVMCodeModelKernel;
pub const CodeModelMedium = c.LLVMCodeModel.LLVMCodeModelMedium;
pub const CodeModelLarge = c.LLVMCodeModel.LLVMCodeModelLarge;
pub const CodeModelDefault = CodeModel.LLVMCodeModelDefault;
pub const CodeModelJITDefault = CodeModel.LLVMCodeModelJITDefault;
pub const CodeModelSmall = CodeModel.LLVMCodeModelSmall;
pub const CodeModelKernel = CodeModel.LLVMCodeModelKernel;
pub const CodeModelMedium = CodeModel.LLVMCodeModelMedium;
pub const CodeModelLarge = CodeModel.LLVMCodeModelLarge;
pub const CodeModel = c.LLVMCodeModel;
pub const EmitAssembly = EmitOutputType.ZigLLVM_EmitAssembly;
@ -251,13 +251,13 @@ pub const EmitBinary = EmitOutputType.ZigLLVM_EmitBinary;
pub const EmitLLVMIr = EmitOutputType.ZigLLVM_EmitLLVMIr;
pub const EmitOutputType = c.ZigLLVM_EmitOutputType;
pub const CCallConv = c.LLVMCCallConv;
pub const FastCallConv = c.LLVMFastCallConv;
pub const ColdCallConv = c.LLVMColdCallConv;
pub const WebKitJSCallConv = c.LLVMWebKitJSCallConv;
pub const AnyRegCallConv = c.LLVMAnyRegCallConv;
pub const X86StdcallCallConv = c.LLVMX86StdcallCallConv;
pub const X86FastcallCallConv = c.LLVMX86FastcallCallConv;
pub const CCallConv = CallConv.LLVMCCallConv;
pub const FastCallConv = CallConv.LLVMFastCallConv;
pub const ColdCallConv = CallConv.LLVMColdCallConv;
pub const WebKitJSCallConv = CallConv.LLVMWebKitJSCallConv;
pub const AnyRegCallConv = CallConv.LLVMAnyRegCallConv;
pub const X86StdcallCallConv = CallConv.LLVMX86StdcallCallConv;
pub const X86FastcallCallConv = CallConv.LLVMX86FastcallCallConv;
pub const CallConv = c.LLVMCallConv;
pub const CallAttr = extern enum {
@ -288,6 +288,6 @@ extern fn ZigLLVMTargetMachineEmitToFile(
) bool;
pub const BuildCall = ZigLLVMBuildCall;
extern fn ZigLLVMBuildCall(B: *Builder, Fn: *Value, Args: [*]*Value, NumArgs: c_uint, CC: c_uint, fn_inline: CallAttr, Name: [*:0]const u8) ?*Value;
extern fn ZigLLVMBuildCall(B: *Builder, Fn: *Value, Args: [*]*Value, NumArgs: c_uint, CC: CallConv, fn_inline: CallAttr, Name: [*:0]const u8) ?*Value;
pub const PrivateLinkage = c.LLVMLinkage.LLVMPrivateLinkage;

2
src-self-hosted/stage1.zig
View File

@ -95,7 +95,7 @@ export fn stage2_translate_c(
args_end: [*]?[*]const u8,
resources_path: [*:0]const u8,
) Error {
var errors: []translate_c.ClangErrMsg = undefined;
var errors = @as([*]translate_c.ClangErrMsg, undefined)[0..0];
out_ast.* = translate_c.translate(std.heap.c_allocator, args_begin, args_end, &errors, resources_path) catch |err| switch (err) {
error.SemanticAnalyzeFail => {
out_errors_ptr.* = errors.ptr;

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

@ -249,6 +249,7 @@ pub fn translate(
.arena_allocator = tree_arena,
.tokens = undefined, // can't reference the allocator yet
.errors = undefined, // can't reference the allocator yet
.generated = true,
};
break :blk tree;
};
@ -409,11 +410,17 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
const param_name = tokenSlice(c, param.name_token orelse
return failDecl(c, fn_decl_loc, fn_name, "function {} parameter has no name", .{fn_name}));
const checked_param_name = if (try scope.createAlias(rp.c, param_name)) |a| blk: {
try block_scope.variables.push(.{ .name = param_name, .alias = a });
break :blk a;
} else param_name;
const arg_name = try std.fmt.allocPrint(c.a(), "_arg_{}", .{checked_param_name});
// in Zig top level declarations are order-independent so this might be shadowed later
const checked_param_name = try std.fmt.allocPrint(c.a(), "{}_{}", .{ param_name, c.getMangle() });
try block_scope.variables.push(.{ .name = param_name, .alias = checked_param_name });
const arg_name = blk: {
const bare_arg_name = try std.fmt.allocPrint(c.a(), "_arg_{}", .{checked_param_name});
break :blk if (try scope.createAlias(rp.c, bare_arg_name)) |a|
a
else
bare_arg_name;
};
const node = try transCreateNodeVarDecl(c, false, false, checked_param_name);
node.eq_token = try appendToken(c, .Equal, "=");
@ -532,49 +539,53 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl) Error
const typedef_name = try c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, typedef_decl)));
if (mem.eql(u8, typedef_name, "uint8_t"))
// TODO https://github.com/ziglang/zig/issues/3756
// TODO https://github.com/ziglang/zig/issues/1802
const checked_name = if (isZigPrimitiveType(typedef_name)) try std.fmt.allocPrint(c.a(), "_{}", .{typedef_name}) else typedef_name;
if (mem.eql(u8, checked_name, "uint8_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "u8")
else if (mem.eql(u8, typedef_name, "int8_t"))
else if (mem.eql(u8, checked_name, "int8_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "i8")
else if (mem.eql(u8, typedef_name, "uint16_t"))
else if (mem.eql(u8, checked_name, "uint16_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "u16")
else if (mem.eql(u8, typedef_name, "int16_t"))
else if (mem.eql(u8, checked_name, "int16_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "i16")
else if (mem.eql(u8, typedef_name, "uint32_t"))
else if (mem.eql(u8, checked_name, "uint32_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "u32")
else if (mem.eql(u8, typedef_name, "int32_t"))
else if (mem.eql(u8, checked_name, "int32_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "i32")
else if (mem.eql(u8, typedef_name, "uint64_t"))
else if (mem.eql(u8, checked_name, "uint64_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "u64")
else if (mem.eql(u8, typedef_name, "int64_t"))
else if (mem.eql(u8, checked_name, "int64_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "i64")
else if (mem.eql(u8, typedef_name, "intptr_t"))
else if (mem.eql(u8, checked_name, "intptr_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "isize")
else if (mem.eql(u8, typedef_name, "uintptr_t"))
else if (mem.eql(u8, checked_name, "uintptr_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "usize")
else if (mem.eql(u8, typedef_name, "ssize_t"))
else if (mem.eql(u8, checked_name, "ssize_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "isize")
else if (mem.eql(u8, typedef_name, "size_t"))
else if (mem.eql(u8, checked_name, "size_t"))
return transTypeDefAsBuiltin(c, typedef_decl, "usize");
_ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), typedef_name);
_ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), checked_name);
const visib_tok = try appendToken(c, .Keyword_pub, "pub");
const const_tok = try appendToken(c, .Keyword_const, "const");
const node = try transCreateNodeVarDecl(c, true, true, typedef_name);
const node = try transCreateNodeVarDecl(c, true, true, checked_name);
node.eq_token = try appendToken(c, .Equal, "=");
const child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
const typedef_loc = ZigClangTypedefNameDecl_getLocation(typedef_decl);
node.init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) {
error.UnsupportedType => {
try failDecl(c, typedef_loc, typedef_name, "unable to resolve typedef child type", .{});
try failDecl(c, typedef_loc, checked_name, "unable to resolve typedef child type", .{});
return null;
},
error.OutOfMemory => |e| return e,
};
node.semicolon_token = try appendToken(c, .Semicolon, ";");
try addTopLevelDecl(c, typedef_name, &node.base);
return transCreateNodeIdentifier(c, typedef_name);
try addTopLevelDecl(c, checked_name, &node.base);
return transCreateNodeIdentifier(c, checked_name);
}
fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*ast.Node {
@ -842,15 +853,15 @@ fn transStmt(
.ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const ZigClangReturnStmt, stmt)),
.StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used),
.ParenExprClass => {
const expr = try transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), result_used, lrvalue);
if (expr.id == .GroupedExpression) return expr;
const expr = try transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), .used, lrvalue);
if (expr.id == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
const node = try rp.c.a().create(ast.Node.GroupedExpression);
node.* = .{
.lparen = try appendToken(rp.c, .LParen, "("),
.expr = expr,
.rparen = try appendToken(rp.c, .RParen, ")"),
};
return &node.base;
return maybeSuppressResult(rp, scope, result_used, &node.base);
},
.InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const ZigClangInitListExpr, stmt), result_used),
.ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used),
@ -1193,7 +1204,7 @@ fn transImplicitCastExpr(
const dest_type = getExprQualType(c, @ptrCast(*const ZigClangExpr, expr));
const src_type = getExprQualType(c, sub_expr);
switch (ZigClangImplicitCastExpr_getCastKind(expr)) {
.BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast => {
.BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => {
return transCCast(rp, scope, ZigClangImplicitCastExpr_getBeginLoc(expr), dest_type, src_type, sub_expr_node);
},
.LValueToRValue, .NoOp, .FunctionToPointerDecay, .ArrayToPointerDecay => {
@ -1220,29 +1231,6 @@ fn transImplicitCastExpr(
const rhs_node = try transCreateNodeInt(rp.c, 0);
return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, result_used, false);
},
.PointerToIntegral => {
// @intCast(dest_type, @ptrToInt(val))
const cast_node = try transCreateNodeBuiltinFnCall(rp.c, "@intCast");
try cast_node.params.push(try transQualType(rp, dest_type, ZigClangImplicitCastExpr_getBeginLoc(expr)));
_ = try appendToken(rp.c, .Comma, ",");
const ptr_to_int = try transCreateNodeBuiltinFnCall(rp.c, "@ptrToInt");
try ptr_to_int.params.push(try transExpr(rp, scope, sub_expr, .used, .r_value));
ptr_to_int.rparen_token = try appendToken(rp.c, .RParen, ")");
try cast_node.params.push(&ptr_to_int.base);
cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
return maybeSuppressResult(rp, scope, result_used, &cast_node.base);
},
.IntegralToPointer => {
// @intToPtr(dest_type, val)
const int_to_ptr = try transCreateNodeBuiltinFnCall(rp.c, "@intToPtr");
try int_to_ptr.params.push(try transQualType(rp, dest_type, ZigClangImplicitCastExpr_getBeginLoc(expr)));
_ = try appendToken(rp.c, .Comma, ",");
try int_to_ptr.params.push(try transExpr(rp, scope, sub_expr, .used, .r_value));
int_to_ptr.rparen_token = try appendToken(rp.c, .RParen, ")");
return maybeSuppressResult(rp, scope, result_used, &int_to_ptr.base);
},
else => |kind| return revertAndWarn(
rp,
error.UnsupportedTranslation,
@ -1508,8 +1496,18 @@ fn transCCast(
if (ZigClangQualType_eq(dst_type, src_type)) return expr;
if (qualTypeIsPtr(dst_type) and qualTypeIsPtr(src_type))
return transCPtrCast(rp, loc, dst_type, src_type, expr);
if (cIsUnsignedInteger(dst_type) and qualTypeIsPtr(src_type)) {
const cast_node = try transCreateNodeBuiltinFnCall(rp.c, "@as");
if (cIsInteger(dst_type) and cIsInteger(src_type)) {
// @intCast(dest_type, val)
const cast_node = try transCreateNodeBuiltinFnCall(rp.c, "@intCast");
try cast_node.params.push(try transQualType(rp, dst_type, loc));
_ = try appendToken(rp.c, .Comma, ",");
try cast_node.params.push(expr);
cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
return &cast_node.base;
}
if (cIsInteger(dst_type) and qualTypeIsPtr(src_type)) {
// @intCast(dest_type, @ptrToInt(val))
const cast_node = try transCreateNodeBuiltinFnCall(rp.c, "@intCast");
try cast_node.params.push(try transQualType(rp, dst_type, loc));
_ = try appendToken(rp.c, .Comma, ",");
const builtin_node = try transCreateNodeBuiltinFnCall(rp.c, "@ptrToInt");
@ -1519,7 +1517,8 @@ fn transCCast(
cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
return &cast_node.base;
}
if (cIsUnsignedInteger(src_type) and qualTypeIsPtr(dst_type)) {
if (cIsInteger(src_type) and qualTypeIsPtr(dst_type)) {
// @intToPtr(dest_type, val)
const builtin_node = try transCreateNodeBuiltinFnCall(rp.c, "@intToPtr");
try builtin_node.params.push(try transQualType(rp, dst_type, loc));
_ = try appendToken(rp.c, .Comma, ",");
@ -1793,7 +1792,10 @@ fn transDoWhileLoop(
// zig: b;
// zig: if (!cond) break;
// zig: }
break :blk (try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value)).cast(ast.Node.Block).?;
const body = (try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value)).cast(ast.Node.Block).?;
// if this is used as an expression in Zig it needs to be immediately followed by a semicolon
_ = try appendToken(rp.c, .Semicolon, ";");
break :blk body;
} else blk: {
// the C statement is without a block, so we need to create a block to contain it.
// c: do
@ -2096,6 +2098,9 @@ fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangMemberE
}
const name = try rp.c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, ZigClangMemberExpr_getMemberDecl(stmt))));
if (name.len == 0) {
return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO access of anonymous field", .{});
}
const node = try transCreateNodeFieldAccess(rp.c, container_node, name);
return maybeSuppressResult(rp, scope, result_used, node);
}
@ -2869,6 +2874,10 @@ fn typeIsOpaque(c: *Context, ty: *const ZigClangType, loc: ZigClangSourceLocatio
}
}
fn cIsInteger(qt: ZigClangQualType) bool {
return cIsSignedInteger(qt) or cIsUnsignedInteger(qt);
}
fn cIsUnsignedInteger(qt: ZigClangQualType) bool {
const c_type = qualTypeCanon(qt);
if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
@ -4234,7 +4243,7 @@ fn transMacroFnDefine(c: *Context, it: *ctok.TokenList.Iterator, name: []const u
_ = try appendToken(c, .RParen, ")");
const type_of = try transCreateNodeBuiltinFnCall(c, "@TypeOf");
type_of.rparen_token = try appendToken(c, .LParen, ")");
type_of.rparen_token = try appendToken(c, .RParen, ")");
const fn_proto = try c.a().create(ast.Node.FnProto);
fn_proto.* = .{
@ -4279,7 +4288,33 @@ fn transMacroFnDefine(c: *Context, it: *ctok.TokenList.Iterator, name: []const u
const ParseError = Error || error{ParseError};
fn parseCExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: ZigClangSourceLocation, scope: *Scope) ParseError!*ast.Node {
return parseCPrefixOpExpr(c, it, source_loc, scope);
const node = try parseCPrefixOpExpr(c, it, source_loc, scope);
switch (it.next().?.id) {
.QuestionMark => {
// must come immediately after expr
_ = try appendToken(c, .RParen, ")");
const if_node = try transCreateNodeIf(c);
if_node.condition = node;
if_node.body = try parseCPrimaryExpr(c, it, source_loc, scope);
if (it.next().?.id != .Colon) {
try failDecl(
c,
source_loc,
it.list.at(0).*.bytes,
"unable to translate C expr: expected ':'",
.{},
);
return error.ParseError;
}
if_node.@"else" = try transCreateNodeElse(c);
if_node.@"else".?.body = try parseCPrimaryExpr(c, it, source_loc, scope);
return &if_node.base;
},
else => {
_ = it.prev();
return node;
},
}
}
fn parseCNumLit(c: *Context, tok: *CToken, source_loc: ZigClangSourceLocation) ParseError!*ast.Node {
@ -4391,8 +4426,8 @@ fn parseCPrimaryExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: ZigC
const type_of_1 = try transCreateNodeBuiltinFnCall(c, "@TypeOf");
try type_id_1.params.push(&type_of_1.base);
try type_of_1.params.push(node_to_cast);
type_of_1.rparen_token = try appendToken(c, .LParen, ")");
type_id_1.rparen_token = try appendToken(c, .LParen, ")");
type_of_1.rparen_token = try appendToken(c, .RParen, ")");
type_id_1.rparen_token = try appendToken(c, .RParen, ")");
const cmp_1 = try c.a().create(ast.Node.InfixOp);
cmp_1.* = .{
@ -4402,12 +4437,12 @@ fn parseCPrimaryExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: ZigC
.rhs = try transCreateNodeEnumLiteral(c, "Pointer"),
};
if_1.condition = &cmp_1.base;
_ = try appendToken(c, .LParen, ")");
_ = try appendToken(c, .RParen, ")");
const ptr_cast = try transCreateNodeBuiltinFnCall(c, "@ptrCast");
try ptr_cast.params.push(inner_node);
try ptr_cast.params.push(node_to_cast);
ptr_cast.rparen_token = try appendToken(c, .LParen, ")");
ptr_cast.rparen_token = try appendToken(c, .RParen, ")");
if_1.body = &ptr_cast.base;
const else_1 = try transCreateNodeElse(c);
@ -4418,8 +4453,8 @@ fn parseCPrimaryExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: ZigC
const type_of_2 = try transCreateNodeBuiltinFnCall(c, "@TypeOf");
try type_id_2.params.push(&type_of_2.base);
try type_of_2.params.push(node_to_cast);
type_of_2.rparen_token = try appendToken(c, .LParen, ")");
type_id_2.rparen_token = try appendToken(c, .LParen, ")");
type_of_2.rparen_token = try appendToken(c, .RParen, ")");
type_id_2.rparen_token = try appendToken(c, .RParen, ")");
const cmp_2 = try c.a().create(ast.Node.InfixOp);
cmp_2.* = .{
@ -4430,12 +4465,12 @@ fn parseCPrimaryExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: ZigC
};
if_2.condition = &cmp_2.base;
else_1.body = &if_2.base;
_ = try appendToken(c, .LParen, ")");
_ = try appendToken(c, .RParen, ")");
const int_to_ptr = try transCreateNodeBuiltinFnCall(c, "@intToPtr");
try int_to_ptr.params.push(inner_node);
try int_to_ptr.params.push(node_to_cast);
int_to_ptr.rparen_token = try appendToken(c, .LParen, ")");
int_to_ptr.rparen_token = try appendToken(c, .RParen, ")");
if_2.body = &int_to_ptr.base;
const else_2 = try transCreateNodeElse(c);
@ -4444,7 +4479,7 @@ fn parseCPrimaryExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: ZigC
const as = try transCreateNodeBuiltinFnCall(c, "@as");
try as.params.push(inner_node);
try as.params.push(node_to_cast);
as.rparen_token = try appendToken(c, .LParen, ")");
as.rparen_token = try appendToken(c, .RParen, ")");
else_2.body = &as.base;
return &if_1.base;
@ -4524,7 +4559,7 @@ fn parseCSuffixOpExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: Zig
},
.Shl => {
const op_token = try appendToken(c, .AngleBracketAngleBracketLeft, "<<");
const rhs = try parseCExpr(c, it, source_loc, scope);
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const bitshift_node = try c.a().create(ast.Node.InfixOp);
bitshift_node.* = .{
.op_token = op_token,
@ -4534,9 +4569,21 @@ fn parseCSuffixOpExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: Zig
};
node = &bitshift_node.base;
},
.Shr => {
const op_token = try appendToken(c, .AngleBracketAngleBracketRight, ">>");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const bitshift_node = try c.a().create(ast.Node.InfixOp);
bitshift_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .BitShiftRight,
.rhs = rhs,
};
node = &bitshift_node.base;
},
.Pipe => {
const op_token = try appendToken(c, .Pipe, "|");
const rhs = try parseCExpr(c, it, source_loc, scope);
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const or_node = try c.a().create(ast.Node.InfixOp);
or_node.* = .{
.op_token = op_token,
@ -4546,9 +4593,117 @@ fn parseCSuffixOpExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: Zig
};
node = &or_node.base;
},
.Ampersand => {
const op_token = try appendToken(c, .Ampersand, "&");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const bitand_node = try c.a().create(ast.Node.InfixOp);
bitand_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .BitAnd,
.rhs = rhs,
};
node = &bitand_node.base;
},
.Plus => {
const op_token = try appendToken(c, .Plus, "+");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const add_node = try c.a().create(ast.Node.InfixOp);
add_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .Add,
.rhs = rhs,
};
node = &add_node.base;
},
.Minus => {
const op_token = try appendToken(c, .Minus, "-");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const sub_node = try c.a().create(ast.Node.InfixOp);
sub_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .Sub,
.rhs = rhs,
};
node = &sub_node.base;
},
.And => {
const op_token = try appendToken(c, .Keyword_and, "and");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const and_node = try c.a().create(ast.Node.InfixOp);
and_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .BoolAnd,
.rhs = rhs,
};
node = &and_node.base;
},
.Or => {
const op_token = try appendToken(c, .Keyword_or, "or");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const or_node = try c.a().create(ast.Node.InfixOp);
or_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .BoolOr,
.rhs = rhs,
};
node = &or_node.base;
},
.Gt => {
const op_token = try appendToken(c, .AngleBracketRight, ">");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const and_node = try c.a().create(ast.Node.InfixOp);
and_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .GreaterThan,
.rhs = rhs,
};
node = &and_node.base;
},
.Gte => {
const op_token = try appendToken(c, .AngleBracketRightEqual, ">=");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const and_node = try c.a().create(ast.Node.InfixOp);
and_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .GreaterOrEqual,
.rhs = rhs,
};
node = &and_node.base;
},
.Lt => {
const op_token = try appendToken(c, .AngleBracketLeft, "<");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const and_node = try c.a().create(ast.Node.InfixOp);
and_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .LessThan,
.rhs = rhs,
};
node = &and_node.base;
},
.Lte => {
const op_token = try appendToken(c, .AngleBracketLeftEqual, "<=");
const rhs = try parseCPrefixOpExpr(c, it, source_loc, scope);
const and_node = try c.a().create(ast.Node.InfixOp);
and_node.* = .{
.op_token = op_token,
.lhs = node,
.op = .LessOrEqual,
.rhs = rhs,
};
node = &and_node.base;
},
.LBrace => {
const arr_node = try transCreateNodeArrayAccess(c, node);
arr_node.op.ArrayAccess = try parseCExpr(c, it, source_loc, scope);
arr_node.op.ArrayAccess = try parseCPrefixOpExpr(c, it, source_loc, scope);
arr_node.rtoken = try appendToken(c, .RBrace, "]");
node = &arr_node.base;
if (it.next().?.id != .RBrace) {
@ -4565,7 +4720,7 @@ fn parseCSuffixOpExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: Zig
.LParen => {
const call_node = try transCreateNodeFnCall(c, node);
while (true) {
const arg = try parseCExpr(c, it, source_loc, scope);
const arg = try parseCPrefixOpExpr(c, it, source_loc, scope);
try call_node.op.Call.params.push(arg);
const next = it.next().?;
if (next.id == .Comma)
@ -4586,26 +4741,6 @@ fn parseCSuffixOpExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: Zig
call_node.rtoken = try appendToken(c, .RParen, ")");
node = &call_node.base;
},
.QuestionMark => {
// must come immediately after expr
_ = try appendToken(c, .RParen, ")");
const if_node = try transCreateNodeIf(c);
if_node.condition = node;
if_node.body = try parseCPrimaryExpr(c, it, source_loc, scope);
if (it.next().?.id != .Colon) {
try failDecl(
c,
source_loc,
it.list.at(0).*.bytes,
"unable to translate C expr: expected ':'",
.{},
);
return error.ParseError;
}
if_node.@"else" = try transCreateNodeElse(c);
if_node.@"else".?.body = try parseCPrimaryExpr(c, it, source_loc, scope);
node = &if_node.base;
},
else => {
_ = it.prev();
return node;
@ -4646,7 +4781,11 @@ fn parseCPrefixOpExpr(c: *Context, it: *ctok.TokenList.Iterator, source_loc: Zig
fn tokenSlice(c: *Context, token: ast.TokenIndex) []u8 {
const tok = c.tree.tokens.at(token);
return c.source_buffer.toSlice()[tok.start..tok.end];
const slice = c.source_buffer.toSlice()[tok.start..tok.end];
return if (mem.startsWith(u8, slice, "@\""))
slice[2 .. slice.len - 1]
else
slice;
}
fn getContainer(c: *Context, node: *ast.Node) ?*ast.Node {

840
src/c_tokenizer.cpp
View File

@ -1,840 +0,0 @@
/*
* Copyright (c) 2016 Andrew Kelley
*
* This file is part of zig, which is MIT licensed.
* See http://opensource.org/licenses/MIT
*/
#include "c_tokenizer.hpp"
#include <inttypes.h>
#define WHITESPACE_EXCEPT_N \
' ': \
case '\t': \
case '\v': \
case '\f'
#define DIGIT_NON_ZERO \
'1': \
case '2': \
case '3': \
case '4': \
case '5': \
case '6': \
case '7': \
case '8': \
case '9'
#define DIGIT \
'0': \
case DIGIT_NON_ZERO
#define ALPHA \
'a': \
case 'b': \
case 'c': \
case 'd': \
case 'e': \
case 'f': \
case 'g': \
case 'h': \
case 'i': \
case 'j': \
case 'k': \
case 'l': \
case 'm': \
case 'n': \
case 'o': \
case 'p': \
case 'q': \
case 'r': \
case 's': \
case 't': \
case 'u': \
case 'v': \
case 'w': \
case 'x': \
case 'y': \
case 'z': \
case 'A': \
case 'B': \
case 'C': \
case 'D': \
case 'E': \
case 'F': \
case 'G': \
case 'H': \
case 'I': \
case 'J': \
case 'K': \
case 'L': \
case 'M': \
case 'N': \
case 'O': \
case 'P': \
case 'Q': \
case 'R': \
case 'S': \
case 'T': \
case 'U': \
case 'V': \
case 'W': \
case 'X': \
case 'Y': \
case 'Z'
#define IDENT_START \
ALPHA: \
case '_'
#define IDENT \
IDENT_START: \
case DIGIT
#define LINE_ENDING \
'\r': \
case '\n'
static void begin_token(CTokenize *ctok, CTokId id) {
assert(ctok->cur_tok == nullptr);
ctok->tokens.add_one();
ctok->cur_tok = &ctok->tokens.last();
ctok->cur_tok->id = id;
switch (id) {
case CTokIdStrLit:
memset(&ctok->cur_tok->data.str_lit, 0, sizeof(Buf));
buf_resize(&ctok->cur_tok->data.str_lit, 0);
break;
case CTokIdSymbol:
memset(&ctok->cur_tok->data.symbol, 0, sizeof(Buf));
buf_resize(&ctok->cur_tok->data.symbol, 0);
break;
case CTokIdNumLitInt:
ctok->cur_tok->data.num_lit_int.x = 0;
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixNone;
break;
case CTokIdCharLit:
case CTokIdNumLitFloat:
case CTokIdMinus:
case CTokIdLParen:
case CTokIdRParen:
case CTokIdEOF:
case CTokIdDot:
case CTokIdAsterisk:
case CTokIdBang:
case CTokIdTilde:
case CTokIdShl:
case CTokIdLt:
break;
}
}
static void end_token(CTokenize *ctok) {
ctok->cur_tok = nullptr;
}
static void mark_error(CTokenize *ctok) {
ctok->error = true;
}
static void add_char(CTokenize *ctok, uint8_t c) {
assert(ctok->cur_tok);
if (ctok->cur_tok->id == CTokIdCharLit) {
ctok->cur_tok->data.char_lit = c;
ctok->state = CTokStateExpectEndQuot;
} else if (ctok->cur_tok->id == CTokIdStrLit) {
buf_append_char(&ctok->cur_tok->data.str_lit, c);
ctok->state = CTokStateString;
} else {
zig_unreachable();
}
}
static void hex_digit(CTokenize *ctok, uint8_t value) {
// TODO @mul_with_overflow
ctok->cur_tok->data.num_lit_int.x *= 16;
// TODO @add_with_overflow
ctok->cur_tok->data.num_lit_int.x += value;
static const uint8_t hex_digit[] = "0123456789abcdef";
buf_append_char(&ctok->buf, hex_digit[value]);
}
static void end_float(CTokenize *ctok) {
// TODO detect errors, overflow, and underflow
double value = strtod(buf_ptr(&ctok->buf), nullptr);
ctok->cur_tok->data.num_lit_float = value;
end_token(ctok);
ctok->state = CTokStateStart;
}
void tokenize_c_macro(CTokenize *ctok, const uint8_t *c) {
ctok->tokens.resize(0);
ctok->state = CTokStateStart;
ctok->error = false;
ctok->cur_tok = nullptr;
buf_resize(&ctok->buf, 0);
for (; *c; c += 1) {
switch (ctok->state) {
case CTokStateStart:
switch (*c) {
case WHITESPACE_EXCEPT_N:
break;
case '\'':
ctok->state = CTokStateExpectChar;
begin_token(ctok, CTokIdCharLit);
break;
case '\"':
ctok->state = CTokStateString;
begin_token(ctok, CTokIdStrLit);
break;
case '/':
ctok->state = CTokStateOpenComment;
break;
case '\\':
ctok->state = CTokStateBackslash;
break;
case LINE_ENDING:
goto found_end_of_macro;
case IDENT_START:
ctok->state = CTokStateIdentifier;
begin_token(ctok, CTokIdSymbol);
buf_append_char(&ctok->cur_tok->data.symbol, *c);
break;
case DIGIT_NON_ZERO:
ctok->state = CTokStateDecimal;
begin_token(ctok, CTokIdNumLitInt);
ctok->cur_tok->data.num_lit_int.x = *c - '0';
buf_resize(&ctok->buf, 0);
buf_append_char(&ctok->buf, *c);
break;
case '0':
ctok->state = CTokStateGotZero;
begin_token(ctok, CTokIdNumLitInt);
ctok->cur_tok->data.num_lit_int.x = 0;
buf_resize(&ctok->buf, 0);
buf_append_char(&ctok->buf, '0');
break;
case '.':
begin_token(ctok, CTokIdDot);
end_token(ctok);
break;
case '<':
begin_token(ctok, CTokIdLt);
ctok->state = CTokStateGotLt;
break;
case '(':
begin_token(ctok, CTokIdLParen);
end_token(ctok);
break;
case ')':
begin_token(ctok, CTokIdRParen);
end_token(ctok);
break;
case '*':
begin_token(ctok, CTokIdAsterisk);
end_token(ctok);
break;
case '-':
begin_token(ctok, CTokIdMinus);
end_token(ctok);
break;
case '!':
begin_token(ctok, CTokIdBang);
end_token(ctok);
break;
case '~':
begin_token(ctok, CTokIdTilde);
end_token(ctok);
break;
default:
return mark_error(ctok);
}
break;
case CTokStateGotLt:
switch (*c) {
case '<':
ctok->cur_tok->id = CTokIdShl;
end_token(ctok);
ctok->state = CTokStateStart;
break;
default:
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateFloat:
switch (*c) {
case '.':
break;
case 'e':
case 'E':
buf_append_char(&ctok->buf, 'e');
ctok->state = CTokStateExpSign;
break;
case 'f':
case 'F':
case 'l':
case 'L':
end_float(ctok);
break;
case DIGIT:
buf_append_char(&ctok->buf, *c);
break;
default:
c -= 1;
end_float(ctok);
continue;
}
break;
case CTokStateExpSign:
switch (*c) {
case '+':
case '-':
ctok->state = CTokStateFloatExpFirst;
buf_append_char(&ctok->buf, *c);
break;
case DIGIT:
ctok->state = CTokStateFloatExp;
buf_append_char(&ctok->buf, *c);
break;
default:
return mark_error(ctok);
}
break;
case CTokStateFloatExpFirst:
switch (*c) {
case DIGIT:
buf_append_char(&ctok->buf, *c);
ctok->state = CTokStateFloatExp;
break;
default:
return mark_error(ctok);
}
break;
case CTokStateFloatExp:
switch (*c) {
case DIGIT:
buf_append_char(&ctok->buf, *c);
break;
case 'f':
case 'F':
case 'l':
case 'L':
end_float(ctok);
break;
default:
c -= 1;
end_float(ctok);
continue;
}
break;
case CTokStateDecimal:
switch (*c) {
case DIGIT:
buf_append_char(&ctok->buf, *c);
// TODO @mul_with_overflow
ctok->cur_tok->data.num_lit_int.x *= 10;
// TODO @add_with_overflow
ctok->cur_tok->data.num_lit_int.x += *c - '0';
break;
case '\'':
break;
case 'u':
case 'U':
ctok->state = CTokStateNumLitIntSuffixU;
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixU;
break;
case 'l':
case 'L':
ctok->state = CTokStateNumLitIntSuffixL;
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixL;
break;
case '.':
buf_append_char(&ctok->buf, '.');
ctok->cur_tok->id = CTokIdNumLitFloat;
ctok->state = CTokStateFloat;
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateGotZero:
switch (*c) {
case 'x':
case 'X':
ctok->state = CTokStateHex;
break;
case '.':
ctok->state = CTokStateFloat;
ctok->cur_tok->id = CTokIdNumLitFloat;
buf_append_char(&ctok->buf, '.');
break;
case 'l':
case 'L':
case 'u':
case 'U':
c -= 1;
ctok->state = CTokStateDecimal;
continue;
default:
c -= 1;
ctok->state = CTokStateOctal;
continue;
}
break;
case CTokStateOctal:
switch (*c) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
// TODO @mul_with_overflow
ctok->cur_tok->data.num_lit_int.x *= 8;
// TODO @add_with_overflow
ctok->cur_tok->data.num_lit_int.x += *c - '0';
break;
case '8':
case '9':
return mark_error(ctok);
case '\'':
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateHex:
switch (*c) {
case '0':
hex_digit(ctok, 0);
break;
case '1':
hex_digit(ctok, 1);
break;
case '2':
hex_digit(ctok, 2);
break;
case '3':
hex_digit(ctok, 3);
break;
case '4':
hex_digit(ctok, 4);
break;
case '5':
hex_digit(ctok, 5);
break;
case '6':
hex_digit(ctok, 6);
break;
case '7':
hex_digit(ctok, 7);
break;
case '8':
hex_digit(ctok, 8);
break;
case '9':
hex_digit(ctok, 9);
break;
case 'a':
case 'A':
hex_digit(ctok, 10);
break;
case 'b':
case 'B':
hex_digit(ctok, 11);
break;
case 'c':
case 'C':
hex_digit(ctok, 12);
break;
case 'd':
case 'D':
hex_digit(ctok, 13);
break;
case 'e':
case 'E':
hex_digit(ctok, 14);
break;
case 'f':
case 'F':
hex_digit(ctok, 15);
break;
case 'p':
case 'P':
ctok->cur_tok->id = CTokIdNumLitFloat;
ctok->state = CTokStateExpSign;
break;
case 'u':
case 'U':
// marks the number literal as unsigned
ctok->state = CTokStateNumLitIntSuffixU;
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixU;
break;
case 'l':
case 'L':
// marks the number literal as long
ctok->state = CTokStateNumLitIntSuffixL;
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixL;
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateNumLitIntSuffixU:
switch (*c) {
case 'l':
case 'L':
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixLU;
ctok->state = CTokStateNumLitIntSuffixUL;
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateNumLitIntSuffixL:
switch (*c) {
case 'l':
case 'L':
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixLL;
ctok->state = CTokStateNumLitIntSuffixLL;
break;
case 'u':
case 'U':
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixLU;
end_token(ctok);
ctok->state = CTokStateStart;
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateNumLitIntSuffixLL:
switch (*c) {
case 'u':
case 'U':
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixLLU;
end_token(ctok);
ctok->state = CTokStateStart;
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateNumLitIntSuffixUL:
switch (*c) {
case 'l':
case 'L':
ctok->cur_tok->data.num_lit_int.suffix = CNumLitSuffixLLU;
end_token(ctok);
ctok->state = CTokStateStart;
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateIdentifier:
switch (*c) {
case IDENT:
buf_append_char(&ctok->cur_tok->data.symbol, *c);
break;
default:
c -= 1;
end_token(ctok);
ctok->state = CTokStateStart;
continue;
}
break;
case CTokStateString:
switch (*c) {
case '\\':
ctok->state = CTokStateCharEscape;
break;
case '\"':
end_token(ctok);
ctok->state = CTokStateStart;
break;
default:
buf_append_char(&ctok->cur_tok->data.str_lit, *c);
}
break;
case CTokStateExpectChar:
switch (*c) {
case '\\':
ctok->state = CTokStateCharEscape;
break;
case '\'':
return mark_error(ctok);
default:
ctok->cur_tok->data.char_lit = *c;
ctok->state = CTokStateExpectEndQuot;
}
break;
case CTokStateCharEscape:
switch (*c) {
case '\'':
case '"':
case '?':
case '\\':
add_char(ctok, *c);
break;
case 'a':
add_char(ctok, '\a');
break;
case 'b':
add_char(ctok, '\b');
break;
case 'f':
add_char(ctok, '\f');
break;
case 'n':
add_char(ctok, '\n');
break;
case 'r':
add_char(ctok, '\r');
break;
case 't':
add_char(ctok, '\t');
break;
case 'v':
add_char(ctok, '\v');
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
ctok->state = CTokStateStrOctal;
ctok->cur_char = (uint8_t)(*c - '0');
ctok->octal_index = 1;
break;
case 'x':
ctok->state = CTokStateStrHex;
ctok->cur_char = 0;
break;
case 'u':
zig_panic("TODO unicode");
break;
case 'U':
zig_panic("TODO Unicode");
break;
default:
return mark_error(ctok);
}
break;
case CTokStateStrHex: {
uint8_t value = 0;
switch (*c) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
value = *c - '0';
break;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
value = (*c - 'a') + 10;
break;
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
value = (*c - 'A') + 10;
break;
default:
c -= 1;
add_char(ctok, ctok->cur_char);
continue;
}
// TODO @mul_with_overflow
if (((long)ctok->cur_char) * 16 >= 256) {
zig_panic("TODO str hex mul overflow");
}
ctok->cur_char = (uint8_t)(ctok->cur_char * (uint8_t)16);
// TODO @add_with_overflow
if (((long)ctok->cur_char) + (long)(value) >= 256) {
zig_panic("TODO str hex add overflow");
}
ctok->cur_char = (uint8_t)(ctok->cur_char + value);
break;
}
case CTokStateStrOctal:
switch (*c) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
// TODO @mul_with_overflow
if (((long)ctok->cur_char) * 8 >= 256) {
zig_panic("TODO");
}
ctok->cur_char = (uint8_t)(ctok->cur_char * (uint8_t)8);
// TODO @add_with_overflow
if (((long)ctok->cur_char) + (long)(*c - '0') >= 256) {
zig_panic("TODO");
}
ctok->cur_char = (uint8_t)(ctok->cur_char + (uint8_t)(*c - '0'));
ctok->octal_index += 1;
if (ctok->octal_index == 3) {
add_char(ctok, ctok->cur_char);
}
break;
default:
c -= 1;
add_char(ctok, ctok->cur_char);
continue;
}
break;
case CTokStateExpectEndQuot:
switch (*c) {
case '\'':
end_token(ctok);
ctok->state = CTokStateStart;
break;
default:
return mark_error(ctok);
}
break;
case CTokStateOpenComment:
switch (*c) {
case '/':
ctok->state = CTokStateLineComment;
break;
case '*':
ctok->state = CTokStateComment;
break;
default:
return mark_error(ctok);
}
break;
case CTokStateLineComment:
if (*c == '\n') {
ctok->state = CTokStateStart;
goto found_end_of_macro;
}
break;
case CTokStateComment:
switch (*c) {
case '*':
ctok->state = CTokStateCommentStar;
break;
default:
break;
}
break;
case CTokStateCommentStar:
switch (*c) {
case '/':
ctok->state = CTokStateStart;
break;
case '*':
break;
default:
ctok->state = CTokStateComment;
break;
}
break;
case CTokStateBackslash:
switch (*c) {
case '\n':
ctok->state = CTokStateStart;
break;
default:
return mark_error(ctok);
}
break;
}
}
found_end_of_macro:
switch (ctok->state) {
case CTokStateStart:
break;
case CTokStateIdentifier:
case CTokStateDecimal:
case CTokStateHex:
case CTokStateOctal:
case CTokStateGotZero:
case CTokStateNumLitIntSuffixU:
case CTokStateNumLitIntSuffixL:
case CTokStateNumLitIntSuffixUL:
case CTokStateNumLitIntSuffixLL:
case CTokStateGotLt:
end_token(ctok);
break;
case CTokStateFloat:
case CTokStateFloatExp:
end_float(ctok);
break;
case CTokStateExpectChar:
case CTokStateExpectEndQuot:
case CTokStateOpenComment:
case CTokStateLineComment:
case CTokStateComment:
case CTokStateCommentStar:
case CTokStateCharEscape:
case CTokStateBackslash:
case CTokStateString:
case CTokStateExpSign:
case CTokStateFloatExpFirst:
case CTokStateStrHex:
case CTokStateStrOctal:
return mark_error(ctok);
}
assert(ctok->cur_tok == nullptr);
begin_token(ctok, CTokIdEOF);
end_token(ctok);
}

98
src/c_tokenizer.hpp
View File

@ -1,98 +0,0 @@
/*
* Copyright (c) 2016 Andrew Kelley
*
* This file is part of zig, which is MIT licensed.
* See http://opensource.org/licenses/MIT
*/
#ifndef ZIG_C_TOKENIZER_HPP
#define ZIG_C_TOKENIZER_HPP
#include "buffer.hpp"
enum CTokId {
CTokIdCharLit,
CTokIdStrLit,
CTokIdNumLitInt,
CTokIdNumLitFloat,
CTokIdSymbol,
CTokIdMinus,
CTokIdLParen,
CTokIdRParen,
CTokIdEOF,
CTokIdDot,
CTokIdAsterisk,
CTokIdBang,
CTokIdTilde,
CTokIdShl,
CTokIdLt,
};
enum CNumLitSuffix {
CNumLitSuffixNone,
CNumLitSuffixL,
CNumLitSuffixU,
CNumLitSuffixLU,
CNumLitSuffixLL,
CNumLitSuffixLLU,
};
struct CNumLitInt {
uint64_t x;
CNumLitSuffix suffix;
};
struct CTok {
enum CTokId id;
union {
uint8_t char_lit;
Buf str_lit;
CNumLitInt num_lit_int;
double num_lit_float;
Buf symbol;
} data;
};
enum CTokState {
CTokStateStart,
CTokStateExpectChar,
CTokStateCharEscape,
CTokStateExpectEndQuot,
CTokStateOpenComment,
CTokStateLineComment,
CTokStateComment,
CTokStateCommentStar,
CTokStateBackslash,
CTokStateString,
CTokStateIdentifier,
CTokStateDecimal,
CTokStateOctal,
CTokStateGotZero,
CTokStateHex,
CTokStateFloat,
CTokStateExpSign,
CTokStateFloatExp,
CTokStateFloatExpFirst,
CTokStateStrHex,
CTokStateStrOctal,
CTokStateNumLitIntSuffixU,
CTokStateNumLitIntSuffixL,
CTokStateNumLitIntSuffixLL,
CTokStateNumLitIntSuffixUL,
CTokStateGotLt,
};
struct CTokenize {
ZigList<CTok> tokens;
CTokState state;
bool error;
CTok *cur_tok;
Buf buf;
uint8_t cur_char;
int octal_index;
};
void tokenize_c_macro(CTokenize *ctok, const uint8_t *c);
#endif

24
src/codegen.cpp
View File

@ -15,7 +15,6 @@
#include "hash_map.hpp"
#include "ir.hpp"
#include "os.hpp"
#include "translate_c.hpp"
#include "target.hpp"
#include "util.hpp"
#include "zig_llvm.h"
@ -9104,7 +9103,7 @@ void add_cc_args(CodeGen *g, ZigList<const char *> &args, const char *out_dep_pa
}
void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation) {
void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file) {
Error err;
Buf *src_basename = buf_alloc();
Buf *src_dirname = buf_alloc();
@ -9117,10 +9116,6 @@ void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_us
init(g);
TranslateMode trans_mode = buf_ends_with_str(full_path, ".h") ?
TranslateModeImport : TranslateModeTranslate;
ZigList<const char *> clang_argv = {0};
add_cc_args(g, clang_argv, nullptr, true);
@ -9140,15 +9135,9 @@ void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_us
Stage2ErrorMsg *errors_ptr;
size_t errors_len;
Stage2Ast *ast;
AstNode *root_node;
if (use_userland_implementation) {
err = stage2_translate_c(&ast, &errors_ptr, &errors_len,
&clang_argv.at(0), &clang_argv.last(), resources_path);
} else {
err = parse_h_file(g, &root_node, &errors_ptr, &errors_len, &clang_argv.at(0), &clang_argv.last(),
trans_mode, resources_path);
}
err = stage2_translate_c(&ast, &errors_ptr, &errors_len,
&clang_argv.at(0), &clang_argv.last(), resources_path);
if (err == ErrorCCompileErrors && errors_len > 0) {
for (size_t i = 0; i < errors_len; i += 1) {
@ -9172,12 +9161,7 @@ void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_us
exit(1);
}
if (use_userland_implementation) {
stage2_render_ast(ast, out_file);
} else {
ast_render(out_file, root_node, 4);
}
stage2_render_ast(ast, out_file);
}
static void update_test_functions_builtin_decl(CodeGen *g) {

2
src/codegen.hpp
View File

@ -54,7 +54,7 @@ ZigPackage *codegen_create_package(CodeGen *g, const char *root_src_dir, const c
void codegen_add_assembly(CodeGen *g, Buf *path);
void codegen_add_object(CodeGen *g, Buf *object_path);
void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_userland_implementation);
void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file);
Buf *codegen_generate_builtin_source(CodeGen *g);

9
src/ir.cpp
View File

@ -13,7 +13,6 @@
#include "os.hpp"
#include "range_set.hpp"
#include "softfloat.hpp"
#include "translate_c.hpp"
#include "util.hpp"
#include <errno.h>
@ -23758,14 +23757,14 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
clang_argv.append(nullptr); // to make the [start...end] argument work
AstNode *root_node;
Stage2ErrorMsg *errors_ptr;
size_t errors_len;
Stage2Ast *ast;
const char *resources_path = buf_ptr(ira->codegen->zig_c_headers_dir);
if ((err = parse_h_file(ira->codegen, &root_node, &errors_ptr, &errors_len,
&clang_argv.at(0), &clang_argv.last(), TranslateModeImport, resources_path)))
if ((err = stage2_translate_c(&ast, &errors_ptr, &errors_len,
&clang_argv.at(0), &clang_argv.last(), resources_path)))
{
if (err != ErrorCCompileErrors) {
ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
@ -23816,7 +23815,7 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct
buf_sprintf("C import failed: unable to open output file: %s", strerror(errno)));
return ira->codegen->invalid_instruction;
}
ast_render(out_file, root_node, 4);
stage2_render_ast(ast, out_file);
if (fclose(out_file) != 0) {
ir_add_error_node(ira, node,
buf_sprintf("C import failed: unable to write to output file: %s", strerror(errno)));

16
src/main.cpp
View File

@ -243,7 +243,6 @@ enum Cmd {
CmdTargets,
CmdTest,
CmdTranslateC,
CmdTranslateCUserland,
CmdVersion,
CmdZen,
CmdLibC,
@ -960,8 +959,6 @@ int main(int argc, char **argv) {
cmd = CmdLibC;
} else if (strcmp(arg, "translate-c") == 0) {
cmd = CmdTranslateC;
} else if (strcmp(arg, "translate-c-2") == 0) {
cmd = CmdTranslateCUserland;
} else if (strcmp(arg, "test") == 0) {
cmd = CmdTest;
out_type = OutTypeExe;
@ -978,7 +975,6 @@ int main(int argc, char **argv) {
case CmdBuild:
case CmdRun:
case CmdTranslateC:
case CmdTranslateCUserland:
case CmdTest:
case CmdLibC:
if (!in_file) {
@ -1112,7 +1108,6 @@ int main(int argc, char **argv) {
case CmdRun:
case CmdBuild:
case CmdTranslateC:
case CmdTranslateCUserland:
case CmdTest:
{
if (cmd == CmdBuild && !in_file && objects.length == 0 &&
@ -1124,7 +1119,7 @@ int main(int argc, char **argv) {
" * --object argument\n"
" * --c-source argument\n");
return print_error_usage(arg0);
} else if ((cmd == CmdTranslateC || cmd == CmdTranslateCUserland ||
} else if ((cmd == CmdTranslateC ||
cmd == CmdTest || cmd == CmdRun) && !in_file)
{
fprintf(stderr, "Expected source file argument.\n");
@ -1136,7 +1131,7 @@ int main(int argc, char **argv) {
assert(cmd != CmdBuild || out_type != OutTypeUnknown);
bool need_name = (cmd == CmdBuild || cmd == CmdTranslateC || cmd == CmdTranslateCUserland);
bool need_name = (cmd == CmdBuild || cmd == CmdTranslateC);
if (cmd == CmdRun) {
out_name = "run";
@ -1170,8 +1165,7 @@ int main(int argc, char **argv) {
return print_error_usage(arg0);
}
Buf *zig_root_source_file = (cmd == CmdTranslateC || cmd == CmdTranslateCUserland) ?
nullptr : in_file_buf;
Buf *zig_root_source_file = cmd == CmdTranslateC ? nullptr : in_file_buf;
if (cmd == CmdRun && buf_out_name == nullptr) {
buf_out_name = buf_create_from_str("run");
@ -1336,8 +1330,8 @@ int main(int argc, char **argv) {
} else {
zig_unreachable();
}
} else if (cmd == CmdTranslateC || cmd == CmdTranslateCUserland) {
codegen_translate_c(g, in_file_buf, stdout, cmd == CmdTranslateCUserland);
} else if (cmd == CmdTranslateC) {
codegen_translate_c(g, in_file_buf, stdout);
if (timing_info)
codegen_print_timing_report(g, stderr);
return main_exit(root_progress_node, EXIT_SUCCESS);

5156
src/translate_c.cpp
View File

File diff suppressed because it is too large Load Diff

24
src/translate_c.hpp
View File

@ -1,24 +0,0 @@
/*
* Copyright (c) 2015 Andrew Kelley
*
* This file is part of zig, which is MIT licensed.
* See http://opensource.org/licenses/MIT
*/
#ifndef ZIG_PARSEC_HPP
#define ZIG_PARSEC_HPP
#include "all_types.hpp"
enum TranslateMode {
TranslateModeImport,
TranslateModeTranslate,
};
Error parse_h_file(CodeGen *codegen, AstNode **out_root_node,
Stage2ErrorMsg **errors_ptr, size_t *errors_len,
const char **args_begin, const char **args_end,
TranslateMode mode, const char *resources_path);
#endif

53
test/tests.zig
View File

@ -1422,7 +1422,6 @@ pub const TranslateCContext = struct {
sources: ArrayList(SourceFile),
expected_lines: ArrayList([]const u8),
allow_warnings: bool,
stage2: bool,
const SourceFile = struct {
filename: []const u8,
@ -1475,7 +1474,7 @@ pub const TranslateCContext = struct {
var zig_args = ArrayList([]const u8).init(b.allocator);
zig_args.append(b.zig_exe) catch unreachable;
const translate_c_cmd = if (self.case.stage2) "translate-c-2" else "translate-c";
const translate_c_cmd = "translate-c";
zig_args.append(translate_c_cmd) catch unreachable;
zig_args.append(b.pathFromRoot(root_src)) catch unreachable;
@ -1583,7 +1582,6 @@ pub const TranslateCContext = struct {
.sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
.expected_lines = ArrayList([]const u8).init(self.b.allocator),
.allow_warnings = allow_warnings,
.stage2 = false,
};
tc.addSourceFile(filename, source);
@ -1604,53 +1602,6 @@ pub const TranslateCContext = struct {
self.addCase(tc);
}
pub fn addC(
self: *TranslateCContext,
name: []const u8,
source: []const u8,
expected_lines: []const []const u8,
) void {
const tc = self.create(false, "source.c", name, source, expected_lines);
self.addCase(tc);
}
pub fn add_both(
self: *TranslateCContext,
name: []const u8,
source: []const u8,
expected_lines: []const []const u8,
) void {
for ([_]bool{ false, true }) |stage2| {
const tc = self.create(false, "source.h", name, source, expected_lines);
tc.stage2 = stage2;
self.addCase(tc);
}
}
pub fn addC_both(
self: *TranslateCContext,
name: []const u8,
source: []const u8,
expected_lines: []const []const u8,
) void {
for ([_]bool{ false, true }) |stage2| {
const tc = self.create(false, "source.c", name, source, expected_lines);
tc.stage2 = stage2;
self.addCase(tc);
}
}
pub fn add_2(
self: *TranslateCContext,
name: []const u8,
source: []const u8,
expected_lines: []const []const u8,
) void {
const tc = self.create(false, "source.h", name, source, expected_lines);
tc.stage2 = true;
self.addCase(tc);
}
pub fn addAllowWarnings(
self: *TranslateCContext,
name: []const u8,
@ -1664,7 +1615,7 @@ pub const TranslateCContext = struct {
pub fn addCase(self: *TranslateCContext, case: *const TestCase) void {
const b = self.b;
const translate_c_cmd = if (case.stage2) "translate-c-2" else "translate-c";
const translate_c_cmd = "translate-c";
const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {}", .{ translate_c_cmd, case.name }) catch unreachable;
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) return;

1562
test/translate_c.zig
View File

File diff suppressed because it is too large Load Diff