aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/all_types.hpp91
-rw-r--r--src/analyze.cpp196
-rw-r--r--src/analyze.hpp4
-rw-r--r--src/ast_render.cpp14
-rw-r--r--src/bignum.cpp2
-rw-r--r--src/buffer.cpp4
-rw-r--r--src/buffer.hpp48
-rw-r--r--src/codegen.cpp217
-rw-r--r--src/codegen.hpp2
-rw-r--r--src/errmsg.cpp37
-rw-r--r--src/errmsg.hpp10
-rw-r--r--src/eval.cpp42
-rw-r--r--src/eval.hpp2
-rw-r--r--src/link.cpp22
-rw-r--r--src/list.hpp37
-rw-r--r--src/main.cpp18
-rw-r--r--src/os.cpp45
-rw-r--r--src/parseh.cpp22
-rw-r--r--src/parser.cpp152
-rw-r--r--src/target.cpp16
-rw-r--r--src/target.hpp10
-rw-r--r--src/tokenizer.cpp12
-rw-r--r--src/tokenizer.hpp14
-rw-r--r--src/util.hpp26
24 files changed, 533 insertions, 510 deletions
diff --git a/src/all_types.hpp b/src/all_types.hpp
index 27c519a1b1..8bf842d359 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -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;
- int inline_or_var_type_arg_count;
+ size_t inline_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;
- int column;
+ size_t line;
+ 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;
- int column;
+ size_t line;
+ 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;
- int gen_index;
+ size_t src_index;
+ size_t gen_index;
};
struct TypeTableEntryStruct {
AstNode *decl_node;
@@ -958,8 +957,8 @@ struct TypeTableEntryUnion {
};
struct FnGenParamInfo {
- int src_index;
- int gen_index;
+ size_t src_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;
- int branches_used;
+ size_t branch_quota;
+ 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;
- int version_minor;
- int version_patch;
+ size_t version_major;
+ size_t version_minor;
+ 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;
- int gen_arg_index;
+ size_t src_arg_index;
+ size_t gen_arg_index;
BlockContext *block_context;
LLVMValueRef param_value_ref;
bool force_depends_on_compile_var;
diff --git a/src/analyze.cpp b/src/analyze.cpp
index ec6fed7d74..a79744b49c 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -205,7 +205,7 @@ static TypeTableEntry *new_container_type_entry(TypeTableEntryId id, AstNode *so
}
-static int bits_needed_for_unsigned(uint64_t x) {
+static size_t bits_needed_for_unsigned(uint64_t x) {
if (x <= UINT8_MAX) {
return 8;
} else if (x <= UINT16_MAX) {
@@ -579,7 +579,7 @@ TypeTableEntry *get_slice_type(CodeGen *g, TypeTableEntry *child_type, bool is_c
slice_type_common_init(g, child_type, is_const, entry);
if (child_type->zero_bits) {
entry->data.structure.gen_field_count = 1;
- entry->data.structure.fields[0].gen_index = -1;
+ entry->data.structure.fields[0].gen_index = SIZE_MAX;
entry->data.structure.fields[1].gen_index = 0;
}
@@ -736,7 +736,7 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id, bool gen_debug_inf
const char *naked_str = fn_type_id->is_naked ? "naked " : "";
const char *cold_str = fn_type_id->is_cold ? "cold " : "";
buf_appendf(&fn_type->name, "%s%s%sfn(", extern_str, naked_str, cold_str);
- for (int i = 0; i < fn_type_id->param_count; i += 1) {
+ for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
FnTypeParamInfo *param_info = &fn_type_id->param_info[i];
TypeTableEntry *param_type = param_info->type;
@@ -763,7 +763,7 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id, bool gen_debug_inf
// +1 because 0 is the return type and +1 for maybe making first arg ret val
ZigLLVMDIType **param_di_types = allocate<ZigLLVMDIType*>(2 + fn_type_id->param_count);
param_di_types[0] = fn_type_id->return_type->di_type;
- int gen_param_index = 0;
+ size_t gen_param_index = 0;
TypeTableEntry *gen_return_type;
if (!type_has_bits(fn_type_id->return_type)) {
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
fn_type->data.fn.gen_return_type = gen_return_type;
fn_type->data.fn.gen_param_info = allocate<FnGenParamInfo>(fn_type_id->param_count);
- for (int i = 0; i < fn_type_id->param_count; i += 1) {
+ for (size_t i = 0; i < fn_type_id->param_count; i += 1) {
FnTypeParamInfo *src_param_info = &fn_type->data.fn.fn_type_id.param_info[i];
TypeTableEntry *type_entry = src_param_info->type;
FnGenParamInfo *gen_param_info = &fn_type->data.fn.gen_param_info[i];
gen_param_info->src_index = i;
- gen_param_info->gen_index = -1;
+ gen_param_info->gen_index = SIZE_MAX;
assert(type_is_complete(type_entry));
if (type_has_bits(type_entry)) {
@@ -946,7 +946,7 @@ static TypeTableEntry *analyze_fn_proto_type(CodeGen *g, ImportTableEntry *impor
fn_type_id.is_var_args = fn_proto->is_var_args;
fn_type_id.return_type = analyze_type_expr(g, import, context, fn_proto->return_type);
- for (int i = 0; i < fn_type_id.param_count; i += 1) {
+ for (size_t i = 0; i < fn_type_id.param_count; i += 1) {
AstNode *child = fn_proto->params.at(i);
assert(child->type == NodeTypeParamDecl);
@@ -1047,7 +1047,7 @@ static TypeTableEntry *analyze_fn_proto_type(CodeGen *g, ImportTableEntry *impor
fn_table_entry->want_pure_return_type = fn_proto->return_type;
ErrorMsg *err_msg = nullptr;
- for (int i = 0; i < fn_proto->params.length; i += 1) {
+ for (size_t i = 0; i < fn_proto->params.length; i += 1) {
AstNode *param_decl_node = fn_proto->params.at(i);
assert(param_decl_node->type == NodeTypeParamDecl);
if (!param_decl_node->data.param_decl.is_inline) {
@@ -1135,7 +1135,7 @@ static void resolve_function_proto(CodeGen *g, AstNode *node, FnTableEntry *fn_t
bool is_noinline = false;
if (fn_proto->top_level_decl.directives) {
- for (int i = 0; i < fn_proto->top_level_decl.directives->length; i += 1) {
+ for (size_t i = 0; i < fn_proto->top_level_decl.directives->length; i += 1) {
AstNode *directive_node = fn_proto->top_level_decl.directives->at(i);
Buf *name = directive_node->data.directive.name;
@@ -1342,7 +1342,7 @@ static void resolve_enum_type(CodeGen *g, ImportTableEntry *import, TypeTableEnt
// set temporary flag
enum_type->data.enumeration.embedded_in_current = true;
- int gen_field_index = 0;
+ size_t gen_field_index = 0;
for (uint32_t i = 0; i < field_count; i += 1) {
AstNode *field_node = decl_node->data.struct_decl.fields.at(i);
TypeEnumField *type_enum_field = &enum_type->data.enumeration.fields[i];
@@ -1518,7 +1518,7 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
struct_type->deep_const = true;
- int field_count = decl_node->data.struct_decl.fields.length;
+ size_t field_count = decl_node->data.struct_decl.fields.length;
struct_type->data.structure.src_field_count = field_count;
struct_type->data.structure.fields = allocate<TypeStructField>(field_count);
@@ -1532,8 +1532,8 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
BlockContext *context = struct_type->data.structure.block_context;
- int gen_field_index = 0;
- for (int i = 0; i < field_count; i += 1) {
+ size_t gen_field_index = 0;
+ for (size_t i = 0; i < field_count; i += 1) {
AstNode *field_node = decl_node->data.struct_decl.fields.at(i);
TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
type_struct_field->name = field_node->data.struct_field.name;
@@ -1541,7 +1541,7 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
field_node->data.struct_field.type);
type_struct_field->type_entry = field_type;
type_struct_field->src_index = i;
- type_struct_field->gen_index = -1;
+ type_struct_field->gen_index = SIZE_MAX;
if (!field_type->deep_const) {
struct_type->deep_const = false;
@@ -1574,16 +1574,16 @@ static void resolve_struct_type(CodeGen *g, ImportTableEntry *import, TypeTableE
return;
}
- int gen_field_count = gen_field_index;
+ size_t gen_field_count = gen_field_index;
LLVMStructSetBody(struct_type->type_ref, element_types, gen_field_count, false);
ZigLLVMDIType **di_element_types = allocate<ZigLLVMDIType*>(gen_field_count);
- for (int i = 0; i < field_count; i += 1) {
+ for (size_t i = 0; i < field_count; i += 1) {
AstNode *field_node = decl_node->data.struct_decl.fields.at(i);
TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
gen_field_index = type_struct_field->gen_index;
- if (gen_field_index == -1) {
+ if (gen_field_index == SIZE_MAX) {
continue;
}
@@ -1697,7 +1697,7 @@ static void preview_fn_proto_instance(CodeGen *g, ImportTableEntry *import, AstN
fn_table_entry->type_entry = get_generic_fn_type(g, proto_node);
if (is_extern || proto_node->data.fn_proto.top_level_decl.visib_mod == VisibModExport) {
- for (int i = 0; i < proto_node->data.fn_proto.params.length; i += 1) {
+ for (size_t i = 0; i < proto_node->data.fn_proto.params.length; i += 1) {
AstNode *param_decl_node = proto_node->data.fn_proto.params.at(i);
if (param_decl_node->data.param_decl.is_inline) {
proto_node->data.fn_proto.skip = true;
@@ -1754,7 +1754,7 @@ static void scan_struct_decl(CodeGen *g, ImportTableEntry *import, BlockContext
node->data.struct_decl.type_entry = container_type;
// handle the member function definitions independently
- for (int i = 0; i < node->data.struct_decl.decls.length; i += 1) {
+ for (size_t i = 0; i < node->data.struct_decl.decls.length; i += 1) {
AstNode *child_node = node->data.struct_decl.decls.at(i);
get_as_top_level_decl(child_node)->parent_decl = node;
BlockContext *child_context = get_container_block_context(container_type);
@@ -1802,7 +1802,7 @@ static void preview_error_value_decl(CodeGen *g, AstNode *node) {
// duplicate error definitions allowed and they get the same value
err->value = existing_entry->value->value;
} else {
- int error_value_count = g->error_decls.length;
+ size_t error_value_count = g->error_decls.length;
assert((uint32_t)error_value_count < (((uint32_t)1) << (uint32_t)g->err_tag_type->data.integral.bit_count));
err->value = error_value_count;
g->error_decls.append(node);
@@ -2100,7 +2100,7 @@ static bool types_match_const_cast_only(TypeTableEntry *expected_type, TypeTable
if (expected_type->data.fn.fn_type_id.param_count != actual_type->data.fn.fn_type_id.param_count) {
return false;
}
- for (int i = 0; i < expected_type->data.fn.fn_type_id.param_count; i += 1) {
+ for (size_t i = 0; i < expected_type->data.fn.fn_type_id.param_count; i += 1) {
// note it's reversed for parameters
FnTypeParamInfo *actual_param_info = &actual_type->data.fn.fn_type_id.param_info[i];
FnTypeParamInfo *expected_param_info = &expected_type->data.fn.fn_type_id.param_info[i];
@@ -2121,14 +2121,14 @@ static bool types_match_const_cast_only(TypeTableEntry *expected_type, TypeTable
}
static TypeTableEntry *determine_peer_type_compatibility(CodeGen *g, AstNode *parent_source_node,
- AstNode **child_nodes, TypeTableEntry **child_types, int child_count)
+ AstNode **child_nodes, TypeTableEntry **child_types, size_t child_count)
{
TypeTableEntry *prev_type = child_types[0];
AstNode *prev_node = child_nodes[0];
if (prev_type->id == TypeTableEntryIdInvalid) {
return prev_type;
}
- for (int i = 1; i < child_count; i += 1) {
+ for (size_t i = 1; i < child_count; i += 1) {
TypeTableEntry *cur_type = child_types[i];
AstNode *cur_node = child_nodes[i];
if (cur_type->id == TypeTableEntryIdInvalid) {
@@ -2359,7 +2359,7 @@ static TypeTableEntry *resolve_type_compatibility(CodeGen *g, ImportTableEntry *
static TypeTableEntry *resolve_peer_type_compatibility(CodeGen *g, ImportTableEntry *import,
BlockContext *block_context, AstNode *parent_source_node,
- AstNode **child_nodes, TypeTableEntry **child_types, int child_count)
+ AstNode **child_nodes, TypeTableEntry **child_types, size_t child_count)
{
assert(child_count > 0);
@@ -2370,7 +2370,7 @@ static TypeTableEntry *resolve_peer_type_compatibility(CodeGen *g, ImportTableEn
return expected_type;
}
- for (int i = 0; i < child_count; i += 1) {
+ for (size_t i = 0; i < child_count; i += 1) {
if (!child_nodes[i]) {
continue;
}
@@ -2579,16 +2579,16 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry
codegen->source_node = node;
- int expr_field_count = container_init_expr->entries.length;
- int actual_field_count = container_type->data.structure.src_field_count;
+ size_t expr_field_count = container_init_expr->entries.length;
+ size_t actual_field_count = container_type->data.structure.src_field_count;
AstNode *non_const_expr_culprit = nullptr;
- int *field_use_counts = allocate<int>(actual_field_count);
+ size_t *field_use_counts = allocate<size_t>(actual_field_count);
ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
const_val->ok = true;
const_val->data.x_struct.fields = allocate<ConstExprValue*>(actual_field_count);
- for (int i = 0; i < expr_field_count; i += 1) {
+ for (size_t i = 0; i < expr_field_count; i += 1) {
AstNode *val_field_node = container_init_expr->entries.at(i);
assert(val_field_node->type == NodeTypeStructValueField);
@@ -2608,7 +2608,7 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry
return g->builtin_types.entry_invalid;
}
- int field_index = type_field->src_index;
+ size_t field_index = type_field->src_index;
field_use_counts[field_index] += 1;
if (field_use_counts[field_index] > 1) {
add_node_error(g, val_field_node, buf_sprintf("duplicate field"));
@@ -2641,7 +2641,7 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry
}
}
- for (int i = 0; i < actual_field_count; i += 1) {
+ for (size_t i = 0; i < actual_field_count; i += 1) {
if (field_use_counts[i] == 0) {
add_node_error(g, node,
buf_sprintf("missing field: '%s'", buf_ptr(container_type->data.structure.fields[i].name)));
@@ -2652,7 +2652,7 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry
container_type->data.structure.is_slice &&
kind == ContainerInitKindArray)
{
- int elem_count = container_init_expr->entries.length;
+ size_t elem_count = container_init_expr->entries.length;
TypeTableEntry *pointer_type = container_type->data.structure.fields[0].type_entry;
assert(pointer_type->id == TypeTableEntryIdPointer);
@@ -2662,7 +2662,7 @@ static TypeTableEntry *analyze_container_init_expr(CodeGen *g, ImportTableEntry
const_val->ok = true;
const_val->data.x_array.fields = allocate<ConstExprValue*>(elem_count);
- for (int i = 0; i < elem_count; i += 1) {
+ for (size_t i = 0; i < elem_count; i += 1) {
AstNode **elem_node = &container_init_expr->entries.at(i);
analyze_expression(g, import, context, child_type, *elem_node);
@@ -2787,7 +2787,7 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i
AstNode *value_node;
if (container_init_node) {
assert(container_init_node->type == NodeTypeContainerInitExpr);
- int param_count = container_init_node->data.container_init_expr.entries.length;
+ size_t param_count = container_init_node->data.container_init_expr.entries.length;
if (param_count > 1) {
AstNode *first_invalid_node = container_init_node->data.container_init_expr.entries.at(1);
add_node_error(g, first_executing_node(first_invalid_node),
@@ -2849,7 +2849,7 @@ static TypeTableEntry *analyze_field_access_expr(CodeGen *g, ImportTableEntry *i
AstNode *decl_node = find_decl(namespace_import->block_context, field_name);
if (!decl_node) {
// we must now resolve all the use decls
- for (int i = 0; i < namespace_import->use_decls.length; i += 1) {
+ for (size_t i = 0; i < namespace_import->use_decls.length; i += 1) {
AstNode *use_decl_node = namespace_import->use_decls.at(i);
if (!get_resolved_expr(use_decl_node->data.use.expr)->type_entry) {
preview_use_decl(g, use_decl_node);
@@ -3051,13 +3051,13 @@ static TypeTableEntry *resolve_expr_const_val_as_c_string_lit(CodeGen *g, AstNod
Expr *expr = get_resolved_expr(node);
expr->const_val.ok = true;
- int len_with_null = buf_len(str) + 1;
+ size_t len_with_null = buf_len(str) + 1;
expr->const_val.data.x_ptr.ptr = allocate<ConstExprValue*>(len_with_null);
expr->const_val.data.x_ptr.len = len_with_null;
expr->const_val.data.x_ptr.is_c_str = true;
ConstExprValue *all_chars = allocate<ConstExprValue>(len_with_null);
- for (int i = 0; i < buf_len(str); i += 1) {
+ for (size_t i = 0; i < buf_len(str); i += 1) {
ConstExprValue *this_char = &all_chars[i];
this_char->ok = true;
bignum_init_unsigned(&this_char->data.x_bignum, buf_ptr(str)[i]);
@@ -3078,7 +3078,7 @@ static TypeTableEntry *resolve_expr_const_val_as_string_lit(CodeGen *g, AstNode
expr->const_val.data.x_array.fields = allocate<ConstExprValue*>(buf_len(str));
ConstExprValue *all_chars = allocate<ConstExprValue>(buf_len(str));
- for (int i = 0; i < buf_len(str); i += 1) {
+ for (size_t i = 0; i < buf_len(str); i += 1) {
ConstExprValue *this_char = &all_chars[i];
this_char->ok = true;
bignum_init_unsigned(&this_char->data.x_bignum, buf_ptr(str)[i]);
@@ -4437,7 +4437,7 @@ static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, B
assert(node->type == NodeTypeFnCallExpr);
AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
- int actual_param_count = node->data.fn_call_expr.params.length;
+ size_t actual_param_count = node->data.fn_call_expr.params.length;
if (actual_param_count != 1) {
add_node_error(g, fn_ref_expr, buf_sprintf("cast expression expects exactly one parameter"));
@@ -4799,7 +4799,7 @@ static TypeTableEntry *analyze_c_import(CodeGen *g, ImportTableEntry *parent_imp
if (errors.length > 0) {
ErrorMsg *parent_err_msg = add_node_error(g, node, buf_sprintf("C import failed"));
- for (int i = 0; i < errors.length; i += 1) {
+ for (size_t i = 0; i < errors.length; i += 1) {
ErrorMsg *err_msg = errors.at(i);
err_msg_add_note(parent_err_msg, err_msg);
}
@@ -5113,13 +5113,13 @@ static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry
}
BuiltinFnEntry *builtin_fn = entry->value;
- int actual_param_count = node->data.fn_call_expr.params.length;
+ size_t actual_param_count = node->data.fn_call_expr.params.length;
node->data.fn_call_expr.builtin_fn = builtin_fn;
if (builtin_fn->param_count != actual_param_count) {
add_node_error(g, node,
- buf_sprintf("expected %d arguments, got %d",
+ buf_sprintf("expected %zu arguments, got %zu",
builtin_fn->param_count, actual_param_count));
return g->builtin_types.entry_invalid;
}
@@ -5479,11 +5479,11 @@ static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import,
fn_table_entry->proto_node->data.fn_proto.generic_proto_node : nullptr;
// count parameters
- int struct_node_1_or_0 = struct_node ? 1 : 0;
- int src_param_count = fn_type->data.fn.fn_type_id.param_count +
+ size_t struct_node_1_or_0 = struct_node ? 1 : 0;
+ size_t src_param_count = fn_type->data.fn.fn_type_id.param_count +
(generic_proto_node ? generic_proto_node->data.fn_proto.inline_arg_count : 0);
- int call_param_count = node->data.fn_call_expr.params.length;
- int expect_arg_count = src_param_count - struct_node_1_or_0;
+ size_t call_param_count = node->data.fn_call_expr.params.length;
+ size_t expect_arg_count = src_param_count - struct_node_1_or_0;
bool ok_invocation = true;
@@ -5491,12 +5491,12 @@ static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import,
if (call_param_count < expect_arg_count) {
ok_invocation = false;
add_node_error(g, node,
- buf_sprintf("expected at least %d arguments, got %d", src_param_count, call_param_count));
+ buf_sprintf("expected at least %zu arguments, got %zu", src_param_count, call_param_count));
}
} else if (expect_arg_count != call_param_count) {
ok_invocation = false;
add_node_error(g, node,
- buf_sprintf("expected %d arguments, got %d", expect_arg_count, call_param_count));
+ buf_sprintf("expected %zu arguments, got %zu", expect_arg_count, call_param_count));
}
bool all_args_const_expr = true;
@@ -5510,9 +5510,9 @@ static TypeTableEntry *analyze_fn_call_ptr(CodeGen *g, ImportTableEntry *import,
// analyze each parameter. in the case of a method, we already analyzed the
// first parameter in order to figure out which struct we were calling a method on.
- int next_type_i = struct_node_1_or_0;
- for (int call_i = 0; call_i < call_param_count; call_i += 1) {
- int proto_i = call_i + struct_node_1_or_0;
+ size_t next_type_i = struct_node_1_or_0;
+ for (size_t call_i = 0; call_i < call_param_count; call_i += 1) {
+ size_t proto_i = call_i + struct_node_1_or_0;
AstNode **param_node = &node->data.fn_call_expr.params.at(call_i);
// determine the expected type for each parameter
TypeTableEntry *expected_param_type = nullptr;
@@ -5592,30 +5592,30 @@ static TypeTableEntry *analyze_fn_call_with_inline_args(CodeGen *g, ImportTableE
AstNode *decl_node = fn_table_entry->proto_node;
// count parameters
- int struct_node_1_or_0 = (struct_node ? 1 : 0);
- int src_param_count = decl_node->data.fn_proto.params.length;
- int call_param_count = call_node->data.fn_call_expr.params.length;
+ size_t struct_node_1_or_0 = (struct_node ? 1 : 0);
+ size_t src_param_count = decl_node->data.fn_proto.params.length;
+ size_t call_param_count = call_node->data.fn_call_expr.params.length;
if (src_param_count != call_param_count + struct_node_1_or_0) {
add_node_error(g, call_node,
- buf_sprintf("expected %d arguments, got %d", src_param_count - struct_node_1_or_0, call_param_count));
+ buf_sprintf("expected %zu arguments, got %zu", src_param_count - struct_node_1_or_0, call_param_count));
return g->builtin_types.entry_invalid;
}
- int inline_or_var_type_arg_count = decl_node->data.fn_proto.inline_or_var_type_arg_count;
+ size_t inline_or_var_type_arg_count = decl_node->data.fn_proto.inline_or_var_type_arg_count;
assert(inline_or_var_type_arg_count > 0);
BlockContext *child_context = decl_node->owner->block_context;
- int next_generic_param_index = 0;
+ size_t next_generic_param_index = 0;
GenericFnTypeId *generic_fn_type_id = allocate<GenericFnTypeId>(1);
generic_fn_type_id->decl_node = decl_node;
generic_fn_type_id->generic_param_count = inline_or_var_type_arg_count;
generic_fn_type_id->generic_params = allocate<GenericParamValue>(inline_or_var_type_arg_count);
- int next_impl_i = 0;
- for (int call_i = 0; call_i < call_param_count; call_i += 1) {
- int proto_i = call_i + struct_node_1_or_0;
+ size_t next_impl_i = 0;
+ for (size_t call_i = 0; call_i < call_param_count; call_i += 1) {
+ size_t proto_i = call_i + struct_node_1_or_0;
AstNode *generic_param_decl_node = decl_node->data.fn_proto.params.at(proto_i);
assert(generic_param_decl_node->type == NodeTypeParamDecl);
@@ -5688,10 +5688,10 @@ static TypeTableEntry *analyze_fn_call_with_inline_args(CodeGen *g, ImportTableE
impl_decl_node->data.fn_proto.generic_proto_node = decl_node;
// replace var arg types with actual types
- for (int generic_arg_i = 0; generic_arg_i < inline_or_var_type_arg_count; generic_arg_i += 1) {
+ for (size_t generic_arg_i = 0; generic_arg_i < inline_or_var_type_arg_count; generic_arg_i += 1) {
GenericParamValue *generic_param_value = &generic_fn_type_id->generic_params[generic_arg_i];
if (!generic_param_value->node) {
- int impl_i = generic_param_value->impl_index;
+ size_t impl_i = generic_param_value->impl_index;
AstNode *impl_param_decl_node = impl_decl_node->data.fn_proto.params.at(impl_i);
assert(impl_param_decl_node->type == NodeTypeParamDecl);
@@ -5721,12 +5721,12 @@ static TypeTableEntry *analyze_generic_fn_call(CodeGen *g, ImportTableEntry *imp
assert(decl_node->type == NodeTypeContainerDecl);
ZigList<AstNode *> *generic_params = &decl_node->data.struct_decl.generic_params;
- int expected_param_count = generic_params->length;
- int actual_param_count = node->data.fn_call_expr.params.length;
+ size_t expected_param_count = generic_params->length;
+ size_t actual_param_count = node->data.fn_call_expr.params.length;
if (actual_param_count != expected_param_count) {
add_node_error(g, first_executing_node(node),
- buf_sprintf("expected %d arguments, got %d", expected_param_count, actual_param_count));
+ buf_sprintf("expected %zu arguments, got %zu", expected_param_count, actual_param_count));
return g->builtin_types.entry_invalid;
}
@@ -5736,7 +5736,7 @@ static TypeTableEntry *analyze_generic_fn_call(CodeGen *g, ImportTableEntry *imp
generic_fn_type_id->generic_params = allocate<GenericParamValue>(actual_param_count);
BlockContext *child_context = decl_node->owner->block_context;
- for (int i = 0; i < actual_param_count; i += 1) {
+ for (size_t i = 0; i < actual_param_count; i += 1) {
AstNode *generic_param_decl_node = generic_params->at(i);
assert(generic_param_decl_node->type == NodeTypeParamDecl);
@@ -6104,7 +6104,7 @@ static TypeTableEntry *analyze_switch_expr(CodeGen *g, ImportTableEntry *import,
ConstExprValue *const_val = &get_resolved_expr(node)->const_val;
- int prong_count = node->data.switch_expr.prongs.length;
+ size_t prong_count = node->data.switch_expr.prongs.length;
AstNode **peer_nodes = allocate<AstNode*>(prong_count);
TypeTableEntry **peer_types = allocate<TypeTableEntry*>(prong_count);
@@ -6118,18 +6118,18 @@ static TypeTableEntry *analyze_switch_expr(CodeGen *g, ImportTableEntry *import,
}
- int *field_use_counts = nullptr;
+ size_t *field_use_counts = nullptr;
HashMap<int, AstNode *, int_hash, int_eq> err_use_nodes = {};
if (expr_type->id == TypeTableEntryIdEnum) {
- field_use_counts = allocate<int>(expr_type->data.enumeration.field_count);
+ field_use_counts = allocate<size_t>(expr_type->data.enumeration.field_count);
} else if (expr_type->id == TypeTableEntryIdErrorUnion) {
err_use_nodes.init(10);
}
- int *const_chosen_prong_index = &node->data.switch_expr.const_chosen_prong_index;
- *const_chosen_prong_index = -1;
+ size_t *const_chosen_prong_index = &node->data.switch_expr.const_chosen_prong_index;
+ *const_chosen_prong_index = SIZE_MAX;
AstNode *else_prong = nullptr;
- for (int prong_i = 0; prong_i < prong_count; prong_i += 1) {
+ for (size_t prong_i = 0; prong_i < prong_count; prong_i += 1) {
AstNode *prong_node = node->data.switch_expr.prongs.at(prong_i);
TypeTableEntry *var_type;
@@ -6143,14 +6143,14 @@ static TypeTableEntry *analyze_switch_expr(CodeGen *g, ImportTableEntry *import,
}
var_type = expr_type;
var_is_target_expr = true;
- if (*const_chosen_prong_index == -1 && expr_val->ok) {
+ if (*const_chosen_prong_index == SIZE_MAX && expr_val->ok) {
*const_chosen_prong_index = prong_i;
}
} else {
bool all_agree_on_var_type = true;
var_type = nullptr;
- for (int item_i = 0; item_i < prong_node->data.switch_prong.items.length; item_i += 1) {
+ for (size_t item_i = 0; item_i < prong_node->data.switch_prong.items.length; item_i += 1) {
AstNode *item_node = prong_node->data.switch_prong.items.at(item_i);
if (item_node->type == NodeTypeSwitchRange) {
zig_panic("TODO range in switch statement");
@@ -6274,7 +6274,7 @@ static TypeTableEntry *analyze_switch_expr(CodeGen *g, ImportTableEntry *import,
}
}
- for (int prong_i = 0; prong_i < prong_count; prong_i += 1) {
+ for (size_t prong_i = 0; prong_i < prong_count; prong_i += 1) {
AstNode *prong_node = node->data.switch_expr.prongs.at(prong_i);
BlockContext *child_context = prong_node->data.switch_prong.block_context;
child_context->codegen_excluded = expr_val->ok && (*const_chosen_prong_index != prong_i);
@@ -6312,7 +6312,7 @@ static TypeTableEntry *analyze_switch_expr(CodeGen *g, ImportTableEntry *import,
peer_nodes, peer_types, prong_count);
if (expr_val->ok) {
- assert(*const_chosen_prong_index != -1);
+ assert(*const_chosen_prong_index != SIZE_MAX);
*const_val = get_resolved_expr(peer_nodes[*const_chosen_prong_index])->const_val;
// the target expr depends on a compile var because we have an error on unnecessary
@@ -6460,7 +6460,7 @@ static TypeTableEntry *analyze_block_expr(CodeGen *g, ImportTableEntry *import,
node->data.block.child_block = child_context;
TypeTableEntry *return_type = g->builtin_types.entry_void;
- for (int i = 0; i < node->data.block.statements.length; i += 1) {
+ for (size_t i = 0; i < node->data.block.statements.length; i += 1) {
AstNode *child = node->data.block.statements.at(i);
if (child->type == NodeTypeLabel) {
FnTableEntry *fn_table_entry = child_context->fn_entry;
@@ -6524,7 +6524,7 @@ static TypeTableEntry *analyze_asm_expr(CodeGen *g, ImportTableEntry *import, Bl
node->data.asm_expr.return_count = 0;
TypeTableEntry *return_type = g->builtin_types.entry_void;
- for (int i = 0; i < node->data.asm_expr.output_list.length; i += 1) {
+ for (size_t i = 0; i < node->data.asm_expr.output_list.length; i += 1) {
AsmOutput *asm_output = node->data.asm_expr.output_list.at(i);
if (asm_output->return_type) {
node->data.asm_expr.return_count += 1;
@@ -6547,7 +6547,7 @@ static TypeTableEntry *analyze_asm_expr(CodeGen *g, ImportTableEntry *import, Bl
}
}
}
- for (int i = 0; i < node->data.asm_expr.input_list.length; i += 1) {
+ for (size_t i = 0; i < node->data.asm_expr.input_list.length; i += 1) {
AsmInput *asm_input = node->data.asm_expr.input_list.at(i);
analyze_expression(g, import, context, nullptr, asm_input->expr);
}
@@ -6757,7 +6757,7 @@ static void analyze_fn_body(CodeGen *g, FnTableEntry *fn_table_entry) {
TypeTableEntry *fn_type = fn_table_entry->type_entry;
AstNodeFnProto *fn_proto = &fn_proto_node->data.fn_proto;
- for (int i = 0; i < fn_proto->params.length; i += 1) {
+ for (size_t i = 0; i < fn_proto->params.length; i += 1) {
AstNode *param_decl_node = fn_proto->params.at(i);
assert(param_decl_node->type == NodeTypeParamDecl);
@@ -6797,13 +6797,13 @@ static void analyze_fn_body(CodeGen *g, FnTableEntry *fn_table_entry) {
node->data.fn_def.implicit_return_type = block_return_type;
- for (int i = 0; i < fn_table_entry->goto_list.length; i += 1) {
+ for (size_t i = 0; i < fn_table_entry->goto_list.length; i += 1) {
AstNode *goto_node = fn_table_entry->goto_list.at(i);
assert(goto_node->type == NodeTypeGoto);
analyze_goto_pass2(g, import, goto_node);
}
- for (int i = 0; i < fn_table_entry->all_labels.length; i += 1) {
+ for (size_t i = 0; i < fn_table_entry->all_labels.length; i += 1) {
LabelTableEntry *label = fn_table_entry->all_labels.at(i);
if (!label->used) {
add_node_error(g, label->decl_node,
@@ -6846,8 +6846,8 @@ static void add_top_level_decl(CodeGen *g, ImportTableEntry *import, BlockContex
static void count_inline_and_var_args(AstNode *proto_node) {
assert(proto_node->type == NodeTypeFnProto);
- int *inline_arg_count = &proto_node->data.fn_proto.inline_arg_count;
- int *inline_or_var_type_arg_count = &proto_node->data.fn_proto.inline_or_var_type_arg_count;
+ size_t *inline_arg_count = &proto_node->data.fn_proto.inline_arg_count;
+ size_t *inline_or_var_type_arg_count = &proto_node->data.fn_proto.inline_or_var_type_arg_count;
*inline_arg_count = 0;
*inline_or_var_type_arg_count = 0;
@@ -6855,7 +6855,7 @@ static void count_inline_and_var_args(AstNode *proto_node) {
// TODO run these nodes through the type analysis system rather than looking for
// specialized ast nodes. this would get fooled by `{var}` instead of `var` which
// is supposed to be equivalent
- for (int i = 0; i < proto_node->data.fn_proto.params.length; i += 1) {
+ for (size_t i = 0; i < proto_node->data.fn_proto.params.length; i += 1) {
AstNode *param_node = proto_node->data.fn_proto.params.at(i);
assert(param_node->type == NodeTypeParamDecl);
if (param_node->data.param_decl.is_inline) {
@@ -6870,7 +6870,7 @@ static void count_inline_and_var_args(AstNode *proto_node) {
static void scan_decls(CodeGen *g, ImportTableEntry *import, BlockContext *context, AstNode *node) {
switch (node->type) {
case NodeTypeRoot:
- for (int i = 0; i < import->root->data.root.top_level_decls.length; i += 1) {
+ for (size_t i = 0; i < import->root->data.root.top_level_decls.length; i += 1) {
AstNode *child = import->root->data.root.top_level_decls.at(i);
scan_decls(g, import, context, child);
}
@@ -6992,7 +6992,7 @@ static void add_symbols_from_import(CodeGen *g, AstNode *src_use_node, AstNode *
tld->import->any_imports_failed = true;
}
- for (int i = 0; i < target_import->root->data.root.top_level_decls.length; i += 1) {
+ for (size_t i = 0; i < target_import->root->data.root.top_level_decls.length; i += 1) {
AstNode *decl_node = target_import->root->data.root.top_level_decls.at(i);
if (decl_node->type == NodeTypeFnDef) {
decl_node = decl_node->data.fn_def.fn_proto;
@@ -7018,7 +7018,7 @@ static void add_symbols_from_import(CodeGen *g, AstNode *src_use_node, AstNode *
}
}
- for (int i = 0; i < target_import->use_decls.length; i += 1) {
+ for (size_t i = 0; i < target_import->use_decls.length; i += 1) {
AstNode *use_decl_node = target_import->use_decls.at(i);
TopLevelDecl *target_tld = get_as_top_level_decl(use_decl_node);
if (target_tld->visib_mod != VisibModPrivate) {
@@ -7104,7 +7104,7 @@ ImportTableEntry *add_source_file(CodeGen *g, PackageTableEntry *package,
assert(import_entry->root->type == NodeTypeRoot);
- for (int decl_i = 0; decl_i < import_entry->root->data.root.top_level_decls.length; decl_i += 1) {
+ for (size_t decl_i = 0; decl_i < import_entry->root->data.root.top_level_decls.length; decl_i += 1) {
AstNode *top_level_decl = import_entry->root->data.root.top_level_decls.at(decl_i);
if (top_level_decl->type == NodeTypeFnDef) {
@@ -7135,7 +7135,7 @@ void semantic_analyze(CodeGen *g) {
preview_use_decl(g, use_decl_node);
}
- for (int i = 0; i < g->use_queue.length; i += 1) {
+ for (size_t i = 0; i < g->use_queue.length; i += 1) {
AstNode *use_decl_node = g->use_queue.at(i);
resolve_use_decl(g, use_decl_node);
}
@@ -7146,7 +7146,7 @@ void semantic_analyze(CodeGen *g) {
resolve_top_level_decl(g, decl_node, pointer_only);
}
- for (int i = 0; i < g->fn_defs.length; i += 1) {
+ for (size_t i = 0; i < g->fn_defs.length; i += 1) {
FnTableEntry *fn_entry = g->fn_defs.at(i);
if (fn_entry->anal_state == FnAnalStateReady) {
analyze_fn_body(g, fn_entry);
@@ -7321,8 +7321,8 @@ bool is_node_void_expr(AstNode *node) {
return false;
}
-TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, int size_in_bits) {
- int index;
+TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, size_t size_in_bits) {
+ size_t index;
if (size_in_bits == 8) {
index = 0;
} else if (size_in_bits == 16) {
@@ -7337,7 +7337,7 @@ TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, int size_in_bits)
return &g->builtin_types.entry_int[is_signed ? 0 : 1][index];
}
-TypeTableEntry *get_int_type(CodeGen *g, bool is_signed, int size_in_bits) {
+TypeTableEntry *get_int_type(CodeGen *g, bool is_signed, size_t size_in_bits) {
return *get_int_type_ptr(g, is_signed, size_in_bits);
}
@@ -7417,7 +7417,7 @@ uint32_t fn_type_id_hash(FnTypeId *id) {
result += id->is_cold ? 3605523458 : 0;
result += id->is_var_args ? 1931444534 : 0;
result += hash_ptr(id->return_type);
- for (int i = 0; i < id->param_count; i += 1) {
+ for (size_t i = 0; i < id->param_count; i += 1) {
FnTypeParamInfo *info = &id->param_info[i];
result += info->is_noalias ? 892356923 : 0;
result += hash_ptr(info->type);
@@ -7435,7 +7435,7 @@ bool fn_type_id_eql(FnTypeId *a, FnTypeId *b) {
{
return false;
}
- for (int i = 0; i < a->param_count; i += 1) {
+ for (size_t i = 0; i < a->param_count; i += 1) {
FnTypeParamInfo *a_param_info = &a->param_info[i];
FnTypeParamInfo *b_param_info = &b->param_info[i];
@@ -7511,7 +7511,7 @@ static uint32_t hash_const_val(TypeTableEntry *type, ConstExprValue *const_val)
uint32_t generic_fn_type_id_hash(GenericFnTypeId *id) {
uint32_t result = 0;
result += hash_ptr(id->decl_node);
- for (int i = 0; i < id->generic_param_count; i += 1) {
+ for (size_t i = 0; i < id->generic_param_count; i += 1) {
GenericParamValue *generic_param = &id->generic_params[i];
if (generic_param->node) {
ConstExprValue *const_val = &get_resolved_expr(generic_param->node)->const_val;
@@ -7526,7 +7526,7 @@ uint32_t generic_fn_type_id_hash(GenericFnTypeId *id) {
bool generic_fn_type_id_eql(GenericFnTypeId *a, GenericFnTypeId *b) {
if (a->decl_node != b->decl_node) return false;
assert(a->generic_param_count == b->generic_param_count);
- for (int i = 0; i < a->generic_param_count; i += 1) {
+ for (size_t i = 0; i < a->generic_param_count; i += 1) {
GenericParamValue *a_val = &a->generic_params[i];
GenericParamValue *b_val = &b->generic_params[i];
if (a_val->type != b_val->type) return false;
diff --git a/src/analyze.hpp b/src/analyze.hpp
index fa4bc343e8..16e0627694 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -19,8 +19,8 @@ BlockContext *new_block_context(AstNode *node, BlockContext *parent);
Expr *get_resolved_expr(AstNode *node);
bool is_node_void_expr(AstNode *node);
uint64_t type_size(CodeGen *g, TypeTableEntry *type_entry);
-TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, int size_in_bits);
-TypeTableEntry *get_int_type(CodeGen *g, bool is_signed, int size_in_bits);
+TypeTableEntry **get_int_type_ptr(CodeGen *g, bool is_signed, size_t size_in_bits);
+TypeTableEntry *get_int_type(CodeGen *g, bool is_signed, size_t size_in_bits);
TypeTableEntry **get_c_int_type_ptr(CodeGen *g, CIntType c_int_type);
TypeTableEntry *get_c_int_type(CodeGen *g, CIntType c_int_type);
TypeTableEntry *get_typedecl_type(CodeGen *g, const char *name, TypeTableEntry *child_type);
diff --git a/src/ast_render.cpp b/src/ast_render.cpp
index b18f219828..5857a88b08 100644
--- a/src/ast_render.cpp
+++ b/src/ast_render.cpp
@@ -292,7 +292,7 @@ static bool is_printable(uint8_t c) {
static void string_literal_escape(Buf *source, Buf *dest) {
buf_resize(dest, 0);
- for (int i = 0; i < buf_len(source); i += 1) {
+ for (size_t i = 0; i < buf_len(source); i += 1) {
uint8_t c = *((uint8_t*)buf_ptr(source) + i);
if (is_printable(c)) {
buf_append_char(dest, c);
@@ -330,7 +330,7 @@ static bool is_valid_bare_symbol(Buf *symbol) {
if (!is_alpha_under(first_char)) {
return false;
}
- for (int i = 1; i < buf_len(symbol); i += 1) {
+ for (size_t i = 1; i < buf_len(symbol); i += 1) {
uint8_t c = *((uint8_t*)buf_ptr(symbol) + i);
if (!is_alpha_under(c) && !is_digit(c)) {
return false;
@@ -358,7 +358,7 @@ static void render_node(AstRender *ar, AstNode *node) {
switch (node->type) {
case NodeTypeRoot:
- for (int i = 0; i < node->data.root.top_level_decls.length; i += 1) {
+ for (size_t i = 0; i < node->data.root.top_level_decls.length; i += 1) {
AstNode *child = node->data.root.top_level_decls.at(i);
print_indent(ar);
render_node(ar, child);
@@ -417,7 +417,7 @@ static void render_node(AstRender *ar, AstNode *node) {
ZigList<AstNode *> *directives =
node->data.fn_def.fn_proto->data.fn_proto.top_level_decl.directives;
if (directives) {
- for (int i = 0; i < directives->length; i += 1) {
+ for (size_t i = 0; i < directives->length; i += 1) {
render_node(ar, directives->at(i));
}
}
@@ -433,7 +433,7 @@ static void render_node(AstRender *ar, AstNode *node) {
case NodeTypeBlock:
fprintf(ar->f, "{\n");
ar->indent += ar->indent_size;
- for (int i = 0; i < node->data.block.statements.length; i += 1) {
+ for (size_t i = 0; i < node->data.block.statements.length; i += 1) {
AstNode *statement = node->data.block.statements.at(i);
print_indent(ar);
render_node(ar, statement);
@@ -561,7 +561,7 @@ static void render_node(AstRender *ar, AstNode *node) {
fprintf(ar->f, ")");
}
fprintf(ar->f, "(");
- for (int i = 0; i < node->data.fn_call_expr.params.length; i += 1) {
+ for (size_t i = 0; i < node->data.fn_call_expr.params.length; i += 1) {
AstNode *param = node->data.fn_call_expr.params.at(i);
if (i != 0) {
fprintf(ar->f, ", ");
@@ -628,7 +628,7 @@ static void render_node(AstRender *ar, AstNode *node) {
const char *container_str = container_string(node->data.struct_decl.kind);
fprintf(ar->f, "%s%s %s {\n", pub_str, container_str, struct_name);
ar->indent += ar->indent_size;
- for (int field_i = 0; field_i < node->data.struct_decl.fields.length; field_i += 1) {
+ for (size_t field_i = 0; field_i < node->data.struct_decl.fields.length; field_i += 1) {
AstNode *field_node = node->data.struct_decl.fields.at(field_i);
assert(field_node->type == NodeTypeStructField);
print_indent(ar);
diff --git a/src/bignum.cpp b/src/bignum.cpp
index 7cbb880848..d774e65abb 100644
--- a/src/bignum.cpp
+++ b/src/bignum.cpp
@@ -43,7 +43,7 @@ void bignum_init_signed(BigNum *dest, int64_t x) {
}
void bignum_init_bignum(BigNum *dest, BigNum *src) {
- memcpy(dest, src, sizeof(BigNum));
+ safe_memcpy(dest, src, 1);
}
bool bignum_fits_in_bits(BigNum *bn, int bit_count, bool is_signed) {
diff --git a/src/buffer.cpp b/src/buffer.cpp
index a03ab333f3..59972cc856 100644
--- a/src/buffer.cpp
+++ b/src/buffer.cpp
@@ -41,7 +41,7 @@ void buf_appendf(Buf *buf, const char *format, ...) {
size_t required_size = len1 + 1;
- int orig_len = buf_len(buf);
+ size_t orig_len = buf_len(buf);
buf_resize(buf, orig_len + len1);
@@ -62,7 +62,7 @@ uint32_t buf_hash(Buf *buf) {
assert(buf->list.length);
// FNV 32-bit hash
uint32_t h = 2166136261;
- for (int i = 0; i < buf_len(buf); i += 1) {
+ for (size_t i = 0; i < buf_len(buf); i += 1) {
h = h ^ ((uint8_t)buf->list.at(i));
h = h * 16777619;
}
diff --git a/src/buffer.hpp b/src/buffer.hpp
index 2900bdc1b2..5cf6e8b023 100644
--- a/src/buffer.hpp
+++ b/src/buffer.hpp
@@ -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) {
- Buf *buf = allocate<Buf>(1);
- buf_resize(buf, size);
- return buf;
+static inline Buf *buf_alloc(void) {
+ return buf_alloc_fixed(0);
}
static inline void buf_deinit(Buf *buf) {
buf->list.deinit();
}
-static inline void buf_init_from_mem(Buf *buf, const char *ptr, int len) {
- assert(len >= 0);
+static inline void buf_init_from_mem(Buf *buf, const char *ptr, size_t len) {
+ 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) {
- assert(len >= 0);
+static inline Buf *buf_create_from_mem(const char *ptr, size_t len) {
+ 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(end >= 0);
+ assert(start != SIZE_MAX);
+ 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);
- int old_len = buf_len(buf);
+ assert(mem_len != SIZE_MAX);
+ 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]);
}
}
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 39a3d498fe..7b732e4255 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -111,7 +111,7 @@ CodeGen *codegen_create(Buf *root_source_dir, const ZigTarget *target) {
return g;
}
-void codegen_set_clang_argv(CodeGen *g, const char **args, int len) {
+void codegen_set_clang_argv(CodeGen *g, const char **args, size_t len) {
g->clang_argv = args;
g->clang_argv_len = len;
}
@@ -166,6 +166,7 @@ void codegen_set_libc_include_dir(CodeGen *g, Buf *libc_include_dir) {
void codegen_set_zig_std_dir(CodeGen *g, Buf *zig_std_dir) {
g->zig_std_dir = zig_std_dir;
+
g->std_package->root_src_dir = *zig_std_dir;
}
@@ -261,7 +262,7 @@ enum AddSubMul {
AddSubMulMul = 2,
};
-static int bits_index(int size_in_bits) {
+static size_t bits_index(size_t size_in_bits) {
switch (size_in_bits) {
case 8:
return 0;
@@ -281,7 +282,7 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen *g, TypeTableEntry *type_
{
assert(type_entry->id == TypeTableEntryIdInt);
const char *signed_str = type_entry->data.integral.is_signed ? signed_name : unsigned_name;
- Buf *llvm_name = buf_sprintf("llvm.%s.with.overflow.i%d", signed_str, type_entry->data.integral.bit_count);
+ Buf *llvm_name = buf_sprintf("llvm.%s.with.overflow.i%zu", signed_str, type_entry->data.integral.bit_count);
LLVMTypeRef return_elem_types[] = {
type_entry->type_ref,
@@ -301,9 +302,9 @@ static LLVMValueRef get_arithmetic_overflow_fn(CodeGen *g, TypeTableEntry *type_
static LLVMValueRef get_int_overflow_fn(CodeGen *g, TypeTableEntry *type_entry, AddSubMul add_sub_mul) {
assert(type_entry->id == TypeTableEntryIdInt);
// [0-signed,1-unsigned][0-add,1-sub,2-mul][0-8,1-16,2-32,3-64]
- int index0 = type_entry->data.integral.is_signed ? 0 : 1;
- int index1 = add_sub_mul;
- int index2 = bits_index(type_entry->data.integral.bit_count);
+ size_t index0 = type_entry->data.integral.is_signed ? 0 : 1;
+ size_t index1 = add_sub_mul;
+ size_t index2 = bits_index(type_entry->data.integral.bit_count);
LLVMValueRef *fn = &g->int_overflow_fns[index0][index1][index2];
if (*fn) {
return *fn;
@@ -325,12 +326,12 @@ static LLVMValueRef get_int_overflow_fn(CodeGen *g, TypeTableEntry *type_entry,
static LLVMValueRef get_int_builtin_fn(CodeGen *g, TypeTableEntry *int_type, BuiltinFnId fn_id) {
// [0-ctz,1-clz][0-8,1-16,2-32,3-64]
- int index0 = (fn_id == BuiltinFnIdCtz) ? 0 : 1;
- int index1 = bits_index(int_type->data.integral.bit_count);
+ size_t index0 = (fn_id == BuiltinFnIdCtz) ? 0 : 1;
+ size_t index1 = bits_index(int_type->data.integral.bit_count);
LLVMValueRef *fn = &g->int_builtin_fns[index0][index1];
if (!*fn) {
const char *fn_name = (fn_id == BuiltinFnIdCtz) ? "cttz" : "ctlz";
- Buf *llvm_name = buf_sprintf("llvm.%s.i%d", fn_name, int_type->data.integral.bit_count);
+ Buf *llvm_name = buf_sprintf("llvm.%s.i%zu", fn_name, int_type->data.integral.bit_count);
LLVMTypeRef param_types[] = {
int_type->type_ref,
LLVMInt1Type(),
@@ -516,7 +517,7 @@ static LLVMValueRef gen_unreachable(CodeGen *g, AstNode *node) {
static LLVMValueRef gen_shl_with_overflow(CodeGen *g, AstNode *node) {
assert(node->type == NodeTypeFnCallExpr);
- int fn_call_param_count = node->data.fn_call_expr.params.length;
+ size_t fn_call_param_count = node->data.fn_call_expr.params.length;
assert(fn_call_param_count == 4);
TypeTableEntry *int_type = get_type_for_type_node(node->data.fn_call_expr.params.at(0));
@@ -561,7 +562,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
case BuiltinFnIdCtz:
case BuiltinFnIdClz:
{
- int fn_call_param_count = node->data.fn_call_expr.params.length;
+ size_t fn_call_param_count = node->data.fn_call_expr.params.length;
assert(fn_call_param_count == 2);
TypeTableEntry *int_type = get_type_for_type_node(node->data.fn_call_expr.params.at(0));
assert(int_type->id == TypeTableEntryIdInt);
@@ -578,7 +579,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
case BuiltinFnIdSubWithOverflow:
case BuiltinFnIdMulWithOverflow:
{
- int fn_call_param_count = node->data.fn_call_expr.params.length;
+ size_t fn_call_param_count = node->data.fn_call_expr.params.length;
assert(fn_call_param_count == 4);
TypeTableEntry *int_type = get_type_for_type_node(node->data.fn_call_expr.params.at(0));
@@ -615,7 +616,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
return gen_shl_with_overflow(g, node);
case BuiltinFnIdMemcpy:
{
- int fn_call_param_count = node->data.fn_call_expr.params.length;
+ size_t fn_call_param_count = node->data.fn_call_expr.params.length;
assert(fn_call_param_count == 3);
AstNode *dest_node = node->data.fn_call_expr.params.at(0);
@@ -646,7 +647,7 @@ static LLVMValueRef gen_builtin_fn_call_expr(CodeGen *g, AstNode *node) {
}
case BuiltinFnIdMemset:
{
- int fn_call_param_count = node->data.fn_call_expr.params.length;
+ size_t fn_call_param_count = node->data.fn_call_expr.params.length;
assert(fn_call_param_count == 3);
AstNode *dest_node = node->data.fn_call_expr.params.at(0);
@@ -949,14 +950,14 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
set_debug_source_node(g, node);
- int ptr_index = wanted_type->data.structure.fields[0].gen_index;
- if (ptr_index >= 0) {
+ size_t ptr_index = wanted_type->data.structure.fields[0].gen_index;
+ if (ptr_index != SIZE_MAX) {
LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, ptr_index, "");
LLVMValueRef expr_bitcast = LLVMBuildBitCast(g->builder, expr_val, pointer_type->type_ref, "");
LLVMBuildStore(g->builder, expr_bitcast, ptr_ptr);
}
- int len_index = wanted_type->data.structure.fields[1].gen_index;
+ size_t len_index = wanted_type->data.structure.fields[1].gen_index;
LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, len_index, "");
LLVMValueRef len_val = LLVMConstInt(g->builtin_types.entry_usize->type_ref,
actual_type->data.array.len, false);
@@ -979,10 +980,10 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
set_debug_source_node(g, node);
- int actual_ptr_index = actual_type->data.structure.fields[0].gen_index;
- int actual_len_index = actual_type->data.structure.fields[1].gen_index;
- int wanted_ptr_index = wanted_type->data.structure.fields[0].gen_index;
- int wanted_len_index = wanted_type->data.structure.fields[1].gen_index;
+ size_t actual_ptr_index = actual_type->data.structure.fields[0].gen_index;
+ size_t actual_len_index = actual_type->data.structure.fields[1].gen_index;
+ size_t wanted_ptr_index = wanted_type->data.structure.fields[0].gen_index;
+ size_t wanted_len_index = wanted_type->data.structure.fields[1].gen_index;
LLVMValueRef src_ptr_ptr = LLVMBuildStructGEP(g->builder, expr_val, actual_ptr_index, "");
LLVMValueRef src_ptr = LLVMBuildLoad(g->builder, src_ptr_ptr, "");
@@ -1040,12 +1041,12 @@ static LLVMValueRef gen_cast_expr(CodeGen *g, AstNode *node) {
set_debug_source_node(g, node);
- int wanted_ptr_index = wanted_type->data.structure.fields[0].gen_index;
+ size_t wanted_ptr_index = wanted_type->data.structure.fields[0].gen_index;
LLVMValueRef dest_ptr_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, wanted_ptr_index, "");
LLVMValueRef src_ptr_casted = LLVMBuildBitCast(g->builder, expr_val, wanted_pointer_type->type_ref, "");
LLVMBuildStore(g->builder, src_ptr_casted, dest_ptr_ptr);
- int wanted_len_index = wanted_type->data.structure.fields[1].gen_index;
+ size_t wanted_len_index = wanted_type->data.structure.fields[1].gen_index;
LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, cast_expr->tmp_ptr, wanted_len_index, "");
LLVMValueRef len_val = LLVMConstInt(g->builtin_types.entry_usize->type_ref,
actual_type->data.array.len / type_size(g, wanted_child_type), false);
@@ -1125,15 +1126,15 @@ static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
bool ret_has_bits = type_has_bits(src_return_type);
- int fn_call_param_count = node->data.fn_call_expr.params.length;
+ size_t fn_call_param_count = node->data.fn_call_expr.params.length;
bool first_arg_ret = ret_has_bits && handle_is_ptr(src_return_type);
- int actual_param_count = fn_call_param_count + (struct_type ? 1 : 0) + (first_arg_ret ? 1 : 0);
+ size_t actual_param_count = fn_call_param_count + (struct_type ? 1 : 0) + (first_arg_ret ? 1 : 0);
bool is_var_args = fn_type->data.fn.fn_type_id.is_var_args;
// don't really include void values
LLVMValueRef *gen_param_values = allocate<LLVMValueRef>(actual_param_count);
- int gen_param_index = 0;
+ size_t gen_param_index = 0;
if (first_arg_ret) {
gen_param_values[gen_param_index] = node->data.fn_call_expr.tmp_ptr;
gen_param_index += 1;
@@ -1144,8 +1145,8 @@ static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
gen_param_index += 1;
}
- for (int call_i = 0; call_i < fn_call_param_count; call_i += 1) {
- int proto_i = call_i + (struct_type ? 1 : 0);
+ for (size_t call_i = 0; call_i < fn_call_param_count; call_i += 1) {
+ size_t proto_i = call_i + (struct_type ? 1 : 0);
if (generic_proto_node &&
generic_proto_node->data.fn_proto.params.at(proto_i)->data.param_decl.is_inline)
{
@@ -1231,16 +1232,16 @@ static LLVMValueRef gen_array_elem_ptr(CodeGen *g, AstNode *source_node, LLVMVal
if (want_debug_safety(g, source_node)) {
set_debug_source_node(g, source_node);
- int len_index = array_type->data.structure.fields[1].gen_index;
- assert(len_index >= 0);
+ size_t len_index = array_type->data.structure.fields[1].gen_index;
+ assert(len_index != SIZE_MAX);
LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, array_ptr, len_index, "");
LLVMValueRef len = LLVMBuildLoad(g->builder, len_ptr, "");
add_bounds_check(g, source_node, subscript_value, LLVMIntEQ, nullptr, LLVMIntULT, len);
}
set_debug_source_node(g, source_node);
- int ptr_index = array_type->data.structure.fields[0].gen_index;
- assert(ptr_index >= 0);
+ size_t ptr_index = array_type->data.structure.fields[0].gen_index;
+ assert(ptr_index != SIZE_MAX);
LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, array_ptr, ptr_index, "");
LLVMValueRef ptr = LLVMBuildLoad(g->builder, ptr_ptr, "");
return LLVMBuildInBoundsGEP(g->builder, ptr, &subscript_value, 1, "");
@@ -1297,8 +1298,8 @@ static LLVMValueRef gen_field_ptr(CodeGen *g, AstNode *node, TypeTableEntry **ou
assert(LLVMGetTypeKind(LLVMTypeOf(struct_ptr)) == LLVMPointerTypeKind);
assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(struct_ptr))) == LLVMStructTypeKind);
- int gen_field_index = node->data.field_access_expr.type_struct_field->gen_index;
- assert(gen_field_index >= 0);
+ size_t gen_field_index = node->data.field_access_expr.type_struct_field->gen_index;
+ assert(gen_field_index != SIZE_MAX);
set_debug_source_node(g, node);
return LLVMBuildStructGEP(g->builder, struct_ptr, gen_field_index, "");
@@ -1368,10 +1369,10 @@ static LLVMValueRef gen_slice_expr(CodeGen *g, AstNode *node) {
assert(LLVMGetTypeKind(LLVMTypeOf(array_ptr)) == LLVMPointerTypeKind);
assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(array_ptr))) == LLVMStructTypeKind);
- int ptr_index = array_type->data.structure.fields[0].gen_index;
- assert(ptr_index >= 0);
- int len_index = array_type->data.structure.fields[1].gen_index;
- assert(len_index >= 0);
+ size_t ptr_index = array_type->data.structure.fields[0].gen_index;
+ assert(ptr_index != SIZE_MAX);
+ size_t len_index = array_type->data.structure.fields[1].gen_index;
+ assert(len_index != SIZE_MAX);
LLVMValueRef prev_end = nullptr;
if (!node->data.slice_expr.end || want_debug_safety(g, node)) {
@@ -2395,8 +2396,8 @@ static void gen_defers_for_block(CodeGen *g, BlockContext *inner_block, BlockCon
}
}
-static int get_conditional_defer_count(BlockContext *inner_block, BlockContext *outer_block) {
- int result = 0;
+static size_t get_conditional_defer_count(BlockContext *inner_block, BlockContext *outer_block) {
+ size_t result = 0;
while (inner_block != outer_block) {
if (inner_block->node->type == NodeTypeDefer &&
(inner_block->node->data.defer.kind == ReturnKindError ||
@@ -2776,7 +2777,7 @@ static LLVMValueRef gen_block(CodeGen *g, AstNode *block_node, TypeTableEntry *i
assert(block_node->type == NodeTypeBlock);
LLVMValueRef return_value = nullptr;
- for (int i = 0; i < block_node->data.block.statements.length; i += 1) {
+ for (size_t i = 0; i < block_node->data.block.statements.length; i += 1) {
AstNode *statement_node = block_node->data.block.statements.at(i);
return_value = gen_expr(g, statement_node);
}
@@ -2796,23 +2797,23 @@ static LLVMValueRef gen_block(CodeGen *g, AstNode *block_node, TypeTableEntry *i
}
}
-static int find_asm_index(CodeGen *g, AstNode *node, AsmToken *tok) {
+static size_t find_asm_index(CodeGen *g, AstNode *node, AsmToken *tok) {
const char *ptr = buf_ptr(node->data.asm_expr.asm_template) + tok->start + 2;
- int len = tok->end - tok->start - 2;
- int result = 0;
- for (int i = 0; i < node->data.asm_expr.output_list.length; i += 1, result += 1) {
+ size_t len = tok->end - tok->start - 2;
+ size_t result = 0;
+ for (size_t i = 0; i < node->data.asm_expr.output_list.length; i += 1, result += 1) {
AsmOutput *asm_output = node->data.asm_expr.output_list.at(i);
if (buf_eql_mem(asm_output->asm_symbolic_name, ptr, len)) {
return result;
}
}
- for (int i = 0; i < node->data.asm_expr.input_list.length; i += 1, result += 1) {
+ for (size_t i = 0; i < node->data.asm_expr.input_list.length; i += 1, result += 1) {
AsmInput *asm_input = node->data.asm_expr.input_list.at(i);
if (buf_eql_mem(asm_input->asm_symbolic_name, ptr, len)) {
return result;
}
}
- return -1;
+ return SIZE_MAX;
}
static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
@@ -2825,11 +2826,11 @@ static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
Buf llvm_template = BUF_INIT;
buf_resize(&llvm_template, 0);
- for (int token_i = 0; token_i < asm_expr->token_list.length; token_i += 1) {
+ for (size_t token_i = 0; token_i < asm_expr->token_list.length; token_i += 1) {
AsmToken *asm_token = &asm_expr->token_list.at(token_i);
switch (asm_token->id) {
case AsmTokenIdTemplate:
- for (int offset = asm_token->start; offset < asm_token->end; offset += 1) {
+ for (size_t offset = asm_token->start; offset < asm_token->end; offset += 1) {
uint8_t c = *((uint8_t*)(buf_ptr(src_template) + offset));
if (c == '$') {
buf_append_str(&llvm_template, "$$");
@@ -2842,9 +2843,9 @@ static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
buf_append_char(&llvm_template, '%');
break;
case AsmTokenIdVar:
- int index = find_asm_index(g, node, asm_token);
- assert(index >= 0);
- buf_appendf(&llvm_template, "$%d", index);
+ size_t index = find_asm_index(g, node, asm_token);
+ assert(index < SIZE_MAX);
+ buf_appendf(&llvm_template, "$%zu", index);
break;
}
}
@@ -2854,17 +2855,17 @@ static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
assert(asm_expr->return_count == 0 || asm_expr->return_count == 1);
- int total_constraint_count = asm_expr->output_list.length +
+ size_t total_constraint_count = asm_expr->output_list.length +
asm_expr->input_list.length +
asm_expr->clobber_list.length;
- int input_and_output_count = asm_expr->output_list.length +
+ size_t input_and_output_count = asm_expr->output_list.length +
asm_expr->input_list.length -
asm_expr->return_count;
- int total_index = 0;
- int param_index = 0;
+ size_t total_index = 0;
+ size_t param_index = 0;
LLVMTypeRef *param_types = allocate<LLVMTypeRef>(input_and_output_count);
LLVMValueRef *param_values = allocate<LLVMValueRef>(input_and_output_count);
- for (int i = 0; i < asm_expr->output_list.length; i += 1, total_index += 1) {
+ for (size_t i = 0; i < asm_expr->output_list.length; i += 1, total_index += 1) {
AsmOutput *asm_output = asm_expr->output_list.at(i);
bool is_return = (asm_output->return_type != nullptr);
assert(*buf_ptr(asm_output->constraint) == '=');
@@ -2885,7 +2886,7 @@ static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
param_index += 1;
}
}
- for (int i = 0; i < asm_expr->input_list.length; i += 1, total_index += 1, param_index += 1) {
+ for (size_t i = 0; i < asm_expr->input_list.length; i += 1, total_index += 1, param_index += 1) {
AsmInput *asm_input = asm_expr->input_list.at(i);
buf_append_buf(&constraint_buf, asm_input->constraint);
if (total_index + 1 < total_constraint_count) {
@@ -2896,7 +2897,7 @@ static LLVMValueRef gen_asm_expr(CodeGen *g, AstNode *node) {
param_types[param_index] = expr_type->type_ref;
param_values[param_index] = gen_expr(g, asm_input->expr);
}
- for (int i = 0; i < asm_expr->clobber_list.length; i += 1, total_index += 1) {
+ for (size_t i = 0; i < asm_expr->clobber_list.length; i += 1, total_index += 1) {
Buf *clobber_buf = asm_expr->clobber_list.at(i);
buf_appendf(&constraint_buf, "~{%s}", buf_ptr(clobber_buf));
if (total_index + 1 < total_constraint_count) {
@@ -2927,7 +2928,7 @@ static LLVMValueRef gen_container_init_expr(CodeGen *g, AstNode *node) {
if (node->data.container_init_expr.enum_type) {
- int param_count = node->data.container_init_expr.entries.length;
+ size_t param_count = node->data.container_init_expr.entries.length;
AstNode *arg1_node;
if (param_count == 1) {
arg1_node = node->data.container_init_expr.entries.at(0);
@@ -2943,13 +2944,13 @@ static LLVMValueRef gen_container_init_expr(CodeGen *g, AstNode *node) {
if (type_entry->id == TypeTableEntryIdStruct) {
assert(node->data.container_init_expr.kind == ContainerInitKindStruct);
- int src_field_count = type_entry->data.structure.src_field_count;
+ size_t src_field_count = type_entry->data.structure.src_field_count;
assert(src_field_count == node->data.container_init_expr.entries.length);
StructValExprCodeGen *struct_val_expr_node = &node->data.container_init_expr.resolved_struct_val_expr;
LLVMValueRef tmp_struct_ptr = struct_val_expr_node->ptr;
- for (int i = 0; i < src_field_count; i += 1) {
+ for (size_t i = 0; i < src_field_count; i += 1) {
AstNode *field_node = node->data.container_init_expr.entries.at(i);
assert(field_node->type == NodeTypeStructValueField);
TypeStructField *type_struct_field = field_node->data.struct_val_field.type_struct_field;
@@ -2974,12 +2975,12 @@ static LLVMValueRef gen_container_init_expr(CodeGen *g, AstNode *node) {
StructValExprCodeGen *struct_val_expr_node = &node->data.container_init_expr.resolved_struct_val_expr;
LLVMValueRef tmp_array_ptr = struct_val_expr_node->ptr;
- int field_count = type_entry->data.array.len;
+ size_t field_count = type_entry->data.array.len;
assert(field_count == node->data.container_init_expr.entries.length);
TypeTableEntry *child_type = type_entry->data.array.child_type;
- for (int i = 0; i < field_count; i += 1) {
+ for (size_t i = 0; i < field_count; i += 1) {
AstNode *field_node = node->data.container_init_expr.entries.at(i);
LLVMValueRef elem_val = gen_expr(g, field_node);
@@ -3126,8 +3127,8 @@ static LLVMValueRef gen_for_expr(CodeGen *g, AstNode *node) {
TypeTableEntry *child_ptr_type = array_type->data.structure.fields[0].type_entry;
assert(child_ptr_type->id == TypeTableEntryIdPointer);
child_type = child_ptr_type->data.pointer.child_type;
- int len_index = array_type->data.structure.fields[1].gen_index;
- assert(len_index >= 0);
+ size_t len_index = array_type->data.structure.fields[1].gen_index;
+ assert(len_index != SIZE_MAX);
LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, array_val, len_index, "");
len_val = LLVMBuildLoad(g->builder, len_field_ptr, "");
} else {
@@ -3249,10 +3250,10 @@ static LLVMValueRef gen_var_decl_raw(CodeGen *g, AstNode *source_node, AstNodeVa
LLVMValueRef ptr_val = LLVMBuildArrayAlloca(g->builder, child_type->type_ref,
size_val, "");
- int ptr_index = var_type->data.structure.fields[0].gen_index;
- assert(ptr_index >= 0);
- int len_index = var_type->data.structure.fields[1].gen_index;
- assert(len_index >= 0);
+ size_t ptr_index = var_type->data.structure.fields[0].gen_index;
+ assert(ptr_index != SIZE_MAX);
+ size_t len_index = var_type->data.structure.fields[1].gen_index;
+ assert(len_index != SIZE_MAX);
// store the freshly allocated pointer in the unknown size array struct
LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder,
@@ -3328,7 +3329,7 @@ static LLVMValueRef gen_symbol(CodeGen *g, AstNode *node) {
static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
assert(node->type == NodeTypeSwitchExpr);
- if (node->data.switch_expr.const_chosen_prong_index >= 0) {
+ if (node->data.switch_expr.const_chosen_prong_index != SIZE_MAX) {
AstNode *prong_node = node->data.switch_expr.prongs.at(node->data.switch_expr.const_chosen_prong_index);
assert(prong_node->type == NodeTypeSwitchProng);
AstNode *prong_expr = prong_node->data.switch_prong.expr;
@@ -3362,7 +3363,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
LLVMBasicBlockRef end_block = end_unreachable ?
nullptr : LLVMAppendBasicBlock(g->cur_fn->fn_value, "SwitchEnd");
LLVMBasicBlockRef else_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "SwitchElse");
- int prong_count = node->data.switch_expr.prongs.length;
+ size_t prong_count = node->data.switch_expr.prongs.length;
set_debug_source_node(g, node);
LLVMValueRef switch_instr = LLVMBuildSwitch(g->builder, target_value, else_block, prong_count);
@@ -3371,7 +3372,7 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
ZigList<LLVMBasicBlockRef> incoming_blocks = {0};
AstNode *else_prong = nullptr;
- for (int prong_i = 0; prong_i < prong_count; prong_i += 1) {
+ for (size_t prong_i = 0; prong_i < prong_count; prong_i += 1) {
AstNode *prong_node = node->data.switch_expr.prongs.at(prong_i);
VariableTableEntry *prong_var = prong_node->data.switch_prong.var;
@@ -3382,10 +3383,10 @@ static LLVMValueRef gen_switch_expr(CodeGen *g, AstNode *node) {
prong_block = else_block;
} else {
prong_block = LLVMAppendBasicBlock(g->cur_fn->fn_value, "SwitchProng");
- int prong_item_count = prong_node->data.switch_prong.items.length;
+ size_t prong_item_count = prong_node->data.switch_prong.items.length;
bool make_item_blocks = prong_var && prong_item_count > 1;
- for (int item_i = 0; item_i < prong_item_count; item_i += 1) {
+ for (size_t item_i = 0; item_i < prong_item_count; item_i += 1) {
AstNode *item_node = prong_node->data.switch_prong.items.at(item_i);
assert(item_node->type != NodeTypeSwitchRange);
@@ -3699,7 +3700,7 @@ static LLVMValueRef gen_const_val(CodeGen *g, TypeTableEntry *type_entry, ConstE
LLVMValueRef *fields = allocate<LLVMValueRef>(type_entry->data.structure.gen_field_count);
for (uint32_t i = 0; i < type_entry->data.structure.src_field_count; i += 1) {
TypeStructField *type_struct_field = &type_entry->data.structure.fields[i];
- if (type_struct_field->gen_index == -1) {
+ if (type_struct_field->gen_index == SIZE_MAX) {
continue;
}
fields[type_struct_field->gen_index] = gen_const_val(g, type_struct_field->type_entry,
@@ -3767,13 +3768,13 @@ static LLVMValueRef gen_const_val(CodeGen *g, TypeTableEntry *type_entry, ConstE
case TypeTableEntryIdPointer:
{
TypeTableEntry *child_type = type_entry->data.pointer.child_type;
- int len = const_val->data.x_ptr.len;
+ size_t len = const_val->data.x_ptr.len;
LLVMValueRef target_val;
if (len == 1) {
target_val = gen_const_val(g, child_type, const_val->data.x_ptr.ptr[0]);
} else if (len > 1) {
LLVMValueRef *values = allocate<LLVMValueRef>(len);
- for (int i = 0; i < len; i += 1) {
+ for (size_t i = 0; i < len; i += 1) {
values[i] = gen_const_val(g, child_type, const_val->data.x_ptr.ptr[i]);
}
target_val = LLVMConstArray(child_type->type_ref, values, len);
@@ -3833,7 +3834,7 @@ static LLVMValueRef gen_const_val(CodeGen *g, TypeTableEntry *type_entry, ConstE
}
static void gen_const_globals(CodeGen *g) {
- for (int i = 0; i < g->global_const_list.length; i += 1) {
+ for (size_t i = 0; i < g->global_const_list.length; i += 1) {
AstNode *expr_node = g->global_const_list.at(i);
Expr *expr = get_resolved_expr(expr_node);
ConstExprValue *const_val = &expr->const_val;
@@ -3927,7 +3928,7 @@ static void generate_error_name_table(CodeGen *g) {
LLVMValueRef *values = allocate<LLVMValueRef>(g->error_decls.length);
values[0] = LLVMGetUndef(str_type->type_ref);
- for (int i = 1; i < g->error_decls.length; i += 1) {
+ for (size_t i = 1; i < g->error_decls.length; i += 1) {
AstNode *error_decl_node = g->error_decls.at(i);
assert(error_decl_node->type == NodeTypeErrorValueDecl);
Buf *name = error_decl_node->data.error_value_decl.name;
@@ -3957,7 +3958,7 @@ static void generate_error_name_table(CodeGen *g) {
static void build_label_blocks(CodeGen *g, FnTableEntry *fn) {
LLVMBasicBlockRef entry_block = LLVMAppendBasicBlock(fn->fn_value, "entry");
- for (int i = 0; i < fn->all_labels.length; i += 1) {
+ for (size_t i = 0; i < fn->all_labels.length; i += 1) {
LabelTableEntry *label = fn->all_labels.at(i);
Buf *name = label->decl_node->data.label.name;
label->basic_block = LLVMAppendBasicBlock(fn->fn_value, buf_ptr(name));
@@ -3988,7 +3989,7 @@ static void do_code_gen(CodeGen *g) {
generate_error_name_table(g);
// Generate module level variables
- for (int i = 0; i < g->global_vars.length; i += 1) {
+ for (size_t i = 0; i < g->global_vars.length; i += 1) {
VariableTableEntry *var = g->global_vars.at(i);
if (var->type->id == TypeTableEntryIdNumLitFloat) {
@@ -4063,7 +4064,7 @@ static void do_code_gen(CodeGen *g) {
}
// Generate function prototypes
- for (int fn_proto_i = 0; fn_proto_i < g->fn_protos.length; fn_proto_i += 1) {
+ for (size_t fn_proto_i = 0; fn_proto_i < g->fn_protos.length; fn_proto_i += 1) {
FnTableEntry *fn_table_entry = g->fn_protos.at(fn_proto_i);
if (should_skip_fn_codegen(g, fn_table_entry)) {
// huge time saver
@@ -4097,15 +4098,15 @@ static void do_code_gen(CodeGen *g) {
// set parameter attributes
- for (int param_decl_i = 0; param_decl_i < fn_proto->params.length; param_decl_i += 1) {
+ for (size_t param_decl_i = 0; param_decl_i < fn_proto->params.length; param_decl_i += 1) {
AstNode *param_node = fn_proto->params.at(param_decl_i);
assert(param_node->type == NodeTypeParamDecl);
FnGenParamInfo *info = &fn_type->data.fn.gen_param_info[param_decl_i];
- int gen_index = info->gen_index;
+ size_t gen_index = info->gen_index;
bool is_byval = info->is_byval;
- if (gen_index < 0) {
+ if (gen_index == SIZE_MAX) {
continue;
}
@@ -4169,7 +4170,7 @@ static void do_code_gen(CodeGen *g) {
}
// Generate function definitions.
- for (int fn_i = 0; fn_i < g->fn_defs.length; fn_i += 1) {
+ for (size_t fn_i = 0; fn_i < g->fn_defs.length; fn_i += 1) {
FnTableEntry *fn_table_entry = g->fn_defs.at(fn_i);
if (should_skip_fn_codegen(g, fn_table_entry)) {
// huge time saver
@@ -4194,7 +4195,7 @@ static void do_code_gen(CodeGen *g) {
// Set up debug info for blocks
- for (int bc_i = 0; bc_i < fn_table_entry->all_block_contexts.length; bc_i += 1) {
+ for (size_t bc_i = 0; bc_i < fn_table_entry->all_block_contexts.length; bc_i += 1) {
BlockContext *block_context = fn_table_entry->all_block_contexts.at(bc_i);
if (!block_context->di_scope) {
@@ -4212,7 +4213,7 @@ static void do_code_gen(CodeGen *g) {
clear_debug_source_node(g);
// allocate structs which are the result of casts
- for (int cea_i = 0; cea_i < fn_table_entry->cast_alloca_list.length; cea_i += 1) {
+ for (size_t cea_i = 0; cea_i < fn_table_entry->cast_alloca_list.length; cea_i += 1) {
AstNode *fn_call_node = fn_table_entry->cast_alloca_list.at(cea_i);
Expr *expr = &fn_call_node->data.fn_call_expr.resolved_expr;
fn_call_node->data.fn_call_expr.tmp_ptr = LLVMBuildAlloca(g->builder,
@@ -4220,14 +4221,14 @@ static void do_code_gen(CodeGen *g) {
}
// allocate structs which are struct value expressions
- for (int alloca_i = 0; alloca_i < fn_table_entry->struct_val_expr_alloca_list.length; alloca_i += 1) {
+ for (size_t alloca_i = 0; alloca_i < fn_table_entry->struct_val_expr_alloca_list.length; alloca_i += 1) {
StructValExprCodeGen *struct_val_expr_node = fn_table_entry->struct_val_expr_alloca_list.at(alloca_i);
struct_val_expr_node->ptr = LLVMBuildAlloca(g->builder,
struct_val_expr_node->type_entry->type_ref, "");
}
// create debug variable declarations for variables and allocate all local variables
- for (int var_i = 0; var_i < fn_table_entry->variable_list.length; var_i += 1) {
+ for (size_t var_i = 0; var_i < fn_table_entry->variable_list.length; var_i += 1) {
VariableTableEntry *var = fn_table_entry->variable_list.at(var_i);
if (!type_has_bits(var->type)) {
@@ -4235,7 +4236,7 @@ static void do_code_gen(CodeGen *g) {
}
if (var->block_context->node->type == NodeTypeFnDef) {
- assert(var->gen_arg_index >= 0);
+ assert(var->gen_arg_index != SIZE_MAX);
TypeTableEntry *gen_type;
if (handle_is_ptr(var->type)) {
gen_type = fn_table_entry->type_entry->data.fn.gen_param_info[var->src_arg_index].type;
@@ -4264,13 +4265,13 @@ static void do_code_gen(CodeGen *g) {
}
// create debug variable declarations for parameters
- for (int param_i = 0; param_i < fn_proto->params.length; param_i += 1) {
+ for (size_t param_i = 0; param_i < fn_proto->params.length; param_i += 1) {
AstNode *param_decl = fn_proto->params.at(param_i);
assert(param_decl->type == NodeTypeParamDecl);
FnGenParamInfo *info = &fn_table_entry->type_entry->data.fn.gen_param_info[param_i];
- if (info->gen_index < 0) {
+ if (info->gen_index == SIZE_MAX) {
continue;
}
@@ -4306,7 +4307,7 @@ static void do_code_gen(CodeGen *g) {
#endif
}
-static const int int_sizes_in_bits[] = {
+static const size_t int_sizes_in_bits[] = {
8,
16,
32,
@@ -4380,9 +4381,9 @@ static void define_builtin_types(CodeGen *g) {
g->builtin_types.entry_var = entry;
}
- for (int int_size_i = 0; int_size_i < array_length(int_sizes_in_bits); int_size_i += 1) {
- int size_in_bits = int_sizes_in_bits[int_size_i];
- for (int is_sign_i = 0; is_sign_i < array_length(is_signed_list); is_sign_i += 1) {
+ for (size_t int_size_i = 0; int_size_i < array_length(int_sizes_in_bits); int_size_i += 1) {
+ size_t size_in_bits = int_sizes_in_bits[int_size_i];
+ for (size_t is_sign_i = 0; is_sign_i < array_length(is_signed_list); is_sign_i += 1) {
bool is_signed = is_signed_list[is_sign_i];
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
@@ -4391,7 +4392,7 @@ static void define_builtin_types(CodeGen *g) {
const char u_or_i = is_signed ? 'i' : 'u';
buf_resize(&entry->name, 0);
- buf_appendf(&entry->name, "%c%d", u_or_i, size_in_bits);
+ buf_appendf(&entry->name, "%c%zu", u_or_i, size_in_bits);
unsigned dwarf_tag;
if (is_signed) {
@@ -4420,7 +4421,7 @@ static void define_builtin_types(CodeGen *g) {
}
}
- for (int i = 0; i < array_length(c_int_type_infos); i += 1) {
+ for (size_t i = 0; i < array_length(c_int_type_infos); i += 1) {
const CIntTypeInfo *info = &c_int_type_infos[i];
uint64_t size_in_bits = get_c_type_size_in_bits(&g->zig_target, info->id);
bool is_signed = info->is_signed;
@@ -4459,7 +4460,7 @@ static void define_builtin_types(CodeGen *g) {
g->primitive_type_table.put(&entry->name, entry);
}
- for (int sign_i = 0; sign_i < array_length(is_signed_list); sign_i += 1) {
+ for (size_t sign_i = 0; sign_i < array_length(is_signed_list); sign_i += 1) {
bool is_signed = is_signed_list[sign_i];
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdInt);
@@ -4754,7 +4755,7 @@ static BuiltinFnEntry *create_builtin_fn(CodeGen *g, BuiltinFnId id, const char
return builtin_fn;
}
-static BuiltinFnEntry *create_builtin_fn_with_arg_count(CodeGen *g, BuiltinFnId id, const char *name, int count) {
+static BuiltinFnEntry *create_builtin_fn_with_arg_count(CodeGen *g, BuiltinFnId id, const char *name, size_t count) {
BuiltinFnEntry *builtin_fn = create_builtin_fn(g, id, name);
builtin_fn->param_count = count;
builtin_fn->param_types = allocate<TypeTableEntry *>(count);
@@ -4958,7 +4959,7 @@ void codegen_parseh(CodeGen *g, Buf *src_dirname, Buf *src_basename, Buf *source
}
if (errors.length > 0) {
- for (int i = 0; i < errors.length; i += 1) {
+ for (size_t i = 0; i < errors.length; i += 1) {
ErrorMsg *err_msg = errors.at(i);
print_err_msg(err_msg, g->err_color);
}
@@ -5034,7 +5035,7 @@ void codegen_add_root_code(CodeGen *g, Buf *src_dir, Buf *src_basename, Buf *sou
fprintf(stderr, "OK\n");
}
} else {
- for (int i = 0; i < g->errors.length; i += 1) {
+ for (size_t i = 0; i < g->errors.length; i += 1) {
ErrorMsg *err = g->errors.at(i);
print_err_msg(err, g->err_color);
}
@@ -5063,7 +5064,7 @@ static const char *c_int_type_names[] = {
static void get_c_type(CodeGen *g, TypeTableEntry *type_entry, Buf *out_buf) {
assert(type_entry);
- for (int i = 0; i < array_length(c_int_type_names); i += 1) {
+ for (size_t i = 0; i < array_length(c_int_type_names); i += 1) {
if (type_entry == g->builtin_types.entry_c_int[i]) {
buf_init_from_str(out_buf, c_int_type_names[i]);
return;
@@ -5114,7 +5115,7 @@ static void get_c_type(CodeGen *g, TypeTableEntry *type_entry, Buf *out_buf) {
case TypeTableEntryIdInt:
g->c_want_stdint = true;
buf_resize(out_buf, 0);
- buf_appendf(out_buf, "%sint%d_t",
+ buf_appendf(out_buf, "%sint%zu_t",
type_entry->data.integral.is_signed ? "" : "u",
type_entry->data.integral.bit_count);
break;
@@ -5183,7 +5184,7 @@ void codegen_generate_h_file(CodeGen *g) {
Buf h_buf = BUF_INIT;
buf_resize(&h_buf, 0);
- for (int fn_def_i = 0; fn_def_i < g->fn_defs.length; fn_def_i += 1) {
+ for (size_t fn_def_i = 0; fn_def_i < g->fn_defs.length; fn_def_i += 1) {
FnTableEntry *fn_table_entry = g->fn_defs.at(fn_def_i);
AstNode *proto_node = fn_table_entry->proto_node;
assert(proto_node->type == NodeTypeFnProto);
@@ -5202,7 +5203,7 @@ void codegen_generate_h_file(CodeGen *g) {
Buf param_type_c = BUF_INIT;
if (fn_proto->params.length) {
- for (int param_i = 0; param_i < fn_proto->params.length; param_i += 1) {
+ for (size_t param_i = 0; param_i < fn_proto->params.length; param_i += 1) {
AstNode *param_decl_node = fn_proto->params.at(param_i);
AstNode *param_type = param_decl_node->data.param_decl.type;
get_c_type_node(g, param_type, &param_type_c);
diff --git a/src/codegen.hpp b/src/codegen.hpp
index 17fd7ed73e..dcbe04f6d8 100644
--- a/src/codegen.hpp
+++ b/src/codegen.hpp
@@ -16,7 +16,7 @@
CodeGen *codegen_create(Buf *root_source_dir, const ZigTarget *target);
-void codegen_set_clang_argv(CodeGen *codegen, const char **args, int len);
+void codegen_set_clang_argv(CodeGen *codegen, const char **args, size_t len);
void codegen_set_is_release(CodeGen *codegen, bool is_release);
void codegen_set_is_test(CodeGen *codegen, bool is_test);
void codegen_set_check_unused(CodeGen *codegen, bool check_unused);
diff --git a/src/errmsg.cpp b/src/errmsg.cpp
index 7920620418..23bb6a1c1b 100644
--- a/src/errmsg.cpp
+++ b/src/errmsg.cpp
@@ -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;
- int col = err->column_start + 1;
+ size_t line = err->line_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,
- Buf *source, ZigList<int> *line_offsets, Buf *msg)
+ErrorMsg *err_msg_create_with_line(Buf *path, size_t line, size_t column,
+ 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);
- int end_line = line + 1;
- int 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;
- if (len < 0) {
- len = 0;
- }
+ size_t line_start_offset = line_offsets->at(line);
+ size_t end_line = line + 1;
+ size_t line_end_offset = (end_line >= line_offsets->length) ? buf_len(source) : line_offsets->at(line + 1);
+ size_t len = (line_end_offset + 1 > line_start_offset) ? (line_end_offset - line_start_offset - 1) : 0;
buf_init_from_mem(&err_msg->line_buf, buf_ptr(source) + line_start_offset, len);
diff --git a/src/errmsg.hpp b/src/errmsg.hpp
index b16249ec0b..e8b2f5872d 100644
--- a/src/errmsg.hpp
+++ b/src/errmsg.hpp
@@ -18,8 +18,8 @@ enum ErrColor {
};
struct ErrorMsg {
- int line_start;
- int column_start;
+ size_t line_start;
+ size_t column_start;
Buf *msg;
Buf *path;
Buf line_buf;
@@ -30,10 +30,10 @@ struct ErrorMsg {
void print_err_msg(ErrorMsg *msg, ErrColor color);
void err_msg_add_note(ErrorMsg *parent, ErrorMsg *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_create_with_line(Buf *path, int line, int column,
- Buf *source, ZigList<int> *line_offsets, Buf *msg);
+ErrorMsg *err_msg_create_with_line(Buf *path, size_t line, size_t column,
+ Buf *source, ZigList<size_t> *line_offsets, Buf *msg);
#endif
diff --git a/src/eval.cpp b/src/eval.cpp
index 79d3079adc..1ccf0225f4 100644
--- a/src/eval.cpp
+++ b/src/eval.cpp
@@ -75,7 +75,7 @@ static bool eval_block(EvalFn *ef, AstNode *node, ConstExprValue *out) {
my_scope->block_context = node->block_context;
ef->scope_stack.append(my_scope);
- for (int i = 0; i < node->data.block.statements.length; i += 1) {
+ for (size_t i = 0; i < node->data.block.statements.length; i += 1) {
AstNode *child = node->data.block.statements.at(i);
memset(out, 0, sizeof(ConstExprValue));
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)
}
static EvalVar *find_var(EvalFn *ef, Buf *name) {
- int scope_index = ef->scope_stack.length - 1;
- while (scope_index >= 0) {
+ size_t scope_index = ef->scope_stack.length - 1;
+ while (scope_index != SIZE_MAX) {
EvalScope *scope = ef->scope_stack.at(scope_index);
- for (int var_i = 0; var_i < scope->vars.length; var_i += 1) {
+ for (size_t var_i = 0; var_i < scope->vars.length; var_i += 1) {
EvalVar *var = &scope->vars.at(var_i);
if (buf_eql_buf(var->name, name)) {
return var;
@@ -466,18 +466,18 @@ static bool eval_container_init_expr(EvalFn *ef, AstNode *node, ConstExprValue *
!container_type->data.structure.is_slice &&
kind == ContainerInitKindStruct)
{
- int expr_field_count = container_init_expr->entries.length;
- int actual_field_count = container_type->data.structure.src_field_count;
+ size_t expr_field_count = container_init_expr->entries.length;
+ size_t actual_field_count = container_type->data.structure.src_field_count;
assert(expr_field_count == actual_field_count);
out_val->data.x_struct.fields = allocate<ConstExprValue*>(actual_field_count);
- for (int i = 0; i < expr_field_count; i += 1) {
+ for (size_t i = 0; i < expr_field_count; i += 1) {
AstNode *val_field_node = container_init_expr->entries.at(i);
assert(val_field_node->type == NodeTypeStructValueField);
TypeStructField *type_field = val_field_node->data.struct_val_field.type_struct_field;
- int field_index = type_field->src_index;
+ size_t field_index = type_field->src_index;
ConstExprValue src_field_val = {0};
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 *
kind == ContainerInitKindArray)
{
- int elem_count = container_init_expr->entries.length;
+ size_t elem_count = container_init_expr->entries.length;
out_val->ok = true;
out_val->data.x_array.fields = allocate<ConstExprValue*>(elem_count);
- for (int i = 0; i < elem_count; i += 1) {
+ for (size_t i = 0; i < elem_count; i += 1) {
AstNode *elem_node = container_init_expr->entries.at(i);
ConstExprValue *elem_val = allocate<ConstExprValue>(1);
@@ -698,7 +698,7 @@ void eval_const_expr_implicit_cast(CastOp cast_op,
static bool int_type_depends_on_compile_var(CodeGen *g, TypeTableEntry *int_type) {
assert(int_type->id == TypeTableEntryIdInt);
- for (int i = 0; i < CIntTypeCount; i += 1) {
+ for (size_t i = 0; i < CIntTypeCount; i += 1) {
if (int_type == g->builtin_types.entry_c_int[i]) {
return true;
}
@@ -918,9 +918,9 @@ static bool eval_fn_call_expr(EvalFn *ef, AstNode *node, ConstExprValue *out_val
fn_table_entry = fn_val.data.x_fn;
}
- int param_count = node->data.fn_call_expr.params.length;
+ size_t param_count = node->data.fn_call_expr.params.length;
ConstExprValue *args = allocate<ConstExprValue>(param_count);
- for (int call_i = 0; call_i < param_count; call_i += 1) {
+ for (size_t call_i = 0; call_i < param_count; call_i += 1) {
AstNode *param_expr_node = node->data.fn_call_expr.params.at(call_i);
ConstExprValue *param_val = &args[call_i];
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
root_scope->block_context = fn->fn_def_node->data.fn_def.body->block_context;
ef.scope_stack.append(root_scope);
- int param_count = acting_proto_node->data.fn_proto.params.length;
- for (int proto_i = 0; proto_i < param_count; proto_i += 1) {
+ size_t param_count = acting_proto_node->data.fn_proto.params.length;
+ for (size_t proto_i = 0; proto_i < param_count; proto_i += 1) {
AstNode *decl_param_node = acting_proto_node->data.fn_proto.params.at(proto_i);
assert(decl_param_node->type == NodeTypeParamDecl);
@@ -1358,7 +1358,7 @@ static bool eval_fn_args(EvalFnRoot *efr, FnTableEntry *fn, ConstExprValue *args
}
bool eval_fn(CodeGen *g, AstNode *node, FnTableEntry *fn, ConstExprValue *out_val,
- int branch_quota, AstNode *struct_node)
+ size_t branch_quota, AstNode *struct_node)
{
assert(node->type == NodeTypeFnCallExpr);
@@ -1375,17 +1375,17 @@ bool eval_fn(CodeGen *g, AstNode *node, FnTableEntry *fn, ConstExprValue *out_va
acting_proto_node = fn->proto_node;
}
- int call_param_count = node->data.fn_call_expr.params.length;
- int proto_param_count = acting_proto_node->data.fn_proto.params.length;
+ size_t call_param_count = node->data.fn_call_expr.params.length;
+ size_t proto_param_count = acting_proto_node->data.fn_proto.params.length;
ConstExprValue *args = allocate<ConstExprValue>(proto_param_count);
- int next_arg_index = 0;
+ size_t next_arg_index = 0;
if (struct_node) {
ConstExprValue *struct_val = &get_resolved_expr(struct_node)->const_val;
assert(struct_val->ok);
args[next_arg_index] = *struct_val;
next_arg_index += 1;
}
- for (int call_index = 0; call_index < call_param_count; call_index += 1) {
+ for (size_t call_index = 0; call_index < call_param_count; call_index += 1) {
AstNode *call_param_node = node->data.fn_call_expr.params.at(call_index);
ConstExprValue *src_const_val = &get_resolved_expr(call_param_node)->const_val;
assert(src_const_val->ok);
@@ -1396,7 +1396,7 @@ bool eval_fn(CodeGen *g, AstNode *node, FnTableEntry *fn, ConstExprValue *out_va
if (efr.exceeded_quota_node) {
ErrorMsg *msg = add_node_error(g, fn->fn_def_node,
- buf_sprintf("function evaluation exceeded %d branches", efr.branch_quota));
+ buf_sprintf("function evaluation exceeded %zu branches", efr.branch_quota));
add_error_note(g, msg, efr.call_node, buf_sprintf("called from here"));
add_error_note(g, msg, efr.exceeded_quota_node, buf_sprintf("quota exceeded here"));
diff --git a/src/eval.hpp b/src/eval.hpp
index e0236b7146..aa9606bd14 100644
--- a/src/eval.hpp
+++ b/src/eval.hpp
@@ -10,7 +10,7 @@
#include "all_types.hpp"
-bool eval_fn(CodeGen *g, AstNode *node, FnTableEntry *fn, ConstExprValue *out_val, int branch_quota,
+bool eval_fn(CodeGen *g, AstNode *node, FnTableEntry *fn, ConstExprValue *out_val, size_t branch_quota,
AstNode *struct_node);
bool const_values_equal(ConstExprValue *a, ConstExprValue *b, TypeTableEntry *type_entry);
diff --git a/src/link.cpp b/src/link.cpp
index caec1176be..9698ac46dc 100644
--- a/src/link.cpp
+++ b/src/link.cpp
@@ -172,9 +172,9 @@ static void construct_linker_job_linux(LinkJob *lj) {
lj->args.append("-shared");
buf_resize(&lj->out_file, 0);
- buf_appendf(&lj->out_file, "lib%s.so.%d.%d.%d",
+ buf_appendf(&lj->out_file, "lib%s.so.%zu.%zu.%zu",
buf_ptr(g->root_out_name), g->version_major, g->version_minor, g->version_patch);
- soname = buf_sprintf("lib%s.so.%d", buf_ptr(g->root_out_name), g->version_major);
+ soname = buf_sprintf("lib%s.so.%zu", buf_ptr(g->root_out_name), g->version_major);
}
lj->args.append("-o");
@@ -195,7 +195,7 @@ static void construct_linker_job_linux(LinkJob *lj) {
lj->args.append(get_libc_static_file(g, crtbegino));
}
- for (int i = 0; i < g->lib_dirs.length; i += 1) {
+ for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
const char *lib_dir = g->lib_dirs.at(i);
lj->args.append("-L");
lj->args.append(lib_dir);
@@ -239,7 +239,7 @@ static void construct_linker_job_linux(LinkJob *lj) {
lj->args.append(buf_ptr(compiler_rt_o_path));
}
- for (int i = 0; i < g->link_libs.length; i += 1) {
+ for (size_t i = 0; i < g->link_libs.length; i += 1) {
Buf *link_lib = g->link_libs.at(i);
Buf *arg;
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) {
lj->args.append(get_libc_static_file(g, "crtbegin.o"));
}
- for (int i = 0; i < g->lib_dirs.length; i += 1) {
+ for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
const char *lib_dir = g->lib_dirs.at(i);
lj->args.append("-L");
lj->args.append(lib_dir);
@@ -381,7 +381,7 @@ static void construct_linker_job_mingw(LinkJob *lj) {
}
- for (int i = 0; i < g->link_libs.length; i += 1) {
+ for (size_t i = 0; i < g->link_libs.length; i += 1) {
Buf *link_lib = g->link_libs.at(i);
Buf *arg = buf_sprintf("-l%s", buf_ptr(link_lib));
lj->args.append(buf_ptr(arg));
@@ -635,7 +635,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {
}
}
- for (int i = 0; i < g->lib_dirs.length; i += 1) {
+ for (size_t i = 0; i < g->lib_dirs.length; i += 1) {
const char *lib_dir = g->lib_dirs.at(i);
lj->args.append("-L");
lj->args.append(lib_dir);
@@ -649,7 +649,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {
lj->args.append(buf_ptr(test_runner_o_path));
}
- for (int i = 0; i < g->link_libs.length; i += 1) {
+ for (size_t i = 0; i < g->link_libs.length; i += 1) {
Buf *link_lib = g->link_libs.at(i);
Buf *arg = buf_sprintf("-l%s", buf_ptr(link_lib));
lj->args.append(buf_ptr(arg));
@@ -671,7 +671,7 @@ static void construct_linker_job_darwin(LinkJob *lj) {
zig_panic("TODO");
}
- for (int i = 0; i < g->darwin_frameworks.length; i += 1) {
+ for (size_t i = 0; i < g->darwin_frameworks.length; i += 1) {
lj->args.append("-framework");
lj->args.append(buf_ptr(g->darwin_frameworks.at(i)));
}
@@ -829,7 +829,7 @@ void codegen_link(CodeGen *g, const char *out_file) {
if (g->verbose) {
fprintf(stderr, "%s", buf_ptr(g->linker_path));
- for (int i = 0; i < lj.args.length; i += 1) {
+ for (size_t i = 0; i < lj.args.length; i += 1) {
fprintf(stderr, " %s", lj.args.at(i));
}
fprintf(stderr, "\n");
@@ -853,7 +853,7 @@ void codegen_link(CodeGen *g, const char *out_file) {
fprintf(stderr, "linker failed\n");
}
fprintf(stderr, "%s ", buf_ptr(g->linker_path));
- for (int i = 0; i < lj.args.length; i += 1) {
+ for (size_t i = 0; i < lj.args.length; i += 1) {
fprintf(stderr, "%s ", lj.args.at(i));
}
fprintf(stderr, "\n%s\n", buf_ptr(&ld_stderr));
diff --git a/src/list.hpp b/src/list.hpp
index 43b5370d13..e4d8689b9b 100644
--- a/src/list.hpp
+++ b/src/list.hpp
@@ -23,13 +23,13 @@ struct ZigList {
}
// remember that the pointer to this item is invalid after you
// modify the length of the list
- const T & at(int index) const {
- assert(index >= 0);
+ const T & at(size_t index) const {
+ assert(index != SIZE_MAX);
assert(index < length);
return items[index];
}
- T & at(int index) {
- assert(index >= 0);
+ T & at(size_t index) {
+ assert(index != SIZE_MAX);
assert(index < length);
return items[index];
}
@@ -52,8 +52,8 @@ struct ZigList {
return items[length - 1];
}
- void resize(int new_length) {
- assert(new_length >= 0);
+ void resize(size_t new_length) {
+ assert(new_length != SIZE_MAX);
ensure_capacity(new_length);
length = new_length;
}
@@ -62,19 +62,22 @@ struct ZigList {
length = 0;
}
- void ensure_capacity(int new_capacity) {
- int better_capacity = max(capacity, 16);
- while (better_capacity < new_capacity)
- better_capacity = better_capacity * 2;
- if (better_capacity != capacity) {
- items = reallocate_nonzero(items, better_capacity);
- capacity = better_capacity;
- }
+ void ensure_capacity(size_t new_capacity) {
+ if (capacity >= new_capacity)
+ return;
+
+ size_t better_capacity = capacity;
+ do {
+ better_capacity = better_capacity * 1.4 + 8;
+ } while (better_capacity < new_capacity);
+
+ items = reallocate_nonzero(items, capacity, better_capacity);
+ capacity = better_capacity;
}
- T * items;
- int length;
- int capacity;
+ T *items;
+ size_t length;
+ size_t capacity;
};
#endif
diff --git a/src/main.cpp b/src/main.cpp
index 6b97056e88..ca283df97f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -64,8 +64,8 @@ static int print_target_list(FILE *f) {
get_native_target(&native);
fprintf(f, "Architectures:\n");
- int arch_count = target_arch_count();
- for (int arch_i = 0; arch_i < arch_count; arch_i += 1) {
+ size_t arch_count = target_arch_count();
+ for (size_t arch_i = 0; arch_i < arch_count; arch_i += 1) {
const ArchType *arch = get_target_arch(arch_i);
char arch_name[50];
get_arch_name(arch_name, arch);
@@ -75,16 +75,16 @@ static int print_target_list(FILE *f) {
}
fprintf(f, "\nOperating Systems:\n");
- int os_count = target_os_count();
- for (int i = 0; i < os_count; i += 1) {
+ size_t os_count = target_os_count();
+ for (size_t i = 0; i < os_count; i += 1) {
ZigLLVM_OSType os_type = get_target_os(i);
const char *native_str = (native.os == os_type) ? " (native)" : "";
fprintf(f, " %s%s\n", get_target_os_name(os_type), native_str);
}
fprintf(f, "\nEnvironments:\n");
- int environ_count = target_environ_count();
- for (int i = 0; i < environ_count; i += 1) {
+ size_t environ_count = target_environ_count();
+ for (size_t i = 0; i < environ_count; i += 1) {
ZigLLVM_EnvironmentType environ_type = get_target_environ(i);
const char *native_str = (native.env_type == environ_type) ? " (native)" : "";
fprintf(f, " %s%s\n", ZigLLVMGetEnvironmentTypeName(environ_type), native_str);
@@ -375,13 +375,13 @@ int main(int argc, char **argv) {
codegen_set_verbose(g, verbose);
codegen_set_errmsg_color(g, color);
- for (int i = 0; i < lib_dirs.length; i += 1) {
+ for (size_t i = 0; i < lib_dirs.length; i += 1) {
codegen_add_lib_dir(g, lib_dirs.at(i));
}
- for (int i = 0; i < link_libs.length; i += 1) {
+ for (size_t i = 0; i < link_libs.length; i += 1) {
codegen_add_link_lib(g, link_libs.at(i));
}
- for (int i = 0; i < frameworks.length; i += 1) {
+ for (size_t i = 0; i < frameworks.length; i += 1) {
codegen_add_framework(g, frameworks.at(i));
}
diff --git a/src/os.cpp b/src/os.cpp
index 3e9ab27f8b..60e7faa423 100644
--- a/src/os.cpp
+++ b/src/os.cpp
@@ -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;
- if (last_index >= 0 && buf_ptr(full_path)[last_index] == '/') {
- last_index -= 1;
- }
- for (int i = last_index; i >= 0; i -= 1) {
- uint8_t c = buf_ptr(full_path)[i];
- if (c == '/') {
- if (out_dirname) {
- buf_init_from_mem(out_dirname, buf_ptr(full_path), i);
- }
- if (out_basename) {
- buf_init_from_mem(out_basename, buf_ptr(full_path) + i + 1, buf_len(full_path) - (i + 1));
+ size_t len = buf_len(full_path);
+ if (len != 0) {
+ size_t last_index = len - 1;
+ if (buf_ptr(full_path)[last_index] == '/') {
+ last_index -= 1;
+ }
+ for (size_t i = last_index;;) {
+ uint8_t c = buf_ptr(full_path)[i];
+ if (c == '/') {
+ if (out_dirname) {
+ buf_init_from_mem(out_dirname, buf_ptr(full_path), i);
+ }
+ 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);
- for (int c_i = 0; c_i < arg_len; c_i += 1) {
+ size_t arg_len = strlen(arg);
+ 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]);
}
diff --git a/src/parseh.cpp b/src/parseh.cpp
index 99907b2c2e..d3c964d3db 100644
--- a/src/parseh.cpp
+++ b/src/parseh.cpp
@@ -244,10 +244,10 @@ static AstNode *create_fn_proto_node(Context *c, Buf *name, TypeTableEntry *fn_t
node->data.fn_proto.name = name;
node->data.fn_proto.return_type = make_type_node(c, fn_type->data.fn.fn_type_id.return_type);
- for (int i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {
+ for (size_t i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {
FnTypeParamInfo *info = &fn_type->data.fn.fn_type_id.param_info[i];
char arg_name[20];
- sprintf(arg_name, "arg_%d", i);
+ sprintf(arg_name, "arg_%zu", i);
node->data.fn_proto.params.append(create_param_decl_node(c, arg_name,
make_type_node(c, info->type), info->is_noalias));
}
@@ -272,7 +272,7 @@ static AstNode *create_inline_fn_node(Context *c, Buf *fn_name, Buf *var_name, T
AstNode *fn_call_node = create_node(c, NodeTypeFnCallExpr);
fn_call_node->data.fn_call_expr.fn_ref_expr = unwrap_node;
- for (int i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {
+ for (size_t i = 0; i < fn_type->data.fn.fn_type_id.param_count; i += 1) {
AstNode *decl_node = node->data.fn_def.fn_proto->data.fn_proto.params.at(i);
Buf *param_name = decl_node->data.param_decl.name;
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
fn_type_id.param_info = &fn_type_id.prealloc_param_info[0];
}
- for (int i = 0; i < fn_type_id.param_count; i += 1) {
+ for (size_t i = 0; i < fn_type_id.param_count; i += 1) {
QualType qt = fn_proto_ty->getParamType(i);
TypeTableEntry *param_type = resolve_qual_type(c, qt, decl);
@@ -748,16 +748,16 @@ static void visit_fn_decl(Context *c, const FunctionDecl *fn_decl) {
assert(!fn_type->data.fn.fn_type_id.is_naked);
- int arg_count = fn_type->data.fn.fn_type_id.param_count;
+ size_t arg_count = fn_type->data.fn.fn_type_id.param_count;
Buf name_buf = BUF_INIT;
- for (int i = 0; i < arg_count; i += 1) {
+ for (size_t i = 0; i < arg_count; i += 1) {
FnTypeParamInfo *param_info = &fn_type->data.fn.fn_type_id.param_info[i];
AstNode *type_node = make_type_node(c, param_info->type);
const ParmVarDecl *param = fn_decl->getParamDecl(i);
const char *name = decl_name(param);
if (strlen(name) == 0) {
buf_resize(&name_buf, 0);
- buf_appendf(&name_buf, "arg%d", i);
+ buf_appendf(&name_buf, "arg%zu", i);
name = buf_ptr(&name_buf);
}
@@ -1316,7 +1316,7 @@ static bool name_exists_and_const(Context *c, Buf *name) {
}
static void render_aliases(Context *c) {
- for (int i = 0; i < c->aliases.length; i += 1) {
+ for (size_t i = 0; i < c->aliases.length; i += 1) {
AstNode *alias_node = c->aliases.at(i);
assert(alias_node->type == NodeTypeVariableDeclaration);
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
}
bool negate = false;
- for (int i = 0; i < ctok->tokens.length; i += 1) {
+ for (size_t i = 0; i < ctok->tokens.length; i += 1) {
bool is_first = (i == 0);
bool is_last = (i == ctok->tokens.length - 1);
CTok *tok = &ctok->tokens.at(i);
@@ -1403,7 +1403,7 @@ static void process_macro(Context *c, CTokenize *ctok, Buf *name, const char *ch
}
static void process_symbol_macros(Context *c) {
- for (int i = 0; i < c->macro_symbols.length; i += 1) {
+ for (size_t i = 0; i < c->macro_symbols.length; i += 1) {
MacroSymbol ms = c->macro_symbols.at(i);
if (name_exists_and_const(c, ms.value)) {
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
clang_argv.append("-isystem");
clang_argv.append(buf_ptr(codegen->libc_include_dir));
- for (int i = 0; i < codegen->clang_argv_len; i += 1) {
+ for (size_t i = 0; i < codegen->clang_argv_len; i += 1) {
clang_argv.append(codegen->clang_argv[i]);
}
diff --git a/src/parser.cpp b/src/parser.cpp
index fb3d67f776..e0423ae1e1 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -28,7 +28,7 @@ struct ParseContext {
__attribute__ ((format (printf, 4, 5)))
__attribute__ ((noreturn))
-static void ast_asm_error(ParseContext *pc, AstNode *node, int offset, const char *format, ...) {
+static void ast_asm_error(ParseContext *pc, AstNode *node, size_t offset, const char *format, ...) {
assert(node->type == NodeTypeAsmExpr);
@@ -109,7 +109,7 @@ static void parse_asm_template(ParseContext *pc, AstNode *node) {
enum State state = StateStart;
- for (int i = 0; i < buf_len(asm_template); i += 1) {
+ for (size_t i = 0; i < buf_len(asm_template); i += 1) {
uint8_t c = *((uint8_t*)buf_ptr(asm_template) + i);
switch (state) {
case StateStart:
@@ -205,16 +205,16 @@ static void ast_invalid_token_error(ParseContext *pc, Token *token) {
ast_error(pc, token, "invalid token: '%s'", buf_ptr(&token_value));
}
-static AstNode *ast_parse_expression(ParseContext *pc, int *token_index, bool mandatory);
-static AstNode *ast_parse_block(ParseContext *pc, int *token_index, bool mandatory);
-static AstNode *ast_parse_if_expr(ParseContext *pc, int *token_index, bool mandatory);
-static AstNode *ast_parse_block_expr(ParseContext *pc, int *token_index, bool mandatory);
-static AstNode *ast_parse_unwrap_expr(ParseContext *pc, int *token_index, bool mandatory);
-static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, int *token_index, bool mandatory);
-static AstNode *ast_parse_fn_proto(ParseContext *pc, int *token_index, bool mandatory,
+static AstNode *ast_parse_expression(ParseContext *pc, size_t *token_index, bool mandatory);
+static AstNode *ast_parse_block(ParseContext *pc, size_t *token_index, bool mandatory);
+static AstNode *ast_parse_if_expr(ParseContext *pc, size_t *token_index, bool mandatory);
+static AstNode *ast_parse_block_expr(ParseContext *pc, size_t *token_index, bool mandatory);
+static AstNode *ast_parse_unwrap_expr(ParseContext *pc, size_t *token_index, bool mandatory);
+static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, size_t *token_index, bool mandatory);
+static AstNode *ast_parse_fn_proto(ParseContext *pc, size_t *token_index, bool mandatory,
ZigList<AstNode*> *directives, VisibMod visib_mod);
-static AstNode *ast_parse_return_expr(ParseContext *pc, int *token_index);
-static AstNode *ast_parse_grouped_expr(ParseContext *pc, int *token_index, bool mandatory);
+static AstNode *ast_parse_return_expr(ParseContext *pc, size_t *token_index);
+static AstNode *ast_parse_grouped_expr(ParseContext *pc, size_t *token_index, bool mandatory);
static void ast_expect_token(ParseContext *pc, Token *token, TokenId token_id) {
if (token->id == token_id) {
@@ -226,7 +226,7 @@ static void ast_expect_token(ParseContext *pc, Token *token, TokenId token_id) {
ast_error(pc, token, "expected token '%s', found '%s'", token_name(token_id), token_name(token->id));
}
-static Token *ast_eat_token(ParseContext *pc, int *token_index, TokenId token_id) {
+static Token *ast_eat_token(ParseContext *pc, size_t *token_index, TokenId token_id) {
Token *token = &pc->tokens->at(*token_index);
ast_expect_token(pc, token, token_id);
*token_index += 1;
@@ -236,7 +236,7 @@ static Token *ast_eat_token(ParseContext *pc, int *token_index, TokenId token_id
/*
Directive = "#" "Symbol" "(" Expression ")"
*/
-static AstNode *ast_parse_directive(ParseContext *pc, int *token_index) {
+static AstNode *ast_parse_directive(ParseContext *pc, size_t *token_index) {
Token *number_sign = ast_eat_token(pc, token_index, TokenIdNumberSign);
AstNode *node = ast_create_node(pc, NodeTypeDirective, number_sign);
@@ -251,7 +251,7 @@ static AstNode *ast_parse_directive(ParseContext *pc, int *token_index) {
return node;
}
-static void ast_parse_directives(ParseContext *pc, int *token_index,
+static void ast_parse_directives(ParseContext *pc, size_t *token_index,
ZigList<AstNode *> *directives)
{
for (;;) {
@@ -269,7 +269,7 @@ static void ast_parse_directives(ParseContext *pc, int *token_index,
/*
TypeExpr = PrefixOpExpression | "var"
*/
-static AstNode *ast_parse_type_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_type_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
if (token->id == TokenIdKeywordVar) {
AstNode *node = ast_create_node(pc, NodeTypeVarLiteral, token);
@@ -283,7 +283,7 @@ static AstNode *ast_parse_type_expr(ParseContext *pc, int *token_index, bool man
/*
ParamDecl = option("noalias" | "inline") option("Symbol" ":") TypeExpr | "..."
*/
-static AstNode *ast_parse_param_decl(ParseContext *pc, int *token_index) {
+static AstNode *ast_parse_param_decl(ParseContext *pc, size_t *token_index) {
Token *token = &pc->tokens->at(*token_index);
if (token->id == TokenIdEllipsis) {
@@ -320,7 +320,7 @@ static AstNode *ast_parse_param_decl(ParseContext *pc, int *token_index) {
}
-static void ast_parse_param_decl_list(ParseContext *pc, int *token_index,
+static void ast_parse_param_decl_list(ParseContext *pc, size_t *token_index,
ZigList<AstNode *> *params, bool *is_var_args)
{
*is_var_args = false;
@@ -356,7 +356,7 @@ static void ast_parse_param_decl_list(ParseContext *pc, int *token_index,
zig_unreachable();
}
-static void ast_parse_fn_call_param_list(ParseContext *pc, int *token_index, ZigList<AstNode*> *params) {
+static void ast_parse_fn_call_param_list(ParseContext *pc, size_t *token_index, ZigList<AstNode*> *params) {
Token *token = &pc->tokens->at(*token_index);
if (token->id == TokenIdRParen) {
*token_index += 1;
@@ -381,7 +381,7 @@ static void ast_parse_fn_call_param_list(ParseContext *pc, int *token_index, Zig
/*
GroupedExpression : token(LParen) Expression token(RParen)
*/
-static AstNode *ast_parse_grouped_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_grouped_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *l_paren = &pc->tokens->at(*token_index);
if (l_paren->id != TokenIdLParen) {
if (mandatory) {
@@ -405,7 +405,7 @@ static AstNode *ast_parse_grouped_expr(ParseContext *pc, int *token_index, bool
/*
ArrayType : "[" option(Expression) "]" option("const") PrefixOpExpression
*/
-static AstNode *ast_parse_array_type_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_array_type_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *l_bracket = &pc->tokens->at(*token_index);
if (l_bracket->id != TokenIdLBracket) {
if (mandatory) {
@@ -437,7 +437,7 @@ static AstNode *ast_parse_array_type_expr(ParseContext *pc, int *token_index, bo
/*
AsmInputItem : token(LBracket) token(Symbol) token(RBracket) token(String) token(LParen) Expression token(RParen)
*/
-static void ast_parse_asm_input_item(ParseContext *pc, int *token_index, AstNode *node) {
+static void ast_parse_asm_input_item(ParseContext *pc, size_t *token_index, AstNode *node) {
ast_eat_token(pc, token_index, TokenIdLBracket);
Token *alias = ast_eat_token(pc, token_index, TokenIdSymbol);
ast_eat_token(pc, token_index, TokenIdRBracket);
@@ -458,7 +458,7 @@ static void ast_parse_asm_input_item(ParseContext *pc, int *token_index, AstNode
/*
AsmOutputItem : "[" "Symbol" "]" "String" "(" ("Symbol" | "->" PrefixOpExpression) ")"
*/
-static void ast_parse_asm_output_item(ParseContext *pc, int *token_index, AstNode *node) {
+static void ast_parse_asm_output_item(ParseContext *pc, size_t *token_index, AstNode *node) {
ast_eat_token(pc, token_index, TokenIdLBracket);
Token *alias = ast_eat_token(pc, token_index, TokenIdSymbol);
ast_eat_token(pc, token_index, TokenIdRBracket);
@@ -489,7 +489,7 @@ static void ast_parse_asm_output_item(ParseContext *pc, int *token_index, AstNod
/*
AsmClobbers: token(Colon) list(token(String), token(Comma))
*/
-static void ast_parse_asm_clobbers(ParseContext *pc, int *token_index, AstNode *node) {
+static void ast_parse_asm_clobbers(ParseContext *pc, size_t *token_index, AstNode *node) {
Token *colon_tok = &pc->tokens->at(*token_index);
if (colon_tok->id != TokenIdColon)
@@ -519,7 +519,7 @@ static void ast_parse_asm_clobbers(ParseContext *pc, int *token_index, AstNode *
/*
AsmInput : token(Colon) list(AsmInputItem, token(Comma)) option(AsmClobbers)
*/
-static void ast_parse_asm_input(ParseContext *pc, int *token_index, AstNode *node) {
+static void ast_parse_asm_input(ParseContext *pc, size_t *token_index, AstNode *node) {
Token *colon_tok = &pc->tokens->at(*token_index);
if (colon_tok->id != TokenIdColon)
@@ -546,7 +546,7 @@ static void ast_parse_asm_input(ParseContext *pc, int *token_index, AstNode *nod
/*
AsmOutput : token(Colon) list(AsmOutputItem, token(Comma)) option(AsmInput)
*/
-static void ast_parse_asm_output(ParseContext *pc, int *token_index, AstNode *node) {
+static void ast_parse_asm_output(ParseContext *pc, size_t *token_index, AstNode *node) {
Token *colon_tok = &pc->tokens->at(*token_index);
if (colon_tok->id != TokenIdColon)
@@ -579,7 +579,7 @@ static void ast_parse_asm_output(ParseContext *pc, int *token_index, AstNode *no
/*
AsmExpression : token(Asm) option(token(Volatile)) token(LParen) token(String) option(AsmOutput) token(RParen)
*/
-static AstNode *ast_parse_asm_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_asm_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *asm_token = &pc->tokens->at(*token_index);
if (asm_token->id != TokenIdKeywordAsm) {
@@ -622,7 +622,7 @@ static AstNode *ast_parse_asm_expr(ParseContext *pc, int *token_index, bool mand
PrimaryExpression = "Number" | "String" | "CharLiteral" | KeywordLiteral | GroupedExpression | GotoExpression | BlockExpression | "Symbol" | ("@" "Symbol" FnCallExpression) | ArrayType | FnProto | AsmExpression | ("error" "." "Symbol")
KeywordLiteral = "true" | "false" | "null" | "break" | "continue" | "undefined" | "zeroes" | "error" | "type"
*/
-static AstNode *ast_parse_primary_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_primary_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
if (token->id == TokenIdNumberLiteral) {
@@ -752,7 +752,7 @@ CurlySuffixExpression : PrefixOpExpression option(ContainerInitExpression)
ContainerInitExpression : token(LBrace) ContainerInitBody token(RBrace)
ContainerInitBody : list(StructLiteralField, token(Comma)) | list(Expression, token(Comma))
*/
-static AstNode *ast_parse_curly_suffix_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_curly_suffix_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *prefix_op_expr = ast_parse_prefix_op_expr(pc, token_index, mandatory);
if (!prefix_op_expr) {
return nullptr;
@@ -843,7 +843,7 @@ SliceExpression : token(LBracket) Expression token(Ellipsis) option(Expression)
FieldAccessExpression : token(Dot) token(Symbol)
StructLiteralField : token(Dot) token(Symbol) token(Eq) Expression
*/
-static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_suffix_op_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *primary_expr = ast_parse_primary_expr(pc, token_index, mandatory);
if (!primary_expr) {
return nullptr;
@@ -936,7 +936,7 @@ static PrefixOp tok_to_prefix_op(Token *token) {
PrefixOpExpression : PrefixOp PrefixOpExpression | SuffixOpExpression
PrefixOp = "!" | "-" | "~" | "*" | ("&" option("const")) | "?" | "%" | "%%" | "??" | "-%"
*/
-static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_prefix_op_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
PrefixOp prefix_op = tok_to_prefix_op(token);
if (prefix_op == PrefixOpInvalid) {
@@ -1005,7 +1005,7 @@ static BinOpType tok_to_mult_op(Token *token) {
/*
MultiplyOperator = "*" | "/" | "%" | "**" | "*%"
*/
-static BinOpType ast_parse_mult_op(ParseContext *pc, int *token_index, bool mandatory) {
+static BinOpType ast_parse_mult_op(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
BinOpType result = tok_to_mult_op(token);
if (result == BinOpTypeInvalid) {
@@ -1022,7 +1022,7 @@ static BinOpType ast_parse_mult_op(ParseContext *pc, int *token_index, bool mand
/*
MultiplyExpression : CurlySuffixExpression MultiplyOperator MultiplyExpression | CurlySuffixExpression
*/
-static AstNode *ast_parse_mult_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_mult_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_curly_suffix_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1059,7 +1059,7 @@ static BinOpType tok_to_add_op(Token *token) {
/*
AdditionOperator = "+" | "-" | "++" | "+%" | "-%"
*/
-static BinOpType ast_parse_add_op(ParseContext *pc, int *token_index, bool mandatory) {
+static BinOpType ast_parse_add_op(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
BinOpType result = tok_to_add_op(token);
if (result == BinOpTypeInvalid) {
@@ -1076,7 +1076,7 @@ static BinOpType ast_parse_add_op(ParseContext *pc, int *token_index, bool manda
/*
AdditionExpression : MultiplyExpression AdditionOperator AdditionExpression | MultiplyExpression
*/
-static AstNode *ast_parse_add_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_add_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_mult_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1111,7 +1111,7 @@ static BinOpType tok_to_bit_shift_op(Token *token) {
/*
BitShiftOperator = "<<" | ">>" | "<<%"
*/
-static BinOpType ast_parse_bit_shift_op(ParseContext *pc, int *token_index, bool mandatory) {
+static BinOpType ast_parse_bit_shift_op(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
BinOpType result = tok_to_bit_shift_op(token);
if (result == BinOpTypeInvalid) {
@@ -1128,7 +1128,7 @@ static BinOpType ast_parse_bit_shift_op(ParseContext *pc, int *token_index, bool
/*
BitShiftExpression : AdditionExpression BitShiftOperator BitShiftExpression | AdditionExpression
*/
-static AstNode *ast_parse_bit_shift_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_bit_shift_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_add_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1155,7 +1155,7 @@ static AstNode *ast_parse_bit_shift_expr(ParseContext *pc, int *token_index, boo
/*
BinaryAndExpression : BitShiftExpression token(Ampersand) BinaryAndExpression | BitShiftExpression
*/
-static AstNode *ast_parse_bin_and_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_bin_and_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_bit_shift_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1181,7 +1181,7 @@ static AstNode *ast_parse_bin_and_expr(ParseContext *pc, int *token_index, bool
/*
BinaryXorExpression : BinaryAndExpression token(BinXor) BinaryXorExpression | BinaryAndExpression
*/
-static AstNode *ast_parse_bin_xor_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_bin_xor_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_bin_and_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1207,7 +1207,7 @@ static AstNode *ast_parse_bin_xor_expr(ParseContext *pc, int *token_index, bool
/*
BinaryOrExpression : BinaryXorExpression token(BinOr) BinaryOrExpression | BinaryXorExpression
*/
-static AstNode *ast_parse_bin_or_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_bin_or_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_bin_xor_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1242,7 +1242,7 @@ static BinOpType tok_to_cmp_op(Token *token) {
}
}
-static BinOpType ast_parse_comparison_operator(ParseContext *pc, int *token_index, bool mandatory) {
+static BinOpType ast_parse_comparison_operator(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
BinOpType result = tok_to_cmp_op(token);
if (result == BinOpTypeInvalid) {
@@ -1259,7 +1259,7 @@ static BinOpType ast_parse_comparison_operator(ParseContext *pc, int *token_inde
/*
ComparisonExpression : BinaryOrExpression ComparisonOperator BinaryOrExpression | BinaryOrExpression
*/
-static AstNode *ast_parse_comparison_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_comparison_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_bin_or_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1283,7 +1283,7 @@ static AstNode *ast_parse_comparison_expr(ParseContext *pc, int *token_index, bo
/*
BoolAndExpression : ComparisonExpression token(BoolAnd) BoolAndExpression | ComparisonExpression
*/
-static AstNode *ast_parse_bool_and_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_bool_and_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_comparison_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1309,7 +1309,7 @@ static AstNode *ast_parse_bool_and_expr(ParseContext *pc, int *token_index, bool
/*
Else : token(Else) Expression
*/
-static AstNode *ast_parse_else(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_else(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *else_token = &pc->tokens->at(*token_index);
if (else_token->id != TokenIdKeywordElse) {
@@ -1329,7 +1329,7 @@ IfExpression : IfVarExpression | IfBoolExpression
IfBoolExpression : token(If) token(LParen) Expression token(RParen) Expression option(Else)
IfVarExpression = "if" "(" ("const" | "var") option("*") "Symbol" option(":" TypeExpr) "?=" Expression ")" Expression Option(Else)
*/
-static AstNode *ast_parse_if_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_if_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *if_tok = &pc->tokens->at(*token_index);
if (if_tok->id != TokenIdKeywordIf) {
if (mandatory) {
@@ -1396,7 +1396,7 @@ static AstNode *ast_parse_if_expr(ParseContext *pc, int *token_index, bool manda
/*
ReturnExpression : option("%" | "?") "return" option(Expression)
*/
-static AstNode *ast_parse_return_expr(ParseContext *pc, int *token_index) {
+static AstNode *ast_parse_return_expr(ParseContext *pc, size_t *token_index) {
Token *token = &pc->tokens->at(*token_index);
NodeType node_type;
@@ -1439,7 +1439,7 @@ static AstNode *ast_parse_return_expr(ParseContext *pc, int *token_index) {
/*
Defer = option("%" | "?") "defer" option(Expression)
*/
-static AstNode *ast_parse_defer_expr(ParseContext *pc, int *token_index) {
+static AstNode *ast_parse_defer_expr(ParseContext *pc, size_t *token_index) {
Token *token = &pc->tokens->at(*token_index);
NodeType node_type;
@@ -1482,7 +1482,7 @@ static AstNode *ast_parse_defer_expr(ParseContext *pc, int *token_index) {
/*
VariableDeclaration : ("var" | "const") "Symbol" ("=" Expression | ":" PrefixOpExpression option("=" Expression))
*/
-static AstNode *ast_parse_variable_declaration_expr(ParseContext *pc, int *token_index, bool mandatory,
+static AstNode *ast_parse_variable_declaration_expr(ParseContext *pc, size_t *token_index, bool mandatory,
ZigList<AstNode*> *directives, VisibMod visib_mod)
{
Token *first_token = &pc->tokens->at(*token_index);
@@ -1536,7 +1536,7 @@ static AstNode *ast_parse_variable_declaration_expr(ParseContext *pc, int *token
/*
BoolOrExpression : BoolAndExpression token(BoolOr) BoolOrExpression | BoolAndExpression
*/
-static AstNode *ast_parse_bool_or_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_bool_or_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *operand_1 = ast_parse_bool_and_expr(pc, token_index, mandatory);
if (!operand_1)
return nullptr;
@@ -1562,7 +1562,7 @@ static AstNode *ast_parse_bool_or_expr(ParseContext *pc, int *token_index, bool
/*
WhileExpression = "while" "(" Expression option(";" Expression) ")" Expression
*/
-static AstNode *ast_parse_while_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_while_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
if (token->id != TokenIdKeywordWhile) {
@@ -1598,7 +1598,7 @@ static AstNode *ast_parse_while_expr(ParseContext *pc, int *token_index, bool ma
return node;
}
-static AstNode *ast_parse_symbol(ParseContext *pc, int *token_index) {
+static AstNode *ast_parse_symbol(ParseContext *pc, size_t *token_index) {
Token *token = ast_eat_token(pc, token_index, TokenIdSymbol);
AstNode *node = ast_create_node(pc, NodeTypeSymbol, token);
node->data.symbol_expr.symbol = token_buf(token);
@@ -1608,7 +1608,7 @@ static AstNode *ast_parse_symbol(ParseContext *pc, int *token_index) {
/*
ForExpression = "for" "(" Expression ")" option("|" option("*") "Symbol" option("," "Symbol") "|") Expression
*/
-static AstNode *ast_parse_for_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_for_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
if (token->id != TokenIdKeywordFor) {
@@ -1659,7 +1659,7 @@ SwitchExpression : "switch" "(" Expression ")" "{" many(SwitchProng) "}"
SwitchProng = (list(SwitchItem, ",") | "else") "=>" option("|" "Symbol" "|") Expression ","
SwitchItem : Expression | (Expression "..." Expression)
*/
-static AstNode *ast_parse_switch_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_switch_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
if (token->id != TokenIdKeywordSwitch) {
@@ -1736,7 +1736,7 @@ static AstNode *ast_parse_switch_expr(ParseContext *pc, int *token_index, bool m
/*
BlockExpression : IfExpression | Block | WhileExpression | ForExpression | SwitchExpression
*/
-static AstNode *ast_parse_block_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_block_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
AstNode *if_expr = ast_parse_if_expr(pc, token_index, false);
@@ -1791,7 +1791,7 @@ static BinOpType tok_to_ass_op(Token *token) {
/*
AssignmentOperator = "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" | "&&=" | "||=" | "*%=" | "+%=" | "-%=" | "<<%="
*/
-static BinOpType ast_parse_ass_op(ParseContext *pc, int *token_index, bool mandatory) {
+static BinOpType ast_parse_ass_op(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
BinOpType result = tok_to_ass_op(token);
if (result == BinOpTypeInvalid) {
@@ -1810,7 +1810,7 @@ UnwrapExpression : BoolOrExpression (UnwrapMaybe | UnwrapError) | BoolOrExpressi
UnwrapMaybe : "??" BoolOrExpression
UnwrapError : "%%" option("|" "Symbol" "|") BoolOrExpression
*/
-static AstNode *ast_parse_unwrap_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_unwrap_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *lhs = ast_parse_bool_or_expr(pc, token_index, mandatory);
if (!lhs)
return nullptr;
@@ -1853,7 +1853,7 @@ static AstNode *ast_parse_unwrap_expr(ParseContext *pc, int *token_index, bool m
/*
AssignmentExpression : UnwrapExpression AssignmentOperator UnwrapExpression | UnwrapExpression
*/
-static AstNode *ast_parse_ass_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_ass_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
AstNode *lhs = ast_parse_unwrap_expr(pc, token_index, mandatory);
if (!lhs)
return nullptr;
@@ -1877,7 +1877,7 @@ static AstNode *ast_parse_ass_expr(ParseContext *pc, int *token_index, bool mand
/*
NonBlockExpression : ReturnExpression | AssignmentExpression
*/
-static AstNode *ast_parse_non_block_expr(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_non_block_expr(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
AstNode *return_expr = ast_parse_return_expr(pc, token_index);
@@ -1897,7 +1897,7 @@ static AstNode *ast_parse_non_block_expr(ParseContext *pc, int *token_index, boo
/*
Expression : BlockExpression | NonBlockExpression
*/
-static AstNode *ast_parse_expression(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_expression(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *token = &pc->tokens->at(*token_index);
AstNode *block_expr = ast_parse_block_expr(pc, token_index, false);
@@ -1917,7 +1917,7 @@ static AstNode *ast_parse_expression(ParseContext *pc, int *token_index, bool ma
/*
Label: token(Symbol) token(Colon)
*/
-static AstNode *ast_parse_label(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_label(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *symbol_token = &pc->tokens->at(*token_index);
if (symbol_token->id != TokenIdSymbol) {
if (mandatory) {
@@ -1956,7 +1956,7 @@ static AstNode *ast_create_void_expr(ParseContext *pc, Token *token) {
Block : token(LBrace) list(option(Statement), token(Semicolon)) token(RBrace)
Statement = Label | VariableDeclaration ";" | Defer ";" | NonBlockExpression ";" | BlockExpression
*/
-static AstNode *ast_parse_block(ParseContext *pc, int *token_index, bool mandatory) {
+static AstNode *ast_parse_block(ParseContext *pc, size_t *token_index, bool mandatory) {
Token *last_token = &pc->tokens->at(*token_index);
if (last_token->id != TokenIdLBrace) {
@@ -2021,7 +2021,7 @@ static AstNode *ast_parse_block(ParseContext *pc, int *token_index, bool mandato
/*
FnProto = "fn" option("Symbol") ParamDeclList option("->" TypeExpr)
*/
-static AstNode *ast_parse_fn_proto(ParseContext *pc, int *token_index, bool mandatory,
+static AstNode *ast_parse_fn_proto(ParseContext *pc, size_t *token_index, bool mandatory,
ZigList<AstNode*> *directives, VisibMod visib_mod)
{
Token *first_token = &pc->tokens->at(*token_index);
@@ -2064,7 +2064,7 @@ static AstNode *ast_parse_fn_proto(ParseContext *pc, int *token_index, bool mand
/*
FnDef = option("inline" | "extern") FnProto Block
*/
-static AstNode *ast_parse_fn_def(ParseContext *pc, int *token_index, bool mandatory,
+static AstNode *ast_parse_fn_def(ParseContext *pc, size_t *token_index, bool mandatory,
ZigList<AstNode*> *directives, VisibMod visib_mod)
{
Token *first_token = &pc->tokens->at(*token_index);
@@ -2111,7 +2111,7 @@ static AstNode *ast_parse_fn_def(ParseContext *pc, int *token_index, bool mandat
/*
ExternDecl = "extern" (FnProto | VariableDeclaration) ";"
*/
-static AstNode *ast_parse_extern_decl(ParseContext *pc, int *token_index, bool mandatory,
+static AstNode *ast_parse_extern_decl(ParseContext *pc, size_t *token_index, bool mandatory,
ZigList<AstNode *> *directives, VisibMod visib_mod)
{
Token *extern_kw = &pc->tokens->at(*token_index);
@@ -2151,7 +2151,7 @@ static AstNode *ast_parse_extern_decl(ParseContext *pc, int *token_index, bool m
/*
UseDecl = "use" Expression ";"
*/
-static AstNode *ast_parse_use(ParseContext *pc, int *token_index,
+static AstNode *ast_parse_use(ParseContext *pc, size_t *token_index,
ZigList<AstNode*> *directives, VisibMod visib_mod)
{
Token *use_kw = &pc->tokens->at(*token_index);
@@ -2175,7 +2175,7 @@ ContainerDecl = ("struct" | "enum" | "union") "Symbol" option(ParamDeclList) "{"
StructMember = many(Directive) option(VisibleMod) (StructField | FnDef | GlobalVarDecl | ContainerDecl)
StructField : "Symbol" option(":" Expression) ",")
*/
-static AstNode *ast_parse_container_decl(ParseContext *pc, int *token_index,
+static AstNode *ast_parse_container_decl(ParseContext *pc, size_t *token_index,
ZigList<AstNode*> *directives, VisibMod visib_mod)
{
Token *first_token = &pc->tokens->at(*token_index);
@@ -2289,7 +2289,7 @@ static AstNode *ast_parse_container_decl(ParseContext *pc, int *token_index,
/*
ErrorValueDecl : "error" "Symbol" ";"
*/
-static AstNode *ast_parse_error_value_decl(ParseContext *pc, int *token_index,
+static AstNode *ast_parse_error_value_decl(ParseContext *pc, size_t *token_index,
ZigList<AstNode*> *directives, VisibMod visib_mod)
{
Token *first_token = &pc->tokens->at(*token_index);
@@ -2314,7 +2314,7 @@ static AstNode *ast_parse_error_value_decl(ParseContext *pc, int *token_index,
/*
TypeDecl = "type" "Symbol" "=" TypeExpr ";"
*/
-static AstNode *ast_parse_type_decl(ParseContext *pc, int *token_index,
+static AstNode *ast_parse_type_decl(ParseContext *pc, size_t *token_index,
ZigList<AstNode*> *directives, VisibMod visib_mod)
{
Token *first_token = &pc->tokens->at(*token_index);
@@ -2343,7 +2343,7 @@ static AstNode *ast_parse_type_decl(ParseContext *pc, int *token_index,
/*
TopLevelDecl = many(Directive) option(VisibleMod) (FnDef | ExternDecl | Import | ContainerDecl | GlobalVarDecl | ErrorValueDecl | CImportDecl | TypeDecl)
*/
-static void ast_parse_top_level_decls(ParseContext *pc, int *token_index, ZigList<AstNode *> *top_level_decls) {
+static void ast_parse_top_level_decls(ParseContext *pc, size_t *token_index, ZigList<AstNode *> *top_level_decls) {
for (;;) {
Token *directive_token = &pc->tokens->at(*token_index);
ZigList<AstNode *> *directives = allocate<ZigList<AstNode*>>(1);
@@ -2417,7 +2417,7 @@ static void ast_parse_top_level_decls(ParseContext *pc, int *token_index, ZigLis
/*
Root : many(TopLevelDecl) token(EOF)
*/
-static AstNode *ast_parse_root(ParseContext *pc, int *token_index) {
+static AstNode *ast_parse_root(ParseContext *pc, size_t *token_index) {
AstNode *node = ast_create_node(pc, NodeTypeRoot, &pc->tokens->at(*token_index));
ast_parse_top_level_decls(pc, token_index, &node->data.root.top_level_decls);
@@ -2441,7 +2441,7 @@ AstNode *ast_parse(Buf *buf, ZigList<Token> *tokens, ImportTableEntry *owner,
pc.buf = buf;
pc.tokens = tokens;
pc.next_node_index = next_node_index;
- int token_index = 0;
+ size_t token_index = 0;
pc.root = ast_parse_root(&pc, &token_index);
return pc.root;
}
@@ -2454,7 +2454,7 @@ static void visit_field(AstNode **node, void (*visit)(AstNode **, void *context)
static void visit_node_list(ZigList<AstNode *> *list, void (*visit)(AstNode **, void *context), void *context) {
if (list) {
- for (int i = 0; i < list->length; i += 1) {
+ for (size_t i = 0; i < list->length; i += 1) {
visit(&list->at(i), context);
}
}
@@ -2607,11 +2607,11 @@ void ast_visit_node_children(AstNode *node, void (*visit)(AstNode **, void *cont
// none
break;
case NodeTypeAsmExpr:
- for (int i = 0; i < node->data.asm_expr.input_list.length; i += 1) {
+ for (size_t i = 0; i < node->data.asm_expr.input_list.length; i += 1) {
AsmInput *asm_input = node->data.asm_expr.input_list.at(i);
visit_field(&asm_input->expr, visit, context);
}
- for (int i = 0; i < node->data.asm_expr.output_list.length; i += 1) {
+ for (size_t i = 0; i < node->data.asm_expr.output_list.length; i += 1) {
AsmOutput *asm_output = node->data.asm_expr.output_list.at(i);
visit_field(&asm_output->return_type, visit, context);
}
@@ -2659,7 +2659,7 @@ void normalize_parent_ptrs(AstNode *node) {
static void clone_subtree_list(ZigList<AstNode *> *dest, ZigList<AstNode *> *src, uint32_t *next_node_index) {
memset(dest, 0, sizeof(ZigList<AstNode *>));
dest->resize(src->length);
- for (int i = 0; i < src->length; i += 1) {
+ for (size_t i = 0; i < src->length; i += 1) {
dest->at(i) = ast_clone_subtree(src->at(i), next_node_index);
dest->at(i)->parent_field = &dest->at(i);
}
@@ -2670,7 +2670,7 @@ static void clone_subtree_list_omit_inline_params(ZigList<AstNode *> *dest, ZigL
{
memset(dest, 0, sizeof(ZigList<AstNode *>));
dest->ensure_capacity(src->length);
- for (int i = 0; i < src->length; i += 1) {
+ for (size_t i = 0; i < src->length; i += 1) {
AstNode *src_node = src->at(i);
assert(src_node->type == NodeTypeParamDecl);
if (src_node->data.param_decl.is_inline) {
@@ -2712,7 +2712,7 @@ static void clone_subtree_tld(TopLevelDecl *dest, TopLevelDecl *src, uint32_t *n
AstNode *ast_clone_subtree_special(AstNode *old_node, uint32_t *next_node_index, enum AstCloneSpecial special) {
AstNode *new_node = allocate_nonzero<AstNode>(1);
- memcpy(new_node, old_node, sizeof(AstNode));
+ safe_memcpy(new_node, old_node, 1);
new_node->create_index = *next_node_index;
*next_node_index += 1;
new_node->parent_field = nullptr;
diff --git a/src/target.cpp b/src/target.cpp
index b72f5fc751..005d3ffebb 100644
--- a/src/target.cpp
+++ b/src/target.cpp
@@ -156,7 +156,7 @@ static const ZigLLVM_ObjectFormatType oformat_list[] = {
ZigLLVM_MachO,
};
-int target_oformat_count(void) {
+size_t target_oformat_count(void) {
return array_length(oformat_list);
}
@@ -174,7 +174,7 @@ const char *get_target_oformat_name(ZigLLVM_ObjectFormatType oformat) {
zig_unreachable();
}
-int target_arch_count(void) {
+size_t target_arch_count(void) {
return array_length(arch_list);
}
@@ -182,7 +182,7 @@ const ArchType *get_target_arch(int index) {
return &arch_list[index];
}
-int target_vendor_count(void) {
+size_t target_vendor_count(void) {
return array_length(vendor_list);
}
@@ -190,7 +190,7 @@ ZigLLVM_VendorType get_target_vendor(int index) {
return vendor_list[index];
}
-int target_os_count(void) {
+size_t target_os_count(void) {
return array_length(os_list);
}
ZigLLVM_OSType get_target_os(int index) {
@@ -201,7 +201,7 @@ const char *get_target_os_name(ZigLLVM_OSType os_type) {
return (os_type == ZigLLVM_UnknownOS) ? "freestanding" : ZigLLVMGetOSTypeName(os_type);
}
-int target_environ_count(void) {
+size_t target_environ_count(void) {
return array_length(environ_list);
}
ZigLLVM_EnvironmentType get_target_environ(int index) {
@@ -237,7 +237,7 @@ void get_arch_name(char *out_str, const ArchType *arch) {
}
int parse_target_arch(const char *str, ArchType *out_arch) {
- for (int i = 0; i < array_length(arch_list); i += 1) {
+ for (size_t i = 0; i < array_length(arch_list); i += 1) {
const ArchType *arch = &arch_list[i];
char arch_name[50];
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) {
}
int parse_target_os(const char *str, ZigLLVM_OSType *out_os) {
- for (int i = 0; i < array_length(os_list); i += 1) {
+ for (size_t i = 0; i < array_length(os_list); i += 1) {
ZigLLVM_OSType os = os_list[i];
const char *os_name = get_target_os_name(os);
if (strcmp(os_name, str) == 0) {
@@ -262,7 +262,7 @@ int parse_target_os(const char *str, ZigLLVM_OSType *out_os) {
}
int parse_target_environ(const char *str, ZigLLVM_EnvironmentType *out_environ) {
- for (int i = 0; i < array_length(environ_list); i += 1) {
+ for (size_t i = 0; i < array_length(environ_list); i += 1) {
ZigLLVM_EnvironmentType env_type = environ_list[i];
const char *environ_name = ZigLLVMGetEnvironmentTypeName(env_type);
if (strcmp(environ_name, str) == 0) {
diff --git a/src/target.hpp b/src/target.hpp
index d758df1519..d56b3b02cd 100644
--- a/src/target.hpp
+++ b/src/target.hpp
@@ -38,22 +38,22 @@ enum CIntType {
CIntTypeCount,
};
-int target_arch_count(void);
+size_t target_arch_count(void);
const ArchType *get_target_arch(int index);
void get_arch_name(char *out_str, const ArchType *arch);
-int target_vendor_count(void);
+size_t target_vendor_count(void);
ZigLLVM_VendorType get_target_vendor(int index);
-int target_os_count(void);
+size_t target_os_count(void);
ZigLLVM_OSType get_target_os(int index);
const char *get_target_os_name(ZigLLVM_OSType os_type);
-int target_environ_count(void);
+size_t target_environ_count(void);
ZigLLVM_EnvironmentType get_target_environ(int index);
-int target_oformat_count(void);
+size_t target_oformat_count(void);
const ZigLLVM_ObjectFormatType get_target_oformat(int index);
const char *get_target_oformat_name(ZigLLVM_ObjectFormatType oformat);
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 3ff8af8579..58aa2d2610 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -141,7 +141,7 @@ static const struct ZigKeyword zig_keywords[] = {
};
bool is_zig_keyword(Buf *buf) {
- for (int i = 0; i < array_length(zig_keywords); i += 1) {
+ for (size_t i = 0; i < array_length(zig_keywords); i += 1) {
if (buf_eql_str(buf, zig_keywords[i].text)) {
return true;
}
@@ -209,7 +209,7 @@ enum TokenizeState {
struct Tokenize {
Buf *buf;
- int pos;
+ size_t pos;
TokenizeState state;
ZigList<Token> *tokens;
int line;
@@ -329,7 +329,7 @@ static void end_float_token(Tokenize *t) {
}
}
uint64_t double_bits = (exponent_bits << 52) | significand_bits;
- memcpy(&t->cur_tok->data.num_lit.bignum.data.x_float, &double_bits, sizeof(double));
+ safe_memcpy(&t->cur_tok->data.num_lit.bignum.data.x_float, (double *)&double_bits, 1);
}
static void end_token(Tokenize *t) {
@@ -397,7 +397,7 @@ void tokenize(Buf *buf, Tokenization *out) {
t.tokens = out->tokens = allocate<ZigList<Token>>(1);
t.buf = buf;
- out->line_offsets = allocate<ZigList<int>>(1);
+ out->line_offsets = allocate<ZigList<size_t>>(1);
out->line_offsets->append(0);
for (t.pos = 0; t.pos < buf_len(t.buf); t.pos += 1) {
@@ -1545,10 +1545,10 @@ const char * token_name(TokenId id) {
}
void print_tokens(Buf *buf, ZigList<Token> *tokens) {
- for (int i = 0; i < tokens->length; i += 1) {
+ for (size_t i = 0; i < tokens->length; i += 1) {
Token *token = &tokens->at(i);
fprintf(stderr, "%s ", token_name(token->id));
- if (token->start_pos >= 0) {
+ if (token->start_pos != SIZE_MAX) {
fwrite(buf_ptr(buf) + token->start_pos, 1, token->end_pos - token->start_pos, stderr);
}
fprintf(stderr, "\n");
diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp
index 9ebaccb456..f5d26c5404 100644
--- a/src/tokenizer.hpp
+++ b/src/tokenizer.hpp
@@ -131,10 +131,10 @@ struct TokenCharLit {
struct Token {
TokenId id;
- int start_pos;
- int end_pos;
- int start_line;
- int start_column;
+ size_t start_pos;
+ size_t end_pos;
+ size_t start_line;
+ size_t start_column;
union {
// TokenIdNumberLiteral
@@ -150,12 +150,12 @@ struct Token {
struct Tokenization {
ZigList<Token> *tokens;
- ZigList<int> *line_offsets;
+ ZigList<size_t> *line_offsets;
// if an error occurred
Buf *err;
- int err_line;
- int err_column;
+ size_t err_line;
+ size_t err_column;
};
void tokenize(Buf *buf, Tokenization *out_tokenization);
diff --git a/src/util.hpp b/src/util.hpp
index e6eeae2ae0..0f1def6c76 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -45,15 +45,35 @@ __attribute__((malloc)) static inline T *allocate(size_t count) {
}
template<typename T>
-static inline T *reallocate_nonzero(T * old, size_t new_count) {
+static inline void safe_memcpy(T *dest, const T *src, size_t count) {
+#ifdef NDEBUG
+ memcpy(dest, src, count * sizeof(T));
+#else
+ // manually assign every elment to trigger compile error for non-copyable structs
+ for (size_t i = 0; i < count; i += 1) {
+ dest[i] = src[i];
+ }
+#endif
+}
+
+template<typename T>
+static inline T *reallocate_nonzero(T *old, size_t old_count, size_t new_count) {
+#ifdef NDEBUG
T *ptr = reinterpret_cast<T*>(realloc(old, new_count * sizeof(T)));
if (!ptr)
zig_panic("allocation failed");
return ptr;
+#else
+ // manually assign every element to trigger compile error for non-copyable structs
+ T *ptr = allocate_nonzero<T>(new_count);
+ safe_memcpy(ptr, old, old_count);
+ free(old);
+ return ptr;
+#endif
}
-template <typename T, long n>
-constexpr long array_length(const T (&)[n]) {
+template <typename T, size_t n>
+constexpr size_t array_length(const T (&)[n]) {
return n;
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-27 21:52:20 +0000