Commit 3239b3cb6957aa5f5f04c9d7d9035da14ccd0741 | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-09-15 14:05:15-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-09-19 11:54:01-04:00
log	3239b3cb6957aa5f5f04c9d7d9035da14ccd0741
tree	49045063682e47114d3ca51c81907c6adcb3e0e5
parent	4c0259b107236b39f7b1e8f423d2bf9f48e89b54

use size_t for indexes

protect against incorrect copies in debug mode

27 files changed, 555 insertions(+), 531 deletions(-)

CMakeLists.txt+1-1

...	@@ -177,7 +177,7 @@ if(MINGW)	...	@@ -177,7 +177,7 @@ if(MINGW)
177	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wno-error=format= -Wno-error=format -Wno-error=format-extra-args")	177	set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wno-error=format= -Wno-error=format -Wno-error=format-extra-args")
178	endif()	178	endif()
179		179
180	set(EXE_CFLAGS "-std=c++11 -fno-exceptions -fno-rtti -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__USE_MINGW_ANSI_STDIO -Werror=strict-prototypes -Werror=old-style-definition")	180	set(EXE_CFLAGS "-std=c++11 -fno-exceptions -fno-rtti -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__USE_MINGW_ANSI_STDIO -Werror=strict-prototypes -Werror=old-style-definition -Werror=type-limits")
181	set(EXE_LDFLAGS " ")	181	set(EXE_LDFLAGS " ")
182	if(ZIG_TEST_COVERAGE)	182	if(ZIG_TEST_COVERAGE)
183	set(EXE_CFLAGS "${EXE_CFLAGS} -fprofile-arcs -ftest-coverage")	183	set(EXE_CFLAGS "${EXE_CFLAGS} -fprofile-arcs -ftest-coverage")

src/all_types.hpp+45-46

 @@ -18,7 +18,6 @@
 struct AstNode;
 struct ImportTableEntry;
-struct AsmToken;
 struct FnTableEntry;
 struct BlockContext;
 struct TypeTableEntry;
 @@ -218,8 +217,8 @@ struct AstNodeFnProto {
     bool skip;
     Expr resolved_expr;
     // computed from params field
-    int inline_arg_count;
+    size_t inline_arg_count;
-    int inline_or_var_type_arg_count;
+    size_t inline_or_var_type_arg_count;
     // if this is a generic function implementation, this points to the generic node
     AstNode *generic_proto_node;
 };
 @@ -282,7 +281,7 @@ struct AstNodeDefer {
     // populated by semantic analyzer:
     Expr resolved_expr;
-    int index_in_block;
+    size_t index_in_block;
     LLVMBasicBlockRef basic_block;
     BlockContext *child_block;
 };
 @@ -547,7 +546,7 @@ struct AstNodeSwitchExpr {
     // populated by semantic analyzer
     Expr resolved_expr;
-    int const_chosen_prong_index;
+    size_t const_chosen_prong_index;
 };
 struct AstNodeSwitchProng {
 @@ -599,8 +598,20 @@ struct AsmInput {
 };
 struct SrcPos {
-    int line;
+    size_t line;
-    int column;
+    size_t column;
+};
+enum AsmTokenId {
+    AsmTokenIdTemplate,
+    AsmTokenIdPercent,
+    AsmTokenIdVar,
+};
+struct AsmToken {
+    enum AsmTokenId id;
+    size_t start;
+    size_t end;
 };
 struct AstNodeAsmExpr {
 @@ -612,7 +623,7 @@ struct AstNodeAsmExpr {
     ZigList<Buf*> clobber_list;
     // populated by semantic analyzer
-    int return_count;
+    size_t return_count;
     Expr resolved_expr;
 };
 @@ -763,8 +774,8 @@ struct AstNodeVarLiteral {
 struct AstNode {
     enum NodeType type;
-    int line;
+    size_t line;
-    int column;
+    size_t column;
     uint32_t create_index; // for determinism purposes
     ImportTableEntry *owner;
     AstNode **parent_field; // for AST rewriting
 @@ -823,18 +834,6 @@ struct AstNode {
     } data;
 };
-enum AsmTokenId {
-    AsmTokenIdTemplate,
-    AsmTokenIdPercent,
-    AsmTokenIdVar,
-};
-struct AsmToken {
-    enum AsmTokenId id;
-    int start;
-    int end;
-};
 // this struct is allocated with allocate_nonzero
 struct FnTypeParamInfo {
     bool is_noalias;
 @@ -844,24 +843,24 @@ struct FnTypeParamInfo {
 struct GenericParamValue {
     TypeTableEntry *type;
     AstNode *node;
-    int impl_index;
+    size_t impl_index;
 };
 struct GenericFnTypeId {
     AstNode *decl_node; // the generic fn or container decl node
     GenericParamValue *generic_params;
-    int generic_param_count;
+    size_t generic_param_count;
 };
 uint32_t generic_fn_type_id_hash(GenericFnTypeId *id);
 bool generic_fn_type_id_eql(GenericFnTypeId *a, GenericFnTypeId *b);
-static const int fn_type_id_prealloc_param_info_count = 4;
+static const size_t fn_type_id_prealloc_param_info_count = 4;
 struct FnTypeId {
     TypeTableEntry *return_type;
     FnTypeParamInfo *param_info;
-    int param_count;
+    size_t param_count;
     bool is_var_args;
     bool is_naked;
     bool is_cold;
 @@ -878,12 +877,12 @@ struct TypeTableEntryPointer {
 };
 struct TypeTableEntryInt {
-    int bit_count;
+    size_t bit_count;
     bool is_signed;
 };
 struct TypeTableEntryFloat {
-    int bit_count;
+    size_t bit_count;
 };
 struct TypeTableEntryArray {
 @@ -894,8 +893,8 @@ struct TypeTableEntryArray {
 struct TypeStructField {
     Buf *name;
     TypeTableEntry *type_entry;
-    int src_index;
+    size_t src_index;
-    int gen_index;
+    size_t gen_index;
 };
 struct TypeTableEntryStruct {
     AstNode *decl_node;
 @@ -958,8 +957,8 @@ struct TypeTableEntryUnion {
 };
 struct FnGenParamInfo {
-    int src_index;
+    size_t src_index;
-    int gen_index;
+    size_t gen_index;
     bool is_byval;
     TypeTableEntry *type;
 };
 @@ -967,7 +966,7 @@ struct FnGenParamInfo {
 struct TypeTableEntryFn {
     FnTypeId fn_type_id;
     TypeTableEntry *gen_return_type;
-    int gen_param_count;
+    size_t gen_param_count;
     FnGenParamInfo *gen_param_info;
     LLVMTypeRef raw_type_ref;
 @@ -1057,7 +1056,7 @@ struct ImportTableEntry {
     PackageTableEntry *package;
     ZigLLVMDIFile *di_file;
     Buf *source_code;
-    ZigList<int> *line_offsets;
+    ZigList<size_t> *line_offsets;
     BlockContext *block_context;
     AstNode *c_import_node;
     bool any_imports_failed;
 @@ -1127,8 +1126,8 @@ struct EvalFnRoot {
     CodeGen *codegen;
     FnTableEntry *fn;
     AstNode *call_node;
-    int branch_quota;
+    size_t branch_quota;
-    int branches_used;
+    size_t branches_used;
     AstNode *exceeded_quota_node;
     bool abort;
 };
 @@ -1180,7 +1179,7 @@ enum BuiltinFnId {
 struct BuiltinFnEntry {
     BuiltinFnId id;
     Buf name;
-    int param_count;
+    size_t param_count;
     TypeTableEntry *return_type;
     TypeTableEntry **param_types;
     uint32_t ref_count;
 @@ -1207,11 +1206,11 @@ struct CodeGen {
     HashMap<GenericFnTypeId *, AstNode *, generic_fn_type_id_hash, generic_fn_type_id_eql> generic_table;
     ZigList<ImportTableEntry *> import_queue;
-    int import_queue_index;
+    size_t import_queue_index;
     ZigList<AstNode *> resolve_queue;
-    int resolve_queue_index;
+    size_t resolve_queue_index;
     ZigList<AstNode *> use_queue;
-    int use_queue_index;
+    size_t use_queue_index;
     uint32_t next_unresolved_index;
 @@ -1305,9 +1304,9 @@ struct CodeGen {
     bool c_want_stdint;
     bool c_want_stdbool;
     AstNode *root_export_decl;
-    int version_major;
+    size_t version_major;
-    int version_minor;
+    size_t version_minor;
-    int version_patch;
+    size_t version_patch;
     bool verbose;
     ErrColor err_color;
     ImportTableEntry *root_import;
 @@ -1323,7 +1322,7 @@ struct CodeGen {
     LLVMValueRef int_builtin_fns[2][4]; // [0-ctz,1-clz][0-8,1-16,2-32,3-64]
     const char **clang_argv;
-    int clang_argv_len;
+    size_t clang_argv_len;
     ZigList<const char *> lib_dirs;
     uint32_t test_fn_count;
 @@ -1345,8 +1344,8 @@ struct VariableTableEntry {
     // which node contains the ConstExprValue for this variable's value
     AstNode *val_node;
     ZigLLVMDILocalVariable *di_loc_var;
-    int src_arg_index;
+    size_t src_arg_index;
-    int gen_arg_index;
+    size_t gen_arg_index;
     BlockContext *block_context;
     LLVMValueRef param_value_ref;
     bool force_depends_on_compile_var;

src/analyze.cpp+98-98

src/analyze.hpp+2-2

...	@@ -19,8 +19,8 @@ BlockContext new_block_context(AstNode node, BlockContext *parent);	...	@@ -19,8 +19,8 @@ BlockContext new_block_context(AstNode node, BlockContext *parent);
19	Expr get_resolved_expr(AstNode node);	19	Expr get_resolved_expr(AstNode node);
20	bool is_node_void_expr(AstNode *node);	20	bool is_node_void_expr(AstNode *node);
21	uint64_t type_size(CodeGen g, TypeTableEntry type_entry);	21	uint64_t type_size(CodeGen g, TypeTableEntry type_entry);
22	TypeTableEntry *get_int_type_ptr(CodeGen g, bool is_signed, int size_in_bits);	22	TypeTableEntry *get_int_type_ptr(CodeGen g, bool is_signed, size_t size_in_bits);
23	TypeTableEntry get_int_type(CodeGen g, bool is_signed, int size_in_bits);	23	TypeTableEntry get_int_type(CodeGen g, bool is_signed, size_t size_in_bits);
24	TypeTableEntry *get_c_int_type_ptr(CodeGen g, CIntType c_int_type);	24	TypeTableEntry *get_c_int_type_ptr(CodeGen g, CIntType c_int_type);
25	TypeTableEntry get_c_int_type(CodeGen g, CIntType c_int_type);	25	TypeTableEntry get_c_int_type(CodeGen g, CIntType c_int_type);
26	TypeTableEntry get_typedecl_type(CodeGen g, const char name, TypeTableEntry child_type);	26	TypeTableEntry get_typedecl_type(CodeGen g, const char name, TypeTableEntry child_type);

src/ast_render.cpp+7-7

...	@@ -292,7 +292,7 @@ static bool is_printable(uint8_t c) {	...	@@ -292,7 +292,7 @@ static bool is_printable(uint8_t c) {
292		292
293	static void string_literal_escape(Buf source, Buf dest) {	293	static void string_literal_escape(Buf source, Buf dest) {
294	buf_resize(dest, 0);	294	buf_resize(dest, 0);
295	for (int i = 0; i < buf_len(source); i += 1) {	295	for (size_t i = 0; i < buf_len(source); i += 1) {
296	uint8_t c = ((uint8_t)buf_ptr(source) + i);	296	uint8_t c = ((uint8_t)buf_ptr(source) + i);
297	if (is_printable(c)) {	297	if (is_printable(c)) {
298	buf_append_char(dest, c);	298	buf_append_char(dest, c);
...	@@ -330,7 +330,7 @@ static bool is_valid_bare_symbol(Buf *symbol) {	...	@@ -330,7 +330,7 @@ static bool is_valid_bare_symbol(Buf *symbol) {
330	if (!is_alpha_under(first_char)) {	330	if (!is_alpha_under(first_char)) {
331	return false;	331	return false;
332	}	332	}
333	for (int i = 1; i < buf_len(symbol); i += 1) {	333	for (size_t i = 1; i < buf_len(symbol); i += 1) {
334	uint8_t c = ((uint8_t)buf_ptr(symbol) + i);	334	uint8_t c = ((uint8_t)buf_ptr(symbol) + i);
335	if (!is_alpha_under(c) && !is_digit(c)) {	335	if (!is_alpha_under(c) && !is_digit(c)) {
336	return false;	336	return false;
...	@@ -358,7 +358,7 @@ static void render_node(AstRender ar, AstNode node) {	...	@@ -358,7 +358,7 @@ static void render_node(AstRender ar, AstNode node) {
358		358
359	switch (node->type) {	359	switch (node->type) {
360	case NodeTypeRoot:	360	case NodeTypeRoot:
361	for (int i = 0; i < node->data.root.top_level_decls.length; i += 1) {	361	for (size_t i = 0; i < node->data.root.top_level_decls.length; i += 1) {
362	AstNode *child = node->data.root.top_level_decls.at(i);	362	AstNode *child = node->data.root.top_level_decls.at(i);
363	print_indent(ar);	363	print_indent(ar);
364	render_node(ar, child);	364	render_node(ar, child);
...	@@ -417,7 +417,7 @@ static void render_node(AstRender ar, AstNode node) {	...	@@ -417,7 +417,7 @@ static void render_node(AstRender ar, AstNode node) {
417	ZigList<AstNode > directives =	417	ZigList<AstNode > directives =
418	node->data.fn_def.fn_proto->data.fn_proto.top_level_decl.directives;	418	node->data.fn_def.fn_proto->data.fn_proto.top_level_decl.directives;
419	if (directives) {	419	if (directives) {
420	for (int i = 0; i < directives->length; i += 1) {	420	for (size_t i = 0; i < directives->length; i += 1) {
421	render_node(ar, directives->at(i));	421	render_node(ar, directives->at(i));
422	}	422	}
423	}	423	}
...	@@ -433,7 +433,7 @@ static void render_node(AstRender ar, AstNode node) {	...	@@ -433,7 +433,7 @@ static void render_node(AstRender ar, AstNode node) {
433	case NodeTypeBlock:	433	case NodeTypeBlock:
434	fprintf(ar->f, "{\n");	434	fprintf(ar->f, "{\n");
435	ar->indent += ar->indent_size;	435	ar->indent += ar->indent_size;
436	for (int i = 0; i < node->data.block.statements.length; i += 1) {	436	for (size_t i = 0; i < node->data.block.statements.length; i += 1) {
437	AstNode *statement = node->data.block.statements.at(i);	437	AstNode *statement = node->data.block.statements.at(i);
438	print_indent(ar);	438	print_indent(ar);
439	render_node(ar, statement);	439	render_node(ar, statement);
...	@@ -561,7 +561,7 @@ static void render_node(AstRender ar, AstNode node) {	...	@@ -561,7 +561,7 @@ static void render_node(AstRender ar, AstNode node) {
561	fprintf(ar->f, ")");	561	fprintf(ar->f, ")");
562	}	562	}
563	fprintf(ar->f, "(");	563	fprintf(ar->f, "(");
564	for (int i = 0; i < node->data.fn_call_expr.params.length; i += 1) {	564	for (size_t i = 0; i < node->data.fn_call_expr.params.length; i += 1) {
565	AstNode *param = node->data.fn_call_expr.params.at(i);	565	AstNode *param = node->data.fn_call_expr.params.at(i);
566	if (i != 0) {	566	if (i != 0) {
567	fprintf(ar->f, ", ");	567	fprintf(ar->f, ", ");
...	@@ -628,7 +628,7 @@ static void render_node(AstRender ar, AstNode node) {	...	@@ -628,7 +628,7 @@ static void render_node(AstRender ar, AstNode node) {
628	const char *container_str = container_string(node->data.struct_decl.kind);	628	const char *container_str = container_string(node->data.struct_decl.kind);
629	fprintf(ar->f, "%s%s %s {\n", pub_str, container_str, struct_name);	629	fprintf(ar->f, "%s%s %s {\n", pub_str, container_str, struct_name);
630	ar->indent += ar->indent_size;	630	ar->indent += ar->indent_size;
631	for (int field_i = 0; field_i < node->data.struct_decl.fields.length; field_i += 1) {	631	for (size_t field_i = 0; field_i < node->data.struct_decl.fields.length; field_i += 1) {
632	AstNode *field_node = node->data.struct_decl.fields.at(field_i);	632	AstNode *field_node = node->data.struct_decl.fields.at(field_i);
633	assert(field_node->type == NodeTypeStructField);	633	assert(field_node->type == NodeTypeStructField);
634	print_indent(ar);	634	print_indent(ar);

src/bignum.cpp+1-1

...	@@ -43,7 +43,7 @@ void bignum_init_signed(BigNum *dest, int64_t x) {	...	@@ -43,7 +43,7 @@ void bignum_init_signed(BigNum *dest, int64_t x) {
43	}	43	}
44		44
45	void bignum_init_bignum(BigNum dest, BigNum src) {	45	void bignum_init_bignum(BigNum dest, BigNum src) {
46	memcpy(dest, src, sizeof(BigNum));	46	safe_memcpy(dest, src, 1);
47	}	47	}
48		48
49	bool bignum_fits_in_bits(BigNum *bn, int bit_count, bool is_signed) {	49	bool bignum_fits_in_bits(BigNum *bn, int bit_count, bool is_signed) {

src/buffer.cpp+2-2

...	@@ -41,7 +41,7 @@ void buf_appendf(Buf buf, const char format, ...) {	...	@@ -41,7 +41,7 @@ void buf_appendf(Buf buf, const char format, ...) {
41		41
42	size_t required_size = len1 + 1;	42	size_t required_size = len1 + 1;
43		43
44	int orig_len = buf_len(buf);	44	size_t orig_len = buf_len(buf);
45		45
46	buf_resize(buf, orig_len + len1);	46	buf_resize(buf, orig_len + len1);
47		47
...	@@ -62,7 +62,7 @@ uint32_t buf_hash(Buf *buf) {	...	@@ -62,7 +62,7 @@ uint32_t buf_hash(Buf *buf) {
62	assert(buf->list.length);	62	assert(buf->list.length);
63	// FNV 32-bit hash	63	// FNV 32-bit hash
64	uint32_t h = 2166136261;	64	uint32_t h = 2166136261;
65	for (int i = 0; i < buf_len(buf); i += 1) {	65	for (size_t i = 0; i < buf_len(buf); i += 1) {
66	h = h ^ ((uint8_t)buf->list.at(i));	66	h = h ^ ((uint8_t)buf->list.at(i));
67	h = h * 16777619;	67	h = h * 16777619;
68	}	68	}

src/buffer.hpp+23-25

 @@ -27,7 +27,7 @@ Buf *buf_sprintf(const char *format, ...)
     __attribute__ ((format (printf, 1, 2)));
 Buf *buf_vprintf(const char *format, va_list ap);
-static inline int buf_len(Buf *buf) {
+static inline size_t buf_len(Buf *buf) {
     assert(buf->list.length);
     return buf->list.length - 1;
 }
 @@ -37,31 +37,29 @@ static inline char *buf_ptr(Buf *buf) {
     return buf->list.items;
 }
-static inline void buf_resize(Buf *buf, int new_len) {
+static inline void buf_resize(Buf *buf, size_t new_len) {
     buf->list.resize(new_len + 1);
     buf->list.at(buf_len(buf)) = 0;
 }
-static inline Buf *buf_alloc(void) {
+static inline Buf *buf_alloc_fixed(size_t size) {
     Buf *buf = allocate<Buf>(1);
-    buf_resize(buf, 0);
+    buf_resize(buf, size);
     return buf;
 }
-static inline Buf *buf_alloc_fixed(int size) {
+static inline Buf *buf_alloc(void) {
-    Buf *buf = allocate<Buf>(1);
+    return buf_alloc_fixed(0);
-    buf_resize(buf, size);
-    return buf;
 }
 static inline void buf_deinit(Buf *buf) {
     buf->list.deinit();
 }
-static inline void buf_init_from_mem(Buf *buf, const char *ptr, int len) {
+static inline void buf_init_from_mem(Buf *buf, const char *ptr, size_t len) {
-    assert(len >= 0);
+    assert(len != SIZE_MAX);
     buf->list.resize(len + 1);
-    memcpy(buf_ptr(buf), ptr, len);
+    safe_memcpy(buf_ptr(buf), ptr, len);
     buf->list.at(buf_len(buf)) = 0;
 }
 @@ -73,8 +71,8 @@ static inline void buf_init_from_buf(Buf *buf, Buf *other) {
     buf_init_from_mem(buf, buf_ptr(other), buf_len(other));
 }
-static inline Buf *buf_create_from_mem(const char *ptr, int len) {
+static inline Buf *buf_create_from_mem(const char *ptr, size_t len) {
-    assert(len >= 0);
+    assert(len != SIZE_MAX);
     Buf *buf = allocate<Buf>(1);
     buf_init_from_mem(buf, ptr, len);
     return buf;
 @@ -88,25 +86,25 @@ static inline Buf *buf_create_from_buf(Buf *buf) {
     return buf_create_from_mem(buf_ptr(buf), buf_len(buf));
 }
-static inline Buf *buf_slice(Buf *in_buf, int start, int end) {
+static inline Buf *buf_slice(Buf *in_buf, size_t start, size_t end) {
     assert(in_buf->list.length);
-    assert(start >= 0);
+    assert(start != SIZE_MAX);
-    assert(end >= 0);
+    assert(end != SIZE_MAX);
     assert(start < buf_len(in_buf));
     assert(end <= buf_len(in_buf));
     Buf *out_buf = allocate<Buf>(1);
     out_buf->list.resize(end - start + 1);
-    memcpy(buf_ptr(out_buf), buf_ptr(in_buf) + start, end - start);
+    safe_memcpy(buf_ptr(out_buf), buf_ptr(in_buf) + start, end - start);
     out_buf->list.at(buf_len(out_buf)) = 0;
     return out_buf;
 }
-static inline void buf_append_mem(Buf *buf, const char *mem, int mem_len) {
+static inline void buf_append_mem(Buf *buf, const char *mem, size_t mem_len) {
     assert(buf->list.length);
-    assert(mem_len >= 0);
+    assert(mem_len != SIZE_MAX);
-    int old_len = buf_len(buf);
+    size_t old_len = buf_len(buf);
     buf_resize(buf, old_len + mem_len);
-    memcpy(buf_ptr(buf) + old_len, mem, mem_len);
+    safe_memcpy(buf_ptr(buf) + old_len, mem, mem_len);
     buf->list.at(buf_len(buf)) = 0;
 }
 @@ -128,7 +126,7 @@ static inline void buf_append_char(Buf *buf, uint8_t c) {
 void buf_appendf(Buf *buf, const char *format, ...)
     __attribute__ ((format (printf, 2, 3)));
-static inline bool buf_eql_mem(Buf *buf, const char *mem, int mem_len) {
+static inline bool buf_eql_mem(Buf *buf, const char *mem, size_t mem_len) {
     assert(buf->list.length);
     if (buf_len(buf) != mem_len)
         return false;
 @@ -140,7 +138,7 @@ static inline bool buf_eql_str(Buf *buf, const char *str) {
     return buf_eql_mem(buf, str, strlen(str));
 }
-static inline bool buf_starts_with_mem(Buf *buf, const char *mem, int mem_len) {
+static inline bool buf_starts_with_mem(Buf *buf, const char *mem, size_t mem_len) {
     if (buf_len(buf) < mem_len) {
         return false;
     }
 @@ -155,7 +153,7 @@ static inline bool buf_starts_with_str(Buf *buf, const char *str) {
     return buf_starts_with_mem(buf, str, strlen(str));
 }
-static inline bool buf_ends_with_mem(Buf *buf, const char *mem, int mem_len) {
+static inline bool buf_ends_with_mem(Buf *buf, const char *mem, size_t mem_len) {
     if (buf_len(buf) < mem_len) {
         return false;
     }
 @@ -170,7 +168,7 @@ bool buf_eql_buf(Buf *buf, Buf *other);
 uint32_t buf_hash(Buf *buf);
 static inline void buf_upcase(Buf *buf) {
-    for (int i = 0; i < buf_len(buf); i += 1) {
+    for (size_t i = 0; i < buf_len(buf); i += 1) {
         buf_ptr(buf)[i] = toupper(buf_ptr(buf)[i]);
     }
 }

src/codegen.cpp+109-108

src/codegen.hpp+1-1

...	@@ -16,7 +16,7 @@	...	@@ -16,7 +16,7 @@
16		16
17	CodeGen codegen_create(Buf root_source_dir, const ZigTarget *target);	17	CodeGen codegen_create(Buf root_source_dir, const ZigTarget *target);
18		18
19	void codegen_set_clang_argv(CodeGen codegen, const char *args, int len);	19	void codegen_set_clang_argv(CodeGen codegen, const char *args, size_t len);
20	void codegen_set_is_release(CodeGen *codegen, bool is_release);	20	void codegen_set_is_release(CodeGen *codegen, bool is_release);
21	void codegen_set_is_test(CodeGen *codegen, bool is_test);	21	void codegen_set_is_test(CodeGen *codegen, bool is_test);
22	void codegen_set_check_unused(CodeGen *codegen, bool check_unused);	22	void codegen_set_check_unused(CodeGen *codegen, bool check_unused);

src/errmsg.cpp+17-20

 @@ -16,36 +16,36 @@ enum ErrType {
 static void print_err_msg_type(ErrorMsg *err, ErrColor color, ErrType err_type) {
     const char *path = buf_ptr(err->path);
-    int line = err->line_start + 1;
+    size_t line = err->line_start + 1;
-    int col = err->column_start + 1;
+    size_t col = err->column_start + 1;
     const char *text = buf_ptr(err->msg);
     if (color == ErrColorOn || (color == ErrColorAuto && os_stderr_tty())) {
         if (err_type == ErrTypeError) {
-            fprintf(stderr, WHITE "%s:%d:%d: " RED "error:" WHITE " %s" RESET "\n", path, line, col, text);
+            fprintf(stderr, WHITE "%s:%zu:%zu: " RED "error:" WHITE " %s" RESET "\n", path, line, col, text);
         } else if (err_type == ErrTypeNote) {
-            fprintf(stderr, WHITE "%s:%d:%d: " CYAN "note:" WHITE " %s" RESET "\n", path, line, col, text);
+            fprintf(stderr, WHITE "%s:%zu:%zu: " CYAN "note:" WHITE " %s" RESET "\n", path, line, col, text);
         } else {
             zig_unreachable();
         }
         fprintf(stderr, "%s\n", buf_ptr(&err->line_buf));
-        for (int i = 0; i < err->column_start; i += 1) {
+        for (size_t i = 0; i < err->column_start; i += 1) {
             fprintf(stderr, " ");
         }
         fprintf(stderr, GREEN "^" RESET "\n");
     } else {
         if (err_type == ErrTypeError) {
-            fprintf(stderr, "%s:%d:%d: error: %s\n", path, line, col, text);
+            fprintf(stderr, "%s:%zu:%zu: error: %s\n", path, line, col, text);
         } else if (err_type == ErrTypeNote) {
-            fprintf(stderr, " %s:%d:%d: note: %s\n", path, line, col, text);
+            fprintf(stderr, " %s:%zu:%zu: note: %s\n", path, line, col, text);
         } else {
             zig_unreachable();
         }
     }
-    for (int i = 0; i < err->notes.length; i += 1) {
+    for (size_t i = 0; i < err->notes.length; i += 1) {
         ErrorMsg *note = err->notes.at(i);
         print_err_msg_type(note, color, ErrTypeNote);
     }
 @@ -59,7 +59,7 @@ void err_msg_add_note(ErrorMsg *parent, ErrorMsg *note) {
     parent->notes.append(note);
 }
-ErrorMsg *err_msg_create_with_offset(Buf *path, int line, int column, int offset,
+ErrorMsg *err_msg_create_with_offset(Buf *path, size_t line, size_t column, size_t offset,
         const char *source, Buf *msg)
 {
     ErrorMsg *err_msg = allocate<ErrorMsg>(1);
 @@ -68,7 +68,7 @@ ErrorMsg *err_msg_create_with_offset(Buf *path, int line, int column, int offset
     err_msg->column_start = column;
     err_msg->msg = msg;
-    int line_start_offset = offset;
+    size_t line_start_offset = offset;
     for (;;) {
         if (line_start_offset == 0) {
             break;
 @@ -79,7 +79,7 @@ ErrorMsg *err_msg_create_with_offset(Buf *path, int line, int column, int offset
         line_start_offset -= 1;
     }
-    int line_end_offset = offset;
+    size_t line_end_offset = offset;
     while (source[line_end_offset] && source[line_end_offset] != '\n') {
         line_end_offset += 1;
     }
 @@ -89,8 +89,8 @@ ErrorMsg *err_msg_create_with_offset(Buf *path, int line, int column, int offset
     return err_msg;
 }
-ErrorMsg *err_msg_create_with_line(Buf *path, int line, int column,
+ErrorMsg *err_msg_create_with_line(Buf *path, size_t line, size_t column,
-        Buf *source, ZigList<int> *line_offsets, Buf *msg)
+        Buf *source, ZigList<size_t> *line_offsets, Buf *msg)
 {
     ErrorMsg *err_msg = allocate<ErrorMsg>(1);
     err_msg->path = path;
 @@ -98,13 +98,10 @@ ErrorMsg *err_msg_create_with_line(Buf *path, int line, int column,
     err_msg->column_start = column;
     err_msg->msg = msg;
-    int line_start_offset = line_offsets->at(line);
+    size_t line_start_offset = line_offsets->at(line);
-    int end_line = line + 1;
+    size_t end_line = line + 1;
-    int line_end_offset = (end_line >= line_offsets->length) ? buf_len(source) : line_offsets->at(line + 1);
+    size_t line_end_offset = (end_line >= line_offsets->length) ? buf_len(source) : line_offsets->at(line + 1);
-    int len = line_end_offset - line_start_offset - 1;
+    size_t len = (line_end_offset + 1 > line_start_offset) ? (line_end_offset - line_start_offset - 1) : 0;
-    if (len < 0) {
-        len = 0;
-    }
     buf_init_from_mem(&err_msg->line_buf, buf_ptr(source) + line_start_offset, len);

src/errmsg.hpp+5-5

...	@@ -18,8 +18,8 @@ enum ErrColor {	...	@@ -18,8 +18,8 @@ enum ErrColor {
18	};	18	};
19		19
20	struct ErrorMsg {	20	struct ErrorMsg {
21	int line_start;	21	size_t line_start;
22	int column_start;	22	size_t column_start;
23	Buf *msg;	23	Buf *msg;
24	Buf *path;	24	Buf *path;
25	Buf line_buf;	25	Buf line_buf;
...	@@ -30,10 +30,10 @@ struct ErrorMsg {	...	@@ -30,10 +30,10 @@ struct ErrorMsg {
30	void print_err_msg(ErrorMsg *msg, ErrColor color);	30	void print_err_msg(ErrorMsg *msg, ErrColor color);
31		31
32	void err_msg_add_note(ErrorMsg parent, ErrorMsg note);	32	void err_msg_add_note(ErrorMsg parent, ErrorMsg note);
33	ErrorMsg err_msg_create_with_offset(Buf path, int line, int column, int offset,	33	ErrorMsg err_msg_create_with_offset(Buf path, size_t line, size_t column, size_t offset,
34	const char source, Buf msg);	34	const char source, Buf msg);
35		35
36	ErrorMsg err_msg_create_with_line(Buf path, int line, int column,	36	ErrorMsg err_msg_create_with_line(Buf path, size_t line, size_t column,
37	Buf source, ZigList<int> line_offsets, Buf *msg);	37	Buf source, ZigList<size_t> line_offsets, Buf *msg);
38		38
39	#endif	39	#endif

src/eval.cpp+21-21

src/eval.hpp+1-1

...	@@ -10,7 +10,7 @@	...	@@ -10,7 +10,7 @@
10		10
11	#include "all_types.hpp"	11	#include "all_types.hpp"
12		12
13	bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_val, int branch_quota,	13	bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_val, size_t branch_quota,
14	AstNode *struct_node);	14	AstNode *struct_node);
15		15
16	bool const_values_equal(ConstExprValue a, ConstExprValue b, TypeTableEntry *type_entry);	16	bool const_values_equal(ConstExprValue a, ConstExprValue b, TypeTableEntry *type_entry);

src/link.cpp+11-11

src/list.hpp+20-17

...	@@ -23,13 +23,13 @@ struct ZigList {	...	@@ -23,13 +23,13 @@ struct ZigList {
23	}	23	}
24	// remember that the pointer to this item is invalid after you	24	// remember that the pointer to this item is invalid after you
25	// modify the length of the list	25	// modify the length of the list
26	const T & at(int index) const {	26	const T & at(size_t index) const {
27	assert(index >= 0);	27	assert(index != SIZE_MAX);
28	assert(index < length);	28	assert(index < length);
29	return items[index];	29	return items[index];
30	}	30	}
31	T & at(int index) {	31	T & at(size_t index) {
32	assert(index >= 0);	32	assert(index != SIZE_MAX);
33	assert(index < length);	33	assert(index < length);
34	return items[index];	34	return items[index];
35	}	35	}
...	@@ -52,8 +52,8 @@ struct ZigList {	...	@@ -52,8 +52,8 @@ struct ZigList {
52	return items[length - 1];	52	return items[length - 1];
53	}	53	}
54		54
55	void resize(int new_length) {	55	void resize(size_t new_length) {
56	assert(new_length >= 0);	56	assert(new_length != SIZE_MAX);
57	ensure_capacity(new_length);	57	ensure_capacity(new_length);
58	length = new_length;	58	length = new_length;
59	}	59	}
...	@@ -62,19 +62,22 @@ struct ZigList {	...	@@ -62,19 +62,22 @@ struct ZigList {
62	length = 0;	62	length = 0;
63	}	63	}
64		64
65	void ensure_capacity(int new_capacity) {	65	void ensure_capacity(size_t new_capacity) {
66	int better_capacity = max(capacity, 16);	66	if (capacity >= new_capacity)
67	while (better_capacity < new_capacity)	67	return;
68	better_capacity = better_capacity * 2;	68
69	if (better_capacity != capacity) {	69	size_t better_capacity = capacity;
70	items = reallocate_nonzero(items, better_capacity);	70	do {
71	capacity = better_capacity;	71	better_capacity = better_capacity * 1.4 + 8;
72	}	72	} while (better_capacity < new_capacity);
		73
		74	items = reallocate_nonzero(items, capacity, better_capacity);
		75	capacity = better_capacity;
73	}	76	}
74		77
75	T * items;	78	T *items;
76	int length;	79	size_t length;
77	int capacity;	80	size_t capacity;
78	};	81	};
79		82
80	#endif	83	#endif

src/main.cpp+9-9

src/os.cpp+25-20

 @@ -73,7 +73,7 @@ static void os_spawn_process_posix(const char *exe, ZigList<const char *> &args,
         const char **argv = allocate<const char *>(args.length + 2);
         argv[0] = exe;
         argv[args.length + 1] = nullptr;
-        for (int i = 0; i < args.length; i += 1) {
+        for (size_t i = 0; i < args.length; i += 1) {
             argv[i + 1] = args.at(i);
         }
         execvp(exe, const_cast<char * const *>(argv));
 @@ -114,20 +114,25 @@ void os_path_dirname(Buf *full_path, Buf *out_dirname) {
 }
 void os_path_split(Buf *full_path, Buf *out_dirname, Buf *out_basename) {
-    int last_index = buf_len(full_path) - 1;
+    size_t len = buf_len(full_path);
-    if (last_index >= 0 && buf_ptr(full_path)[last_index] == '/') {
+    if (len != 0) {
-        last_index -= 1;
+        size_t last_index = len - 1;
-    }
+        if (buf_ptr(full_path)[last_index] == '/') {
-    for (int i = last_index; i >= 0; i -= 1) {
+            last_index -= 1;
-        uint8_t c = buf_ptr(full_path)[i];
+        }
-        if (c == '/') {
+        for (size_t i = last_index;;) {
-            if (out_dirname) {
+            uint8_t c = buf_ptr(full_path)[i];
-                buf_init_from_mem(out_dirname, buf_ptr(full_path), i);
+            if (c == '/') {
-            }
+                if (out_dirname) {
-            if (out_basename) {
+                    buf_init_from_mem(out_dirname, buf_ptr(full_path), i);
-                buf_init_from_mem(out_basename, buf_ptr(full_path) + i + 1, buf_len(full_path) - (i + 1));
+                }
+                if (out_basename) {
+                    buf_init_from_mem(out_basename, buf_ptr(full_path) + i + 1, buf_len(full_path) - (i + 1));
+                }
+                return;
             }
-            return;
+            if (i == 0) break;
+            i -= 1;
         }
     }
     if (out_dirname) buf_init_from_mem(out_dirname, ".", 1);
 @@ -246,7 +251,7 @@ static int os_exec_process_posix(const char *exe, ZigList<const char *> &args,
         const char **argv = allocate<const char *>(args.length + 2);
         argv[0] = exe;
         argv[args.length + 1] = nullptr;
-        for (int i = 0; i < args.length; i += 1) {
+        for (size_t i = 0; i < args.length; i += 1) {
             argv[i + 1] = args.at(i);
         }
         execvp(exe, const_cast<char * const *>(argv));
 @@ -297,11 +302,11 @@ static int os_exec_process_windows(const char *exe, ZigList<const char *> &args,
     buf_append_str(&command_line, exe);
     buf_append_char(&command_line, '\"');
-    for (int arg_i = 0; arg_i < args.length; arg_i += 1) {
+    for (size_t arg_i = 0; arg_i < args.length; arg_i += 1) {
         buf_append_str(&command_line, " \"");
         const char *arg = args.at(arg_i);
-        int arg_len = strlen(arg);
+        size_t arg_len = strlen(arg);
-        for (int c_i = 0; c_i < arg_len; c_i += 1) {
+        for (size_t c_i = 0; c_i < arg_len; c_i += 1) {
             if (arg[c_i] == '\"') {
                 zig_panic("TODO");
             }
 @@ -376,7 +381,7 @@ static int os_exec_process_windows(const char *exe, ZigList<const char *> &args,
     CloseHandle(g_hChildStd_ERR_Wr);
     CloseHandle(g_hChildStd_OUT_Wr);
-    static const int BUF_SIZE = 4 * 1024;
+    static const size_t BUF_SIZE = 4 * 1024;
     {
         DWORD dwRead;
         char chBuf[BUF_SIZE];
 @@ -540,7 +545,7 @@ static int os_buf_to_tmp_file_windows(Buf *contents, Buf *suffix, Buf *out_tmp_p
     const char base64[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
     assert(array_length(base64) == 64 + 1);
-    for (int i = 0; i < 8; i += 1) {
+    for (size_t i = 0; i < 8; i += 1) {
         buf_append_char(out_tmp_path, base64[rand() % 64]);
     }

src/parseh.cpp+11-11

src/parser.cpp+76-76

src/target.cpp+8-8

src/target.hpp+5-5

src/tokenizer.cpp+6-6

...	@@ -141,7 +141,7 @@ static const struct ZigKeyword zig_keywords[] = {	...	@@ -141,7 +141,7 @@ static const struct ZigKeyword zig_keywords[] = {
141	};	141	};
142		142
143	bool is_zig_keyword(Buf *buf) {	143	bool is_zig_keyword(Buf *buf) {
144	for (int i = 0; i < array_length(zig_keywords); i += 1) {	144	for (size_t i = 0; i < array_length(zig_keywords); i += 1) {
145	if (buf_eql_str(buf, zig_keywords[i].text)) {	145	if (buf_eql_str(buf, zig_keywords[i].text)) {
146	return true;	146	return true;
147	}	147	}
...	@@ -209,7 +209,7 @@ enum TokenizeState {	...	@@ -209,7 +209,7 @@ enum TokenizeState {
209		209
210	struct Tokenize {	210	struct Tokenize {
211	Buf *buf;	211	Buf *buf;
212	int pos;	212	size_t pos;
213	TokenizeState state;	213	TokenizeState state;
214	ZigList<Token> *tokens;	214	ZigList<Token> *tokens;
215	int line;	215	int line;
...	@@ -329,7 +329,7 @@ static void end_float_token(Tokenize *t) {	...	@@ -329,7 +329,7 @@ static void end_float_token(Tokenize *t) {
329	}	329	}
330	}	330	}
331	uint64_t double_bits = (exponent_bits << 52) \| significand_bits;	331	uint64_t double_bits = (exponent_bits << 52) \| significand_bits;
332	memcpy(&t->cur_tok->data.num_lit.bignum.data.x_float, &double_bits, sizeof(double));	332	safe_memcpy(&t->cur_tok->data.num_lit.bignum.data.x_float, (double *)&double_bits, 1);
333	}	333	}
334		334
335	static void end_token(Tokenize *t) {	335	static void end_token(Tokenize *t) {
...	@@ -397,7 +397,7 @@ void tokenize(Buf buf, Tokenization out) {	...	@@ -397,7 +397,7 @@ void tokenize(Buf buf, Tokenization out) {
397	t.tokens = out->tokens = allocate<ZigList<Token>>(1);	397	t.tokens = out->tokens = allocate<ZigList<Token>>(1);
398	t.buf = buf;	398	t.buf = buf;
399		399
400	out->line_offsets = allocate<ZigList<int>>(1);	400	out->line_offsets = allocate<ZigList<size_t>>(1);
401		401
402	out->line_offsets->append(0);	402	out->line_offsets->append(0);
403	for (t.pos = 0; t.pos < buf_len(t.buf); t.pos += 1) {	403	for (t.pos = 0; t.pos < buf_len(t.buf); t.pos += 1) {
...	@@ -1545,10 +1545,10 @@ const char * token_name(TokenId id) {	...	@@ -1545,10 +1545,10 @@ const char * token_name(TokenId id) {
1545	}	1545	}
1546		1546
1547	void print_tokens(Buf buf, ZigList<Token> tokens) {	1547	void print_tokens(Buf buf, ZigList<Token> tokens) {
1548	for (int i = 0; i < tokens->length; i += 1) {	1548	for (size_t i = 0; i < tokens->length; i += 1) {
1549	Token *token = &tokens->at(i);	1549	Token *token = &tokens->at(i);
1550	fprintf(stderr, "%s ", token_name(token->id));	1550	fprintf(stderr, "%s ", token_name(token->id));
1551	if (token->start_pos >= 0) {	1551	if (token->start_pos != SIZE_MAX) {
1552	fwrite(buf_ptr(buf) + token->start_pos, 1, token->end_pos - token->start_pos, stderr);	1552	fwrite(buf_ptr(buf) + token->start_pos, 1, token->end_pos - token->start_pos, stderr);
1553	}	1553	}
1554	fprintf(stderr, "\n");	1554	fprintf(stderr, "\n");

src/tokenizer.hpp+7-7

...	@@ -131,10 +131,10 @@ struct TokenCharLit {	...	@@ -131,10 +131,10 @@ struct TokenCharLit {
131		131
132	struct Token {	132	struct Token {
133	TokenId id;	133	TokenId id;
134	int start_pos;	134	size_t start_pos;
135	int end_pos;	135	size_t end_pos;
136	int start_line;	136	size_t start_line;
137	int start_column;	137	size_t start_column;
138		138
139	union {	139	union {
140	// TokenIdNumberLiteral	140	// TokenIdNumberLiteral
...	@@ -150,12 +150,12 @@ struct Token {	...	@@ -150,12 +150,12 @@ struct Token {
150		150
151	struct Tokenization {	151	struct Tokenization {
152	ZigList<Token> *tokens;	152	ZigList<Token> *tokens;
153	ZigList<int> *line_offsets;	153	ZigList<size_t> *line_offsets;
154		154
155	// if an error occurred	155	// if an error occurred
156	Buf *err;	156	Buf *err;
157	int err_line;	157	size_t err_line;
158	int err_column;	158	size_t err_column;
159	};	159	};
160		160
161	void tokenize(Buf buf, Tokenization out_tokenization);	161	void tokenize(Buf buf, Tokenization out_tokenization);

src/util.hpp+23-3

...	@@ -45,15 +45,35 @@ __attribute__((malloc)) static inline T *allocate(size_t count) {	...	@@ -45,15 +45,35 @@ __attribute__((malloc)) static inline T *allocate(size_t count) {
45	}	45	}
46		46
47	template<typename T>	47	template<typename T>
48	static inline T reallocate_nonzero(T old, size_t new_count) {	48	static inline void safe_memcpy(T dest, const T src, size_t count) {
		49	#ifdef NDEBUG
		50	memcpy(dest, src, count * sizeof(T));
		51	#else
		52	// manually assign every elment to trigger compile error for non-copyable structs
		53	for (size_t i = 0; i < count; i += 1) {
		54	dest[i] = src[i];
		55	}
		56	#endif
		57	}
		58
		59	template<typename T>
		60	static inline T reallocate_nonzero(T old, size_t old_count, size_t new_count) {
		61	#ifdef NDEBUG
49	T ptr = reinterpret_cast<T>(realloc(old, new_count * sizeof(T)));	62	T ptr = reinterpret_cast<T>(realloc(old, new_count * sizeof(T)));
50	if (!ptr)	63	if (!ptr)
51	zig_panic("allocation failed");	64	zig_panic("allocation failed");
52	return ptr;	65	return ptr;
		66	#else
		67	// manually assign every element to trigger compile error for non-copyable structs
		68	T *ptr = allocate_nonzero<T>(new_count);
		69	safe_memcpy(ptr, old, old_count);
		70	free(old);
		71	return ptr;
		72	#endif
53	}	73	}
54		74
55	template <typename T, long n>	75	template <typename T, size_t n>
56	constexpr long array_length(const T (&)[n]) {	76	constexpr size_t array_length(const T (&)[n]) {
57	return n;	77	return n;
58	}	78	}
59		79

std/list.zig+3-4

 @@ -42,15 +42,14 @@ pub struct SmallList(T: type, static_size: usize) {
     }
     pub fn ensureCapacity(l: &Self, new_capacity: usize) -> %void {
-        const old_capacity = l.items.len;
+        var better_capacity = l.items.len;
-        var better_capacity = old_capacity;
         while (better_capacity < new_capacity) {
             better_capacity *= 2;
         }
-        if (better_capacity != old_capacity) {
+        if (better_capacity != l.items.len) {
             if (l.items.ptr == &l.prealloc_items[0]) {
                 l.items = %return l.allocator.alloc(T, better_capacity);
-                mem.copy(T, l.items, l.prealloc_items[0...old_capacity]);
+                mem.copy(T, l.items, l.prealloc_items[0...l.len]);
             } else {
                 l.items = %return l.allocator.realloc(T, l.items, better_capacity);
             }

test/run_tests.cpp+18-16

...	@@ -75,7 +75,7 @@ static bool eval_block(EvalFn ef, AstNode node, ConstExprValue *out) {	...	@@ -75,7 +75,7 @@ static bool eval_block(EvalFn ef, AstNode node, ConstExprValue *out) {
75	my_scope->block_context = node->block_context;	75	my_scope->block_context = node->block_context;
76	ef->scope_stack.append(my_scope);	76	ef->scope_stack.append(my_scope);
77		77
78	for (int i = 0; i < node->data.block.statements.length; i += 1) {	78	for (size_t i = 0; i < node->data.block.statements.length; i += 1) {
79	AstNode *child = node->data.block.statements.at(i);	79	AstNode *child = node->data.block.statements.at(i);
80	memset(out, 0, sizeof(ConstExprValue));	80	memset(out, 0, sizeof(ConstExprValue));
81	if (eval_expr(ef, child, out)) return true;	81	if (eval_expr(ef, child, out)) return true;
...	@@ -413,10 +413,10 @@ static bool eval_bin_op_expr(EvalFn ef, AstNode node, ConstExprValue *out_val)	...	@@ -413,10 +413,10 @@ static bool eval_bin_op_expr(EvalFn ef, AstNode node, ConstExprValue *out_val)
413	}	413	}
414		414
415	static EvalVar find_var(EvalFn ef, Buf *name) {	415	static EvalVar find_var(EvalFn ef, Buf *name) {
416	int scope_index = ef->scope_stack.length - 1;	416	size_t scope_index = ef->scope_stack.length - 1;
417	while (scope_index >= 0) {	417	while (scope_index != SIZE_MAX) {
418	EvalScope *scope = ef->scope_stack.at(scope_index);	418	EvalScope *scope = ef->scope_stack.at(scope_index);
419	for (int var_i = 0; var_i < scope->vars.length; var_i += 1) {	419	for (size_t var_i = 0; var_i < scope->vars.length; var_i += 1) {
420	EvalVar *var = &scope->vars.at(var_i);	420	EvalVar *var = &scope->vars.at(var_i);
421	if (buf_eql_buf(var->name, name)) {	421	if (buf_eql_buf(var->name, name)) {
422	return var;	422	return var;
...	@@ -466,18 +466,18 @@ static bool eval_container_init_expr(EvalFn ef, AstNode node, ConstExprValue *	...	@@ -466,18 +466,18 @@ static bool eval_container_init_expr(EvalFn ef, AstNode node, ConstExprValue *
466	!container_type->data.structure.is_slice &&	466	!container_type->data.structure.is_slice &&
467	kind == ContainerInitKindStruct)	467	kind == ContainerInitKindStruct)
468	{	468	{
469	int expr_field_count = container_init_expr->entries.length;	469	size_t expr_field_count = container_init_expr->entries.length;
470	int actual_field_count = container_type->data.structure.src_field_count;	470	size_t actual_field_count = container_type->data.structure.src_field_count;
471	assert(expr_field_count == actual_field_count);	471	assert(expr_field_count == actual_field_count);
472		472
473	out_val->data.x_struct.fields = allocate<ConstExprValue*>(actual_field_count);	473	out_val->data.x_struct.fields = allocate<ConstExprValue*>(actual_field_count);
474		474
475	for (int i = 0; i < expr_field_count; i += 1) {	475	for (size_t i = 0; i < expr_field_count; i += 1) {
476	AstNode *val_field_node = container_init_expr->entries.at(i);	476	AstNode *val_field_node = container_init_expr->entries.at(i);
477	assert(val_field_node->type == NodeTypeStructValueField);	477	assert(val_field_node->type == NodeTypeStructValueField);
478		478
479	TypeStructField *type_field = val_field_node->data.struct_val_field.type_struct_field;	479	TypeStructField *type_field = val_field_node->data.struct_val_field.type_struct_field;
480	int field_index = type_field->src_index;	480	size_t field_index = type_field->src_index;
481		481
482	ConstExprValue src_field_val = {0};	482	ConstExprValue src_field_val = {0};
483	if (eval_expr(ef, val_field_node->data.struct_val_field.expr, &src_field_val)) return true;	483	if (eval_expr(ef, val_field_node->data.struct_val_field.expr, &src_field_val)) return true;
...	@@ -496,12 +496,12 @@ static bool eval_container_init_expr(EvalFn ef, AstNode node, ConstExprValue *	...	@@ -496,12 +496,12 @@ static bool eval_container_init_expr(EvalFn ef, AstNode node, ConstExprValue *
496	kind == ContainerInitKindArray)	496	kind == ContainerInitKindArray)
497	{	497	{
498		498
499	int elem_count = container_init_expr->entries.length;	499	size_t elem_count = container_init_expr->entries.length;
500		500
501	out_val->ok = true;	501	out_val->ok = true;
502	out_val->data.x_array.fields = allocate<ConstExprValue*>(elem_count);	502	out_val->data.x_array.fields = allocate<ConstExprValue*>(elem_count);
503		503
504	for (int i = 0; i < elem_count; i += 1) {	504	for (size_t i = 0; i < elem_count; i += 1) {
505	AstNode *elem_node = container_init_expr->entries.at(i);	505	AstNode *elem_node = container_init_expr->entries.at(i);
506		506
507	ConstExprValue *elem_val = allocate<ConstExprValue>(1);	507	ConstExprValue *elem_val = allocate<ConstExprValue>(1);
...	@@ -698,7 +698,7 @@ void eval_const_expr_implicit_cast(CastOp cast_op,	...	@@ -698,7 +698,7 @@ void eval_const_expr_implicit_cast(CastOp cast_op,
698	static bool int_type_depends_on_compile_var(CodeGen g, TypeTableEntry int_type) {	698	static bool int_type_depends_on_compile_var(CodeGen g, TypeTableEntry int_type) {
699	assert(int_type->id == TypeTableEntryIdInt);	699	assert(int_type->id == TypeTableEntryIdInt);
700		700
701	for (int i = 0; i < CIntTypeCount; i += 1) {	701	for (size_t i = 0; i < CIntTypeCount; i += 1) {
702	if (int_type == g->builtin_types.entry_c_int[i]) {	702	if (int_type == g->builtin_types.entry_c_int[i]) {
703	return true;	703	return true;
704	}	704	}
...	@@ -918,9 +918,9 @@ static bool eval_fn_call_expr(EvalFn ef, AstNode node, ConstExprValue *out_val	...	@@ -918,9 +918,9 @@ static bool eval_fn_call_expr(EvalFn ef, AstNode node, ConstExprValue *out_val
918	fn_table_entry = fn_val.data.x_fn;	918	fn_table_entry = fn_val.data.x_fn;
919	}	919	}
920		920
921	int param_count = node->data.fn_call_expr.params.length;	921	size_t param_count = node->data.fn_call_expr.params.length;
922	ConstExprValue *args = allocate<ConstExprValue>(param_count);	922	ConstExprValue *args = allocate<ConstExprValue>(param_count);
923	for (int call_i = 0; call_i < param_count; call_i += 1) {	923	for (size_t call_i = 0; call_i < param_count; call_i += 1) {
924	AstNode *param_expr_node = node->data.fn_call_expr.params.at(call_i);	924	AstNode *param_expr_node = node->data.fn_call_expr.params.at(call_i);
925	ConstExprValue *param_val = &args[call_i];	925	ConstExprValue *param_val = &args[call_i];
926	if (eval_expr(ef, param_expr_node, param_val)) return true;	926	if (eval_expr(ef, param_expr_node, param_val)) return true;
...	@@ -1340,8 +1340,8 @@ static bool eval_fn_args(EvalFnRoot efr, FnTableEntry fn, ConstExprValue *args	...	@@ -1340,8 +1340,8 @@ static bool eval_fn_args(EvalFnRoot efr, FnTableEntry fn, ConstExprValue *args
1340	root_scope->block_context = fn->fn_def_node->data.fn_def.body->block_context;	1340	root_scope->block_context = fn->fn_def_node->data.fn_def.body->block_context;
1341	ef.scope_stack.append(root_scope);	1341	ef.scope_stack.append(root_scope);
1342		1342
1343	int param_count = acting_proto_node->data.fn_proto.params.length;	1343	size_t param_count = acting_proto_node->data.fn_proto.params.length;
1344	for (int proto_i = 0; proto_i < param_count; proto_i += 1) {	1344	for (size_t proto_i = 0; proto_i < param_count; proto_i += 1) {
1345	AstNode *decl_param_node = acting_proto_node->data.fn_proto.params.at(proto_i);	1345	AstNode *decl_param_node = acting_proto_node->data.fn_proto.params.at(proto_i);
1346	assert(decl_param_node->type == NodeTypeParamDecl);	1346	assert(decl_param_node->type == NodeTypeParamDecl);
1347		1347
...	@@ -1358,7 +1358,7 @@ static bool eval_fn_args(EvalFnRoot efr, FnTableEntry fn, ConstExprValue *args	...	@@ -1358,7 +1358,7 @@ static bool eval_fn_args(EvalFnRoot efr, FnTableEntry fn, ConstExprValue *args
1358	}	1358	}
1359		1359
1360	bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_val,	1360	bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_val,
1361	int branch_quota, AstNode *struct_node)	1361	size_t branch_quota, AstNode *struct_node)
1362	{	1362	{
1363	assert(node->type == NodeTypeFnCallExpr);	1363	assert(node->type == NodeTypeFnCallExpr);
1364		1364
...	@@ -1375,17 +1375,17 @@ bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_va	...	@@ -1375,17 +1375,17 @@ bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_va
1375	acting_proto_node = fn->proto_node;	1375	acting_proto_node = fn->proto_node;
1376	}	1376	}
1377		1377
1378	int call_param_count = node->data.fn_call_expr.params.length;	1378	size_t call_param_count = node->data.fn_call_expr.params.length;
1379	int proto_param_count = acting_proto_node->data.fn_proto.params.length;	1379	size_t proto_param_count = acting_proto_node->data.fn_proto.params.length;
1380	ConstExprValue *args = allocate<ConstExprValue>(proto_param_count);	1380	ConstExprValue *args = allocate<ConstExprValue>(proto_param_count);
1381	int next_arg_index = 0;	1381	size_t next_arg_index = 0;
1382	if (struct_node) {	1382	if (struct_node) {
1383	ConstExprValue *struct_val = &get_resolved_expr(struct_node)->const_val;	1383	ConstExprValue *struct_val = &get_resolved_expr(struct_node)->const_val;
1384	assert(struct_val->ok);	1384	assert(struct_val->ok);
1385	args[next_arg_index] = *struct_val;	1385	args[next_arg_index] = *struct_val;
1386	next_arg_index += 1;	1386	next_arg_index += 1;
1387	}	1387	}
1388	for (int call_index = 0; call_index < call_param_count; call_index += 1) {	1388	for (size_t call_index = 0; call_index < call_param_count; call_index += 1) {
1389	AstNode *call_param_node = node->data.fn_call_expr.params.at(call_index);	1389	AstNode *call_param_node = node->data.fn_call_expr.params.at(call_index);
1390	ConstExprValue *src_const_val = &get_resolved_expr(call_param_node)->const_val;	1390	ConstExprValue *src_const_val = &get_resolved_expr(call_param_node)->const_val;
1391	assert(src_const_val->ok);	1391	assert(src_const_val->ok);
...	@@ -1396,7 +1396,7 @@ bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_va	...	@@ -1396,7 +1396,7 @@ bool eval_fn(CodeGen g, AstNode node, FnTableEntry fn, ConstExprValue out_va
1396		1396
1397	if (efr.exceeded_quota_node) {	1397	if (efr.exceeded_quota_node) {
1398	ErrorMsg *msg = add_node_error(g, fn->fn_def_node,	1398	ErrorMsg *msg = add_node_error(g, fn->fn_def_node,
1399	buf_sprintf("function evaluation exceeded %d branches", efr.branch_quota));	1399	buf_sprintf("function evaluation exceeded %zu branches", efr.branch_quota));
1400		1400
1401	add_error_note(g, msg, efr.call_node, buf_sprintf("called from here"));	1401	add_error_note(g, msg, efr.call_node, buf_sprintf("called from here"));
1402	add_error_note(g, msg, efr.exceeded_quota_node, buf_sprintf("quota exceeded here"));	1402	add_error_note(g, msg, efr.exceeded_quota_node, buf_sprintf("quota exceeded here"));

...	@@ -172,9 +172,9 @@ static void construct_linker_job_linux(LinkJob *lj) {	...	@@ -172,9 +172,9 @@ static void construct_linker_job_linux(LinkJob *lj) {
172	lj->args.append("-shared");	172	lj->args.append("-shared");
173		173
174	buf_resize(&lj->out_file, 0);	174	buf_resize(&lj->out_file, 0);
175	buf_appendf(&lj->out_file, "lib%s.so.%d.%d.%d",	175	buf_appendf(&lj->out_file, "lib%s.so.%zu.%zu.%zu",
176	buf_ptr(g->root_out_name), g->version_major, g->version_minor, g->version_patch);	176	buf_ptr(g->root_out_name), g->version_major, g->version_minor, g->version_patch);
177	soname = buf_sprintf("lib%s.so.%d", buf_ptr(g->root_out_name), g->version_major);	177	soname = buf_sprintf("lib%s.so.%zu", buf_ptr(g->root_out_name), g->version_major);
178	}	178	}
179		179
180	lj->args.append("-o");	180	lj->args.append("-o");
...	@@ -195,7 +195,7 @@ static void construct_linker_job_linux(LinkJob *lj) {	...	@@ -195,7 +195,7 @@ static void construct_linker_job_linux(LinkJob *lj) {
195	lj->args.append(get_libc_static_file(g, crtbegino));	195	lj->args.append(get_libc_static_file(g, crtbegino));
196	}	196	}
197		197
198	for (int i = 0; i < g->lib_dirs.length; i += 1) {	198	for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
199	const char *lib_dir = g->lib_dirs.at(i);	199	const char *lib_dir = g->lib_dirs.at(i);
200	lj->args.append("-L");	200	lj->args.append("-L");
201	lj->args.append(lib_dir);	201	lj->args.append(lib_dir);
...	@@ -239,7 +239,7 @@ static void construct_linker_job_linux(LinkJob *lj) {	...	@@ -239,7 +239,7 @@ static void construct_linker_job_linux(LinkJob *lj) {
239	lj->args.append(buf_ptr(compiler_rt_o_path));	239	lj->args.append(buf_ptr(compiler_rt_o_path));
240	}	240	}
241		241
242	for (int i = 0; i < g->link_libs.length; i += 1) {	242	for (size_t i = 0; i < g->link_libs.length; i += 1) {
243	Buf *link_lib = g->link_libs.at(i);	243	Buf *link_lib = g->link_libs.at(i);
244	Buf *arg;	244	Buf *arg;
245	if (buf_starts_with_str(link_lib, "/") \|\| buf_ends_with_str(link_lib, ".a") \|\|	245	if (buf_starts_with_str(link_lib, "/") \|\| buf_ends_with_str(link_lib, ".a") \|\|
...	@@ -350,7 +350,7 @@ static void construct_linker_job_mingw(LinkJob *lj) {	...	@@ -350,7 +350,7 @@ static void construct_linker_job_mingw(LinkJob *lj) {
350	lj->args.append(get_libc_static_file(g, "crtbegin.o"));	350	lj->args.append(get_libc_static_file(g, "crtbegin.o"));
351	}	351	}
352		352
353	for (int i = 0; i < g->lib_dirs.length; i += 1) {	353	for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
354	const char *lib_dir = g->lib_dirs.at(i);	354	const char *lib_dir = g->lib_dirs.at(i);
355	lj->args.append("-L");	355	lj->args.append("-L");
356	lj->args.append(lib_dir);	356	lj->args.append(lib_dir);
...	@@ -381,7 +381,7 @@ static void construct_linker_job_mingw(LinkJob *lj) {	...	@@ -381,7 +381,7 @@ static void construct_linker_job_mingw(LinkJob *lj) {
381	}	381	}
382		382
383		383
384	for (int i = 0; i < g->link_libs.length; i += 1) {	384	for (size_t i = 0; i < g->link_libs.length; i += 1) {
385	Buf *link_lib = g->link_libs.at(i);	385	Buf *link_lib = g->link_libs.at(i);
386	Buf *arg = buf_sprintf("-l%s", buf_ptr(link_lib));	386	Buf *arg = buf_sprintf("-l%s", buf_ptr(link_lib));
387	lj->args.append(buf_ptr(arg));	387	lj->args.append(buf_ptr(arg));
...	@@ -635,7 +635,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {	...	@@ -635,7 +635,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {
635	}	635	}
636	}	636	}
637		637
638	for (int i = 0; i < g->lib_dirs.length; i += 1) {	638	for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
639	const char *lib_dir = g->lib_dirs.at(i);	639	const char *lib_dir = g->lib_dirs.at(i);
640	lj->args.append("-L");	640	lj->args.append("-L");
641	lj->args.append(lib_dir);	641	lj->args.append(lib_dir);
...	@@ -649,7 +649,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {	...	@@ -649,7 +649,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {
649	lj->args.append(buf_ptr(test_runner_o_path));	649	lj->args.append(buf_ptr(test_runner_o_path));
650	}	650	}
651		651
652	for (int i = 0; i < g->link_libs.length; i += 1) {	652	for (size_t i = 0; i < g->link_libs.length; i += 1) {
653	Buf *link_lib = g->link_libs.at(i);	653	Buf *link_lib = g->link_libs.at(i);
654	Buf *arg = buf_sprintf("-l%s", buf_ptr(link_lib));	654	Buf *arg = buf_sprintf("-l%s", buf_ptr(link_lib));
655	lj->args.append(buf_ptr(arg));	655	lj->args.append(buf_ptr(arg));
...	@@ -671,7 +671,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {	...	@@ -671,7 +671,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {
671	zig_panic("TODO");	671	zig_panic("TODO");
672	}	672	}
673		673
674	for (int i = 0; i < g->darwin_frameworks.length; i += 1) {	674	for (size_t i = 0; i < g->darwin_frameworks.length; i += 1) {
675	lj->args.append("-framework");	675	lj->args.append("-framework");
676	lj->args.append(buf_ptr(g->darwin_frameworks.at(i)));	676	lj->args.append(buf_ptr(g->darwin_frameworks.at(i)));
677	}	677	}
...	@@ -829,7 +829,7 @@ void codegen_link(CodeGen g, const char out_file) {	...	@@ -829,7 +829,7 @@ void codegen_link(CodeGen g, const char out_file) {
829		829
830	if (g->verbose) {	830	if (g->verbose) {
831	fprintf(stderr, "%s", buf_ptr(g->linker_path));	831	fprintf(stderr, "%s", buf_ptr(g->linker_path));
832	for (int i = 0; i < lj.args.length; i += 1) {	832	for (size_t i = 0; i < lj.args.length; i += 1) {
833	fprintf(stderr, " %s", lj.args.at(i));	833	fprintf(stderr, " %s", lj.args.at(i));
834	}	834	}
835	fprintf(stderr, "\n");	835	fprintf(stderr, "\n");
...	@@ -853,7 +853,7 @@ void codegen_link(CodeGen g, const char out_file) {	...	@@ -853,7 +853,7 @@ void codegen_link(CodeGen g, const char out_file) {
853	fprintf(stderr, "linker failed\n");	853	fprintf(stderr, "linker failed\n");
854	}	854	}
855	fprintf(stderr, "%s ", buf_ptr(g->linker_path));	855	fprintf(stderr, "%s ", buf_ptr(g->linker_path));
856	for (int i = 0; i < lj.args.length; i += 1) {	856	for (size_t i = 0; i < lj.args.length; i += 1) {
857	fprintf(stderr, "%s ", lj.args.at(i));	857	fprintf(stderr, "%s ", lj.args.at(i));
858	}	858	}
859	fprintf(stderr, "\n%s\n", buf_ptr(&ld_stderr));	859	fprintf(stderr, "\n%s\n", buf_ptr(&ld_stderr));

...	@@ -64,8 +64,8 @@ static int print_target_list(FILE *f) {	...	@@ -64,8 +64,8 @@ static int print_target_list(FILE *f) {
64	get_native_target(&native);	64	get_native_target(&native);
65		65
66	fprintf(f, "Architectures:\n");	66	fprintf(f, "Architectures:\n");
67	int arch_count = target_arch_count();	67	size_t arch_count = target_arch_count();
68	for (int arch_i = 0; arch_i < arch_count; arch_i += 1) {	68	for (size_t arch_i = 0; arch_i < arch_count; arch_i += 1) {
69	const ArchType *arch = get_target_arch(arch_i);	69	const ArchType *arch = get_target_arch(arch_i);
70	char arch_name[50];	70	char arch_name[50];
71	get_arch_name(arch_name, arch);	71	get_arch_name(arch_name, arch);
...	@@ -75,16 +75,16 @@ static int print_target_list(FILE *f) {	...	@@ -75,16 +75,16 @@ static int print_target_list(FILE *f) {
75	}	75	}
76		76
77	fprintf(f, "\nOperating Systems:\n");	77	fprintf(f, "\nOperating Systems:\n");
78	int os_count = target_os_count();	78	size_t os_count = target_os_count();
79	for (int i = 0; i < os_count; i += 1) {	79	for (size_t i = 0; i < os_count; i += 1) {
80	ZigLLVM_OSType os_type = get_target_os(i);	80	ZigLLVM_OSType os_type = get_target_os(i);
81	const char *native_str = (native.os == os_type) ? " (native)" : "";	81	const char *native_str = (native.os == os_type) ? " (native)" : "";
82	fprintf(f, " %s%s\n", get_target_os_name(os_type), native_str);	82	fprintf(f, " %s%s\n", get_target_os_name(os_type), native_str);
83	}	83	}
84		84
85	fprintf(f, "\nEnvironments:\n");	85	fprintf(f, "\nEnvironments:\n");
86	int environ_count = target_environ_count();	86	size_t environ_count = target_environ_count();
87	for (int i = 0; i < environ_count; i += 1) {	87	for (size_t i = 0; i < environ_count; i += 1) {
88	ZigLLVM_EnvironmentType environ_type = get_target_environ(i);	88	ZigLLVM_EnvironmentType environ_type = get_target_environ(i);
89	const char *native_str = (native.env_type == environ_type) ? " (native)" : "";	89	const char *native_str = (native.env_type == environ_type) ? " (native)" : "";
90	fprintf(f, " %s%s\n", ZigLLVMGetEnvironmentTypeName(environ_type), native_str);	90	fprintf(f, " %s%s\n", ZigLLVMGetEnvironmentTypeName(environ_type), native_str);
...	@@ -375,13 +375,13 @@ int main(int argc, char **argv) {	...	@@ -375,13 +375,13 @@ int main(int argc, char **argv) {
375	codegen_set_verbose(g, verbose);	375	codegen_set_verbose(g, verbose);
376	codegen_set_errmsg_color(g, color);	376	codegen_set_errmsg_color(g, color);
377		377
378	for (int i = 0; i < lib_dirs.length; i += 1) {	378	for (size_t i = 0; i < lib_dirs.length; i += 1) {
379	codegen_add_lib_dir(g, lib_dirs.at(i));	379	codegen_add_lib_dir(g, lib_dirs.at(i));
380	}	380	}
381	for (int i = 0; i < link_libs.length; i += 1) {	381	for (size_t i = 0; i < link_libs.length; i += 1) {
382	codegen_add_link_lib(g, link_libs.at(i));	382	codegen_add_link_lib(g, link_libs.at(i));
383	}	383	}
384	for (int i = 0; i < frameworks.length; i += 1) {	384	for (size_t i = 0; i < frameworks.length; i += 1) {
385	codegen_add_framework(g, frameworks.at(i));	385	codegen_add_framework(g, frameworks.at(i));
386	}	386	}
387		387

...	@@ -244,10 +244,10 @@ static AstNode create_fn_proto_node(Context c, Buf name, TypeTableEntry fn_t	...	@@ -244,10 +244,10 @@ static AstNode create_fn_proto_node(Context c, Buf name, TypeTableEntry fn_t
244	node->data.fn_proto.name = name;	244	node->data.fn_proto.name = name;
245	node->data.fn_proto.return_type = make_type_node(c, fn_type->data.fn.fn_type_id.return_type);	245	node->data.fn_proto.return_type = make_type_node(c, fn_type->data.fn.fn_type_id.return_type);
246		246
247	for (int i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {	247	for (size_t i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {
248	FnTypeParamInfo *info = &fn_type->data.fn.fn_type_id.param_info[i];	248	FnTypeParamInfo *info = &fn_type->data.fn.fn_type_id.param_info[i];
249	char arg_name[20];	249	char arg_name[20];
250	sprintf(arg_name, "arg_%d", i);	250	sprintf(arg_name, "arg_%zu", i);
251	node->data.fn_proto.params.append(create_param_decl_node(c, arg_name,	251	node->data.fn_proto.params.append(create_param_decl_node(c, arg_name,
252	make_type_node(c, info->type), info->is_noalias));	252	make_type_node(c, info->type), info->is_noalias));
253	}	253	}
...	@@ -272,7 +272,7 @@ static AstNode create_inline_fn_node(Context c, Buf fn_name, Buf var_name, T	...	@@ -272,7 +272,7 @@ static AstNode create_inline_fn_node(Context c, Buf fn_name, Buf var_name, T
272		272
273	AstNode *fn_call_node = create_node(c, NodeTypeFnCallExpr);	273	AstNode *fn_call_node = create_node(c, NodeTypeFnCallExpr);
274	fn_call_node->data.fn_call_expr.fn_ref_expr = unwrap_node;	274	fn_call_node->data.fn_call_expr.fn_ref_expr = unwrap_node;
275	for (int i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {	275	for (size_t i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {
276	AstNode *decl_node = node->data.fn_def.fn_proto->data.fn_proto.params.at(i);	276	AstNode *decl_node = node->data.fn_def.fn_proto->data.fn_proto.params.at(i);
277	Buf *param_name = decl_node->data.param_decl.name;	277	Buf *param_name = decl_node->data.param_decl.name;
278	fn_call_node->data.fn_call_expr.params.append(create_symbol_node(c, buf_ptr(param_name)));	278	fn_call_node->data.fn_call_expr.params.append(create_symbol_node(c, buf_ptr(param_name)));
...	@@ -621,7 +621,7 @@ static TypeTableEntry resolve_type_with_table(Context c, const Type *ty, const	...	@@ -621,7 +621,7 @@ static TypeTableEntry resolve_type_with_table(Context c, const Type *ty, const
621	fn_type_id.param_info = &fn_type_id.prealloc_param_info[0];	621	fn_type_id.param_info = &fn_type_id.prealloc_param_info[0];
622	}	622	}
623		623
624	for (int i = 0; i < fn_type_id.param_count; i += 1) {	624	for (size_t i = 0; i < fn_type_id.param_count; i += 1) {
625	QualType qt = fn_proto_ty->getParamType(i);	625	QualType qt = fn_proto_ty->getParamType(i);
626	TypeTableEntry *param_type = resolve_qual_type(c, qt, decl);	626	TypeTableEntry *param_type = resolve_qual_type(c, qt, decl);
627		627
...	@@ -748,16 +748,16 @@ static void visit_fn_decl(Context c, const FunctionDecl fn_decl) {	...	@@ -748,16 +748,16 @@ static void visit_fn_decl(Context c, const FunctionDecl fn_decl) {
748		748
749	assert(!fn_type->data.fn.fn_type_id.is_naked);	749	assert(!fn_type->data.fn.fn_type_id.is_naked);
750		750
751	int arg_count = fn_type->data.fn.fn_type_id.param_count;	751	size_t arg_count = fn_type->data.fn.fn_type_id.param_count;
752	Buf name_buf = BUF_INIT;	752	Buf name_buf = BUF_INIT;
753	for (int i = 0; i < arg_count; i += 1) {	753	for (size_t i = 0; i < arg_count; i += 1) {
754	FnTypeParamInfo *param_info = &fn_type->data.fn.fn_type_id.param_info[i];	754	FnTypeParamInfo *param_info = &fn_type->data.fn.fn_type_id.param_info[i];
755	AstNode *type_node = make_type_node(c, param_info->type);	755	AstNode *type_node = make_type_node(c, param_info->type);
756	const ParmVarDecl *param = fn_decl->getParamDecl(i);	756	const ParmVarDecl *param = fn_decl->getParamDecl(i);
757	const char *name = decl_name(param);	757	const char *name = decl_name(param);
758	if (strlen(name) == 0) {	758	if (strlen(name) == 0) {
759	buf_resize(&name_buf, 0);	759	buf_resize(&name_buf, 0);
760	buf_appendf(&name_buf, "arg%d", i);	760	buf_appendf(&name_buf, "arg%zu", i);
761	name = buf_ptr(&name_buf);	761	name = buf_ptr(&name_buf);
762	}	762	}
763		763
...	@@ -1316,7 +1316,7 @@ static bool name_exists_and_const(Context c, Buf name) {	...	@@ -1316,7 +1316,7 @@ static bool name_exists_and_const(Context c, Buf name) {
1316	}	1316	}
1317		1317
1318	static void render_aliases(Context *c) {	1318	static void render_aliases(Context *c) {
1319	for (int i = 0; i < c->aliases.length; i += 1) {	1319	for (size_t i = 0; i < c->aliases.length; i += 1) {
1320	AstNode *alias_node = c->aliases.at(i);	1320	AstNode *alias_node = c->aliases.at(i);
1321	assert(alias_node->type == NodeTypeVariableDeclaration);	1321	assert(alias_node->type == NodeTypeVariableDeclaration);
1322	Buf *name = alias_node->data.variable_declaration.symbol;	1322	Buf *name = alias_node->data.variable_declaration.symbol;
...	@@ -1347,7 +1347,7 @@ static void process_macro(Context c, CTokenize ctok, Buf name, const char ch	...	@@ -1347,7 +1347,7 @@ static void process_macro(Context c, CTokenize ctok, Buf name, const char ch
1347	}	1347	}
1348		1348
1349	bool negate = false;	1349	bool negate = false;
1350	for (int i = 0; i < ctok->tokens.length; i += 1) {	1350	for (size_t i = 0; i < ctok->tokens.length; i += 1) {
1351	bool is_first = (i == 0);	1351	bool is_first = (i == 0);
1352	bool is_last = (i == ctok->tokens.length - 1);	1352	bool is_last = (i == ctok->tokens.length - 1);
1353	CTok *tok = &ctok->tokens.at(i);	1353	CTok *tok = &ctok->tokens.at(i);
...	@@ -1403,7 +1403,7 @@ static void process_macro(Context c, CTokenize ctok, Buf name, const char ch	...	@@ -1403,7 +1403,7 @@ static void process_macro(Context c, CTokenize ctok, Buf name, const char ch
1403	}	1403	}
1404		1404
1405	static void process_symbol_macros(Context *c) {	1405	static void process_symbol_macros(Context *c) {
1406	for (int i = 0; i < c->macro_symbols.length; i += 1) {	1406	for (size_t i = 0; i < c->macro_symbols.length; i += 1) {
1407	MacroSymbol ms = c->macro_symbols.at(i);	1407	MacroSymbol ms = c->macro_symbols.at(i);
1408	if (name_exists_and_const(c, ms.value)) {	1408	if (name_exists_and_const(c, ms.value)) {
1409	AstNode *var_node = create_var_decl_node(c, buf_ptr(ms.name),	1409	AstNode *var_node = create_var_decl_node(c, buf_ptr(ms.name),
...	@@ -1524,7 +1524,7 @@ int parse_h_file(ImportTableEntry import, ZigList<ErrorMsg > *errors, const ch	...	@@ -1524,7 +1524,7 @@ int parse_h_file(ImportTableEntry import, ZigList<ErrorMsg > *errors, const ch
1524	clang_argv.append("-isystem");	1524	clang_argv.append("-isystem");
1525	clang_argv.append(buf_ptr(codegen->libc_include_dir));	1525	clang_argv.append(buf_ptr(codegen->libc_include_dir));
1526		1526
1527	for (int i = 0; i < codegen->clang_argv_len; i += 1) {	1527	for (size_t i = 0; i < codegen->clang_argv_len; i += 1) {
1528	clang_argv.append(codegen->clang_argv[i]);	1528	clang_argv.append(codegen->clang_argv[i]);
1529	}	1529	}
1530		1530

...	@@ -156,7 +156,7 @@ static const ZigLLVM_ObjectFormatType oformat_list[] = {	...	@@ -156,7 +156,7 @@ static const ZigLLVM_ObjectFormatType oformat_list[] = {
156	ZigLLVM_MachO,	156	ZigLLVM_MachO,
157	};	157	};
158		158
159	int target_oformat_count(void) {	159	size_t target_oformat_count(void) {
160	return array_length(oformat_list);	160	return array_length(oformat_list);
161	}	161	}
162		162
...	@@ -174,7 +174,7 @@ const char *get_target_oformat_name(ZigLLVM_ObjectFormatType oformat) {	...	@@ -174,7 +174,7 @@ const char *get_target_oformat_name(ZigLLVM_ObjectFormatType oformat) {
174	zig_unreachable();	174	zig_unreachable();
175	}	175	}
176		176
177	int target_arch_count(void) {	177	size_t target_arch_count(void) {
178	return array_length(arch_list);	178	return array_length(arch_list);
179	}	179	}
180		180
...	@@ -182,7 +182,7 @@ const ArchType *get_target_arch(int index) {	...	@@ -182,7 +182,7 @@ const ArchType *get_target_arch(int index) {
182	return &arch_list[index];	182	return &arch_list[index];
183	}	183	}
184		184
185	int target_vendor_count(void) {	185	size_t target_vendor_count(void) {
186	return array_length(vendor_list);	186	return array_length(vendor_list);
187	}	187	}
188		188
...	@@ -190,7 +190,7 @@ ZigLLVM_VendorType get_target_vendor(int index) {	...	@@ -190,7 +190,7 @@ ZigLLVM_VendorType get_target_vendor(int index) {
190	return vendor_list[index];	190	return vendor_list[index];
191	}	191	}
192		192
193	int target_os_count(void) {	193	size_t target_os_count(void) {
194	return array_length(os_list);	194	return array_length(os_list);
195	}	195	}
196	ZigLLVM_OSType get_target_os(int index) {	196	ZigLLVM_OSType get_target_os(int index) {
...	@@ -201,7 +201,7 @@ const char *get_target_os_name(ZigLLVM_OSType os_type) {	...	@@ -201,7 +201,7 @@ const char *get_target_os_name(ZigLLVM_OSType os_type) {
201	return (os_type == ZigLLVM_UnknownOS) ? "freestanding" : ZigLLVMGetOSTypeName(os_type);	201	return (os_type == ZigLLVM_UnknownOS) ? "freestanding" : ZigLLVMGetOSTypeName(os_type);
202	}	202	}
203		203
204	int target_environ_count(void) {	204	size_t target_environ_count(void) {
205	return array_length(environ_list);	205	return array_length(environ_list);
206	}	206	}
207	ZigLLVM_EnvironmentType get_target_environ(int index) {	207	ZigLLVM_EnvironmentType get_target_environ(int index) {
...	@@ -237,7 +237,7 @@ void get_arch_name(char out_str, const ArchType arch) {	...	@@ -237,7 +237,7 @@ void get_arch_name(char out_str, const ArchType arch) {
237	}	237	}
238		238
239	int parse_target_arch(const char str, ArchType out_arch) {	239	int parse_target_arch(const char str, ArchType out_arch) {
240	for (int i = 0; i < array_length(arch_list); i += 1) {	240	for (size_t i = 0; i < array_length(arch_list); i += 1) {
241	const ArchType *arch = &arch_list[i];	241	const ArchType *arch = &arch_list[i];
242	char arch_name[50];	242	char arch_name[50];
243	get_arch_name_raw(arch_name, arch->arch, arch->sub_arch);	243	get_arch_name_raw(arch_name, arch->arch, arch->sub_arch);
...	@@ -250,7 +250,7 @@ int parse_target_arch(const char str, ArchType out_arch) {	...	@@ -250,7 +250,7 @@ int parse_target_arch(const char str, ArchType out_arch) {
250	}	250	}
251		251
252	int parse_target_os(const char str, ZigLLVM_OSType out_os) {	252	int parse_target_os(const char str, ZigLLVM_OSType out_os) {
253	for (int i = 0; i < array_length(os_list); i += 1) {	253	for (size_t i = 0; i < array_length(os_list); i += 1) {
254	ZigLLVM_OSType os = os_list[i];	254	ZigLLVM_OSType os = os_list[i];
255	const char *os_name = get_target_os_name(os);	255	const char *os_name = get_target_os_name(os);
256	if (strcmp(os_name, str) == 0) {	256	if (strcmp(os_name, str) == 0) {
...	@@ -262,7 +262,7 @@ int parse_target_os(const char str, ZigLLVM_OSType out_os) {	...	@@ -262,7 +262,7 @@ int parse_target_os(const char str, ZigLLVM_OSType out_os) {
262	}	262	}
263		263
264	int parse_target_environ(const char str, ZigLLVM_EnvironmentType out_environ) {	264	int parse_target_environ(const char str, ZigLLVM_EnvironmentType out_environ) {
265	for (int i = 0; i < array_length(environ_list); i += 1) {	265	for (size_t i = 0; i < array_length(environ_list); i += 1) {
266	ZigLLVM_EnvironmentType env_type = environ_list[i];	266	ZigLLVM_EnvironmentType env_type = environ_list[i];
267	const char *environ_name = ZigLLVMGetEnvironmentTypeName(env_type);	267	const char *environ_name = ZigLLVMGetEnvironmentTypeName(env_type);
268	if (strcmp(environ_name, str) == 0) {	268	if (strcmp(environ_name, str) == 0) {

...	@@ -38,22 +38,22 @@ enum CIntType {	...	@@ -38,22 +38,22 @@ enum CIntType {
38	CIntTypeCount,	38	CIntTypeCount,
39	};	39	};
40		40
41	int target_arch_count(void);	41	size_t target_arch_count(void);
42	const ArchType *get_target_arch(int index);	42	const ArchType *get_target_arch(int index);
43	void get_arch_name(char out_str, const ArchType arch);	43	void get_arch_name(char out_str, const ArchType arch);
44		44
45	int target_vendor_count(void);	45	size_t target_vendor_count(void);
46	ZigLLVM_VendorType get_target_vendor(int index);	46	ZigLLVM_VendorType get_target_vendor(int index);
47		47
48	int target_os_count(void);	48	size_t target_os_count(void);
49	ZigLLVM_OSType get_target_os(int index);	49	ZigLLVM_OSType get_target_os(int index);
50	const char *get_target_os_name(ZigLLVM_OSType os_type);	50	const char *get_target_os_name(ZigLLVM_OSType os_type);
51		51
52	int target_environ_count(void);	52	size_t target_environ_count(void);
53	ZigLLVM_EnvironmentType get_target_environ(int index);	53	ZigLLVM_EnvironmentType get_target_environ(int index);
54		54
55		55
56	int target_oformat_count(void);	56	size_t target_oformat_count(void);
57	const ZigLLVM_ObjectFormatType get_target_oformat(int index);	57	const ZigLLVM_ObjectFormatType get_target_oformat(int index);
58	const char *get_target_oformat_name(ZigLLVM_ObjectFormatType oformat);	58	const char *get_target_oformat_name(ZigLLVM_ObjectFormatType oformat);
59		59

...	@@ -93,7 +93,7 @@ static TestCase add_simple_case_libc(const char case_name, const char *source,	...	@@ -93,7 +93,7 @@ static TestCase add_simple_case_libc(const char case_name, const char *source,
93	return tc;	93	return tc;
94	}	94	}
95		95
96	static TestCase add_compile_fail_case(const char case_name, const char *source, int count, ...) {	96	static TestCase add_compile_fail_case(const char case_name, const char *source, size_t count, ...) {
97	va_list ap;	97	va_list ap;
98	va_start(ap, count);	98	va_start(ap, count);
99		99
...	@@ -103,7 +103,7 @@ static TestCase add_compile_fail_case(const char case_name, const char *source	...	@@ -103,7 +103,7 @@ static TestCase add_compile_fail_case(const char case_name, const char *source
103	test_case->source_files.at(0).relative_path = tmp_source_path;	103	test_case->source_files.at(0).relative_path = tmp_source_path;
104	test_case->source_files.at(0).source_code = source;	104	test_case->source_files.at(0).source_code = source;
105		105
106	for (int i = 0; i < count; i += 1) {	106	for (size_t i = 0; i < count; i += 1) {
107	const char arg = va_arg(ap, const char );	107	const char arg = va_arg(ap, const char );
108	test_case->compile_errors.append(arg);	108	test_case->compile_errors.append(arg);
109	}	109	}
...	@@ -181,7 +181,7 @@ static void add_debug_safety_case(const char case_name, const char source) {	...	@@ -181,7 +181,7 @@ static void add_debug_safety_case(const char case_name, const char source) {
181	}	181	}
182		182
183	static TestCase add_parseh_case(const char case_name, AllowWarnings allow_warnings,	183	static TestCase add_parseh_case(const char case_name, AllowWarnings allow_warnings,
184	const char *source, int count, ...)	184	const char *source, size_t count, ...)
185	{	185	{
186	va_list ap;	186	va_list ap;
187	va_start(ap, count);	187	va_start(ap, count);
...	@@ -195,7 +195,7 @@ static TestCase add_parseh_case(const char case_name, AllowWarnings allow_warn	...	@@ -195,7 +195,7 @@ static TestCase add_parseh_case(const char case_name, AllowWarnings allow_warn
195	test_case->source_files.at(0).relative_path = tmp_h_path;	195	test_case->source_files.at(0).relative_path = tmp_h_path;
196	test_case->source_files.at(0).source_code = source;	196	test_case->source_files.at(0).source_code = source;
197		197
198	for (int i = 0; i < count; i += 1) {	198	for (size_t i = 0; i < count; i += 1) {
199	const char arg = va_arg(ap, const char );	199	const char arg = va_arg(ap, const char );
200	test_case->compile_errors.append(arg);	200	test_case->compile_errors.append(arg);
201	}	201	}
...	@@ -1854,7 +1854,7 @@ static void run_self_hosted_test(bool is_release_mode) {	...	@@ -1854,7 +1854,7 @@ static void run_self_hosted_test(bool is_release_mode) {
1854	if (term.how != TerminationIdClean \|\| term.code != 0) {	1854	if (term.how != TerminationIdClean \|\| term.code != 0) {
1855	printf("\nSelf-hosted tests failed:\n");	1855	printf("\nSelf-hosted tests failed:\n");
1856	printf("./zig");	1856	printf("./zig");
1857	for (int i = 0; i < args.length; i += 1) {	1857	for (size_t i = 0; i < args.length; i += 1) {
1858	printf(" %s", args.at(i));	1858	printf(" %s", args.at(i));
1859	}	1859	}
1860	printf("\n%s\n", buf_ptr(&zig_stderr));	1860	printf("\n%s\n", buf_ptr(&zig_stderr));
...	@@ -1881,7 +1881,7 @@ static void add_self_hosted_tests(void) {	...	@@ -1881,7 +1881,7 @@ static void add_self_hosted_tests(void) {
1881		1881
1882	static void print_compiler_invocation(TestCase *test_case) {	1882	static void print_compiler_invocation(TestCase *test_case) {
1883	printf("%s", zig_exe);	1883	printf("%s", zig_exe);
1884	for (int i = 0; i < test_case->compiler_args.length; i += 1) {	1884	for (size_t i = 0; i < test_case->compiler_args.length; i += 1) {
1885	printf(" %s", test_case->compiler_args.at(i));	1885	printf(" %s", test_case->compiler_args.at(i));
1886	}	1886	}
1887	printf("\n");	1887	printf("\n");
...	@@ -1889,7 +1889,7 @@ static void print_compiler_invocation(TestCase *test_case) {	...	@@ -1889,7 +1889,7 @@ static void print_compiler_invocation(TestCase *test_case) {
1889		1889
1890	static void print_exe_invocation(TestCase *test_case) {	1890	static void print_exe_invocation(TestCase *test_case) {
1891	printf("%s", tmp_exe_path);	1891	printf("%s", tmp_exe_path);
1892	for (int i = 0; i < test_case->program_args.length; i += 1) {	1892	for (size_t i = 0; i < test_case->program_args.length; i += 1) {
1893	printf(" %s", test_case->program_args.at(i));	1893	printf(" %s", test_case->program_args.at(i));
1894	}	1894	}
1895	printf("\n");	1895	printf("\n");
...	@@ -1900,7 +1900,7 @@ static void run_test(TestCase *test_case) {	...	@@ -1900,7 +1900,7 @@ static void run_test(TestCase *test_case) {
1900	return run_self_hosted_test(test_case->is_release_mode);	1900	return run_self_hosted_test(test_case->is_release_mode);
1901	}	1901	}
1902		1902
1903	for (int i = 0; i < test_case->source_files.length; i += 1) {	1903	for (size_t i = 0; i < test_case->source_files.length; i += 1) {
1904	TestSourceFile *test_source = &test_case->source_files.at(i);	1904	TestSourceFile *test_source = &test_case->source_files.at(i);
1905	os_write_file(	1905	os_write_file(
1906	buf_create_from_str(test_source->relative_path),	1906	buf_create_from_str(test_source->relative_path),
...	@@ -1917,7 +1917,7 @@ static void run_test(TestCase *test_case) {	...	@@ -1917,7 +1917,7 @@ static void run_test(TestCase *test_case) {
1917		1917
1918	if (!test_case->is_parseh && test_case->compile_errors.length) {	1918	if (!test_case->is_parseh && test_case->compile_errors.length) {
1919	if (term.how != TerminationIdClean \|\| term.code != 0) {	1919	if (term.how != TerminationIdClean \|\| term.code != 0) {
1920	for (int i = 0; i < test_case->compile_errors.length; i += 1) {	1920	for (size_t i = 0; i < test_case->compile_errors.length; i += 1) {
1921	const char *err_text = test_case->compile_errors.at(i);	1921	const char *err_text = test_case->compile_errors.at(i);
1922	if (!strstr(buf_ptr(&zig_stderr), err_text)) {	1922	if (!strstr(buf_ptr(&zig_stderr), err_text)) {
1923	printf("\n");	1923	printf("\n");
...	@@ -1957,7 +1957,7 @@ static void run_test(TestCase *test_case) {	...	@@ -1957,7 +1957,7 @@ static void run_test(TestCase *test_case) {
1957	}	1957	}
1958	}	1958	}
1959		1959
1960	for (int i = 0; i < test_case->compile_errors.length; i += 1) {	1960	for (size_t i = 0; i < test_case->compile_errors.length; i += 1) {
1961	const char *output = test_case->compile_errors.at(i);	1961	const char *output = test_case->compile_errors.at(i);
1962		1962
1963	if (!strstr(buf_ptr(&zig_stdout), output)) {	1963	if (!strstr(buf_ptr(&zig_stdout), output)) {
...	@@ -2015,7 +2015,7 @@ static void run_test(TestCase *test_case) {	...	@@ -2015,7 +2015,7 @@ static void run_test(TestCase *test_case) {
2015	}	2015	}
2016	}	2016	}
2017		2017
2018	for (int i = 0; i < test_case->source_files.length; i += 1) {	2018	for (size_t i = 0; i < test_case->source_files.length; i += 1) {
2019	TestSourceFile *test_source = &test_case->source_files.at(i);	2019	TestSourceFile *test_source = &test_case->source_files.at(i);
2020	remove(test_source->relative_path);	2020	remove(test_source->relative_path);
2021	}	2021	}
...	@@ -2023,21 +2023,23 @@ static void run_test(TestCase *test_case) {	...	@@ -2023,21 +2023,23 @@ static void run_test(TestCase *test_case) {
2023		2023
2024	static void run_all_tests(bool reverse) {	2024	static void run_all_tests(bool reverse) {
2025	if (reverse) {	2025	if (reverse) {
2026	for (int i = test_cases.length - 1; i >= 0; i -= 1) {	2026	for (size_t i = test_cases.length;;) {
2027	TestCase *test_case = test_cases.at(i);	2027	TestCase *test_case = test_cases.at(i);
2028	printf("Test %d/%d %s...", i + 1, test_cases.length, test_case->case_name);	2028	printf("Test %zu/%zu %s...", i + 1, test_cases.length, test_case->case_name);
2029	run_test(test_case);	2029	run_test(test_case);
2030	printf("OK\n");	2030	printf("OK\n");
		2031	if (i == 0) break;
		2032	i -= 1;
2031	}	2033	}
2032	} else {	2034	} else {
2033	for (int i = 0; i < test_cases.length; i += 1) {	2035	for (size_t i = 0; i < test_cases.length; i += 1) {
2034	TestCase *test_case = test_cases.at(i);	2036	TestCase *test_case = test_cases.at(i);
2035	printf("Test %d/%d %s...", i + 1, test_cases.length, test_case->case_name);	2037	printf("Test %zu/%zu %s...", i + 1, test_cases.length, test_case->case_name);
2036	run_test(test_case);	2038	run_test(test_case);
2037	printf("OK\n");	2039	printf("OK\n");
2038	}	2040	}
2039	}	2041	}
2040	printf("%d tests passed.\n", test_cases.length);	2042	printf("%zu tests passed.\n", test_cases.length);
2041	}	2043	}
2042		2044
2043	static void cleanup(void) {	2045	static void cleanup(void) {

...	@@ -205,7 +205,7 @@ static TypeTableEntry new_container_type_entry(TypeTableEntryId id, AstNode so	...	@@ -205,7 +205,7 @@ static TypeTableEntry new_container_type_entry(TypeTableEntryId id, AstNode so
205	}	205	}
206		206
207		207
208	static int bits_needed_for_unsigned(uint64_t x) {	208	static size_t bits_needed_for_unsigned(uint64_t x) {
209	if (x <= UINT8_MAX) {	209	if (x <= UINT8_MAX) {
210	return 8;	210	return 8;
211	} else if (x <= UINT16_MAX) {	211	} else if (x <= UINT16_MAX) {
...	@@ -579,7 +579,7 @@ TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *child_type, bool is_c	...	@@ -579,7 +579,7 @@ TypeTableEntry get_slice_type(CodeGen g, TypeTableEntry *child_type, bool is_c
579	slice_type_common_init(g, child_type, is_const, entry);	579	slice_type_common_init(g, child_type, is_const, entry);
580	if (child_type->zero_bits) {	580	if (child_type->zero_bits) {
581	entry->data.structure.gen_field_count = 1;	581	entry->data.structure.gen_field_count = 1;
582	entry->data.structure.fields[0].gen_index = -1;	582	entry->data.structure.fields[0].gen_index = SIZE_MAX;
583	entry->data.structure.fields[1].gen_index = 0;	583	entry->data.structure.fields[1].gen_index = 0;
584	}	584	}
585		585
...	@@ -736,7 +736,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_inf	...	@@ -736,7 +736,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_inf
736	const char *naked_str = fn_type_id->is_naked ? "naked " : "";	736	const char *naked_str = fn_type_id->is_naked ? "naked " : "";
737	const char *cold_str = fn_type_id->is_cold ? "cold " : "";	737	const char *cold_str = fn_type_id->is_cold ? "cold " : "";
738	buf_appendf(&fn_type->name, "%s%s%sfn(", extern_str, naked_str, cold_str);	738	buf_appendf(&fn_type->name, "%s%s%sfn(", extern_str, naked_str, cold_str);
739	for (int i = 0; i < fn_type_id->param_count; i += 1) {	739	for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
740	FnTypeParamInfo *param_info = &fn_type_id->param_info[i];	740	FnTypeParamInfo *param_info = &fn_type_id->param_info[i];
741		741
742	TypeTableEntry *param_type = param_info->type;	742	TypeTableEntry *param_type = param_info->type;
...	@@ -763,7 +763,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_inf	...	@@ -763,7 +763,7 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_inf
763	// +1 because 0 is the return type and +1 for maybe making first arg ret val	763	// +1 because 0 is the return type and +1 for maybe making first arg ret val
764	ZigLLVMDIType *param_di_types = allocate<ZigLLVMDIType>(2 + fn_type_id->param_count);	764	ZigLLVMDIType *param_di_types = allocate<ZigLLVMDIType>(2 + fn_type_id->param_count);
765	param_di_types[0] = fn_type_id->return_type->di_type;	765	param_di_types[0] = fn_type_id->return_type->di_type;
766	int gen_param_index = 0;	766	size_t gen_param_index = 0;
767	TypeTableEntry *gen_return_type;	767	TypeTableEntry *gen_return_type;
768	if (!type_has_bits(fn_type_id->return_type)) {	768	if (!type_has_bits(fn_type_id->return_type)) {
769	gen_return_type = g->builtin_types.entry_void;	769	gen_return_type = g->builtin_types.entry_void;
...	@@ -780,13 +780,13 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_inf	...	@@ -780,13 +780,13 @@ TypeTableEntry get_fn_type(CodeGen g, FnTypeId *fn_type_id, bool gen_debug_inf
780	fn_type->data.fn.gen_return_type = gen_return_type;	780	fn_type->data.fn.gen_return_type = gen_return_type;
781		781
782	fn_type->data.fn.gen_param_info = allocate<FnGenParamInfo>(fn_type_id->param_count);	782	fn_type->data.fn.gen_param_info = allocate<FnGenParamInfo>(fn_type_id->param_count);
783	for (int i = 0; i < fn_type_id->param_count; i += 1) {	783	for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
784	FnTypeParamInfo *src_param_info = &fn_type->data.fn.fn_type_id.param_info[i];	784	FnTypeParamInfo *src_param_info = &fn_type->data.fn.fn_type_id.param_info[i];
785	TypeTableEntry *type_entry = src_param_info->type;	785	TypeTableEntry *type_entry = src_param_info->type;
786	FnGenParamInfo *gen_param_info = &fn_type->data.fn.gen_param_info[i];	786	FnGenParamInfo *gen_param_info = &fn_type->data.fn.gen_param_info[i];

...	@@ -111,7 +111,7 @@ CodeGen codegen_create(Buf root_source_dir, const ZigTarget *target) {	...	@@ -111,7 +111,7 @@ CodeGen codegen_create(Buf root_source_dir, const ZigTarget *target) {
111	return g;	111	return g;
112	}	112	}
113		113
114	void codegen_set_clang_argv(CodeGen g, const char *args, int len) {	114	void codegen_set_clang_argv(CodeGen g, const char *args, size_t len) {
115	g->clang_argv = args;	115	g->clang_argv = args;
116	g->clang_argv_len = len;	116	g->clang_argv_len = len;
117	}	117	}
...	@@ -166,6 +166,7 @@ void codegen_set_libc_include_dir(CodeGen g, Buf libc_include_dir) {	...	@@ -166,6 +166,7 @@ void codegen_set_libc_include_dir(CodeGen g, Buf libc_include_dir) {
166		166
167	void codegen_set_zig_std_dir(CodeGen g, Buf zig_std_dir) {	167	void codegen_set_zig_std_dir(CodeGen g, Buf zig_std_dir) {
168	g->zig_std_dir = zig_std_dir;	168	g->zig_std_dir = zig_std_dir;
		169
169	g->std_package->root_src_dir = *zig_std_dir;	170	g->std_package->root_src_dir = *zig_std_dir;
170	}	171	}
171		172
...	@@ -261,7 +262,7 @@ enum AddSubMul {	...	@@ -261,7 +262,7 @@ enum AddSubMul {
261	AddSubMulMul = 2,	262	AddSubMulMul = 2,
262	};	263	};
263		264
264	static int bits_index(int size_in_bits) {	265	static size_t bits_index(size_t size_in_bits) {
265	switch (size_in_bits) {	266	switch (size_in_bits) {
266	case 8:	267	case 8:
267	return 0;	268	return 0;
...	@@ -281,7 +282,7 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, TypeTableEntry type_	...	@@ -281,7 +282,7 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, TypeTableEntry type_
281	{	282	{
282	assert(type_entry->id == TypeTableEntryIdInt);	283	assert(type_entry->id == TypeTableEntryIdInt);
283	const char *signed_str = type_entry->data.integral.is_signed ? signed_name : unsigned_name;	284	const char *signed_str = type_entry->data.integral.is_signed ? signed_name : unsigned_name;
284	Buf *llvm_name = buf_sprintf("llvm.%s.with.overflow.i%d", signed_str, type_entry->data.integral.bit_count);	285	Buf *llvm_name = buf_sprintf("llvm.%s.with.overflow.i%zu", signed_str, type_entry->data.integral.bit_count);
285		286
286	LLVMTypeRef return_elem_types[] = {	287	LLVMTypeRef return_elem_types[] = {
287	type_entry->type_ref,	288	type_entry->type_ref,
...	@@ -301,9 +302,9 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, TypeTableEntry type_	...	@@ -301,9 +302,9 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen g, TypeTableEntry type_
301	static LLVMValueRef get_int_overflow_fn(CodeGen g, TypeTableEntry type_entry, AddSubMul add_sub_mul) {	302	static LLVMValueRef get_int_overflow_fn(CodeGen g, TypeTableEntry type_entry, AddSubMul add_sub_mul) {
302	assert(type_entry->id == TypeTableEntryIdInt);	303	assert(type_entry->id == TypeTableEntryIdInt);
303	// [0-signed,1-unsigned][0-add,1-sub,2-mul][0-8,1-16,2-32,3-64]	304	// [0-signed,1-unsigned][0-add,1-sub,2-mul][0-8,1-16,2-32,3-64]
304	int index0 = type_entry->data.integral.is_signed ? 0 : 1;	305	size_t index0 = type_entry->data.integral.is_signed ? 0 : 1;
305	int index1 = add_sub_mul;	306	size_t index1 = add_sub_mul;
306	int index2 = bits_index(type_entry->data.integral.bit_count);	307	size_t index2 = bits_index(type_entry->data.integral.bit_count);
307	LLVMValueRef *fn = &g->int_overflow_fns[index0][index1][index2];	308	LLVMValueRef *fn = &g->int_overflow_fns[index0][index1][index2];

...	@@ -28,7 +28,7 @@ struct ParseContext {	...	@@ -28,7 +28,7 @@ struct ParseContext {
28		28
29	__attribute__ ((format (printf, 4, 5)))	29	__attribute__ ((format (printf, 4, 5)))
30	__attribute__ ((noreturn))	30	__attribute__ ((noreturn))
31	static void ast_asm_error(ParseContext pc, AstNode node, int offset, const char *format, ...) {	31	static void ast_asm_error(ParseContext pc, AstNode node, size_t offset, const char *format, ...) {
32	assert(node->type == NodeTypeAsmExpr);	32	assert(node->type == NodeTypeAsmExpr);
33		33
34		34
...	@@ -109,7 +109,7 @@ static void parse_asm_template(ParseContext pc, AstNode node) {	...	@@ -109,7 +109,7 @@ static void parse_asm_template(ParseContext pc, AstNode node) {
109		109
110	enum State state = StateStart;	110	enum State state = StateStart;
111		111
112	for (int i = 0; i < buf_len(asm_template); i += 1) {	112	for (size_t i = 0; i < buf_len(asm_template); i += 1) {
113	uint8_t c = ((uint8_t)buf_ptr(asm_template) + i);	113	uint8_t c = ((uint8_t)buf_ptr(asm_template) + i);
114	switch (state) {	114	switch (state) {
115	case StateStart:	115	case StateStart:
...	@@ -205,16 +205,16 @@ static void ast_invalid_token_error(ParseContext pc, Token token) {	...	@@ -205,16 +205,16 @@ static void ast_invalid_token_error(ParseContext pc, Token token) {
205	ast_error(pc, token, "invalid token: '%s'", buf_ptr(&token_value));	205	ast_error(pc, token, "invalid token: '%s'", buf_ptr(&token_value));
206	}	206	}
207		207
208	static AstNode ast_parse_expression(ParseContext pc, int *token_index, bool mandatory);	208	static AstNode ast_parse_expression(ParseContext pc, size_t *token_index, bool mandatory);
209	static AstNode ast_parse_block(ParseContext pc, int *token_index, bool mandatory);	209	static AstNode ast_parse_block(ParseContext pc, size_t *token_index, bool mandatory);
210	static AstNode ast_parse_if_expr(ParseContext pc, int *token_index, bool mandatory);	210	static AstNode ast_parse_if_expr(ParseContext pc, size_t *token_index, bool mandatory);
211	static AstNode ast_parse_block_expr(ParseContext pc, int *token_index, bool mandatory);	211	static AstNode ast_parse_block_expr(ParseContext pc, size_t *token_index, bool mandatory);
212	static AstNode ast_parse_unwrap_expr(ParseContext pc, int *token_index, bool mandatory);	212	static AstNode ast_parse_unwrap_expr(ParseContext pc, size_t *token_index, bool mandatory);
213	static AstNode ast_parse_prefix_op_expr(ParseContext pc, int *token_index, bool mandatory);	213	static AstNode ast_parse_prefix_op_expr(ParseContext pc, size_t *token_index, bool mandatory);
214	static AstNode ast_parse_fn_proto(ParseContext pc, int *token_index, bool mandatory,	214	static AstNode ast_parse_fn_proto(ParseContext pc, size_t *token_index, bool mandatory,
215	ZigList<AstNode> directives, VisibMod visib_mod);	215	ZigList<AstNode> directives, VisibMod visib_mod);
216	static AstNode ast_parse_return_expr(ParseContext pc, int *token_index);	216	static AstNode ast_parse_return_expr(ParseContext pc, size_t *token_index);
217	static AstNode ast_parse_grouped_expr(ParseContext pc, int *token_index, bool mandatory);	217	static AstNode ast_parse_grouped_expr(ParseContext pc, size_t *token_index, bool mandatory);
218		218
219	static void ast_expect_token(ParseContext pc, Token token, TokenId token_id) {	219	static void ast_expect_token(ParseContext pc, Token token, TokenId token_id) {
220	if (token->id == token_id) {	220	if (token->id == token_id) {
...	@@ -226,7 +226,7 @@ static void ast_expect_token(ParseContext pc, Token token, TokenId token_id) {	...	@@ -226,7 +226,7 @@ static void ast_expect_token(ParseContext pc, Token token, TokenId token_id) {
226	ast_error(pc, token, "expected token '%s', found '%s'", token_name(token_id), token_name(token->id));	226	ast_error(pc, token, "expected token '%s', found '%s'", token_name(token_id), token_name(token->id));
227	}	227	}
228		228
229	static Token ast_eat_token(ParseContext pc, int *token_index, TokenId token_id) {	229	static Token ast_eat_token(ParseContext pc, size_t *token_index, TokenId token_id) {
230	Token token = &pc->tokens->at(token_index);	230	Token token = &pc->tokens->at(token_index);
231	ast_expect_token(pc, token, token_id);	231	ast_expect_token(pc, token, token_id);