Commit e89c42655cf9851cdf02065bc75cda0e27884966 | zig

lib/std/array_list.zig+114-89

...	...	@@ -20,11 +20,9 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
20	20	return struct {
21	21	const Self = @This();
22	22
23		/// Use `span` instead of slicing this directly, because if you don't
24		/// specify the end position of the slice, this will potentially give
25		/// you uninitialized memory.
	23	/// Content of the ArrayList
26	24	items: Slice,
27		len: usize,
	25	capacity: usize,
28	26	allocator: *Allocator,
29	27
30	28	pub const Slice = if (alignment) \|a\| ([]align(a) T) else []T;
...	...	@@ -34,7 +32,7 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
34	32	pub fn init(allocator: *Allocator) Self {
35	33	return Self{
36	34	.items = &[_]T{},
37		.len = 0,
	35	.capacity = 0,
38	36	.allocator = allocator,
39	37	};
40	38	}
...	...	@@ -49,60 +47,55 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
49	47
50	48	/// Release all allocated memory.
51	49	pub fn deinit(self: Self) void {
52		self.allocator.free(self.items);
	50	self.allocator.free(self.allocatedSlice());
53	51	}
54	52
	53	/// Deprecated: use `items` field directly.
55	54	/// Return contents as a slice. Only valid while the list
56	55	/// doesn't change size.
57		pub fn span(self: var) @TypeOf(self.items[0..self.len]) {
58		return self.items[0..self.len];
	56	pub fn span(self: var) @TypeOf(self.items) {
	57	return self.items;
59	58	}
60	59
61		/// Deprecated: use `span`.
	60	/// Deprecated: use `items` field directly.
62	61	pub fn toSlice(self: Self) Slice {
63		return self.span();
	62	return self.items;
64	63	}
65	64
66		/// Deprecated: use `span`.
	65	/// Deprecated: use `items` field directly.
67	66	pub fn toSliceConst(self: Self) SliceConst {
68		return self.span();
	67	return self.items;
69	68	}
70	69
71		/// Deprecated: use `span()[i]`.
	70	/// Deprecated: use `list.items[i]`.
72	71	pub fn at(self: Self, i: usize) T {
73		return self.span()[i];
	72	return self.items[i];
74	73	}
75	74
76		/// Deprecated: use `&span()[i]`.
	75	/// Deprecated: use `&list.items[i]`.
77	76	pub fn ptrAt(self: Self, i: usize) *T {
78		return &self.span()[i];
	77	return &self.items[i];
79	78	}
80	79
81		/// Deprecated: use `if (i >= list.len) return error.OutOfBounds else span()[i] = item`.
	80	/// Deprecated: use `if (i >= list.items.len) return error.OutOfBounds else list.items[i] = item`.
82	81	pub fn setOrError(self: Self, i: usize, item: T) !void {
83		if (i >= self.len) return error.OutOfBounds;
	82	if (i >= self.items.len) return error.OutOfBounds;
84	83	self.items[i] = item;
85	84	}
86	85
87		/// Deprecated: use `list.span()[i] = item`.
	86	/// Deprecated: use `list.items[i] = item`.
88	87	pub fn set(self: *Self, i: usize, item: T) void {
89		assert(i < self.len);
	88	assert(i < self.items.len);
90	89	self.items[i] = item;
91	90	}
92	91
93		/// Return the maximum number of items the list can hold
94		/// without allocating more memory.
95		pub fn capacity(self: Self) usize {
96		return self.items.len;
97		}
98
99	92	/// ArrayList takes ownership of the passed in slice. The slice must have been
100	93	/// allocated with `allocator`.
101	94	/// Deinitialize with `deinit` or use `toOwnedSlice`.
102	95	pub fn fromOwnedSlice(allocator: *Allocator, slice: Slice) Self {
103	96	return Self{
104	97	.items = slice,
105		.len = slice.len,
	98	.capacity = slice.len,
106	99	.allocator = allocator,
107	100	};
108	101	}
...	...	@@ -110,7 +103,7 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
110	103	/// The caller owns the returned memory. ArrayList becomes empty.
111	104	pub fn toOwnedSlice(self: *Self) Slice {
112	105	const allocator = self.allocator;
113		const result = allocator.shrink(self.items, self.len);
	106	const result = allocator.shrink(self.allocatedSlice(), self.items.len);
114	107	self.* = init(allocator);
115	108	return result;
116	109	}
...	...	@@ -118,10 +111,10 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
118	111	/// Insert `item` at index `n`. Moves `list[n .. list.len]`
119	112	/// to make room.
120	113	pub fn insert(self: *Self, n: usize, item: T) !void {
121		try self.ensureCapacity(self.len + 1);
122		self.len += 1;
	114	try self.ensureCapacity(self.items.len + 1);
	115	self.items.len += 1;
123	116
124		mem.copyBackwards(T, self.items[n + 1 .. self.len], self.items[n .. self.len - 1]);
	117	mem.copyBackwards(T, self.items[n + 1 .. self.items.len], self.items[n .. self.items.len - 1]);
125	118	self.items[n] = item;
126	119	}
127	120
...	...	@@ -129,10 +122,10 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
129	122	/// `list[i .. list.len]` to make room.
130	123	/// This operation is O(N).
131	124	pub fn insertSlice(self: *Self, i: usize, items: SliceConst) !void {
132		try self.ensureCapacity(self.len + items.len);
133		self.len += items.len;
	125	try self.ensureCapacity(self.items.len + items.len);
	126	self.items.len += items.len;
134	127
135		mem.copyBackwards(T, self.items[i + items.len .. self.len], self.items[i .. self.len - items.len]);
	128	mem.copyBackwards(T, self.items[i + items.len .. self.items.len], self.items[i .. self.items.len - items.len]);
136	129	mem.copy(T, self.items[i .. i + items.len], items);
137	130	}
138	131
...	...	@@ -153,13 +146,13 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
153	146	/// Asserts the array has at least one item.
154	147	/// This operation is O(N).
155	148	pub fn orderedRemove(self: *Self, i: usize) T {
156		const newlen = self.len - 1;
	149	const newlen = self.items.len - 1;
157	150	if (newlen == i) return self.pop();
158	151
159		const old_item = self.at(i);
	152	const old_item = self.items[i];
160	153	for (self.items[i..newlen]) \|b, j\| b. = self.items[i + 1 + j];
161	154	self.items[newlen] = undefined;
162		self.len = newlen;
	155	self.items.len = newlen;
163	156	return old_item;
164	157	}
165	158
...	...	@@ -167,26 +160,28 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
167	160	/// The empty slot is filled from the end of the list.
168	161	/// This operation is O(1).
169	162	pub fn swapRemove(self: *Self, i: usize) T {
170		if (self.len - 1 == i) return self.pop();
	163	if (self.items.len - 1 == i) return self.pop();
171	164
172		const slice = self.span();
173		const old_item = slice[i];
174		slice[i] = self.pop();
	165	const old_item = self.items[i];
	166	self.items[i] = self.pop();
175	167	return old_item;
176	168	}
177	169
178		/// Deprecated: use `if (i >= list.len) return error.OutOfBounds else list.swapRemove(i)`.
	170	/// Deprecated: use `if (i >= list.items.len) return error.OutOfBounds else list.swapRemove(i)`.
179	171	pub fn swapRemoveOrError(self: *Self, i: usize) !T {
180		if (i >= self.len) return error.OutOfBounds;
	172	if (i >= self.items.len) return error.OutOfBounds;
181	173	return self.swapRemove(i);
182	174	}
183	175
184	176	/// Append the slice of items to the list. Allocates more
185	177	/// memory as necessary.
186	178	pub fn appendSlice(self: *Self, items: SliceConst) !void {
187		try self.ensureCapacity(self.len + items.len);
188		mem.copy(T, self.items[self.len..], items);
189		self.len += items.len;
	179	const oldlen = self.items.len;
	180	const newlen = self.items.len + items.len;
	181
	182	try self.ensureCapacity(newlen);
	183	self.items.len = newlen;
	184	mem.copy(T, self.items[oldlen..], items);
190	185	}
191	186
192	187	/// Same as `append` except it returns the number of bytes written, which is always the same
...	...	@@ -206,50 +201,58 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
206	201	/// Append a value to the list `n` times.
207	202	/// Allocates more memory as necessary.
208	203	pub fn appendNTimes(self: *Self, value: T, n: usize) !void {
209		const old_len = self.len;
210		try self.resize(self.len + n);
211		mem.set(T, self.items[old_len..self.len], value);
	204	const old_len = self.items.len;
	205	try self.resize(self.items.len + n);
	206	mem.set(T, self.items[old_len..self.items.len], value);
212	207	}
213	208
214	209	/// Adjust the list's length to `new_len`.
215	210	/// Does not initialize added items if any.
216	211	pub fn resize(self: *Self, new_len: usize) !void {
217	212	try self.ensureCapacity(new_len);
218		self.len = new_len;
	213	self.items.len = new_len;
219	214	}
220	215
221	216	/// Reduce allocated capacity to `new_len`.
222	217	/// Invalidates element pointers.
223	218	pub fn shrink(self: *Self, new_len: usize) void {
224		assert(new_len <= self.len);
225		self.len = new_len;
226		self.items = self.allocator.realloc(self.items, new_len) catch \|e\| switch (e) {
227		error.OutOfMemory => return, // no problem, capacity is still correct then.
	219	assert(new_len <= self.items.len);
	220
	221	self.items = self.allocator.realloc(self.allocatedSlice(), new_len) catch \|e\| switch (e) {
	222	error.OutOfMemory => { // no problem, capacity is still correct then.
	223	self.items.len = new_len;
	224	return;
	225	},
228	226	};
	227	self.capacity = new_len;
229	228	}
230	229
231	230	pub fn ensureCapacity(self: *Self, new_capacity: usize) !void {
232		var better_capacity = self.capacity();
	231	var better_capacity = self.capacity;
233	232	if (better_capacity >= new_capacity) return;
	233
234	234	while (true) {
235	235	better_capacity += better_capacity / 2 + 8;
236	236	if (better_capacity >= new_capacity) break;
237	237	}
238		self.items = try self.allocator.realloc(self.items, better_capacity);
	238
	239	const new_memory = try self.allocator.realloc(self.allocatedSlice(), better_capacity);
	240	self.items.ptr = new_memory.ptr;
	241	self.capacity = new_memory.len;
239	242	}
240	243
241	244	/// Increases the array's length to match the full capacity that is already allocated.
242	245	/// The new elements have `undefined` values. This operation does not invalidate any
243	246	/// element pointers.
244	247	pub fn expandToCapacity(self: *Self) void {
245		self.len = self.items.len;
	248	self.items.len = self.capacity;
246	249	}
247	250
248	251	/// Increase length by 1, returning pointer to the new item.
249	252	/// The returned pointer becomes invalid when the list is resized.
250	253	pub fn addOne(self: Self) !T {
251		const new_length = self.len + 1;
252		try self.ensureCapacity(new_length);
	254	const newlen = self.items.len + 1;
	255	try self.ensureCapacity(newlen);
253	256	return self.addOneAssumeCapacity();
254	257	}
255	258
...	...	@@ -257,25 +260,32 @@ pub fn AlignedArrayList(comptime T: type, comptime alignment: ?u29) type {
257	260	/// Asserts that there is already space for the new item without allocating more.
258	261	/// The returned pointer becomes invalid when the list is resized.
259	262	pub fn addOneAssumeCapacity(self: Self) T {
260		assert(self.len < self.capacity());
261		const result = &self.items[self.len];
262		self.len += 1;
263		return result;
	263	assert(self.items.len < self.capacity);
	264
	265	self.items.len += 1;
	266	return &self.items[self.items.len - 1];
264	267	}
265	268
266	269	/// Remove and return the last element from the list.
267	270	/// Asserts the list has at least one item.
268	271	pub fn pop(self: *Self) T {
269		self.len -= 1;
270		return self.items[self.len];
	272	const val = self.items[self.items.len - 1];
	273	self.items.len -= 1;
	274	return val;
271	275	}
272	276
273	277	/// Remove and return the last element from the list.
274	278	/// If the list is empty, returns `null`.
275	279	pub fn popOrNull(self: *Self) ?T {
276		if (self.len == 0) return null;
	280	if (self.items.len == 0) return null;
277	281	return self.pop();
278	282	}
	283
	284	// For a nicer API, `items.len` is the length, not the capacity.
	285	// This requires "unsafe" slicing.
	286	fn allocatedSlice(self: Self) Slice {
	287	return self.items.ptr[0..self.capacity];
	288	}
279	289	};
280	290	}
281	291
...	...	@@ -283,15 +293,15 @@ test "std.ArrayList.init" {
283	293	var list = ArrayList(i32).init(testing.allocator);
284	294	defer list.deinit();
285	295
286		testing.expect(list.len == 0);
287		testing.expect(list.capacity() == 0);
	296	testing.expect(list.items.len == 0);
	297	testing.expect(list.capacity == 0);
288	298	}
289	299
290	300	test "std.ArrayList.initCapacity" {
291	301	var list = try ArrayList(i8).initCapacity(testing.allocator, 200);
292	302	defer list.deinit();
293		testing.expect(list.len == 0);
294		testing.expect(list.capacity() >= 200);
	303	testing.expect(list.items.len == 0);
	304	testing.expect(list.capacity >= 200);
295	305	}
296	306
297	307	test "std.ArrayList.basic" {
...	...	@@ -315,7 +325,7 @@ test "std.ArrayList.basic" {
315	325	}
316	326	}
317	327
318		for (list.span()) \|v, i\| {
	328	for (list.items) \|v, i\| {
319	329	testing.expect(v == @intCast(i32, i + 1));
320	330	}
321	331
...	...	@@ -324,19 +334,19 @@ test "std.ArrayList.basic" {
324	334	}
325	335
326	336	testing.expect(list.pop() == 10);
327		testing.expect(list.len == 9);
	337	testing.expect(list.items.len == 9);
328	338
329	339	list.appendSlice(&[_]i32{ 1, 2, 3 }) catch unreachable;
330		testing.expect(list.len == 12);
	340	testing.expect(list.items.len == 12);
331	341	testing.expect(list.pop() == 3);
332	342	testing.expect(list.pop() == 2);
333	343	testing.expect(list.pop() == 1);
334		testing.expect(list.len == 9);
	344	testing.expect(list.items.len == 9);
335	345
336	346	list.appendSlice(&[_]i32{}) catch unreachable;
337		testing.expect(list.len == 9);
	347	testing.expect(list.items.len == 9);
338	348
339		// can only set on indices < self.len
	349	// can only set on indices < self.items.len
340	350	list.set(7, 33);
341	351	list.set(8, 42);
342	352
...	...	@@ -352,8 +362,8 @@ test "std.ArrayList.appendNTimes" {
352	362	defer list.deinit();
353	363
354	364	try list.appendNTimes(2, 10);
355		testing.expectEqual(@as(usize, 10), list.len);
356		for (list.span()) \|element\| {
	365	testing.expectEqual(@as(usize, 10), list.items.len);
	366	for (list.items) \|element\| {
357	367	testing.expectEqual(@as(i32, 2), element);
358	368	}
359	369	}
...	...	@@ -378,17 +388,17 @@ test "std.ArrayList.orderedRemove" {
378	388
379	389	//remove from middle
380	390	testing.expectEqual(@as(i32, 4), list.orderedRemove(3));
381		testing.expectEqual(@as(i32, 5), list.at(3));
382		testing.expectEqual(@as(usize, 6), list.len);
	391	testing.expectEqual(@as(i32, 5), list.items[3]);
	392	testing.expectEqual(@as(usize, 6), list.items.len);
383	393
384	394	//remove from end
385	395	testing.expectEqual(@as(i32, 7), list.orderedRemove(5));
386		testing.expectEqual(@as(usize, 5), list.len);
	396	testing.expectEqual(@as(usize, 5), list.items.len);
387	397
388	398	//remove from front
389	399	testing.expectEqual(@as(i32, 1), list.orderedRemove(0));
390		testing.expectEqual(@as(i32, 2), list.at(0));
391		testing.expectEqual(@as(usize, 4), list.len);
	400	testing.expectEqual(@as(i32, 2), list.items[0]);
	401	testing.expectEqual(@as(usize, 4), list.items.len);
392	402	}
393	403
394	404	test "std.ArrayList.swapRemove" {
...	...	@@ -405,17 +415,17 @@ test "std.ArrayList.swapRemove" {
405	415
406	416	//remove from middle
407	417	testing.expect(list.swapRemove(3) == 4);
408		testing.expect(list.at(3) == 7);
409		testing.expect(list.len == 6);
	418	testing.expect(list.items[3] == 7);
	419	testing.expect(list.items.len == 6);
410	420
411	421	//remove from end
412	422	testing.expect(list.swapRemove(5) == 6);
413		testing.expect(list.len == 5);
	423	testing.expect(list.items.len == 5);
414	424
415	425	//remove from front
416	426	testing.expect(list.swapRemove(0) == 1);
417		testing.expect(list.at(0) == 5);
418		testing.expect(list.len == 4);
	427	testing.expect(list.items[0] == 5);
	428	testing.expect(list.items.len == 4);
419	429	}
420	430
421	431	test "std.ArrayList.swapRemoveOrError" {
...	...	@@ -478,7 +488,7 @@ test "std.ArrayList.insertSlice" {
478	488
479	489	const items = [_]i32{1};
480	490	try list.insertSlice(0, items[0..0]);
481		testing.expect(list.len == 6);
	491	testing.expect(list.items.len == 6);
482	492	testing.expect(list.items[0] == 1);
483	493	}
484	494
...	...	@@ -504,3 +514,18 @@ test "std.ArrayList(u8) implements outStream" {
504	514
505	515	testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.span());
506	516	}
	517
	518	test "std.ArrayList.shrink still sets length on error.OutOfMemory" {
	519	// use an arena allocator to make sure realloc returns error.OutOfMemory
	520	var arena = std.heap.ArenaAllocator.init(testing.allocator);
	521	defer arena.deinit();
	522
	523	var list = ArrayList(i32).init(&arena.allocator);
	524
	525	try list.append(1);
	526	try list.append(2);
	527	try list.append(3);
	528
	529	list.shrink(1);
	530	testing.expect(list.items.len == 1);
	531	}

lib/std/array_list_sentineled.zig+8-8

...	...	@@ -82,8 +82,8 @@ pub fn ArrayListSentineled(comptime T: type, comptime sentinel: T) type {
82	82	self.list.deinit();
83	83	}
84	84
85		pub fn span(self: var) @TypeOf(self.list.items[0 .. self.list.len - 1 :sentinel]) {
86		return self.list.span()[0..self.len() :sentinel];
	85	pub fn span(self: var) @TypeOf(self.list.items[0..:sentinel]) {
	86	return self.list.items[0..self.len() :sentinel];
87	87	}
88	88
89	89	pub fn shrink(self: *Self, new_len: usize) void {
...	...	@@ -98,16 +98,16 @@ pub fn ArrayListSentineled(comptime T: type, comptime sentinel: T) type {
98	98	}
99	99
100	100	pub fn isNull(self: Self) bool {
101		return self.list.len == 0;
	101	return self.list.items.len == 0;
102	102	}
103	103
104	104	pub fn len(self: Self) usize {
105		return self.list.len - 1;
	105	return self.list.items.len - 1;
106	106	}
107	107
108	108	pub fn capacity(self: Self) usize {
109		return if (self.list.items.len > 0)
110		self.list.items.len - 1
	109	return if (self.list.capacity > 0)
	110	self.list.capacity - 1
111	111	else
112	112	0;
113	113	}
...	...	@@ -115,13 +115,13 @@ pub fn ArrayListSentineled(comptime T: type, comptime sentinel: T) type {
115	115	pub fn appendSlice(self: *Self, m: []const T) !void {
116	116	const old_len = self.len();
117	117	try self.resize(old_len + m.len);
118		mem.copy(T, self.list.span()[old_len..], m);
	118	mem.copy(T, self.list.items[old_len..], m);
119	119	}
120	120
121	121	pub fn append(self: *Self, byte: T) !void {
122	122	const old_len = self.len();
123	123	try self.resize(old_len + 1);
124		self.list.span()[old_len] = byte;
	124	self.list.items[old_len] = byte;
125	125	}
126	126
127	127	pub fn eql(self: Self, m: []const T) bool {

lib/std/build.zig+2-2

...	...	@@ -1779,7 +1779,7 @@ pub const LibExeObjStep = struct {
1779	1779	const self = @fieldParentPtr(LibExeObjStep, "step", step);
1780	1780	const builder = self.builder;
1781	1781
1782		if (self.root_src == null and self.link_objects.len == 0) {
	1782	if (self.root_src == null and self.link_objects.items.len == 0) {
1783	1783	warn("{}: linker needs 1 or more objects to link\n", .{self.step.name});
1784	1784	return error.NeedAnObject;
1785	1785	}
...	...	@@ -1847,7 +1847,7 @@ pub const LibExeObjStep = struct {
1847	1847	}
1848	1848	}
1849	1849
1850		if (self.build_options_contents.len > 0) {
	1850	if (self.build_options_contents.items.len > 0) {
1851	1851	const build_options_file = try fs.path.join(
1852	1852	builder.allocator,
1853	1853	&[_][]const u8{ builder.cache_root, builder.fmt("{}_build_options.zig", .{self.name}) },

lib/std/build/emit_raw.zig+1-1

...	...	@@ -94,7 +94,7 @@ const BinaryElfOutput = struct {
94	94
95	95	sort.sort(*BinaryElfSegment, self.segments.span(), segmentSortCompare);
96	96
97		if (self.segments.len > 0) {
	97	if (self.segments.items.len > 0) {
98	98	const firstSegment = self.segments.at(0);
99	99	if (firstSegment.firstSection) \|firstSection\| {
100	100	const diff = firstSection.elfOffset - firstSegment.elfOffset;

lib/std/coff.zig+1-1

...	...	@@ -181,7 +181,7 @@ pub const Coff = struct {
181	181	}
182	182
183	183	pub fn loadSections(self: *Coff) !void {
184		if (self.sections.len == self.coff_header.number_of_sections)
	184	if (self.sections.items.len == self.coff_header.number_of_sections)
185	185	return;
186	186
187	187	try self.sections.ensureCapacity(self.coff_header.number_of_sections);

lib/std/debug.zig+1-1

...	...	@@ -1478,7 +1478,7 @@ pub const ModuleDebugInfo = switch (builtin.os.tag) {
1478	1478
1479	1479	var coff_section: *coff.Section = undefined;
1480	1480	const mod_index = for (self.sect_contribs) \|sect_contrib\| {
1481		if (sect_contrib.Section > self.coff.sections.len) continue;
	1481	if (sect_contrib.Section > self.coff.sections.items.len) continue;
1482	1482	// Remember that SectionContribEntry.Section is 1-based.
1483	1483	coff_section = &self.coff.sections.span()[sect_contrib.Section - 1];
1484	1484

lib/std/dwarf.zig+4-4

...	...	@@ -206,7 +206,7 @@ const LineNumberProgram = struct {
206	206	if (self.target_address >= self.prev_address and self.target_address < self.address) {
207	207	const file_entry = if (self.prev_file == 0) {
208	208	return error.MissingDebugInfo;
209		} else if (self.prev_file - 1 >= self.file_entries.len) {
	209	} else if (self.prev_file - 1 >= self.file_entries.items.len) {
210	210	return error.InvalidDebugInfo;
211	211	} else
212	212	&self.file_entries.items[self.prev_file - 1];
...	...	@@ -645,7 +645,7 @@ pub const DwarfInfo = struct {
645	645	.offset = abbrev_offset,
646	646	.table = try di.parseAbbrevTable(abbrev_offset),
647	647	});
648		return &di.abbrev_table_list.items[di.abbrev_table_list.len - 1].table;
	648	return &di.abbrev_table_list.items[di.abbrev_table_list.items.len - 1].table;
649	649	}
650	650
651	651	fn parseAbbrevTable(di: *DwarfInfo, offset: u64) !AbbrevTable {
...	...	@@ -665,7 +665,7 @@ pub const DwarfInfo = struct {
665	665	.has_children = (try in.readByte()) == CHILDREN_yes,
666	666	.attrs = ArrayList(AbbrevAttr).init(di.allocator()),
667	667	});
668		const attrs = &result.items[result.len - 1].attrs;
	668	const attrs = &result.items[result.items.len - 1].attrs;
669	669
670	670	while (true) {
671	671	const attr_id = try leb.readULEB128(u64, in);
...	...	@@ -689,7 +689,7 @@ pub const DwarfInfo = struct {
689	689	.has_children = table_entry.has_children,
690	690	.attrs = ArrayList(Die.Attr).init(di.allocator()),
691	691	};
692		try result.attrs.resize(table_entry.attrs.len);
	692	try result.attrs.resize(table_entry.attrs.items.len);
693	693	for (table_entry.attrs.span()) \|attr, i\| {
694	694	result.attrs.items[i] = Die.Attr{
695	695	.id = attr.attr_id,

lib/std/fs.zig+3-3

...	...	@@ -1440,9 +1440,9 @@ pub const Walker = struct {
1440	1440	/// a reference to the path.
1441	1441	pub fn next(self: *Walker) !?Entry {
1442	1442	while (true) {
1443		if (self.stack.len == 0) return null;
	1443	if (self.stack.items.len == 0) return null;
1444	1444	// `top` becomes invalid after appending to `self.stack`.
1445		const top = &self.stack.span()[self.stack.len - 1];
	1445	const top = &self.stack.span()[self.stack.items.len - 1];
1446	1446	const dirname_len = top.dirname_len;
1447	1447	if (try top.dir_it.next()) \|base\| {
1448	1448	self.name_buffer.shrink(dirname_len);
...	...	@@ -1457,7 +1457,7 @@ pub const Walker = struct {
1457	1457	errdefer new_dir.close();
1458	1458	try self.stack.append(StackItem{
1459	1459	.dir_it = new_dir.iterate(),
1460		.dirname_len = self.name_buffer.len,
	1460	.dirname_len = self.name_buffer.items.len,
1461	1461	});
1462	1462	}
1463	1463	}

lib/std/http/headers.zig+12-12

...	...	@@ -139,7 +139,7 @@ pub const Headers = struct {
139	139	pub fn clone(self: Self, allocator: *Allocator) !Self {
140	140	var other = Headers.init(allocator);
141	141	errdefer other.deinit();
142		try other.data.ensureCapacity(self.data.len);
	142	try other.data.ensureCapacity(self.data.items.len);
143	143	try other.index.initCapacity(self.index.entries.len);
144	144	for (self.data.span()) \|entry\| {
145	145	try other.append(entry.name, entry.value, entry.never_index);
...	...	@@ -152,7 +152,7 @@ pub const Headers = struct {
152	152	}
153	153
154	154	pub fn append(self: *Self, name: []const u8, value: []const u8, never_index: ?bool) !void {
155		const n = self.data.len + 1;
	155	const n = self.data.items.len + 1;
156	156	try self.data.ensureCapacity(n);
157	157	var entry: HeaderEntry = undefined;
158	158	if (self.index.get(name)) \|kv\| {
...	...	@@ -197,7 +197,7 @@ pub const Headers = struct {
197	197	if (self.index.remove(name)) \|kv\| {
198	198	var dex = &kv.value;
199	199	// iterate backwards
200		var i = dex.len;
	200	var i = dex.items.len;
201	201	while (i > 0) {
202	202	i -= 1;
203	203	const data_index = dex.at(i);
...	...	@@ -220,18 +220,18 @@ pub const Headers = struct {
220	220	const removed = self.data.orderedRemove(i);
221	221	const kv = self.index.get(removed.name).?;
222	222	var dex = &kv.value;
223		if (dex.len == 1) {
	223	if (dex.items.len == 1) {
224	224	// was last item; delete the index
225	225	_ = self.index.remove(kv.key);
226	226	dex.deinit();
227	227	removed.deinit();
228	228	self.allocator.free(kv.key);
229	229	} else {
230		dex.shrink(dex.len - 1);
	230	dex.shrink(dex.items.len - 1);
231	231	removed.deinit();
232	232	}
233	233	// if it was the last item; no need to rebuild index
234		if (i != self.data.len) {
	234	if (i != self.data.items.len) {
235	235	self.rebuild_index();
236	236	}
237	237	}
...	...	@@ -242,18 +242,18 @@ pub const Headers = struct {
242	242	const removed = self.data.swapRemove(i);
243	243	const kv = self.index.get(removed.name).?;
244	244	var dex = &kv.value;
245		if (dex.len == 1) {
	245	if (dex.items.len == 1) {
246	246	// was last item; delete the index
247	247	_ = self.index.remove(kv.key);
248	248	dex.deinit();
249	249	removed.deinit();
250	250	self.allocator.free(kv.key);
251	251	} else {
252		dex.shrink(dex.len - 1);
	252	dex.shrink(dex.items.len - 1);
253	253	removed.deinit();
254	254	}
255	255	// if it was the last item; no need to rebuild index
256		if (i != self.data.len) {
	256	if (i != self.data.items.len) {
257	257	self.rebuild_index();
258	258	}
259	259	}
...	...	@@ -277,7 +277,7 @@ pub const Headers = struct {
277	277	pub fn get(self: Self, allocator: *Allocator, name: []const u8) !?[]const HeaderEntry {
278	278	const dex = self.getIndices(name) orelse return null;
279	279
280		const buf = try allocator.alloc(HeaderEntry, dex.len);
	280	const buf = try allocator.alloc(HeaderEntry, dex.items.len);
281	281	var n: usize = 0;
282	282	for (dex.span()) \|idx\| {
283	283	buf[n] = self.data.at(idx);
...	...	@@ -301,7 +301,7 @@ pub const Headers = struct {
301	301
302	302	// adapted from mem.join
303	303	const total_len = blk: {
304		var sum: usize = dex.len - 1; // space for separator(s)
	304	var sum: usize = dex.items.len - 1; // space for separator(s)
305	305	for (dex.span()) \|idx\|
306	306	sum += self.data.at(idx).value.len;
307	307	break :blk sum;
...	...	@@ -330,7 +330,7 @@ pub const Headers = struct {
330	330	var it = self.index.iterator();
331	331	while (it.next()) \|kv\| {
332	332	var dex = &kv.value;
333		dex.len = 0; // keeps capacity available
	333	dex.items.len = 0; // keeps capacity available
334	334	}
335	335	}
336	336	{ // fill up indexes again; we know capacity is fine from before

lib/std/io/in_stream.zig+2-2

...	...	@@ -54,7 +54,7 @@ pub fn InStream(
54	54	/// and the `std.ArrayList` has exactly `max_append_size` bytes appended.
55	55	pub fn readAllArrayList(self: Self, array_list: *std.ArrayList(u8), max_append_size: usize) !void {
56	56	try array_list.ensureCapacity(math.min(max_append_size, 4096));
57		const original_len = array_list.len;
	57	const original_len = array_list.items.len;
58	58	var start_index: usize = original_len;
59	59	while (true) {
60	60	array_list.expandToCapacity();
...	...	@@ -106,7 +106,7 @@ pub fn InStream(
106	106	return;
107	107	}
108	108
109		if (array_list.len == max_size) {
	109	if (array_list.items.len == max_size) {
110	110	return error.StreamTooLong;
111	111	}
112	112

lib/std/json.zig+10-10

...	...	@@ -1556,7 +1556,7 @@ fn parseInternal(comptime T: type, token: Token, tokens: *TokenStream, options:
1556	1556	else => {},
1557	1557	}
1558	1558
1559		try arraylist.ensureCapacity(arraylist.len + 1);
	1559	try arraylist.ensureCapacity(arraylist.items.len + 1);
1560	1560	const v = try parseInternal(ptrInfo.child, tok, tokens, options);
1561	1561	arraylist.appendAssumeCapacity(v);
1562	1562	}
...	...	@@ -1874,7 +1874,7 @@ pub const Parser = struct {
1874	1874	try p.transition(&arena.allocator, input, s.i - 1, token);
1875	1875	}
1876	1876
1877		debug.assert(p.stack.len == 1);
	1877	debug.assert(p.stack.items.len == 1);
1878	1878
1879	1879	return ValueTree{
1880	1880	.arena = arena,
...	...	@@ -1888,7 +1888,7 @@ pub const Parser = struct {
1888	1888	switch (p.state) {
1889	1889	.ObjectKey => switch (token) {
1890	1890	.ObjectEnd => {
1891		if (p.stack.len == 1) {
	1891	if (p.stack.items.len == 1) {
1892	1892	return;
1893	1893	}
1894	1894
...	...	@@ -1907,8 +1907,8 @@ pub const Parser = struct {
1907	1907	},
1908	1908	},
1909	1909	.ObjectValue => {
1910		var object = &p.stack.items[p.stack.len - 2].Object;
1911		var key = p.stack.items[p.stack.len - 1].String;
	1910	var object = &p.stack.items[p.stack.items.len - 2].Object;
	1911	var key = p.stack.items[p.stack.items.len - 1].String;
1912	1912
1913	1913	switch (token) {
1914	1914	.ObjectBegin => {
...	...	@@ -1950,11 +1950,11 @@ pub const Parser = struct {
1950	1950	}
1951	1951	},
1952	1952	.ArrayValue => {
1953		var array = &p.stack.items[p.stack.len - 1].Array;
	1953	var array = &p.stack.items[p.stack.items.len - 1].Array;
1954	1954
1955	1955	switch (token) {
1956	1956	.ArrayEnd => {
1957		if (p.stack.len == 1) {
	1957	if (p.stack.items.len == 1) {
1958	1958	return;
1959	1959	}
1960	1960
...	...	@@ -2021,12 +2021,12 @@ pub const Parser = struct {
2021	2021	}
2022	2022
2023	2023	fn pushToParent(p: Parser, value: const Value) !void {
2024		switch (p.stack.span()[p.stack.len - 1]) {
	2024	switch (p.stack.span()[p.stack.items.len - 1]) {
2025	2025	// Object Parent -> [ ..., object, <key>, value ]
2026	2026	Value.String => \|key\| {
2027	2027	_ = p.stack.pop();
2028	2028
2029		var object = &p.stack.items[p.stack.len - 1].Object;
	2029	var object = &p.stack.items[p.stack.items.len - 1].Object;
2030	2030	_ = try object.put(key, value.*);
2031	2031	p.state = .ObjectKey;
2032	2032	},
...	...	@@ -2165,7 +2165,7 @@ test "json.parser.dynamic" {
2165	2165	testing.expect(animated.Bool == false);
2166	2166
2167	2167	const array_of_object = image.Object.get("ArrayOfObject").?.value;
2168		testing.expect(array_of_object.Array.len == 1);
	2168	testing.expect(array_of_object.Array.items.len == 1);
2169	2169
2170	2170	const obj0 = array_of_object.Array.at(0).Object.get("n").?.value;
2171	2171	testing.expect(mem.eql(u8, obj0.String, "m"));

lib/std/math/big/rational.zig-1

...	...	@@ -4,7 +4,6 @@ const math = std.math;
4	4	const mem = std.mem;
5	5	const testing = std.testing;
6	6	const Allocator = mem.Allocator;
7		const ArrayList = std.ArrayList;
8	7
9	8	const bn = @import("int.zig");
10	9	const Limb = bn.Limb;

lib/std/net.zig+8-8

...	...	@@ -509,7 +509,7 @@ pub fn getAddressList(allocator: mem.Allocator, name: []const u8, port: u16) !
509	509
510	510	try linuxLookupName(&lookup_addrs, &canon, name, family, flags, port);
511	511
512		result.addrs = try arena.alloc(Address, lookup_addrs.len);
	512	result.addrs = try arena.alloc(Address, lookup_addrs.items.len);
513	513	if (!canon.isNull()) {
514	514	result.canon_name = canon.toOwnedSlice();
515	515	}
...	...	@@ -554,7 +554,7 @@ fn linuxLookupName(
554	554	return name_err;
555	555	} else {
556	556	try linuxLookupNameFromHosts(addrs, canon, name, family, port);
557		if (addrs.len == 0) {
	557	if (addrs.items.len == 0) {
558	558	try linuxLookupNameFromDnsSearch(addrs, canon, name, family, port);
559	559	}
560	560	}
...	...	@@ -562,11 +562,11 @@ fn linuxLookupName(
562	562	try canon.resize(0);
563	563	try linuxLookupNameFromNull(addrs, family, flags, port);
564	564	}
565		if (addrs.len == 0) return error.UnknownHostName;
	565	if (addrs.items.len == 0) return error.UnknownHostName;
566	566
567	567	// No further processing is needed if there are fewer than 2
568	568	// results or if there are only IPv4 results.
569		if (addrs.len == 1 or family == os.AF_INET) return;
	569	if (addrs.items.len == 1 or family == os.AF_INET) return;
570	570	const all_ip4 = for (addrs.span()) \|addr\| {
571	571	if (addr.addr.any.family != os.AF_INET) break false;
572	572	} else true;
...	...	@@ -908,7 +908,7 @@ fn linuxLookupNameFromDnsSearch(
908	908	canon.shrink(canon_name.len + 1);
909	909	try canon.appendSlice(tok);
910	910	try linuxLookupNameFromDns(addrs, canon, canon.span(), family, rc, port);
911		if (addrs.len != 0) return;
	911	if (addrs.items.len != 0) return;
912	912	}
913	913
914	914	canon.shrink(canon_name.len);
...	...	@@ -967,7 +967,7 @@ fn linuxLookupNameFromDns(
967	967	dnsParse(ap[i], ctx, dnsParseCallback) catch {};
968	968	}
969	969
970		if (addrs.len != 0) return;
	970	if (addrs.items.len != 0) return;
971	971	if (ap[0].len < 4 or (ap[0][3] & 15) == 2) return error.TemporaryNameServerFailure;
972	972	if ((ap[0][3] & 15) == 0) return error.UnknownHostName;
973	973	if ((ap[0][3] & 15) == 3) return;
...	...	@@ -1049,7 +1049,7 @@ fn getResolvConf(allocator: mem.Allocator, rc: ResolvConf) !void {
1049	1049	}
1050	1050	}
1051	1051
1052		if (rc.ns.len == 0) {
	1052	if (rc.ns.items.len == 0) {
1053	1053	return linuxLookupNameFromNumericUnspec(&rc.ns, "127.0.0.1", 53);
1054	1054	}
1055	1055	}
...	...	@@ -1078,7 +1078,7 @@ fn resMSendRc(
1078	1078	var ns_list = std.ArrayList(Address).init(rc.ns.allocator);
1079	1079	defer ns_list.deinit();
1080	1080
1081		try ns_list.resize(rc.ns.len);
	1081	try ns_list.resize(rc.ns.items.len);
1082	1082	const ns = ns_list.span();
1083	1083
1084	1084	for (rc.ns.span()) \|iplit, i\| {

lib/std/special/build_runner.zig+1-1

...	...	@@ -171,7 +171,7 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: var) !void {
171	171	\\
172	172	);
173	173
174		if (builder.available_options_list.len == 0) {
	174	if (builder.available_options_list.items.len == 0) {
175	175	try out_stream.print(" (none)\n", .{});
176	176	} else {
177	177	for (builder.available_options_list.span()) \|option\| {

lib/std/unicode.zig+2-2

...	...	@@ -475,7 +475,7 @@ pub fn utf16leToUtf8Alloc(allocator: *mem.Allocator, utf16le: []const u16) ![]u8
475	475	var it = Utf16LeIterator.init(utf16le);
476	476	while (try it.nextCodepoint()) \|codepoint\| {
477	477	const utf8_len = utf8CodepointSequenceLength(codepoint) catch unreachable;
478		try result.resize(result.len + utf8_len);
	478	try result.resize(result.items.len + utf8_len);
479	479	assert((utf8Encode(codepoint, result.items[out_index..]) catch unreachable) == utf8_len);
480	480	out_index += utf8_len;
481	481	}
...	...	@@ -571,7 +571,7 @@ pub fn utf8ToUtf16LeWithNull(allocator: *mem.Allocator, utf8: []const u8) ![:0]u
571	571	}
572	572	}
573	573
574		const len = result.len;
	574	const len = result.items.len;
575	575	try result.append(0);
576	576	return result.toOwnedSlice()[0..len :0];
577	577	}

src-self-hosted/libc_installation.zig+3-3

...	...	@@ -268,7 +268,7 @@ pub const LibCInstallation = struct {
268	268	try search_paths.append(line);
269	269	}
270	270	}
271		if (search_paths.len == 0) {
	271	if (search_paths.items.len == 0) {
272	272	return error.CCompilerCannotFindHeaders;
273	273	}
274	274
...	...	@@ -276,9 +276,9 @@ pub const LibCInstallation = struct {
276	276	const sys_include_dir_example_file = if (is_windows) "sys\\types.h" else "sys/errno.h";
277	277
278	278	var path_i: usize = 0;
279		while (path_i < search_paths.len) : (path_i += 1) {
	279	while (path_i < search_paths.items.len) : (path_i += 1) {
280	280	// search in reverse order
281		const search_path_untrimmed = search_paths.at(search_paths.len - path_i - 1);
	281	const search_path_untrimmed = search_paths.at(search_paths.items.len - path_i - 1);
282	282	const search_path = std.mem.trimLeft(u8, search_path_untrimmed, " ");
283	283	var search_dir = fs.cwd().openDir(search_path, .{}) catch \|err\| switch (err) {
284	284	error.FileNotFound,

src-self-hosted/stage2.zig+2-2

...	...	@@ -239,7 +239,7 @@ fn fmtMain(argc: c_int, argv: []const [:0]const u8) !void {
239	239	}
240	240
241	241	if (stdin_flag) {
242		if (input_files.len != 0) {
	242	if (input_files.items.len != 0) {
243	243	try stderr.writeAll("cannot use --stdin with positional arguments\n");
244	244	process.exit(1);
245	245	}
...	...	@@ -273,7 +273,7 @@ fn fmtMain(argc: c_int, argv: []const [:0]const u8) !void {
273	273	return;
274	274	}
275	275
276		if (input_files.len == 0) {
	276	if (input_files.items.len == 0) {
277	277	try stderr.writeAll("expected at least one source file argument\n");
278	278	process.exit(1);
279	279	}

src-self-hosted/translate_c.zig+3-3

...	...	@@ -4309,7 +4309,7 @@ fn makeRestorePoint(c: *Context) RestorePoint {
4309	4309	return RestorePoint{
4310	4310	.c = c,
4311	4311	.token_index = c.tree.tokens.len,
4312		.src_buf_index = c.source_buffer.len,
	4312	.src_buf_index = c.source_buffer.items.len,
4313	4313	};
4314	4314	}
4315	4315
...	...	@@ -4771,11 +4771,11 @@ fn appendToken(c: *Context, token_id: Token.Id, bytes: []const u8) !ast.TokenInd
4771	4771
4772	4772	fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: var) !ast.TokenIndex {
4773	4773	assert(token_id != .Invalid);
4774		const start_index = c.source_buffer.len;
	4774	const start_index = c.source_buffer.items.len;
4775	4775	errdefer c.source_buffer.shrink(start_index);
4776	4776
4777	4777	try c.source_buffer.outStream().print(format, args);
4778		const end_index = c.source_buffer.len;
	4778	const end_index = c.source_buffer.items.len;
4779	4779	const token_index = c.tree.tokens.len;
4780	4780	const new_token = try c.tree.tokens.addOne();
4781	4781	errdefer c.tree.tokens.shrink(token_index);

test/standalone/brace_expansion/main.zig+2-2

...	...	@@ -113,7 +113,7 @@ fn parse(tokens: const ArrayList(Token), token_index: usize) ParseError!Node {
113	113
114	114	fn expandString(input: []const u8, output: *ArrayListSentineled(u8, 0)) !void {
115	115	const tokens = try tokenize(input);
116		if (tokens.len == 1) {
	116	if (tokens.items.len == 1) {
117	117	return output.resize(0);
118	118	}
119	119
...	...	@@ -142,7 +142,7 @@ fn expandString(input: []const u8, output: *ArrayListSentineled(u8, 0)) !void {
142	142	const ExpandNodeError = error{OutOfMemory};
143	143
144	144	fn expandNode(node: Node, output: *ArrayList(ArrayListSentineled(u8, 0))) ExpandNodeError!void {
145		assert(output.len == 0);
	145	assert(output.items.len == 0);
146	146	switch (node) {
147	147	Node.Scalar => \|scalar\| {
148	148	try output.append(try ArrayListSentineled(u8, 0).init(global_allocator, scalar));

test/tests.zig+2-2

...	...	@@ -879,13 +879,13 @@ pub const CompileErrorContext = struct {
879	879	var err_iter = ErrLineIter.init(stderr);
880	880	var i: usize = 0;
881	881	ok = while (err_iter.next()) \|line\| : (i += 1) {
882		if (i >= self.case.expected_errors.len) break false;
	882	if (i >= self.case.expected_errors.items.len) break false;
883	883	const expected = self.case.expected_errors.at(i);
884	884	if (mem.indexOf(u8, line, expected) == null) break false;
885	885	continue;
886	886	} else true;
887	887
888		ok = ok and i == self.case.expected_errors.len;
	888	ok = ok and i == self.case.expected_errors.items.len;
889	889
890	890	if (!ok) {
891	891	warn("\n======== Expected these compile errors: ========\n", .{});

tools/merge_anal_dumps.zig+4-4

...	...	@@ -194,7 +194,7 @@ const Dump = struct {
194	194	for (other_files) \|other_file, i\| {
195	195	const gop = try self.file_map.getOrPut(other_file.String);
196	196	if (!gop.found_existing) {
197		gop.kv.value = self.file_list.len;
	197	gop.kv.value = self.file_list.items.len;
198	198	try self.file_list.append(other_file.String);
199	199	}
200	200	try other_file_to_mine.putNoClobber(i, gop.kv.value);
...	...	@@ -213,7 +213,7 @@ const Dump = struct {
213	213	};
214	214	const gop = try self.node_map.getOrPut(other_node);
215	215	if (!gop.found_existing) {
216		gop.kv.value = self.node_list.len;
	216	gop.kv.value = self.node_list.items.len;
217	217	try self.node_list.append(other_node);
218	218	}
219	219	try other_ast_node_to_mine.putNoClobber(i, gop.kv.value);
...	...	@@ -243,7 +243,7 @@ const Dump = struct {
243	243	};
244	244	const gop = try self.error_map.getOrPut(other_error);
245	245	if (!gop.found_existing) {
246		gop.kv.value = self.error_list.len;
	246	gop.kv.value = self.error_list.items.len;
247	247	try self.error_list.append(other_error);
248	248	}
249	249	try other_error_to_mine.putNoClobber(i, gop.kv.value);
...	...	@@ -304,7 +304,7 @@ const Dump = struct {
304	304	) !void {
305	305	const gop = try self.type_map.getOrPut(other_type);
306	306	if (!gop.found_existing) {
307		gop.kv.value = self.type_list.len;
	307	gop.kv.value = self.type_list.items.len;
308	308	try self.type_list.append(other_type);
309	309	}
310	310	try other_types_to_mine.putNoClobber(other_type_index, gop.kv.value);

author	Andrew Kelley <andrew@ziglang.org> 2020-04-03 22:31:15-04:00
committer	GitHub <noreply@github.com> 2020-04-03 22:31:15-04:00
log	e89c42655cf9851cdf02065bc75cda0e27884966
tree	b25e26e53ceda1ac03e65de5d483491ee46e7c0e
parent	1568470c44eafb59425c070ea9884b78cc2516b2
parent	7a28c644aa8eb3d27dee113338af8278f8f6334f
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #4868 from xackus/new-arraylist-api