WebSVN – Kolibri OS – Blame – /programs/develop/cmm/tokr.cpp

Rev	Author	Line No.	Line
6446	GerdtR	1	#define _TOKR_
		2
		3
		4
		5	char useasm=FALSE;
		6
		7
		8
		9	void asmtwo1(int basecode); // used for ADD ADC SUB SBB CMP AND OR XOR.
		10
		11	void Scanbit(int basecode);
		12
		13	void asmone1(int basecode); // used for INC and DEC.
		14
		15
		16
		17	unsigned char tabldeckr(int code);
		18
		19	void doasmmov(); // do MOV
		20
		21	void movd();
		22
		23	void packMMX(int code,int code1,int code2);
		24
		25	void Shxd(int code);
		26
		27	void FpuType2(unsigned int addrm,unsigned int addrm2);
		28
		29	void FpuType4(unsigned int opcode,unsigned int addrm);
		30
		31	void FpuType6(unsigned int opcode,unsigned int addrm);
		32
		33	void FpuType8(unsigned int opcode,unsigned int addrm);
		34
		35	unsigned long SaveNumber(int type,int tok4,char *name);
		36
		37	void mmxiii(int type);
		38
		39	void pextrw();
		40
		41	void pshufw();
		42
		43	void xmm3instr(int type,int sec);
		44
		45	void movxmm(int code,int code2,int addc=1);
		46
		47	void movxmm3(int code,int code2=0,int type=tk_xmmreg);
		48
		49	void shiftxmm(int rm); //rxmm,i8
		50
		51	void AADM(int code);
		52
		53	extern void shortjumperror();
		54
		55	extern void invalidfarcallitem();
		56
		57	extern void axalexpected();
		58
		59	extern void reg32regexpected(int type);
		60
		61	extern void regexpected(int type);
		62
		63	extern void mmxregexpected(int type=0);
		64
		65	extern void mmxormem(int type);
		66
		67	extern void xmmregorvarexpected(int type);
		68
		69	extern void fpustakexpected(int type);
		70
		71
		72
		73	{
		74
		75	int htok;
		76
		77	char *hbuf;
		78
		79	unsigned int i=0;
		80
		81	unsigned long hnumber;
		82
		83	if(nexta==FALSE){
		84
		85	nexttok();
		86
		87	}
		88
		89	htok=itok.rm;
		90
		91	}
		92
		93	if(tok2==tk_colon){ //��⪠
		94
		95	else doid((char)(tok==tk_ID?1:0),tk_void);
		96
		97	}
		98
		99	htok=FastSearch((unsigned char )asmMnem,ofsmnem,0,(char )string);
		100
		101	asmparam=TRUE;
		102
		103
		104
		105	case a_adc: //ADC
		106
		107	case a_and: //AND
		108
		109	case a_xor: //XOR
		110
		111	asmtwo1(htok*8);
		112
		113	break;
		114
		115	case a_neg: //NEG
		116
		117	case a_div: //DIV
		118
		119	asmone2((htok-a_not)*8+16);
		120
		121	case a_rol: //ROL
		122
		123	case a_rcl: //RCL
		124
		125	case a_shl: //SHL
		126
		127	case a_sar: //SAR
		128
		129	next=0;
		130
		131	case a_btc: //BTC
		132
		133	case a_bts: //BTS
		134
		135	CheckBit((htok-a_bt)*8);
		136
		137	break;
		138
		139	case a_inc: //INC
		140
		141
		142
		143	case a_shld: //SHLD
		144
		145	next=0;
		146
		147	case a_aaa:
		148
		149	op(0x37); //AAA
		150
		151	case a_aad:
		152
		153	AADM(0xD5); //AAD
		154
		155	case a_aam:
		156
		157	AADM(0xD4); //AAM
		158
		159	case a_aas:
		160
		161	op(0x3F); //AAS
		162
		163	case a_adrsiz:
		164
		165	possiblecpu=3;
		166
		167	case a_arpl: //ARPL
		168
		169	htok=tok;
		170
		171	hbuf=bufrm;
		172
		173	hstr=strinf;
		174
		175	nextexpecting2(tk_camma);
		176
		177	switch(htok){
		178
		179	case tk_wordvar:
		180
		181	ClearVarByNum(&hstok);
		182
		183	CheckAllMassiv(hbuf,2,&hstr,&hstok);
		184
		185	outseg(&hstok,2);
		186
		187	op(hstok.rm+(unsigned int)itok.number*8);
		188
		189	break;
		190
		191	ClearReg(hstok.number);
		192
		193	op(192+(unsigned int)itok.number*8+hstok.number);
		194
		195	default: wordvalexpected();
		196
		197	possiblecpu=2;
		198
		199	case a_bound: //BOUND
		200
		201	possiblecpu=2;
		202
		203	case a_lea:
		204
		205	break;
		206
		207	case a_les: //LES
		208
		209	break;
		210
		211	asmregmem(0xF,0xB2);
		212
		213	break;
		214
		215	case a_lfs: //LFS
		216
		217	possiblecpu=3;
		218
		219	case a_bswap: //BSWAP
		220
		221	ClearReg(itok.number);
		222
		223	op66(tok==tk_reg?r16:r32);
		224
		225	op(0xC8+(unsigned int)itok.number);
		226
		227	else preerror("Expecting 32 bit Register for BSWAP");
		228
		229	break;
		230
		231	case a_bsr: //BSR
		232
		233	break;
		234
		235	nexttok();
		236
		237	if(tok==tk_ID\|\|tok==tk_id){
		238
		239	nexttok();
		240
		241	htok=1;
		242
		243	else if(stricmp("NEAR",(char *)string)==0){
		244
		245	htok=1;
		246
		247	}
		248
		249	nexttok();
		250
		251	htok=1;
		252
		253	// printf("call %d\n",tok);
		254
		255	case tk_proc:
		256
		257	if(itok.segm==DYNAMIC){
		258
		259	updatetree();
		260
		261	int flag=itok.flag;
		262
		263	addacall(itok.number,(unsigned char)(am32!=FALSE?CALL_32:CALL_NEAR));
		264
		265	}
		266
		267	}
		268
		269	break;
		270
		271	asmparam=FALSE;
		272
		273	if(faradd==0)callloc(hnumber);
		274
		275	op(0x9A);
		276
		277	unsigned long tempi=doconstdwordmath();
		278
		279	else outdword(tempi);
		280
		281	}
		282
		283	break; /* CALL num */
		284
		285	if(faradd==0){
		286
		287	op(0xE8);
		288
		289	if(am32==FALSE)outword(itok.number);
		290
		291	/* op(0xE8);
		292
		293	if(am32==FALSE)outword((unsigned int)itok.number);
		294
		295	}
		296
		297	break;
		298
		299	op66(r32);
		300
		301	case tk_reg:
		302
		303	callreg:
		304
		305	op(0xFF);
		306
		307	} /* CALL reg */
		308
		309	break;
		310
		311	case tk_id:
		312
		313	tobedefined(am32==FALSE?CALL_NEAR:CALL_32,tk_void);
		314
		315	} /* CALL NEAR */
		316
		317	break;
		318
		319	tok=tk_undefproc;
		320
		321	case tk_locallabel:
		322
		323	if(faradd==0){
		324
		325	(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?CALL_NEAR:CALL_32)));
		326
		327	} /* CALL NEAR */
		328
		329	break;
		330
		331	case tk_longvar:
		332
		333	if(am32==FALSE&&htok==0)faradd=8;
		334
		335	case tk_wordvar:
		336
		337	CheckAllMassiv(bufrm,i,&strinf);
		338
		339	op(0xFF); op(0x10+itok.rm+faradd);
		340
		341	break;
		342
		343	preerror("Invalid item for CALL");
		344
		345	}
		346
		347	FreeGlobalConst();
		348
		349	clearregstat();
		350
		351	case a_cbw:
		352
		353	if(am32)op(0x66);
		354
		355	break;
		356
		357	ClearReg(DX);
		358
		359	op(0x99);
		360
		361	break;
		362
		363	op(0xF8); //CLC
		364
		365	case a_cld:
		366
		367	break;
		368
		369	op(0xFA); //CLI
		370
		371	case a_clts: //CLTS
		372
		373	possiblecpu=2;
		374
		375	case a_cmc:
		376
		377	break;
		378
		379	ClearReg(SI);
		380
		381	op(0xA6);
		382
		383	case a_cmpsw:
		384
		385	ClearReg(DI);
		386
		387	op(0xA7);
		388
		389	case a_cmpsd:
		390
		391	xmm3instr(0xC2,0xF2);
		392
		393	next=0;
		394
		395	else{
		396
		397	ClearReg(DI);
		398
		399	op(0xA7);
		400
		401	}
		402
		403	case a_cmpxchg: //CMPXCHG
		404
		405	htok=tok;
		406
		407	hbuf=bufrm;
		408
		409	hstr=strinf;
		410
		411	nextexpecting2(tk_camma);
		412
		413	ClearReg(AX);
		414
		415	case tk_reg32:
		416
		417	case tk_reg:
		418
		419	switch(tok){
		420
		421	if(i==r16)goto erreg;
		422
		423	op66(i);
		424
		425	op(128+64+(unsigned int)itok.number*8+hstok.number);
		426
		427	case tk_longvar:
		428
		429	if(i==r16)goto erreg;
		430
		431	case tk_wordvar:
		432
		433	ClearVarByNum(&itok);
		434
		435	CheckAllMassiv(bufrm,i,&strinf);
		436
		437	outseg(&itok,3);
		438
		439	op(itok.rm+hstok.number*8);
		440
		441	break;
		442
		443	erreg:
		444
		445	else dwordvalexpected();
		446
		447	}
		448
		449	case tk_beg:
		450
		451	switch(tok){
		452
		453	outword(0xB00F);
		454
		455	break;
		456
		457	case tk_bytevar:
		458
		459	outseg(&itok,3);
		460
		461	op(itok.rm+hstok.number*8);
		462
		463	break;
		464
		465	break;
		466
		467	break;
		468
		469	case tk_bytevar:
		470
		471	ClearVarByNum(&hstok);
		472
		473	if(tok!=tk_beg)begexpected(2);
		474
		475	KillVar(hstok.name);
		476
		477	outword(0xB00F);
		478
		479	outaddress(&hstok);
		480
		481	case tk_longvar:
		482
		483	if(tok!=tk_reg32)reg32expected(2);
		484
		485	goto noint;
		486
		487	case tk_wordvar:
		488
		489	noint:
		490
		491	ClearVarByNum(&hstok);
		492
		493	CheckAllMassiv(hbuf,i,&hstr,&hstok);
		494
		495	op66(i);
		496
		497	outword(0xB10F);
		498
		499	outaddress(&hstok);
		500
		501	default:
		502
		503	break;
		504
		505	possiblecpu=4;
		506
		507	case a_cmpxchg8b: //CMPXCHG8B
		508
		509	if(tok!=tk_qwordvar)qwordvalexpected();
		510
		511	ClearVarByNum(&itok);
		512
		513	CheckAllMassiv(bufrm,8,&strinf);
		514
		515	outseg(&itok,3);
		516
		517	op(itok.rm+8);
		518
		519	possiblecpu=5;
		520
		521	case a_cwd:
		522
		523	op66(r16);
		524
		525	break;
		526
		527	ClearReg(AX);
		528
		529	op(0x98);
		530
		531	break;
		532
		533	ClearReg(AX);
		534
		535	ClearReg(CX);
		536
		537	outword(0xa20f); //CPUID
		538
		539	break;
		540
		541	ClearReg(AX);
		542
		543	break;
		544
		545	ClearReg(AX);
		546
		547	break;
		548
		549	dbgact++;
		550
		551	do{
		552
		553	nexttok();
		554
		555	if(tok==tk_number){
		556
		557	if(tok==tk_id&&strcmp((char *)string,"dup")==0){
		558
		559	nexttok();
		560
		561	if(tok==tk_number)hnumber=doconstdwordmath();
		562
		563	}
		564
		565	}
		566
		567	for(i=0;i<(unsigned int)itok.number;i++)opd(string[i]);
		568
		569	case zero_term:
		570
		571	opd(0);
		572
		573	case dos_term:
		574
		575	opd('$');
		576
		577	}
		578
		579	}
		580
		581	numexpected();
		582
		583	}
		584
		585	dbgact--;
		586
		587	break;
		588
		589	faradd++;
		590
		591	DDDW(faradd);
		592
		593	break;
		594
		595	ClearReg(BP);
		596
		597	nexttok();
		598
		599	else{
		600
		601	nexttok();
		602
		603	expecting2(tk_camma);
		604
		605	else{
		606
		607	nexttok();
		608
		609	next=0;
		610
		611	break;
		612
		613	outword(0x770f);
		614
		615	break;
		616
		617	nexttok();
		618
		619	ClearReg(AX);
		620
		621	case tk_reg32:
		622
		623	razr=r32;
		624
		625	ClearReg(DX);
		626
		627	op(246+1);
		628
		629	break;
		630
		631	op(246);
		632
		633	break;
		634
		635	case tk_bytevar:
		636
		637	outseg(&itok,2);
		638
		639	op(itok.rm+40);
		640
		641	break;
		642
		643	case tk_dwordvar:
		644
		645	possiblecpu=3;
		646
		647	case tk_intvar:
		648
		649	CheckAllMassiv(bufrm,2,&strinf);
		650
		651	op66(razr);
		652
		653	op(247);
		654
		655	outaddress(&itok);
		656
		657	default: varexpected(1); break;
		658
		659	}
		660
		661	htok=tok;
		662
		663	ClearReg(hnumber);
		664
		665	possiblecpu=2;
		666
		667	switch(tok){
		668
		669	switch(htok){
		670
		671	possiblecpu=3;
		672
		673	case tk_reg:
		674
		675	if(short_ok(itok.number,TRUE))i=2; //��⪠� �ଠ
		676
		677	op(0xc0+(unsigned int)hnumber+(unsigned int)hnumber*8);
		678
		679	else{
		680
		681	else outdword(itok.number);
		682
		683	break;
		684
		685	}
		686
		687	case tk_reg32:
		688
		689	case tk_reg:
		690
		691	possiblecpu=3;
		692
		693	outword(0xaf0f);
		694
		695	break;
		696
		697	tok++;
		698
		699	if(htok!=tk_reg32)reg32expected(1);
		700
		701	razr=r32;
		702
		703	case tk_intvar:
		704
		705	case tk_wordvar:
		706
		707	possiblecpu=3;
		708
		709	CheckAllMassiv(bufrm,2,&strinf);
		710
		711	outseg(&itok,3);
		712
		713	op(itok.rm+hnumber*8);
		714
		715	break;
		716
		717	}
		718
		719	else{
		720
		721	hstok=itok;
		722
		723	hstr=strinf;
		724
		725	bufrm=NULL;
		726
		727	if(tok!=tk_number)numexpected(3);
		728
		729	case tk_reg32:
		730
		731	razr=r32;
		732
		733	op66(razr);
		734
		735	if(short_ok(itok.number,TRUE))i=2; //��⪠� �ଠ
		736
		737	op(0xc0+(unsigned int)hstok.number+(unsigned int)hnumber*8);
		738
		739	else{
		740
		741	else outdword(itok.number);
		742
		743	break;
		744
		745	tok++;
		746
		747	possiblecpu=3;
		748
		749	CheckAllMassiv(hbuf,4,&hstr,&hstok);
		750
		751	goto imul2;
		752
		753	tok++;
		754
		755	imul2:
		756
		757	CheckAllMassiv(hbuf,2,&hstr,&hstok);
		758
		759	if(short_ok(itok.number,TRUE))i=2; //��⪠� �ଠ
		760
		761	op(0x69+i);
		762
		763	outaddress(&hstok);
		764
		765	else{
		766
		767	else outdword(itok.number);
		768
		769	break;
		770
		771	}
		772
		773	}
		774
		775	case a_in: //IN
		776
		777	nexttok();
		778
		779	op66(tok==tk_reg?r16:r32);
		780
		781	nexttok();
		782
		783	if(tok==tk_number){
		784
		785	asmparam=FALSE;
		786
		787	op(hnumber);
		788
		789	}
		790
		791	else bytedxexpected();
		792
		793	else if(tok==tk_beg&&(unsigned int)itok.number==AL){
		794
		795	expecting(tk_camma);
		796
		797	op(0xE4);
		798
		799	if((hnumber=doconstdwordmath())>255)bytedxexpected();
		800
		801	next=0;
		802
		803	else if(tok==tk_reg&&(unsigned int)itok.number==DX)op(0xEC);
		804
		805	}
		806
		807	break;
		808
		809	ClearReg(AX);
		810
		811	op(0x6C);
		812
		813	break;
		814
		815	op66(r16);
		816
		817	goto insd;
		818
		819	case a_insd: //INSD
		820
		821	possiblecpu=3;
		822
		823	op(0x6D);
		824
		825	ClearReg(DI);
		826
		827	case a_int: //INT
		828
		829	nexttok();
		830
		831	asmparam=FALSE;
		832
		833	if(htok==3)op(0xCC);
		834
		835	op(0xCD);
		836
		837	}
		838
		839	}
		840
		841	break;
		842
		843	op(0xCE); //INTO
		844
		845	case a_invd: //INVD
		846
		847	possiblecpu=4;
		848
		849	case a_invlpg: //INVLPG
		850
		851	switch(tok){
		852
		853	case tk_dwordvar:
		854
		855	goto invlgp;
		856
		857	case tk_wordvar:
		858
		859	invlgp:
		860
		861	outword(0x010F);
		862
		863	outaddress(&itok);
		864
		865
		866
		867	strcpy(hstok.name,itok.name);
		868
		869	case tk_number:
		870
		871	outword(0x010f);
		872
		873	if(postnumflag&f_reloc)AddReloc();
		874
		875	if(am32)outdword(hnumber);
		876
		877	next=0;
		878
		879	case tk_postnumber:
		880
		881	op((am32==FALSE?rm_d16:rm_d32)+0x38);
		882
		883	if(am32==FALSE)outword(itok.number); //�뫮 0
		884
		885	break;
		886
		887	default:
		888
		889	}
		890
		891	break;
		892
		893	#ifdef OPTVARCONST
		894
		895	#endif
		896
		897	clearregstat();
		898
		899	op(0xCF); //IRET
		900
		901	case a_iretd:
		902
		903	ClearLVIC();
		904
		905	RestoreStack();
		906
		907	op66(r32);
		908
		909	break;
		910
		911	case a_jno:
		912
		913	case a_jnc:
		914
		915	case a_jnz:
		916
		917	case a_ja:
		918
		919	case a_jns:
		920
		921	case a_jnp:
		922
		923	case a_jnl:
		924
		925	case a_jg:
		926
		927	asmshortjump((htok-a_jo)+0x70,(htok-a_jo)+0x80);
		928
		929	break;
		930
		931	RestoreStack();
		932
		933	asmshortjump(0xE3,0);
		934
		935	break;
		936
		937	RestoreStack();
		938
		939	asmshortjump(0xE3,0);
		940
		941	break;
		942
		943	RestoreStack();
		944
		945	faradd=0;
		946
		947	if(stricmp("FAR",itok.name)==0){
		948
		949	faradd=8;
		950
		951	else if(stricmp("NEAR",itok.name)==0)nexttok();
		952
		953	nexttok();
		954
		955	break;
		956
		957	next=gotol(faradd);
		958
		959	case a_lahf:
		960
		961	op(0x9F); //LAHF
		962
		963	case a_lar: //LAR
		964
		965	lar_lsl(htok-a_lar+2);
		966
		967	case a_leave: //LEAVE
		968
		969	op(0xC9);
		970
		971	possiblecpu = 2;
		972
		973	case a_lmsw:
		974
		975	break;
		976
		977	outword(0x050F);
		978
		979	break;
		980
		981	ClearReg(SI);
		982
		983	op(0xAC); //LODSB
		984
		985	case a_lodsw:
		986
		987	ClearReg(SI);
		988
		989	op(0xAD); //LODSW
		990
		991	case a_lodsd:
		992
		993	ClearReg(SI);
		994
		995	op(0xAD);
		996
		997	break;
		998
		999	op(0xF0); //LOCK
		1000
		1001	case a_loop:
		1002
		1003	op67(r16);
		1004
		1005	next=0;
		1006
		1007	case a_loopd:
		1008
		1009	possiblecpu=3;
		1010
		1011	asmshortjump(0xE2,0);
		1012
		1013	break;
		1014
		1015	ClearReg(CX);
		1016
		1017	next=0;
		1018
		1019	case a_loopnz: //LOOPNZ LOOPNE
		1020
		1021	asmshortjump(0xE0,0);
		1022
		1023	break;
		1024
		1025	protectinstr(0,0x18); //LTR
		1026
		1027	case a_str:
		1028
		1029	break;
		1030
		1031	next=tabldeckr(0x10);
		1032
		1033	case a_lidt: //LIDT
		1034
		1035	break;
		1036
		1037	protectinstr(0,0x10); //LLDT
		1038
		1039	case a_mov:
		1040
		1041	next=0;
		1042
		1043	case a_movsb:
		1044
		1045	break;
		1046
		1047	if(ScanTok3()==tk_camma&&(tok2==tk_xmmreg\|\|(tok2>=tk_charvar&&tok2
		1048
		1049	possiblecpu=9;
		1050
		1051	else movsd(); //MOVSD
		1052
		1053	case a_movsw:
		1054
		1055	break;
		1056
		1057	case a_movsx:
		1058
		1059	break;
		1060
		1061	movd(); //MOVD
		1062
		1063	case a_movq:
		1064
		1065	break;
		1066
		1067	op(0x90); //NOP
		1068
		1069	case a_opsiz: //OPSIZ OPSIZE
		1070
		1071	possiblecpu=3;
		1072
		1073	case a_out: //OUT
		1074
		1075	if(tok==tk_number){
		1076
		1077	expecting2(tk_camma);
		1078
		1079	op66(tok==tk_reg?r16:r32);
		1080
		1081	op(0xE7); op(hnumber);
		1082
		1083	else if(tok==tk_beg&&(unsigned int)itok.number==AL){
		1084
		1085	}
		1086
		1087	}
		1088
		1089	nextexpecting2(tk_camma);
		1090
		1091	op66(tok==tk_reg?r16:r32);
		1092
		1093	op(0xEF);
		1094
		1095	else if(tok==tk_beg&&(unsigned int)itok.number==AL)op(0xEE);
		1096
		1097	}
		1098
		1099	break;
		1100
		1101	ClearReg(SI);
		1102
		1103	possiblecpu=2;
		1104
		1105	case a_outsw: //OUTSW
		1106
		1107	op66(r16);
		1108
		1109	possiblecpu=2;
		1110
		1111	case a_outsd: //OUTSD
		1112
		1113	op66(r32);
		1114
		1115	possiblecpu=3;
		1116
		1117	case a_pop: //POP
		1118
		1119	do{
		1120
		1121	asmparam=TRUE;
		1122
		1123	razr=r16;
		1124
		1125	case tk_reg32:
		1126
		1127	razr=r32;
		1128
		1129	ClearReg(itok.number);
		1130
		1131	op(0x58+(unsigned int)itok.number); break;
		1132
		1133	tok--;
		1134
		1135	CheckAllMassiv(bufrm,4,&strinf);
		1136
		1137	razr=r32;
		1138
		1139	case tk_wordvar:
		1140
		1141	case tk_intvar:
		1142
		1143	pop:
		1144
		1145	ClearVarByNum(&itok);
		1146
		1147	KillVar(itok.name);
		1148
		1149	outseg(&itok,2);
		1150
		1151	outaddress(&itok);
		1152
		1153	case tk_seg:
		1154
		1155	PopSeg((unsigned int)itok.number);
		1156
		1157	}
		1158
		1159	preerror("Invalid operand for POP");
		1160
		1161	}
		1162
		1163	asmparam=FALSE;
		1164
		1165	nexttok();
		1166
		1167	next=0;
		1168
		1169	case a_popa: //POPA
		1170
		1171	possiblecpu=2;
		1172
		1173	case a_popad: //POPAD
		1174
		1175	possiblecpu=3;
		1176
		1177	op66(razr);
		1178
		1179	RestoreStack();
		1180
		1181	op(0x61);
		1182
		1183	case a_popf:
		1184
		1185	goto POPFD;
		1186
		1187	razr=r32;
		1188
		1189	POPFD:
		1190
		1191	addESP-=razr==r16?2:4;
		1192
		1193	op(0x9D);
		1194
		1195	case a_push: //PUSH
		1196
		1197	do{
		1198
		1199	nexttok();
		1200
		1201	asmparam=FALSE;
		1202
		1203	}while(tok==tk_camma);
		1204
		1205	break;
		1206
		1207	razr=r16;
		1208
		1209	goto PUSHAD;
		1210
		1211	razr=r32;
		1212
		1213	PUSHAD:
		1214
		1215	addESP+=razr==r16?16:32;
		1216
		1217	op(0x60);
		1218
		1219	case a_pushf:
		1220
		1221	goto PUSHFD;
		1222
		1223	razr=r32;
		1224
		1225	PUSHFD:
		1226
		1227	RestoreStack();
		1228
		1229	addESP+=razr==r16?2:4;
		1230
		1231	case a_pcmpeqd:
		1232
		1233	case a_pcmpeqb:
		1234
		1235	case a_punpckhdq:
		1236
		1237	case a_punpckhbw:
		1238
		1239	case a_pcmpgtd:
		1240
		1241	case a_pcmpgtb:
		1242
		1243	case a_punpckldq:
		1244
		1245	case a_punpcklbw:
		1246
		1247	break;
		1248
		1249	mmxiii(0xD5); //PMULLW
		1250
		1251	case a_pmuludq:
		1252
		1253	break;
		1254
		1255	mmxiii(0xD8); //PSUBUSB
		1256
		1257	case a_psubusw:
		1258
		1259	break;
		1260
		1261	mmxiii(0xDB); //PAND
		1262
		1263	case a_paddusb: //+xmm
		1264
		1265	break;
		1266
		1267	mmxiii(0xDD);//PADDUSW
		1268
		1269	case a_pandn: //+xmm
		1270
		1271	break;
		1272
		1273	outword(0x90F3);
		1274
		1275	break;
		1276
		1277	mmxiii(0xE5); //PMULHW
		1278
		1279	case a_psubsb:
		1280
		1281	break;
		1282
		1283	mmxiii(0xE9);//PSUBSW
		1284
		1285	case a_por:
		1286
		1287	break;
		1288
		1289	mmxiii(0xEC); //PADDSB
		1290
		1291	case a_paddsw: //+xmm
		1292
		1293	break;
		1294
		1295	mmxiii(0xEF); //PXOR
		1296
		1297	case a_pmaddwd:
		1298
		1299	break;
		1300
		1301	mmxiii(0xF8); //PSUBB
		1302
		1303	case a_psubw:
		1304
		1305	break;
		1306
		1307	mmxiii(0xFA);//PSUBD
		1308
		1309	case a_psubq:
		1310
		1311	possiblecpu=9;
		1312
		1313	case a_paddb: //+xmm
		1314
		1315	break;
		1316
		1317	mmxiii(0xFD);//PADDW
		1318
		1319	case a_paddd: //+xmm
		1320
		1321	break;
		1322
		1323	mmxiii(0xD4);//PADDQ
		1324
		1325	break;
		1326
		1327	case a_psrlw:
		1328
		1329	next=0;
		1330
		1331	case a_psrld:
		1332
		1333	next=0;
		1334
		1335	case a_psrlq:
		1336
		1337	next=0;
		1338
		1339	case a_psraw:
		1340
		1341	next=0;
		1342
		1343	case a_psrad:
		1344
		1345	next=0;
		1346
		1347	case a_psllw:
		1348
		1349	next=0;
		1350
		1351	case a_pslld:
		1352
		1353	next=0;
		1354
		1355	case a_psllq:
		1356
		1357	next=0;
		1358
		1359	case a_pslldq:
		1360
		1361	next=0;
		1362
		1363	break;
		1364
		1365	shiftxmm(3);
		1366
		1367	possiblecpu=9;
		1368
		1369	case a_rdmsr:
		1370
		1371	ClearReg(DX);
		1372
		1373	possiblecpu=5;
		1374
		1375	case a_rdtsc:
		1376
		1377	possiblecpu=5;
		1378
		1379	case a_rep:
		1380
		1381	ClearReg(CX);
		1382
		1383	case a_repnz:
		1384
		1385	ClearReg(CX);
		1386
		1387	case a_ret: //RET
		1388
		1389	ClearLVIC();
		1390
		1391	RestoreStack();
		1392
		1393	next=0;
		1394
		1395	// usedirectiv=TRUE;
		1396
		1397	op(0xC2);
		1398
		1399	outword((unsigned int)doconstlongmath());
		1400
		1401	}
		1402
		1403	op(0xC3);
		1404
		1405	}
		1406
		1407	case a_retf:
		1408
		1409	ClearLVIC();
		1410
		1411	RestoreStack();
		1412
		1413	next=0;
		1414
		1415	nexttok();
		1416
		1417	asmparam=FALSE;
		1418
		1419	}
		1420
		1421	op(0xCB);
		1422
		1423	}//RETF
		1424
		1425	case a_rsm: //RSM
		1426
		1427	possiblecpu=5;
		1428
		1429	case a_sahf:
		1430
		1431	break;
		1432
		1433	op(0xAE); //SCASB
		1434
		1435	break;
		1436
		1437	op66(r16);
		1438
		1439	ClearReg(DI);
		1440
		1441	case a_scasd: //SCASD
		1442
		1443	op(0xAF);
		1444
		1445	ClearReg(DI);
		1446
		1447	case a_smsw:
		1448
		1449	break;
		1450
		1451	op(0xF9); //STC
		1452
		1453	case a_std:
		1454
		1455	break;
		1456
		1457	op(0xFB); //STI
		1458
		1459	case a_stosb:
		1460
		1461	break;
		1462
		1463	stosw(); //STOSW
		1464
		1465	case a_stosd:
		1466
		1467	break;
		1468
		1469	case a_setno:
		1470
		1471	case a_setnc:
		1472
		1473	case a_setnz:
		1474
		1475	case a_seta:
		1476
		1477	case a_setns:
		1478
		1479	case a_setnp:
		1480
		1481	case a_setnl:
		1482
		1483	case a_setg:
		1484
		1485	nexttok();
		1486
		1487	case tk_beg:
		1488
		1489	op(0xf);
		1490
		1491	op(0xc0+(unsigned int)itok.number);
		1492
		1493	case tk_charvar:
		1494
		1495	CheckAllMassiv(bufrm,1,&strinf);
		1496
		1497	outseg(&itok,3);
		1498
		1499	op(0x90+i);
		1500
		1501	outaddress(&itok);
		1502
		1503	default: bytevalexpected(0);
		1504
		1505	possiblecpu=3;
		1506
		1507	case a_sgdt:
		1508
		1509	break;
		1510
		1511	next=tabldeckr(0x8);
		1512
		1513	case a_sldt:
		1514
		1515	break;
		1516
		1517	case a_wait:
		1518
		1519	break;
		1520
		1521	outword(0x090F);
		1522
		1523	break;
		1524
		1525	outword(0x300F);
		1526
		1527	break;
		1528
		1529	nexttok();
		1530
		1531	htok=tok;
		1532
		1533	bufrm=NULL;
		1534
		1535	strinf.bufstr=NULL;
		1536
		1537	switch(htok){
		1538
		1539	razr=r32;
		1540
		1541	switch(tok){
		1542
		1543	if(razr==r16)goto erxreg;
		1544
		1545	RegToReg(itok.number,hstok.number,razr);
		1546
		1547	op66(razr);
		1548
		1549	op(128+64+(unsigned int)itok.number*8+hstok.number);
		1550
		1551	case tk_longvar:
		1552
		1553	if(razr==r16)goto erxreg;
		1554
		1555	case tk_wordvar:
		1556
		1557	/if(bufrm==0&&strinf.bufstr==NULL)/AddRegVar(hstok.number,razr,&itok);
		1558
		1559	op66(razr);
		1560
		1561	outword(0xC10F);
		1562
		1563	outaddress(&itok);
		1564
		1565	default:
		1566
		1567	wordvalexpected(); break;
		1568
		1569	break;
		1570
		1571	switch(tok){
		1572
		1573	RegToReg(itok.number,hstok.number,r8);
		1574
		1575	outword(0xC00F);
		1576
		1577	break;
		1578
		1579	case tk_bytevar:
		1580
		1581	/if(bufrm==0&&strinf.bufstr==NULL)/AddRegVar(hstok.number,r8,&itok);
		1582
		1583	outseg(&itok,3);
		1584
		1585	op(itok.rm+hstok.number*8);
		1586
		1587	break;
		1588
		1589	}
		1590
		1591	case tk_charvar:
		1592
		1593	if(tok!=tk_beg)begexpected(2);
		1594
		1595	ClearReg(itok.number);
		1596
		1597	outseg(&hstok,3);
		1598
		1599	op(hstok.rm+(unsigned int)itok.number*8);
		1600
		1601	break;
		1602
		1603	case tk_dwordvar:
		1604
		1605	razr=r32;
		1606
		1607	case tk_intvar:
		1608
		1609	if(tok!=tk_reg)regexpected(1);
		1610
		1611	CheckAllMassiv(hbuf,razr,&hstr,&hstok);
		1612
		1613	KillVar(hstok.name);
		1614
		1615	outseg(&hstok,3);
		1616
		1617	op(hstok.rm+(unsigned int)itok.number*8);
		1618
		1619	break;
		1620
		1621	}
		1622
		1623	break;
		1624
		1625	nexttok();
		1626
		1627	hstok=itok;
		1628
		1629	bufrm=NULL;
		1630
		1631	strinf.bufstr=NULL;
		1632
		1633	switch(htok){
		1634
		1635	razr=r32;
		1636
		1637	case tk_reg:
		1638
		1639	case tk_reg32:
		1640
		1641	case tk_reg:
		1642
		1643	RegSwapReg(hstok.number,itok.number,razr);
		1644
		1645	else if((unsigned int)itok.number==AX)op(0x90+hstok.number);
		1646
		1647	op(0x87);
		1648
		1649	}
		1650
		1651	case tk_longvar:
		1652
		1653	if(razr==r16)goto erregx;
		1654
		1655	case tk_wordvar:
		1656
		1657	KillVar(itok.name);
		1658
		1659	op66(razr);
		1660
		1661	op(0x87);
		1662
		1663	outaddress(&itok);
		1664
		1665	default:
		1666
		1667	wordvalexpected(); break;
		1668
		1669	break;
		1670
		1671	switch(tok){
		1672
		1673	RegSwapReg(hstok.number,itok.number,r8);
		1674
		1675	op(128+64+(unsigned int)itok.number*8+hstok.number);
		1676
		1677	case tk_charvar:
		1678
		1679	CheckAllMassiv(bufrm,1,&strinf);
		1680
		1681	IDZToReg(itok.name,hstok.number,r8);
		1682
		1683	op(0x86);
		1684
		1685	outaddress(&itok);
		1686
		1687	default: bytevalexpected(2); break;
		1688
		1689	break;
		1690
		1691	case tk_bytevar:
		1692
		1693	CheckAllMassiv(hbuf,1,&hstr,&hstok);
		1694
		1695	IDZToReg(hstok.name,itok.number,r8);
		1696
		1697	op(0x86);
		1698
		1699	outaddress(&hstok);
		1700
		1701	case tk_longvar:
		1702
		1703	razr=r32;
		1704
		1705	if(tok!=tk_reg32)reg32expected(2);
		1706
		1707	case tk_intvar:
		1708
		1709	if(tok!=tk_reg)regexpected(2);
		1710
		1711	CheckAllMassiv(hbuf,razr,&hstr,&hstok);
		1712
		1713	IDZToReg(hstok.name,itok.number,razr);
		1714
		1715	outseg(&hstok,2);
		1716
		1717	op(hstok.rm+(unsigned int)itok.number*8);
		1718
		1719	break;
		1720
		1721	}
		1722
		1723	case a_xlat:
		1724
		1725	op(0xD7); //XLAT
		1726
		1727	case a_hlt:
		1728
		1729
		1730
		1731	protectinstr(0,0x20); //VERR
		1732
		1733	case a_verw:
		1734
		1735	break;
		1736
		1737	if(iTest()==FALSE)invalidoperand(0);
		1738
		1739	break;
		1740
		1741	FpuType1(0x10);
		1742
		1743	case a_fcomp: //FCOMP
		1744
		1745	break;
		1746
		1747	FpuType2(0,0);
		1748
		1749	case a_fdiv: //FDIV
		1750
		1751	break;
		1752
		1753	FpuType2(0x30,0x38);
		1754
		1755	case a_fmul: //FMUL
		1756
		1757	break;
		1758
		1759	FpuType2(0x28,0x20);
		1760
		1761	case a_fsubr: //FSUBR
		1762
		1763	break;
		1764
		1765	FpuType3(0xDE,0);
		1766
		1767	case a_fdivp: //FDIVP
		1768
		1769	break;
		1770
		1771
		1772
		1773	case a_ffree: //FFREE
		1774
		1775	break;
		1776
		1777	FpuType3(0xDE,8);
		1778
		1779	case a_fsubp: //FSUBP
		1780
		1781	break;
		1782
		1783	FpuType3(0xDE,0x20);
		1784
		1785	case a_fucom: //FUCOM
		1786
		1787	break;
		1788
		1789	FpuType3(0xDD,0x28);
		1790
		1791	case a_fxch: //FXCH
		1792
		1793	break;
		1794
		1795	case a_fiadd: //FIADD
		1796
		1797	break;
		1798
		1799	FpuType4(0,0x10);
		1800
		1801	case a_ficomp: //FICOMP
		1802
		1803	break;
		1804
		1805	FpuType4(0,0x30);
		1806
		1807	case a_fidivr: //FIDIVR
		1808
		1809	break;
		1810
		1811	FpuType4(1,0);
		1812
		1813	case a_fimul: //FIMUL
		1814
		1815	break;
		1816
		1817	FpuType4(1,0x10);
		1818
		1819	case a_fistp: //FISTP
		1820
		1821	break;
		1822
		1823	FpuType4(0,0x20);
		1824
		1825	case a_fisubr: //FISUBR
		1826
		1827	break;
		1828
		1829	case a_fld: //FLD
		1830
		1831	break;
		1832
		1833	FpuType5(0xDD,0x10);
		1834
		1835	case a_fstp: //FSTP
		1836
		1837	break;
		1838
		1839	case a_fbld: //FBLD
		1840
		1841	break;
		1842
		1843	FpuType6(0xDF,0X30);
		1844
		1845	case a_fildq: //FILDQ
		1846
		1847	break;
		1848
		1849	FpuType6(0xD9,0x20);
		1850
		1851	case a_frstor: //FRSTOR ��
		1852
		1853	break;
		1854
		1855	fwait();
		1856
		1857	FpuType6(0xDD,0x30);
		1858
		1859	case a_fstenv: //FSTENV ��
		1860
		1861	case a_fnstenv: //FNSTENV ��
		1862
		1863	break;
		1864
		1865	case a_fldcw: //FLDCW
		1866
		1867	break;
		1868
		1869	fwait();
		1870
		1871	FpuType7(0x38);
		1872
		1873
		1874
		1875	outword(0xf0d9); //F2XM1
		1876
		1877	break;
		1878
		1879	outword(0xE1D9); //FABS
		1880
		1881	case a_fchs:
		1882
		1883	break;
		1884
		1885	fwait();
		1886
		1887	// break;
		1888
		1889	outword(0xE2DB); //FNCLEX
		1890
		1891	case a_fcompp:
		1892
		1893	break;
		1894
		1895	outword(0xFFD9);
		1896
		1897	break;
		1898
		1899	outword(0xF6D9); //FDECSTP
		1900
		1901	case a_fdisi:
		1902
		1903	case a_fndisi:
		1904
		1905	break;
		1906
		1907	fwait();
		1908
		1909	outword(0xE0DB); //FENI
		1910
		1911	case a_fincstr:
		1912
		1913	break;
		1914
		1915	fwait();
		1916
		1917	outword(0xE3DB); //FNINIT
		1918
		1919	case a_fldlg2:
		1920
		1921	break;
		1922
		1923	outword(0xEDD9); //FLDLN2
		1924
		1925	case a_fldl2e:
		1926
		1927	break;
		1928
		1929	outword(0xE9D9); //FLDL2T
		1930
		1931	case a_fldpi:
		1932
		1933	break;
		1934
		1935	outword(0xEED9); //FLDZ
		1936
		1937	case a_fld1:
		1938
		1939	break;
		1940
		1941	outword(0xD0D9); //FNOP
		1942
		1943	case a_fpatan:
		1944
		1945	break;
		1946
		1947	outword(0xF8D9); //FPREM
		1948
		1949	case a_fprem1:
		1950
		1951	possiblecpu=3;
		1952
		1953	case a_fptan:
		1954
		1955	break;
		1956
		1957	outword(0xFCD9); //FRNDINT
		1958
		1959	case a_fsetpm:
		1960
		1961	case a_fnsetpm:
		1962
		1963	possiblecpu=2;
		1964
		1965	case a_fscale:
		1966
		1967	break;
		1968
		1969	outword(0xFED9);
		1970
		1971	break;
		1972
		1973	outword(0xFBD9);
		1974
		1975	break;
		1976
		1977	outword(0xFAD9); //FSQRT
		1978
		1979	case a_fstsw: //FSTSW
		1980
		1981	case a_fnstsw: //FNSTSW
		1982
		1983	switch(tok){
		1984
		1985	case tk_intvar:
		1986
		1987	KillVar(itok.name);
		1988
		1989	op(0xDD);
		1990
		1991	outaddress(&itok);
		1992
		1993	case tk_reg:
		1994
		1995	else preerror("Use only AX");
		1996
		1997	break;
		1998
		1999	}
		2000
		2001	case a_ftst:
		2002
		2003	break;
		2004
		2005	outword(0xE9DA);
		2006
		2007	break;
		2008
		2009	outword(0xE5D9); //FXAM
		2010
		2011	case a_fxtract:
		2012
		2013	break;
		2014
		2015	outword(0xF1D9); //FYL2X
		2016
		2017	case a_fyl2xp1:
		2018
		2019	break;
		2020
		2021	outword(0x0B0F); //UD2
		2022
		2023	break;
		2024
		2025	outword(0x340F); //SYSENTER
		2026
		2027	break;
		2028
		2029	outword(0x350F); //SYSEXIT
		2030
		2031	break;
		2032
		2033	outword(0x330F); //RDPMC
		2034
		2035	break;
		2036
		2037	i+=8;
		2038
		2039	i+=8;
		2040
		2041	i+=8;
		2042
		2043	FpuType8(0xDB,i);
		2044
		2045	case a_fcmovu:
		2046
		2047	case a_fcmovbe:
		2048
		2049	case a_fcmove:
		2050
		2051	case a_fcmovb:
		2052
		2053	break;
		2054
		2055	i+=8;
		2056
		2057	FpuType8(0xDB,i+0x28);
		2058
		2059	case a_fcomip:
		2060
		2061	case a_fucomip:
		2062
		2063	break;
		2064
		2065	case a_cmovno:
		2066
		2067	case a_cmovnc:
		2068
		2069	case a_cmovnz:
		2070
		2071	case a_cmova:
		2072
		2073	case a_cmovns:
		2074
		2075	case a_cmovnp:
		2076
		2077	case a_cmovnl:
		2078
		2079	case a_cmovg:
		2080
		2081	possiblecpu=7;
		2082
		2083	case a_lfence: //LFENCE
		2084
		2085	op(0xE8);
		2086
		2087	break;
		2088
		2089	outword(0xAE0F);
		2090
		2091	possiblecpu=9;
		2092
		2093	case a_sfence: //SFENCE
		2094
		2095	op(0xF8);
		2096
		2097	break;
		2098
		2099	nexttok();
		2100
		2101	if(tok!=tk_mmxreg)mmxregexpected(1);
		2102
		2103	if(tok!=tk_mmxreg)mmxregexpected(2);
		2104
		2105	op(0xC0+hnumber+itok.number*8);
		2106
		2107	break;
		2108
		2109	movxmm3(0xE7,0,tk_mmxreg);
		2110
		2111	break;
		2112
		2113	mmxiii(0xE0);
		2114
		2115	case a_pavgw:
		2116
		2117	break;
		2118
		2119	mmxiii(0xDE);
		2120
		2121	case a_pmaxsw:
		2122
		2123	break;
		2124
		2125	mmxiii(0xDA);
		2126
		2127	case a_pminsw:
		2128
		2129	break;
		2130
		2131	mmxiii(0xE4);
		2132
		2133	case a_psadbw:
		2134
		2135	break;
		2136
		2137	prefetch(0x18,1);
		2138
		2139	break;
		2140
		2141	prefetch(0x18,2);
		2142
		2143	break;
		2144
		2145	prefetch(0x18,3);
		2146
		2147	break;
		2148
		2149	prefetch(0x18,0);
		2150
		2151	break;
		2152
		2153	pextrw();
		2154
		2155	break;
		2156
		2157	pinsrw();
		2158
		2159	break;
		2160
		2161	nexttok();
		2162
		2163	htok=itok.number;
		2164
		2165	nextexpecting2(tk_camma);
		2166
		2167	op(0x66);
		2168
		2169	}
		2170
		2171	possiblecpu=8;
		2172
		2173	}
		2174
		2175	op(rm_mod11+htok*8+itok.number);
		2176
		2177	case a_pshufw:
		2178
		2179	next=0;
		2180
		2181	break;
		2182
		2183	xmm3instr(0x70,0x66);
		2184
		2185	next=0;
		2186
		2187	case a_pshufhw:
		2188
		2189	possiblecpu=9;
		2190
		2191	break;
		2192
		2193	xmm3instr(0x70,0xf2);
		2194
		2195	next=0;
		2196
		2197	case a_addpd:
		2198
		2199	possiblecpu=9;
		2200
		2201	case a_addps:
		2202
		2203	possiblecpu=8;
		2204
		2205	case a_addsd:
		2206
		2207	possiblecpu=9;
		2208
		2209	case a_addss:
		2210
		2211	possiblecpu=8;
		2212
		2213	case a_addsubpd:
		2214
		2215	possiblecpu=9;
		2216
		2217	case a_addsubps:
		2218
		2219	possiblecpu=9;
		2220
		2221	case a_andnpd:
		2222
		2223	possiblecpu=9;
		2224
		2225	case a_andnps:
		2226
		2227	possiblecpu=8;
		2228
		2229	case a_andpd:
		2230
		2231	possiblecpu=9;
		2232
		2233	case a_andps:
		2234
		2235	possiblecpu=8;
		2236
		2237	case a_comisd:
		2238
		2239	possiblecpu=9;
		2240
		2241	case a_comiss:
		2242
		2243	possiblecpu=8;
		2244
		2245	case a_divps:
		2246
		2247	possiblecpu=8;
		2248
		2249	case a_divsd:
		2250
		2251	possiblecpu=9;
		2252
		2253	case a_divss:
		2254
		2255	possiblecpu=8;
		2256
		2257	case a_haddpd:
		2258
		2259	possiblecpu=9;
		2260
		2261	case a_haddps:
		2262
		2263	possiblecpu=9;
		2264
		2265	case a_hsubpd:
		2266
		2267	possiblecpu=9;
		2268
		2269	case a_hsubps:
		2270
		2271	possiblecpu=9;
		2272
		2273	case a_maskmovdqu:
		2274
		2275	possiblecpu=9;
		2276
		2277	case a_maxpd:
		2278
		2279	possiblecpu=9;
		2280
		2281	case a_maxps:
		2282
		2283	possiblecpu=8;
		2284
		2285	case a_maxsd:
		2286
		2287	possiblecpu=9;
		2288
		2289	case a_maxss:
		2290
		2291	possiblecpu=8;
		2292
		2293	case a_minpd:
		2294
		2295	possiblecpu=9;
		2296
		2297	case a_minps:
		2298
		2299	possiblecpu=8;
		2300
		2301	case a_minsd:
		2302
		2303	possiblecpu=9;
		2304
		2305	case a_minss:
		2306
		2307	possiblecpu=8;
		2308
		2309	case a_mulpd:
		2310
		2311	possiblecpu=9;
		2312
		2313	case a_mulps:
		2314
		2315	possiblecpu=8;
		2316
		2317	case a_mulsd:
		2318
		2319	possiblecpu=9;
		2320
		2321	case a_mulss:
		2322
		2323	possiblecpu=8;
		2324
		2325	case a_orpd:
		2326
		2327	possiblecpu=9;
		2328
		2329	case a_orps:
		2330
		2331	possiblecpu=8;
		2332
		2333	case a_rcpps:
		2334
		2335	possiblecpu=8;
		2336
		2337	case a_rcpss:
		2338
		2339	possiblecpu=8;
		2340
		2341	case a_rsqrtps:
		2342
		2343	possiblecpu=8;
		2344
		2345	case a_rsqrtss:
		2346
		2347	possiblecpu=8;
		2348
		2349	case a_sqrtpd:
		2350
		2351	possiblecpu=9;
		2352
		2353	case a_sqrtps:
		2354
		2355	possiblecpu=8;
		2356
		2357	case a_sqrtsd:
		2358
		2359	possiblecpu=9;
		2360
		2361	case a_sqrtss:
		2362
		2363	possiblecpu=8;
		2364
		2365	case a_subpd:
		2366
		2367	possiblecpu=9;
		2368
		2369	case a_subps:
		2370
		2371	possiblecpu=8;
		2372
		2373	case a_subsd:
		2374
		2375	possiblecpu=9;
		2376
		2377	case a_subss:
		2378
		2379	possiblecpu=8;
		2380
		2381	case a_ucomisd:
		2382
		2383	possiblecpu=9;
		2384
		2385	case a_ucomiss:
		2386
		2387	possiblecpu=8;
		2388
		2389	case a_unpckhpd:
		2390
		2391	possiblecpu=9;
		2392
		2393	case a_unpckhps:
		2394
		2395	possiblecpu=8;
		2396
		2397	case a_unpcklpd:
		2398
		2399	possiblecpu=9;
		2400
		2401	case a_unpcklps:
		2402
		2403	possiblecpu=8;
		2404
		2405	case a_xorpd:
		2406
		2407	possiblecpu=9;
		2408
		2409	case a_xorps:
		2410
		2411	possiblecpu=8;
		2412
		2413	case a_cmppd:
		2414
		2415	possiblecpu=9;
		2416
		2417	break;
		2418
		2419	case a_cmpltpd:
		2420
		2421	case a_cmpunordpd:
		2422
		2423	case a_cmpnltpd:
		2424
		2425	case a_cmpordpd:
		2426
		2427	possiblecpu=9;
		2428
		2429	break;
		2430
		2431	xmm3instr(0xC2,0);
		2432
		2433	next=0;
		2434
		2435	case a_cmpeqps:
		2436
		2437	case a_cmpleps:
		2438
		2439	case a_cmpneqps:
		2440
		2441	case a_cmpnleps:
		2442
		2443	xmminstr(0xC2,0);
		2444
		2445	op(htok-a_cmpeqps);
		2446
		2447	case a_cmpss:
		2448
		2449	possiblecpu=8;
		2450
		2451	break;
		2452
		2453	case a_cmpltss:
		2454
		2455	case a_cmpunordss:
		2456
		2457	case a_cmpnltss:
		2458
		2459	case a_cmpordss:
		2460
		2461	possiblecpu=9;
		2462
		2463	break;
		2464
		2465	case a_cmpltsd:
		2466
		2467	case a_cmpunordsd:
		2468
		2469	case a_cmpnltsd:
		2470
		2471	case a_cmpordsd:
		2472
		2473	op(htok-a_cmpeqsd);
		2474
		2475	break;
		2476
		2477	xmm3instr(0xC6,0x66);
		2478
		2479	next=0;
		2480
		2481	case a_shufps:
		2482
		2483	possiblecpu=8;
		2484
		2485	break;
		2486
		2487	xmminstr(0xE6,0xF3);
		2488
		2489	break;
		2490
		2491	xmminstr(0x5B,0);
		2492
		2493	break;
		2494
		2495	xmminstr(0xE6,0xF2);
		2496
		2497	break;
		2498
		2499	xmminstr(0x2d,0x66,tk_mmxreg,tk_xmmreg);
		2500
		2501	break;
		2502
		2503	xmminstr(0x5a,0x66);
		2504
		2505	break;
		2506
		2507	xmminstr(0x2a,0x66,tk_xmmreg,tk_mmxreg);
		2508
		2509	break;
		2510
		2511	xmminstr(0x2a,0,tk_xmmreg,tk_mmxreg);
		2512
		2513	break;
		2514
		2515	xmminstr(0x5b,0x66);
		2516
		2517	break;
		2518
		2519	xmminstr(0x5a,0);
		2520
		2521	break;
		2522
		2523	xmminstr(0x2a,0xf3,tk_xmmreg,tk_reg32);
		2524
		2525	break;
		2526
		2527	xmminstr(0x2d,0,tk_mmxreg,tk_xmmreg);
		2528
		2529	break;
		2530
		2531	xmminstr(0x2d,0xf2,tk_reg32,tk_xmmreg);
		2532
		2533	break;
		2534
		2535	xmminstr(0x5a,0xf2);
		2536
		2537	break;
		2538
		2539	xmminstr(0x2a,0xf2,tk_xmmreg,tk_reg32);
		2540
		2541	break;
		2542
		2543	xmminstr(0x5a,0xf3);
		2544
		2545	break;
		2546
		2547	xmminstr(0x2d,0xf3,tk_reg32,tk_xmmreg);
		2548
		2549	break;
		2550
		2551	xmminstr(0x2c,0x66,tk_mmxreg,tk_xmmreg);
		2552
		2553	break;
		2554
		2555	xmminstr(0xE6,0x66);
		2556
		2557	break;
		2558
		2559	xmminstr(0x5B,0xF3);
		2560
		2561	break;
		2562
		2563	xmminstr(0x2c,0,tk_mmxreg,tk_xmmreg);
		2564
		2565	break;
		2566
		2567	xmminstr(0x2C,0xF2,tk_reg32,tk_xmmreg);
		2568
		2569	break;
		2570
		2571	xmminstr(0x2C,0xF3,tk_reg32,tk_xmmreg);
		2572
		2573	break;
		2574
		2575	xmminstr(0x5E,0x66);
		2576
		2577	break;
		2578
		2579	xmminstr(0x6D,0x66);
		2580
		2581	break;
		2582
		2583	xmminstr(0x6C,0x66);
		2584
		2585	break;
		2586
		2587	prefetch(0xAE,1);
		2588
		2589	break;
		2590
		2591	prefetch(0xAE,0);
		2592
		2593	break;
		2594
		2595	prefetch(0xAE,2);
		2596
		2597	break;
		2598
		2599	prefetch(0xAE,3);
		2600
		2601	break;
		2602
		2603	prefetch(0xAE,7);
		2604
		2605	break;
		2606
		2607	outword(0x010F);
		2608
		2609	possiblecpu=9;
		2610
		2611	case a_mwait:
		2612
		2613	op(0xc9);
		2614
		2615	break;
		2616
		2617	movxmm4(0xF0,0xF2);
		2618
		2619	break;
		2620
		2621	xmm2xmm(0x12);
		2622
		2623	break;
		2624
		2625	xmm2xmm(0x16);
		2626
		2627	break;
		2628
		2629	xmm2xmm(0x50,0,tk_reg32);
		2630
		2631	break;
		2632
		2633	movxmm3(0xE7,0x66);
		2634
		2635	break;
		2636
		2637	movxmm3(0x2B,0x66);
		2638
		2639	break;
		2640
		2641	movxmm3(0x2b,0);
		2642
		2643	break;
		2644
		2645	movxmm(0x28,0x66);
		2646
		2647	break;
		2648
		2649	movxmm(0x28,0);
		2650
		2651
		2652
		2653	movxmm(0x6f,0x66,0x10);
		2654
		2655	break;
		2656
		2657	xmminstr(0x12,0xF2);
		2658
		2659	break;
		2660
		2661	xmminstr(0x16,0xF3);
		2662
		2663	break;
		2664
		2665	xmminstr(0x12,0xF3);
		2666
		2667	break;
		2668
		2669	movxmm(0x6f,0xf3,0x10);
		2670
		2671	break;
		2672
		2673	xmm2xmm(0xd6,0xf2,tk_mmxreg);
		2674
		2675	break;
		2676
		2677	movxmm2(0x16,0x66);
		2678
		2679	break;
		2680
		2681	movxmm2(0x12,0x66);
		2682
		2683	break;
		2684
		2685	xmm2xmm(0x50,0x66,tk_reg32);
		2686
		2687	break;
		2688
		2689	movxmm3(0xC3,0,tk_reg32);
		2690
		2691	break;
		2692
		2693	nexttok();
		2694
		2695	if(tok!=tk_xmmreg)xmmregexpected(1);
		2696
		2697	if(tok!=tk_mmxreg)mmxregexpected(2);
		2698
		2699	outword(0xD60F);
		2700
		2701	possiblecpu=9;
		2702
		2703	case a_movupd:
		2704
		2705	possiblecpu=9;
		2706
		2707	case a_movups:
		2708
		2709	possiblecpu=8;
		2710
		2711	case a_movss:
		2712
		2713	possiblecpu=8;
		2714
		2715	case a_movhps:
		2716
		2717	possiblecpu=8;
		2718
		2719	case a_movlps:
		2720
		2721	possiblecpu=8;
		2722
		2723
		2724
		2725	default:
		2726
		2727	break;
		2728
		2729	asmparam=FALSE;
		2730
		2731	if(next)nexttok();
		2732
		2733	else if(tok==tk_seg){
		2734
		2735	case ES: op(0x26); break;
		2736
		2737	case CS: op(0x2E); break;
		2738
		2739	case FS: op(0x64);
		2740
		2741	break;
		2742
		2743	if(cpu<3)cpu=3;
		2744
		2745	default: beep(); break;
		2746
		2747	nextexpecting2(tk_colon);
		2748
		2749	else if(tok==tk_locallabel)define_locallabel();
		2750
		2751	nexttok();
		2752
		2753	}
		2754
		2755	if(tok==tk_semicolon)nexttok();
		2756
		2757
		2758
		2759	{
		2760
		2761	int reg;
		2762
		2763	if(tok==tk_reg)type=r16;
		2764
		2765	reg=itok.number;
		2766
		2767	nextexpecting2(tk_camma);
		2768
		2769	switch(tok){
		2770
		2771	if(type==r32)reg32expected(2);
		2772
		2773	case tk_reg32:
		2774
		2775	regs:
		2776
		2777	op(0x40+num);
		2778
		2779	break;
		2780
		2781	case tk_intvar:
		2782
		2783	CheckAllMassiv(bufrm,2,&strinf);
		2784
		2785	case tk_dwordvar:
		2786
		2787	if(type==r16)wordvalexpected();
		2788
		2789	dwords:
		2790
		2791	op(0x0F);
		2792
		2793	op(itok.rm+reg*8);
		2794
		2795	break;
		2796
		2797	varexpected(2);
		2798
		2799	}
		2800
		2801
		2802
		2803	int GetOperand(int code)
		2804
		2805	switch(code){
		2806
		2807	case a_add: return tk_plus;
		2808
		2809	case a_and: return tk_and;
		2810
		2811	case a_sub: return tk_minus;
		2812
		2813	case a_not: return tk_not;
		2814
		2815	case a_shl: return tk_ll;
		2816
		2817	}
		2818
		2819	}
		2820
		2821
		2822
		2823	{
		2824
		2825	int htok,typet=r16;
		2826
		2827	char *hbuf;
		2828
		2829	unsigned char next=1;
		2830
		2831	#ifdef OPTVARCONST
		2832
		2833	int operand=GetOperand(basecode/8);
		2834
		2835	nexttok();
		2836
		2837	htok=tok;
		2838
		2839	bufrm=NULL;
		2840
		2841	strinf.bufstr=NULL;
		2842
		2843	int i=tok;
		2844
		2845	case tk_reg:
		2846
		2847	switch(tok){
		2848
		2849	strcpy(hstok.name,itok.name);
		2850
		2851	goto wnum;
		2852
		2853	if(tok2!=tk_number){
		2854
		2855	break;
		2856
		2857	case tk_number:
		2858
		2859	asmparam=FALSE;
		2860
		2861	next=0;
		2862
		2863	if(hstok.number==AX){
		2864
		2865	if((postnumflag&f_reloc)!=0)AddReloc();
		2866
		2867	outword(holdnumber2);
		2868
		2869	else{
		2870
		2871	op(128+2+1);
		2872
		2873	op(holdnumber2);
		2874
		2875	else{
		2876
		2877	op(128+64+hstok.number+basecode);
		2878
		2879	if(i==tk_undefofs)AddUndefOff(2,hstok.name);
		2880
		2881	}
		2882
		2883	break;
		2884
		2885	op66(r16);
		2886
		2887	else{
		2888
		2889	op(128+64+hstok.number+basecode);
		2890
		2891	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		2892
		2893	break;
		2894
		2895	op66(r16);
		2896
		2897	op(128+64+(unsigned int)itok.number+hstok.number*8);
		2898
		2899	case tk_wordvar:
		2900
		2901	CheckAllMassiv(bufrm,2,&strinf);
		2902
		2903	outseg(&itok,2);
		2904
		2905	op(itok.rm+hstok.number*8);
		2906
		2907	break;
		2908
		2909	}
		2910
		2911	case tk_reg32:
		2912
		2913	switch(tok){
		2914
		2915	strcpy(hstok.name,itok.name);
		2916
		2917	goto dnum;
		2918
		2919	i=tk_number;
		2920
		2921	dwordvalexpected();
		2922
		2923	}
		2924
		2925	dnum:
		2926
		2927	asmparam=FALSE;
		2928
		2929	next=0;
		2930
		2931	op(128+2+1);
		2932
		2933	op((int)longholdnumber);
		2934
		2935	else{
		2936
		2937	else{
		2938
		2939	op(128+64+hstok.number+basecode);
		2940
		2941	if((postnumflag&f_reloc)!=0)AddReloc();
		2942
		2943	outdword(longholdnumber);
		2944
		2945	break;
		2946
		2947	op66(r32);
		2948
		2949	else{
		2950
		2951	op(128+64+hstok.number+basecode);
		2952
		2953	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		2954
		2955	break;
		2956
		2957	op66(r32);
		2958
		2959	op(128+64+(unsigned int)itok.number+hstok.number*8);
		2960
		2961	case tk_dwordvar:
		2962
		2963	CheckAllMassiv(bufrm,4,&strinf);
		2964
		2965	outseg(&itok,2);
		2966
		2967	op(itok.rm+hstok.number*8);
		2968
		2969	break;
		2970
		2971	}
		2972
		2973	break;
		2974
		2975	if((basecode/8)!=a_cmp)ClearReg(hstok.number>3?hstok.number-4:hstok.number);
		2976
		2977	case tk_minus:
		2978
		2979	bytevalexpected(2);
		2980
		2981	}
		2982
		2983	asmparam=FALSE;
		2984
		2985	next=0;
		2986
		2987	else{
		2988
		2989	op(128+64+hstok.number+basecode);
		2990
		2991	op(holdnumber2);
		2992
		2993	case tk_beg:
		2994
		2995	op(128+64+(unsigned int)itok.number+hstok.number*8);
		2996
		2997	case tk_bytevar:
		2998
		2999	CheckAllMassiv(bufrm,1,&strinf);
		3000
		3001	op(2+basecode);
		3002
		3003	outaddress(&itok);
		3004
		3005	default: bytevalexpected(2); break;
		3006
		3007	break;
		3008
		3009	case tk_longvar:
		3010
		3011	if(cpu<3)cpu=3;
		3012
		3013	case tk_wordvar:
		3014
		3015	CheckAllMassiv(hbuf,typet,&hstr,&hstok);
		3016
		3017	outseg(&hstok,2);
		3018
		3019	case tk_undefofs:
		3020
		3021	tok=tk_number;
		3022
		3023	case tk_minus:
		3024
		3025	case tk_number:
		3026
		3027	asmparam=FALSE;
		3028
		3029	#ifdef OPTVARCONST
		3030
		3031	initconst=UpdVarConst(&hstok,holdnumber2,tk_dword,operand);
		3032
		3033	#endif
		3034
		3035	if(i!=tk_undefofs&&(postnumflag&f_reloc)==0&&short_ok(holdnumber2,typet/2-1)){
		3036
		3037	op(hstok.rm+basecode);
		3038
		3039	op(holdnumber2);
		3040
		3041	else{
		3042
		3043	op(hstok.rm+basecode);
		3044
		3045	if((postnumflag&f_reloc)!=0)AddReloc();
		3046
		3047	if(typet==r16)outword(holdnumber2);
		3048
		3049	}
		3050
		3051	case tk_postnumber:
		3052
		3053	op(128+1);
		3054
		3055	outaddress(&hstok);
		3056
		3057	if(typet==r16)outword(itok.number);
		3058
		3059	break;
		3060
		3061	if(typet==r16)goto erval;
		3062
		3063	op(1+basecode);
		3064
		3065	outaddress(&hstok);
		3066
		3067	default:
		3068
		3069	if(typet==r16)wordvalexpected();
		3070
		3071	break;
		3072
		3073	#ifdef OPTVARCONST
		3074
		3075	#endif
		3076
		3077	break;
		3078
		3079	case tk_charvar:
		3080
		3081	CheckAllMassiv(hbuf,1,&hstr,&hstok);
		3082
		3083	case tk_minus:
		3084
		3085	bytevalexpected(2);
		3086
		3087	}
		3088
		3089	asmparam=FALSE;
		3090
		3091	#ifdef OPTVARCONST
		3092
		3093	initconst=UpdVarConst(&hstok,holdnumber2,tk_byte,operand);
		3094
		3095	#endif
		3096
		3097	outseg(&hstok,2);
		3098
		3099	op(hstok.rm+basecode);
		3100
		3101	op(holdnumber2);
		3102
		3103	case tk_beg:
		3104
		3105	op(basecode);
		3106
		3107	outaddress(&hstok);
		3108
		3109	default: bytevalexpected(2); break;
		3110
		3111	#ifdef OPTVARCONST
		3112
		3113	#endif
		3114
		3115	default: varexpected(1); break;
		3116
		3117	if(next)nexttok();
		3118
		3119
		3120
		3121	{
		3122
		3123	CheckIP();
		3124
		3125	ClearLVIC();
		3126
		3127	clearregstat();
		3128
		3129	case tk_proc:
		3130
		3131	if(itok.segm!=NOT_DYNAMIC){
		3132
		3133	itok.segm=ptr->recsegm=DYNAMIC_USED;
		3134
		3135	goto undefproc;
		3136
		3137	jumploc(itok.number); //�� 楤�� ࠭��
		3138
		3139	case tk_number:
		3140
		3141	jumploc(doconstlongmath());//��
		3142
		3143	break;
		3144
		3145	addlocaljump(CALL_SHORT); //��
		3146
		3147	break;
		3148
		3149	tobedefined(CALL_SHORT,tk_void);//�� ��
		3150
		3151	break;
		3152
		3153	tok=tk_undefproc;
		3154
		3155	case tk_locallabel:
		3156
		3157	undefproc:
		3158
		3159	outword(0x00EB); // JMP SHORT
		3160
		3161	default: shortjumperror(); break;
		3162
		3163	return next;
		3164
		3165
		3166
		3167	{
		3168
		3169	unsigned long hnumber;
		3170
		3171	CheckIP();
		3172
		3173	ClearLVIC();
		3174
		3175	clearregstat();
		3176
		3177	case tk_declare:
		3178
		3179	tok=tk_undefproc;
		3180
		3181	}
		3182
		3183	case tk_undefproc:
		3184
		3185	asmparam=FALSE;
		3186
		3187	break;
		3188
		3189	if(faradd==0){
		3190
		3191	jumploc0();
		3192
		3193	else invalidfarjumpitem();
		3194
		3195	case tk_proc:
		3196
		3197	doanyproc(TRUE);
		3198
		3199	}
		3200
		3201	idrec *ptr=itok.rec;
		3202
		3203	itok.rm=tok=tk_undefofs; //ᬥ饭�� ⭮� ��⪨
		3204
		3205	addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?JMP_NEAR:JMP_32)));
		3206
		3207	break;
		3208
		3209	}
		3210
		3211	if(faradd==0)jumploc(itok.number);
		3212
		3213	break;
		3214
		3215	asmparam=FALSE;
		3216
		3217	if(doanyundefproc(TRUE)==tokens)next=0;
		3218
		3219	else{
		3220
		3221	outword(0x25ff);
		3222
		3223	}
		3224
		3225	addacall(itok.number,(unsigned char)CALL_32);
		3226
		3227	}
		3228
		3229	break;
		3230
		3231	if(tok2!=tk_number)goto err;
		3232
		3233	asmparam=FALSE;
		3234
		3235	if(faradd==0)jumploc(hnumber);
		3236
		3237	op(0xEA);
		3238
		3239	int htok=tok;
		3240
		3241	if(tok==tk_undefofs){
		3242
		3243	strcpy(name,itok.name);
		3244
		3245	unsigned long tempi=doconstdwordmath();
		3246
		3247	if(htok==tk_undefofs)AddUndefOff(2,name);
		3248
		3249	else outdword(tempi);
		3250
		3251	}
		3252
		3253	break; /* JMP num */
		3254
		3255	if(faradd==0){
		3256
		3257	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		3258
		3259	else outdword(itok.number);
		3260
		3261	else invalidfarjumpitem();
		3262
		3263	case tk_reg32:
		3264
		3265	goto jmpreg;
		3266
		3267	op66(r16);
		3268
		3269	if(faradd==0){
		3270
		3271	op(0xE0+(unsigned int)itok.number);
		3272
		3273	else invalidfarjumpitem();
		3274
		3275	case tk_ID:
		3276
		3277	addlocaljump(am32==FALSE?JMP_NEAR:JMP_32);
		3278
		3279	} /* JMP num */
		3280
		3281	break;
		3282
		3283	if(faradd==0){
		3284
		3285	jumploc0();
		3286
		3287	else invalidfarjumpitem();
		3288
		3289	case tk_dwordvar:
		3290
		3291	i=2;
		3292
		3293	case tk_wordvar:
		3294
		3295	CheckAllMassiv(bufrm,i,&strinf);
		3296
		3297	op(0xFF); op(0x20+itok.rm+(faradd==0?(i==4&&am32==0?8:0):8));
		3298
		3299	break;
		3300
		3301	err:
		3302
		3303	break;
		3304
		3305	return next;
		3306
		3307
		3308
		3309	{
		3310
		3311	nexttok();
		3312
		3313	if(tok!=tk_reg32&&tok!=tk_reg)reg32regexpected(1);
		3314
		3315	ClearReg(itok.number);
		3316
		3317	switch(tok){
		3318
		3319	case tk_wordvar:
		3320
		3321	case tk_bytevar:
		3322
		3323	case tk_dwordvar:
		3324
		3325	default: varexpected(2);
		3326
		3327	CheckAllMassiv(bufrm,2,&strinf);
		3328
		3329	else outseg(&itok,3);
		3330
		3331	if(out2!=0)op(out2);
		3332
		3333	outaddress(&itok);
		3334
		3335
		3336
		3337	{
		3338
		3339	int htok,typet=r16;
		3340
		3341	hnumber=itok.number;
		3342
		3343	htok=tok;
		3344
		3345	switch(htok){
		3346
		3347	typet=r32;
		3348
		3349	case tk_reg:
		3350
		3351	case tk_reg32:
		3352
		3353	case tk_reg:
		3354
		3355	op(0xf);
		3356
		3357	op(0xc0+(unsigned int)itok.number+hnumber*8);
		3358
		3359	case tk_dwordvar:
		3360
		3361	if(typet==r16)goto erval;
		3362
		3363	case tk_intvar:
		3364
		3365	op66(typet);
		3366
		3367	op(0xf);
		3368
		3369	op(itok.rm+hnumber*8);
		3370
		3371	break;
		3372
		3373	erval:
		3374
		3375	else dwordvalexpected();
		3376
		3377	}
		3378
		3379	default: reg32regexpected(1);
		3380
		3381	if(cpu<3)cpu=3;
		3382
		3383
		3384
		3385	{
		3386
		3387	int htok;
		3388
		3389	unsigned char next=1;
		3390
		3391	SINFO hstr;
		3392
		3393	hstok=itok;
		3394
		3395	hbuf=bufrm;
		3396
		3397	hstr=strinf;
		3398
		3399	nextexpecting2(tk_camma);
		3400
		3401	case tk_reg32:
		3402
		3403	op66(htok==tk_reg?r16:r32);
		3404
		3405	switch(tok){
		3406
		3407	asmparam=FALSE;
		3408
		3409	next=0;
		3410
		3411	op(0xe0+code+hstok.number);
		3412
		3413	break;
		3414
		3415	if(tok!=htok){
		3416
		3417	break;
		3418
		3419	case tk_reg:
		3420
		3421	op(0xf);
		3422
		3423	op(0xc0+hstok.number+(unsigned int)itok.number*8);
		3424
		3425	default: wordvalexpected(); break;
		3426
		3427	break;
		3428
		3429	case tk_wordvar:
		3430
		3431	if(code)KillVar(hstok.name);
		3432
		3433	switch(tok){
		3434
		3435	varc:
		3436
		3437	holdnumber2=doconstlongmath();
		3438
		3439	outseg(&hstok,3);
		3440
		3441	op(hstok.rm+code+0x20);
		3442
		3443	op(holdnumber2);
		3444
		3445	case tk_reg:
		3446
		3447	outseg(&hstok,3);
		3448
		3449	op(0xa3+code);
		3450
		3451	outaddress(&hstok);
		3452
		3453	default: wordvalexpected(); break;
		3454
		3455	#ifdef OPTVARCONST
		3456
		3457	#endif
		3458
		3459	case tk_dwordvar:
		3460
		3461	CheckAllMassiv(hbuf,4,&hstr,&hstok);
		3462
		3463	op66(r32);
		3464
		3465	if(tok==tk_reg32)goto varreg;
		3466
		3467	break;
		3468
		3469	}
		3470
		3471	if(next)nexttok();
		3472
		3473
		3474
		3475	{
		3476
		3477	#ifdef OPTVARCONST
		3478
		3479	#endif
		3480
		3481	switch(tok){
		3482
		3483	if(cpu<3)cpu=3;
		3484
		3485	case tk_reg:
		3486
		3487	op66(razr);
		3488
		3489	break;
		3490
		3491	ClearReg(itok.number);
		3492
		3493	break;
		3494
		3495	case tk_bytevar:
		3496
		3497	UpdVarConst(&itok,1,tk_byte,operand);
		3498
		3499	CheckAllMassiv(bufrm,1,&strinf);
		3500
		3501	outseg(&itok,2);
		3502
		3503	op(itok.rm+basecode);
		3504
		3505	break;
		3506
		3507	case tk_dwordvar:
		3508
		3509	if(cpu<3)cpu=3;
		3510
		3511	goto dec;
		3512
		3513	case tk_wordvar:
		3514
		3515	dec:
		3516
		3517	UpdVarConst(&itok,1,tk_dword,operand);
		3518
		3519	KillVar(itok.name);
		3520
		3521	outseg(&itok,2);
		3522
		3523	op(itok.rm+basecode);
		3524
		3525	break;
		3526
		3527	}
		3528
		3529
		3530
		3531	{
		3532
		3533	#ifdef OPTVARCONST
		3534
		3535	#endif
		3536
		3537	switch(tok){
		3538
		3539	if(cpu<3)cpu=3;
		3540
		3541	case tk_reg:
		3542
		3543	op66(razr);
		3544
		3545	case tk_beg:
		3546
		3547	op(246); op(128+64+basecode+(unsigned int)itok.number); break;
		3548
		3549	case tk_charvar:
		3550
		3551	#ifdef OPTVARCONST
		3552
		3553	#endif
		3554
		3555	KillVar(itok.name);
		3556
		3557	op(246);
		3558
		3559	outaddress(&itok);
		3560
		3561	break;
		3562
		3563	case tk_dwordvar:
		3564
		3565	if(cpu<3)cpu=3;
		3566
		3567	goto neg;
		3568
		3569	case tk_wordvar:
		3570
		3571	neg:
		3572
		3573	UpdVarConst(&itok,0,tk_dword,operand);
		3574
		3575	KillVar(itok.name);
		3576
		3577	outseg(&itok,2);
		3578
		3579	op(itok.rm+basecode);
		3580
		3581	break;
		3582
		3583	}
		3584
		3585	ClearReg(AX);
		3586
		3587
		3588
		3589
		3590
		3591	{
		3592
		3593	unsigned int address;
		3594
		3595	ClearLVIC();
		3596
		3597	nexttok();
		3598
		3599	preerror("FAR jump not available for this instruction");
		3600
		3601	}
		3602
		3603	shortjump=0;
		3604
		3605	}
		3606
		3607	if(shortjump){
		3608
		3609	switch(tok){
		3610
		3611	(unsigned int )&itok.number-=outptr+2;
		3612
		3613	op(shortcode);
		3614
		3615	}
		3616
		3617	break;
		3618
		3619	asmparam=FALSE;
		3620
		3621	if(short_ok(address)){
		3622
		3623	op(address);
		3624
		3625	else shortjumptoolarge();
		3626
		3627	break;
		3628
		3629	addlocaljump(CALL_SHORT);
		3630
		3631	break;
		3632
		3633	tobedefined(CALL_SHORT,tk_void);
		3634
		3635	break;
		3636
		3637	tok=tk_undefproc;
		3638
		3639	case tk_locallabel:
		3640
		3641	addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:CALL_SHORT));
		3642
		3643	break;
		3644
		3645	}
		3646
		3647	else if(nearcode!=0){
		3648
		3649	asmparam=FALSE;
		3650
		3651	case tk_proc:
		3652
		3653	numlong=itok.number-outptr-2;
		3654
		3655
		3656
		3657	case tk_number:
		3658
		3659	numlong=doconstdwordmath()-outptr-2;
		3660
		3661	else outdword(numlong-2);
		3662
		3663	break;
		3664
		3665	op(0xF); op(nearcode);
		3666
		3667	outword(-(int)(outptr-2));
		3668
		3669	break;
		3670
		3671	op(0xF); op(nearcode);
		3672
		3673	numlong=itok.number-outptr-2;
		3674
		3675
		3676
		3677	case tk_ID:
		3678
		3679	addlocaljump(am32==FALSE?CALL_NEAR:CALL_32);
		3680
		3681	if(am32!=FALSE)outword(0x0000);
		3682
		3683	case tk_id:
		3684
		3685	tobedefined(am32==FALSE?CALL_NEAR:CALL_32,tk_void);
		3686
		3687	if(am32!=FALSE)outword(0x0000);
		3688
		3689	case tk_declare:
		3690
		3691	updatetree();
		3692
		3693	case tk_undefproc:
		3694
		3695	addacall((unsigned int)itok.number,(unsigned char)((itok.flag&f_extern)!=0?CALL_EXT:(am32==FALSE?CALL_NEAR:CALL_32)));
		3696
		3697	if(am32!=FALSE)outword(0x0000);
		3698
		3699	default: preerror("Invalid operand for NEAR jump"); break;
		3700
		3701	if(cpu<3)cpu=3;
		3702
		3703	else preerror("NEAR jump not available for this instruction");
		3704
		3705	}
		3706
		3707	void lar_lsl(int code)
		3708
		3709	unsigned char possiblecpu=0;
		3710
		3711	nexttok();
		3712
		3713	int htok=tok;
		3714
		3715	ClearReg(itok.number);
		3716
		3717	switch(tok){
		3718
		3719	if(htok==tk_reg)reg32expected(1);
		3720
		3721	razr=r32;
		3722
		3723	case tk_reg:
		3724
		3725	possiblecpu=2;
		3726
		3727
		3728
		3729	op(code);
		3730
		3731	break;
		3732
		3733	case tk_dwordvar:
		3734
		3735	CheckAllMassiv(bufrm,4,&strinf);
		3736
		3737	razr=r32;
		3738
		3739	case tk_intvar:
		3740
		3741	if(htok==tk_reg32)regexpected(1);
		3742
		3743	CheckAllMassiv(bufrm,2,&strinf);
		3744
		3745
		3746
		3747	op(0x0f);
		3748
		3749	op(itok.rm+hnumber*8);
		3750
		3751	break;
		3752
		3753	}
		3754
		3755	}
		3756
		3757	unsigned char tabldeckr(int code)
		3758
		3759	unsigned int i=0;
		3760
		3761	unsigned char next=1;
		3762
		3763	nexttok();
		3764
		3765	KillVar(itok.name);
		3766
		3767	case tk_longvar:
		3768
		3769	i=2;
		3770
		3771	case tk_wordvar:
		3772
		3773	case tk_charvar:
		3774
		3775	i++;
		3776
		3777	outseg(&itok,3);
		3778
		3779	op(itok.rm+code);
		3780
		3781	break;
		3782
		3783	strcpy(name,itok.name);
		3784
		3785	case tk_number:
		3786
		3787	outword(0x010f);
		3788
		3789	if(postnumflag&f_reloc)AddReloc();
		3790
		3791	if(am32)outdword(i);
		3792
		3793	next=0;
		3794
		3795	default: varexpected(0);
		3796
		3797	if(cpu<2)cpu=2;
		3798
		3799	}
		3800
		3801	void protectinstr(int code,int code2)
		3802
		3803	int i=0;
		3804
		3805	switch(tok){
		3806
		3807	case tk_dwordvar:
		3808
		3809	case tk_intvar:
		3810
		3811	i++;
		3812
		3813	case tk_bytevar:
		3814
		3815	#ifdef OPTVARCONST
		3816
		3817	#endif
		3818
		3819	KillVar(itok.name);
		3820
		3821	op(0x0f);
		3822
		3823	op(itok.rm+code2);
		3824
		3825	break;
		3826
		3827	case tk_reg:
		3828
		3829	op(0x0f);
		3830
		3831	op(0xc0+code2+(unsigned int)itok.number);
		3832
		3833	default: wordvalexpected();
		3834
		3835	if(cpu<2)cpu=2;
		3836
		3837
		3838
		3839	{
		3840
		3841	int htok,typet;
		3842
		3843	char *hbuf;
		3844
		3845	#ifdef OPTVARCONST
		3846
		3847	#endif
		3848
		3849	hstok=itok;
		3850
		3851	hbuf=bufrm;
		3852
		3853	hstr=strinf;
		3854
		3855	nextexpecting2(tk_camma);
		3856
		3857	int i=tok;
		3858
		3859	case tk_reg32:
		3860
		3861	typet=r32;
		3862
		3863	switch(tok){
		3864
		3865	ClearReg(hstok.number);
		3866
		3867	outword(0x210F);
		3868
		3869	possiblecpu=4;
		3870
		3871	\|\|(unsigned int)itok.number==DR7)possiblecpu=3;
		3872
		3873	case tk_controlreg:
		3874
		3875	if(typet==r16)goto erreg;
		3876
		3877	op(128+64+(unsigned int)itok.number*8+hstok.number);
		3878
		3879	if((unsigned int)itok.number<=CR3)possiblecpu=3;
		3880
		3881	case tk_testreg:
		3882
		3883	if(typet==r16)goto erreg;
		3884
		3885	op(128+64+(unsigned int)itok.number*8+hstok.number);
		3886
		3887	if((unsigned int)itok.number==TR6\|\|(unsigned int)itok.number==TR7)possiblecpu=3;
		3888
		3889	case tk_reg32:
		3890
		3891	case tk_reg:
		3892
		3893	op66(typet);
		3894
		3895	op(128+64+(unsigned int)itok.number*8+hstok.number);
		3896
		3897	case tk_undefofs:
		3898
		3899	tok=tk_number;
		3900
		3901	case tk_minus:
		3902
		3903	wordvalexpected();
		3904
		3905	}
		3906
		3907	wnum:
		3908
		3909	op(0xB8+hstok.number);
		3910
		3911	asmparam=FALSE;
		3912
		3913	next=0;
		3914
		3915	case tk_postnumber:
		3916
		3917	op66(typet);
		3918
		3919	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		3920
		3921	else outword((unsigned int)itok.number);
		3922
		3923	case tk_dwordvar:
		3924
		3925	if(typet==r16)goto erreg;
		3926
		3927	case tk_intvar:
		3928
		3929	IDZToReg(itok.name,hstok.number,typet);
		3930
		3931	if(hstok.number==0&&((itok.rm==rm_d16&&itok.sib==CODE16)\|\|(itok.rm==rm_d32&&(itok.sib==CODE32\|\|itok.sib==0)))){
		3932
		3933	op(0xA1);
		3934
		3935	else{
		3936
		3937	op(0x8B);
		3938
		3939	}
		3940
		3941	break;
		3942
		3943	if(typet==r32)goto erreg;
		3944
		3945	op66(r16);
		3946
		3947	op(128+64+(unsigned int)itok.number*8+hstok.number);
		3948
		3949	break;
		3950
		3951	erreg:
		3952
		3953	}
		3954
		3955	case tk_beg:
		3956
		3957	switch(tok){
		3958
		3959	op(0x88);
		3960
		3961	break;
		3962
		3963	op(0xB0+hstok.number);
		3964
		3965	op((int)doconstlongmath());
		3966
		3967	break;
		3968
		3969	case tk_charvar:
		3970
		3971	if(hstok.number==0&&((itok.rm==rm_d16&&itok.sib==CODE16)\|\|(itok.rm==rm_d32&&(itok.sib==CODE32\|\|itok.sib==0)))){
		3972
		3973	op(0xA0);
		3974
		3975	else{
		3976
		3977	op(0x8A);
		3978
		3979	}
		3980
		3981	break;
		3982
		3983	}
		3984
		3985	case tk_seg:
		3986
		3987	invalidoperand(1); break;
		3988
		3989	switch(tok){
		3990
		3991	op66(r16);
		3992
		3993	op(128+64+hstok.number*8+(unsigned int)itok.number);
		3994
		3995	break;
		3996
		3997	case tk_intvar:
		3998
		3999	op66(r16);
		4000
		4001	op(0x8E);
		4002
		4003	outaddress(&itok);
		4004
		4005	break;
		4006
		4007	}
		4008
		4009	case tk_dwordvar:
		4010
		4011	possiblecpu=3;
		4012
		4013	case tk_wordvar:
		4014
		4015	KillVar(itok.name);
		4016
		4017	op66(typet);
		4018
		4019	case tk_reg32:
		4020
		4021	case tk_reg:
		4022
		4023	AddRegVar(itok.number,typet,&hstok);
		4024
		4025	outseg(&hstok,1);
		4026
		4027	outaddress(&hstok);
		4028
		4029	else{
		4030
		4031	op(0x89);
		4032
		4033	outaddress(&hstok);
		4034
		4035	break;
		4036
		4037	strcpy(hstok.name,itok.name);
		4038
		4039	goto vnum;
		4040
		4041	if(tok2!=tk_number){
		4042
		4043	break;
		4044
		4045	case tk_number:
		4046
		4047	outseg(&hstok,2);
		4048
		4049	op(hstok.rm);
		4050
		4051	asmparam=FALSE;
		4052
		4053	unsigned long t;
		4054
		4055	if(typet==r16)t&=0xffff;
		4056
		4057	if((i==tk_number\|\|i==tk_minus)&&(postnumflag&f_reloc)){
		4058
		4059	initconst=TRUE;
		4060
		4061	#else
		4062
		4063	#endif
		4064
		4065	break;
		4066
		4067	outseg(&hstok,2);
		4068
		4069	op(hstok.rm);
		4070
		4071	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		4072
		4073	else outdword(itok.number);
		4074
		4075	case tk_seg:
		4076
		4077	if(typet==r32)goto ervar;
		4078
		4079	op(hstok.rm+(unsigned int)itok.number*8);
		4080
		4081	if(hstok.number==FS\|\|hstok.number==GS)possiblecpu=3;
		4082
		4083	default:
		4084
		4085	invalidoperand(2); break;
		4086
		4087	#ifdef OPTVARCONST
		4088
		4089	#endif
		4090
		4091	case tk_charvar:
		4092
		4093	KillVar(itok.name);
		4094
		4095	switch(tok){
		4096
		4097	/if(tok==tk_beg&&hbuf==NULL&&hstr.bufstr==NULL)/
		4098
		4099	if(itok.number==0&&((hstok.rm==rm_d16&&hstok.sib==CODE16)\|\|(hstok.rm==rm_d32&&(hstok.sib==CODE32\|\|hstok.sib==0)))){
		4100
		4101	op(0xA2);
		4102
		4103	}
		4104
		4105	outseg(&hstok,2);
		4106
		4107	op(hstok.rm+(unsigned int)itok.number*8);
		4108
		4109	}
		4110
		4111	case tk_number:
		4112
		4113	op(0xC6);
		4114
		4115	outaddress(&hstok);
		4116
		4117	#ifdef OPTVARCONST
		4118
		4119	t=doconstlongmath()&0xff;
		4120
		4121	if((postnumflag&f_reloc)){
		4122
		4123	Const2Var(&hstok,t,tk_byte);
		4124
		4125	#else
		4126
		4127	#endif
		4128
		4129	break;
		4130
		4131	}
		4132
		4133	if(initconst==FALSE)ClearVarByNum(&hstok);
		4134
		4135	break;
		4136
		4137	if(tok==tk_reg32){
		4138
		4139	op(128+64+hstok.number*8+(unsigned int)itok.number);
		4140
		4141	if(hstok.number<=DR3\|\|hstok.number==DR6\|\|hstok.number==DR7)possiblecpu=3;
		4142
		4143	else invalidoperand(2);
		4144
		4145	case tk_controlreg:
		4146
		4147	outword(0x220F);
		4148
		4149	possiblecpu=4;
		4150
		4151	}
		4152
		4153	break;
		4154
		4155	if(tok==tk_reg32){
		4156
		4157	op(128+64+hstok.number*8+(unsigned int)itok.number);
		4158
		4159	if(hstok.number==TR6\|\|hstok.number==TR7)possiblecpu=3;
		4160
		4161	else invalidoperand(2);
		4162
		4163	default: invalidoperand(1); break;
		4164
		4165	asmparam=FALSE;
		4166
		4167	if(next)nexttok();
		4168
		4169
		4170
		4171	{
		4172
		4173	int razr=r16;
		4174
		4175	if(tok==tk_reg32)razr=r32;
		4176
		4177	regnum=(unsigned int)itok.number*8;
		4178
		4179	nextexpecting2(tk_camma);
		4180
		4181	case tk_reg:
		4182
		4183	op(0xF); op(basecode\|1);
		4184
		4185	break;
		4186
		4187	op66(razr);
		4188
		4189	op(128+64+regnum+(unsigned int)itok.number);
		4190
		4191	case tk_wordvar:
		4192
		4193	CheckAllMassiv(bufrm,2,&strinf);
		4194
		4195	outseg(&itok,3);
		4196
		4197	op(itok.rm+regnum);
		4198
		4199	break;
		4200
		4201	case tk_charvar:
		4202
		4203	op66(razr);
		4204
		4205	op(0xF); op(basecode);
		4206
		4207	outaddress(&itok);
		4208
		4209	default: varexpected(2); break;
		4210
		4211	if(cpu<3)cpu=3;
		4212
		4213
		4214
		4215	{
		4216
		4217	int htok;
		4218
		4219	SINFO hstr;
		4220
		4221	nexttok();
		4222
		4223	htok=tok;
		4224
		4225	bufrm=NULL;
		4226
		4227	strinf.bufstr=NULL;
		4228
		4229	if(tok==tk_xmmreg)i++;
		4230
		4231	case tk_reg32:
		4232
		4233	if(tok==tk_mmxreg\|\|i){ //MOVD EAX,MM0
		4234
		4235	outword(0x7E0F);
		4236
		4237	}
		4238
		4239	break;
		4240
		4241	case tk_longvar:
		4242
		4243	#ifdef OPTVARCONST
		4244
		4245	#endif
		4246
		4247	KillVar(hstok.name);
		4248
		4249	if(i)op(0x66);
		4250
		4251	op(hstok.rm+(unsigned int)itok.number*8);
		4252
		4253	}
		4254
		4255	break;
		4256
		4257	i++;
		4258
		4259	switch(tok){
		4260
		4261	if(i)op(0x66);
		4262
		4263	op(0xc0+hstok.number*8+(unsigned int)itok.number);
		4264
		4265	case tk_dwordvar: //MOVD MMO,mem
		4266
		4267	CheckAllMassiv(bufrm,4,&strinf);
		4268
		4269	if(i)op(0x66);
		4270
		4271	op(itok.rm+hstok.number*8);
		4272
		4273	break;
		4274
		4275	}
		4276
		4277	default: mmxregordwordexpected(1);
		4278
		4279	if(cpu<6)cpu=6;
		4280
		4281	}
		4282
		4283	void movq()
		4284
		4285	int htok;
		4286
		4287	char *hbuf;
		4288
		4289	int i=1,xmm=0;
		4290
		4291	hstok=itok;
		4292
		4293	hbuf=bufrm;
		4294
		4295	hstr=strinf;
		4296
		4297	nextexpecting2(tk_camma);
		4298
		4299	switch(htok){
		4300
		4301	case tk_doublevar:
		4302
		4303	case tk_longvar:
		4304
		4305	case tk_floatvar:
		4306
		4307	case tk_wordvar:
		4308
		4309	i++;
		4310
		4311	case tk_bytevar:
		4312
		4313	#ifdef OPTVARCONST
		4314
		4315	#endif
		4316
		4317	CheckAllMassiv(hbuf,i,&hstr,&hstok);
		4318
		4319	if(xmm){
		4320
		4321	outword(0xD60f);
		4322
		4323	else outword(0x7F0F);
		4324
		4325	outaddress(&hstok);
		4326
		4327	else mmxregexpected(2);
		4328
		4329	case tk_mmxreg:
		4330
		4331	case tk_mmxreg: //MOVQ MM0,MM1
		4332
		4333	op(0xc0+hstok.number*8+(unsigned int)itok.number);
		4334
		4335	case tk_qwordvar:
		4336
		4337	i+=4;
		4338
		4339	case tk_dwordvar:
		4340
		4341	i+=2;
		4342
		4343	case tk_intvar:
		4344
		4345	case tk_charvar:
		4346
		4347	CheckAllMassiv(bufrm,i,&strinf);
		4348
		4349	outword(0x6F0F);
		4350
		4351	outaddress(&itok);
		4352
		4353	default: mmxregordwordexpected(2);
		4354
		4355	break;
		4356
		4357	switch(tok){
		4358
		4359	op(0xF3);
		4360
		4361	op(0xc0+hstok.number*8+(unsigned int)itok.number);
		4362
		4363	case tk_qwordvar:
		4364
		4365	i+=4;
		4366
		4367	case tk_dwordvar:
		4368
		4369	i+=2;
		4370
		4371	case tk_intvar:
		4372
		4373	case tk_charvar:
		4374
		4375	CheckAllMassiv(bufrm,i,&strinf);
		4376
		4377	op(0xF3);
		4378
		4379	op(itok.rm+hstok.number*8);
		4380
		4381	xmm++;
		4382
		4383	default: xmmregorvarexpected(2);
		4384
		4385	break;
		4386
		4387	}
		4388
		4389	if(xmm&&cpu<9)cpu=9;
		4390
		4391
		4392
		4393	{
		4394
		4395	int htok,next=TRUE;
		4396
		4397	int xmm=FALSE;
		4398
		4399	hnumber=(unsigned int)itok.number;
		4400
		4401	nextexpecting2(tk_camma);
		4402
		4403	else if(htok!=tk_mmxreg)mmxregexpected(1);
		4404
		4405	case tk_mmxreg:
		4406
		4407	op(0x0f);
		4408
		4409	op(0xc0+hnumber*8+(unsigned int)itok.number);
		4410
		4411	case tk_xmmreg:
		4412
		4413	else op(0x66);
		4414
		4415	op(code);
		4416
		4417	break;
		4418
		4419	if(xmm)op(0x66);
		4420
		4421	op(code1);
		4422
		4423	asmparam=FALSE;
		4424
		4425	next=FALSE;
		4426
		4427	case tk_qwordvar:
		4428
		4429	case tk_longvar:
		4430
		4431	case tk_floatvar:
		4432
		4433	case tk_wordvar:
		4434
		4435	i++;
		4436
		4437	case tk_bytevar:
		4438
		4439	outseg(&itok,xmm==FALSE?3:4);
		4440
		4441	op(0x0f);
		4442
		4443	op(itok.rm+hnumber*8);
		4444
		4445	break;
		4446
		4447	mmxregordwordexpected(2);
		4448
		4449	}
		4450
		4451	if(xmm&&cpu<9)cpu=9;
		4452
		4453	}
		4454
		4455	void asmshift(int basecode) // used for ROL ROR RCL RCR SHL SAL SHR SAR.
		4456
		4457	int htok,precode;
		4458
		4459	int usenumsh=TRUE;
		4460
		4461	char *hbuf;
		4462
		4463	SINFO hstr;
		4464
		4465	#ifdef OPTVARCONST
		4466
		4467	#endif
		4468
		4469	htok=tok;
		4470
		4471	hbuf=bufrm;
		4472
		4473	hstr=strinf;
		4474
		4475	nextexpecting2(tk_camma);
		4476
		4477	precode=0xD2;
		4478
		4479	}
		4480
		4481	asmparam=FALSE;
		4482
		4483	if(holdbyte==1){
		4484
		4485	usenumsh=FALSE;
		4486
		4487	else /if(holdbyte!=0)/{
		4488
		4489	if(cpu<2)cpu=2;
		4490
		4491	next=0;
		4492
		4493	else clornumberexpected();
		4494
		4495	switch(htok){
		4496
		4497	if(cpu<3)cpu=3;
		4498
		4499	case tk_reg:
		4500
		4501	op66(razr);
		4502
		4503	break;
		4504
		4505	ClearReg(hstok.number);
		4506
		4507	break;
		4508
		4509	case tk_bytevar:
		4510
		4511	if(precode==0xD0\|\|precode==0xc0)UpdVarConst(&hstok,holdbyte,tk_byte,operand);
		4512
		4513	#endif
		4514
		4515	KillVar(hstok.name);
		4516
		4517	op(precode);
		4518
		4519	outaddress(&hstok);
		4520
		4521	case tk_dwordvar:
		4522
		4523	CheckAllMassiv(hbuf,4,&hstr,&hstok);
		4524
		4525	razr=r32;
		4526
		4527	case tk_wordvar:
		4528
		4529	CheckAllMassiv(hbuf,2,&hstr,&hstok);
		4530
		4531	#ifdef OPTVARCONST
		4532
		4533	else ClearVarByNum(&hstok);
		4534
		4535	KillVar(hstok.name);
		4536
		4537	outseg(&hstok,2);
		4538
		4539	op(hstok.rm+basecode);
		4540
		4541	break;
		4542
		4543	}
		4544
		4545	if(next)nexttok();
		4546
		4547
		4548
		4549	{
		4550
		4551	if(tok==tk_beg){
		4552
		4553	else clornumberexpected();
		4554
		4555	else if(tok!=tk_number)clornumberexpected();
		4556
		4557	}
		4558
		4559	void Shxd(int code)
		4560
		4561	unsigned int h2number;
		4562
		4563	ITOK hstok;
		4564
		4565	unsigned char next=1;
		4566
		4567	nexttok();
		4568
		4569	htok=tok;
		4570
		4571	bufrm=NULL;
		4572
		4573	strinf.bufstr=NULL;
		4574
		4575	h2number=(unsigned int)itok.number;
		4576
		4577	h2tok=tok;
		4578
		4579	switch(htok){
		4580
		4581	if(h2tok==tk_reg){
		4582
		4583	regreg:
		4584
		4585	CheckCl(code);
		4586
		4587	if(tok==tk_number){
		4588
		4589	op(doconstlongmath());
		4590
		4591	}
		4592
		4593	else regexpected(2);
		4594
		4595	case tk_reg32:
		4596
		4597	op66(r32);
		4598
		4599	}
		4600
		4601	break;
		4602
		4603	case tk_wordvar:
		4604
		4605	CheckAllMassiv(hbuf,2,&hstr,&hstok);
		4606
		4607	varreg:
		4608
		4609	ClearVarByNum(&hstok);
		4610
		4611
		4612
		4613	outseg(&hstok,3);
		4614
		4615	op(hstok.rm+h2number*8);
		4616
		4617	if(tok==tk_number){
		4618
		4619	op(doconstlongmath());
		4620
		4621	}
		4622
		4623	else regexpected(2);
		4624
		4625	case tk_dwordvar:
		4626
		4627	if(h2tok==tk_reg32){
		4628
		4629	op66(r32);
		4630
		4631	}
		4632
		4633	break;
		4634
		4635	}
		4636
		4637	if(next)nexttok();
		4638
		4639
		4640
		4641	{
		4642
		4643	int oscan=scanlexmode;
		4644
		4645	nexttok();
		4646
		4647	if(tok==tk_endline\|\|tok==tk_semicolon){
		4648
		4649	op(0xC1+addrm);
		4650
		4651	}
		4652
		4653	opcode=0xdc;
		4654
		4655	}
		4656
		4657	case tk_fpust:
		4658
		4659	op(0xC0+(unsigned int)itok.number+addrm);
		4660
		4661	case tk_longvar:
		4662
		4663	case tk_floatvar:
		4664
		4665	outseg(&itok,2);
		4666
		4667	op(itok.rm+addrm);
		4668
		4669	break;
		4670
		4671	CheckAllMassiv(bufrm,8,&strinf);
		4672
		4673	op(0xDC);
		4674
		4675	outaddress(&itok);
		4676
		4677	default: fpuvarexpected(0);
		4678
		4679	}
		4680
		4681	void FpuType2(unsigned int addrm,unsigned int addrm2)
		4682
		4683	long hnum;
		4684
		4685	int oscan=scanlexmode;
		4686
		4687	nexttok();
		4688
		4689	if(tok==tk_endline\|\|tok==tk_semicolon){
		4690
		4691	op(0xC1+addrm);
		4692
		4693	}
		4694
		4695	opcode=0xdc;
		4696
		4697	}
		4698
		4699	case tk_fpust:
		4700
		4701	nextexpecting2(tk_camma);
		4702
		4703	if(tok==tk_fpust){
		4704
		4705	op(0xC0+addrm2+(unsigned int)itok.number);
		4706
		4707	else fpustakexpected(2);
		4708
		4709	else{
		4710
		4711	if(itok.number!=0)fpu0expected();
		4712
		4713	op(0xC0+(unsigned int)hnum+addrm);
		4714
		4715	else fpustakexpected(2);
		4716
		4717	break;
		4718
		4719	case tk_dwordvar:
		4720
		4721	CheckAllMassiv(bufrm,4,&strinf);
		4722
		4723	op(opcode);
		4724
		4725	outaddress(&itok);
		4726
		4727	case tk_doublevar:
		4728
		4729	outseg(&itok,2);
		4730
		4731	op(addrm2+itok.rm);
		4732
		4733	break;
		4734
		4735	}
		4736
		4737
		4738
		4739	{
		4740
		4741
		4742
		4743	nexttok();
		4744
		4745	retoldscanmode(oscan);
		4746
		4747	op(opcode);
		4748
		4749	}
		4750
		4751	op(opcode);
		4752
		4753	}
		4754
		4755	if(opcode==0xDE&&tok2==tk_camma){
		4756
		4757	nexttok();
		4758
		4759
		4760
		4761	}
		4762
		4763	void FpuType4(unsigned int opcode,unsigned int addrm)
		4764
		4765	nexttok();
		4766
		4767	if(addrm==0)addrm=0x28;
		4768
		4769	CheckAllMassiv(bufrm,8,&strinf);
		4770
		4771	outseg(&itok,2);
		4772
		4773	op(itok.rm+addrm);
		4774
		4775	return;
		4776
		4777	switch(tok){
		4778
		4779	case tk_intvar:
		4780
		4781	KillVar(itok.name);
		4782
		4783	op(0xDE + opcode);
		4784
		4785	outaddress(&itok);
		4786
		4787	case tk_longvar:
		4788
		4789	case tk_floatvar:
		4790
		4791	KillVar(itok.name);
		4792
		4793	op(0xDA+opcode);
		4794
		4795	outaddress(&itok);
		4796
		4797	default: fpuvarexpected(0);
		4798
		4799	}
		4800
		4801	void FpuType5(unsigned int opcode,unsigned int addrm)
		4802
		4803	int opc=0xd9;
		4804
		4805	nexttok();
		4806
		4807	nexttok();
		4808
		4809	}
		4810
		4811	opc=0xdb;
		4812
		4813	if(addrm==0)addrm=40;
		4814
		4815	nexttok();
		4816
		4817	}
		4818
		4819	case tk_fpust:
		4820
		4821	op(0xC0+(unsigned int)itok.number+addrm);
		4822
		4823	case tk_qwordvar:
		4824
		4825	opc=0xdd;
		4826
		4827	case tk_longvar:
		4828
		4829	case tk_floatvar:
		4830
		4831	if(opcode!=0xD9)KillVar(itok.name);
		4832
		4833	op(opc);
		4834
		4835	outaddress(&itok);
		4836
		4837	default: fpuvarexpected(0);
		4838
		4839	}
		4840
		4841	void FpuType6(unsigned int opcode,unsigned int addrm)
		4842
		4843	int i=0;
		4844
		4845	if(opcode==0xDF){
		4846
		4847	nexttok();
		4848
		4849	}
		4850
		4851	i=2;
		4852
		4853	tok=tk_qwordvar;
		4854
		4855	}
		4856
		4857	case tk_qwordvar:
		4858
		4859	i=+4;
		4860
		4861	case tk_dwordvar:
		4862
		4863	i+=2;
		4864
		4865	case tk_intvar:
		4866
		4867	CheckAllMassiv(bufrm,i,&strinf);
		4868
		4869	outseg(&itok,2);
		4870
		4871	op(itok.rm+addrm);
		4872
		4873	break;
		4874
		4875	}
		4876
		4877
		4878
		4879	{
		4880
		4881	switch(tok){
		4882
		4883	case tk_intvar:
		4884
		4885	if(addrm!=0x28)KillVar(itok.name);
		4886
		4887	op(0xD9);
		4888
		4889	outaddress(&itok);
		4890
		4891	default: wordvalexpected();
		4892
		4893	}
		4894
		4895	void FpuType8(unsigned int opcode,unsigned int addrm)
		4896
		4897	nexttok();
		4898
		4899	nexttok();
		4900
		4901	}
		4902
		4903	op(opcode);
		4904
		4905	if(cpu<7)cpu=7;
		4906
		4907	else fpustakexpected(1);
		4908
		4909
		4910
		4911
		4912
		4913	{
		4914
		4915	if(thenumber<=SHORTMAX&&thenumber>=SHORTMIN)return(1);
		4916
		4917	else{
		4918
		4919	}
		4920
		4921	}
		4922
		4923	void cbw()
		4924
		4925	if(optimizespeed&&(chip==5\|\|chip==6)){
		4926
		4927	op(7);
		4928
		4929	else{
		4930
		4931	op(0x98);
		4932
		4933	ClearReg(AX);
		4934
		4935
		4936
		4937	{
		4938
		4939	ClearReg(DI);
		4940
		4941
		4942
		4943	{
		4944
		4945	op(0xAB);
		4946
		4947	}
		4948
		4949	void stosd()
		4950
		4951	op66(r32);
		4952
		4953	if(cpu<3)cpu=3;
		4954
		4955	}
		4956
		4957	void movsb()
		4958
		4959	op(0xA4);
		4960
		4961	ClearReg(SI);
		4962
		4963
		4964
		4965	{
		4966
		4967	op(0xA5);
		4968
		4969	ClearReg(SI);
		4970
		4971
		4972
		4973	{
		4974
		4975	op(0xA5);
		4976
		4977	ClearReg(DI);
		4978
		4979	}
		4980
		4981	void pushds() /* produce PUSH DS */
		4982
		4983	RestoreStack();
		4984
		4985	}
		4986
		4987	void pushss()
		4988
		4989	RestoreStack();
		4990
		4991	}
		4992
		4993	void popes() /* produce POP ES */
		4994
		4995	RestoreStack();
		4996
		4997	}
		4998
		4999	void ret() /* produce RET */
		5000
		5001	RestoreStack();
		5002
		5003	}
		5004
		5005	void retf() /* produce RETF */
		5006
		5007	RestoreStack();
		5008
		5009	}
		5010
		5011	void jumploc(long loc) /* produce JUMP # */
		5012
		5013
		5014
		5015	if(loc>-130&&loc<127){
		5016
		5017	op(0xEB);
		5018
		5019	if(loc==0)notunreach=TRUE;
		5020
		5021	else{
		5022
		5023	op(0xE9);
		5024
		5025	}
		5026
		5027	if(!optimizespeed&&(loc>126&&loc<65533)){
		5028
		5029	outword(loc-1);
		5030
		5031	else{
		5032
		5033	outdword(loc-2);
		5034
		5035	}
		5036
		5037	}
		5038
		5039	void callloc(long loc) /* produce CALL # */
		5040
		5041	loc=loc-outptr-3;
		5042
		5043	if(am32==FALSE) outword(loc);
		5044
		5045	}
		5046
		5047	void xorAHAH() /* produce XOR AH,AH */
		5048
		5049	outword(0xE430);
		5050
		5051	}
		5052
		5053	void xorAXAX() /* produce XOR AX,AX */
		5054
		5055	op66(r16);
		5056
		5057	ConstToReg(0,AX,r16);
		5058
		5059
		5060
		5061	{
		5062
		5063	outword(0xC031);
		5064
		5065	ConstToReg(0,AX,r32);
		5066
		5067
		5068
		5069	{
		5070
		5071	op(0x31);
		5072
		5073	ConstToReg(0,reg,razr);
		5074
		5075
		5076
		5077	{
		5078
		5079	}
		5080
		5081	void cwdq(int razr)
		5082
		5083	op66(razr);
		5084
		5085	outword(0xC289); //mov dx,ax
		5086
		5087	outword(0xFAC1); //sar dx,15
		5088
		5089	}
		5090
		5091	ClearReg(DX);
		5092
		5093
		5094
		5095	{
		5096
		5097	expecting2(want);
		5098
		5099
		5100
		5101	{
		5102
		5103	nexttok();
		5104
		5105
		5106
		5107	{
		5108
		5109	tok=tk_number;
		5110
		5111	}
		5112
		5113
		5114
		5115	{
		5116
		5117	outword(0); /* the large jump */
		5118
		5119	}
		5120
		5121	void callloc0()
		5122
		5123	op(0xE8);
		5124
		5125	if(am32!=FALSE)outword(0);
		5126
		5127
		5128
		5129	{
		5130
		5131	outword(0xEC89); // MOV SP,BP
		5132
		5133	}
		5134
		5135	}
		5136
		5137	void tobedefined(int callkind,int expectedreturn)
		5138
		5139	// strcpy(itok.name,(char *)string);
		5140
		5141	itok.flag=(unsigned char)(tok==tk_ID?tp_fastcall:(comfile==file_w32?tp_stdcall:tp_pascal));
		5142
		5143	itok.number=secondcallnum;
		5144
		5145	itok.rm=expectedreturn;
		5146
		5147	addtotree(itok.name);
		5148
		5149	}
		5150
		5151	void addlocaljump(int callkind)
		5152
		5153	addlocalvar((char *)string,tk_locallabel,secondcallnum,TRUE);
		5154
		5155	}
		5156
		5157	unsigned long SaveNumber(int type,int tok4,char *name)
		5158
		5159	unsigned long t=doconstdwordmath();
		5160
		5161	else if((postnumflag&f_reloc)!=0)AddReloc();
		5162
		5163	else outdword(t);
		5164
		5165	}
		5166
		5167	void Swap2tok(int tok4, ITOK itok4, char *buf4, SINFO strinf4, int *tok6,
		5168
		5169	{
		5170
		5171	ITOK hstok;
		5172
		5173	SINFO hstr;
		5174
		5175	tok4=tok6;
		5176
		5177	hstok=*itok4;
		5178
		5179	*itok6=hstok;
		5180
		5181	buf4=buf6;
		5182
		5183	hstr=*strinf4;
		5184
		5185	*strinf6=hstr;
		5186
		5187
		5188
		5189	{
		5190
		5191	ITOK hstok;
		5192
		5193	SINFO hstr;
		5194
		5195	unsigned long num;
		5196
		5197	nexttok();
		5198
		5199	hstok=itok;
		5200
		5201	bufrm=NULL;
		5202
		5203	strinf.bufstr=NULL;
		5204
		5205	else nexttok();
		5206
		5207	i=r16;
		5208
		5209	// tok,itok.number,bufrm,htok,hstok.number,hbuf);
		5210
		5211	&htok,&hstok,&hbuf,&hstr);
		5212
		5213	// tok,itok.number,bufrm,htok,hstok.number,hbuf);
		5214
		5215	case tk_reg32:
		5216
		5217	possiblecpu=3;
		5218
		5219	switch(tok){
		5220
		5221	if(i==r16){
		5222
		5223	return FALSE;
		5224
		5225	op66(i);
		5226
		5227	op(128+64+(unsigned int)itok.number*8+hstok.number);
		5228
		5229	case tk_reg:
		5230
		5231	reg32expected(2);
		5232
		5233	}
		5234
		5235	op(0x85);
		5236
		5237	break;
		5238
		5239	asmparam=FALSE;
		5240
		5241	if(mode){
		5242
		5243	if(num<65536)i=r16;
		5244
		5245	op66(i);
		5246
		5247	else{
		5248
		5249	op(128+64+hstok.number);
		5250
		5251	if(i==r16)outword((unsigned int)num);
		5252
		5253	next=0;
		5254
		5255	case tk_postnumber:
		5256
		5257	op66(r16);
		5258
		5259	else{
		5260
		5261	op(128+64+hstok.number);
		5262
		5263	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		5264
		5265	break;
		5266
		5267	case tk_longvar:
		5268
		5269	reg32expected(1);
		5270
		5271	}
		5272
		5273	op66(i);
		5274
		5275	op(0x85);
		5276
		5277	outaddress(&itok);
		5278
		5279	case tk_wordvar:
		5280
		5281	if(i==r32){
		5282
		5283	return FALSE;
		5284
		5285	CheckAllMassiv(bufrm,i,&strinf);
		5286
		5287	outseg(&itok,2);
		5288
		5289	op(hstok.number*8+itok.rm);
		5290
		5291	break;
		5292
		5293	}
		5294
		5295	case tk_beg:
		5296
		5297	case tk_beg:
		5298
		5299	op(128+64+(unsigned int)itok.number*8+hstok.number);
		5300
		5301	case tk_number:
		5302
		5303	num=doconstdwordmath();
		5304
		5305	if(hstok.number==AL)op(0xA8);
		5306
		5307	op(0xF6);
		5308
		5309	}
		5310
		5311	next=0;
		5312
		5313	case tk_charvar:
		5314
		5315	CheckAllMassiv(bufrm,1,&strinf);
		5316
		5317	op(0x84);
		5318
		5319	outaddress(&itok);
		5320
		5321	default: return FALSE;
		5322
		5323	break;
		5324
		5325	case tk_longvar:
		5326
		5327	possiblecpu=3;
		5328
		5329	case tk_intvar:
		5330
		5331	switch(tok){
		5332
		5333	if(i==r16){
		5334
		5335	return FALSE;
		5336
		5337	op66(i);
		5338
		5339	op(0x85);
		5340
		5341	outaddress(&hstok);
		5342
		5343	case tk_reg:
		5344
		5345	reg32expected(2);
		5346
		5347	}
		5348
		5349	outseg(&hstok,2);
		5350
		5351	op((unsigned int)itok.number*8+hstok.rm);
		5352
		5353	break;
		5354
		5355	asmparam=FALSE;
		5356
		5357	if(mode){
		5358
		5359	if(num<65536)i=r16;
		5360
		5361	op66(i);
		5362
		5363	op(0xF7);
		5364
		5365	outaddress(&hstok);
		5366
		5367	else outword((unsigned int)num);
		5368
		5369	break;
		5370
		5371	op66(i);
		5372
		5373	if(i==r32)return FALSE;
		5374
		5375	op(hstok.rm);
		5376
		5377	(itok.flag&f_extern)==0?setwordpost(&itok):setwordext(&itok.number);
		5378
		5379	break;
		5380
		5381	}
		5382
		5383	case tk_charvar:
		5384
		5385	CheckAllMassiv(hbuf,1,&hstr,&hstok);
		5386
		5387	case tk_beg:
		5388
		5389	op(0x84);
		5390
		5391	outaddress(&hstok);
		5392
		5393	case tk_number:
		5394
		5395	num=doconstdwordmath();
		5396
		5397	outseg(&hstok,2);
		5398
		5399	op(hstok.rm);
		5400
		5401	op(num);
		5402
		5403	break;
		5404
		5405	}
		5406
		5407	default: return FALSE;
		5408
		5409	if(cpu
		5410
		5411	return TRUE;
		5412
		5413
		5414
		5415	{
		5416
		5417	int xmm=FALSE;
		5418
		5419	if(tok==tk_xmmreg)xmm=TRUE;
		5420
		5421	num1=itok.number;
		5422
		5423	switch(tok){
		5424
		5425	if(xmm)xmmregorvarexpected(2);
		5426
		5427	op(type);
		5428
		5429	break;
		5430
		5431	if(xmm==FALSE)mmxormem(2);
		5432
		5433	op(type);
		5434
		5435	break;
		5436
		5437	i+=4;
		5438
		5439	case tk_dwordvar:
		5440
		5441	i+=2;
		5442
		5443	case tk_intvar:
		5444
		5445
		5446
		5447	CheckAllMassiv(bufrm,i,&strinf);
		5448
		5449	if(xmm)op(0x66);
		5450
		5451	op(type);
		5452
		5453	outaddress(&itok);
		5454
		5455	default:
		5456
		5457	break;
		5458
		5459	if(cpu<8)cpu=8;
		5460
		5461	}
		5462
		5463	void prefetch(int code,int type)
		5464
		5465	int i=1;
		5466
		5467	switch(tok){
		5468
		5469	i+=4;
		5470
		5471	case tk_dwordvar:
		5472
		5473	i+=2;
		5474
		5475	case tk_intvar:
		5476
		5477	case tk_charvar:
		5478
		5479	CheckAllMassiv(bufrm,i,&strinf);
		5480
		5481	outseg(&itok,3);
		5482
		5483	op(code);
		5484
		5485	outaddress(&itok);
		5486
		5487	default:
		5488
		5489	break;
		5490
		5491	}
		5492
		5493	void pextrw()
		5494
		5495	int num1,num2;
		5496
		5497	nexttok();
		5498
		5499	num1=itok.number;
		5500
		5501	nextexpecting2(tk_camma);
		5502
		5503	else if(tok!=tk_mmxreg)mmxregexpected(2);
		5504
		5505	nextexpecting2(tk_camma);
		5506
		5507	if(xmm)op(0x66);
		5508
		5509	op(rm_mod11+num1+num2*8);
		5510
		5511	if(cpu<8)cpu=8;
		5512
		5513
		5514
		5515	void pinsrw()
		5516
		5517	int num1,htok;
		5518
		5519	char *hbuf;
		5520
		5521	int xmm=FALSE;
		5522
		5523	if(tok==tk_xmmreg)xmm=TRUE;
		5524
		5525	num1=itok.number;
		5526
		5527	htok=tok;
		5528
		5529	hbuf=bufrm;
		5530
		5531	hstr=strinf;
		5532
		5533	nextexpecting2(tk_camma);
		5534
		5535	switch(htok){
		5536
		5537	if(xmm)op(0x66);
		5538
		5539	op(rm_mod11+num1+hstok.number*8);
		5540
		5541	case tk_wordvar:
		5542
		5543	CheckAllMassiv(hbuf,2,&hstr);
		5544
		5545	if(xmm)op(0x66);
		5546
		5547	op(hstok.rm+num1*8);
		5548
		5549	break;
		5550
		5551	reg32orword(2);
		5552
		5553	}
		5554
		5555	if(cpu<8)cpu=8;
		5556
		5557	}
		5558
		5559	void pshufw()
		5560
		5561	int num1,htok;
		5562
		5563	char *hbuf;
		5564
		5565	int i=1;
		5566
		5567	if(tok!=tk_mmxreg)mmxregexpected(1);
		5568
		5569	nextexpecting2(tk_camma);
		5570
		5571	hstok=itok;
		5572
		5573	bufrm=NULL;
		5574
		5575	strinf.bufstr=NULL;
		5576
		5577	if(tok!=tk_number)numexpected(3);
		5578
		5579	case tk_mmxreg:
		5580
		5581	op(rm_mod11+num1+hstok.number*8);
		5582
		5583	case tk_longvar:
		5584
		5585	case tk_floatvar:
		5586
		5587	case tk_wordvar:
		5588
		5589	i++;
		5590
		5591	case tk_bytevar:
		5592
		5593	KillVar(hstok.name);
		5594
		5595	outword(0x700F);
		5596
		5597	outaddress(&hstok);
		5598
		5599	default:
		5600
		5601
		5602
		5603	op(doconstdwordmath());
		5604
		5605
		5606
		5607	{
		5608
		5609	nexttok();
		5610
		5611	if(op1==tk_mmxreg)mmxregexpected(1);
		5612
		5613	else xmmregexpected(1);
		5614
		5615	if(tok==tk_reg32)ClearReg(itok.number);
		5616
		5617	nextexpecting2(tk_camma);
		5618
		5619	case tk_reg32:
		5620
		5621	case tk_xmmreg:
		5622
		5623	if(op2==tk_mmxreg)mmxregexpected(2);
		5624
		5625	else xmmregexpected(2);
		5626
		5627	if(sec)op(sec);
		5628
		5629	op(type);
		5630
		5631	break;
		5632
		5633	i+=4;
		5634
		5635	case tk_dwordvar:
		5636
		5637	i+=2;
		5638
		5639	case tk_intvar:
		5640
		5641
		5642
		5643	CheckAllMassiv(bufrm,i,&strinf);
		5644
		5645	if(sec)op(sec);
		5646
		5647	op(type);
		5648
		5649	outaddress(&itok);
		5650
		5651	default:
		5652
		5653	else if(op2==tk_reg32)reg32orword(2);
		5654
		5655	break;
		5656
		5657	}
		5658
		5659	void xmm3instr(int type,int sec) //xmm,xmm/mem,i8
		5660
		5661	int num1,i=1,htok;
		5662
		5663	char *hbuf;
		5664
		5665	nexttok();
		5666
		5667	num1=itok.number;
		5668
		5669	htok=tok;
		5670
		5671	hbuf=bufrm;
		5672
		5673	hstr=strinf;
		5674
		5675	nextexpecting2(tk_camma);
		5676
		5677	switch(htok){
		5678
		5679	if(sec)op(sec);
		5680
		5681	op(type);
		5682
		5683	break;
		5684
		5685	i+=4;
		5686
		5687	case tk_dwordvar:
		5688
		5689	i+=2;
		5690
		5691	case tk_intvar:
		5692
		5693	case tk_charvar:
		5694
		5695	CheckAllMassiv(hbuf,i,&hstr);
		5696
		5697	if(sec)op(sec);
		5698
		5699	op(type);
		5700
		5701	outaddress(&hstok);
		5702
		5703	default:
		5704
		5705	break;
		5706
		5707	op(doconstdwordmath());
		5708
		5709
		5710
		5711	{
		5712
		5713	nexttok();
		5714
		5715	if(type==tk_mmxreg)mmxregexpected(1);
		5716
		5717	else xmmregexpected(1);
		5718
		5719	if(tok==tk_reg32)ClearReg(itok.number);
		5720
		5721	nextexpecting2(tk_camma);
		5722
		5723	if(code2)op(code2);
		5724
		5725	op(code);
		5726
		5727	}
		5728
		5729	void movxmm3(int code,int code2,int type)
		5730
		5731	int i=1,htok;
		5732
		5733	char *hbuf;
		5734
		5735	nexttok();
		5736
		5737	hstok=itok;
		5738
		5739	bufrm=NULL;
		5740
		5741	strinf.bufstr=NULL;
		5742
		5743	if(tok!=type){
		5744
		5745	else if(type==tk_xmmreg)xmmregexpected(2);
		5746
		5747	}
		5748
		5749	case tk_qwordvar:
		5750
		5751	case tk_longvar:
		5752
		5753	case tk_floatvar:
		5754
		5755	case tk_wordvar:
		5756
		5757	i+=1;
		5758
		5759	case tk_bytevar:
		5760
		5761	KillVar(hstok.name);
		5762
		5763	if(code2)op(code2);
		5764
		5765	op(code);
		5766
		5767	outaddress(&hstok);
		5768
		5769	default: varexpected(1);
		5770
		5771	}
		5772
		5773	void movxmm4(int code,int code2)
		5774
		5775	int i=1;
		5776
		5777	nexttok();
		5778
		5779	if(tok!=tk_xmmreg)xmmregexpected(1);
		5780
		5781	switch(tok){
		5782
		5783	i+=4;
		5784
		5785	case tk_dwordvar:
		5786
		5787	i+=2;
		5788
		5789	case tk_intvar:
		5790
		5791	case tk_charvar:
		5792
		5793	CheckAllMassiv(bufrm,i,&strinf);
		5794
		5795	if(code2)op(code2);
		5796
		5797	op(code);
		5798
		5799	outaddress(&itok);
		5800
		5801	default: varexpected(2);
		5802
		5803	}
		5804
		5805	void movxmm(int code,int code2,int addc)
		5806
		5807	int i=1,htok;
		5808
		5809	char *hbuf;
		5810
		5811	nexttok();
		5812
		5813	hstok=itok;
		5814
		5815	bufrm=NULL;
		5816
		5817	strinf.bufstr=NULL;
		5818
		5819	switch(htok){
		5820
		5821	switch(tok){
		5822
		5823	if(code2)op(code2);
		5824
		5825	op(code);
		5826
		5827	break;
		5828
		5829	i+=4;
		5830
		5831	case tk_dwordvar:
		5832
		5833	i+=2;
		5834
		5835	case tk_intvar:
		5836
		5837	case tk_charvar:
		5838
		5839	CheckAllMassiv(bufrm,i,&strinf);
		5840
		5841	if(code2)op(code2);
		5842
		5843	op(code);
		5844
		5845	outaddress(&itok);
		5846
		5847	default:
		5848
		5849	break;
		5850
		5851	break;
		5852
		5853	i+=4;
		5854
		5855	case tk_dwordvar:
		5856
		5857	i+=2;
		5858
		5859	case tk_intvar:
		5860
		5861	case tk_charvar:
		5862
		5863	if(tok!=tk_xmmreg)xmmregexpected(2);
		5864
		5865	KillVar(hstok.name);
		5866
		5867	if(code2)op(code2);
		5868
		5869	op(code+addc);
		5870
		5871	outaddress(&hstok);
		5872
		5873	default:
		5874
		5875	break;
		5876
		5877	}
		5878
		5879	void movxmm2(int code,int code2)
		5880
		5881	int i=1,htok;
		5882
		5883	char *hbuf;
		5884
		5885	nexttok();
		5886
		5887	hstok=itok;
		5888
		5889	bufrm=NULL;
		5890
		5891	strinf.bufstr=NULL;
		5892
		5893	switch(htok){
		5894
		5895	switch(tok){
		5896
		5897	i+=4;
		5898
		5899	case tk_dwordvar:
		5900
		5901	i+=2;
		5902
		5903	case tk_intvar:
		5904
		5905	case tk_charvar:
		5906
		5907	CheckAllMassiv(bufrm,i,&strinf);
		5908
		5909	if(code2)op(code2);
		5910
		5911	op(code);
		5912
		5913	outaddress(&itok);
		5914
		5915	default:
		5916
		5917	break;
		5918
		5919	break;
		5920
		5921	i+=4;
		5922
		5923	case tk_dwordvar:
		5924
		5925	i+=2;
		5926
		5927	case tk_intvar:
		5928
		5929	case tk_charvar:
		5930
		5931	if(tok!=tk_xmmreg)xmmregexpected(2);
		5932
		5933	KillVar(hstok.name);
		5934
		5935	if(code2)op(code2);
		5936
		5937	op(code+1);
		5938
		5939	outaddress(&hstok);
		5940
		5941	default:
		5942
		5943	break;
		5944
		5945	}
		5946
		5947	void shiftxmm(int rm) //rxmm,i8
		5948
		5949	int num;
		5950
		5951	if(tok!=tk_xmmreg)xmmregexpected(1);
		5952
		5953	nextexpecting2(tk_camma);
		5954
		5955	op(0x66);
		5956
		5957	op(0x73);
		5958
		5959	op(doconstdwordmath());
		5960
		5961
		5962
		5963	{
		5964
		5965	char name[IDLENGTH];
		5966
		5967	if(dbg&2)AddDataNullLine(faradd==0?2:4);
		5968
		5969	asmparam=FALSE;
		5970
		5971	i=1;
		5972
		5973	CheckIP();
		5974
		5975	switch(tok){
		5976
		5977	tok=tk_number;
		5978
		5979	case tk_number:
		5980
		5981	if(tok==tk_id&&strcmp((char *)string,"dup")==0){
		5982
		5983	nexttok();
		5984
		5985	htok=tok;
		5986
		5987	tok=tk_number;
		5988
		5989	}
		5990
		5991	else numexpected();
		5992
		5993	for(;i!=0;i--){
		5994
		5995	if(htok==tk_undefofs)AddUndefOff(2,name);
		5996
		5997	else outword(hnumber);
		5998
		5999	break;
		6000
		6001	setwordpost(&itok);
		6002
		6003	else outword(itok.number);
		6004
		6005	break;
		6006
		6007	numexpected();
		6008
		6009	break;
		6010
		6011	}while(tok==tk_camma);
		6012
		6013	}
		6014
		6015	void AADM(int code)
		6016
		6017	op(code);
		6018
		6019	if(tok2==tk_number)nexttok();
		6020
		6021	ClearReg(AX);
		6022
		6023
		6024
		6025	{
		6026
		6027	int razr;
		6028
		6029	unsigned long hnumber;
		6030
		6031	int next=1;
		6032
		6033	razr=r16;
		6034
		6035	case tk_id:
		6036
		6037	if((stricmp("dword",(char )string)==0)\|\|(stricmp("long",(char )string)==0))i=r32;
		6038
		6039	else return FALSE;
		6040
		6041	case tk_dword:
		6042
		6043	i=r32;
		6044
		6045	case tk_int:
		6046
		6047	i=r16;
		6048
		6049	nexttok();
		6050
		6051	if(tok==tk_number)goto pushnum;
		6052
		6053	return FALSE;
		6054
		6055	possiblecpu=3;
		6056
		6057	op66(tok==tk_reg?r16:r32);
		6058
		6059	break;
		6060
		6061	PushSeg((unsigned int)itok.number);
		6062
		6063	case tk_undefofs:
		6064
		6065	hstok=itok;
		6066
		6067	hnumber=doconstlongmath();
		6068
		6069	op(0x68);
		6070
		6071	AddUndefOff(2,hstok.name);
		6072
		6073	else outdword(hnumber);
		6074
		6075	next=0;
		6076
		6077	case tk_minus:
		6078
		6079	case tk_number:
		6080
		6081	hnumber=doconstlongmath();
		6082
		6083	else hnumber&=0xffffffff;
		6084
		6085	op66(i);
		6086
		6087	op(0x6A);
		6088
		6089	}
		6090
		6091	op(0x68);
		6092
		6093	if(i==r16)outword(hnumber);
		6094
		6095	}
		6096
		6097	next=0;
		6098
		6099	case tk_dwordvar:
		6100
		6101	CheckAllMassiv(bufrm,4,&strinf);
		6102
		6103	razr=r32;
		6104
		6105	case tk_wordvar:
		6106
		6107	CheckAllMassiv(bufrm,2,&strinf);
		6108
		6109	op66(razr);
		6110
		6111	op(0xFF); op(0x30+itok.rm);
		6112
		6113	break;
		6114
		6115	op(0x68);
		6116
		6117	if(am32==FALSE)outword((unsigned int)itok.number);
		6118
		6119	break;
		6120
		6121	op66(i);
		6122
		6123	if(am32==FALSE)outword(addpoststring());
		6124
		6125	break;
		6126
		6127	return FALSE;
		6128
		6129	if(cpu
		6130
		6131	if(next)nexttok();
		6132
		6133	}
		6134
		6135	>
		6136
		6137
		6138
		6139	>
		6140
		6141
		6142
		6143	>
		6144
		6145
		6146
		6147	>
		6148
		6149	>
		6150
		6151
		6152
		6153	>
		6154
		6155	>
		6156
		6157	>
		6158
		6159	>
		6160
		6161	>
		6162
		6163	>
		6164
		6165	}
		6166
		6167	void>
		6168
		6169	}
		6170
		6171	void>
		6172
		6173	}
		6174
		6175	void>
		6176
		6177	>
		6178
		6179	}
		6180
		6181	void>
		6182
		6183	>
		6184
		6185	>
		6186
		6187	>
		6188
		6189	}
		6190
		6191	void>
		6192
		6193	>
		6194
		6195	>
		6196
		6197	>
		6198
		6199

Subversion Repositories Kolibri OS

(root)/programs/develop/cmm/tokr.cpp @ 7626 – Rev 6446