renormalize line endings

src/base/base_entry_point.c

@@ -191,7 +191,7 @@ async_thread_entry_point(void *params)
   {
     MutexScope(async_tick_start_mutex) cond_var_wait(async_tick_start_cond_var, async_tick_start_mutex, os_now_microseconds()+100000);
 #if defined(FILE_STREAM_H)
-    fs_async_tick();
+    fs_tick();
 #endif
     cond_var_broadcast(async_tick_stop_cond_var);
   }

src/base/base_strings.c

@@ -397,7 +397,7 @@ str8_is_before(String8 a, String8 b)
 //~ rjf: String Slicing
 
 internal String8
-str8_substr(String8 str, Rng1U64 range)
+str8_substr(String8 str, Rng1U64 range)
 {
   range.min = ClampTop(range.min, str.size);
   range.max = ClampTop(range.max, str.size);
@@ -407,14 +407,14 @@ str8_substr(String8 str, Rng1U64 range)
 }
 
 internal String8
-str8_prefix(String8 str, U64 size)
+str8_prefix(String8 str, U64 size)
 {
   str.size = ClampTop(size, str.size);
   return str;
 }
 
 internal String8
-str8_skip(String8 str, U64 amt)
+str8_skip(String8 str, U64 amt)
 {
   amt = ClampTop(amt, str.size);
   str.str += amt;
@@ -423,7 +423,7 @@ str8_skip(String8 str, U64 amt)
 }
 
 internal String8
-str8_postfix(String8 str, U64 size)
+str8_postfix(String8 str, U64 size)
 {
   size = ClampTop(size, str.size);
   str.str = (str.str + str.size) - size;
@@ -432,7 +432,7 @@ str8_postfix(String8 str, U64 size)
 }
 
 internal String8
-str8_chop(String8 str, U64 amt)
+str8_chop(String8 str, U64 amt)
 {
   amt = ClampTop(amt, str.size);
   str.size -= amt;
@@ -555,12 +555,12 @@ push_cstr(Arena *arena, String8 str)
 //- rjf: string -> integer
 
 internal S64
-sign_from_str8(String8 string, String8 *string_tail)
+sign_from_str8(String8 string, String8 *string_tail)
 {
   // count negative signs
   U64 neg_count = 0;
   U64 i = 0;
-  for(; i < string.size; i += 1)
+  for(; i < string.size; i += 1)
   {
     if (string.str[i] == '-'){
       neg_count += 1;
@@ -579,18 +579,18 @@ sign_from_str8(String8 string, String8 *string_tail)
 }
 
 internal B32
-str8_is_integer(String8 string, U32 radix)
+str8_is_integer(String8 string, U32 radix)
 {
   B32 result = 0;
-  if(string.size > 0)
+  if(string.size > 0)
   {
-    if(1 < radix && radix <= 16)
+    if(1 < radix && radix <= 16)
     {
       result = 1;
-      for(U64 i = 0; i < string.size; i += 1)
+      for(U64 i = 0; i < string.size; i += 1)
       {
         U8 c = string.str[i];
-        if(!(c < 0x80) || integer_symbol_reverse[c] >= radix)
+        if(!(c < 0x80) || integer_symbol_reverse[c] >= radix)
         {
           result = 0;
           break;
@@ -602,12 +602,12 @@ str8_is_integer(String8 string, U32 radix)
 }
 
 internal U64
-u64_from_str8(String8 string, U32 radix)
+u64_from_str8(String8 string, U32 radix)
 {
   U64 x = 0;
-  if(1 < radix && radix <= 16)
+  if(1 < radix && radix <= 16)
   {
-    for(U64 i = 0; i < string.size; i += 1)
+    for(U64 i = 0; i < string.size; i += 1)
     {
       x *= radix;
       x += integer_symbol_reverse[string.str[i]&0x7F];
@@ -617,7 +617,7 @@ u64_from_str8(String8 string, U32 radix)
 }
 
 internal S64
-s64_from_str8(String8 string, U32 radix)
+s64_from_str8(String8 string, U32 radix)
 {
   S64 sign = sign_from_str8(string, &string);
   S64 x = (S64)u64_from_str8(string, radix) * sign;
@@ -642,11 +642,11 @@ s32_from_str8(String8 string, U32 radix)
 
 internal B32
 try_u64_from_str8_c_rules(String8 string, U64 *x)
-{
+{
-  // rjf: unpack radix / prefix size based on string prefix
+  // rjf: unpack radix / prefix size based on string prefix
-  U64 radix = 0;
+  U64 radix = 0;
-  U64 prefix_size = 0;
+  U64 prefix_size = 0;
-  {
+  {
     // hex
     if(str8_match(str8_prefix(string, 2), str8_lit("0x"), StringMatchFlag_CaseInsensitive))
     {
@@ -667,16 +667,16 @@ try_u64_from_str8_c_rules(String8 string, U64 *x)
     {
       radix = 10, prefix_size = 0;
     }
-  }
+  }
-  
+  
-  // rjf: convert if we can
+  // rjf: convert if we can
   String8 integer    = str8_skip(string, prefix_size);
   B32     is_integer = str8_is_integer(integer, radix);
   if(is_integer)
   {
     *x = u64_from_str8(integer, radix);
-  }
+  }
-  
+  
   return is_integer;
 }
 
@@ -696,8 +696,8 @@ try_s64_from_str8_c_rules(String8 string, S64 *x)
 internal String8
 str8_from_memory_size(Arena *arena, U64 size)
 {
-  String8 result = {0};
+  String8 result = {0};
-  {
+  {
     if(size < KB(1))
     {
       result = push_str8f(arena, "%llu Bytes", size);
@@ -717,8 +717,8 @@ str8_from_memory_size(Arena *arena, U64 size)
     else
     {
       result = push_str8f(arena, "%llu.%02llu TiB", size / TB(1), ((size * 100) / TB(1)) % 100);
-    }
+    }
-  }
+  }
   return result;
 }
 
@@ -973,7 +973,7 @@ f64_from_str8(String8 string)
 //~ rjf: String List Construction Functions
 
 internal String8Node *
-str8_list_push_node(String8List *list, String8Node *node)
+str8_list_push_node(String8List *list, String8Node *node)
 {
   SLLQueuePush(list->first, list->last, node);
   list->node_count += 1;
@@ -982,7 +982,7 @@ str8_list_push_node(String8List *list, String8Node *node)
 }
 
 internal String8Node *
-str8_list_push_node_set_string(String8List *list, String8Node *node, String8 string)
+str8_list_push_node_set_string(String8List *list, String8Node *node, String8 string)
 {
   SLLQueuePush(list->first, list->last, node);
   list->node_count += 1;
@@ -992,7 +992,7 @@ str8_list_push_node_set_string(String8List *list, String8Node *node, String8 str
 }
 
 internal String8Node *
-str8_list_push_node_front(String8List *list, String8Node *node)
+str8_list_push_node_front(String8List *list, String8Node *node)
 {
   SLLQueuePushFront(list->first, list->last, node);
   list->node_count += 1;
@@ -1001,7 +1001,7 @@ str8_list_push_node_front(String8List *list, String8Node *node)
 }
 
 internal String8Node *
-str8_list_push_node_front_set_string(String8List *list, String8Node *node, String8 string)
+str8_list_push_node_front_set_string(String8List *list, String8Node *node, String8 string)
 {
   SLLQueuePushFront(list->first, list->last, node);
   list->node_count += 1;
@@ -1011,7 +1011,7 @@ str8_list_push_node_front_set_string(String8List *list, String8Node *node, Strin
 }
 
 internal String8Node *
-str8_list_push(Arena *arena, String8List *list, String8 string)
+str8_list_push(Arena *arena, String8List *list, String8 string)
 {
   String8Node *node = push_array_no_zero(arena, String8Node, 1);
   str8_list_push_node_set_string(list, node, string);
@@ -1019,7 +1019,7 @@ str8_list_push(Arena *arena, String8List *list, String8 string)
 }
 
 internal String8Node *
-str8_list_push_front(Arena *arena, String8List *list, String8 string)
+str8_list_push_front(Arena *arena, String8List *list, String8 string)
 {
   String8Node *node = push_array_no_zero(arena, String8Node, 1);
   str8_list_push_node_front_set_string(list, node, string);
@@ -1027,18 +1027,18 @@ str8_list_push_front(Arena *arena, String8List *list, String8 string)
 }
 
 internal void
-str8_list_concat_in_place(String8List *list, String8List *to_push)
+str8_list_concat_in_place(String8List *list, String8List *to_push)
 {
-  if(to_push->node_count != 0)
+  if(to_push->node_count != 0)
   {
-    if(list->last)
+    if(list->last)
     {
       list->node_count += to_push->node_count;
       list->total_size += to_push->total_size;
       list->last->next = to_push->first;
       list->last = to_push->last;
     }
-    else
+    else
     {
       *list = *to_push;
     }
@@ -1070,7 +1070,7 @@ str8_list_push_aligner(Arena *arena, String8List *list, U64 min, U64 align){
 }
 
 internal String8Node*
-str8_list_pushf(Arena *arena, String8List *list, char *fmt, ...)
+str8_list_pushf(Arena *arena, String8List *list, char *fmt, ...)
 {
   va_list args;
   va_start(args, fmt);
@@ -1081,7 +1081,7 @@ str8_list_pushf(Arena *arena, String8List *list, char *fmt, ...)
 }
 
 internal String8Node*
-str8_list_push_frontf(Arena *arena, String8List *list, char *fmt, ...)
+str8_list_push_frontf(Arena *arena, String8List *list, char *fmt, ...)
 {
   va_list args;
   va_start(args, fmt);
@@ -1092,10 +1092,10 @@ str8_list_push_frontf(Arena *arena, String8List *list, char *fmt, ...)
 }
 
 internal String8List
-str8_list_copy(Arena *arena, String8List *list)
+str8_list_copy(Arena *arena, String8List *list)
 {
   String8List result = {0};
-  for(String8Node *node = list->first; node != 0; node = node->next)
+  for(String8Node *node = list->first; node != 0; node = node->next)
   {
     String8Node *new_node = push_array_no_zero(arena, String8Node, 1);
     String8 new_string = push_str8_copy(arena, node->string);
@@ -1108,34 +1108,34 @@ str8_list_copy(Arena *arena, String8List *list)
 //~ rjf: String Splitting & Joining
 
 internal String8List
-str8_split(Arena *arena, String8 string, U8 *split_chars, U64 split_char_count, StringSplitFlags flags)
+str8_split(Arena *arena, String8 string, U8 *split_chars, U64 split_char_count, StringSplitFlags flags)
 {
   String8List list = {0};
   B32 keep_empties = (flags & StringSplitFlag_KeepEmpties);
   U8 *ptr = string.str;
   U8 *opl = string.str + string.size;
-  for(;ptr < opl;)
+  for(;ptr < opl;)
   {
     U8 *first = ptr;
-    for(;ptr < opl; ptr += 1)
+    for(;ptr < opl; ptr += 1)
     {
       U8 c = *ptr;
       B32 is_split = 0;
-      for(U64 i = 0; i < split_char_count; i += 1)
+      for(U64 i = 0; i < split_char_count; i += 1)
       {
-        if(split_chars[i] == c)
+        if(split_chars[i] == c)
         {
           is_split = 1;
           break;
         }
       }
-      if(is_split)
+      if(is_split)
       {
         break;
       }
     }
     String8 string = str8_range(first, ptr);
-    if(keep_empties || string.size > 0)
+    if(keep_empties || string.size > 0)
     {
       str8_list_push(arena, &list, string);
     }
@@ -1145,22 +1145,22 @@ str8_split(Arena *arena, String8 string, U8 *split_chars, U64 split_char_count,
 }
 
 internal String8List
-str8_split_by_string_chars(Arena *arena, String8 string, String8 split_chars, StringSplitFlags flags)
+str8_split_by_string_chars(Arena *arena, String8 string, String8 split_chars, StringSplitFlags flags)
 {
   String8List list = str8_split(arena, string, split_chars.str, split_chars.size, flags);
   return list;
 }
 
 internal String8
-str8_list_join(Arena *arena, String8List *list, StringJoin *optional_params)
+str8_list_join(Arena *arena, String8List *list, StringJoin *optional_params)
 {
   StringJoin join = {0};
-  if(optional_params != 0)
+  if(optional_params != 0)
   {
     MemoryCopyStruct(&join, optional_params);
   }
   U64 sep_count = 0;
-  if(list->node_count > 0)
+  if(list->node_count > 0)
   {
     sep_count = list->node_count - 1;
   }
@@ -1171,11 +1171,11 @@ str8_list_join(Arena *arena, String8List *list, StringJoin *optional_params)
   ptr += join.pre.size;
   for(String8Node *node = list->first;
       node != 0;
-      node = node->next)
+      node = node->next)
   {
     MemoryCopy(ptr, node->string.str, node->string.size);
     ptr += node->string.size;
-    if(node->next != 0)
+    if(node->next != 0)
     {
       MemoryCopy(ptr, join.sep.str, join.sep.size);
       ptr += join.sep.size;
@@ -1218,7 +1218,7 @@ internal String8Array
 str8_array_from_list(Arena *arena, String8List *list)
 {
   String8Array array;
-  array.count   = list->node_count;
+  array.count   = list->node_count;
   array.v = push_array_no_zero(arena, String8, array.count);
   U64 idx = 0;
   for(String8Node *n = list->first; n != 0; n = n->next, idx += 1)
@@ -1410,13 +1410,13 @@ str8_split_path(Arena *arena, String8 string)
 internal void
 str8_path_list_resolve_dots_in_place(String8List *path, PathStyle style)
 {
-  Temp scratch = scratch_begin(0, 0);
+  Temp scratch = scratch_begin(0, 0);
   typedef struct String8MetaNode String8MetaNode;
   struct String8MetaNode
   {
     String8MetaNode *next;
     String8Node *node;
-  };
+  };
   String8MetaNode *stack = 0;
   String8MetaNode *free_meta_node = 0;
   String8Node *first = path->first;
@@ -1796,13 +1796,13 @@ path_replace_file_extension(Arena *arena, String8 file_name, String8 ext)
 ////////////////////////////////
 //~ rjf: UTF-8 & UTF-16 Decoding/Encoding
 
-read_only global U8 utf8_class[32] =
+read_only global U8 utf8_class[32] =
 {
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,2,2,2,2,3,3,4,5,
 };
 
 internal UnicodeDecode
-utf8_decode(U8 *str, U64 max)
+utf8_decode(U8 *str, U64 max)
 {
   UnicodeDecode result = {1, max_U32};
   U8 byte = str[0];
@@ -1863,12 +1863,12 @@ utf8_decode(U8 *str, U64 max)
 }
 
 internal UnicodeDecode
-utf16_decode(U16 *str, U64 max)
+utf16_decode(U16 *str, U64 max)
 {
   UnicodeDecode result = {1, max_U32};
   result.codepoint = str[0];
   result.inc = 1;
-  if(max > 1 && 0xD800 <= str[0] && str[0] < 0xDC00 && 0xDC00 <= str[1] && str[1] < 0xE000)
+  if(max > 1 && 0xD800 <= str[0] && str[0] < 0xDC00 && 0xDC00 <= str[1] && str[1] < 0xE000)
   {
     result.codepoint = ((str[0] - 0xD800) << 10) | ((str[1] - 0xDC00) + 0x10000);
     result.inc = 2;
@@ -1877,28 +1877,28 @@ utf16_decode(U16 *str, U64 max)
 }
 
 internal U32
-utf8_encode(U8 *str, U32 codepoint)
+utf8_encode(U8 *str, U32 codepoint)
 {
   U32 inc = 0;
-  if(codepoint <= 0x7F)
+  if(codepoint <= 0x7F)
   {
     str[0] = (U8)codepoint;
     inc = 1;
   }
-  else if(codepoint <= 0x7FF)
+  else if(codepoint <= 0x7FF)
   {
     str[0] = (bitmask2 << 6) | ((codepoint >> 6) & bitmask5);
     str[1] = bit8 | (codepoint & bitmask6);
     inc = 2;
   }
-  else if(codepoint <= 0xFFFF)
+  else if(codepoint <= 0xFFFF)
   {
     str[0] = (bitmask3 << 5) | ((codepoint >> 12) & bitmask4);
     str[1] = bit8 | ((codepoint >> 6) & bitmask6);
     str[2] = bit8 | ( codepoint       & bitmask6);
     inc = 3;
   }
-  else if(codepoint <= 0x10FFFF)
+  else if(codepoint <= 0x10FFFF)
   {
     str[0] = (bitmask4 << 4) | ((codepoint >> 18) & bitmask3);
     str[1] = bit8 | ((codepoint >> 12) & bitmask6);
@@ -1906,7 +1906,7 @@ utf8_encode(U8 *str, U32 codepoint)
     str[3] = bit8 | ( codepoint        & bitmask6);
     inc = 4;
   }
-  else
+  else
   {
     str[0] = '?';
     inc = 1;
@@ -1915,18 +1915,18 @@ utf8_encode(U8 *str, U32 codepoint)
 }
 
 internal U32
-utf16_encode(U16 *str, U32 codepoint)
+utf16_encode(U16 *str, U32 codepoint)
 {
   U32 inc = 1;
-  if(codepoint == max_U32)
+  if(codepoint == max_U32)
   {
     str[0] = (U16)'?';
   }
-  else if(codepoint < 0x10000)
+  else if(codepoint < 0x10000)
   {
     str[0] = (U16)codepoint;
   }
-  else
+  else
   {
     U32 v = codepoint - 0x10000;
     str[0] = safe_cast_u16(0xD800 + (v >> 10));
@@ -2053,7 +2053,7 @@ StaticAssert(ArrayCount(g_os_enum_map) == OperatingSystem_COUNT, g_os_enum_map_c
 internal OperatingSystem
 operating_system_from_string(String8 string)
 {
-  for EachElement(idx, g_os_enum_map)
+  for EachElement(idx, g_os_enum_map)
   {
     if(str8_match(g_os_enum_map[idx].string, string, StringMatchFlag_CaseInsensitive))
     {
@@ -2064,9 +2064,9 @@ operating_system_from_string(String8 string)
 }
 
 internal String8
-string_from_dimension(Dimension dimension)
+string_from_dimension(Dimension dimension)
 {
-  read_only local_persist String8 strings[] =
+  read_only local_persist String8 strings[] =
   {
     str8_lit_comp("X"),
     str8_lit_comp("Y"),
@@ -2074,7 +2074,7 @@ string_from_dimension(Dimension dimension)
     str8_lit_comp("W"),
   };
   String8 result = str8_lit("error");
-  if((U32)dimension < 4)
+  if((U32)dimension < 4)
   {
     result = strings[dimension];
   }
@@ -2082,15 +2082,15 @@ string_from_dimension(Dimension dimension)
 }
 
 internal String8
-string_from_side(Side side)
+string_from_side(Side side)
 {
-  local_persist String8 strings[] =
+  local_persist String8 strings[] =
   {
     str8_lit_comp("Min"),
     str8_lit_comp("Max"),
   };
   String8 result = str8_lit("error");
-  if((U32)side < 2)
+  if((U32)side < 2)
   {
     result = strings[side];
   }
@@ -2109,26 +2109,26 @@ string_from_operating_system(OperatingSystem os)
 }
 
 internal String8
-string_from_arch(Arch arch)
+string_from_arch(Arch arch)
-{
+{
-  String8 result = {0};
+  String8 result = {0};
-  switch(arch)
+  switch(arch)
-  {
+  {
-    case Arch_Null:  {result = str8_lit("Null");}break;
+    case Arch_Null:  {result = str8_lit("Null");}break;
-    case Arch_x64:   {result = str8_lit("x64");}break;
+    case Arch_x64:   {result = str8_lit("x64");}break;
-    case Arch_x86:   {result = str8_lit("x86");}break;
+    case Arch_x86:   {result = str8_lit("x86");}break;
-    case Arch_arm64: {result = str8_lit("arm64");}break;
+    case Arch_arm64: {result = str8_lit("arm64");}break;
-    case Arch_arm32: {result = str8_lit("arm32");}break;
+    case Arch_arm32: {result = str8_lit("arm32");}break;
-    case Arch_COUNT:
+    case Arch_COUNT:
-    {result = str8_lit("Invalid");}break;
+    {result = str8_lit("Invalid");}break;
-  }
+  }
   return result;
 }
 
 internal String8
-string_from_week_day(WeekDay week_day)
+string_from_week_day(WeekDay week_day)
 {
-  read_only local_persist String8 strings[] =
+  read_only local_persist String8 strings[] =
   {
     str8_lit_comp("Sun"),
     str8_lit_comp("Mon"),
@@ -2139,7 +2139,7 @@ string_from_week_day(WeekDay week_day)
     str8_lit_comp("Sat"),
   };
   String8 result = str8_lit("Err");
-  if((U32)week_day < WeekDay_COUNT)
+  if((U32)week_day < WeekDay_COUNT)
   {
     result = strings[week_day];
   }
@@ -2147,9 +2147,9 @@ string_from_week_day(WeekDay week_day)
 }
 
 internal String8
-string_from_month(Month month)
+string_from_month(Month month)
 {
-  read_only local_persist String8 strings[] =
+  read_only local_persist String8 strings[] =
   {
     str8_lit_comp("Jan"),
     str8_lit_comp("Feb"),
@@ -2165,7 +2165,7 @@ string_from_month(Month month)
     str8_lit_comp("Dec"),
   };
   String8 result = str8_lit("Err");
-  if((U32)month < Month_COUNT)
+  if((U32)month < Month_COUNT)
   {
     result = strings[month];
   }
@@ -2173,16 +2173,16 @@ string_from_month(Month month)
 }
 
 internal String8
-string_from_date_time(Arena *arena, DateTime *date_time)
+string_from_date_time(Arena *arena, DateTime *date_time)
 {
   char *mon_str = (char*)string_from_month(date_time->month).str;
   U32 adjusted_hour = date_time->hour%12;
-  if(adjusted_hour == 0)
+  if(adjusted_hour == 0)
   {
     adjusted_hour = 12;
   }
   char *ampm = "am";
-  if(date_time->hour >= 12)
+  if(date_time->hour >= 12)
   {
     ampm = "pm";
   }
@@ -2193,7 +2193,7 @@ string_from_date_time(Arena *arena, DateTime *date_time)
 }
 
 internal String8
-string_from_date_time__file_name(Arena *arena, DateTime *date_time)
+string_from_date_time__file_name(Arena *arena, DateTime *date_time)
 {
   char *mon_str = (char*)string_from_month(date_time->month).str;
   String8 result = str8f(arena, "%d-%s-%0d--%02d-%02d-%02d",
@@ -2203,22 +2203,22 @@ string_from_date_time__file_name(Arena *arena, DateTime *date_time)
 }
 
 internal String8
-string_from_elapsed_time(Arena *arena, DateTime dt)
+string_from_elapsed_time(Arena *arena, DateTime dt)
 {
   Temp scratch = scratch_begin(&arena, 1);
   String8List list = {0};
-  if(dt.year)
+  if(dt.year)
   {
     str8_list_pushf(scratch.arena, &list, "%dy", dt.year);
     str8_list_pushf(scratch.arena, &list, "%um", dt.mon);
     str8_list_pushf(scratch.arena, &list, "%ud", dt.day);
-  }
+  }
-  else if(dt.mon)
+  else if(dt.mon)
   {
     str8_list_pushf(scratch.arena, &list, "%um", dt.mon);
     str8_list_pushf(scratch.arena, &list, "%ud", dt.day);
-  }
+  }
-  else if (dt.day)
+  else if (dt.day)
   {
     str8_list_pushf(scratch.arena, &list, "%ud", dt.day);
   }
@@ -2850,7 +2850,7 @@ str8_compar(String8 a, String8 b, B32 ignore_case)
   return cmp;
 }
 
-internal int
+internal int str8_compar_ignore_case(const void *a, const void *b)
 {
   return str8_compar(*(String8*)a, *(String8*)b, 1);
 }

src/file_stream/file_stream.c

@@ -241,10 +241,10 @@ fs_properties_from_path(String8 path)
 }
 
 ////////////////////////////////
-//~ rjf: Asynchronous Tick
+//~ rjf: Tick
 
 internal void
-fs_async_tick(void)
+fs_tick(void)
 {
   Temp scratch = scratch_begin(0, 0);
   

src/file_stream/file_stream.h

@@ -122,8 +122,8 @@ internal U128 fs_hash_from_path_range(String8 path, Rng1U64 range, U64 endt_us);
 internal FileProperties fs_properties_from_path(String8 path);
 
 ////////////////////////////////
-//~ rjf: Asynchronous Tick
+//~ rjf: Tick
 
-internal void fs_async_tick(void);
+internal void fs_tick(void);
 
 #endif // FILE_STREAM_H