Beispiel #1
0
HB_BOOL hb_cdpCharCaseEq( PHB_CODEPAGE cdp, const char * szText1, HB_SIZE nLen1, HB_SIZE * pnPos1,
                          const char * szText2, HB_SIZE nLen2, HB_SIZE * pnPos2 )
{
   HB_SYMBOL_UNUSED( cdp );

   if( *pnPos1 < nLen1 && *pnPos2 < nLen2 )
   {
      HB_UCHAR uc1 = szText1[ ( *pnPos1 )++ ],
               uc2 = szText2[ ( *pnPos2 )++ ];
      return HB_TOUPPER( uc1 ) == HB_TOUPPER( uc2 );
   }
   else
      return HB_FALSE;
}
Beispiel #2
0
static void hb_cp_init( PHB_CODEPAGE cdp )
{
   HB_UCHAR * flags, * upper, * lower;
   int i;

   cdp->buffer = ( HB_UCHAR * ) hb_xgrab( 0x300 );
   cdp->flags = flags = ( HB_UCHAR * ) cdp->buffer;
   cdp->upper = upper = ( HB_UCHAR * ) cdp->buffer + 0x100;
   cdp->lower = lower = ( HB_UCHAR * ) cdp->buffer + 0x200;

   for( i = 0; i < 0x100; ++i )
   {
      flags[ i ] = 0;
      if( HB_ISDIGIT( i ) )
         flags[ i ] |= HB_CDP_DIGIT;
      if( HB_ISALPHA( i ) )
         flags[ i ] |= HB_CDP_ALPHA;
      if( HB_ISUPPER( i ) )
         flags[ i ] |= HB_CDP_UPPER;
      if( HB_ISLOWER( i ) )
         flags[ i ] |= HB_CDP_LOWER;
      upper[ i ] = ( HB_UCHAR ) HB_TOUPPER( i );
      lower[ i ] = ( HB_UCHAR ) HB_TOLOWER( i );
   }
}
Beispiel #3
0
HB_FATTR hb_fsAttrEncode( const char * szAttr )
{
   const char * pos = szAttr;
   char ch;
   HB_FATTR nAttr = 0;

   HB_TRACE( HB_TR_DEBUG, ( "hb_fsAttrEncode(%p)", szAttr ) );

   while( ( ch = ( char ) HB_TOUPPER( *pos ) ) != '\0' )
   {
      switch( ch )
      {
         case 'R': nAttr |= HB_FA_READONLY;  break;
         case 'H': nAttr |= HB_FA_HIDDEN;    break;
         case 'S': nAttr |= HB_FA_SYSTEM;    break;
         case 'A': nAttr |= HB_FA_ARCHIVE;   break;
         case 'D': nAttr |= HB_FA_DIRECTORY; break;
         case 'V': nAttr |= HB_FA_LABEL;     break;
         case 'L': nAttr |= HB_FA_LINK;      break;
      }

      pos++;
   }

   return nAttr;
}
Beispiel #4
0
/* converts iChar to upper case */
int hb_charUpper( int iChar )
{
#ifndef HB_CDP_SUPPORT_OFF
   PHB_CODEPAGE cdp = hb_cdppage();
   if( cdp && cdp->nChars )
      return ( unsigned char ) cdp->s_upper[ (unsigned char) iChar ];
   else
#endif
      return HB_TOUPPER( iChar );
}
Beispiel #5
0
static HB_BOOL s_fileAccept( PHB_FILE_FUNCS pFuncs, const char * pszFileName )
{
   HB_SYMBOL_UNUSED( pFuncs );

   if( HB_TOUPPER( pszFileName[ 0 ] ) == 'C' &&
       HB_TOUPPER( pszFileName[ 1 ] ) == 'O' &&
       HB_TOUPPER( pszFileName[ 2 ] ) == 'M' )
   {
      if( pszFileName[ 3 ] == '$' )
         return strchr( pszFileName + 4, ':' ) != NULL;
      else if( pszFileName[ 3 ] >= '1' && pszFileName[ 3 ] <= '9' )
      {
         pszFileName += 4;
         while( HB_ISDIGIT( *pszFileName ) )
            ++pszFileName;
         return *pszFileName == ':';
      }
   }
   return HB_FALSE;
}
Beispiel #6
0
/*
 * Harbour Project source code:
 * String matching functions
 *
 * Copyright 1999-2001 Viktor Szakats <*****@*****.**>
 * 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, 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 software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
 *
 * As a special exception, the Harbour Project gives permission for
 * additional uses of the text contained in its release of Harbour.
 *
 * The exception is that, if you link the Harbour libraries with other
 * files to produce an executable, this does not by itself cause the
 * resulting executable to be covered by the GNU General Public License.
 * Your use of that executable is in no way restricted on account of
 * linking the Harbour library code into it.
 *
 * This exception does not however invalidate any other reasons why
 * the executable file might be covered by the GNU General Public License.
 *
 * This exception applies only to the code released by the Harbour
 * Project under the name Harbour.  If you copy code from other
 * Harbour Project or Free Software Foundation releases into a copy of
 * Harbour, as the General Public License permits, the exception does
 * not apply to the code that you add in this way.  To avoid misleading
 * anyone as to the status of such modified files, you must delete
 * this exception notice from them.
 *
 * If you write modifications of your own for Harbour, it is your choice
 * whether to permit this exception to apply to your modifications.
 * If you do not wish that, delete this exception notice.
 *
 */

#include <ctype.h>

#include "hbapi.h"
#include "hbregex.h"

#if defined( HB_OS_UNIX ) && !defined( __WATCOMC__ )
#  include <fnmatch.h>
#endif

#if 0  /* disabled to eliminate warnings */
static BOOL hb_strMatchDOS( const char * pszString, const char * pszMask )
{
   HB_TRACE(HB_TR_DEBUG, ("hb_strMatchDOS(%s, %s)", pszString, pszMask));

   while( *pszMask != '\0' && *pszString != '\0' )
   {
      if( *pszMask == '*' )
      {
         while( *pszMask == '*' )
         {
            pszMask++;
         }

         if( *pszMask == '\0' )
         {
            return TRUE;
         }
         else if( *pszMask == '?' )
         {
            pszString++;
         }
         else
         {
            while( HB_TOUPPER( *pszString ) != HB_TOUPPER( *pszMask ) )
            {
               if( *( ++pszString ) == '\0' )
               {
                  return FALSE;
               }
            }

            while( HB_TOUPPER( *pszString ) == HB_TOUPPER( *pszMask ) )
            {
               if( *( ++pszString ) == '\0' )
               {
                  break;
               }
            }

            pszMask++;
         }
      }
      else if( HB_TOUPPER( *pszMask ) != HB_TOUPPER( *pszString ) && *pszMask != '?' )
      {
         return FALSE;
      }
      else
      {
         pszMask++;
         pszString++;
      }
   }

   return ! ( ( *pszMask != '\0' && *pszString == '\0' && *pszMask != '*') || ( *pszMask == '\0' && *pszString != '\0' ) );
}
Beispiel #7
0
/* converts szText to upper case. Does not create a new string! */
char * hb_strUpper( char * szText, ULONG ulLen )
{
   HB_TRACE(HB_TR_DEBUG, ("hb_strUpper(%s, %lu)", szText, ulLen));

   {
      ULONG i;
#ifndef HB_CDP_SUPPORT_OFF
      PHB_CODEPAGE cdp = hb_cdppage();
      if( cdp && cdp->nChars )
         for( i = 0; i < ulLen; i++ )
            szText[ i ] = ( char ) cdp->s_upper[ ( UCHAR ) szText[ i ] ];
      else
#endif
         for( i = 0; i < ulLen; i++ )
            szText[ i ] = HB_TOUPPER( ( BYTE ) szText[ i ] );
   }

   return szText;
}
Beispiel #8
0
/*
 * Find a field index by name
 */
HB_USHORT hb_rddFieldIndex( AREAP pArea, const char * szName )
{
   HB_TRACE( HB_TR_DEBUG, ( "hb_rddFieldIndex(%p, %s)", pArea, szName ) );

   while( HB_ISSPACE( *szName ) )
      ++szName;

   if( *szName )
   {
      HB_SIZE nLen = strlen( szName );

      while( HB_ISSPACE( szName[ nLen - 1 ] ) )
         --nLen;

      if( nLen <= HB_SYMBOL_NAME_LEN )
      {
         char szFieldName[ HB_SYMBOL_NAME_LEN + 1 ];
         PHB_DYNS pDynSym;

         szFieldName[ nLen ] = '\0';
         while( nLen-- )
            szFieldName[ nLen ] = HB_TOUPPER( szName[ nLen ] );

         pDynSym = hb_dynsymFind( szFieldName );
         if( pDynSym )
         {
            LPFIELD pField = pArea->lpFields;
            HB_USHORT uiCount = 0;

            while( pField )
            {
               ++uiCount;
               if( pDynSym == ( PHB_DYNS ) pField->sym )
                  return uiCount;
               pField = pField->lpfNext;
            }
         }
      }
   }
   return 0;
}
Beispiel #9
0
static int s_filePortParams( const char * pszName, int * piTimeout,
                             int * piBaud, int * piParity,
                             int * piSize, int * piStop,
                             int * piFlow )
{
   int iPort = 0, iLen, iValue;

   *piTimeout = -1;
   *piBaud = *piParity = *piSize = *piStop = *piFlow = 0;

   pszName += 3;
   if( *pszName == '$' )
   {
      const char * pszParams = strchr( pszName, ':' );

      if( pszParams != NULL && pszParams - pszName > 1 )
      {
         char * pszPort = hb_strndup( pszName + 1, pszParams - pszName - 1 );

         iPort = hb_comFindPort( pszPort, HB_TRUE );
         hb_xfree( pszPort );
         pszName = pszParams;
      }
   }
   else
   {
      while( HB_ISDIGIT( *pszName ) )
         iPort = iPort * 10 + ( *pszName++ - '0' );
   }

   while( iPort > 0 && *pszName )
   {
      if( HB_ISDIGIT( *pszName ) )
      {
         iValue = s_fileGetValue( pszName, &iLen );
         if( iLen == 1 )
         {
            if( iValue >= 1 && iValue <= 2 && *piStop == 0 )
               *piStop = iValue;
            else if( iValue >= 5 && iValue <= 8 && *piSize == 0 )
               *piSize = iValue;
            else
               iPort = -1;
         }
         else if( iLen == 2 && *piStop == 0 && *piSize == 0 )
         {
            if( pszName[ 0 ] >= '1' && pszName[ 0 ] <= '2' &&
                pszName[ 1 ] >= '5' && pszName[ 1 ] <= '8' )
            {
               *piStop = pszName[ 0 ] - '0';
               *piSize = pszName[ 1 ] - '0';
            }
            else if( pszName[ 0 ] >= '5' && pszName[ 0 ] <= '8' &&
                     pszName[ 1 ] >= '1' && pszName[ 1 ] <= '2' )
            {
               *piStop = pszName[ 1 ] - '0';
               *piSize = pszName[ 0 ] - '0';
            }
            else if( *piBaud )
               iPort = -1;
            else
               *piBaud = iValue;
         }
         else if( *piBaud )
            iPort = -1;
         else
            *piBaud = iValue;
         pszName += iLen;
      }
      else if( HB_ISALPHA( *pszName ) )
      {
         if( hb_strnicmp( pszName, "RTS", 3 ) == 0 )
         {
            *piFlow |= HB_COM_FLOW_IRTSCTS;
            pszName += 3;
         }
         else if( hb_strnicmp( pszName, "CTS", 3 ) == 0 )
         {
            *piFlow |= HB_COM_FLOW_ORTSCTS;
            pszName += 3;
         }
         else if( hb_strnicmp( pszName, "DTR", 3 ) == 0 )
         {
            *piFlow |= HB_COM_FLOW_IDTRDSR;
            pszName += 3;
         }
         else if( hb_strnicmp( pszName, "DSR", 3 ) == 0 )
         {
            *piFlow |= HB_COM_FLOW_ODTRDSR;
            pszName += 3;
         }
         else if( hb_strnicmp( pszName, "DCD", 3 ) == 0 )
         {
            *piFlow |= HB_COM_FLOW_DCD;
            pszName += 3;
         }
         else if( hb_strnicmp( pszName, "XOFF", 4 ) == 0 )
         {
            *piFlow |= HB_COM_FLOW_XOFF;
            pszName += 4;
         }
         else if( hb_strnicmp( pszName, "XON", 3 ) == 0 )
         {
            *piFlow |= HB_COM_FLOW_XON;
            pszName += 3;
         }
         else if( *piParity == 0 && ! HB_ISALPHA( pszName[ 1 ] ) )
         {
            switch( *pszName )
            {
               case 'N':
               case 'n':
               case 'E':
               case 'e':
               case 'O':
               case 'o':
               case 'S':
               case 's':
               case 'M':
               case 'm':
                  *piParity = HB_TOUPPER( *pszName );
                  pszName++;
                  break;
               default:
                  iPort = -1;
                  break;
            }
         }
         else
            iPort = -1;
      }
      else if( *pszName == ':' || *pszName == ',' || *pszName == ' ' )
         pszName++;
      else
         iPort = -1;
   }

   if( *piBaud == 0 )
      *piBaud = 9600;
   if( *piParity == 0 )
      *piParity = 'N';
   if( *piSize == 0 )
      *piSize = 8;
   if( *piStop == 0 )
      *piStop = 1;

   return iPort;
}
Beispiel #10
0
int hb_charUpper( int iChar )
{
   return HB_TOUPPER( iChar );
}
Beispiel #11
0
static const char * hb_compChkParseSwitch( HB_COMP_DECL, const char * szSwitch,
                                           HB_BOOL fEnv )
{
   const char * szSwPtr = szSwitch;

   if( szSwPtr[ 0 ] == '-' && szSwPtr[ 1 ] == '-' )
   {
      if( strncmp( szSwPtr + 2, "version", 7 ) == 0 )
      {
         szSwPtr += 9;
         HB_COMP_PARAM->fLogo = HB_TRUE;
         HB_COMP_PARAM->fQuiet = HB_TRUE;
      }
      else if( strncmp( szSwPtr + 2, "help", 4 ) == 0 )
      {
         szSwPtr += 6;
         HB_COMP_PARAM->fLogo = HB_TRUE;
         HB_COMP_PARAM->fQuiet = HB_FALSE;
         HB_COMP_PARAM->fExit = HB_FALSE;
      }
   }
   else if( HB_ISOPTSEP( *szSwPtr ) )
   {
      ++szSwPtr;
      switch( HB_TOUPPER( *szSwPtr ) )
      {
         case 'A':
            ++szSwPtr;
            if( *szSwPtr == '-' )
            {
               ++szSwPtr;
               HB_COMP_PARAM->fAutoMemvarAssume = HB_FALSE;
            }
            else
               HB_COMP_PARAM->fAutoMemvarAssume = HB_TRUE;
            break;

         case 'B':
         {
            char *szOption = hb_compChkOptionDup( szSwPtr );

            if( strcmp( szOption, "BUILD" ) == 0 )
            {
               HB_COMP_PARAM->fBuildInfo = HB_TRUE;
               szSwPtr += 5;
            }
            else if( szSwPtr[ 1 ] == '-' )
            {
               HB_COMP_PARAM->fDebugInfo = HB_FALSE;
               szSwPtr += 2;
            }
            else
            {
               HB_COMP_PARAM->fDebugInfo = HB_TRUE;
               HB_COMP_PARAM->fLineNumbers = HB_TRUE;
               ++szSwPtr;
            }
            hb_xfree( szOption );
            break;
         }

         case 'C':
         {
            char *szOption = hb_compChkOptionDup( szSwPtr );

            if( strlen( szOption ) >= 4 &&
                strncmp( "CREDITS", szOption, strlen( szOption ) ) == 0 )
            {
               HB_COMP_PARAM->fCredits = HB_TRUE;
               szSwPtr += strlen( szOption );
            }
            hb_xfree( szOption );
            break;
         }

         case 'D':
            szSwPtr = hb_compChkAddDefine( HB_COMP_PARAM, szSwPtr + 1, HB_TRUE, fEnv );
            break;

         case 'E':
            if( HB_TOUPPER( szSwPtr[ 1 ] ) == 'S' )
            {
               switch( szSwPtr[ 2 ] )
               {
                  case '1':
                     szSwPtr += 3;
                     HB_COMP_PARAM->iExitLevel = HB_EXITLEVEL_SETEXIT;
                     break;
                  case '2':
                     szSwPtr += 3;
                     HB_COMP_PARAM->iExitLevel = HB_EXITLEVEL_DELTARGET;
                     break;
                  case '0':
                     ++szSwPtr;
                     /* no break; */
                  default:
                     szSwPtr += 2;
                     HB_COMP_PARAM->iExitLevel = HB_EXITLEVEL_DEFAULT;
                     break;
               }
            }
            break;

         case 'F':
            switch( HB_TOUPPER( szSwPtr[ 1 ] ) )
            {
               case 'N':
                  if( szSwPtr[ 2 ] == ':' )
                  {
                     if( HB_TOUPPER( szSwPtr[ 3 ] ) == 'U' )
                     {
                        szSwPtr += 4;
                        hb_setSetFileCase( HB_SET_CASE_UPPER );
                     }
                     else if( HB_TOUPPER( szSwPtr[ 3 ] ) == 'L' )
                     {
                        szSwPtr += 4;
                        hb_setSetFileCase( HB_SET_CASE_LOWER );
                     }
                  }
                  else
                  {
                     szSwPtr += 2;
                     if( *szSwPtr == '-' )
                        ++szSwPtr;
                     hb_setSetFileCase( HB_SET_CASE_MIXED );
                  }
                  break;
               case 'D':
                  if( szSwPtr[ 2 ] == ':' )
                  {
                     if( HB_TOUPPER( szSwPtr[ 3 ] ) == 'U' )
                     {
                        szSwPtr += 4;
                        hb_setSetDirCase( HB_SET_CASE_UPPER );
                     }
                     else if( HB_TOUPPER( szSwPtr[ 3 ] ) == 'L' )
                     {
                        szSwPtr += 4;
                        hb_setSetDirCase( HB_SET_CASE_LOWER );
                     }
                  }
                  else
                  {
                     szSwPtr += 2;
                     if( *szSwPtr == '-' )
                        ++szSwPtr;
                     hb_setSetDirCase( HB_SET_CASE_MIXED );
                  }
                  break;
               case 'P':
                  szSwPtr += 2;
                  if( *szSwPtr == ':' )
                  {
                     if( szSwPtr[ 1 ] && szSwPtr[ 1 ] != ' ' )
                     {
                        hb_setSetDirSeparator( szSwPtr[ 1 ] );
                        szSwPtr += 2;
                     }
                  }
                  else
                  {
                     if( *szSwPtr == '-' )
                        ++szSwPtr;
                     hb_setSetDirSeparator( HB_OS_PATH_DELIM_CHR );
                  }
                  break;
               case 'S':
                  szSwPtr += 2;
                  if( *szSwPtr == '-' )
                  {
                     ++szSwPtr;
                     hb_setSetTrimFileName( HB_FALSE );
                  }
                  else
                     hb_setSetTrimFileName( HB_TRUE );
            }
            break;

         case 'G':
            switch( HB_TOUPPER( szSwPtr[ 1 ] ) )
            {
               case 'C':
                  HB_COMP_PARAM->iLanguage = HB_LANG_C;
                  szSwPtr += 2;
                  switch( *szSwPtr )
                  {
                     case '1':
                        ++szSwPtr;
                        HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_NORMAL;
                        break;
                     case '2':
                        ++szSwPtr;
                        HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_VERBOSE;
                        break;
                     case '3':
                        ++szSwPtr;
                        HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_REALCODE;
                        break;
                     case '0':
                        ++szSwPtr;
                        /* no break; */
                     default:
                        HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_COMPACT;
                        break;
                  }
                  break;

               case 'H':
                  HB_COMP_PARAM->iLanguage = HB_LANG_PORT_OBJ;
                  szSwPtr += 2;
                  break;

               case 'D':
                  if( HB_COMP_PARAM->szDepExt )
                  {
                     hb_xfree( HB_COMP_PARAM->szDepExt );
                     HB_COMP_PARAM->szDepExt = NULL;
                  }
                  szSwPtr += 2;
                  if( *szSwPtr == '-' )
                  {
                     HB_COMP_PARAM->iTraceInclude = 0;
                     ++szSwPtr;
                  }
                  else
                  {
                     HB_COMP_PARAM->iTraceInclude = 2;
                     if( *szSwPtr == '.' )
                        szSwPtr = hb_compChkOptionGet( szSwPtr, &HB_COMP_PARAM->szDepExt, fEnv );
                  }
                  break;

               case 'E':
                  szSwPtr += 2;
                  switch( *szSwPtr )
                  {
                     case '1':
                        ++szSwPtr;
                        HB_COMP_PARAM->iErrorFmt = HB_ERRORFMT_IDE;
                        break;
                     case '0':
                        ++szSwPtr;
                        /* no break; */
                     default:
                        HB_COMP_PARAM->iErrorFmt = HB_ERRORFMT_CLIPPER;
                        break;
                  }
                  break;

               default:
                  hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_UNSUPPORTED_LANG, NULL, NULL );
                  break;
            }
            break;

         case 'H':
         case '?':
            /* HELP message */
            break;

         case 'I':
            ++szSwPtr;
            switch( *szSwPtr )
            {
               case '-':
                  HB_COMP_PARAM->fINCLUDE = HB_FALSE;
                  ++szSwPtr;
                  break;
               case '+':
                  HB_COMP_PARAM->fINCLUDE = HB_TRUE;
                  ++szSwPtr;
                  break;
               default:
                  szSwPtr = hb_compChkOptionAddPath( HB_COMP_PARAM, szSwPtr, fEnv );
            }
            break;

         case 'J':
            ++szSwPtr;
            HB_COMP_PARAM->fI18n = HB_TRUE;
            if( *szSwPtr )
               szSwPtr = hb_compChkOptionFName( szSwPtr, &HB_COMP_PARAM->pI18nFileName, fEnv );
            break;

         case 'K':
            ++szSwPtr;
            while( *szSwPtr && ! HB_COMP_PARAM->fExit )
            {
               int ch = HB_TOUPPER( *szSwPtr );

               ++szSwPtr;
               switch( ch )
               {
                  case '?':
                     hb_compPrintLogo( HB_COMP_PARAM );
                     hb_compPrintModes( HB_COMP_PARAM );
                     HB_COMP_PARAM->fLogo = HB_FALSE;
                     HB_COMP_PARAM->fQuiet = HB_TRUE;
                     break;

                  case 'H':
                     /* default Harbour mode */
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_HARBOUR;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_HARBOUR;
                     break;

                  case 'C':
                     /* clear all flags - minimal set of features */
                     HB_COMP_PARAM->supported &= HB_COMPFLAG_SHORTCUTS;
                     HB_COMP_PARAM->supported |= HB_COMPFLAG_OPTJUMP |
                                                 HB_COMPFLAG_MACROTEXT;
                     break;

                  case 'X':
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_XBASE;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_XBASE;
                     break;

                  case 'I':
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_HB_INLINE;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_HB_INLINE;
                     break;

                  case 'J':
                     if( *szSwPtr == '+' )
                     {
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_OPTJUMP;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_OPTJUMP;
                     break;

                  case 'M':
                     if( *szSwPtr == '+' )
                     {
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_MACROTEXT;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_MACROTEXT;
                     break;

                  case 'D':
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_MACRODECL;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_MACRODECL;
                     break;

                  case 'R':
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_RT_MACRO;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_RT_MACRO;
                     break;

                  case 'S':
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_ARRSTR;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_ARRSTR;
                     break;

                  case 'O':
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_EXTOPT;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_EXTOPT;
                     break;

                  case 'U':
                     if( *szSwPtr == '-' )
                     {
                        HB_COMP_PARAM->supported &= ~HB_COMPFLAG_USERCP;
                        ++szSwPtr;
                     }
                     else
                        HB_COMP_PARAM->supported |= HB_COMPFLAG_USERCP;
                     break;

                  default:
                     ch = -1;
                     --szSwPtr;
               }
               if( ch == -1 )
                  break;
            }
            break;

         case 'L':
            ++szSwPtr;
            if( *szSwPtr == '-' )
            {
               HB_COMP_PARAM->fLineNumbers = HB_TRUE;
               ++szSwPtr;
            }
            else
               HB_COMP_PARAM->fLineNumbers = HB_FALSE;
            break;

         case 'M':
            ++szSwPtr;
            if( *szSwPtr == '-' )
            {
               HB_COMP_PARAM->fSingleModule = HB_FALSE;
               ++szSwPtr;
            }
            else
               HB_COMP_PARAM->fSingleModule = HB_TRUE;
            break;

         case 'N':
            ++szSwPtr;
            HB_COMP_PARAM->fNoStartUp = *szSwPtr == '1';
            switch( *szSwPtr )
            {
               case '-':
                  HB_COMP_PARAM->iStartProc = 0;
                  ++szSwPtr;
                  break;
               case '2':
                  HB_COMP_PARAM->iStartProc = 2;
                  ++szSwPtr;
                  break;
               case '0':
               case '1':
                  ++szSwPtr;
                  /* no break; */
               default:
                  HB_COMP_PARAM->iStartProc = 1;
                  break;
            }
            break;

         case 'O':
            szSwPtr = hb_compChkOptionFName( szSwPtr + 1, &HB_COMP_PARAM->pOutPath, fEnv );
            break;

         case 'P':
            ++szSwPtr;
            if( *szSwPtr == '+' )
            {
               HB_COMP_PARAM->fPPT = HB_TRUE;
               ++szSwPtr;
            }
            else
            {
               if( HB_COMP_PARAM->pPpoPath )
               {
                  hb_xfree( HB_COMP_PARAM->pPpoPath );
                  HB_COMP_PARAM->pPpoPath = NULL;
               }
               if( *szSwPtr == '-' )
               {
                  HB_COMP_PARAM->fPPT = HB_COMP_PARAM->fPPO = HB_FALSE;
                  ++szSwPtr;
               }
               else
               {
                  if( *szSwPtr )
                     szSwPtr = hb_compChkOptionFName( szSwPtr, &HB_COMP_PARAM->pPpoPath, fEnv );
                  HB_COMP_PARAM->fPPO = HB_TRUE;
               }
            }
            break;

         case 'Q':
            ++szSwPtr;
            switch( *szSwPtr )
            {
               case 'l':
               case 'L':
                  HB_COMP_PARAM->fGauge = HB_FALSE;
                  ++szSwPtr;
                  break;
               case '2':
                  HB_COMP_PARAM->fFullQuiet = HB_TRUE;
                  /* no break */
               case '0':
                  HB_COMP_PARAM->fLogo = HB_FALSE;
                  ++szSwPtr;
                  /* no break */
               default:
                  HB_COMP_PARAM->fQuiet = HB_TRUE;
            }
            break;

         case 'R':
            ++szSwPtr;
            if( szSwPtr[ 0 ] == ':' )
            {
               if( HB_ISDIGIT( szSwPtr[ 1 ] ) )
               {
                  int iCycles = 0;
                  ++szSwPtr;
                  while( HB_ISDIGIT( *szSwPtr ) )
                     iCycles = iCycles * 10 + *szSwPtr++ - '0';
                  if( iCycles > 0 )
                     HB_COMP_PARAM->iMaxTransCycles = iCycles;
               }
            }
            else
            {
               /* NOTE: ignored for Cl*pper compatibility:
                        /r[<lib>] request linker to search <lib> (or none) */
               hb_compChkIgnoredInfo( HB_COMP_PARAM, "-r[<lib>]" );
               szSwPtr = hb_compChkOptionGet( szSwPtr, NULL, fEnv );
            }
            break;

         case 'S':
            ++szSwPtr;
            switch( *szSwPtr )
            {
               case '-':
                  HB_COMP_PARAM->iSyntaxCheckOnly = 0;
                  ++szSwPtr;
                  break;
               case 'm':
               case 'M':
                  HB_COMP_PARAM->iSyntaxCheckOnly = 2;
                  ++szSwPtr;
                  break;
               default:
                  HB_COMP_PARAM->iSyntaxCheckOnly = 1;
                  break;
            }
            break;

         case 'T':
            /* NOTE: ignored for Cl*pper compatibility:
                     /t<path> path for temp file creation */
            hb_compChkIgnoredInfo( HB_COMP_PARAM, "-t<path>" );
            szSwPtr = hb_compChkOptionGet( szSwPtr + 1, NULL, fEnv );
            break;

         case 'U':
            if( hb_strnicmp( szSwPtr, "UNDEF:", 6 ) == 0 )
            {
               if( hb_strnicmp( szSwPtr + 6, ".ARCH.", 6 ) == 0 )
               {
                  HB_COMP_PARAM->fNoArchDefs = HB_TRUE;
                  szSwPtr += 12;
               }
               else
                  szSwPtr = hb_compChkAddDefine( HB_COMP_PARAM, szSwPtr + 6, HB_FALSE, fEnv );
               break;
            }
            ++szSwPtr;
            /* extended definitions file: -u+<file> */
            if( *szSwPtr == '+' )
            {
               if( szSwPtr[ 1 ] && hb_compChkOptionLen( szSwPtr + 1, fEnv ) > 0 )
               {
                  HB_COMP_PARAM->szStdChExt = ( char ** )
                     ( HB_COMP_PARAM->iStdChExt == 0 ?
                        hb_xgrab( sizeof( char * ) ) :
                        hb_xrealloc( HB_COMP_PARAM->szStdChExt,
                                     ( HB_COMP_PARAM->iStdChExt + 1 ) *
                                     sizeof( char * ) ) );
                  szSwPtr = hb_compChkOptionGet( szSwPtr + 1,
                                                 &HB_COMP_PARAM->szStdChExt[ HB_COMP_PARAM->iStdChExt++ ],
                                                 fEnv );
               }
            }
            else
            {
               if( HB_COMP_PARAM->szStdCh )
                  hb_xfree( HB_COMP_PARAM->szStdCh );
               szSwPtr = hb_compChkOptionGet( szSwPtr, &HB_COMP_PARAM->szStdCh, fEnv );
            }
            break;

         case 'V':
            ++szSwPtr;
            if( *szSwPtr == '-' )
            {
               HB_COMP_PARAM->fForceMemvars = HB_FALSE;
               ++szSwPtr;
            }
            else
               HB_COMP_PARAM->fForceMemvars = HB_TRUE;
            break;

         case 'W':
            ++szSwPtr;
            HB_COMP_PARAM->iWarnings = 1;
            if( *szSwPtr >= '0' && *szSwPtr <= '3' )
            {
               HB_COMP_PARAM->iWarnings = *szSwPtr - '0';
               ++szSwPtr;
            }
            break;

#ifdef YYDEBUG
         case 'Y':
            ++szSwPtr;
            extern int hb_comp_yydebug;
            hb_comp_yydebug = HB_TRUE;
            break;
#endif

         case 'Z':
            ++szSwPtr;
            if( *szSwPtr == '-' )
            {
               HB_COMP_PARAM->supported |= HB_COMPFLAG_SHORTCUTS;
               ++szSwPtr;
            }
            else
               HB_COMP_PARAM->supported &= ~HB_COMPFLAG_SHORTCUTS;
            break;
      }
   }

   if( ! HB_COMP_PARAM->fExit )
   {
      if( szSwPtr - szSwitch <= 1 ||
          ( *szSwPtr != '\0' && *szSwPtr != ' ' && ! HB_ISOPTSEP( *szSwPtr ) ) )
         hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F',
                          fEnv ? HB_COMP_ERR_BADOPTION : HB_COMP_ERR_BADPARAM,
                          szSwitch, NULL );
      else
         return szSwPtr;
   }

   return "";
}
Beispiel #12
0
char * hb_dateFormat( const char * szDate, char * szFormattedDate, const char * szDateFormat )
{
   /*
    * NOTE: szFormattedDate must point to a buffer of at least 11 bytes.
    *       szDateFormat must point to a buffer holding the date format to use.
    */
   int format_count, digit_count, size;

   HB_TRACE( HB_TR_DEBUG, ( "hb_dateFormat(%s, %p, %s)", szDate, szFormattedDate, szDateFormat ) );

   /*
    * Determine the maximum size of the formatted date string
    */
   size = ( int ) strlen( szDateFormat );
   if( size > 10 )
      size = 10;

   if( szDate && strlen( szDate ) == 8 ) /* A valid date is always 8 characters */
   {
      const char * szPtr;
      HB_BOOL used_d, used_m, used_y;

      format_count = 0;
      used_d = used_m = used_y = HB_FALSE;
      szPtr = szDateFormat;

      while( format_count < size )
      {
         int digit = HB_TOUPPER( ( HB_UCHAR ) *szPtr );
         szPtr++;
         digit_count = 1;
         while( HB_TOUPPER( ( HB_UCHAR ) *szPtr ) == digit && format_count < size )
         {
            szPtr++;
            if( format_count + digit_count < size )
               digit_count++;
         }
         switch( digit )
         {
            case 'D':
               switch( digit_count )
               {
                  case 4:
                     if( ! used_d && format_count < size )
                     {
                        /* szFormattedDate[ format_count++ ] = '0'; */
                        szFormattedDate[ format_count++ ] = szDate[ 6 ];
                        digit_count--;
                     }
                  case 3:
                     if( ! used_d && format_count < size )
                     {
                        /* szFormattedDate[ format_count++ ] = '0'; */
                        szFormattedDate[ format_count++ ] = szDate[ 6 ];
                        digit_count--;
                     }
                  case 2:
                     if( ! used_d && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 6 ];
                        digit_count--;
                     }
                  default:
                     if( ! used_d && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 7 ];
                        digit_count--;
                     }
                     while( digit_count-- > 0 && format_count < size )
                        szFormattedDate[ format_count++ ] = ( char ) digit;
               }
               used_d = HB_TRUE;
               break;

            case 'M':
               switch( digit_count )
               {
                  case 4:
                     if( ! used_m && format_count < size )
                     {
                        /* szFormattedDate[ format_count++ ] = '0'; */
                        szFormattedDate[ format_count++ ] = szDate[ 4 ];
                        digit_count--;
                     }
                  case 3:
                     if( ! used_m && format_count < size )
                     {
                        /* szFormattedDate[ format_count++ ] = '0'; */
                        szFormattedDate[ format_count++ ] = szDate[ 4 ];
                        digit_count--;
                     }
                  case 2:
                     if( ! used_m && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 4 ];
                        digit_count--;
                     }
                  default:
                     if( ! used_m && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 5 ];
                        digit_count--;
                     }
                     while( digit_count-- > 0 && format_count < size )
                        szFormattedDate[ format_count++ ] = ( char ) digit;
               }
               used_m = HB_TRUE;
               break;

            case 'Y':
               switch( digit_count )
               {
                  case 4:
                     if( ! used_y && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 0 ];
                        digit_count--;
                     }

                  case 3:
                     if( ! used_y && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 1 ];
                        digit_count--;
                     }

                  case 2:
                     if( ! used_y && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 2 ];
                        digit_count--;
                     }

                  default:
                     if( ! used_y && format_count < size )
                     {
                        szFormattedDate[ format_count++ ] = szDate[ 3 ];
                        digit_count--;
                     }
                     while( digit_count-- > 0 && format_count < size )
                        szFormattedDate[ format_count++ ] = ( char ) digit;
               }
               used_y = HB_TRUE;
               break;

            default:
               while( digit_count-- > 0 && format_count < size )
                  szFormattedDate[ format_count++ ] = ( char ) digit;
         }
      }
   }
   else
   {
      /* Not a valid date string, so return a blank date with separators */
      format_count = size; /* size is either 8 or 10 */
      hb_strncpy( szFormattedDate, szDateFormat, size );

      for( digit_count = 0; digit_count < size; digit_count++ )
      {
         switch( szFormattedDate[ digit_count ] )
         {
            case 'D':
            case 'd':
            case 'M':
            case 'm':
            case 'Y':
            case 'y':
               szFormattedDate[ digit_count ] = ' ';
         }
      }
   }

   szFormattedDate[ format_count ] = '\0';

   return szFormattedDate;
}
Beispiel #13
0
/* time modifiers:
 *    H - hour
 *    M - minutes
 *    S - seconds
 *    F - fractional part of seconds
 *    P - PM/AM marker
 * maximal size of time pattern:
 *    16 for "hh:mm:ss:ffff pp"
 * always safe buffer size is 17 (+1 for 0)
 */
char * hb_timeFormat( char * szBuffer, const char * szTimeFormat, long lMilliSec )
{
   char * szTimeBuffer;
   int iHour, iMinutes, iSeconds, iMSec, iPM, i12;
   int size, i, value, digits, skip;

   HB_TRACE( HB_TR_DEBUG, ( "hb_timeFormat(%p, %s, %ld)", szBuffer, szTimeFormat, lMilliSec ) );

   hb_timeDecode( lMilliSec, &iHour, &iMinutes, &iSeconds, &iMSec );
   szTimeBuffer = szBuffer;

   size = ( int ) hb_strnlen( szTimeFormat, 16 );
   iPM = i12 = 0;
   for( i = 0; i < size; ++i )
   {
      if( HB_TOUPPER( szTimeFormat[ i ] ) == 'P' )
      {
         if( iHour >= 12 )
         {
            iPM = 1;
            iHour -= 12;
         }
         if( iHour == 0 )
            iHour += 12;
         if( iHour < 10 )
            i12 = 1;
         break;
      }
   }

   i = 0;
   while( i < size )
   {
      int count = -i;
      int ch = HB_TOUPPER( szTimeFormat[ i ] );
      ++i;
      while( ch == HB_TOUPPER( szTimeFormat[ i ] ) && i < size )
         ++i;
      count += i;
      switch( ch )
      {
         case 'H':
            value = iHour;
            if( count == 2 && value >= 0 )
            {
               if( i12 )
               {
                  *szTimeBuffer++ = ' ';
                  --count;
               }
               digits = count;
            }
            else
               digits = 1;
            iHour = -1;
            break;
         case 'M':
            value = iMinutes;
            iMinutes = -1;
            digits = count > 2 ? 1 : count;
            break;
         case 'S':
            value = iSeconds;
            iSeconds = -1;
            digits = count > 2 ? 1 : count;
            break;
         case 'F':
            value = iMSec;
            iMSec = -1;
            digits = count > 4 ? 1 : count;
            switch( digits )
            {
               case 4:
                  value *= 10;
                  break;
               case 2:
                  value = ( value + 5 ) / 10;
                  break;
               case 1:
                  value = ( value + 50 ) / 100;
                  break;
            }
            break;
         case 'P':
            if( iPM >= 0 )
            {
               *szTimeBuffer++ = iPM ? 'P' : 'A';
               if( --count )
               {
                  *szTimeBuffer++ = 'M';
                  --count;
               }
               iPM = -1;
            }
         default:
            digits = value = 0;
      }
      if( digits && value >= 0 )
      {
         skip = digits;
         count -= digits;
         do
         {
            szTimeBuffer[ --digits ] = ( char ) ( '0' + value % 10 );
            value /= 10;
         }
         while( digits );
         szTimeBuffer += skip;
      }
      while( count-- )
         *szTimeBuffer++ = ( char ) ch;
   }

   *szTimeBuffer = '\0';

   return szBuffer;
}