Exemplo n.º 1
0
void PP_Dependency_List( pp_callback *callback )
{
    PP_CallBack = callback;
    for( ; PP_Char() != EOF; ) {
        PPTokenPtr = "";        // quickly skip over token
    }
}
Exemplo n.º 2
0
int main( int argc, char *argv[] )
{
    int         c;

    dumpheap();
    if( argc < 2 ) {
        printf( "Usage: testpp filename\n" );
        exit( 1 );
    }
    if( argv[2] != NULL ) {
        PreProcChar = argv[2][0];
    }
    if( PP_Init( argv[1], PPFLAG_EMIT_LINE, NULL ) != 0 ) {
        printf( "Unable to open '%s'\n", argv[1] );
        exit( 1 );
    }
    for( ;; ) {
        c = PP_Char();
        if( c == EOF )
            break;
        putchar( c );
    }
    dumpheap();
    PP_Fini();
    dumpheap();
    return( 0 );
}
Exemplo n.º 3
0
static int ReadBuffer( FileStack * stack )
/****************************************/
{
    PhysFileInfo    *phys;
    int             numread;
    int             error;
    int             inchar;

    phys = &(stack->Current->Physical);
    if( !phys->IsOpen ) {
        error = OpenPhysicalFile( phys );
        if( error ) return( TRUE );
    }
    if( CmdLineParms.NoPreprocess ) {
        numread = RcRead( phys->Handle, stack->Buffer, stack->BufferSize );
    } else {
        for( numread = 0; numread < stack->BufferSize; numread++ ) {
            inchar = PP_Char();
            if( inchar == EOF ) {
                break;
            }
            *( stack->Buffer + numread ) = (char)inchar;
        }
    }
    stack->NextChar = stack->Buffer;
    stack->EofChar = stack->Buffer + numread;   /* may be past end of buffer */

    return( FALSE );
} /* ReadBuffer */
Exemplo n.º 4
0
static bool ReadBuffer( FileStack * stack )
/*****************************************/
{
    PhysFileInfo    *phys;
    size_t          numread;
    bool            error;
    int             inchar;

    phys = &(stack->Current->Physical);
    if( !phys->IsOpen ) {
        error = OpenPhysicalFile( phys );
        if( error ) {
            return( true );
        }
    }
    if( CmdLineParms.NoPreprocess ) {
        numread = fread( stack->Buffer, 1, stack->BufferSize, phys->fp );
    } else {
        for( numread = 0; numread < stack->BufferSize; numread++ ) {
            inchar = PP_Char();
            if( inchar == EOF ) {
                break;
            }
            *( stack->Buffer + numread ) = (char)inchar;
        }
    }
    stack->NextChar = stack->Buffer;
    stack->EofChar = stack->Buffer + numread;   /* may be past end of buffer */

    return( false );
} /* ReadBuffer */
Exemplo n.º 5
0
static char *WRELoadSymbols( WRHashTable **table, char *file_name, bool prompt )
{
    char                *name;
    int                 c;
    unsigned            flags;
    char                *inc_path;
    WREGetFileStruct    gf;
    unsigned            pp_count;
    unsigned            busy_count;
    char                busy_str[2];
    bool                ret;
    bool                ok;

    name = NULL;

    ok = (table != NULL);

    if( ok ) {
        WRESetStatusText( NULL, "", FALSE );
        WRESetStatusByID( WRE_LOADINGSYMBOLS, -1 );
    }

    if( ok ) {
        if( file_name == NULL || prompt ) {
            gf.file_name = file_name;
            gf.title = WRESymLoadTitle;
            gf.filter = WRESymSaveFilter;
            gf.save_ext = FALSE;
            name = WREGetOpenFileName( &gf );
        } else {
            name = WREStrDup( file_name );
        }
        ok = (name != NULL);
    }

    WRESetWaitCursor( TRUE );

    if( ok ) {
        flags = PPFLAG_IGNORE_INCLUDE | PPFLAG_EMIT_LINE;
        inc_path = NULL;
        ret = setjmp( SymEnv );
        if( ret ) {
            PP_Fini();
            WREDisplayErrorMsg( WRE_SYMOUTOFMEM );
            ok = false;
        }
    }

    if( ok ) {
        ok = !PP_Init( name, flags, inc_path );
        if( !ok ) {
            WREDisplayErrorMsg( WRE_NOLOADHEADERFILE );
        }
    }

    if( ok ) {
        pp_count = 0;
        busy_count = 0;
        busy_str[1] = '\0';
        do {
            pp_count++;
            c = PP_Char();
            if( pp_count == MAX_PP_CHARS ) {
                busy_count++;
                busy_str[0] = WREBusyChars[busy_count % 4];
                WRESetStatusText( NULL, busy_str, TRUE );
                pp_count = 0;
            }
        } while( c != EOF );
        if( *table == NULL ) {
            *table = WRInitHashTable();
        }
        WREAddSymbols( *table );
        WRMakeHashTableClean( *table );
        PP_Fini();
        WRESetStatusText( NULL, " ", TRUE );
    }

    if( !ok ) {
        if( name != NULL ) {
            WRMemFree( name );
            name = NULL;
        }
    }

    WRESetWaitCursor( FALSE );

    WRESetStatusReadyText();

    return( name );
}
Exemplo n.º 6
0
char *WLoadSymbols( WRHashTable **table, char *file_name, HWND parent, bool prompt )
{
    char                *name;
    int                 c;
    unsigned            flags;
    char                *inc_path;
    WGetFileStruct      gf;
    bool                ret;
    bool                ok;

    name = NULL;

    ok = (table != NULL);

    if( ok ) {
        if( file_name == NULL || prompt ) {
            gf.file_name = file_name;
            gf.title = AllocRCString( W_LOADSYMTITLE );
            gf.filter = AllocRCString( W_SYMFILTER );
            WMassageFilter( gf.filter );
            name = WGetOpenFileName( parent, &gf );
            if( gf.title != NULL ) {
                FreeRCString( gf.title );
            }
            if( gf.filter != NULL ) {
                FreeRCString( gf.filter );
            }
        } else {
            name = WStrDup( file_name );
        }
        ok = (name != NULL);
    }

    WSetWaitCursor( parent, TRUE );

    if( ok ) {
        flags = PPFLAG_IGNORE_INCLUDE | PPFLAG_EMIT_LINE;
        inc_path = NULL;
        ret = setjmp( SymEnv ) != 0;
        if( ret ) {
            PP_Fini();
            WDisplayErrorMsg( W_SYMOUTOFMEM );
            ok = false;
        }
    }

    if( ok ) {
        ok = !PP_Init( name, flags, inc_path );
        if( !ok ) {
            WDisplayErrorMsg( W_NOOPENSYMFILE );
        }
    }

    if( ok ) {
        do {
            c = PP_Char();
        } while( c != EOF );
        if( *table == NULL ) {
            *table = WRInitHashTable();
        }
        addSymbols( *table );
        WRMakeHashTableClean( *table );
        PP_Fini();
    }

    if( !ok ) {
        if( name != NULL ) {
            WRMemFree( name );
            name = NULL;
        }
    }

    WSetWaitCursor( parent, FALSE );

    return( name );
}
Exemplo n.º 7
0
static bool scanEnvVarOrFile( const char *name )
/**********************************************/
{
    /*
     * Pass nofilenames and analysis of getenv(name) into argc and argv
     * to doScanParams. Return view on usability of data. (true is usable.)
     *
     * Recursion is supported but circularity is rejected.
     */
    typedef struct VarInfo {
        struct VarInfo      *next;
        char                *name;
        char                **argv; /* points into buf */
        char                buf[1]; /* dynamic array */
    } VarInfo;

    int                 argc;
    VarInfo             *info;
    static VarInfo      *stack = NULL;  // Needed to detect recursion.
    size_t              argvsize;
    size_t              argbufsize;
    const char          *optstring;
    size_t              varlen;         // size to hold name copy.
    bool                result;         // doScanParams Result.
    char                fbuf[512];

    optstring = PP_GetEnv( name );
    if( optstring == NULL ) {
        FILE *fh;

        fh = fopen( name, "rt" );
        if( fh == NULL ) {
//            RcWarning( ERR_ENV_VAR_NOT_FOUND, name );
            return( true );
        }
        fgets( fbuf, sizeof( fbuf ), fh );
        fclose( fh );
        optstring = fbuf;
    }
    // This used to cause stack overflow: set foo=@foo && wrc @foo.
    for( info = stack; info != NULL; info = info->next ) {
#if defined( __UNIX__ )
        if( strcmp( name, info->name ) == 0 ) {     // Case-sensitive
#else
        if( stricmp( name, info->name ) == 0 ) {    // Case-insensitive
#endif
//            RcFatalError( ERR_RCVARIABLE_RECURSIVE, name );
        }
    }
    argc = ParseVariable( optstring, NULL, NULL );  // count parameters.
    argbufsize = strlen( optstring ) + 1 + argc;    // inter-parameter spaces map to 0
    argvsize = argc * sizeof( char * );             // sizeof argv[argc+1]
    varlen = strlen( name ) + 1;                    // Copy taken to detect recursion.
    info = malloc( sizeof( *info ) + argbufsize + argvsize + varlen );
    info->next = stack;
    stack = info;                                   // push info on stack
    info->argv = (char **)info->buf;
    ParseVariable( optstring, info->argv, info->buf + argvsize );
    info->name = info->buf + argvsize + argbufsize;
    strcpy( info->name, name );
    result = doScanParams( argc, info->argv );

    stack = info->next;                             // pop stack
    free( info );
    return( result );
}

static bool doScanParams( int argc, char *argv[] )
/************************************************/
{
    const char  *arg;
    int         switchchar;
    bool        contok;         /* continue with main execution */
    int         currarg;

    contok = true;
    switchchar = _dos_switch_char();
    for( currarg = 0; currarg < argc && contok; currarg++ ) {
        arg = argv[currarg];
        if( *arg == switchchar || *arg == '-' ) {
            contok = ScanOptionsArg( arg + 1 ) && contok;
        } else if( *arg == '@' ) {
            contok = scanEnvVarOrFile( arg + 1 ) && contok;
        } else if( *arg == '?' ) {
            wcpp_quit( usageMsg, NULL );
//            contok = false;
        } else {
            filenames = realloc( (void *)filenames, ( nofilenames + 1 ) * sizeof( char * ) );
            filenames[nofilenames++] = my_strdup( arg );
        }
    }
    return( contok );
}

int main( int argc, char *argv[] )
{
    int         ch;
    int         i;
    int         j;
    int         rc;
    FILE        *fo;

    if( argc < 2 ) {
        wcpp_quit( usageMsg, "No filename specified\n" );
    } else if( argc == 2 ) {
        if( !strcmp( argv[1], "?" ) ) {
            wcpp_quit( usageMsg, NULL );
        }
    }

    PP_IncludePathInit();

    rc = EXIT_FAILURE;
    if( doScanParams( argc - 1, argv + 1 ) && nofilenames != 0 ) {
        PP_Init( '#' );
        fo = stdout;
        if( out_filename != NULL ) {
            fo = fopen( out_filename, "wb" );
        }
        rc = EXIT_SUCCESS;
        for( i = 0; i < nofilenames; ++i ) {
            if( PP_FileInit( filenames[i], flags, NULL ) != 0 ) {
                fprintf( stderr, "Unable to open '%s'\n", filenames[i] );
                rc = EXIT_FAILURE;
                break;
            }
            for( j = 0; j < numdefs; j++ ) {
                PP_Define( defines[j] );
            }
            for( ;; ) {
                ch = PP_Char();
                if( ch == EOF )
                    break;
#ifndef __UNIX__
                if( ch == '\n' )
                    fputc( '\r', fo );
#endif
                fputc( ch, fo );
            }
            PP_FileFini();
        }
        if( fo == stdout ) {
            fflush( fo );
        } else if( fo != NULL ) {
            fclose( fo );
        }
        PP_Fini();
    }

    if( out_filename != NULL ) {
        free( out_filename );
    }
    for( i = 0; i < nofilenames; ++i ) {
        free( filenames[i] );
    }
    free( (void *)filenames );
    for( i = 0; i < numdefs; i++ ) {
        free( defines[i] );
    }
    free( (void *)defines );

    PP_IncludePathFini();

    if( rc == EXIT_FAILURE && nofilenames == 0 ) {
        wcpp_quit( usageMsg, "No filename specified\n" );
    }

    return( rc );
}