Updated indentation to C3 standard.

lib/std/collections/enummap.c3

@@ -2,15 +2,15 @@ module std::collections::enummap(<Enum, ValueType>);
 
 struct EnumMap
 {
-    ValueType[Enum.len] values;
+	ValueType[Enum.len] values;
 }
 
 fn void EnumMap.init(&self, ValueType init_value)
 {
-    foreach(&a : self.values)
-    {
-        *a = init_value;
-    }
+	foreach(&a : self.values)
+	{
+		*a = init_value;
+	}
 }
 
 

lib/std/collections/enumset.c3

@@ -17,7 +17,7 @@ fn void EnumSet.add(&self, Enum v)
 	$if IS_CHAR_ARRAY:
 		(*self)[(usz)v / 8] |= (char)(1u << ((usz)v % 8));
 	$else
-        *self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v);
+		*self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v);
 	$endif
 }
 
@@ -26,7 +26,7 @@ fn void EnumSet.clear(&self)
 	$if IS_CHAR_ARRAY:
 		*self = {};
 	$else
-        *self = 0;
+		*self = 0;
 	$endif
 }
 
@@ -37,10 +37,10 @@ fn bool EnumSet.remove(&self, Enum v)
 		(*self)[(usz)v / 8] &= (char)~(1u << ((usz)v % 8));
 		return true;
 	$else
-        EnumSetType old = (EnumSetType)*self;
-        EnumSetType new = old & ~(1u << (EnumSetType)v);
-        *self = (EnumSet)new;
-        return old != new;
+		EnumSetType old = (EnumSetType)*self;
+		EnumSetType new = old & ~(1u << (EnumSetType)v);
+		*self = (EnumSet)new;
+		return old != new;
 	$endif
 }
 
@@ -49,7 +49,7 @@ fn bool EnumSet.has(&self, Enum v)
 	$if IS_CHAR_ARRAY:
 		return (bool)(((*self)[(usz)v / 8] << ((usz)v % 8)) & 0x01);
 	$else
-        return ((EnumSetType)*self & (1u << (EnumSetType)v)) != 0;
+		return ((EnumSetType)*self & (1u << (EnumSetType)v)) != 0;
 	$endif
 }
 
@@ -58,7 +58,7 @@ fn void EnumSet.add_all(&self, EnumSet s)
 	$if IS_CHAR_ARRAY:
 		foreach (i, c : s) (*self)[i] |= c;
 	$else
-        *self = (EnumSet)((EnumSetType)*self | (EnumSetType)s);
+		*self = (EnumSet)((EnumSetType)*self | (EnumSetType)s);
 	$endif
 }
 
@@ -67,7 +67,7 @@ fn void EnumSet.retain_all(&self, EnumSet s)
 	$if IS_CHAR_ARRAY:
 		foreach (i, c : s) (*self)[i] &= c;
 	$else
-        *self = (EnumSet)((EnumSetType)*self & (EnumSetType)s);
+		*self = (EnumSet)((EnumSetType)*self & (EnumSetType)s);
 	$endif
 }
 
@@ -76,7 +76,7 @@ fn void EnumSet.remove_all(&self, EnumSet s)
 	$if IS_CHAR_ARRAY:
 		foreach (i, c : s) (*self)[i] &= ~c;
 	$else
-        *self = (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
+		*self = (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
 	$endif
 }
 
@@ -87,7 +87,7 @@ fn EnumSet EnumSet.and_of(&self, EnumSet s)
 		copy.retain_all(s);
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self & (EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self & (EnumSetType)s);
 	$endif
 }
 
@@ -98,7 +98,7 @@ fn EnumSet EnumSet.or_of(&self, EnumSet s)
 		copy.add_all(s);
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self | (EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self | (EnumSetType)s);
 	$endif
 }
 
@@ -110,7 +110,7 @@ fn EnumSet EnumSet.diff_of(&self, EnumSet s)
 		copy.remove_all(s);
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
 	$endif
 }
 
@@ -121,7 +121,7 @@ fn EnumSet EnumSet.xor_of(&self, EnumSet s)
 		foreach (i, c : s) copy[i] ^= c;
 		return copy;
 	$else
-        return (EnumSet)((EnumSetType)*self ^ (EnumSetType)s);
+		return (EnumSet)((EnumSetType)*self ^ (EnumSetType)s);
 	$endif
 }
 

lib/std/collections/linkedlist.c3

@@ -5,22 +5,22 @@ module std::collections::linkedlist(<Type>);
 
 struct Node @private
 {
-    Node *next;
-    Node *prev;
-    Type value;
+	Node *next;
+	Node *prev;
+	Type value;
 }
 
 struct LinkedList
 {
-    Allocator *allocator;
-    usz size;
-    Node *_first;
-    Node *_last;
+	Allocator *allocator;
+	usz size;
+	Node *_first;
+	Node *_last;
 }
 
 fn void LinkedList.push(&self, Type value)
 {
-    self.link_first(value);
+	self.link_first(value);
 }
 
 fn void LinkedList.push_last(&self, Type value)
@@ -50,36 +50,36 @@ macro Node* LinkedList.alloc_node(&self) @private
 
 fn void LinkedList.link_first(&self, Type value) @private
 {
-    Node *first = self._first;
-    Node *new_node = self.alloc_node();
-    *new_node = { .next = first, .value = value };
-    self._first = new_node;
-    if (!first)
-    {
-        self._last = new_node;
-    }
-    else
-    {
-        first.prev = new_node;
-    }
-    self.size++;
+	Node *first = self._first;
+	Node *new_node = self.alloc_node();
+	*new_node = { .next = first, .value = value };
+	self._first = new_node;
+	if (!first)
+	{
+		self._last = new_node;
+	}
+	else
+	{
+		first.prev = new_node;
+	}
+	self.size++;
 }
 
 fn void LinkedList.link_last(&self, Type value) @private
 {
-    Node *last = self._last;
-    Node *new_node = self.alloc_node();
-    *new_node = { .prev = last, .value = value };
-    self._last = new_node;
-    if (!last)
-    {
-        self._first = new_node;
-    }
-    else
-    {
-        last.next = new_node;
-    }
-    self.size++;
+	Node *last = self._last;
+	Node *new_node = self.alloc_node();
+	*new_node = { .prev = last, .value = value };
+	self._last = new_node;
+	if (!last)
+	{
+		self._first = new_node;
+	}
+	else
+	{
+		last.next = new_node;
+	}
+	self.size++;
 }
 
 fn Type! LinkedList.peek(&self) => self.first() @inline;
@@ -101,15 +101,15 @@ fn void LinkedList.free(&self) => self.clear() @inline;
 
 fn void LinkedList.clear(&self)
 {
-    for (Node* node = self._first; node != null;)
-    {
-        Node* next = node.next;
-        self.free_node(node);
-        node = next;
-    }
-    self._first = null;
-    self._last = null;
-    self.size = 0;
+	for (Node* node = self._first; node != null;)
+	{
+		Node* next = node.next;
+		self.free_node(node);
+		node = next;
+	}
+	self._first = null;
+	self._last = null;
+	self.size = 0;
 }
 
 fn usz LinkedList.len(&self) @inline => self.size;
@@ -121,14 +121,14 @@ macro Node* LinkedList.node_at_index(&self, usz index)
 {
 	if (index * 2 >= self.size)
 	{
-	    Node* node = self._last;
-	    index = self.size - index - 1;
-        while (index--) node = node.prev;
-        return node;
+		Node* node = self._last;
+		index = self.size - index - 1;
+		while (index--) node = node.prev;
+		return node;
 	}
-    Node* node = self._first;
-    while (index--) node = node.next;
-    return node;
+	Node* node = self._first;
+	while (index--) node = node.next;
+	return node;
 }
 /**
  * @require index < self.size
@@ -174,19 +174,19 @@ fn void LinkedList.insert(&self, usz index, Type element)
  **/
 fn void LinkedList.link_before(&self, Node *succ, Type value) @private
 {
-    Node* pred = succ.prev;
-    Node* new_node = malloc(Node);
-    *new_node = { .prev = pred, .next = succ, .value = value };
-    succ.prev = new_node;
-    if (!pred)
-    {
-        self._first = new_node;
-    }
-    else
-    {
-        pred.next = new_node;
-    }
-    self.size++;
+	Node* pred = succ.prev;
+	Node* new_node = malloc(Node);
+	*new_node = { .prev = pred, .next = succ, .value = value };
+	succ.prev = new_node;
+	if (!pred)
+	{
+		self._first = new_node;
+	}
+	else
+	{
+		pred.next = new_node;
+	}
+	self.size++;
 }
 
 /**
@@ -195,44 +195,44 @@ fn void LinkedList.link_before(&self, Node *succ, Type value) @private
 fn void LinkedList.unlink_first(&self) @private
 {
 	Node* f = self._first;
-    Node* next = f.next;
-    self.free_node(f);
-    self._first = next;
-    if (!next)
-    {
-        self._last = null;
-    }
-    else
-    {
-        next.prev = null;
-    }
-    self.size--;
+	Node* next = f.next;
+	self.free_node(f);
+	self._first = next;
+	if (!next)
+	{
+		self._last = null;
+	}
+	else
+	{
+		next.prev = null;
+	}
+	self.size--;
 }
 
 fn bool LinkedList.remove_value(&self, Type t)
 {
-    for (Node* node = self._first; node != null; node = node.next)
-    {
-        if (node.value == t)
-        {
-            self.unlink(node);
-            return true;
-        }
-    }
-    return false;
+	for (Node* node = self._first; node != null; node = node.next)
+	{
+		if (node.value == t)
+		{
+			self.unlink(node);
+			return true;
+		}
+	}
+	return false;
 }
 
 fn bool LinkedList.remove_last_value(&self, Type t)
 {
-    for (Node* node = self._last; node != null; node = node.prev)
-    {
-        if (node.value == t)
-        {
-            self.unlink(node);
-            return true;
-        }
-    }
-    return false;
+	for (Node* node = self._last; node != null; node = node.prev)
+	{
+		if (node.value == t)
+		{
+			self.unlink(node);
+			return true;
+		}
+	}
+	return false;
 }
 
 fn Type! LinkedList.pop(&self)
@@ -260,18 +260,18 @@ fn void! LinkedList.remove_first(&self)
 fn void LinkedList.unlink_last(&self) @inline @private
 {
 	Node* l = self._last;
-    Node* prev = l.prev;
-    self._last = prev;
-    self.free_node(l);
-    if (!prev)
-    {
-        self._first = null;
-    }
-    else
-    {
-        prev.next = null;
-    }
-    self.size--;
+	Node* prev = l.prev;
+	self._last = prev;
+	self.free_node(l);
+	if (!prev)
+	{
+		self._first = null;
+	}
+	else
+	{
+		prev.next = null;
+	}
+	self.size--;
 }
 
 /**
@@ -279,24 +279,24 @@ fn void LinkedList.unlink_last(&self) @inline @private
  **/
 fn void LinkedList.unlink(&self, Node* x) @private
 {
-    Node* next = x.next;
-    Node* prev = x.prev;
-    if (!prev)
-    {
-        self._first = next;
-    }
-    else
-    {
-        prev.next = next;
-    }
-    if (!next)
-    {
-        self._last = prev;
-    }
-    else
-    {
-        next.prev = prev;
-    }
-    self.free_node(x);
-    self.size--;
+	Node* next = x.next;
+	Node* prev = x.prev;
+	if (!prev)
+	{
+		self._first = next;
+	}
+	else
+	{
+		prev.next = next;
+	}
+	if (!next)
+	{
+		self._last = prev;
+	}
+	else
+	{
+		next.prev = prev;
+	}
+	self.free_node(x);
+	self.size--;
 }

lib/std/collections/list.c3

@@ -10,10 +10,10 @@ const ELEMENT_IS_POINTER = Type.kindof == POINTER;
 
 struct List
 {
-    usz size;
-    usz capacity;
-    Allocator *allocator;
-    Type *entries;
+	usz size;
+	usz capacity;
+	Allocator *allocator;
+	Type *entries;
 }
 
 /**
@@ -66,13 +66,13 @@ fn String List.to_string(&self, Allocator* using = mem::heap()) @dynamic
 
 fn void List.push(&self, Type element) @inline
 {
-    self.append(element);
+	self.append(element);
 }
 
 fn void List.append(&self, Type element)
 {
-    self.ensure_capacity();
-    self.entries[self.size++] = element;
+	self.ensure_capacity();
+	self.entries[self.size++] = element;
 }
 
 /**
@@ -80,12 +80,12 @@ fn void List.append(&self, Type element)
  */
 fn Type List.pop(&self)
 {
-    return self.entries[--self.size];
+	return self.entries[--self.size];
 }
 
 fn void List.clear(&self)
 {
-    self.size = 0;
+	self.size = 0;
 }
 
 /**
@@ -93,18 +93,18 @@ fn void List.clear(&self)
  */
 fn Type List.pop_first(&self)
 {
-    Type value = self.entries[0];
-    self.remove_at(0);
-    return value;
+	Type value = self.entries[0];
+	self.remove_at(0);
+	return value;
 }
 
 fn void List.remove_at(&self, usz index)
 {
-    for (usz i = index + 1; i < self.size; i++)
-    {
-        self.entries[i - 1] = self.entries[i];
-    }
-    self.size--;
+	for (usz i = index + 1; i < self.size; i++)
+	{
+		self.entries[i - 1] = self.entries[i];
+	}
+	self.size--;
 }
 
 fn void List.add_all(&self, List* other_list)
@@ -113,7 +113,7 @@ fn void List.add_all(&self, List* other_list)
 	self.reserve(other_list.size);
 	foreach (&value : other_list)
 	{
-	    self.entries[self.size++] = *value;
+		self.entries[self.size++] = *value;
 	}
 }
 
@@ -151,24 +151,24 @@ fn void List.add_array(&self, Type[] array)
 	self.reserve(array.len);
 	foreach (&value : array)
 	{
-	    self.entries[self.size++] = *value;
+		self.entries[self.size++] = *value;
 	}
 }
 
 fn void List.push_front(&self, Type type) @inline
 {
-    self.insert_at(0, type);
+	self.insert_at(0, type);
 }
 
 fn void List.insert_at(&self, usz index, Type type)
 {
-    self.ensure_capacity();
-    for (usz i = self.size; i > index; i--)
-    {
-        self.entries[i] = self.entries[i - 1];
-    }
-    self.size++;
-    self.entries[index] = type;
+	self.ensure_capacity();
+	for (usz i = self.size; i > index; i--)
+	{
+		self.entries[i] = self.entries[i - 1];
+	}
+	self.size++;
+	self.entries[index] = type;
 }
 
 /**
@@ -176,51 +176,51 @@ fn void List.insert_at(&self, usz index, Type type)
  **/
 fn void List.set_at(&self, usz index, Type type)
 {
-    self.entries[index] = type;
+	self.entries[index] = type;
 }
 
 fn void List.remove_last(&self)
 {
-    self.size--;
+	self.size--;
 }
 
 fn void List.remove_first(&self)
 {
-    self.remove_at(0);
+	self.remove_at(0);
 }
 
 fn Type* List.first(&self)
 {
-    return self.size ? &self.entries[0] : null;
+	return self.size ? &self.entries[0] : null;
 }
 
 fn Type* List.last(&self)
 {
-    return self.size ? &self.entries[self.size - 1] : null;
+	return self.size ? &self.entries[self.size - 1] : null;
 }
 
 fn bool List.is_empty(&self) @inline
 {
-    return !self.size;
+	return !self.size;
 }
 
 fn usz List.len(&self) @operator(len) @inline
 {
-    return self.size;
+	return self.size;
 }
 
 fn Type List.get(&self, usz index) @inline
 {
-    return self.entries[index];
+	return self.entries[index];
 }
 
 fn void List.free(&self)
 {
 	if (!self.allocator) return;
-    free_aligned(self.entries, .using = self.allocator);
-    self.capacity = 0;
-    self.size = 0;
-    self.entries = null;
+	free_aligned(self.entries, .using = self.allocator);
+	self.capacity = 0;
+	self.size = 0;
+	self.entries = null;
 }
 
 fn void List.swap(&self, usz i, usz j)
@@ -276,29 +276,29 @@ fn void List.reserve(&self, usz min_capacity)
 	if (self.capacity >= min_capacity) return;
 	if (!self.allocator) self.allocator = mem::heap();
 	min_capacity = math::next_power_of_2(min_capacity);
-    self.entries = realloc_aligned(self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof, .using = self.allocator) ?? null;
+	self.entries = realloc_aligned(self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof, .using = self.allocator) ?? null;
 	self.capacity = min_capacity;
 }
 
 macro Type List.@item_at(&self, usz index) @operator([])
 {
-    return self.entries[index];
+	return self.entries[index];
 }
 
 fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
 {
-    return &self.entries[index];
+	return &self.entries[index];
 }
 
 fn void List.set(&self, usz index, Type value) @operator([]=)
 {
-    self.entries[index] = value;
+	self.entries[index] = value;
 }
 
 fn void List.ensure_capacity(&self, usz added = 1) @inline @private
 {
 	usz new_size = self.size + added;
-    if (self.capacity > new_size) return;
+	if (self.capacity > new_size) return;
 
 	assert(new_size < usz.max / 2U);
 	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;

lib/std/collections/map.c3

@@ -74,7 +74,7 @@ fn bool HashMap.is_empty(&map) @inline
 
 fn usz HashMap.len(&map) @inline
 {
-    return map.count;
+	return map.count;
 }
 
 fn Value*! HashMap.get_ref(&map, Key key)
@@ -204,14 +204,14 @@ macro HashMap.@each(map; @body(key, value))
 {
 	if (map.count)
 	{
-        foreach (Entry* entry : map.table)
-        {
-            while (entry)
-            {
-                @body(entry.key, entry.value);
-                entry = entry.next;
-            }
-        }
+		foreach (Entry* entry : map.table)
+		{
+			while (entry)
+			{
+				@body(entry.key, entry.value);
+				entry = entry.next;
+			}
+		}
 	}
 }
 
@@ -260,7 +260,7 @@ fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_ind
 	if (map.count++ >= map.threshold)
 	{
 		map.resize(map.table.len * 2);
-    }
+	}
 }
 
 fn void HashMap.resize(&map, uint new_capacity) @private
@@ -281,8 +281,8 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 
 fn uint rehash(uint hash) @inline @private
 {
-    hash ^= (hash >> 20) ^ (hash >> 12);
-    return hash ^ ((hash >> 7) ^ (hash >> 4));
+	hash ^= (hash >> 20) ^ (hash >> 12);
+	return hash ^ ((hash >> 7) ^ (hash >> 4));
 }
 
 macro uint index_for(uint hash, uint capacity) @private
@@ -293,36 +293,36 @@ macro uint index_for(uint hash, uint capacity) @private
 fn void HashMap.transfer(&map, Entry*[] new_table) @private
 {
 	Entry*[] src = map.table;
-    uint new_capacity = new_table.len;
-    foreach (uint j, Entry *e : src)
-    {
-        if (!e) continue;
-        do
-        {
-            Entry* next = e.next;
-            uint i = index_for(e.hash, new_capacity);
-            e.next = new_table[i];
-            new_table[i] = e;
-            e = next;
-        }
-        while (e);
-    }
+	uint new_capacity = new_table.len;
+	foreach (uint j, Entry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			Entry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
 }
 
 fn void HashMap.put_all_for_create(&map, HashMap* other_map) @private
 {
 	if (!other_map.count) return;
-    foreach (Entry *e : other_map.table)
-    {
-        if (!e) continue;
-        map.put_for_create(e.key, e.value);
-    }
+	foreach (Entry *e : other_map.table)
+	{
+		if (!e) continue;
+		map.put_for_create(e.key, e.value);
+	}
 }
 
 fn void HashMap.put_for_create(&map, Key key, Value value) @private
 {
-    uint hash = rehash(key.hash());
-    uint i = index_for(hash, map.table.len);
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
 	for (Entry *e = map.table[i]; e != null; e = e.next)
 	{
 		if (e.hash == hash && equals(key, e.key))

lib/std/collections/priorityqueue.c3

@@ -38,12 +38,12 @@ struct PrivatePriorityQueue
 
 fn void PrivatePriorityQueue.init(&self, usz initial_capacity = 16, Allocator* using = mem::heap()) @inline
 {
-    self.heap.init(initial_capacity, using);
+	self.heap.init(initial_capacity, using);
 }
 
 fn void PrivatePriorityQueue.tinit(&self, usz initial_capacity = 16) @inline
 {
-    self.init(initial_capacity, mem::temp());
+	self.init(initial_capacity, mem::temp());
 }
 
 fn void PrivatePriorityQueue.push(&self, Type element)
@@ -56,13 +56,13 @@ fn void PrivatePriorityQueue.push(&self, Type element)
 		Type item = self.heap[i];
 		Type parent_item = self.heap[parent];
 		$if MAX:
-		    bool ok = greater(item, parent_item);
+			bool ok = greater(item, parent_item);
 		$else
-		    bool ok = less(item, parent_item);
+			bool ok = less(item, parent_item);
 		$endif
 		if (!ok) break;
-        self.heap.swap(i, parent);
-        i = parent;
+		self.heap.swap(i, parent);
+		i = parent;
 	}
 }
 
@@ -79,26 +79,26 @@ fn Type! PrivatePriorityQueue.pop(&self)
 	while ((2 * i + 1) < newCount)
 	{
 		usz j = 2 * i + 1;
-        Type itemj = self.heap[j];
+		Type itemj = self.heap[j];
 		if ((j + 1) < newCount)
 		{
-		    Type nextj = self.heap[j + 1];
-		    $if MAX:
-                bool ok = greater(nextj, itemj);
-            $else
-                bool ok = less(nextj, itemj);
-            $endif
-            if (ok) j++;
+			Type nextj = self.heap[j + 1];
+			$if MAX:
+				bool ok = greater(nextj, itemj);
+			$else
+				bool ok = less(nextj, itemj);
+			$endif
+			if (ok) j++;
 		}
 		Type item = self.heap[i];
-        $if MAX:
-            bool ok = less(item, itemj);
-        $else
-            bool ok = greater(item, itemj);
-        $endif
-        if (!ok) break;
-        self.heap.swap(i, j);
-        i = j;
+		$if MAX:
+			bool ok = less(item, itemj);
+		$else
+			bool ok = greater(item, itemj);
+		$endif
+		if (!ok) break;
+		self.heap.swap(i, j);
+		i = j;
 	}
 
 	return self.heap.pop();

lib/std/collections/range.c3

@@ -26,7 +26,7 @@ fn bool Range.contains(&self, Type value) @inline
  **/
 fn Type Range.get(&self, usz index) @operator([])
 {
-    return self.start + (Type)index;
+	return self.start + (Type)index;
 }
 
 fn String Range.to_string(&self, Allocator* using = mem::heap()) @dynamic
@@ -71,5 +71,5 @@ fn String ExclusiveRange.to_string(&self, Allocator* using = mem::heap()) @dynam
  **/
 fn Type ExclusiveRange.get(&self, usz index) @operator([])
 {
-    return self.start + (Type)index;
+	return self.start + (Type)index;
 }