source: dev/trunk/abdev/BasicCompiler32/Compile_Func.cpp@ 357

Last change on this file since 357 was 357, checked in by dai_9181, 17 years ago

例外処理機構実装中...
File size: 18.6 KB
RevLine 
[206]1#include "stdafx.h"
2
[183]3#include <jenga/include/smoothie/Smoothie.h>
4
[193]5#include <Compiler.h>
6
[3]7#include "../BasicCompiler_Common/common.h"
8#include "Opcode.h"
9
10int GetFunctionFromName(char *FuncName){
[325]11 if( lstrcmpi( FuncName, "CUDbl" ) == 0 ) return FUNC_CUDBL;
12 if( lstrcmpi( FuncName, "Fix" ) == 0 ) return FUNC_FIX;
13 if( lstrcmpi( FuncName, "Len" ) == 0 ) return FUNC_LEN;
14 if( lstrcmpi( FuncName, "AddressOf" ) == 0 ) return FUNC_ADDRESSOF;
15 if( lstrcmpi( FuncName, "SizeOf" ) == 0 ) return FUNC_SIZEOF;
16 if( lstrcmpi( FuncName, "VarPtr" ) == 0 ) return FUNC_VARPTR;
17 if( lstrcmpi( FuncName, "ObjPtr" ) == 0 ) return FUNC_OBJPTR;
18 if( lstrcmpi( FuncName, "__delegate_dynamicmethod_call" ) == 0 ) return FUNC_DELEGATE_DYNAMICMETHOD_CALL;
19 if( lstrcmpi( FuncName, "__delegate_staticmethod_call" ) == 0 ) return FUNC_DELEGATE_STATICMETHOD_CALL;
[357]20 if( lstrcmpi( FuncName, "_System_GetNowScopeCatchAddresses" ) == 0 )return FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS;
21 if( lstrcmpi( FuncName, "_System_GetBp" ) == 0 ) return FUNC_SYSTEM_GET_BP;
[325]22 if( lstrcmpi( FuncName, "GetDouble" ) == 0 ) return FUNC_GETDOUBLE;
23 if( lstrcmpi( FuncName, "GetSingle" ) == 0 ) return FUNC_GETSINGLE;
24 if( lstrcmpi( FuncName, "GetQWord" ) == 0 ) return FUNC_GETQWORD;
25 if( lstrcmpi( FuncName, "GetDWord" ) == 0 ) return FUNC_GETDWORD;
26 if( lstrcmpi( FuncName, "GetWord" ) == 0 ) return FUNC_GETWORD;
27 if( lstrcmpi( FuncName, "GetByte" ) == 0 ) return FUNC_GETBYTE;
[3]28 return 0;
29}
30
[76]31void Opcode_Func_Fix(const char *lpszParms){
32 Type resultType;
33 if( !NumOpe( lpszParms, Type(), resultType ) ){
34 return;
35 }
[3]36
[76]37 if( resultType.IsDouble() ){
[3]38 //fld qword ptr[esp]
[225]39 compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]40
41 //fnstcw word ptr[esp]
[250]42 compiler.codeGenerator.PutOld(
43 (char)0xD9,
44 (char)0x3C,
45 (char)0x24
46 );
[3]47
48 //mov ax,word ptr[esp]
[250]49 compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]50
51 //or ah,0Ch
[250]52 compiler.codeGenerator.PutOld(
53 (char)0x80,
54 (char)0xCC,
55 (char)0x0C
56 );
[3]57
58 //mov word ptr[esp-2],ax
[250]59 compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
[3]60
61 //fldcw word ptr[esp-2]
[250]62 compiler.codeGenerator.PutOld(
63 (char)0xD9,
64 (char)0x6C,
65 (char)0x24,
66 (char)0xFE
67 );
[3]68
69 //fistp dword ptr[esp+4]
[250]70 compiler.codeGenerator.PutOld(
71 (char)0xDB,
72 (char)0x5C,
73 (char)0x24,
74 (char)0x04
75 );
[3]76
77 //fldcw word ptr[esp]
[250]78 compiler.codeGenerator.PutOld(
79 (char)0xD9,
80 (char)0x2C,
81 (char)0x24
82 );
[3]83
84 //add esp,4
[225]85 compiler.codeGenerator.op_add_esp(4);
[3]86 }
[76]87 else if( resultType.IsSingle() ){
[3]88 //fld dword ptr[esp]
[225]89 compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]90
91 //sub esp,4
[225]92 compiler.codeGenerator.op_sub_esp(4);
[3]93
94 //fnstcw word ptr[esp]
[250]95 compiler.codeGenerator.PutOld(
96 (char)0xD9,
97 (char)0x3C,
98 (char)0x24
99 );
[3]100
101 //mov ax,word ptr[esp]
[250]102 compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]103
104 //or ah,0Ch
[250]105 compiler.codeGenerator.PutOld(
106 (char)0x80,
107 (char)0xCC,
108 (char)0x0C
109 );
[3]110
111 //mov word ptr[esp-2],ax
[250]112 compiler.codeGenerator.op_mov_MR( sizeof(short), REG_EAX, REG_ESP, -2, MOD_BASE_DISP8 );
[3]113
114 //fldcw word ptr[esp-2]
[250]115 compiler.codeGenerator.PutOld(
116 (char)0xD9,
117 (char)0x6C,
118 (char)0x24,
119 (char)0xFE
120 );
[3]121
122 //fistp dword ptr[esp+4]
[250]123 compiler.codeGenerator.PutOld(
124 (char)0xDB,
125 (char)0x5C,
126 (char)0x24,
127 (char)0x04
128 );
[3]129
130 //fldcw word ptr[esp]
[250]131 compiler.codeGenerator.PutOld(
132 (char)0xD9,
133 (char)0x2C,
134 (char)0x24
135 );
[3]136
137 //add esp,4
[225]138 compiler.codeGenerator.op_add_esp(4);
[3]139 }
[76]140 else if( resultType.Is64() ){
[3]141 //pop eax
[225]142 compiler.codeGenerator.op_pop(REG_EAX);
[3]143
144 //add esp,4
[225]145 compiler.codeGenerator.op_add_esp(4);
[3]146
147 //push eax
[225]148 compiler.codeGenerator.op_push(REG_EAX);
[3]149 }
150
151 //pop eax
[225]152 compiler.codeGenerator.op_pop(REG_EAX);
[3]153}
154
[46]155void Opcode_Func_CUDbl(const char *Parameter){
[76]156 Type resultType;
157 if( !NumOpe(Parameter,Type(),resultType) ){
158 return;
159 }
160 ChangeTypeToLong(resultType.GetBasicType());
[3]161
162 //pop eax
[225]163 compiler.codeGenerator.op_pop(REG_EAX);
[3]164
165 //push 0
[235]166 compiler.codeGenerator.op_push_V( 0 );
[3]167
168 //push eax
[225]169 compiler.codeGenerator.op_push(REG_EAX);
[3]170
171 //fild qword ptr[esp]
[235]172 compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]173
174 //add esp,8
[225]175 compiler.codeGenerator.op_add_esp(8);
[3]176}
[46]177void Opcode_Func_Len(const char *Parameter){
[3]178 BOOL bArrayHead;
179
[46]180 const char *tempParm=Parameter;
[3]181 char temporary[VN_SIZE];
182 char temp2[32];
[76]183 Type type;
184 if( !GetVarType(Parameter,type,0) ){
[3]185 sprintf(temporary,"_System_DummyStr2=%s",Parameter);
186 OpcodeCalc(temporary);
187
188 lstrcpy(temp2,"_System_DummyStr2");
189 tempParm=temp2;
190
[265]191 type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
[3]192 }
193
[97]194 if( type.IsStringClass() ){
[3]195 //Stringオブジェクトの場合
196 sprintf(temporary,"%s.Length",tempParm);
197
[76]198 int reg=REG_RAX;
199 NumOpe(temporary,Type(),Type());
[3]200
201 //pop eax
[225]202 compiler.codeGenerator.op_pop(REG_EAX);
[3]203
204 return;
205 }
206
[206]207 Subscripts subscripts;
[3]208 RELATIVE_VAR RelativeVar;
[206]209 if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,&subscripts)) return;
[3]210
[76]211 if(type.GetBasicType()&FLAG_PTR){
212 type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
[3]213
214 bArrayHead=1;
215 }
216 else bArrayHead=0;
217
[76]218 int typeSize = type.GetSize();
[3]219
[206]220 if(bArrayHead) typeSize*=JumpSubScripts(subscripts);
[3]221
[235]222 //mov eax,typeSize
223 compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
[3]224}
225
[332]226void _Opcode_Func_AddressOf( const char *methodInstanceName, const UserProc &userProc )
227{
228 if( userProc.IsVirtual() ){
[3]229 ///////////////////////////////
230 // 仮想関数の場合
231 // thisポインタをrcxにコピー
232 ///////////////////////////////
233
[114]234 const CClass *pobj_c;
[3]235
236 char ObjectName[VN_SIZE];
[290]237 ReferenceKind referenceKind;
[332]238 SplitObjectName( methodInstanceName, ObjectName, referenceKind );
[3]239
240 if(ObjectName[0]){
241 if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
242 else{
243 RELATIVE_VAR RelativeVar;
[76]244 Type type;
245 if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
[3]246 SetVarPtrToEax(&RelativeVar);
247
248 //mov ecx,eax
[225]249 compiler.codeGenerator.op_mov_RR(REG_ECX,REG_EAX);
[3]250
251 //参照タイプが整合しているかをチェック
[290]252 if( !( type.IsObject() && referenceKind == RefDot
253 || type.IsObjectPtr() && referenceKind == RefPointer ) )
254 {
255 SetError(104,ObjectName,cp);
256 }
[3]257
[76]258 if(type.IsObjectPtr()){
[3]259 //mov ecx,dword ptr[ecx]
[225]260 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_ECX,REG_ECX,0,MOD_BASE);
[3]261 }
262 }
263 }
264 else{
265InClassMember:
266 //自身のオブジェクトのThisポインタをrcxにコピー
267 SetThisPtrToReg(REG_RCX);
268
[206]269 pobj_c=compiler.pCompilingClass;
[3]270 }
271
272
[349]273 int vtblIndex;
274 if( pobj_c->IsInterface() )
275 {
276 // インターフェイスメソッド呼び出し
[3]277
[349]278 int offset_vtbl = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__vtbl" );
[348]279
[3]280
[349]281 // vtblのポインタを取得
282 //mov edx,dword ptr[ecx+offset_vtbl]
283 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, offset_vtbl, MOD_BASE_DISP8 );
284
285 int offset_this = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr()->GetMemberOffset( "__this" );
286
287
288
289 // インターフェイスの場合は更に__thisを取得する
290 //mov rcx,qword ptr[rcx+offset_this]
291 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ECX, REG_ECX, offset_this, MOD_BASE_DISP8 );
292
293 int vtblMasterListIndex;
294 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
295 if( vtblMasterListIndex != 0 )
296 {
297 SetError();
298 }
299 }
300 else
301 {
302 //仮想関数（オブジェクトメソッド）呼び出し
303 // pObj -> vtbl_master_list -> vtbl1 -> func1
304 // -> func2
305 // -> func3
306 // -> vtbl2 -> func1
307 // -> func2
308 // -> func3
309
310 int vtblMasterListIndex;
311 pobj_c->GetVtblMasterListIndexAndVtblIndex( &userProc, vtblMasterListIndex, vtblIndex );
312
313 // vtblマスターリストのポインタを取得
314 //mov edx,dword ptr[ecx]
315 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_ECX, 0, MOD_BASE );
316
317 // vtblのポインタを取得
318 //mov edx,dword ptr[edx+vtblMasterListIndex]
[350]319 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EDX, vtblMasterListIndex*PTR_SIZE, MOD_BASE_DISP32 );
[349]320 }
321
[3]322 //mov eax,dword ptr[edx+func_index]
[342]323 if( vtblIndex * PTR_SIZE <= 0x7F )
324 {
325 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP8);
[3]326 }
327 else{
[342]328 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_EDX,vtblIndex*PTR_SIZE,MOD_BASE_DISP32);
[3]329 }
330 }
331 else{
332 //一般の関数
333
334 //mov eax,ProcAddr
[332]335 compiler.codeGenerator.op_addressof( REG_EAX, &userProc );
[3]336 }
337
[332]338 userProc.Using();
[3]339}
[335]340void Opcode_CreateDelegate( const CClass &dgClass, const char *methodInstanceName, const UserProc &userProc )
[332]341{
342 /////////////////////////////////////////////////////////////////
343 // 関数ポインタをpush
344 /////////////////////////////////////////////////////////////////
345
346 //push AddressOf(userProc)
347 _Opcode_Func_AddressOf( methodInstanceName, userProc );
348 compiler.codeGenerator.op_push( REG_EAX );
349
350
[336]351 if( userProc.GetMethod().IsDynamic() )
352 {
353 /////////////////////////////////////////////////////////////////
354 // オブジェクト ポインタをpush
355 /////////////////////////////////////////////////////////////////
[332]356
[336]357 // オブジェクト名を取得
358 char objectName[VN_SIZE];
359 char memberName[VN_SIZE];
360 char *thisPtrName = "This";
361 Type type;
362 if( SplitMemberName( methodInstanceName, objectName, memberName ) )
[332]363 {
[336]364 if( GetVarType( objectName, type, false ) )
365 {
366 thisPtrName = objectName;
367 }
[332]368 }
369
[336]370 // オブジェクト ポインタを取得
371 RELATIVE_VAR relativeVar;
372 GetVarOffsetReadOnly( thisPtrName, &relativeVar, type );
373 if( !type.IsObject() )
374 {
375 extern int cp;
376 SetError(1,NULL,cp);
377 return;
378 }
[332]379
[336]380 SetVarPtrToEax( &relativeVar );
[332]381
[336]382 //mov eax,dword ptr[eax]
383 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
[332]384
[336]385 //push eax
386 compiler.codeGenerator.op_push( REG_EAX );
387 }
[332]388
389
390 /////////////////////////////////////////////////////////////////
[336]391 // call _CreateDynamicDelegate/_CreateStaticDelegate
[332]392 /////////////////////////////////////////////////////////////////
393
[334]394 std::vector<const UserProc *> subs;
[336]395 if( userProc.GetMethod().IsDynamic() )
396 {
397 dgClass.GetStaticMethods().Enum( "_CreateDynamicDelegate", subs );
398 }
399 else
400 {
401 dgClass.GetStaticMethods().Enum( "_CreateStaticDelegate", subs );
402 }
[334]403
[336]404 // call _CreateDynamicDelegate
[334]405 compiler.codeGenerator.op_call( subs[0] );
[332]406}
[339]407void Opcode_Func_AddressOf( const char *name, const Type &baseType, bool isCallOn, Type &resultType )
408{
[332]409 extern int cp;
410 const UserProc *pUserProc;
411
412 const Parameters *pBaseParams = NULL;
413 if( baseType.IsProcPtr() )
414 {
415 // 左辺で関数ポインタを要求されているとき
416 pBaseParams = &compiler.GetObjectModule().meta.GetProcPointers()[baseType.GetIndex()]->Params();
417 }
[334]418 else if( baseType.IsDelegate() )
[332]419 {
420 // 左辺でデリゲートを要求されているとき
[334]421 pBaseParams = &baseType.GetClass().GetDelegate().Params();
[332]422 }
423
424 if( pBaseParams )
425 {
426 //左辺の型にのっとり、オーバーロードを解決
427
428 std::vector<const UserProc *> subs;
429 GetOverloadSubHash( name, subs );
430 if( subs.size() == 0 ){
431 SetError(27,name,cp);
432 return;
433 }
434
435 //オーバーロードを解決
436 pUserProc=OverloadSolution( name, subs, *pBaseParams, Type() );
437
[338]438 if( isCallOn && baseType.IsDelegate() )
[337]439 {
440 // コード生成を伴う場合はエラーチェックを行う
441 if( !pUserProc->Params().Equals( *pBaseParams )
442 || !pUserProc->ReturnType().Equals( baseType.GetClass().GetDelegate().ReturnType() ) )
443 {
444 if( baseType.IsDelegate() )
445 {
446 SetError(67, name, cp );
447 }
448 else
449 {
450 SetError(66, name, cp );
451 }
452 }
453 }
454
[332]455 if(!pUserProc){
456 SetError(27,name,cp);
457 return;
458 }
459 }
460 else{
461 pUserProc=GetSubHash(name);
462 if(!pUserProc){
463 SetError(27,name,cp);
464 return;
465 }
466 }
467
[334]468 if( baseType.IsDelegate() )
[332]469 {
470 if( isCallOn )
471 {
472 // デリゲートのとき
[335]473 Opcode_CreateDelegate( baseType.GetClass(), name, *pUserProc );
[332]474 }
475 resultType = baseType;
476 }
477 else
478 {
479 if( isCallOn )
480 {
481 // 関数ポインタのとき
482 _Opcode_Func_AddressOf( name, *pUserProc );
483 }
484 resultType.SetBasicType( DEF_PTR_VOID );
485 }
486}
[79]487void Opcode_Func_SizeOf( const string &typeName ){
488 Type tempType;
[299]489 if( !compiler.StringToType( typeName, tempType ) ){
[79]490 SetError(3,typeName,cp);
491 return;
[3]492 }
493
[79]494 int typeSize = ( tempType.IsObject() ) ?
495 tempType.GetClass().GetSize() : tempType.GetSize();
496
[3]497 //mov eax,size
[225]498 compiler.codeGenerator.op_mov_RV( REG_EAX, typeSize );
[3]499}
[76]500void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
501 if( isCallOn == false ){
502 // 戻り値の型を取得するだけ
503
504 //変数のアドレスを取得
505 if(!GetVarType( Parameter, resultType, true )) return;
506
507 resultType.PtrLevelUp();
508
509 return;
510 }
511
[3]512 RELATIVE_VAR RelativeVar;
513
514 //変数のアドレスを取得
[76]515 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
[3]516
[76]517 int beforeType = resultType.GetBasicType();
[64]518
[76]519 resultType.PtrLevelUp();
[46]520
[3]521 SetVarPtrToEax(&RelativeVar);
522}
[109]523void Opcode_Func_ObjPtr( const char *Parameter, Type &resultType, bool isCallOn ){
524 if( isCallOn == false ){
525 // 戻り値の型を取得するだけ
526
527 //変数のアドレスを取得
528 if(!GetVarType( Parameter, resultType, true )) return;
529
530 resultType.PtrLevelUp();
531
532 return;
533 }
534
535 RELATIVE_VAR RelativeVar;
536
537 //変数のアドレスを取得
538 if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
539
540 int beforeType = resultType.GetBasicType();
541
542 resultType.PtrLevelUp();
543
544 SetVarPtrToEax(&RelativeVar);
545
[111]546 if( lstrcmpi( Parameter, "This" )==0 ){
547 // Thisの場合は特別にオブジェクトポインタが返ってくるので、何もせずに抜ける
548 }
549 else if( beforeType == DEF_OBJECT ){
[109]550 //参照をオブジェクトポインタに変更
551
552 //mov eax,dword ptr[eax]
[225]553 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
[109]554 }
555 else{
556 SetError(134,NULL,cp );
557 }
558}
[325]559
560void Opcode_Func_delegate_call( const char *paramsStr, Type &resultType, bool isDynamicCall, bool isCallOn )
561{
562 if( isCallOn )
563 {
564 int i = 0;
565 char methodPtrParamStr[VN_SIZE];
566 i = GetOneParameter( paramsStr, i, methodPtrParamStr );
567
[336]568 char objPtrValueStr[VN_SIZE]="";
[325]569 if( isDynamicCall )
570 {
571 i = GetOneParameter( paramsStr, i, objPtrValueStr );
572 }
573
574 Opcode_CallDelegate( compiler.pCompilingClass->GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
575 }
576
577 resultType = UserProc::CompilingUserProc().ReturnType();
578}
[357]579void Opcode_Func_System_Get_Bp()
580{
581 //mov eax,ebp
582 compiler.codeGenerator.op_mov_RR(REG_EAX,REG_EBP);
583}
[325]584
[46]585void Opcode_Func_GetPtrData(const char *Parameter,const int type){
[76]586 Type tempType;
587 if( !NumOpe(Parameter,Type(),tempType) ){
588 return;
589 }
590 if(!tempType.IsWhole()){
591 SetError(11,Parameter,cp);
592 return;
593 }
594 ChangeTypeToLong(tempType.GetBasicType());
[3]595
596 if(type==DEF_DOUBLE){
597 //pop eax
[225]598 compiler.codeGenerator.op_pop(REG_EAX);
[3]599
600 //fld qword ptr[eax]
[235]601 compiler.codeGenerator.PutOld(
602 (char)0xDD,
603 (char)0x00
604 );
[3]605 }
606 else if(type==DEF_SINGLE||type==DEF_DWORD){
607 //pop eax
[225]608 compiler.codeGenerator.op_pop(REG_EAX);
[3]609
610 //mov eax,dword ptr[eax]
[235]611 compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
[3]612 }
613 else if(type==DEF_QWORD){
614 //pop ecx
[225]615 compiler.codeGenerator.op_pop(REG_ECX);
[3]616
617 //mov eax,dword ptr[ecx]
[225]618 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EAX,REG_ECX,0,MOD_BASE);
[3]619
620 //mov edx,dword ptr[ecx+sizeof(long)]
[225]621 compiler.codeGenerator.op_mov_RM(sizeof(long),REG_EDX,REG_ECX,sizeof(long),MOD_BASE_DISP8);
[3]622 }
623 else if(type==DEF_WORD){
624 //pop ebx
[225]625 compiler.codeGenerator.op_pop(REG_EBX);
[3]626
627 //xor eax,eax
[227]628 compiler.codeGenerator.op_xor_RR(REG_EAX);
[3]629
630 //mov ax,word ptr[ebx]
[235]631 compiler.codeGenerator.op_mov_RM( sizeof(short), REG_EAX, REG_EBX, 0, MOD_BASE );
[3]632 }
633 else if(type==DEF_BYTE){
634 //pop ebx
[225]635 compiler.codeGenerator.op_pop(REG_EBX);
[3]636
637 //xor eax,eax
[227]638 compiler.codeGenerator.op_xor_RR(REG_EAX);
[3]639
640 //mov al,byte ptr[ebx]
[235]641 compiler.codeGenerator.op_mov_RM( sizeof(char), REG_EAX, REG_EBX, 0, MOD_BASE );
[3]642 }
643}
644
[331]645bool Opcode_CallFunc( const char *Parameter, const int FuncNum, const Type &baseType, Type &resultType, bool isCallOn )
646{
[3]647 switch(FuncNum){
648 case FUNC_FIX:
[76]649 if( isCallOn ) Opcode_Func_Fix(Parameter);
650 resultType.SetBasicType( DEF_LONG );
[46]651 break;
[3]652 case FUNC_CUDBL:
[76]653 if( isCallOn ) Opcode_Func_CUDbl(Parameter);
654 resultType.SetBasicType( DEF_DOUBLE );
[46]655 break;
[3]656 case FUNC_LEN:
[76]657 if( isCallOn ) Opcode_Func_Len(Parameter);
658 resultType.SetBasicType( DEF_LONG );
[46]659 break;
[3]660 case FUNC_ADDRESSOF:
[332]661 Opcode_Func_AddressOf( Parameter, baseType, isCallOn, resultType );
[46]662 break;
[3]663 case FUNC_SIZEOF:
[76]664 if( isCallOn ) Opcode_Func_SizeOf(Parameter);
665 resultType.SetBasicType( DEF_LONG );
[46]666 break;
[3]667 case FUNC_VARPTR:
[76]668 Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
[46]669 break;
[109]670 case FUNC_OBJPTR:
671 Opcode_Func_ObjPtr( Parameter, resultType, isCallOn );
672 break;
[325]673 case FUNC_DELEGATE_DYNAMICMETHOD_CALL:
674 Opcode_Func_delegate_call( Parameter, resultType, true, isCallOn );
675 break;
676 case FUNC_DELEGATE_STATICMETHOD_CALL:
677 Opcode_Func_delegate_call( Parameter, resultType, false, isCallOn );
678 break;
[357]679 case FUNC_SYSTEM_GET_NOW_SCOPE_CATCH_ADDRESS:
680 if( isCallOn ) Exception::Opcode_Func_System_GetNowScopeCatchAddress();
681 resultType.SetBasicType( DEF_LONG );
682 break;
683 case FUNC_SYSTEM_GET_BP:
684 if( isCallOn ) Opcode_Func_System_Get_Bp();
685 resultType.SetBasicType( DEF_LONG );
686 break;
[3]687
688 case FUNC_GETDOUBLE:
[76]689 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
690 resultType.SetBasicType( DEF_DOUBLE );
[46]691 break;
[3]692 case FUNC_GETSINGLE:
[76]693 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
694 resultType.SetBasicType( DEF_SINGLE );
[46]695 break;
[3]696 case FUNC_GETQWORD:
[76]697 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
698 resultType.SetBasicType( DEF_QWORD );
[46]699 break;
[3]700 case FUNC_GETDWORD:
[76]701 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
702 resultType.SetBasicType( DEF_DWORD );
[46]703 break;
[3]704 case FUNC_GETWORD:
[76]705 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
706 resultType.SetBasicType( DEF_WORD );
[46]707 break;
[3]708 case FUNC_GETBYTE:
[76]709 if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
710 resultType.SetBasicType( DEF_BYTE );
[46]711 break;
[76]712 default:
713 return false;
[3]714 }
[76]715 return true;
[3]716}
Note: See TracBrowser for help on using the repository browser.