Commit c9ae30d27e123f87fc9c10b6af2e380eab57d6df | zig

doc/langref.md-13

...	@@ -295,19 +295,6 @@ has a terminating null byte.	...	@@ -295,19 +295,6 @@ has a terminating null byte.
295	Built-in functions are prefixed with `@`. Remember that the `comptime` keyword on	295	Built-in functions are prefixed with `@`. Remember that the `comptime` keyword on
296	a parameter means that the parameter must be known at compile time.	296	a parameter means that the parameter must be known at compile time.
297		297
298	### @alloca(comptime T: type, count: usize) -> []T
299
300	Allocates memory in the stack frame of the caller. This temporary space is
301	automatically freed when the function that called alloca returns to its caller,
302	just like other stack variables.
303
304	When using this function to allocate memory, you should know the upper bound
305	of `count`. Consider putting a constant array on the stack with the upper bound
306	instead of using alloca. If you do use alloca it is to save a few bytes off
307	the memory size given that you didn't actually hit your upper bound.
308
309	The allocated memory contents are undefined.
310
311	### @typeOf(expression) -> type	298	### @typeOf(expression) -> type
312		299
313	This function returns a compile-time constant, which is the type of the	300	This function returns a compile-time constant, which is the type of the

src/all_types.hpp-10

 @@ -1190,7 +1190,6 @@ enum BuiltinFnId {
     BuiltinFnIdTruncate,
     BuiltinFnIdIntType,
     BuiltinFnIdSetDebugSafety,
-    BuiltinFnIdAlloca,
     BuiltinFnIdTypeName,
     BuiltinFnIdIsInteger,
     BuiltinFnIdIsFloat,
 @@ -1706,7 +1705,6 @@ enum IrInstructionId {
     IrInstructionIdTruncate,
     IrInstructionIdIntType,
     IrInstructionIdBoolNot,
-    IrInstructionIdAlloca,
     IrInstructionIdMemset,
     IrInstructionIdMemcpy,
     IrInstructionIdSlice,
 @@ -2234,14 +2232,6 @@ struct IrInstructionBoolNot {
     IrInstruction *value;
 };
-struct IrInstructionAlloca {
-    IrInstruction base;
-    IrInstruction *type_value;
-    IrInstruction *count;
-    LLVMValueRef tmp_ptr;
-};
 struct IrInstructionMemset {
     IrInstruction base;

src/codegen.cpp+1-27

 @@ -2190,26 +2190,6 @@ static LLVMValueRef ir_render_truncate(CodeGen *g, IrExecutable *executable, IrI
     }
 }
-static LLVMValueRef ir_render_alloca(CodeGen *g, IrExecutable *executable, IrInstructionAlloca *instruction) {
-    TypeTableEntry *slice_type = get_underlying_type(instruction->base.value.type);
-    TypeTableEntry *ptr_type = slice_type->data.structure.fields[slice_ptr_index].type_entry;
-    TypeTableEntry *child_type = ptr_type->data.pointer.child_type;
-    LLVMValueRef size_val = ir_llvm_value(g, instruction->count);
-    LLVMValueRef ptr_val = LLVMBuildArrayAlloca(g->builder, child_type->type_ref, size_val, "");
-    // TODO in debug mode, initialize all the bytes to 0xaa
-    // store the freshly allocated pointer in the slice
-    LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, slice_ptr_index, "");
-    LLVMBuildStore(g->builder, ptr_val, ptr_field_ptr);
-    // store the size in the len field
-    LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, slice_len_index, "");
-    LLVMBuildStore(g->builder, size_val, len_field_ptr);
-    return instruction->tmp_ptr;
-}
 static LLVMValueRef ir_render_memset(CodeGen *g, IrExecutable *executable, IrInstructionMemset *instruction) {
     LLVMValueRef dest_ptr = ir_llvm_value(g, instruction->dest_ptr);
     LLVMValueRef char_val = ir_llvm_value(g, instruction->byte);
 @@ -2548,7 +2528,7 @@ static LLVMValueRef ir_render_maybe_wrap(CodeGen *g, IrExecutable *executable, I
     assert(instruction->tmp_ptr);
     LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, maybe_child_index, "");
-    assert(child_type == instruction->value->value.type);
+    // child_type and instruction->value->value.type may differ by constness
     gen_assign_raw(g, val_ptr, payload_val, child_type);
     LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, maybe_null_index, "");
     LLVMBuildStore(g->builder, LLVMConstAllOnes(LLVMInt1Type()), maybe_ptr);
 @@ -2796,8 +2776,6 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_truncate(g, executable, (IrInstructionTruncate *)instruction);
         case IrInstructionIdBoolNot:
             return ir_render_bool_not(g, executable, (IrInstructionBoolNot *)instruction);
-        case IrInstructionIdAlloca:
-            return ir_render_alloca(g, executable, (IrInstructionAlloca *)instruction);
         case IrInstructionIdMemset:
             return ir_render_memset(g, executable, (IrInstructionMemset *)instruction);
         case IrInstructionIdMemcpy:
 @@ -3648,9 +3626,6 @@ static void do_code_gen(CodeGen *g) {
             } else if (instruction->id == IrInstructionIdCall) {
                 IrInstructionCall *call_instruction = (IrInstructionCall *)instruction;
                 slot = &call_instruction->tmp_ptr;
-            } else if (instruction->id == IrInstructionIdAlloca) {
-                IrInstructionAlloca *alloca_instruction = (IrInstructionAlloca *)instruction;
-                slot = &alloca_instruction->tmp_ptr;
             } else if (instruction->id == IrInstructionIdSlice) {
                 IrInstructionSlice *slice_instruction = (IrInstructionSlice *)instruction;
                 slot = &slice_instruction->tmp_ptr;
 @@ -4326,7 +4301,6 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn(g, BuiltinFnIdCompileLog, "compileLog", SIZE_MAX);
     create_builtin_fn(g, BuiltinFnIdIntType, "intType", 2);
     create_builtin_fn(g, BuiltinFnIdSetDebugSafety, "setDebugSafety", 2);
-    create_builtin_fn(g, BuiltinFnIdAlloca, "alloca", 2);
     create_builtin_fn(g, BuiltinFnIdSetGlobalAlign, "setGlobalAlign", 2);
     create_builtin_fn(g, BuiltinFnIdSetGlobalSection, "setGlobalSection", 2);
     create_builtin_fn(g, BuiltinFnIdSetGlobalLinkage, "setGlobalLinkage", 2);

src/ir.cpp-77

...	@@ -404,10 +404,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionBoolNot *) {	...	@@ -404,10 +404,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionBoolNot *) {
404	return IrInstructionIdBoolNot;	404	return IrInstructionIdBoolNot;
405	}	405	}
406		406
407	static constexpr IrInstructionId ir_instruction_id(IrInstructionAlloca *) {
408	return IrInstructionIdAlloca;
409	}
410
411	static constexpr IrInstructionId ir_instruction_id(IrInstructionMemset *) {	407	static constexpr IrInstructionId ir_instruction_id(IrInstructionMemset *) {
412	return IrInstructionIdMemset;	408	return IrInstructionIdMemset;
413	}	409	}
...	@@ -1668,27 +1664,6 @@ static IrInstruction ir_build_bool_not_from(IrBuilder irb, IrInstruction *old_	...	@@ -1668,27 +1664,6 @@ static IrInstruction ir_build_bool_not_from(IrBuilder irb, IrInstruction *old_
1668	return new_instruction;	1664	return new_instruction;
1669	}	1665	}
1670		1666
1671	static IrInstruction ir_build_alloca(IrBuilder irb, Scope scope, AstNode source_node,
1672	IrInstruction type_value, IrInstruction count)
1673	{
1674	IrInstructionAlloca *instruction = ir_build_instruction<IrInstructionAlloca>(irb, scope, source_node);
1675	instruction->type_value = type_value;
1676	instruction->count = count;
1677
1678	ir_ref_instruction(type_value, irb->current_basic_block);
1679	ir_ref_instruction(count, irb->current_basic_block);
1680
1681	return &instruction->base;
1682	}
1683
1684	static IrInstruction ir_build_alloca_from(IrBuilder irb, IrInstruction *old_instruction,
1685	IrInstruction type_value, IrInstruction count)
1686	{
1687	IrInstruction *new_instruction = ir_build_alloca(irb, old_instruction->scope, old_instruction->source_node, type_value, count);
1688	ir_link_new_instruction(new_instruction, old_instruction);
1689	return new_instruction;
1690	}
1691
1692	static IrInstruction ir_build_memset(IrBuilder irb, Scope scope, AstNode source_node,	1667	static IrInstruction ir_build_memset(IrBuilder irb, Scope scope, AstNode source_node,
1693	IrInstruction dest_ptr, IrInstruction byte, IrInstruction *count)	1668	IrInstruction dest_ptr, IrInstruction byte, IrInstruction *count)
1694	{	1669	{
...	@@ -2567,14 +2542,6 @@ static IrInstruction ir_instruction_boolnot_get_dep(IrInstructionBoolNot instr	...	@@ -2567,14 +2542,6 @@ static IrInstruction ir_instruction_boolnot_get_dep(IrInstructionBoolNot instr
2567	}	2542	}
2568	}	2543	}
2569		2544
2570	static IrInstruction ir_instruction_alloca_get_dep(IrInstructionAlloca instruction, size_t index) {
2571	switch (index) {
2572	case 0: return instruction->type_value;
2573	case 1: return instruction->count;
2574	default: return nullptr;
2575	}
2576	}
2577
2578	static IrInstruction ir_instruction_memset_get_dep(IrInstructionMemset instruction, size_t index) {	2545	static IrInstruction ir_instruction_memset_get_dep(IrInstructionMemset instruction, size_t index) {
2579	switch (index) {	2546	switch (index) {
2580	case 0: return instruction->dest_ptr;	2547	case 0: return instruction->dest_ptr;
...	@@ -2938,8 +2905,6 @@ static IrInstruction ir_instruction_get_dep(IrInstruction instruction, size_t	...	@@ -2938,8 +2905,6 @@ static IrInstruction ir_instruction_get_dep(IrInstruction instruction, size_t
2938	return ir_instruction_inttype_get_dep((IrInstructionIntType *) instruction, index);	2905	return ir_instruction_inttype_get_dep((IrInstructionIntType *) instruction, index);
2939	case IrInstructionIdBoolNot:	2906	case IrInstructionIdBoolNot:
2940	return ir_instruction_boolnot_get_dep((IrInstructionBoolNot *) instruction, index);	2907	return ir_instruction_boolnot_get_dep((IrInstructionBoolNot *) instruction, index);
2941	case IrInstructionIdAlloca:
2942	return ir_instruction_alloca_get_dep((IrInstructionAlloca *) instruction, index);
2943	case IrInstructionIdMemset:	2908	case IrInstructionIdMemset:
2944	return ir_instruction_memset_get_dep((IrInstructionMemset *) instruction, index);	2909	return ir_instruction_memset_get_dep((IrInstructionMemset *) instruction, index);
2945	case IrInstructionIdMemcpy:	2910	case IrInstructionIdMemcpy:
...	@@ -4100,20 +4065,6 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo	...	@@ -4100,20 +4065,6 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4100		4065
4101	return ir_build_int_type(irb, scope, node, arg0_value, arg1_value);	4066	return ir_build_int_type(irb, scope, node, arg0_value, arg1_value);
4102	}	4067	}
4103	case BuiltinFnIdAlloca:
4104	{
4105	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
4106	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
4107	if (arg0_value == irb->codegen->invalid_instruction)
4108	return arg0_value;
4109
4110	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
4111	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
4112	if (arg1_value == irb->codegen->invalid_instruction)
4113	return arg1_value;
4114
4115	return ir_build_alloca(irb, scope, node, arg0_value, arg1_value);
4116	}
4117	case BuiltinFnIdMemcpy:	4068	case BuiltinFnIdMemcpy:
4118	{	4069	{
4119	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);	4070	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
...	@@ -11461,31 +11412,6 @@ static TypeTableEntry ir_analyze_instruction_bool_not(IrAnalyze ira, IrInstruc	...	@@ -11461,31 +11412,6 @@ static TypeTableEntry ir_analyze_instruction_bool_not(IrAnalyze ira, IrInstruc
11461	return bool_type;	11412	return bool_type;
11462	}	11413	}
11463		11414
11464	static TypeTableEntry ir_analyze_instruction_alloca(IrAnalyze ira, IrInstructionAlloca *instruction) {
11465	IrInstruction *type_value = instruction->type_value->other;
11466	if (type_is_invalid(type_value->value.type))
11467	return ira->codegen->builtin_types.entry_invalid;
11468
11469	IrInstruction *count_value = instruction->count->other;
11470	if (type_is_invalid(count_value->value.type))
11471	return ira->codegen->builtin_types.entry_invalid;
11472
11473	TypeTableEntry *child_type = ir_resolve_type(ira, type_value);
11474
11475	if (type_requires_comptime(child_type)) {
11476	ir_add_error(ira, type_value,
11477	buf_sprintf("invalid alloca type '%s'", buf_ptr(&child_type->name)));
11478	// TODO if this is a typedecl, add error note showing the declaration of the type decl
11479	return ira->codegen->builtin_types.entry_invalid;
11480	} else {
11481	TypeTableEntry *slice_type = get_slice_type(ira->codegen, child_type, false);
11482	IrInstruction *new_instruction = ir_build_alloca_from(&ira->new_irb, &instruction->base, type_value, count_value);
11483	ir_add_alloca(ira, new_instruction, slice_type);
11484	return slice_type;
11485	}
11486	zig_unreachable();
11487	}
11488
11489	static TypeTableEntry ir_analyze_instruction_memset(IrAnalyze ira, IrInstructionMemset *instruction) {	11415	static TypeTableEntry ir_analyze_instruction_memset(IrAnalyze ira, IrInstructionMemset *instruction) {
11490	IrInstruction *dest_ptr = instruction->dest_ptr->other;	11416	IrInstruction *dest_ptr = instruction->dest_ptr->other;
11491	if (type_is_invalid(dest_ptr->value.type))	11417	if (type_is_invalid(dest_ptr->value.type))
...	@@ -12550,8 +12476,6 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi	...	@@ -12550,8 +12476,6 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
12550	return ir_analyze_instruction_int_type(ira, (IrInstructionIntType *)instruction);	12476	return ir_analyze_instruction_int_type(ira, (IrInstructionIntType *)instruction);
12551	case IrInstructionIdBoolNot:	12477	case IrInstructionIdBoolNot:
12552	return ir_analyze_instruction_bool_not(ira, (IrInstructionBoolNot *)instruction);	12478	return ir_analyze_instruction_bool_not(ira, (IrInstructionBoolNot *)instruction);
12553	case IrInstructionIdAlloca:
12554	return ir_analyze_instruction_alloca(ira, (IrInstructionAlloca *)instruction);
12555	case IrInstructionIdMemset:	12479	case IrInstructionIdMemset:
12556	return ir_analyze_instruction_memset(ira, (IrInstructionMemset *)instruction);	12480	return ir_analyze_instruction_memset(ira, (IrInstructionMemset *)instruction);
12557	case IrInstructionIdMemcpy:	12481	case IrInstructionIdMemcpy:
...	@@ -12749,7 +12673,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {	...	@@ -12749,7 +12673,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {
12749	case IrInstructionIdTruncate:	12673	case IrInstructionIdTruncate:
12750	case IrInstructionIdIntType:	12674	case IrInstructionIdIntType:
12751	case IrInstructionIdBoolNot:	12675	case IrInstructionIdBoolNot:
12752	case IrInstructionIdAlloca:
12753	case IrInstructionIdSlice:	12676	case IrInstructionIdSlice:
12754	case IrInstructionIdMemberCount:	12677	case IrInstructionIdMemberCount:
12755	case IrInstructionIdAlignOf:	12678	case IrInstructionIdAlignOf:

src/ir_print.cpp-11

...	@@ -601,14 +601,6 @@ static void ir_print_truncate(IrPrint irp, IrInstructionTruncate instruction)	...	@@ -601,14 +601,6 @@ static void ir_print_truncate(IrPrint irp, IrInstructionTruncate instruction)
601	fprintf(irp->f, ")");	601	fprintf(irp->f, ")");
602	}	602	}
603		603
604	static void ir_print_alloca(IrPrint irp, IrInstructionAlloca instruction) {
605	fprintf(irp->f, "@alloca(");
606	ir_print_other_instruction(irp, instruction->type_value);
607	fprintf(irp->f, ", ");
608	ir_print_other_instruction(irp, instruction->count);
609	fprintf(irp->f, ")");
610	}
611
612	static void ir_print_int_type(IrPrint irp, IrInstructionIntType instruction) {	604	static void ir_print_int_type(IrPrint irp, IrInstructionIntType instruction) {
613	fprintf(irp->f, "@intType(");	605	fprintf(irp->f, "@intType(");
614	ir_print_other_instruction(irp, instruction->is_signed);	606	ir_print_other_instruction(irp, instruction->is_signed);
...	@@ -1049,9 +1041,6 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {	...	@@ -1049,9 +1041,6 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1049	case IrInstructionIdTruncate:	1041	case IrInstructionIdTruncate:
1050	ir_print_truncate(irp, (IrInstructionTruncate *)instruction);	1042	ir_print_truncate(irp, (IrInstructionTruncate *)instruction);
1051	break;	1043	break;
1052	case IrInstructionIdAlloca:
1053	ir_print_alloca(irp, (IrInstructionAlloca *)instruction);
1054	break;
1055	case IrInstructionIdIntType:	1044	case IrInstructionIdIntType:
1056	ir_print_int_type(irp, (IrInstructionIntType *)instruction);	1045	ir_print_int_type(irp, (IrInstructionIntType *)instruction);
1057	break;	1046	break;

std/build.zig+3-1

...	@@ -40,6 +40,8 @@ pub const Builder = struct {	...	@@ -40,6 +40,8 @@ pub const Builder = struct {
40	}	40	}
41		41
42	pub fn make(self: &Builder, cli_args: []const []const u8) -> %void {	42	pub fn make(self: &Builder, cli_args: []const []const u8) -> %void {
		43	var env_map = %return os.getEnvMap(self.allocator);
		44
43	var verbose = false;	45	var verbose = false;
44	for (cli_args) \|arg\| {	46	for (cli_args) \|arg\| {
45	if (mem.eql(u8, arg, "--verbose")) {	47	if (mem.eql(u8, arg, "--verbose")) {
...	@@ -93,7 +95,7 @@ pub const Builder = struct {	...	@@ -93,7 +95,7 @@ pub const Builder = struct {
93	}	95	}
94		96
95	printInvocation(self.zig_exe, zig_args);	97	printInvocation(self.zig_exe, zig_args);
96	var child = %return os.ChildProcess.spawn(self.zig_exe, zig_args.toSliceConst(), os.environ,	98	var child = %return os.ChildProcess.spawn(self.zig_exe, zig_args.toSliceConst(), env_map,
97	StdIo.Ignore, StdIo.Inherit, StdIo.Inherit, self.allocator);	99	StdIo.Ignore, StdIo.Inherit, StdIo.Inherit, self.allocator);
98	const term = %return child.wait();	100	const term = %return child.wait();
99	switch (term) {	101	switch (term) {

std/hash_map.zig+12-7

 @@ -29,7 +29,7 @@ pub fn HashMap(comptime K: type, comptime V: type,
         };
         pub const Iterator = struct {
-            hm: &Self,
+            hm: &const Self,
             // how many items have we returned
             count: usize,
             // iterator through the entry array
 @@ -99,17 +99,21 @@ pub fn HashMap(comptime K: type, comptime V: type,
         }
         pub fn get(hm: &Self, key: K) -> ?&Entry {
+            if (hm.entries.len == 0) {
+                return null;
+            }
             return hm.internalGet(key);
         }
-        pub fn remove(hm: &Self, key: K) {
+        pub fn remove(hm: &Self, key: K) -> ?&Entry {
             hm.incrementModificationCount();
             const start_index = hm.keyToIndex(key);
             {var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index; roll_over += 1) {
                 const index = (start_index + roll_over) % hm.entries.len;
                 var entry = &hm.entries[index];
-                assert(entry.used); // key not found
+                if (!entry.used)
+                    return null;
                 if (!eql(entry.key, key)) continue;
 @@ -119,7 +123,7 @@ pub fn HashMap(comptime K: type, comptime V: type,
                     if (!next_entry.used or next_entry.distance_from_start_index == 0) {
                         entry.used = false;
                         hm.size -= 1;
-                        return;
+                        return entry;
                     }
                     *entry = *next_entry;
                     entry.distance_from_start_index -= 1;
 @@ -127,10 +131,10 @@ pub fn HashMap(comptime K: type, comptime V: type,
                 }
                 unreachable // shifting everything in the table
             }}
-            unreachable // key not found
+            return null;
         }
-        pub fn entryIterator(hm: &Self) -> Iterator {
+        pub fn entryIterator(hm: &const Self) -> Iterator {
             return Iterator {
                 .hm = hm,
                 .count = 0,
 @@ -231,7 +235,8 @@ test "basicHashMapTest" {
     %%map.put(5, 55);
     assert((??map.get(2)).value == 22);
-    map.remove(2);
+    _ = map.remove(2);
+    assert(map.remove(2) == null);
     assert(if (const entry ?= map.get(2)) false else true);
 }

std/os/index.zig+135-23

...	@@ -21,6 +21,8 @@ const mem = @import("../mem.zig");	...	@@ -21,6 +21,8 @@ const mem = @import("../mem.zig");
21	const Allocator = mem.Allocator;	21	const Allocator = mem.Allocator;
22		22
23	const io = @import("../io.zig");	23	const io = @import("../io.zig");
		24	const HashMap = @import("../hash_map.zig").HashMap;
		25	const cstr = @import("../cstr.zig");
24		26
25	error Unexpected;	27	error Unexpected;
26	error SysResources;	28	error SysResources;
...	@@ -284,12 +286,12 @@ pub const ChildProcess = struct {	...	@@ -284,12 +286,12 @@ pub const ChildProcess = struct {
284	Close,	286	Close,
285	};	287	};
286		288
287	pub fn spawn(exe_path: []const u8, args: []const []const u8, env: []const EnvPair,	289	pub fn spawn(exe_path: []const u8, args: []const []const u8, env_map: &const EnvMap,
288	stdin: StdIo, stdout: StdIo, stderr: StdIo, allocator: &Allocator) -> %ChildProcess	290	stdin: StdIo, stdout: StdIo, stderr: StdIo, allocator: &Allocator) -> %ChildProcess
289	{	291	{
290	switch (@compileVar("os")) {	292	switch (@compileVar("os")) {
291	Os.linux, Os.macosx, Os.ios, Os.darwin => {	293	Os.linux, Os.macosx, Os.ios, Os.darwin => {
292	return spawnPosix(exe_path, args, env, stdin, stdout, stderr, allocator);	294	return spawnPosix(exe_path, args, env_map, stdin, stdout, stderr, allocator);
293	},	295	},
294	else => @compileError("Unsupported OS"),	296	else => @compileError("Unsupported OS"),
295	}	297	}
...	@@ -351,7 +353,7 @@ pub const ChildProcess = struct {	...	@@ -351,7 +353,7 @@ pub const ChildProcess = struct {
351	};	353	};
352	}	354	}
353		355
354	fn spawnPosix(exe_path: []const u8, args: []const []const u8, env: []const EnvPair,	356	fn spawnPosix(exe_path: []const u8, args: []const []const u8, env_map: &const EnvMap,
355	stdin: StdIo, stdout: StdIo, stderr: StdIo, allocator: &Allocator) -> %ChildProcess	357	stdin: StdIo, stdout: StdIo, stderr: StdIo, allocator: &Allocator) -> %ChildProcess
356	{	358	{
357	// TODO issue #295	359	// TODO issue #295
...	@@ -408,7 +410,7 @@ pub const ChildProcess = struct {	...	@@ -408,7 +410,7 @@ pub const ChildProcess = struct {
408	setUpChildIo(stderr, stderr_pipe[1], posix.STDERR_FILENO, dev_null_fd) %%	410	setUpChildIo(stderr, stderr_pipe[1], posix.STDERR_FILENO, dev_null_fd) %%
409	\|err\| forkChildErrReport(err_pipe[1], err);	411	\|err\| forkChildErrReport(err_pipe[1], err);
410		412
411	const err = posix.getErrno(%return execve(exe_path, args, env, allocator));	413	const err = posix.getErrno(%return execve(exe_path, args, env_map, allocator));
412	assert(err > 0);	414	assert(err > 0);
413	forkChildErrReport(err_pipe[1], switch (err) {	415	forkChildErrReport(err_pipe[1], switch (err) {
414	errno.EFAULT => unreachable,	416	errno.EFAULT => unreachable,
...	@@ -473,7 +475,7 @@ pub const ChildProcess = struct {	...	@@ -473,7 +475,7 @@ pub const ChildProcess = struct {
473	/// It must also convert to KEY=VALUE\0 format for environment variables, and include null	475	/// It must also convert to KEY=VALUE\0 format for environment variables, and include null
474	/// pointers after the args and after the environment variables.	476	/// pointers after the args and after the environment variables.
475	/// Also make the first arg equal to path.	477	/// Also make the first arg equal to path.
476	fn execve(path: []const u8, argv: []const []const u8, envp: []const EnvPair, allocator: &Allocator) -> %usize {	478	fn execve(path: []const u8, argv: []const []const u8, env_map: &const EnvMap, allocator: &Allocator) -> %usize {
477	const path_buf = %return allocator.alloc(u8, path.len + 1);	479	const path_buf = %return allocator.alloc(u8, path.len + 1);
478	defer allocator.free(path_buf);	480	defer allocator.free(path_buf);
479	@memcpy(&path_buf[0], &path[0], path.len);	481	@memcpy(&path_buf[0], &path[0], path.len);
...	@@ -505,39 +507,149 @@ fn execve(path: []const u8, argv: []const []const u8, envp: []const EnvPair, all	...	@@ -505,39 +507,149 @@ fn execve(path: []const u8, argv: []const []const u8, envp: []const EnvPair, all
505	}	507	}
506	argv_buf[argv.len + 1] = null;	508	argv_buf[argv.len + 1] = null;
507		509
508	const envp_buf = %return allocator.alloc(?&const u8, envp.len + 1);	510	const envp_count = env_map.count();
		511	const envp_buf = %return allocator.alloc(?&const u8, envp_count + 1);
509	mem.set(?&const u8, envp_buf, null);	512	mem.set(?&const u8, envp_buf, null);
510	defer {	513	defer {
511	for (envp_buf) \|env, i\| {	514	for (envp_buf) \|env, i\| {
512	const env_buf = if (const ptr ?= env) ptr[0...envp[i].key.len + envp[i].value.len + 2] else break;	515	const env_buf = if (const ptr ?= env) ptr[0...cstr.len(ptr)] else break;
513	allocator.free(env_buf);	516	allocator.free(env_buf);
514	}	517	}
515	allocator.free(envp_buf);	518	allocator.free(envp_buf);
516	}	519	}
517	for (envp) \|pair, i\| {	520	{
518	const env_buf = %return allocator.alloc(u8, pair.key.len + pair.value.len + 2);	521	var it = env_map.iterator();
519	@memcpy(&env_buf[0], pair.key.ptr, pair.key.len);	522	var i: usize = 0;
520	env_buf[pair.key.len] = '=';	523	while (true; i += 1) {
521	@memcpy(&env_buf[pair.key.len + 1], pair.value.ptr, pair.value.len);	524	const pair = it.next() ?? break;
522	env_buf[env_buf.len - 1] = 0;	525
523		526	const env_buf = %return allocator.alloc(u8, pair.key.len + pair.value.len + 2);
524	envp_buf[i] = env_buf.ptr;	527	@memcpy(&env_buf[0], pair.key.ptr, pair.key.len);
		528	env_buf[pair.key.len] = '=';
		529	@memcpy(&env_buf[pair.key.len + 1], pair.value.ptr, pair.value.len);
		530	env_buf[env_buf.len - 1] = 0;
		531
		532	envp_buf[i] = env_buf.ptr;
		533	}
		534	assert(i == envp_count);
525	}	535	}
526	envp_buf[envp.len] = null;	536	envp_buf[envp_count] = null;
527		537
528	return posix.execve(path_buf.ptr, argv_buf.ptr, envp_buf.ptr);	538	return posix.execve(path_buf.ptr, argv_buf.ptr, envp_buf.ptr);
529	}	539	}
530		540
531	pub const EnvPair = struct {	541	pub var environ_raw: []&u8 = undefined;
532	key: []const u8,	542
533	value: []const u8,	543	pub const EnvMap = struct {
		544	hash_map: EnvHashMap,
		545
		546	const EnvHashMap = HashMap([]const u8, []const u8, hash_slice_u8, eql_slice_u8);
		547
		548	pub fn init(allocator: &Allocator) -> EnvMap {
		549	var self = EnvMap {
		550	.hash_map = undefined,
		551	};
		552	self.hash_map.init(allocator);
		553	return self;
		554	}
		555
		556	pub fn deinit(self: &EnvMap) {
		557	var it = self.hash_map.entryIterator();
		558	while (true) {
		559	const entry = it.next() ?? break;
		560	self.free(entry.key);
		561	self.free(entry.value);
		562	}
		563
		564	self.hash_map.deinit();
		565	}
		566
		567	pub fn set(self: &EnvMap, key: []const u8, value: []const u8) -> %void {
		568	if (const entry ?= self.hash_map.get(key)) {
		569	const value_copy = %return self.copy(value);
		570	%defer self.free(value_copy);
		571	%return self.hash_map.put(key, value_copy);
		572	self.free(entry.value);
		573	} else {
		574	const key_copy = %return self.copy(key);
		575	%defer self.free(key_copy);
		576	const value_copy = %return self.copy(value);
		577	%defer self.free(value_copy);
		578	%return self.hash_map.put(key_copy, value_copy);
		579	}
		580	}
		581
		582	pub fn delete(self: &EnvMap, key: []const u8) {
		583	const entry = self.hash_map.remove(key) ?? return;
		584	self.free(entry.key);
		585	self.free(entry.value);
		586	}
		587
		588	pub fn count(self: &const EnvMap) -> usize {
		589	return self.hash_map.size;
		590	}
		591
		592	pub fn iterator(self: &const EnvMap) -> EnvHashMap.Iterator {
		593	return self.hash_map.entryIterator();
		594	}
		595
		596	fn free(self: &EnvMap, value: []const u8) {
		597	// remove the const
		598	const mut_value = @ptrcast(&u8, value.ptr)[0...value.len];
		599	self.hash_map.allocator.free(mut_value);
		600	}
		601
		602	fn copy(self: &EnvMap, value: []const u8) -> %[]const u8 {
		603	const result = %return self.hash_map.allocator.alloc(u8, value.len);
		604	mem.copy(u8, result, value);
		605	return result;
		606	}
534	};	607	};
535	pub var environ: []const EnvPair = undefined;	608
		609	pub fn getEnvMap(allocator: &Allocator) -> %EnvMap {
		610	var result = EnvMap.init(allocator);
		611	%defer result.deinit();
		612
		613	for (environ_raw) \|ptr\| {
		614	var line_i: usize = 0;
		615	while (ptr[line_i] != 0 and ptr[line_i] != '='; line_i += 1) {}
		616	const key = ptr[0...line_i];
		617
		618	var end_i: usize = line_i;
		619	while (ptr[end_i] != 0; end_i += 1) {}
		620	const value = ptr[line_i + 1...end_i];
		621
		622	%return result.set(key, value);
		623	}
		624	return result;
		625	}
536		626
537	pub fn getEnv(key: []const u8) -> ?[]const u8 {	627	pub fn getEnv(key: []const u8) -> ?[]const u8 {
538	for (environ) \|pair\| {	628	for (environ_raw) \|ptr\| {
539	if (mem.eql(u8, pair.key, key))	629	var line_i: usize = 0;
540	return pair.value;	630	while (ptr[line_i] != 0 and ptr[line_i] != '='; line_i += 1) {}
		631	const this_key = ptr[0...line_i];
		632	if (!mem.eql(u8, key, this_key))
		633	continue;
		634
		635	var end_i: usize = line_i;
		636	while (ptr[end_i] != 0; end_i += 1) {}
		637	const this_value = ptr[line_i + 1...end_i];
		638
		639	return this_value;
541	}	640	}
542	return null;	641	return null;
543	}	642	}
		643
		644	fn hash_slice_u8(k: []const u8) -> u32 {
		645	// FNV 32-bit hash
		646	var h: u32 = 2166136261;
		647	for (k) \|b\| {
		648	h = (h ^ b) *% 16777619;
		649	}
		650	return h;
		651	}
		652
		653	fn eql_slice_u8(a: []const u8, b: []const u8) -> bool {
		654	return mem.eql(u8, a, b);
		655	}

std/special/bootstrap.zig+17-35

 @@ -9,8 +9,7 @@ const want_start_symbol = !want_main_symbol;
 const exit = std.os.posix.exit;
-var argc: usize = undefined;
+var argc_ptr: &usize = undefined;
-var argv: &&u8 = undefined;
 export nakedcc fn _start() -> noreturn {
     @setGlobalLinkage(_start, if (want_start_symbol) GlobalLinkage.Strong else GlobalLinkage.Internal);
 @@ -20,21 +19,28 @@ export nakedcc fn _start() -> noreturn {
     switch (@compileVar("arch")) {
         Arch.x86_64 => {
-            argc = asm("mov %[argc], [rsp]": [argc] "=r" (-> usize));
+            argc_ptr = asm("lea %[argc], [rsp]": [argc] "=r" (-> &usize));
-            argv = asm("lea %[argv], [rsp + 8h]": [argv] "=r" (-> &&u8));
         },
         Arch.i386 => {
-            argc = asm("mov %[argc], [esp]": [argc] "=r" (-> usize));
+            argc_ptr = asm("lea %[argc], [esp]": [argc] "=r" (-> &usize));
-            argv = asm("lea %[argv], [esp + 4h]": [argv] "=r" (-> &&u8));
         },
         else => @compileError("unsupported arch"),
     }
     callMainAndExit()
 }
-fn callMain(envp: &?&u8) -> %void {
+fn callMainAndExit() -> noreturn {
-    // TODO issue #225
+    const argc = *argc_ptr;
-    const args = @alloca([]u8, argc);
+    const argv = @ptrcast(&&u8, &argc_ptr[1]);
+    const envp = @ptrcast(&?&u8, &argv[argc + 1]);
+    callMain(argc, argv, envp) %% exit(1);
+    exit(0);
+}
+var args_data: [32][]u8 = undefined;
+fn callMain(argc: usize, argv: &&u8, envp: &?&u8) -> %void {
+    // TODO create args API to make it work with > 32 args
+    const args = args_data[0...argc];
     for (args) |_, i| {
         const ptr = argv[i];
         args[i] = ptr[0...std.cstr.len(ptr)];
 @@ -42,41 +48,17 @@ fn callMain(envp: &?&u8) -> %void {
     var env_count: usize = 0;
     while (envp[env_count] != null; env_count += 1) {}
-    // TODO issue #225
+    std.os.environ_raw = @ptrcast(&&u8, envp)[0...env_count];
-    const environ = @alloca(std.os.EnvPair, env_count);
-    for (environ) |_, env_i| {
-        const ptr = ??envp[env_i];
-        var line_i: usize = 0;
-        while (ptr[line_i] != 0 and ptr[line_i] != '='; line_i += 1) {}
-        var end_i: usize = line_i;
-        while (ptr[end_i] != 0; end_i += 1) {}
-        environ[env_i] = std.os.EnvPair {
-            .key = ptr[0...line_i],
-            .value = ptr[line_i + 1...end_i],
-        };
-    }
-    std.os.environ = environ;
     return root.main(args);
 }
-fn callMainAndExit() -> noreturn {
-    const envp = @ptrcast(&?&u8, &argv[argc + 1]);
-    callMain(envp) %% exit(1);
-    exit(0);
-}
 export fn main(c_argc: i32, c_argv: &&u8, c_envp: &?&u8) -> i32 {
     @setGlobalLinkage(main, if (want_main_symbol) GlobalLinkage.Strong else GlobalLinkage.Internal);
     if (!want_main_symbol) {
         unreachable;
     }
-    argc = usize(c_argc);
+    callMain(usize(c_argc), c_argv, c_envp) %% return 1;
-    argv = c_argv;
-    callMain(c_envp) %% return 1;
     return 0;
 }

test/cases/const_slice_child.zig+3-2

...	@@ -1,4 +1,5 @@	...	@@ -1,4 +1,5 @@
1	const assert = @import("std").debug.assert;	1	const debug = @import("std").debug;
		2	const assert = debug.assert;
2		3
3	var argv: &const &const u8 = undefined;	4	var argv: &const &const u8 = undefined;
4		5
...	@@ -20,7 +21,7 @@ fn foo(args: [][]const u8) {	...	@@ -20,7 +21,7 @@ fn foo(args: [][]const u8) {
20	}	21	}
21		22
22	fn bar(argc: usize) {	23	fn bar(argc: usize) {
23	const args = @alloca([]u8, argc);	24	const args = %%debug.global_allocator.alloc([]u8, argc);
24	for (args) \|_, i\| {	25	for (args) \|_, i\| {
25	const ptr = argv[i];	26	const ptr = argv[i];
26	args[i] = ptr[0...strlen(ptr)];	27	args[i] = ptr[0...strlen(ptr)];

author	Andrew Kelley <andrew@ziglang.org> 2017-04-03 18:11:57-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2017-04-03 18:11:57-04:00
log	c9ae30d27e123f87fc9c10b6af2e380eab57d6df
tree	97c8144f1f77a37f12ad8582cd56778d596d3181
parent	c400cb429abf2980962739731f5b64861a54ab61

delete alloca builtin function