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

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