ps
/
4coder
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4coder/custom/generated/lexer_cpp.cpp

5154 lines
108 KiB
C++
Raw Normal View History

new lexer
2019-09-27 03:52:29 +00:00
#if !defined(FCODER_LEX_GEN_HAND_WRITTEN)
#define FCODER_LEX_GEN_HAND_WRITTEN
internal u64
lexeme_hash(u64 seed, u8 *ptr, umem size){
u64 result = 0;
for (umem i = 0; i < size; i += 1, ptr += 1){
result ^= ((*ptr) ^ result*59) + seed;
}
return(result);
}
internal Lexeme_Table_Lookup
lexeme_table_lookup(u64 *hash_array, String_Const_u8 *key_array,
Lexeme_Table_Value *value_array, i32 slot_count, u64 seed,
u8 *ptr, umem size){
Lexeme_Table_Lookup result = {};
u64 hash = lexeme_hash(seed, ptr, size);
u64 comparison_hash = hash | 1;
i32 first_index = (hash % slot_count);
i32 index = first_index;
for (;;){
if (hash_array[index] == comparison_hash){
if (string_match(SCu8(ptr, size), key_array[index])){
result.found_match = true;
result.base_kind = value_array[index].base_kind;
result.sub_kind = value_array[index].sub_kind;
break;
}
}
else if (hash_array[index] == 0){
break;
}
index += 1;
if (index == slot_count){
index = 0;
}
if (index == first_index){
break;
}
}
return(result);
}
#endif
lexer with breaks
2019-10-22 05:53:47 +00:00
u64 main_keys_hash_array[125] = {
0x0000000000000000,0x0000000000000000,0xae0dc40193b178f9,0xb96986ad74366239,
0xae0dc4007d2799c3,0x0000000000000000,0x6b890ab6607df9f5,0xfe4cf8e09552fd7d,
0xb96986abf449ab87,0x0ce3b6f3f2ae6d8b,0xb96986b1e4d5012d,0x0000000000000000,
0xae0dc4006a46609d,0xbae13981c29d9e93,0xb96986ac8864fc5b,0x0000000000000000,
0xfe4cdd7782bcdf87,0x0000000000000000,0x27dc518216dc92b9,0x0000000000000000,
0x0000000000000000,0x0ce3a6b2ed33a3f3,0xb6c16efd6d7f8691,0x0000000000000000,
0x5f1d5c76d1541da9,0x0000000000000000,0x0000000000000000,0xae0dc4006ef1e009,
0xb96986ad76870c01,0xb96986aba21ca901,0xb96986ae1e791a09,0xfe4cda48543d15eb,
0x0000000000000000,0xfe4c21260e153663,0xbae13981c29e1649,0xae0dc4007c306d83,
0x0000000000000000,0x0000000000000000,0x0000000000000000,0xfe53a22c8fba72db,
0x0000000000000000,0x0000000000000000,0xfe4c3c0e0a6459c3,0x0000000000000000,
0x0000000000000000,0x482db76ef4a7c2b9,0x0000000000000000,0x0000000000000000,
0xb96986adef80de03,0xbae13981c29e443f,0x0000000000000000,0x0000000000000000,
0x0000000000000000,0xfe4c3b126f24e73b,0x0000000000000000,0x0000000000000000,
0xb6c16efd6d5e9039,0x0ce3a73cf2370b75,0x0000000000000000,0x0000000000000000,
0x0000000000000000,0x0ce3a6cd0e243afd,0xae0dc4006d60a3dd,0xb6c16efd6d33baeb,
0x0000000000000000,0x0000000000000000,0xae0dc4007c1e53d9,0xfe50f7d974bbaa05,
0xb96986acb1e73223,0xb96986ad72de7ddd,0xb96986ae0d38e84b,0x0000000000000000,
0x0000000000000000,0xfe4c3b65bbba43b3,0x320c5ad54842e269,0xb6c16efd6d7eb2db,
0x0000000000000000,0x0000000000000000,0x0000000000000000,0x0000000000000000,
0xb6c16efd6d41ec49,0xb6c16efd6d3ad8c3,0xb6c16efd6d79768d,0x0000000000000000,
0x0ce3a725764fbd37,0x0000000000000000,0xb6c16efd6d326823,0xae0dc4006a76982b,
0x0000000000000000,0x0000000000000000,0xae0dc40193bc7f19,0xa48abde904c1baf9,
0x0000000000000000,0x0000000000000000,0x0000000000000000,0x0000000000000000,
0x0000000000000000,0xb6c16efd6d379001,0x0000000000000000,0x0000000000000000,
0x0000000000000000,0x0000000000000000,0xb96986ae0d2c0de5,0x0000000000000000,
0xb96986ac4109bb39,0x0000000000000000,0x5ee5e1225dabbaf9,0x6b8a48a90953eeab,
0x0000000000000000,0x0000000000000000,0x0000000000000000,0x0000000000000000,
0xb6c16efd6d3a30eb,0xb96986ae1e53e287,0xfe4c6461b7a951e5,0x0000000000000000,
0xbae13981c29ded97,0xbae13981c29dde75,0x5f1d5c76d1541c8f,0x0000000000000000,
0x0ce3b6f5b502c4ff,0x0000000000000000,0xae0dc4006c0426b9,0x0ce3b6f3f2ae5611,
0xc8cfe7a5027aeab5,
new lexer
2019-09-27 03:52:29 +00:00
};
lexer with breaks
2019-10-22 05:53:47 +00:00
u8 main_keys_key_array_2[] = {0x63,0x6f,0x6e,0x73,0x74,};
u8 main_keys_key_array_3[] = {0x73,0x74,0x72,0x75,0x63,0x74,};
u8 main_keys_key_array_4[] = {0x77,0x68,0x69,0x6c,0x65,};
u8 main_keys_key_array_6[] = {0x70,0x72,0x6f,0x74,0x65,0x63,0x74,0x65,0x64,};
u8 main_keys_key_array_7[] = {0x65,0x78,0x70,0x6c,0x69,0x63,0x69,0x74,};
u8 main_keys_key_array_8[] = {0x72,0x65,0x74,0x75,0x72,0x6e,};
u8 main_keys_key_array_9[] = {0x61,0x6c,0x69,0x67,0x6e,0x6f,0x66,};
u8 main_keys_key_array_10[] = {0x74,0x79,0x70,0x65,0x69,0x64,};
u8 main_keys_key_array_12[] = {0x66,0x6c,0x6f,0x61,0x74,};
u8 main_keys_key_array_13[] = {0x61,0x73,0x6d,};
u8 main_keys_key_array_14[] = {0x69,0x6e,0x6c,0x69,0x6e,0x65,};
u8 main_keys_key_array_16[] = {0x6f,0x70,0x65,0x72,0x61,0x74,0x6f,0x72,};
u8 main_keys_key_array_18[] = {0x73,0x74,0x61,0x74,0x69,0x63,0x5f,0x63,0x61,0x73,0x74,};
u8 main_keys_key_array_21[] = {0x70,0x72,0x69,0x76,0x61,0x74,0x65,};
u8 main_keys_key_array_22[] = {0x74,0x68,0x69,0x73,};
u8 main_keys_key_array_24[] = {0x64,0x6f,};
u8 main_keys_key_array_27[] = {0x73,0x68,0x6f,0x72,0x74,};
u8 main_keys_key_array_28[] = {0x73,0x74,0x61,0x74,0x69,0x63,};
u8 main_keys_key_array_29[] = {0x70,0x75,0x62,0x6c,0x69,0x63,};
u8 main_keys_key_array_30[] = {0x65,0x78,0x70,0x6f,0x72,0x74,};
u8 main_keys_key_array_31[] = {0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,};
u8 main_keys_key_array_33[] = {0x64,0x65,0x63,0x6c,0x74,0x79,0x70,0x65,};
u8 main_keys_key_array_34[] = {0x69,0x6e,0x74,};
u8 main_keys_key_array_35[] = {0x75,0x6e,0x69,0x6f,0x6e,};
u8 main_keys_key_array_39[] = {0x63,0x6f,0x6e,0x74,0x69,0x6e,0x75,0x65,};
u8 main_keys_key_array_42[] = {0x76,0x6f,0x6c,0x61,0x74,0x69,0x6c,0x65,};
u8 main_keys_key_array_45[] = {0x64,0x79,0x6e,0x61,0x6d,0x69,0x63,0x5f,0x63,0x61,0x73,0x74,};
u8 main_keys_key_array_48[] = {0x64,0x6f,0x75,0x62,0x6c,0x65,};
u8 main_keys_key_array_49[] = {0x74,0x72,0x79,};
u8 main_keys_key_array_53[] = {0x74,0x79,0x70,0x65,0x6e,0x61,0x6d,0x65,};
u8 main_keys_key_array_56[] = {0x6c,0x6f,0x6e,0x67,};
u8 main_keys_key_array_57[] = {0x76,0x69,0x72,0x74,0x75,0x61,0x6c,};
u8 main_keys_key_array_61[] = {0x64,0x65,0x66,0x61,0x75,0x6c,0x74,};
u8 main_keys_key_array_62[] = {0x63,0x61,0x74,0x63,0x68,};
u8 main_keys_key_array_63[] = {0x63,0x61,0x73,0x65,};
u8 main_keys_key_array_66[] = {0x75,0x73,0x69,0x6e,0x67,};
u8 main_keys_key_array_67[] = {0x6e,0x6f,0x65,0x78,0x63,0x65,0x70,0x74,};
u8 main_keys_key_array_68[] = {0x64,0x65,0x6c,0x65,0x74,0x65,};
u8 main_keys_key_array_69[] = {0x73,0x77,0x69,0x74,0x63,0x68,};
u8 main_keys_key_array_70[] = {0x73,0x69,0x7a,0x65,0x6f,0x66,};
u8 main_keys_key_array_73[] = {0x74,0x65,0x6d,0x70,0x6c,0x61,0x74,0x65,};
u8 main_keys_key_array_74[] = {0x73,0x74,0x61,0x74,0x69,0x63,0x5f,0x61,0x73,0x73,0x65,0x72,0x74,};
u8 main_keys_key_array_75[] = {0x74,0x72,0x75,0x65,};
u8 main_keys_key_array_80[] = {0x67,0x6f,0x74,0x6f,};
u8 main_keys_key_array_81[] = {0x65,0x6e,0x75,0x6d,};
u8 main_keys_key_array_82[] = {0x76,0x6f,0x69,0x64,};
u8 main_keys_key_array_84[] = {0x74,0x79,0x70,0x65,0x64,0x65,0x66,};
u8 main_keys_key_array_86[] = {0x63,0x68,0x61,0x72,};
u8 main_keys_key_array_87[] = {0x66,0x61,0x6c,0x73,0x65,};
u8 main_keys_key_array_90[] = {0x63,0x6c,0x61,0x73,0x73,};
u8 main_keys_key_array_91[] = {0x72,0x65,0x69,0x6e,0x74,0x65,0x72,0x70,0x72,0x65,0x74,0x5f,0x63,0x61,0x73,0x74,};
u8 main_keys_key_array_97[] = {0x62,0x6f,0x6f,0x6c,};
u8 main_keys_key_array_102[] = {0x73,0x69,0x67,0x6e,0x65,0x64,};
u8 main_keys_key_array_104[] = {0x66,0x72,0x69,0x65,0x6e,0x64,};
u8 main_keys_key_array_106[] = {0x63,0x6f,0x6e,0x73,0x74,0x5f,0x63,0x61,0x73,0x74,};
u8 main_keys_key_array_107[] = {0x6e,0x61,0x6d,0x65,0x73,0x70,0x61,0x63,0x65,};
u8 main_keys_key_array_112[] = {0x65,0x6c,0x73,0x65,};
u8 main_keys_key_array_113[] = {0x65,0x78,0x74,0x65,0x72,0x6e,};
u8 main_keys_key_array_114[] = {0x75,0x6e,0x73,0x69,0x67,0x6e,0x65,0x64,};
u8 main_keys_key_array_116[] = {0x66,0x6f,0x72,};
u8 main_keys_key_array_117[] = {0x6e,0x65,0x77,};
u8 main_keys_key_array_118[] = {0x69,0x66,};
u8 main_keys_key_array_120[] = {0x6e,0x75,0x6c,0x6c,0x70,0x74,0x72,};
u8 main_keys_key_array_122[] = {0x62,0x72,0x65,0x61,0x6b,};
u8 main_keys_key_array_123[] = {0x61,0x6c,0x69,0x67,0x6e,0x61,0x73,};
u8 main_keys_key_array_124[] = {0x74,0x68,0x72,0x65,0x61,0x64,0x5f,0x6c,0x6f,0x63,0x61,0x6c,};
String_Const_u8 main_keys_key_array[125] = {
{0, 0},
{0, 0},
{main_keys_key_array_2, 5},
{main_keys_key_array_3, 6},
{main_keys_key_array_4, 5},
{0, 0},
{main_keys_key_array_6, 9},
{main_keys_key_array_7, 8},
{main_keys_key_array_8, 6},
{main_keys_key_array_9, 7},
{main_keys_key_array_10, 6},
{0, 0},
{main_keys_key_array_12, 5},
{main_keys_key_array_13, 3},
{main_keys_key_array_14, 6},
{0, 0},
{main_keys_key_array_16, 8},
{0, 0},
{main_keys_key_array_18, 11},
{0, 0},
{0, 0},
{main_keys_key_array_21, 7},
{main_keys_key_array_22, 4},
{0, 0},
{main_keys_key_array_24, 2},
{0, 0},
{0, 0},
{main_keys_key_array_27, 5},
{main_keys_key_array_28, 6},
{main_keys_key_array_29, 6},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{main_keys_key_array_30, 6},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_31, 8},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_33, 8},
{main_keys_key_array_34, 3},
{main_keys_key_array_35, 5},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_39, 8},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_42, 8},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_45, 12},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_48, 6},
{main_keys_key_array_49, 3},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_53, 8},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_56, 4},
{main_keys_key_array_57, 7},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_61, 7},
{main_keys_key_array_62, 5},
{main_keys_key_array_63, 4},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_66, 5},
{main_keys_key_array_67, 8},
{main_keys_key_array_68, 6},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{main_keys_key_array_69, 6},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_70, 6},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{main_keys_key_array_73, 8},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_74, 13},
{main_keys_key_array_75, 4},
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{0, 0},
{main_keys_key_array_80, 4},
{main_keys_key_array_81, 4},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{main_keys_key_array_82, 4},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_84, 7},
{0, 0},
{main_keys_key_array_86, 4},
{main_keys_key_array_87, 5},
{0, 0},
{0, 0},
{main_keys_key_array_90, 5},
{main_keys_key_array_91, 16},
{0, 0},
{0, 0},
{0, 0},
{0, 0},
{0, 0},
{main_keys_key_array_97, 4},
{0, 0},
{0, 0},
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_102, 6},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_104, 6},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_106, 10},
{main_keys_key_array_107, 9},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_112, 4},
{main_keys_key_array_113, 6},
{main_keys_key_array_114, 8},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_116, 3},
{main_keys_key_array_117, 3},
{main_keys_key_array_118, 2},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_120, 7},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{main_keys_key_array_122, 5},
{main_keys_key_array_123, 7},
{main_keys_key_array_124, 12},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
};
lexer with breaks
2019-10-22 05:53:47 +00:00
Lexeme_Table_Value main_keys_value_array[125] = {
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Const},
{4, TokenCppKind_Struct},
{4, TokenCppKind_While},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Protected},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{4, TokenCppKind_Explicit},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Return},
{4, TokenCppKind_AlignOf},
{4, TokenCppKind_TypeID},
{0, 0},
{4, TokenCppKind_Float},
{4, TokenCppKind_Asm},
{4, TokenCppKind_Inline},
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Operator},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_StaticCast},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{0, 0},
{4, TokenCppKind_Private},
{4, TokenCppKind_This},
{0, 0},
{4, TokenCppKind_Do},
{0, 0},
{0, 0},
{4, TokenCppKind_Short},
{4, TokenCppKind_Static},
{4, TokenCppKind_Public},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{4, TokenCppKind_Export},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Register},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_DeclType},
{4, TokenCppKind_Int},
{4, TokenCppKind_Union},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Continue},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Volatile},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_DynamicCast},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Double},
{4, TokenCppKind_Try},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{0, 0},
{4, TokenCppKind_Typename},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Long},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{4, TokenCppKind_Virtual},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Default},
{4, TokenCppKind_Catch},
{4, TokenCppKind_Case},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Using},
{4, TokenCppKind_NoExcept},
{4, TokenCppKind_Delete},
{4, TokenCppKind_Switch},
{4, TokenCppKind_SizeOf},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{0, 0},
{4, TokenCppKind_Template},
{4, TokenCppKind_StaticAssert},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{8, TokenCppKind_LiteralTrue},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Goto},
{4, TokenCppKind_Enum},
{4, TokenCppKind_Void},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
{4, TokenCppKind_Typedef},
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Char},
{8, TokenCppKind_LiteralFalse},
{0, 0},
{0, 0},
{4, TokenCppKind_Class},
{4, TokenCppKind_ReinterpretCast},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{4, TokenCppKind_Bool},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Signed},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Friend},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_ConstCast},
{4, TokenCppKind_Namespace},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_Else},
{4, TokenCppKind_Extern},
{4, TokenCppKind_Unsigned},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_For},
{4, TokenCppKind_New},
{4, TokenCppKind_If},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{4, TokenCppKind_NullPtr},
{0, 0},
{4, TokenCppKind_Break},
{4, TokenCppKind_AlignAs},
{4, TokenCppKind_ThreadLocal},
new lexer
2019-09-27 03:52:29 +00:00
};
lexer with breaks
2019-10-22 05:53:47 +00:00
i32 main_keys_slot_count = 125;
u64 main_keys_seed = 0xfa381694d5674125;
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
u64 pp_directives_hash_array[25] = {
lexer with breaks
2019-10-22 05:53:47 +00:00
0x0000000000000000,0x34b86dc413bdc61d,0x0000000000000000,0xcc5e69206f9dddbd,
0x0000000000000000,0x65f024ddd53ade19,0x65f02489c656353d,0x0000000000000000,
0xcc5e69207d2543bd,0x35db8e7164ab1e55,0x6bb45a7c34b15b09,0x35db8e7164f625dd,
0x0000000000000000,0x0000000000000000,0x35db8e7164ab3649,0xcc5e692189cbad79,
0x0000000000000000,0xcc5e69207d6608a3,0x0000000000000000,0x0000000000000000,
0x65f02488282ecfbd,0x6bb4b5a2472171e5,0xcc5e6921a27c7d55,0x0000000000000000,
0x65f02489e6243cc7,
new lexer
2019-09-27 03:52:29 +00:00
};
lexer with breaks
2019-10-22 05:53:47 +00:00
u8 pp_directives_key_array_1[] = {0x69,0x66,};
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
u8 pp_directives_key_array_3[] = {0x69,0x66,0x64,0x65,0x66,};
u8 pp_directives_key_array_5[] = {0x70,0x72,0x61,0x67,0x6d,0x61,};
lexer with breaks
2019-10-22 05:53:47 +00:00
u8 pp_directives_key_array_6[] = {0x64,0x65,0x66,0x69,0x6e,0x65,};
u8 pp_directives_key_array_8[] = {0x75,0x6e,0x64,0x65,0x66,};
u8 pp_directives_key_array_9[] = {0x65,0x6c,0x69,0x66,};
u8 pp_directives_key_array_10[] = {0x69,0x6e,0x63,0x6c,0x75,0x64,0x65,};
u8 pp_directives_key_array_11[] = {0x6c,0x69,0x6e,0x65,};
u8 pp_directives_key_array_14[] = {0x65,0x6c,0x73,0x65,};
u8 pp_directives_key_array_15[] = {0x65,0x72,0x72,0x6f,0x72,};
u8 pp_directives_key_array_17[] = {0x75,0x73,0x69,0x6e,0x67,};
u8 pp_directives_key_array_20[] = {0x69,0x66,0x6e,0x64,0x65,0x66,};
u8 pp_directives_key_array_21[] = {0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,};
u8 pp_directives_key_array_22[] = {0x65,0x6e,0x64,0x69,0x66,};
u8 pp_directives_key_array_24[] = {0x69,0x6d,0x70,0x6f,0x72,0x74,};
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
String_Const_u8 pp_directives_key_array[25] = {
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_directives_key_array_1, 2},
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
{0, 0},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{pp_directives_key_array_3, 5},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{pp_directives_key_array_5, 6},
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_directives_key_array_6, 6},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_directives_key_array_8, 5},
{pp_directives_key_array_9, 4},
{pp_directives_key_array_10, 7},
{pp_directives_key_array_11, 4},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_directives_key_array_14, 4},
{pp_directives_key_array_15, 5},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_directives_key_array_17, 5},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_directives_key_array_20, 6},
{pp_directives_key_array_21, 7},
{pp_directives_key_array_22, 5},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_directives_key_array_24, 6},
new lexer
2019-09-27 03:52:29 +00:00
};
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
Lexeme_Table_Value pp_directives_value_array[25] = {
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{5, TokenCppKind_PPIf},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{5, TokenCppKind_PPIfDef},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
{5, TokenCppKind_PPPragma},
lexer with breaks
2019-10-22 05:53:47 +00:00
{5, TokenCppKind_PPDefine},
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
{0, 0},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{5, TokenCppKind_PPUndef},
{5, TokenCppKind_PPElIf},
lexer with breaks
2019-10-22 05:53:47 +00:00
{5, TokenCppKind_PPInclude},
{5, TokenCppKind_PPLine},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{5, TokenCppKind_PPElse},
{5, TokenCppKind_PPError},
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{0, 0},
Fallback command maps in view context
2019-10-20 01:46:57 +00:00
{5, TokenCppKind_PPUsing},
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
lexer with breaks
2019-10-22 05:53:47 +00:00
{5, TokenCppKind_PPIfNDef},
{5, TokenCppKind_PPVersion},
{5, TokenCppKind_PPEndIf},
{0, 0},
{5, TokenCppKind_PPImport},
new lexer
2019-09-27 03:52:29 +00:00
};
Reorganized files for lexer generation
2019-10-01 23:34:54 +00:00
i32 pp_directives_slot_count = 25;
lexer with breaks
2019-10-22 05:53:47 +00:00
u64 pp_directives_seed = 0x8fec132e93357a37;
new lexer
2019-09-27 03:52:29 +00:00
u64 pp_keys_hash_array[2] = {
lexer with breaks
2019-10-22 05:53:47 +00:00
0xaa00330834c0d751,0x0000000000000000,
new lexer
2019-09-27 03:52:29 +00:00
};
lexer with breaks
2019-10-22 05:53:47 +00:00
u8 pp_keys_key_array_0[] = {0x64,0x65,0x66,0x69,0x6e,0x65,0x64,};
new lexer
2019-09-27 03:52:29 +00:00
String_Const_u8 pp_keys_key_array[2] = {
lexer with breaks
2019-10-22 05:53:47 +00:00
{pp_keys_key_array_0, 7},
new lexer
2019-09-27 03:52:29 +00:00
{0, 0},
};
Lexeme_Table_Value pp_keys_value_array[2] = {
Fix scroll/cursor linking (need more generic version though); cleanup access system; remove some unecessary enum types
2019-10-18 02:54:02 +00:00
{4, TokenCppKind_PPDefined},
lexer with breaks
2019-10-22 05:53:47 +00:00
{0, 0},
new lexer
2019-09-27 03:52:29 +00:00
};
i32 pp_keys_slot_count = 2;
lexer with breaks
2019-10-22 05:53:47 +00:00
u64 pp_keys_seed = 0x444d48e552bc237e;
struct Lex_State_Cpp{
u32 flags_ZF0;
u32 flags_KF0;
u16 flags_KB0;
u8 *base;
u8 *delim_first;
u8 *delim_one_past_last;
u8 *emit_ptr;
u8 *ptr;
u8 *opl_ptr;
};
internal void
lex_full_input_cpp_init(Lex_State_Cpp *state_ptr, String_Const_u8 input){
state_ptr->flags_ZF0 = 0;
state_ptr->flags_KF0 = 0;
state_ptr->flags_KB0 = 0;
state_ptr->base = input.str;
state_ptr->delim_first = input.str;
state_ptr->delim_one_past_last = input.str;
state_ptr->emit_ptr = input.str;
state_ptr->ptr = input.str;
state_ptr->opl_ptr = input.str + input.size;
}
internal b32
lex_full_input_cpp_breaks(Arena *arena, Token_List *list, Lex_State_Cpp *state_ptr, u64 max){
b32 result = false;
u64 emit_counter = 0;
Lex_State_Cpp state;
block_copy_struct(&state, state_ptr);
new lexer
2019-09-27 03:52:29 +00:00
{
state_label_1: // root
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_EOF;
token.kind = 0;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
result = true;
new lexer
2019-09-27 03:52:29 +00:00
goto end;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:
case 0x07:case 0x08:case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:
case 0x13:case 0x14:case 0x15:case 0x16:case 0x17:case 0x18:case 0x19:
case 0x1a:case 0x1b:case 0x1c:case 0x1d:case 0x1e:case 0x1f:case 0x40:
case 0x60:case 0x7f:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x09:case 0x0b:case 0x0c:case 0x0d:case 0x20:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
if ((HasFlag(state.flags_KF0, 0x2))){
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_4; // error_body
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_3; // whitespace
}break;
case 0x0a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_KB0 &= ~(0x1);
state.flags_KF0 &= ~(0x1);
state.flags_KF0 &= ~(0x2);
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_3; // whitespace
}break;
case 0x21:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_60; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
if ((HasFlag(state.flags_KF0, 0x1))){
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_26; // include_quotes
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x23:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
if ((!HasFlag(state.flags_KB0, 0x1))){
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_23; // pp_directive_whitespace
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_67; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_2; // identifier
}break;
case 0x25:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_64; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x26:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_61; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x27:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x40;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x28:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_ParenOp;
token.kind = 13;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x29:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_ParenCl;
token.kind = 14;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_63; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x2b:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_53; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x2c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Comma;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_54; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x2e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_6; // operator_or_fnumber_dot
}break;
case 0x2f:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_7; // operator_or_comment_slash
}break;
case 0x30:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_9; // znumber
}break;
case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:case 0x37:
case 0x38:case 0x39:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_8; // number
}break;
case 0x3a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_52; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x3b:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Semicolon;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
if ((!HasFlag(state.flags_KF0, 0x1))){
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_56; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_25; // include_pointy
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_59; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x3e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_57; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x3f:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Ternary;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x4;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_27; // pre_L
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x52:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_31; // pre_R
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x55:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x20;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_29; // pre_U
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x5b:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_BrackOp;
token.kind = 13;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x5c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_5; // backslash
}break;
case 0x5d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_BrackCl;
token.kind = 14;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x5e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Xor;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x10;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_28; // pre_u
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x7b:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_BraceOp;
token.kind = 11;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x7c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_62; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x7d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_BraceCl;
token.kind = 12;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x7e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Tilde;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_2: // identifier
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_KB0, 0x1)){
Lexeme_Table_Lookup lookup = lexeme_table_lookup(pp_keys_hash_array, pp_keys_key_array, pp_keys_value_array, pp_keys_slot_count, pp_keys_seed, state.emit_ptr, token.size);
new lexer
2019-09-27 03:52:29 +00:00
if (lookup.found_match){
token.kind = lookup.base_kind;
token.sub_kind = lookup.sub_kind;
break;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
Lexeme_Table_Lookup lookup = lexeme_table_lookup(main_keys_hash_array, main_keys_key_array, main_keys_value_array, main_keys_slot_count, main_keys_seed, state.emit_ptr, token.size);
new lexer
2019-09-27 03:52:29 +00:00
if (lookup.found_match){
token.kind = lookup.base_kind;
token.sub_kind = lookup.sub_kind;
break;
}
token.sub_kind = TokenCppKind_Identifier;
token.kind = 6;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
case 0x00:case 0x01:case 0x02:case 0x03:case 0x04:case 0x05:case 0x06:
case 0x07:case 0x08:case 0x09:case 0x0a:case 0x0b:case 0x0c:case 0x0d:
case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:
case 0x15:case 0x16:case 0x17:case 0x18:case 0x19:case 0x1a:case 0x1b:
case 0x1c:case 0x1d:case 0x1e:case 0x1f:case 0x20:case 0x21:case 0x22:
case 0x23:case 0x25:case 0x26:case 0x27:case 0x28:case 0x29:case 0x2a:
case 0x2b:case 0x2c:case 0x2d:case 0x2e:case 0x2f:case 0x3a:case 0x3b:
case 0x3c:case 0x3d:case 0x3e:case 0x3f:case 0x40:case 0x5b:case 0x5c:
case 0x5d:case 0x5e:case 0x60:case 0x7b:case 0x7c:case 0x7d:case 0x7e:
case 0x7f:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_KB0, 0x1)){
Lexeme_Table_Lookup lookup = lexeme_table_lookup(pp_keys_hash_array, pp_keys_key_array, pp_keys_value_array, pp_keys_slot_count, pp_keys_seed, state.emit_ptr, token.size);
new lexer
2019-09-27 03:52:29 +00:00
if (lookup.found_match){
token.kind = lookup.base_kind;
token.sub_kind = lookup.sub_kind;
break;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
Lexeme_Table_Lookup lookup = lexeme_table_lookup(main_keys_hash_array, main_keys_key_array, main_keys_value_array, main_keys_slot_count, main_keys_seed, state.emit_ptr, token.size);
new lexer
2019-09-27 03:52:29 +00:00
if (lookup.found_match){
token.kind = lookup.base_kind;
token.sub_kind = lookup.sub_kind;
break;
}
token.sub_kind = TokenCppKind_Identifier;
token.kind = 6;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_2; // identifier
}break;
}
}
{
state_label_3: // whitespace
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Whitespace;
token.kind = 1;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Whitespace;
token.kind = 1;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x09:case 0x0b:case 0x0c:case 0x0d:case 0x20:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_3; // whitespace
}break;
case 0x0a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_KB0 &= ~(0x1);
state.flags_KF0 &= ~(0x1);
state.flags_KF0 &= ~(0x2);
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_3; // whitespace
}break;
}
}
{
state_label_4: // error_body
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PPErrorMessage;
token.kind = 10;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_4; // error_body
}break;
case 0x0a:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PPErrorMessage;
token.kind = 10;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_5: // backslash
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Backslash;
token.kind = 1;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Backslash;
token.kind = 1;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x0a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Backslash;
token.kind = 1;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_6: // operator_or_fnumber_dot
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Dot;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Dot;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_DotStar;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_68; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_10; // fnumber_decimal
}break;
}
}
{
state_label_7: // operator_or_comment_slash
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Div;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Div;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_49; // comment_block
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x2f:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_51; // comment_line
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_DivEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_8: // number
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralInteger;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralInteger;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_10; // fnumber_decimal
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_8; // number
}break;
case 0x45:case 0x65:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_11; // fnumber_exponent
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_18; // L_number
}break;
case 0x55:case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_17; // U_number
}break;
case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_20; // l_number
}break;
}
}
{
state_label_9: // znumber
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralInteger;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralInteger;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_10; // fnumber_decimal
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x2;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_16; // number_oct
}break;
case 0x45:case 0x65:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_11; // fnumber_exponent
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_18; // L_number
}break;
case 0x55:case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_17; // U_number
}break;
case 0x58:case 0x78:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_14; // number_hex_first
}break;
case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_20; // l_number
}break;
}
}
{
state_label_10: // fnumber_decimal
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_10; // fnumber_decimal
}break;
case 0x45:case 0x65:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_11; // fnumber_exponent
}break;
case 0x46:case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat32;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_11: // fnumber_exponent
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2b:case 0x2d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_12; // fnumber_exponent_sign
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_13; // fnumber_exponent_digits
}break;
case 0x46:case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat32;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_12: // fnumber_exponent_sign
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_13; // fnumber_exponent_digits
}break;
case 0x46:case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat32;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_13: // fnumber_exponent_digits
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_13; // fnumber_exponent_digits
}break;
case 0x46:case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat32;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralFloat64;
token.kind = 9;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_14: // number_hex_first
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_15; // number_hex
}break;
}
}
{
state_label_15: // number_hex
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralIntegerHex;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralIntegerHex;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_15; // number_hex
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_18; // L_number
}break;
case 0x55:case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_17; // U_number
}break;
case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_20; // l_number
}break;
}
}
{
state_label_16: // number_oct
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralIntegerOct;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LiteralIntegerOct;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x2;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_16; // number_oct
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_18; // L_number
}break;
case 0x55:case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_17; // U_number
}break;
case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_20; // l_number
}break;
}
}
{
state_label_17: // U_number
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexU;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctU;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerU;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexU;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctU;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerU;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_19; // UL_number
}break;
case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_21; // Ul_number
}break;
}
}
{
state_label_18: // L_number
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_22; // LL_number
}break;
case 0x55:case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexUL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctUL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerUL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_19: // UL_number
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexUL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctUL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerUL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexUL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctUL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerUL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x4c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexULL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctULL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerULL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_20: // l_number
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x55:case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexUL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctUL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerUL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_22; // LL_number
}break;
}
}
{
state_label_21: // Ul_number
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexUL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctUL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerUL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexUL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctUL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerUL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x6c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexULL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctULL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerULL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
state_label_22: // LL_number
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexLL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctLL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerLL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexLL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctLL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerLL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x55:case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x1)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerHexULL;
token.kind = 8;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x2)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralIntegerOctULL;
token.kind = 8;
break;
}
token.sub_kind = TokenCppKind_LiteralIntegerULL;
token.kind = 8;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_23: // pp_directive_whitespace
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_1; // root
}break;
case 0x09:case 0x0b:case 0x0c:case 0x20:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_23; // pp_directive_whitespace
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x47:case 0x48:case 0x49:case 0x4a:case 0x4b:
case 0x4c:case 0x4d:case 0x4e:case 0x4f:case 0x50:case 0x51:case 0x52:
case 0x53:case 0x54:case 0x55:case 0x56:case 0x57:case 0x58:case 0x59:
case 0x5a:case 0x5f:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:case 0x67:case 0x68:case 0x69:case 0x6a:case 0x6b:case 0x6c:
case 0x6d:case 0x6e:case 0x6f:case 0x70:case 0x71:case 0x72:case 0x73:
case 0x74:case 0x75:case 0x76:case 0x77:case 0x78:case 0x79:case 0x7a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.delim_first = state.ptr;
state.flags_KB0 |= 0x1;
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_24; // pp_directive
}break;
}
}
{
state_label_24: // pp_directive
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
lexer with breaks
2019-10-22 05:53:47 +00:00
state.delim_one_past_last = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
Lexeme_Table_Lookup lookup = lexeme_table_lookup(pp_directives_hash_array, pp_directives_key_array, pp_directives_value_array, pp_directives_slot_count, pp_directives_seed, state.delim_first, (state.delim_one_past_last - state.delim_first));
new lexer
2019-09-27 03:52:29 +00:00
if (lookup.found_match){
token.kind = lookup.base_kind;
token.sub_kind = lookup.sub_kind;
break;
}
token.sub_kind = TokenCppKind_PPUnknown;
token.kind = 2;
}while(0);
switch (token.sub_kind){
case TokenCppKind_PPInclude:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_KF0 |= 0x1;
new lexer
2019-09-27 03:52:29 +00:00
}break;
case TokenCppKind_PPError:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_KF0 |= 0x2;
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.delim_one_past_last = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
Lexeme_Table_Lookup lookup = lexeme_table_lookup(pp_directives_hash_array, pp_directives_key_array, pp_directives_value_array, pp_directives_slot_count, pp_directives_seed, state.delim_first, (state.delim_one_past_last - state.delim_first));
new lexer
2019-09-27 03:52:29 +00:00
if (lookup.found_match){
token.kind = lookup.base_kind;
token.sub_kind = lookup.sub_kind;
break;
}
token.sub_kind = TokenCppKind_PPUnknown;
token.kind = 2;
}while(0);
switch (token.sub_kind){
case TokenCppKind_PPInclude:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_KF0 |= 0x1;
new lexer
2019-09-27 03:52:29 +00:00
}break;
case TokenCppKind_PPError:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_KF0 |= 0x2;
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x47:case 0x48:case 0x49:case 0x4a:case 0x4b:
case 0x4c:case 0x4d:case 0x4e:case 0x4f:case 0x50:case 0x51:case 0x52:
case 0x53:case 0x54:case 0x55:case 0x56:case 0x57:case 0x58:case 0x59:
case 0x5a:case 0x5f:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:case 0x67:case 0x68:case 0x69:case 0x6a:case 0x6b:case 0x6c:
case 0x6d:case 0x6e:case 0x6f:case 0x70:case 0x71:case 0x72:case 0x73:
case 0x74:case 0x75:case 0x76:case 0x77:case 0x78:case 0x79:case 0x7a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_24; // pp_directive
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_25: // include_pointy
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x20:case 0x2e:case 0x2f:case 0x30:case 0x31:case 0x32:case 0x33:
case 0x34:case 0x35:case 0x36:case 0x37:case 0x38:case 0x39:case 0x41:
case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:case 0x47:case 0x48:
case 0x49:case 0x4a:case 0x4b:case 0x4c:case 0x4d:case 0x4e:case 0x4f:
case 0x50:case 0x51:case 0x52:case 0x53:case 0x54:case 0x55:case 0x56:
case 0x57:case 0x58:case 0x59:case 0x5a:case 0x5c:case 0x5f:case 0x61:
case 0x62:case 0x63:case 0x64:case 0x65:case 0x66:case 0x67:case 0x68:
case 0x69:case 0x6a:case 0x6b:case 0x6c:case 0x6d:case 0x6e:case 0x6f:
case 0x70:case 0x71:case 0x72:case 0x73:case 0x74:case 0x75:case 0x76:
case 0x77:case 0x78:case 0x79:case 0x7a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_25; // include_pointy
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x3e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PPIncludeFile;
token.kind = 10;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_26: // include_quotes
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x20:case 0x2e:case 0x2f:case 0x30:case 0x31:case 0x32:case 0x33:
case 0x34:case 0x35:case 0x36:case 0x37:case 0x38:case 0x39:case 0x41:
case 0x42:case 0x43:case 0x44:case 0x45:case 0x46:case 0x47:case 0x48:
case 0x49:case 0x4a:case 0x4b:case 0x4c:case 0x4d:case 0x4e:case 0x4f:
case 0x50:case 0x51:case 0x52:case 0x53:case 0x54:case 0x55:case 0x56:
case 0x57:case 0x58:case 0x59:case 0x5a:case 0x5c:case 0x5f:case 0x61:
case 0x62:case 0x63:case 0x64:case 0x65:case 0x66:case 0x67:case 0x68:
case 0x69:case 0x6a:case 0x6b:case 0x6c:case 0x6d:case 0x6e:case 0x6f:
case 0x70:case 0x71:case 0x72:case 0x73:case 0x74:case 0x75:case 0x76:
case 0x77:case 0x78:case 0x79:case 0x7a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_26; // include_quotes
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PPIncludeFile;
token.kind = 10;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_27: // pre_L
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
goto state_label_2; // identifier
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
goto state_label_2; // identifier
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x52:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_31; // pre_R
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_28: // pre_u
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
goto state_label_2; // identifier
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
goto state_label_2; // identifier
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x38:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_ZF0 |= 0x8;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_30; // pre_u8
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x52:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_31; // pre_R
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_29: // pre_U
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
goto state_label_2; // identifier
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
goto state_label_2; // identifier
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x52:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_31; // pre_R
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_30: // pre_u8
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
goto state_label_2; // identifier
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
goto state_label_2; // identifier
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x52:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_31; // pre_R
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_31: // pre_R
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
goto state_label_2; // identifier
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
goto state_label_2; // identifier
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.delim_first = state.ptr;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_45; // raw_string_get_delim
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_32: // string
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x0a:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
if ((!HasFlag(state.flags_ZF0, 0x40))){
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x4)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringWide;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x8)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringUTF8;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x10)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringUTF16;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x20)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringUTF32;
token.kind = 10;
break;
}
token.sub_kind = TokenCppKind_LiteralString;
token.kind = 10;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x27:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
if ((HasFlag(state.flags_ZF0, 0x40))){
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x4)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralCharacterWide;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x8)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralCharacterUTF8;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x10)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralCharacterUTF16;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x20)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralCharacterUTF32;
token.kind = 10;
break;
}
token.sub_kind = TokenCppKind_LiteralCharacter;
token.kind = 10;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x5c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_33; // string_esc
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_33: // string_esc
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_EOF;
token.kind = 0;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
result = true;
new lexer
2019-09-27 03:52:29 +00:00
goto end;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_34; // string_esc_oct2
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x55:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_37; // string_esc_universal_8
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x75:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_41; // string_esc_universal_4
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x78:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_36; // string_esc_hex
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_34: // string_esc_oct2
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_35; // string_esc_oct1
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_35: // string_esc_oct1
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_36: // string_esc_hex
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_36; // string_esc_hex
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_37: // string_esc_universal_8
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_38; // string_esc_universal_7
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_38: // string_esc_universal_7
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_39; // string_esc_universal_6
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_39: // string_esc_universal_6
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_40; // string_esc_universal_5
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_40: // string_esc_universal_5
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_41; // string_esc_universal_4
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_41: // string_esc_universal_4
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_42; // string_esc_universal_3
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_42: // string_esc_universal_3
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_43; // string_esc_universal_2
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_43: // string_esc_universal_2
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_44; // string_esc_universal_1
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_44: // string_esc_universal_1
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x30:case 0x31:case 0x32:case 0x33:case 0x34:case 0x35:case 0x36:
case 0x37:case 0x38:case 0x39:case 0x41:case 0x42:case 0x43:case 0x44:
case 0x45:case 0x46:case 0x61:case 0x62:case 0x63:case 0x64:case 0x65:
case 0x66:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_32; // string
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_45: // raw_string_get_delim
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_EOF;
token.kind = 0;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
result = true;
new lexer
2019-09-27 03:52:29 +00:00
goto end;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_45; // raw_string_get_delim
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x20:case 0x29:case 0x5c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x28:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.delim_one_past_last = state.ptr;
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_46; // raw_string_find_close
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_46: // raw_string_find_close
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_EOF;
token.kind = 0;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
result = true;
new lexer
2019-09-27 03:52:29 +00:00
goto end;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_46; // raw_string_find_close
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x29:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_47; // raw_string_try_delim
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_47: // raw_string_try_delim
lexer with breaks
2019-10-22 05:53:47 +00:00
umem delim_length = state.delim_one_past_last - state.delim_first;
new lexer
2019-09-27 03:52:29 +00:00
umem parse_length = 0;
for (;;){
if (parse_length == delim_length){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_48; // raw_string_try_quote
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_48; // raw_string_try_quote
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (*state.ptr == state.delim_first[parse_length]){
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
parse_length += 1;
}
else{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_46; // raw_string_find_close
new lexer
2019-09-27 03:52:29 +00:00
}
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_48: // raw_string_try_quote
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_46; // raw_string_find_close
new lexer
2019-09-27 03:52:29 +00:00
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_46; // raw_string_find_close
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x22:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x4)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringWideRaw;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x8)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringUTF8Raw;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x10)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringUTF16Raw;
token.kind = 10;
break;
}
lexer with breaks
2019-10-22 05:53:47 +00:00
if (HasFlag(state.flags_ZF0, 0x20)){
new lexer
2019-09-27 03:52:29 +00:00
token.sub_kind = TokenCppKind_LiteralStringUTF32Raw;
token.kind = 10;
break;
}
token.sub_kind = TokenCppKind_LiteralStringRaw;
token.kind = 10;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_49: // comment_block
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_BlockComment;
token.kind = 3;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_EOF;
token.kind = 0;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
result = true;
new lexer
2019-09-27 03:52:29 +00:00
goto end;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_49; // comment_block
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x0a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
state.flags_KB0 &= ~(0x1);
state.flags_KF0 &= ~(0x1);
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_49; // comment_block
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x2a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_50; // comment_block_try_close
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_50: // comment_block_try_close
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_BlockComment;
token.kind = 3;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_EOF;
token.kind = 0;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
result = true;
new lexer
2019-09-27 03:52:29 +00:00
goto end;
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_49; // comment_block
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x2a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_50; // comment_block_try_close
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x2f:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_BlockComment;
token.kind = 3;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_51: // comment_line
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LineComment;
token.kind = 3;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_51; // comment_line
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x0a:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LineComment;
token.kind = 3;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_52: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Colon;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Colon;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_ColonColon;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_53: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Plus;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Plus;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2b:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PlusPlus;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PlusEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_54: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Minus;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Minus;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_MinusMinus;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_MinusEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_55; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_55: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Arrow;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Arrow;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2a:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_ArrowStar;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_56: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Less;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Less;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_65; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_58; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_57: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Grtr;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Grtr;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_GrtrEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
goto state_label_66; // op stage
new lexer
2019-09-27 03:52:29 +00:00
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_58: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LessEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LessEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Compare;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_59: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Eq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Eq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_EqEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_60: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Not;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Not;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_NotEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_61: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_And;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_And;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x26:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_AndAnd;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_62: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Or;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Or;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x7c:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_OrOr;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_63: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Star;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Star;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_StarEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_64: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Mod;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_Mod;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_ModEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_65: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LeftLeft;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LeftLeft;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LeftLeftEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_66: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_RightRight;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_RightRight;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x3d:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_RightRightEq;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_67: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PPStringify;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PPStringify;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x23:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_PPConcat;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
{
Fixed lexer for preprocssor directives completely; fixed up build paths some more
2019-10-01 22:03:21 +00:00
state_label_68: // op stage
lexer with breaks
2019-10-22 05:53:47 +00:00
if (state.ptr == state.opl_ptr){
new lexer
2019-09-27 03:52:29 +00:00
if ((true)){
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}
}
lexer with breaks
2019-10-22 05:53:47 +00:00
switch (*state.ptr){
new lexer
2019-09-27 03:52:29 +00:00
default:
{
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_LexError;
token.kind = 2;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
}
state.emit_ptr = state.ptr;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
case 0x2e:
{
lexer with breaks
2019-10-22 05:53:47 +00:00
state.ptr += 1;
new lexer
2019-09-27 03:52:29 +00:00
{
Token token = {};
lexer with breaks
2019-10-22 05:53:47 +00:00
token.pos = (i64)(state.emit_ptr - state.base);
token.size = (i64)(state.ptr - state.emit_ptr);
token.flags = state.flags_KB0;
new lexer
2019-09-27 03:52:29 +00:00
do{
token.sub_kind = TokenCppKind_DotDotDot;
token.kind = 7;
}while(0);
lexer with breaks
2019-10-22 05:53:47 +00:00
token_list_push(arena, list, &token);
emit_counter += 1;
if (emit_counter == max){
goto end;
new lexer
2019-09-27 03:52:29 +00:00
}
lexer with breaks
2019-10-22 05:53:47 +00:00
state.emit_ptr = state.ptr;
}
state.flags_ZF0 = 0;
new lexer
2019-09-27 03:52:29 +00:00
goto state_label_1; // root
}break;
}
}
end:;
lexer with breaks
2019-10-22 05:53:47 +00:00
block_copy_struct(state_ptr, &state);
return(result);
}
internal Token_List
lex_full_input_cpp(Arena *arena, String_Const_u8 input){
Lex_State_Cpp state = {};
lex_full_input_cpp_init(&state, input);
Token_List list = {};
lex_full_input_cpp_breaks(arena, &list, &state, max_u64);
new lexer
2019-09-27 03:52:29 +00:00
return(list);
}