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 ); }