pch_status PCHReadSegments( void ) { char *src_suffix; char *dest_suffix; char *class_name; size_t class_name_len; size_t suffix_len; size_t len; size_t old_module_len; size_t curr_module_len; size_t extra; fe_seg_id sib_id; PC_SEGMENT *curr; curr_module_len = strlen( ModuleName ); old_module_len = PCHReadUInt(); extra = 0; if( curr_module_len > old_module_len ) { extra = curr_module_len - old_module_len; } PCHRead( &seg_max, sizeof( seg_max ) ); PCHRead( &dgroup_size, sizeof( dgroup_size ) ); RingFree( &seg_list ); for(;;) { len = PCHReadUInt(); if( len == 0 ) break; curr = CMemAlloc( len + extra ); PCHRead( curr, len ); if( curr->module_prefix ) { if( old_module_len != curr_module_len ) { suffix_len = len; suffix_len -= sizeof( PC_SEGMENT ) - sizeof( char ); suffix_len -= old_module_len; src_suffix = &(curr->name[old_module_len]); dest_suffix = &(curr->name[curr_module_len]); memmove( dest_suffix, src_suffix, suffix_len ); } memcpy( curr->name, ModuleName, curr_module_len ); } curr->label = SymbolMapIndex( curr->label ); class_name_len = (size_t) curr->class_name; if( class_name_len != 0 ) { class_name = CPermAlloc( class_name_len ); PCHRead( class_name, class_name_len ); } else { class_name = NULL; } curr->class_name = class_name; RingAppend( &seg_list, curr ); } RingIterBeg( seg_list, curr ) { sib_id = (fe_seg_id) curr->sibling; if( sib_id != curr->seg_id ) { curr->sibling = segIdLookup( sib_id ); } else { curr->sibling = curr; } }
pch_status PCHReadFrontData( void ) { CGFILE *tmp_cgfile; PCHRead( &tmp_cgfile, sizeof( tmp_cgfile ) ); dataCGFILE = CGFileMapIndex( tmp_cgfile ); PCHRead( &tmp_cgfile, sizeof( tmp_cgfile ) ); codeCGFILE = CGFileMapIndex( tmp_cgfile ); return( PCHCB_OK ); }
static unsigned doReadUnsigned( void ) /************************************/ { unsigned read_value; PCHRead( &read_value, sizeof( read_value ) ); return( read_value ); }
static void alignPCH( unsigned i, bool writing ) { unsigned skip; char dummy[PCH_ALIGN] = {0}; if( writing ) { skip = - cursorWriteFilePosition(); skip &= PCH_ALIGN - 1; PCHWriteUInt( skip ); DbgAssert( skip == 0 ); if( skip != 0 ) { PCHWrite( dummy, skip ); } } else { skip = PCHReadUInt(); if( skip != 0 ) { PCHRead( dummy, skip ); } } #ifndef NDEBUG if( writing ) { unsigned w = -i; PCHWriteUInt( w ); } else { unsigned r; r = PCHReadUInt(); if( r != -i ) { printf( "index = %u\n", i ); CFatal( "pre-compiled header read/write out of synch" ); } } #else i = i; #endif }
static void readAuxInfo( AUX_INFO *i ) { unsigned len; PCHReadVar( *i ); AsmSysPCHReadCode( i ); len = PCHGetUInt( i->parms ); if( len != 0 ) { i->parms = CMemAlloc( len ); PCHRead( i->parms, len ); } len = PCHGetUInt( i->objname ); if( len != 0 ) { i->objname = CMemAlloc( len ); PCHRead( i->objname, len ); } }
static char *readFileString( char *buff ) { unsigned len; // assumes 'buff' is at least _MAX_PATH bytes len = PCHReadUInt(); return( PCHRead( buff, len ) ); }
pch_status PCHReadVerify( void ) /******************************/ { char buff[10]; pchDebugInfoName = NamePCHRead(); PCHRead( buff, 10 ); if( memcmp( buff, "WATCOM-PCH", 10 ) != 0 ) { return( PCHCB_ERROR ); } return( PCHCB_OK ); }
void CgInfoLibPCHRead( void ) /***************************/ { size_t len; LIB_LIST *lib_entry; CgInfoFreeLibs(); for(;;) { len = PCHReadUInt(); if( len == 0 ) break; lib_entry = CMemAlloc( len ); PCHRead( lib_entry, len ); RingAppend( &libRing, lib_entry ); } }
void AsmSysPCHReadCode( AUX_INFO *info ) /**************************************/ { byte *p; byte *s; byte_seq *code; unsigned fixup; SYMBOL sym; byte_seq_len seq_size; byte_seq_len code_length; seq_size = PCHReadUInt(); if( seq_size == 0 ) { info->code = NULL; return; } code = CMemAlloc( seq_size ); info->code = code; PCHRead( code, seq_size ); if(( code->length & DO_FLOATING_FIXUPS ) == 0 ) { /* code has no relocs */ return; } code_length = code->length & MAX_BYTE_SEQ_LEN; p = code->data; s = code->data + code_length; while( p != s ) { if( p[0] == FLOATING_FIXUP_BYTE ) { fixup = p[1]; p += 2; if( fixup != FLOATING_FIXUP_BYTE ) { switch( fixup ) { case FIX_SYM_OFFSET: case FIX_SYM_SEGMENT: case FIX_SYM_RELOFF: sym = SymbolMapIndex( *((SYMBOL*)p) ); copyCodeLen( p, &sym, sizeof( sym ) ); p += sizeof( SYMBOL ) + sizeof( unsigned long ); break; default: break; } } } else { ++p; } } }
static void readExtrefs( void ) { SYMBOL sym; unsigned len; PRAG_EXT_REF *entry; RingFree( &pragmaExtrefs ); while( (sym = SymbolPCHRead()) != NULL ) { entry = RingAlloc( &pragmaExtrefs, offsetof( PRAG_EXT_REF, name ) + 1 ); entry->symbol = sym; entry->name[0] = '\0'; } while( (len = PCHReadUInt()) != 0 ) { entry = RingAlloc( &pragmaExtrefs, offsetof( PRAG_EXT_REF, name ) + len + 1 ); PCHRead( entry->name, len + 1 ); entry->symbol = NULL; } }
pch_status PCHReadPragmas( void ) { unsigned size; unsigned max_index; unsigned entry_len; unsigned index; AUX_ENTRY *e; AUX_ENTRY *f; AUX_ENTRY *next_f; AUX_INFO *info; for( f = AuxList; f != NULL; f = next_f ) { next_f = f->next; freeAuxInfo( f->info ); CMemFree( f->info ); CMemFree( f ); } max_index = PCHReadUInt(); size = max_index * sizeof( AUX_INFO * ); infoTranslate = CMemAlloc( size ); memset( infoTranslate, 0, size ); // read all aux_info for( index = PCH_FIRST_INDEX; index < max_index; ++index ) { if( index < PCH_FIRST_USER_INDEX ) { info = BuiltinAuxInfo + index - PCH_FIRST_INDEX; } else { info = CMemAlloc( sizeof( AUX_INFO ) ); } infoTranslate[index] = info; readAuxInfo( info ); } // read aux entries AuxList = NULL; for( ; (entry_len = PCHReadUInt()) != 0; ) { e = CMemAlloc( offsetof( AUX_ENTRY, name ) + entry_len + 1 ); PCHRead( e->name, entry_len + 1 ); e->info = PragmaMapIndex( PCHSetUInt( PCHReadUInt() ) ); e->next = AuxList; AuxList = e; } return( PCHCB_OK ); }
pch_status PCHReadConstantPool( void ) { unsigned len; POOL_CON *c; auto cvinit_t data; pool_float = ConstantPoolPCHRead(); pool_int64 = ConstantPoolPCHRead(); CarveInitStart( carvePOOL_CON, &data ); for( ; (c = PCHReadCVIndexElement( &data )) != NULL; ) { PCHReadVar( *c ); c->next = ConstantPoolMapIndex( c->next ); if( c->flt ) { len = c->u.s.len; c->u.s.fp_constant = CPermAlloc( len ); PCHRead( c->u.s.fp_constant, len ); } } return( PCHCB_OK ); }
pch_status PCHReadNames( void ) { unsigned len; idname **p; idname **head; idname *name; memset( hashTable, 0, sizeof( hashTable ) ); PCHReadVar( nameCount ); PCHReadVar( nameDummyIndex ); nameTranslateTable = CMemAlloc( nameCount * sizeof( idname * ) ); p = nameTranslateTable; for( ; (len = PCHReadUInt()) != 0; ) { name = CPermAlloc( NAME_SIZE + len + 1 ); PCHRead( &(name->xhash), NAME_SIZE_PCH + len + 1 ); head = &hashTable[ name->hash ]; name->next = *head; *head = name; *p++ = name; } return( PCHCB_OK ); }