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

Last change on this file since 436 was 436, checked in by dai_9181, 16 years ago

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