#include "compiler.h" #define COMPILER_FUNCTION_LIMIT 16u #define COMPILER_CALL_LIMIT 64u #define COMPILER_ARGUMENT_LIMIT 16u #define COMPILER_GLOBAL_LIMIT 16u #define COMPILER_STRUCT_LIMIT 8u #define COMPILER_FIELD_LIMIT 16u #define COMPILER_TYPEDEF_LIMIT 32u #define COMPILER_ENUM_LIMIT 8u #define COMPILER_ENUM_CONSTANT_LIMIT 64u #define COMPILER_LOCAL_LIMIT 64u #define COMPILER_LOCAL_FRAME_SIZE 1024u typedef struct { char Name[32]; u16 CodeOffset; u8 ReturnType,ArgumentCount,ArgumentTypes[COMPILER_ARGUMENT_LIMIT],Defined; } BOB64_C_FUNCTION; typedef struct { char Name[32]; u16 DisplacementOffset; u8 ArgumentCount,ArgumentTypes[COMPILER_ARGUMENT_LIMIT]; } BOB64_C_CALL; #define COMPILER_CONTROL_LOOP 1u #define COMPILER_CONTROL_SWITCH 2u #define COMPILER_SWITCH_CASE_LIMIT 32u typedef struct { u16 ContinueTarget,BreakBranches[32],ContinueBranches[32]; u16 CaseTargets[COMPILER_SWITCH_CASE_LIMIT],DefaultTarget; u64 CaseValues[COMPILER_SWITCH_CASE_LIMIT]; u8 Kind,BreakCount,ContinueCount,CaseCount,HasDefault; } BOB64_C_CONTROL; typedef struct { u16 LocalBytes; u8 VariableCount; } BOB64_C_SCOPE; typedef struct { char Name[32]; u16 DataOffset,ArrayLength,InitTarget; u8 Type,InitKind; } BOB64_C_GLOBAL; typedef struct { char Name[32]; u16 Offset; u8 Type; } BOB64_C_FIELD; typedef struct { char Name[32]; u16 Size; u8 Alignment,FieldCount; BOB64_C_FIELD Fields[COMPILER_FIELD_LIMIT]; } BOB64_C_STRUCT; typedef struct { char Name[32]; u8 Type; } BOB64_C_TYPEDEF; typedef struct { char Name[32]; } BOB64_C_ENUM; typedef struct { char Name[32]; u64 Value; } BOB64_C_ENUM_CONSTANT; typedef struct { const char *Source; usize Length,Position,ErrorOffset; u8 Code[BOB64_COMPILER_CODE_CAPACITY]; u8 Data[BOB64_COMPILER_DATA_CAPACITY]; usize CodePosition,DataLength; char VariableNames[COMPILER_LOCAL_LIMIT][32]; s16 VariableDisplacement[COMPILER_LOCAL_LIMIT]; u8 VariableType[COMPILER_LOCAL_LIMIT],VariableCount; u16 VariableArrayLength[COMPILER_LOCAL_LIMIT]; u16 LocalBytes,StackBytes; BOB64_C_FUNCTION Functions[COMPILER_FUNCTION_LIMIT]; BOB64_C_GLOBAL Globals[COMPILER_GLOBAL_LIMIT]; BOB64_C_STRUCT Structs[COMPILER_STRUCT_LIMIT]; BOB64_C_TYPEDEF Typedefs[COMPILER_TYPEDEF_LIMIT]; BOB64_C_ENUM Enums[COMPILER_ENUM_LIMIT]; BOB64_C_ENUM_CONSTANT EnumConstants[COMPILER_ENUM_CONSTANT_LIMIT]; BOB64_C_CALL Calls[COMPILER_CALL_LIMIT]; BOB64_C_CONTROL Controls[16]; BOB64_C_SCOPE Scopes[32]; u16 FunctionSourceStart[COMPILER_FUNCTION_LIMIT]; u16 FunctionSourceEnd[COMPILER_FUNCTION_LIMIT]; u8 FunctionCount,GlobalCount,StructCount,TypedefCount,EnumCount; u8 EnumConstantCount,CallCount; u8 FunctionSourceCount,ScopeDepth,ControlCount; u64 IntegerValue; u8 ExpressionType,IntegerType; u8 ReturnType,Return64,Failed,ControlDepth; } BOB64_C_COMPILER; static int compiler_emit(BOB64_C_COMPILER *compiler,u8 value); static int compiler_emit_u32(BOB64_C_COMPILER *compiler,u32 value); #define COMPILER_TYPE_INT 1u #define COMPILER_TYPE_LONG_LONG 2u #define COMPILER_TYPE_INT_POINTER 3u #define COMPILER_TYPE_INT_ARRAY 4u #define COMPILER_TYPE_CHAR 5u #define COMPILER_TYPE_CHAR_POINTER 6u #define COMPILER_TYPE_CHAR_ARRAY 7u #define COMPILER_TYPE_SHORT 8u #define COMPILER_TYPE_SHORT_POINTER 9u #define COMPILER_TYPE_SHORT_ARRAY 10u #define COMPILER_TYPE_USIZE 11u #define COMPILER_TYPE_VOID 12u #define COMPILER_TYPE_ISIZE_POINTER 13u #define COMPILER_TYPE_USIZE_POINTER 14u #define COMPILER_TYPE_LONG_LONG_ARRAY 15u #define COMPILER_TYPE_STRUCT_BASE 16u #define COMPILER_TYPE_USIZE_ARRAY 24u #define COMPILER_TYPE_VOID_POINTER 25u #define COMPILER_TYPE_STRUCT_POINTER_BASE 64u static int compiler_is_pointer(u8 type) { return type==COMPILER_TYPE_INT_POINTER||type==COMPILER_TYPE_CHAR_POINTER|| type==COMPILER_TYPE_SHORT_POINTER||type==COMPILER_TYPE_ISIZE_POINTER|| type==COMPILER_TYPE_USIZE_POINTER||type==COMPILER_TYPE_VOID_POINTER|| (type>=COMPILER_TYPE_STRUCT_POINTER_BASE&& type=COMPILER_TYPE_STRUCT_POINTER_BASE&& typeStructs[type-COMPILER_TYPE_STRUCT_POINTER_BASE].Size; return 4u; } static u8 compiler_pointer_type(u8 value_type) { if(value_type==COMPILER_TYPE_CHAR||value_type==COMPILER_TYPE_CHAR_ARRAY) return COMPILER_TYPE_CHAR_POINTER; if(value_type==COMPILER_TYPE_SHORT||value_type==COMPILER_TYPE_SHORT_ARRAY) return COMPILER_TYPE_SHORT_POINTER; if(value_type==COMPILER_TYPE_LONG_LONG||value_type==COMPILER_TYPE_LONG_LONG_ARRAY) return COMPILER_TYPE_ISIZE_POINTER; if(value_type==COMPILER_TYPE_USIZE||value_type==COMPILER_TYPE_USIZE_ARRAY) return COMPILER_TYPE_USIZE_POINTER; return COMPILER_TYPE_INT_POINTER; } static int compiler_emit_scale_register(BOB64_C_COMPILER *compiler,u32 scale, u8 register_id) { if(scale==1)return 1; if(scale==2||scale==4||scale==8) { u8 shift=scale==2?1:(scale==4?2:3); return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0xc1)&& compiler_emit(compiler,register_id?0xe1:0xe0)&& compiler_emit(compiler,shift); } return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x69)&& compiler_emit(compiler,register_id?0xc9:0xc0)&& compiler_emit_u32(compiler,scale); } static void compiler_skip(BOB64_C_COMPILER *compiler) { for(;;) { while(compiler->PositionLength&& (compiler->Source[compiler->Position]==' '|| compiler->Source[compiler->Position]=='\t'|| compiler->Source[compiler->Position]=='\r'|| compiler->Source[compiler->Position]=='\n'))compiler->Position++; if(compiler->Position+1Length&& compiler->Source[compiler->Position]=='/'&& compiler->Source[compiler->Position+1]=='/') { while(compiler->PositionLength&& compiler->Source[compiler->Position]!='\n')compiler->Position++; } else if(compiler->Position+1Length&& compiler->Source[compiler->Position]=='/'&& compiler->Source[compiler->Position+1]=='*') { compiler->Position+=2; while(compiler->Position+1Length&& !(compiler->Source[compiler->Position]=='*'&& compiler->Source[compiler->Position+1]=='/'))compiler->Position++; if(compiler->Position+1>=compiler->Length) { compiler->Failed=1;compiler->ErrorOffset=compiler->Position;return; } compiler->Position+=2; } else return; } } static int compiler_take(BOB64_C_COMPILER *compiler,char value) { compiler_skip(compiler); if(compiler->Failed||compiler->Position>=compiler->Length|| compiler->Source[compiler->Position]!=value)return 0; compiler->Position++;return 1; } static int compiler_word(BOB64_C_COMPILER *compiler,const char *word) { usize start,length=0; compiler_skip(compiler);start=compiler->Position; while(word[length])length++; if(compiler->Failed||length>compiler->Length-start)return 0; for(usize i=0;iSource[start+i]!=word[i])return 0; if(start+lengthLength) { char next=compiler->Source[start+length]; if((next>='a'&&next<='z')||(next>='A'&&next<='Z')|| (next>='0'&&next<='9')||next=='_')return 0; } compiler->Position+=length;return 1; } static u8 compiler_long_type(BOB64_C_COMPILER *compiler) { if(!compiler_word(compiler,"long"))return 0; /* bob64 follows LLP64: long is 32-bit; long long is 64-bit. */ return compiler_word(compiler,"long")?COMPILER_TYPE_LONG_LONG:COMPILER_TYPE_INT; } static u8 compiler_integer_type(BOB64_C_COMPILER *compiler) { usize saved=compiler->Position; if(compiler_word(compiler,"unsigned")) { if(compiler_word(compiler,"long")&&compiler_word(compiler,"long")) { (void)compiler_word(compiler,"int"); return COMPILER_TYPE_USIZE; } compiler->Position=saved; } if(compiler_word(compiler,"int"))return COMPILER_TYPE_INT; if(compiler_word(compiler,"short"))return COMPILER_TYPE_SHORT; if(compiler_word(compiler,"usize")||compiler_word(compiler,"uintptr_t")) return COMPILER_TYPE_USIZE; if(compiler_word(compiler,"isize")||compiler_word(compiler,"intptr_t")) return COMPILER_TYPE_LONG_LONG; return compiler_long_type(compiler); } static int compiler_identifier(BOB64_C_COMPILER *compiler,char *name,usize capacity) { usize length=0; compiler_skip(compiler); if(compiler->Position>=compiler->Length)return 0; char first=compiler->Source[compiler->Position]; if(!((first>='a'&&first<='z')||(first>='A'&&first<='Z')||first=='_'))return 0; while(compiler->PositionLength) { char next=compiler->Source[compiler->Position]; if(!((next>='a'&&next<='z')||(next>='A'&&next<='Z')|| (next>='0'&&next<='9')||next=='_'))break; if(length+1>=capacity)return 0; name[length++]=next;compiler->Position++; } name[length]=0;return 1; } static int compiler_struct_find(BOB64_C_COMPILER *compiler,const char *name); static int compiler_type_is_struct(u8 type); static int compiler_enum_find(BOB64_C_COMPILER *compiler,const char *name); static int compiler_enum_constant_find(BOB64_C_COMPILER *compiler,const char *name); static int compiler_typedef_find(BOB64_C_COMPILER *compiler,const char *name) { for(u32 i=0;iTypedefCount;i++) { usize position=0; while(compiler->Typedefs[i].Name[position]&& compiler->Typedefs[i].Name[position]==name[position])position++; if(!compiler->Typedefs[i].Name[position]&&!name[position])return (int)i; } return -1; } static u8 compiler_type_specifier(BOB64_C_COMPILER *compiler) { if(compiler_word(compiler,"char"))return COMPILER_TYPE_CHAR; if(compiler_word(compiler,"void"))return COMPILER_TYPE_VOID; if(compiler_word(compiler,"struct")) { char name[32]; if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int structure=compiler_struct_find(compiler,name); return structure<0?0:(u8)(COMPILER_TYPE_STRUCT_BASE+(u32)structure); } if(compiler_word(compiler,"enum")) { char name[32]; if(!compiler_identifier(compiler,name,sizeof(name))|| compiler_enum_find(compiler,name)<0)return 0; return COMPILER_TYPE_INT; } u8 type=compiler_integer_type(compiler); if(type)return type; usize saved=compiler->Position; char name[32]; if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int alias=compiler_typedef_find(compiler,name); if(alias<0) {compiler->Position=saved;return 0;} return compiler->Typedefs[alias].Type; } static u8 compiler_pointer_to(BOB64_C_COMPILER *compiler,u8 type) { (void)compiler; if(type==COMPILER_TYPE_VOID)return COMPILER_TYPE_VOID_POINTER; if(compiler_type_is_struct(type)) return (u8)(COMPILER_TYPE_STRUCT_POINTER_BASE+type-COMPILER_TYPE_STRUCT_BASE); if(!type||type==COMPILER_TYPE_VOID||compiler_is_pointer(type))return 0; return compiler_pointer_type(type); } static u8 compiler_array_type(u8 type) { if(type==COMPILER_TYPE_CHAR)return COMPILER_TYPE_CHAR_ARRAY; if(type==COMPILER_TYPE_SHORT)return COMPILER_TYPE_SHORT_ARRAY; if(type==COMPILER_TYPE_LONG_LONG)return COMPILER_TYPE_LONG_LONG_ARRAY; if(type==COMPILER_TYPE_USIZE)return COMPILER_TYPE_USIZE_ARRAY; if(type==COMPILER_TYPE_INT)return COMPILER_TYPE_INT_ARRAY; return 0; } static int compiler_function_signature(BOB64_C_COMPILER *compiler,char *name, usize name_capacity,u8 *return_type,u8 *argument_count, u8 argument_types[COMPILER_ARGUMENT_LIMIT], char parameter_names[COMPILER_ARGUMENT_LIMIT][32],int require_names) { u32 count=0; u8 value_type=compiler_type_specifier(compiler); int struct_type=compiler_type_is_struct(value_type)? (int)(value_type-COMPILER_TYPE_STRUCT_BASE):-1; if(!value_type)return 0; int return_pointer=compiler_take(compiler,'*'); if(struct_type>=0&&!return_pointer)return 0; *return_type=return_pointer?compiler_pointer_to(compiler,value_type):value_type; if(!*return_type)return 0; if(!compiler_identifier(compiler,name,name_capacity)||!compiler_take(compiler,'('))return 0; if(!compiler_take(compiler,')')) { int pending_void=compiler_word(compiler,"void"); if(!(pending_void&&compiler_take(compiler,')'))) { for(;;) { int pointer,has_name; if(count>=COMPILER_ARGUMENT_LIMIT)return 0; u8 value_type=pending_void?COMPILER_TYPE_VOID: compiler_type_specifier(compiler); pending_void=0; int struct_type=compiler_type_is_struct(value_type)? (int)(value_type-COMPILER_TYPE_STRUCT_BASE):-1; if(!value_type)return 0; pointer=compiler_take(compiler,'*'); if(value_type==COMPILER_TYPE_VOID&&!pointer)return 0; if(struct_type>=0&&!pointer)return 0; compiler_skip(compiler); has_name=compiler_identifier(compiler,parameter_names[count], sizeof(parameter_names[count])); if(require_names&&!has_name)return 0; if(!has_name)parameter_names[count][0]=0; if(compiler_take(compiler,'[')) { if(pointer||!compiler_take(compiler,']'))return 0; pointer=1; } argument_types[count]=pointer? compiler_pointer_to(compiler,value_type):value_type; if(!argument_types[count])return 0; count++; if(compiler_take(compiler,')'))break; if(!compiler_take(compiler,','))return 0; } } } *argument_count=(u8)count; return 1; } static int compiler_variable_find(BOB64_C_COMPILER *compiler,const char *name) { for(u32 i=compiler->VariableCount;i>0;i--) { usize position=0; u32 variable=i-1; while(compiler->VariableNames[variable][position]&& compiler->VariableNames[variable][position]==name[position])position++; if(!compiler->VariableNames[variable][position]&&!name[position]) return (int)variable; } for(u32 i=0;iGlobalCount;i++) { usize position=0; while(compiler->Globals[i].Name[position]&& compiler->Globals[i].Name[position]==name[position])position++; if(!compiler->Globals[i].Name[position]&&!name[position])return (int)(0x8000u|i); } return -1; } static int compiler_scope_push(BOB64_C_COMPILER *compiler) { if(compiler->ScopeDepth>=sizeof(compiler->Scopes)/sizeof(compiler->Scopes[0])) return 0; BOB64_C_SCOPE *scope=&compiler->Scopes[compiler->ScopeDepth++]; scope->VariableCount=compiler->VariableCount; scope->LocalBytes=compiler->LocalBytes; return 1; } static void compiler_scope_pop(BOB64_C_COMPILER *compiler) { if(!compiler->ScopeDepth)return; BOB64_C_SCOPE *scope=&compiler->Scopes[--compiler->ScopeDepth]; compiler->VariableCount=scope->VariableCount; compiler->LocalBytes=scope->LocalBytes; } static int compiler_struct_find(BOB64_C_COMPILER *compiler,const char *name) { for(u32 i=0;iStructCount;i++) { usize position=0; while(compiler->Structs[i].Name[position]&& compiler->Structs[i].Name[position]==name[position])position++; if(!compiler->Structs[i].Name[position]&&!name[position])return (int)i; } return -1; } static int compiler_enum_find(BOB64_C_COMPILER *compiler,const char *name) { for(u32 i=0;iEnumCount;i++) { usize position=0; while(compiler->Enums[i].Name[position]&& compiler->Enums[i].Name[position]==name[position])position++; if(!compiler->Enums[i].Name[position]&&!name[position])return (int)i; } return -1; } static int compiler_enum_constant_find(BOB64_C_COMPILER *compiler, const char *name) { for(u32 i=0;iEnumConstantCount;i++) { usize position=0; while(compiler->EnumConstants[i].Name[position]&& compiler->EnumConstants[i].Name[position]==name[position])position++; if(!compiler->EnumConstants[i].Name[position]&&!name[position])return (int)i; } return -1; } static int compiler_type_is_struct(u8 type) { return type>=COMPILER_TYPE_STRUCT_BASE&& typeStructs[type-COMPILER_TYPE_STRUCT_BASE].Size; if(type==COMPILER_TYPE_CHAR)return 1; if(type==COMPILER_TYPE_SHORT)return 2; if(type==COMPILER_TYPE_SHORT_ARRAY)return 2; if(type==COMPILER_TYPE_INT||type==COMPILER_TYPE_INT_ARRAY)return 4; if(type==COMPILER_TYPE_LONG_LONG_ARRAY||type==COMPILER_TYPE_USIZE_ARRAY)return 8; return 8; } static u32 compiler_type_alignment(BOB64_C_COMPILER *compiler,u8 type) { if(compiler_type_is_struct(type)) return compiler->Structs[type-COMPILER_TYPE_STRUCT_BASE].Alignment; u32 size=compiler_type_size(compiler,type); return size>=8?8:(size>=4?4:(size>=2?2:1)); } static int compiler_field_find(BOB64_C_COMPILER *compiler,u8 struct_type, const char *name) { if(!compiler_type_is_struct(struct_type))return -1; BOB64_C_STRUCT *structure=&compiler->Structs[struct_type-COMPILER_TYPE_STRUCT_BASE]; for(u32 i=0;iFieldCount;i++) { usize position=0; while(structure->Fields[i].Name[position]&& structure->Fields[i].Name[position]==name[position])position++; if(!structure->Fields[i].Name[position]&&!name[position])return (int)i; } return -1; } static int compiler_variable_is_global(u32 variable) { return (variable&0x8000u)!=0; } static int compiler_emit_rbp_operand(BOB64_C_COMPILER *compiler, u8 disp8_modrm,s16 displacement) { if(displacement>=-128&&displacement<=127) return compiler_emit(compiler,disp8_modrm)&& compiler_emit(compiler,(u8)(s8)displacement); u8 disp32_modrm=(u8)((disp8_modrm&0x3fu)|0x80u); return compiler_emit(compiler,disp32_modrm)&& compiler_emit_u32(compiler,(u32)(s32)displacement); } static u8 compiler_variable_type(BOB64_C_COMPILER *compiler,u32 variable) { return compiler_variable_is_global(variable)? compiler->Globals[variable&0x7fffu].Type:compiler->VariableType[variable]; } static u32 compiler_variable_array_length(BOB64_C_COMPILER *compiler,u32 variable) { return compiler_variable_is_global(variable)? compiler->Globals[variable&0x7fffu].ArrayLength: compiler->VariableArrayLength[variable]; } static int compiler_emit_global_displacement(BOB64_C_COMPILER *compiler,u32 variable) { BOB64_C_GLOBAL *global=&compiler->Globals[variable&0x7fffu]; s64 displacement=(s64)(BOB64_COMPILER_CODE_CAPACITY+global->DataOffset)- (s64)(compiler->CodePosition+4u); if(displacement<(-2147483647LL-1)||displacement>2147483647)return 0; return compiler_emit_u32(compiler,(u32)(s32)displacement); } static int compiler_emit_data_displacement(BOB64_C_COMPILER *compiler,u16 data_offset) { s64 displacement=(s64)(BOB64_COMPILER_CODE_CAPACITY+data_offset)- (s64)(compiler->CodePosition+4u); if(displacement<(-2147483647LL-1)||displacement>2147483647)return 0; return compiler_emit_u32(compiler,(u32)(s32)displacement); } static int compiler_emit_global_initializers(BOB64_C_COMPILER *compiler) { for(u32 i=0;iGlobalCount;i++) { BOB64_C_GLOBAL *global=&compiler->Globals[i]; if(!global->InitKind)continue; if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x8d)|| !compiler_emit(compiler,0x05)|| !compiler_emit_data_displacement(compiler,global->InitTarget)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x05)|| !compiler_emit_global_displacement(compiler,0x8000u|i))return 0; } return 1; } static int compiler_function_find(BOB64_C_COMPILER *compiler,const char *name) { for(u32 i=0;iFunctionCount;i++) { usize position=0; while(compiler->Functions[i].Name[position]&& compiler->Functions[i].Name[position]==name[position])position++; if(!compiler->Functions[i].Name[position]&&!name[position])return (int)i; } return -1; } static int compiler_function_declare(BOB64_C_COMPILER *compiler,const char *name, u16 code_offset,u8 return_type,u8 argument_count, const u8 *argument_types,int defined) { if(argument_count>COMPILER_ARGUMENT_LIMIT|| compiler_enum_constant_find(compiler,name)>=0)return 0; int existing=compiler_function_find(compiler,name); if(existing>=0) { BOB64_C_FUNCTION *function=&compiler->Functions[existing]; if(function->ReturnType!=return_type||function->ArgumentCount!=argument_count|| (defined&&function->Defined))return 0; for(u32 i=0;iArgumentTypes[i]!=argument_types[i])return 0; if(defined) { function->CodeOffset=code_offset; function->Defined=1; } return 1; } if(compiler->FunctionCount>=COMPILER_FUNCTION_LIMIT)return 0; u32 index=compiler->FunctionCount++; BOB64_C_FUNCTION *function=&compiler->Functions[index]; usize position=0; while(name[position]&&position+1Name)) { function->Name[position]=name[position];position++; } if(name[position])return 0; function->Name[position]=0; function->CodeOffset=code_offset; function->ReturnType=return_type; function->ArgumentCount=argument_count; function->Defined=(u8)defined; for(u32 i=0;iArgumentTypes[i]=argument_types[i]; return 1; } static int compiler_variable_load(BOB64_C_COMPILER *compiler,u32 variable) { if(compiler_variable_is_global(variable)) { u8 type=compiler_variable_type(compiler,variable); if(type==COMPILER_TYPE_CHAR) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x0f)&& compiler_emit(compiler,0xbe)&&compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); if(type==COMPILER_TYPE_SHORT) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x0f)&& compiler_emit(compiler,0xbf)&&compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); if(type==COMPILER_TYPE_LONG_LONG||type==COMPILER_TYPE_USIZE|| compiler_is_pointer(type)) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x8b)&& compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x63)&& compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); } s16 displacement=compiler->VariableDisplacement[variable]; if(compiler->VariableType[variable]==COMPILER_TYPE_CHAR) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x0f)&& compiler_emit(compiler,0xbe)&& compiler_emit_rbp_operand(compiler,0x45,displacement); if(compiler->VariableType[variable]==COMPILER_TYPE_SHORT) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x0f)&& compiler_emit(compiler,0xbf)&& compiler_emit_rbp_operand(compiler,0x45,displacement); if(compiler->VariableType[variable]==COMPILER_TYPE_LONG_LONG|| compiler->VariableType[variable]==COMPILER_TYPE_USIZE|| compiler_is_pointer(compiler->VariableType[variable])) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x8b)&& compiler_emit_rbp_operand(compiler,0x45,displacement); return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x63)&& compiler_emit_rbp_operand(compiler,0x45,displacement); } static int compiler_variable_store(BOB64_C_COMPILER *compiler,u32 variable) { if(compiler_variable_is_global(variable)) { u8 type=compiler_variable_type(compiler,variable); if(type==COMPILER_TYPE_CHAR) return compiler_emit(compiler,0x88)&&compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); if(type==COMPILER_TYPE_SHORT) return compiler_emit(compiler,0x66)&&compiler_emit(compiler,0x89)&& compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); if(type==COMPILER_TYPE_LONG_LONG||type==COMPILER_TYPE_USIZE|| compiler_is_pointer(type)) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x89)&& compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); return compiler_emit(compiler,0x89)&&compiler_emit(compiler,0x05)&& compiler_emit_global_displacement(compiler,variable); } s16 displacement=compiler->VariableDisplacement[variable]; if(compiler->VariableType[variable]==COMPILER_TYPE_CHAR) return compiler_emit(compiler,0x88)&& compiler_emit_rbp_operand(compiler,0x45,displacement); if(compiler->VariableType[variable]==COMPILER_TYPE_SHORT) return compiler_emit(compiler,0x66)&&compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler,0x45,displacement); if(compiler->VariableType[variable]==COMPILER_TYPE_LONG_LONG|| compiler->VariableType[variable]==COMPILER_TYPE_USIZE|| compiler_is_pointer(compiler->VariableType[variable])) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler,0x45,displacement); return compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler,0x45,displacement); } static int compiler_variable_address(BOB64_C_COMPILER *compiler,u32 variable, u8 destination_register) { if(compiler_variable_is_global(variable)) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x8d)&& compiler_emit(compiler,(u8)(0x05u|(destination_register<<3)))&& compiler_emit_global_displacement(compiler,variable); s16 displacement=compiler->VariableDisplacement[variable]; return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x8d)&& compiler_emit_rbp_operand(compiler, (u8)(0x45u|(destination_register<<3)),displacement); } static int compiler_member_address(BOB64_C_COMPILER *compiler,u32 variable, const BOB64_C_FIELD *field) { if(!compiler_variable_address(compiler,variable,0))return 0; if(!field->Offset)return 1; return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x05)&& compiler_emit_u32(compiler,field->Offset); } static int compiler_member_load(BOB64_C_COMPILER *compiler,u8 type) { if(type==COMPILER_TYPE_CHAR) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x0f)&& compiler_emit(compiler,0xbe)&&compiler_emit(compiler,0x00); if(type==COMPILER_TYPE_SHORT) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x0f)&& compiler_emit(compiler,0xbf)&&compiler_emit(compiler,0x00); if(type==COMPILER_TYPE_INT) return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x63)&& compiler_emit(compiler,0x00); return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x8b)&& compiler_emit(compiler,0x00); } static int compiler_member_store(BOB64_C_COMPILER *compiler,u8 type) { if(type==COMPILER_TYPE_CHAR) return compiler_emit(compiler,0x88)&&compiler_emit(compiler,0x01); if(type==COMPILER_TYPE_SHORT) return compiler_emit(compiler,0x66)&&compiler_emit(compiler,0x89)&& compiler_emit(compiler,0x01); if(type==COMPILER_TYPE_INT) return compiler_emit(compiler,0x89)&&compiler_emit(compiler,0x01); return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x89)&& compiler_emit(compiler,0x01); } static int compiler_add_variable(BOB64_C_COMPILER *compiler,const char *name, u8 type,u32 array_length,u32 *variable_out) { usize length=0; u32 bytes; u32 scope_start=compiler->ScopeDepth? compiler->Scopes[compiler->ScopeDepth-1].VariableCount:0; for(u32 i=scope_start;iVariableCount;i++) { usize position=0; while(compiler->VariableNames[i][position]&& compiler->VariableNames[i][position]==name[position])position++; if(!compiler->VariableNames[i][position]&&!name[position])return 0; } if(compiler->VariableCount>=COMPILER_LOCAL_LIMIT|| compiler_enum_constant_find(compiler,name)>=0)return 0; if(type==COMPILER_TYPE_INT_ARRAY) { if(!array_length||array_length>COMPILER_LOCAL_FRAME_SIZE/4u)return 0; bytes=array_length*4; compiler->LocalBytes=(u16)((compiler->LocalBytes+3u)&~3u); } else if(type==COMPILER_TYPE_SHORT_ARRAY) { if(!array_length||array_length>COMPILER_LOCAL_FRAME_SIZE/2u)return 0; bytes=array_length*2; compiler->LocalBytes=(u16)((compiler->LocalBytes+1u)&~1u); } else if(type==COMPILER_TYPE_CHAR_ARRAY) { if(!array_length||array_length>COMPILER_LOCAL_FRAME_SIZE)return 0; bytes=array_length; } else if(type==COMPILER_TYPE_LONG_LONG_ARRAY||type==COMPILER_TYPE_USIZE_ARRAY) { if(!array_length||array_length>COMPILER_LOCAL_FRAME_SIZE/8u)return 0; bytes=array_length*8u; compiler->LocalBytes=(u16)((compiler->LocalBytes+7u)&~7u); } else if(compiler_type_is_struct(type)) { u32 alignment=compiler_type_alignment(compiler,type); compiler->LocalBytes=(u16)((compiler->LocalBytes+alignment-1u)&~(alignment-1u)); bytes=compiler_type_size(compiler,type); } else { bytes=8; compiler->LocalBytes=(u16)((compiler->LocalBytes+7u)&~7u); } if(compiler->LocalBytes>COMPILER_LOCAL_FRAME_SIZE|| bytes>COMPILER_LOCAL_FRAME_SIZE-compiler->LocalBytes)return 0; compiler->LocalBytes=(u16)(compiler->LocalBytes+bytes); u32 variable=compiler->VariableCount++; while(name[length])length++; for(usize i=0;i<=length;i++)compiler->VariableNames[variable][i]=name[i]; compiler->VariableType[variable]=type; compiler->VariableArrayLength[variable]=(u16)array_length; compiler->VariableDisplacement[variable]=-(s16)compiler->LocalBytes; if(variable_out)*variable_out=variable; return 1; } static int compiler_integer(BOB64_C_COMPILER *compiler,u64 *value) { u64 number=0;u32 base=10;usize digits=0; int has_unsigned=0,long_count=0,unsigned_after_long=0; compiler_skip(compiler); if(compiler->Position+1Length&&compiler->Source[compiler->Position]=='0'&& (compiler->Source[compiler->Position+1]=='x'|| compiler->Source[compiler->Position+1]=='X')) { base=16;compiler->Position+=2; } while(compiler->PositionLength) { char character=compiler->Source[compiler->Position]; u32 digit; if(character>='0'&&character<='9')digit=(u32)(character-'0'); else if(base==16&&character>='a'&&character<='f')digit=(u32)(character-'a'+10); else if(base==16&&character>='A'&&character<='F')digit=(u32)(character-'A'+10); else break; if(digit>=base||number>(~(u64)0-digit)/base)return 0; number=number*base+digit;digits++;compiler->Position++; } if(!digits)return 0; while(compiler->PositionLength) { char suffix=compiler->Source[compiler->Position]; if((suffix=='u'||suffix=='U')&&!has_unsigned) { has_unsigned=1;if(long_count)unsigned_after_long=1;compiler->Position++; } else if((suffix=='l'||suffix=='L')&&long_count<2) { if(unsigned_after_long)return 0; long_count++;compiler->Position++; } else break; } if(compiler->PositionLength) { char next=compiler->Source[compiler->Position]; if((next>='a'&&next<='z')||(next>='A'&&next<='Z')||next=='_')return 0; } *value=number; compiler->IntegerType=has_unsigned?COMPILER_TYPE_USIZE: ((long_count>=2||number>0x7fffffffu)?COMPILER_TYPE_LONG_LONG: COMPILER_TYPE_INT); return 1; } static int compiler_string(BOB64_C_COMPILER *compiler,usize *offset,usize *length) { compiler_skip(compiler); if(compiler->Position>=compiler->Length||compiler->Source[compiler->Position]!='"')return 0; compiler->Position++;*offset=compiler->DataLength;*length=0; while(compiler->PositionLength&&compiler->Source[compiler->Position]!='"') { u8 value=(u8)compiler->Source[compiler->Position++]; if(value=='\\') { if(compiler->Position>=compiler->Length)return 0; value=(u8)compiler->Source[compiler->Position++]; if(value=='n')value='\n';else if(value=='r')value='\r'; else if(value=='t')value='\t'; else if(value!='\\'&&value!='"'&&value!='\'')return 0; } if(!value||*length>=BOB64_SYSCALL_MAX_BUFFER|| compiler->DataLength>=sizeof(compiler->Data))return 0; compiler->Data[compiler->DataLength++]=value;(*length)++; } if(compiler->Position>=compiler->Length)return 0; compiler->Position++; if(compiler->DataLength>=sizeof(compiler->Data))return 0; compiler->Data[compiler->DataLength++]=0; return 1; } static int compiler_character(BOB64_C_COMPILER *compiler,u64 *value) { compiler_skip(compiler); if(compiler->Position>=compiler->Length||compiler->Source[compiler->Position]!='\'') return 0; compiler->Position++; if(compiler->Position>=compiler->Length)return 0; u8 character=(u8)compiler->Source[compiler->Position++]; if(character=='\\') { if(compiler->Position>=compiler->Length)return 0; character=(u8)compiler->Source[compiler->Position++]; if(character=='n')character='\n';else if(character=='r')character='\r'; else if(character=='t')character='\t';else if(character=='0')character=0; else if(character!='\\'&&character!='\''&&character!='"')return 0; } if(compiler->Position>=compiler->Length|| compiler->Source[compiler->Position++]!='\'')return 0; *value=(u64)(s64)(s8)character; return 1; } static int compiler_emit(BOB64_C_COMPILER *compiler,u8 value) { if(compiler->CodePosition>=sizeof(compiler->Code))return 0; compiler->Code[compiler->CodePosition++]=value;return 1; } static int compiler_emit_u32(BOB64_C_COMPILER *compiler,u32 value) { for(u32 i=0;i<4;i++)if(!compiler_emit(compiler,(u8)(value>>(i*8))))return 0; return 1; } static int compiler_emit_u64(BOB64_C_COMPILER *compiler,u64 value) { for(u32 i=0;i<8;i++)if(!compiler_emit(compiler,(u8)(value>>(i*8))))return 0; return 1; } static int compiler_emit_integer(BOB64_C_COMPILER *compiler,u64 value) { return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0xb8)&& compiler_emit_u64(compiler,value); } static int compiler_expression(BOB64_C_COMPILER *compiler); static int compiler_sizeof_type(BOB64_C_COMPILER *compiler,u32 *size_out) { u8 type=compiler_type_specifier(compiler); u64 count; u32 size; int pointer; if(!type)return -1; pointer=compiler_take(compiler,'*'); if(type==COMPILER_TYPE_VOID&&!pointer)return 0; size=pointer?8u:compiler_type_size(compiler,type); if(compiler_take(compiler,'[')) { if(!compiler_integer(compiler,&count)||!count|| !compiler_take(compiler,']')||count>0xffffffffu/size)return 0; size*=(u32)count; } if(!size)return 0; if(!compiler_take(compiler,')'))return -1; *size_out=size; return 1; } static int compiler_sizeof_expression(BOB64_C_COMPILER *compiler, u32 *size_out) { usize position=compiler->Position; char name[32]; u32 variable_size; int variable; if(compiler_identifier(compiler,name,sizeof(name))&& compiler_take(compiler,')')) { variable=compiler_variable_find(compiler,name); if(variable>=0) { u8 type=compiler_variable_type(compiler,(u32)variable); if(compiler_type_is_array(type)) variable_size=compiler_array_element_size(type)* compiler_variable_array_length(compiler,(u32)variable); else variable_size=compiler_type_size(compiler,type); if(variable_size) {*size_out=variable_size;return 1;} } compiler->Position=position; } else compiler->Position=position; if(positionLength&&compiler->Source[position]=='"') { usize old_data_length=compiler->DataLength; usize string_offset,string_length; if(compiler_string(compiler,&string_offset,&string_length)&& compiler_take(compiler,')')&&string_length<0xffffffffu) { compiler->DataLength=old_data_length; *size_out=(u32)string_length+1u; return 1; } compiler->DataLength=old_data_length; compiler->Position=position; } usize saved_code=compiler->CodePosition; usize saved_data=compiler->DataLength; u8 saved_calls=compiler->CallCount; u16 saved_stack=compiler->StackBytes; u8 saved_expression_type=compiler->ExpressionType; u8 saved_integer_type=compiler->IntegerType; if(!compiler_expression(compiler)||!compiler_take(compiler,')'))return 0; u8 type=compiler->ExpressionType; if(type==COMPILER_TYPE_VOID)return 0; variable_size=compiler_type_size(compiler,type); if(!variable_size)return 0; compiler->CodePosition=saved_code; compiler->DataLength=saved_data; compiler->CallCount=saved_calls; compiler->StackBytes=saved_stack; compiler->ExpressionType=saved_expression_type; compiler->IntegerType=saved_integer_type; *size_out=variable_size; return 1; } static int compiler_shift(BOB64_C_COMPILER *compiler); static int compiler_relational(BOB64_C_COMPILER *compiler); static int compiler_equality(BOB64_C_COMPILER *compiler); static int compiler_bitwise_and(BOB64_C_COMPILER *compiler); static int compiler_bitwise_xor(BOB64_C_COMPILER *compiler); static int compiler_bitwise_or(BOB64_C_COMPILER *compiler); static int compiler_emit_branch(BOB64_C_COMPILER *compiler,u8 opcode, u16 *displacement_offset); static int compiler_patch_branch(BOB64_C_COMPILER *compiler,u16 displacement_offset, usize target); static int compiler_for_post(BOB64_C_COMPILER *compiler); static int compiler_emit_call(BOB64_C_COMPILER *compiler,const char *name) { u8 argument_types[COMPILER_ARGUMENT_LIMIT]; u32 argument_count=0; u16 saved_stack_bytes=compiler->StackBytes; if(!compiler_take(compiler,'('))return 0; if(!compiler_take(compiler,')')) { for(;;) { if(argument_count>=COMPILER_ARGUMENT_LIMIT|| !compiler_expression(compiler)|| compiler->ExpressionType==COMPILER_TYPE_VOID)return 0; argument_types[argument_count++]=compiler->ExpressionType; if(!compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; if(compiler_take(compiler,')'))break; if(!compiler_take(compiler,','))return 0; } } if(compiler->CallCount>=COMPILER_CALL_LIMIT)return 0; u32 stack_argument_bytes=argument_count>4?(argument_count-4u)*8u:0u; u32 outgoing_bytes=32u+stack_argument_bytes; u32 allocation=outgoing_bytes+ ((16u-((compiler->StackBytes+outgoing_bytes)&15u))&15u); if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x83)|| !compiler_emit(compiler,0xec)||!compiler_emit(compiler,(u8)allocation))return 0; compiler->StackBytes=(u16)(compiler->StackBytes+allocation); for(u32 i=0;iCalls[compiler->CallCount++]; usize name_length=0; while(name[name_length]&&name_length+1Name)) { call->Name[name_length]=name[name_length];name_length++; } if(name[name_length])return 0; call->Name[name_length]=0; call->ArgumentCount=(u8)argument_count; for(u32 i=0;iArgumentTypes[i]=argument_types[i]; if(!compiler_emit(compiler,0xe8))return 0; call->DisplacementOffset=(u16)compiler->CodePosition; if(!compiler_emit_u32(compiler,0))return 0; u32 cleanup=allocation+argument_count*8u; if(cleanup<=127u) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x83)|| !compiler_emit(compiler,0xc4)||!compiler_emit(compiler,(u8)cleanup))return 0; } else if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x81)|| !compiler_emit(compiler,0xc4)|| !compiler_emit_u32(compiler,cleanup))return 0; /* Argument evaluation and the outgoing call frame are both temporary. Restore the depth that was present before evaluating the arguments; subtracting cleanup from the tracked depth underflows for ordinary calls. */ compiler->StackBytes=saved_stack_bytes; return 1; } static int compiler_index_address(BOB64_C_COMPILER *compiler,u32 variable) { u8 type=compiler_variable_type(compiler,variable); if(compiler_type_is_struct_pointer(type))return 0; if(compiler_type_is_array(type)) { if(!compiler_variable_address(compiler,variable,2))return 0; } else if(compiler_is_pointer(type)) { if(!compiler_variable_load(compiler,variable)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0xc2))return 0; } else return 0; if(!compiler_expression(compiler)||!compiler_take(compiler,']'))return 0; if(compiler_is_pointer(compiler->ExpressionType))return 0; /* Scale pointer offsets by the pointed-to element width. */ u8 pointer_type=compiler_type_is_array(type)?compiler_pointer_type(type):type; u32 scale=compiler_pointer_scale(compiler,pointer_type); if(scale==4) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x8d)|| !compiler_emit(compiler,0x04)||!compiler_emit(compiler,0x82))return 0; } else { if(!compiler_emit_scale_register(compiler,scale,0)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x01)|| !compiler_emit(compiler,0xc2)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x89)||!compiler_emit(compiler,0xd0))return 0; } compiler->ExpressionType=pointer_type; return 1; } static int compiler_increment_variable(BOB64_C_COMPILER *compiler,u32 variable, int postfix,char operation) { u8 type=compiler_variable_type(compiler,variable); u32 amount=1; if(compiler_type_is_array(type)||compiler_type_is_struct(type))return 0; if(compiler_is_pointer(type)) { amount=compiler_pointer_scale(compiler,type); if(!amount)return 0; } else if(type!=COMPILER_TYPE_CHAR&&type!=COMPILER_TYPE_SHORT&& type!=COMPILER_TYPE_INT&&type!=COMPILER_TYPE_LONG_LONG&& type!=COMPILER_TYPE_USIZE)return 0; if(!compiler_variable_load(compiler,variable))return 0; if(postfix) { if(!compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; } if(amount==1u) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x83)|| !compiler_emit(compiler,operation=='+'?0xc0:0xe8)|| !compiler_emit(compiler,1))return 0; } else if(!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,operation=='+'?0x05:0x2d)|| !compiler_emit_u32(compiler,amount))return 0; if(!compiler_variable_store(compiler,variable))return 0; if(postfix) { if(!compiler_emit(compiler,0x58))return 0; compiler->StackBytes-=8; } else if(type==COMPILER_TYPE_CHAR||type==COMPILER_TYPE_SHORT) { if(!compiler_variable_load(compiler,variable))return 0; } compiler->ExpressionType=type==COMPILER_TYPE_CHAR||type==COMPILER_TYPE_SHORT? COMPILER_TYPE_INT:type; return 1; } static int compiler_increment_pair(BOB64_C_COMPILER *compiler,char *operation) { compiler_skip(compiler); if(compiler->Position+1>=compiler->Length)return 0; char first=compiler->Source[compiler->Position]; if((first!='+'&&first!='-')||compiler->Source[compiler->Position+1]!=first) return 0; compiler->Position+=2; if(operation)*operation=first; return 1; } static int compiler_primary(BOB64_C_COMPILER *compiler) { u64 value; char name[32]; if(compiler_take(compiler,'(')) { if(!compiler_expression(compiler)||!compiler_take(compiler,')'))return 0; return 1; } if(compiler_integer(compiler,&value)) { compiler->ExpressionType=compiler->IntegerType; return compiler_emit_integer(compiler,value); } if(compiler_character(compiler,&value)) { compiler->ExpressionType=COMPILER_TYPE_INT; return compiler_emit_integer(compiler,value); } usize string_offset,string_length; if(compiler_string(compiler,&string_offset,&string_length)) { (void)string_length; s64 displacement=(s64)(BOB64_COMPILER_CODE_CAPACITY+string_offset)- (s64)(compiler->CodePosition+7); if(displacement<(-2147483647LL-1)||displacement>2147483647|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x8d)|| !compiler_emit(compiler,0x05)|| !compiler_emit_u32(compiler,(u32)(s32)displacement))return 0; compiler->ExpressionType=COMPILER_TYPE_CHAR_POINTER; return 1; } if(!compiler_identifier(compiler,name,sizeof(name)))return 0; compiler_skip(compiler); if(compiler->PositionLength&&compiler->Source[compiler->Position]=='(') { int function=compiler_function_find(compiler,name); if(compiler_variable_find(compiler,name)>=0|| !compiler_emit_call(compiler,name))return 0; compiler->ExpressionType=function>=0? compiler->Functions[function].ReturnType:COMPILER_TYPE_INT; if(compiler->ExpressionType==COMPILER_TYPE_VOID)return 0; return 1; } int enumerator=compiler_enum_constant_find(compiler,name); if(enumerator>=0) { compiler->ExpressionType=COMPILER_TYPE_INT; return compiler_emit_integer(compiler, compiler->EnumConstants[enumerator].Value); } int variable=compiler_variable_find(compiler,name); if(variable<0)return 0; u8 variable_type=compiler_variable_type(compiler,(u32)variable); int pointer_member=compiler_type_is_struct_pointer(variable_type); if(compiler_type_is_struct(variable_type)|| (pointer_member&&compiler->Position+1Length&& compiler->Source[compiler->Position]=='-'&& compiler->Source[compiler->Position+1]=='>')) { char field_name[32]; if((pointer_member?(!compiler_take(compiler,'-')||!compiler_take(compiler,'>')): !compiler_take(compiler,'.'))|| !compiler_identifier(compiler,field_name,sizeof(field_name)))return 0; u8 struct_type=pointer_member? (u8)(COMPILER_TYPE_STRUCT_BASE+variable_type-COMPILER_TYPE_STRUCT_POINTER_BASE): variable_type; int field_index=compiler_field_find(compiler,struct_type,field_name); if(field_index<0)return 0; BOB64_C_FIELD *field=&compiler->Structs[struct_type-COMPILER_TYPE_STRUCT_BASE].Fields[field_index]; int address_ok=pointer_member? (compiler_variable_load(compiler,(u32)variable)&& (!field->Offset||(compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x05)&& compiler_emit_u32(compiler,field->Offset)))): compiler_member_address(compiler,(u32)variable,field); if(!address_ok|| !compiler_member_load(compiler,field->Type))return 0; compiler->ExpressionType=field->Type; return 1; } if(compiler_take(compiler,'[')) { if(!compiler_index_address(compiler,(u32)variable))return 0; if(compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_CHAR_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_CHAR_ARRAY) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbe)||!compiler_emit(compiler,0x00))return 0; compiler->ExpressionType=COMPILER_TYPE_CHAR; } else if(compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_SHORT_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_SHORT_ARRAY) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbf)||!compiler_emit(compiler,0x00))return 0; compiler->ExpressionType=COMPILER_TYPE_SHORT; } else if(compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_USIZE_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_ISIZE_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_USIZE_ARRAY|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_LONG_LONG_ARRAY) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x8b)|| !compiler_emit(compiler,0x00))return 0; compiler->ExpressionType= (compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_USIZE_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_USIZE_ARRAY)? COMPILER_TYPE_USIZE:COMPILER_TYPE_LONG_LONG; } else { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x63)|| !compiler_emit(compiler,0x00))return 0; compiler->ExpressionType=COMPILER_TYPE_INT; } return 1; } if(compiler_type_is_array(compiler_variable_type(compiler,(u32)variable))) { compiler->ExpressionType=compiler_pointer_type( compiler_variable_type(compiler,(u32)variable)); return compiler_variable_address(compiler,(u32)variable,0); } char operation; if(compiler_increment_pair(compiler,&operation)) return compiler_increment_variable(compiler,(u32)variable,1,operation); compiler->ExpressionType=compiler_variable_type(compiler,(u32)variable); return compiler_variable_load(compiler,(u32)variable); } static int compiler_unary(BOB64_C_COMPILER *compiler) { { char operation,name[32]; if(compiler_increment_pair(compiler,&operation)) { if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int variable=compiler_variable_find(compiler,name); if(variable<0||!compiler_increment_variable(compiler,(u32)variable, 0,operation))return 0; return 1; } } if(compiler_word(compiler,"sizeof")) { u32 size; if(!compiler_take(compiler,'('))return 0; int type_result=compiler_sizeof_type(compiler,&size); if(!type_result)return 0; if(type_result<0&&!compiler_sizeof_expression(compiler,&size))return 0; if(!compiler_emit_integer(compiler,size))return 0; compiler->ExpressionType=COMPILER_TYPE_USIZE; return 1; } { usize saved_position=compiler->Position; if(compiler_take(compiler,'(')) { u8 value_type=compiler_type_specifier(compiler); int pointer=compiler_take(compiler,'*'); if(value_type&&compiler_take(compiler,')')) { u8 target_type=pointer?compiler_pointer_to(compiler,value_type):value_type; if(!target_type||(compiler_type_is_struct(value_type)&&!pointer)|| (!pointer&&value_type==COMPILER_TYPE_VOID)|| !compiler_unary(compiler)|| compiler->ExpressionType==COMPILER_TYPE_VOID|| compiler_type_is_struct(compiler->ExpressionType))return 0; if(!pointer) { if(target_type==COMPILER_TYPE_CHAR) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbe)||!compiler_emit(compiler,0xc0)) return 0; } else if(target_type==COMPILER_TYPE_SHORT) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbf)||!compiler_emit(compiler,0xc0)) return 0; } else if(target_type==COMPILER_TYPE_INT) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x63)|| !compiler_emit(compiler,0xc0))return 0; } else if(target_type!=COMPILER_TYPE_LONG_LONG&& target_type!=COMPILER_TYPE_USIZE)return 0; } compiler->ExpressionType=target_type; return 1; } compiler->Position=saved_position; } } if(compiler_take(compiler,'&')) { char name[32]; if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int variable=compiler_variable_find(compiler,name); u8 type=variable>=0?compiler_variable_type(compiler,(u32)variable):0; if(variable<0||(type!=COMPILER_TYPE_INT&&type!=COMPILER_TYPE_CHAR&& type!=COMPILER_TYPE_SHORT&&type!=COMPILER_TYPE_LONG_LONG&& type!=COMPILER_TYPE_USIZE&&type!=COMPILER_TYPE_INT_ARRAY&& type!=COMPILER_TYPE_CHAR_ARRAY&&type!=COMPILER_TYPE_SHORT_ARRAY&& type!=COMPILER_TYPE_LONG_LONG_ARRAY&&type!=COMPILER_TYPE_USIZE_ARRAY&& !compiler_type_is_struct(type)))return 0; compiler->ExpressionType=compiler_type_is_struct(type)? (u8)(COMPILER_TYPE_STRUCT_POINTER_BASE+type-COMPILER_TYPE_STRUCT_BASE): compiler_pointer_type(type==COMPILER_TYPE_CHAR_ARRAY?COMPILER_TYPE_CHAR: (type==COMPILER_TYPE_SHORT_ARRAY?COMPILER_TYPE_SHORT:type)); return compiler_variable_address(compiler,(u32)variable,0); } if(compiler_take(compiler,'*')) { if(!compiler_unary(compiler)||!compiler_is_pointer(compiler->ExpressionType)|| compiler->ExpressionType==COMPILER_TYPE_VOID_POINTER|| compiler_type_is_struct_pointer(compiler->ExpressionType)) return 0; if(compiler->ExpressionType==COMPILER_TYPE_CHAR_POINTER) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbe)||!compiler_emit(compiler,0x00))return 0; compiler->ExpressionType=COMPILER_TYPE_CHAR; } else if(compiler->ExpressionType==COMPILER_TYPE_SHORT_POINTER) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbf)||!compiler_emit(compiler,0x00))return 0; compiler->ExpressionType=COMPILER_TYPE_SHORT; } else if(compiler->ExpressionType==COMPILER_TYPE_USIZE_POINTER|| compiler->ExpressionType==COMPILER_TYPE_ISIZE_POINTER) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x8b)|| !compiler_emit(compiler,0x00))return 0; compiler->ExpressionType=compiler->ExpressionType==COMPILER_TYPE_USIZE_POINTER? COMPILER_TYPE_USIZE:COMPILER_TYPE_LONG_LONG; } else { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x63)|| !compiler_emit(compiler,0x00))return 0; compiler->ExpressionType=COMPILER_TYPE_INT; } return 1; } if(compiler_take(compiler,'!')) { if(!compiler_unary(compiler)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x85)||!compiler_emit(compiler,0xc0)|| !compiler_emit(compiler,0x0f)||!compiler_emit(compiler,0x94)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xb6)||!compiler_emit(compiler,0xc0))return 0; compiler->ExpressionType=COMPILER_TYPE_INT; return 1; } if(compiler_take(compiler,'~')) { if(!compiler_unary(compiler)||compiler_is_pointer(compiler->ExpressionType)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xf7)|| !compiler_emit(compiler,0xd0))return 0; return 1; } if(compiler_take(compiler,'-')) { if(!compiler_unary(compiler)||compiler_is_pointer(compiler->ExpressionType)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xf7)|| !compiler_emit(compiler,0xd8))return 0; if(compiler->ExpressionType!=COMPILER_TYPE_USIZE) compiler->ExpressionType=COMPILER_TYPE_INT; return 1; } return compiler_primary(compiler); } static int compiler_term(BOB64_C_COMPILER *compiler) { if(!compiler_unary(compiler))return 0; for(;;) { u8 left_type=compiler->ExpressionType; char operation; compiler_skip(compiler); if(compiler->Position>=compiler->Length)return 1; operation=compiler->Source[compiler->Position]; if(operation!='*'&&operation!='/'&&operation!='%')return 1; compiler->Position++; if(compiler_is_pointer(compiler->ExpressionType)|| !compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; if(!compiler_unary(compiler)|| compiler_is_pointer(compiler->ExpressionType))return 0; u8 right_type=compiler->ExpressionType; if(operation=='*') { if(!compiler_emit(compiler,0x59)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xaf)||!compiler_emit(compiler,0xc1))return 0; compiler->StackBytes-=8; } else { int unsigned_operation=left_type==COMPILER_TYPE_USIZE|| right_type==COMPILER_TYPE_USIZE; if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0xc1)||!compiler_emit(compiler,0x58))return 0; compiler->StackBytes-=8; if(unsigned_operation) { if(!compiler_emit(compiler,0x31)||!compiler_emit(compiler,0xd2)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xf7)|| !compiler_emit(compiler,0xf1))return 0; } else if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x99)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xf7)|| !compiler_emit(compiler,0xf9))return 0; if(operation=='%'&& (!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0xd0)))return 0; } compiler->ExpressionType=left_type==COMPILER_TYPE_USIZE|| right_type==COMPILER_TYPE_USIZE? COMPILER_TYPE_USIZE: (left_type==COMPILER_TYPE_LONG_LONG|| right_type==COMPILER_TYPE_LONG_LONG? COMPILER_TYPE_LONG_LONG:COMPILER_TYPE_INT); } } static int compiler_additive(BOB64_C_COMPILER *compiler) { if(!compiler_term(compiler))return 0; for(;;) { char operation; u8 left_type=compiler->ExpressionType,right_type; compiler_skip(compiler); if(compiler->Position>=compiler->Length)return 1; operation=compiler->Source[compiler->Position]; if(operation!='+'&&operation!='-')return 1; compiler->Position++; if(!compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; if(!compiler_term(compiler))return 0; right_type=compiler->ExpressionType; if(compiler_is_pointer(left_type)&&compiler_is_pointer(right_type)) { if(!compiler_pointer_types_compatible(left_type,right_type)|| left_type==COMPILER_TYPE_VOID_POINTER|| right_type==COMPILER_TYPE_VOID_POINTER)return 0; if(operation!='-'||!compiler_emit(compiler,0x59)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x29)|| !compiler_emit(compiler,0xc1)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x89)||!compiler_emit(compiler,0xc8))return 0; u32 scale=compiler_pointer_scale(compiler,left_type); if(scale==2||scale==4||scale==8) { u8 shift=scale==2?1:(scale==4?2:3); if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xc1)|| !compiler_emit(compiler,0xf8)||!compiler_emit(compiler,shift))return 0; } else if(scale!=1&& (!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x99)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xb9)|| !compiler_emit_u64(compiler,scale)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0xf7)||!compiler_emit(compiler,0xf9)))return 0; compiler->StackBytes-=8; compiler->ExpressionType=COMPILER_TYPE_LONG_LONG; continue; } if(compiler_is_pointer(left_type)) { if(left_type==COMPILER_TYPE_VOID_POINTER)return 0; if(!compiler_emit_scale_register(compiler, compiler_pointer_scale(compiler,left_type),0))return 0; } else if(compiler_is_pointer(right_type)) { if(right_type==COMPILER_TYPE_VOID_POINTER||operation!='+'||!compiler_emit(compiler,0x59)|| !compiler_emit_scale_register(compiler, compiler_pointer_scale(compiler,right_type),1)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x01)|| !compiler_emit(compiler,0xc8))return 0; compiler->StackBytes-=8; compiler->ExpressionType=right_type; continue; } if(!compiler_emit(compiler,0x59))return 0; compiler->StackBytes-=8; if(operation=='+') { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x01)|| !compiler_emit(compiler,0xc8))return 0; } else if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x29)|| !compiler_emit(compiler,0xc1)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x89)||!compiler_emit(compiler,0xc8))return 0; compiler->ExpressionType=compiler_is_pointer(left_type)?left_type: (left_type==COMPILER_TYPE_USIZE||right_type==COMPILER_TYPE_USIZE? COMPILER_TYPE_USIZE: (left_type==COMPILER_TYPE_LONG_LONG||right_type==COMPILER_TYPE_LONG_LONG? COMPILER_TYPE_LONG_LONG:COMPILER_TYPE_INT)); } } typedef int (*COMPILER_EXPRESSION_PARSER)(BOB64_C_COMPILER *compiler); static int compiler_shift(BOB64_C_COMPILER *compiler) { if(!compiler_additive(compiler))return 0; for(;;) { compiler_skip(compiler); if(compiler->Position+1>=compiler->Length|| (compiler->Source[compiler->Position]!='<'&& compiler->Source[compiler->Position]!='>')|| compiler->Source[compiler->Position+1]!=compiler->Source[compiler->Position]) return 1; char operation=compiler->Source[compiler->Position]; u8 left_type=compiler->ExpressionType; compiler->Position+=2; if(compiler_is_pointer(left_type)||!compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; if(!compiler_additive(compiler)||compiler_is_pointer(compiler->ExpressionType))return 0; u8 right_type=compiler->ExpressionType; if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0xc1)||!compiler_emit(compiler,0x58))return 0; compiler->StackBytes-=8; if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xd3)|| !compiler_emit(compiler,operation=='<'?0xe0: (left_type==COMPILER_TYPE_USIZE?0xe8:0xf8)))return 0; compiler->ExpressionType=left_type==COMPILER_TYPE_USIZE|| right_type==COMPILER_TYPE_USIZE?COMPILER_TYPE_USIZE: (left_type==COMPILER_TYPE_LONG_LONG||right_type==COMPILER_TYPE_LONG_LONG? COMPILER_TYPE_LONG_LONG:COMPILER_TYPE_INT); } } static int compiler_compare_level(BOB64_C_COMPILER *compiler, COMPILER_EXPRESSION_PARSER lower,int equality) { typedef struct { char First,Second;u8 Length,SetCondition,UnsignedCondition; } OP; static const OP equal_ops[]={ {'=', '=',2,0x94,0x94},{'!', '=',2,0x95,0x95} }; static const OP relational_ops[]={ {'<', '=',2,0x9e,0x96},{'>', '=',2,0x9d,0x93}, {'<', 0,1,0x9c,0x92},{'>', 0,1,0x9f,0x97} }; const OP *operations=equality?equal_ops:relational_ops; u32 count=equality?2:4; if(!lower(compiler))return 0; for(;;) { compiler_skip(compiler); if(compiler->Position>=compiler->Length)return 1; int operation=-1; for(u32 i=0;iSource[compiler->Position]!=candidate->First)continue; if(candidate->Length==2) { if(compiler->Position+1>=compiler->Length|| compiler->Source[compiler->Position+1]!=candidate->Second)continue; } else if(compiler->Position+1Length&& compiler->Source[compiler->Position+1]=='=')continue; operation=(int)i;break; } if(operation<0)return 1; u8 left_type=compiler->ExpressionType; compiler->Position+=operations[operation].Length; if(!compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; if(!lower(compiler))return 0; u8 right_type=compiler->ExpressionType; int pointer_comparison=compiler_is_pointer(left_type)|| compiler_is_pointer(right_type); if(pointer_comparison&&(!compiler_pointer_types_compatible(left_type,right_type)|| !compiler_is_pointer(left_type)||!equality))return 0; u8 condition=left_type==COMPILER_TYPE_USIZE||right_type==COMPILER_TYPE_USIZE? operations[operation].UnsignedCondition:operations[operation].SetCondition; if(!compiler_emit(compiler,0x59)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x39)||!compiler_emit(compiler,0xc1)|| !compiler_emit(compiler,0x0f)||!compiler_emit(compiler,condition)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xb6)||!compiler_emit(compiler,0xc0))return 0; compiler->StackBytes-=8; compiler->ExpressionType=COMPILER_TYPE_INT; } } static int compiler_relational(BOB64_C_COMPILER *compiler) { return compiler_compare_level(compiler,compiler_shift,0); } static int compiler_equality(BOB64_C_COMPILER *compiler) { return compiler_compare_level(compiler,compiler_relational,1); } static int compiler_bitwise_level(BOB64_C_COMPILER *compiler, COMPILER_EXPRESSION_PARSER lower,char operation,u8 opcode) { if(!lower(compiler))return 0; for(;;) { compiler_skip(compiler); if(compiler->Position>=compiler->Length|| compiler->Source[compiler->Position]!=operation)return 1; if((operation=='&'||operation=='|')&& compiler->Position+1Length&& compiler->Source[compiler->Position+1]==operation)return 1; u8 left_type=compiler->ExpressionType; if(compiler_is_pointer(left_type))return 0; compiler->Position++; if(!compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; if(!lower(compiler)||compiler_is_pointer(compiler->ExpressionType))return 0; u8 right_type=compiler->ExpressionType; if(!compiler_emit(compiler,0x59)||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,opcode)||!compiler_emit(compiler,0xc8))return 0; compiler->StackBytes-=8; compiler->ExpressionType=left_type==COMPILER_TYPE_USIZE|| right_type==COMPILER_TYPE_USIZE?COMPILER_TYPE_USIZE: (left_type==COMPILER_TYPE_LONG_LONG||right_type==COMPILER_TYPE_LONG_LONG? COMPILER_TYPE_LONG_LONG:COMPILER_TYPE_INT); } } static int compiler_bitwise_and(BOB64_C_COMPILER *compiler) { return compiler_bitwise_level(compiler,compiler_equality,'&',0x21); } static int compiler_bitwise_xor(BOB64_C_COMPILER *compiler) { return compiler_bitwise_level(compiler,compiler_bitwise_and,'^',0x31); } static int compiler_bitwise_or(BOB64_C_COMPILER *compiler) { return compiler_bitwise_level(compiler,compiler_bitwise_xor,'|',0x09); } static int compiler_logical_and(BOB64_C_COMPILER *compiler) { if(!compiler_bitwise_or(compiler))return 0; for(;;) { u16 false_branch,end_branch; compiler_skip(compiler); if(compiler->Position+1>=compiler->Length|| compiler->Source[compiler->Position]!='&'|| compiler->Source[compiler->Position+1]!='&')return 1; compiler->Position+=2; if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x85)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit_branch(compiler,0x84,&false_branch)|| !compiler_bitwise_or(compiler)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x85)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0x95)||!compiler_emit(compiler,0xc0)|| !compiler_emit(compiler,0x0f)||!compiler_emit(compiler,0xb6)|| !compiler_emit(compiler,0xc0)|| !compiler_emit_branch(compiler,0xe9,&end_branch)|| !compiler_patch_branch(compiler,false_branch,compiler->CodePosition)|| !compiler_emit(compiler,0x31)||!compiler_emit(compiler,0xc0)|| !compiler_patch_branch(compiler,end_branch,compiler->CodePosition))return 0; compiler->ExpressionType=COMPILER_TYPE_INT; } } static int compiler_expression(BOB64_C_COMPILER *compiler) { if(!compiler_logical_and(compiler))return 0; for(;;) { u16 true_branch,end_branch; compiler_skip(compiler); if(compiler->Position+1>=compiler->Length|| compiler->Source[compiler->Position]!='|'|| compiler->Source[compiler->Position+1]!='|')return 1; compiler->Position+=2; if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x85)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit_branch(compiler,0x85,&true_branch)|| !compiler_logical_and(compiler)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x85)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0x95)||!compiler_emit(compiler,0xc0)|| !compiler_emit(compiler,0x0f)||!compiler_emit(compiler,0xb6)|| !compiler_emit(compiler,0xc0)|| !compiler_emit_branch(compiler,0xe9,&end_branch)|| !compiler_patch_branch(compiler,true_branch,compiler->CodePosition)|| !compiler_emit(compiler,0xb8)||!compiler_emit_u32(compiler,1)|| !compiler_patch_branch(compiler,end_branch,compiler->CodePosition))return 0; compiler->ExpressionType=COMPILER_TYPE_INT; } } static int compiler_array_element_address(BOB64_C_COMPILER *compiler, u32 variable,u32 element) { u32 type=compiler->VariableType[variable]; u32 scale=compiler_array_element_size((u8)type); s16 displacement=(s16)(compiler->VariableDisplacement[variable]+(s16)(element*scale)); if(element>=compiler->VariableArrayLength[variable])return 0; return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x8d)&& compiler_emit_rbp_operand(compiler,0x45,displacement); } static int compiler_array_initializer(BOB64_C_COMPILER *compiler,u32 variable) { u32 element=0; if(compiler->VariableType[variable]==COMPILER_TYPE_CHAR_ARRAY) { usize offset,length; if(compiler_string(compiler,&offset,&length)) { u32 array_length=compiler_variable_array_length(compiler,variable); if(length>array_length)return 0; for(u32 i=0;iData[offset+i]:0; if(!compiler_array_element_address(compiler,variable,i)|| !compiler_emit(compiler,0xc6)|| !compiler_emit_rbp_operand(compiler,0x45, (s16)(compiler->VariableDisplacement[variable]+(s16)i))|| !compiler_emit(compiler,value))return 0; } return compiler_take(compiler,';'); } } if(!compiler_take(compiler,'{'))return 0; for(;;) { if(compiler_take(compiler,'}'))break; if(element>=compiler_variable_array_length(compiler,variable)|| !compiler_array_element_address(compiler,variable,element)|| !compiler_emit(compiler,0x50))return 0; compiler->StackBytes+=8; if(!compiler_expression(compiler)|| compiler_is_pointer(compiler->ExpressionType)|| !compiler_emit(compiler,0x59))return 0; if(compiler->VariableType[variable]==COMPILER_TYPE_CHAR_ARRAY) { if(!compiler_emit(compiler,0x88)||!compiler_emit(compiler,0x01))return 0; } else if(compiler->VariableType[variable]==COMPILER_TYPE_SHORT_ARRAY) { if(!compiler_emit(compiler,0x66)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01))return 0; } else if(compiler->VariableType[variable]==COMPILER_TYPE_LONG_LONG_ARRAY|| compiler->VariableType[variable]==COMPILER_TYPE_USIZE_ARRAY) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01))return 0; } else if(!compiler_emit(compiler,0x89)||!compiler_emit(compiler,0x01))return 0; compiler->StackBytes-=8; element++; if(compiler_take(compiler,'}'))break; if(!compiler_take(compiler,','))return 0; } while(elementStackBytes+=8; if(!compiler_emit(compiler,0x31)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x59))return 0; if(compiler->VariableType[variable]==COMPILER_TYPE_CHAR_ARRAY) { if(!compiler_emit(compiler,0x88)||!compiler_emit(compiler,0x01))return 0; } else if(compiler->VariableType[variable]==COMPILER_TYPE_SHORT_ARRAY) { if(!compiler_emit(compiler,0x66)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01))return 0; } else if(compiler->VariableType[variable]==COMPILER_TYPE_LONG_LONG_ARRAY|| compiler->VariableType[variable]==COMPILER_TYPE_USIZE_ARRAY) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01))return 0; } else if(!compiler_emit(compiler,0x89)||!compiler_emit(compiler,0x01))return 0; compiler->StackBytes-=8; } return compiler_take(compiler,';'); } /* Return 1 for a consumed local declaration/assignment, 0 for another statement. */ static int compiler_local_statement(BOB64_C_COMPILER *compiler) { usize saved=compiler->Position; char name[32]; u8 declared_type=compiler_type_specifier(compiler); int is_char=0,is_short=0,is_pointer=0,is_struct=0,variable; if(!declared_type) { compiler->Position=saved; if(compiler_take(compiler,'*')) { if(!compiler_identifier(compiler,name,sizeof(name))) { compiler->Position=saved;return 0; } variable=compiler_variable_find(compiler,name); if(variable<0||!compiler_is_pointer(compiler_variable_type(compiler,(u32)variable))|| !compiler_take(compiler,'=')) { compiler->Position=saved;return 0; } if(!compiler_variable_load(compiler,(u32)variable)|| !compiler_emit(compiler,0x50))return -1; compiler->StackBytes+=8; if(!compiler_expression(compiler)|| compiler_is_pointer(compiler->ExpressionType)|| !compiler_take(compiler,';')||!compiler_emit(compiler,0x59)|| (compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_CHAR_POINTER? (!compiler_emit(compiler,0x88)||!compiler_emit(compiler,0x01)): (compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_SHORT_POINTER? (!compiler_emit(compiler,0x66)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01)): ((compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_USIZE_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_ISIZE_POINTER)? (!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01)): (!compiler_emit(compiler,0x89)||!compiler_emit(compiler,0x01))))))return -1; compiler->StackBytes-=8; return 1; } if(!compiler_identifier(compiler,name,sizeof(name))) { compiler->Position=saved;return 0; } variable=compiler_variable_find(compiler,name); if(variable<0) { compiler->Position=saved;return 0; } u8 variable_type=compiler_variable_type(compiler,(u32)variable); char increment_operation; if(compiler_increment_pair(compiler,&increment_operation)) { if(!compiler_increment_variable(compiler,(u32)variable,1, increment_operation)|| !compiler_take(compiler,';'))return -1; return 1; } int pointer_member=compiler_type_is_struct_pointer(variable_type); if(compiler_type_is_struct(variable_type)||pointer_member) { char field_name[32]; if((pointer_member?(!compiler_take(compiler,'-')||!compiler_take(compiler,'>')): !compiler_take(compiler,'.'))|| !compiler_identifier(compiler,field_name,sizeof(field_name)))return -1; u8 struct_type=pointer_member? (u8)(COMPILER_TYPE_STRUCT_BASE+variable_type-COMPILER_TYPE_STRUCT_POINTER_BASE): variable_type; int field_index=compiler_field_find(compiler,struct_type,field_name); if(field_index<0)return -1; BOB64_C_FIELD *field=&compiler->Structs[ struct_type-COMPILER_TYPE_STRUCT_BASE].Fields[field_index]; int address_ok=pointer_member? (compiler_variable_load(compiler,(u32)variable)&& (!field->Offset||(compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x05)&& compiler_emit_u32(compiler,field->Offset)))): compiler_member_address(compiler,(u32)variable,field); if(!compiler_take(compiler,'=')||!address_ok|| !compiler_emit(compiler,0x50))return -1; compiler->StackBytes+=8; if(!compiler_expression(compiler)|| !compiler_value_types_compatible(field->Type,compiler->ExpressionType)|| !compiler_take(compiler,';')||!compiler_emit(compiler,0x59)|| !compiler_member_store(compiler,field->Type))return -1; compiler->StackBytes-=8; return 1; } if(compiler_take(compiler,'[')) { if((!compiler_type_is_array(compiler_variable_type(compiler,(u32)variable))&& !compiler_is_pointer(compiler_variable_type(compiler,(u32)variable)))|| !compiler_index_address(compiler,(u32)variable)|| !compiler_take(compiler,'=')||!compiler_emit(compiler,0x50))return -1; compiler->StackBytes+=8; if(!compiler_expression(compiler)|| compiler_is_pointer(compiler->ExpressionType)|| !compiler_take(compiler,';')||!compiler_emit(compiler,0x59))return -1; if(compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_CHAR_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_CHAR_ARRAY) { if(!compiler_emit(compiler,0x88)||!compiler_emit(compiler,0x01))return -1; } else if(compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_SHORT_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_SHORT_ARRAY) { if(!compiler_emit(compiler,0x66)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01))return -1; } else if(compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_USIZE_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_ISIZE_POINTER|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_USIZE_ARRAY|| compiler_variable_type(compiler,(u32)variable)==COMPILER_TYPE_LONG_LONG_ARRAY) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0x01))return -1; } else if(!compiler_emit(compiler,0x89)||!compiler_emit(compiler,0x01))return -1; compiler->StackBytes-=8; return 1; } if(compiler_type_is_array(compiler_variable_type(compiler,(u32)variable))|| !compiler_take(compiler,'=')) { compiler->Position=saved;return 0; } if(!compiler_expression(compiler)|| !compiler_value_types_compatible( compiler_variable_type(compiler,(u32)variable), compiler->ExpressionType)|| !compiler_take(compiler,';')|| !compiler_variable_store(compiler,(u32)variable))return -1; return 1; } if(compiler_take(compiler,'*')) { declared_type=compiler_pointer_to(compiler,declared_type); if(!declared_type)return -1; } if(declared_type==COMPILER_TYPE_VOID)return -1; is_struct=compiler_type_is_struct(declared_type); is_pointer=compiler_is_pointer(declared_type); is_char=declared_type==COMPILER_TYPE_CHAR; is_short=declared_type==COMPILER_TYPE_SHORT; if(!compiler_identifier(compiler,name,sizeof(name)))return -1; if(is_struct) { if(!compiler_take(compiler,';')|| !compiler_add_variable(compiler,name,declared_type,0,0))return -1; return 1; } if(compiler_take(compiler,'[')) { u64 array_length; u8 array_type=compiler_array_type(declared_type); if(!array_type)return -1; u32 array_limit=is_char?COMPILER_LOCAL_FRAME_SIZE: (is_short?COMPILER_LOCAL_FRAME_SIZE/2u: ((array_type==COMPILER_TYPE_LONG_LONG_ARRAY|| array_type==COMPILER_TYPE_USIZE_ARRAY)? COMPILER_LOCAL_FRAME_SIZE/8u:COMPILER_LOCAL_FRAME_SIZE/4u)); if(is_pointer||!compiler_integer(compiler,&array_length)|| array_length>array_limit||!compiler_take(compiler,']')|| !compiler_add_variable(compiler,name,array_type, (u32)array_length,0))return -1; variable=compiler_variable_find(compiler,name); if(compiler_take(compiler,';'))return 1; if(!compiler_take(compiler,'=')|| !compiler_array_initializer(compiler,(u32)variable))return -1; return 1; } u8 type=declared_type; if(!compiler_add_variable(compiler,name,type,0,0))return -1; variable=compiler_variable_find(compiler,name); if(compiler_take(compiler,';'))return 1; if(!compiler_take(compiler,'='))return -1; if(!compiler_expression(compiler)|| !compiler_value_types_compatible(type,compiler->ExpressionType)|| !compiler_take(compiler,';')|| !compiler_variable_store(compiler,(u32)variable))return -1; return 1; } static int compiler_function_prologue(BOB64_C_COMPILER *compiler) { return compiler_emit(compiler,0x55)&&compiler_emit(compiler,0x48)&& compiler_emit(compiler,0x89)&&compiler_emit(compiler,0xe5)&& compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x81)&& compiler_emit(compiler,0xec)&& compiler_emit_u32(compiler,COMPILER_LOCAL_FRAME_SIZE); } static int compiler_function_epilogue(BOB64_C_COMPILER *compiler) { if(compiler->ReturnType==COMPILER_TYPE_CHAR) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbe)||!compiler_emit(compiler,0xc0))return 0; } else if(compiler->ReturnType==COMPILER_TYPE_SHORT) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x0f)|| !compiler_emit(compiler,0xbf)||!compiler_emit(compiler,0xc0))return 0; } else if(compiler->ReturnType!=COMPILER_TYPE_VOID&&!compiler->Return64&& (!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x63)||!compiler_emit(compiler,0xc0)))return 0; return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x89)&& compiler_emit(compiler,0xec)&&compiler_emit(compiler,0x5d)&& compiler_emit(compiler,0xc3); } static int compiler_return_type_matches(BOB64_C_COMPILER *compiler) { if(compiler->ReturnType==COMPILER_TYPE_VOID|| compiler->ExpressionType==COMPILER_TYPE_VOID)return 0; int result_pointer=compiler_is_pointer(compiler->ReturnType); int expression_pointer=compiler_is_pointer(compiler->ExpressionType); if(result_pointer)return expression_pointer&& compiler_pointer_types_compatible(compiler->ReturnType,compiler->ExpressionType); return !expression_pointer||compiler->Return64; } static int compiler_statement(BOB64_C_COMPILER *compiler); static int compiler_emit_branch(BOB64_C_COMPILER *compiler,u8 opcode, u16 *displacement_offset) { if(!compiler_emit(compiler,opcode))return 0; *displacement_offset=(u16)compiler->CodePosition; return compiler_emit_u32(compiler,0); } static int compiler_patch_branch(BOB64_C_COMPILER *compiler,u16 displacement_offset, usize target) { s64 displacement=(s64)target-(s64)(displacement_offset+4u); if(displacement<(-2147483647LL-1)||displacement>2147483647|| displacement_offset+4u>compiler->CodePosition)return 0; u32 encoded=(u32)(s32)displacement; for(u32 byte=0;byte<4;byte++) compiler->Code[displacement_offset+byte]=(u8)(encoded>>(byte*8)); return 1; } static int compiler_loop_push(BOB64_C_COMPILER *compiler,usize continue_target) { if(compiler->ControlCount>=sizeof(compiler->Controls)/sizeof(compiler->Controls[0])|| continue_target>0xffffu)return 0; BOB64_C_CONTROL *loop=&compiler->Controls[compiler->ControlCount++]; loop->Kind=COMPILER_CONTROL_LOOP; loop->ContinueTarget=(u16)continue_target; loop->BreakCount=0;loop->ContinueCount=0; return 1; } static int compiler_loop_finish(BOB64_C_COMPILER *compiler,usize break_target) { if(!compiler->ControlCount|| compiler->Controls[compiler->ControlCount-1].Kind!=COMPILER_CONTROL_LOOP) return 0; BOB64_C_CONTROL *loop=&compiler->Controls[--compiler->ControlCount]; for(u32 i=0;iBreakCount;i++) if(!compiler_patch_branch(compiler,loop->BreakBranches[i],break_target))return 0; for(u32 i=0;iContinueCount;i++) if(!compiler_patch_branch(compiler,loop->ContinueBranches[i],loop->ContinueTarget))return 0; return 1; } static int compiler_switch_push(BOB64_C_COMPILER *compiler, BOB64_C_CONTROL **control) { if(compiler->ControlCount>=sizeof(compiler->Controls)/sizeof(compiler->Controls[0])) return 0; BOB64_C_CONTROL *entry=&compiler->Controls[compiler->ControlCount++]; entry->Kind=COMPILER_CONTROL_SWITCH;entry->BreakCount=0; entry->ContinueCount=0;entry->CaseCount=0;entry->HasDefault=0; *control=entry; return 1; } static int compiler_switch_finish(BOB64_C_COMPILER *compiler, usize break_target) { if(!compiler->ControlCount|| compiler->Controls[compiler->ControlCount-1].Kind!=COMPILER_CONTROL_SWITCH) return 0; BOB64_C_CONTROL *control=&compiler->Controls[--compiler->ControlCount]; for(u32 i=0;iBreakCount;i++) if(!compiler_patch_branch(compiler,control->BreakBranches[i],break_target)) return 0; return 1; } static int compiler_switch_temporary(BOB64_C_COMPILER *compiler,u8 type, u32 *variable) { for(u32 candidate=0;candidate<100;candidate++) { char name[16]={'_','b','6','4','s','w', (char)('0'+candidate/10),(char)('0'+candidate%10),0}; if(compiler_variable_find(compiler,name)<0) { if(!compiler_add_variable(compiler,name,type,0,0))return 0; int found=compiler_variable_find(compiler,name); if(found<0||found>=0x8000)return 0; *variable=(u32)found; return 1; } } return 0; } static int compiler_switch_constant(BOB64_C_COMPILER *compiler,u64 *value) { int negative=compiler_take(compiler,'-'); if(!negative)compiler_take(compiler,'+'); if(compiler_character(compiler,value)) { if(negative)*value=0u-*value; return 1; } if(!compiler_integer(compiler,value)) { char name[32]; if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int enumerator=compiler_enum_constant_find(compiler,name); if(enumerator<0)return 0; *value=compiler->EnumConstants[enumerator].Value; if(negative)*value=0u-*value; return 1; } if(negative) { if(*value>0x8000000000000000ULL)return 0; *value=0u-*value; } return 1; } static int compiler_statement(BOB64_C_COMPILER *compiler) { usize saved=compiler->Position; { char operation,name[32]; if(compiler_increment_pair(compiler,&operation)) { if(!compiler_identifier(compiler,name,sizeof(name)))return -1; int variable=compiler_variable_find(compiler,name); if(variable<0||!compiler_increment_variable(compiler,(u32)variable, 0,operation)|| !compiler_take(compiler,';'))return -1; return 1; } compiler->Position=saved; } if(compiler_word(compiler,"return")) { if(compiler->ReturnType==COMPILER_TYPE_VOID) { if(compiler->StackBytes||!compiler_take(compiler,';')|| !compiler_function_epilogue(compiler))return -1; return 1; } if(compiler->StackBytes||!compiler_expression(compiler)|| !compiler_return_type_matches(compiler)|| !compiler_take(compiler,';')||!compiler_function_epilogue(compiler))return -1; return 1; } compiler->Position=saved; if(compiler_word(compiler,"break")) { if(!compiler->ControlCount||!compiler_take(compiler,';'))return -1; BOB64_C_CONTROL *control=&compiler->Controls[compiler->ControlCount-1]; if(control->BreakCount>=sizeof(control->BreakBranches)/ sizeof(control->BreakBranches[0])|| !compiler_emit_branch(compiler,0xe9, &control->BreakBranches[control->BreakCount]))return -1; control->BreakCount++; return 1; } compiler->Position=saved; if(compiler_word(compiler,"continue")) { BOB64_C_CONTROL *loop=0; for(u32 depth=compiler->ControlCount;depth>0;depth--) if(compiler->Controls[depth-1].Kind==COMPILER_CONTROL_LOOP) { loop=&compiler->Controls[depth-1];break; } if(!loop||!compiler_take(compiler,';'))return -1; if(loop->ContinueCount>=sizeof(loop->ContinueBranches)/ sizeof(loop->ContinueBranches[0])|| !compiler_emit_branch(compiler,0xe9, &loop->ContinueBranches[loop->ContinueCount]))return -1; loop->ContinueCount++; return 1; } compiler->Position=saved; if(compiler_word(compiler,"if")) { u16 false_branch,end_branch; if(compiler->ControlDepth>=32||!compiler_take(compiler,'(')|| !compiler_expression(compiler)||!compiler_take(compiler,')')|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x85)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit_branch(compiler,0x84,&false_branch))return -1; compiler->ControlDepth++; if(compiler_statement(compiler)<=0)return -1; compiler->ControlDepth--; if(compiler_word(compiler,"else")) { if(!compiler_emit_branch(compiler,0xe9,&end_branch)|| !compiler_patch_branch(compiler,false_branch,compiler->CodePosition))return -1; compiler->ControlDepth++; if(compiler_statement(compiler)<=0)return -1; compiler->ControlDepth--; if(!compiler_patch_branch(compiler,end_branch,compiler->CodePosition))return -1; } else if(!compiler_patch_branch(compiler,false_branch,compiler->CodePosition))return -1; return 1; } compiler->Position=saved; if(compiler_word(compiler,"switch")) { BOB64_C_CONTROL *control; u16 enter_dispatch,body_exit,end_branch=0; u32 value_variable; if(compiler->ControlDepth>=32||!compiler_scope_push(compiler)|| !compiler_take(compiler,'(')||!compiler_expression(compiler))return -1; u8 switch_type=compiler->ExpressionType; if(compiler_is_pointer(switch_type)||compiler_type_is_array(switch_type)|| compiler_type_is_struct(switch_type)||switch_type==COMPILER_TYPE_VOID|| !compiler_switch_temporary(compiler,switch_type,&value_variable)|| !compiler_variable_store(compiler,value_variable)|| !compiler_take(compiler,')')||!compiler_take(compiler,'{')|| !compiler_switch_push(compiler,&control)|| !compiler_emit_branch(compiler,0xe9,&enter_dispatch))return -1; compiler->ControlDepth++; for(;;) { usize statement_start=compiler->Position; if(compiler_take(compiler,'}'))break; if(compiler_word(compiler,"case")) { u64 value; if(control->CaseCount>=COMPILER_SWITCH_CASE_LIMIT|| !compiler_switch_constant(compiler,&value)|| !compiler_take(compiler,':'))return -1; for(u32 i=0;iCaseCount;i++) if(control->CaseValues[i]==value)return -1; u32 index=control->CaseCount++; control->CaseValues[index]=value; control->CaseTargets[index]=(u16)compiler->CodePosition; continue; } compiler->Position=statement_start; if(compiler_word(compiler,"default")) { if(control->HasDefault||!compiler_take(compiler,':'))return -1; control->HasDefault=1; control->DefaultTarget=(u16)compiler->CodePosition; continue; } compiler->Position=statement_start; if(compiler_statement(compiler)<=0)return -1; } compiler->ControlDepth--; if(!compiler_emit_branch(compiler,0xe9,&body_exit)|| !compiler_patch_branch(compiler,enter_dispatch, compiler->CodePosition))return -1; for(u32 i=0;iCaseCount;i++) { if(!compiler_variable_load(compiler,value_variable)|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0xb9)|| !compiler_emit_u64(compiler,control->CaseValues[i])|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x39)|| !compiler_emit(compiler,0xc8)||!compiler_emit(compiler,0x0f)) return -1; u16 case_branch; if(!compiler_emit_branch(compiler,0x84,&case_branch)|| !compiler_patch_branch(compiler,case_branch, control->CaseTargets[i]))return -1; } if(control->HasDefault) { if(!compiler_emit_branch(compiler,0xe9,&end_branch)|| !compiler_patch_branch(compiler,end_branch, control->DefaultTarget))return -1; } else if(!compiler_emit_branch(compiler,0xe9,&end_branch))return -1; usize switch_end=compiler->CodePosition; if(!compiler_patch_branch(compiler,body_exit,switch_end)|| (!control->HasDefault&& !compiler_patch_branch(compiler,end_branch,switch_end))|| !compiler_switch_finish(compiler,switch_end))return -1; compiler_scope_pop(compiler); return 1; } compiler->Position=saved; if(compiler_word(compiler,"for")) { u16 loop_exit,body_branch,loop_back; usize loop_start,post_start,body_start; if(compiler->ControlDepth>=32||!compiler_take(compiler,'(')|| !compiler_scope_push(compiler))return -1; if(!compiler_take(compiler,';')) { int init=compiler_local_statement(compiler); if(init<=0)return -1; } loop_start=compiler->CodePosition; if(compiler_take(compiler,';')) { if(!compiler_emit_integer(compiler,1))return -1; } else if(!compiler_expression(compiler)||!compiler_take(compiler,';'))return -1; if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x85)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit_branch(compiler,0x84,&loop_exit)|| !compiler_emit_branch(compiler,0xe9,&body_branch))return -1; post_start=compiler->CodePosition; if(!compiler_take(compiler,')')&& (!compiler_for_post(compiler)||!compiler_take(compiler,')')))return -1; if(!compiler_emit_branch(compiler,0xe9,&loop_back)|| !compiler_patch_branch(compiler,loop_back,loop_start))return -1; body_start=compiler->CodePosition; if(!compiler_patch_branch(compiler,body_branch,body_start))return -1; if(!compiler_loop_push(compiler,post_start))return -1; compiler->ControlDepth++; if(compiler_statement(compiler)<=0)return -1; compiler->ControlDepth--; u16 body_back; if(!compiler_emit_branch(compiler,0xe9,&body_back)|| !compiler_patch_branch(compiler,body_back,post_start)|| !compiler_patch_branch(compiler,loop_exit,compiler->CodePosition)|| !compiler_loop_finish(compiler,compiler->CodePosition))return -1; compiler_scope_pop(compiler); return 1; } compiler->Position=saved; if(compiler_word(compiler,"do")) { usize body_start=compiler->CodePosition,condition_start; u16 loop_back; if(compiler->ControlDepth>=32||!compiler_loop_push(compiler,0))return -1; compiler->ControlDepth++; if(compiler_statement(compiler)<=0)return -1; compiler->ControlDepth--; condition_start=compiler->CodePosition; if(condition_start>0xffffu||!compiler->ControlCount|| compiler->Controls[compiler->ControlCount-1].Kind!=COMPILER_CONTROL_LOOP) return -1; compiler->Controls[compiler->ControlCount-1].ContinueTarget= (u16)condition_start; if(!compiler_word(compiler,"while")||!compiler_take(compiler,'(')|| !compiler_expression(compiler)||!compiler_take(compiler,')')|| !compiler_take(compiler,';')||!compiler_emit(compiler,0x48)|| !compiler_emit(compiler,0x85)||!compiler_emit(compiler,0xc0)|| !compiler_emit(compiler,0x0f)|| !compiler_emit_branch(compiler,0x85,&loop_back)|| !compiler_patch_branch(compiler,loop_back,body_start)|| !compiler_loop_finish(compiler,compiler->CodePosition))return -1; return 1; } compiler->Position=saved; if(compiler_word(compiler,"while")) { usize loop_start=compiler->CodePosition; u16 loop_exit,loop_back; if(compiler->ControlDepth>=32||!compiler_take(compiler,'(')|| !compiler_expression(compiler)||!compiler_take(compiler,')')|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x85)|| !compiler_emit(compiler,0xc0)||!compiler_emit(compiler,0x0f)|| !compiler_emit_branch(compiler,0x84,&loop_exit))return -1; if(!compiler_loop_push(compiler,loop_start))return -1; compiler->ControlDepth++; if(compiler_statement(compiler)<=0)return -1; compiler->ControlDepth--; if(!compiler_emit_branch(compiler,0xe9,&loop_back)|| !compiler_patch_branch(compiler,loop_back,loop_start)|| !compiler_patch_branch(compiler,loop_exit,compiler->CodePosition)|| !compiler_loop_finish(compiler,compiler->CodePosition))return -1; return 1; } compiler->Position=saved; if(compiler_take(compiler,'{')) { if(compiler->ControlDepth>=32||!compiler_scope_push(compiler))return -1; compiler->ControlDepth++; for(;;) { if(compiler_take(compiler,'}'))break; if(compiler_statement(compiler)<=0)return -1; } compiler->ControlDepth--; compiler_scope_pop(compiler); return 1; } compiler->Position=saved; char call_name[32]; if(compiler_identifier(compiler,call_name,sizeof(call_name))) { compiler_skip(compiler); if(compiler_function_find(compiler,call_name)>=0&& compiler_variable_find(compiler,call_name)<0&& compiler->PositionLength&& compiler->Source[compiler->Position]=='(') { compiler->Position=saved; if(!compiler_identifier(compiler,call_name,sizeof(call_name))|| !compiler_emit_call(compiler,call_name)|| !compiler_take(compiler,';'))return -1; return 1; } } compiler->Position=saved; if(compiler_word(compiler,"bob64_app_write")) { if(!compiler_take(compiler,'(')||!compiler_expression(compiler)|| compiler->ExpressionType!=COMPILER_TYPE_CHAR_POINTER|| !compiler_take(compiler,',')||!compiler_emit(compiler,0x50))return -1; compiler->StackBytes+=8; if(!compiler_expression(compiler)|| compiler_is_pointer(compiler->ExpressionType)|| !compiler_take(compiler,')')||!compiler_take(compiler,';')|| !compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x89)|| !compiler_emit(compiler,0xc2)||!compiler_emit(compiler,0x59)|| !compiler_emit(compiler,0xb8)|| !compiler_emit_u32(compiler,BOB64_SYSCALL_WRITE_BUFFER)|| !compiler_emit(compiler,0xcd)||!compiler_emit(compiler,0x80))return -1; compiler->StackBytes-=8; return 1; } compiler->Position=saved; if(compiler_take(compiler,';'))return 1; return compiler_local_statement(compiler); } static int compiler_for_post(BOB64_C_COMPILER *compiler) { char name[32]; char operation; if(compiler_increment_pair(compiler,&operation)) { if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int variable=compiler_variable_find(compiler,name); return variable>=0&&compiler_increment_variable(compiler,(u32)variable, 0,operation); } if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int variable=compiler_variable_find(compiler,name); if(variable>=0&&compiler_increment_pair(compiler,&operation)) return compiler_increment_variable(compiler,(u32)variable,1,operation); if(variable<0||compiler_type_is_array(compiler_variable_type(compiler,(u32)variable))|| !compiler_take(compiler,'=')||!compiler_expression(compiler)|| (compiler_is_pointer(compiler_variable_type(compiler,(u32)variable))!= compiler_is_pointer(compiler->ExpressionType)|| (compiler_is_pointer(compiler_variable_type(compiler,(u32)variable))&& compiler_variable_type(compiler,(u32)variable)!=compiler->ExpressionType))|| !compiler_variable_store(compiler,(u32)variable))return 0; return 1; } static int compiler_function_body(BOB64_C_COMPILER *compiler) { for(;;) { usize saved=compiler->Position; if(compiler_word(compiler,"return")) { compiler->Position=saved; break; } compiler->Position=saved; int statement=compiler_statement(compiler); if(statement<0)return 0; if(statement>0)continue; break; } if(compiler->ReturnType==COMPILER_TYPE_VOID) { if(compiler->StackBytes)return 0; if(compiler_word(compiler,"return")) { if(!compiler_take(compiler,';')||!compiler_take(compiler,'}'))return 0; } else if(!compiler_take(compiler,'}'))return 0; return compiler_function_epilogue(compiler); } if(compiler->StackBytes||!compiler_word(compiler,"return")|| !compiler_expression(compiler)|| !compiler_return_type_matches(compiler)|| !compiler_take(compiler,';')||!compiler_take(compiler,'}')|| !compiler_function_epilogue(compiler))return 0; return 1; } static int compiler_store_parameter(BOB64_C_COMPILER *compiler,u32 variable, u32 argument) { s16 displacement=compiler->VariableDisplacement[variable]; u8 type=compiler->VariableType[variable]; if(argument>=4) { u32 incoming=16u+argument*8u; u8 load_modrm=incoming<=127u?0x45:0x85; if(type==COMPILER_TYPE_SHORT) return compiler_emit(compiler,0x0f)&&compiler_emit(compiler,0xbf)&& compiler_emit_rbp_operand(compiler,load_modrm,(s16)incoming)&& compiler_emit(compiler,0x66)&&compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler,0x45,displacement); if(type==COMPILER_TYPE_CHAR) return compiler_emit(compiler,0x0f)&&compiler_emit(compiler,0xbe)&& compiler_emit_rbp_operand(compiler,load_modrm,(s16)incoming)&& compiler_emit(compiler,0x88)&& compiler_emit_rbp_operand(compiler,0x45,displacement); if(compiler_is_pointer(type)||type==COMPILER_TYPE_USIZE|| type==COMPILER_TYPE_LONG_LONG) { if(!compiler_emit(compiler,0x48)||!compiler_emit(compiler,0x8b)|| !compiler_emit_rbp_operand(compiler,load_modrm,(s16)incoming))return 0; return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler,0x45,displacement); } if(!compiler_emit(compiler,0x8b)|| !compiler_emit_rbp_operand(compiler,load_modrm,(s16)incoming))return 0; return compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler,0x45,displacement); } if(compiler_is_pointer(type)||type==COMPILER_TYPE_USIZE|| type==COMPILER_TYPE_LONG_LONG) { if(argument<2) { u8 modrm=argument==0?0x4d:0x55; return compiler_emit(compiler,0x48)&&compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler,modrm,displacement); } return compiler_emit(compiler,0x4c)&&compiler_emit(compiler,0x89)&& compiler_emit_rbp_operand(compiler, (u8)(argument==2?0x45:0x4d),displacement); } if(type==COMPILER_TYPE_CHAR) { if(argument==0)return compiler_emit(compiler,0x88)&& compiler_emit_rbp_operand(compiler,0x4d,displacement); if(argument==1)return compiler_emit(compiler,0x88)&& compiler_emit_rbp_operand(compiler,0x55,displacement); return compiler_emit(compiler,0x41)&&compiler_emit(compiler,0x88)&& compiler_emit_rbp_operand(compiler, (u8)(argument==2?0x45:0x4d),displacement); } if(type==COMPILER_TYPE_SHORT) { static const u8 short_stores[4][4]={ {0x66,0x89,0x4d,0},{0x66,0x89,0x55,0}, {0x66,0x44,0x89,0x45},{0x66,0x44,0x89,0x4d} }; u32 instruction_bytes=argument<2?3u:4u; for(u32 byte=0;byteCodePosition, return_type,(u8)argument_count,argument_types,1))return 0; compiler->VariableCount=0;compiler->LocalBytes=0;compiler->ScopeDepth=0; compiler->ReturnType=return_type; compiler->Return64=return_type==COMPILER_TYPE_LONG_LONG|| return_type==COMPILER_TYPE_USIZE|| compiler_is_pointer(return_type); compiler->StackBytes=0;compiler->ControlDepth=0; if(!compiler_function_prologue(compiler)|| (is_main&&!compiler_emit_global_initializers(compiler)))return 0; for(u32 i=0;iCallCount;i++) { BOB64_C_CALL *call=&compiler->Calls[i]; int function=compiler_function_find(compiler,call->Name); if(function<0||!compiler->Functions[function].Defined|| compiler->Functions[function].ArgumentCount!=call->ArgumentCount) return 0; for(u32 argument=0;argumentArgumentCount;argument++) { u8 expected=compiler->Functions[function].ArgumentTypes[argument]; u8 actual=call->ArgumentTypes[argument]; if(!compiler_value_types_compatible(expected,actual))return 0; } s64 displacement=(s64)compiler->Functions[function].CodeOffset- (s64)(call->DisplacementOffset+4u); if(displacement<(-2147483647LL-1)||displacement>2147483647)return 0; u32 encoded=(u32)(s32)displacement; for(u32 byte=0;byte<4;byte++) compiler->Code[call->DisplacementOffset+byte]=(u8)(encoded>>(byte*8)); } return 1; } static u32 compiler_crc32(const u8 *bytes,usize length) { u32 value=0xffffffffu; for(usize i=0;i>1)^(0xedb88320u&-(value&1u)); } return ~value; } static void compiler_write16(u8 *bytes,u16 value) { bytes[0]=(u8)value;bytes[1]=(u8)(value>>8); } static void compiler_write32(u8 *bytes,u32 value) { for(u32 i=0;i<4;i++)bytes[i]=(u8)(value>>(i*8)); } static void compiler_write64(u8 *bytes,u64 value) { compiler_write32(bytes,(u32)value);compiler_write32(bytes+4,(u32)(value>>32)); } static int compiler_scan_skip_quote(BOB64_C_COMPILER *compiler,usize *position) { char quote=compiler->Source[(*position)++]; while(*positionLength) { char value=compiler->Source[(*position)++]; if(value=='\\') { if(*position>=compiler->Length)return 0; (*position)++; } else if(value==quote)return 1; } return 0; } static int compiler_scan_skip_comment(BOB64_C_COMPILER *compiler,usize *position) { if(*position+1>=compiler->Length||compiler->Source[*position]!='/')return 0; if(compiler->Source[*position+1]=='/') { *position+=2; while(*positionLength&&compiler->Source[*position]!='\n')(*position)++; return 1; } if(compiler->Source[*position+1]=='*') { *position+=2; while(*position+1Length&& !(compiler->Source[*position]=='*'&&compiler->Source[*position+1]=='/')) (*position)++; if(*position+1>=compiler->Length)return -1; *position+=2; return 1; } return 0; } static int compiler_global_add(BOB64_C_COMPILER *compiler,const char *name, u8 type,u32 array_length,u32 bytes,u32 *global_index) { usize name_length=0; if(compiler->GlobalCount>=COMPILER_GLOBAL_LIMIT|| compiler_variable_find(compiler,name)>=0|| compiler_enum_constant_find(compiler,name)>=0|| bytes>sizeof(compiler->Data)-compiler->DataLength) return 0; u32 alignment=compiler_type_is_struct(type)?compiler_type_alignment(compiler,type): ((type==COMPILER_TYPE_LONG_LONG||type==COMPILER_TYPE_USIZE|| type==COMPILER_TYPE_LONG_LONG_ARRAY||type==COMPILER_TYPE_USIZE_ARRAY|| compiler_is_pointer(type))?8u: (type==COMPILER_TYPE_INT||type==COMPILER_TYPE_INT_ARRAY?4u: (type==COMPILER_TYPE_SHORT||type==COMPILER_TYPE_SHORT_ARRAY?2u:1u))); compiler->DataLength=(compiler->DataLength+alignment-1u)&~(alignment-1u); if(bytes>sizeof(compiler->Data)-compiler->DataLength)return 0; u32 index=compiler->GlobalCount++; BOB64_C_GLOBAL *global=&compiler->Globals[index]; while(name[name_length]&&name_length+1Name)) { global->Name[name_length]=name[name_length];name_length++; } if(name[name_length])return 0; global->Name[name_length]=0; global->Type=type; global->ArrayLength=(u16)array_length; global->InitKind=0;global->InitTarget=0; global->DataOffset=(u16)compiler->DataLength; for(u32 i=0;iData[compiler->DataLength+i]=0; compiler->DataLength+=bytes; if(global_index)*global_index=index; return 1; } static int compiler_struct_definition(BOB64_C_COMPILER *compiler,const char *name) { usize name_length=0; if(compiler->StructCount>=COMPILER_STRUCT_LIMIT|| compiler_struct_find(compiler,name)>=0)return 0; u32 index=compiler->StructCount++; BOB64_C_STRUCT *structure=&compiler->Structs[index]; while(name[name_length]&&name_length+1Name)) { structure->Name[name_length]=name[name_length];name_length++; } if(name[name_length])return 0; structure->Name[name_length]=0;structure->Size=0; structure->Alignment=1;structure->FieldCount=0; u32 offset=0; for(;;) { if(compiler_take(compiler,'}'))break; u8 base_type=compiler_type_specifier(compiler); int struct_index=compiler_type_is_struct(base_type)? (int)(base_type-COMPILER_TYPE_STRUCT_BASE):-1; if(!base_type)return 0; int pointer=compiler_take(compiler,'*'); if(base_type==COMPILER_TYPE_VOID&&!pointer)return 0; if(struct_index>=0&&!pointer)return 0; char field_name[32]; if(!compiler_identifier(compiler,field_name,sizeof(field_name))|| !compiler_take(compiler,';')||structure->FieldCount>=COMPILER_FIELD_LIMIT|| compiler_field_find(compiler,(u8)(COMPILER_TYPE_STRUCT_BASE+index),field_name)>=0) return 0; u8 field_type=pointer?compiler_pointer_to(compiler,base_type):base_type; if(!field_type)return 0; u32 alignment=compiler_type_alignment(compiler,field_type); u32 size=compiler_type_size(compiler,field_type); offset=(offset+alignment-1u)&~(alignment-1u); BOB64_C_FIELD *field=&structure->Fields[structure->FieldCount++]; usize field_length=0; while(field_name[field_length]) { field->Name[field_length]=field_name[field_length];field_length++; } field->Name[field_length]=0;field->Offset=(u16)offset;field->Type=field_type; offset+=size; if(alignment>structure->Alignment)structure->Alignment=(u8)alignment; if(offset>2048)return 0; } if(!structure->FieldCount)return 0; structure->Size=(u16)((offset+structure->Alignment-1u)&~(structure->Alignment-1u)); return compiler_take(compiler,';'); } /* Returns 1 for a definition, 0 when this is an enum-typed declaration, -1 on error. */ static int compiler_enum_definition(BOB64_C_COMPILER *compiler) { usize saved=compiler->Position; char tag[32]; if(!compiler_word(compiler,"enum")|| !compiler_identifier(compiler,tag,sizeof(tag))|| !compiler_take(compiler,'{')) { compiler->Position=saved; return 0; } if(compiler->EnumCount>=COMPILER_ENUM_LIMIT|| compiler_enum_find(compiler,tag)>=0)return -1; u32 enum_index=compiler->EnumCount++; usize tag_length=0; while(tag[tag_length]) { compiler->Enums[enum_index].Name[tag_length]=tag[tag_length]; tag_length++; } compiler->Enums[enum_index].Name[tag_length]=0; u64 next_value=0; u32 count=0; for(;;) { char name[32]; if(!compiler_identifier(compiler,name,sizeof(name))|| compiler_enum_constant_find(compiler,name)>=0|| compiler_variable_find(compiler,name)>=0|| compiler_function_find(compiler,name)>=0|| compiler_typedef_find(compiler,name)>=0|| compiler->EnumConstantCount>=COMPILER_ENUM_CONSTANT_LIMIT)return -1; BOB64_C_ENUM_CONSTANT *constant= &compiler->EnumConstants[compiler->EnumConstantCount++]; usize length=0; while(name[length]) {constant->Name[length]=name[length];length++;} constant->Name[length]=0; if(compiler_take(compiler,'=')) { if(!compiler_switch_constant(compiler,&next_value))return -1; } constant->Value=next_value; count++; if(compiler_take(compiler,'}'))break; if(!compiler_take(compiler,','))return -1; if(compiler_take(compiler,'}'))break; if(next_value==~(u64)0)return -1; next_value++; } if(!count||!compiler_take(compiler,';'))return -1; return 1; } static int compiler_typedef_name_reserved(const char *name) { static const char *reserved[]={"void","char","short","int","long", "usize","uintptr_t","isize","intptr_t","struct","enum"}; for(u32 i=0;i=0|| compiler_enum_constant_find(compiler,name)>=0|| compiler->TypedefCount>=COMPILER_TYPEDEF_LIMIT|| !compiler_take(compiler,';'))return 0; BOB64_C_TYPEDEF *alias=&compiler->Typedefs[compiler->TypedefCount++]; usize length=0; while(name[length]) {alias->Name[length]=name[length];length++;} alias->Name[length]=0;alias->Type=type; return 1; } static int compiler_global_declaration(BOB64_C_COMPILER *compiler) { char name[32]; u8 type,base_type; u32 array_length=0,bytes,index; int is_pointer,is_struct; if(compiler_word(compiler,"static")) { } if(compiler_word(compiler,"struct")) { char struct_name[32]; if(!compiler_identifier(compiler,struct_name,sizeof(struct_name)))return 0; if(compiler_take(compiler,'{'))return compiler_struct_definition(compiler,struct_name); int structure=compiler_struct_find(compiler,struct_name); if(structure<0)return 0; base_type=(u8)(COMPILER_TYPE_STRUCT_BASE+(u32)structure); } else base_type=compiler_type_specifier(compiler); if(!base_type)return 0; int pointer=compiler_take(compiler,'*'); if(base_type==COMPILER_TYPE_VOID&&!pointer)return 0; if(pointer) { base_type=compiler_pointer_to(compiler,base_type); if(!base_type)return 0; } type=base_type; is_struct=compiler_type_is_struct(type); is_pointer=compiler_is_pointer(type); if(!compiler_identifier(compiler,name,sizeof(name)))return 0; int array=compiler_take(compiler,'['); if(array) { u64 size; if(is_pointer||is_struct||!compiler_integer(compiler,&size)||!size|| !compiler_take(compiler,']'))return 0; type=compiler_array_type(base_type); if(!type)return 0; u32 element_size=compiler_array_element_size(type); u32 maximum=sizeof(compiler->Data)/element_size; if(size>maximum)return 0; array_length=(u32)size; bytes=array_length*element_size; } else bytes=is_struct?compiler_type_size(compiler,type): (is_pointer?8u:compiler_type_size(compiler,type)); if(!compiler_global_add(compiler,name,type,array_length,bytes,&index))return 0; BOB64_C_GLOBAL *global=&compiler->Globals[index]; if(compiler_take(compiler,'=')) { if(is_struct)return 0; if(is_pointer) { usize string_offset,string_length; if((type==COMPILER_TYPE_CHAR_POINTER|| type==COMPILER_TYPE_VOID_POINTER)&& compiler_string(compiler,&string_offset,&string_length)) { (void)string_length; global->InitKind=2; global->InitTarget=(u16)string_offset; } else { int address=compiler_take(compiler,'&'); char target_name[32]; if(compiler_identifier(compiler,target_name,sizeof(target_name))) { int target=compiler_variable_find(compiler,target_name); if(target<0||!compiler_variable_is_global((u32)target))return 0; BOB64_C_GLOBAL *target_global=&compiler->Globals[(u32)target&0x7fffu]; u8 target_type=target_global->Type; u8 target_pointer_type; if(compiler_type_is_struct(target_type)) target_pointer_type=(u8)(COMPILER_TYPE_STRUCT_POINTER_BASE+ target_type-COMPILER_TYPE_STRUCT_BASE); else if(compiler_type_is_array(target_type)) target_pointer_type=compiler_pointer_type(target_type); else if(address) target_pointer_type=compiler_pointer_type(target_type); else target_pointer_type=0; if(!compiler_value_types_compatible(type,target_pointer_type)|| (compiler_type_is_struct(target_type)&&!address))return 0; global->InitKind=1; global->InitTarget=target_global->DataOffset; } else { u64 value; if(!compiler_integer(compiler,&value)||value!=0)return 0; } } } else if(array&&type==COMPILER_TYPE_CHAR_ARRAY) { usize string_offset,string_length; if(compiler_string(compiler,&string_offset,&string_length)) { if(string_length>array_length)return 0; for(u32 i=0;iData[global->DataOffset+i]=compiler->Data[string_offset+i]; } else { if(!compiler_take(compiler,'{'))return 0; u32 element=0; for(;;) { if(compiler_take(compiler,'}'))break; u64 value; if(element>=array_length|| !compiler_switch_constant(compiler,&value))return 0; compiler->Data[global->DataOffset+element++]=(u8)value; if(compiler_take(compiler,'}'))break; if(!compiler_take(compiler,','))return 0; } } } else if(array) { if(!compiler_take(compiler,'{'))return 0; u32 element=0; for(;;) { if(compiler_take(compiler,'}'))break; u64 value; if(element>=array_length|| !compiler_switch_constant(compiler,&value))return 0; u32 element_size=compiler_array_element_size((u8)type); u32 offset=global->DataOffset+element++*element_size; for(u32 byte=0;byteData[offset+byte]=(u8)(value>>(byte*8)); if(compiler_take(compiler,'}'))break; if(!compiler_take(compiler,','))return 0; } } else { u64 value; if(!compiler_switch_constant(compiler,&value))return 0; for(u32 byte=0;byteData[global->DataOffset+byte]=(u8)(value>>(byte*8)); } } return compiler_take(compiler,';'); } static int compiler_collect_function_sources(BOB64_C_COMPILER *compiler, u32 *main_source_index) { usize scan=0; u32 main_count=0; compiler->FunctionSourceCount=0; while(scanLength) { compiler->Position=scan; compiler_skip(compiler); if(compiler->Failed)return 0; if(compiler->Position>=compiler->Length)break; usize start=compiler->Position; if(compiler_word(compiler,"enum")) { compiler->Position=start; int enum_result=compiler_enum_definition(compiler); if(enum_result<0)return 0; if(enum_result>0) { scan=compiler->Position; continue; } } if(compiler_word(compiler,"typedef")) { compiler->Position=start; if(!compiler_typedef_declaration(compiler))return 0; scan=compiler->Position; continue; } char name[32],parameter_names[COMPILER_ARGUMENT_LIMIT][32]; u8 return_type,argument_count,argument_types[COMPILER_ARGUMENT_LIMIT]; if(!compiler_function_signature(compiler,name,sizeof(name),&return_type, &argument_count,argument_types,parameter_names,0)) { compiler->Position=start; if(!compiler_global_declaration(compiler))return 0; scan=compiler->Position; continue; } if(!compiler_function_declare(compiler,name,0,return_type,argument_count, argument_types,0))return 0; compiler_skip(compiler); if(compiler->Position>=compiler->Length)return 0; if(compiler->Source[compiler->Position]==';') { compiler->Position++; scan=compiler->Position; continue; } if(compiler->Source[compiler->Position]!='{'|| compiler->FunctionSourceCount>=COMPILER_FUNCTION_LIMIT)return 0; compiler->Position++; usize position=compiler->Position; u32 depth=1; while(positionLength&&depth) { char value=compiler->Source[position]; if(value=='/'&&position+1Length) { usize next=position; int skipped=compiler_scan_skip_comment(compiler,&next); if(skipped<0)return 0; if(skipped) { position=next;continue; } } if(value=='\''||value=='"') { if(!compiler_scan_skip_quote(compiler,&position))return 0; continue; } if(value=='{')depth++; else if(value=='}')depth--; position++; } if(depth)return 0; usize end=position; u32 source_index=compiler->FunctionSourceCount++; compiler->FunctionSourceStart[source_index]=(u16)start; compiler->FunctionSourceEnd[source_index]=(u16)end; if(name[0]=='m'&&name[1]=='a'&&name[2]=='i'&&name[3]=='n'&&!name[4]) { *main_source_index=source_index; main_count++; } scan=end; } compiler->Position=0; return main_count==1; } int bob64_compile_c(const char *source,usize source_length,void *output, usize output_capacity,usize *output_length, usize *error_offset) { /* The initial kernel is single-tasked; a later compiler job queue needs per-job state. */ static BOB64_C_COMPILER compiler; static u8 payload[BOB64_COMPILER_CODE_CAPACITY+ BOB64_COMPILER_DATA_CAPACITY]; u8 *file=(u8 *)output; u32 main_source_index=0; if(output_length)*output_length=0; if(error_offset)*error_offset=0; if(!source||!output||!output_length||source_length>BOB64_COMPILER_SOURCE_LIMIT|| output_capacity