srctree

lib/compiler/aro/** linguist-vendored

$ zig build && ./zig-out/bin/arocc hello.c -o hello

//! Autogenerated by GenerateDef from src/aro/Attribute/names.def, do not edit

const Node = packed struct(u32) {

/// it's possible to store & lookup the properties of each name using a separate array.

number: u8,

/// If true, this node is the end of a valid name.

child_index: u14,

.x => builder.combine(undefined, .float16, 0) catch unreachable,

//! Autogenerated by GenerateDef from src/aro/Builtins/Builtin.def, do not edit

if (comp.langopts.gnuc_version > 0) {

try w.print("#define __GNUC__ {d}\n", .{comp.langopts.gnuc_version / 10_000});

try w.print("#define __GNUC_MINOR__ {d}\n", .{comp.langopts.gnuc_version / 100 % 100});

try w.print("#define __GNUC_PATCHLEVEL__ {d}\n", .{comp.langopts.gnuc_version % 100});

}

 

// TODO: Set these to target-specific constants depending on backend capabilities

// For now they are just set to the "may be lock-free" value

try w.writeAll(

\\#define __ATOMIC_BOOL_LOCK_FREE 1

\\#define __ATOMIC_CHAR_LOCK_FREE 1

\\#define __ATOMIC_CHAR16_T_LOCK_FREE 1

\\#define __ATOMIC_CHAR32_T_LOCK_FREE 1

\\#define __ATOMIC_WCHAR_T_LOCK_FREE 1

\\#define __ATOMIC_SHORT_LOCK_FREE 1

\\#define __ATOMIC_INT_LOCK_FREE 1

\\#define __ATOMIC_LONG_LOCK_FREE 1

\\#define __ATOMIC_LLONG_LOCK_FREE 1

\\#define __ATOMIC_POINTER_LOCK_FREE 1

\\

);

if (comp.langopts.hasChar8_T()) {

try w.writeAll("#define __ATOMIC_CHAR8_T_LOCK_FREE 1\n");

}

 

try comp.generateIntMaxAndWidth(w, "SIG_ATOMIC", target_util.sigAtomicType(comp.target));

try generateTypeMacro(w, mapper, "__CHAR16_TYPE__", comp.types.uint_least16_t, comp.langopts);

try generateTypeMacro(w, mapper, "__CHAR32_TYPE__", comp.types.uint_least32_t, comp.langopts);

/// Add built-in aro headers directory to system include paths

pub fn addBuiltinIncludeDir(comp: *Compilation, aro_dir: []const u8) !void {

}

pub fn addSystemIncludeDir(comp: *Compilation, path: []const u8) !void {

const duped = try comp.gpa.dupe(u8, path);

errdefer comp.gpa.free(duped);

try comp.system_include_dirs.append(comp.gpa, duped);

if (mem.indexOfScalar(u8, filename, 0) != null) {

return false;

}

 

@"shift-count-negative": Kind = .default,

@"shift-count-overflow": Kind = .default,

i = half -| 1;

//! Autogenerated by GenerateDef from src/aro/Diagnostics/messages.def, do not edit

negative_shift_count,

too_big_shift_count,

complex_conj,

overflow_builtin_requires_int,

overflow_result_requires_ptr,

.{ .msg = "shift count is negative", .opt = W("shift-count-negative"), .kind = .warning, .all = true },

.{ .msg = "shift count >= width of type", .opt = W("shift-count-overflow"), .kind = .warning, .all = true },

.{ .msg = "ISO C does not support '~' for complex conjugation of '{s}'", .opt = W("pedantic"), .extra = .str, .kind = .off },

.{ .msg = "operand argument to overflow builtin must be an integer ('{s}' invalid)", .extra = .str, .kind = .@"error" },

.{ .msg = "result argument to overflow builtin must be a pointer to a non-const integer ('{s}' invalid)", .extra = .str, .kind = .@"error" },

const GCCVersion = @import("Driver/GCCVersion.zig");

nobuiltininc: bool = false,

nostdinc: bool = false,

nostdlibinc: bool = false,

\\ -fgnuc-version=<value> Controls value of __GNUC__ and related macros. Set to 0 or empty to disable them.

\\ -nobuiltininc Do not search the compiler's builtin directory for include files

\\ -nostdinc, --no-standard-includes

\\ Do not search the standard system directories or compiler builtin directories for include files.

\\ -nostdlibinc Do not search the standard system directories for include files, but do search compiler builtin include directories

var gnuc_version: []const u8 = "4.2.1"; // default value set by clang

} else if (mem.eql(u8, arg, "-fgnuc-version=")) {

gnuc_version = "0";

} else if (option(arg, "-fgnuc-version=")) |version| {

gnuc_version = version;

} else if (mem.eql(u8, arg, "-nobuiltininc")) {

d.nobuiltininc = true;

} else if (mem.eql(u8, arg, "-nostdinc") or mem.eql(u8, arg, "--no-standard-includes")) {

d.nostdinc = true;

} else if (mem.eql(u8, arg, "-nostdlibinc")) {

d.nostdlibinc = true;

const version = GCCVersion.parse(gnuc_version);

if (version.major == -1) {

return d.fatal("invalid value '{0s}' in '-fgnuc-version={0s}'", .{gnuc_version});

}

d.comp.langopts.gnuc_version = version.toUnsigned();

try tc.discover();

tc.defineSystemIncludes() catch |er| switch (er) {

/// Used for determining __GNUC__ macro values

/// This matches clang's logic for overflowing values

pub fn toUnsigned(self: GCCVersion) u32 {

var result: u32 = 0;

if (self.major > 0) result = @as(u32, @intCast(self.major)) *% 10_000;

if (self.minor > 0) result +%= @as(u32, @intCast(self.minor)) *% 100;

if (self.patch > 0) result +%= @as(u32, @intCast(self.patch));

return result;

}

 

//! A hideset is a linked list (implemented as an array so that elements are identified by 4-byte indices)

//! of the set of identifiers from which a token was expanded.

//! During macro expansion, if a token would otherwise be expanded, but its hideset contains

//! the token itself, then it is not expanded

//! Most tokens have an empty hideset, and the hideset is not needed once expansion is complete,

//! so we use a hash map to store them instead of directly storing them with the token.

//! The C standard underspecifies the algorithm for updating a token's hideset;

//! we use the one here: https://www.spinellis.gr/blog/20060626/cpp.algo.pdf

 

const std = @import("std");

const mem = std.mem;

const Allocator = mem.Allocator;

const Source = @import("Source.zig");

const Compilation = @import("Compilation.zig");

const Tokenizer = @import("Tokenizer.zig");

 

pub const Hideset = @This();

 

const Identifier = struct {

id: Source.Id = .unused,

byte_offset: u32 = 0,

 

fn slice(self: Identifier, comp: *const Compilation) []const u8 {

var tmp_tokenizer = Tokenizer{

.buf = comp.getSource(self.id).buf,

.langopts = comp.langopts,

.index = self.byte_offset,

.source = .generated,

};

const res = tmp_tokenizer.next();

return tmp_tokenizer.buf[res.start..res.end];

}

 

fn fromLocation(loc: Source.Location) Identifier {

return .{

.id = loc.id,

.byte_offset = loc.byte_offset,

};

}

};

 

const Item = struct {

identifier: Identifier = .{},

next: Index = .none,

 

const List = std.MultiArrayList(Item);

};

 

const Index = enum(u32) {

none = std.math.maxInt(u32),

_,

};

 

map: std.AutoHashMapUnmanaged(Identifier, Index) = .{},

/// Used for computing intersection of two lists; stored here so that allocations can be retained

/// until hideset is deinit'ed

intersection_map: std.AutoHashMapUnmanaged(Identifier, void) = .{},

linked_list: Item.List = .{},

comp: *const Compilation,

 

/// Invalidated if the underlying MultiArrayList slice is reallocated due to resize

const Iterator = struct {

slice: Item.List.Slice,

i: Index,

 

fn next(self: *Iterator) ?Identifier {

if (self.i == .none) return null;

defer self.i = self.slice.items(.next)[@intFromEnum(self.i)];

return self.slice.items(.identifier)[@intFromEnum(self.i)];

}

};

 

pub fn deinit(self: *Hideset) void {

self.map.deinit(self.comp.gpa);

self.intersection_map.deinit(self.comp.gpa);

self.linked_list.deinit(self.comp.gpa);

}

 

pub fn clearRetainingCapacity(self: *Hideset) void {

self.linked_list.shrinkRetainingCapacity(0);

self.map.clearRetainingCapacity();

}

 

pub fn clearAndFree(self: *Hideset) void {

self.map.clearAndFree(self.comp.gpa);

self.intersection_map.clearAndFree(self.comp.gpa);

self.linked_list.shrinkAndFree(self.comp.gpa, 0);

}

 

/// Iterator is invalidated if the underlying MultiArrayList slice is reallocated due to resize

fn iterator(self: *const Hideset, idx: Index) Iterator {

return Iterator{

.slice = self.linked_list.slice(),

.i = idx,

};

}

 

pub fn get(self: *const Hideset, loc: Source.Location) Index {

return self.map.get(Identifier.fromLocation(loc)) orelse .none;

}

 

pub fn put(self: *Hideset, loc: Source.Location, value: Index) !void {

try self.map.put(self.comp.gpa, Identifier.fromLocation(loc), value);

}

 

fn ensureUnusedCapacity(self: *Hideset, new_size: usize) !void {

try self.linked_list.ensureUnusedCapacity(self.comp.gpa, new_size);

}

 

/// Creates a one-item list with contents `identifier`

fn createNodeAssumeCapacity(self: *Hideset, identifier: Identifier) Index {

const next_idx = self.linked_list.len;

self.linked_list.appendAssumeCapacity(.{ .identifier = identifier });

return @enumFromInt(next_idx);

}

 

/// Create a new list with `identifier` at the front followed by `tail`

pub fn prepend(self: *Hideset, loc: Source.Location, tail: Index) !Index {

const new_idx = self.linked_list.len;

try self.linked_list.append(self.comp.gpa, .{ .identifier = Identifier.fromLocation(loc), .next = tail });

return @enumFromInt(new_idx);

}

 

/// Copy a, then attach b at the end

pub fn @"union"(self: *Hideset, a: Index, b: Index) !Index {

var cur: Index = .none;

var head: Index = b;

try self.ensureUnusedCapacity(self.len(a));

var it = self.iterator(a);

while (it.next()) |identifier| {

const new_idx = self.createNodeAssumeCapacity(identifier);

if (head == b) {

head = new_idx;

}

if (cur != .none) {

self.linked_list.items(.next)[@intFromEnum(cur)] = new_idx;

}

cur = new_idx;

}

if (cur != .none) {

self.linked_list.items(.next)[@intFromEnum(cur)] = b;

}

return head;

}

 

pub fn contains(self: *const Hideset, list: Index, str: []const u8) bool {

var it = self.iterator(list);

while (it.next()) |identifier| {

if (mem.eql(u8, str, identifier.slice(self.comp))) return true;

}

return false;

}

 

fn len(self: *const Hideset, list: Index) usize {

const nexts = self.linked_list.items(.next);

var cur = list;

var count: usize = 0;

while (cur != .none) : (count += 1) {

cur = nexts[@intFromEnum(cur)];

}

return count;

}

 

pub fn intersection(self: *Hideset, a: Index, b: Index) !Index {

if (a == .none or b == .none) return .none;

self.intersection_map.clearRetainingCapacity();

 

var cur: Index = .none;

var head: Index = .none;

var it = self.iterator(a);

var a_len: usize = 0;

while (it.next()) |identifier| : (a_len += 1) {

try self.intersection_map.put(self.comp.gpa, identifier, {});

}

try self.ensureUnusedCapacity(@min(a_len, self.len(b)));

 

it = self.iterator(b);

while (it.next()) |identifier| {

if (self.intersection_map.contains(identifier)) {

const new_idx = self.createNodeAssumeCapacity(identifier);

if (head == .none) {

head = new_idx;

}

if (cur != .none) {

self.linked_list.items(.next)[@intFromEnum(cur)] = new_idx;

}

cur = new_idx;

}

}

return head;

}

/// Used ONLY for generating __GNUC__ and related macros. Does not control the presence/absence of any features

/// Encoded as major * 10,000 + minor * 100 + patch

/// e.g. 4.2.1 == 40201

gnuc_version: u32 = 0,

 

}, p.pp.expansionSlice(tok_i));

if (@import("builtin").mode != .Debug) {

if (ty.is(.invalid)) {

return "Tried to render invalid type - this is an aro bug.";

}

}

if (@import("builtin").mode != .Debug) {

if (a.is(.invalid) or b.is(.invalid)) {

return "Tried to render invalid type - this is an aro bug.";

}

}

const attr_count = p.field_attr_buf.items.len - old_field_attr_start;

const record_decls = p.decl_buf.items[decl_buf_top..];

if (attr_count > 0) {

if (attr_count != record_decls.len) {

// A mismatch here means that non-field decls were parsed. This can happen if there were

// parse errors during attribute parsing. Bail here because if there are any field attributes,

// there must be exactly one per field.

return error.ParsingFailed;

}

if (sym.kind != .enumeration) continue; // already an error

const lhs_type = if (data.bin.lhs != .none) p.nodeIsNoreturn(data.bin.lhs) else .no;

const rhs_type = if (data.bin.rhs != .none) p.nodeIsNoreturn(data.bin.rhs) else .no;

if (lhs_type == .complex or rhs_type == .complex) return .complex;

if (lhs_type == .yes or rhs_type == .yes) return .yes;

var it = data.range.start;

while (it != data.range.end) : (it += 1) {

const kind = p.nodeIsNoreturn(p.data.items[it]);

if (kind != .no) return kind;

}

return .no;

.default_stmt => {

if (data.un == .none) return .no;

return p.nodeIsNoreturn(data.un);

.while_stmt, .do_while_stmt, .for_decl_stmt, .forever_stmt, .for_stmt, .switch_stmt => return .complex,

Builtin.tagFromName("__builtin_complex").?,

Builtin.tagFromName("__builtin_add_overflow").?,

Builtin.tagFromName("__builtin_sub_overflow").?,

Builtin.tagFromName("__builtin_mul_overflow").?,

=> false,

@setEvalBranchQuota(10_000);

Builtin.tagFromName("__builtin_add_overflow").?,

Builtin.tagFromName("__builtin_sub_overflow").?,

Builtin.tagFromName("__builtin_mul_overflow").?,

=> return p.checkArithOverflowArg(builtin_tok, first_after, param_tok, arg, arg_idx),

 

Builtin.tagFromName("__c11_atomic_thread_fence").?,

Builtin.tagFromName("__c11_atomic_signal_fence").?,

Builtin.tagFromName("__c11_atomic_is_lock_free").?,

=> 1,

Builtin.tagFromName("__builtin_complex").?,

Builtin.tagFromName("__c11_atomic_load").?,

Builtin.tagFromName("__c11_atomic_init").?,

=> 2,

 

Builtin.tagFromName("__c11_atomic_store").?,

Builtin.tagFromName("__c11_atomic_exchange").?,

Builtin.tagFromName("__c11_atomic_fetch_add").?,

Builtin.tagFromName("__c11_atomic_fetch_sub").?,

Builtin.tagFromName("__c11_atomic_fetch_or").?,

Builtin.tagFromName("__c11_atomic_fetch_xor").?,

Builtin.tagFromName("__c11_atomic_fetch_and").?,

Builtin.tagFromName("__atomic_add_fetch").?,

Builtin.tagFromName("__atomic_sub_fetch").?,

Builtin.tagFromName("__atomic_and_fetch").?,

Builtin.tagFromName("__atomic_xor_fetch").?,

Builtin.tagFromName("__atomic_or_fetch").?,

Builtin.tagFromName("__atomic_nand_fetch").?,

Builtin.tagFromName("__builtin_add_overflow").?,

Builtin.tagFromName("__builtin_sub_overflow").?,

Builtin.tagFromName("__builtin_mul_overflow").?,

Builtin.tagFromName("__c11_atomic_compare_exchange_strong").?,

Builtin.tagFromName("__c11_atomic_compare_exchange_weak").?,

=> 5,

 

Builtin.tagFromName("__c11_atomic_exchange").? => {

if (p.list_buf.items.len != 4) return Type.invalid; // wrong number of arguments; already an error

const second_param = p.list_buf.items[2];

return p.nodes.items(.ty)[@intFromEnum(second_param)];

},

Builtin.tagFromName("__c11_atomic_load").? => {

if (p.list_buf.items.len != 3) return Type.invalid; // wrong number of arguments; already an error

const first_param = p.list_buf.items[1];

const ty = p.nodes.items(.ty)[@intFromEnum(first_param)];

if (!ty.isPtr()) return Type.invalid;

return ty.elemType();

},

 

Builtin.tagFromName("__atomic_add_fetch").?,

Builtin.tagFromName("__c11_atomic_fetch_add").?,

 

Builtin.tagFromName("__atomic_sub_fetch").?,

Builtin.tagFromName("__c11_atomic_fetch_sub").?,

 

Builtin.tagFromName("__atomic_and_fetch").?,

Builtin.tagFromName("__c11_atomic_fetch_and").?,

 

Builtin.tagFromName("__atomic_xor_fetch").?,

Builtin.tagFromName("__c11_atomic_fetch_xor").?,

 

Builtin.tagFromName("__atomic_or_fetch").?,

Builtin.tagFromName("__c11_atomic_fetch_or").?,

 

Builtin.tagFromName("__atomic_nand_fetch").?,

Builtin.tagFromName("__c11_atomic_fetch_nand").?,

if (p.list_buf.items.len != 3) return Type.invalid; // wrong number of arguments; already an error

const second_param = p.list_buf.items[2];

Builtin.tagFromName("__c11_atomic_is_lock_free").?,

 

Builtin.tagFromName("__c11_atomic_compare_exchange_strong").?,

Builtin.tagFromName("__c11_atomic_compare_exchange_weak").?,

=> {

if (p.list_buf.items.len != 6) return Type.invalid; // wrong number of arguments

const third_param = p.list_buf.items[3];

return p.nodes.items(.ty)[@intFromEnum(third_param)];

},

const cast_info = p.nodes.items(.data)[@intFromEnum(fn_ptr)].cast.operand;

const decl_ref = p.nodes.items(.data)[@intFromEnum(cast_info)].decl_ref;

if (fn_ty.hasAttribute(.nodiscard)) try p.errStr(.nodiscard_unused, expr_start, p.tokSlice(decl_ref));

if (fn_ty.hasAttribute(.warn_unused_result)) try p.errStr(.warn_unused_result, expr_start, p.tokSlice(decl_ref));

const cast_info = p.nodes.items(.data)[@intFromEnum(fn_ptr)].cast.operand;

const decl_ref = p.nodes.items(.data)[@intFromEnum(cast_info)].decl_ref;

if (fn_ty.hasAttribute(.nodiscard)) try p.errStr(.nodiscard_unused, expr_start, p.tokSlice(decl_ref));

if (fn_ty.hasAttribute(.warn_unused_result)) try p.errStr(.warn_unused_result, expr_start, p.tokSlice(decl_ref));

if (rhs.val.compare(.lt, Value.zero, p.comp)) {

try p.errStr(.negative_shift_count, shl orelse shr.?, try rhs.str(p));

}

if (rhs.val.compare(.gte, try Value.int(lhs.ty.bitSizeof(p.comp).?, p.comp), p.comp)) {

try p.errStr(.too_big_shift_count, shl orelse shr.?, try rhs.str(p));

}

if (try lhs.val.shl(lhs.val, rhs.val, lhs.ty, p.comp) and

lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(shl.?, lhs);

if (try lhs.val.add(lhs.val, rhs.val, lhs.ty, p.comp) and

lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(plus.?, lhs);

if (try lhs.val.sub(lhs.val, rhs.val, lhs.ty, p.comp) and

lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(minus.?, lhs);

if (try lhs.val.mul(lhs.val, rhs.val, lhs.ty, p.comp) and

lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(mul.?, lhs);

if (try lhs.val.div(lhs.val, rhs.val, lhs.ty, p.comp) and

lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(mul.?, lhs);

if (operand.val.is(.int, p.comp) or operand.val.is(.float, p.comp)) {

} else if (operand.ty.isComplex()) {

try p.errStr(.complex_conj, tok, try p.typeStr(operand.ty));

fn checkArithOverflowArg(p: *Parser, builtin_tok: TokenIndex, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, idx: u32) !void {

_ = builtin_tok;

_ = first_after;

if (idx <= 1) {

if (!arg.ty.isInt()) {

return p.errStr(.overflow_builtin_requires_int, param_tok, try p.typeStr(arg.ty));

}

} else if (idx == 2) {

if (!arg.ty.isPtr()) return p.errStr(.overflow_result_requires_ptr, param_tok, try p.typeStr(arg.ty));

const child = arg.ty.elemType();

if (!child.isInt() or child.is(.bool) or child.is(.@"enum") or child.qual.@"const") return p.errStr(.overflow_result_requires_ptr, param_tok, try p.typeStr(arg.ty));

}

}

 

var is_multichar = false;

is_multichar = chars.items.len > 1;

var value = try Value.int(val, p.comp);

// C99 6.4.4.4.10

// > If an integer character constant contains a single character or escape sequence,

// > its value is the one that results when an object with type char whose value is

// > that of the single character or escape sequence is converted to type int.

// This conversion only matters if `char` is signed and has a high-order bit of `1`

if (char_kind == .char and !is_multichar and val > 0x7F and p.comp.getCharSignedness() == .signed) {

try value.intCast(.{ .specifier = .char }, p.comp);

}

 

.val = value,

const Tree = @import("Tree.zig");

const Token = Tree.Token;

const TokenWithExpansionLocs = Tree.TokenWithExpansionLocs;

const Hideset = @import("Hideset.zig");

const ExpansionEntry = struct {

idx: Tree.TokenIndex,

locs: [*]Source.Location,

};

 

const TokenState = struct {

tokens_len: usize,

expansion_entries_len: usize,

};

 

/// Do not directly mutate this; use addToken / addTokenAssumeCapacity / ensureTotalTokenCapacity / ensureUnusedTokenCapacity

/// Do not directly mutate this; must be kept in sync with `tokens`

expansion_entries: std.MultiArrayList(ExpansionEntry) = .{},

hideset: Hideset,

 

.hideset = .{ .comp = comp },

pp.hideset.deinit();

for (pp.expansion_entries.items(.locs)) |locs| TokenWithExpansionLocs.free(locs, pp.gpa);

pp.expansion_entries.deinit(pp.gpa);

}

 

/// Free buffers that are not needed after preprocessing

fn clearBuffers(pp: *Preprocessor) void {

pp.token_buf.clearAndFree();

pp.char_buf.clearAndFree();

pp.top_expansion_buf.clearAndFree();

pp.hideset.clearAndFree();

}

 

pub fn expansionSlice(pp: *Preprocessor, tok: Tree.TokenIndex) []Source.Location {

const S = struct {

fn order_token_index(context: void, lhs: Tree.TokenIndex, rhs: Tree.TokenIndex) std.math.Order {

_ = context;

return std.math.order(lhs, rhs);

}

};

 

const indices = pp.expansion_entries.items(.idx);

const idx = std.sort.binarySearch(Tree.TokenIndex, tok, indices, {}, S.order_token_index) orelse return &.{};

const locs = pp.expansion_entries.items(.locs)[idx];

var i: usize = 0;

while (locs[i].id != .unused) : (i += 1) {}

return locs[0..i];

try pp.addIncludeResume(first.id, 0, 1);

try pp.addToken(eof);

pp.clearBuffers();

pub fn preprocess(pp: *Preprocessor, source: Source) Error!TokenWithExpansionLocs {

try pp.ensureTotalTokenCapacity(pp.tokens.len + estimated_token_count);

try pp.addToken(tokFromRaw(tok));

try pp.addToken(.{ .id = .include_start, .loc = .{

.line = 1,

try pp.addToken(.{ .id = .include_resume, .loc = .{

fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpansionLocs {

try pp.ensureTotalTokenCapacity(pp.tokens.len + estimated_token_count);

.hash => if (!start_of_line) try pp.addToken(tokFromRaw(tok)) else {

try pp.addToken(tokFromRaw(tok));

.whitespace => if (pp.preserve_whitespace) try pp.addToken(tokFromRaw(tok)),

if (pp.preserve_whitespace) try pp.addToken(tokFromRaw(tok));

pub fn tokSlice(pp: *Preprocessor, token: anytype) []const u8 {

fn tokFromRaw(raw: RawToken) TokenWithExpansionLocs {

fn errStr(pp: *Preprocessor, tok: TokenWithExpansionLocs, tag: Diagnostics.Tag, str: []const u8) !void {

fn fatalNotFound(pp: *Preprocessor, tok: TokenWithExpansionLocs, filename: []const u8) Compilation.Error {

if (tok.id == .whitespace or tok.id == .comment) continue;

fn getTokenState(pp: *const Preprocessor) TokenState {

return .{

.tokens_len = pp.tokens.len,

.expansion_entries_len = pp.expansion_entries.len,

};

}

 

fn restoreTokenState(pp: *Preprocessor, state: TokenState) void {

pp.tokens.len = state.tokens_len;

pp.expansion_entries.len = state.expansion_entries_len;

}

 

const token_state = pp.getTokenState();

for (pp.top_expansion_buf.items) |tok| TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);

pp.restoreTokenState(token_state);

pp.hideset.clearRetainingCapacity();

try pp.ensureUnusedTokenCapacity(pp.top_expansion_buf.items.len);

pp.addTokenAssumeCapacity(tok);

try pp.addToken(.{

.tok_i = @intCast(token_state.tokens_len),

fn handleKeywordDefined(pp: *Preprocessor, macro_tok: *TokenWithExpansionLocs, tokens: []const TokenWithExpansionLocs, eof: RawToken) !usize {

try pp.addToken(.{ .id = .nl, .loc = .{

const ExpandBuf = std.ArrayList(TokenWithExpansionLocs);

TokenWithExpansionLocs.free(placemarker.expansion_locs, buf.allocator);

const MacroArguments = std.ArrayList([]const TokenWithExpansionLocs);

for (item) |tok| TokenWithExpansionLocs.free(tok.expansion_locs, allocator);

if (simple_macro.tokens.len == 0) {

try buf.append(.{ .id = .placemarker, .loc = .{ .id = .generated } });

return buf;

}

fn pasteStringsUnsafe(pp: *Preprocessor, toks: []const TokenWithExpansionLocs) ![]const u8 {

fn pragmaOperator(pp: *Preprocessor, arg_tok: TokenWithExpansionLocs, operator_loc: Source.Location) !void {

fn stringify(pp: *Preprocessor, tokens: []const TokenWithExpansionLocs) !void {

fn reconstructIncludeString(pp: *Preprocessor, param_toks: []const TokenWithExpansionLocs, embed_args: ?*[]const TokenWithExpansionLocs, first: TokenWithExpansionLocs) !?[]const u8 {

assert(param_toks.len != 0);

.loc = first.loc,

}, first.expansionSlice());

if (include_str.len == 0) {

try pp.comp.addDiagnostic(.{

.tag = .expected_filename,

.loc = first.loc,

}, first.expansionSlice());

return null;

}

fn handleBuiltinMacro(pp: *Preprocessor, builtin: RawToken.Id, param_toks: []const TokenWithExpansionLocs, src_loc: Source.Location) Error!bool {

var invalid: ?TokenWithExpansionLocs = null;

var identifier: ?TokenWithExpansionLocs = null;

var invalid: ?TokenWithExpansionLocs = null;

var identifier: ?TokenWithExpansionLocs = null;

const include_str = (try pp.reconstructIncludeString(param_toks, null, param_toks[0])) orelse return false;

/// Treat whitespace-only paste arguments as empty

fn getPasteArgs(args: []const TokenWithExpansionLocs) []const TokenWithExpansionLocs {

for (args) |tok| {

if (tok.id != .macro_ws) return args;

}

return &[1]TokenWithExpansionLocs{.{

.id = .placemarker,

.loc = .{ .id = .generated, .byte_offset = 0, .line = 0 },

}};

}

 

const comma = TokenWithExpansionLocs{ .id = .comma, .loc = .{ .id = .generated } };

&[1]TokenWithExpansionLocs{tokFromRaw(raw_next)},

.macro_param, .macro_param_no_expand => getPasteArgs(args.items[raw_next.end]),

else => &[1]TokenWithExpansionLocs{tokFromRaw(raw_next)},

const slice = getPasteArgs(args.items[raw.end]);

var invalid: ?TokenWithExpansionLocs = null;

var vendor_ident: ?TokenWithExpansionLocs = null;

var colon_colon: ?TokenWithExpansionLocs = null;

var attr_ident: ?TokenWithExpansionLocs = null;

var embed_args: []const TokenWithExpansionLocs = &.{};

const include_str = (try pp.reconstructIncludeString(arg, &embed_args, arg[0])) orelse

slice: []const TokenWithExpansionLocs,

prev: TokenWithExpansionLocs,

fn next(it: *@This()) TokenWithExpansionLocs {

var first_arg: TokenWithExpansionLocs = undefined;

var invalid: ?TokenWithExpansionLocs = null;

var string: ?TokenWithExpansionLocs = null;

fn bufCopyTokens(buf: *ExpandBuf, tokens: []const TokenWithExpansionLocs, src: []const Source.Location) !void {

errdefer TokenWithExpansionLocs.free(copy.expansion_locs, buf.allocator);

) Error!TokenWithExpansionLocs {

return TokenWithExpansionLocs{ .id = .eof, .loc = .{ .id = .generated } };

r_paren: *TokenWithExpansionLocs,

var curArgument = std.ArrayList(TokenWithExpansionLocs).init(pp.gpa);

errdefer TokenWithExpansionLocs.free(duped.expansion_locs, pp.gpa);

errdefer TokenWithExpansionLocs.free(duped.expansion_locs, pp.gpa);

r_paren.* = tok;

errdefer TokenWithExpansionLocs.free(duped.expansion_locs, pp.gpa);

errdefer TokenWithExpansionLocs.free(duped.expansion_locs, pp.gpa);

for (buf.items[start .. start + len]) |tok| TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);

toks: []const TokenWithExpansionLocs,

fn init(toks: []const TokenWithExpansionLocs) TokenIterator {

fn nextNoWS(self: *TokenIterator) ?TokenWithExpansionLocs {

if (!macro_tok.id.isMacroIdentifier() or macro_tok.flags.expansion_disabled) {

const expanded = pp.expandedSlice(macro_tok);

const macro = pp.defines.getPtr(expanded) orelse {

idx += 1;

continue;

};

const macro_hidelist = pp.hideset.get(macro_tok.loc);

if (pp.hideset.contains(macro_hidelist, expanded)) {

idx += 1;

continue;

}

 

macro_handler: {

var r_paren: TokenWithExpansionLocs = undefined;

&r_paren,

assert(r_paren.id == .r_paren);

const r_paren_hidelist = pp.hideset.get(r_paren.loc);

var hs = try pp.hideset.intersection(macro_hidelist, r_paren_hidelist);

hs = try pp.hideset.prepend(macro_tok.loc, hs);

const tok_hidelist = pp.hideset.get(tok.loc);

const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hs);

try pp.hideset.put(tok.loc, new_hidelist);

for (buf.items[idx .. idx + tokens_removed]) |tok| TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);

const hs = try pp.hideset.prepend(macro_tok.loc, macro_hidelist);

 

 

const tok_hidelist = pp.hideset.get(tok.loc);

const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hs);

try pp.hideset.put(tok.loc, new_hidelist);

 

TokenWithExpansionLocs.free(buf.items[idx].expansion_locs, pp.gpa);

TokenWithExpansionLocs.free(item.expansion_locs, pp.gpa);

return pp.addToken(source_tok);

pp.hideset.clearRetainingCapacity();

try pp.ensureUnusedTokenCapacity(pp.top_expansion_buf.items.len);

TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);

TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);

continue;

}

if (tok.id == .placemarker) {

TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);

pp.addTokenAssumeCapacity(tok.*);

try pp.ensureUnusedTokenCapacity(pp.add_expansion_nl);

pp.addTokenAssumeCapacity(.{ .id = .nl, .loc = .{

fn expandedSliceExtra(pp: *const Preprocessor, tok: anytype, macro_ws_handling: enum { single_macro_ws, preserve_macro_ws }) []const u8 {

pub fn expandedSlice(pp: *const Preprocessor, tok: anytype) []const u8 {

fn pasteTokens(pp: *Preprocessor, lhs_toks: *ExpandBuf, rhs_toks: []const TokenWithExpansionLocs) Error!void {

TokenWithExpansionLocs.free(lhs.expansion_locs, pp.gpa);

defer TokenWithExpansionLocs.free(lhs.expansion_locs, pp.gpa);

fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: TokenWithExpansionLocs) !TokenWithExpansionLocs {

var pasted_token = TokenWithExpansionLocs{ .id = id, .loc = .{

while (true) {

.nl, .eof => break,

}

while (true) {

if (tok.id == .r_paren) break;

break;

break;

break;

}

tok_loop: while (true) {

.nl, .eof => break,

}

defer TokenWithExpansionLocs.free(filename_tok.expansion_locs, pp.gpa);

try pp.ensureUnusedTokenCapacity(2 * embed_bytes.len - 1); // N bytes and N-1 commas

pp.addTokenAssumeCapacity(try pp.makeGeneratedToken(start, .embed_byte, filename_tok));

pp.addTokenAssumeCapacity(.{ .id = .comma, .loc = .{ .id = .generated, .byte_offset = @intCast(start) } });

pp.addTokenAssumeCapacity(try pp.makeGeneratedToken(start + 1, .embed_byte, filename_tok));

const token_state = pp.getTokenState();

for (pp.expansion_entries.items(.locs)[token_state.expansion_entries_len..]) |loc| TokenWithExpansionLocs.free(loc, pp.gpa);

pp.restoreTokenState(token_state);

try pp.addToken(.{ .id = .nl, .loc = .{

fn makePragmaToken(pp: *Preprocessor, raw: RawToken, operator_loc: ?Source.Location, arg_locs: []const Source.Location) !TokenWithExpansionLocs {

pub fn addToken(pp: *Preprocessor, tok: TokenWithExpansionLocs) !void {

if (tok.expansion_locs) |expansion_locs| {

try pp.expansion_entries.append(pp.gpa, .{ .idx = @intCast(pp.tokens.len), .locs = expansion_locs });

}

try pp.tokens.append(pp.gpa, .{ .id = tok.id, .loc = tok.loc });

}

 

pub fn addTokenAssumeCapacity(pp: *Preprocessor, tok: TokenWithExpansionLocs) void {

if (tok.expansion_locs) |expansion_locs| {

pp.expansion_entries.appendAssumeCapacity(.{ .idx = @intCast(pp.tokens.len), .locs = expansion_locs });

}

pp.tokens.appendAssumeCapacity(.{ .id = tok.id, .loc = tok.loc });

}

 

pub fn ensureTotalTokenCapacity(pp: *Preprocessor, capacity: usize) !void {

try pp.tokens.ensureTotalCapacity(pp.gpa, capacity);

try pp.expansion_entries.ensureTotalCapacity(pp.gpa, capacity);

}

 

pub fn ensureUnusedTokenCapacity(pp: *Preprocessor, capacity: usize) !void {

try pp.tokens.ensureUnusedCapacity(pp.gpa, capacity);

try pp.expansion_entries.ensureUnusedCapacity(pp.gpa, capacity);

}

 

try pp.addToken(try pp.makePragmaToken(pragma_tok, operator_loc, arg_locs));

try pp.addToken(pragma_name_tok);

try pp.addToken(.{

try pp.addToken(try pp.makePragmaToken(next_tok, operator_loc, arg_locs));

) !TokenWithExpansionLocs {

defer for (pp.top_expansion_buf.items) |tok| TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);

var trailing_toks: []const TokenWithExpansionLocs = &.{};

const include_str = (try pp.reconstructIncludeString(pp.top_expansion_buf.items, &trailing_toks, tokFromRaw(first))) orelse {

defer TokenWithExpansionLocs.free(filename_tok.expansion_locs, pp.gpa);

try w.print(" {d} \"", .{line_no});

try pp.printLinemarker(w, 1, source, .start);

try pp.addToken(eof);

 

pub fn defineSystemIncludes(tc: *Toolchain) !void {

return switch (tc.inner) {

.uninitialized => unreachable,

.linux => |*linux| linux.defineSystemIncludes(tc),

.unknown => {

if (tc.driver.nostdinc) return;

 

const comp = tc.driver.comp;

if (!tc.driver.nobuiltininc) {

try comp.addBuiltinIncludeDir(tc.driver.aro_name);

}

 

if (!tc.driver.nostdlibinc) {

try comp.addSystemIncludeDir("/usr/include");

}

},

};

}

loc: Source.Location,

 

pub const List = std.MultiArrayList(Token);

pub const Id = Tokenizer.Token.Id;

pub const NumberPrefix = number_affixes.Prefix;

pub const NumberSuffix = number_affixes.Suffix;

};

 

pub const TokenWithExpansionLocs = struct {

id: Token.Id,

pub fn expansionSlice(tok: TokenWithExpansionLocs) []const Source.Location {

pub fn addExpansionLocation(tok: *TokenWithExpansionLocs, gpa: std.mem.Allocator, new: []const Source.Location) !void {

if (new.len == 0 or tok.id == .whitespace or tok.id == .macro_ws or tok.id == .placemarker) return;

pub fn dupe(tok: TokenWithExpansionLocs, gpa: std.mem.Allocator) !TokenWithExpansionLocs {

pub fn checkMsEof(tok: TokenWithExpansionLocs, source: Source, comp: *Compilation) !void {

if (a.params.len == 0 and b.params.len == 0) return true;

return false;

.typeof_expr, .variable_len_array => ty.data.expr.ty.hasIncompleteSize(),

.unspecified_variable_len_array => ty.data.sub_type.hasIncompleteSize(),

return (ty.isArray() or !ty.hasIncompleteSize() or ty.is(.void)) and !ty.is(.invalid);

const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });

comp.target = try std.zig.system.resolveTargetQuery(target_query);

const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });

comp.target = try std.zig.system.resolveTargetQuery(target_query);

/// Converts the stored value to a float of the specified type

}, pp.expansionSlice(start_idx));

}, pp.expansionSlice(start_idx + 1));

}, pp.expansionSlice(start_idx + 1));

}, pp.expansionSlice(start_idx + 1));

pp.expansionSlice(start_idx + 1),

}, pp.expansionSlice(start_idx + 2));

var i: u32 = 2;

}, pp.expansionSlice(start_idx + i));

}, pp.expansionSlice(start_idx + i));

const message_expansion_locs = pp.expansionSlice(start_idx);

}, pp.expansionSlice(start_idx + 1));

}, p.pp.expansionSlice(idx));

/// sig_atomic_t for this target

pub fn sigAtomicType(target: std.Target) Type {

if (target.cpu.arch.isWasm()) return .{ .specifier = .long };

return switch (target.cpu.arch) {

.avr => .{ .specifier = .schar },

.msp430 => .{ .specifier = .long },

else => .{ .specifier = .int },

};

}

 

pub fn defineSystemIncludes(self: *const Linux, tc: *const Toolchain) !void {

if (tc.driver.nostdinc) return;

 

const comp = tc.driver.comp;

const target = tc.getTarget();

 

// musl prefers /usr/include before builtin includes, so musl targets will add builtins

// at the end of this function (unless disabled with nostdlibinc)

if (!tc.driver.nobuiltininc and (!target.isMusl() or tc.driver.nostdlibinc)) {

try comp.addBuiltinIncludeDir(tc.driver.aro_name);

}

 

if (tc.driver.nostdlibinc) return;

 

const sysroot = tc.getSysroot();

const local_include = try std.fmt.allocPrint(comp.gpa, "{s}{s}", .{ sysroot, "/usr/local/include" });

defer comp.gpa.free(local_include);

try comp.addSystemIncludeDir(local_include);

 

if (self.gcc_detector.is_valid) {

const gcc_include_path = try std.fs.path.join(comp.gpa, &.{ self.gcc_detector.parent_lib_path, "..", self.gcc_detector.gcc_triple, "include" });

defer comp.gpa.free(gcc_include_path);

try comp.addSystemIncludeDir(gcc_include_path);

}

 

if (getMultiarchTriple(target)) |triple| {

const joined = try std.fs.path.join(comp.gpa, &.{ sysroot, "usr", "include", triple });

defer comp.gpa.free(joined);

if (tc.filesystem.exists(joined)) {

try comp.addSystemIncludeDir(joined);

}

}

 

if (target.os.tag == .rtems) return;

 

try comp.addSystemIncludeDir("/include");

try comp.addSystemIncludeDir("/usr/include");

 

std.debug.assert(!tc.driver.nostdlibinc);

if (!tc.driver.nobuiltininc and target.isMusl()) {

try comp.addBuiltinIncludeDir(tc.driver.aro_name);

}

}

 

const target_query = try std.Target.Query.parse(.{ .arch_os_abi = raw_triple });

comp.target = try std.zig.system.resolveTargetQuery(target_query);

.tag = .f80,

.tag = .f128,

.bytes => |b| return std.zig.stringEscape(b, "", .{}, w),