diff --git a/src/base/base_strings.c b/src/base/base_strings.c index 119e9e2b..d2ea3244 100644 --- a/src/base/base_strings.c +++ b/src/base/base_strings.c @@ -50,7 +50,7 @@ char_is_digit(U8 c, U32 base) } internal U8 -char_to_lower(U8 c) +lower_from_char(U8 c) { if(char_is_upper(c)) { @@ -60,7 +60,7 @@ char_to_lower(U8 c) } internal U8 -char_to_upper(U8 c) +upper_from_char(U8 c) { if(char_is_lower(c)) { @@ -70,7 +70,7 @@ char_to_upper(U8 c) } internal U8 -char_to_correct_slash(U8 c) +correct_slash_from_char(U8 c) { if(char_is_slash(c)) { @@ -242,7 +242,7 @@ upper_from_str8(Arena *arena, String8 string) string = push_str8_copy(arena, string); for(U64 idx = 0; idx < string.size; idx += 1) { - string.str[idx] = char_to_upper(string.str[idx]); + string.str[idx] = upper_from_char(string.str[idx]); } return string; } @@ -253,7 +253,7 @@ lower_from_str8(Arena *arena, String8 string) string = push_str8_copy(arena, string); for(U64 idx = 0; idx < string.size; idx += 1) { - string.str[idx] = char_to_lower(string.str[idx]); + string.str[idx] = lower_from_char(string.str[idx]); } return string; } @@ -292,13 +292,13 @@ str8_match(String8 a, String8 b, StringMatchFlags flags) U8 bt = b.str[i]; if(case_insensitive) { - at = char_to_upper(at); - bt = char_to_upper(bt); + at = upper_from_char(at); + bt = upper_from_char(bt); } if(slash_insensitive) { - at = char_to_correct_slash(at); - bt = char_to_correct_slash(bt); + at = correct_slash_from_char(at); + bt = correct_slash_from_char(bt); } if(at != bt) { @@ -324,14 +324,14 @@ str8_find_needle(String8 string, U64 start_pos, String8 needle, StringMatchFlags U8 needle_first_char_adjusted = needle.str[0]; if(adjusted_flags & StringMatchFlag_CaseInsensitive) { - needle_first_char_adjusted = char_to_upper(needle_first_char_adjusted); + needle_first_char_adjusted = upper_from_char(needle_first_char_adjusted); } for(;p < stop_p; p += 1) { U8 haystack_char_adjusted = *p; if(adjusted_flags & StringMatchFlag_CaseInsensitive) { - haystack_char_adjusted = char_to_upper(haystack_char_adjusted); + haystack_char_adjusted = upper_from_char(haystack_char_adjusted); } if(haystack_char_adjusted == needle_first_char_adjusted) { @@ -397,41 +397,46 @@ 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); str.str += range.min; str.size = dim_1u64(range); - return(str); + return str; } internal String8 -str8_prefix(String8 str, U64 size){ +str8_prefix(String8 str, U64 size) +{ str.size = ClampTop(size, str.size); - return(str); + return str; } internal String8 -str8_skip(String8 str, U64 amt){ +str8_skip(String8 str, U64 amt) +{ amt = ClampTop(amt, str.size); str.str += amt; str.size -= amt; - return(str); + return str; } 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; str.size = size; - return(str); + return str; } internal String8 -str8_chop(String8 str, U64 amt){ +str8_chop(String8 str, U64 amt) +{ amt = ClampTop(amt, str.size); str.size -= amt; - return(str); + return str; } internal String8 @@ -550,11 +555,13 @@ 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; } @@ -568,18 +575,23 @@ sign_from_str8(String8 string, String8 *string_tail){ // output integer sign S64 sign = (neg_count & 1)?-1:+1; - return(sign); + return sign; } internal B32 -str8_is_integer(String8 string, U32 radix){ +str8_is_integer(String8 string, U32 radix) +{ B32 result = 0; - if (string.size > 0){ - if (1 < radix && radix <= 16){ + if(string.size > 0) + { + 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; } @@ -590,22 +602,26 @@ 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){ - for (U64 i = 0; i < string.size; i += 1){ + if(1 < radix && radix <= 16) + { + for(U64 i = 0; i < string.size; i += 1) + { x *= radix; x += integer_symbol_reverse[string.str[i]&0x7F]; } } - return(x); + return x; } 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; - return(x); + return x; } internal U32 @@ -626,36 +642,41 @@ s32_from_str8(String8 string, U32 radix) internal B32 try_u64_from_str8_c_rules(String8 string, U64 *x) -{ - U64 radix, prefix_size; - // hex - if(str8_match(str8_prefix(string, 2), str8_lit("0x"), StringMatchFlag_CaseInsensitive)) - { - radix = 0x10, prefix_size = 2; - } - // binary - else if(str8_match(str8_prefix(string, 2), str8_lit("0b"), StringMatchFlag_CaseInsensitive)) - { - radix = 2, prefix_size = 2; - } - // octal - else if(str8_match(str8_prefix(string, 1), str8_lit("0"), StringMatchFlag_CaseInsensitive) && string.size > 1) - { - radix = 010, prefix_size = 1; - } - // decimal - else - { - radix = 10, prefix_size = 0; - } - +{ + // rjf: unpack radix / prefix size based on string prefix + U64 radix = 0; + U64 prefix_size = 0; + { + // hex + if(str8_match(str8_prefix(string, 2), str8_lit("0x"), StringMatchFlag_CaseInsensitive)) + { + radix = 0x10, prefix_size = 2; + } + // binary + else if(str8_match(str8_prefix(string, 2), str8_lit("0b"), StringMatchFlag_CaseInsensitive)) + { + radix = 2, prefix_size = 2; + } + // octal + else if(str8_match(str8_prefix(string, 1), str8_lit("0"), StringMatchFlag_CaseInsensitive) && string.size > 1) + { + radix = 010, prefix_size = 1; + } + // decimal + else + { + radix = 10, prefix_size = 0; + } + } + + // 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; } @@ -675,78 +696,78 @@ try_s64_from_str8_c_rules(String8 string, S64 *x) internal String8 str8_from_memory_size(Arena *arena, U64 size) { - String8 result; - - if(size < KB(1)) - { - result = push_str8f(arena, "%llu Bytes", size); - } - else if(size < MB(1)) - { - result = push_str8f(arena, "%llu.%02llu KiB", size / KB(1), ((size * 100) / KB(1)) % 100); - } - else if(size < GB(1)) - { - result = push_str8f(arena, "%llu.%02llu MiB", size / MB(1), ((size * 100) / MB(1)) % 100); - } - else if(size < TB(1)) - { - result = push_str8f(arena, "%llu.%02llu GiB", size / GB(1), ((size * 100) / GB(1)) % 100); - } - else - { - result = push_str8f(arena, "%llu.%02llu TiB", size / TB(1), ((size * 100) / TB(1)) % 100); - } - + String8 result = {0}; + { + if(size < KB(1)) + { + result = push_str8f(arena, "%llu Bytes", size); + } + else if(size < MB(1)) + { + result = push_str8f(arena, "%llu.%02llu KiB", size / KB(1), ((size * 100) / KB(1)) % 100); + } + else if(size < GB(1)) + { + result = push_str8f(arena, "%llu.%02llu MiB", size / MB(1), ((size * 100) / MB(1)) % 100); + } + else if(size < TB(1)) + { + result = push_str8f(arena, "%llu.%02llu GiB", size / GB(1), ((size * 100) / GB(1)) % 100); + } + else + { + result = push_str8f(arena, "%llu.%02llu TiB", size / TB(1), ((size * 100) / TB(1)) % 100); + } + } return result; } internal String8 str8_from_count(Arena *arena, U64 count) { - String8 result; - - if(count < 1 * 1000) + String8 result = {0}; { - result = push_str8f(arena, "%llu", count); - } - else if(count < 1000000) - { - U64 frac = ((count * 100) / 1000) % 100; - if(frac > 0) + if(count < 1 * 1000) { - result = push_str8f(arena, "%llu.%02lluK", count / 1000, frac); + result = push_str8f(arena, "%llu", count); + } + else if(count < 1000000) + { + U64 frac = ((count * 100) / 1000) % 100; + if(frac > 0) + { + result = push_str8f(arena, "%llu.%02lluK", count / 1000, frac); + } + else + { + result = push_str8f(arena, "%lluK", count / 1000); + } + } + else if(count < 1000000000) + { + U64 frac = ((count * 100) / 1000000) % 100; + if(frac > 0) + { + result = push_str8f(arena, "%llu.%02lluM", count / 1000000, frac); + } + else + { + result = push_str8f(arena, "%lluM", count / 1000000); + } } else { - result = push_str8f(arena, "%lluK", count / 1000); + U64 frac = ((count * 100) * 1000000000) % 100; + if(frac > 0) + { + result = push_str8f(arena, "%llu.%02lluB", count / 1000000000, frac); + } + else + { + result = push_str8f(arena, "%lluB", count / 1000000000, frac); + } } } - else if(count < 1000000000) - { - U64 frac = ((count * 100) / 1000000) % 100; - if(frac > 0) - { - result = push_str8f(arena, "%llu.%02lluM", count / 1000000, frac); - } - else - { - result = push_str8f(arena, "%lluM", count / 1000000); - } - } - else - { - U64 frac = ((count * 100) * 1000000000) % 100; - if(frac > 0) - { - result = push_str8f(arena, "%llu.%02lluB", count / 1000000000, frac); - } - else - { - result = push_str8f(arena, "%lluB", count / 1000000000, frac); - } - } - return result; } @@ -859,7 +880,7 @@ str8_from_u64(Arena *arena, U64 u64, U32 radix, U8 min_digits, U8 digit_group_se } else { - result.str[result.size - idx - 1] = char_to_lower(integer_symbols[u64_reduce%radix]); + result.str[result.size - idx - 1] = lower_from_char(integer_symbols[u64_reduce%radix]); u64_reduce /= radix; } digits_until_separator -= 1; @@ -951,73 +972,74 @@ f64_from_str8(String8 string) //////////////////////////////// //~ rjf: String List Construction Functions -internal String8Node* -str8_list_push_node(String8List *list, String8Node *node){ - SLLQueuePush(list->first, list->last, node); - list->node_count += 1; - list->total_size += node->string.size; - return(node); -} - -internal String8Node* -str8_list_push_node_set_string(String8List *list, String8Node *node, String8 string){ - SLLQueuePush(list->first, list->last, node); - list->node_count += 1; - list->total_size += string.size; - node->string = string; - return(node); -} - -internal String8Node* -str8_list_push_node_front(String8List *list, String8Node *node){ - SLLQueuePushFront(list->first, list->last, node); - list->node_count += 1; - list->total_size += node->string.size; - return(node); -} - -internal String8Node* -str8_list_push_node_front_set_string(String8List *list, String8Node *node, String8 string){ - SLLQueuePushFront(list->first, list->last, node); - list->node_count += 1; - list->total_size += string.size; - node->string = string; - return(node); -} - -internal String8Node* -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); - return(node); -} - internal String8Node * -str8_list_push_cstr(Arena *arena, String8List *list, String8 string) +str8_list_push_node(String8List *list, String8Node *node) { - String8Node *node = str8_list_push(arena, list, string); - local_persist String8 null = str8_lit_comp("\0"); - str8_list_push(arena, list, null); + SLLQueuePush(list->first, list->last, node); + list->node_count += 1; + list->total_size += node->string.size; return node; } -internal String8Node* -str8_list_push_front(Arena *arena, String8List *list, String8 string){ +internal String8Node * +str8_list_push_node_set_string(String8List *list, String8Node *node, String8 string) +{ + SLLQueuePush(list->first, list->last, node); + list->node_count += 1; + list->total_size += string.size; + node->string = string; + return node; +} + +internal String8Node * +str8_list_push_node_front(String8List *list, String8Node *node) +{ + SLLQueuePushFront(list->first, list->last, node); + list->node_count += 1; + list->total_size += node->string.size; + return node; +} + +internal String8Node * +str8_list_push_node_front_set_string(String8List *list, String8Node *node, String8 string) +{ + SLLQueuePushFront(list->first, list->last, node); + list->node_count += 1; + list->total_size += string.size; + node->string = string; + return node; +} + +internal String8Node * +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); + return node; +} + +internal String8Node * +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); - return(node); + return node; } internal void -str8_list_concat_in_place(String8List *list, String8List *to_push){ - if(to_push->node_count != 0){ - if (list->last){ +str8_list_concat_in_place(String8List *list, String8List *to_push) +{ + if(to_push->node_count != 0) + { + 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; } MemoryZeroStruct(to_push); @@ -1048,7 +1070,8 @@ 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); String8 string = push_str8fv(arena, fmt, args); @@ -1058,7 +1081,8 @@ 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); String8 string = push_str8fv(arena, fmt, args); @@ -1068,11 +1092,11 @@ 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); str8_list_push_node_set_string(&result, new_node, new_string); @@ -1080,103 +1104,89 @@ str8_list_copy(Arena *arena, String8List *list){ return result; } +//////////////////////////////// +//~ 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){ - if (split_chars[i] == c){ + for(U64 i = 0; i < split_char_count; i += 1) + { + 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); } ptr += 1; } - - return(list); -} - -internal String8List -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 String8List -str8_list_split_by_string_chars(Arena *arena, String8List list, String8 split_chars, StringSplitFlags flags){ - String8List result = {0}; - for (String8Node *node = list.first; node != 0; node = node->next){ - String8List split = str8_split_by_string_chars(arena, node->string, split_chars, flags); - str8_list_concat_in_place(&result, &split); - } - return result; +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; } - String8 result; result.size = join.pre.size + join.post.size + sep_count*join.sep.size + list->total_size; U8 *ptr = result.str = push_array_no_zero(arena, U8, result.size + 1); - MemoryCopy(ptr, join.pre.str, join.pre.size); ptr += join.pre.size; - for (String8Node *node = list->first; - node != 0; - node = node->next){ + for(String8Node *node = list->first; + node != 0; + 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; } } MemoryCopy(ptr, join.post.str, join.post.size); ptr += join.post.size; - *ptr = 0; - return result; } -internal void -str8_list_from_flags(Arena *arena, String8List *list, - U32 flags, String8 *flag_string_table, U32 flag_string_count){ - for (U32 i = 0; i < flag_string_count; i += 1){ - U32 flag = (1 << i); - if (flags & flag){ - str8_list_push(arena, list, flag_string_table[i]); - } - } -} - //////////////////////////////// //~ rjf: Basic Data Structure Stringification Helpers @@ -1208,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) @@ -1281,7 +1291,7 @@ str8_from_version(Arena *arena, U64 version) U64 version_major = MajorFromVersion(version); U64 version_minor = MinorFromVersion(version); U64 version_patch = PatchFromVersion(version); - String8 result = push_str8f(arena, "%I64d.%I64d.%I64d", version_major, version_minor, version_patch); + String8 result = str8f(arena, "%I64d.%I64d.%I64d", version_major, version_minor, version_patch); return result; } @@ -1400,7 +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; @@ -1773,23 +1789,25 @@ internal String8 path_replace_file_extension(Arena *arena, String8 file_name, String8 ext) { String8 file_name_no_ext = str8_chop_last_dot(file_name); - String8 result = push_str8f(arena, "%S.%S", file_name_no_ext, ext); + String8 result = str8f(arena, "%S.%S", file_name_no_ext, ext); return result; } //////////////////////////////// //~ 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]; U8 byte_class = utf8_class[byte >> 3]; - switch (byte_class) + switch(byte_class) { case 1: { @@ -1797,10 +1815,10 @@ utf8_decode(U8 *str, U64 max){ }break; case 2: { - if (1 < max) + if(1 < max) { U8 cont_byte = str[1]; - if (utf8_class[cont_byte >> 3] == 0) + if(utf8_class[cont_byte >> 3] == 0) { result.codepoint = (byte & bitmask5) << 6; result.codepoint |= (cont_byte & bitmask6); @@ -1810,11 +1828,11 @@ utf8_decode(U8 *str, U64 max){ }break; case 3: { - if (2 < max) + if(2 < max) { U8 cont_byte[2] = {str[1], str[2]}; - if (utf8_class[cont_byte[0] >> 3] == 0 && - utf8_class[cont_byte[1] >> 3] == 0) + if(utf8_class[cont_byte[0] >> 3] == 0 && + utf8_class[cont_byte[1] >> 3] == 0) { result.codepoint = (byte & bitmask4) << 12; result.codepoint |= ((cont_byte[0] & bitmask6) << 6); @@ -1825,12 +1843,12 @@ utf8_decode(U8 *str, U64 max){ }break; case 4: { - if (3 < max) + if(3 < max) { U8 cont_byte[3] = {str[1], str[2], str[3]}; - if (utf8_class[cont_byte[0] >> 3] == 0 && - utf8_class[cont_byte[1] >> 3] == 0 && - utf8_class[cont_byte[2] >> 3] == 0) + if(utf8_class[cont_byte[0] >> 3] == 0 && + utf8_class[cont_byte[1] >> 3] == 0 && + utf8_class[cont_byte[2] >> 3] == 0) { result.codepoint = (byte & bitmask3) << 18; result.codepoint |= ((cont_byte[0] & bitmask6) << 12); @@ -1845,11 +1863,13 @@ 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; } @@ -1857,58 +1877,63 @@ 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); str[2] = bit8 | ((codepoint >> 6) & bitmask6); str[3] = bit8 | ( codepoint & bitmask6); inc = 4; } - else{ + else + { str[0] = '?'; inc = 1; } - return(inc); + return inc; } 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)); str[1] = safe_cast_u16(0xDC00 + (v & bitmask10)); inc = 2; } - return(inc); -} - -internal U32 -utf8_from_utf32_single(U8 *buffer, U32 character){ - return(utf8_encode(buffer, character)); + return inc; } //////////////////////////////// @@ -2010,7 +2035,7 @@ str32_from_8(Arena *arena, String8 in) } //////////////////////////////// -//~ String -> Enum Conversions +//~ rjf: Basic Types & Space Enum -> String Conversions read_only global struct { @@ -2028,42 +2053,45 @@ StaticAssert(ArrayCount(g_os_enum_map) == OperatingSystem_COUNT, g_os_enum_map_c internal OperatingSystem operating_system_from_string(String8 string) { - for(U64 i = 0; i < ArrayCount(g_os_enum_map); ++i) + for EachElement(idx, g_os_enum_map) { - if(str8_match(g_os_enum_map[i].string, string, StringMatchFlag_CaseInsensitive)) + if(str8_match(g_os_enum_map[idx].string, string, StringMatchFlag_CaseInsensitive)) { - return g_os_enum_map[i].os; + return g_os_enum_map[idx].os; } } return OperatingSystem_Null; } -//////////////////////////////// -//~ rjf: Basic Types & Space Enum -> String Conversions - internal String8 -string_from_dimension(Dimension dimension){ - local_persist String8 strings[] = { +string_from_dimension(Dimension dimension) +{ + read_only local_persist String8 strings[] = + { str8_lit_comp("X"), str8_lit_comp("Y"), str8_lit_comp("Z"), str8_lit_comp("W"), }; String8 result = str8_lit("error"); - if ((U32)dimension < 4){ + if((U32)dimension < 4) + { result = strings[dimension]; } return result; } internal String8 -string_from_side(Side side){ - local_persist String8 strings[] = { +string_from_side(Side side) +{ + 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]; } return result; @@ -2081,27 +2109,27 @@ string_from_operating_system(OperatingSystem os) } internal String8 -string_from_arch(Arch arch){ - local_persist String8 strings[] = { - str8_lit_comp("Null"), - str8_lit_comp("x64"), - str8_lit_comp("x86"), - str8_lit_comp("arm64"), - str8_lit_comp("arm32"), - }; - String8 result = str8_lit("error"); - if (arch < Arch_COUNT){ - result = strings[arch]; - } +string_from_arch(Arch arch) +{ + String8 result = {0}; + switch(arch) + { + case Arch_Null: {result = str8_lit("Null");}break; + case Arch_x64: {result = str8_lit("x64");}break; + case Arch_x86: {result = str8_lit("x86");}break; + case Arch_arm64: {result = str8_lit("arm64");}break; + case Arch_arm32: {result = str8_lit("arm32");}break; + case Arch_COUNT: + {result = str8_lit("Invalid");}break; + } return result; } -//////////////////////////////// -//~ rjf: Time Types -> String - internal String8 -string_from_week_day(WeekDay week_day){ - local_persist String8 strings[] = { +string_from_week_day(WeekDay week_day) +{ + read_only local_persist String8 strings[] = + { str8_lit_comp("Sun"), str8_lit_comp("Mon"), str8_lit_comp("Tue"), @@ -2111,15 +2139,18 @@ 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]; } return result; } internal String8 -string_from_month(Month month){ - local_persist String8 strings[] = { +string_from_month(Month month) +{ + read_only local_persist String8 strings[] = + { str8_lit_comp("Jan"), str8_lit_comp("Feb"), str8_lit_comp("Mar"), @@ -2134,21 +2165,25 @@ 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]; } return result; } internal String8 -push_date_time_string(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"; } String8 result = push_str8f(arena, "%d %s %d, %02d:%02d:%02d %s", @@ -2158,26 +2193,33 @@ push_date_time_string(Arena *arena, DateTime *date_time){ } internal String8 -push_file_name_date_time_string(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 = push_str8f(arena, "%d-%s-%0d--%02d-%02d-%02d", - date_time->year, mon_str, date_time->day, - date_time->hour, date_time->min, date_time->sec); + String8 result = str8f(arena, "%d-%s-%0d--%02d-%02d-%02d", + date_time->year, mon_str, date_time->day, + date_time->hour, date_time->min, date_time->sec); return result; } 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); } str8_list_pushf(scratch.arena, &list, "%u:%u:%u:%u ms", dt.hour, dt.min, dt.sec, dt.msec); @@ -2188,23 +2230,23 @@ string_from_elapsed_time(Arena *arena, DateTime dt){ } //////////////////////////////// -//~ Globally UNique Ids +//~ rjf: String <-> Globally Unique IDs internal String8 string_from_guid(Arena *arena, Guid guid) { - String8 result = push_str8f(arena, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", - guid.data1, - guid.data2, - guid.data3, - guid.data4[0], - guid.data4[1], - guid.data4[2], - guid.data4[3], - guid.data4[4], - guid.data4[5], - guid.data4[6], - guid.data4[7]); + String8 result = str8f(arena, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", + guid.data1, + guid.data2, + guid.data3, + guid.data4[0], + guid.data4[1], + guid.data4[2], + guid.data4[3], + guid.data4[4], + guid.data4[5], + guid.data4[6], + guid.data4[7]); return result; } @@ -2458,7 +2500,7 @@ wrapped_lines_from_string(Arena *arena, String8 string, U64 first_line_max_width internal String8 hex_string_from_rgba_4f32(Arena *arena, Vec4F32 rgba) { - String8 hex_string = push_str8f(arena, "%02x%02x%02x%02x", (U8)(rgba.x*255.f), (U8)(rgba.y*255.f), (U8)(rgba.z*255.f), (U8)(rgba.w*255.f)); + String8 hex_string = str8f(arena, "%02x%02x%02x%02x", (U8)(rgba.x*255.f), (U8)(rgba.y*255.f), (U8)(rgba.z*255.f), (U8)(rgba.w*255.f)); return hex_string; } @@ -2471,7 +2513,7 @@ rgba_from_hex_string_4f32(String8 hex_string) { if(char_is_digit(hex_string.str[idx], 16)) { - byte_text[byte_text_idx] = char_to_lower(hex_string.str[idx]); + byte_text[byte_text_idx] = lower_from_char(hex_string.str[idx]); byte_text_idx += 1; } } @@ -2774,8 +2816,8 @@ str8_compar(String8 a, String8 b, B32 ignore_case) U64 size = Min(a.size, b.size); if (ignore_case) { for (U64 i = 0; i < size; ++i) { - U8 la = char_to_lower(a.str[i]); - U8 lb = char_to_lower(b.str[i]); + U8 la = lower_from_char(a.str[i]); + U8 lb = lower_from_char(b.str[i]); if (la < lb) { cmp = -1; break; diff --git a/src/base/base_strings.h b/src/base/base_strings.h index 830f7762..06459427 100644 --- a/src/base/base_strings.h +++ b/src/base/base_strings.h @@ -38,13 +38,6 @@ struct String8Node String8 string; }; -typedef struct String8MetaNode String8MetaNode; -struct String8MetaNode -{ - String8MetaNode *next; - String8Node *node; -}; - typedef struct String8List String8List; struct String8List { @@ -59,6 +52,7 @@ struct String8Array { String8 *v; U64 count; + U64 total_size; }; //////////////////////////////// @@ -152,9 +146,9 @@ internal B32 char_is_lower(U8 c); internal B32 char_is_alpha(U8 c); internal B32 char_is_slash(U8 c); internal B32 char_is_digit(U8 c, U32 base); -internal U8 char_to_lower(U8 c); -internal U8 char_to_upper(U8 c); -internal U8 char_to_correct_slash(U8 c); +internal U8 lower_from_char(U8 c); +internal U8 upper_from_char(U8 c); +internal U8 correct_slash_from_char(U8 c); //////////////////////////////// //~ rjf: C-String Measurement @@ -262,12 +256,12 @@ internal F64 f64_from_str8(String8 string); //////////////////////////////// //~ rjf: String List Construction Functions -internal String8Node* str8_list_push_node(String8List *list, String8Node *node); -internal String8Node* str8_list_push_node_set_string(String8List *list, String8Node *node, String8 string); -internal String8Node* str8_list_push_node_front(String8List *list, String8Node *node); -internal String8Node* str8_list_push_node_front_set_string(String8List *list, String8Node *node, String8 string); -internal String8Node* str8_list_push(Arena *arena, String8List *list, String8 string); -internal String8Node* str8_list_push_front(Arena *arena, String8List *list, String8 string); +internal String8Node *str8_list_push_node(String8List *list, String8Node *node); +internal String8Node *str8_list_push_node_set_string(String8List *list, String8Node *node, String8 string); +internal String8Node *str8_list_push_node_front(String8List *list, String8Node *node); +internal String8Node *str8_list_push_node_front_set_string(String8List *list, String8Node *node, String8 string); +internal String8Node *str8_list_push(Arena *arena, String8List *list, String8 string); +internal String8Node *str8_list_push_front(Arena *arena, String8List *list, String8 string); internal void str8_list_concat_in_place(String8List *list, String8List *to_push); internal String8Node* str8_list_push_aligner(Arena *arena, String8List *list, U64 min, U64 align); internal String8Node* str8_list_pushf(Arena *arena, String8List *list, char *fmt, ...); @@ -280,9 +274,7 @@ internal String8List str8_list_copy(Arena *arena, String8List *list); internal String8List str8_split(Arena *arena, String8 string, U8 *split_chars, U64 split_char_count, StringSplitFlags flags); internal String8List str8_split_by_string_chars(Arena *arena, String8 string, String8 split_chars, StringSplitFlags flags); -internal String8List str8_list_split_by_string_chars(Arena *arena, String8List list, String8 split_chars, StringSplitFlags flags); internal String8 str8_list_join(Arena *arena, String8List *list, StringJoin *optional_params); -internal void str8_list_from_flags(Arena *arena, String8List *list, U32 flags, String8 *flag_string_table, U32 flag_string_count); //////////////////////////////// //~ rjf: Basic Data Stringification Helpers @@ -298,7 +290,7 @@ internal String8Array str8_array_reserve(Arena *arena, U64 count); internal String8Array str8_array_copy(Arena *arena, String8Array array); //////////////////////////////// -//~ rjf: String Version Helpers +//~ rjf: String <-> Version Helpers internal U64 version_from_str8(String8 string); internal String8 str8_from_version(Arena *arena, U64 version); @@ -362,7 +354,6 @@ internal UnicodeDecode utf8_decode(U8 *str, U64 max); internal UnicodeDecode utf16_decode(U16 *str, U64 max); internal U32 utf8_encode(U8 *str, U32 codepoint); internal U32 utf16_encode(U16 *str, U32 codepoint); -internal U32 utf8_from_utf32_single(U8 *buffer, U32 character); //////////////////////////////// //~ rjf: Unicode String Conversions @@ -373,29 +364,21 @@ internal String8 str8_from_32(Arena *arena, String32 in); internal String32 str32_from_8(Arena *arena, String8 in); //////////////////////////////// -//~ String -> Enum Conversions +//~ rjf: Basic Types & Space Enum <-> String Conversions internal OperatingSystem operating_system_from_string(String8 string); - -//////////////////////////////// -//~ rjf: Basic Types & Space Enum -> String Conversions - internal String8 string_from_dimension(Dimension dimension); internal String8 string_from_side(Side side); internal String8 string_from_operating_system(OperatingSystem os); internal String8 string_from_arch(Arch arch); - -//////////////////////////////// -//~ rjf: Time Types -> String - internal String8 string_from_week_day(WeekDay week_day); internal String8 string_from_month(Month month); -internal String8 push_date_time_string(Arena *arena, DateTime *date_time); -internal String8 push_file_name_date_time_string(Arena *arena, DateTime *date_time); +internal String8 string_from_date_time(Arena *arena, DateTime *date_time); +internal String8 string_from_date_time__file_name(Arena *arena, DateTime *date_time); internal String8 string_from_elapsed_time(Arena *arena, DateTime dt); //////////////////////////////// -//~ Globally Unique Ids +//~ rjf: String <-> Globally Unique IDs internal String8 string_from_guid(Arena *arena, Guid guid); internal B32 try_guid_from_string(String8 string, Guid *guid_out); @@ -467,4 +450,4 @@ internal U64 str8_deserial_read_block(String8 string, U64 off, U64 size, Stri internal U64 u64_hash_from_seed_str8(U64 seed, String8 string); internal U64 u64_hash_from_str8(String8 string); -#endif //BASE_STRINGS_H +#endif // BASE_STRINGS_H diff --git a/src/coff/coff.c b/src/coff/coff.c index e3879768..a37bc009 100644 --- a/src/coff/coff.c +++ b/src/coff/coff.c @@ -31,21 +31,21 @@ coff_section_flag_from_align_size(U64 align) { COFF_SectionFlags flags = 0; switch (align) { - case 0: flags = COFF_SectionAlign_None; break; - case 1: flags = COFF_SectionAlign_1Bytes; break; - case 2: flags = COFF_SectionAlign_2Bytes; break; - case 4: flags = COFF_SectionAlign_4Bytes; break; - case 8: flags = COFF_SectionAlign_8Bytes; break; - case 16: flags = COFF_SectionAlign_16Bytes; break; - case 32: flags = COFF_SectionAlign_32Bytes; break; - case 64: flags = COFF_SectionAlign_64Bytes; break; - case 128: flags = COFF_SectionAlign_128Bytes; break; - case 256: flags = COFF_SectionAlign_256Bytes; break; - case 512: flags = COFF_SectionAlign_512Bytes; break; - case 1024: flags = COFF_SectionAlign_1024Bytes; break; - case 2048: flags = COFF_SectionAlign_2048Bytes; break; - case 4096: flags = COFF_SectionAlign_4096Bytes; break; - case 8192: flags = COFF_SectionAlign_8192Bytes; break; + case 0: flags = COFF_SectionAlign_None; break; + case 1: flags = COFF_SectionAlign_1Bytes; break; + case 2: flags = COFF_SectionAlign_2Bytes; break; + case 4: flags = COFF_SectionAlign_4Bytes; break; + case 8: flags = COFF_SectionAlign_8Bytes; break; + case 16: flags = COFF_SectionAlign_16Bytes; break; + case 32: flags = COFF_SectionAlign_32Bytes; break; + case 64: flags = COFF_SectionAlign_64Bytes; break; + case 128: flags = COFF_SectionAlign_128Bytes; break; + case 256: flags = COFF_SectionAlign_256Bytes; break; + case 512: flags = COFF_SectionAlign_512Bytes; break; + case 1024: flags = COFF_SectionAlign_1024Bytes; break; + case 2048: flags = COFF_SectionAlign_2048Bytes; break; + case 4096: flags = COFF_SectionAlign_4096Bytes; break; + case 8192: flags = COFF_SectionAlign_8192Bytes; break; } flags <<= COFF_SectionFlag_AlignShift; return flags; @@ -182,67 +182,67 @@ coff_pick_reloc_value_x64(COFF_Reloc_X64 type, { U64 reloc_value_size = 0; S64 reloc_value = 0; - + switch (type) { - case COFF_Reloc_X64_Abs: {} break; - case COFF_Reloc_X64_Addr64: { - reloc_value_size = 8; - reloc_value = symbol_virtual_offset + (S64)image_base; - } break; - case COFF_Reloc_X64_Addr32: { - reloc_value_size = 4; - reloc_value = safe_cast_s32(symbol_virtual_offset + (S64)image_base); - } break; - case COFF_Reloc_X64_Addr32Nb: { - reloc_value_size = 4; - reloc_value = symbol_virtual_offset; - } break; - case COFF_Reloc_X64_Rel32: { - reloc_value_size = 4; - reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 0)); - } break; - case COFF_Reloc_X64_Rel32_1: { - reloc_value_size = 4; - reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 1)); - } break; - case COFF_Reloc_X64_Rel32_2: { - reloc_value_size = 4; - reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 2)); - } break; - case COFF_Reloc_X64_Rel32_3: { - reloc_value_size = 4; - reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 3)); - } break; - case COFF_Reloc_X64_Rel32_4: { - reloc_value_size = 4; - reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 4)); - } break; - case COFF_Reloc_X64_Rel32_5: { - reloc_value_size = 4; - reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 5)); - } break; - case COFF_Reloc_X64_Section: { - reloc_value_size = 4; - reloc_value = symbol_section_number; - } break; - case COFF_Reloc_X64_SecRel: { - reloc_value_size = 4; - reloc_value = symbol_section_offset; - } break; - case COFF_Reloc_X64_SecRel7: - case COFF_Reloc_X64_Token: - case COFF_Reloc_X64_SRel32: - case COFF_Reloc_X64_Pair: - case COFF_Reloc_X64_SSpan32: - case COFF_Reloc_X64_Unknown_11: { - NotImplemented; - } break; + case COFF_Reloc_X64_Abs: {} break; + case COFF_Reloc_X64_Addr64: { + reloc_value_size = 8; + reloc_value = symbol_virtual_offset + (S64)image_base; + } break; + case COFF_Reloc_X64_Addr32: { + reloc_value_size = 4; + reloc_value = safe_cast_s32(symbol_virtual_offset + (S64)image_base); + } break; + case COFF_Reloc_X64_Addr32Nb: { + reloc_value_size = 4; + reloc_value = symbol_virtual_offset; + } break; + case COFF_Reloc_X64_Rel32: { + reloc_value_size = 4; + reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 0)); + } break; + case COFF_Reloc_X64_Rel32_1: { + reloc_value_size = 4; + reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 1)); + } break; + case COFF_Reloc_X64_Rel32_2: { + reloc_value_size = 4; + reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 2)); + } break; + case COFF_Reloc_X64_Rel32_3: { + reloc_value_size = 4; + reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 3)); + } break; + case COFF_Reloc_X64_Rel32_4: { + reloc_value_size = 4; + reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 4)); + } break; + case COFF_Reloc_X64_Rel32_5: { + reloc_value_size = 4; + reloc_value = safe_cast_s32(symbol_virtual_offset - reloc_virtual_offset - (4 + 5)); + } break; + case COFF_Reloc_X64_Section: { + reloc_value_size = 4; + reloc_value = symbol_section_number; + } break; + case COFF_Reloc_X64_SecRel: { + reloc_value_size = 4; + reloc_value = symbol_section_offset; + } break; + case COFF_Reloc_X64_SecRel7: + case COFF_Reloc_X64_Token: + case COFF_Reloc_X64_SRel32: + case COFF_Reloc_X64_Pair: + case COFF_Reloc_X64_SSpan32: + case COFF_Reloc_X64_Unknown_11: { + NotImplemented; + } break; } - + COFF_RelocValue result = {0}; result.size = reloc_value_size; result.value = reloc_value; - + return result; } @@ -265,7 +265,7 @@ coff_make_lib_member_header(Arena *arena, String8 name, COFF_TimeStamp time_stam str8_list_pushf(scratch.arena, &list, "%-10u", size); str8_list_pushf(scratch.arena, &list, "`\n"); String8 result = str8_list_join(arena, &list, 0); - + Assert(result.size == sizeof(COFF_ArchiveMemberHeader)); scratch_end(scratch); return result; @@ -302,18 +302,18 @@ coff_ordinal_data_from_hint(Arena *arena, COFF_MachineType machine, U16 hint) { String8 ordinal_data = {0}; switch (machine) { - case COFF_MachineType_Unknown: break; - case COFF_MachineType_X64: { - U64 *ordinal = push_array(arena, U64, 1); - *ordinal = coff_make_ordinal64(hint); - ordinal_data = str8_struct(ordinal); - } break; - case COFF_MachineType_X86: { - U32 *ordinal = push_array(arena, U32, 1); - *ordinal = coff_make_ordinal32(hint); - ordinal_data = str8_struct(ordinal); - } break; - default: { NotImplemented; } break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: { + U64 *ordinal = push_array(arena, U64, 1); + *ordinal = coff_make_ordinal64(hint); + ordinal_data = str8_struct(ordinal); + } break; + case COFF_MachineType_X86: { + U32 *ordinal = push_array(arena, U32, 1); + *ordinal = coff_make_ordinal32(hint); + ordinal_data = str8_struct(ordinal); + } break; + default: { NotImplemented; } break; } return ordinal_data; } @@ -331,7 +331,7 @@ coff_make_import_header(Arena *arena, COFF_ImportHeaderFlags flags = 0; flags |= (type & COFF_ImportHeader_TypeMask) << COFF_ImportHeader_TypeShift; flags |= import_by << COFF_ImportHeader_ImportByShift; - + COFF_ImportHeader header = {0}; header.sig1 = COFF_MachineType_Unknown; header.sig2 = max_U16; @@ -368,12 +368,12 @@ coff_code_align_byte_from_machine(COFF_MachineType machine) { U8 align_byte = 0; switch (machine) { - case COFF_MachineType_Unknown: break; - case COFF_MachineType_X64: - case COFF_MachineType_X86: { - align_byte = 0xCC; - } break; - default: { NotImplemented; } break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: + case COFF_MachineType_X86: { + align_byte = 0xCC; + } break; + default: { NotImplemented; } break; } return align_byte; } @@ -383,11 +383,11 @@ coff_default_align_from_machine(COFF_MachineType machine) { U16 align = 0; switch (machine) { - case COFF_MachineType_Unknown: break; - case COFF_MachineType_X64: { - align = 16; - } break; - default: { NotImplemented; } break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: { + align = 16; + } break; + default: { NotImplemented; } break; } return align; } @@ -472,7 +472,7 @@ coff_string_from_time_stamp(Arena *arena, COFF_TimeStamp time_stamp) result = str8_lit("-1"); } else { DateTime dt = date_time_from_unix_time(time_stamp); - result = push_date_time_string(arena, &dt); + result = string_from_date_time(arena, &dt); } return result; } diff --git a/src/coff/coff_obj_writer.c b/src/coff/coff_obj_writer.c index 2a8a91af..419fc398 100644 --- a/src/coff/coff_obj_writer.c +++ b/src/coff/coff_obj_writer.c @@ -20,14 +20,14 @@ internal String8 coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) { Temp scratch = scratch_begin(&arena, 1); - + String8List srl = {0}; - + String8List string_table = {0}; U32 *string_table_size = push_array(scratch.arena, U32, 1); *string_table_size = sizeof(*string_table_size); str8_list_push(scratch.arena, &string_table, str8_struct(string_table_size)); - + // // assing section numbers // @@ -41,11 +41,11 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) COFF_ObjSection *sect = §_n->v; sect->section_number = sect_idx+1; obj_sections[sect_idx] = sect; - + } } AssertAlways(obj_sections_count <= max_U16); - + // // serialize symbol table // @@ -55,26 +55,27 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) U64 symbol_idx = 0; for (COFF_ObjSymbolNode *symbol_n = obj_writer->symbol_first; symbol_n != 0; symbol_n = symbol_n->next) { COFF_ObjSymbol *s = &symbol_n->v; - + // assign symbol index s->idx = symbol_idx++; symbol_idx += s->aux_symbols.node_count; } } - + U64 symbol_idx = 0; for (COFF_ObjSymbolNode *symbol_n = obj_writer->symbol_first; symbol_n != 0; symbol_n = symbol_n->next) { COFF_ObjSymbol *s = &symbol_n->v; - + COFF_Symbol16 *d = push_array(scratch.arena, COFF_Symbol16, 1); str8_list_push(scratch.arena, &symbol_table, str8_struct(d)); - + COFF_SymbolName name = {0}; // long name if (s->name.size > sizeof(name.short_name)) { U64 string_table_offset = string_table.total_size; - str8_list_push_cstr(scratch.arena, &string_table, s->name); - + str8_list_push(scratch.arena, &string.table, s->name); + str8_list_push(scratch.arena, &string.table, str8_lit("\0")); + name.long_name.zeroes = 0; name.long_name.string_table_offset = safe_cast_u32(string_table_offset); } @@ -83,22 +84,22 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) MemoryCopyStr8(name.short_name, s->name); MemoryZeroTyped(name.short_name + s->name.size, sizeof(name.short_name) - s->name.size); } - + // symbol header AssertAlways(s->aux_symbols.node_count <= max_U8); d->name = name; d->value = s->value; switch (s->loc.type) { - case COFF_SymbolLocation_Null: break; - case COFF_SymbolLocation_Section: d->section_number = safe_cast_u16(s->loc.u.section->section_number); break; - case COFF_SymbolLocation_Abs: d->section_number = COFF_Symbol_AbsSection16; break; - case COFF_SymbolLocation_Undef: d->section_number = COFF_Symbol_UndefinedSection; break; - case COFF_SymbolLocation_Common: d->section_number = COFF_Symbol_UndefinedSection; break; + case COFF_SymbolLocation_Null: break; + case COFF_SymbolLocation_Section: d->section_number = safe_cast_u16(s->loc.u.section->section_number); break; + case COFF_SymbolLocation_Abs: d->section_number = COFF_Symbol_AbsSection16; break; + case COFF_SymbolLocation_Undef: d->section_number = COFF_Symbol_UndefinedSection; break; + case COFF_SymbolLocation_Common: d->section_number = COFF_Symbol_UndefinedSection; break; } d->type = s->type; d->storage_class = s->storage_class; d->aux_symbol_count = 0; - + U64 start_symbol_idx = symbol_idx; if (s->storage_class == COFF_SymStorageClass_WeakExternal) { if (s->aux_symbols.node_count > 0) { @@ -106,7 +107,7 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) COFF_SymbolWeakExt *d_weak = push_array(scratch.arena, COFF_SymbolWeakExt, 1); d_weak->tag_index = s_weak->tag ? s_weak->tag->idx : max_U32; d_weak->characteristics = s_weak->characteristics; - + str8_list_push(scratch.arena, &symbol_table, str8_struct(d_weak)); symbol_idx += 1; } @@ -114,32 +115,32 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) if (s->aux_symbols.node_count > 0) { Assert(s->loc.type == COFF_SymbolLocation_Section); COFF_ObjSection *sect = s->loc.u.section; - + COFF_ObjSymbolSecDef *s_sd = (COFF_ObjSymbolSecDef *)s->aux_symbols.first->string.str; COFF_SymbolSecDef *d_sd = push_array(scratch.arena, COFF_SymbolSecDef, 1); - + d_sd->length = safe_cast_u32(sect->data.total_size); d_sd->number_of_relocations = (U16)sect->reloc_count; d_sd->check_sum = 0; d_sd->number_lo = s_sd->selection == COFF_ComdatSelect_Associative ? safe_cast_u16(s_sd->associate->section_number) : 0; d_sd->selection = s_sd->selection; - + str8_list_push(scratch.arena, &symbol_table, str8_struct(d_sd)); symbol_idx += 1; } } - + U8 processed_aux_symbol_count = (U8)(symbol_idx - start_symbol_idx); - + for (U64 aux_idx = processed_aux_symbol_count; aux_idx < s->aux_symbols.node_count; aux_idx += 1) { COFF_Symbol16 *a = push_array(scratch.arena, COFF_Symbol16, 1); str8_list_push(scratch.arena, &symbol_table, str8_struct(a)); } - + d->aux_symbol_count = (U8)s->aux_symbols.node_count; } } - + // // file header // @@ -152,35 +153,35 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) file_header->optional_header_size = 0; file_header->flags = 0; str8_list_push(scratch.arena, &srl, str8_struct(file_header)); - + // // section table // - + COFF_SectionHeader *sectab = push_array(scratch.arena, COFF_SectionHeader, obj_sections_count); str8_list_push(scratch.arena, &srl, str8_array(sectab, obj_sections_count)); { for (U64 sect_idx = 0; sect_idx < obj_sections_count; sect_idx += 1) { COFF_ObjSection *s = obj_sections[sect_idx]; COFF_SectionHeader *d = §ab[sect_idx]; - + // section name String8 sect_name = s->name; if (sect_name.size > sizeof(d->name)) { U64 sect_name_off = string_table.total_size; str8_list_push_cstr(scratch.arena, &string_table, sect_name); - + sect_name = push_str8f(scratch.arena, "/%u", sect_name_off); AssertAlways(sect_name.size <= sizeof(d->name)); } - + // alloc zero nodes for (String8Node *data_n = s->data.first; data_n != 0; data_n = data_n->next) { if (data_n->string.str == 0 && data_n->string.size > 0) { data_n->string = str8(push_array(scratch.arena, U8, data_n->string.size), data_n->string.size); } } - + // section data U64 data_foff = 0; U64 data_size = 0; @@ -189,7 +190,7 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) data_size = s->data.total_size; str8_list_concat_in_place(&srl, &s->data); } - + // section relocs U64 relocs_foff = 0; if (s->reloc_count) { @@ -206,7 +207,7 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) relocs_foff = srl.total_size; str8_list_push(scratch.arena, &srl, str8_array(relocs, s->reloc_count)); } - + // section header MemoryCopyStr8(d->name, sect_name); MemoryZeroTyped(d->name + sect_name.size, sizeof(d->name) - sect_name.size); @@ -221,7 +222,7 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) d->flags = s->flags; } } - + // // symbol table // @@ -229,7 +230,7 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) file_header->symbol_table_foff = srl.total_size; str8_list_concat_in_place(&srl, &symbol_table); } - + // // string table // @@ -237,12 +238,12 @@ coff_obj_writer_serialize(Arena *arena, COFF_ObjWriter *obj_writer) *string_table_size = safe_cast_u32(string_table.total_size); str8_list_concat_in_place(&srl, &string_table); } - + // // join // String8 obj = str8_list_join(arena, &srl, 0); - + scratch_end(scratch); return obj; } @@ -253,15 +254,15 @@ coff_obj_writer_push_section(COFF_ObjWriter *obj_writer, String8 name, COFF_Sect COFF_ObjSectionNode *sect_n = push_array(obj_writer->arena, COFF_ObjSectionNode, 1); SLLQueuePush(obj_writer->sect_first, obj_writer->sect_last, sect_n); obj_writer->sect_count += 1; - + COFF_ObjSection *sect = §_n->v; sect->name = name; sect->flags = flags; - + if (data.size) { str8_list_push(obj_writer->arena, §->data, data); } - + return sect; } @@ -271,14 +272,14 @@ coff_obj_writer_push_symbol(COFF_ObjWriter *obj_writer, String8 name, U32 value, COFF_ObjSymbolNode *n = push_array(obj_writer->arena, COFF_ObjSymbolNode, 1); SLLQueuePush(obj_writer->symbol_first, obj_writer->symbol_last, n); obj_writer->symbol_count += 1; - + COFF_ObjSymbol *s = &n->v; s->name = name; s->value = value; s->loc = loc; s->type = type; s->storage_class = storage_class; - + return s; } @@ -307,9 +308,9 @@ coff_obj_writer_push_symbol_static(COFF_ObjWriter *obj_writer, String8 name, U32 COFF_SymbolLocation loc = {0}; loc.type = COFF_SymbolLocation_Section; loc.u.section = section; - + COFF_SymbolType symtype = {0}; - + COFF_ObjSymbol *s = coff_obj_writer_push_symbol(obj_writer, name, off, loc, symtype, COFF_SymStorageClass_Static); return s; } @@ -341,13 +342,13 @@ coff_obj_writer_push_symbol_weak(COFF_ObjWriter *obj_writer, String8 name, COFF_ COFF_SymbolLocation loc = {0}; COFF_SymbolType symtype = {0}; COFF_ObjSymbol *s = coff_obj_writer_push_symbol(obj_writer, name, COFF_Symbol_UndefinedSection, loc, symtype, COFF_SymStorageClass_WeakExternal); - + COFF_ObjSymbolWeak *weak_ext = push_array(obj_writer->arena, COFF_ObjSymbolWeak, 1); weak_ext->tag = tag; weak_ext->characteristics = characteristics; - + str8_list_push(obj_writer->arena, &s->aux_symbols, str8_struct(weak_ext)); - + return s; } @@ -398,10 +399,10 @@ coff_obj_writer_push_symbol_sect(COFF_ObjWriter *obj_writer, String8 name, COFF_ COFF_SymbolLocation loc = {0}; loc.type = COFF_SymbolLocation_Section; loc.u.section = sect; - + // strip align flags COFF_SectionFlags expected_flags = sect->flags & ~(COFF_SectionFlag_AlignMask << COFF_SectionFlag_AlignShift); - + COFF_ObjSymbol *s = coff_obj_writer_push_symbol(obj_writer, name, expected_flags, loc, type, COFF_SymStorageClass_Section); return s; } @@ -430,12 +431,12 @@ coff_obj_writer_section_push_reloc(COFF_ObjWriter *obj_writer, COFF_ObjSection * COFF_ObjRelocNode *reloc_n = push_array(obj_writer->arena, COFF_ObjRelocNode, 1); SLLQueuePush(sect->reloc_first, sect->reloc_last, reloc_n); sect->reloc_count += 1; - + COFF_ObjReloc *reloc = &reloc_n->v; reloc->apply_off = apply_off; reloc->symbol = symbol; reloc->type = type; - + return reloc; } @@ -444,9 +445,9 @@ coff_obj_writer_section_push_reloc_addr32(COFF_ObjWriter *obj_writer, COFF_ObjSe { COFF_RelocType reloc_type = 0; switch (obj_writer->machine) { - case COFF_MachineType_Unknown: break; - case COFF_MachineType_X64: reloc_type = COFF_Reloc_X64_Addr32; break; - default: { NotImplemented; } break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: reloc_type = COFF_Reloc_X64_Addr32; break; + default: { NotImplemented; } break; } return coff_obj_writer_section_push_reloc(obj_writer, sect, apply_off, symbol, reloc_type); } @@ -456,9 +457,9 @@ coff_obj_writer_section_push_reloc_addr(COFF_ObjWriter *obj_writer, COFF_ObjSect { COFF_RelocType reloc_type = 0; switch (obj_writer->machine) { - case COFF_MachineType_Unknown: break; - case COFF_MachineType_X64: reloc_type = COFF_Reloc_X64_Addr64; break; - default: { NotImplemented; } break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: reloc_type = COFF_Reloc_X64_Addr64; break; + default: { NotImplemented; } break; } return coff_obj_writer_section_push_reloc(obj_writer, sect, apply_off, symbol, reloc_type); } @@ -468,9 +469,9 @@ coff_obj_writer_section_push_reloc_voff(COFF_ObjWriter *obj_writer, COFF_ObjSect { COFF_RelocType reloc_type = 0; switch (obj_writer->machine) { - case COFF_MachineType_Unknown: break; - case COFF_MachineType_X64: reloc_type = COFF_Reloc_X64_Addr32Nb; break; - default: { NotImplemented; } break; + case COFF_MachineType_Unknown: break; + case COFF_MachineType_X64: reloc_type = COFF_Reloc_X64_Addr32Nb; break; + default: { NotImplemented; } break; } return coff_obj_writer_section_push_reloc(obj_writer, sect, apply_off, symbol, reloc_type); } diff --git a/src/ctrl/ctrl_core.c b/src/ctrl/ctrl_core.c index b9b51256..ec12c673 100644 --- a/src/ctrl/ctrl_core.c +++ b/src/ctrl/ctrl_core.c @@ -3991,8 +3991,8 @@ ctrl_thread__append_resolved_module_user_bp_traps(Arena *arena, CTRL_EvalScope * String8 filename_normalized = push_str8_copy(scratch.arena, filename); for(U64 idx = 0; idx < filename_normalized.size; idx += 1) { - filename_normalized.str[idx] = char_to_lower(filename_normalized.str[idx]); - filename_normalized.str[idx] = char_to_correct_slash(filename_normalized.str[idx]); + filename_normalized.str[idx] = lower_from_char(filename_normalized.str[idx]); + filename_normalized.str[idx] = correct_slash_from_char(filename_normalized.str[idx]); } // rjf: filename -> src_id diff --git a/src/dbg_engine/dbg_engine_core.c b/src/dbg_engine/dbg_engine_core.c index 980f99ae..e72a46aa 100644 --- a/src/dbg_engine/dbg_engine_core.c +++ b/src/dbg_engine/dbg_engine_core.c @@ -37,7 +37,7 @@ d_hash_from_seed_string__case_insensitive(U64 seed, String8 string) U64 result = seed; for(U64 i = 0; i < string.size; i += 1) { - result = ((result << 5) + result) + char_to_lower(string.str[i]); + result = ((result << 5) + result) + lower_from_char(string.str[i]); } return result; } diff --git a/src/dbgi/dbgi.c b/src/dbgi/dbgi.c index 87bb07ec..49aec576 100644 --- a/src/dbgi/dbgi.c +++ b/src/dbgi/dbgi.c @@ -13,7 +13,7 @@ di_hash_from_seed_string(U64 seed, String8 string, StringMatchFlags match_flags) U64 result = seed; for(U64 i = 0; i < string.size; i += 1) { - result = ((result << 5) + result) + ((match_flags & StringMatchFlag_CaseInsensitive) ? char_to_lower(string.str[i]) : string.str[i]); + result = ((result << 5) + result) + ((match_flags & StringMatchFlag_CaseInsensitive) ? lower_from_char(string.str[i]) : string.str[i]); } return result; } diff --git a/src/os/gfx/os_gfx.c b/src/os/gfx/os_gfx.c index ec0ccade..3b584ec0 100644 --- a/src/os/gfx/os_gfx.c +++ b/src/os/gfx/os_gfx.c @@ -35,13 +35,9 @@ internal String8List os_string_list_from_modifiers(Arena *arena, OS_Modifiers modifiers) { String8List result = {0}; - String8 modifier_strs[] = - { - str8_lit("Ctrl"), - str8_lit("Shift"), - str8_lit("Alt"), - }; - str8_list_from_flags(arena, &result, modifiers, modifier_strs, ArrayCount(modifier_strs)); + if(modifiers & OS_Modifier_Ctrl) { str8_list_push(arena, &result, str8_lit("Ctrl")); } + if(modifiers & OS_Modifier_Shift) { str8_list_push(arena, &result, str8_lit("Shift")); } + if(modifiers & OS_Modifier_Alt) { str8_list_push(arena, &result, str8_lit("Alt")); } return result; } diff --git a/src/radcon/radcon.c b/src/radcon/radcon.c deleted file mode 100644 index 1cd0643b..00000000 --- a/src/radcon/radcon.c +++ /dev/null @@ -1,481 +0,0 @@ -internal String8 -rc_data_from_file_path(Arena *arena, String8 path) -{ - String8 data = os_data_from_file_path(arena, path); - if (data.size == 0) { - fprintf(stderr, "error: unable to read file %.*s\n", str8_varg(path)); - os_abort(1); - } - return data; -} - -internal RC_Context -rc_context_from_cmd_line(Arena *arena, CmdLine *cmdl) -{ - Temp scratch = scratch_begin(&arena, 1); - - if (cmdl->inputs.node_count > 2) { - fprintf(stderr, "error: too many input files on the command line.\n"); - os_abort(1); - } - - B32 is_pe_present = 0; - B32 is_pdb_present = 0; - B32 is_elf_present = 0; - B32 is_elf_debug_present = 0; - String8 pe_name = {0}; - String8 pe_data = {0}; - String8 pdb_name = {0}; - String8 pdb_data = {0}; - String8 elf_name = {0}; - String8 elf_data = {0}; - String8 elf_debug_name = {0}; - String8 elf_debug_data = {0}; - - // - // Set typed inputs - // - if (cmd_line_has_flag(cmdl, str8_lit("pe"))) { - pe_name = cmd_line_string(cmdl, str8_lit("pe")); - pe_data = rc_data_from_file_path(arena, pe_name); - if (!pe_check_magic(pe_data)) { - fprintf(stderr, "error: -pe:%.*s is not of PE format\n", str8_varg(pe_name)); - os_abort(1); - } - is_pe_present = 1; - } - if (cmd_line_has_flag(cmdl, str8_lit("pdb"))) { - pdb_name = cmd_line_string(cmdl, str8_lit("pdb")); - pdb_data = rc_data_from_file_path(arena, pdb_name); - if (!msf_check_magic_20(pdb_data) && !msf_check_magic_70(pdb_data)) { - fprintf(stderr, "error: -pdb:%.*s is not of PDB format\n", str8_varg(pdb_name)); - os_abort(1); - } - is_pdb_present = 1; - } - if (cmd_line_has_flag(cmdl, str8_lit("elf"))) { - elf_name = cmd_line_string(cmdl, str8_lit("elf")); - elf_data = rc_data_from_file_path(arena, elf_name); - if (!elf_check_magic(elf_data)) { - fprintf(stderr, "error: -elf:%.*s is not of ELF format\n", str8_varg(elf_name)); - os_abort(1); - } - is_elf_present = 1; - } - if (cmd_line_has_flag(cmdl, str8_lit("elf_debug"))) { - elf_debug_name = cmd_line_string(cmdl, str8_lit("elf_debug")); - elf_debug_data = rc_data_from_file_path(arena, elf_debug_name); - if (!elf_check_magic(elf_debug_data)) { - fprintf(stderr, "error: -elf_debug:%.*s is not of ELF format\n", str8_varg(elf_debug_name)); - os_abort(1); - } - is_elf_debug_present = 1; - } - - // - // Pick conversion driver - // - RC_Driver driver = RC_Driver_Null; - if (cmd_line_has_flag(cmdl, str8_lit("driver"))) { - String8 driver_name = cmd_line_string(cmdl, str8_lit("driver")); - if (str8_match(driver_name, str8_lit("dwarf"), StringMatchFlag_CaseInsensitive)) { - driver = RC_Driver_Dwarf; - } else if (str8_match(driver_name, str8_lit("pdb"), StringMatchFlag_CaseInsensitive)) { - driver = RC_Driver_Pdb; - } else { - fprintf(stderr, "error: unknown driver \"%.*s\"\n", str8_varg(driver_name)); - os_abort(1); - } - } - - // - // Load inputs - // - for (String8Node *input_n = cmdl->inputs.first; input_n != 0; input_n = input_n->next) { - String8 input_data = os_data_from_file_path(arena, input_n->string); - - if (input_data.size == 0) { - fprintf(stderr, "unable to read input %.*s\n", str8_varg(input_n->string)); - os_abort(1); - } - - if (pe_check_magic(input_data)) { - if (is_pe_present) { - fprintf(stderr, "error: too many PE files are specified on the command line\n"); - fprintf(stderr, " selected: %.*s\n", str8_varg(pe_name)); - fprintf(stderr, " current: %.*s\n", str8_varg(input_n->string)); - os_abort(1); - } - pe_data = input_data; - pe_name = input_n->string; - is_pe_present = 1; - } else if (elf_check_magic(input_data)) { - ELF_Bin elf = elf_bin_from_data(input_data); - B32 is_dwarf_present = dw_is_dwarf_present_from_bin(input_data, &elf); - if (is_dwarf_present) { - if (is_elf_debug_present) { - fprintf(stderr, "error: ambiguous input, both ELFs have DWARF debug sections, please use --elf: --elf_debug: to clarify inputs.\n"); - os_abort(1); - } - elf_debug_name = input_n->string; - elf_debug_data = input_data; - is_elf_debug_present = 1; - } else { - elf_name = input_n->string; - elf_data = input_data; - is_elf_present = 1; - } - } else if (msf_check_magic_20(input_data) || msf_check_magic_70(input_data)) { - if (is_pdb_present) { - fprintf(stderr, "error: too many PDB files are specified on the command line\n"); - fprintf(stderr, " selected: %.*s\n", str8_varg(pdb_name)); - fprintf(stderr, " current: %.*s\n", str8_varg(input_n->string)); - continue; - } - pdb_name = input_n->string; - pdb_data = input_data; - is_pdb_present = 1; - } else { - fprintf(stderr, "error: unknown file format %.*s\n", str8_varg(input_n->string)); - } - } - - // - // Validate input combos - // - if ((is_pe_present || is_pdb_present) && (is_elf_present || is_elf_debug_present)) { - fprintf(stderr, "error: invalid combination of inputs provided, we convert only (PE|PDB) or (ELF|ELF_DEBUG) at a time.\n"); - if (is_pe_present) { - fprintf(stderr, " PE: %.*s\n", str8_varg(pe_name)); - } - if (is_pdb_present) { - fprintf(stderr, " PDB: %.*s\n", str8_varg(pdb_name)); - } - if (is_elf_present) { - fprintf(stderr, " ELF: %.*s\n", str8_varg(elf_name)); - } - if (is_elf_debug_present) { - fprintf(stderr, " ELF Debug: %.*s\n", str8_varg(elf_debug_name)); - } - os_abort(1); - } - - if (is_pe_present && (is_elf_present || is_elf_debug_present)) { - fprintf(stderr, "error: command line has too many image types specified.\n"); - os_abort(1); - } - - - ExecutableImageKind image = ExecutableImageKind_Null; - String8 image_name = {0}; - String8 image_data = {0}; - String8 debug_name = {0}; - String8 debug_data = {0}; - - B32 check_guid = 0; - Guid pe_pdb_guid = {0}; - - B32 elf_has_debug_link = 0; - ELF_GnuDebugLink debug_link = {0}; - - // - // Input has PE/COFF - // - if (is_pe_present) { - image = ExecutableImageKind_CoffPe; - image_name = pe_name; - image_data = pe_data; - - PE_BinInfo pe = pe_bin_info_from_data(scratch.arena, pe_data); - String8 raw_debug_dir = str8_substr(pe_data, pe.data_dir_franges[PE_DataDirectoryIndex_DEBUG]); - PE_DebugInfoList debug_dir = pe_debug_info_list_from_raw_debug_dir(scratch.arena, pe_data, raw_debug_dir); - for (PE_DebugInfoNode *debug_n = debug_dir.first; debug_n != 0; debug_n = debug_n->next) { - PE_DebugInfo *debug = &debug_n->v; - if (debug->header.type == PE_DebugDirectoryType_CODEVIEW) { - if (debug->u.codeview.magic == PE_CODEVIEW_PDB70_MAGIC) { - check_guid = 1; - pe_pdb_guid = debug->u.codeview.pdb70.header.guid; - - if (!is_pdb_present) { - pdb_name = debug->u.codeview.pdb70.path; - pdb_data = rc_data_from_file_path(arena, pdb_name); - is_pdb_present = 1; - } - - break; - } - } - } - - if (driver == RC_Driver_Null || driver == RC_Driver_Dwarf) { - PE_BinInfo pe = pe_bin_info_from_data(scratch.arena, pe_data); - String8 raw_section_table = str8_substr(pe_data, pe.section_table_range); - String8 string_table = str8_substr(pe_data, pe.string_table_range); - U64 section_count = raw_section_table.size / sizeof(COFF_SectionHeader); - COFF_SectionHeader *section_table = (COFF_SectionHeader *)raw_section_table.str; - if (dw_is_dwarf_present_coff_section_table(pe_data, string_table, section_count, section_table)) { - driver = RC_Driver_Dwarf; - debug_name = pe_name; - debug_data = pe_data; - goto driver_found; - } else if (driver == RC_Driver_Dwarf) { - fprintf(stderr, "error: image doesn't have DWARF debug sections.\n"); - os_abort(1); - } - } - } - - if (is_elf_present || is_elf_debug_present) { - if (driver != RC_Driver_Null && driver != RC_Driver_Dwarf) { - fprintf(stderr, "error: ELF inputs are only supported when using DWARF driver.\n"); - os_abort(1); - } - - // - // Load image ELF - // - ELF_Bin elf = elf_bin_from_data(elf_data); - B32 has_elf_dwarf = dw_is_dwarf_present_from_elf_bin(elf_data, &elf); - - // - // ELF doesn't have debug info and no .debug was specified on command line, - // try to load .debug via debug link - // - if (is_elf_present && !is_elf_debug_present) { - elf_has_debug_link = elf_parse_debug_link(elf_data, &elf, &debug_link); - } - if (elf_has_debug_link) { - elf_debug_data = rc_data_from_file_path(arena, debug_link.path); - is_elf_debug_present = 1; - } - - // - // Load .debug ELF - // - ELF_Bin elf_debug = elf_bin_from_data(elf_debug_data); - B32 has_elf_debug_dwarf = dw_is_dwarf_present_from_elf_bin(elf_debug_data, &elf_debug); - - // - // Input is image ELF and .debug ELF - // - B32 is_split_elf = is_elf_present && is_elf_debug_present && !has_elf_dwarf && has_elf_debug_dwarf; - if (is_split_elf) { - driver = RC_Driver_Dwarf; - image = ELF_HdrIs64Bit(elf.hdr.e_ident) ? ExecutableImageKind_Elf64 : ExecutableImageKind_Elf32; - image_name = elf_name; - image_data = elf_data; - debug_name = elf_debug_name; - debug_data = elf_debug_data; - goto driver_found; - } - - // - // Input ELF is image with debug info - // - B32 is_monolithic_elf = is_elf_present && !is_elf_debug_present && has_elf_dwarf; - if (is_monolithic_elf) { - driver = RC_Driver_Dwarf; - image = ELF_HdrIs64Bit(elf.hdr.e_ident) ? ExecutableImageKind_Elf64 : ExecutableImageKind_Elf32; - image_name = elf_name; - image_data = elf_data; - debug_name = elf_name; - debug_data = elf_data; - goto driver_found; - } - - // - // Input ELF is .debug - // - B32 is_debug_elf = !is_elf_present && is_elf_debug_present && has_elf_debug_dwarf; - if (is_debug_elf) { - driver = RC_Driver_Dwarf; - image = ELF_HdrIs64Bit(elf_debug.hdr.e_ident) ? ExecutableImageKind_Elf64 : ExecutableImageKind_Elf32; - debug_name = elf_debug_name; - debug_data = elf_debug_data; - goto driver_found; - } - } - - // - // Input is PDB - // - if (is_pdb_present) { - if (driver == RC_Driver_Null || driver == RC_Driver_Pdb) { - driver = RC_Driver_Pdb; - debug_name = pdb_name; - debug_data = pdb_data; - goto driver_found; - } else if (driver == RC_Driver_Dwarf) { - fprintf(stderr, "error: unable to select DWARF conversion driver because convert doesn't support PDB as input format.\n"); - os_abort(1); - } else { - InvalidPath; - } - } - - driver_found:; - - // - // Handle -out param - // - String8 out_name = {0}; - if (cmd_line_has_flag(cmdl, str8_lit("out"))) { - out_name = cmd_line_string(cmdl, str8_lit("out")); - if (out_name.size == 0) { - fprintf(stderr, "error: -out parameter doesn't have a value\n"); - os_abort(1); - } - } else { - if (image_name.size) { - out_name = path_replace_file_extension(arena, image_name, str8_lit("rdi")); - } else { - out_name = path_replace_file_extension(arena, debug_name, str8_lit("rdi")); - } - } - - - // - // Validate driver input - // - if (driver == RC_Driver_Pdb && - !is_pdb_present && (is_elf_present || is_elf_debug_present)) { - fprintf(stderr, "error: DWARF is an invalid input for PDB driver\n"); - os_abort(1); - } - - - RC_Context ctx = {0}; - ctx.driver = driver; - ctx.image = image; - ctx.image_name = image_name; - ctx.image_data = image_data; - ctx.debug_name = debug_name; - ctx.debug_data = debug_data; - ctx.flags = RC_Flag_Strings| - RC_Flag_IndexRuns| - RC_Flag_BinarySections| - RC_Flag_Units| - RC_Flag_Procedures| - RC_Flag_GlobalVariables| - RC_Flag_ThreadVariables| - RC_Flag_Scopes| - RC_Flag_Locals| - RC_Flag_Types| - RC_Flag_UDTs| - RC_Flag_LineInfo| - RC_Flag_GlobalVariableNameMap| - RC_Flag_ThreadVariableNameMap| - RC_Flag_ProcedureNameMap| - RC_Flag_TypeNameMap| - RC_Flag_LinkNameProcedureNameMap| - RC_Flag_NormalSourcePathNameMap; - if (check_guid) { - ctx.flags |= RC_Flag_CheckPdbGuid; - ctx.guid = pe_pdb_guid; - } - if (elf_has_debug_link) { - ctx.flags |= RC_Flag_CheckElfChecksum; - ctx.debug_link = debug_link; - } - ctx.out_name = out_name; - - scratch_end(scratch); - return ctx; -} - -internal String8List -rc_run(Arena *arena, RC_Context *rc) -{ - Temp scratch = scratch_begin(&arena, 1); - - ProfBegin("Convert"); - RDIM_LocalState *local_state = rdim_local_init(); - RDIM_BakeParams *convert2bake = 0; - switch (rc->driver) { - case RC_Driver_Null: break; - case RC_Driver_Dwarf: convert2bake = d2r_convert(scratch.arena, local_state, rc); break; - case RC_Driver_Pdb: convert2bake = p2r_convert(scratch.arena, local_state, rc); break; - } - ProfEnd(); - - if (rc->errors.node_count) { - NotImplemented; - } - - ProfBegin("Bake"); - RDIM_BakeResults bake2srlz = rdim_bake(local_state, convert2bake); - ProfEnd(); - - ProfBegin("Serialize Bake"); - RDIM_SerializedSectionBundle srlz2file = rdim_serialized_section_bundle_from_bake_results(&bake2srlz); - ProfEnd(); - - RDIM_SerializedSectionBundle srlz2file_compressed = srlz2file; - if (rc->flags & RC_Flag_Compress) { - ProfBegin("Compress"); - srlz2file_compressed = rdim_compress(scratch.arena, &srlz2file); - ProfEnd(); - } - - ProfBegin("Serialize"); - String8List raw_rdi = rdim_file_blobs_from_section_bundle(scratch.arena, &srlz2file_compressed); - ProfEnd(); - - scratch_end(scratch); - return raw_rdi; -} - -internal String8 -rc_rdi_from_cmd_line(Arena *arena, CmdLine *cmdl) -{ - Temp scratch = scratch_begin(&arena, 1); - RC_Context rc = rc_context_from_cmd_line(scratch.arena, cmdl); - String8List raw_rdi = rc_run(scratch.arena, &rc); - String8 result = str8_list_join(arena, &raw_rdi, 0); - scratch_end(scratch); - return result; -} - -internal void -rc_main(CmdLine *cmdl) -{ - B32 do_help = (cmd_line_has_flag(cmdl, str8_lit("help")) || - cmd_line_has_flag(cmdl, str8_lit("h")) || - cmd_line_has_flag(cmdl, str8_lit("?")) || - cmdl->argc == 1); - if (do_help) { - fprintf(stderr, "--- Help ---------------------------------------------------------------------\n"); - fprintf(stderr, " %s\n\n", BUILD_TITLE_STRING_LITERAL); - fprintf(stderr, " Usage: radcon [Options] [Files]\n\n"); - fprintf(stderr, " Options:\n"); - fprintf(stderr, " -pe: Path to Win32 executable image\n"); - fprintf(stderr, " -pdb: Path to PDB\n"); - fprintf(stderr, " -elf: Path to ELF\n"); - fprintf(stderr, " -elf_debug: Path to ELF with debug info\n"); - fprintf(stderr, " -out: Path at which the output RDI debug info will be written\n"); - fprintf(stderr, " -driver: Sets converter for debug info\n"); - } else { - Temp scratch = scratch_begin(0,0); - - // make converter context - RC_Context rc = rc_context_from_cmd_line(scratch.arena, cmdl); - - // make RDI from context - String8List raw_rdi = rc_run(scratch.arena, &rc); - - // output RDI - if (rc.errors.node_count == 0) { - if (!os_write_data_list_to_file_path(rc.out_name, raw_rdi)) { - str8_list_pushf(scratch.arena, &rc.errors, "no write access to path %.*s", str8_varg(rc.out_name)); - } - } - - // report any errors - for (String8Node *error_n = rc.errors.first; error_n != 0; error_n = error_n->next) { - fprintf(stderr, "error: %.*s\n", str8_varg(error_n->string)); - } - - scratch_end(scratch); - } -} - diff --git a/src/radcon/radcon.h b/src/radcon/radcon.h deleted file mode 100644 index 06458d85..00000000 --- a/src/radcon/radcon.h +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#ifndef RADCON_H -#define RADCON_H - -typedef U32 RC_Flags; -enum -{ - RC_Flag_Strings = (1 << 0), - RC_Flag_IndexRuns = (1 << 1), - RC_Flag_BinarySections = (1 << 2), - RC_Flag_Units = (1 << 3), - RC_Flag_Procedures = (1 << 4), - RC_Flag_GlobalVariables = (1 << 5), - RC_Flag_ThreadVariables = (1 << 6), - RC_Flag_Scopes = (1 << 7), - RC_Flag_Locals = (1 << 8), - RC_Flag_Types = (1 << 9), - RC_Flag_UDTs = (1 << 10), - RC_Flag_LineInfo = (1 << 11), - RC_Flag_GlobalVariableNameMap = (1 << 12), - RC_Flag_ThreadVariableNameMap = (1 << 13), - RC_Flag_ProcedureNameMap = (1 << 14), - RC_Flag_TypeNameMap = (1 << 15), - RC_Flag_LinkNameProcedureNameMap= (1 << 16), - RC_Flag_NormalSourcePathNameMap = (1 << 17), - RC_Flag_Compress = (1 << 18), - RC_Flag_StrictDwarfParse = (1 << 19), - RC_Flag_Deterministic = (1 << 20), - RC_Flag_CheckPdbGuid = (1 << 21), - RC_Flag_CheckElfChecksum = (1 << 22), - RC_Flag_All = 0xffffffff, -}; - -typedef enum -{ - RC_Driver_Null, - RC_Driver_Dwarf, - RC_Driver_Pdb, -} RC_Driver; - -typedef struct RC_Context -{ - ExecutableImageKind image; - RC_Driver driver; - String8 image_name; - String8 image_data; - String8 debug_name; - String8 debug_data; - String8 out_name; - RC_Flags flags; - Guid guid; - ELF_GnuDebugLink debug_link; - String8List errors; -} RC_Context; - -//////////////////////////////// - -internal RC_Context rc_context_from_cmd_line(Arena *arena, CmdLine *cmdl); -internal String8List rc_run(Arena *arena, RC_Context *rc); -internal String8 rc_rdi_from_cmd_line(Arena *arena, CmdLine *cmdl); -internal void rc_main(CmdLine *cmdl); - -#endif // RADCON_H - diff --git a/src/radcon/radcon_main.c b/src/radcon/radcon_main.c deleted file mode 100644 index 0681750f..00000000 --- a/src/radcon/radcon_main.c +++ /dev/null @@ -1,94 +0,0 @@ -// Copyright (c) Epic Games Tools -// Licensed under the MIT license (https://opensource.org/license/mit/) - -#define BUILD_TITLE "Epic Games Tools (R) RAD Debug Info Converter" -#define BUILD_CONSOLE_INTERFACE 1 - -//////////////////////////////// -// Third Party - -#include "third_party/rad_lzb_simple/rad_lzb_simple.h" -#include "third_party/rad_lzb_simple/rad_lzb_simple.c" -#define XXH_STATIC_LINKING_ONLY -#include "third_party/xxHash/xxhash.c" -#include "third_party/xxHash/xxhash.h" -#define SINFL_IMPLEMENTATION -#include "third_party/sinfl/sinfl.h" -#include "third_party/radsort/radsort.h" - -//////////////////////////////// -// RDI Format Library - -#include "lib_rdi_format/rdi_format.h" -#include "lib_rdi_format/rdi_format.c" - -//////////////////////////////// -// Headers - -#include "base/base_inc.h" -#include "os/os_inc.h" -#include "async/async.h" -#include "rdi_make/rdi_make_local.h" -#include "linker/hash_table.h" -#include "coff/coff.h" -#include "coff/coff_parse.h" -#include "pe/pe.h" -#include "elf/elf.h" -#include "elf/elf_parse.h" -#include "codeview/codeview.h" -#include "codeview/codeview_parse.h" -#include "dwarf/dwarf.h" -#include "dwarf/dwarf_parse.h" -#include "dwarf/dwarf_coff.h" -#include "dwarf/dwarf_elf.h" -#include "msf/msf.h" -#include "msf/msf_parse.h" -#include "pdb/pdb.h" -#include "pdb/pdb_parse.h" -#include "pdb/pdb_stringize.h" -#include "radcon.h" -#include "radcon_coff.h" -#include "radcon_elf.h" -#include "radcon_cv.h" -#include "radcon_dwarf.h" -#include "radcon_pdb.h" - -//////////////////////////////// -// Implementations - -#include "base/base_inc.c" -#include "os/os_inc.c" -#include "async/async.c" -#include "rdi_make/rdi_make_local.c" -#include "linker/hash_table.c" -#include "coff/coff.c" -#include "coff/coff_parse.c" -#include "pe/pe.c" -#include "elf/elf.c" -#include "elf/elf_parse.c" -#include "codeview/codeview.c" -#include "codeview/codeview_parse.c" -#include "msf/msf.c" -#include "msf/msf_parse.c" -#include "pdb/pdb.c" -#include "pdb/pdb_parse.c" -#include "pdb/pdb_stringize.c" -#include "dwarf/dwarf.c" -#include "dwarf/dwarf_parse.c" -#include "dwarf/dwarf_coff.c" -#include "dwarf/dwarf_elf.c" -#include "radcon.c" -#include "radcon_coff.c" -#include "radcon_elf.c" -#include "radcon_cv.c" -#include "radcon_dwarf.c" -#include "radcon_pdb.c" - -//////////////////////////////// - -internal void -entry_point(CmdLine *cmdl) -{ - rc_main(cmdl); -} - diff --git a/src/raddump/raddump.c b/src/raddump/raddump.c index edb6a2f4..04192a6d 100644 --- a/src/raddump/raddump.c +++ b/src/raddump/raddump.c @@ -275,7 +275,7 @@ rd_format_preamble(Arena *arena, String8List *out, String8 indent, String8 input DateTime universal_dt = os_now_universal_time(); DateTime local_dt = os_local_time_from_universal(&universal_dt); - String8 time = push_date_time_string(scratch.arena, &local_dt); + String8 time = string_from_date_time(scratch.arena, &local_dt); String8 full_path = os_full_path_from_path(scratch.arena, input_path); rd_printf("# %S, [%S] %S", time, input_type_string, full_path); diff --git a/src/scratch/parse_inline_sites.c b/src/scratch/parse_inline_sites.c index f6ae9eed..bd2bb656 100644 --- a/src/scratch/parse_inline_sites.c +++ b/src/scratch/parse_inline_sites.c @@ -266,7 +266,7 @@ entry_point(CmdLine *cmdl) // print run info DateTime now_time_universal = os_now_universal_time(); DateTime now_time_local = os_local_time_from_universal_time(&now_time_universal); - String8 now_time_str = push_date_time_string(arena, &now_time_local); + String8 now_time_str = string_from_date_time(arena, &now_time_local); fprintf(stdout, "Time: %.*s\n", str8_varg(now_time_str)); fprintf(stdout, "File: %.*s\n", str8_varg(pdb_name)); fprintf(stdout, "Size: %llu (bytes)\n", pdb_data.size);