Rijn/TempleOS-Rijn
1
1 Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
d14bbc24f93665639beb0341bfb2403c9789b710
TempleOS-Rijn/LT/COMPILE/COMPILE.CPZ
T
Terry A. Davis f86e69648b LTCD_060719.ISO
2018-09-08 21:45:17 +02:00

2652 lines
68 KiB
Plaintext
Raw Blame History

I8 CmpKeyWord(LexStruct *l)
{
I8 result=-1;
SysHashEntry *temph;
if (l->token==TK_IDENT)
if (temph=l->hash_entry)
if (temph->type == HTT_KEYWORD)
result=temph->user0;
return result;
}
#define PVLM_LOCAL_VAR 0
#define PVLM_FUNCTION_PARAM 1
#define PVLM_CLASS 2
#define PVLM_UNION 3
void CmpParseVarList(LexStruct *l,ClassStruct *tempc,
I8 mode,U8 union_base=MAX_I4)
{
I8 i,j,k,old_flags;
U8 ptr_cnt,size;
ClassStruct *tempc1,*tempc2;
SysHashEntry *temph;
MemberListStruct *tempm;
U1 *e;
if (mode!=PVLM_LOCAL_VAR || union_base!=MAX_I4) {
if (l->token=='(' || l->token=='{')
Lex(l);
}
while (TRUE) {
while (l->token==';') Lex(l);
if (l->token==')' || l->token=='}') {
Lex(l);
return;
}
if (l->token=='.') {
if (Lex(l)=='.') {
if (Lex(l)=='.') {
Lex(l);
tempm=MAllocZ(sizeof(MemberListStruct));
tempm->flags=MLF_DOT_DOT_DOT;
tempm->member_class=sys_internal_types[IT_U4];
tempm->string=NewString("argc");
tempc2=tempc->last_in_member_list;
tempc2->next=tempm;
tempc->last_in_member_list=tempm;
tempm->offset=tempc->size;
tempc->size+=8;
tempm=MAllocZ(sizeof(MemberListStruct));
tempm->flags=MLF_DOT_DOT_DOT;
tempm->member_class=sys_internal_types[IT_I8]+sizeof(ClassStruct);
tempm->string=NewString("argv");
tempm->cnt=127; //nonzero
tempc2=tempc->last_in_member_list;
tempc2->next=tempm;
tempc->last_in_member_list=tempm;
tempm->offset=tempc->size;
tempc->size+=8;
if (l->token==')' || l->token=='}')
Lex(l);
return;
} else
PrsExcept(l,"ST_EXPECTING_TYPE");
} else
PrsExcept(l,"ST_EXPECTING_TYPE");
}
temph=NULL;
if (l->token==TK_IDENT) {
temph=l->hash_entry;
k=CmpKeyWord(l);
}
if (!temph)
PrsExcept(l,"ST_EXPECTING_TYPE");
if (k==KW_UNION) {
Lex(l);
CmpParseVarList(l,tempc,mode,tempc->size);
} else {
tempc1=temph;
if (!(tempc1->type & (HTT_CLASS | HTT_INTERNAL_TYPE)))
PrsExcept(l,"ST_EXPECTING_TYPE");
do {
LexPush(l);
Lex(l); //skip type
ptr_cnt=0;
while (l->token=='*') {
l->stack_ptr--; //grows up
LexPush(l);
Lex(l);
ptr_cnt++;
}
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_IDENTIFIER");
tempm=MAllocZ(sizeof(MemberListStruct));
tempm->member_class=tempc1;
tempm->string=l->ident;
l->ident=NULL;
tempc2=tempc->last_in_member_list;
tempc2->next=tempm;
tempc->last_in_member_list=tempm;
tempc->member_cnt++;
if (Lex(l)=='(') {
tempm->flags|=MLF_FUNCTION;
if (Lex(l)!=')') {
tempm->parameter_cnt++;
while (l->token!=')') {
if (l->token==',')
tempm->parameter_cnt++;
Lex(l);
}
}
Lex(l); //skip )
}
if (l->token=='[') {
if (Lex(l)=='])
ptr_cnt++;
else
tempm->cnt=Expression(l);
if (l->token!=']')
PrsExcept(l,"ST_MISSING_RIGHT_BRACKET");
Lex(l);
}
tempm->member_class+=ptr_cnt*sizeof(ClassStruct);
if (tempm->flags & MLF_FUNCTION)
tempm->member_class=sys_internal_types[IT_U4]+sizeof(ClassStruct);
tempc2=tempm->member_class;
i=tempc2->size;
j=(tempm->cnt)? tempm->cnt:1;
i*=j;
if (mode==PVLM_LOCAL_VAR) {
if (union_base!=0x7FFFFFFF) {
if (union_base-tempc->size<i)
tempc->size=union_base-i;
} else
tempc->size=tempc->size-i;
tempm->offset=tempc->size;
if (l->token=='=') {
LexPop(l);
Lex(l);
if (!PrsParseExpression(l,TRUE))
throw(EXCEPT_COMPILER,7);
} else
l->stack_ptr--;
} else if (mode==PVLM_FUNCTION_PARAM) {
if (union_base!=0x7FFFFFFF) {
tempm->offset=union_base;
if (tempc->size-union_base<8)
tempc->size=8+union_base;
} else {
tempm->offset=tempc->size;
tempc->size+=8;
}
if (l->token=='=') {
Lex(l);
old_flags=l->flags;
l->flags&=~LF_HAS_MISC_DATA;
e=CompileExpression(l);
if (!e)
throw(EXCEPT_COMPILER,8);
tempm->default_value=Run(e); //TODO: if l->a
if (!(l->flags & LF_HAS_MISC_DATA))
DelExpression(e);
else if (l->a)
PrsExcept(l,"ST_STRING_DEFAULT");
tempm->flags|=MLF_DEFAULT_AVAILABLE;
l->flags|=old_flags&LF_HAS_MISC_DATA;
}
l->stack_ptr--;
} else { //CLASS
if (union_base!=MAX_I4) {
tempm->offset=union_base;
if (tempc->size-union_base<i)
tempc->size=i+union_base;
} else {
tempm->offset=tempc->size;
tempc->size+=i;
}
do {
temph=NULL;
k=CmpKeyWord(l);
if (k==KW_FMTSTR) {
if (Lex(l)!=TK_STRING)
PrsExcept(l,"ST_EXPECTING_STRING");
tempm->fmtstr=LexExtendString(l,&size);
} else if (k==KW_FMTDATA) {
if (Lex(l)!=TK_STRING)
PrsExcept(l,"ST_EXPECTING_STRING");
tempm->fmtdata=LexExtendString(l,&size);
}
} while (k==KW_FMTSTR || k==KW_FMTDATA);
l->stack_ptr--;
}
if (l->token==',') {
if (mode==PVLM_FUNCTION_PARAM && union_base==MAX_I4) {
Lex(l);
break;
}
} else if (l->token==')' || l->token=='}') {
Lex(l);
return;
} else if (l->token==';') {
Lex(l);
if (mode==PVLM_LOCAL_VAR && union_base==MAX_I4)
return;
break;
} else
PrsExcept(l,"ST_MISSING_SEMICOLON");
} while (TRUE);
}
}
}
ClassStruct *CmpParseClass(LexStruct *l,BoolU4 is_union,BoolU4 is_public)
{
SysHashEntry *temph1;
ClassStruct *tempc;
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_IDENTIFIER");
tempc=CmpClassNew;
if (is_public)
tempc->type|=HTT_PUBLIC;
tempc->string=l->ident;
l->ident=NULL;
SetSourceFileInfo(l,tempc);
tempc->use_cnt=0;
if (l->a)
temph1=FindHashBucket(tempc->string,l->a->glbl_hash);
else
temph1=FindHashBucket(tempc->string,l->hash_table_list);
tempc->next=temph1->next;
temph1->next=tempc;
Lex(l);
CmpParseVarList(l,tempc,PVLM_CLASS,(is_union)?0:0x7FFFFFFF);
return tempc;
}
void UndefinedExtern()
{
PutSysText("ST_UNDEFINED_EXTERN");
throw(EXCEPT_UNDEF_EXTERN);
}
ClassStruct *CmpParseFunctionJoin(LexStruct *l,
ClassStruct *temp_return,I1 *name,BoolU4 is_public,BoolU4 needs_abs)
{
MemberListStruct *tempm;
AsmCtrlStruct *a=l->a;
SysHashEntry *temph1;
SysHashTable *tempht;
ClassStruct *tempc;
ExeAbsoluteAddressStruct *tempa;
if (a) {
if (tempc=FindHashEntry(name,a->glbl_hash,HTT_ALL)) {
if (!(tempc->type & HTT_FUNCTION))
tempc=NULL;
}
if (!tempc)
temph1=FindHashBucket(name,a->glbl_hash);
} else {
tempht=l->hash_table_list->next;
l->hash_table_list->next=NULL;
if (tempc=FindHashEntry(name,l->hash_table_list,HTT_ALL)) {
if (!(tempc->type & HTT_FUNCTION))
tempc=NULL;
}
l->hash_table_list->next=tempht;
if (!tempc)
temph1=FindHashBucket(name,l->hash_table_list);
}
if (!tempc) {
tempc=CmpClassNew;
tempc->next=temph1->next;
temph1->next=tempc;
tempc->type=HTT_FUNCTION;
tempc->string=name;
if (a) {
tempc->executable_address=a->ip;
if (needs_abs) {
tempa=MAllocZ(sizeof(ExeAbsoluteAddressStruct));
tempa->next=a->absolutes;
a->absolutes=tempa;
tempa->ip=a->ip;
}
AsmStoreCodeU1(l,0);
AsmStoreCodeU1(l,0);
AsmStoreCodeU1(l,0);
AsmStoreCodeU1(l,0);
} else
tempc->executable_address=&UndefinedExtern;
Bts(&tempc->flags,Cf_EXTERN);
} else {
Free(tempc->source_link);
Free(name);
DelMemberList(tempc);
}
if (is_public)
tempc->type|=HTT_PUBLIC;
else
tempc->type&=~HTT_PUBLIC;
tempc->return_class=temp_return;
tempc->use_cnt=0;
SetSourceFileInfo(l,tempc);
CmpParseVarList(l,tempc,PVLM_FUNCTION_PARAM);
tempc->parameter_cnt=tempc->member_cnt;
tempm=tempc->member_list;
while (tempm) {
tempm->offset+=8; //EBP+RETURN
tempm=tempm->next;
}
tempc->size=0;
return tempc;
}
void CmpParseFunction(LexStruct *l,
ClassStruct *temp_return,I1 *name,BoolU4 is_public)
{
U1 *result;
AsmCtrlStruct *a=l->a;
ClassStruct *tempc;
MemberListStruct *tempm;
U8 i,j,size;
DbgInfo *dbg=NULL;
l->flags&=~LF_NO_REG_OPT;
tempc=CmpParseFunctionJoin(l,temp_return,name,is_public,TRUE);
l->local_var_list=tempc;
CbPush(l);
CbInitOutPtrs(&l->cb);
CbAddIc(l,EC_ENTER,0,0);
CmpParseStatement(l,tempc,0,NULL,NULL,FALSE);
CbAddIc(l,EC_LEAVE,0,0);
CbAddIc(l,0,0,0);
tempc->size&=-8;
if (a) {
i=a->ip;
j=tempc->executable_address;
if (Bt(&tempc->flags,Cf_EXTERN)) {
AsmStoreCodeU1At(l,i.u1[0],j);
AsmStoreCodeU1At(l,i.u1[1],j+1);
AsmStoreCodeU1At(l,i.u1[2],j+2);
AsmStoreCodeU1At(l,i.u1[3],j+3);
}
tempc->executable_address=i;
tempc->type|=HTT_EXPORT;
result=CbCompile(l,tempc,&size,&dbg);
tempc->debug=dbg;
if (result) {
for (i=0;i<size;i++)
AsmStoreCodeU1(l,result[i]);
Free(result);
}
} else {
tempc->executable_address=CbCompile(l,tempc,&size,&dbg);
tempc->debug=dbg;
}
Btr(&tempc->flags,Cf_EXTERN);
CbPop(l);
l->local_var_list=NULL;
tempm=tempc->member_list;
while (tempm) {
if (!tempm->use_cnt) {
coutln SysText("ST_WARNING"),SysText("ST_UNUSED_VAR");
PrintF(" $$LK -A \"FL:%s,%d\"$$ '",
l->cur_lfn->name,l->cur_lfn->line_num);
coutln tempm->string,"' in '",tempc->string,"'";
}
tempm=tempm->next;
}
}
void CatchAll()
{
I8 i;
if (Fs->except_argc>0) {
if (Fs->except_argv[0]<SysTextSubCount("ST_EXCEPT_TYPES")) {
PrintF("Exception Type :%Z\r\n",Fs->except_argv[0],"ST_EXCEPT_TYPES");
if (Fs->except_argv[0]==EXCEPT_UNDEF_SYSTEXT)
PrintF("Name:'%s'\r\n",Fs->except_argv[1]);
else if (Fs->except_argv[0]==EXCEPT_ARITHMETIC)
PrintF("Address:%P\r\n",Fs->except_argv[1]);
else if (Fs->except_argv[0]==EXCEPT_FLOATING)
PrintF("Address:%P\r\n",Fs->except_argv[1]);
else {
for (i=1;i<Fs->except_argc;i++)
cout Fs->except_argv[i]," ";
CrLf;
}
} else {
cout "Exception:";
for (i=1;i<Fs->except_argc;i++)
cout Fs->except_argv[i]," ";
CrLf;
}
} else
PrintF("Generic Exception\r\n");
Fs->catch_except=TRUE;
}
BoolU4 PrsVarInit(LexStruct *l,U1 **dd,ClassStruct *cl,U8 cnt)
{
U1 *d=*dd,*e;
U8 i,j,r,old_flags;
BoolU4 result=FALSE,stop;
MemberListStruct *ml;
while (cl->return_class)
cl=cl->return_class;
if (ml=cl->member_list) {
if (l->token!='{')
PrsExcept(l,"ST_EXPECTING_LEFT_BRACE");
Lex(l);
while (ml) {
if (ml->cnt && l->token=='{')
Lex(l);
j=(ml->cnt) ? ml->cnt:1;
stop=FALSE;
for (i=0;i<j && !stop;i++) {
stop=PrsVarInit(l,&d,ml->member_class,ml->cnt);
if (l->token==',')
Lex(l);
}
if (ml->cnt && l->token=='}')
Lex(l);
ml=ml->next;
}
if (l->token!='}')
PrsExcept(l,"ST_MISSING_RIGHT_BRACE");
Lex(l);
} else {
if (cl->type & HTT_INTERNAL_TYPE &&
!cl->pointer_cnt && cnt &&
(cl->sub_type==IT_I1 || cl->sub_type==IT_U1) &&
l->token==TK_STRING) {
e=LexExtendString(l,&i);
MemCpy(d,e,i);
d+=cnt;
result=TRUE;
} else {
old_flags=l->flags;
l->flags&=~LF_HAS_MISC_DATA;
e=CompileExpression(l);
if (!e)
throw(EXCEPT_COMPILER,10);
r=Run(e);
if (!(l->flags & LF_HAS_MISC_DATA))
DelExpression(e);
MemCpy(d,&r,cl->size);
d+=cl->size;
l->flags|=old_flags&LF_HAS_MISC_DATA;
}
}
*dd=d;
return result;
}
void PrsParseGlblInit(LexStruct *l,GlblVarStruct *tempg)
{
U1 *dd=&tempg->data;
U8 i,j;
ClassStruct *cl=tempg->var_class;
BoolU4 stop=FALSE;
while (cl->return_class)
cl=cl->return_class;
if (tempg->cnt && l->token=='{')
Lex(l);
j=(tempg->cnt) ? tempg->cnt:1;
for (i=0;i<j && !stop;i++) {
stop=PrsVarInit(l,&dd,cl,tempg->cnt);
if (j>1 && l->token==',')
Lex(l);
}
if (tempg->cnt && l->token=='}')
Lex(l);
}
#define PG_NULL 0
#define PG_LTEXTERN 1
#define PG_LTINTERN 2
#define PG_LTIMPORT 3
#define PG_EXTERN 4
#define PG_IMPORT 5
void CmpParseGlblVarList(LexStruct *l,I8 saved_mode,ClassStruct *saved_tempc,
U8 saved_val,BoolU4 is_public)
{
I8 i,j,mode;
U8 k,val;
I1 *st;
SysHashEntry *temph,*temph1;
GlblVarStruct *tempg,*tempg1;
AsmCtrlStruct *a=l->a;
ClassStruct *tempc,*tempc1;
U1 *u1;
while (TRUE) {
Lex(l);
tempc=saved_tempc;
val=saved_val;
mode=saved_mode;
while (l->token=='*') {
Lex(l);
tempc+=sizeof(ClassStruct);
}
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_IDENTIFIER");
if ((temph=l->hash_entry) && mode==PG_EXTERN && !a) {
if (temph->type & HTT_SYS_SYMBOL) {
val=temph->user0;
mode=PG_LTEXTERN;
}
}
if (CmpKeyWord(l)==KW_UNION) {
Lex(l);
tempc1=CmpParseClass(l,TRUE,is_public);
tempc1->return_class=tempc;
return;
} else if (CmpKeyWord(l)==KW_CLASS) {
Lex(l);
tempc1=CmpParseClass(l,FALSE,is_public);
tempc1->return_class=tempc;
return;
}
st=l->ident;
l->ident=NULL;
if (Lex(l)=='(') {
if (mode==PG_LTINTERN) {
tempc1=CmpParseFunctionJoin(l,tempc,st,is_public,FALSE);
tempc1->executable_address=val;
Bts(&tempc1->flags,Cf_INTERNAL);
Btr(&tempc1->flags,Cf_EXTERN);
return;
} else if (mode==PG_LTEXTERN) {
tempc1=CmpParseFunctionJoin(l,tempc,st,is_public,FALSE);
tempc1->executable_address=val;
Btr(&tempc1->flags,Cf_EXTERN);
return;
} else if (mode==PG_EXTERN) {
CmpParseFunctionJoin(l,tempc,st,is_public,TRUE);
return;
} else if (mode==PG_IMPORT || mode==PG_LTIMPORT) {
if (!a)
PrsExcept(l,"ST_IMPORT_NOT_NEEDED");
else {
tempc1=CmpParseFunctionJoin(l,tempc,st,is_public,FALSE);
tempc1->type|=HTT_IMPORT;
if (mode==PG_LTIMPORT)
tempc1->import_name=NewString(val);
else
tempc1->import_name=NewString(st);
}
return;
} else {
CmpParseFunction(l,tempc,st,is_public);
return;
}
}
i=0;
if (l->token=='[') {
if (Lex(l)==']')
tempc+=sizeof(ClassStruct);
else
i=Expression(l);
if (l->token!=']')
PrsExcept(l,"ST_MISSING_RIGHT_BRACKET");
Lex(l);
}
j=tempc->size;
if (i) j*=i;
if (mode==PG_LTEXTERN) {
tempg=MAllocZ(sizeof(GlblVarStruct)-4);
tempg->data_address=val;
if (a)
tempg->type=HTT_GLBL_VAR | HTT_EXPORT;
else
tempg->type=HTT_GLBL_VAR;
} else if (mode==PG_LTIMPORT || mode==PG_IMPORT) {
if (!a)
PrsExcept(l,"ST_IMPORT_NOT_NEEDED");
else {
tempg=MAllocZ(sizeof(GlblVarStruct)-4);
tempg->type=HTT_GLBL_VAR | HTT_IMPORT;
if (mode==PG_LTIMPORT)
tempg->import_name=NewString(val);
else
tempg->import_name=NewString(st);
tempg->data_address=a->ip;
k=0;
AsmStoreCodeU1(l,k.u1[0]);
AsmStoreCodeU1(l,k.u1[1]);
AsmStoreCodeU1(l,k.u1[2]);
AsmStoreCodeU1(l,k.u1[3]);
}
} else if (mode==PG_EXTERN) {
tempg=MAllocZ(sizeof(GlblVarStruct)-4);
tempg->data_address=0;
if (a)
tempg->type=HTT_GLBL_VAR;
else
tempg->type=HTT_GLBL_VAR|HTT_UNRESOLVED_GLBL;
} else {
if (a) {
if (l->token=='=')
tempg=MAllocZ(j+sizeof(GlblVarStruct)-4);
else
tempg=MAllocZ(sizeof(GlblVarStruct)-4);
tempg->data_address=a->ip;
tempg->type=HTT_GLBL_VAR | HTT_EXPORT;
if (temph && (temph->type & HTT_GLBL_VAR)) {
tempg1=temph;
tempg1->data_address=a->ip;
}
for (k=0;k<j;k++)
AsmStoreCodeU1(l,0);
} else {
tempg=MAllocZ(j+sizeof(GlblVarStruct)-4);
tempg->data_address=&tempg->data;
tempg->type=HTT_GLBL_VAR;
if (temph && temph->type&HTT_GLBL_VAR &&
temph->type&HTT_UNRESOLVED_GLBL) {
tempg1=temph; //TODO: do not resolve extern variables in parent tasks
tempg1->data_address=&tempg->data;
}
}
}
if (is_public)
tempg->type|=HTT_PUBLIC;
tempg->flags=0;
tempg->parameter_cnt=0;
tempg->var_class=tempc;
tempg->string=st;
tempg->size=j;
tempg->cnt=i;
tempg->use_cnt=0;
SetSourceFileInfo(l,tempg);
if (mode==PG_IMPORT || mode==PG_LTIMPORT)
tempg->flags|=GVAF_IMPORT;
if (mode==PG_EXTERN)
tempg->flags|=GVAF_EXTERN;
temph1=(a) ?FindHashBucket(st,a->glbl_hash):
FindHashBucket(st,l->hash_table_list);
tempg->next=temph1->next;
temph1->next=tempg;
if (l->token=='=') {
Lex(l);
PrsParseGlblInit(l,tempg);
if (a) {
u1=&tempg->data;
for (k=0;k<tempg->size;k++)
AsmStoreCodeU1At(l,u1[k],tempg->data_address+k);
}
}
if (l->token!=',') {
if (l->token!=';')
PrsExcept(l,"ST_MISSING_SEMICOLON");
Lex(l);
return;
}
}
}
void CmpParseIf(LexStruct *l,ClassStruct *locals,I8 try_count,
CbMiscStruct *break_label,CbMiscStruct *continue_label)
{
CbMiscStruct *templ,*templ1;
I8 k;
if (l->token!='(')
PrsExcept(l,"ST_EXPECTING_LEFT_PAREN");
Lex(l);
if (!PrsParseExpression(l,TRUE))
throw(EXCEPT_COMPILER,11);
if (l->token!=')')
PrsExcept(l,"ST_MISSING_RIGHT_PAREN");
Lex(l);
templ=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_SKIPZ2,templ,0);
CmpParseStatement(l,locals,try_count,break_label,continue_label);
k=CmpKeyWord(l);
if (k==KW_ELSE) {
Lex(l);
templ1=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_JMP,templ1,0);
CbAddIc(l,EC_LABEL,templ,0);
CmpParseStatement(l,locals,try_count,break_label,continue_label);
CbAddIc(l,EC_LABEL,templ1,0);
} else
CbAddIc(l,EC_LABEL,templ,0);
}
void CmpParseWhile(LexStruct *l,ClassStruct *locals,I8 try_count)
{
CbMiscStruct *templ,*templ1;
if (l->token!='(')
PrsExcept(l,"ST_EXPECTING_LEFT_PAREN");
Lex(l);
templ=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_LABEL,templ,0);
if (!PrsParseExpression(l,TRUE))
throw(EXCEPT_COMPILER,12);
if (l->token!=')')
PrsExcept(l,"ST_MISSING_RIGHT_PAREN");
Lex(l);
templ1=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_SKIPZ2,templ1,0);
CmpParseStatement(l,locals,try_count,templ1,templ);
CbAddIc(l,EC_JMP,templ,0);
CbAddIc(l,EC_LABEL,templ1,0);
}
void CmpParseDoWhile(LexStruct *l,ClassStruct *locals,I8 try_count)
{
CbMiscStruct *templ,*templ1;
templ=CbMiscNew(l,CBMT_LABEL);
templ1=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_LABEL,templ,0);
CmpParseStatement(l,locals,try_count,templ1,templ);
if (CmpKeyWord(l)!=KW_WHILE)
PrsExcept(l,"ST_MISSING_WHILE");
if (Lex(l)!='(')
PrsExcept(l,"ST_EXPECTING_LEFT_PAREN");
Lex(l);
if (!PrsParseExpression(l,TRUE))
throw(EXCEPT_COMPILER,13);
if (l->token!=')')
PrsExcept(l,"ST_MISSING_RIGHT_PAREN");
Lex(l);
CbAddIc(l,EC_SKIPNZ2,templ,0);
CbAddIc(l,EC_LABEL,templ1,0);
}
void CmpParseFor(LexStruct *l,ClassStruct *locals,I8 try_count)
{
LexCbStack *templs;
CbMiscStruct *templ,*templ1,*templ2;
if (l->token!='(')
PrsExcept(l,"ST_EXPECTING_LEFT_PAREN");
Lex(l);
CmpParseStatement(l,locals,try_count);
templ=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_LABEL,templ,0);
if (!PrsParseExpression(l,TRUE))
throw(EXCEPT_COMPILER,14);
templ1=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_SKIPZ2,templ1,0);
if (l->token!=';')
PrsExcept(l,"ST_MISSING_SEMICOLON");
Lex(l);
CbPush(l);
CbInitOutPtrs(&l->cb);
templ2=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_LABEL,templ2,0);
CmpParseStatement(l,locals,try_count,NULL,NULL,FALSE);
CbAddIc(l,0,0,0);
CbPush(l);
templs=CbPopNoFree(l);
CbPop(l);
if (l->token!=')')
PrsExcept(l,"ST_MISSING_RIGHT_PAREN");
Lex(l);
CmpParseStatement(l,locals,try_count,templ1,templ2);
CbAppend(l,templs);
CbAddIc(l,EC_JMP,templ,0);
CbAddIc(l,EC_LABEL,templ1,0);
}
class SwitchCaseEntry {
SwitchCaseEntry *next;
CbMiscStruct *label;
U8 value;
};
void CmpParseSwitch(LexStruct *l,ClassStruct *locals,I8 try_count)
{
SwitchCaseEntry *header=NULL,*temps,*temps1;
CbMiscStruct *templ_break,*templ_default,*templ_jmp;
IntermediateCode *tempi_sub,*tempi_cmp;
AsmCtrlStruct *a=l->a;
BoolU4 default_found=FALSE;
I8 i,k;
I8 lo=MAX_I8,hi=MIN_I8,range;
U4 *jmp_table;
if (l->token!='(')
PrsExcept(l,"ST_EXPECTING_LEFT_PAREN");
Lex(l);
templ_break=CbMiscNew(l,CBMT_LABEL);
templ_default=CbMiscNew(l,CBMT_LABEL);
templ_jmp=CbMiscNew(l,CBMT_JMP_TABLE);
if (!PrsParseExpression(l,FALSE))
throw(EXCEPT_COMPILER,15);
CbAddIc(l,EC_U8,0,sys_internal_types[IT_I4]);
tempi_sub=l->cb.cb_last_out_ptr;
CbAddIc(l,EC_SUBTRACTION,0,sys_internal_types[IT_I4]);
CbAddIc(l,EC_U8,0,sys_internal_types[IT_I4]);
tempi_cmp=l->cb.cb_last_out_ptr;
CbAddIc(l,EC_SWITCH,templ_jmp,0);
CbAddIc(l,EC_JMP,templ_default,0);
if (l->token!=')')
PrsExcept(l,"ST_MISSING_RIGHT_PAREN");
if (Lex(l)!='{')
PrsExcept(l,"ST_EXPECTING_LEFT_BRACE");
Lex(l);
while (l->token && l->token!='}') {
k=CmpKeyWord(l);
if (k==KW_CASE) {
Lex(l);
temps=MAlloc(sizeof(SwitchCaseEntry));
temps->label=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_LABEL,temps->label,0);
k=Expression(l);
if (l->token!=':')
PrsExcept(l,"ST_EXPECTING_COLON");
Lex(l);
if (k<lo) lo=k;
if (k>hi) hi=k;
temps->value=k;
temps->next=header;
header=temps;
} else if (k==KW_DEFAULT) {
if (Lex(l)==':')
Lex(l);
CbAddIc(l,EC_LABEL,templ_default,0);
default_found=TRUE;
} else
CmpParseStatement(l,locals,try_count,templ_break,NULL);
}
if (!default_found)
CbAddIc(l,EC_LABEL,templ_default,0);
CbAddIc(l,EC_LABEL,templ_break,0);
if (l->token!='}')
PrsExcept(l,"ST_MISSING_RIGHT_BRACE");
Lex(l);
range=hi-lo+1;
if (range<=0 || range>0x4000)
PrsExcept(l,"ST_CASE_RANGE_ERROR");
jmp_table=MAlloc(PTR_SIZE*range);
for (i=0;i<range;i++)
jmp_table[i]=templ_default;
tempi_sub->ic_data=lo;
tempi_cmp->ic_data=range;
temps=header;
while (temps) {
temps1=temps->next;
jmp_table[temps->value-lo]=temps->label;
Free(temps);
temps=temps1;
}
templ_jmp->jmp_table=jmp_table;
templ_jmp->st_len=range;
}
void CmpParseCout(LexStruct *l,BoolU4 linefeed)
{
ClassStruct *tempc;
SysHashEntry *temph;
IntermediateCode *tempi;
I8 cnt=0,i,j;
while (l->token!=';') {
cnt++;
if (!PrsParseExpression(l,FALSE))
throw(EXCEPT_COMPILER,16);
tempi=l->cb.cb_last_out_ptr;
tempc=tempi->ic_class;
j=tempc->pointer_cnt;
tempc-=sizeof(ClassStruct)*j;
while (tempc->return_class)
tempc=tempc->return_class;
temph=tempc;
if (temph->type & HTT_INTERNAL_TYPE)
i=tempc->sub_type+j*IT_NUM_IT;
else
i=IT_U4;
CbAddIc(l,EC_TYPE,i,sys_internal_types[IT_U4]);
if (l->token==',' || l->token==TK_SHL)
Lex(l);
else {
if (l->token!=';')
PrsExcept(l,"ST_EXPECTING_COMMA");
}
}
CbAddIc(l,EC_U8,cnt,sys_internal_types[IT_U4]);
if (linefeed)
CbAddIc(l,EC_IRQ,I_COUTLN,0);
else
CbAddIc(l,EC_IRQ,I_COUT,0);
CbAddIc(l,EC_ADD_ESP32,cnt<<4+8,0);
}
void CmpParseExeBlk(LexStruct *l)
{
AsmCtrlStruct *a=l->a;
SysHashTable *ht1=l->hash_table_list,
*ht2=l->define_hash_table;
U8 old_hash_mask=l->hash_mask;
U8 old_flags=l->flags & (LF_ASM_EXPRESSIONS | LF_EXE_BLK);
ExeBlkStruct *tempe=MAlloc(sizeof(ExeBlkStruct));
U4 *old_var_list=l->local_var_list;
l->local_var_list=NULL;
tempe->body=NewString("");
InsQue(tempe,l->last_exe_blk);
CbPush(l); //TODO Misc lists
l->hash_mask=HTT_ALL;
l->hash_table_list=Fs->hash_table;
l->define_hash_table=Fs->hash_table;
l->flags=(l->flags & ~LF_ASM_EXPRESSIONS) |
LF_EXE_BLK;
l->a=NULL;
if (l->token=='{')
Lex(l);
else
PrsExcept(l,"ST_MISSING_RIGHT_BRACE");
while (l->token && l->token!='}')
ExecuteCmdLine(l);
l->a=a;
l->hash_table_list=ht1,
l->define_hash_table=ht2;
l->local_var_list=old_var_list;
l->hash_mask=old_hash_mask;
l->flags=(l->flags&~LF_EXE_BLK) | old_flags;
CbPop(l);
RemQue(tempe);
if (*tempe->body)
LexIncludeString(l,"ExeBlk",tempe->body,FALSE);
else
Free(tempe->body);
Free(tempe);
Lex(l); //Skip "}"
}
void ExePutS(I1 *st)
{
LexStruct *l=Fs->last_lex;
ExeBlkStruct *tempe=l->last_exe_blk;
if (tempe!=&l->next_exe_blk)
tempe->body=Add2String(tempe->body,st);
else
coutln "Error: No exe{} blk";
}
void ExePrintF(I1 *src,...)
{
I1 *buf=SPrintFJoin(NULL,src,argc,argv);
ExePutS(buf);
Free(buf);
}
void CmpParseTryBlk(LexStruct *l,ClassStruct *locals,I8 try_count)
{
CbMiscStruct *templ,*templ1,*templ2;
ClassStruct *d=sys_internal_types[IT_U4],
*temp_try=FindHashEntry("SysTry",l->hash_table_list,HTT_FUNCTION),
*temp_catch=FindHashEntry("SysCatch",l->hash_table_list,HTT_FUNCTION);
l->flags|=LF_NO_REG_OPT;
templ=CbMiscNew(l,CBMT_LABEL);
templ1=CbMiscNew(l,CBMT_LABEL);
templ2=CbMiscNew(l,CBMT_LABEL);
CbAddIc(l,EC_GET_STACK_PTR,0,d);
CbAddIc(l,EC_GET_BASE_PTR,0,d);
CbAddIc(l,EC_GET_LABEL,templ2,d);
CbAddIc(l,EC_GET_LABEL,templ,d);
if (Bt(&temp_try->flags,Cf_EXTERN)) {
if (l->a)
CbAddIc(l,EC_CALL_INDIRECT2,temp_try->executable_address,d);
else
CbAddIc(l,EC_CALL_INDIRECT2,&temp_try->executable_address,d);
} else
CbAddIc(l,EC_CALL,temp_try->executable_address,d);
CbAddIc(l,EC_ADD_ESP32,40,d);
if (try_count<0)
CmpParseStatement(l,locals,try_count-1);
else
CmpParseStatement(l,locals,try_count+1);
CbAddIc(l,EC_LABEL,templ2,0);
if (Bt(&temp_catch->flags,Cf_EXTERN)) {
if (l->a)
CbAddIc(l,EC_CALL_INDIRECT2,temp_catch->executable_address,d);
else
CbAddIc(l,EC_CALL_INDIRECT2,&temp_catch->executable_address,d);
} else
CbAddIc(l,EC_CALL,temp_catch->executable_address,d);
CbAddIc(l,EC_ADD_ESP32,8,d);
CbAddIc(l,EC_JMP,templ1,0);
if (CmpKeyWord(l)!=KW_CATCH)
PrsExcept(l,"ST_MISSING_CATCH");
Lex(l);
CbAddIc(l,EC_LABEL,templ,0);
if (try_count<0)
CmpParseStatement(l,locals,try_count-1);
else
CmpParseStatement(l,locals,-try_count-1);
CbAddIc(l,EC_RET,0,d);
CbAddIc(l,EC_LABEL,templ1,0);
}
void CmpParseAsmBlk(LexStruct *l)
{
AsmCtrlStruct *a=l->a;
I8 i,j;
OpcodeHashEntry *tempo;
SysHashEntry *temph,**temph1;
U8 argcnt,saved_ip;
BoolU4 is_literal;
U1 *file_buf,*b;
U8 file_size;
U8 old_hash_mask=l->hash_mask;
I1 *next_last_label;
ArcCompressStruct *ac;
void my_CmpParseExeBlk(LexStruct *l);
if (!a)
PutAsmError(l,"ST_ASM_NOT_ALLOWED");
a->use16=FALSE;
l->flags|=LF_ASM_EXPRESSIONS;
l->hash_mask&=~(HTT_INTERNAL_TYPE|HTT_CLASS|HTT_PUBLIC|
HTT_WORD|HTT_LOCAL_VAR|HTT_GLBL_VAR|HTT_FUNCTION|HTT_FILE|
HTT_MODULE|HTT_PRIVATE|HTT_EXPORT|HTT_IMPORT);
if (l->token=='{')
Lex(l);
else
PrsExcept(l,"ST_MISSING_RIGHT_BRACE");
while (l->token && l->token!='}') {
AsmListLine(l);
if (l->token==TK_IDENT && l->hash_entry) {
if (l->hash_entry->type==HTT_KEYWORD) {
i=l->hash_entry->user0;
Lex(l); //skip keyword
switch (i) {
case AKW_IMPORT:
case AKW_EXPORT:
while (l->token && l->token!=';') {
if (l->token=='#') {
is_literal=TRUE;
Lex(l);
} else
is_literal=FALSE;
if (l->token==TK_IDENT) {
if (temph=l->hash_entry) {
temph=FindHashEntry(l->ident,a->glbl_hash,HTT_ALL);
if (temph)
temph->type=HTT_SYS_SYMBOL+HTT_UNRESOLVED_GLBL;
}
if (!temph) {
temph=MAllocZ(sizeof(SysHashEntry));
temph->string=l->ident;
l->ident=0;
temph->type=HTT_SYS_SYMBOL+HTT_UNRESOLVED_GLBL;
temph->use_cnt=0;
temph->user0=0;
temph->user1=NULL;
SetSourceFileInfo(l,temph);
temph1=FindHashBucket(temph->string,a->glbl_hash);
temph->next=*temph1;
*temph1=temph;
}
if (i==AKW_IMPORT)
temph->type=temph->type | HTT_IMPORT;
else if (i==AKW_EXPORT)
temph->type=temph->type | HTT_EXPORT;
if (is_literal)
temph->type=temph->type | HTT_LITERAL;
if (Lex(l)==',')
Lex(l); //skip ','
} else {
PutAsmError(l,"ST_EXPECTING_IDENTIFIER");
break;
}
}
if (l->token!=';')
PutAsmError(l,"ST_MISSING_SEMICOLON");
else
Lex(l); //skip ';';
break;
case AKW_ALIGN:
if (l->token!=TK_INTEGER)
PutAsmError(l,"ST_EXPECTING_INTEGER");
else {
i=(a->ip+l->cur_i-1) & -l->cur_i;
if (Lex(l)==',')
Lex(l);
if (l->token==TK_INTEGER) {
for (j=a->ip;j<i;j++)
AsmStoreCodeU1(l,l->cur_i);
Lex(l);
} else
a->ip=i;
}
break;
case AKW_END:
break; //TODO
case KW_EXE:
my_CmpParseExeBlk=ext[EXT_CMP_EXE_BLK];
my_CmpParseExeBlk(l);
break;
case AKW_DU1:
DefineU1s(l,a,1);
break;
case AKW_DU2:
DefineU1s(l,a,2);
break;
case AKW_DU4:
DefineU1s(l,a,4);
break;
case AKW_DU8:
DefineU1s(l,a,8);
break;
case AKW_INSERT:
if (l->token!=TK_STRING)
PutAsmError(l,"ST_EXPECTING_STRING");
else {
file_buf=ReadFile(l->ident,&file_size);
if (file_buf) {
for (i=0;i<file_size;i++)
AsmStoreCodeU1(l,file_buf[i]);
Free(file_buf);
}
Lex(l);
}
break;
case AKW_INSERT_COMPRESSED:
if (l->token!=TK_STRING)
PutAsmError(l,"ST_EXPECTING_STRING");
else {
file_buf=ReadFile(l->ident,&file_size);
if (file_buf) {
ac=CompressBuf(file_buf,file_size);
b=ac;
for (i=0;i<ac->compressed_size;i++)
AsmStoreCodeU1(l,b[i]);
Free(file_buf);
Free(ac);
}
Lex(l);
}
break;
case AKW_LIST:
a->list=TRUE;
break;
case AKW_NOLIST:
a->list=FALSE;
break;
case AKW_ORG:
a->ip=AsmEvalExpression(l);
break;
case AKW_STRUC:
a->flags|=ACSF_IN_STRUCT;
saved_ip=a->ip;
a->ip=AsmEvalExpression(l);
break;
case AKW_ENDS:
a->ip=saved_ip;
a->flags&=~ACSF_IN_STRUCT;
break;
case AKW_USE16:
a->use16=TRUE;
break;
case AKW_USE32:
a->use16=FALSE;
break;
default:
PutAsmError(l,"ST_SYNTAX_ERROR");
break;
}
} else if (l->hash_entry->type & HTT_OPCODE) {
tempo=l->hash_entry;
Lex(l); //skip opcode
argcnt=0;
if (tempo->ins[0].arg1) {
argcnt++;
ParseAsmArg(l,a,&a->arg1,a->ip);
if (tempo->ins[0].arg2) {
argcnt++;
if (l->token!=',')
PutAsmError(l,"ST_EXPECTING_COMMA");
else {
Lex(l); //skip ','
ParseAsmArg(l,a,&a->arg2,a->ip);
}
}
}
AsmCodeInstruction(l,a,tempo,argcnt);
} else if (l->hash_entry->type & HTT_SYS_SYMBOL) {
if (a->flags & ACSF_IN_STRUCT)
l->hash_entry->type|=HTT_LITERAL;
else
l->hash_entry->type&=~HTT_LITERAL;
if (l->hash_entry->type & HTT_UNRESOLVED_LOCAL) {
l->hash_entry->type&=~HTT_UNRESOLVED_LOCAL;
l->hash_entry->user0=a->ip;
if (Lex(l)!=':')
PutAsmError(l,"ST_EXPECTING_COLON");
else
Lex(l);
} else if (l->hash_entry->type & HTT_UNRESOLVED_GLBL) {
if (l->hash_entry->type & HTT_IMPORT)
PutAsmError(l,"ST_ATTEMPT_DEFINE_IMPORT");
else {
l->hash_entry->type&=~HTT_UNRESOLVED_GLBL;
l->hash_entry->user0=a->ip;
next_last_label=l->hash_entry->string;
Lex(l); //Skip ident
if (l->token!=':' && l->token!=TK_DOUBLE_COLON)
PutAsmError(l,"ST_EXPECTING_COLON");
else {
if (l->token==TK_DOUBLE_COLON) {
l->hash_entry->type|=HTT_EXPORT;
ResolveLocals(l);
a->last_label=next_last_label;
}
if (Lex(l)=='#') {
Lex(l);
l->hash_entry->type|=HTT_LITERAL | HTT_EXPORT;
}
}
}
} else
PutAsmError(l,"ST_REDEFINITION");
} else
PutAsmError(l,"ST_SYNTAX_ERROR");
} else {
if (l->token==TK_IDENT) {
temph=MAllocZ(sizeof(SysHashEntry));
temph->string=l->ident;
l->ident=0;
temph->type=HTT_SYS_SYMBOL;
if (a->flags & ACSF_IN_STRUCT)
temph->type|=HTT_LITERAL;
temph->use_cnt=0;
SetSourceFileInfo(l,temph);
temph->user0=a->ip;
temph->user1=NULL;
Lex(l); //Skip ident
if (l->token==':' || l->token==TK_DOUBLE_COLON) {
if (temph->string[0]=='@' && temph->string[1]=='@') {
temph1=FindHashBucket(temph->string,a->local_hash);
a->has_locals=TRUE;
} else
temph1=FindHashBucket(temph->string,a->glbl_hash);
temph->next=*temph1;
*temph1=temph;
if (l->token==TK_DOUBLE_COLON) {
temph->type=temph->type | HTT_EXPORT; //Export
ResolveLocals(l);
a->last_label=temph->string;
Lex(l);
} else {
if (Lex(l)=='#') {
temph->type=temph->type | HTT_EXPORT | HTT_LITERAL; //Export
ResolveLocals(l);
a->last_label=temph->string;
Lex(l);
}
}
} else {
PutAsmError(l,"ST_EXPECTING_COLON");
Free(temph->string);
Free(temph);
}
} else
PutAsmError(l,"ST_SYNTAX_ERROR");
}
}
ResolveLocals(l);
l->flags&=~LF_ASM_EXPRESSIONS;
l->hash_mask=old_hash_mask;
Lex(l); //Skip "}"
}
BoolU4 CmpParseStatement(LexStruct *l,ClassStruct *locals,I8 try_count=0,
CbMiscStruct *break_label=NULL,CbMiscStruct *continue_label=NULL,
BoolU4 saved_prs_semicolon=TRUE)
{
BoolU4 prs_exp,cont,prs_semicolon,is_asm=FALSE,
is_public=FALSE,last_is_public=FALSE;
U8 i;
SysHashEntry *temph;
CbMiscStruct *templ;
I1 *import_name;
ClassStruct *d,*temp_catch;
void my_CmpParseExeBlk(LexStruct *l);
do {
is_public=FALSE;
cont=FALSE;
prs_exp=FALSE;
prs_semicolon=saved_prs_semicolon;
l->statement_cnt++;
while (l->token==',')
Lex(l);
if (l->token=='{') {
l->braces_cnt++;
Lex(l);
while (l->token!='}')
CmpParseStatement(l,locals,try_count,break_label,continue_label);
l->braces_cnt--;
l->statement_cnt--;
Lex(l);
} else if (l->token==TK_EOF) ;
else if (l->token==';') {
if (prs_semicolon) {
l->statement_cnt--;
Lex(l);
}
} else {
if (l->token==TK_IDENT) {
if (temph=l->hash_entry) {
if (temph->type & HTT_KEYWORD) {
i=temph->user0;
switch (i) {
case KW_IF:
Lex(l);
CmpParseIf(l,locals,try_count,break_label,continue_label);
prs_semicolon=FALSE;
break;
case KW_FOR:
Lex(l);
CmpParseFor(l,locals,try_count);
prs_semicolon=FALSE;
break;
case KW_WHILE:
Lex(l);
CmpParseWhile(l,locals,try_count);
prs_semicolon=FALSE;
break;
case KW_DO:
Lex(l);
CmpParseDoWhile(l,locals,try_count);
prs_semicolon=FALSE;
break;
case KW_SWITCH:
Lex(l);
CmpParseSwitch(l,locals,try_count);
prs_semicolon=FALSE;
break;
case KW_LTEXTERN:
Lex(l);
if (Bt(&l->flags,LFf_EXTERNS_TO_IMPORTS))
goto keyword_LTimport;
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_SYS_SYMBOL");
if (!(temph=l->hash_entry))
PrsExcept(l,"ST_EXPECTING_SYS_SYMBOL");
if (!(temph->type & HTT_SYS_SYMBOL))
PrsExcept(l,"ST_EXPECTING_SYS_SYMBOL");
i=temph->user0;
if (Lex(l)!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph=l->hash_entry))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph->type & (HTT_CLASS|HTT_INTERNAL_TYPE)))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (locals)
PrsExcept(l,"ST_NOT_ALLOWED_IN_FUNCTION");
CmpParseGlblVarList(l,PG_LTEXTERN,temph,i,last_is_public);
prs_semicolon=FALSE;
cont=TRUE;
break;
case KW_LTIMPORT:
Lex(l);
keyword_LTimport:
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_SYS_SYMBOL");
import_name=l->ident;
l->ident=0;
if (Lex(l)!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph=l->hash_entry))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph->type & (HTT_CLASS|HTT_INTERNAL_TYPE)))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (locals)
PrsExcept(l,"ST_NOT_ALLOWED_IN_FUNCTION");
CmpParseGlblVarList(l,PG_LTIMPORT,temph,import_name,FALSE);
Free(import_name);
prs_semicolon=FALSE;
cont=TRUE;
break;
case KW_INTERNAL:
Lex(l);
if (l->token!=TK_INTEGER)
PrsExcept(l,"ST_EXPECTING_INTEGER");
i=l->cur_i;
if (Lex(l)!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph=l->hash_entry))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph->type & (HTT_CLASS|HTT_INTERNAL_TYPE)))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (locals)
PrsExcept(l,"ST_NOT_ALLOWED_IN_FUNCTION");
CmpParseGlblVarList(l,PG_LTINTERN,temph,i,last_is_public);
prs_semicolon=FALSE;
cont=TRUE;
break;
case KW_EXTERN:
Lex(l);
if (Bt(&l->flags,LFf_EXTERNS_TO_IMPORTS))
goto keyword_import;
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph=l->hash_entry))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph->type & (HTT_CLASS|HTT_INTERNAL_TYPE)))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (locals)
PrsExcept(l,"ST_NOT_ALLOWED_IN_FUNCTION");
CmpParseGlblVarList(l,PG_EXTERN,temph,0,last_is_public);
prs_semicolon=FALSE;
cont=TRUE;
break;
case KW_IMPORT:
Lex(l);
keyword_import:
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph=l->hash_entry))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (!(temph->type & (HTT_CLASS|HTT_INTERNAL_TYPE)))
PrsExcept(l,"ST_EXPECTING_TYPE");
if (locals)
PrsExcept(l,"ST_NOT_ALLOWED_IN_FUNCTION");
CmpParseGlblVarList(l,PG_IMPORT,temph,0,FALSE);
prs_semicolon=FALSE;
cont=TRUE;
break;
case KW_ASM:
Lex(l);
CmpParseAsmBlk(l);
prs_semicolon=FALSE;
is_asm=TRUE;
break;
case KW_EXE:
Lex(l);
my_CmpParseExeBlk=ext[EXT_CMP_EXE_BLK];
my_CmpParseExeBlk(l);
prs_semicolon=FALSE;
break;
case KW_TRY:
Lex(l);
CmpParseTryBlk(l,locals,try_count);
prs_semicolon=FALSE;
break;
case KW_BREAK:
Lex(l);
if (!break_label)
PrsExcept(l,"ST_BREAK_NOT_ALLOWED");
CbAddIc(l,EC_JMP,break_label,0);
break;
case KW_CONTINUE:
Lex(l);
if (!continue_label)
PrsExcept(l,"ST_CONTINUE_NOT_ALLOWED");
CbAddIc(l,EC_JMP,continue_label,0);
break;
case KW_RETURN:
Lex(l);
if (l->token!=';') {
if (!PrsParseExpression(l,TRUE))
throw(EXCEPT_COMPILER,17);
}
if (try_count<0) {//inside catch{}
CbAddIc(l,EC_GET_BASE_PTR,0,0);
CbAddIc(l,EC_U8,locals->size,sys_internal_types[IT_U8]);
CbAddIc(l,EC_ADDITION,0,sys_internal_types[IT_U8]);
CbAddIc(l,EC_SET_STACK_PTR,0,0);
try_count=-try_count; //force removal from queue
}
if (try_count) {
d=sys_internal_types[IT_U4];
temp_catch=FindHashEntry("SysCatch",
l->hash_table_list,HTT_FUNCTION);
for (i=0;i<try_count;i++) {
if (Bt(&temp_catch->flags,Cf_EXTERN)) {
if (l->a)
CbAddIc(l,EC_CALL_INDIRECT2,
temp_catch->executable_address,d);
else
CbAddIc(l,EC_CALL_INDIRECT2,
&temp_catch->executable_address,d);
} else
CbAddIc(l,EC_CALL,temp_catch->executable_address,d);
CbAddIc(l,EC_ADD_ESP32,8,d);
}
}
if (locals)
CbAddIc(l,EC_LEAVE,0,0);
else
CbAddIc(l,EC_RET,0,0);
break;
case KW_GOTO:
Lex(l);
if (l->token!=TK_IDENT)
PrsExcept(l,"ST_EXPECTING_IDENTIFIER");
if (!(templ=CbFindGotoLabel(l,l->ident))) {
templ=CbMiscNew(l,CBMT_GOTO_LABEL);
templ->string=l->ident;
l->ident=NULL;
}
CbAddIc(l,EC_JMP,templ,0);
Lex(l);
break;
case KW_COUT:
Lex(l);
CmpParseCout(l,FALSE);
break;
case KW_COUTLN:
Lex(l);
CmpParseCout(l,TRUE);
break;
case KW_CLASS:
Lex(l);
CmpParseClass(l,FALSE,last_is_public);
break;
case KW_UNION:
Lex(l);
CmpParseClass(l,TRUE,last_is_public);
break;
case KW_PUBLIC:
Lex(l);
is_public=TRUE;
cont=TRUE;
prs_semicolon=FALSE;
break;
default:
prs_exp=TRUE;
break;
}
} else if (temph->type & (HTT_CLASS|HTT_INTERNAL_TYPE)) {
if (locals)
CmpParseVarList(l,locals,PVLM_LOCAL_VAR);
else
CmpParseGlblVarList(l,PG_NULL,temph,0,last_is_public);
prs_semicolon=FALSE;
cont=TRUE;
} else prs_exp=TRUE;
} else {
if (l->local_var_entry)
prs_exp=TRUE;
else {
if (!(templ=CbFindGotoLabel(l,l->ident))) {
templ=CbMiscNew(l,CBMT_GOTO_LABEL);
templ->string=l->ident;
l->ident=NULL;
}
CbAddIc(l,EC_LABEL,templ,0);
if (Lex(l)==':') //skip ident
Lex(l); //skip colon
else
PrsExcept(l,"ST_UNDEFINED_IDENTIFIER");
prs_semicolon=FALSE;
}
}
} else prs_exp=TRUE;
if (prs_exp) {
if (!PrsParseExpression(l,TRUE))
throw(EXCEPT_COMPILER,18);
}
if (l->token!=',')
l->statement_cnt--;
if (prs_semicolon && l->token!=',') {
if (l->token==';')
Lex(l);
else
PrsExcept(l,"ST_MISSING_SEMICOLON");
}
}
last_is_public=is_public;
} while (l->token==',' || cont);
return is_asm;
}
U1 *CompileStatement(LexStruct *l,U8 *type=NULL)
{
U1 *result=INVALID_PTR;
AsmCtrlStruct *a=l->a;
U8 size,i,j;
DbgInfo *dbg=NULL;
if (type) *type=IT_U8;
CbInitOutPtrs(&l->cb);
if (!CmpParseStatement(l,NULL)) {
CbAddIc(l,EC_RET,0,0);
CbAddIc(l,0,0,0);
if (result=CbCompile(l,NULL,&size,&dbg,type)) {
if (a) {
if (size!=1) {//not just RET
j=a->ip;
for (i=0;i<size;i++)
AsmStoreCodeU1(l,result[i]);
Free(result);
result=j;
} else {
Free(result);
result=INVALID_PTR;
}
} else {
if (size==1) {//just RET
Free(result);
result=INVALID_PTR;
}
}
} else
result=INVALID_PTR;
} else
DelLinkedList(l->cb.cb_out_first);
Free(dbg);
return result;
}
ExeStruct *CompileBuf(U1 *buf,I1 *map_name=NULL,
I8 *error_cnt=NULL, I8 *warning_cnt=NULL,I1 mapfile_drive=0)
{
BoolU4 okay=TRUE;
LexStruct *l;
AsmCtrlStruct *a;
U8 i,j;
ExeStruct *result=NULL;
AsmCodeBlk *tempc;
ExeImportExportStruct *tempe,*tempe1;
void my_HashRep(SysHashTable *h,U8 mask,I1 *outname,I1 *flags,I1 drive);
if (!is_first_compiler)
coutln "$$FG PURPLE$$**** Not First Compiler ****$$FG$$";
my_HashRep=FindExtern("HashRep");
result=MAllocZ(sizeof(ExeStruct));
l=LexNew(buf,LF_DONT_FREE_BUFFER,NULL);
InsQue(l,Fs->last_lex);
a=MAllocZ(sizeof(AsmCtrlStruct));
a->code=MAllocZ(sizeof(AsmCodeBlk));
a->local_hash=NewHashTable(16);
a->glbl_hash=NewHashTable(2048);
a->glbl_hash->next=asm_hash;
a->local_hash->next=a->glbl_hash;
l->a=a;
l->hash_table_list=a->local_hash;
l->define_hash_table=a->glbl_hash;
l->local_hash_table=a->local_hash;
l->glbl_hash_table=a->glbl_hash;
Lex(l);
try {
while (l->token!=TK_EOF) {
i=CompileStatement(l);
if (i!=INVALID_PTR) {
tempe=MAlloc(sizeof(ExeImportExportStruct));
tempe->type=EIE_MAIN;
tempe->ip=i;
tempe->string=NULL;
tempe->next=NULL;
tempe1=&result->ie;
while (tempe1->next) //TODO:This could be optimized
tempe1=tempe1->next;
tempe1->next=tempe;
}
}
ResolveGlbls(l,result);
} catch {
if (Fs->except_argc>0)
if (Fs->except_argv[0]==EXCEPT_COMPILER)
Fs->catch_except=TRUE;
okay=FALSE;
}
RemQue(l);
if (error_cnt) *error_cnt=l->error_cnt;
if (warning_cnt) *warning_cnt=l->warning_cnt;
if (!okay) {
//TODO free debug info and possibly classes
if (error_cnt)
if (*error_cnt<1) *error_cnt=1;
result=NULL;
} else {
if (map_name)
my_HashRep(a->glbl_hash,HTT_ALL,map_name,"",mapfile_drive);
LexDel(l);
DelHashTable(a->local_hash);
DelHashTable(a->glbl_hash);
if (!a->num_code_U1s)
result->code=NULL;
else {
result->code=MAlloc(a->num_code_U1s);
result->code_U1s=a->num_code_U1s;
tempc=a->code;
j=0;
l=a->num_code_U1s;
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;
}
}
DelLinkedList(a->code);
result->absolutes=a->absolutes;
Free(a);
}
return result;
}
I8 CompileFile(I1 *filename,I1 *map_name=NULL,I1 *out_name=NULL,I1 mapfile_drive=0)
{
I1 *fbuf=NULL,*fbuf2=NULL,*fbuf3=NULL;
ExeStruct *e;
U4 *dd;
U8 size=0;
U1 *header=MAlloc(0x20000),*ptr;
BinFileHeaderStruct *bfh;
U8 i,cnt=0,error_cnt=0,warning_cnt=0;
ExeImportExportStruct *tempe,*tempe1;
ExeAbsoluteAddressStruct *tempa,*tempa1;
fbuf=DefaultExtension(filename,"CPZ");
fbuf2=MSPrintF("#include \"%s\"",fbuf);
if (map_name)
fbuf3=DefaultExtension(map_name,"MPZ");
e=CompileBuf(fbuf2,fbuf3,&error_cnt,&warning_cnt,mapfile_drive);
if (e) {
ptr=header;
tempa=e->absolutes;
while (tempa) {
cnt++;
tempa=tempa->next;
}
if (cnt) {
*ptr++=EIE_ABSOLUTE_ADDRESS;
dd=ptr;
*dd=cnt;
ptr+=sizeof(U4);
*ptr++=0;
tempa=e->absolutes;
while (tempa) {
tempa1=tempa->next;
dd=ptr;
*dd=tempa->ip;
ptr+=sizeof(U4);
Free(tempa);
tempa=tempa1;
}
}
tempe=e->ie;
while (tempe) {
tempe1=tempe->next;
*ptr++=tempe->type;
dd=ptr;
*dd=tempe->ip;
ptr+=sizeof(U4);
if (tempe->string) {
i=StrLen(tempe->string);
MemCpy(ptr,tempe->string,i+1);
Free(tempe->string);
ptr+=i+1;
} else
*ptr++=0;
Free(tempe);
tempe=tempe1;
}
*ptr++=EIE_END;
i=(ptr-header+15) & -0x10;
size=i+e->code_U1s+sizeof(BinFileHeaderStruct);
bfh=MAlloc(size);
MemCpy(bfh+e->code_U1s+sizeof(BinFileHeaderStruct),header,i);
MemCpy(bfh+sizeof(BinFileHeaderStruct),e->code,e->code_U1s);
bfh->jmp=0xE9+256*(16-3);
bfh->header_offset=e->code_U1s+sizeof(BinFileHeaderStruct);
bfh->file_size=size;
bfh->xsum=LT_XSUM;
bfh->xsum=ArcCheckSum(bfh,size);
Free(fbuf2);
if (out_name)
fbuf2=DefaultExtension(out_name,"BIZ");
else
fbuf2=ChangeExtension(fbuf,"BIZ");
WriteFile(fbuf2,bfh,size);
Free(bfh);
Free(e->code);
Free(e);
}
Free(header);
Free(fbuf);
Free(fbuf2);
Free(fbuf3);
PrintF(SysText("ST_ERRORS_WARNINGS"),error_cnt,warning_cnt,size);
return error_cnt;
}
I8 ExecuteCmdLine(LexStruct *l)
{
I8 result=0,i,type;
double *resultd;
I1 *ptr,*ptr2,*ptr3;
U1 *code;
LtfEntry *cl;
Ltf *ltf;
while (l->token &&
(l->token!='}' || !(l->flags & LF_EXE_BLK)) ) {
ptr2=&Fs->task_descriptor;
ptr3=ptr2+TSS_DESC_LENGTH;
if (l->cur_lfn->flags & LFSF_IS_LTF) {
cl=l->cur_lfn->line_start;
ltf=l->cur_lfn->l;
while (cl!=ltf && ptr2<ptr3) {
switch (cl->btype && ptr2<ptr3) {
case LTFT_TEXT:
ptr=cl->display;
while (*ptr && ptr2<ptr3)
*ptr2++=*ptr++;
break;
case LTFT_TAB:
case LTFT_CR:
*ptr2++='.';
break;
}
cl=cl->next;
}
} else
if (ptr=l->cur_lfn->line_start)
MemCpy(ptr2,ptr,TSS_DESC_LENGTH);
code=CompileStatement(l,&type);
if (code!=INVALID_PTR) {
result=Run(code);
for (i=6;i>=0;i--) {
Fs->answers[i+1]=Fs->answers[i];
Fs->double_answers[i+1]=Fs->double_answers[i];
Fs->answers_types[i+1]=Fs->answers_types[i];
}
Fs->answers[0]=result;
resultd=&result;
Fs->double_answers[0]=*resultd;
Fs->answers_types[0]=type;
Free(code);
}
}
return result;
}
void ContinueUserTask()
{
LexStruct *l;
while (TRUE) {
l=LexNew(NULL,LF_PROMPT,NULL);
InsQue(l,Fs->last_lex);
try {
Lex(l);
ExecuteCmdLine(l);
} catch
CatchAll;
RemQue(l);
//LexDel(l); //Sometimes crashes on BREAK
}
}
I8 ExecuteString(I1 *buf,I1 *filename=NULL)
{
I8 result;
BoolU4 okay=TRUE;
LexStruct *l;
if (!filename)
filename=sys_temp_filename;
l=LexNew(buf,LF_DONT_FREE_BUFFER,AbsoluteFileName(filename));
InsQue(l,Fs->last_lex);
try {
Lex(l);
result=ExecuteCmdLine(l);
} 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;
}
}
RemQue(l);
if (okay)
LexDel(l);
return result;
}
I8 ExecuteFile(I1 *name)
{
I8 result;
I1 *name2=DefaultExtension(name,"CPZ");
I1 *st=MSPrintF("#include \"%s\";",name2);
result=ExecuteString(st,name);
Free(st);
Free(name2);
return result;
}
void LoadCompileSysText()
{
LoadStr("ST_ERROR","ERROR: ");
LoadStr("ST_MISSING_SEMICOLON","missing ';' at");
LoadStr("ST_MISSING_EXPRESSION","missing Expression at ");
LoadStr("ST_MISSING_RIGHT_PAREN","missing ')' at ");
LoadStr("ST_MISSING_RIGHT_BRACKET","missing ']' at ");
LoadStr("ST_UNDEFINED_SYMBOL","undefined symbol at ");
LoadStr("ST_UNDEFINED_IDENTIFIER","undefined identifier at ");
LoadStr("ST_INVALID_CLASS","invalid class at ");
LoadStr("ST_INVALID_MEMBER","invalid member at ");
LoadStr("ST_EXPECTING_TYPE","expecting type at ");
LoadStr("ST_EXPECTING_IDENTIFIER","expecting identifier at ");
LoadStr("ST_EXPECTING_RIGHT_PAREN","expecting ')' at ");
LoadStr("ST_EXPECTING_LEFT_BRACE","expecting '{' at ");
LoadStr("ST_MISSING_RIGHT_BRACE","missing '}' at ");
LoadStr("ST_INVALID_LVALUE","invalid lvalue at ");
LoadStr("ST_EXPECTING_EQUAL","expecting '=' at ");
LoadStr("ST_NOT_POINTER_TYPE","not pointer type at ");
LoadStr("ST_EXPECTING_COMMA","expecting ',' at ");
LoadStr("ST_EXPECTING_SYS_SYMBOL","expecting System symbol at ");
LoadStr("ST_EXPECTING_STRING","expecting string at ");
LoadStr("ST_MISSING_WHILE","missing 'while' at");
LoadStr("ST_UNKNOWN_STATEMENT","unknown statement at ");
LoadStr("ST_ALREADY_ONE_IMMEDIATE","already one immediate at ");
LoadStr("ST_SYNTAX_ERROR","syntax error at ");
LoadStr("ST_EXPECTING_SCALE_FACTOR","expecting scale factor at ");
LoadStr("ST_QUESTION_NOT_ALLOWED","'?' not allowed at ");
LoadStr("ST_EXPECTING_LEFT_PAREN","expecting '(' at ");
LoadStr("ST_UNDEFINED_DUP_CNT","undefined DUP cnt at ");
LoadStr("ST_EXPECTING_COLON","expecting ':' at ");
LoadStr("ST_EXPECTING_DOUBLE_COLON","expecting '::' at ");
LoadStr("ST_EXPECTING_DOT","expecting '.' at ");
LoadStr("ST_REDEFINITION","redefinition at ");
LoadStr("ST_INVALID_INSTRUCTION","invalid instruction at ");
LoadStr("ST_INTERNAL_ERROR","LTintern error at ");
LoadStr("ST_BRANCH_OUT_OF_RANGE","branch out of range at ");
LoadStr("ST_ATTEMPT_DEFINE_IMPORT","attempt to define import at ");
LoadStr("ST_COULD_USE_U1_DISP","could use U1 displacement at ");
LoadStr("ST_WARNING","WARNING: ");
LoadStr("ST_LINE","line: ");
LoadStr("ST_NO_SIZE_SPECIFIED","no size specified at ");
LoadList("ST_U1_REGS","AL\0CL\0DL\0BL\0AH\0CH\0DH\0BH\0");
LoadList("ST_U2_REGS","AX\0CX\0DX\0BX\0SP\0BP\0SI\0DI\0");
LoadList("ST_U4_REGS","EAX\0ECX\0EDX\0EBX\0ESP\0EBP\0ESI\0EDI\0");
LoadList("ST_OPCODE_MODIFIERS","NO\0R\0CB\0CW\0CD\0CP\0IB\0IW\0ID\0RB\0RW\0RD\0");
LoadList("ST_ARGUMENT_TYPES",
"NO\0REL8\0REL16\0REL32\0UIMM8\0UIMM16\0UIMM32\0R8\0R16\0R32\0"
"IMM8\0IMM16\0IMM32\0RM8\0RM16\0RM32\0M8\0M16\0M32\0"
"M1616\0M1632\0M16N32\0M16N16\0M32N32\0"
"MOFFS8\0MOFFS16\0MOFFS32\0CL\0"
"AL\0AX\0EAX\0DX\0SS\0DS\0ES\0FS\0GS\0SREG\0CS\0");
LoadList("ST_SEG_REGS","ES\0CS\0SS\0DS\0FS\0GS\0");
LoadStr("ST_EXPECTING_INTEGER","expecting integer at ");
LoadStr("ST_DIVIDE_BY_ZERO","Divide by zero at ");
LoadStr("ST_OPT_INTERNAL_ERROR","Compiler Optimization Error at ");
LoadStr("ST_UNRESOLVED_REFERENCE","Unresolved Reference:");
LoadStr("ST_NOT_DEFINED","Not Defined");
LoadStr("ST_SCANNING_DIRECTORY","Scanning Directory:");
LoadStr("ST_ASM_NOT_ALLOWED","ASM not allowed");
LoadStr("ST_UNUSED_VAR","Unused Var");
LoadStr("ST_NOT_ALLOWED_IN_FUNCTION","Not allowed in function");
LoadStr("ST_MISSING_CATCH","missing 'catch' at");
LoadStr("ST_UNDEFINED_GOTO_LABEL","Undefined goto label:");
LoadStr("ST_BREAK_NOT_ALLOWED","'break' not allowed\r\n");
LoadStr("ST_CONTINUE_NOT_ALLOWED","'continue' not allowed\r\n");
LoadStr("ST_ERRORS_WARNINGS","Errors:%04d Warnings:%04d Size:%08X\r\n");
LoadStr("ST_IMPORT_NOT_NEEDED","import not needed at ");
LoadStr("ST_EXPECTING_CASE","expecting 'case' at ");
LoadStr("ST_CASE_RANGE_ERROR","switch range error at ");
LoadStr("ST_LEX_STACK_OVERFLOW","Lex Stack overflow");
LoadStr("ST_STRING_DEFAULT","String defaults not implemented in static mode at ");
$AN,"Anchor for inserting Compiler systext","COMPILE_SYSTEXT"$
LoadList("ST_INTERMEDIATE_CODE",
//The first character is a flag
// '*' means it is a dereferrence instruction
// '=' means it is an assignment instruction
".NULL\0"
".NOP\0"
".END_EXP\0"
".ZERO\0"
".U8\0"
".U4\0"
".U2\0"
".U1\0"
".DOUBLE\0"
".STRING_CONSTANT\0"
".EBP\0"
".FS\0"
".ESI\0"
".EDI\0"
".TO_DOUBLE\0"
".TO_INT\0"
".COM\0"
".NOT\0"
".UNARY_MINUS\0"
".ADDRESS\0"
".U8_DISP32\0"
".U4_DISP32\0"
".U2_DISP32\0"
".U1_DISP32\0"
".U8_DISP8\0"
".U4_DISP8\0"
".U2_DISP8\0"
".U1_DISP8\0"
".FS_U8_DISP32\0"
".FS_U4_DISP32\0"
".FS_U2_DISP32\0"
".FS_U1_DISP32\0"
".ESI_U8_DISP32\0"
".ESI_U4_DISP32\0"
".ESI_U2_DISP32\0"
".ESI_U1_DISP32\0"
".ESI_U8_DISP8\0"
".ESI_U4_DISP8\0"
".ESI_U2_DISP8\0"
".ESI_U1_DISP8\0"
".EDI_U8_DISP32\0"
".EDI_U4_DISP32\0"
".EDI_U2_DISP32\0"
".EDI_U1_DISP32\0"
".EDI_U8_DISP8\0"
".EDI_U4_DISP8\0"
".EDI_U2_DISP8\0"
".EDI_U1_DISP8\0"
"*DEREF_U8\0"
"*DEREF_U4\0"
"*DEREF_U2\0"
"*DEREF_U1\0"
"*ESI_DEREF_U8\0"
"*ESI_DEREF_U4\0"
"*ESI_DEREF_U2\0"
"*ESI_DEREF_U1\0"
"*EDI_DEREF_U8\0"
"*EDI_DEREF_U4\0"
"*EDI_DEREF_U2\0"
"*EDI_DEREF_U1\0"
"*U8_PP\0"
"*U4_PP\0"
"*U2_PP\0"
"*U1_PP\0"
"*U8_MM\0"
"*U4_MM\0"
"*U2_MM\0"
"*U1_MM\0"
"*PP_U8\0"
"*PP_U4\0"
"*PP_U2\0"
"*PP_U1\0"
"*MM_U8\0"
"*MM_U4\0"
"*MM_U2\0"
"*MM_U1\0"
"*ESI_U4_PP\0"
"*ESI_U4_MM\0"
"*ESI_PP_U4\0"
"*ESI_MM_U4\0"
"*EDI_U4_PP\0"
"*EDI_U4_MM\0"
"*EDI_PP_U4\0"
"*EDI_MM_U4\0"
".LEA_DISP32_EBP\0"
".LEA_DISP8_EBP\0"
".U8_DISP32_SCALED\0"
".U4_DISP32_SCALED\0"
".U2_DISP32_SCALED\0"
".SHL\0"
".SHR\0"
".SHL_CONSTANT1\0"
".SHL_CONSTANT2\0"
".SHR_CONSTANT1\0"
".SHR_CONSTANT2\0"
".POWER\0"
".MULTIPLICATION\0"
".DIVISION\0"
".REMAINDER\0"
".AND\0"
".OR\0"
".XOR\0"
".ADDITION\0"
".SUBTRACTION\0"
".EQUAL_EQUAL\0"
".NOT_EQUAL_TO\0"
".LESS_THAN\0"
".GREATER_THAN\0"
".LESS_OR_EQUAL\0"
".GREATER_OR_EQUAL\0"
".AND_AND\0"
".OR_OR\0"
".XOR_XOR\0"
".COLON\0"
".QUESTION\0"
"=ASSIGN_U8\0"
"=ASSIGN_U4\0"
"=ASSIGN_U2\0"
"=ASSIGN_U1\0"
"=SHL_EQUAL_U8\0"
"=SHL_EQUAL_U4\0"
"=SHL_EQUAL_U2\0"
"=SHL_EQUAL_U1\0"
"=SHR_EQUAL_U8\0"
"=SHR_EQUAL_U4\0"
"=SHR_EQUAL_U2\0"
"=SHR_EQUAL_U1\0"
"=MUL_EQUAL_U8\0"
"=MUL_EQUAL_U4\0"
"=MUL_EQUAL_U2\0"
"=MUL_EQUAL_U1\0"
"=DIV_EQUAL_U8\0"
"=DIV_EQUAL_U4\0"
"=DIV_EQUAL_U2\0"
"=DIV_EQUAL_U1\0"
"=AND_EQUAL_U8\0"
"=AND_EQUAL_U4\0"
"=AND_EQUAL_U2\0"
"=AND_EQUAL_U1\0"
"=OR_EQUAL_U8\0"
"=OR_EQUAL_U4\0"
"=OR_EQUAL_U2\0"
"=OR_EQUAL_U1\0"
"=XOR_EQUAL_U8\0"
"=XOR_EQUAL_U4\0"
"=XOR_EQUAL_U2\0"
"=XOR_EQUAL_U1\0"
"=ADD_EQUAL_U8\0"
"=ADD_EQUAL_U4\0"
"=ADD_EQUAL_U2\0"
"=ADD_EQUAL_U1\0"
"=SUB_EQUAL_U8\0"
"=SUB_EQUAL_U4\0"
"=SUB_EQUAL_U2\0"
"=SUB_EQUAL_U1\0"
"=ESI_ASSIGN_U4\0"
"=ESI_SHL_EQUAL_U4\0"
"=ESI_SHR_EQUAL_U4\0"
"=ESI_MUL_EQUAL_U4\0"
"=ESI_DIV_EQUAL_U4\0"
"=ESI_AND_EQUAL_U4\0"
"=ESI_OR_EQUAL_U4\0"
"=ESI_XOR_EQUAL_U4\0"
"=ESI_ADD_EQUAL_U4\0"
"=ESI_SUB_EQUAL_U4\0"
"=EDI_ASSIGN_U4\0"
"=EDI_SHL_EQUAL_U4\0"
"=EDI_SHR_EQUAL_U4\0"
"=EDI_MUL_EQUAL_U4\0"
"=EDI_DIV_EQUAL_U4\0"
"=EDI_AND_EQUAL_U4\0"
"=EDI_OR_EQUAL_U4\0"
"=EDI_XOR_EQUAL_U4\0"
"=EDI_ADD_EQUAL_U4\0"
"=EDI_SUB_EQUAL_U4\0"
".ADD64\0"
".ADD32\0"
".ADD8\0"
".INC\0"
".SUB64\0"
".SUB32\0"
".SUB8\0"
".DEC\0"
".ENTER\0"
".LEAVE\0"
".ENTER1\0"
".LEAVE1\0"
".ENTER2\0"
".LEAVE2\0"
".ADD_ESP32\0"
".ADD_ESP8\0"
".RET\0"
".CALL\0"
".CALL_INDIRECT\0"
".CALL_INDIRECT2\0"
".IRQ\0"
".CLI\0"
".STI\0"
".GET_FLAGS\0"
".SET_FLAGS\0"
".GET_BASE_PTR\0"
".SET_BASE_PTR\0"
".GET_STACK_PTR\0"
".SET_STACK_PTR\0"
".GET_LABEL\0"
".ABSOLUTE_ADDRESS\0"
".LABEL\0"
".TYPE\0"
".BT\0"
".BTS\0"
".BTR\0"
".BTC\0"
".BSF\0"
".BSR\0"
".INSQUE\0"
".INSQUE_REV\0"
".REMQUE\0"
".STRLEN\0"
".MEMCPY\0"
".MEMSET\0"
".INPD\0"
".INPW\0"
".INP\0"
".OUTPD\0"
".OUTPW\0"
".OUTP\0"
".JMP\0"
".SHORT_JMP\0"
".SWITCH\0"
".SKIPZ\0"
".SKIPZ2\0"
".SKIPNZ\0"
".SKIPNZ2\0"
".EQUAL_EQUAL_SKIPZ\0"
".EQUAL_EQUAL_SKIPZ2\0"
".NOT_EQUAL_TO_SKIPZ\0"
".NOT_EQUAL_TO_SKIPZ2\0"
".LESS_THAN_SKIPZ\0"
".LESS_THAN_SKIPZ2\0"
".GREATER_THAN_SKIPZ\0"
".GREATER_THAN_SKIPZ2\0"
".LESS_OR_EQUAL_SKIPZ\0"
".LESS_OR_EQUAL_SKIPZ2\0"
".GREATER_OR_EQUAL_SKIPZ\0"
".GREATER_OR_EQUAL_SKIPZ2\0"
".AND_AND_SKIPZ\0"
".AND_AND_SKIPZ2\0"
".AND_AND_SKIPNZ\0"
".AND_AND_SKIPNZ2\0"
".OR_OR_SKIPZ\0"
".OR_OR_SKIPZ2\0"
".OR_OR_SKIPNZ\0"
".OR_OR_SKIPNZ2\0"
".LEA_DISP32_ESI\0"
".LEA_DISP8_ESI\0"
".LEA_DISP32_EDI\0"
".LEA_DISP8_EDI\0"
".PUSH_U8\0"
".PUSH_U4\0"
".PUSH_U2\0"
".PUSH_U1\0"
".PUSH_NEG_U4\0"
".PUSH_NEG_U2\0"
".PUSH_NEG_U1\0"
".PUSH_DOUBLE\0"
".PUSH_U8_DISP32\0"
".PUSH_U8_DISP8\0"
".PUSH_ESI_U8_DISP32\0"
".PUSH_ESI_U8_DISP8\0"
".PUSH_EDI_U8_DISP32\0"
".PUSH_EDI_U8_DISP8\0"
".PUSH_DEREF_U8\0"
".PUSH_U8_DISP32_SCALED\0"
".BT_CONSTANT\0"
".BTS_CONSTANT\0"
".BTR_CONSTANT\0"
".BTC_CONSTANT\0"
"*ESI_NEXT_EQUAL_U4\0"
"*EDI_NEXT_EQUAL_U4\0"
".ADD_EQUAL_U8_CONSTANT_U1\0"
".SUB_EQUAL_U8_CONSTANT_U1\0"
".ADD_EQUAL_U4_CONSTANT_U1\0"
".ESI_ADD_EQUAL_U4_CONSTANT_U1\0"
".EDI_ADD_EQUAL_U4_CONSTANT_U1\0"
);
}
void FillCompilerTables()
{
I1 *st,buf[128];
U1 *d;
U8 i;
I8 j;
U2 *u;
U4 *d4;
assign_bitmap=MAllocZ((EC_NUM_ENTRIES+7)>>3);
deref_bitmap=MAllocZ((EC_NUM_ENTRIES+7)>>3);
push_bitmap=MAllocZ((EC_NUM_ENTRIES+7)>>3);
push_map=MAllocZ(sizeof(U2)*EC_NUM_ENTRIES);
st=SysText("ST_INTERMEDIATE_CODE");
for (i=0;i<EC_NUM_ENTRIES;i++) {
if (*st=='*')
Bts(deref_bitmap,i);
else if (*st=='=')
Bts(assign_bitmap,i);
SPrintF(buf,"%cPUSH_%s",*st,st+1);
j=MatchSysTextEntry(buf,"ST_INTERMEDIATE_CODE");
if (j>=0)
push_map[i]=j;
st+=StrLen(st)+1;
}
d=MAllocZ(EC_NUM_ENTRIES);
unsigned_fix_up_table=d;
d[EC_ADD8]=FUT_8_4;
d[EC_SUB8]=FUT_8_4;
d[EC_IRQ]=FUT_8_1;
d[EC_ADD_ESP8]=FUT_8_1;
d[EC_U1_DISP8]=FUT_8_1;
d[EC_U2_DISP8]=FUT_8_1;
d[EC_U4_DISP8]=FUT_8_1;
d[EC_U8_DISP8]=FUT_8_6;
d[EC_PUSH_U8_DISP8]=FUT_8_6;
d[EC_ESI_U1_DISP8]=FUT_8_1;
d[EC_ESI_U2_DISP8]=FUT_8_1;
d[EC_ESI_U4_DISP8]=FUT_8_1;
d[EC_ESI_U8_DISP8]=FUT_8_6;
d[EC_PUSH_ESI_U8_DISP8]=FUT_8_6;
d[EC_EDI_U1_DISP8]=FUT_8_1;
d[EC_EDI_U2_DISP8]=FUT_8_1;
d[EC_EDI_U4_DISP8]=FUT_8_1;
d[EC_EDI_U8_DISP8]=FUT_8_6;
d[EC_PUSH_EDI_U8_DISP8]=FUT_8_6;
d[EC_LEA_DISP8_EBP]=FUT_8_1;
d[EC_LEA_DISP8_ESI]=FUT_8_1;
d[EC_LEA_DISP8_EDI]=FUT_8_1;
d[EC_SHL_CONSTANT1]=FUT_8_6;
d[EC_SHL_CONSTANT2]=FUT_8_5;
d[EC_SHR_CONSTANT1]=FUT_8_6;
d[EC_SHR_CONSTANT2]=FUT_8_5;
d[EC_ADD_EQUAL_U8_CONSTANT_U1]=FUT_8_10;
d[EC_SUB_EQUAL_U8_CONSTANT_U1]=FUT_8_10;
d[EC_ADD_EQUAL_U4_CONSTANT_U1]=FUT_8_5;
d[EC_ESI_ADD_EQUAL_U4_CONSTANT_U1]=FUT_8_5;
d[EC_EDI_ADD_EQUAL_U4_CONSTANT_U1]=FUT_8_5;
d[EC_BT_CONSTANT]=FUT_8_6;
d[EC_BTS_CONSTANT]=FUT_8_6;
d[EC_BTR_CONSTANT]=FUT_8_6;
d[EC_BTC_CONSTANT]=FUT_8_6;
d[EC_CALL]=FUT_32_4_CALL;
d[EC_U8]=FUT_64_H9_L4;
d[EC_U4]=FUT_32_4;
d[EC_U1]=FUT_8_1;
d[EC_DOUBLE]=FUT_64_H9_L4;
d[EC_PUSH_U8]=FUT_64_H9_L4;
d[EC_PUSH_DOUBLE]=FUT_64_H9_L4;
d[EC_PUSH_U4]=FUT_32_4;
d[EC_PUSH_U2]=FUT_32_4;
d[EC_PUSH_U1]=FUT_8_1;
d[EC_PUSH_NEG_U4]=FUT_32_4;
d[EC_PUSH_NEG_U2]=FUT_32_4;
d[EC_PUSH_NEG_U1]=FUT_8_1;
d[EC_ADD32]=FUT_32_7;
d[EC_SUB32]=FUT_32_7;
d[EC_ADD_ESP32]=FUT_32_4;
d[EC_ENTER]=FUT_32_4;
d[EC_ENTER1]=FUT_ENTER1;
d[EC_ENTER2]=FUT_ENTER2;
d[EC_LEAVE]=FUT_32_6;
d[EC_LEAVE1]=FUT_32_6;
d[EC_LEAVE2]=FUT_32_6;
d[EC_TYPE]=FUT_32_4;
d[EC_U1_DISP32]=FUT_32_4;
d[EC_U2_DISP32]=FUT_32_4;
d[EC_U4_DISP32]=FUT_32_4;
d[EC_U8_DISP32]=FUT_32_9;
d[EC_PUSH_U8_DISP32]=FUT_32_9;
d[EC_ESI_U1_DISP32]=FUT_32_4;
d[EC_ESI_U2_DISP32]=FUT_32_4;
d[EC_ESI_U4_DISP32]=FUT_32_4;
d[EC_ESI_U8_DISP32]=FUT_32_9;
d[EC_PUSH_ESI_U8_DISP32]=FUT_32_9;
d[EC_EDI_U1_DISP32]=FUT_32_4;
d[EC_EDI_U2_DISP32]=FUT_32_4;
d[EC_EDI_U4_DISP32]=FUT_32_4;
d[EC_EDI_U8_DISP32]=FUT_32_9;
d[EC_PUSH_EDI_U8_DISP32]=FUT_32_9;
d[EC_FS_U1_DISP32]=FUT_32_4;
d[EC_FS_U2_DISP32]=FUT_32_4;
d[EC_FS_U4_DISP32]=FUT_32_4;
d[EC_FS_U8_DISP32]=FUT_32_4P10_4;
d[EC_LEA_DISP32_EBP]=FUT_32_4;
d[EC_LEA_DISP32_ESI]=FUT_32_4;
d[EC_LEA_DISP32_EDI]=FUT_32_4;
d[EC_CALL_INDIRECT]=FUT_32_4;
d[EC_U2_DISP32_SCALED]=FUT_32_6;
d[EC_U4_DISP32_SCALED]=FUT_32_6;
d[EC_U8_DISP32_SCALED]=FUT_32_9;
d[EC_PUSH_U8_DISP32_SCALED]=FUT_32_9;
d[EC_CALL_INDIRECT2]=FUT_32_4_ABS;
d[EC_ABSOLUTE_ADDRESS]=FUT_32_4_ABS;
d[EC_STRING_CONSTANT]=FUT_32_4_ABS2;
d[EC_GET_LABEL]=FUT_32_4_ABS2;
d[EC_SWITCH]=FUT_32_4_ABS2;
d[EC_SKIPZ2]=FUT_32_JMP_4;
d[EC_SKIPNZ2]=FUT_32_JMP_4;
d[EC_OR_OR_SKIPZ2]=FUT_32_JMP_4;
d[EC_OR_OR_SKIPNZ2]=FUT_32_JMP_4;
d[EC_AND_AND_SKIPZ2]=FUT_32_JMP_4;
d[EC_AND_AND_SKIPNZ2]=FUT_32_JMP_4;
d[EC_LESS_THAN_SKIPZ2]=FUT_32_JMP_4;
d[EC_GREATER_THAN_SKIPZ2]=FUT_32_JMP_4;
d[EC_EQUAL_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_NOT_EQUAL_TO_SKIPZ2]=FUT_32_JMP_4;
d[EC_GREATER_OR_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_LESS_OR_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_JMP]=FUT_32_JMP_4;
d[EC_SKIPZ]=FUT_8_JMP_1;
d[EC_SKIPNZ]=FUT_8_JMP_1;
d[EC_OR_OR_SKIPZ]=FUT_8_JMP_1;
d[EC_OR_OR_SKIPNZ]=FUT_8_JMP_1;
d[EC_AND_AND_SKIPZ]=FUT_8_JMP_1;
d[EC_AND_AND_SKIPNZ]=FUT_8_JMP_1;
d[EC_LESS_THAN_SKIPZ]=FUT_8_JMP_1;
d[EC_GREATER_THAN_SKIPZ]=FUT_8_JMP_1;
d[EC_EQUAL_EQUAL_SKIPZ]=FUT_8_JMP_1;
d[EC_NOT_EQUAL_TO_SKIPZ]=FUT_8_JMP_1;
d[EC_GREATER_OR_EQUAL_SKIPZ]=FUT_8_JMP_1;
d[EC_LESS_OR_EQUAL_SKIPZ]=FUT_8_JMP_1;
d[EC_SHORT_JMP]=FUT_8_JMP_1;
d=MAllocZ(EC_NUM_ENTRIES);
signed_fix_up_table=d;
d[EC_ADD_ESP8]=FUT_8_1;
d[EC_U1_DISP8]=FUT_8_2;
d[EC_U2_DISP8]=FUT_8_2;
d[EC_U4_DISP8]=FUT_8_2;
d[EC_ESI_U1_DISP8]=FUT_8_2;
d[EC_ESI_U2_DISP8]=FUT_8_2;
d[EC_ESI_U4_DISP8]=FUT_8_2;
d[EC_EDI_U1_DISP8]=FUT_8_2;
d[EC_EDI_U2_DISP8]=FUT_8_2;
d[EC_EDI_U4_DISP8]=FUT_8_2;
d[EC_SHR_CONSTANT1]=FUT_8_6;
d[EC_SHR_CONSTANT2]=FUT_8_4;
d[EC_ADD_EQUAL_U4_CONSTANT_U1]=FUT_8_4;
d[EC_ESI_ADD_EQUAL_U4_CONSTANT_U1]=FUT_8_4;
d[EC_EDI_ADD_EQUAL_U4_CONSTANT_U1]=FUT_8_4;
d[EC_U4]=FUT_32_5;
d[EC_U1_DISP32]=FUT_32_5;
d[EC_U2_DISP32]=FUT_32_5;
d[EC_U4_DISP32]=FUT_32_5;
d[EC_ESI_U1_DISP32]=FUT_32_5;
d[EC_ESI_U2_DISP32]=FUT_32_5;
d[EC_ESI_U4_DISP32]=FUT_32_5;
d[EC_EDI_U1_DISP32]=FUT_32_5;
d[EC_EDI_U2_DISP32]=FUT_32_5;
d[EC_EDI_U4_DISP32]=FUT_32_5;
d[EC_FS_U1_DISP32]=FUT_32_5;
d[EC_FS_U2_DISP32]=FUT_32_5;
d[EC_FS_U4_DISP32]=FUT_32_5;
d[EC_LEA_DISP32_EBP]=FUT_32_4;
d[EC_U2_DISP32_SCALED]=FUT_32_5;
d[EC_U4_DISP32_SCALED]=FUT_32_5;
d[EC_ABSOLUTE_ADDRESS]=FUT_32_4_ABS;
d[EC_GET_LABEL]=FUT_32_4_ABS2;
d[EC_SWITCH]=FUT_32_4_ABS2;
d[EC_SKIPZ2]=FUT_32_JMP_4;
d[EC_SKIPNZ2]=FUT_32_JMP_4;
d[EC_OR_OR_SKIPZ2]=FUT_32_JMP_4;
d[EC_OR_OR_SKIPNZ2]=FUT_32_JMP_4;
d[EC_AND_AND_SKIPZ2]=FUT_32_JMP_4;
d[EC_AND_AND_SKIPNZ2]=FUT_32_JMP_4;
d[EC_LESS_THAN_SKIPZ2]=FUT_32_JMP_4;
d[EC_GREATER_THAN_SKIPZ2]=FUT_32_JMP_4;
d[EC_EQUAL_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_NOT_EQUAL_TO_SKIPZ2]=FUT_32_JMP_4;
d[EC_GREATER_OR_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_LESS_OR_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_SKIPZ]=FUT_8_JMP_1;
d[EC_SKIPNZ]=FUT_8_JMP_1;
d[EC_OR_OR_SKIPZ]=FUT_8_JMP_1;
d[EC_OR_OR_SKIPNZ]=FUT_8_JMP_1;
d[EC_AND_AND_SKIPZ]=FUT_8_JMP_1;
d[EC_AND_AND_SKIPNZ]=FUT_8_JMP_1;
d[EC_LESS_THAN_SKIPZ]=FUT_8_JMP_1;
d[EC_GREATER_THAN_SKIPZ]=FUT_8_JMP_1;
d[EC_EQUAL_EQUAL_SKIPZ]=FUT_8_JMP_1;
d[EC_NOT_EQUAL_TO_SKIPZ]=FUT_8_JMP_1;
d[EC_GREATER_OR_EQUAL_SKIPZ]=FUT_8_JMP_1;
d[EC_LESS_OR_EQUAL_SKIPZ]=FUT_8_JMP_1;
d=MAllocZ(EC_NUM_ENTRIES);
double_fix_up_table=d;
d[EC_LESS_THAN_SKIPZ2]=FUT_32_JMP_4;
d[EC_GREATER_THAN_SKIPZ2]=FUT_32_JMP_4;
d[EC_GREATER_OR_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_LESS_OR_EQUAL_SKIPZ2]=FUT_32_JMP_4;
d[EC_LESS_THAN_SKIPZ]=FUT_8_JMP_1;
d[EC_GREATER_THAN_SKIPZ]=FUT_8_JMP_1;
d[EC_GREATER_OR_EQUAL_SKIPZ]=FUT_8_JMP_1;
d[EC_LESS_OR_EQUAL_SKIPZ]=FUT_8_JMP_1;
d[EC_SHORT_JMP]=FUT_8_JMP_1;
u=MAllocZ(sizeof(U2)*TK_NUM_TK);
duel_I1_tokens1=u;
u['!']=256*TK_NOT_EQUAL+'=';
u['&']=256*TK_AND_AND+'&';
u['*']=256*TK_MUL_EQUAL+'=';
u['+']=256*TK_PLUS_PLUS+'+';
u['-']=256*TK_DEREFERRENCE+'>';
u['/']='*';
u[':']=256*TK_DOUBLE_COLON+':';
u['<']=256*TK_LESS_EQUAL+'=';
u['=']=256*TK_EQUAL_EQUAL+'=';
u['>']=256*TK_GREATER_EQUAL+'=';
u['^']=256*TK_XOR_EQUAL+'=';
u['|']=256*TK_OR_OR+'|';
u=MAllocZ(sizeof(U2)*TK_NUM_TK);
duel_I1_tokens2=u;
u['&']=256*TK_AND_EQUAL+'=';
u['+']=256*TK_ADD_EQUAL+'=';
u['-']=256*TK_MINUS_MINUS+'-';
u['/']='/';
u['<']=256*TK_SHL+'<';
u['>']=256*TK_SHR+'>';
u['^']=256*TK_XOR_XOR+'^';
u['|']=256*TK_OR_EQUAL+'=';
u=MAllocZ(sizeof(U2)*TK_NUM_TK);
duel_I1_tokens3=u;
u['-']=256*TK_SUB_EQUAL+'=';
u['/']=256*TK_DIV_EQUAL+'=';
u['>']=256*TK_CAST+'<';
d4=MAllocZ(sizeof(U4)*TK_NUM_TK);
binary_ops_table=d4;
d4['`'] =0x20000+EC_POWER;
d4[TK_SHL] =0x20000+EC_SHL;
d4[TK_SHR] =0x20000+EC_SHR;
d4['*'] =0x30000+EC_MULTIPLICATION;
d4['/'] =0x30000+EC_DIVISION;
d4['%'] =0x30000+EC_REMAINDER;
d4['&'] =0x40000+EC_AND;
d4['|'] =0x50000+EC_OR;
d4['^'] =0x50000+EC_XOR;
d4['+'] =0x60000+EC_ADDITION;
d4['-'] =0x60000+EC_SUBTRACTION;
d4[TK_EQUAL_EQUAL] =0x70000+EC_EQUAL_EQUAL;
d4[TK_NOT_EQUAL] =0x70000+EC_NOT_EQUAL_TO;
d4['<'] =0x70000+EC_LESS_THAN;
d4['>'] =0x70000+EC_GREATER_THAN;
d4[TK_LESS_EQUAL] =0x70000+EC_LESS_OR_EQUAL;
d4[TK_GREATER_EQUAL]=0x70000+EC_GREATER_OR_EQUAL;
d4[TK_AND_AND] =0x80000+EC_AND_AND;
d4[TK_OR_OR] =0x90000+EC_OR_OR;
d4[TK_XOR_XOR] =0x90000+EC_XOR_XOR;
d4[':'] =0xA0000+EC_COLON;
d4['?'] =0xA0000+EC_QUESTION;
d4['='] =0x100000+EC_ASSIGN_U8;
d4[TK_SHL_EQUAL]=0x100000+EC_SHL_EQUAL_U8;
d4[TK_SHR_EQUAL]=0x100000+EC_SHR_EQUAL_U8;
d4[TK_MUL_EQUAL]=0x100000+EC_MUL_EQUAL_U8;
d4[TK_DIV_EQUAL]=0x100000+EC_DIV_EQUAL_U8;
d4[TK_AND_EQUAL]=0x100000+EC_AND_EQUAL_U8;
d4[TK_OR_EQUAL] =0x100000+EC_OR_EQUAL_U8;
d4[TK_XOR_EQUAL]=0x100000+EC_XOR_EQUAL_U8;
d4[TK_ADD_EQUAL]=0x100000+EC_ADD_EQUAL_U8;
d4[TK_SUB_EQUAL]=0x100000+EC_SUB_EQUAL_U8;
d4=MAllocZ(sizeof(U4)*TK_NUM_TK);
unary_ops_table=d4;
d4['~']=0x10000+EC_COM;
d4['!']=0x10000+EC_NOT;
d4['-']=0x10000+EC_UNARY_MINUS;
d4['&']=0x10000+EC_ADDRESS;
d4['*']=0x10000+EC_DEREF_U8;
d4=unsigned_code_table[EC_ABSOLUTE_ADDRESS+1]-4;
*d4=offset(TssStruct.absolute_address);
for (i=0;i<EC_NUM_ENTRIES;i++) {
u=unsigned_code_table[i];
if (unsigned_code_table[i+1]-u) {
if (*u==0x5052)
Bts(push_bitmap,i);
}
}
}
void InitCompiler(BoolU4 first)
{
is_first_compiler=first;
if (first)
ext[EXT_CMP_EXE_BLK]=&CmpParseExeBlk;
LoadCompileSysText;
FillCompilerTables;
LoadAsmHash(first);
}
#define ADAM_STARTUP_NAME "/LT/OSMain/ADAMK.CPZ"
void AdamStartUpFile()
{
LexStruct *l=LexNew(ReadTextFile(ADAM_STARTUP_NAME),0,
NewString(ADAM_STARTUP_NAME));
InsQue(l,Fs->last_lex);
ext[EXT_SPRINTF_JOIN]=&SPrintFJoin2;
ext[EXT_GETF_JOIN]=&GetFJoin2;
ext[EXT_EXECUTE_FILE]=&ExecuteFile;
ext[EXT_EXECUTE_STRING]=&ExecuteString;
InitCompiler(TRUE);
try {
Lex(l);
ExecuteCmdLine(l);
} catch
CatchAll;
RemQue(l);
LexDel(l);
}
Reference in new issue View Git Blame Copy Permalink