wf77aux.c

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

        }
    }
    new_arr = FMemAlloc( sizeof( arr_info ) + arr_len );
    new_arr->link = NULL;
    memcpy( &new_arr->arr, arr_name, arr_len );
    new_arr->arr[arr_len] = NULLCHAR;
    *arr = new_arr;
}
#endif

void    AddDependencyInfo( source_t *fi ) {
//=======================================

// Add dependency information for an included file.

    char        *p;
    dep_info    **dep;
    dep_info    *new_dep;
    struct stat stat_info;
    char        buff[MAX_FILE];

    p = _fullpath( buff, fi->name, MAX_FILE );
    if( p != NULL ) {
        for( dep = &DependencyInfo; *dep != NULL; dep = &(*dep)->link ) {
            if( strcmp( &(*dep)->fn, p ) == 0 ) {
                return;
            }
        }
        if( fstat( ((a_file *)(fi->fileptr))->handle, &stat_info ) != -1 ) {
            new_dep = FMemAlloc( sizeof( dep_info ) + strlen( p ) );
            new_dep->link = NULL;
            strcpy( &new_dep->fn, p );
            new_dep->time_stamp = stat_info.st_mtime;
            *dep = new_dep;
        }
    }
}


static  void    AddDefaultLib( char *lib_ptr, int lib_len, char priority ) {
//==========================================================================

    default_lib         **lib;
    default_lib         *new_lib;

    if( !( Options & OPT_DFLT_LIB ) )
        return;
    if( ( *lib_ptr == '"' ) && ( lib_ptr[lib_len - 1] == '"' ) ) {
        lib_len -= 2;
        ++lib_ptr;
    }
    for( lib = &DefaultLibs; *lib != NULL; lib = &(*lib)->link ) {
        if( strlen( &(*lib)->lib[1] ) != lib_len )
            continue;
        if( memcmp( &(*lib)->lib[1], lib_ptr, lib_len ) == 0 ) {
            return;
        }
    }
    new_lib = FMemAlloc( sizeof( default_lib ) + lib_len );
    new_lib->link = NULL;
    new_lib->lib[0] = priority;
    memcpy( &new_lib->lib[1], lib_ptr, lib_len );
    new_lib->lib[1+lib_len] = NULLCHAR;
    *lib = new_lib;
}


void    DefaultLibInfo( void ) {
//========================

#if _CPU == 386
    if( CGOpts & CGOPT_STK_ARGS ) {
        if( CPUOpts & CPUOPT_FPC ) {
            AddDefaultLib( _flibs, _FLIBS, '1' );
            AddDefaultLib( _maths, _MATHS, '1' );
        } else {
            AddDefaultLib( _flib7s, _FLIB7S, '1' );
            AddDefaultLib( _math7s, _MATH7S, '1' );
        }
        AddDefaultLib( _clibs, _CLIBS, '1' );
        if( Options & OPT_RESOURCES ) {
            AddDefaultLib( _wresfs, _WRESFS, '1' );
        }
    } else {
        if( CPUOpts & CPUOPT_FPC ) {
            AddDefaultLib( _flib, _FLIB, '1' );
            AddDefaultLib( _math, _MATH, '1' );
        } else {
            AddDefaultLib( _flib7, _FLIB7, '1' );
            AddDefaultLib( _math7, _MATH7, '1' );
        }
        AddDefaultLib( _clib, _CLIB, '1' );
        if( Options & OPT_RESOURCES ) {
            AddDefaultLib( _wresf, _WRESF, '1' );
        }
    }
    if( CPUOpts & CPUOPT_FPI ) {
        AddDefaultLib( _emu387, _EMU387, '1' );
    } else if( CPUOpts & CPUOPT_FPI87 ) {
        AddDefaultLib( _noemu387, _NOEMU387, '1' );
    }
#elif _CPU == 8086
    if( CGOpts & CGOPT_M_MEDIUM ) {
        if( CPUOpts & CPUOPT_FPC ) {
            AddDefaultLib( _flibm, _FLIBM, '1' );
            AddDefaultLib( _mathm, _MATHM, '1' );
        } else {
            AddDefaultLib( _flib7m, _FLIB7M, '1' );
            AddDefaultLib( _math7m, _MATH7M, '1' );
        }
        AddDefaultLib( _clibm, _CLIBM, '1' );
        if( Options & OPT_RESOURCES ) {
            AddDefaultLib( _wresm, _WRESM, '1' );
        }
    } else {
        if( CPUOpts & CPUOPT_FPC ) {
            AddDefaultLib( _flibl, _FLIBL, '1' );
            AddDefaultLib( _mathl, _MATHL, '1' );
        } else {
            AddDefaultLib( _flib7l, _FLIB7L, '1' );
            AddDefaultLib( _math7l, _MATH7L, '1' );
        }
        AddDefaultLib( _clibl, _CLIBL, '1' );
        if( Options & OPT_RESOURCES ) {
            AddDefaultLib( _wresl, _WRESL, '1' );
        }
    }
    if( CPUOpts & CPUOPT_FPI ) {
        AddDefaultLib( _emu87, _EMU87, '1' );
    } else if( CPUOpts & CPUOPT_FPI87 ) {
        AddDefaultLib( _noemu87, _NOEMU87, '1' );
    }
#elif _CPU == _AXP
    AddDefaultLib( _flib, _FLIB, '1' );
    AddDefaultLib( _math, _MATH, '1' );
    AddDefaultLib( _clib, _CLIB, '1' );
    if( Options & OPT_RESOURCES ) {
        AddDefaultLib( _wresaxp, _WRESAXP, '1' );
    }
#elif _CPU == _PPC
    AddDefaultLib( _flib, _FLIB, '1' );
    AddDefaultLib( _math, _MATH, '1' );
    AddDefaultLib( _clib, _CLIB, '1' );
    if( Options & OPT_RESOURCES ) {
        AddDefaultLib( _wresppc, _WRESPPC, '1' );
    }
#else
  #error Unknown Platform
#endif
}


static  void    FreeAuxEntry( aux_info *aux ) {
//=============================================

    FreeAuxElements( aux );
    FMemFree( aux );
}


static  void    FreeAuxElements( aux_info *aux ) {
//================================================

    FreeArgList( aux );
    if( aux->parms != DefaultInfo.parms ) {
        FMemFree( aux->parms );
        aux->parms = DefaultInfo.parms;
    }
    if( aux->code != DefaultInfo.code ) {
        FMemFree( aux->code );
        aux->code = DefaultInfo.code;
    }
    if( aux->objname != DefaultInfo.objname ) {
        FMemFree( aux->objname );
        aux->objname = DefaultInfo.objname;
    }
}


static  void    FreeArgList( aux_info *aux ) {
//============================================

    FreeChain( &aux->arg_info );
}


aux_info        *NewAuxEntry( char *name, int name_len ) {
//========================================================

    aux_info    *aux;

    aux = FMemAlloc( sizeof( aux_info ) + name_len );
    aux->sym_len = name_len;
    memcpy( aux->sym_name, name, name_len );
    aux->sym_name[ name_len ] = NULLCHAR;
    aux->link = AuxInfo;
    aux->parms = DefaultInfo.parms;
    aux->code = DefaultInfo.code;
    aux->objname = DefaultInfo.objname;
    aux->arg_info = NULL;
    AuxInfo = aux;
    return( aux );
}


static  bool    CurrToken( char *tok ) {
//======================================

    char    *ptr;

    ptr = TokStart;
    for(;;) {
        if( ptr == TokEnd )
            break;
        if( toupper( *ptr ) != *tok )
            break;
        ptr++;
        tok++;
    }
    if( ( ptr == TokEnd ) && ( *tok == '\0' ) )
        return( TRUE );
    return( FALSE );
}


static  bool    RecToken( char *tok ) {
//=====================================

    if( CurrToken( tok ) ) {
        ScanToken();
        return( TRUE );
    }
    return( FALSE );
}

static  bool    RecFnToken( char *tok ) {
//=======================================

    if( CurrToken( tok ) ) {
        ScanFnToken();
        return( TRUE );
    }
    return( FALSE );
}



void            Pragma( void ) {
//========================

// Process a pragma.

#if ( _CPU == 8086 || _CPU == 386 )
    char        *arr;
    uint        arr_len;
#endif

    struct {
        unsigned f_far    : 1;
        unsigned f_far16  : 1;
        unsigned f_loadds : 1;
        unsigned f_export : 1;
        unsigned f_parm   : 1;
        unsigned f_value  : 1;
        unsigned f_modify : 1;
    } have;

    if( RecFnToken( "LIBRARY" ) ) {
        if( RecFnToken( "\0" ) ) {
            DefaultLibInfo();
        } else {
            while( !RecFnToken( "\0" ) ) {
                AddDefaultLib( TokStart, TokEnd - TokStart, '9' );
                ScanFnToken();
            }
        }
#if ( _CPU == 8086 || _CPU == 386 )
    } else if( RecToken( "ARRAY" ) ) {
        SymbolId();
        TokUpper();
        arr = TokStart;
        arr_len = TokEnd - TokStart;
        ScanToken();
#if _CPU == 386
        if( RecToken( "FAR" ) ) {
            if( _SmallDataModel( CGOpts ) ) {
                AddArrayInfo( arr, arr_len );
            }
        }
#elif _CPU == 8086
        if( RecToken( "FAR" ) ) {
            if( _SmallDataModel( CGOpts ) ) {
                AddArrayInfo( arr, arr_len );
            }
        } else if( RecToken( "HUGE" ) ) {
            if( CGOpts & CGOPT_M_LARGE ) {
                AddArrayInfo( arr, arr_len );
            }
        }
#endif
#endif
    } else {
        AliasInfo = &FortranInfo;
        if( RecToken( "LINKAGE" ) ) {
            ReqToken( "(" );
            SymbolName();
            ReqToken( "," );
            AliasName();
            ProcessAlias();
            ReqToken( ")" );
        } else {
            ReqToken( "AUX" );
            if( RecToken( "(" ) ) {
                AliasName();
                ReqToken( ")" );
            }
            SymbolName();
            ProcessAlias();
            ObjectName();

            have.f_far    = 0;
            have.f_loadds = 0;
            have.f_export = 0;
            have.f_value  = 0;
            have.f_modify = 0;
            have.f_parm   = 0;
            for( ;; ) {
                if( !have.f_parm && RecToken( "PARM" ) ) {
                    GetParmInfo();
                    have.f_parm = 1;
                } else if( !have.f_far && RecToken( "=" ) ) {
                    GetByteSeq();
#if ( _CPU == 8086 || _CPU == 386 )
                    have.f_far = 1;
                } else if( !have.f_far && RecToken( "FAR" ) ) {
                    CurrAux->cclass |= FAR;
                    have.f_far = 1;
#if _CPU == 386
                } else if( !have.f_far16 && RecToken( "FAR16" ) ) {
                    CurrAux->cclass |= FAR16_CALL;
                    have.f_far16 = 1;
#endif
                } else if( !have.f_far && RecToken( "NEAR" ) ) {
                    CurrAux->cclass &= ~FAR;
                    have.f_far = 1;
                } else if( !have.f_loadds && RecToken( "LOADDS" ) ) {
                    CurrAux->cclass |= LOAD_DS_ON_ENTRY;
                    have.f_loadds = 1;
#endif
                } else if( !have.f_export && RecToken( "EXPORT" ) ) {
                    CurrAux->cclass |= DLL_EXPORT;
                    have.f_export = 1;
#if ( _CPU == 8086 || _CPU == 386 )
                } else if( !have.f_value && RecToken( "VALUE" ) ) {
                    GetRetInfo();
                    have.f_value = 1;
#endif
                } else if( !have.f_value && RecToken( "ABORTS" ) ) {
                    CurrAux->cclass |= SUICIDAL;
                    have.f_value = 1;
#if ( _CPU == 8086 || _CPU == 386 )
                } else if( !have.f_modify && RecToken( "MODIFY" ) ) {
                    GetSaveInfo();
                    have.f_modify = 1;
#endif
                } else {
                    break;
                }
            }
        }
    }
}


void    DoPragma( char *ptr ) {
//=============================

    int         status;

    TokStart = ptr;
    TokEnd = ptr;
    ScanToken();
    for(;;) {
        status = Spawn( &Pragma );
        if( status != 0 ) {
            if( ProgSw & PS_FATAL_ERROR ) {
                Suicide();
            }
            AsmSymFini();
            break;
        }
        if( RecToken( "\0" ) ) {
            break;
        }
    }
}


void    ProcPragma( char *ptr ) {
//===============================

    // don't process auxiliary pragma's until pass 2
    if( ProgSw & PS_DONT_GENERATE )
        return;
    DoPragma( ptr );
}


static  void    ScanToken( void ) {
//===========================

    char    *ptr;
    int     found_token;
    int     first;

    ptr = TokEnd;
    ptr = SkipBlanks( ptr );
    TokStart = ptr;
    first = TRUE;
    found_token = FALSE;
    for(;;) {
        switch( *ptr ) {
        case ' ' :
        case '\t' :
        case '\0' :
            found_token = TRUE;
            break;
        case '"' :
            if( first ) {
                for(;;) {
                    ++ptr;
                    if( *ptr == '\0' )
                        break;
                    if( *ptr == '"' ) {
                        ++ptr;
                        break;
                    }
                }