/* * $Id$ */ /* * Harbour Project source code: * Compiler .NET .il source generation * * Copyright 2003 Antonio Linares * www - http://www.harbour-project.org * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit * their web site at http://www.gnu.org/). * */ #include #include "hbcomp.h" static void hb_compGenCReadable( PFUNCTION pFunc, FILE * yyc ); static void hb_compGenCCompact( PFUNCTION pFunc, FILE * yyc ); static void hb_genNetFunctions( FILE * yyc ); /* helper structure to pass information */ typedef struct HB_stru_genc_info { FILE * yyc; BOOL bVerbose; USHORT iNestedCodeblock; } HB_GENC_INFO, * HB_GENC_INFO_PTR; typedef struct HB_stru_funcalls { char * szName; BOOL bFirstParam; void * pNext; } HB_FUNCALLS, * HB_FUNCALLS_PTR; static HB_FUNCALLS_PTR pFunCalls = NULL; #define HB_GENC_FUNC( func ) HB_PCODE_FUNC( func, HB_GENC_INFO_PTR ) typedef HB_GENC_FUNC( HB_GENC_FUNC_ ); typedef HB_GENC_FUNC_ * HB_GENC_FUNC_PTR; void hb_compGenILCode( PHB_FNAME pFileName ) /* generates the IL output */ { char szFileName[ _POSIX_PATH_MAX ]; PFUNCTION pFunc = hb_comp_functions.pFirst; PCOMSYMBOL pSym = hb_comp_symbols.pFirst; PCOMDECLARED pDeclared; PCOMCLASS pClass; FILE * yyc; /* file handle for IL output */ PINLINE pInline = hb_comp_inlines.pFirst; BOOL bIsPublicFunction ; BOOL bIsInitFunction ; BOOL bIsExitFunction ; BOOL bIsStaticVariable ; BOOL bIsFirstFunction = TRUE; if( ! pFileName->szExtension ) pFileName->szExtension = ".il"; hb_fsFNameMerge( szFileName, pFileName ); yyc = fopen( szFileName, "wb" ); if( ! yyc ) { hb_compGenError( hb_comp_szErrors, 'E', HB_COMP_ERR_CREATE_OUTPUT, szFileName, NULL ); return; } if( ! hb_comp_bQuiet ) { printf( "Generating IL source output to \'%s\'... ", szFileName ); fflush( stdout ); } fprintf( yyc, "// Harbour Compiler, Alpha build %d.%d (%s)\n", HB_VER_MINOR, HB_VER_REVISION, HB_VER_LEX ); fprintf( yyc, "// Generated .NET IL source code\n\n" ); if( hb_comp_iFunctionCnt ) { fprintf( yyc, ".assembly extern mscorlib{}\n" ); fprintf( yyc, ".assembly " ); fprintf( yyc, hb_strupr( pFileName->szName ) ); fprintf( yyc, "_PRG{}\n" ); // if( hb_comp_iGenCOutput != HB_COMPGENC_COMPACT ) // fprintf( yyc, "#include \"hbpcode.h\"\n" ); // fprintf( yyc, "#include \"hbinit.h\"\n\n\n" ); // if( ! hb_comp_bStartProc ) // pFunc = pFunc->pNext; /* No implicit starting procedure */ // /* write functions prototypes for PRG defined functions */ // while( pFunc ) // { // bIsInitFunction = ( pFunc->cScope & HB_FS_INIT ) ; // bIsExitFunction = ( pFunc->cScope & HB_FS_EXIT ) ; // bIsStaticVariable = ( pFunc == hb_comp_pInitFunc ) ; // bIsPublicFunction = ( pFunc->cScope == HB_FS_PUBLIC ) ; // // /* Is it a PUBLIC FUNCTION/PROCEDURE */ // if ( bIsPublicFunction ) // fprintf( yyc, "HB_FUNC( %s );\n", pFunc->szName ); // /* Is it a STATIC$ */ // else if ( bIsStaticVariable ) // fprintf( yyc, "static HARBOUR hb_INITSTATICS( void );\n" ); /* NOTE: hb_ intentionally in lower case */ // /* Is it an INIT FUNCTION/PROCEDURE */ // else if ( bIsInitFunction ) // fprintf( yyc, "HB_FUNC_INIT( %s );\n", pFunc->szName ); // /* Is it an EXIT FUNCTION/PROCEDURE */ // else if ( bIsExitFunction ) // fprintf( yyc, "HB_FUNC_EXIT( %s );\n", pFunc->szName ); // /* Then it must be a STATIC FUNCTION/PROCEDURE */ // else // fprintf( yyc, "HB_FUNC_STATIC( %s );\n", pFunc->szName ); // // pFunc = pFunc->pNext; // } // /* write functions prototypes for inline blocks */ // while( pInline ) // { // if( pInline->szName ) // fprintf( yyc, "HB_FUNC_STATIC( %s );\n", pInline->szName ); // pInline = pInline->pNext; // } // /* write functions prototypes for called functions outside this PRG */ // pFunc = hb_comp_funcalls.pFirst; // while( pFunc ) // { // if( hb_compFunctionFind( pFunc->szName ) == NULL && // hb_compInlineFind( pFunc->szName ) == NULL ) // fprintf( yyc, "extern HB_FUNC( %s );\n", pFunc->szName ); // // pFunc = pFunc->pNext; // } // /* writes the symbol table */ // /* Generate the wrapper that will initialize local symbol table // */ // hb_strupr( pFileName->szName ); // fprintf( yyc, "\n\nHB_INIT_SYMBOLS_BEGIN( hb_vm_SymbolInit_%s%s )\n", hb_comp_szPrefix, pFileName->szName ); // while( pSym ) // { // if( pSym->szName[ 0 ] == '(' ) // { // /* Since the normal function cannot be INIT and EXIT at the same time // * we are using these two bits to mark the special function used to // * initialize static variables // */ // fprintf( yyc, "{ \"(_INITSTATICS)\", HB_FS_INIT | HB_FS_EXIT, hb_INITSTATICS, NULL }" ); /* NOTE: hb_ intentionally in lower case */ // } // else // { // fprintf( yyc, "{ \"%s\", ", pSym->szName ); // // if( pSym->cScope & HB_FS_STATIC ) // { // fprintf( yyc, "HB_FS_STATIC" ); // // if( pSym->cScope & HB_FS_PUBLIC ) // fprintf( yyc, " | HB_FS_PUBLIC" ); // } // // else if( pSym->cScope & HB_FS_INIT ) // fprintf( yyc, "HB_FS_INIT" ); // // else if( pSym->cScope & HB_FS_EXIT ) // fprintf( yyc, "HB_FS_EXIT" ); // // else // fprintf( yyc, "HB_FS_PUBLIC" ); // // if( pSym->cScope & VS_MEMVAR ) // fprintf( yyc, " | HB_FS_MEMVAR" ); // // if( ( pSym->cScope != HB_FS_MESSAGE ) && ( pSym->cScope & HB_FS_MESSAGE ) ) /* only for non public symbols */ // fprintf( yyc, " | HB_FS_MESSAGE" ); // // if ( ( pSym->cScope & HB_FS_FIRST ) && ( ! hb_comp_bNoStartUp ) ) // fprintf( yyc, " | HB_FS_FIRST" ); // // /* specify the function address if it is a defined function or an // external called function */ // if( hb_compFunctionFind( pSym->szName ) ) /* is it a function defined in this module */ // fprintf( yyc, ", HB_FUNCNAME( %s ), NULL }", pSym->szName ); // else if( hb_compFunCallFind( pSym->szName ) ) /* is it a function called from this module */ // fprintf( yyc, ", HB_FUNCNAME( %s ), NULL }", pSym->szName ); // else // fprintf( yyc, ", NULL, NULL }" ); /* memvar */ // } // // if( pSym != hb_comp_symbols.pLast ) // fprintf( yyc, ",\n" ); // // pSym = pSym->pNext; // } // fprintf( yyc, "\nHB_INIT_SYMBOLS_END( hb_vm_SymbolInit_%s%s )\n" // "#if defined(_MSC_VER)\n" // " #if _MSC_VER >= 1010\n" // /* [pt] First version of MSC I have that supports this */ // /* is msvc4.1 (which is msc 10.10) */ // " #pragma data_seg( \".CRT$XIY\" )\n" // " #pragma comment( linker, \"/Merge:.CRT=.data\" )\n" // " #else\n" // " #pragma data_seg( \"XIY\" )\n" // " #endif\n" // " static HB_$INITSYM hb_vm_auto_SymbolInit_%s%s = hb_vm_SymbolInit_%s%s;\n" // " #pragma data_seg()\n" // "#elif ! defined(__GNUC__)\n" // " #pragma startup hb_vm_SymbolInit_%s%s\n" // "#endif\n\n", // hb_comp_szPrefix, pFileName->szName, // hb_comp_szPrefix, pFileName->szName, // hb_comp_szPrefix, pFileName->szName, // hb_comp_szPrefix, pFileName->szName ); /* Generate functions data */ pFunc = hb_comp_functions.pFirst; if( ! hb_comp_bStartProc ) pFunc = pFunc->pNext; /* No implicit starting procedure */ while( pFunc ) { bIsInitFunction = ( pFunc->cScope & HB_FS_INIT ) ; bIsExitFunction = ( pFunc->cScope & HB_FS_EXIT ) ; bIsStaticVariable = ( pFunc == hb_comp_pInitFunc ) ; bIsPublicFunction = ( pFunc->cScope == HB_FS_PUBLIC ) ; /* Is it a PUBLIC FUNCTION/PROCEDURE */ if ( bIsPublicFunction ) fprintf( yyc, "\n.method public static void %s()", pFunc->szName ); /* Is it STATICS$ */ else if( bIsStaticVariable ) fprintf( yyc, "static HARBOUR hb_INITSTATICS( void )" ); /* NOTE: hb_ intentionally in lower case */ /* Is it an INIT FUNCTION/PROCEDURE */ else if ( bIsInitFunction ) fprintf( yyc, "HB_FUNC_INIT( %s )", pFunc->szName ); /* Is it an EXIT FUNCTION/PROCEDURE */ else if ( bIsExitFunction ) fprintf( yyc, "HB_FUNC_EXIT( %s )", pFunc->szName ); /* Then it must be a STATIC FUNCTION/PROCEDURE */ else fprintf( yyc, "HB_FUNC_STATIC( %s )", pFunc->szName ); fprintf( yyc, "\n{\n" ); if( bIsFirstFunction ) { fprintf( yyc, " .entrypoint\n" ); bIsFirstFunction = FALSE; } if( hb_comp_iGenCOutput == HB_COMPGENC_COMPACT ) hb_compGenCCompact( pFunc, yyc ); else hb_compGenCReadable( pFunc, yyc ); fprintf( yyc, " ret\n}\n" ); // fprintf( yyc, " hb_vmExecute( pcode, symbols );\n}\n\n" ); pFunc = pFunc->pNext; } /* Generate codeblocks data */ if( hb_comp_cInlineID > '0' ) { fprintf( yyc, "#include \"hbapi.h\"\n" ); fprintf( yyc, "#include \"hbstack.h\"\n" ); fprintf( yyc, "#include \"hbapierr.h\"\n" ); fprintf( yyc, "#include \"hbapiitm.h\"\n" ); fprintf( yyc, "#include \"hbvm.h\"\n" ); fprintf( yyc, "#include \"hboo.ch\"\n" ); } pInline = hb_comp_inlines.pFirst; while( pInline ) { fprintf( yyc, "#line %i \"%s\"\n", pInline->iLine, pInline->szFileName ); if( pInline->szName ) { fprintf( yyc, "HB_FUNC_STATIC( %s )\n", pInline->szName ); } fprintf( yyc, "%s", pInline->pCode ); pInline = pInline->pNext; } } else { fprintf( yyc, "/* Empty source file */\n\n" ); } // Generate .NET support functions hb_genNetFunctions( yyc ); fclose( yyc ); pFunc = hb_comp_functions.pFirst; while( pFunc ) pFunc = hb_compFunctionKill( pFunc ); pFunc = hb_comp_funcalls.pFirst; while( pFunc ) { hb_comp_funcalls.pFirst = pFunc->pNext; hb_xfree( ( void * ) pFunc ); /* NOTE: szName will be released by hb_compSymbolKill() */ pFunc = hb_comp_funcalls.pFirst; } pInline = hb_comp_inlines.pFirst; while( pInline ) { hb_comp_inlines.pFirst = pInline->pNext; if( pInline->pCode ) { hb_xfree( ( void * ) pInline->pCode ); } hb_xfree( ( void * ) pInline->szFileName ); hb_xfree( ( void * ) pInline ); /* NOTE: szName will be released by hb_compSymbolKill() */ pInline = hb_comp_inlines.pFirst; } if ( hb_comp_iWarnings >= 3 ) { pDeclared = hb_comp_pReleaseDeclared->pNext; while( pDeclared ) { hb_comp_pFirstDeclared = pDeclared->pNext; hb_xfree( ( void * ) pDeclared ); pDeclared = hb_comp_pFirstDeclared; } pClass = hb_comp_pReleaseClass->pNext; while( pClass ) { hb_comp_pFirstClass = pClass->pNext; pDeclared = pClass->pMethod; while ( pDeclared ) { hb_comp_pFirstDeclared = pDeclared->pNext; hb_xfree( ( void * ) pDeclared ); pDeclared = hb_comp_pFirstDeclared; } hb_xfree( ( void * ) pClass ); pClass = hb_comp_pFirstClass; } } pSym = hb_comp_symbols.pFirst; while( pSym ) pSym = hb_compSymbolKill( pSym ); if( ! hb_comp_bQuiet ) printf( "Done.\n" ); } static HB_GENC_FUNC( hb_p_and ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_AND,\n" ); return 1; } static HB_GENC_FUNC( hb_p_arraypush ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call object ObjArrayPush( object, object )\n" ); // fprintf( cargo->yyc, "\tHB_P_ARRAYPUSH,\n" ); return 1; } static HB_GENC_FUNC( hb_p_arraypop ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_ARRAYPOP,\n" ); return 1; } static HB_GENC_FUNC( hb_p_dec ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_DEC,\n" ); return 1; } static HB_GENC_FUNC( hb_p_arraydim ) { fprintf( cargo->yyc, "\tHB_P_ARRAYDIM, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_divide ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_DIVIDE,\n" ); return 1; } static HB_GENC_FUNC( hb_p_do ) { fprintf( cargo->yyc, "\tHB_P_DO, %i, %i,\n", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_doshort ) { HB_FUNCALLS_PTR pTemp = pFunCalls, pPrev = NULL; char * szFunName; while( pTemp->pNext != NULL ) { pPrev = pTemp; pTemp = ( HB_FUNCALLS_PTR ) pTemp->pNext; } szFunName = pTemp->szName; pTemp->bFirstParam = FALSE; hb_xfree( pTemp ); if( pTemp == pFunCalls ) pFunCalls = NULL; else if( pPrev != NULL ) pPrev->pNext = NULL; fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call object %s( object )\n", szFunName ); fprintf( cargo->yyc, " pop\n" ); // fprintf( cargo->yyc, "\tHB_P_DOSHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_duplicate ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_DUPLICATE,\n" ); return 1; } static HB_GENC_FUNC( hb_p_dupltwo ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_DUPLTWO,\n" ); return 1; } static HB_GENC_FUNC( hb_p_equal ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_EQUAL,\n" ); return 1; } static HB_GENC_FUNC( hb_p_exactlyequal ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call bool ObjExactlyEqual( object, object )\n" ); // fprintf( cargo->yyc, "\tHB_P_EXACTLYEQUAL,\n" ); return 1; } static HB_GENC_FUNC( hb_p_endblock ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); --cargo->iNestedCodeblock; fprintf( cargo->yyc, "\tHB_P_ENDBLOCK,\n" ); return 1; } static HB_GENC_FUNC( hb_p_endproc ) { // if( (lPCodePos+1) == pFunc->lPCodePos ) // fprintf( cargo->yyc, "\tHB_P_ENDPROC\n" ); // else // fprintf( cargo->yyc, "\tHB_P_ENDPROC,\n" ); return 1; } static HB_GENC_FUNC( hb_p_false ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "ldc.i4.0\n" ); fprintf( cargo->yyc, " box [mscorlib]System.Boolean\n" ); // fprintf( cargo->yyc, "\tHB_P_FALSE,\n" ); return 1; } static HB_GENC_FUNC( hb_p_fortest ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call bool ObjForTest( object, object, object )\n" ); // fprintf( cargo->yyc, "\tHB_P_FORTEST,\n" ); return 1; } static HB_GENC_FUNC( hb_p_frame ) { int i; fprintf( cargo->yyc, " .locals init (" ); for( i = 0; i < pFunc->pCode[ lPCodePos + 1 ]; i++ ) { if( i > 0 ) fprintf( cargo->yyc, "," ); fprintf( cargo->yyc, " object V_%i", i ); } fprintf( cargo->yyc, " )\n" ); // fprintf( cargo->yyc, "\tHB_P_FRAME, %i, %i,", // pFunc->pCode[ lPCodePos + 1 ], // pFunc->pCode[ lPCodePos + 2 ] ); // if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* locals, params */" ); // fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_funcptr ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_FUNCPTR,\n" ); return 1; } static HB_GENC_FUNC( hb_p_function ) { fprintf( cargo->yyc, "\tHB_P_FUNCTION, %i, %i,\n", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_functionshort ) { HB_FUNCALLS_PTR pTemp = pFunCalls, pPrev = NULL; char * szFunName; while( pTemp->pNext != NULL ) { pPrev = pTemp; pTemp = ( HB_FUNCALLS_PTR ) pTemp->pNext; } szFunName = pTemp->szName; pTemp->bFirstParam = FALSE; hb_xfree( pTemp ); if( pTemp == pFunCalls ) pFunCalls = NULL; else if( pPrev != NULL ) pPrev->pNext = NULL; fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call object %s( object )\n", szFunName ); // fprintf( cargo->yyc, "\tHB_P_FUNCTIONHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_arraygen ) { int i; fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call vararg object ObjArrayGen( ..." ); for( i = 0; i < pFunc->pCode[ lPCodePos + 1 ] + ( pFunc->pCode[ lPCodePos + 2 ] * 256 ); i++ ) fprintf( cargo->yyc, ",object" ); fprintf( cargo->yyc, ")\n" ); // fprintf( cargo->yyc, "\tHB_P_ARRAYGEN, %i, %i,", // pFunc->pCode[ lPCodePos + 1 ], // pFunc->pCode[ lPCodePos + 2 ] ); // if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); // fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_greater ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_GREATER,\n" ); return 1; } static HB_GENC_FUNC( hb_p_greaterequal ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_GREATEREQUAL,\n" ); return 1; } static HB_GENC_FUNC( hb_p_inc ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_INC,\n" ); return 1; } static HB_GENC_FUNC( hb_p_instring ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_INSTRING,\n" ); return 1; } static HB_GENC_FUNC( hb_p_jumpnear ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] ); if( lOffset > 127 ) lOffset -= 256; fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "br.s" ); fprintf( cargo->yyc, " IL_%04lX\n", ( LONG ) ( lPCodePos + lOffset ) ); // fprintf( cargo->yyc, "\tHB_P_JUMPNEAR, %i,", // pFunc->pCode[ lPCodePos + 1 ] ); // if( cargo->bVerbose ) // { // LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] ); // // if( lOffset > 127 ) // lOffset -= 256; // // fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); // } // fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_jump ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); if( lOffset > SHRT_MAX ) lOffset -= 65536; fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "br.s" ); fprintf( cargo->yyc, " IL_%04lX\n", ( LONG ) ( lPCodePos + lOffset ) ); // fprintf( cargo->yyc, "\tHB_P_JUMP, %i, %i,", // pFunc->pCode[ lPCodePos + 1 ], // pFunc->pCode[ lPCodePos + 2 ] ); // if( cargo->bVerbose ) // { // LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); // // if( lOffset > SHRT_MAX ) // lOffset -= 65536; // // fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); // } // fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_jumpfar ) { fprintf( cargo->yyc, "\tHB_P_JUMPFAR, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ], pFunc->pCode[ lPCodePos + 3 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 + pFunc->pCode[ lPCodePos + 3 ] * 65536 ); if( lOffset > 8388607L ) lOffset -= 16777216; fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); } fprintf( cargo->yyc, "\n" ); return 4; } static HB_GENC_FUNC( hb_p_jumpfalsenear ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] ); if( lOffset > 127 ) lOffset -= 256; fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "brfalse.s" ); fprintf( cargo->yyc, " IL_%04lX\n", ( LONG ) ( lPCodePos + lOffset ) ); // fprintf( cargo->yyc, "\tHB_P_JUMPFALSENEAR, %i,", // pFunc->pCode[ lPCodePos + 1 ] ); // if( cargo->bVerbose ) // { // LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] ); // // if( lOffset > 127 ) // lOffset -= 256; // // fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); // } // fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_jumpfalse ) { fprintf( cargo->yyc, "\tHB_P_JUMPFALSE, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); if( lOffset > SHRT_MAX ) lOffset -= 65536; fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_jumpfalsefar ) { fprintf( cargo->yyc, "\tHB_P_JUMPFALSEFAR, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ], pFunc->pCode[ lPCodePos + 3 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 + pFunc->pCode[ lPCodePos + 3 ] * 65536 ); if( lOffset > 8388607L ) lOffset -= 16777216; fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); } fprintf( cargo->yyc, "\n" ); return 4; } static HB_GENC_FUNC( hb_p_jumptruenear ) { fprintf( cargo->yyc, "\tHB_P_JUMPTRUENEAR, %i,", pFunc->pCode[ lPCodePos + 1 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] ); if( lOffset > 127 ) lOffset -= 256; fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); } fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_jumptrue ) { fprintf( cargo->yyc, "\tHB_P_JUMPTRUE, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); if( lOffset > SHRT_MAX ) lOffset -= 65536; fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_jumptruefar ) { fprintf( cargo->yyc, "\tHB_P_JUMPTRUEFAR, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ], pFunc->pCode[ lPCodePos + 3 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 + pFunc->pCode[ lPCodePos + 3 ] * 65536 ); if( lOffset > 8388607L ) lOffset -= 16777216; fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, ( LONG ) ( lPCodePos + lOffset ) ); } fprintf( cargo->yyc, "\n" ); return 4; } static HB_GENC_FUNC( hb_p_less ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_LESS,\n" ); return 1; } static HB_GENC_FUNC( hb_p_lessequal ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call bool ObjLessEqual( object, object )\n" ); // fprintf( cargo->yyc, "\tHB_P_LESSEQUAL,\n" ); return 1; } static HB_GENC_FUNC( hb_p_line ) { fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "nop // HB_P_LINE\n" ); // if( cargo->bVerbose ) // fprintf( cargo->yyc, "/* %05li */ ", lPCodePos ); // else // fprintf( cargo->yyc, "\t" ); // fprintf( cargo->yyc, "HB_P_LINE, %i, %i,", // pFunc->pCode[ lPCodePos + 1 ], // pFunc->pCode[ lPCodePos + 2 ] ); // if( cargo->bVerbose ) // fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); // fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_localname ) { ULONG ulStart = lPCodePos; fprintf( cargo->yyc, "\tHB_P_LOCALNAME, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + lPCodePos + 3 ); fprintf( cargo->yyc, "\n" ); lPCodePos += 3; while( pFunc->pCode[ lPCodePos ] ) { char chr = pFunc->pCode[ lPCodePos++ ]; if( chr == '\'' || chr == '\\') fprintf( cargo->yyc, " \'\\%c\',", chr ); else fprintf( cargo->yyc, " \'%c\',", chr ); } fprintf( cargo->yyc, " 0,\n" ); return (USHORT) ( lPCodePos - ulStart + 1 ); } static HB_GENC_FUNC( hb_p_macropop ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPOP, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropopaliased ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPOPALIASED, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropush ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSH, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropusharg ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSHARG, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropushlist ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSHLIST, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropushindex ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSHINDEX, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropushpare ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSHPARE, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macropushaliased ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROPUSHALIASED, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_macrosymbol ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROSYMBOL,\n" ); return 1; } static HB_GENC_FUNC( hb_p_macrotext ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROTEXT,\n" ); return 1; } static HB_GENC_FUNC( hb_p_message ) { fprintf( cargo->yyc, "\tHB_P_MESSAGE, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_minus ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MINUS,\n" ); return 1; } static HB_GENC_FUNC( hb_p_modulename ) { ULONG ulStart = lPCodePos; fprintf( cargo->yyc, "\tHB_P_MODULENAME," ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + lPCodePos + 1 ); fprintf( cargo->yyc, "\n" ); lPCodePos++; while( pFunc->pCode[ lPCodePos ] ) { char chr = pFunc->pCode[ lPCodePos++ ]; if( chr == '\'' || chr == '\\') fprintf( cargo->yyc, " \'\\%c\',", chr ); else fprintf( cargo->yyc, " \'%c\',", chr ); } fprintf( cargo->yyc, " 0,\n" ); return (USHORT) ( lPCodePos - ulStart + 1 ); } static HB_GENC_FUNC( hb_p_modulus ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MODULUS,\n" ); return 1; } static HB_GENC_FUNC( hb_p_mult ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MULT,\n" ); return 1; } static HB_GENC_FUNC( hb_p_negate ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_NEGATE,\n" ); return 1; } static HB_GENC_FUNC( hb_p_not ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "call object ObjNot( object )\n" ); // fprintf( cargo->yyc, "\tHB_P_NOT,\n" ); return 1; } static HB_GENC_FUNC( hb_p_notequal ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_NOTEQUAL,\n" ); return 1; } static HB_GENC_FUNC( hb_p_or ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_OR,\n" ); return 1; } static HB_GENC_FUNC( hb_p_parameter ) { fprintf( cargo->yyc, "\tHB_P_PARAMETER, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ], pFunc->pCode[ lPCodePos + 3 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 4; } static HB_GENC_FUNC( hb_p_plus ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " call object ObjAdd( object, object )\n" ); // fprintf( cargo->yyc, "\tHB_P_PLUS,\n" ); return 1; } static HB_GENC_FUNC( hb_p_pop ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_POP,\n" ); return 1; } static HB_GENC_FUNC( hb_p_popalias ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_POPALIAS,\n" ); return 1; } static HB_GENC_FUNC( hb_p_popaliasedfield ) { fprintf( cargo->yyc, "\tHB_P_POPALIASEDFIELD, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_popaliasedfieldnear ) { fprintf( cargo->yyc, "\tHB_P_POPALIASEDFIELDNEAR, %i,", pFunc->pCode[ lPCodePos + 1 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] )->szName ); fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_popaliasedvar ) { fprintf( cargo->yyc, "\tHB_P_POPALIASEDVAR, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_popfield ) { fprintf( cargo->yyc, "\tHB_P_POPFIELD, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_poplocal ) { fprintf( cargo->yyc, "\tHB_P_POPLOCAL, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { SHORT wVar = * ( ( SHORT * ) &( pFunc->pCode )[ lPCodePos + 1 ] ); /* Variable with negative order are local variables * referenced in a codeblock -handle it with care */ if( cargo->iNestedCodeblock ) { /* we are accesing variables within a codeblock */ /* the names of codeblock variable are lost */ if( wVar < 0 ) fprintf( cargo->yyc, "\t/* localvar%i */", -wVar ); else fprintf( cargo->yyc, "\t/* codeblockvar%i */", wVar ); } else fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, wVar )->szName ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_poplocalnear ) { // important: check the below code for codeblock locals management fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); // warning: IL requires zero based locals index fprintf( cargo->yyc, "stloc.%i\n", pFunc->pCode[ lPCodePos + 1 ] - 1 ); // fprintf( cargo->yyc, "\tHB_P_POPLOCALNEAR, %i,", // pFunc->pCode[ lPCodePos + 1 ] ); // if( cargo->bVerbose ) // { // char wVar = ( char ) pFunc->pCode[ lPCodePos + 1 ]; // /* Variable with negative order are local variables // * referenced in a codeblock -handle it with care // */ // // if( cargo->iNestedCodeblock ) // { // /* we are accesing variables within a codeblock */ // /* the names of codeblock variable are lost */ // if( wVar < 0 ) // fprintf( cargo->yyc, "\t/* localvar%i */", -wVar ); // else // fprintf( cargo->yyc, "\t/* codeblockvar%i */", wVar ); // } // else // fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, wVar )->szName ); // } // fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_popmemvar ) { fprintf( cargo->yyc, "\tHB_P_POPMEMVAR, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_popstatic ) { fprintf( cargo->yyc, "\tHB_P_POPSTATIC, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { PVAR pVar; PFUNCTION pTmp = hb_comp_functions.pFirst; USHORT wVar = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256; while( pTmp->pNext && pTmp->pNext->iStaticsBase < wVar ) pTmp = pTmp->pNext; pVar = hb_compVariableFind( pTmp->pStatics, wVar - pTmp->iStaticsBase ); fprintf( cargo->yyc, "\t/* %s */", pVar->szName ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_popvariable ) { fprintf( cargo->yyc, "\tHB_P_POPVARIABLE, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_power ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_POWER,\n" ); return 1; } static HB_GENC_FUNC( hb_p_pushalias ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHALIAS,\n" ); return 1; } static HB_GENC_FUNC( hb_p_pushaliasedfield ) { fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDFIELD, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushaliasedfieldnear ) { fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDFIELDNEAR, %i,", pFunc->pCode[ lPCodePos + 1 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] )->szName ); fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_pushaliasedvar ) { fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDVAR, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushblock ) { USHORT wVar, w; ULONG ulStart = lPCodePos; ++cargo->iNestedCodeblock; fprintf( cargo->yyc, "\tHB_P_PUSHBLOCK, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); fprintf( cargo->yyc, "\n" ); w = * ( ( USHORT * ) &( pFunc->pCode [ lPCodePos + 3 ] ) ); fprintf( cargo->yyc, "\t%i, %i,", pFunc->pCode[ lPCodePos + 3 ], pFunc->pCode[ lPCodePos + 4 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* number of local parameters (%i) */", w ); fprintf( cargo->yyc, "\n" ); wVar = * ( ( USHORT * ) &( pFunc->pCode [ lPCodePos + 5 ] ) ); fprintf( cargo->yyc, "\t%i, %i,", pFunc->pCode[ lPCodePos + 5 ], pFunc->pCode[ lPCodePos + 6 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* number of local variables (%i) */", wVar ); fprintf( cargo->yyc, "\n" ); lPCodePos += 7; /* codeblock size + number of parameters + number of local variables */ /* create the table of referenced local variables */ while( wVar-- ) { w = * ( ( USHORT * ) &( pFunc->pCode [ lPCodePos ] ) ); fprintf( cargo->yyc, "\t%i, %i,", pFunc->pCode[ lPCodePos ], pFunc->pCode[ lPCodePos + 1 ] ); /* NOTE: * When a codeblock is used to initialize a static variable * the names of local variables cannot be determined * because at the time of C code generation we don't know * in which function was defined this local variable */ if( ( pFunc->cScope & ( HB_FS_INIT | HB_FS_EXIT ) ) != ( HB_FS_INIT | HB_FS_EXIT ) ) if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, w )->szName ); fprintf( cargo->yyc, "\n" ); lPCodePos +=2; } return (USHORT) (lPCodePos - ulStart); } static HB_GENC_FUNC( hb_p_pushblockshort ) { ++cargo->iNestedCodeblock; fprintf( cargo->yyc, "\tHB_P_PUSHBLOCKSHORT, %i,", pFunc->pCode[ lPCodePos + 1 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] ); fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_pushdouble ) { int i; fprintf( cargo->yyc, "\tHB_P_PUSHDOUBLE," ); ++lPCodePos; for( i = 0; i < sizeof( double ) + sizeof( BYTE ) + sizeof( BYTE ); ++i ) fprintf( cargo->yyc, " %i,", ( ( BYTE * ) pFunc->pCode )[ lPCodePos + i ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %.*f, %d, %d */", *( ( BYTE * ) &( pFunc->pCode[ lPCodePos + sizeof( double ) ] ) ), *( ( double * ) &( pFunc->pCode[ lPCodePos ] ) ), *( ( BYTE * ) &( pFunc->pCode[ lPCodePos + sizeof( double ) ] ) ), *( ( BYTE * ) &( pFunc->pCode[ lPCodePos + sizeof( double ) + sizeof( BYTE ) ] ) ) ); fprintf( cargo->yyc, "\n" ); return sizeof( double ) + sizeof( BYTE ) + sizeof( BYTE ) + 1; } static HB_GENC_FUNC( hb_p_pushfield ) { fprintf( cargo->yyc, "\tHB_P_PUSHFIELD, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushbyte ) { fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); // load constant numeric onto the stack fprintf( cargo->yyc, "ldc.i4.s %i\n", pFunc->pCode[ lPCodePos + 1 ] ); // turn the stack value into an object fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" ); // fprintf( cargo->yyc, "\tHB_P_PUSHBYTE, %i,", // pFunc->pCode[ lPCodePos + 1 ] ); // if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", // pFunc->pCode[ lPCodePos + 1 ] ); // fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_pushint ) { fprintf( cargo->yyc, "\tHB_P_PUSHINT, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushlocal ) { fprintf( cargo->yyc, "\tHB_P_PUSHLOCAL, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { SHORT wVar = * ( ( SHORT * ) &( pFunc->pCode )[ lPCodePos + 1 ] ); /* Variable with negative order are local variables * referenced in a codeblock -handle it with care */ if( cargo->iNestedCodeblock ) { /* we are accesing variables within a codeblock */ /* the names of codeblock variable are lost */ if( wVar < 0 ) fprintf( cargo->yyc, "\t/* localvar%i */", -wVar ); else fprintf( cargo->yyc, "\t/* codeblockvar%i */", wVar ); } else fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, wVar )->szName ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushlocalnear ) { // Important: check the below code for codeblocks locals fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); // Warning: IL uses zero based locals indexes fprintf( cargo->yyc, "ldloc.%i\n", pFunc->pCode[ lPCodePos + 1 ] - 1 ); // fprintf( cargo->yyc, "\tHB_P_PUSHLOCALNEAR, %i,", // pFunc->pCode[ lPCodePos + 1 ] ); // if( cargo->bVerbose ) // { // signed char wVar = ( signed char ) pFunc->pCode[ lPCodePos + 1 ]; // /* Variable with negative order are local variables // * referenced in a codeblock -handle it with care // */ // // if( cargo->iNestedCodeblock ) // { // /* we are accesing variables within a codeblock */ // /* the names of codeblock variable are lost */ // if( wVar < 0 ) // fprintf( cargo->yyc, "\t/* localvar%i */", -wVar ); // else // fprintf( cargo->yyc, "\t/* codeblockvar%i */", wVar ); // } // else // fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, wVar )->szName ); // } // fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_pushlocalref ) { fprintf( cargo->yyc, "\tHB_P_PUSHLOCALREF, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { SHORT wVar = * ( ( SHORT * ) &( pFunc->pCode )[ lPCodePos + 1 ] ); /* Variable with negative order are local variables * referenced in a codeblock -handle it with care */ if( cargo->iNestedCodeblock ) { /* we are accesing variables within a codeblock */ /* the names of codeblock variable are lost */ if( wVar < 0 ) fprintf( cargo->yyc, "\t/* localvar%i */", -wVar ); else fprintf( cargo->yyc, "\t/* codeblockvar%i */", wVar ); } else fprintf( cargo->yyc, "\t/* %s */", hb_compLocalVariableFind( pFunc, wVar )->szName ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushlong ) { fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "ldc.i4 %li\n", *( ( long * ) &( pFunc->pCode[ lPCodePos + 1 ] ) ) ); fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" ); // fprintf( cargo->yyc, "\tHB_P_PUSHLONG, %i, %i, %i, %i,", // pFunc->pCode[ lPCodePos + 1 ], // pFunc->pCode[ lPCodePos + 2 ], // pFunc->pCode[ lPCodePos + 3 ], // pFunc->pCode[ lPCodePos + 4 ] ); // if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %li */", *( ( long * ) &( pFunc->pCode[ lPCodePos + 1 ] ) ) ); // fprintf( cargo->yyc, "\n" ); return 1 + sizeof( long ); } static HB_GENC_FUNC( hb_p_pushmemvar ) { fprintf( cargo->yyc, "\tHB_P_PUSHMEMVAR, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushmemvarref ) { fprintf( cargo->yyc, "\tHB_P_PUSHMEMVARREF, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushnil ) { HB_FUNCALLS_PTR pTemp = pFunCalls; HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); if( pTemp ) { while( pTemp->pNext ) pTemp = ( HB_FUNCALLS_PTR ) pTemp->pNext; if( pTemp->bFirstParam ) pTemp->bFirstParam = FALSE; else { // fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); // fprintf( cargo->yyc, "ldnull\n" ); } } else { // fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); // fprintf( cargo->yyc, "ldnull\n" ); } // fprintf( cargo->yyc, " // HB_P_PUSHNIL,\n" ); return 1; } static HB_GENC_FUNC( hb_p_pushself ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_PUSHSELF,\n" ); return 1; } static HB_GENC_FUNC( hb_p_pushstatic ) { fprintf( cargo->yyc, "\tHB_P_PUSHSTATIC, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { PVAR pVar; PFUNCTION pTmp = hb_comp_functions.pFirst; USHORT wVar = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256; while( pTmp->pNext && pTmp->pNext->iStaticsBase < wVar ) pTmp = pTmp->pNext; pVar = hb_compVariableFind( pTmp->pStatics, wVar - pTmp->iStaticsBase ); fprintf( cargo->yyc, "\t/* %s */", pVar->szName ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushstaticref ) { fprintf( cargo->yyc, "\tHB_P_PUSHSTATICREF, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) { PVAR pVar; PFUNCTION pTmp = hb_comp_functions.pFirst; USHORT wVar = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256; while( pTmp->pNext && pTmp->pNext->iStaticsBase < wVar ) pTmp = pTmp->pNext; pVar = hb_compVariableFind( pTmp->pStatics, wVar - pTmp->iStaticsBase ); fprintf( cargo->yyc, "\t/* %s */", pVar->szName ); } fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushstr ) { ULONG ulStart = lPCodePos; USHORT wLen = pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256; fprintf( cargo->yyc, "\tHB_P_PUSHSTR, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %i */", wLen ); lPCodePos += 3; if( wLen > 0 ) { fprintf( cargo->yyc, "\n\t" ); while( wLen-- ) { BYTE uchr = ( BYTE ) pFunc->pCode[ lPCodePos++ ]; /* * NOTE: After optimization some CHR(n) can be converted * into a string containing nonprintable characters. * * TODO: add switch to use hexadecimal format "%#04x" */ if( ( uchr < ( BYTE ) ' ' ) || ( uchr >= 127 ) ) fprintf( cargo->yyc, "%i, ", uchr ); else if( strchr( "\'\\\"", uchr ) ) fprintf( cargo->yyc, "%i, ", uchr ); else fprintf( cargo->yyc, "\'%c\', ", uchr ); } } fprintf( cargo->yyc, "\n" ); return (USHORT) (lPCodePos - ulStart); } static HB_GENC_FUNC( hb_p_pushstrshort ) { ULONG ulStart = lPCodePos; USHORT wLen = pFunc->pCode[ lPCodePos + 1 ]; // fprintf( cargo->yyc, "\tHB_P_PUSHSTRSHORT, %i,", pFunc->pCode[ lPCodePos + 1 ] ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "ldstr " ); // if( cargo->bVerbose ) // fprintf( cargo->yyc, "\t/* %i */", wLen ); lPCodePos += 2; if( wLen > 0 ) { fprintf( cargo->yyc, "\"" ); while( wLen-- ) { BYTE uchr = ( BYTE ) pFunc->pCode[ lPCodePos++ ]; /* * NOTE: After optimization some CHR(n) can be converted * into a string containing nonprintable characters. * * TODO: add switch to use hexadecimal format "%#04x" */ if( uchr == 0 ) fprintf( cargo->yyc, "" ); else if( ( uchr < ( BYTE ) ' ' ) || ( uchr >= 127 ) ) fprintf( cargo->yyc, "%i, ", uchr ); else if( strchr( "\'\\\"", uchr ) ) fprintf( cargo->yyc, "%i, ", uchr ); else fprintf( cargo->yyc, "%c", uchr ); } } fprintf( cargo->yyc, "\"\n" ); return (USHORT) ( lPCodePos - ulStart ); } static HB_GENC_FUNC( hb_p_pushsym ) { fprintf( cargo->yyc, "\tHB_P_PUSHSYM, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_pushsymnear ) { HB_FUNCALLS_PTR pTemp = pFunCalls; if( pTemp != NULL ) { while( pTemp->pNext != NULL ) pTemp = ( HB_FUNCALLS_PTR ) pTemp->pNext; pTemp->pNext = ( HB_FUNCALLS_PTR ) hb_xgrab( sizeof( HB_FUNCALLS ) ); pTemp = ( HB_FUNCALLS_PTR ) pTemp->pNext; } else { pFunCalls = ( HB_FUNCALLS_PTR ) hb_xgrab( sizeof( HB_FUNCALLS ) ); pTemp = pFunCalls; } pTemp->szName = hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] )->szName; pTemp->bFirstParam = TRUE; pTemp->pNext = NULL; // fprintf( cargo->yyc, "\tHB_P_PUSHSYMNEAR, %i,", // pFunc->pCode[ lPCodePos + 1 ] ); // if( cargo->bVerbose ) // fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] )->szName ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "nop\n" ); // fprintf( cargo->yyc, " call void %s()\n", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] )->szName ); // fprintf( cargo->yyc, "\n" ); return 2; } static HB_GENC_FUNC( hb_p_pushvariable ) { fprintf( cargo->yyc, "\tHB_P_PUSHVARIABLE, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolGetPos( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 )->szName ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_retvalue ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " // HB_P_RETVALUE,\n" ); return 1; } static HB_GENC_FUNC( hb_p_send ) { fprintf( cargo->yyc, "\tHB_P_SEND, %i, %i,\n", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); return 3; } static HB_GENC_FUNC( hb_p_sendshort ) { fprintf( cargo->yyc, "\tHB_P_SENDSHORT, %i,\n", pFunc->pCode[ lPCodePos + 1 ] ); return 2; } static HB_GENC_FUNC( hb_p_seqbegin ) { fprintf( cargo->yyc, "\tHB_P_SEQBEGIN, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ], pFunc->pCode[ lPCodePos + 3 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 + pFunc->pCode[ lPCodePos + 3 ] * 65536 ); fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, lPCodePos + lOffset ); } fprintf( cargo->yyc, "\n" ); return 4; } static HB_GENC_FUNC( hb_p_seqend ) { if( cargo->bVerbose ) fprintf( cargo->yyc, "/* %05li */ ", lPCodePos ); else fprintf( cargo->yyc, "\t" ); fprintf( cargo->yyc, "HB_P_SEQEND, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ], pFunc->pCode[ lPCodePos + 3 ] ); if( cargo->bVerbose ) { LONG lOffset = ( LONG ) ( pFunc->pCode[ lPCodePos + 1 ] + pFunc->pCode[ lPCodePos + 2 ] * 256 + pFunc->pCode[ lPCodePos + 3 ] * 65536 ); fprintf( cargo->yyc, "\t/* %li (abs: %05li) */", lOffset, lPCodePos + lOffset ); } fprintf( cargo->yyc, "\n" ); return 4; } static HB_GENC_FUNC( hb_p_seqrecover ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_SEQRECOVER,\n" ); return 1; } static HB_GENC_FUNC( hb_p_sframe ) { fprintf( cargo->yyc, "\tHB_P_SFRAME, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* symbol (_INITSTATICS) */" ); fprintf( cargo->yyc, "\n" ); return 3; } static HB_GENC_FUNC( hb_p_statics ) { PFUNCTION pInitStatics = hb_comp_functions.pFirst; PVAR pVar; USHORT wVar = 0, i; char chr; long lByteCount = 5; fprintf( cargo->yyc, "\tHB_P_STATICS, %i, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ], pFunc->pCode[ lPCodePos + 3 ], pFunc->pCode[ lPCodePos + 4 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* symbol (_INITSTATICS), %i statics */", pFunc->pCode[ lPCodePos + 3 ] + pFunc->pCode[ lPCodePos + 4 ] * 256 ); fprintf( cargo->yyc, "\n" ); if( hb_comp_bDebugInfo ) { if( pInitStatics->szName[0] == 0 ) /* is _INITSTATICS ? */ { pVar = pInitStatics->pStatics; /* first static variable */ while( pVar ) { fprintf( cargo->yyc, "\tHB_P_STATICNAME, 1, %i, %i,", /* 1 means global static */ HB_LOBYTE( wVar + 1 ), HB_HIBYTE( wVar + 1 ) ); lByteCount += 4; if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", pVar->szName ); fprintf( cargo->yyc, "\n" ); i = 0; while( ( chr = pVar->szName[ i++ ] ) != 0 ) { if( chr == '\'' || chr == '\\') fprintf( cargo->yyc, " \'\\%c\',", chr ); else fprintf( cargo->yyc, " \'%c\',", chr ); lByteCount++; } fprintf( cargo->yyc, " 0,\n" ); lByteCount++; pVar = pVar->pNext; wVar++; } } } return (USHORT) lByteCount; } static HB_GENC_FUNC( hb_p_staticname ) { ULONG ulStart = lPCodePos; fprintf( cargo->yyc, "\tHB_P_STATICNAME, 0, %i, %i,", /* zero means it is a in-function static */ pFunc->pCode[ lPCodePos + 1 ], pFunc->pCode[ lPCodePos + 2 ] ); if( cargo->bVerbose ) fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + lPCodePos + 3 ); fprintf( cargo->yyc, "\n" ); lPCodePos += 3; while( pFunc->pCode[ lPCodePos ] ) { char chr = pFunc->pCode[ lPCodePos++ ]; if( chr == '\'' || chr == '\\') fprintf( cargo->yyc, " \'\\%c\',", chr ); else fprintf( cargo->yyc, " \'%c\',", chr ); } fprintf( cargo->yyc, " 0,\n" ); return (USHORT) ( lPCodePos - ulStart + 1 ); } static HB_GENC_FUNC( hb_p_swapalias ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_SWAPALIAS,\n" ); return 1; } static HB_GENC_FUNC( hb_p_true ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "ldc.i4.1\n" ); fprintf( cargo->yyc, " box [mscorlib]System.Boolean\n" ); // fprintf( cargo->yyc, "\tHB_P_TRUE,\n" ); return 1; } static HB_GENC_FUNC( hb_p_one ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "ldc.i4.1\n" ); // turn the stack value into an object fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" ); // fprintf( cargo->yyc, "\tHB_P_ONE,\n" ); return 1; } static HB_GENC_FUNC( hb_p_zero ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_ZERO,\n" ); return 1; } static HB_GENC_FUNC( hb_p_noop ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_NOOP,\n" ); return 1; } static HB_GENC_FUNC( hb_p_dummy ) { HB_SYMBOL_UNUSED( cargo ); HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); return 1; } static HB_GENC_FUNC( hb_p_macrolist ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROLIST,\n" ); return 1; } static HB_GENC_FUNC( hb_p_macrolistend ) { HB_SYMBOL_UNUSED( pFunc ); HB_SYMBOL_UNUSED( lPCodePos ); fprintf( cargo->yyc, "\tHB_P_MACROLISTEND,\n" ); return 1; } #define HB_PCODE_MKSHORT( p ) ( *( SHORT * )( p ) ) static HB_GENC_FUNC( hb_p_localnearaddint ) { fprintf( cargo->yyc, " IL_%04lX: ", lPCodePos ); fprintf( cargo->yyc, "ldloc.%i\n", pFunc->pCode[ lPCodePos + 1 ] - 1 ); fprintf( cargo->yyc, " unbox [mscorlib]System.Int32\n" ); fprintf( cargo->yyc, " ldind.i4\n" ); fprintf( cargo->yyc, " ldc.i4.s %i\n", pFunc->pCode[ lPCodePos + 2 ] + ( pFunc->pCode[ lPCodePos + 3 ] * 256 ) ); fprintf( cargo->yyc, " add\n" ); fprintf( cargo->yyc, " box [mscorlib]System.Int32\n" ); fprintf( cargo->yyc, " stloc.%i\n", pFunc->pCode[ lPCodePos + 1 ] - 1 ); // fprintf( cargo->yyc, "\tHB_P_LOCALNEARADDINT, %i, %i, %i,", pFunc->pCode[ lPCodePos + 1 ], // pFunc->pCode[ lPCodePos + 2 ], // pFunc->pCode[ lPCodePos + 3 ] ); // // if( cargo->bVerbose ) // { // fprintf( cargo->yyc, "\t/* %s %i*/", hb_compLocalVariableFind( pFunc, ( signed char ) pFunc->pCode[ lPCodePos + 1 ] )->szName, // HB_PCODE_MKSHORT( &( pFunc->pCode[ lPCodePos + 2 ] ) ) ); // } // // fprintf( cargo->yyc, "\n" ); return 4; } /* NOTE: The order of functions have to match the order of opcodes * mnemonics */ static HB_GENC_FUNC_PTR s_verbose_table[] = { hb_p_and, hb_p_arraypush, hb_p_arraypop, hb_p_arraydim, hb_p_arraygen, hb_p_equal, hb_p_endblock, hb_p_endproc, hb_p_exactlyequal, hb_p_false, hb_p_fortest, hb_p_function, hb_p_functionshort, hb_p_frame, hb_p_funcptr, hb_p_greater, hb_p_greaterequal, hb_p_dec, hb_p_divide, hb_p_do, hb_p_doshort, hb_p_duplicate, hb_p_dupltwo, hb_p_inc, hb_p_instring, hb_p_jumpnear, hb_p_jump, hb_p_jumpfar, hb_p_jumpfalsenear, hb_p_jumpfalse, hb_p_jumpfalsefar, hb_p_jumptruenear, hb_p_jumptrue, hb_p_jumptruefar, hb_p_lessequal, hb_p_less, hb_p_line, hb_p_localname, hb_p_macropop, hb_p_macropopaliased, hb_p_macropush, hb_p_macropusharg, hb_p_macropushlist, hb_p_macropushindex, hb_p_macropushpare, hb_p_macropushaliased, hb_p_macrosymbol, hb_p_macrotext, hb_p_message, hb_p_minus, hb_p_modulus, hb_p_modulename, /* start: pcodes generated by macro compiler */ hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, hb_p_dummy, /* end: */ hb_p_mult, hb_p_negate, hb_p_noop, hb_p_not, hb_p_notequal, hb_p_or, hb_p_parameter, hb_p_plus, hb_p_pop, hb_p_popalias, hb_p_popaliasedfield, hb_p_popaliasedfieldnear, hb_p_popaliasedvar, hb_p_popfield, hb_p_poplocal, hb_p_poplocalnear, hb_p_popmemvar, hb_p_popstatic, hb_p_popvariable, hb_p_power, hb_p_pushalias, hb_p_pushaliasedfield, hb_p_pushaliasedfieldnear, hb_p_pushaliasedvar, hb_p_pushblock, hb_p_pushblockshort, hb_p_pushfield, hb_p_pushbyte, hb_p_pushint, hb_p_pushlocal, hb_p_pushlocalnear, hb_p_pushlocalref, hb_p_pushlong, hb_p_pushmemvar, hb_p_pushmemvarref, hb_p_pushnil, hb_p_pushdouble, hb_p_pushself, hb_p_pushstatic, hb_p_pushstaticref, hb_p_pushstr, hb_p_pushstrshort, hb_p_pushsym, hb_p_pushsymnear, hb_p_pushvariable, hb_p_retvalue, hb_p_send, hb_p_sendshort, hb_p_seqbegin, hb_p_seqend, hb_p_seqrecover, hb_p_sframe, hb_p_statics, hb_p_staticname, hb_p_swapalias, hb_p_true, hb_p_zero, hb_p_one, hb_p_macrolist, hb_p_macrolistend, /* start: more pcodes generated by macro compiler */ hb_p_dummy, /* end: */ hb_p_localnearaddint }; static void hb_compGenCReadable( PFUNCTION pFunc, FILE * yyc ) { HB_GENC_INFO genc_info; /* Make sure that table is correct */ assert( HB_P_LAST_PCODE == sizeof( s_verbose_table ) / sizeof( HB_GENC_FUNC_PTR ) ); genc_info.iNestedCodeblock = 0; genc_info.bVerbose = ( hb_comp_iGenCOutput == HB_COMPGENC_VERBOSE ); genc_info.yyc = yyc; hb_compPCodeEval( pFunc, ( HB_PCODE_FUNC_PTR * ) s_verbose_table, ( void * ) &genc_info ); // if( genc_info.bVerbose ) // fprintf( yyc, "/* %05li */\n", pFunc->lPCodePos ); } static void hb_compGenCCompact( PFUNCTION pFunc, FILE * yyc ) { ULONG lPCodePos = 0; int nChar; fprintf( yyc, "\t" ); nChar = 0; while( lPCodePos < pFunc->lPCodePos ) { ++nChar; if( nChar > 1 ) fprintf( yyc, ", " ); if( nChar == 15 ) { fprintf( yyc, "\n\t" ); nChar = 1; } /* Displaying as decimal is more compact than hex */ fprintf( yyc, "%d", ( int ) pFunc->pCode[ lPCodePos++ ] ); } if( nChar != 0) fprintf( yyc, "\n" ); } static void hb_genNetFunctions( FILE * yyc ) { int i; // generated IL code for C# source code: // public static object ObjAdd( object a, object b ) // { // if( a.GetType() == typeof( int ) && b.GetType() == typeof( int ) ) // return ( int ) a + ( int ) b; // // if( a.GetType() == typeof( string ) && b.GetType() == typeof( string ) ) // return a.ToString() + b.ToString(); // // return null; // } // VERY IMPORTANT: As ObjAdd() is a public method, not specific to a Class, // then arguments have to be decreased, as on a normal method, argument 0 is Self. char * ObjAdd[] = { "\n.method public static object ObjAdd(object a, object b)", "{", " .maxstack 2", " .locals init (object V_0)", " IL_0000: ldarg.0", " IL_0001: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0006: ldtoken [mscorlib]System.Int32", " IL_000b: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0010: bne.un.s IL_003b", " IL_0012: ldarg.1", " IL_0013: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0018: ldtoken [mscorlib]System.Int32", " IL_001d: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0022: bne.un.s IL_003b", " IL_0024: ldarg.0", " IL_0025: unbox [mscorlib]System.Int32", " IL_002a: ldind.i4", " IL_002b: ldarg.1", " IL_002c: unbox [mscorlib]System.Int32", " IL_0031: ldind.i4", " IL_0032: add", " IL_0033: box [mscorlib]System.Int32", " IL_0038: stloc.0", " IL_0039: br.s IL_0077", " IL_003b: ldarg.0", " IL_003c: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0041: ldtoken [mscorlib]System.String", " IL_0046: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_004b: bne.un.s IL_0073", " IL_004d: ldarg.1", " IL_004e: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0053: ldtoken [mscorlib]System.String", " IL_0058: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_005d: bne.un.s IL_0073", " IL_005f: ldarg.0", " IL_0060: callvirt instance string [mscorlib]System.Object::ToString()", " IL_0065: ldarg.1", " IL_0066: callvirt instance string [mscorlib]System.Object::ToString()", " IL_006b: call string [mscorlib]System.String::Concat(string,string)", " IL_0070: stloc.0", " IL_0071: br.s IL_0077", " IL_0073: ldnull", " IL_0074: stloc.0", " IL_0075: br.s IL_0077", " IL_0077: ldloc.0", " IL_0078: ret", "}", 0 }; // public static object ObjArrayGen( __arglist ) // { // ArrayList a = new ArrayList(); // ArgIterator ai = new ArgIterator( __arglist ); // // while( ai.GetRemainingCount() > 0 ) // a.Add( __refvalue( ai.GetNextArg(), object ) ); // // return a; // } char * ObjArrayGen[] = { "\n.method public static vararg object ObjArrayGen()", "{", " .maxstack 2", " .locals init (class [mscorlib]System.Collections.ArrayList V_0,", " valuetype [mscorlib]System.ArgIterator V_1,", " object V_2)", " IL_0000: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor()", " IL_0005: stloc.0", " IL_0006: ldloca.s V_1", " IL_0008: arglist", " IL_000a: call instance void [mscorlib]System.ArgIterator::.ctor(valuetype [mscorlib]System.RuntimeArgumentHandle)", " IL_000f: br.s IL_0025", " IL_0011: ldloc.0", " IL_0012: ldloca.s V_1", " IL_0014: call instance typedref [mscorlib]System.ArgIterator::GetNextArg()", " IL_0019: refanyval [mscorlib]System.Object", " IL_001e: ldind.ref", " IL_001f: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)", " IL_0024: pop", " IL_0025: ldloca.s V_1", " IL_0027: call instance int32 [mscorlib]System.ArgIterator::GetRemainingCount()", " IL_002c: ldc.i4.0", " IL_002d: bgt.s IL_0011", " IL_002f: ldloc.0", " IL_0030: stloc.2", " IL_0031: br.s IL_0033", " IL_0033: ldloc.2", " IL_0034: ret", "}", 0 }; // public static object ObjArrayPush( object array, object index ) // { // return ( ( ArrayList ) array )[ ( ( int ) index ) - 1 ]; // } char * ObjArrayPush[] = { "\n.method public static object ObjArrayPush(object 'array', object index)", "{", " .maxstack 3", " .locals init (object V_0)", " IL_0000: ldarg.0", " IL_0001: castclass [mscorlib]System.Collections.ArrayList", " IL_0006: ldarg.1", " IL_0007: unbox [mscorlib]System.Int32", " IL_000c: ldind.i4", " IL_000d: ldc.i4.1", " IL_000e: sub", " IL_000f: callvirt instance object [mscorlib]System.Collections.ArrayList::get_Item(int32)", " IL_0014: stloc.0", " IL_0015: br.s IL_0017", " IL_0017: ldloc.0", " IL_0018: ret", "}", 0 }; // public static bool ObjLessEqual( object a, object b ) // { // if( a.GetType() == typeof( int ) && b.GetType() == typeof( int ) ) // return ( int ) a <= ( int ) b; // // return false; // } char * ObjLessEqual[] = { "\n.method public static bool ObjLessEqual( object a, object b )", "{", " .maxstack 2", " .locals init (bool V_0)", " IL_0000: ldarg.0", " IL_0001: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0006: ldtoken [mscorlib]System.Int32", " IL_000b: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0010: bne.un.s IL_003a", " IL_0012: ldarg.1", " IL_0013: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0018: ldtoken [mscorlib]System.Int32", " IL_001d: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0022: bne.un.s IL_003a", " IL_0024: ldarg.0", " IL_0025: unbox [mscorlib]System.Int32", " IL_002a: ldind.i4", " IL_002b: ldarg.1", " IL_002c: unbox [mscorlib]System.Int32", " IL_0031: ldind.i4", " IL_0032: cgt", " IL_0034: ldc.i4.0", " IL_0035: ceq", " IL_0037: stloc.0", " IL_0038: br.s IL_003e", " IL_003a: ldc.i4.0", " IL_003b: stloc.0", " IL_003c: br.s IL_003e", " IL_003e: ldloc.0", " IL_003f: ret", "}", 0 }; // public static bool ObjForTest( object current, object end, object step ) // { // if( ( int ) step >= 0 ) // return ( int ) current <= ( int ) end; // else // return ( int ) current >= ( int ) end; // } char * ObjForTest[] = { "\n.method public static bool ObjForTest(object current,object end,object step)", "{", " .maxstack 2", " .locals init (bool V_0)", " IL_0000: ldarg.2", " IL_0001: unbox [mscorlib]System.Int32", " IL_0006: ldind.i4", " IL_0007: ldc.i4.0", " IL_0008: blt.s IL_0020", " IL_000a: ldarg.0", " IL_000b: unbox [mscorlib]System.Int32", " IL_0010: ldind.i4", " IL_0011: ldarg.1", " IL_0012: unbox [mscorlib]System.Int32", " IL_0017: ldind.i4", " IL_0018: cgt", " IL_001a: ldc.i4.0", " IL_001b: ceq", " IL_001d: stloc.0", " IL_001e: br.s IL_0036", " IL_0020: ldarg.0", " IL_0021: unbox [mscorlib]System.Int32", " IL_0026: ldind.i4", " IL_0027: ldarg.1", " IL_0028: unbox [mscorlib]System.Int32", " IL_002d: ldind.i4", " IL_002e: clt", " IL_0030: ldc.i4.0", " IL_0031: ceq", " IL_0033: stloc.0", " IL_0034: br.s IL_0036", " IL_0036: ldloc.0", " IL_0037: ret", "}", 0 }; // public static bool ObjExactlyEqual( object a, object b ) // { // if( a.GetType() == typeof( int ) && b.GetType() == typeof( int ) ) // return ( int ) a == ( int ) b; // // if( a.GetType() == typeof( string ) && b.GetType() == typeof( string ) ) // return a.ToString() == b.ToString(); // // return false; // } char * ObjExactlyEqual[] = { "\n.method public static bool ObjExactlyEqual(object a, object b)", "{", " .maxstack 2", " .locals init (bool V_0)", " IL_0000: ldarg.0", " IL_0001: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0006: ldtoken [mscorlib]System.Int32", " IL_000b: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0010: bne.un.s IL_0037", " IL_0012: ldarg.1", " IL_0013: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0018: ldtoken [mscorlib]System.Int32", " IL_001d: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0022: bne.un.s IL_0037", " IL_0024: ldarg.0", " IL_0025: unbox [mscorlib]System.Int32", " IL_002a: ldind.i4", " IL_002b: ldarg.1", " IL_002c: unbox [mscorlib]System.Int32", " IL_0031: ldind.i4", " IL_0032: ceq", " IL_0034: stloc.0", " IL_0035: br.s IL_0073", " IL_0037: ldarg.0", " IL_0038: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_003d: ldtoken [mscorlib]System.String", " IL_0042: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0047: bne.un.s IL_006f", " IL_0049: ldarg.1", " IL_004a: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_004f: ldtoken [mscorlib]System.String", " IL_0054: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0059: bne.un.s IL_006f", " IL_005b: ldarg.0", " IL_005c: callvirt instance string [mscorlib]System.Object::ToString()", " IL_0061: ldarg.1", " IL_0062: callvirt instance string [mscorlib]System.Object::ToString()", " IL_0067: call bool [mscorlib]System.String::op_Equality(string,string)", " IL_006c: stloc.0", " IL_006d: br.s IL_0073", " IL_006f: ldc.i4.0", " IL_0070: stloc.0", " IL_0071: br.s IL_0073", " IL_0073: ldloc.0", " IL_0074: ret", "}", 0 }; // public static object ObjNot( object o ) // { // return ! ( bool ) o; // } char * ObjNot[] = { "\n.method public static object ObjNot(object o)", "{", " .maxstack 2", " .locals init (object V_0)", " IL_0000: ldarg.0", " IL_0001: unbox [mscorlib]System.Boolean", " IL_0006: ldind.i1", " IL_0007: ldc.i4.0", " IL_0008: ceq", " IL_000a: box [mscorlib]System.Boolean", " IL_000f: stloc.0", " IL_0010: br.s IL_0012", " IL_0012: ldloc.0", " IL_0013: ret", "}", 0 }; // public static object LEN( object o ) // { // return ( ( ArrayList ) o ).Count; // } char * LEN[] = { "\n.method public static object LEN(object o)", "{", " .maxstack 2", " .locals init (object V_0)", " IL_0000: ldarg.0", " IL_0001: castclass [mscorlib]System.Collections.ArrayList", " IL_0006: callvirt instance int32 [mscorlib]System.Collections.ArrayList::get_Count()", " IL_000b: box [mscorlib]System.Int32", " IL_0010: stloc.0", " IL_0011: br.s IL_0013", " IL_0013: ldloc.0", " IL_0014: ret", "}", 0 }; // public static object QOUT( object o ) // { // if( o == null ) // Console.WriteLine( "NIL" ); // // if( o.GetType() == typeof( bool ) ) // Console.WriteLine( ( bool ) o ? ".T.": ".F." ); // // else // Console.WriteLine( o ); // // return null; // } char * QOUT[] = { "\n.method public static object QOUT(object o)", "{", " .maxstack 2", " .locals init (object V_0)", " IL_0000: ldarg.0", " IL_0001: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0006: ldtoken [mscorlib]System.Boolean", " IL_000b: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)", " IL_0010: bne.un.s IL_002e", " IL_0012: ldarg.0", " IL_0013: unbox [mscorlib]System.Boolean", " IL_0018: ldind.i1", " IL_0019: brtrue.s IL_0022", " IL_001b: ldstr \".F.\"", " IL_0020: br.s IL_0027", " IL_0022: ldstr \".T.\"", " IL_0027: call void [mscorlib]System.Console::WriteLine(string)", " IL_002c: br.s IL_0048", " IL_002e: ldarg.0", " IL_002f: callvirt instance class [mscorlib]System.Type [mscorlib]System.Object::GetType()", " IL_0034: brtrue.s IL_0042", " IL_0036: ldstr \"nil\"", " IL_003b: call void [mscorlib]System.Console::WriteLine(string)", " IL_0040: br.s IL_0048", " IL_0042: ldarg.0", " IL_0043: call void [mscorlib]System.Console::WriteLine(object)", " IL_0048: ldnull", " IL_0049: stloc.0", " IL_004a: br.s IL_004c", " IL_004c: ldloc.0", " IL_004d: ret", "}", 0 }; i = 0; while( ObjAdd[ i ] != 0 ) fprintf( yyc, "%s\n", ObjAdd[ i++ ] ); i = 0; while( ObjArrayGen[ i ] != 0 ) fprintf( yyc, "%s\n", ObjArrayGen[ i++ ] ); i = 0; while( ObjArrayPush[ i ] != 0 ) fprintf( yyc, "%s\n", ObjArrayPush[ i++ ] ); i = 0; while( ObjLessEqual[ i ] != 0 ) fprintf( yyc, "%s\n", ObjLessEqual[ i++ ] ); i = 0; while( ObjForTest[ i ] != 0 ) fprintf( yyc, "%s\n", ObjForTest[ i++ ] ); i = 0; while( ObjExactlyEqual[ i ] != 0 ) fprintf( yyc, "%s\n", ObjExactlyEqual[ i++ ] ); i = 0; while( ObjNot[ i ] != 0 ) fprintf( yyc, "%s\n", ObjNot[ i++ ] ); i = 0; while( LEN[ i ] != 0 ) fprintf( yyc, "%s\n", LEN[ i++ ] ); i = 0; while( QOUT[ i ] != 0 ) fprintf( yyc, "%s\n", QOUT[ i++ ] ); }