static segment_id AddSeg( const char *segname, const char *class_name, int segtype )
{
seg_name *seg;
user_seg *useg, **lnk;
hw_reg_set reg;
const char *p;
size_t len;
len = strlen( segname ) + 1;
for( seg = &Predefined_Segs[0]; seg->name != NULL; seg++ ) {
if( memcmp( segname, seg->name, len ) == 0 ) {
return( seg->segid );
}
}
HW_CAsgn( reg, HW_EMPTY );
for( p = segname; *p != '\0'; ++p ) {
if( *p == ':' ) {
reg = PragRegName( segname, p - segname );
segname = p + 1;
len = strlen( segname ) + 1;
break;
}
}
for( lnk = &userSegments; (useg = *lnk) != NULL; lnk = &useg->next ) {
if( memcmp( segname, useg->name, len ) == 0 ) {
return( useg->segid ); /* was return( segment ) */
}
}
useg = AllocUserSeg( segname, class_name, segtype );
useg->next = *lnk;
useg->pegged_register = reg;
*lnk = useg;
return( useg->segid );
}
hw_reg_set PragRegList( // GET PRAGMA REGISTER SET
void )
{
hw_reg_set res; // - resultant set
hw_reg_set reg; // - current set
TOKEN close_token; // - ending delimiter
HW_CAsgn( res, HW_EMPTY );
if( CurToken == T_LEFT_BRACKET ) {
close_token = T_RIGHT_BRACKET;
} else if( CurToken == T_LEFT_BRACE ) {
close_token = T_RIGHT_BRACE;
} else {
return( res );
}
PPCTL_ENABLE_MACROS();
NextToken();
for( ; CurToken != close_token; ) {
reg = PragRegName( Buffer, strlen( Buffer ) );
HW_TurnOn( res, reg );
NextToken();
}
PPCTL_DISABLE_MACROS();
MustRecog( close_token );
return( res );
}
hw_reg_set PragRegList( void )
/****************************/
{
hw_reg_set res, reg;
TOKEN close;
char buf[ 80 ];
HW_CAsgn( res, HW_EMPTY );
HW_CAsgn( reg, HW_EMPTY );
close = PragRegSet();
if( close != T_NULL ) {
PPCTL_ENABLE_MACROS();
NextToken();
*buf = '\0';
for( ; CurToken != close; ) {
strcat( buf, Buffer );
if( CurToken != T_BAD_CHAR ) {
reg = PragRegName( buf );
HW_TurnOn( res, reg );
*buf = '\0';
}
NextToken();
}
PPCTL_DISABLE_MACROS();
MustRecog( close );
}
return( res );
}
static PC_SEGMENT *segmentDefine(// SEGMENT: DEFINE IF REQUIRED
const char *seg_name, // - segment name
const char *class_name, // - segment class name
fe_seg_id seg_id, // - segment id (if not SEG_NULL)
unsigned attrs, // - segment attributes
unsigned control ) // - segmentAlloc control mask
{
PC_SEGMENT *curr; // - current segment
struct seg_look lk; // - look-up structure
#if _INTEL_CPU
const char* pc_reg; // - scans register bound to segment
char pc_reg_name[8]; // - name of pc register
for( pc_reg = seg_name; ; ++pc_reg ) {
if( *pc_reg == '\0' ) {
pc_reg_name[0] = '\0';
break;
}
if( *pc_reg == ':' ) {
stvcpy( pc_reg_name, seg_name, pc_reg - seg_name );
seg_name = pc_reg + 1;
break;
}
}
#endif
lk.seg_id = seg_id;
lk.use_seg_id = TRUE;
lk.attrs = attrs;
lk.use_attrs = TRUE;
lk.use_align = FALSE;
lk.use_sym_size_align = FALSE;
lk.seg_name = seg_name;
lk.class_name = class_name;
lk.use_name = TRUE;
lk.use_only_strings = FALSE;
curr = RingLookup( seg_list, &same_segment, &lk );
if( curr == NULL ) {
curr = segmentAlloc( lk.seg_name, lk.class_name, lk.seg_id, lk.attrs, control );
#if _INTEL_CPU
if( pc_reg_name[0] != '\0' ) {
curr->binding = PragRegName( pc_reg_name );
}
#endif
}
return curr;
}
static segment_id AddSeg( const char *segname, const char *class_name, int segtype )
{
int i;
user_seg *useg, **lnk;
#if _INTEL_CPU
hw_reg_set reg;
const char *p;
#endif
size_t len;
len = strlen( segname ) + 1;
for( i = 0; i < CArraySize( Predefined_Segs ); i++ ) {
if( memcmp( segname, Predefined_Segs[i].name, len ) == 0 ) {
return( Predefined_Segs[i].segid );
}
}
#if _INTEL_CPU
HW_CAsgn( reg, HW_EMPTY );
for( p = segname; *p != '\0'; ++p ) {
if( *p == ':' ) {
reg = PragRegName( segname, p - segname );
segname = p + 1;
len = strlen( segname ) + 1;
break;
}
}
#endif
for( lnk = &userSegments; (useg = *lnk) != NULL; lnk = &useg->next ) {
if( memcmp( segname, useg->name, len ) == 0 ) {
return( useg->segid ); /* was return( segment ) */
}
}
useg = AllocUserSeg( segname, class_name, segtype );
useg->next = *lnk;
#if _INTEL_CPU
useg->pegged_register = reg;
#endif
*lnk = useg;
return( useg->segid );
}
static int AddSeg( char *segname, char *class_name, int segtype )
{
struct seg_name *seg;
struct user_seg *useg, **lnk;
hw_reg_set reg;
char *p;
for( seg = &Predefined_Segs[0]; seg->name; seg++ ) {
if( strcmp( segname, seg->name ) == 0 ) {
return( seg->segment );
}
}
HW_CAsgn( reg, HW_EMPTY );
p = segname;
for( ;; ) {
if( *p == '\0' ) break;
if( *p == ':' ) {
*p = '\0';
reg = PragRegName( segname );
*p = ':';
segname = p + 1;
break;
}
++p;
}
lnk = &UserSegments;
while( (useg = *lnk) != NULL ) {
if( strcmp( segname, useg->name ) == 0 ) {
return( useg->segment ); /* 11-mar-93 - was return( segment ) */
}
lnk = &useg->next;
}
useg = AllocUserSeg( segname, class_name, segtype );
useg->next = *lnk;
useg->pegged_register = reg;
*lnk = useg;
return( useg->segment );
}
hw_reg_set PragReg( void )
{
return( PragRegName( Buffer, TokenLen ) );
}
