source: dev/trunk/ab5.0/abdev/compiler_x86/NumOpe.cpp @ 673

Last change on this file since 673 was 673, checked in by dai_9181, 15 years ago

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