#define _SWITCH_



#include "tok.h"



extern int lastcommand;	//последний оператор в блоке



#define MAXCASE 1024



FSWI *swtables;	//таблица информаций об switch

int numswtable=0;	//число блоков в этой таблице

char mesSWITCH[]="SWITCH";

char mesCASE[]="CASE";

int numexpandcase;

int numberbreak=0;



void CheckJmpSW(int line,int endsw,int startsw,int shortjmp,char *mes)

{

int size=startsw-endsw;

	if(shortjmp==FALSE){

		if((unsigned int)size<128)warningjmp(mes,line);

		if(am32==FALSE)*(unsigned short *)&output[endsw-2]=(unsigned short)size;

		else *(unsigned long *)&output[endsw-4]=(unsigned long)size;

	}

	else{

		if((unsigned int)size>127)jumperror(line,mes);

		output[endsw-1]=(unsigned char) size;

	}

}



void CmpRegNum(int tokr,unsigned long value,int reg)

{

	if(tokr!=r8){

		op66(tokr);         //CMP EAX,val

		if(value==0){

			op(0x85);

			op(0xC0+reg*9);	//test AX,AX

		}

		else{

			if(short_ok(value,tokr==r32?TRUE:FALSE)){

				op(0x83);

				op(0xF8+reg);

				op(value);

			}

			else{

				if(reg==0)op(0x3D);

				else{

					op(0x81);

					op(0xF8+reg);

				}

				tokr==r32?outdword(value):outword(value);

			}

		}

	}

	else{                   //CMP AL,val

		if(value==0){

			op(0x84);

			op(0xC0+reg*9);

		}

		else{

			if(reg==0)op(0x3c);

			else{

				op(0x80);

				op(0xF8+reg);

			}

			op(value);

		}

	}

}



int ScanSwitch(int *numcase,ISW *caseinf,COM_MOD *startmod)

{

unsigned char dcha;

int dtok,line,oinptr,i,otok2;

//new

unsigned char *oinput;

int oendinptr;



ITOK otok;

int retcode=TRUE;

	dtok=tok;

	otok=itok;

	otok2=tok2;

	line=linenum2;

	dcha=cha2;

	oinptr=inptr=inptr2;

	cha=cha2;

//new

	oinput=input;

	oendinptr=endinptr;

	if(startmod!=cur_mod){

		COM_MOD *pmod=cur_mod;

		while(pmod->next!=startmod){

			pmod=pmod->next;

		}

		input=pmod->input;

		inptr=pmod->inptr;

		endinptr=pmod->endinptr;

		cha=input[inptr];

		inptr++;

	}



	if(SkipParam()){

		FastTok(0);

		if(tok!=tk_openbrace){

			SwTok(tk_openbrace);

			retcode=FALSE;

		}

		else{

			for(i=1;i!=0;){

				FastTok(1);

				if(tok==tk_question)CheckDir();

				switch(tok){

					case tk_eof:

						unexpectedeof();

						retcode=FALSE;

						i=0;

						break;

					case tk_openbrace: i++; break;

					case tk_closebrace: i--; break;

					case tk_id:

					case tk_case:

					case tk_CASE:

						if(i==1){

							if(stricmp(itok.name,"case")==0){

								inptr2=inptr;

								cha2=cha;

								linenum2=linenumber;

								(caseinf+*numcase)->postcase=(itok.name[0]=='c'?FALSE:TRUE);

								nexttok();

								if(tok==tk_number||(tok==tk_minus&&tok2==tk_number)){

									if(*numcase==MAXCASE){

										preerror("Many to use <case>");

										retcode=FALSE;

									}

									else{

										unsigned long val=doconstlongmath();

										for(int j=0;j<*numcase;j++){

											if(val==(caseinf+j)->value){

												preerror("Duplicate 'case'");

												retcode=FALSE;

												break;

											}

										}

										(caseinf+*numcase)->value=val;

										if(tok==tk_multipoint){

											(caseinf+*numcase)->type=startmulti;

											nexttok();

											val=doconstlongmath();

											numexpandcase+=val-(caseinf+*numcase)->value-1;

											if(val<(caseinf+*numcase)->value){

												preerror("The first value 'case' should be smaller");

												retcode=FALSE;

											}

											*numcase=*numcase+1;

											(caseinf+*numcase)->type=endmulti;

											(caseinf+*numcase)->value=val;

											(caseinf+*numcase)->postcase=(caseinf+*numcase-1)->postcase;

										}

										else (caseinf+*numcase)->type=singlcase;

										*numcase=*numcase+1;

									}

								}

								else{

									numexpected();

									retcode=FALSE;

								}

								inptr=inptr2;

								cha=cha2;

							}

						}

						break;

				}

			}

		}

	}

	if(retcode){	//если не найдено ошибок

		tok=dtok;

		itok=otok;

		linenum2=line;

		cha2=dcha;

		inptr2=oinptr;

		tok2=otok2;

	}

	else{

		inptr2=inptr;

		cha2=cha;

		linenum2=linenumber;

	}

//new

	input=oinput;

	endinptr=oendinptr;



	return retcode;

}



void doswitch()

{

ISW *caseinf;

int numcase=0,reg=AX,mode=0;

unsigned int endsw,defaul=0,tokr,endsw2=0;

int shortjmp=(tok==tk_switch?FALSE:TRUE);

int sline=linenumber;

REGISTERSTAT *bakregstat,*changeregstat;

char *ofsstr=NULL;

//new

COM_MOD *startmod=cur_mod;

unsigned char oinline=useinline;

#ifdef OPTVARCONST

ITOK otok;

int swvar=FALSE;

unsigned long numbervar;

int numrm;

int nonum;

#endif

	useinline=0;

	caseinf=(ISW *)MALLOC(sizeof(ISW)*MAXCASE);	//блок для инфо о case

	numexpandcase=0;

	uptdbr(/*TRUE*/);

	getoperand();

char signflag=0;

	expecting(tk_openbracket);

	switch(tok){

		case tk_intvar:

			signflag=1;

			goto dint;

		case tk_int:

			signflag=1;

		case tk_word:

			getoperand();

		case tk_wordvar:

		case tk_reg:

dint:

			tokr=r16;

			break;

		case tk_charvar:

			signflag=1;

			goto dchar;

		case tk_char:

			signflag=1;

		case tk_byte:

			getoperand();

		case tk_bytevar:

		case tk_beg:

dchar:

			tokr=r8;

			break;

		case tk_long:

			signflag=1;

		case tk_dword:

			getoperand();

			goto dlong;

		case tk_qword:

			getoperand();

			goto qword;

		case tk_floatvar:

		case tk_longvar: signflag=1;

		case tk_dwordvar:

		case tk_reg32:

dlong:

			tokr=r32;

			break;

		case tk_doublevar: signflag=1;

		case tk_qwordvar:

qword:

			tokr=r64;

			break;

		case tk_openbracket:

			nexttok();

			if(tok>=tk_char&&tok<=tk_double){

				tokr=typesize(tok);

				switch(tok){

					case tk_double:

					case tk_float:

					case tk_char:

					case tk_int:

					case tk_long:

						signflag=1;

				}

			}

			nexttok();

			expectingoperand(tk_closebracket);

			break;

		default:

			tokr=(am32+1)*2;

			break;

	}

#ifdef OPTVARCONST

	if(tok>=tk_charvar&&tok<=tk_dwordvar&&tok2==tk_closebracket){

		otok=itok;

		swvar=TRUE;

	}

#endif

	if(ScanSwitch(&numcase,caseinf,startmod)){

int i;

unsigned int sizetab;	//размер таблицы

unsigned long min=0xffffffff,max=0;

unsigned int size0=0,size1;

int reg0=0,svop=0;

long smin=0x7fffffff,smax=-0x7fffffff;

unsigned int size2=0;

unsigned oaddESP=addESP;

		if(numcase>2){

			if(!optimizespeed){

				if((am32==FALSE&&tokr==r32)||(am32&&tokr==r16))size0=numcase;

				else if(tokr==r8)size0=numcase*2;

				if((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&tok2==tk_closebracket)

					reg0=itok.number;	//предполагаемый регистр метода 0

			}

			for(i=0;i<numcase;i++){	//расчет размера по методу 0

				if((caseinf+i)->value>max)max=(caseinf+i)->value;

				if((caseinf+i)->value<min)min=(caseinf+i)->value;

				if((long) (caseinf+i)->value>smax)smax=(caseinf+i)->value;

				if((long) (caseinf+i)->value<smin)smin=(caseinf+i)->value;

				if((!optimizespeed)&&tokr!=r8){

					if((caseinf+i)->value==0)size0+=2;

					else if((caseinf+i)->value<128)size0+=3;

					else{

						size0+=(reg0==0?3:4);

						if(am32)size0+=2;

					}

				}

				if(i!=0){

					if((caseinf+i)->postcase==0)size0+=(am32==FALSE?(chip<3?5:4):6);

					else size0+=2;

				}

			}

			if((unsigned int)(smax-smin)<(max-min)){

				max=smax-smin;

				svop=8;

				min=-smin;

			}

			else{

				smin=min;

				max-=min;

			}

			sizetab=max+1;	//размер таблицы для метода 1

			if(sizetab<0x1000000&&(!(am32==FALSE&&tokr==r32))){

				if(optimizespeed){

					if((unsigned int)(sizetab/numcase)<(unsigned int)(am32==FALSE?3:4)){

						mode=1;

						if(am32==FALSE)reg=BX;

					/* если отношение числа элементов в таблице к числу case менее

					 3 для 16-битного режима и 4 для 32-битного, то берется метод 1 */

					}

				}

				else{	//вычислить размер для оптимизации по размеру

					if(shortjmp)size0+=2;

					else size0+=(am32==FALSE?(chip<3?5:4):6);

					size1=sizetab*(am32==FALSE?2:4);

					size1+=(max<128?3:am32==FALSE?4:6)+(shortjmp==FALSE?(chip<3?5:4):2);

					if(max>127&&reg0==AX)size1--;

					if(min!=0){

						if(min==1)size1++;

						else if(min==2&&(!optimizespeed))size1+=2;

						else if(min<128)size1+=3;

						else{

							size1+=(am32==FALSE?4:6);

							if(reg0==AX)size1--;

						}

					}

					size1+=(am32==FALSE?6:9);

					if(am32){

						if(tokr!=r32)size1+=3;

						if(shortjmp)size1-=2;

					}

					else{

						if(reg0!=BX)size1+=2;

					}

				//выбор метода с меньшим размером

					if(size1<=size0){

						mode=1;

						size0=size1;

						if(am32==FALSE)reg=BX;



					}

				}

			}

		}

		if(numcase>9&&(!optimizespeed)){

// расчет метода 2

			size2=numcase+numexpandcase;

			switch(tokr){

				case r8:

					if(am32)size2=size2*5;

					else size2=size2*3+8;

					break;

				case r16:

					if(am32)size2=size2*6+1;

					else size2=size2*4+8;

					break;

				case r32:

					if(am32)size2=size2*8;

					else size2=size2*6+9;

					break;

			}

			size2+=29;

			//выбор метода с меньшим размером

			if(size2<=size0)mode=2;

		}

//		printf("Num CASE %d Metod 0 size=%d. Metod 1 size=%d. Metod 2 size=%d\n",numcase,size0,size1,size2);

		if(mode==2){

			reg=AX;

			reg0=idxregs[1];

			if((!am32)||(am32&&(!((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&tok2==tk_closebracket)))){

				if(tokr==r8)doalmath(signflag,&ofsstr);

				else do_e_axmath(signflag,tokr,&ofsstr);

			}

			else{

				reg=itok.number;

				if(reg==reg0)reg0=idxregs[0];

				nexttok();

			}

				ClearReg(reg);

				ClearReg(reg0);

			warningreg(regs[am32][reg0]);

		}

		else if((tok==tk_beg||tok==tk_reg||tok==tk_reg32)&&tok2==tk_closebracket){

			if(reg==AX){

				reg=itok.number;

				if(mode&&am32)getintoreg_32(reg,r32,0,&ofsstr);

				else nexttok();

				ClearReg(AX);

			}

			else{

				getintoreg_32(BX,r16,0,&ofsstr);

				ClearReg(BX);

				warningreg("BX");

			}

		}

		else{

			if(tokr==r8)doalmath(signflag,&ofsstr);

			else do_e_axmath(signflag,tokr,&ofsstr);

			if(reg!=AX){

				ClearReg(BX);

				if(tokr==r8)outword(0xB4);	//mov ah,0

				if(optimizespeed)outword(0xC389);	//mov bx,ax

				else op(0x93);	//xchg ax,bx

			}

			else{

				ClearReg(AX);

				if(mode&&am32&&tokr!=r32){

					op(0x0F);

					op(tokr==r8?0xB6:0xB7);

					op(0xC0);

				}

			}

		}

		nextexpecting2(tk_openbrace);	//пров на откр скобку

		if(numcase){

			if(mode==1){	//первый метод

				if(min!=0){

					if(min==1)op(0x48+reg-svop);	//dec reg

					else if(min==2&&(!optimizespeed)){

						op(0x48+reg-svop);	//dec reg

						op(0x48+reg-svop);	//dec reg

					}

					else if(min<128){

						op(0x83);

						op(0xE8+reg-svop*5);

						op(min);

					}

					else{

						if(reg==AX)op(0x2D-svop*5);

						else{

							op(0x81);

							op(0xE8+reg-svop*5);

						}

						if(am32)outdword(min);

						else outword(min);

					}

					if(am32)warningreg(regs[1][reg]);

				}

				if(max<128){

					op(0x83);	//cmp reg,max

					op(0xF8+reg);

					op(max);

				}

				else{

					if(reg==AX)op(0x3D);

					else{

						op(0x81);

						op(0xF8+reg);

					}

					if(am32)outdword(max);

					else outword(max);

				}

				if(shortjmp==FALSE){

					if(chip<3){

						outword(0x376);	//jbe 3

						op(0xE9);	//jmp to default

					}

					else outword(0x870F);	//ja default

					outword(0);

					if(am32)outword(0);

				}

				else{

					op(0x77);

					op(0);

				}

				endsw=outptr;	//адрес конца switch или default

				if(am32){

					outword(0x24FF);

					op(0x85+reg*8);

				}

				else outdword(0xA7FFDB01);	//add bx,bx jmp [bx+table]

				AddReloc(CS);

				size1=outptr;

				outword(0);

				if(am32)outword(0);

			}

			else if(mode==0){

				svop=numcase;

				for(;numcase>0;){	//ветвление

					numcase--;

					CmpRegNum(tokr,(caseinf+numcase)->value,reg);

					if((caseinf+numcase)->type==singlcase){

						if(numcase){

							if((caseinf+numcase)->postcase==FALSE){

								if(chip<3){

									outword(0x375);	//jnz 3

									op(0xE9);	//jmp to default

								}

								else outword(0x840F);	//jz default

								outword(0);

								if(am32)outword(0);

							}

							else outword(0x74);

							(caseinf+numcase)->postcase=outptr;

						}

						else{

							if(shortjmp==FALSE){

								if(chip<3){

									outword(0x374);	//jnz 3

									op(0xE9);	//jmp to default

								}

								else outword(0x850F);	//jz default

								outword(0);

								if(am32)outword(0);

							}

							else outword(0x75);

							endsw=outptr;	//адрес конца switch или default

						}

					}

					else{	//case 1...5

						numcase--;

						max=(caseinf+numcase)->value;

						if(numcase!=0){

							if((caseinf+numcase+1)->postcase==FALSE){

								if(max==0){

									if(chip>2){

										outdword(0x860F);

										if(am32)outword(0);

									}

									else{

										outword(am32==FALSE?0x0377:0x577);

										jumploc0();

									}

								}

								else{

									outword(0x77);

									endsw=outptr;

									CmpRegNum(tokr,max,reg);

									if(chip>2){

										outdword(0x830F);

										if(am32)outword(0);

									}

									else{

										outword(am32==FALSE?0x0372:0x572);

										jumploc0();

									}

									output[endsw-1]=(unsigned char)(outptr-endsw);

								}

							}

							else{

								if(max==0)outword(0x76);

								else{

									outword(0x77);

									endsw=outptr;

									CmpRegNum(tokr,max,reg);

									outword(0x73);

									output[endsw-1]=(unsigned char)(outptr-endsw);

								}

							}

							(caseinf+numcase)->postcase=outptr;

						}

						else{

							if(shortjmp==FALSE){

								if((optimizespeed&&chip>2)||(chip>2&&max==0)){

									outdword(0x870F);

									if(am32)outword(0);

									if(max!=0){

										endsw2=outptr;

										CmpRegNum(tokr,max,reg);

										outdword(0x820F);

										if(am32)outword(0);

									}

								}

								else{

									if(max==0) outword(am32==FALSE?0x0376:0x576);

									else{

										outword(0x77);

										endsw=outptr-1;

										CmpRegNum(tokr,max,reg);

										outword(am32==FALSE?0x0373:0x573);

										output[endsw]=(unsigned char)(outptr-endsw-1);

									}

									jumploc0();

								}

							}

							else{

								outword(0x77);

								if(max!=0){

									endsw2=outptr;

									CmpRegNum(tokr,max,reg);

									outword(0x72);

								}

							}

							endsw=outptr;	//адрес конца switch или default

						}

					}

				}

			}

			else if(mode==2){

				if(!am32){

					outdword(0x071E0651);	//push cx,es,ds pop es

					op(0xB9);	//mov CX,numcase

					outword(numcase+numexpandcase);

					op(0xBF);	//mov DI,tableval

					AddReloc(CS);

					size2=outptr;

					outword(0);

					op(0xF2);	//repnz

					switch(tokr){

						case r8: op(0xAE); break;

						case r32: op(0x66);

						case r16: op(0xAF); break;

					}

					outword(0x7407);	//pop es ,jz

					op(shortjmp==FALSE?4:3);

					op(0x59);	//pop cx

					if(shortjmp==FALSE)jumploc0();

					else outword(0xEB);

					endsw=outptr;	//адрес конца switch или default

					op(0xBF);	//mov DI,numcase

					outword(numcase+numexpandcase);

					outdword(0x014FCF29);	//sub di,cx dec di add di,di

					op(0xFF);

					outword(0xC781);	//add di,tableadr

					AddReloc(CS);

					size1=outptr;

					outword(0);

					op(0x59);	//pop cx

					outword(0x25FF);	//jmp [di]

				}

				else{

					op(0x31);

					op(0xC0+reg0*9);	//xor reg0,reg0

					switch(tokr){	//cmp [reg0*size+tableadr],reg

						case r8: op(0x38); op(0x4+reg*8); op(5+reg0*8); break;

						case r32: op(0x39); op(0x4+reg*8); op(0x85+reg0*8); break;

						case r16: op(0x66); op(0x39); op(0x4+reg*8); op(0x45+reg0*8); break;

					}

					AddReloc(CS);

					size2=outptr;

					outdword(0);

					outword(0x0775);	//jne

					outword(0x24FF);	//jmp [reg0*4+tableadr]

					op(0x85+reg0*8);

					AddReloc(CS);

					size1=outptr;

					outdword(0);

					op(0x40+reg0);	//inc reg0

					if((numcase+numexpandcase)>127){	//cmp reg0,numcase

						op(0x81);

						op(0xF8+reg0);

						outdword(numcase+numexpandcase);

					}

					else{

						op(0x83);

						op(0xF8+reg0);

						op(numcase+numexpandcase);

					}

					op(0x72);

					if((numcase+numexpandcase)>127)op(tokr==r16?0xE6:0xE7);

					else op(tokr==r16?0xE9:0xEA);

					if(shortjmp==FALSE)jumploc0();

					else outword(0xEB);

					endsw=outptr;	//адрес конца switch или default

				}

			}

		}

		numcase=0;

		useinline=oinline;

		bakregstat=BakRegStat();

		changeregstat=BakRegStat();

		lastcommand=tk_switch;

		do{

			if(tok==tk_case||tok==tk_CASE||tok==tk_default){     //если case - запомнить позицию и величину

				RestoreStack();

				CompareRegStat(changeregstat);

				switch(lastcommand){

					case tk_goto:

					case tk_GOTO:

					case tk_break:

					case tk_BREAK:

					case tk_return:

					case tk_RETURN:

					case tk_switch:

						CopyRegStat(bakregstat);

#ifdef OPTVARCONST

						nonum=FALSE;

#endif

						addESP=oaddESP;

						break;

					default:

						CopyRegStat(changeregstat);

#ifdef OPTVARCONST

						nonum=TRUE;

#endif

						if(ESPloc&&am32&&oaddESP!=addESP)warESP();

						break;

				}

				if(tok==tk_default){	//тоже для default

					if(mode==0&&svop){

						if(numcase==0)jumploc0();	//default самый первый

						CheckJmpSW(sline,endsw,outptr,shortjmp,mesSWITCH);

						if(endsw2)CheckJmpSW(sline,endsw2,outptr,shortjmp,mesSWITCH);

					}

					if(defaul)preerror("Duplicate 'default'");

					defaul=outptr;

					nexttok();

					expecting(tk_colon);	//пров на : и чтение следующ tok

					continue;

				}

				if(mode==0){

					if(numcase==0&&defaul){	//default самый первый

						if(am32==FALSE)*(unsigned short *)&output[defaul-2]=(unsigned short)(outptr-defaul);

						else *(unsigned long *)&output[defaul-4]=(unsigned long)(outptr-defaul);

					}

					else if(numcase)CheckJmpSW(linenumber,(caseinf+numcase)->postcase,outptr,tok==tk_case?FALSE:TRUE,mesCASE);

				}

				else (caseinf+numcase)->postcase=outptr;

				lastcommand=tok;	//new 12.12.07 14:27

				nexttok();

#ifdef OPTVARCONST

				numrm=itok.rm;

				numbervar=doconstlongmath();

				(caseinf+numcase)->value=numbervar-(mode==1?smin:0);

#else

				(caseinf+numcase)->value=doconstlongmath()-(mode==1?smin:0);

#endif

				numcase++;

				if(tok==tk_multipoint){

					nexttok();

					(caseinf+numcase)->value=doconstlongmath()-(mode==1?smin:0);

					numcase++;

				}

#ifdef OPTVARCONST

				else if(swvar&&nonum==FALSE)Const2Var(&otok,numbervar,numrm);

#endif

				expecting(tk_colon);	//пров на : и чтение следующ tok

				if(tok==tk_closebrace)numcase--;

				continue;//goto checkcase;

			}

			startblock();

			docommand();

			endblock();

		}while(tok!=tk_closebrace);

		RestoreStack();

		if(numberbreak==0){

			switch(lastcommand){

				case tk_break:

					posts--;

					outptr-=(am32==FALSE?3:5);

					break;

				case tk_BREAK:

					posts--;

					outptr-=2;

					break;

			}

		}

		if(defaul&&outptr<defaul){

			if(mode==0&&svop){

				if(numcase==0)jumploc0();	//default самый первый

				CheckJmpSW(sline,endsw,outptr,shortjmp,mesSWITCH);

				if(endsw2)CheckJmpSW(sline,endsw2,outptr,shortjmp,mesSWITCH);

			}

			defaul=outptr;

		}

//		printf("outptr=%08X defaul=%08X\n",outptr,defaul);

		CompareRegStat(changeregstat);

		FreeStat(bakregstat);

		CopyRegStat(changeregstat);

		FreeStat(changeregstat);

		if(numcase){

			if(mode==0){

				if(defaul==0){

					CheckJmpSW(sline,endsw,outptr,shortjmp,mesSWITCH);

					if(endsw2)CheckJmpSW(sline,endsw2,outptr,shortjmp,mesSWITCH);

				}

				free(caseinf);

			}

			else{

				if(defaul==0||defaul>outptr)defaul=outptr;

				CheckJmpSW(sline,endsw,defaul,shortjmp,mesSWITCH);

				caseinf=(ISW *)REALLOC(caseinf,sizeof(ISW)*numcase);

				if(!numswtable)swtables=(FSWI *)MALLOC(sizeof(FSWI));

				else swtables=(FSWI *)REALLOC(swtables,sizeof(FSWI)*(numswtable+1));

				FSWI *swt=swtables+numswtable;

				swt->info=caseinf;

				swt->sizetab=(mode==2?numcase:sizetab)+numexpandcase;

				swt->type=(am32==FALSE?2:4);

				swt->numcase=numcase;

				swt->defal=defaul;

				swt->ptb=size1;

				swt->ptv=size2;

				swt->mode=mode;

				swt->razr=tokr;

				numswtable++;

			}

		}

		else free(caseinf);

		SetBreakLabel();

		SetContinueLabel();

	}

	nexttok();

	lastcommand=tk_switch;

	retproc=FALSE;

}