TempleOSTS_130315.ISO

TempleOS/Compiler/CmpMain.CPP

@@ -0,0 +1,701 @@
+U0 StreamPutS(U8 *st)
+//Inss text into the stream of
+//characters being compiled.  Called
+//from withing #exe{} block.
+{
+  CLex *lx=Fs->last_lex;
+  CStreamBlk *tempe=lx->last_stream_blk;
+  if (tempe!=&lx->next_stream_blk)
+    tempe->body=StrAdd(tempe->body,st);
+  else
+    PrintFErr("No exe{} blk\n");
+}
+
+U0 StreamPrintF(U8 *src,...)
+//Inss text into the stream of
+//characters being compiled.  Called
+//from withing #exe{} block.
+{
+  U8 *buf=SPrintFJoin(NULL,src,argc,argv);
+StreamPutS(buf);
+  Free(buf);
+}
+
+U8 *CmpStatement(CLex *lx,I64 *type)
+{
+  I64 size,i,j,k,*result=INVALID_PTR;
+  CIntermediateCode *tempi;
+  if (type) *type=IT_I64;
+  Btr(&lx->flags,Lf_OPT_TRACE_PRESENT);
+  if (lx->a_depth==2)
+    CBPush(lx);
+  CBOutPtrsInit(lx);
+  CBICAdd(lx,IC_START,0,0); //So we can scan back an instruction
+  tempi=lx->cbh.cb_last_out_ptr;
+  if (!PrsStatement(lx,NULL)) {
+    if (tempi!=lx->cbh.cb_last_out_ptr) {
+      CBICAdd(lx,IC_RETURN_VAL2,0,NULL);
+      CBICAdd(lx,IC_RET,0,0);
+      CBICAdd(lx,IC_END,0,0);
+      if (result=CBCompile(lx,NULL,&size,NULL,NULL,type)) {
+	if (lx->flags&LF_AOT_COMPILE) {
+	  j=lx->a->ip;
+	  k=(size+7)>>3;
+	  for (i=0;i<k;i++)
+	    AsmStoreCodeU64(lx,result[i]);
+	  Free(result);
+	  result=j;
+	}
+      }
+    } else
+      LinkedLstDel(lx->cbh.cb_out_first);
+  } else
+    LinkedLstDel(lx->cbh.cb_out_first);
+  if (lx->a_depth==2)
+    CBPop(lx);
+  return result;
+}
+
+
+CExe *CmpJoin(CLex *lx,CHashFun *locals,Bool first_lex,Bool asm_blk=FALSE,
+  U8 *map_name=NULL,U8 mapfile_drv=0)
+{
+  CAsmCtrl *a,*old_a=lx->a;
+  I64 i,j,l;
+  CAsmCodeBlk *tempc;
+  CExeImportExport *tempe;
+  Bool okay=TRUE;
+  CHashTable *ht1=lx->hash_table_lst,
+	       *ht2=lx->define_hash_table,
+	       *ht3=lx->glbl_hash_table,
+	       *ht4=lx->local_hash_table,
+	       *asm_hash_alias=MAllocIdentical(asm_hash);
+  CHashFun     *old_var_lst=lx->local_var_lst;
+  CExe *result=CAlloc(sizeof(CExe));
+  result->parent_exe=lx->exe_struct;
+  lx->exe_struct=result;
+
+  result->next_ie=result->last_ie=&result->next_ie;
+  lx->a=a=CAlloc(sizeof(CAsmCtrl));
+  lx->a_depth++;
+
+  a->code=CAlloc(sizeof(CAsmCodeBlk));
+  a->max_align=1;
+  a->module_org=INVALID_PTR;
+
+  lx->local_hash_table=HashTableNew(16);
+  lx->glbl_hash_table =HashTableNew(2048);
+
+  asm_hash_alias->next=lx->local_hash_table;
+  lx->local_hash_table->next=lx->glbl_hash_table;
+
+  if (lx->flags&LF_AOT_COMPILE)
+    lx->define_hash_table=lx->glbl_hash_table;
+  else
+    lx->glbl_hash_table->next=Fs->hash_table;
+  lx->hash_table_lst =asm_hash_alias;
+
+  lx->local_var_lst=locals; //C+ local vars
+  try {
+    if (first_lex)
+      Lex(lx);
+    if (lx->flags&LF_AOT_COMPILE) {
+      while (lx->token!=TK_EOF) {
+	i=CmpStatement(lx,NULL);
+	if (i!=INVALID_PTR) {
+	  tempe=CAlloc(sizeof(CExeImportExport));
+	  tempe->type=EIE_MAIN;
+	  tempe->ip=i;
+	  QueIns(tempe,result->last_ie);
+	}
+	if (asm_blk)
+	  break;
+      }
+    } else
+      PrsStatement(lx,NULL);
+    AsmGlblsResolve(lx,result);
+  } catch {
+    if (Fs->except_argc>0 && Fs->except_argv[0]==EXCEPT_COMPILER &&
+      !asm_blk) {
+      if (Fs->except_argc>1 && Fs->except_argv[1]) {
+	"Compiler exception #%d\n",Fs->except_argv[1];
+	LexPutPos(lx);
+      }
+      Fs->catch_except=TRUE;
+    }
+    okay=FALSE;
+  }
+  if (!okay) {
+    if (lx->error_cnt<1)
+      lx->error_cnt=1;
+    lx->exe_struct=result->parent_exe;
+    Free(result);
+    LinkedLstDel(a->code);
+    result=NULL;
+  } else {
+    if (map_name && !cmp_do_not_write_to_dsk)
+      HashRep(lx->glbl_hash_table,HTG_ALL,map_name,"-r-p",mapfile_drv);
+    HashTableDel(lx->local_hash_table);
+    HashTableDel(lx->glbl_hash_table);
+
+    if (!a->num_code_U8s)
+      result->code=NULL;
+    else {
+      if (lx->flags&LF_AOT_COMPILE)
+	result->code=MAlloc(a->num_code_U8s);
+      else {
+	if (a->module_org==INVALID_PTR)
+	  result->code=MAlloc(a->num_code_U8s,Fs->code_heap);
+	else
+	  result->code=a->module_org;
+      }
+      result->code_U8s=a->num_code_U8s;
+      tempc=a->code;
+      j=0;
+      l=a->num_code_U8s;
+      while (tempc) {
+	i=l;
+	if (i>ASM_CODE_BLK_SIZE)
+	  i=ASM_CODE_BLK_SIZE;
+	MemCpy(result->code+j,tempc->body,i);
+	j+=i;
+	l-=i;
+	tempc=tempc->next;
+      }
+    }
+    LinkedLstDel(a->code);
+    result->abss=a->abss;
+    result->heap_glbls=a->heap_glbls;
+    result->max_align =a->max_align;
+    result->module_org=a->module_org;
+    lx->exe_struct=result->parent_exe;
+  }
+  lx->hash_table_lst  =ht1,
+  lx->define_hash_table=ht2;
+  lx->glbl_hash_table  =ht3;
+  lx->local_hash_table =ht4;
+  lx->local_var_lst=old_var_lst;
+  Free(asm_hash_alias);
+  Free(a);
+  lx->a=old_a;
+  lx->a_depth--;
+  return result;
+}
+
+CExe *CmpBuf(U8 *buf,U8 *map_name=NULL,
+  I64 *error_cnt=NULL, I64 *warning_cnt=NULL,U8 mapfile_drv=0)
+{
+  CLex *lx;
+  CExe *result=NULL;
+  if (!is_first_compiler)
+    "$$FG,PURPLE$$**** Not First Compiler ****$$FG$$\n";
+  lx=LexNew(buf,LF_DONT_FREE_BUF,NULL);
+  lx->flags|=LF_AOT_COMPILE;
+  QueIns(lx,Fs->last_lex);
+  result=CmpJoin(lx,NULL,TRUE,FALSE,map_name,mapfile_drv);
+  if (error_cnt) *error_cnt=lx->error_cnt;
+  if (warning_cnt) *warning_cnt=lx->warning_cnt;
+  QueRem(lx);
+  if (result)
+    LexDel(lx);
+  return result;
+}
+
+U0 CmpFixUpJITAsm(CLex *lx,CExe *ex,I64 ip2)
+{
+  I64 i,*str=NULL;
+  U8 *ptr;
+  CExeAbsAddr *tempa,*tempa1;
+  CExeImportExport *tempe,*tempe1;
+  CHashExport *tempess;
+  CHashFun *tempf;
+  CHashGlblVar *tempg;
+
+  tempa=ex->abss;
+  while (tempa) {
+    tempa1=tempa->next;
+    nobound_switch (tempa->type) {
+      case EAA_ADD_U8:
+	*(ex->code(U8 *)+tempa->ip)(U8 *)+=ip2;
+	break;
+      case EAA_SUB_U8:
+	*(ex->code(U8 *)+tempa->ip)(U8 *)-=ip2;
+	break;
+      case EAA_ADD_U16:
+	*(ex->code(U8 *)+tempa->ip)(U16 *)+=ip2;
+	break;
+      case EAA_SUB_U16:
+	*(ex->code(U8 *)+tempa->ip)(U16 *)-=ip2;
+	break;
+      case EAA_ADD_U32:
+	*(ex->code(U8 *)+tempa->ip)(U32 *)+=ip2;
+	break;
+      case EAA_SUB_U32:
+	*(ex->code(U8 *)+tempa->ip)(U32 *)-=ip2;
+	break;
+      case EAA_ADD_U64:
+	*(ex->code(U8 *)+tempa->ip)(I64 *)+=ip2;
+	break;
+      case EAA_SUB_U64:
+	*(ex->code(U8 *)+tempa->ip)(I64 *)-=ip2;
+	break;
+    }
+    Free(tempa);
+    tempa=tempa1;
+  }
+  tempe=ex->next_ie;
+  while (tempe!=&ex->next_ie) {
+    tempe1=tempe->next;
+    if (tempe->str) {
+      Free(str);
+      str=tempe->str;
+    }
+    if (tempe->type<=EIE_LIT_EXPORT) {
+      tempess=CAlloc(sizeof(CHashExport));
+      tempess->str=str;
+      str=NULL;
+      tempess->type=HTT_EXPORT_SYS_SYM|HTF_LIT;
+      if (tempe->type==EIE_LIT_EXPORT)
+	tempess->val=tempe->ip;
+      else
+	tempess->val=tempe->ip+ip2;
+      tempess->src_link=tempe->src_link;
+      tempe->src_link=NULL;
+      if (IsReplaceSyms)
+	HashReplace(tempess,Fs->hash_table);
+      else
+	HashAdd(tempess,Fs->hash_table);
+      SysSymImportsResolve(tempess->str);
+    } else if (tempe->type<EIE_MAIN) {
+      if (tempe->str && !(tempess=HashFind(str,Fs->hash_table,HTG_ALL-HTT_IMPORT_SYS_SYM)))
+	"%S%s\n","ST_UNRESOLVED_REFERENCE",str;
+      else {
+	ptr=tempe->ip+ip2;
+	if (tempess->type & HTT_FUN) {
+	  tempf=tempess;
+	  if (tempe->type & 1)
+	    i=tempf->executable_addr;
+	  else
+	    i=tempf->executable_addr-ex->code;
+	} else if (tempess->type & HTT_GLBL_VAR) {
+	  tempg=tempess;
+	  if (tempe->type & 1)
+	    i=tempg->data_addr;
+	  else
+	    i=tempg->data_addr-ex->code;
+	} else {
+	  if (tempe->type & 1)
+	    i=tempess->val;
+	  else
+	    i=tempess->val(U8 *)-ex->code;
+	}
+	if (tempe->type<=EIE_LIT_U8)
+	  *ptr(U8 *)+=i;
+	else if (tempe->type<=EIE_LIT_U16)
+	  *ptr(U16 *)+=i;
+	else if (tempe->type<=EIE_LIT_U32)
+	  *ptr(U32 *)+=i;
+	else if (tempe->type<=EIE_LIT_U64)
+	  *ptr(I64 *)+=i;
+      }
+    }
+    Free(tempe->src_link);
+    Free(tempe);
+    tempe=tempe1;
+  }
+  Free(str);
+  if (!lx->a_depth && Bt(&lx->opts,OPTf_COMPILE_TRACE))
+    Un(ex->code,ex->code_U8s,64);
+  Free(ex);
+}
+
+U0 CmpFixUpAOTAsm(CLex *lx,CExe *ex,I64 ip2)
+{
+  CAsmCtrl *a=lx->a;
+  U8 *ptr;
+  CExeAbsAddr *tempa,*tempa1;
+  CExeImportExport *tempe,*tempe1;
+
+  tempa=ex->abss;
+  while (tempa) {
+    tempa1=tempa->next;
+    tempa->next=a->abss;
+    nobound_switch (tempa->type) {
+      case EAA_ADD_U8:
+	*(ex->code(U8 *)+tempa->ip)(U8 *)+=ip2;
+	break;
+      case EAA_SUB_U8:
+	*(ex->code(U8 *)+tempa->ip)(U8 *)-=ip2;
+	break;
+      case EAA_ADD_U16:
+	*(ex->code(U8 *)+tempa->ip)(U16 *)+=ip2;
+	break;
+      case EAA_SUB_U16:
+	*(ex->code(U8 *)+tempa->ip)(U16 *)-=ip2;
+	break;
+      case EAA_ADD_U32:
+	*(ex->code(U8 *)+tempa->ip)(U32 *)+=ip2;
+	break;
+      case EAA_SUB_U32:
+	*(ex->code(U8 *)+tempa->ip)(U32 *)-=ip2;
+	break;
+      case EAA_ADD_U64:
+	*(ex->code(U8 *)+tempa->ip)(I64 *)+=ip2;
+	break;
+      case EAA_SUB_U64:
+	*(ex->code(U8 *)+tempa->ip)(I64 *)-=ip2;
+	break;
+    }
+    a->abss=tempa;
+    tempa->ip+=ip2;
+    tempa=tempa1;
+  }
+
+  tempe=ex->next_ie;
+  while (tempe!=&ex->next_ie) {
+    tempe1=tempe->next;
+    QueRem(tempe);
+    if (tempe->type<=EIE_LIT_EXPORT)
+      tempe->ip+=ip2;
+    else if (tempe->type<EIE_MAIN) {
+      ptr=ex->code(U8 *)+tempe->ip;
+      if (tempe->type<=EIE_LIT_U8)
+	*ptr(U8 *)-=ip2;
+      else if (tempe->type<=EIE_LIT_U16)
+	*ptr(U16 *)-=ip2;
+      else if (tempe->type<=EIE_LIT_U32)
+	*ptr(U32 *)-=ip2;
+      else if (tempe->type<=EIE_LIT_U64)
+	*ptr(I64 *)-=ip2;
+      tempe->ip+=ip2;
+    }
+    QueIns(tempe,ex->parent_exe->last_ie);
+    tempe=tempe1;
+  }
+  Free(ex);
+}
+
+I64 Cmp(U8 *filename,U8 *map_name=NULL,U8 *out_name=NULL,U8 mapfile_drv=0)
+{ //Compile file, returns err_cnt
+  U8 *ptr,*fbuf=NULL,*fbuf2=NULL,*fbuf3=NULL,
+     *patch_table=MAlloc(0x20000);
+  CExe *ex;
+  I64 i,cnt,size=0,error_cnt=0,warning_cnt=0,code_U8s=0;
+  CBinFile *bfh;
+  CExeImportExport *tempe,*tempe1;
+  CExeAbsAddr *tempa,*tempa1;
+  CExeHeapGlblRef *temphgr,*temphgr1;
+  CExeHeapGlbl *temphg,*temphg1;
+
+  fbuf=DftExt(filename,"PRJ.Z");
+  fbuf2=MSPrintF("#include \"%s\"",fbuf);
+  if (map_name)
+    fbuf3=DftExt(map_name,"MAP.Z");
+  ex=CmpBuf(fbuf2,fbuf3,&error_cnt,&warning_cnt,mapfile_drv);
+
+  if (ex) {
+    code_U8s=ex->code_U8s;
+    ptr=patch_table;
+    //See $LK,"CBinFilePatchTableWithoutOrg","MN:CBinFilePatchTableWithoutOrg"$
+    *ptr++=EIE_MODULE_ALIGNMENT; //See $LK,"Load","MN:Load"$() and $LK,"BinRep","MN:BinRep"$()
+    *ptr(U32 *)++=ex->max_align;
+    *ptr++=0;
+    if (ex->module_org!=INVALID_PTR) {
+      //See $LK,"CBinFilePatchTableWithOrg","MN:CBinFilePatchTableWithOrg"$
+      *ptr++=EIE_MODULE_ORG;
+      *ptr(U32 *)++=ex->module_org;
+      *ptr++=0;
+    }
+    cnt=0;
+    tempa=ex->abss;
+    while (tempa) {
+      if (!(tempa->type&1))
+	cnt++;
+      tempa=tempa->next;
+    }
+    if (cnt) {
+      *ptr++=EIE_ABS_ADDR;
+      *ptr(U32 *)++=cnt;
+      *ptr++=0;
+      tempa=ex->abss;
+      while (tempa) {
+	tempa1=tempa->next;
+	if (!(tempa->type&1))
+	  *ptr(U32 *)++ =tempa->ip;
+	Free(tempa);
+	tempa=tempa1;
+      }
+    }
+    temphg=ex->heap_glbls;
+    while (temphg) {
+      temphg1=temphg->next;
+      cnt=0;
+      temphgr=temphg->references;
+      while (temphgr) {
+	cnt++;
+	temphgr=temphgr->next;
+      }
+      if (cnt) {
+	*ptr++=EIE_HEAP_GLBL;
+	*ptr(U32 *)++=cnt;
+	if (temphg->str) {
+	  i=StrLen(temphg->str);
+	  MemCpy(ptr,temphg->str,i+1);
+	  Free(temphg->str);
+	  ptr+=i+1;
+	} else
+	  *ptr++=0;
+	*ptr(I64 *)++=temphg->size;
+	temphgr=temphg->references;
+	while (temphgr) {
+	  temphgr1=temphgr->next;
+	  *ptr(U32 *)++=temphgr->ip;
+	  Free(temphgr);
+	  temphgr=temphgr1;
+	}
+      }
+      Free(temphg);
+      temphg=temphg1;
+    }
+
+//Do exports first
+    tempe=ex->next_ie;
+    while (tempe!=&ex->next_ie) {
+      tempe1=tempe->next;
+      if (tempe->type<=EIE_LIT_EXPORT) {
+	QueRem(tempe);
+	*ptr++=tempe->type;
+	*ptr(U32 *)++=tempe->ip;
+	if (tempe->str) {
+	  i=StrLen(tempe->str);
+	  MemCpy(ptr,tempe->str,i+1);
+	  Free(tempe->str);
+	  ptr+=i+1;
+	} else
+	  *ptr++=0;
+	Free(tempe->src_link);
+	Free(tempe);
+      }
+      tempe=tempe1;
+    }
+
+//Do imports second
+    tempe=ex->next_ie;
+    while (tempe!=&ex->next_ie) {
+      tempe1=tempe->next;
+      QueRem(tempe);
+      *ptr++=tempe->type;
+      *ptr(U32 *)++=tempe->ip;
+      if (tempe->str) {
+	i=StrLen(tempe->str);
+	MemCpy(ptr,tempe->str,i+1);
+	Free(tempe->str);
+	ptr+=i+1;
+      } else
+	*ptr++=0;
+      Free(tempe->src_link);
+      Free(tempe);
+      tempe=tempe1;
+    }
+
+    *ptr++=EIE_END;
+    MemSet(ptr,0,16);
+    i=ptr-patch_table;
+    //$LK,"NATIVE_XSUM","FF:::/TempleOS/Kernel/KStart.CPP,NATIVE_XSUM"$ needs 16 ALIGN
+    size=(sizeof(CBinFile)+code_U8s+i+15)&-16;
+    bfh=MAlloc(size);
+    bfh->jmp=0xEB+256*(sizeof(CBinFile)-2);
+#assert sizeof(CBinFile)-2<=MAX_I8
+    bfh->type=0;
+    bfh->loader_patch_table_offset=sizeof(CBinFile)+code_U8s;
+    bfh->file_size=size;
+    bfh->xsum=NATIVE_XSUM;
+    MemCpy(bfh(U8 *)+sizeof(CBinFile),ex->code,code_U8s);
+    MemCpy(bfh(U8 *)+sizeof(CBinFile)+code_U8s,patch_table,
+      size-code_U8s-sizeof(CBinFile));
+    bfh->xsum=ArcXSum(bfh,size);
+    Free(fbuf2);
+    if (out_name)
+      fbuf2=DftExt(out_name,"BIN.Z");
+    else
+      fbuf2=ChgExt(fbuf,"BIN.Z");
+    if (!cmp_do_not_write_to_dsk)
+      FileWrite(fbuf2,bfh,size);
+    Free(bfh);
+    Free(ex->code);
+    Free(ex);
+  }
+  Free(patch_table);
+  Free(fbuf);
+  Free(fbuf2);
+  Free(fbuf3);
+  PrintF(Define("ST_ERRORS_WARNINGS"),error_cnt,warning_cnt,code_U8s,size);
+  return error_cnt;
+}
+
+I64 ExePutS(U8 *buf,U8 *filename=NULL,Bool just_load=FALSE)
+{
+  I64 result;
+  Bool okay=TRUE;
+  CLex *lx;
+  if (!filename)
+    filename=sys_temp_filename;
+  lx=LexNew(buf,LF_DONT_FREE_BUF,FileNameAbs(filename));
+  if (just_load)
+    lx->flags|=LF_JUST_LOAD;
+  if (Fs->last_lex!=&Fs->next_lex)
+    lx->opts=Fs->last_lex->opts;
+  QueIns(lx,Fs->last_lex);
+  try {
+    Lex(lx);
+    result=ExeCmdLine(lx);
+  } catch {
+    if (Fs->except_argc>0) {
+      if (Fs->except_argv[0]==EXCEPT_COMPILER ||
+      Fs->except_argv[0]==EXCEPT_BREAK) {
+	Fs->catch_except=TRUE;
+	okay=FALSE;
+	result=0;
+      }
+    }
+  }
+  QueRem(lx);
+  if (okay)
+    LexDel(lx); //TODO: can crash
+  return result;
+}
+
+I64 ExePrintF(U8 *fmt,...)
+{
+  I64 result;
+  U8 *buf=SPrintFJoin(NULL,fmt,argc,argv);
+  result=ExePutS(buf);
+  Free(buf);
+  return result;
+}
+
+I64 ExeFile(U8 *name,Bool just_load=FALSE)
+{
+  I64 result;
+  U8 *name2=DftExt(name,"CPP.Z"),
+     *st=MSPrintF("#include \"%s\";",name2);
+  result=ExePutS(st,name,just_load);
+  Free(st);
+  Free(name2);
+  return result;
+}
+
+I64 ExePutS2(U8 *buf,U8 *filename=NULL,Bool just_load=FALSE)
+{ //with REPLACE_SYMS
+  I64 result;
+  Bool okay=TRUE;
+  CLex *lx;
+  if (!filename)
+    filename=sys_temp_filename;
+  lx=LexNew(buf,LF_DONT_FREE_BUF,FileNameAbs(filename));
+  if (just_load)
+    lx->flags|=LF_JUST_LOAD;
+  if (Fs->last_lex!=&Fs->next_lex)
+    lx->opts=Fs->last_lex->opts|1<<OPTf_REPLACE_SYMS;
+  QueIns(lx,Fs->last_lex);
+  try {
+    Lex(lx);
+    result=ExeCmdLine(lx);
+  } catch {
+    if (Fs->except_argc>0) {
+      if (Fs->except_argv[0]==EXCEPT_COMPILER ||
+      Fs->except_argv[0]==EXCEPT_BREAK) {
+	Fs->catch_except=TRUE;
+	okay=FALSE;
+	result=0;
+      }
+    }
+  }
+  QueRem(lx);
+  if (okay)
+    LexDel(lx); //TODO: can crash
+  return result;
+}
+
+I64 ExePrintF2(U8 *fmt,...)
+{ //with REPLACE_SYMS
+  I64 result;
+  U8 *buf=SPrintFJoin(NULL,fmt,argc,argv);
+  result=ExePutS2(buf);
+  Free(buf);
+  return result;
+}
+
+I64 ExeFile2(U8 *name,Bool just_load=FALSE)
+{ //with REPLACE_SYMS
+  I64 result;
+  U8 *name2=DftExt(name,"CPP.Z"),
+     *st=MSPrintF("#include \"%s\";",name2);
+  result=ExePutS2(st,name,just_load);
+  Free(st);
+  Free(name2);
+  return result;
+}
+
+I64 ExePutS3(U8 *buf,U8 *filename=NULL,Bool just_load=FALSE)
+{ //throws exceptions
+  I64 result;
+  CLex *lx;
+  if (!filename)
+    filename=sys_temp_filename;
+  lx=LexNew(buf,LF_DONT_FREE_BUF,FileNameAbs(filename));
+  if (just_load)
+    lx->flags|=LF_JUST_LOAD;
+  if (Fs->last_lex!=&Fs->next_lex)
+    lx->opts=Fs->last_lex->opts;
+  QueIns(lx,Fs->last_lex);
+  Lex(lx);
+  result=ExeCmdLine(lx);
+  QueRem(lx);
+  LexDel(lx);
+  return result;
+}
+
+I64 ExePrintF3(U8 *fmt,...)
+{ //throws exceptions
+  I64 result;
+  U8 *buf=SPrintFJoin(NULL,fmt,argc,argv);
+  result=ExePutS3(buf);
+  Free(buf);
+  return result;
+}
+
+
+I64 ExeFile3(U8 *name,Bool just_load=FALSE)
+{ //throws exceptions
+  I64 result;
+  U8 *name2=DftExt(name,"CPP.Z"),
+     *st=MSPrintF("#include \"%s\";",name2);
+  result=ExePutS3(st,name,just_load);
+  Free(st);
+  Free(name2);
+  return result;
+}
+
+U0 CmpInit()
+{
+  if (!sys_num_installed_compilers++) {
+    is_first_compiler=TRUE;
+    fp_prs_stream_blk=&PrsStreamBlk;
+  } else
+    is_first_compiler=FALSE;
+  compiled_lines=0;
+  compiled_funs=0;
+  compiled_bytes=0;
+  cmp_do_not_write_to_dsk=FALSE;
+  CmpLoadDefines;
+  CmpFillTables;
+  MemSet(&opt_nop,0,sizeof(CIntermediateCode));
+  opt_nop.ic_class=sys_internal_types[IT_I64];
+
+  opt_nop.ic_opcode=IC_NOP;
+  AsmHashLoad(is_first_compiler);
+  UnasmHashLoad;
+}
+
+CmpInit;