cmdlnany.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 1,444 行 · 第 1/3 页

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  Platform independent command line processing.
*
****************************************************************************/


#include "plusplus.h"

#include "compcfg.h"

#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>

#include "memmgr.h"
#include "errdefns.h"
#include "preproc.h"
#include "macro.h"
#include "cmdline.h"
#include "context.h"
#include "scan.h"
#include "iosupp.h"
#include "fname.h"
#include "unicode.h"
#include "cgdata.h"
#include "pcheader.h"
#include "hfile.h"
#include "codegen.h"
#include "cgback.h"
#include "pragdefn.h"
#include "pdefn2.h"
#include "initdefs.h"
#include "brinfo.h"

#include "cmdlnpr1.gh"
#include "cmdlnsys.h"


#define MAX_INDIRECTION                 5       // max. '@' indirections
static unsigned indirectionLevel;               // # '@' indirections

static void checkPacking( unsigned *p )
{
    *p = VerifyPackAmount( *p );
}

static void checkWarnLevel( unsigned *p )
{
    if( *p > 10 ) {
        *p = 10;
    }
}

static void checkPPWidth( unsigned *p )
{
    *p = PpVerifyWidth( *p );
}

static void checkTabWidth( unsigned *p )
{
    switch( *p ) {
    case 2:
    case 4:
    case 8:
        break;
    default:
        *p = DEF_TAB_WIDTH;
    }
}

static void checkOENumber( unsigned *p )
{
    p = p;
}

static void checkPrologSize( unsigned *p )
{
    *p += TARGET_UINT - 1;
    *p &= ~( TARGET_UINT - 1 );
}

static void checkErrorLimit( unsigned *p )
{
    p = p;
}

static int scanDefine( OPT_STRING **p )
{
    MEPTR cmdln_mac;

    p = p;
    cmdln_mac = DefineCmdLineMacro( CompFlags.extended_defines );
    if( cmdln_mac != NULL ) {
        cmdln_mac->macro_flags |= MACRO_USER_DEFINED;
    }
    return( 1 );
}

static int scanDefinePlus( OPT_STRING **p )
{
    MEPTR cmdln_mac;

    p = p;
    if( CmdScanSwEnd() ) {
        CompFlags.extended_defines = 1;
    } else {
        cmdln_mac = DefineCmdLineMacro( TRUE );
        if( cmdln_mac != NULL ) {
            cmdln_mac->macro_flags |= MACRO_USER_DEFINED;
        }
    }
    return( 1 );
}

static int scanUndefine( OPT_STRING **p )
{
    p = p;
    AddUndefName();
    return( 1 );
}

#ifdef OPT_BR
typedef enum                    // BROWSE KINDS
{   FBI_VAR          = 0x01     // - variables
,   FBI_TYPE         = 0x02     // - types
,   FBI_MEMB_DATA    = 0x04     // - member data
,   FBI_FUN          = 0x08     // - functions
,   FBI_MACRO        = 0x10     // - macros
// derived
,   FBI_DEFAULT_ON
        = FBI_VAR | FBI_TYPE | FBI_MEMB_DATA | FBI_FUN | FBI_MACRO
,   FBI_DEFAULT_OFF
        = FBI_VAR | FBI_TYPE | FBI_MEMB_DATA | FBI_FUN | FBI_MACRO
} FBI_KIND;

static int scanFBIopts          // SCAN FBI/FBX OPTIONS
    ( FBI_KIND* a_kind          // - addr[ option kinds ]
    , FBI_KIND def_kind )       // - default kind
{
    int retn;                   // - return: 1 ==> ok, 0 ==> error
    FBI_KIND kind;              // - options scanned

    kind = 0;
    CmdRecogEquals();
    for( ; ; ) {
        if( CmdScanSwEnd()
         || CmdPeekChar() == '-' ) {
            if( 0 == kind ) {
                kind = def_kind;
            }
            retn = 1;
            break;
        }
        switch( CmdScanChar() ) {
          case 'v' :
            kind |= FBI_VAR;
            continue;
          case 't' :
            kind |= FBI_TYPE;
            continue;
          case 'f' :
            kind |= FBI_FUN;
            continue;
          case 'm' :
            kind |= FBI_MEMB_DATA;
            continue;
          case 'p' :
            kind |= FBI_MACRO;
            continue;
          default :
            BadCmdLine( ERR_INVALID_OPTION );
            retn = 0;
            break;
        }
        break;
    }
    *a_kind = kind;
    return retn;
}

#endif

static int scanFBX( OPT_STRING **p )
{
#ifdef OPT_BR
    int retn;                   // - return: 1 ==> ok, 0 ==> error
    FBI_KIND options;           // - options scanned

    p = p;
    if( scanFBIopts( &options, FBI_DEFAULT_OFF ) ) {
        if( options & FBI_VAR ) {
            CompFlags.optbr_v = FALSE;
        }
        if( options & FBI_TYPE ) {
            CompFlags.optbr_t = FALSE;
        }
        if( options & FBI_MEMB_DATA ) {
            CompFlags.optbr_m = FALSE;
        }
        if( options & FBI_MACRO ) {
            CompFlags.optbr_p = FALSE;
        }
        if( options & FBI_FUN ) {
            CompFlags.optbr_f = FALSE;
        }
        retn = 1;
    } else {
        retn = 0;
    }
    return retn;
#else
    p = p;
    BadCmdLine( ERR_INVALID_OPTION );
    return 0;
#endif
}

static int scanFBI( OPT_STRING **p )
{
#ifdef OPT_BR
    int retn;                   // - return: 1 ==> ok, 0 ==> error
    FBI_KIND options;           // - options scanned

    p = p;
    if( scanFBIopts( &options, FBI_DEFAULT_ON ) ) {
        if( options & FBI_VAR ) {
            CompFlags.optbr_v = TRUE;
        }
        if( options & FBI_TYPE ) {
            CompFlags.optbr_t = TRUE;
        }
        if( options & FBI_MEMB_DATA ) {
            CompFlags.optbr_m = TRUE;
        }
        if( options & FBI_MACRO ) {
            CompFlags.optbr_p = TRUE;
        }
        if( options & FBI_FUN ) {
            CompFlags.optbr_f = TRUE;
        }
        retn = 1;
    } else {
        retn = 0;
    }
    return retn;
#else
    p = p;
    BadCmdLine( ERR_INVALID_OPTION );
    return 0;
#endif
}

int OPT_GET_LOWER( void )
{
    return( CmdScanLowerChar() );
}

int OPT_RECOG_LOWER( int c )
{
    return( CmdRecogLowerChar( c ) );
}

int OPT_RECOG( int c )
{
    return( CmdRecogChar( c ) );
}

void OPT_UNGET( void )
{
    CmdScanUngetChar();
}

int OPT_END( void )
{
    return( CmdDelimitChar() );
}

static int scanOffNumber( unsigned *pvalue )
{
    int number_scanned;
    unsigned value;
    int c;

    CmdRecogEquals();
    number_scanned = 0;
    value = 0;
    for(;;) {
        c = CmdScanLowerChar();
        if( ! isdigit( c ) ) {
            CmdScanUngetChar();
            break;
        }
        value *= 10;
        value += c - '0';
        number_scanned = 1;
    }
    if( number_scanned ) {
        *pvalue = value;
    }
    return( number_scanned );
}

int OPT_GET_NUMBER_DEFAULT( unsigned *p, unsigned default_value )
{
    unsigned value;

    if( scanOffNumber( &value ) ) {
        *p = value;
    } else {
        *p = default_value;
    }
    return( 1 );
}

int OPT_GET_NUMBER( unsigned *p )
{
    unsigned value;

    if( scanOffNumber( &value ) ) {
        *p = value;
        return( 1 );
    }
    BadCmdLine( ERR_INVALID_OPTION_NUMBER );
    return( 0 );
}

static void addNumber( OPT_NUMBER **h, unsigned number )
{
    OPT_NUMBER *value;

    value = CMemAlloc( sizeof( *value ) );
    value->number = number;
    value->next = *h;
    *h = value;
}

int OPT_GET_NUMBER_MULTIPLE( OPT_NUMBER **h )
{
    unsigned value;

    if( scanOffNumber( &value ) ) {
        addNumber( h, value );
        return( 1 );
    }
    BadCmdLine( ERR_INVALID_OPTION_NUMBER );
    return( 0 );
}

int OPT_GET_CHAR( int *p )
{
    int c;

    if( ! OPT_END() ) {
        CmdRecogEquals();
        if( ! OPT_END() ) {
            c = CmdScanChar();
            if( isprint( c ) ) {
                *p = c;
                return( 1 );
            }
        }
    }
    BadCmdLine( ERR_INVALID_OPTION );
    return( 0 );
}

static void addString( OPT_STRING **h, char const *s, size_t len )
{
    OPT_STRING *value;

    value = CMemAlloc( sizeof( *value ) + len );
    stvcpy( value->data, s, len );
    value->next = *h;
    *h = value;
}

static void stripQuotes( char *fname )
{
    char *s;
    char *d;

    if( *fname == '"' ) {
        // string will shrink so we can reduce in place
        d = fname;
        for( s = d + 1; *s && *s != '"'; ++s ) {
            // collapse double backslashes, only then look for escaped quotes
            if( s[0] == '\\' && s[1] == '\\' ) {
                ++s;
            } else if( s[0] == '\\' && s[1] == '"' ) {
                ++s;
            }
            *d++ = *s;
        }
        *d = '\0';
    }
}

static void OPT_CLEAN_STRING( OPT_STRING **h )
{
    OPT_STRING *s;

    while( *h ) {
        s = *h;
        *h = s->next;
        CMemFree( s );
    }
}

static void OPT_CLEAN_NUMBER( OPT_NUMBER **h )
{
    OPT_NUMBER *s;

    while( *h ) {
        s = *h;
        *h = s->next;
        CMemFree( s );
    }
}

static void reverseList( OPT_STRING **h )
{
    OPT_STRING *s;
    OPT_STRING *p;
    OPT_STRING *n;

    s = *h;
    *h = NULL;
    for( p = s; p != NULL; p = n ) {
        n = p->next;
        p->next = *h;
        *h = p;
    }
}

static char *reduceToOneString( OPT_STRING **h )
{
    OPT_STRING *s;
    char *p;

    s = *h;
    if( s != NULL ) {
        if( s->data[0] != '\0' ) {
            *h = s->next;
            OPT_CLEAN_STRING( h );
            p = (char*)s;
            strcpy( p, s->data );
        } else {
            OPT_CLEAN_STRING( h );
            p = NULL;
        }
    } else {
        p = NULL;
    }
    return( p );
}

char *SetStringOption( char **o, OPT_STRING **h )