Context Navigation

NumOpe.cpp@ 154

Last change on this file since 154 was 140, checked in by dai_9181, 17 years ago
traceログ機能を搭載動的メンバをstl::vectorにまとめたシンボルをクラス化した
File size: 30.5 KB

Line
1	#include "../BasicCompiler_Common/common.h"
2	#include "Opcode.h"
3
4	void NewStringObject(int reg, const char *str){
5	///////////////////////////////////////////////////////
6	// lpszTextを元にStringオブジェクトを生成し、
7	// オブジェクトポインタをregに格納する
8	///////////////////////////////////////////////////////
9
10
11	//////////////////////////////////////////////////////
12	///// レジスタ資源のバックアップ
13	{ BACKUP_REGISTER_RESOURCE
14	//////////////////////////////////////////////////////
15
16	char parameter = (char )malloc( lstrlen( str ) + 32 );
17	sprintf( parameter, "\"%s\"%c%c*Char", str, 1, ESC_AS );
18	SetStringQuotes( parameter );
19
20	Operator_New( pobj_DBClass->GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, pobj_DBClass->GetStringClassPtr() ) );
21
22	free( parameter );
23
24	//mov reg,rax
25	op_mov_RR( reg, REG_RAX );
26
27	/////////////////////////////////////////////
28	////// レジスタ資源を復元
29	RESTORE_REGISTER_RESOURCE
30	}////////////////////////////////////////////
31	}
32
33	void SetUseRegFromRax(int type,int UseReg,int XmmReg){
34	if(IsRealNumberType(type)){
35	//実数型
36	if(XmmReg==REG_XMM4){
37	if(type==DEF_DOUBLE){
38	//movsd qword ptr[rsp+offset],xmm0 ※スタックフレームを利用
39	pobj_sf->push(REG_XMM0,sizeof(double));
40	}
41	if(type==DEF_SINGLE){
42	//movss dword ptr[rsp+offset],xmm0 ※スタックフレームを利用
43	pobj_sf->push(REG_XMM0,sizeof(float));
44	}
45	}
46	else{
47	if(type==DEF_DOUBLE){
48	//movsd xmm_reg,xmm0
49	op_movsd_RR(XmmReg,REG_XMM0);
50	}
51	else if(type==DEF_SINGLE){
52	//movss xmm_reg,xmm0
53	op_movss_RR(XmmReg,REG_XMM0);
54	}
55	}
56	}
57	else{
58	//整数型
59	if(UseReg==REG_R14){
60	//mov qword ptr[rsp+offset],rax ※スタックフレームを利用
61	pobj_sf->push(REG_RAX);
62	}
63	else{
64	//mov reg,rax
65	op_mov_RR(UseReg,REG_RAX);
66	}
67	}
68	}
69
70	void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
71	switch( Type::GetBasicSize( bigBasicType ) ){
72	case sizeof(_int64):
73	ExtendTypeTo64(baseBasicType,reg);
74	break;
75	case sizeof(long):
76	ExtendTypeTo32(baseBasicType,reg);
77	break;
78	case sizeof(short):
79	ExtendTypeTo16(baseBasicType,reg);
80	break;
81	}
82	}
83
84
85	bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
86	int UseReg=pobj_reg->GetNextReg();
87	int XmmReg=pobj_reg->GetNextXmmReg();
88
89	//大きな型への暗黙の変換
90	int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
91
92	if(resultType.GetBasicType()&FLAG_PTR){
93	//配列ポインタ
94	resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
95
96	SetVarPtrToReg(UseReg,&relativeVar);
97	}
98	else if(resultType.IsReal()){
99	//実数型
100	if( resultType.IsDouble() )
101	SetXmmReg_DoubleVariable(&relativeVar,XmmReg);
102	if( resultType.IsSingle() )
103	SetXmmReg_SingleVariable(&relativeVar,XmmReg);
104	}
105	else if( resultType.IsWhole() \|\| resultType.IsObject()){
106	//整数型
107	SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,UseReg);
108	}
109	else if( resultType.IsStruct() ){
110	//構造体ポインタをUseRegへ格納（構造体は値型）
111	SetVarPtrToReg(UseReg,&relativeVar);
112	}
113	else{
114	return false;
115	}
116
117	if( resultType.GetBasicType() != bigType ){
118	// 大きな型へ変換された場合
119	// ※レジスタの値をキャストする
120	ExtendRegToBigType( UseReg, bigType, resultType.GetBasicType() );
121
122	resultType.SetBasicType( bigType );
123	}
124
125	return true;
126	}
127	bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char termFull, const char termLeft, const char *member ){
128
129	int UseReg=pobj_reg->GetNextReg();
130	int XmmReg=pobj_reg->GetNextXmmReg();
131
132
133	if( GetMemberType( objClass, member, resultType, 0, false ) ){
134	// メンバが見つかったとき
135
136	//オブジェクトポインタをr11にコピー
137	op_mov_RR( REG_R11, UseReg );
138
139	RELATIVE_VAR relativeVar;
140	relativeVar.dwKind=VAR_DIRECTMEM;
141
142	if( !_member_offset(
143	true, //エラー表示あり
144	false, //読み込み専用
145	objClass,
146	member,&relativeVar,resultType,0)){
147	return false;
148	}
149
150	if( !VarToReg( relativeVar, baseType, resultType ) ){
151	SetError(11,termFull,cp);
152	}
153
154	return true;
155	}
156
157
158	///////////////////////////////////////////////////////////////////
159	// 動的メソッドを検索
160	///////////////////////////////////////////////////////////////////
161	vector<UserProc *> userProcs;
162
163	char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
164	CClass::RefType refType;
165	lstrcpy( methodName, member );
166	GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
167
168	objClass.GetMethods().Enum( methodName, userProcs );
169	UserProc *pUserProc;
170	if(userProcs.size()){
171	//オーバーロードを解決
172	pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
173
174	if( pUserProc ){
175
176	resultType = pUserProc->ReturnType();
177
178
179	//////////////////////////////////////////////////////
180	///// レジスタ資源のバックアップ
181	{ BACKUP_REGISTER_RESOURCE
182	//////////////////////////////////////////////////////
183
184	//オブジェクトポインタをスタックに入れておく
185	//mov qword ptr[rsp+offset],reg ※スタックフレームを利用
186	pobj_sf->push( UseReg );
187
188	if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
189	//レジスタ資源を復元
190	RESTORE_REGISTER_RESOURCE
191
192	return false;
193	}
194
195	pobj_sf->pop();
196
197	/////////////////////
198	// 戻り値の処理
199	/////////////////////
200
201	//大きな型への暗黙の変換
202	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
203
204	if( resultType.GetBasicType() != bigType ){
205	// 大きな型へ変換された場合
206	// ※レジスタの値をキャストする
207	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
208
209	resultType.SetBasicType( bigType );
210	}
211
212	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
213
214
215	/////////////////////////////////////////////
216	////// レジスタ資源を復元
217	RESTORE_REGISTER_RESOURCE
218	}////////////////////////////////////////////
219
220	return true;
221	}
222	}
223
224	return false;
225	}
226	bool TermOpe( const char term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL pbUseHeap, bool isWantObject, bool *pIsClassName, bool isProcedureCallOnly ){
227	char parameter[VN_SIZE];
228
229	// Withを解決
230	char termFull[VN_SIZE];
231	if(term[0]=='.'){
232	GetWithName(termFull);
233	lstrcat(termFull,term);
234	}
235	else lstrcpy(termFull,term);
236
237	char termLeft[VN_SIZE];
238	lstrcpy(termLeft,termFull);
239
240	// パース
241	char member[VN_SIZE];
242	CClass::RefType refType;
243	if( SplitMemberName( termFull, termLeft, member, refType ) ){
244	///////////////////////////////////////////////////////////////////
245	// オブジェクトとメンバに分解できるとき
246	// termLeft.member
247	///////////////////////////////////////////////////////////////////
248
249	isLiteral = false;
250
251	// オブジェクト側の型を取得
252	bool isClassName = false;
253	Type leftType;
254	if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
255	if( isClassName == false && Smoothie::Meta::blittableTypes.IsExist( leftType ) ){
256	// 左側のオブジェクト部分がBlittable型のとき
257
258	char temporary[VN_SIZE];
259	lstrcpy( temporary, termLeft );
260	sprintf( termLeft, "%s(%s)",
261	Smoothie::Meta::blittableTypes.Find( leftType ).GetCreateStaticMethodFullName().c_str(),
262	temporary );
263	}
264	}
265
266	if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, true, &isClassName ) ){
267	goto globalArea;
268	}
269
270	if( isClassName ){
271	// 静的メンバ/メソッドの場合
272	goto globalArea;
273	}
274
275	if( !leftType.HasMember() ){
276	// メンバを持たない型の場合
277	return false;
278	}
279
280	return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
281	}
282	globalArea:
283
284	//////////////////////////////////////////////
285	// クラス名かどうかをチェック（静的メンバ用）
286	//////////////////////////////////////////////
287
288	if( pIsClassName ){
289	if( pobj_DBClass->Find( termFull ) ){
290	*pIsClassName = true;
291	return true;
292	}
293	}
294
295
296	/////////////////////////////////////////////////////////////////
297	// グローバル属性エリア
298	/////////////////////////////////////////////////////////////////
299
300	int UseReg=pobj_reg->GetNextReg();
301	int XmmReg=pobj_reg->GetNextXmmReg();
302
303
304	if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
305	//Thisオブジェクト
306	resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
307
308	SetThisPtrToReg( UseReg );
309
310	isLiteral = false;
311
312	return true;
313	}
314
315
316	//////////////////////////////////////
317	// 関数（DLL、ユーザー定義、組み込み）
318	//////////////////////////////////////
319	char procName[VN_SIZE];
320	char temporary[8192];
321
322	int i2=GetCallProcName(termFull,procName);
323	if(termFull[i2]=='('){
324	int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
325
326	void *pInfo;
327	int idProc=GetProc(procName,(void **)&pInfo);
328
329	if(idProc){
330	//閉じカッコ")"に続く文字がNULLでないとき
331	if(termFull[i2+1+i4+1]!='\0'){
332	SetError(42,NULL,cp);
333	}
334
335
336	//////////////////////////////////////////////////////
337	///// レジスタ資源のバックアップ
338	{ BACKUP_REGISTER_RESOURCE
339	//////////////////////////////////////////////////////
340
341
342	////////////////
343	// 呼び出し
344	////////////////
345
346	CallProc(idProc,pInfo,procName,parameter,resultType);
347
348
349	/////////////////////
350	// 戻り値の処理
351	/////////////////////
352
353	//大きな型への暗黙の変換
354	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
355
356	if( resultType.GetBasicType() != bigType ){
357	// 大きな型へ変換された場合
358	// ※レジスタの値をキャストする
359	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
360
361	resultType.SetBasicType( bigType );
362	}
363
364	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
365
366	/////////////////////////////////////////////
367	////// レジスタ資源を復元
368	RESTORE_REGISTER_RESOURCE
369	}////////////////////////////////////////////
370
371	if(resultType.IsStruct()){
372	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
373	//※後にfreeする必要あり
374	// TODO: 解放はGCに任せる
375	*pbUseHeap = 1;
376	}
377
378	isLiteral = false;
379
380	return true;
381	}
382	else if(GetConstCalcBuffer(procName,parameter,temporary)){
383	/////////////////////////
384	// マクロ関数
385	/////////////////////////
386
387	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
388	if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
389
390	//マクロ関数の場合
391	NumOpe(&UseReg,temporary,Type(),resultType);
392
393	if(!IS_LITERAL(resultType.GetIndex())){
394	//リテラル値ではなかったとき
395	isLiteral = false;
396	}
397
398	return true;
399	}
400	}
401	else if( isProcedureCallOnly ){
402	// 関数呼び出し以外は受け付けない
403	return false;
404	}
405
406
407	////////////////////////////////
408	// インデクサ（getアクセサ）
409	////////////////////////////////
410
411	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
412	GetArrayElement(termFull,VarName,ArrayElements);
413	if(ArrayElements[0]){
414	GetVarType(VarName,resultType,false);
415	if( resultType.IsObject() ){
416	CallIndexerGetterProc(UseReg,&resultType.GetClass(),VarName,ArrayElements,resultType);
417
418	isLiteral = false;
419
420	return true;
421	}
422	}
423
424
425	////////////////////////////////
426	// 変数
427	////////////////////////////////
428
429	RELATIVE_VAR relativeVar;
430	if(GetVarOffset(
431	false, //エラー表示なし
432	false, //読み込み専用
433	termFull,
434	&relativeVar,resultType)){
435	//////////
436	// 変数
437	//////////
438
439	if( !VarToReg( relativeVar, baseType, resultType ) ){
440	SetError(11,termFull,cp);
441	}
442
443	isLiteral = false;
444
445	return true;
446	}
447
448	/*
449	////////////////////////////////
450	// 型名
451	////////////////////////////////
452
453	if( Type::StringToType( termFull, resultType ) ){
454	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
455	return true;
456	}*/
457
458
459	/////////////////////////////////
460	// プロパティ用のメソッド
461	/////////////////////////////////
462
463	//配列要素を排除
464	GetArrayElement(termFull,VarName,ArrayElements);
465
466	if(GetSubHash(VarName,0)){
467
468	//////////////////////////////////////////////////////
469	///// レジスタ資源のバックアップ
470	{ BACKUP_REGISTER_RESOURCE
471	//////////////////////////////////////////////////////
472
473	CallPropertyMethod(termFull,NULL,resultType);
474
475	//大きな型への暗黙の変換
476	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
477
478	if( resultType.GetBasicType() != bigType ){
479	// 大きな型へ変換された場合
480	// ※レジスタの値をキャストする
481	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
482
483	resultType.SetBasicType( bigType );
484	}
485
486	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
487
488	/////////////////////////////////////////////
489	////// レジスタ資源を復元
490	RESTORE_REGISTER_RESOURCE
491	}////////////////////////////////////////////
492
493	if(resultType.IsStruct()){
494	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
495	//※後にfreeする必要あり
496	// TODO: 解放はGCに任せる
497	*pbUseHeap = 1;
498	}
499
500	isLiteral = false;
501
502	return true;
503	}
504
505
506	return false;
507	}
508
509	bool NumOpe( int *pReg,
510	const char *expression,
511	const Type &baseType,
512	Type &resultType,
513	BOOL *pbUseHeap ){
514
515	int i,i2,i3;
516	char temporary[1024],temp2[1024];
517
518	if(expression[0]=='\0'){
519	SetError(1,NULL,cp);
520	return false;
521	}
522
523	if(expression[0]==1&& expression[1]==ESC_NEW ){
524	//New演算子（オブジェクト生成）
525
526	if( pobj_BlockReg->check(REG_RAX) ){
527	SetError();
528	}
529
530	//////////////////////////////////////////////////////
531	///// レジスタ資源のバックアップ
532	{ BACKUP_REGISTER_RESOURCE
533	//////////////////////////////////////////////////////
534
535	if( !Operator_New( expression+2, baseType, resultType ) ){
536	return false;
537	}
538
539	/////////////////////////////////////////////
540	////// レジスタ資源を復元
541	RESTORE_REGISTER_RESOURCE
542	}////////////////////////////////////////////
543
544	//mov reg,rax
545	op_mov_RR( *pReg, REG_RAX );
546
547	return true;
548	}
549
550	if( !baseType.IsNull() && expression[0] == '[' ){
551	// リテラル配列の場合
552
553	if( !baseType.IsPointer() ){
554	SetError(1,NULL,cp);
555	return false;
556	}
557	Type tempBaseType( baseType );
558	tempBaseType.PtrLevelDown();
559
560	char buffer = (char )malloc( lstrlen( expression ) + 1 );
561	lstrcpy( buffer, expression );
562	RemoveStringBracket( buffer );
563
564	void *binary = malloc( 1 );
565	int num = 0;
566
567	i = 0;
568	while( buffer[i] ){
569	i = GetOneParameter( buffer, i, temporary );
570	if( buffer[i] == ',' ){
571	i++;
572	}
573
574	Type resultType;
575	_int64 i64data;
576	if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
577	return false;
578	}
579	if( !resultType.IsWhole() ){
580	// TODO: 実数に未対応
581	SetError();
582	return false;
583	}
584
585	binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
586	memcpy( (char )binary + (num tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
587	num++;
588	}
589
590	i2 = dataTable.AddBinary( binary, num * tempBaseType.GetSize() );
591
592	//mov reg,i2
593	op_mov_RV(sizeof(_int64),*pReg,i2);
594	obp-=sizeof(long);
595	pobj_DataTableSchedule->add();
596	obp+=sizeof(long);
597
598	free( buffer );
599
600	resultType = baseType;
601
602	return true;
603	}
604
605
606	/////////////////////////////////
607	// 式要素を逆ポーランド式で取得
608	/////////////////////////////////
609
610	char *values[255];
611	long calc[255];
612	long stack[255];
613	int pnum;
614	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
615	for(i=0;i<pnum;i++){
616	if(values[i]) HeapDefaultFree(values[i]);
617	}
618	return 0;
619	}
620
621
622	BOOL bInitRegSwitch=0;
623	if(!pobj_reg){
624	bInitRegSwitch=1;
625
626	//作業用レジスタを取得
627	pobj_reg=new CRegister(*pReg);
628	}
629
630	//エラー時の復旧用
631	CRegister objReg_Backup;
632	objReg_Backup=*pobj_reg;
633
634
635
636	////////////////////////////////
637	// 演算部分のコード生成を開始
638	////////////////////////////////
639
640	BOOL bError;
641	bError=0;
642
643	//リテラル値のみの計算かどうかを判別するためのフラグ
644	BOOL bLiteralCalculation=1;
645
646	//リテラル演算の場合を考慮した演算前のバッファ位置
647	int BeforeObp;
648	BeforeObp=obp;
649
650	//リテラル演算の場合を考慮した演算前のプロシージャスケジュール位置
651	//※64ビットの掛け算、除算などで特殊関数が呼ばれるため
652	int Before_ProcAddrScheduleNum;
653	Before_ProcAddrScheduleNum=pobj_SubAddrSchedule->num;
654
655	//リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置
656	int Before_DataTableScheduleNum;
657	Before_DataTableScheduleNum=pobj_DataTableSchedule->num;
658
659	//リテラル演算の場合を考慮した演算前の再配置スケジュール
660	CReloc *pobj_BackReloc;
661	pobj_BackReloc=new CReloc();
662	pobj_BackReloc->copy(pobj_Reloc);
663
664	//リテラル演算の場合を考慮した演算前のスタックフレームスケジュール位置
665	int Before_StackFrameScheduleNum;
666	Before_StackFrameScheduleNum=pobj_sf->num;
667
668	double dbl;
669	int sp;
670	int type_stack[255];
671	LONG_PTR index_stack[255];
672	bool isNothing_stack[255];
673	BOOL bUseHeap[255];
674	_int64 i64data;
675	int UseReg,XmmReg;
676	BOOL bXmm;
677	for(i=0,sp=0;i<pnum;i++){
678	int idCalc;
679	idCalc=calc[i]%100;
680
681	if(idCalc){
682	if(type_stack[sp-2]==DEF_OBJECT){
683	if( idCalc == CALC_AS
684	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
685	&& index_stack[sp-1] == index_stack[sp-2]
686	\|\| isNothing_stack[sp-2] ){
687	// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
688	}
689	else if( idCalc == CALC_AS
690	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
691	&& ( ((CClass )index_stack[sp-1])->IsEqualsOrSubClass( (CClass )index_stack[sp-2] ) \|\| ((CClass )index_stack[sp-2])->IsEqualsOrSubClass( (CClass )index_stack[sp-1] )
692	)){
693	// ダウンキャストを許可する
694	}
695	else if( idCalc == CALC_AS
696	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST ) && ((CClass *)index_stack[sp-1])->IsInterface()
697	){
698	// インターフェイスへのキャスト
699	// TODO: 実装
700	CastToInterface( pobj_reg->GetLockingReg(), REG_R15, (CClass )index_stack[sp-2], (CClass )index_stack[sp-1] );
701	}
702	else{
703	//オーバーロードされたオペレータを呼び出す
704	i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
705	if(i2==0){
706	if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
707	else GetCalcName(idCalc,temp2);
708	sprintf(temporary,"Operator %s",temp2);
709	SetError(27,temporary,cp);
710	goto error;
711	}
712	else if(i2==-1) goto error;
713
714	continue;
715	}
716	}
717
718	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
719	}
720
721	switch(idCalc){
722	//数値
723	case 0:
724	index_stack[sp]=-1;
725	isNothing_stack[sp] = false;
726	bUseHeap[sp]=0;
727
728	UseReg=pobj_reg->GetNextReg();
729	XmmReg=pobj_reg->GetNextXmmReg();
730
731	bXmm=0;
732
733	char *term;
734	term=values[i];
735
736	if( calc[i+1]%100 == CALC_AS ){
737	// As演算子の右辺値
738	//型名
739	if( Type::StringToType( term, resultType ) ){
740	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
741	}
742	else{
743	SetError(3, term, cp );
744	goto error;
745	}
746
747	type_stack[sp] = resultType.GetBasicType();
748	index_stack[sp] = resultType.GetIndex();
749	sp++;
750
751	break;
752	}
753
754	if(term[0]=='\"'){
755	//リテラル文字列
756	if(!RemoveStringQuotes(term)){
757	SetError(43,NULL,cp);
758	goto error;
759	}
760	i3=lstrlen(term);
761	StrLiteral:
762
763	if( baseType.IsObject() \|\| baseType.IsNull() ){
764	//要求タイプがオブジェクト、または未定のとき
765
766	//String型オブジェクトを生成
767	NewStringObject(UseReg,term);
768
769	type_stack[sp]=DEF_OBJECT;
770	index_stack[sp]=(LONG_PTR)pobj_DBClass->GetStringClassPtr();
771	bLiteralCalculation=0;
772
773	if(bXmm) pobj_reg->LockXmmReg();
774	else pobj_reg->LockReg();
775
776	sp++;
777	break;
778	}
779
780	type_stack[sp]=typeOfPtrChar;
781	bLiteralCalculation=0;
782
783	i2 = dataTable.AddString( term, i3 );
784
785	//mov reg,i2
786	op_mov_RV(sizeof(_int64),UseReg,i2);
787	obp-=sizeof(long);
788	pobj_DataTableSchedule->add();
789	obp+=sizeof(long);
790
791	if(UseReg==REG_R14){
792	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
793	pobj_sf->push(REG_R14);
794	}
795	}
796	else if((term[0]=='e'\|\|term[0]=='E')&&
797	(term[1]=='x'\|\|term[1]=='X')&&
798	term[2]=='\"'){
799	//拡張版リテラル文字列（エスケープシーケンス可能）
800	if(!RemoveStringQuotes(term+2)){
801	SetError(43,NULL,cp);
802	goto error;
803	}
804	i3=FormatString_EscapeSequence(term+2);
805	term+=2;
806
807	goto StrLiteral;
808	}
809	else if(IsVariableTopChar(term[0])\|\|
810	term[0]=='*'\|\|
811	(term[0]=='.'&&IsVariableTopChar(term[1]))){
812	//////////////////
813	// 何らかの識別子
814
815	bool isLiteral;
816	if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
817	if(resultType.IsNull()){
818	//戻り値が存在しないとき
819	for(i2=0;;i2++){
820	if(term[i2]=='('\|\|term[i2]=='\0'){
821	term[i2]=0;
822	break;
823	}
824	}
825	SetError(38,term,cp);
826
827	goto error;
828	}
829
830	type_stack[sp] = resultType.GetBasicType();
831	index_stack[sp] = resultType.GetIndex();
832
833	if( !isLiteral ){
834	bLiteralCalculation=0;
835	}
836
837	if( resultType.GetBasicType() & FLAG_CAST ){
838	// 型名のみ
839	SetError();
840	}
841	else{
842	if( resultType.IsReal() == false && UseReg==REG_R14 ){
843	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
844	pobj_sf->push(REG_R14);
845	}
846	if( resultType.IsReal() && XmmReg==REG_XMM4 ){
847	if(resultType.IsDouble()){
848	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
849	pobj_sf->push(REG_XMM4,sizeof(double));
850	}
851	if(resultType.IsSingle()){
852	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
853	pobj_sf->push(REG_XMM4,sizeof(float));
854	}
855	}
856
857	if( resultType.IsReal() ){
858	pobj_reg->LockXmmReg();
859	}
860	else{
861	pobj_reg->LockReg();
862	}
863	}
864
865	sp++;
866	break;
867	}
868
869
870	// Nothing
871	if( lstrcmp( term, "Nothing" ) == 0 ){
872	isNothing_stack[sp] = true;
873
874	type_stack[sp] = DEF_OBJECT;
875	if( baseType.IsObject() ){
876	index_stack[sp] = baseType.GetIndex();
877	}
878	else{
879	index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClassPtr();
880	}
881
882	bLiteralCalculation = 0;
883
884	//xor reg,reg
885	op_zero_reg( UseReg );
886
887	if(UseReg==REG_R14){
888	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
889	pobj_sf->push(REG_R14);
890	}
891
892	pobj_reg->LockReg();
893	sp++;
894	break;
895	}
896
897
898	//////////////
899	// 定数の場合
900	//////////////
901
902	i3 = CDBConst::obj.GetBasicType(term);
903	if(i3){
904	if( CDBConst::obj.IsStringPtr( term ) ){
905	//リテラル文字列
906
907	double dbl = CDBConst::obj.GetDoubleData(term);
908	memcpy(&i64data,&dbl,sizeof(double));
909
910	//バイト数
911	i3=lstrlen((char *)i64data);
912
913	memcpy(term,(char *)i64data,i3);
914	term[i3]=0;
915	goto StrLiteral;
916	}
917
918	type_stack[sp] = i3;
919	if(IsRealNumberType(i3)){
920	//実数
921	double dbl = CDBConst::obj.GetDoubleData(term);
922	memcpy(&i64data,&dbl,sizeof(double));
923	goto Literal;
924	}
925	else if(IsWholeNumberType(i3)){
926	//整数
927	i64data = CDBConst::obj.GetWholeData(term);
928	goto Literal;
929	}
930	/*else if(i3==DEF_STRING){
931	//リテラル文字列
932
933	//バイト数
934	i3=(int)dbl;
935
936	memcpy(term,temporary,i3);
937	goto StrLiteral;
938	}*/
939	else{
940	SetError(1,NULL,0);
941	goto error;
942	}
943	}
944
945
946	//該当する識別子が見当たらないときはエラー扱いにする
947	bError=1;
948	SetError(3,term,cp);
949	type_stack[sp]=DEF_DOUBLE;
950	}
951	else{
952	//リテラル値
953	type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
954	Literal:
955	if(type_stack[sp]==DEF_DOUBLE){
956	//64ビット浮動小数型
957	bXmm=1;
958
959	if(XmmReg==REG_XMM4){
960	//mov r14,i64data
961	op_mov64_ToReg(REG_R14,i64data);
962
963
964	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
965	pobj_sf->push(REG_R14);
966	}
967	else{
968	i3 = dataTable.Add( i64data );
969
970	//movlpd xmm_reg,qword ptr[data table offset]
971	OpBuffer[obp++]=(char)0x66;
972	OpBuffer[obp++]=(char)0x0F;
973	OpBuffer[obp++]=(char)0x12;
974	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
975	OpBuffer[obp++]=(char)0x25;
976	((long )(OpBuffer+obp))=i3;
977	pobj_DataTableSchedule->add();
978	obp+=sizeof(long);
979	}
980	}
981	else if(type_stack[sp]==DEF_SINGLE){
982	//32ビット浮動小数型
983	bXmm=1;
984
985	float flt;
986	int i32data;
987	memcpy(&dbl,&i64data,sizeof(double));
988	flt=(float)dbl;
989	memcpy(&i32data,&flt,sizeof(long));
990
991	if(XmmReg==REG_XMM4){
992	SetError(); // TODO: 未実装
993	//push term
994	op_push_value(i32data);
995	}
996	else{
997	i3=dataTable.Add( i32data );
998
999	//movss xmm_reg,dword ptr[data table offset]
1000	OpBuffer[obp++]=(char)0xF3;
1001	OpBuffer[obp++]=(char)0x0F;
1002	OpBuffer[obp++]=(char)0x10;
1003	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
1004	OpBuffer[obp++]=(char)0x25;
1005	((long )(OpBuffer+obp))=i3;
1006	pobj_DataTableSchedule->add();
1007	obp+=sizeof(long);
1008	}
1009	}
1010	else{
1011	//整数
1012
1013	index_stack[sp]=GetLiteralIndex(i64data);
1014
1015	//mov reg,i64data
1016	op_mov64_ToReg(UseReg,i64data);
1017
1018	if(UseReg==REG_R14){
1019	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
1020	pobj_sf->push(REG_R14);
1021	}
1022	}
1023	}
1024
1025	if(bXmm) pobj_reg->LockXmmReg();
1026	else pobj_reg->LockReg();
1027
1028	sp++;
1029	break;
1030
1031	//論理演算子
1032	case CALC_XOR:
1033	case CALC_OR:
1034	case CALC_AND:
1035	if(!CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp)) goto error;
1036	break;
1037	case CALC_NOT:
1038	//value[sp-1]=Not value[sp-1]
1039	//NOT演算子
1040	if(!Calc_Not(type_stack,sp)) goto error;
1041	break;
1042
1043	//比較演算子
1044	case CALC_PE: //value[sp-2] <= value[sp-1]
1045	case CALC_QE: //value[sp-2] >= value[sp-1]
1046	case CALC_P: //value[sp-2] < value[sp-1]
1047	case CALC_Q: //value[sp-2] > value[sp-1]
1048	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
1049	case CALC_EQUAL: //value[sp-2] = value[sp-1]
1050	if(!CalcTwoTerm_Relational(idCalc,type_stack,index_stack,&sp)) goto error;
1051	break;
1052
1053	//ビットシフト
1054	case CALC_SHL: //value[sp-2] << value[sp-1]
1055	case CALC_SHR: //value[sp-2] >> value[sp-1]
1056	if(!Calc_Shift(idCalc,type_stack,&sp)) goto error;
1057	break;
1058
1059	//算術演算
1060	case CALC_ADDITION:
1061	case CALC_SUBTRACTION:
1062	case CALC_PRODUCT:
1063	if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
1064	break;
1065	case CALC_MOD:
1066	//value[sp-2]%=value[sp-1]
1067	//剰余演算
1068	if(!Calc_Mod(type_stack,index_stack,&sp)) goto error;
1069	break;
1070	case CALC_QUOTIENT:
1071	//value[sp-2]/=value[sp-1];
1072	//除算
1073	if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
1074	break;
1075	case CALC_INTQUOTIENT:
1076	//value[sp-2]/=value[sp-1]
1077	//整数除算
1078	if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
1079	break;
1080	case CALC_MINUSMARK:
1081	//value[sp-1]=-value[sp-1]
1082	//符号反転
1083	if(!Calc_MinusMark(type_stack,sp)) goto error;
1084	break;
1085	case CALC_POWER:
1086	//べき乗演算（浮動小数点演算のみ）
1087	if(!Calc_Power(type_stack,&sp)) goto error;
1088	break;
1089	case CALC_AS:
1090	//キャスト
1091	if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
1092	break;
1093	case CALC_BYVAL:
1094	//ポインタ型→参照型
1095	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
1096	//ポインタ型ではないとき
1097	SetError( 3, NULL, cp );
1098	goto error;
1099	}
1100
1101	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
1102
1103	break;
1104
1105	default:
1106	SetError(300,NULL,cp);
1107	goto error;
1108	}
1109	}
1110
1111	if(bError) goto error;
1112
1113	if(sp!=1){
1114	SetError(1,NULL,cp);
1115	goto error;
1116	}
1117
1118	if(bLiteralCalculation){
1119	//右辺値が数値の定数式の場合
1120	Type resultType;
1121	StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
1122
1123	obp=BeforeObp;
1124	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
1125	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
1126	pobj_Reloc->copy(pobj_BackReloc);
1127	pobj_sf->num=Before_StackFrameScheduleNum;
1128	*pobj_reg=objReg_Backup;
1129
1130	if(resultType.IsReal()){
1131	if(baseType.IsReal()) resultType=baseType;
1132
1133	XmmReg=pobj_reg->LockXmmReg();
1134
1135	if(resultType.IsDouble()){
1136	i3 = dataTable.Add( i64data );
1137
1138	//movlpd xmm_reg,qword ptr[data table offset]
1139	OpBuffer[obp++]=(char)0x66;
1140	OpBuffer[obp++]=(char)0x0F;
1141	OpBuffer[obp++]=(char)0x12;
1142	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
1143	OpBuffer[obp++]=(char)0x25;
1144	((long )(OpBuffer+obp))=i3;
1145	pobj_DataTableSchedule->add();
1146	obp+=sizeof(long);
1147	}
1148	if(resultType.IsSingle()){
1149	memcpy(&dbl,&i64data,sizeof(_int64));
1150
1151	float flt;
1152	int i32data;
1153	flt=(float)dbl;
1154	memcpy(&i32data,&flt,sizeof(long));
1155
1156	i3 = dataTable.Add( i32data );
1157
1158	//movss xmm_reg,dword ptr[data table offset]
1159	OpBuffer[obp++]=(char)0xF3;
1160	OpBuffer[obp++]=(char)0x0F;
1161	OpBuffer[obp++]=(char)0x10;
1162	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
1163	OpBuffer[obp++]=(char)0x25;
1164	((long )(OpBuffer+obp))=i3;
1165	pobj_DataTableSchedule->add();
1166	obp+=sizeof(long);
1167	}
1168	}
1169	else{
1170	if(!resultType.Is64()){
1171	//整数（符号有り/無し）
1172
1173	i3=(long)i64data;
1174
1175	if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
1176	if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
1177
1178	i64data=(_int64)i3;
1179	}
1180
1181	UseReg=pobj_reg->LockReg();
1182
1183	//mov reg,i64data
1184	op_mov64_ToReg(UseReg,i64data);
1185	}
1186
1187	type_stack[0]=resultType.GetBasicType();
1188	index_stack[0]=resultType.GetIndex();
1189	}
1190	else{
1191	//右辺値が数値の定数式ではないとき
1192	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
1193	}
1194
1195	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
1196
1197	if(IsRealNumberType(type_stack[0]))
1198	*pReg=pobj_reg->UnlockXmmReg();
1199	else
1200	*pReg=pobj_reg->UnlockReg();
1201
1202
1203	if(bInitRegSwitch){
1204	//整合性をチェック（バグ回避）
1205	pobj_reg->bug_check();
1206
1207	//作業レジスタを解放
1208	delete pobj_reg;
1209	pobj_reg=0;
1210	}
1211
1212	resultType.SetType( type_stack[0], index_stack[0] );
1213
1214	bool isSuccessful = true;
1215	goto finish;
1216
1217
1218
1219	//////////////////
1220	// エラー処理
1221	//////////////////
1222
1223	error:
1224
1225	*pobj_reg=objReg_Backup;
1226
1227	if(bInitRegSwitch){
1228	//作業レジスタを解放
1229	delete pobj_reg;
1230	pobj_reg=0;
1231	}
1232
1233	isSuccessful = false;
1234	goto finish;
1235
1236
1237
1238
1239	finish:
1240
1241	for(i=0;i<pnum;i++){
1242	if(values[i]) HeapDefaultFree(values[i]);
1243	}
1244
1245	//再配置スケジュールバックアップ情報を解放
1246	delete pobj_BackReloc;
1247
1248	return isSuccessful;
1249	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: dev/trunk/abdev/BasicCompiler64/NumOpe.cpp@ 154

Download in other formats: