1d13959a7b
* include/extend.api
* include/hbgtcore.h
* include/hbwince.h
* include/hbthread.h
* include/hbdefs.h
* include/hbsetup.h
* include/hbapi.h
* include/clipdefs.h
* include/hbatomic.h
* contrib/hbmysql/mysql.c
* contrib/hbct/ctnet.c
* contrib/hbct/files.c
* contrib/hbct/dattime3.c
* contrib/hbct/disk.c
* contrib/hbodbc/odbc.c
* contrib/xhb/hboutdbg.c
* contrib/xhb/hbsyslog.c
* contrib/xhb/filestat.c
* contrib/hbmsql/msql.c
* contrib/hbole/ole2.c
* contrib/hbmzip/hbmzip.c
* contrib/hbapollo/apollo.c
* contrib/hbfbird/firebird.c
* contrib/hbnf/descendn.c
* contrib/hbnf/getenvrn.c
* contrib/rddsql/sqlmix.c
* contrib/gtwvg/gtwvg.c
* contrib/gtwvg/wvggui.c
* contrib/gtwvg/wvgwin.c
* contrib/gtwvg/wvgutils.c
* contrib/gtwvg/wvgcore.c
* contrib/rddads/adsx.c
* contrib/rddads/rddads.h
* contrib/rddads/adsmgmnt.c
* contrib/rddads/adsfunc.c
* contrib/rddads/ads1.c
* contrib/hbfimage/fi_winfu.c
* contrib/hbfimage/fi_wrp.c
* contrib/hbgd/gd.ch
* contrib/hbgd/gdwrp.c
* contrib/hbgf/hbgfwin/winapi.c
* contrib/hbtip/utils.c
* contrib/hbtip/ChangeLog
* contrib/hbwin/win_prn2.c
* contrib/hbwin/win_osc.c
* contrib/hbwin/win_misc.c
* contrib/hbwin/win_prt.c
* contrib/hbwin/win_dll.c
* contrib/hbwin/win_ole.c
* contrib/hbwin/win_prn1.c
* contrib/hbwin/win_regc.c
* contrib/hbssl/sslsess.c
* contrib/hbssl/sslrand.c
* contrib/hbwhat/whtdate.c
* contrib/hbwhat/whtini.c
* contrib/hbwhat/whtcret.c
* contrib/hbwhat/whthead.c
* contrib/hbwhat/whtilst.c
* contrib/hbwhat/whtreg.c
* contrib/hbwhat/whtclpb.c
* contrib/hbwhat/whtmous.c
* contrib/hbwhat/whtrgn.c
* contrib/hbwhat/whtmeta.c
* contrib/hbwhat/whttbar.c
* contrib/hbwhat/whtrect.c
* contrib/hbwhat/whtbrsh.c
* contrib/hbwhat/whtgdi.c
* contrib/hbwhat/whtdlg.c
* contrib/hbwhat/whtview.c
* contrib/hbwhat/whtsys.c
* contrib/hbwhat/whtmain.c
* contrib/hbwhat/whtwnd.c
* contrib/hbwhat/whtmmcap.c
* contrib/hbwhat/whtfont.c
* contrib/hbwhat/whtdir.c
* contrib/hbwhat/whtbmp.c
* contrib/hbwhat/whtkbrd.c
* contrib/hbwhat/whtpen.c
* contrib/hbwhat/whttext.c
* contrib/hbwhat/whtdc.c
* contrib/hbwhat/whtdraw.c
* contrib/examples/uhttpd/socket.c
* contrib/examples/uhttpd/uhttpdc.c
* source/vm/mainwin.c
* source/vm/maindll.c
* source/vm/maindllh.c
* source/vm/hvm.c
* source/vm/cmdarg.c
* source/vm/maindllp.c
* source/vm/fm.c
* source/vm/extrap.c
* source/vm/thread.c
* source/vm/dynlibhb.c
* source/vm/set.c
* source/common/hbgete.c
* source/common/hbver.c
* source/common/hbfsapi.c
* source/common/hbwince.c
* source/common/hbdate.c
* source/rtl/diskspac.c
* source/rtl/console.c
* source/rtl/gtwin/gtwin.c
* source/rtl/fserror.c
* source/rtl/hbgtcore.c
* source/rtl/gtclip.c
* source/rtl/fstemp.c
* source/rtl/idle.c
* source/rtl/oemansi.c
* source/rtl/disksphb.c
* source/rtl/net.c
* source/rtl/gtgui/gtgui.c
* source/rtl/seconds.c
* source/rtl/gttone.c
* source/rtl/hbproces.c
* source/rtl/gtkeycod.c
* source/rtl/version.c
* source/rtl/gtwvt/gtwvt.c
* source/rtl/hbrandom.c
* source/rtl/hbinet.c
* source/rtl/hbffind.c
* source/rtl/gtsys.c
* source/rtl/filesys.c
* source/rtl/gtkbstat.c
* source/rtl/isprint.c
* source/compiler/cmdcheck.c
* utils/hbmake/hbmlang.c
* #defines renamed to be bitwidth-independent.
- HB_OS_WIN_32_USED -> HB_OS_WIN_USED
- HB_OS_WIN_32 -> HB_OS_WIN
; Please modify your code accordingly.
* include/hbdefs.h
* include/hbsetup.h
+ Added compatibility to still understand HB_OS_WIN_32_USED,
and to #define HB_OS_WIN_32 in addition to HB_OS_WIN.
This means that old code will still work, but these
compatibility features will be removed in the future,
so it's recommended to change the code as above.
1157 lines
38 KiB
C
1157 lines
38 KiB
C
/*
|
|
* $Id$
|
|
*/
|
|
|
|
/*
|
|
* Harbour Project source code:
|
|
* Compiler command line and HARBOURCMD/CLIPPERCMD checking
|
|
*
|
|
* Copyright 1999 {list of individual authors and e-mail addresses}
|
|
* www - http://www.harbour-project.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version, with one exception:
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit
|
|
* their web site at http://www.gnu.org/).
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* The following parts are Copyright of the individual authors.
|
|
* www - http://www.harbour-project.org
|
|
*
|
|
* Copyright 2000 Ron Pinkas <Ron@Profit-Master.com>
|
|
* hb_compChkCompilerSwitch()
|
|
*
|
|
* Copyright 1999 Jose Lalin <dezac@corevia.com>
|
|
* hb_compChkEnvironVar()
|
|
*
|
|
* Copyright 1999-2001 Viktor Szakats <viktor.szakats@syenar.hu>
|
|
* PackDateTime()
|
|
* hb_compChkDefineSwitch()
|
|
* hb_compChkDefines()
|
|
*
|
|
* See doc/license.txt for licensing terms.
|
|
*
|
|
*/
|
|
|
|
#include "hbcomp.h"
|
|
|
|
#if defined(HB_OS_WIN)
|
|
#include <windows.h>
|
|
#else
|
|
#include <time.h>
|
|
#endif
|
|
|
|
/* TODO: Add support for this compiler switches
|
|
-r -t || hb_getenv( "TMP" )
|
|
*/
|
|
|
|
|
|
/* NOTE: Making the date and time info to fit into 32 bits can only be done
|
|
in a "lossy" way, in practice that means it's not possible to unpack
|
|
the exact date/time info from the resulting ULONG. Since the year
|
|
is only stored in 6 bits, 1980 will result in the same bit pattern
|
|
as 2044. The purpose of this value is only used to *differenciate*
|
|
between the dates ( the exact dates are not significant ), so this
|
|
can be used here without problems. [vszakats] */
|
|
|
|
/* 76543210765432107654321076543210
|
|
|.......|.......|.......|.......
|
|
|____| Year 6 bits
|
|
|__| Month 4 bits
|
|
|___| Day 5 bits
|
|
|___| Hour 5 bits
|
|
|____| Minute 6 bits
|
|
|____| Second 6 bits */
|
|
|
|
static ULONG PackDateTime( void )
|
|
{
|
|
BYTE szString[4];
|
|
BYTE nValue;
|
|
|
|
#if defined(HB_OS_WIN)
|
|
SYSTEMTIME st;
|
|
|
|
GetLocalTime( &st );
|
|
|
|
nValue = ( BYTE ) ( ( st.wYear - 1980 ) & ( 2 ^ 6 ) ); /* 6 bits */
|
|
szString[0] = nValue << 2;
|
|
nValue = ( BYTE ) ( st.wMonth ); /* 4 bits */
|
|
szString[0] |= nValue >> 2;
|
|
szString[1] = nValue << 6;
|
|
nValue = ( BYTE ) ( st.wDay ); /* 5 bits */
|
|
szString[1] |= nValue << 1;
|
|
|
|
nValue = ( BYTE ) st.wHour; /* 5 bits */
|
|
szString[1] = nValue >> 4;
|
|
szString[2] = nValue << 4;
|
|
nValue = ( BYTE ) st.wMinute; /* 6 bits */
|
|
szString[2] |= nValue >> 2;
|
|
szString[3] = nValue << 6;
|
|
nValue = ( BYTE ) st.wSecond; /* 6 bits */
|
|
szString[3] |= nValue;
|
|
#else
|
|
time_t t;
|
|
struct tm *oTime;
|
|
|
|
#if !defined( HB_OS_UNIX ) || _POSIX_C_SOURCE < 199506L || defined( HB_OS_DARWIN_5 )
|
|
time( &t );
|
|
oTime = localtime( &t );
|
|
#else
|
|
struct tm tm;
|
|
time( &t );
|
|
oTime = &tm;
|
|
localtime_r( &t, oTime );
|
|
#endif
|
|
|
|
nValue = ( BYTE ) ( ( ( oTime->tm_year + 1900 ) - 1980 ) & ( 2 ^ 6 ) ); /* 6 bits */
|
|
szString[0] = nValue << 2;
|
|
nValue = ( BYTE ) ( oTime->tm_mon + 1 ); /* 4 bits */
|
|
szString[0] |= nValue >> 2;
|
|
szString[1] = nValue << 6;
|
|
nValue = ( BYTE ) ( oTime->tm_mday ); /* 5 bits */
|
|
szString[1] |= nValue << 1;
|
|
|
|
nValue = ( BYTE ) oTime->tm_hour; /* 5 bits */
|
|
szString[1] = nValue >> 4;
|
|
szString[2] = nValue << 4;
|
|
nValue = ( BYTE ) oTime->tm_min; /* 6 bits */
|
|
szString[2] |= nValue >> 2;
|
|
szString[3] = nValue << 6;
|
|
nValue = ( BYTE ) oTime->tm_sec; /* 6 bits */
|
|
szString[3] |= nValue;
|
|
#endif
|
|
|
|
return HB_MKLONG( szString[3], szString[2], szString[1], szString[0] );
|
|
}
|
|
|
|
static void hb_notSupportedInfo( HB_COMP_DECL, const char *szSwitch )
|
|
{
|
|
char buffer[ 512 ];
|
|
|
|
hb_snprintf( buffer, sizeof( buffer ),
|
|
"Not yet supported command line option: %s\n", szSwitch );
|
|
|
|
hb_compOutStd( HB_COMP_PARAM, buffer );
|
|
}
|
|
|
|
static void hb_compChkEnvironVar( HB_COMP_DECL, const char *szSwitch )
|
|
{
|
|
if( szSwitch && !HB_COMP_PARAM->fExit )
|
|
{
|
|
const char *s = szSwitch;
|
|
|
|
/* If szSwitch doesn't start with a HB_OSOPTSEP char
|
|
* show an error
|
|
*/
|
|
if( !HB_ISOPTSEP( *s ) )
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
else
|
|
{
|
|
s++;
|
|
switch( *s )
|
|
{
|
|
case 'a':
|
|
case 'A':
|
|
if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->fAutoMemvarAssume = FALSE;
|
|
else
|
|
HB_COMP_PARAM->fAutoMemvarAssume = TRUE;
|
|
break;
|
|
|
|
case 'b':
|
|
case 'B':
|
|
{
|
|
unsigned int i = 0;
|
|
char *szOption = hb_strupr( hb_strdup( s ) );
|
|
|
|
while( i < strlen( szOption ) && !HB_ISOPTSEP( szOption[i] ) )
|
|
i++;
|
|
szOption[i] = '\0';
|
|
|
|
if( strcmp( szOption, "BUILD" ) == 0 )
|
|
HB_COMP_PARAM->fBuildInfo = TRUE;
|
|
else
|
|
{
|
|
if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->fDebugInfo = FALSE;
|
|
else
|
|
{
|
|
HB_COMP_PARAM->fDebugInfo = TRUE;
|
|
HB_COMP_PARAM->fLineNumbers = TRUE;
|
|
}
|
|
}
|
|
|
|
hb_xfree( szOption );
|
|
break;
|
|
}
|
|
|
|
case 'c':
|
|
case 'C':
|
|
{
|
|
unsigned int i = 0;
|
|
char *szOption = hb_strupr( hb_strdup( s ) );
|
|
|
|
while( i < strlen( szOption ) && !HB_ISOPTSEP( szOption[i] ) )
|
|
i++;
|
|
szOption[i] = '\0';
|
|
|
|
if( strcmp( szOption, "CREDITS" ) == 0 ||
|
|
strcmp( szOption, "CREDIT" ) == 0 ||
|
|
strcmp( szOption, "CREDI" ) == 0 ||
|
|
strcmp( szOption, "CRED" ) == 0 )
|
|
HB_COMP_PARAM->fCredits = TRUE;
|
|
else
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, szOption, NULL );
|
|
|
|
hb_xfree( szOption );
|
|
break;
|
|
}
|
|
|
|
case 'd':
|
|
case 'D':
|
|
/* NOTE: Ignore these -d switches will be processed separately */
|
|
break;
|
|
|
|
case 'e':
|
|
case 'E':
|
|
if( *( s + 1 ) == 's' || *( s + 1 ) == 'S' )
|
|
{
|
|
switch( *( s + 2 ) )
|
|
{
|
|
case '\0':
|
|
case '0':
|
|
HB_COMP_PARAM->iExitLevel = HB_EXITLEVEL_DEFAULT;
|
|
break;
|
|
|
|
case '1':
|
|
HB_COMP_PARAM->iExitLevel = HB_EXITLEVEL_SETEXIT;
|
|
break;
|
|
|
|
case '2':
|
|
HB_COMP_PARAM->iExitLevel = HB_EXITLEVEL_DELTARGET;
|
|
break;
|
|
|
|
default:
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
}
|
|
}
|
|
else
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
|
|
break;
|
|
|
|
case 'g':
|
|
case 'G':
|
|
switch( *( s + 1 ) )
|
|
{
|
|
case 'c':
|
|
case 'C':
|
|
HB_COMP_PARAM->iLanguage = HB_LANG_C;
|
|
|
|
switch( *( s + 2 ) )
|
|
{
|
|
case '3':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_REALCODE;
|
|
break;
|
|
|
|
case '2':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_VERBOSE;
|
|
break;
|
|
|
|
case '1':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_NORMAL;
|
|
break;
|
|
|
|
case '\0':
|
|
case '0':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_COMPACT;
|
|
break;
|
|
|
|
default:
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
}
|
|
break;
|
|
|
|
case 'o':
|
|
case 'O':
|
|
HB_COMP_PARAM->iLanguage = HB_LANG_OBJ_MODULE;
|
|
|
|
switch( *( s + 2 ) )
|
|
{
|
|
case '3':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_REALCODE;
|
|
break;
|
|
|
|
case '2':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_VERBOSE;
|
|
break;
|
|
|
|
case '1':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_NORMAL;
|
|
break;
|
|
|
|
case '\0':
|
|
case '0':
|
|
HB_COMP_PARAM->iGenCOutput = HB_COMPGENC_COMPACT;
|
|
break;
|
|
|
|
default:
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
}
|
|
break;
|
|
|
|
case 'h':
|
|
case 'H':
|
|
HB_COMP_PARAM->iLanguage = HB_LANG_PORT_OBJ;
|
|
break;
|
|
|
|
#ifdef HB_GEN_W32_OBJ
|
|
case 'w':
|
|
case 'W':
|
|
HB_COMP_PARAM->iLanguage = HB_LANG_OBJ32;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_UNSUPPORTED_LANG, NULL, NULL );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
/* NOTE:
|
|
h or H from HELP or help
|
|
*/
|
|
case 'h':
|
|
case 'H':
|
|
case '?':
|
|
break;
|
|
|
|
/* NOTE:
|
|
It already has support for several include files
|
|
*/
|
|
case 'i':
|
|
case 'I':
|
|
hb_pp_addSearchPath( HB_COMP_PARAM->pLex->pPP, s + 1, FALSE );
|
|
break;
|
|
|
|
case 'j':
|
|
case 'J':
|
|
HB_COMP_PARAM->fI18n = TRUE;
|
|
if( s[ 1 ] )
|
|
HB_COMP_PARAM->pI18nFileName = hb_fsFNameSplit( s + 1 );
|
|
break;
|
|
|
|
case 'k':
|
|
case 'K':
|
|
{
|
|
int i = 1;
|
|
|
|
while( s[i] && !HB_COMP_PARAM->fExit )
|
|
{
|
|
switch( s[i++] )
|
|
{
|
|
case '?':
|
|
hb_compPrintLogo( HB_COMP_PARAM );
|
|
hb_compPrintModes( HB_COMP_PARAM );
|
|
HB_COMP_PARAM->fLogo = FALSE;
|
|
HB_COMP_PARAM->fQuiet = TRUE;
|
|
break;
|
|
|
|
case 'h':
|
|
case 'H':
|
|
/* default Harbour mode */
|
|
if( s[i] == '-' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_HARBOUR;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_HARBOUR;
|
|
break;
|
|
|
|
case 'c':
|
|
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':
|
|
case 'X':
|
|
if( s[i] == '-' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_XBASE;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_XBASE;
|
|
break;
|
|
|
|
case 'i':
|
|
case 'I':
|
|
if( s[i] == '-' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_HB_INLINE;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_HB_INLINE;
|
|
break;
|
|
|
|
case 'j':
|
|
case 'J':
|
|
if( s[i] == '+' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_OPTJUMP;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_OPTJUMP;
|
|
break;
|
|
|
|
case 'm':
|
|
case 'M':
|
|
if( s[i] == '+' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_MACROTEXT;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_MACROTEXT;
|
|
break;
|
|
|
|
case 'r':
|
|
case 'R':
|
|
if( s[i] == '-' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_RT_MACRO;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_RT_MACRO;
|
|
break;
|
|
|
|
case 's':
|
|
case 'S':
|
|
if( s[i] == '-' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_ARRSTR;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_ARRSTR;
|
|
break;
|
|
|
|
case 'o':
|
|
case 'O':
|
|
if( s[i] == '-' )
|
|
{
|
|
i++;
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_EXTOPT;
|
|
}
|
|
else
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_EXTOPT;
|
|
break;
|
|
|
|
default:
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 'l':
|
|
case 'L':
|
|
if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->fLineNumbers = TRUE;
|
|
else
|
|
HB_COMP_PARAM->fLineNumbers = FALSE;
|
|
break;
|
|
|
|
case 'm':
|
|
case 'M':
|
|
if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->fAutoOpen = TRUE;
|
|
else
|
|
HB_COMP_PARAM->fAutoOpen = FALSE;
|
|
break;
|
|
|
|
case 'n':
|
|
case 'N':
|
|
/*
|
|
-n1 no start up procedure and no implicit start up procedure
|
|
*/
|
|
if( *( s + 1 ) == '1' )
|
|
{
|
|
HB_COMP_PARAM->fStartProc = FALSE;
|
|
HB_COMP_PARAM->fNoStartUp = TRUE;
|
|
}
|
|
/*
|
|
-n or -n0 no implicit start up procedure
|
|
*/
|
|
else if( ( *( s + 1 ) == '0' ) || ( *( s + 1 ) == '\0' ) )
|
|
HB_COMP_PARAM->fStartProc = FALSE;
|
|
/*
|
|
-n- ceates implicit start up procedure
|
|
*/
|
|
else if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->fStartProc = TRUE;
|
|
else
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
break;
|
|
|
|
case 'o':
|
|
case 'O':
|
|
{
|
|
char *szPath = hb_strdup( s + 1 );
|
|
|
|
HB_COMP_PARAM->pOutPath = hb_fsFNameSplit( szPath );
|
|
hb_xfree( szPath );
|
|
break;
|
|
}
|
|
|
|
/* Added for preprocessor needs */
|
|
case 'p':
|
|
case 'P':
|
|
if( s[ 1 ] == '+' && s[ 2 ] == '\0' )
|
|
HB_COMP_PARAM->fPPT = TRUE;
|
|
else if( s[ 1 ] == '-' && s[ 2 ] == '\0' )
|
|
HB_COMP_PARAM->fPPO = FALSE;
|
|
else
|
|
{
|
|
if( HB_COMP_PARAM->pPpoPath )
|
|
{
|
|
HB_COMP_PARAM->pPpoPath = NULL;
|
|
hb_xfree( HB_COMP_PARAM->pPpoPath );
|
|
}
|
|
if( s[ 1 ] )
|
|
HB_COMP_PARAM->pPpoPath = hb_fsFNameSplit( s + 1 );
|
|
HB_COMP_PARAM->fPPO = TRUE;
|
|
}
|
|
break;
|
|
|
|
case 'q':
|
|
case 'Q':
|
|
switch( *( s + 1 ) )
|
|
{
|
|
case '2':
|
|
HB_COMP_PARAM->fFullQuiet = TRUE;
|
|
case '0':
|
|
HB_COMP_PARAM->fLogo = FALSE;
|
|
default:
|
|
HB_COMP_PARAM->fQuiet = TRUE;
|
|
}
|
|
break;
|
|
|
|
case 'r':
|
|
case 'R':
|
|
if( *( s + 1 ) == ':' )
|
|
{
|
|
int iOverflow;
|
|
int iCycles = ( int ) hb_strValInt( s + 2, &iOverflow );
|
|
|
|
if( !iOverflow && iCycles > 0 )
|
|
HB_COMP_PARAM->iMaxTransCycles = iCycles;
|
|
}
|
|
else
|
|
{
|
|
/* TODO: Implement this switch */
|
|
hb_notSupportedInfo( HB_COMP_PARAM, s );
|
|
}
|
|
break;
|
|
|
|
case 's':
|
|
case 'S':
|
|
if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->fSyntaxCheckOnly = FALSE;
|
|
else
|
|
HB_COMP_PARAM->fSyntaxCheckOnly = TRUE;
|
|
break;
|
|
|
|
case 't':
|
|
case 'T':
|
|
/* TODO: Implement this switch */
|
|
hb_notSupportedInfo( HB_COMP_PARAM, s );
|
|
break;
|
|
|
|
case 'u':
|
|
case 'U':
|
|
if( s[1] && toupper( s[1] ) == 'N'
|
|
&& s[2] && toupper( s[2] ) == 'D' && s[3] && toupper( s[3] ) == 'E' && s[4] && toupper( s[4] ) == 'F' && s[5] == ':' )
|
|
{
|
|
/* NOTE: Ignore these -undef: switches will be processed separately */
|
|
break;
|
|
}
|
|
HB_COMP_PARAM->szStdCh = hb_strdup( s + 1 );
|
|
break;
|
|
|
|
case 'v':
|
|
case 'V':
|
|
if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->fForceMemvars = FALSE;
|
|
else
|
|
HB_COMP_PARAM->fForceMemvars = TRUE;
|
|
break;
|
|
|
|
case 'w':
|
|
case 'W':
|
|
HB_COMP_PARAM->iWarnings = 1;
|
|
if( s[1] )
|
|
{ /*there is -w<0,1,2,3> probably */
|
|
HB_COMP_PARAM->iWarnings = s[1] - '0';
|
|
if( HB_COMP_PARAM->iWarnings < 0 || HB_COMP_PARAM->iWarnings > 3 )
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
}
|
|
break;
|
|
|
|
case 'x':
|
|
case 'X':
|
|
{
|
|
unsigned int i = 1;
|
|
while( s[i] && !HB_ISOPTSEP( s[i] ) &&
|
|
i < sizeof( HB_COMP_PARAM->szPrefix ) - 1 )
|
|
{
|
|
++i;
|
|
}
|
|
if( i > 1 )
|
|
{
|
|
memcpy( HB_COMP_PARAM->szPrefix, s + 1, i - 1 );
|
|
HB_COMP_PARAM->szPrefix[ i - 1 ] = '_';
|
|
HB_COMP_PARAM->szPrefix[ i ] = '\0';
|
|
}
|
|
else
|
|
{
|
|
hb_snprintf( HB_COMP_PARAM->szPrefix,
|
|
sizeof( HB_COMP_PARAM->szPrefix ),
|
|
"%08lX_", PackDateTime() );
|
|
}
|
|
break;
|
|
}
|
|
|
|
#ifdef YYDEBUG
|
|
case 'y':
|
|
case 'Y':
|
|
yydebug = TRUE;
|
|
break;
|
|
#endif
|
|
|
|
case 'z':
|
|
case 'Z':
|
|
if( *( s + 1 ) == '-' )
|
|
HB_COMP_PARAM->supported |= HB_COMPFLAG_SHORTCUTS;
|
|
else
|
|
HB_COMP_PARAM->supported &= ~HB_COMPFLAG_SHORTCUTS;
|
|
break;
|
|
|
|
default:
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, s, NULL );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void hb_compChkCompilerSwitch( HB_COMP_DECL, int iArg, char * const Args[] )
|
|
{
|
|
/* If iArg is passed check the command line options */
|
|
if( iArg )
|
|
{
|
|
int i;
|
|
|
|
/* Check all switches in command line
|
|
They start with an OS_OPT_DELIMITER char
|
|
*/
|
|
for( i = 1; i < iArg && !HB_COMP_PARAM->fExit; i++ )
|
|
{
|
|
const char * szSwitch = Args[i];
|
|
|
|
if( !HB_ISOPTSEP( szSwitch[0] ) )
|
|
continue;
|
|
|
|
if( szSwitch[0] == '-' )
|
|
{
|
|
int j = 1;
|
|
char Switch[7];
|
|
|
|
Switch[0] = '-';
|
|
|
|
while( szSwitch[j] && !HB_COMP_PARAM->fExit )
|
|
{
|
|
Switch[1] = szSwitch[j];
|
|
|
|
if( szSwitch[j + 1] == '-' )
|
|
{
|
|
Switch[2] = '-';
|
|
Switch[3] = '\0';
|
|
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
|
|
j += 2;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
switch( Switch[1] )
|
|
{
|
|
case 'b':
|
|
case 'B':
|
|
if( szSwitch[j + 1] && toupper( ( BYTE ) szSwitch[j + 1] ) == 'U' &&
|
|
szSwitch[j + 2] && toupper( ( BYTE ) szSwitch[j + 2] ) == 'I' &&
|
|
szSwitch[j + 3] && toupper( ( BYTE ) szSwitch[j + 3] ) == 'L' &&
|
|
szSwitch[j + 4] && toupper( ( BYTE ) szSwitch[j + 4] ) == 'D' )
|
|
{
|
|
Switch[2] = 'U';
|
|
Switch[3] = 'I';
|
|
Switch[4] = 'L';
|
|
Switch[5] = 'D';
|
|
Switch[6] = '\0';
|
|
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
|
|
j += 5;
|
|
continue;
|
|
}
|
|
else if( !szSwitch[j + 1] )
|
|
{
|
|
Switch[2] = '\0';
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
j += 1;
|
|
continue;
|
|
}
|
|
break;
|
|
|
|
case 'c':
|
|
case 'C':
|
|
if( szSwitch[j + 1] && toupper( ( BYTE ) szSwitch[j + 1] ) == 'R' &&
|
|
szSwitch[j + 2] && toupper( ( BYTE ) szSwitch[j + 2] ) == 'E' &&
|
|
szSwitch[j + 3] && toupper( ( BYTE ) szSwitch[j + 3] ) == 'D' )
|
|
{
|
|
Switch[2] = 'R';
|
|
Switch[3] = 'E';
|
|
Switch[4] = 'D';
|
|
Switch[5] = '\0';
|
|
|
|
j += 4;
|
|
|
|
if( szSwitch[j] && toupper( ( BYTE ) szSwitch[j] ) == 'I' )
|
|
{
|
|
j++;
|
|
if( szSwitch[j] && toupper( ( BYTE ) szSwitch[j] ) == 'T' )
|
|
{
|
|
j++;
|
|
if( szSwitch[j] && toupper( ( BYTE ) szSwitch[j] ) == 'S' )
|
|
{
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
}
|
|
else
|
|
{
|
|
Switch[2] = '\0';
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, Switch, NULL );
|
|
}
|
|
continue;
|
|
|
|
case 'd':
|
|
case 'D':
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
|
|
/* Accept rest as part of #define and continue with next Args[]. */
|
|
j = strlen( szSwitch );
|
|
continue;
|
|
|
|
case 'e':
|
|
case 'E':
|
|
if( toupper( ( BYTE ) szSwitch[j + 1] ) == 'S' && isdigit( ( BYTE ) szSwitch[j + 2] ) )
|
|
{
|
|
Switch[2] = 'S';
|
|
Switch[3] = szSwitch[j + 2];
|
|
Switch[4] = '\0';
|
|
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
j += 3;
|
|
}
|
|
else
|
|
{
|
|
Switch[2] = '\0';
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, Switch, NULL );
|
|
}
|
|
continue;
|
|
|
|
case 'g':
|
|
case 'G':
|
|
/* Required argument */
|
|
Switch[2] = szSwitch[j + 1];
|
|
if( Switch[2] )
|
|
{
|
|
if( isdigit( ( BYTE ) szSwitch[j + 2] ) )
|
|
{
|
|
/* Optional argument */
|
|
Switch[3] = szSwitch[j + 2];
|
|
Switch[4] = '\0';
|
|
j += 3;
|
|
}
|
|
else
|
|
{
|
|
/* No optional argument */
|
|
Switch[3] = '\0';
|
|
j += 2;
|
|
}
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
}
|
|
else
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, Switch, NULL );
|
|
continue;
|
|
|
|
case 'i':
|
|
case 'I':
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
|
|
/* Accept rest as IncludePath and continue with next Args[]. */
|
|
j = strlen( szSwitch );
|
|
continue;
|
|
|
|
case 'j':
|
|
case 'J':
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
j = strlen( szSwitch );
|
|
continue;
|
|
|
|
case 'k':
|
|
case 'K':
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
|
|
/* Accept rest as part of #define and continue with next Args[]. */
|
|
j = strlen( szSwitch );
|
|
continue;
|
|
|
|
case 'n':
|
|
case 'N':
|
|
/* Required argument */
|
|
if( szSwitch[j + 1] )
|
|
{
|
|
/* Optional argument */
|
|
Switch[2] = szSwitch[j + 1];
|
|
Switch[3] = '\0';
|
|
j += 2;
|
|
}
|
|
else
|
|
{
|
|
/* No optional argument */
|
|
Switch[2] = '\0';
|
|
j += 1;
|
|
}
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
continue;
|
|
|
|
case 'o':
|
|
case 'O':
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
|
|
/* Accept rest as OutputPath and continue with next Args[]. */
|
|
j = strlen( szSwitch );
|
|
continue;
|
|
|
|
case 'p':
|
|
case 'P':
|
|
if( szSwitch[j + 1] )
|
|
{
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
|
|
/* Accept rest as PPOPath and continue with next Args[]. */
|
|
j += strlen( szSwitch ) - 1;
|
|
}
|
|
else
|
|
{
|
|
Switch[2] = '\0';
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
j++;
|
|
}
|
|
continue;
|
|
|
|
case 'q':
|
|
case 'Q':
|
|
if( szSwitch[j + 1] && isdigit( ( BYTE ) szSwitch[j + 1] ) )
|
|
{
|
|
Switch[2] = szSwitch[j + 1];
|
|
Switch[3] = '\0';
|
|
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
|
|
j += 2;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
Switch[2] = '\0';
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
}
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
case 'R':
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
j = strlen( szSwitch ) - 1;
|
|
break;
|
|
|
|
case 'u':
|
|
case 'U':
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
|
|
/* Accept rest as part of .ch Path or "undef:<id>" and continue with next Args[]. */
|
|
j = strlen( szSwitch );
|
|
continue;
|
|
|
|
case 'w':
|
|
case 'W':
|
|
if( szSwitch[j + 1] && isdigit( ( BYTE ) szSwitch[j + 1] ) )
|
|
{
|
|
Switch[2] = szSwitch[j + 1];
|
|
Switch[3] = '\0';
|
|
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
|
|
j += 2;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
Switch[2] = '\0';
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
}
|
|
|
|
break;
|
|
|
|
case 'x':
|
|
case 'X':
|
|
szSwitch += ( j - 1 );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
|
|
/* Accept rest as INIT Symbol and continue with next Args[]. */
|
|
j = strlen( szSwitch );
|
|
continue;
|
|
|
|
case '-':
|
|
{
|
|
int l = ++j;
|
|
while( szSwitch[j] && !HB_ISOPTSEP( szSwitch[j] ) )
|
|
j++;
|
|
if( szSwitch[l-1] == '-' && j-l == 7 &&
|
|
memcmp( &szSwitch[l], "version", 7 ) == 0 )
|
|
{
|
|
HB_COMP_PARAM->fLogo = TRUE;
|
|
HB_COMP_PARAM->fQuiet = TRUE;
|
|
}
|
|
else
|
|
hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'F', HB_COMP_ERR_BADOPTION, &szSwitch[l], NULL );
|
|
if( szSwitch[j] )
|
|
++j;
|
|
continue;
|
|
}
|
|
default:
|
|
Switch[2] = '\0';
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, Switch );
|
|
}
|
|
}
|
|
|
|
j++;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
while( !HB_COMP_PARAM->fExit )
|
|
{
|
|
int j = 1;
|
|
|
|
while( szSwitch[j] && !HB_ISOPTSEP( szSwitch[j] ) )
|
|
j++;
|
|
|
|
if( szSwitch[j] && szSwitch[j] == '/' )
|
|
{
|
|
char * szTmp = hb_strndup( szSwitch, j );
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szTmp );
|
|
hb_xfree( szTmp );
|
|
szSwitch += j;
|
|
}
|
|
else
|
|
{
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
/* Chech the environment variables */
|
|
{
|
|
/* NOTE: CLIPPERCMD enviroment variable
|
|
is overriden if HARBOURCMD exists
|
|
*/
|
|
char *szStrEnv = hb_getenv( "HARBOURCMD" );
|
|
|
|
if( !szStrEnv || szStrEnv[0] == '\0' )
|
|
{
|
|
if( szStrEnv )
|
|
hb_xfree( ( void * ) szStrEnv );
|
|
|
|
szStrEnv = hb_getenv( "CLIPPERCMD" );
|
|
}
|
|
|
|
if( szStrEnv )
|
|
{
|
|
char *szSwitch, *szPtr;
|
|
|
|
szPtr = szStrEnv;
|
|
while( *szPtr && !HB_COMP_PARAM->fExit )
|
|
{
|
|
while( *szPtr == ' ' )
|
|
++szPtr;
|
|
szSwitch = szPtr;
|
|
if( *szSwitch )
|
|
{
|
|
while( *++szPtr )
|
|
{
|
|
if( *szPtr == ' ' )
|
|
{
|
|
*szPtr++ = '\0';
|
|
break;
|
|
}
|
|
}
|
|
hb_compChkEnvironVar( HB_COMP_PARAM, szSwitch );
|
|
}
|
|
}
|
|
hb_xfree( ( void * ) szStrEnv );
|
|
}
|
|
}
|
|
}
|
|
|
|
void hb_compChkPaths( HB_COMP_DECL )
|
|
{
|
|
char *szInclude = hb_getenv( "INCLUDE" );
|
|
|
|
if( szInclude )
|
|
{
|
|
if( szInclude[0] != '\0' )
|
|
hb_pp_addSearchPath( HB_COMP_PARAM->pLex->pPP, szInclude, FALSE );
|
|
hb_xfree( ( void * ) szInclude );
|
|
}
|
|
}
|
|
|
|
static void hb_compChkDefineSwitch( HB_COMP_DECL, const char *pszSwitch )
|
|
{
|
|
if( pszSwitch && HB_ISOPTSEP( pszSwitch[0] ) )
|
|
{
|
|
if( pszSwitch[1] == 'd' || pszSwitch[1] == 'D' )
|
|
{
|
|
if( pszSwitch[2] )
|
|
{
|
|
char *szDefText = hb_strdup( pszSwitch + 2 ), *szAssign;
|
|
|
|
szAssign = strchr( szDefText, '=' );
|
|
if( szAssign )
|
|
*szAssign++ = '\0';
|
|
hb_pp_addDefine( HB_COMP_PARAM->pLex->pPP, szDefText, szAssign );
|
|
hb_xfree( szDefText );
|
|
}
|
|
}
|
|
else if( pszSwitch[1] && toupper( pszSwitch[1] ) == 'U' &&
|
|
pszSwitch[2] && toupper( pszSwitch[2] ) == 'N' &&
|
|
pszSwitch[3] && toupper( pszSwitch[3] ) == 'D' &&
|
|
pszSwitch[4] && toupper( pszSwitch[4] ) == 'E' &&
|
|
pszSwitch[5] && toupper( pszSwitch[5] ) == 'F' &&
|
|
pszSwitch[6] == ':' )
|
|
{
|
|
char *szDefText = hb_strdup( pszSwitch + 7 );
|
|
unsigned int i = 0;
|
|
|
|
while( szDefText[i] && !HB_ISOPTSEP( szDefText[i] ) )
|
|
{
|
|
i++;
|
|
}
|
|
szDefText[i] = '\0';
|
|
|
|
if( szDefText[0] )
|
|
hb_pp_delDefine( HB_COMP_PARAM->pLex->pPP, szDefText );
|
|
hb_xfree( szDefText );
|
|
}
|
|
}
|
|
}
|
|
|
|
void hb_compChkDefines( HB_COMP_DECL, int iArg, char * const Args[] )
|
|
{
|
|
/* Check the environment variables */
|
|
{
|
|
/* NOTE: CLIPPERCMD enviroment variable is overriden
|
|
if HARBOURCMD exists */
|
|
char *szStrEnv = hb_getenv( "HARBOURCMD" );
|
|
|
|
if( !szStrEnv || szStrEnv[0] == '\0' )
|
|
{
|
|
if( szStrEnv )
|
|
hb_xfree( ( void * ) szStrEnv );
|
|
|
|
szStrEnv = hb_getenv( "CLIPPERCMD" );
|
|
}
|
|
|
|
if( szStrEnv )
|
|
{
|
|
char *szSwitch, *szPtr;
|
|
|
|
szPtr = szStrEnv;
|
|
while( *szPtr && !HB_COMP_PARAM->fExit )
|
|
{
|
|
while( *szPtr == ' ' )
|
|
++szPtr;
|
|
szSwitch = szPtr;
|
|
if( *szSwitch )
|
|
{
|
|
while( *++szPtr )
|
|
{
|
|
if( *szPtr == ' ' )
|
|
{
|
|
*szPtr++ = '\0';
|
|
break;
|
|
}
|
|
}
|
|
hb_compChkDefineSwitch( HB_COMP_PARAM, szSwitch );
|
|
}
|
|
}
|
|
hb_xfree( ( void * ) szStrEnv );
|
|
}
|
|
}
|
|
|
|
/* Check the command line options */
|
|
{
|
|
int i;
|
|
|
|
/* Check all switches in command line They start with an OS_OPT_DELIMITER
|
|
char */
|
|
for( i = 1; i < iArg; i++ )
|
|
hb_compChkDefineSwitch( HB_COMP_PARAM, Args[i] );
|
|
}
|
|
}
|