void CmdSysFini( void )
/*********************/
{
CMemFreePtr( &ModuleName );
CMemFreePtr( &CodeClassName );
CMemFreePtr( &DataSegName );
CMemFreePtr( &GenCodeGroup );
}
static void freeInfo( AUX_INFO *info )
{
if( info->code != NULL ) {
CMemFreePtr( &info->code );
}
if( !IsAuxParmsBuiltIn( info->parms ) ) {
CMemFreePtr( &info->parms );
}
if( info->objname != NULL ) {
CMemFreePtr( &info->objname );
}
}
pch_status PCHFiniPragmas( bool writing )
{
if( !writing ) {
CMemFreePtr( &infoTranslate );
}
return( PCHCB_OK );
}
static void handleOptionFC( OPT_STORAGE *data, int value )
{
value = value;
if( data->fc ) {
data->fc = FALSE;
if( CompFlags.batch_file_primary ) {
if( CompFlags.batch_file_processing ) {
BadCmdLine( ERR_FC_IN_BATCH_FILE );
} else {
BadCmdLine( ERR_FC_MORE_THAN_ONCE );
}
} else {
CompFlags.batch_file_primary = TRUE;
if( CompFlags.batch_file_processing ) {
VBUF buf;
if( CmdLnBatchRead( &buf ) ) {
CmdLnCtxPush( CTX_CLTYPE_FC );
procOptions( data, VbufString( &buf ) );
CmdLnCtxPop();
}
CmdLnBatchFreeRecord( &buf );
} else {
CmdLnBatchOpen( data->fc_value->data );
CMemFreePtr( &data->fc_value );
}
}
}
}
static void hfileFini( // FREE HFILE LIST
INITFINI* defn ) // - definition
{
/* unused parameters */ (void)defn;
CMemFreePtr( &hfile_list );
}
static void fini( // FINALIZATION
INITFINI* defn ) // - definition
{
defn = defn;
CMemFreePtr( &ObjectFileName );
CmdSysFini();
}
pch_status PCHFiniNames( bool writing )
{
writing = writing;
nameFlags.no_creates_allowed = FALSE;
CMemFreePtr( &nameTranslateTable );
return( PCHCB_OK );
}
void DwioBuffFini( // BUFFERING COMPLETION
void )
{
if( NULL != beingWritten ) {
CMemFreePtr( &beingWritten );
}
RingFree( &freeBufs );
}
static char* brinfPchGetBuffer // GET BUFFER FOR READ
( BRI_PCH_CTL* ctl // - control
, unsigned size ) // - size required
{
if( size > ctl->bsize ) {
CMemFreePtr( &ctl->buffer );
ctl->buffer = CMemAlloc( ( size + 1024 - 1 ) & -1024 );
}
return ctl->buffer;
}
static void cgfrontInit( // INITIALIZE FOR FRONT-END CODE GENERATION
INITFINI* defn ) // - definition
{
char seg_name[30]; // - computed segment name
defn = defn;
if( *TextSegName == '\0' ) {
if( TargetSwitches & BIG_CODE ) {
stpcpy( stpcpy( seg_name, ModuleName ), TS_SEG_CODE );
} else {
stpcpy( seg_name, TS_SEG_CODE );
}
CMemFreePtr( &TextSegName );
TextSegName = strsave( seg_name );
}
SegmentInit( TextSegName );
codeCGFILE = NULL;
dataCGFILE = CgioCreateFile( NULL );
emitDataCGFILE = &dataCGFILE;
flags.init_data_beg = FALSE;
flags.init_data_end = FALSE;
}
void CgFrontFini( // release any memory used
void )
{
CMemFreePtr( &TextSegName );
}
pch_absorb PCHeaderAbsorb( char *include_file )
/*********************************************/
{
pch_absorb ret;
int status;
auto jmp_buf restore_state;
#ifndef NDEBUG
clock_t start;
clock_t stop;
start = clock();
#endif
if( ErrCount != 0 ) {
return( PCHA_ERRORS_PRESENT );
}
if( CompFlags.fhw_switch_used ) {
return( PCHA_IGNORE );
}
pchFile = sopen3( PCHFileName(), O_RDONLY | O_BINARY, SH_DENYWR );
if( pchFile == -1 ) {
return( PCHA_NOT_PRESENT );
}
ioBuffer = CMemAlloc( IO_BUFFER_SIZE );
pch_buff_eob = ioBuffer + IO_BUFFER_SIZE;
pch_buff_cur = pch_buff_eob;
ret = PCHA_OK;
abortData = &restore_state;
status = setjmp( restore_state );
if( status == 0 ) {
if( initialRead() == 0 ) {
ret = PCHA_NOT_PRESENT;
} else {
auto precompiled_header_header header;
#ifdef OPT_BR
unsigned long br_posn;
#endif
PCHReadVar( header );
#ifdef OPT_BR
br_posn = header.browse_info;
#endif
if( headerIsOK( &header ) ) {
if( ! stalePCH( include_file ) ) {
execInitFunctions( false );
execControlFunctions( false, readFunctions );
execFiniFunctions( false );
#ifdef OPT_BR
if( 0 != br_posn ) {
BrinfPchRead();
}
#endif
} else {
ret = PCHA_STALE;
}
} else {
pchWarn( WARN_PCH_CONTENTS_HEADER_ERROR );
ret = PCHA_HEADER;
}
}
} else {
CErr1( ERR_PCH_READ_ERROR );
}
abortData = NULL;
CMemFreePtr( &ioBuffer );
close( pchFile );
if( CompFlags.pch_debug_info_opt && ret == PCHA_OK ) {
CompFlags.pch_debug_info_read = true;
}
#ifndef NDEBUG
stop = clock();
printf( "%u ticks to load pre-compiled header\n", (unsigned)( stop - start ) );
#endif
return( ret );
}
void PCHeaderCreate( char *include_file )
/***************************************/
{
char * volatile pch_fname; // must be preserved by setjmp()
int status;
auto jmp_buf restore_state;
#ifndef NDEBUG
clock_t start;
clock_t stop;
start = clock();
#endif
if( ErrCount != 0 ) {
return;
}
if( CompFlags.fhr_switch_used ) {
// treat any .PCH as read-only (do not create one)
return;
}
pch_fname = PCHFileName();
pchFile = sopen4( pch_fname, O_RDWR | O_BINARY | O_CREAT | O_TRUNC, SH_DENYRW, PMODE_RW );
if( pchFile == -1 ) {
CErr2p( ERR_PCH_CREATE_ERROR, pch_fname );
return;
}
bufferPosition = 0;
ioBuffer = CMemAlloc( IO_BUFFER_SIZE );
bufferCursor = ioBuffer;
amountLeft = IO_BUFFER_SIZE;
abortData = &restore_state;
status = setjmp( restore_state );
if( status == 0 ) {
unsigned long brinf_posn;
if( CompFlags.pch_debug_info_opt ) {
pchDebugInfoName = CppPCHDebugInfoName( include_file );
}
dumpHeader();
dumpCheckData( include_file );
execInitFunctions( true );
execControlFunctions( true, writeFunctions );
execFiniFunctions( true );
brinf_posn = BrinfPch( pchFile );
PCHFlushBuffer();
// keep this PCH file
pch_fname = NULL;
setOKHeader( brinf_posn );
} else {
CErr1( ERR_PCH_WRITE_ERROR );
}
abortData = NULL;
CMemFreePtr( &ioBuffer );
close( pchFile );
if( pch_fname != NULL ) {
// write error occurred; delete PCH file
remove( pch_fname );
} else {
if( CompFlags.pch_debug_info_opt ) {
CompFlags.pch_debug_info_write = true;
CompFlags.all_debug_type_names = true;
}
}
#ifndef NDEBUG
stop = clock();
printf( "%u ticks to parse header\n", (unsigned)( start - start_parse ) );
printf( "%u ticks to save pre-compiled header\n", (unsigned)( stop - start ) );
#endif
}
static void pchFini( INITFINI* defn )
{
defn = defn;
CMemFreePtr( &pchName );
}
void PCHPerformReloc( pch_reloc_index ri )
/****************************************/
{
long start_position;
long stop_position;
unsigned reloc_size;
char *volatile pch_fname; // must be preserved by setjmp()
int status;
jmp_buf restore_state;
#ifndef NDEBUG
clock_t start;
clock_t stop;
start = clock();
#endif
if( ErrCount != 0 ) {
return;
}
start_position = relocInfo[ ri ].start;
if( start_position == 0 ) {
return;
}
stop_position = relocInfo[ ri ].stop;
pch_fname = PCHFileName();
pchFile = sopen3( pch_fname, O_RDWR | O_BINARY | O_EXCL, SH_DENYRW );
if( pchFile == -1 ) {
CErr2p( ERR_PCH_OPEN_ERROR, pch_fname );
return;
}
DbgAssert( ( stop_position - start_position ) < UINT_MAX );
reloc_size = stop_position - start_position;
ioBuffer = CMemAlloc( reloc_size );
abortData = &restore_state;
status = setjmp( restore_state );
if( status == 0 ) {
if( lseek( pchFile, start_position, SEEK_SET ) != start_position ) {
fail();
}
if( read( pchFile, ioBuffer, reloc_size ) != reloc_size ) {
fail();
}
if( relocFunctions[ri]( ioBuffer, reloc_size ) == PCHCB_ERROR ) {
fail();
}
if( lseek( pchFile, -(long)reloc_size, SEEK_CUR ) != start_position ) {
fail();
}
if( write( pchFile, ioBuffer, reloc_size ) != reloc_size ) {
fail();
}
// keep this PCH file
pch_fname = NULL;
} else {
CErr1( ERR_PCH_WRITE_ERROR );
}
abortData = NULL;
CMemFreePtr( &ioBuffer );
close( pchFile );
if( pch_fname != NULL ) {
// write error occurred; delete PCH file
remove( pch_fname );
}
#ifndef NDEBUG
stop = clock();
printf( "%u ticks to relocate pre-compiled header (%u section)\n", (unsigned)( stop - start ), ri );
#endif
}
static void hfileFini( // FREE HFILE LIST
INITFINI* defn ) // - definition
{
defn = defn;
CMemFreePtr( &hfile_list );
}
static BRI_PCH_CTL* brinfPchFini // COMPLETION OF CONTROL INFO
( BRI_PCH_CTL* ctl ) // - control
{
CMemFreePtr( &ctl->buffer );
return ctl;
}
static void macroStorageFree( MACRO_SEG_LIST **seglist, MEPTR **hashtab )
{
CMemFreePtr( hashtab );
RingFree( seglist );
}
