bbString t_mx2_Translator::m_AllocGCTmp(t_mx2_Type* l_type){
struct f0_t : public bbGCFrame{
t_mx2_Translator_GCTmp* l_tmp{};
void gcMark(){
bbGCMarkPtr(l_tmp);
}
}f0{};
{
bbInt l_i=bbInt(0);
for(;(l_i<this->m__0gcframe->m_tmps->m_Length());l_i+=1){
struct f2_t : public bbGCFrame{
t_mx2_Translator_GCTmp* l_tmp{};
void gcMark(){
bbGCMarkPtr(l_tmp);
}
}f2{};
f2.l_tmp=this->m__0gcframe->m_tmps->m__idx(l_i);
if((f2.l_tmp->m_used||!f2.l_tmp->m_type->m_Equals(l_type))){
continue;
}
f2.l_tmp->m_used=true;
return ((this->m__0gcframe->m_ident+BB_T("."))+f2.l_tmp->m_ident);
}
}
f0.l_tmp=bbGCNew<t_mx2_Translator_GCTmp>();
f0.l_tmp->m_used=true;
f0.l_tmp->m_type=l_type;
f0.l_tmp->m_ident=(BB_T("t")+bbString(this->m__0gcframe->m_tmps->m_Length()));
this->m__0gcframe->m_tmps->m_Push(f0.l_tmp);
return ((this->m__0gcframe->m_ident+BB_T("."))+f0.l_tmp->m_ident);
}
bbString t_mx2_GenArgType::m_ToString(){
bbString l_str=(this->m_ident+BB_T("?"));
if(bbBool(this->m_types)){
l_str+=((BB_T("<")+g_mx2_Join_1Tt_mx2_Type_2(this->m_types,BB_T(",")))+BB_T(">"));
}
return l_str;
}
t_mx2_Stmt* t_mx2_ThrowStmtExpr::m_OnSemant(t_mx2_Block* l_block){
if(bbBool(this->m_expr)){
struct f1_t : public bbGCFrame{
t_mx2_ClassType* l_ctype{};
t_mx2_Value* l_value{};
t_mx2_Stmt* t0{};
void gcMark(){
bbGCMarkPtr(l_ctype);
bbGCMarkPtr(l_value);
bbGCMarkPtr(t0);
}
}f1{};
f1.l_value=this->m_expr->m_SemantRValue(((t_mx2_Scope*)(l_block)),((t_mx2_Type*)0));
f1.l_ctype=g_mx2_TCast_1Tt_mx2_ClassType_2(f1.l_value->m_type);
if((!bbBool(f1.l_ctype)||!f1.l_ctype->m_ExtendsType(((t_mx2_Type*)(g_mx2_Type_ThrowableClass))))){
throw bbGCNew<t_mx2_SemantEx>(BB_T("Thrown value type must extend 'Throwable'"));
}
l_block->m_Emit(f1.t0=((t_mx2_Stmt*)(bbGCNew<t_mx2_ThrowStmt>(((t_mx2_PNode*)(this)),f1.l_value))));
l_block->m_reachable=false;
}else if(l_block->m_inex){
struct f1_t : public bbGCFrame{
t_mx2_Stmt* t0{};
void gcMark(){
bbGCMarkPtr(t0);
}
}f1{};
l_block->m_Emit(f1.t0=((t_mx2_Stmt*)(bbGCNew<t_mx2_ThrowStmt>(((t_mx2_PNode*)(this)),((t_mx2_Value*)0)))));
l_block->m_reachable=false;
}else{
throw bbGCNew<t_mx2_SemantEx>(BB_T("Exceptions can only be rethrown inside 'Catch' blocks"));
}
return ((t_mx2_Stmt*)0);
}
void t_mx2_Translator::m_Refs(t_mx2_FuncValue* l_func){
struct f0_t : public bbGCFrame{
t_mx2_FuncDecl* l_fdecl{};
void gcMark(){
bbGCMarkPtr(l_fdecl);
}
}f0{};
f0.l_fdecl=l_func->m_fdecl;
if(f0.l_fdecl->m_IsExtern()){
this->m_Uses(l_func->m_transFile);
return;
}
if(((f0.l_fdecl->m_kind==BB_T("function"))||l_func->m_IsExtension())){
if(this->m_AddRef(((t_mx2_SNode*)(l_func)))){
return;
}
this->m__0refsFuncs->m_Push(l_func);
this->m_Refs(((t_mx2_Type*)(l_func->m_ftype)));
}else if((f0.l_fdecl->m_kind==BB_T("method"))){
struct f1_t : public bbGCFrame{
t_mx2_ClassType* t0{};
void gcMark(){
bbGCMarkPtr(t0);
}
}f1{};
this->m_Uses(f1.t0=l_func->m_scope->m_FindClass());
this->m_Refs(((t_mx2_Type*)(l_func->m_ftype)));
}else if((f0.l_fdecl->m_kind==BB_T("lambda"))){
}else{
throw bbGCNew<t_mx2_TransEx>(((BB_T("Trans.Refs() FuncValue '")+bbString::fromCString(l_func->typeName()))+BB_T("' not recognized")));
}
}
void t_mx2_RepeatStmtExpr::m_Emit(t_std_collections_Stack_1s* l_buf,bbString l_spc){
l_buf->m_Push((l_spc+BB_T("repeat")));
g_mx2_EmitStmts(this->m_stmts,l_buf,l_spc);
if(bbBool(this->m_expr)){
l_buf->m_Push(((l_spc+BB_T("until "))+this->m_expr->m_ToString()));
}else{
l_buf->m_Push((l_spc+BB_T("forever")));
}
}
bbString t_mx2_PrimType::m_TypeId(){
if(this==g_mx2_Type_IntType){
return BB_T("i");
}else if(this==g_mx2_Type_FloatType){
return BB_T("f");
}else if(this==g_mx2_Type_StringType){
return BB_T("s");
}
return BB_T("?");
}
t_mx2_VarValue::t_mx2_VarValue(t_mx2_VarDecl* l_vdecl,t_mx2_Scope* l_scope){
this->m_pnode=((t_mx2_PNode*)(l_vdecl));
this->m_vdecl=l_vdecl;
this->m_scope=l_scope;
this->m_transFile=l_scope->m_FindFile()->m_fdecl;
this->m_cscope=bb_object_cast<t_mx2_ClassScope*>(l_scope);
if((((l_vdecl->m_kind==BB_T("global"))||(l_vdecl->m_kind==BB_T("local")))||(l_vdecl->m_kind==BB_T("param")))){
this->m_flags|=(g_mx2_VALUE_0LVALUE|g_mx2_VALUE_0ASSIGNABLE);
}
}
t_mx2_Value* t_mx2_VarValue::m_ToValue(t_mx2_Value* l_instance){
if((this->m_vdecl->m_kind==BB_T("field"))){
if(!bbBool(l_instance)){
throw bbGCNew<t_mx2_SemantEx>(((BB_T("Field '")+this->m_vdecl->m_ident)+BB_T("' cannot be accessed without an instance")));
}
if(!l_instance->m_type->m_ExtendsType(((t_mx2_Type*)(this->m_cscope->m_ctype)))){
throw bbGCNew<t_mx2_SemantEx>(((BB_T("Field '")+this->m_vdecl->m_ident)+BB_T("' cannot be accessed from an instance of a different class")));
}
return ((t_mx2_Value*)(bbGCNew<t_mx2_MemberVarValue>(l_instance,this)));
}
return ((t_mx2_Value*)(this));
}
void t_mx2_Translator::m_Emit(bbString l_str){
if(!bbBool(l_str)){
return;
}
if(l_str.startsWith(BB_T("}"))){
this->m__0indent=this->m__0indent.slice(bbInt(0),-2);
}
this->m__0buf->m_Push((this->m__0indent+l_str));
if(l_str.endsWith(BB_T("{"))){
this->m__0indent+=BB_T(" ");
}
}
t_mx2_Stmt* t_mx2_AssignStmtExpr::m_OnSemant(t_mx2_Block* l_block){
struct f0_t : public bbGCFrame{
t_mx2_Value* l_lhs{};
t_mx2_Value* l_rhs{};
void gcMark(){
bbGCMarkPtr(l_lhs);
bbGCMarkPtr(l_rhs);
}
}f0{};
bbString l_op=this->m_op;
f0.l_lhs=this->m_lhs->m_Semant(((t_mx2_Scope*)(l_block)));
f0.l_rhs=this->m_rhs->m_Semant(((t_mx2_Scope*)(l_block)));
if(((l_op!=BB_T("="))&&f0.l_lhs->m_IsLValue())){
struct f1_t : public bbGCFrame{
t_mx2_Value* l_node{};
void gcMark(){
bbGCMarkPtr(l_node);
}
}f1{};
f1.l_node=f0.l_lhs->m_FindValue(l_op);
if(bbBool(f1.l_node)){
struct f2_t : public bbGCFrame{
bbArray<bbGCVar<t_mx2_Value>>* l_args{};
t_mx2_Value* l_value{};
void gcMark(){
bbGCMarkPtr(l_args);
bbGCMarkPtr(l_value);
}
}f2{};
f2.l_args=bbArray<bbGCVar<t_mx2_Value>>::create(1);
f2.l_args->at(bbInt(0))=f0.l_rhs;
f2.l_value=f1.l_node->m_Invoke(f2.l_args);
return ((t_mx2_Stmt*)(bbGCNew<t_mx2_EvalStmt>(((t_mx2_PNode*)(this)),f2.l_value)));
}
f1.l_node=f0.l_lhs->m_FindValue(l_op.slice(bbInt(0),-1));
if(bbBool(f1.l_node)){
struct f2_t : public bbGCFrame{
bbArray<bbGCVar<t_mx2_Value>>* l_args{};
void gcMark(){
bbGCMarkPtr(l_args);
}
}f2{};
f2.l_args=bbArray<bbGCVar<t_mx2_Value>>::create(1);
f2.l_args->at(bbInt(0))=f0.l_rhs;
f0.l_rhs=f1.l_node->m_Invoke(f2.l_args);
l_op=BB_T("=");
}
}
if(!f0.l_lhs->m_IsAssignable()){
throw bbGCNew<t_mx2_SemantEx>(((BB_T("Value '")+f0.l_lhs->m_ToString())+BB_T("' is not assignable")));
}
return f0.l_lhs->m_Assign(((t_mx2_PNode*)(this)),l_op,f0.l_rhs,l_block);
}
t_mx2_VarValue::t_mx2_VarValue(bbString l_kind,bbString l_ident,t_mx2_Value* l_init,t_mx2_Scope* l_scope){
this->m_vdecl=bbGCNew<t_mx2_VarDecl>();
this->m_vdecl->m_kind=l_kind;
this->m_vdecl->m_ident=l_ident;
this->m_pnode=((t_mx2_PNode*)(this->m_vdecl));
this->m_type=l_init->m_type;
this->m_scope=l_scope;
this->m_cscope=bb_object_cast<t_mx2_ClassScope*>(l_scope);
this->m_init=l_init;
if((((this->m_vdecl->m_kind==BB_T("global"))||(this->m_vdecl->m_kind==BB_T("local")))||(this->m_vdecl->m_kind==BB_T("param")))){
this->m_flags|=(g_mx2_VALUE_0LVALUE|g_mx2_VALUE_0ASSIGNABLE);
}
this->m_semanted=((t_mx2_SNode*)(this));
}
bbString t_mx2_Translator::m_CFuncType(t_mx2_FuncType* l_type){
bbString l_retType=this->m_TransType(l_type->m_retType);
bbString l_argTypes=bbString{};
{
bbInt l_i=bbInt(0);
for(;(l_i<l_type->m_argTypes->length());l_i+=1){
if(bbBool(l_argTypes)){
l_argTypes+=BB_T(",");
}
l_argTypes+=this->m_TransType(l_type->m_argTypes->at(l_i));
}
}
return (((l_retType+BB_T("("))+l_argTypes)+BB_T(")"));
}
bbBool g_mx2_IsGCType(t_mx2_Type* l_type){
struct f0_t : public bbGCFrame{
t_mx2_ClassType* l_ctype{};
void gcMark(){
bbGCMarkPtr(l_ctype);
}
}f0{};
if(bbBool(g_mx2_TCast_1Tt_mx2_FuncType_2(l_type))){
return true;
}
if(bbBool(g_mx2_TCast_1Tt_mx2_ArrayType_2(l_type))){
return true;
}
f0.l_ctype=g_mx2_TCast_1Tt_mx2_ClassType_2(l_type);
if(!bbBool(f0.l_ctype)){
return false;
}
if(f0.l_ctype->m_IsVoid()){
return false;
}
if(((f0.l_ctype->m_cdecl->m_kind==BB_T("class"))||(f0.l_ctype->m_cdecl->m_kind==BB_T("interface")))){
return true;
}
if((f0.l_ctype->m_cdecl->m_kind==BB_T("struct"))){
{
struct f2_t : public bbGCFrame{
t_std_collections_Stack_1Tt_mx2_VarValue_2_Iterator l_0{};
void gcMark(){
bbGCMark(l_0);
}
}f2{};
f2.l_0=f0.l_ctype->m_fields->m_All();
for(;!f2.l_0.m_AtEnd();f2.l_0.m_Bump()){
struct f3_t : public bbGCFrame{
t_mx2_VarValue* l_vvar{};
void gcMark(){
bbGCMarkPtr(l_vvar);
}
}f3{};
f3.l_vvar=f2.l_0.m_Current();
if(g_mx2_IsGCType(f3.l_vvar->m_type)){
return true;
}
}
}
return false;
}
return false;
}
void t_mx2_Translator::m_EmitInclude(t_mx2_FileDecl* l_fdecl,bbString l_baseDir){
if(this->m__0incs->m_Contains(l_fdecl->m_ident)){
return;
}
this->m_Emit(((BB_T("#include \"")+g_mx2_MakeRelativePath(l_fdecl->m_hfile,l_baseDir))+BB_T("\"")));
this->m__0incs->m__idxeq(l_fdecl->m_ident,l_fdecl);
}
bbString bbRequesters::RequestFile( bbString title,bbString exts,bbBool save,bbString path ){
bbString cmd=BB_T("zenity --title=\"")+title+BB_T("\" --file-selection");
FILE *f=popen( cmd.toUtf8String(),"r" );
if( !f ) return "";
char buf[PATH_MAX];
int n=fread( buf,1,PATH_MAX,f );
pclose( f );
if( n<0 || n>PATH_MAX ) return "";
while( n && buf[n-1]<=32 ) --n;
return bbString::fromUtf8( buf,n );
}
void t_std_collections_Stack_1Tt_default_Voice_2::m_Erase(bbInt l_index){
bbDebugAssert(((l_index>=bbInt(0))&&(l_index<=this->m__0length)),BB_T("Debug assert failed"));
if((l_index==this->m__0length)){
return;
}
this->m__0data->copyTo(this->m__0data,(l_index+1),l_index,((this->m__0length-l_index)-1));
this->m_Resize((this->m__0length-1));
}
void t_std_collections_Stack_1Tt_default_Voice_2::m_Insert(bbInt l_index,t_default_Voice* l_value){
bbDebugAssert(((l_index>=bbInt(0))&&(l_index<=this->m__0length)),BB_T("Debug assert failed"));
this->m_Reserve((this->m__0length+1));
this->m__0data->copyTo(this->m__0data,l_index,(l_index+1),(this->m__0length-l_index));
this->m__0data->at(l_index)=l_value;
this->m__0length+=1;
this->m__0seq+=1;
}
t_mx2_Translator_GCFrame::t_mx2_Translator_GCFrame(t_mx2_Translator_GCFrame* l_outer,bbInt l_inspos){
init();
this->m_outer=l_outer;
this->m_inspos=l_inspos;
if(bbBool(l_outer)){
this->m_depth=(l_outer->m_depth+1);
}
this->m_ident=(BB_T("f")+bbString(this->m_depth));
}
bbString t_mx2_FuncType::m_Name(){
bbString l_args=bbString{};
{
bbInt l_0=bbInt(0);
bbInt l_1=this->m_argTypes->length();
for(;(l_0<l_1);l_0+=1){
struct f2_t : public bbGCFrame{
t_mx2_Type* l_arg{};
void gcMark(){
bbGCMarkPtr(l_arg);
}
}f2{};
f2.l_arg=this->m_argTypes->at(l_0);
l_args+=(BB_T(",")+f2.l_arg->m_Name());
}
}
return (((this->m_retType->m_Name()+BB_T("("))+l_args.slice(1))+BB_T(")"));
}
void t_mx2_SelectStmtExpr::m_Emit(t_std_collections_Stack_1s* l_buf,bbString l_spc){
l_buf->m_Push(((l_spc+BB_T("select "))+this->m_expr->m_ToString()));
{
bbInt l_0=bbInt(0);
bbInt l_1=this->m_cases->length();
for(;(l_0<l_1);l_0+=1){
struct f2_t : public bbGCFrame{
t_mx2_CaseExpr* l_c{};
void gcMark(){
bbGCMarkPtr(l_c);
}
}f2{};
f2.l_c=this->m_cases->at(l_0);
l_buf->m_Push((BB_T("case ")+g_mx2_Join_1Tt_mx2_Expr_2(f2.l_c->m_exprs,BB_T(","))));
g_mx2_EmitStmts(f2.l_c->m_stmts,l_buf,l_spc);
}
}
l_buf->m_Push((l_spc+BB_T("end")));
}
bbBool t_mx2_Translator::m_IsStruct(t_mx2_Type* l_type){
struct f0_t : public bbGCFrame{
t_mx2_ClassType* l_ctype{};
void gcMark(){
bbGCMarkPtr(l_ctype);
}
}f0{};
f0.l_ctype=g_mx2_TCast_1Tt_mx2_ClassType_2(l_type);
return (bbBool(f0.l_ctype)&&(f0.l_ctype->m_cdecl->m_kind==BB_T("struct")));
}
int system_( const char *cmd ){
#if _WIN32
bool inherit=false;
DWORD flags=CREATE_NO_WINDOW;
STARTUPINFOA si={sizeof(si)};
PROCESS_INFORMATION pi={0};
bbString tmp=BB_T( "cmd /S /C\"" )+BB_T( cmd )+BB_T( "\"" );
if( GetStdHandle( STD_OUTPUT_HANDLE ) ){
inherit=true;
si.dwFlags=STARTF_USESTDHANDLES;
si.hStdInput=GetStdHandle( STD_INPUT_HANDLE );
si.hStdOutput=GetStdHandle( STD_OUTPUT_HANDLE );
si.hStdError=GetStdHandle( STD_ERROR_HANDLE );
}
if( GetConsoleWindow() ){
flags=0;
}
if( !CreateProcessA( 0,(LPSTR)tmp.c_str(),0,0,inherit,flags,0,0,&si,&pi ) ) return -1;
WaitForSingleObject( pi.hProcess,INFINITE );
int res=GetExitCodeProcess( pi.hProcess,(DWORD*)&res ) ? res : -1;
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
return res;
#else
return system( cmd );
#endif
}
void bbMain(){
static bool done;
if(done) return;
done=true;
void mx2_mojo_main();mx2_mojo_main();
void mx2_std_main();mx2_std_main();
g_default_instance=bbGCNew<t_mojo_app_AppInstance>();
bbGCNew<t_default_VSynth>(BB_T("VSynth0.01"));
g_mojo_app_App->m_Run();
}
bbString t_mx2_VarDecl::m_ToString(){
bbString l_str=bbString{};
if((this->m_kind==BB_T("param"))){
l_str=this->m_ident;
}else{
l_str=t_mx2_Decl::m_ToString();
}
if(bbBool(this->m_type)){
if(bbBool(l_str)){
l_str+=BB_T(":");
}
l_str+=this->m_type->m_ToString();
if(bbBool(this->m_init)){
l_str+=(BB_T("=")+this->m_init->m_ToString());
}
}else if(bbBool(this->m_init)){
l_str+=(BB_T(":=")+this->m_init->m_ToString());
}
return l_str;
}
void t_default_VSynth::m_OpenAudio(){
struct f0_t : public bbGCFrame{
SDL_AudioSpec l_spec{};
void gcMark(){
bbGCMark(l_spec);
}
}f0{};
this->m_buffer=bbArray<bbFloat>::create((g_default_FragmentSize*2));
f0.l_spec.freq=44100;
f0.l_spec.format=bbShort(AUDIO_S16);
f0.l_spec.channels=2;
f0.l_spec.samples=bbShort(g_default_FragmentSize);
f0.l_spec.callback=g_default_VSynth_audio_0callback;
Mix_CloseAudio();
bbInt l_error=SDL_OpenAudio(&f0.l_spec,this->m_audioSpec);
if(bbBool(l_error)){
puts((((BB_T("error=")+bbString(l_error))+BB_T(" "))+bbString::fromCString(((void*)(SDL_GetError())))).c_str());fflush( stdout );
}
SDL_PauseAudio(bbInt(0));
}
t_mx2_Translator::t_mx2_Translator(){
init();
struct f0_t : public bbGCFrame{
t_mx2_Builder* l_builder{};
void gcMark(){
bbGCMarkPtr(l_builder);
}
}f0{};
f0.l_builder=g_mx2_Builder_instance;
this->m_debug=(f0.l_builder->m_opts->m_config==BB_T("debug"));
}
bbInt t_std_collections_Stack_1Tt_default_Voice_2::m_FindIndex(t_default_Voice* l_value,bbInt l_start){
bbDebugAssert(((l_start>=bbInt(0))&&(l_start<=this->m__0length)),BB_T("Debug assert failed"));
bbInt l_i=l_start;
while((l_i<this->m__0length)){
if((this->m__0data->at(l_i)==l_value)){
return l_i;
}
l_i+=1;
}
return -1;
}
void t_std_collections_Stack_1Tt_default_Voice_2::m_Resize(bbInt l_length){
bbDebugAssert((l_length>=bbInt(0)),BB_T("Debug assert failed"));
{
bbInt l_i=l_length;
for(;(l_i<this->m__0length);l_i+=1){
this->m__0data->at(l_i)=((t_default_Voice*)0);
}
}
this->m_Reserve(l_length);
this->m__0length=l_length;
this->m__0seq+=1;
}
bbString t_mx2_GenArgType::m_Name(){
bbString l_args=bbString{};
{
bbInt l_0=bbInt(0);
bbInt l_1=this->m_types->length();
for(;(l_0<l_1);l_0+=1){
struct f2_t : public bbGCFrame{
t_mx2_Type* l_arg{};
void gcMark(){
bbGCMarkPtr(l_arg);
}
}f2{};
f2.l_arg=this->m_types->at(l_0);
l_args+=(BB_T(",")+f2.l_arg->m_Name());
}
}
if(bbBool(l_args)){
l_args=((BB_T("<")+l_args.slice(1))+BB_T(">"));
}
return ((this->m_ident+BB_T("?"))+l_args);
}
void t_mx2_IfStmtExpr::m_Emit(t_std_collections_Stack_1s* l_buf,bbString l_spc){
struct f0_t : public bbGCFrame{
t_mx2_IfStmtExpr* l_stmt{};
void gcMark(){
bbGCMarkPtr(l_stmt);
}
}f0{};
l_buf->m_Push(((l_spc+BB_T("If "))+this->m_cond->m_ToString()));
g_mx2_EmitStmts(this->m_stmts,l_buf,l_spc);
f0.l_stmt=this->m_succ;
while(bbBool(f0.l_stmt)){
if(bbBool(f0.l_stmt->m_cond)){
l_buf->m_Push(((l_spc+BB_T("else If "))+f0.l_stmt->m_cond->m_ToString()));
}else{
l_buf->m_Push((l_spc+BB_T("else")));
}
g_mx2_EmitStmts(f0.l_stmt->m_stmts,l_buf,l_spc);
f0.l_stmt=f0.l_stmt->m_succ;
}
l_buf->m_Push((l_spc+BB_T("end")));
}
