Subversion Repositories Kolibri OS

#define _ERRORS_

	warningprint,1,warningprint,1,warningprint,1,warningprint,1,warningprint,1,

unsigned char mapfile=FALSE;

/* ================== error messages start =========================== */

//	while(tok!=tk_eof&&itok2.type!=tp_stopper/*tok2!=tk_semicolon&&tok2!=tk_camma*/){

		nexttok();

//	}

{

	inptr=inptr2;

	linenum2=linenumber;

void FindEndLex()

	while(tok2!=tk_semicolon&&tok!=tk_eof)nexttok();

{

}

void  preerror3(char *str,unsigned int line,unsigned int file)//error message at a different than current line

	if(error

		sprintf((char *)string3,"%s(%d)#%d> %s.\n",startfileinfo==NULL?"":(startfileinfo+file)->filename,line,error,str);

	}

}

void internalerror (char *str)// serious internal compiler error message

char buf[200];

	preerror(buf);

	printf("TOK:%d SEGM:%d POST:%d RM:%d number:%ld\n",tok,itok.segm,itok.post,itok.rm,itok.number);

	printf("TOK2:%d SEGM2:%d POST2:%d RM2:%d number2:%ld\n",tok2,itok2.segm,itok2.post,itok2.rm,itok2.number);

	exit(e_internalerror);

{

		case 1:

			break;

			strcpy(buferr,"2-nd ");

		case 3:

			sprintf(buferr,"%d-th ",type%256);

	}

	return buferr;

	sprintf(holdstr,"'%c' expected",ch);

}

void numexpected(int type)

char buf[40];

	preerror(buf);

{

	sprintf(buf,"%svariable expected",getnumoperand(type,"operand "));

}

void stringexpected()

	preerror("string expected");

{

}

void wordvalexpected()

	preerror("word value expected");

{

}

void qwordvalexpected()

	preerror("qword value expected");

{

}

	preerror("operator identifier expected");

{

}

void swaperror()

	preerror("invalid or incompatable swap item");

{

}

void idalreadydefined()

char holdstr[80];

	preerror(holdstr);

//	nexttok();

{

char buf[80];

	strlwr(smalltype);

	preerror3(buf,line);

{

}

	preerror("maximum output code size exceeded");

}

void unableopenfile(char *name)

char holdstr[256];

	preerror(holdstr);

}

void thisundefined(char *str,int next)

char holdstr[80];

	preerror(holdstr);

	if(next)FindStopTok();

	sprintf(buf,"%smemory variable expected",getnumoperand(type,"operand "));

	FindStopTok();

{

}

void tobigpost()

}

void unuseableinput()

	preerror("unuseable input");

}

	preerror("to many use logic compare");

{

}

	preerror("maximum output data size exceeded");

}

void errorreadingfile(char *name)

char buf[256];

{

	sprintf(buf,"bad input file '%s'",name);

}

char buf[64];

	sprintf(buf,"error declare %sparameters in function",getnumoperand(num,""));

}

void CompareOr()

{

}

void OnlyComFile()

{

	sprintf(buf,"error redeclare function \"%s\"",name);

}

	preerror("function has return type of void");

{

	sprintf(buf,"extra parameter in function %s",name);

void blockerror()

	preerror("illegal syntax within [ ]");

{

void notstructname()

	preerror("unique struct name expected");

{

		preerror(buf);

}

void expectederror(char *str)

char holdstr[80];

		sprintf(holdstr,"%s expected",str);

	}

{

void declareunion()

	preerror("Error declare union");

/*

{

} */

void segoperror()

	preerror("only '=' or '><' operands valid with segment register");

{

void regmathoperror()

	preerror("invalid operation for non-AX register math");

{

void negregerror()

	preerror("negative non-constant invalid for non-AX register math");

{

}

	preerror("specified 16 bit operand invalid for non-AL register math");

{

}

void regmatherror()

	preerror("invalid operand for non-AX register math");

{

}

void wordnotoper()

	preerror("word or int operands invalid for non-EAX register math");

{

	sprintf(buf,"%sword register expected",getnumoperand(type,"operand "));

}

void bytevalexpected(int type)

char buf[50];

{

void invalidfarjumpitem()

	preerror("invalid operand for FAR jump");

{

}

void begexpected(int type)

char buf[50];

{

	sprintf(buf,"%s32 bit register expected",getnumoperand(type,"operand "));

}

char buf[50];

	preerror(buf);

{

}

	preerror("byte constant or DX expected");

{

}

void invalidoperand(int type)

	preerror(buf);

{

	sprintf(buf,"%sMMX register expected",getnumoperand(type,"operand "));

void xmmregexpected(int type)

char buf[50];

	preerror(buf);

	sprintf(buf,"%sXMM register or memory varible expected",getnumoperand(type,"operand "));

}

void mmxregordwordexpected(int type)

char buf[60];

	preerror(buf);

{

}

void fpuvarexpected(int type)

char buf[70];

	preerror(buf);

	sprintf(buf,"%sexpected FPU register",getnumoperand(type,"operand "));

}

void fpu0expected()

	preerror("2-nd expected only st(0) fpu register");

{

void errstruct()

	preerror("illegal use of struct");

{

}

void ErrWrite()

	//fprintf(stderr,"unable to write output file.\n");
	printf("unable to write output file.\n");

{

}

void InvOperComp()

	preerror("invalid operation for compare");

{

	sprintf(buf,"%sexpected mmx register or memory variable",getnumoperand(type,"operand "));

}

void reg32orword(int type)

	preerror(buf);

{

	sprintf(buf,"Base class '%s' not defined",name);

void unknowntype()

	preerror("unknown type");

{

}

void unknownstruct (char *name,char *sname)

	preerror(buf);

{

	sprintf(buf,"unknown tag '%s'",name);

void unknownobj(char *name)

char buf[IDLENGTH+32];

	preerror(buf);

void q();

{

	sprintf(buf,"unknown parametr for #pragma %s",name);

/*-----------------08.08.00 22:49-------------------

	--------------------------------------------------*/

void warningoptnum()

	if(wact[0].usewarn)wact[0].fwarn("Optimize numerical expressions",linenumber,currentfileinfo);

{

	if(wact[1].usewarn){

	}

	if(wact[2].usewarn){

		wact[2].fwarn(buf,line,file);

}

void warningstring()

		wact[3].fwarn((char *)string2,linenumber,currentfileinfo);

}

void warningexpand()

	if(wact[4].usewarn)wact[4].fwarn("Expansion variable",linenumber,currentfileinfo);

{

}

void warningprint(char *str,unsigned int line,unsigned int file)

		//	if((wartype.file=fopen(wartype.name,"w+t"))==NULL)wartype.file=stdout;

		//fprintf(wartype.file,"%s(%d)> Warning! %s.\n",startfileinfo==NULL?"":(startfileinfo+file)->filename,line,str);
		printf("%s(%d)> Warning! %s.\n",startfileinfo==NULL?"":(startfileinfo+file)->filename,line,str);

}

void  warningdefined(char *name)

char buf[IDLENGTH+30];

		sprintf(buf,"'%s' defined above, therefore skipped",name);

	}

char *typenames[]={"Variable","Structure","Function","Local variable",

	if(wact[7].usewarn){

		wact[7].fwarn(buf,linenumber,currentfileinfo);

}

char buf[IDLENGTH+50];

		sprintf(buf,"Non-initialized variable '%s' may have been used",name);

	}

{

}

void warningunreach()

	if(wact[10].usewarn)wact[10].fwarn("Code may not be executable",linenumber,currentfileinfo);

}

void warnsize()

	if(wact[12].usewarn)wact[12].fwarn("Sources size exceed destination size",linenumber,currentfileinfo);

char buf[IDLENGTH+50];

	warningprint(buf,linenumber,currentfileinfo);

}

void waralreadinitreg(char *reg,char *reg2)

	sprintf(buf,"Register %s same as %s",reg,reg2);

#endif

{

void missingpar(char *name)

char buf[120];

		sprintf(buf,"Missing parameter in function %s",name);

	}

void warreplasevar(char *name)

char buf[120];

	if(displaytokerrors){

		warningprint(buf,linenumber,currentfileinfo);

}

void waralreadinitvar(char *name,unsigned int num)

char buf[120];

	if(displaytokerrors){

//	}

}

void warcompneqconst()

	warningprint("Comparison not equal constant. Skipped code",linenumber,currentfileinfo);

{

}

void warpointerstruct()

	warningprint("Compiler not support pointers on structure",linenumber,currentfileinfo);

{

}

/* *****************   map file *************** */

void OpenMapFile()

	hmap=fopen(buf,"w+t");

{

	if(flag&f_interrupt)return "";

			retcode="byte ";

		case tk_charvar:

			retcode="char ";

		case tk_wordvar:

		case tk_longvar:

			retcode="long ";

		case tk_dwordvar:

			retcode="dword ";

		case tk_doublevar:

			retcode="double ";

			break;

		case tk_float:

			break;

		case tk_qword:

			break;

			retcode="void ";

			retcode="int ";

		case tk_structvar:

			break;

			retcode="int ";

}

char *GetTypeProc(int flag)

char *retcode;

	string2[0]=0;

	if(flag&f_export)strcat((char *)string2,"_export ");

	if(flag&f_static)strcat((char *)string2,"static ");

		t="";

			case tk_overflowflag:

				t="NOTOVERFLOW ";

			case tk_carryflag:

				break;

				t="NOTCARRYFLAG ";

			case tk_zeroflag:

				break;

			case tk_minusflag:

				break;

				t="PLUSFLAG ";

		}

	}

		case tp_pascal:

			t="cdecl ";

		case tp_stdcall:

			break;

			t="fastcall ";

	}

	return (char *)string2;

{

		case 'B':

			return "byte";

			if(c2>=0x30&&c2<=0x37)return regs[0][c2-0x30];

			return "dword";

		case 'I': return "int";

		case 'F': return "float";

		case 'Q':

			}

		case 'E': return "double";

			if(c2>=0x30&&c2<=0x37){

				return (char *)string2;

		case 'U': return "void";

	return "";;

{

char iname[IDLENGTH];

	if((tn=strchr(iname,'@'))!=NULL)*tn=0;

	else strcpy((char *)string3,iname);

}

char *GetSizeVar(int type,int adr)

char *reg;

	if(type==tp_postvar||type==tp_gvar)return "DS:???";

		if(ESPloc)reg="ESP";

	if(adr<0)sign="";

	sprintf((char *)string2,"%s%s%d",reg,sign,adr);

}

void GetRangeUsed(char *buf,localinfo *ptr)

	if(ptr->count==0)buf[0]=0;

	else sprintf(buf,"%d-%d",ptr->usedfirst,ptr->usedlast);

{

struct localrec *ptr;

char buf[32];

	if(hmap){

		for(i=0;;i++){

			if(c==0)break;

			unsigned char c3=string[i+2];

		}

		fprintf(hmap,"\nlocation: line %d-%d file %s",line,linenumber,startfileinfo==NULL?"":(startfileinfo+currentfileinfo)->filename);

	}

	for(ftlr=btlr;ftlr!=NULL;ftlr=ftlr->next){

			i=ptr->rec.type;

					fputs("\n----------------------------------------------",hmap);

				}

				fprintf(hmap,"\n%-8s%-10s%-12s%-4d%-8d",GetRetType(ptr->rec.rectok,0),GetSizeVar(ptr->rec.type,ptr->rec.recnumber),buf,ptr->li.count,ptr->rec.recsize);

				fputs(ptr->rec.recid,hmap);

	fputs("\n",hmap);

>

>

>