source: dev/trunk/abdev/BasicCompiler32/NumOpe.cpp@ 319

Last change on this file since 319 was 319, checked in by dai_9181, 18 years ago

GCのバグをいくつか修正
File size: 27.6 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 PushReturnValue(int type){
12 //関数の戻り値をスタックへプッシュする
13 //※この処理内では、esi、ediは使用不可
14
15 if(type==DEF_OBJECT || type==DEF_STRUCT){
16 //push eax
17 compiler.codeGenerator.op_push(REG_EAX);
18 }
19 else if(type==DEF_DOUBLE){
20 //sub esp,8
21 compiler.codeGenerator.op_sub_esp(8);
22
23 //fstp qword ptr[esp]
24 compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
25 }
26 else if(type==DEF_SINGLE){
27 //sub esp,4
28 compiler.codeGenerator.op_sub_esp(4);
29
30 //fstp dword ptr[esp]
31 compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
32 }
33 else if(type==DEF_INT64||type==DEF_QWORD){
34 //push edx
35 compiler.codeGenerator.op_push(REG_EDX);
36
37 //push eax
38 compiler.codeGenerator.op_push(REG_EAX);
39 }
40 else if(type==DEF_LONG){
41 //push eax
42 compiler.codeGenerator.op_push(REG_EAX);
43 }
44 else if(type==DEF_INTEGER || (Smoothie::IsUnicode()&&type==DEF_CHAR)){
45 //movsx ebx,ax
46 compiler.codeGenerator.op_movsx_R32R16( REG_EBX, REG_EAX );
47
48 //push ebx
49 compiler.codeGenerator.op_push(REG_EBX);
50 }
51 else if(type==DEF_SBYTE || (Smoothie::IsUnicode()==false&&type==DEF_CHAR)){
52 //movsx ebx,al
53 compiler.codeGenerator.op_movsx_R32R8( REG_EBX, REG_EAX );
54
55 //push ebx
56 compiler.codeGenerator.op_push(REG_EBX);
57 }
58 else if(type==DEF_DWORD||type==DEF_WORD||type==DEF_BYTE||type==DEF_BOOLEAN||
59 IsPtrType(type)){
60 //push eax
61 compiler.codeGenerator.op_push(REG_EAX);
62 }
63 else{
64 SetError();
65 }
66}
67
68void NewStringObject( const char *str ){
69 ///////////////////////////////////////////////////////
70 // lpszTextを元にStringオブジェクトを生成し、
71 // オブジェクトポインタをregに格納する
72 ///////////////////////////////////////////////////////
73
74 char *parameter = (char *)malloc( lstrlen( str ) + 32 );
75 sprintf( parameter, "%s%c%c*Char", str, 1, ESC_AS );
76
77 Operator_New( *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() ) );
78
79 free( parameter );
80}
81
82void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
83 if( reg != REG_EAX ){
84 SetError();
85 }
86 switch( Type::GetBasicSize( bigBasicType ) ){
87 case sizeof(_int64):
88 ExtendTypeTo64(baseBasicType);
89 break;
90 case sizeof(long):
91 ExtendTypeTo32(baseBasicType,reg);
92 break;
93 case sizeof(short):
94 ExtendTypeTo16(baseBasicType,reg);
95 break;
96 }
97}
98
99
100
101bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
102 const int useReg = REG_EAX;
103
104 //大きな型への暗黙の変換
105 int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
106
107 if(resultType.GetBasicType()&FLAG_PTR){
108 //配列ポインタ
109 resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
110
111 SetVarPtrToReg(useReg, &relativeVar);
112 }
113 else if( resultType.IsStruct() ){
114 //構造体ポインタをeaxへ格納（構造体は値型）
115 SetVarPtrToReg(useReg, &relativeVar);
116 }
117 else if( resultType.IsReal() ){
118 // 実数
119 SetReg_RealVariable( resultType.GetBasicType(), &relativeVar );
120 }
121 else if( resultType.IsWhole() || resultType.IsObject()){
122 //整数型
123 SetReg_WholeVariable(resultType,&relativeVar,useReg);
124 }
125 else if( resultType.IsStruct() ){
126 //構造体ポインタをUseRegへ格納（構造体は値型）
127 SetVarPtrToReg(useReg,&relativeVar);
128 }
129 else{
130 return false;
131 }
132
133 if( resultType.GetBasicType() != bigType ){
134 // 大きな型へ変換された場合
135 // ※レジスタの値をキャストする
136 ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
137
138 resultType.SetBasicType( bigType );
139 }
140
141 return true;
142}
143bool TermMemberOpe( const Type &leftType, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member )
144{
145 const CClass &objClass = leftType.GetClass();
146
147 const int useReg = REG_EAX;
148
149 if( GetMemberType( leftType, member, resultType, 0, false ) ){
150 // メンバが見つかったとき
151
152 //オブジェクトポインタをecxにコピー
153 compiler.codeGenerator.op_mov_RR( REG_ECX, useReg );
154
155 RELATIVE_VAR relativeVar;
156 relativeVar.dwKind=VAR_DIRECTMEM;
157
158 if( !_member_offset(
159 true, //エラー表示あり
160 false, //読み込み専用
161 leftType,
162 member,&relativeVar,resultType,0)){
163 return false;
164 }
165
166 if( !VarToReg( relativeVar, baseType, resultType ) ){
167 SetError(11,termFull,cp);
168 }
169
170 return true;
171 }
172
173
174 ///////////////////////////////////////////////////////////////////
175 // 動的メソッドを検索
176 ///////////////////////////////////////////////////////////////////
177 vector<const UserProc *> userProcs;
178
179 char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
180 ReferenceKind refType;
181 lstrcpy( methodName, member );
182 GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
183
184 objClass.GetMethods().Enum( methodName, userProcs );
185 if(userProcs.size()){
186 //オーバーロードを解決
187 const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
188
189 if( pUserProc ){
190
191 resultType = pUserProc->ReturnType();
192
193 {
194 //オブジェクトポインタをスタックに入れておく
195 //push reg
196 compiler.codeGenerator.op_push( useReg );
197
198 if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft) ){
199
200 return false;
201 }
202
203 compiler.codeGenerator.op_pop();
204
205 /////////////////////
206 // 戻り値の処理
207 /////////////////////
208
209 //大きな型への暗黙の変換
210 int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
211
212 if( resultType.GetBasicType() != bigType ){
213 // 大きな型へ変換された場合
214 // ※レジスタの値をキャストする
215 ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
216
217 resultType.SetBasicType( bigType );
218 }
219
220 //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
221
222 // 型パラメータを解決
223 ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
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.GetObjectModule().meta.GetBlittableTypes().IsExist( leftType ) ){
262 // 左側のオブジェクト部分がBlittable型のとき
263
264 char temporary[VN_SIZE];
265 lstrcpy( temporary, termLeft );
266 sprintf( termLeft, "%s(%s)",
267 compiler.GetObjectModule().meta.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, baseType, resultType, termFull, termLeft, member );
287 }
288globalArea:
289
290
291 //////////////////////////////////////////////
292 // クラス名かどうかをチェック（静的メンバ用）
293 //////////////////////////////////////////////
294
295 if( pIsClassName ){
296 if( compiler.GetObjectModule().meta.GetClasses().Find( termFull ) ){
297 *pIsClassName = true;
298 return true;
299 }
300 }
301
302
303 /////////////////////////////////////////////////////////////////
304 // グローバル属性エリア
305 /////////////////////////////////////////////////////////////////
306
307 const int useReg = REG_EAX;
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 // 呼び出し
345 ////////////////
346
347 CallProc(idProc,pInfo,procName,parameter,resultType);
348
349
350 /////////////////////
351 // 戻り値の処理
352 /////////////////////
353
354 //大きな型への暗黙の変換
355 int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
356
357 /*
358 ※後でNumOpe内でプッシュする
359 //スタックへプッシュ
360 PushReturnValue( resultType.GetBasicType() );
361 */
362
363 if( resultType.GetBasicType() != bigType ){
364 // 大きな型へ変換された場合
365 // ※レジスタの値をキャストする
366 ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
367
368 resultType.SetBasicType( bigType );
369 }
370
371 //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
372 }
373
374
375 if(resultType.IsStruct()){
376 //構造体が戻ったときはヒープ領域にインスタンスが格納されている
377 //※後にfreeする必要あり
378 // TODO: 解放はGCに任せる
379 *pbUseHeap = 1;
380 }
381
382 isLiteral = false;
383
384 return true;
385 }
386
387 ConstMacro *pConstMacro = compiler.GetObjectModule().meta.GetGlobalConstMacros().Find( procName );
388 if( pConstMacro )
389 {
390 if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
391 {
392 /////////////////////////
393 // マクロ関数
394 /////////////////////////
395
396 //閉じカッコ")"に続く文字がNULLでないときはエラーにする
397 if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
398
399 //マクロ関数の場合
400 NumOpe(useReg, temporary,Type(),resultType);
401
402 if(!IS_LITERAL(resultType.GetIndex())){
403 //リテラル値ではなかったとき
404 isLiteral = false;
405 }
406
407 return true;
408 }
409 }
410 }
411 else if( isProcedureCallOnly ){
412 // 関数呼び出し以外は受け付けない
413 return false;
414 }
415
416
417 ////////////////////////////////
418 // インデクサ（getアクセサ）
419 ////////////////////////////////
420
421 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
422 GetArrayElement(termFull,VarName,ArrayElements);
423 if(ArrayElements[0]){
424 Type classType;
425 GetVarType(VarName,classType,false);
426 if( classType.IsObject() )
427 {
428 CallIndexerGetterProc(/*UseReg,*/classType,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 //配列要素を排除
466 GetArrayElement(termFull,VarName,ArrayElements);
467
468 if(GetSubHash(VarName,0)){
469
470 {
471 CallPropertyMethod(termFull,NULL,resultType);
472
473 //大きな型への暗黙の変換
474 int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
475
476 if( resultType.GetBasicType() != bigType ){
477 // 大きな型へ変換された場合
478 // ※レジスタの値をキャストする
479 ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
480
481 resultType.SetBasicType( bigType );
482 }
483
484 //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
485 }
486
487
488 if(resultType.IsStruct()){
489 //構造体が戻ったときはヒープ領域にインスタンスが格納されている
490 //※後にfreeする必要あり
491 // TODO: 解放はGCに任せる
492 *pbUseHeap = 1;
493 }
494
495 isLiteral = false;
496
497 return true;
498 }
499
500
501 return false;
502}
503
504
505bool NumOpe( int reg,
506 const char *expression,
507 const Type &baseType,
508 Type &resultType,
509 BOOL *pbUseHeap ){
510
511 if( !NumOpe( expression, baseType, resultType, pbUseHeap ) ){
512 return false;
513 }
514
515 if( reg != REG_EAX ){
516 // TODO: 未実装
517 SetError();
518 }
519
520 if( resultType.IsReal() ){
521 //fld ptr[esp]
522 compiler.codeGenerator.op_fld_ptr_esp( resultType.GetBasicType() );
523
524 //add esp,size
525 compiler.codeGenerator.op_add_esp( resultType.GetBasicSize() );
526 }
527 else{
528 //pop eax
529 compiler.codeGenerator.op_pop(REG_EAX);
530
531 if( resultType.Is64() ){
532 //pop edx
533 compiler.codeGenerator.op_pop(REG_EDX);
534 }
535 }
536 return true;
537}
538bool NumOpe( const char *expression,
539 const Type &baseType,
540 Type &resultType,
541 BOOL *pbUseHeap )
542{
543 int i,i2,i3;
544 char temporary[1024],temp2[1024];
545
546 if(expression[0]=='\0'){
547 SetError(1,NULL,cp);
548 return false;
549 }
550
551 if( !baseType.IsNull() && expression[0] == '[' ){
552 // リテラル配列の場合
553
554 if( !baseType.IsPointer() ){
555 SetError(1,NULL,cp);
556 return false;
557 }
558 Type tempBaseType( baseType );
559 tempBaseType.PtrLevelDown();
560
561 char *buffer = (char *)malloc( lstrlen( expression ) + 1 );
562 lstrcpy( buffer, expression );
563 RemoveStringBracket( buffer );
564
565 void *binary = malloc( 1 );
566 int num = 0;
567
568 i = 0;
569 while( buffer[i] ){
570 i = GetOneParameter( buffer, i, temporary );
571 if( buffer[i] == ',' ){
572 i++;
573 }
574
575 Type resultType;
576 _int64 i64data;
577 if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
578 return false;
579 }
580 if( !resultType.IsWhole() ){
581 // TODO: 実数に未対応
582 SetError();
583 return false;
584 }
585
586 binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
587 memcpy( (char *)binary + (num * tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
588 num++;
589 }
590
591 i2 = compiler.GetObjectModule().dataTable.AddBinary( binary, num * tempBaseType.GetSize() );
592
593 //mov eax,i2
594 compiler.codeGenerator.op_mov_RV(REG_EAX,i2, Schedule::DataTable );
595
596 free( buffer );
597
598 resultType = baseType;
599
600 //push eax
601 compiler.codeGenerator.op_push( REG_EAX );
602
603 return true;
604 }
605
606 bool isLiteralCalculation;
607 if( !NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
608 {
609 return false;
610 }
611 if( isLiteralCalculation )
612 {
613 //右辺値が数値の定数式の場合
614 _int64 i64data;
615 StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
616
617 if( resultType.GetBasicSize() == sizeof(_int64) ){
618 //64ビット（符号有り整数/実数）
619
620 //push HILONG(i64data)
621 compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
622
623 //push LOLONG(i64data)
624 compiler.codeGenerator.op_push_V(*(long *)(&i64data));
625 }
626 else if( resultType.IsSingle() ){
627 //single実数
628
629 double dbl;
630 memcpy(&dbl,&i64data,sizeof(_int64));
631
632 float flt;
633 flt=(float)dbl;
634 long l;
635 memcpy(&l,&flt,sizeof(long));
636
637 //push flt
638 compiler.codeGenerator.op_push_V(l);
639 }
640 else{
641 //整数（符号有り/無し）
642
643 long l = (long)i64data;
644
645 if(resultType.GetBasicSize()==sizeof(char)) l = l & 0x000000FF;
646 if(resultType.GetBasicSize()==sizeof(short)) l = l & 0x0000FFFF;
647
648 //push term
649 compiler.codeGenerator.op_push_V(l);
650 }
651 return true;
652 }
653
654 if(expression[0]==1&& expression[1]==ESC_NEW ){
655 //New演算子（オブジェクト生成）
656
657 if( !Operator_New( expression+2, baseType, resultType ) ){
658 return false;
659 }
660
661 return true;
662 }
663
664
665 /////////////////////////////////
666 // 式要素を逆ポーランド式で取得
667 /////////////////////////////////
668
669 char *values[255];
670 long calc[255];
671 long stack[255];
672 int pnum;
673 if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
674 for(i=0;i<pnum;i++){
675 if(values[i]) HeapDefaultFree(values[i]);
676 }
677 return false;
678 }
679
680
681 BOOL bError;
682 bError=0;
683
684 //リテラル値のみの計算かどうかを判別するためのフラグ
685 BOOL bLiteralCalculation=1;
686
687 //リテラル演算の場合を考慮した演算前の再配置スケジュール
688 CReloc *pobj_BackReloc;
689 pobj_BackReloc=new CReloc();
690 pobj_BackReloc->copy(pobj_Reloc);
691
692 double dbl;
693 int sp;
694 int type_stack[255];
695 bool isNothing_stack[255];
696 LONG_PTR index_stack[255];
697 BOOL bUseHeap[255];
698 _int64 i64data;
699 for(i=0,sp=0;i<pnum;i++){
700 int idCalc;
701 idCalc=calc[i]%100;
702
703 if(idCalc){
704 if(type_stack[sp-2]==DEF_OBJECT){
705 if( idCalc == CALC_AS
706 && type_stack[sp-1] == ( DEF_OBJECT | FLAG_CAST )
707 && index_stack[sp-1] == index_stack[sp-2]
708 || isNothing_stack[sp-2] ){
709 // 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
710 }
711 else if( idCalc == CALC_AS
712 && type_stack[sp-1] == ( DEF_OBJECT | FLAG_CAST )
713 && ( ((CClass *)index_stack[sp-1])->IsEqualsOrSubClass( (CClass *)index_stack[sp-2] ) || ((CClass *)index_stack[sp-2])->IsEqualsOrSubClass( (CClass *)index_stack[sp-1] )
714 )){
715 // ダウンキャストを許可する
716 }
717 else{
718 //オーバーロードされたオペレータを呼び出す
719 i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
720 if(i2==0){
721 if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
722 else GetCalcName(idCalc,temp2);
723 sprintf(temporary,"Operator %s",temp2);
724 SetError(27,temporary,cp);
725 goto error;
726 }
727 else if(i2==-1) goto error;
728
729 continue;
730 }
731 }
732
733 if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
734 }
735
736 switch(idCalc){
737 //数値
738 case 0:
739 index_stack[sp]=-1;
740 isNothing_stack[sp] = false;
741 bUseHeap[sp]=0;
742
743 char *term;
744 term=values[i];
745
746 if( calc[i+1]%100 == CALC_AS ){
747 // As演算子の右辺値
748 //型名
749 if( compiler.StringToType( term, resultType ) ){
750 resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
751 }
752 else{
753 SetError(3, term, cp );
754 goto error;
755 }
756
757 type_stack[sp] = resultType.GetBasicType();
758 index_stack[sp] = resultType.GetIndex();
759 sp++;
760
761 break;
762 }
763
764 if( (term[0]=='e'||term[0]=='E')
765 && (term[1]=='x'||term[1]=='X')
766 && term[2]=='\"'
767 || term[0] == '\"' )
768 {
769 if( baseType.IsObject() || baseType.IsNull() )
770 {
771 //要求タイプがオブジェクト、または未定のとき
772
773 //String型オブジェクトを生成
774 NewStringObject(term);
775
776 type_stack[sp]=DEF_OBJECT;
777 index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
778 bLiteralCalculation=0;
779
780 sp++;
781 break;
782 }
783
784 bool isEx = true;
785 if( term[0] == '\"' )
786 {
787 isEx = false;
788 }
789
790 if( isEx )
791 {
792 // 拡張版リテラル文字列（エスケープシーケンス可能）
793 if(!RemoveStringQuotes(term+2)){
794 SetError(43,NULL,cp);
795 goto error;
796 }
797 i3=FormatString_EscapeSequence(term+2);
798 term+=2;
799 }
800 else
801 {
802 // 通常文字列
803 if(!RemoveStringQuotes(term)){
804 SetError(43,NULL,cp);
805 goto error;
806 }
807 i3=lstrlen(term);
808 }
809StrLiteral:
810 type_stack[sp]=typeOfPtrChar;
811 bLiteralCalculation=0;
812
813 i2=compiler.GetObjectModule().dataTable.AddString(term,i3);
814
815 //push DataSize
816 compiler.codeGenerator.op_push_V( i2, Schedule::DataTable );
817 }
818 else if(IsVariableTopChar(term[0])||
819 term[0]=='*'||
820 (term[0]=='.'&&IsVariableTopChar(term[1]))){
821 //////////////////
822 // 何らかの識別子
823
824 bool isLiteral;
825 if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
826 if(resultType.IsNull()){
827 //戻り値が存在しないとき
828 for(i2=0;;i2++){
829 if(term[i2]=='('||term[i2]=='\0'){
830 term[i2]=0;
831 break;
832 }
833 }
834 SetError(38,term,cp);
835
836 goto error;
837 }
838
839 type_stack[sp] = resultType.GetBasicType();
840 index_stack[sp] = resultType.GetIndex();
841
842 if( !isLiteral ){
843 bLiteralCalculation=0;
844 }
845
846 if( resultType.GetBasicType() & FLAG_CAST ){
847 // 型名のみ
848 SetError();
849 }
850 else{
851 if( resultType.IsReal() ){
852 //sub esp,size
853 //fstp ptr[esp]
854 compiler.codeGenerator.op_fstp_push( resultType );
855 }
856 else{
857 if( resultType.Is64() ){
858 //push edx
859 compiler.codeGenerator.op_push( REG_EDX );
860 }
861 else{
862 ExtendTypeTo32( resultType.GetBasicType(), REG_EAX );
863 }
864
865 //push eax
866 compiler.codeGenerator.op_push( REG_EAX );
867 }
868 }
869
870 sp++;
871 break;
872 }
873
874
875 // Nothing
876 if( lstrcmp( term, "Nothing" ) == 0 ){
877 isNothing_stack[sp] = true;
878
879 type_stack[sp] = DEF_OBJECT;
880 if( baseType.IsObject() ){
881 index_stack[sp] = baseType.GetIndex();
882 }
883 else{
884 index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
885 }
886
887 bLiteralCalculation = 0;
888
889 //push 0
890 compiler.codeGenerator.op_push_V( 0 );
891
892 sp++;
893 break;
894 }
895
896
897 //////////////
898 // 定数の場合
899 //////////////
900
901 i3 = compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(term);
902 if(i3){
903 if( compiler.GetObjectModule().meta.GetGlobalConsts().IsStringPtr( term ) ){
904 //リテラル文字列
905
906 if( baseType.IsObject() || baseType.IsNull() )
907 {
908 //要求タイプがオブジェクト、または未定のとき
909
910 //String型オブジェクトを生成
911 NewStringObject(term);
912
913 type_stack[sp]=DEF_OBJECT;
914 index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
915 bLiteralCalculation=0;
916
917 sp++;
918 break;
919 }
920
921 double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
922 memcpy(&i64data,&dbl,sizeof(double));
923
924 //バイト数
925 i3=lstrlen((char *)i64data);
926
927 memcpy(term,(char *)i64data,i3);
928 term[i3]=0;
929 goto StrLiteral;
930 }
931
932 type_stack[sp]=i3;
933 if(IsRealNumberType(i3)){
934 //実数
935 double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
936 memcpy(&i64data,&dbl,sizeof(double));
937 goto Literal;
938 }
939 else if(IsWholeNumberType(i3)){
940 //整数
941 i64data = compiler.GetObjectModule().meta.GetGlobalConsts().GetWholeData(term);
942 goto Literal;
943 }
944 else{
945 SetError(300,NULL,cp);
946 goto error;
947 }
948 }
949
950
951 //該当する識別子が見当たらないときはエラー扱いにする
952 bError=1;
953 SetError(3,term,cp);
954 type_stack[sp]=DEF_DOUBLE;
955 }
956 else{
957 //リテラル値
958 type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
959Literal:
960 if(type_stack[sp]==DEF_INT64||
961 type_stack[sp]==DEF_QWORD||
962 type_stack[sp]==DEF_DOUBLE){
963 //64ビット（符号有り整数/実数）
964
965 //push HILONG(dbl)
966 compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
967
968 //push LOLONG(dbl)
969 compiler.codeGenerator.op_push_V(*(long *)(&i64data));
970 }
971 else if(type_stack[sp]==DEF_SINGLE){
972 //single実数
973
974 float flt;
975 memcpy(&dbl,&i64data,sizeof(double));
976 flt=(float)dbl;
977 memcpy(&i3,&flt,sizeof(long));
978
979 //push term
980 compiler.codeGenerator.op_push_V(i3);
981 }
982 else{
983 //その他
984
985 //push term
986 compiler.codeGenerator.op_push_V((long)i64data);
987
988 if((long)i64data==0) index_stack[sp]=LITERAL_NULL;
989 }
990
991
992 //リテラル値の種類
993 if(Is64Type(type_stack[sp])==0&&IsRealNumberType(type_stack[sp])==0){
994 //整数（符号有り/無し）
995
996 index_stack[sp]=GetLiteralIndex(i64data);
997 }
998 }
999 sp++;
1000 break;
1001
1002 //論理演算子
1003 case CALC_XOR:
1004 //value[sp-2] xor= value[sp-1]
1005 //xor演算
1006 if(!Calc_Xor(type_stack,index_stack,&sp)) goto error;
1007 break;
1008 case CALC_OR:
1009 //value[sp-2] or= value[sp-1]
1010 //or演算
1011 if(!Calc_Or(type_stack,index_stack,&sp)) goto error;
1012 break;
1013 case CALC_AND:
1014 //value[sp-2] and= value[sp-1]
1015 //and演算
1016 if(!Calc_And(type_stack,index_stack,&sp)) goto error;
1017 break;
1018 case CALC_NOT:
1019 //value[sp-1]=Not value[sp-1]
1020 //NOT演算子
1021 if(!Calc_Not(type_stack,sp)) goto error;
1022 break;
1023
1024 //比較演算子
1025 case CALC_PE:
1026 //value[sp-2]<=value[sp-1]
1027 if(!Calc_Relation_PE(type_stack,index_stack,&sp)) goto error;
1028 break;
1029 case CALC_QE:
1030 //value[sp-2]>=value[sp-1]
1031 if(!Calc_Relation_QE(type_stack,index_stack,&sp)) goto error;
1032 break;
1033 case CALC_P:
1034 //value[sp-2]<value[sp-1]
1035 if(!Calc_Relation_P(type_stack,index_stack,&sp)) goto error;
1036 break;
1037 case CALC_Q:
1038 //value[sp-2]>value[sp-1]
1039 if(!Calc_Relation_Q(type_stack,index_stack,&sp)) goto error;
1040 break;
1041 case CALC_NOTEQUAL:
1042 //value[sp-2]<>value[sp-1]
1043 if(!Calc_Relation_NotEqual(type_stack,&sp)) goto error;
1044 break;
1045 case CALC_EQUAL:
1046 //value[sp-2]=value[sp-1]
1047 if(!Calc_Relation_Equal(type_stack,&sp)) goto error;
1048 break;
1049
1050 //ビットシフト
1051 case CALC_SHL:
1052 //value[sp-2]=value[sp-2]<<value[sp-1]
1053 if(!Calc_SHL(type_stack,&sp)) goto error;
1054 break;
1055 case CALC_SHR:
1056 //value[sp-2]=value[sp-2]>>value[sp-1]
1057 if(!Calc_SHR(type_stack,&sp)) goto error;
1058 break;
1059
1060 //算術演算
1061 case CALC_ADDITION:
1062 case CALC_SUBTRACTION:
1063 case CALC_PRODUCT:
1064 if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
1065 break;
1066
1067 case CALC_MOD:
1068 //value[sp-2]%=value[sp-1]
1069 //剰余演算
1070 if(!Calc_Mod(type_stack,&sp)) goto error;
1071 break;
1072 case CALC_QUOTIENT:
1073 //value[sp-2]/=value[sp-1];
1074 //除算
1075 if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
1076 break;
1077 case CALC_INTQUOTIENT:
1078 //value[sp-2]/=value[sp-1]
1079 //整数除算
1080 if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
1081 break;
1082 case CALC_MINUSMARK:
1083 //value[sp-1]=-value[sp-1]
1084 //符号反転
1085 if(!Calc_MinusMark(type_stack,sp)) goto error;
1086 index_stack[sp-1]=-1;
1087 break;
1088 case CALC_POWER:
1089 //べき乗演算（浮動小数点演算のみ）
1090 if(!Calc_Power(type_stack,&sp)) goto error;
1091 break;
1092 case CALC_AS:
1093 //キャスト
1094 if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
1095 break;
1096
1097 case CALC_BYVAL:
1098 //ポインタ型→参照型
1099 if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
1100 //ポインタ型ではないとき
1101 SetError( 3, NULL, cp );
1102 goto error;
1103 }
1104
1105 type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
1106
1107 break;
1108
1109 default:
1110 SetError(300,NULL,cp);
1111 goto error;
1112 }
1113 }
1114
1115 if(bError) goto error;
1116
1117 if(sp!=1){
1118 SetError(1,NULL,cp);
1119 goto error;
1120 }
1121
1122 if(bLiteralCalculation){
1123 //右辺値が数値の定数式の場合
1124 SetError();
1125 }
1126 else{
1127 //右辺値が数値の定数式ではないとき
1128 if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
1129 }
1130
1131 if(pbUseHeap) *pbUseHeap=bUseHeap[0];
1132
1133 resultType.SetType( type_stack[0], index_stack[0] );
1134
1135 bool isSuccessful = true;
1136 goto finish;
1137
1138
1139error:
1140 isSuccessful = false;
1141 goto finish;
1142
1143
1144finish:
1145
1146 for(i=0;i<pnum;i++){
1147 if(values[i]) HeapDefaultFree(values[i]);
1148 }
1149
1150 //再配置スケジュールバックアップ情報を解放
1151 delete pobj_BackReloc;
1152
1153 return isSuccessful;
1154}
Note: See TracBrowser for help on using the repository browser.