/*
 * Compiler C source generation
 *
 * Copyright 1999 Antonio Linares <alinares@fivetech.com>
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 * (or visit their website at https://www.gnu.org/licenses/).
 *
 */

#include "hbcomp.h"
#include "hbdate.h"
#include "hbassert.h"

static void hb_compGenCReadable( HB_COMP_DECL, PHB_HFUNC pFunc, FILE * yyc );
static void hb_compGenCCompact( PHB_HFUNC pFunc, FILE * yyc );
static void hb_compGenCFunc( FILE * yyc, const char * cDecor, const char * szName, HB_BOOL fStrip, int iFuncSuffix );
static void hb_writeEndInit( HB_COMP_DECL, FILE * yyc, const char * szModulname, const char * szSourceFile );

/* helper structure to pass information */
typedef struct HB_stru_genc_info
{
   HB_COMP_DECL;
   FILE *  yyc;
   HB_BOOL bVerbose;
   HB_SIZE nEndBlockPos;
} HB_GENC_INFO, * PHB_GENC_INFO;

#define HB_GENC_FUNC( func )  HB_PCODE_FUNC( func, PHB_GENC_INFO )
typedef HB_GENC_FUNC( HB_GENC_FUNC_ );
typedef HB_GENC_FUNC_ * PHB_GENC_FUNC;

static void hb_compDumpFindCFunc( HB_COMP_DECL )
{
   PHB_HINLINE pInline;

   pInline = HB_COMP_PARAM->inlines.pFirst;
   while( pInline )
   {
      if( pInline->pCode && ! pInline->szName )
      {
         const char * pszCCode = ( const char * ) pInline->pCode;
         char         ch;
         int          len;
         while( ( ch = *pszCCode++ ) != 0 )
         {
            if( HB_ISFIRSTIDCHAR( ch ) )
            {
               if( ch == 'H' && strncmp( pszCCode, "B_FUNC", 6 ) == 0 )
               {
                  HB_SYMBOLSCOPE scope = HB_FS_LOCAL;
                  pszCCode += 6;
                  if( strncmp( pszCCode, "_STATIC", 7 ) == 0 )
                  {
                     pszCCode += 7;
                     scope |= HB_FS_STATIC;
                  }
                  while( HB_ISSPACE( *pszCCode ) )
                     ++pszCCode;
                  if( *pszCCode == '(' )
                  {
                     ++pszCCode;
                     while( HB_ISSPACE( *pszCCode ) )
                        ++pszCCode;
                     if( HB_ISFIRSTIDCHAR( *pszCCode ) )
                     {
                        const char * pszName = pszCCode++;

                        while( HB_ISNEXTIDCHAR( *pszCCode ) )
                           ++pszCCode;
                        len = ( int ) ( pszCCode - pszName );
                        while( HB_ISSPACE( *pszCCode ) )
                           ++pszCCode;
                        if( *pszCCode == ')' )
                        {
                           char * name = hb_strndup( pszName, len );
                           hb_compFunctionSetScope( HB_COMP_PARAM, name, scope );
                           hb_xfree( name );
                        }
                     }
                  }
               }
               while( HB_ISNEXTIDCHAR( *pszCCode ) )
                  ++pszCCode;
            }
            else if( ch == '/' && *pszCCode == '*' )
            {
               pszCCode++;
               while( *pszCCode )
               {
                  if( *pszCCode++ == '*' )
                  {
                     if( *pszCCode++ == '/' )
                        break;
                  }
               }
            }
            else if( ch == '/' && *pszCCode == '/' )
            {
               do
               {
                  ++pszCCode;
               }
               while( *pszCCode && *pszCCode != '\n' );
            }
            else if( ch == '"' || ch == '\'' )
            {
               while( *pszCCode )
               {
                  if( *pszCCode == '\\' )
                  {
                     pszCCode++;
                     if( *pszCCode )
                        pszCCode++;
                  }
                  else if( *pszCCode++ == ch )
                     break;
               }
            }
         }
      }
      pInline = pInline->pNext;
   }
}

static void hb_compGenCStdHeaders( HB_COMP_DECL, FILE * yyc, HB_BOOL fHbInLine )
{
   fprintf( yyc, "#include \"hbvmpub.h\"\n" );

   if( HB_COMP_PARAM->iGenCOutput != HB_COMPGENC_COMPACT )
      fprintf( yyc, "#include \"hbpcode.h\"\n" );

   fprintf( yyc, "#include \"hbinit.h\"\n" );

   if( HB_COMP_PARAM->iGenCOutput == HB_COMPGENC_REALCODE )
      fprintf( yyc, "#include \"hbxvm.h\"\n" );

   if( fHbInLine )
   {
      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 \"hbapicls.h\"\n" );
      fprintf( yyc, "#include \"hboo.ch\"\n" );
   }
}

static void hb_compFuncUsed( HB_COMP_DECL, PHB_HSYMBOL pSym )
{
   if( ( pSym->cScope & HB_FS_USED ) == 0 )
      hb_compGenWarning( HB_COMP_PARAM, hb_comp_szWarnings, 'W', HB_COMP_WARN_STATIC_FUNC_UNUSED, pSym->szName, NULL );
}

void hb_compGenCCode( HB_COMP_DECL, PHB_FNAME pFileName )       /* generates the C language output */
{
   char        szFileName[ HB_PATH_MAX ];
   PHB_HSYMBOL pSym;
   PHB_HFUNC   pFunc;
   PHB_HINLINE pInline;
   FILE *      yyc; /* file handle for C output */
   HB_BOOL     fHasHbInline = HB_FALSE;

   hb_fsFNameMerge( szFileName, pFileName );
   if( ! pFileName->szExtension )
      pFileName->szExtension = ".c";
   hb_fsFNameMerge( szFileName, pFileName );

   yyc = hb_fopen( szFileName, "w" );
   if( ! yyc )
   {
      hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'E', HB_COMP_ERR_CREATE_OUTPUT, szFileName, NULL );
      return;
   }

   if( ! HB_COMP_PARAM->fQuiet )
   {
      char buffer[ 80 + HB_PATH_MAX - 1 ];
      hb_snprintf( buffer, sizeof( buffer ),
                   "Generating C source output to \'%s\'... ", szFileName );
      hb_compOutStd( HB_COMP_PARAM, buffer );
   }

   {
      char * szCmp = hb_verCompiler();
      char * szHrb = hb_verHarbour();

      fprintf( yyc, "/*\n * %s\n", szHrb );
      fprintf( yyc, " * %s\n", szCmp );
      fprintf( yyc, " * Generated C source from \"%s\"\n */\n\n", HB_COMP_PARAM->szFile );

      hb_xfree( szCmp );
      hb_xfree( szHrb );
   }

   pFunc = HB_COMP_PARAM->functions.pFirst;
   while( pFunc &&
          ( ( pFunc->funFlags & HB_FUNF_FILE_DECL ) != 0 ||
            pFunc == HB_COMP_PARAM->pInitFunc ||
            pFunc == HB_COMP_PARAM->pLineFunc ) )
      pFunc = pFunc->pNext;

   if( pFunc )
   {
      int iFuncSuffix;

      hb_compDumpFindCFunc( HB_COMP_PARAM );

      pInline = HB_COMP_PARAM->inlines.pFirst;
      while( pInline )
      {
         if( pInline->szName )
         {
            fHasHbInline = HB_TRUE;
            break;
         }
         pInline = pInline->pNext;
      }

      hb_compGenCStdHeaders( HB_COMP_PARAM, yyc, fHasHbInline );

      fprintf( yyc, "\n\n" );

      /* write functions prototypes */
      pSym = HB_COMP_PARAM->symbols.pFirst;
      while( pSym )
      {
         if( pSym->iFunc )
         {
            if( pSym->szName[ 0 ] == '(' )
            {
               fprintf( yyc, "HB_FUNC_INIT%s();\n",
                        ! memcmp( pSym->szName + 1, "_INITLINES", 10 ) ?
                        "LINES" : "STATICS" );
            }
            else if( pSym->cScope & HB_FS_LOCAL ) /* is it a function defined in this module */
            {
               iFuncSuffix = pSym->pFunc ? pSym->pFunc->iFuncSuffix : 0;
               if( pSym->cScope & HB_FS_INIT )
                  hb_compGenCFunc( yyc, "HB_FUNC_INIT( %s );\n", pSym->szName, HB_TRUE, iFuncSuffix );
               else if( pSym->cScope & HB_FS_EXIT )
                  hb_compGenCFunc( yyc, "HB_FUNC_EXIT( %s );\n", pSym->szName, HB_TRUE, iFuncSuffix );
               else if( pSym->cScope & HB_FS_STATIC )
               {
                  hb_compGenCFunc( yyc, "HB_FUNC_STATIC( %s );\n", pSym->szName, HB_FALSE, iFuncSuffix );
                  hb_compFuncUsed( HB_COMP_PARAM, pSym );
               }
               else
                  hb_compGenCFunc( yyc, "HB_FUNC( %s );\n", pSym->szName, HB_FALSE, iFuncSuffix );
            }
            else if( ( pSym->cScope & HB_FS_DEFERRED ) == 0 ) /* it's not a function declared as dynamic */
               hb_compGenCFunc( yyc, "HB_FUNC_EXTERN( %s );\n", pSym->szName, HB_FALSE, 0 );
         }
         pSym = pSym->pNext;
      }

      /* writes the symbol table */
      /* Generate the wrapper that will initialize local symbol table
       */
      hb_strncpyUpper( szFileName, pFileName->szName, sizeof( szFileName ) - 1 );
      /* replace non ID characters in name of local symbol table by '_' */
      {
         int iLen = ( int ) strlen( szFileName ), i;

         for( i = 0; i < iLen; i++ )
         {
            char c = szFileName[ i ];
            if( ! HB_ISNEXTIDCHAR( c ) )
               szFileName[ i ] = '_';
         }
      }
      fprintf( yyc, "\n\nHB_INIT_SYMBOLS_BEGIN( hb_vm_SymbolInit_%s )\n", szFileName );

      pSym = HB_COMP_PARAM->symbols.pFirst;
      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 or debugging info about valid stop lines
             */
            fprintf( yyc, "{ \"%s\", {HB_FS_INITEXIT | HB_FS_LOCAL}, {hb_INIT%s}, NULL }",
                     pSym->szName, ! memcmp( pSym->szName + 1, "_INITLINES", 10 ) ?
                     "LINES" : "STATICS" ); /* NOTE: "hb_" intentionally in lower case */
         }
         else
         {
            fprintf( yyc, "{ \"%s\", {", pSym->szName );

            if( pSym->cScope & HB_FS_STATIC )
               fprintf( yyc, "HB_FS_STATIC" );
            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 & HB_VSCOMP_MEMVAR )
               fprintf( yyc, " | HB_FS_MEMVAR" );

            if( pSym->cScope & HB_FS_MESSAGE )
               fprintf( yyc, " | HB_FS_MESSAGE" );

            if( ( pSym->cScope & HB_FS_FIRST ) && ( ! HB_COMP_PARAM->fNoStartUp ) )
               fprintf( yyc, " | HB_FS_FIRST" );

            /* specify the function address if it is a defined function or an
               external called function */
            if( pSym->cScope & HB_FS_LOCAL ) /* is it a function defined in this module */
            {
               fprintf( yyc, " | HB_FS_LOCAL" );

               iFuncSuffix = pSym->pFunc ? pSym->pFunc->iFuncSuffix : 0;
               if( pSym->cScope & HB_FS_INIT )
                  hb_compGenCFunc( yyc, "}, {HB_INIT_FUNCNAME( %s )}, NULL }", pSym->szName, HB_TRUE, iFuncSuffix );
               else if( pSym->cScope & HB_FS_EXIT )
                  hb_compGenCFunc( yyc, "}, {HB_EXIT_FUNCNAME( %s )}, NULL }", pSym->szName, HB_TRUE, iFuncSuffix );
               else
                  hb_compGenCFunc( yyc, "}, {HB_FUNCNAME( %s )}, NULL }", pSym->szName, HB_FALSE, iFuncSuffix );
            }
            else if( pSym->cScope & HB_FS_DEFERRED ) /* is it a function declared as dynamic */
               fprintf( yyc, " | HB_FS_DEFERRED}, {NULL}, NULL }" );
            else if( pSym->iFunc )                   /* is it a function called from this module */
               hb_compGenCFunc( yyc, "}, {HB_FUNCNAME( %s )}, NULL }", pSym->szName, HB_FALSE, 0 );
            else
               fprintf( yyc, "}, {NULL}, NULL }" );   /* memvar | alias | message */
         }

         if( pSym != HB_COMP_PARAM->symbols.pLast )
            fprintf( yyc, ",\n" );

         pSym = pSym->pNext;
      }

      hb_writeEndInit( HB_COMP_PARAM, yyc, szFileName, HB_COMP_PARAM->szFile );

      /* Generate functions data
       */
      pFunc = HB_COMP_PARAM->functions.pFirst;
      while( pFunc )
      {
         if( ( pFunc->funFlags & HB_FUNF_FILE_DECL ) == 0 )
         {
            /* Is it _STATICS$ - static initialization function */
            if( pFunc == HB_COMP_PARAM->pInitFunc )
               fprintf( yyc, "HB_FUNC_INITSTATICS()\n" );
            /* Is it an (_INITLINES) function */
            else if( pFunc == HB_COMP_PARAM->pLineFunc )
               fprintf( yyc, "HB_FUNC_INITLINES()\n" );
            /* Is it an INIT FUNCTION/PROCEDURE */
            else if( pFunc->cScope & HB_FS_INIT )
               hb_compGenCFunc( yyc, "HB_FUNC_INIT( %s )\n", pFunc->szName, HB_TRUE, pFunc->iFuncSuffix );
            /* Is it an EXIT FUNCTION/PROCEDURE */
            else if( pFunc->cScope & HB_FS_EXIT )
               hb_compGenCFunc( yyc, "HB_FUNC_EXIT( %s )\n", pFunc->szName, HB_TRUE, pFunc->iFuncSuffix );
            /* Is it a STATIC FUNCTION/PROCEDURE */
            else if( pFunc->cScope & HB_FS_STATIC )
               hb_compGenCFunc( yyc, "HB_FUNC_STATIC( %s )\n", pFunc->szName, HB_FALSE, pFunc->iFuncSuffix );
            else /* Then it must be PUBLIC FUNCTION/PROCEDURE */
               hb_compGenCFunc( yyc, "HB_FUNC( %s )\n", pFunc->szName, HB_FALSE, pFunc->iFuncSuffix );

            if( HB_COMP_PARAM->iGenCOutput == HB_COMPGENC_REALCODE )
               hb_compGenCRealCode( HB_COMP_PARAM, pFunc, yyc );
            else
            {
               if( HB_COMP_PARAM->iGenCOutput == HB_COMPGENC_COMPACT )
                  hb_compGenCCompact( pFunc, yyc );
               else
                  hb_compGenCReadable( HB_COMP_PARAM, pFunc, yyc );
            }
            fprintf( yyc, "\n" );
         }
         pFunc = pFunc->pNext;
      }

      /* Generate C inline functions
       */
      pInline = HB_COMP_PARAM->inlines.pFirst;
      while( pInline )
      {
         if( pInline->pCode )
         {
            fprintf( yyc, "#line %i ", pInline->iLine );
            hb_compGenCString( yyc, ( const HB_BYTE * ) pInline->szFileName,
                               strlen( pInline->szFileName ) );
            fprintf( yyc, "\n" );

            if( pInline->szName )
               hb_compGenCFunc( yyc, "HB_FUNC_STATIC( %s )\n", pInline->szName, HB_FALSE, 0 );

            fprintf( yyc, "%s", pInline->pCode );
         }
         pInline = pInline->pNext;
      }
   }
   else
   {
      pInline = HB_COMP_PARAM->inlines.pFirst;
      while( pInline )
      {
         if( pInline->pCode )
         {
            if( ! fHasHbInline )
            {
               hb_compGenCStdHeaders( HB_COMP_PARAM, yyc, HB_FALSE );
               fHasHbInline = HB_TRUE;
            }
            fprintf( yyc, "#line %i ", pInline->iLine );
            hb_compGenCString( yyc, ( const HB_BYTE * ) pInline->szFileName,
                               strlen( pInline->szFileName ) );
            fprintf( yyc, "\n" );

            if( pInline->szName )
               hb_compGenCFunc( yyc, "HB_FUNC_STATIC( %s )\n", pInline->szName, HB_FALSE, 0 );

            fprintf( yyc, "%s", pInline->pCode );
         }
         pInline = pInline->pNext;
      }
      if( ! fHasHbInline )
         fprintf( yyc, "\n/* Empty source file */\n" );
   }

   fclose( yyc );

   if( ! HB_COMP_PARAM->fQuiet )
      hb_compOutStd( HB_COMP_PARAM, "Done.\n" );
}

static void hb_writeEndInit( HB_COMP_DECL, FILE * yyc, const char * szModulname, const char * szSourceFile )
{
   fprintf( yyc, "\nHB_INIT_SYMBOLS_EX_END( hb_vm_SymbolInit_%s, ", szModulname );
   if( HB_COMP_PARAM->fHideSource )
      szSourceFile = "";
   hb_compGenCString( yyc, ( const HB_BYTE * ) szSourceFile, strlen( szSourceFile ) );
   fprintf( yyc, ", 0x%lx, 0x%04x )\n\n", 0L, HB_PCODE_VER );

   fprintf( yyc,
            "#if defined( HB_PRAGMA_STARTUP )\n"
            "   #pragma startup hb_vm_SymbolInit_%s\n"
            "#elif defined( HB_DATASEG_STARTUP )\n"
            "   #define HB_DATASEG_BODY    HB_DATASEG_FUNC( hb_vm_SymbolInit_%s )\n"
            "   #include \"hbiniseg.h\"\n"
            "#endif\n\n",
            szModulname, szModulname );
}

static void hb_compGenCFunc( FILE * yyc, const char * cDecor, const char * szName,
                             HB_BOOL fStrip, int iFuncSuffix )
{
   int i = 0;

   while( cDecor[ i ] )
   {
      if( cDecor[ i ] == '%' && cDecor[ i + 1 ] == 's' )
      {
         const char * tmp = szName;
         char         c;

         while( ( c = *tmp++ ) != 0 )
         {
            if( HB_ISNEXTIDCHAR( c ) )
               fputc( ( HB_UCHAR ) c, yyc );
            else if( ! fStrip || c != '$' || *tmp != 0 )
            {
               /* 'x' is used to force unique name and eliminate possible
                * collisions with other function names.
                */
               fprintf( yyc, "x%02x", ( HB_UCHAR ) c );
            }
         }
         if( iFuncSuffix )
            fprintf( yyc, "v%d", iFuncSuffix );
         i += 2;
      }
      else
      {
         fputc( ( HB_UCHAR ) cDecor[ i ], yyc );
         i++;
      }
   }
}

static void hb_compGenCByteStr( FILE * yyc, const HB_BYTE * pText, HB_SIZE nLen )
{
   HB_SIZE nPos;

   for( nPos = 0; nPos < nLen; nPos++ )
   {
      HB_BYTE uchr = ( HB_BYTE ) pText[ nPos ];
      /*
       * NOTE: After optimization some Chr( n ) can be converted
       *    into a string containing non-printable characters.
       *
       * TODO: add switch to use hexadecimal format "%#04x"
       */
      fprintf( yyc, ( uchr < ( HB_BYTE ) ' ' || uchr >= 127 || uchr == '\\' ||
                      uchr == '\'' ) ? "%i, " : "\'%c\', ", uchr );
   }
}

static void hb_compGenCLocalName( PHB_HFUNC pFunc, int iLocal, HB_SIZE nPCodePos, PHB_GENC_INFO cargo )
{
   /* Variable with negative order are local variables
    * referenced in a codeblock -handle it with care
    */

   if( cargo->nEndBlockPos > nPCodePos )
   {
      /* we are accessing variables within a codeblock */
      /* the names of codeblock variable are lost     */
      if( iLocal < 0 )
         fprintf( cargo->yyc, "\t/* localvar%i */", -iLocal );
      else
         fprintf( cargo->yyc, "\t/* codeblockvar%i */", iLocal );
   }
   else
   {
      const char * szName = hb_compLocalVariableName( pFunc, ( HB_USHORT ) iLocal );

      if( szName )
         fprintf( cargo->yyc, "\t/* %s */", szName );
      else
         fprintf( cargo->yyc, "\t/* localvar%i */", iLocal );
   }
}

static void hb_compGenCStaticName( HB_USHORT uiStatic, PHB_GENC_INFO cargo )
{
   const char * szName = hb_compStaticVariableName( cargo->HB_COMP_PARAM, uiStatic );

   if( szName )
      fprintf( cargo->yyc, "\t/* %s */", szName );
   else
      fprintf( cargo->yyc, "\t/* staticvar%hu */", uiStatic );
}

static HB_GENC_FUNC( hb_p_and )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_AND,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_arraypush )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_ARRAYPUSH,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_arraypushref )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_ARRAYPUSHREF,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_arraypop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_ARRAYPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_dec )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DEC,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_arraydim )
{
   fprintf( cargo->yyc, "\tHB_P_ARRAYDIM, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_divide )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DIVIDE,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_do )
{
   fprintf( cargo->yyc, "\tHB_P_DO, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_doshort )
{
   fprintf( cargo->yyc, "\tHB_P_DOSHORT, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_duplicate )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DUPLICATE,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_duplunref )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DUPLUNREF,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pushunref )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PUSHUNREF,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_swap )
{
   fprintf( cargo->yyc, "\tHB_P_SWAP, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_equal )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_EQUAL,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_exactlyequal )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_EXACTLYEQUAL,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_endblock )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_ENDBLOCK,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_endproc )
{
   if( nPCodePos + 1 == pFunc->nPCodePos )
      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( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_FALSE,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_fortest )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_FORTEST,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_frame )
{
   fprintf( cargo->yyc, "\tHB_P_FRAME, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 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( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_FUNCPTR,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_function )
{
   fprintf( cargo->yyc, "\tHB_P_FUNCTION, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_functionshort )
{
   fprintf( cargo->yyc, "\tHB_P_FUNCTIONSHORT, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_arraygen )
{
   fprintf( cargo->yyc, "\tHB_P_ARRAYGEN, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_hashgen )
{
   fprintf( cargo->yyc, "\tHB_P_HASHGEN, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_greater )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_GREATER,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_greaterequal )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_GREATEREQUAL,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_inc )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_INC,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_instring )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_INSTRING,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_jumpnear )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPNEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] );

      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %05" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_jump )
{
   fprintf( cargo->yyc, "\tHB_P_JUMP, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );

      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %05" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_jumpfar )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPFAR, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %08" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_jumpfalsenear )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPFALSENEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %05" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_jumpfalse )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPFALSE, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %05" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_jumpfalsefar )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPFALSEFAR, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %08" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_jumptruenear )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPTRUENEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = ( signed char ) ( pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %05" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_jumptrue )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPTRUE, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %05" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_jumptruefar )
{
   fprintf( cargo->yyc, "\tHB_P_JUMPTRUEFAR, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %08" HB_PFS "i) */", nOffset, ( HB_ISIZ ) ( nPCodePos + nOffset ) );
   }
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_less )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_LESS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_lessequal )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_LESSEQUAL,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_line )
{
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "/* %05" HB_PFS "u */ ", nPCodePos );
   else
      fprintf( cargo->yyc, "\t" );
   fprintf( cargo->yyc, "HB_P_LINE, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_localname )
{
   HB_SIZE nStart = nPCodePos;

   fprintf( cargo->yyc, "\tHB_P_LOCALNAME, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + nPCodePos + 3 );
   fprintf( cargo->yyc, "\n" );
   nPCodePos += 3;
   while( pFunc->pCode[ nPCodePos ] )
   {
      char chr = pFunc->pCode[ nPCodePos++ ];
      if( chr == '\'' || chr == '\\' )
         fprintf( cargo->yyc, " \'\\%c\',", chr );
      else
         fprintf( cargo->yyc, " \'%c\',", chr );
   }
   fprintf( cargo->yyc, " 0,\n" );

   return nPCodePos - nStart + 1;
}

static HB_GENC_FUNC( hb_p_macropop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPOP, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_macropopaliased )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPOPALIASED, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_macropush )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPUSH, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_macropushref )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPUSHREF,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_macrodo )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACRODO, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_macrofunc )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROFUNC, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_macrosend )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROSEND, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_macroarraygen )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROARRAYGEN, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_macropushlist )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPUSHLIST, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_macropushindex )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPUSHINDEX,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_macropushpare )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPUSHPARE, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_macropushaliased )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROPUSHALIASED, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_macrosymbol )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROSYMBOL,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_macrotext )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MACROTEXT,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_message )
{
   fprintf( cargo->yyc, "\tHB_P_MESSAGE, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_minus )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MINUS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_modulename )
{
   HB_SIZE nStart = nPCodePos;

   fprintf( cargo->yyc, "\tHB_P_MODULENAME," );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + nPCodePos + 1 );
   fprintf( cargo->yyc, "\n" );
   nPCodePos++;
   while( pFunc->pCode[ nPCodePos ] )
   {
      char chr = pFunc->pCode[ nPCodePos++ ];
      if( chr == '\'' || chr == '\\' )
         fprintf( cargo->yyc, " \'\\%c\',", chr );
      else
         fprintf( cargo->yyc, " \'%c\',", chr );
   }
   fprintf( cargo->yyc, " 0,\n" );

   return nPCodePos - nStart + 1;
}

static HB_GENC_FUNC( hb_p_modulus )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MODULUS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_mult )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MULT,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_negate )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_NEGATE,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_not )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_NOT,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_notequal )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_NOTEQUAL,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_or )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_OR,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_parameter )
{
   fprintf( cargo->yyc, "\tHB_P_PARAMETER, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_plus )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PLUS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_POP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_popalias )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_POPALIAS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_popaliasedfield )
{
   fprintf( cargo->yyc, "\tHB_P_POPALIASEDFIELD, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_popaliasedfieldnear )
{
   fprintf( cargo->yyc, "\tHB_P_POPALIASEDFIELDNEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_popaliasedvar )
{
   fprintf( cargo->yyc, "\tHB_P_POPALIASEDVAR, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_popfield )
{
   fprintf( cargo->yyc, "\tHB_P_POPFIELD, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_poplocal )
{
   fprintf( cargo->yyc, "\tHB_P_POPLOCAL, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
   {
      int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_poplocalnear )
{
   fprintf( cargo->yyc, "\tHB_P_POPLOCALNEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
   {
      int iVar = ( signed char ) pFunc->pCode[ nPCodePos + 1 ];
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_popmemvar )
{
   fprintf( cargo->yyc, "\tHB_P_POPMEMVAR, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_popstatic )
{
   fprintf( cargo->yyc, "\tHB_P_POPSTATIC, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), cargo );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_popvariable )
{
   fprintf( cargo->yyc, "\tHB_P_POPVARIABLE, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_power )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_POWER,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pushalias )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PUSHALIAS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pushaliasedfield )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDFIELD, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushaliasedfieldnear )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDFIELDNEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_pushaliasedvar )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHALIASEDVAR, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushblockshort )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHBLOCKSHORT, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */",
               pFunc->pCode[ nPCodePos + 1 ] );
   fprintf( cargo->yyc, "\n" );

   if( cargo->nEndBlockPos < nPCodePos )
      cargo->nEndBlockPos = nPCodePos + pFunc->pCode[ nPCodePos + 1 ] - 1;

   return 2;
}

static HB_GENC_FUNC( hb_p_pushblock )
{
   HB_USHORT wVar, w;
   HB_SIZE   nStart = nPCodePos;

   fprintf( cargo->yyc, "\tHB_P_PUSHBLOCK, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */",
               HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );

   w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 3 ] );
   fprintf( cargo->yyc, "\t%u, %u,",
            pFunc->pCode[ nPCodePos + 3 ],
            pFunc->pCode[ nPCodePos + 4 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* number of local parameters (%u) */", w );
   fprintf( cargo->yyc, "\n" );

   wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 5 ] );
   fprintf( cargo->yyc, "\t%u, %u,",
            pFunc->pCode[ nPCodePos + 5 ],
            pFunc->pCode[ nPCodePos + 6 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* number of local variables (%u) */", wVar );
   fprintf( cargo->yyc, "\n" );

   nPCodePos += 7;  /* codeblock size + number of parameters + number of local variables */
   /* create the table of referenced local variables */
   while( wVar-- )
   {
      fprintf( cargo->yyc, "\t%u, %u,",
               pFunc->pCode[ nPCodePos ],
               pFunc->pCode[ nPCodePos + 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( cargo->bVerbose && ( pFunc->cScope & HB_FS_INITEXIT ) != HB_FS_INITEXIT )
      {
         w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos ] );
         hb_compGenCLocalName( pFunc, w, nPCodePos, cargo );
      }
      fprintf( cargo->yyc, "\n" );
      nPCodePos += 2;
   }

   if( cargo->nEndBlockPos < nStart )
      cargo->nEndBlockPos = nStart + HB_PCODE_MKUSHORT( &pFunc->pCode[ nStart + 1 ] ) - 1;

   return nPCodePos - nStart;
}

static HB_GENC_FUNC( hb_p_pushblocklarge )
{
   HB_USHORT wVar, w;
   HB_SIZE   nStart = nPCodePos;

   fprintf( cargo->yyc, "\tHB_P_PUSHBLOCKLARGE, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %lu */",
               HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );

   w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 4 ] );
   fprintf( cargo->yyc, "\t%u, %u,",
            pFunc->pCode[ nPCodePos + 4 ],
            pFunc->pCode[ nPCodePos + 5 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* number of local parameters (%u) */", w );
   fprintf( cargo->yyc, "\n" );

   wVar = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 6 ] );
   fprintf( cargo->yyc, "\t%u, %u,",
            pFunc->pCode[ nPCodePos + 6 ],
            pFunc->pCode[ nPCodePos + 7 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* number of local variables (%u) */", wVar );
   fprintf( cargo->yyc, "\n" );

   nPCodePos += 8;  /* codeblock size + number of parameters + number of local variables */
   /* create the table of referenced local variables */
   while( wVar-- )
   {
      fprintf( cargo->yyc, "\t%u, %u,",
               pFunc->pCode[ nPCodePos ],
               pFunc->pCode[ nPCodePos + 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( cargo->bVerbose && ( pFunc->cScope & HB_FS_INITEXIT ) != HB_FS_INITEXIT )
      {
         w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos ] );
         hb_compGenCLocalName( pFunc, w, nPCodePos, cargo );
      }
      fprintf( cargo->yyc, "\n" );
      nPCodePos += 2;
   }

   if( cargo->nEndBlockPos < nStart )
      cargo->nEndBlockPos = nStart + HB_PCODE_MKUINT24( &pFunc->pCode[ nStart + 1 ] ) - 1;

   return nPCodePos - nStart;
}

static HB_GENC_FUNC( hb_p_pushdouble )
{
   int i;

   fprintf( cargo->yyc, "\tHB_P_PUSHDOUBLE," );
   ++nPCodePos;
   for( i = 0; i < ( int ) ( sizeof( double ) + sizeof( HB_BYTE ) + sizeof( HB_BYTE ) ); ++i )
   {
      fprintf( cargo->yyc, " %u,", ( HB_UCHAR ) pFunc->pCode[ nPCodePos + i ] );
   }
   if( cargo->bVerbose )
   {
      fprintf( cargo->yyc, "\t/* %.*f, %u, %u */",
               ( HB_UCHAR ) pFunc->pCode[ nPCodePos + sizeof( double ) + sizeof( HB_BYTE ) ],
               HB_PCODE_MKDOUBLE( &pFunc->pCode[ nPCodePos ] ),
               ( HB_UCHAR ) pFunc->pCode[ nPCodePos + sizeof( double ) ],
               ( HB_UCHAR ) pFunc->pCode[ nPCodePos + sizeof( double ) + sizeof( HB_BYTE ) ] );
   }
   fprintf( cargo->yyc, "\n" );

   return sizeof( double ) + sizeof( HB_BYTE ) + sizeof( HB_BYTE ) + 1;
}

static HB_GENC_FUNC( hb_p_pushfield )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHFIELD, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushbyte )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHBYTE, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %i */", ( signed char ) pFunc->pCode[ nPCodePos + 1 ] );
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_pushint )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHINT, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushlocal )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHLOCAL, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
   {
      int iVar = ( int ) HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushlocalnear )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHLOCALNEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
   {
      int iVar = ( signed char ) pFunc->pCode[ nPCodePos + 1 ];
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_pushlocalref )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHLOCALREF, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
   {
      int iVar = ( int ) HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushlong )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHLONG, %u, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ],
            pFunc->pCode[ nPCodePos + 4 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %li */", HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );

   return 5;
}

static HB_GENC_FUNC( hb_p_pushlonglong )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHLONGLONG, %u, %u, %u, %u, %u, %u, %u, %u, ",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ],
            pFunc->pCode[ nPCodePos + 4 ],
            pFunc->pCode[ nPCodePos + 5 ],
            pFunc->pCode[ nPCodePos + 6 ],
            pFunc->pCode[ nPCodePos + 7 ],
            pFunc->pCode[ nPCodePos + 8 ] );
   if( cargo->bVerbose )
   {
#ifdef HB_LONG_LONG_OFF
      fprintf( cargo->yyc, "\t/* %lf */", HB_PCODE_MKLONGLONG( &pFunc->pCode[ nPCodePos + 1 ] ) );
#else
      char szBuf[ 24 ];
      fprintf( cargo->yyc, "\t/* %s */", hb_numToStr( szBuf, sizeof( szBuf ),
                                                      HB_PCODE_MKLONGLONG( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
#endif
   }
   fprintf( cargo->yyc, "\n" );

   return 9;
}

static HB_GENC_FUNC( hb_p_pushmemvar )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHMEMVAR, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushmemvarref )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHMEMVARREF, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushnil )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PUSHNIL,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pushself )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PUSHSELF,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pushstatic )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHSTATIC, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), cargo );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushstaticref )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHSTATICREF, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), cargo );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushstrshort )
{
   HB_USHORT wLen = pFunc->pCode[ nPCodePos + 1 ];

   fprintf( cargo->yyc, "\tHB_P_PUSHSTRSHORT, %u,", pFunc->pCode[ nPCodePos + 1 ] );

   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */", wLen );

   if( wLen > 0 )
   {
      fprintf( cargo->yyc, "\n\t" );
      hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 2 ], wLen );
   }
   fprintf( cargo->yyc, "\n" );
   return wLen + 2;
}

static HB_GENC_FUNC( hb_p_pushstr )
{
   HB_USHORT wLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] );

   fprintf( cargo->yyc, "\tHB_P_PUSHSTR, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );

   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */", wLen );

   if( wLen > 0 )
   {
      fprintf( cargo->yyc, "\n\t" );
      hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 3 ], wLen );
   }
   fprintf( cargo->yyc, "\n" );
   return wLen + 3;
}

static HB_GENC_FUNC( hb_p_pushstrlarge )
{
   HB_SIZE nLen = HB_PCODE_MKUINT24( &pFunc->pCode[ nPCodePos + 1 ] );

   fprintf( cargo->yyc, "\tHB_P_PUSHSTRLARGE, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );

   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %" HB_PFS "u */", nLen );

   if( nLen > 0 )
   {
      fprintf( cargo->yyc, "\n\t" );
      hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 4 ], nLen );
   }
   fprintf( cargo->yyc, "\n" );
   return nLen + 4;
}

static HB_GENC_FUNC( hb_p_pushstrhidden )
{
   HB_USHORT wLen = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 2 ] );

   fprintf( cargo->yyc, "\tHB_P_PUSHSTRHIDDEN, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );

   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %u */", wLen );

   if( wLen > 0 )
   {
      fprintf( cargo->yyc, "\n\t" );
      hb_compGenCByteStr( cargo->yyc, &pFunc->pCode[ nPCodePos + 4 ], wLen );
   }
   fprintf( cargo->yyc, "\n" );
   return wLen + 4;
}

static HB_GENC_FUNC( hb_p_pushsym )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHSYM, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushsymnear )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHSYMNEAR, %u,",
            pFunc->pCode[ nPCodePos + 1 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, pFunc->pCode[ nPCodePos + 1 ] ) );
   fprintf( cargo->yyc, "\n" );
   return 2;
}

static HB_GENC_FUNC( hb_p_pushfuncsym )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHFUNCSYM, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushvariable )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHVARIABLE, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_retvalue )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_RETVALUE,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_send )
{
   fprintf( cargo->yyc, "\tHB_P_SEND, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_sendshort )
{
   fprintf( cargo->yyc, "\tHB_P_SENDSHORT, %u,\n", pFunc->pCode[ nPCodePos + 1 ] );
   return 2;
}

static HB_GENC_FUNC( hb_p_pushovarref )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PUSHOVARREF,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_seqblock )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_SEQBLOCK,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_seqbegin )
{
   fprintf( cargo->yyc, "\tHB_P_SEQBEGIN, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %08" HB_PFS "u) */", nOffset, nPCodePos + nOffset );
   }
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_seqend )
{
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "/* %05" HB_PFS "u */ ", nPCodePos );
   else
      fprintf( cargo->yyc, "\t" );
   fprintf( cargo->yyc, "HB_P_SEQEND, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %08" HB_PFS "u) */", nOffset, nPCodePos + nOffset );
   }
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_seqrecover )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_SEQRECOVER,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_seqalways )
{
   fprintf( cargo->yyc, "\tHB_P_SEQALWAYS, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %08" HB_PFS "u) */", nOffset, nPCodePos + nOffset );
   }
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_alwaysbegin )
{
   HB_SYMBOL_UNUSED( pFunc );

   if( cargo->bVerbose )
      fprintf( cargo->yyc, "/* %05" HB_PFS "u */ ", nPCodePos );
   else
      fprintf( cargo->yyc, "\t" );

   fprintf( cargo->yyc, "HB_P_ALWAYSBEGIN, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
   {
      HB_ISIZ nOffset = HB_PCODE_MKINT24( &pFunc->pCode[ nPCodePos + 1 ] );
      fprintf( cargo->yyc, "\t/* %" HB_PFS "i (abs: %08" HB_PFS "u) */", nOffset, nPCodePos + nOffset );
   }
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_alwaysend )
{
   HB_SYMBOL_UNUSED( pFunc );

   if( cargo->bVerbose )
      fprintf( cargo->yyc, "/* %05" HB_PFS "u */ ", nPCodePos );
   else
      fprintf( cargo->yyc, "\t" );

   fprintf( cargo->yyc, "HB_P_ALWAYSEND,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_sframe )
{
   fprintf( cargo->yyc, "\tHB_P_SFRAME, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* symbol (_INITSTATICS) */" );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_statics )
{
   fprintf( cargo->yyc, "\tHB_P_STATICS, %u, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ],
            pFunc->pCode[ nPCodePos + 4 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* symbol (_INITSTATICS), %u statics */", HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) );
   fprintf( cargo->yyc, "\n" );

   return 5;
}

static HB_GENC_FUNC( hb_p_staticname )
{
   HB_SIZE nStart = nPCodePos;

   fprintf( cargo->yyc, "\tHB_P_STATICNAME, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", ( char * ) pFunc->pCode + nPCodePos + 4 );
   fprintf( cargo->yyc, "\n" );

   nPCodePos += 4;
   while( pFunc->pCode[ nPCodePos ] )
   {
      char chr = pFunc->pCode[ nPCodePos++ ];
      if( chr == '\'' || chr == '\\' )
         fprintf( cargo->yyc, " \'\\%c\',", chr );
      else
         fprintf( cargo->yyc, " \'%c\',", chr );
   }
   fprintf( cargo->yyc, " 0,\n" );

   return nPCodePos - nStart + 1;
}

static HB_GENC_FUNC( hb_p_threadstatics )
{
   HB_USHORT w = HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ), u;

   fprintf( cargo->yyc, "\tHB_P_THREADSTATICS, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* number of thread static variables: %u */", w );
   fprintf( cargo->yyc, "\n" );

   nPCodePos += 3;
   for( u = 0; u < w; ++u )
   {
      fprintf( cargo->yyc, "\t%u, %u,",
               pFunc->pCode[ nPCodePos ],
               pFunc->pCode[ nPCodePos + 1 ] );
      if( cargo->bVerbose )
         hb_compGenCStaticName( HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos ] ), cargo );
      fprintf( cargo->yyc, "\n" );
      nPCodePos += 2;
   }

   return ( ( HB_SIZE ) w << 1 ) + 3;
}

static HB_GENC_FUNC( hb_p_swapalias )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_SWAPALIAS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_true )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_TRUE,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_one )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_ONE,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_zero )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_ZERO,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_noop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   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( nPCodePos );
   return 1;
}

static HB_GENC_FUNC( hb_p_enumstart )
{
   fprintf( cargo->yyc, "\tHB_P_ENUMSTART, %u, %u,\n",
            pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] );
   return 3;
}

static HB_GENC_FUNC( hb_p_enumnext )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );
   fprintf( cargo->yyc, "\tHB_P_ENUMNEXT,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_enumprev )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );
   fprintf( cargo->yyc, "\tHB_P_ENUMPREV,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_enumend )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );
   fprintf( cargo->yyc, "\tHB_P_ENUMEND,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_switch )
{
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "/* %05" HB_PFS "u */ ", nPCodePos );
   else
      fprintf( cargo->yyc, "\t" );

   fprintf( cargo->yyc, "HB_P_SWITCH, %u, %u,", pFunc->pCode[ nPCodePos + 1 ], pFunc->pCode[ nPCodePos + 2 ] );

   if( cargo->bVerbose )
   {
      fprintf( cargo->yyc, "\t/* %i*/", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) );
   }

   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_pushdate )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHDATE, %u, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ],
            pFunc->pCode[ nPCodePos + 4 ] );
   if( cargo->bVerbose )
   {
      int  year, month, day;
      char date[ 9 ];

      hb_dateDecode( HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ), &year, &month, &day );
      hb_dateStrPut( date, year, month, day );
      date[ 8 ] = '\0';
      fprintf( cargo->yyc, "\t/* %s */", date );
   }
   fprintf( cargo->yyc, "\n" );

   return 5;
}

static HB_GENC_FUNC( hb_p_pushtimestamp )
{
   fprintf( cargo->yyc, "\tHB_P_PUSHTIMESTAMP, %u, %u, %u, %u, %u, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ],
            pFunc->pCode[ nPCodePos + 4 ],
            pFunc->pCode[ nPCodePos + 5 ],
            pFunc->pCode[ nPCodePos + 6 ],
            pFunc->pCode[ nPCodePos + 7 ],
            pFunc->pCode[ nPCodePos + 8 ] );
   if( cargo->bVerbose )
   {
      char timestamp[ 24 ];

      hb_timeStampStr( timestamp,
                       HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 1 ] ),
                       HB_PCODE_MKLONG( &pFunc->pCode[ nPCodePos + 5 ] ) );
      fprintf( cargo->yyc, "\t/* %s */", timestamp );
   }
   fprintf( cargo->yyc, "\n" );

   return 9;
}

static HB_GENC_FUNC( hb_p_localnearaddint )
{
   fprintf( cargo->yyc, "\tHB_P_LOCALNEARADDINT, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );

   if( cargo->bVerbose )
   {
      int iVar = ( signed char ) pFunc->pCode[ nPCodePos + 1 ];
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
      fprintf( cargo->yyc, "/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 2 ] ) );
   }
   fprintf( cargo->yyc, "\n" );

   return 4;
}

static HB_GENC_FUNC( hb_p_localaddint )
{
   fprintf( cargo->yyc, "\tHB_P_LOCALADDINT, %u, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ],
            pFunc->pCode[ nPCodePos + 4 ] );

   if( cargo->bVerbose )
   {
      int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
      fprintf( cargo->yyc, "/* %i */", HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 3 ] ) );
   }
   fprintf( cargo->yyc, "\n" );

   return 5;
}

static HB_GENC_FUNC( hb_p_localinc )
{
   fprintf( cargo->yyc, "\tHB_P_LOCALINC, %u, %u,", pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );

   if( cargo->bVerbose )
   {
      int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );

   return 3;
}

static HB_GENC_FUNC( hb_p_localdec )
{
   fprintf( cargo->yyc, "\tHB_P_LOCALDEC, %u, %u,", pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );

   if( cargo->bVerbose )
   {
      int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );

   return 3;
}

static HB_GENC_FUNC( hb_p_localincpush )
{
   fprintf( cargo->yyc, "\tHB_P_LOCALINCPUSH, %u, %u,", pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );

   if( cargo->bVerbose )
   {
      int iVar = HB_PCODE_MKSHORT( &pFunc->pCode[ nPCodePos + 1 ] );
      hb_compGenCLocalName( pFunc, iVar, nPCodePos, cargo );
   }
   fprintf( cargo->yyc, "\n" );

   return 3;
}

static HB_GENC_FUNC( hb_p_pluseqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PLUSEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_minuseqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MINUSEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_multeqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MULTEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_diveqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DIVEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_modeqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MODEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_expeqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_EXPEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_inceqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_INCEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_deceqpop )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DECEQPOP,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pluseq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PLUSEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_minuseq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MINUSEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_multeq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MULTEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_diveq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DIVEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_modeq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_MODEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_expeq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_EXPEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_inceq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_INCEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_deceq )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_DECEQ,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_withobjectstart )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_WITHOBJECTSTART,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_withobjectmessage )
{
   fprintf( cargo->yyc, "\tHB_P_WITHOBJECTMESSAGE, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* %s */", hb_compSymbolName( cargo->HB_COMP_PARAM, HB_PCODE_MKUSHORT( &pFunc->pCode[ nPCodePos + 1 ] ) ) );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_withobjectend )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_WITHOBJECTEND,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_vframe )
{
   fprintf( cargo->yyc, "\tHB_P_VFRAME, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* locals, params */" );
   fprintf( cargo->yyc, "\n" );
   return 3;
}

static HB_GENC_FUNC( hb_p_largeframe )
{
   fprintf( cargo->yyc, "\tHB_P_LARGEFRAME, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* locals, params */" );
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_largevframe )
{
   fprintf( cargo->yyc, "\tHB_P_LARGEVFRAME, %u, %u, %u,",
            pFunc->pCode[ nPCodePos + 1 ],
            pFunc->pCode[ nPCodePos + 2 ],
            pFunc->pCode[ nPCodePos + 3 ] );
   if( cargo->bVerbose )
      fprintf( cargo->yyc, "\t/* locals, params */" );
   fprintf( cargo->yyc, "\n" );
   return 4;
}

static HB_GENC_FUNC( hb_p_pushvparams )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PUSHVPARAMS,\n" );
   return 1;
}

static HB_GENC_FUNC( hb_p_pushaparams )
{
   HB_SYMBOL_UNUSED( pFunc );
   HB_SYMBOL_UNUSED( nPCodePos );

   fprintf( cargo->yyc, "\tHB_P_PUSHAPARAMS,\n" );
   return 1;
}

/* NOTE: The order of functions have to match the order of opcodes
 *       mnemonics
 */
static const PHB_GENC_FUNC 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_pushtimestamp,
   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_macroarraygen,
   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_macrofunc,
   hb_p_macrodo,
   /* start: more pcodes generated by macro compiler */
   hb_p_dummy,
   /* end: */
   hb_p_localnearaddint,
   hb_p_macropushref,
   hb_p_pushlonglong,
   hb_p_enumstart,
   hb_p_enumnext,
   hb_p_enumprev,
   hb_p_enumend,
   hb_p_switch,
   hb_p_pushdate,
   /* optimization of inlined math operations (+=, -= */
   hb_p_pluseqpop,
   hb_p_minuseqpop,
   hb_p_multeqpop,
   hb_p_diveqpop,
   hb_p_pluseq,
   hb_p_minuseq,
   hb_p_multeq,
   hb_p_diveq,
   hb_p_withobjectstart,
   hb_p_withobjectmessage,
   hb_p_withobjectend,
   hb_p_macrosend,
   hb_p_pushovarref,
   hb_p_arraypushref,
   hb_p_vframe,
   hb_p_largeframe,
   hb_p_largevframe,
   hb_p_pushstrhidden,
   hb_p_localaddint,
   hb_p_modeqpop,
   hb_p_expeqpop,
   hb_p_modeq,
   hb_p_expeq,
   hb_p_duplunref,
   hb_p_dummy,
   hb_p_dummy,
   hb_p_pushblocklarge,
   hb_p_pushstrlarge,
   hb_p_swap,
   hb_p_pushvparams,
   hb_p_pushunref,
   hb_p_seqalways,
   hb_p_alwaysbegin,
   hb_p_alwaysend,
   hb_p_deceqpop,
   hb_p_inceqpop,
   hb_p_deceq,
   hb_p_inceq,
   hb_p_localdec,
   hb_p_localinc,
   hb_p_localincpush,
   hb_p_pushfuncsym,
   hb_p_hashgen,
   hb_p_seqblock,
   hb_p_threadstatics,
   hb_p_pushaparams
};

static void hb_compGenCReadable( HB_COMP_DECL, PHB_HFUNC pFunc, FILE * yyc )
{
   const PHB_GENC_FUNC * pFuncTable = s_verbose_table;
   HB_GENC_INFO genc_info;

   /* Make sure that table is correct */
   assert( HB_P_LAST_PCODE == sizeof( s_verbose_table ) / sizeof( PHB_GENC_FUNC ) );

   genc_info.HB_COMP_PARAM = HB_COMP_PARAM;
   genc_info.nEndBlockPos  = 0;
   genc_info.bVerbose      = ( HB_COMP_PARAM->iGenCOutput == HB_COMPGENC_VERBOSE );
   genc_info.yyc = yyc;

   fprintf( yyc, "{\n   static const HB_BYTE pcode[] =\n   {\n" );
   hb_compPCodeEval( pFunc, ( const PHB_PCODE_FUNC * ) pFuncTable, ( void * ) &genc_info );

   if( genc_info.bVerbose )
      fprintf( yyc, "/* %05" HB_PFS "u */\n", pFunc->nPCodePos );
   fprintf( yyc, "   };\n\n" );
   fprintf( yyc, "   hb_vmExecute( pcode, symbols );\n}\n" );
}

static void hb_compGenCCompact( PHB_HFUNC pFunc, FILE * yyc )
{
   HB_SIZE nPCodePos = 0;
   int     nChar;

   fprintf( yyc, "{\n\tstatic const HB_BYTE pcode[] =\n\t{\n\t\t" );

   nChar = 0;
   while( nPCodePos < pFunc->nPCodePos )
   {
      ++nChar;

      if( nChar > 1 )
         fprintf( yyc, "," );

      if( nChar == 15 )
      {
         fprintf( yyc, "\n\t\t" );
         nChar = 1;
      }

      /* Displaying as decimal is more compact than hex */
      fprintf( yyc, "%d", ( int ) pFunc->pCode[ nPCodePos++ ] );
   }

   if( nChar != 0 )
      fprintf( yyc, "\n" );

   fprintf( yyc, "\t};\n\n" );
   fprintf( yyc, "\thb_vmExecute( pcode, symbols );\n}\n" );
}
