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