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

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

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