Switch from using dollar signs as namespace delimiters to using 々, ヽ, andunicode-identifiers

〇.

1 files changed, 58 insertions, 58 deletions

diff --git a/src/stdlib/lists.h b/src/stdlib/lists.h
index a2853e48..95ff8966 100644
--- a/src/stdlib/lists.h
+++ b/src/stdlib/lists.h
@@ -25,13 +25,13 @@
     if (unlikely(off < 0 || off >= list->length)) \
         fail_source(__SOURCE_FILE__, start, end, "Invalid list index: ", index, " (list has length ", (int64_t)list->length, ")\n"); \
     if (list->data_refcount > 0) \
-        List$compact(list, sizeof(item_type)); \
+        Listヽcompact(list, sizeof(item_type)); \
     (item_type*)(list->data + list->stride * off); })
 #define List_lvalue_unchecked(item_type, arr_expr, index_expr) *({ \
     List_t *list = arr_expr; int64_t index = index_expr; \
     int64_t off = index + (index < 0) * (list->length + 1) - 1; \
     if (list->data_refcount > 0) \
-        List$compact(list, sizeof(item_type)); \
+        Listヽcompact(list, sizeof(item_type)); \
     (item_type*)(list->data + list->stride * off); })
 #define List_set(item_type, list, index, value, start, end) \
     List_lvalue(item_type, arr_expr, index, start, end) = value
@@ -59,79 +59,79 @@
 #define LIST_DECREF(list) (list).data_refcount -= ((list).data_refcount < LIST_MAX_DATA_REFCOUNT)
 #define LIST_COPY(list) ({ LIST_INCREF(list); list; })
 
-#define List$insert_value(list, item_expr, index, padded_item_size) List$insert(list, (__typeof(item_expr)[1]){item_expr}, index, padded_item_size)
-void List$insert(List_t *list, const void *item, Int_t index, int64_t padded_item_size);
-void List$insert_all(List_t *list, List_t to_insert, Int_t index, int64_t padded_item_size);
-void List$remove_at(List_t *list, Int_t index, Int_t count, int64_t padded_item_size);
-void List$remove_item(List_t *list, void *item, Int_t max_removals, const TypeInfo_t *type);
-#define List$remove_item_value(list, item_expr, max, type) List$remove_item(list, (__typeof(item_expr)[1]){item_expr}, max, type)
+#define Listヽinsert_value(list, item_expr, index, padded_item_size) Listヽinsert(list, (__typeof(item_expr)[1]){item_expr}, index, padded_item_size)
+void Listヽinsert(List_t *list, const void *item, Int_t index, int64_t padded_item_size);
+void Listヽinsert_all(List_t *list, List_t to_insert, Int_t index, int64_t padded_item_size);
+void Listヽremove_at(List_t *list, Int_t index, Int_t count, int64_t padded_item_size);
+void Listヽremove_item(List_t *list, void *item, Int_t max_removals, const TypeInfo_t *type);
+#define Listヽremove_item_value(list, item_expr, max, type) Listヽremove_item(list, (__typeof(item_expr)[1]){item_expr}, max, type)
 
-#define List$pop(arr_expr, index_expr, item_type, nonnone_var, nonnone_expr, none_expr) ({ \
+#define Listヽpop(arr_expr, index_expr, item_type, nonnone_var, nonnone_expr, none_expr) ({ \
     List_t *list = arr_expr; \
     Int_t index = index_expr; \
-    int64_t index64 = Int64$from_int(index, false); \
+    int64_t index64 = Int64ヽfrom_int(index, false); \
     int64_t off = index64 + (index64 < 0) * (list->length + 1) - 1; \
     (off >= 0 && off < list->length) ? ({ \
         item_type nonnone_var = *(item_type*)(list->data + off*list->stride); \
-        List$remove_at(list, index, I_small(1), sizeof(item_type)); \
+        Listヽremove_at(list, index, I_small(1), sizeof(item_type)); \
         nonnone_expr; \
     }) : none_expr; })
 
-OptionalInt_t List$find(List_t list, void *item, const TypeInfo_t *type);
-#define List$find_value(list, item_expr, type) ({ __typeof(item_expr) item = item_expr; List$find(list, &item, type); })
-OptionalInt_t List$first(List_t list, Closure_t predicate);
-void List$sort(List_t *list, Closure_t comparison, int64_t padded_item_size);
-List_t List$sorted(List_t list, Closure_t comparison, int64_t padded_item_size);
-void List$shuffle(List_t *list, OptionalClosure_t random_int64, int64_t padded_item_size);
-List_t List$shuffled(List_t list, OptionalClosure_t random_int64, int64_t padded_item_size);
-void *List$random(List_t list, OptionalClosure_t random_int64);
-#define List$random_value(list, random_int64, t) ({ List_t _arr = list; if (_arr.length == 0) fail("Cannot get a random value from an empty list!"); *(t*)List$random(_arr, random_int64); })
-List_t List$sample(List_t list, Int_t n, List_t weights, Closure_t random_num, int64_t padded_item_size);
-Table_t List$counts(List_t list, const TypeInfo_t *type);
-void List$clear(List_t *list);
-void List$compact(List_t *list, int64_t padded_item_size);
-PUREFUNC bool List$has(List_t list, void *item, const TypeInfo_t *type);
-#define List$has_value(list, item_expr, type) ({ __typeof(item_expr) item = item_expr; List$has(list, &item, type); })
-PUREFUNC List_t List$from(List_t list, Int_t first);
-PUREFUNC List_t List$to(List_t list, Int_t last);
-PUREFUNC List_t List$by(List_t list, Int_t stride, int64_t padded_item_size);
-PUREFUNC List_t List$slice(List_t list, Int_t int_first, Int_t int_last);
-PUREFUNC List_t List$reversed(List_t list, int64_t padded_item_size);
-List_t List$concat(List_t x, List_t y, int64_t padded_item_size);
-PUREFUNC uint64_t List$hash(const void *list, const TypeInfo_t *type);
-PUREFUNC int32_t List$compare(const void *x, const void *y, const TypeInfo_t *type);
-PUREFUNC bool List$equal(const void *x, const void *y, const TypeInfo_t *type);
-PUREFUNC bool List$is_none(const void *obj, const TypeInfo_t*);
-Text_t List$as_text(const void *list, bool colorize, const TypeInfo_t *type);
-void List$heapify(List_t *heap, Closure_t comparison, int64_t padded_item_size);
-void List$heap_push(List_t *heap, const void *item, Closure_t comparison, int64_t padded_item_size);
-#define List$heap_push_value(heap, _value, comparison, padded_item_size) ({ __typeof(_value) value = _value; List$heap_push(heap, &value, comparison, padded_item_size); })
-void List$heap_pop(List_t *heap, Closure_t comparison, int64_t padded_item_size);
-#define List$heap_pop_value(heap, comparison, type, nonnone_var, nonnone_expr, none_expr) \
+OptionalInt_t Listヽfind(List_t list, void *item, const TypeInfo_t *type);
+#define Listヽfind_value(list, item_expr, type) ({ __typeof(item_expr) item = item_expr; Listヽfind(list, &item, type); })
+OptionalInt_t Listヽfirst(List_t list, Closure_t predicate);
+void Listヽsort(List_t *list, Closure_t comparison, int64_t padded_item_size);
+List_t Listヽsorted(List_t list, Closure_t comparison, int64_t padded_item_size);
+void Listヽshuffle(List_t *list, OptionalClosure_t random_int64, int64_t padded_item_size);
+List_t Listヽshuffled(List_t list, OptionalClosure_t random_int64, int64_t padded_item_size);
+void *Listヽrandom(List_t list, OptionalClosure_t random_int64);
+#define Listヽrandom_value(list, random_int64, t) ({ List_t _arr = list; if (_arr.length == 0) fail("Cannot get a random value from an empty list!"); *(t*)Listヽrandom(_arr, random_int64); })
+List_t Listヽsample(List_t list, Int_t n, List_t weights, Closure_t random_num, int64_t padded_item_size);
+Table_t Listヽcounts(List_t list, const TypeInfo_t *type);
+void Listヽclear(List_t *list);
+void Listヽcompact(List_t *list, int64_t padded_item_size);
+PUREFUNC bool Listヽhas(List_t list, void *item, const TypeInfo_t *type);
+#define Listヽhas_value(list, item_expr, type) ({ __typeof(item_expr) item = item_expr; Listヽhas(list, &item, type); })
+PUREFUNC List_t Listヽfrom(List_t list, Int_t first);
+PUREFUNC List_t Listヽto(List_t list, Int_t last);
+PUREFUNC List_t Listヽby(List_t list, Int_t stride, int64_t padded_item_size);
+PUREFUNC List_t Listヽslice(List_t list, Int_t int_first, Int_t int_last);
+PUREFUNC List_t Listヽreversed(List_t list, int64_t padded_item_size);
+List_t Listヽconcat(List_t x, List_t y, int64_t padded_item_size);
+PUREFUNC uint64_t Listヽhash(const void *list, const TypeInfo_t *type);
+PUREFUNC int32_t Listヽcompare(const void *x, const void *y, const TypeInfo_t *type);
+PUREFUNC bool Listヽequal(const void *x, const void *y, const TypeInfo_t *type);
+PUREFUNC bool Listヽis_none(const void *obj, const TypeInfo_t*);
+Text_t Listヽas_text(const void *list, bool colorize, const TypeInfo_t *type);
+void Listヽheapify(List_t *heap, Closure_t comparison, int64_t padded_item_size);
+void Listヽheap_push(List_t *heap, const void *item, Closure_t comparison, int64_t padded_item_size);
+#define Listヽheap_push_value(heap, _value, comparison, padded_item_size) ({ __typeof(_value) value = _value; Listヽheap_push(heap, &value, comparison, padded_item_size); })
+void Listヽheap_pop(List_t *heap, Closure_t comparison, int64_t padded_item_size);
+#define Listヽheap_pop_value(heap, comparison, type, nonnone_var, nonnone_expr, none_expr) \
     ({ List_t *_heap = heap; \
      (_heap->length > 0) ? ({ \
          type nonnone_var = *(type*)_heap->data; \
-         List$heap_pop(_heap, comparison, sizeof(type)); \
+         Listヽheap_pop(_heap, comparison, sizeof(type)); \
          nonnone_expr; \
      }) : none_expr; })
-Int_t List$binary_search(List_t list, void *target, Closure_t comparison);
-#define List$binary_search_value(list, target, comparison) \
-    ({ __typeof(target) _target = target; List$binary_search(list, &_target, comparison); })
-void List$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type);
-void List$deserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type);
+Int_t Listヽbinary_search(List_t list, void *target, Closure_t comparison);
+#define Listヽbinary_search_value(list, target, comparison) \
+    ({ __typeof(target) _target = target; Listヽbinary_search(list, &_target, comparison); })
+void Listヽserialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type);
+void Listヽdeserialize(FILE *in, void *obj, List_t *pointers, const TypeInfo_t *type);
 
-#define List$metamethods { \
-    .as_text=List$as_text, \
-    .compare=List$compare, \
-    .equal=List$equal, \
-    .hash=List$hash, \
-    .is_none=List$is_none, \
-    .serialize=List$serialize, \
-    .deserialize=List$deserialize, \
+#define Listヽmetamethods { \
+    .as_text=Listヽas_text, \
+    .compare=Listヽcompare, \
+    .equal=Listヽequal, \
+    .hash=Listヽhash, \
+    .is_none=Listヽis_none, \
+    .serialize=Listヽserialize, \
+    .deserialize=Listヽdeserialize, \
 }
 
-#define List$info(item_info) &((TypeInfo_t){.size=sizeof(List_t), .align=__alignof__(List_t), \
+#define Listヽinfo(item_info) &((TypeInfo_t){.size=sizeof(List_t), .align=__alignof__(List_t), \
                                 .tag=ListInfo, .ListInfo.item=item_info, \
-                                .metamethods=List$metamethods})
+                                .metamethods=Listヽmetamethods})
 
 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0