static void writeAuxInfo( AUX_INFO *info, unsigned index )
{
hw_reg_set *regs;
hw_reg_set *save_parms;
char *save_objname;
unsigned len;
info->index = index;
save_parms = info->parms;
save_objname = info->objname;
if( save_parms != NULL ) {
len = 0;
regs = save_parms;
for(;;) {
len += sizeof( hw_reg_set );
if( HW_CEqual( *regs, HW_EMPTY ) ) break;
++regs;
}
info->parms = PCHSetUInt( len );
}
if( save_objname != NULL ) {
info->objname = PCHSetUInt( strlen( save_objname ) + 1 );
}
PCHWriteVar( *info );
AsmSysPCHWriteCode( info );
if( save_parms != NULL ) {
PCHWrite( save_parms, PCHGetUInt( info->parms ) );
}
if( save_objname != NULL ) {
PCHWrite( save_objname, PCHGetUInt( info->objname ) );
}
info->parms = save_parms;
info->objname = save_objname;
}
AUX_INFO *PragmaMapIndex( AUX_INFO *i )
{
if( PCHGetUInt( i ) < PCH_FIRST_INDEX ) {
return( NULL );
}
return( infoTranslate[PCHGetUInt( i )] );
}
NAME NameMapIndex( NAME index )
/*****************************/
{
if( PCHGetUInt( index ) < PCH_FIRST_INDEX ) {
return( NULL );
}
#ifndef NDEBUG
if( PCHGetUInt( index ) >= nameCount + PCH_FIRST_INDEX ) {
CFatal( "invalid name index" );
}
#endif
return( NAME_RETVAL( nameTranslateTable[ PCHGetUInt( index ) - PCH_FIRST_INDEX ] ) );
}
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 );
}
}
pch_status PCHWriteRTFNames( void )
{
NAME *name;
for( name = runTimeCodeName; name < &runTimeCodeName[ RTF_LAST ]; ++name ) {
PCHWriteUInt( PCHGetUInt( NameGetIndex( *name ) ) );
}
return( PCHCB_OK );
}
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;
}
PCHReadVar( seg_max );
PCHReadVar( dgroup_size );
RingFree( &seg_list );
for( ; (len = PCHReadUInt()) != 0; ) {
curr = CMemAlloc( len + extra );
PCHRead( curr, len );
if( curr->module_prefix ) {
if( old_module_len != curr_module_len ) {
suffix_len = len;
suffix_len -= offsetof( PC_SEGMENT, name );
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 = PCHGetUInt( 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)(pointer_int)curr->sibling;
if( sib_id != curr->seg_id ) {
curr->sibling = segIdLookup( sib_id );
} else {
curr->sibling = curr;
}
} RingIterEnd( curr )
pch_status PCHWritePragmas( void )
{
unsigned index;
unsigned len;
AUX_INFO *info;
AUX_ENTRY *e;
// get aux_info count
for( e = AuxList; e != NULL; e = e->next ) {
e->info->index = PCH_NULL_INDEX;
}
index = PCH_FIRST_USER_INDEX;
for( e = AuxList; e != NULL; e = e->next ) {
if( e->info->index == PCH_NULL_INDEX ) {
e->info->index = index++;
}
}
PCHWriteUInt( index );
for( e = AuxList; e != NULL; e = e->next ) {
e->info->index = PCH_NULL_INDEX;
}
// write built-in aux_info
for( index = PCH_FIRST_INDEX; index < PCH_FIRST_USER_INDEX; ++index ) {
info = BuiltinAuxInfo + index - PCH_FIRST_INDEX;
writeAuxInfo( info, index );
}
// write user aux_info
for( e = AuxList; e != NULL; e = e->next ) {
info = e->info;
if( info->index == PCH_NULL_INDEX ) {
writeAuxInfo( info, index++ );
}
}
// write aux entries
for( e = AuxList; e != NULL; e = e->next ) {
len = strlen( e->name );
PCHWriteUInt( len );
PCHWrite( e->name, len + 1 );
PCHWriteUInt( PCHGetUInt( PragmaGetIndex( e->info ) ) );
}
PCHWriteUInt( 0 );
return( PCHCB_OK );
}
