void HFileAppend( // APPEND HFILE TO LIST
const char *path_list ) // - list of path names
{
int old_len; // - length of old H list
char *p; // - points into H list
char *old_list; // - old H list
int len;
len = strlen( path_list );
if( len != 0 ) {
if( hfile_list != NULL ) {
old_list = hfile_list;
old_len = strlen( old_list );
hfile_list = CMemAlloc( old_len + 1 + len + 1 );
memcpy( hfile_list, old_list, old_len );
CMemFree( old_list );
p = hfile_list + old_len;
} else {
p = hfile_list = CMemAlloc( len + 1 );
}
while( *path_list != '\0' ) {
if( p != hfile_list )
*p++ = PATH_LIST_SEP;
path_list = GetPathElement( path_list, NULL, &p );
}
*p = '\0';
}
}
static void dw_write( dw_sectnum section, const void *block, dw_size_t len )
/********************************************************************/
{
unsigned bufnum;
unsigned endbufnum;
C_DW_SECTION *dwsect;
char **newbufptrs;
unsigned bufsize;
char *bufptr;
dwsect = &DWSections[section];
#ifdef __DD__
//int i;
printf( "\nDW_WRITE(%d:%d): offset: %d len: %d ",
section,
dwsect->length,
dwsect->offset,
len );
//for( i = 0 ; i < len; i++ ) {
// printf( "%02x ", (int)((char *)block)[i] );
//}
#endif
bufnum = dwsect->offset / C_DWARF_BUFSIZE;
endbufnum = (dwsect->offset + len) / C_DWARF_BUFSIZE;
if( endbufnum >= dwsect->bufcount ) {
newbufptrs = (char**)CMemAlloc( (endbufnum + 1) * sizeof(char**) );
if( dwsect->bufptrs != NULL ) {
memcpy( newbufptrs,
dwsect->bufptrs,
dwsect->bufcount * sizeof(char**) );
CMemFree( dwsect->bufptrs );
}
dwsect->bufptrs = newbufptrs;
dwsect->bufcount = endbufnum + 1;
}
bufsize = C_DWARF_BUFSIZE - (dwsect->offset % C_DWARF_BUFSIZE);
dwsect->offset += len;
if( dwsect->offset > dwsect->length ) {
dwsect->length = dwsect->offset;
}
while( len != 0 ) {
bufptr = dwsect->bufptrs[bufnum];
if( bufptr == NULL ) {
bufptr = (char *)CMemAlloc( C_DWARF_BUFSIZE );
dwsect->bufptrs[bufnum] = bufptr;
}
bufptr += C_DWARF_BUFSIZE - bufsize;
if( len < bufsize ) bufsize = len;
memcpy( bufptr, block, bufsize );
block = (char *)block + bufsize;
len -= bufsize;
++bufnum; // advance to next buffer
bufsize = C_DWARF_BUFSIZE; // buffer is full size
}
}
void CreateAux( // CREATE AUX ID
const char *id ) // - id
{
CurrEntry = CMemAlloc( offsetof( AUX_ENTRY, name ) + strlen( id ) + 1 );
strcpy( CurrEntry->name, id );
CurrInfo = CMemAlloc( sizeof( AUX_INFO ) );
// AuxCopy assumes destination is valid
CurrInfo->parms = NULL;
CurrInfo->objname = NULL;
CurrInfo->code = NULL;
}
void *AsmAlloc( size_t amount )
{
void *ptr;
ptr = CMemAlloc( amount );
return( ptr );
}
void PragManyRegSets( // GET PRAGMA REGISTER SETS
void )
{
hw_reg_set buff[ MAXIMUM_PARMSETS ];
int i;
hw_reg_set list;
hw_reg_set *sets;
list = PragRegList();
i = 0;
while( !HW_CEqual( list, HW_EMPTY ) && ( i != MAXIMUM_PARMSETS ) ) {
buff[ i++ ] = list;
list = PragRegList();
}
if( !HW_CEqual( list, HW_EMPTY ) ) {
CErr1( ERR_TOO_MANY_PARM_SETS );
}
HW_CAsgn( buff[i], HW_EMPTY );
i++;
i *= sizeof( hw_reg_set );
sets = ( hw_reg_set * ) CMemAlloc( i );
memcpy( sets, buff, i );
if( !IsAuxParmsBuiltIn( CurrInfo->parms ) ) {
CMemFree( CurrInfo->parms );
}
CurrInfo->parms = sets;
}
static void ChunkSaveData( STRCHUNK *pch, const char *data, size_t len )
{
int bytesleft;
int requestbytes;
char *newdata;
bytesleft = pch->maxsize - (pch->cursize+len+1);
if( bytesleft <= 0 ) {
requestbytes = -bytesleft;
if( requestbytes < STRCHUNK_INCREMENT ) {
requestbytes = STRCHUNK_INCREMENT;
}
requestbytes += pch->maxsize;
newdata = CMemAlloc( requestbytes );
if( pch->data ) {
memcpy( newdata, pch->data, pch->cursize );
CMemFree( pch->data );
}
pch->data = newdata;
pch->maxsize = requestbytes;
}
memcpy( pch->data+pch->cursize, data, len );
pch->cursize += len;
pch->data[pch->cursize] = '\0';
}
pch_status PCHInitNames( bool writing )
{
int i;
idname *name;
idname **p;
if( ! writing ) {
return( PCHCB_OK );
}
nameTranslateTable = CMemAlloc( nameCount * sizeof( idname * ) );
p = nameTranslateTable;
for( i = 0; i < NAME_TABLE_HASH; ++i ) {
for( name = hashTable[ i ]; name != NULL; name = name->next ) {
*p = name;
++p;
}
}
qsort( nameTranslateTable, nameCount, sizeof( idname * ), cmpName );
#ifndef NDEBUG
{
int i;
for( i = 1; i < nameCount; ++i ) {
if( nameTranslateTable[i - 1] == nameTranslateTable[i] ) {
CFatal( "two identical names in translation table" );
}
}
}
#endif
nameFlags.no_creates_allowed = TRUE;
return( PCHCB_OK );
}
local void getPackArgs( void )
/****************************/
{
struct pack_info *pi;
/* check to make sure it is a numeric token */
if( PragIdRecog( "push" ) ) { /* 29-sep-94 */
pi = (struct pack_info *)CMemAlloc( sizeof( struct pack_info ) );
pi->next = PackInfo;
pi->pack_amount = PackAmount;
PackInfo = pi;
if( CurToken == T_COMMA ) {
PPCTL_ENABLE_MACROS();
NextToken();
PPCTL_DISABLE_MACROS();
if( ExpectingConstant() ) {
SetPackAmount();
}
NextToken();
}
} else if( PragIdRecog( "pop" ) ) {
pi = PackInfo;
if( pi != NULL ) {
PackAmount = pi->pack_amount;
PackInfo = pi->next;
CMemFree( pi );
}
} else {
CErr1( ERR_NOT_A_CONSTANT_EXPR );
}
}
void AddLibraryName( char *name, char priority )
/**********************************************/
{
library_list **new_owner;
library_list **owner;
library_list *lib;
int len;
for( owner = &HeadLibs; (lib = *owner) != NULL; owner = &lib->next ) {
if( lib->libname[0] < priority ) {
break;
}
if( FNAMECMPSTR( lib->libname + 1, name ) == 0 ) {
return;
}
}
new_owner = owner;
for( ; (lib = *owner) != NULL; owner = &lib->next ) {
if( FNAMECMPSTR( lib->libname + 1, name ) == 0 ) {
*owner = lib->next;
break;
}
}
if( lib == NULL ) {
len = strlen( name );
lib = CMemAlloc( offsetof( library_list, libname ) + len + 2 );
memcpy( lib->libname + 1, name, len + 1 );
}
lib->libname[0] = priority;
lib->next = *new_owner;
*new_owner = lib;
}
void *SafeRecurseCpp( func_sr rtn, void *arg )
/********************************************/
/* This code assumes NO parameters on the stack! */
{
#define SAVE_SIZE 512 /* this must be smaller than the stack */
void *savearea;
void *retval;
if( stackavail() < 0x2000 ) { /* stack getting low! */
savearea = CMemAlloc( SAVE_SIZE );
if( savearea != NULL ) {
memcpy( bp(), savearea, SAVE_SIZE );
memcpy( sp(), sp() + SAVE_SIZE, bp() - sp() );
setbp( bp() + SAVE_SIZE );
setsp( sp() + SAVE_SIZE );
retval = rtn( arg );
setsp( sp() - SAVE_SIZE );
memcpy( sp() + SAVE_SIZE, sp(), bp() - sp() - SAVE_SIZE );
setbp( bp() - SAVE_SIZE );
memcpy( savearea, bp(), SAVE_SIZE );
CMemFree( savearea );
return( retval );
}
}
return( rtn( arg ) );
}
static void AddCaseLabel( unsigned long value )
{
CASEPTR ce, prev_ce, new_ce;
unsigned long old_value, converted_value;
TREEPTR tree;
char buffer[12];
prev_ce = NULL;
#if 0
leaf.u.ulong_konst = value;
leaf.data_type = SwitchStack->case_type;
SetLeafType( &leaf, 1 );
// converted_value = value & SwitchStack->case_mask;
converted_value = leaf.u.ulong_konst;
#else
converted_value = value;
#endif
old_value = converted_value + 1; /* make old_value different */
for( ce = SwitchStack->case_list; ce; ce = ce->next_case ) {
old_value = ce->value;
if( old_value >= converted_value ) break;
prev_ce = ce;
}
if( converted_value == old_value ) { /* duplicate case value found */
sprintf( buffer, SwitchStack->case_format, value );
CErr2p( ERR_DUPLICATE_CASE_VALUE, buffer );
} else {
new_ce = (CASEPTR)CMemAlloc( sizeof( CASEDEFN ) );
new_ce->value = converted_value;
if( prev_ce == NULL ) {
new_ce->next_case = SwitchStack->case_list;
SwitchStack->case_list = new_ce;
} else {
prev_ce->next_case = new_ce;
new_ce->next_case = ce;
}
/* Check if the previous statement was a 'case'. If so, reuse the label, as generating
* too many labels seriously slows down code generation.
*/
if( prev_ce && LastStmt->op.opr == OPR_STMT && LastStmt->right->op.opr == OPR_CASE ) {
new_ce->label = SwitchStack->last_case_label;
new_ce->gen_label = FALSE;
} else {
new_ce->label = NextLabel();
new_ce->gen_label = TRUE;
}
SwitchStack->number_of_cases++;
if( converted_value < SwitchStack->low_value ) {
SwitchStack->low_value = converted_value;
}
if( converted_value > SwitchStack->high_value ) {
SwitchStack->high_value = converted_value;
}
SwitchStack->last_case_label = new_ce->label;
tree = LeafNode( OPR_CASE );
tree->op.case_info = new_ce;
AddStmt( tree );
}
}
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 );
}
}
// #pragma alias(id1/"name1", id2/"name2")
//
// Causes linker to replace references to id1/name1 with references
// to id2/name2. Both the alias and the substituted symbol may be defined
// either as a string name or an id of existing symbol.
//
static void PragAlias( void )
/***************************/
{
SYM_HANDLE alias_sym;
SYM_HANDLE subst_sym;
const char *alias_name;
const char *subst_name;
alias_list **alias;
alias_list *new_alias;
alias_name = subst_name = NULL;
alias_sym = subst_sym = NULL;
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
PPNextToken();
if( CurToken == T_ID ) {
alias_sym = SymLook( HashValue, Buffer );
if( alias_sym == 0 ) {
CErr2p( ERR_UNDECLARED_SYM, Buffer );
}
} else if( CurToken == T_STRING ) {
alias_name = CStrSave( Buffer );
}
PPNextToken();
MustRecog( T_COMMA );
if( CurToken == T_ID ) {
subst_sym = SymLook( HashValue, Buffer );
if( subst_sym == 0 ) {
CErr2p( ERR_UNDECLARED_SYM, Buffer );
}
} else if( CurToken == T_STRING ) {
subst_name = CStrSave( Buffer );
}
PPNextToken();
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
}
/* Add a new alias record - if it's valid - to the list */
if( ( alias_name != NULL || alias_sym != NULL ) && ( subst_name != NULL || subst_sym != NULL ) ) {
for( alias = &AliasHead; *alias != NULL; alias = &(*alias)->next )
; /* nothing to do */
new_alias = (void *)CMemAlloc( sizeof( alias_list ) );
new_alias->next = NULL;
if( alias_name ) {
new_alias->name = alias_name;
} else {
new_alias->a_sym = alias_sym;
}
if( subst_name ) {
new_alias->subst = subst_name;
} else {
new_alias->s_sym = subst_sym;
}
*alias = new_alias;
}
}
// form: #pragma include_alias( "alias_name", "real_name" )
// #pragma include_alias( <alias_name>, <real_name> )
//
// (1) causes include directives referencing alias_name to refer
// to real_name instead
//
static void pragIncludeAlias( void )
{
if( ExpectingToken( T_LEFT_PAREN ) ) {
PPCTL_ENABLE_MACROS();
NextToken();
if( CurToken == T_STRING ) {
char *alias_name;
alias_name = CMemAlloc( strlen( Buffer ) + 1 );
strcpy( alias_name, Buffer );
NextToken();
if( ExpectingToken( T_COMMA ) ) {
NextToken();
}
if( CurToken == T_STRING ) {
IAliasAdd( alias_name, Buffer, false );
NextToken();
}
CMemFree( alias_name );
} else if( CurToken == T_LT ) {
char a_buf[82];
char r_buf[82];
a_buf[0] = '\0';
for( ;; ) {
NextToken();
if( CurToken == T_GT ) {
NextToken();
break;
}
if( CurToken == T_NULL ) {
break;
}
strncat( a_buf, Buffer, sizeof( a_buf ) - 2 );
}
if( ExpectingToken( T_COMMA ) ) {
NextToken();
}
if( CurToken == T_LT ) {
r_buf[0] = '\0';
for( ;; ) {
NextToken();
if( CurToken == T_GT ) {
NextToken();
break;
}
if( CurToken == T_NULL ) {
break;
}
strncat( r_buf, Buffer, sizeof( r_buf ) - 2 );
}
IAliasAdd( a_buf, r_buf, true );
}
}
PPCTL_DISABLE_MACROS();
MustRecog( T_RIGHT_PAREN );
}
}
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;
}
}
static void *dw_alloc( size_t size )
/**********************************/
{
char *p;
p = CMemAlloc( size );
memset( p, 0xA5, size );
return( p );
}
void CreateAux( char *id )
/************************/
{
CurrEntry = (aux_entry *)CMemAlloc( offsetof( aux_entry, name ) + strlen( id ) + 1 );
strcpy( CurrEntry->name, id );
#if _CPU == 370
CurrEntry->offset = -1;
#endif
}
static void AddSymList( SYM_HANDLE sym_handle )
{
SYM_LISTS *symlist;
symlist = (SYM_LISTS *)CMemAlloc( sizeof( SYM_LISTS ) );
symlist->next = SymListHeads;
symlist->sym_head = sym_handle;
SymListHeads = symlist;
}
// forms: (1) #pragma enum int
// (2) #pragma enum minimum
// (3) #pragma enum original
// (4) #pragma enum pop
//
// The pragma affects the underlying storage-definition for subsequent
// enum declarations.
//
// (1) make int the underlying storage definition (same as -ei)
// (2) minimize the underlying storage definition (same as no -ei)
// (3) reset back to result of command-line parsing
// (4) restore previous value
//
// 1-3 all push previous value before affecting value
//
static void PushEnum( void ) {
/***************************/
struct enums_info *ei;
ei = CMemAlloc( sizeof( struct enums_info ) );
ei->make_enums = CompFlags.make_enums_an_int;
ei->next = EnumInfo;
EnumInfo = ei;
}
static void macroStorageAlloc( void )
{
macroHashTable = CMemAlloc( HASH_TABLE_SIZE );
memset( macroHashTable, 0, HASH_TABLE_SIZE );
macroSegmentList = NULL;
beforeIncludeChecks = NULL;
undefCount = 0;
MacroOffset = NULL;
macroSegmentLimit = 0;
}
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 set_buffering( // SET BUFFERING FOR AN OPEN FILE
FILE *fp, // - opened file
size_t buf_size, // - buffer size
int mode ) // - buffering mode
{
BUF_ALLOC* ba = RingCarveAlloc( carve_buf, &buffers );
ba->file = fp;
ba->buffer = CMemAlloc( buf_size );
setvbuf( fp, ba->buffer, mode, buf_size );
}
char *vctsave( // ALLOCATE AND SAVE VECTOR AS STRING
const char *vector, // - source vector
size_t vsize ) // - size of source vector
{
char * new_str; // - target string
new_str = (char *) CMemAlloc( vsize + 1 );
stvcpy( new_str, vector, vsize );
return( new_str );
}
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 );
}
void CmdLnCtxPushEnv( // PUSH FOR ENVIRONMENT-VARIABLE PROCESSING
char const *var ) // - environment variable
{
CTX_CL* entry; // - new entry
size_t size; // - variable size
entry = cmdLnCtxAlloc( CTX_CLTYPE_ENV );
size = strlen( var ) + 1;
entry->env.var = CMemAlloc( size );
memcpy( (void*)entry->env.var, var, size );
}
char *AddUndefName( const char *str )
{
size_t len;
undef_names *uname;
len = strlen( str );
if( len == 0 ) {
CompFlags.undefine_all_macros = 1;
} else {
CalcHash( str, len );
if( !MacroDel( str ) ) {
uname = (undef_names *)CMemAlloc( sizeof( undef_names ) );
uname->next = UndefNames;
uname->name = CMemAlloc( len + 1 );
memcpy( uname->name, str, len + 1 );
UndefNames = uname;
str += len;
}
}
return( (char *)str );
}
static LIB_LIST *addNewLib( char *name, char priority )
{
size_t len;
LIB_LIST *new_lib;
len = strlen( name );
new_lib = CMemAlloc( sizeof( *new_lib ) + 1 + len );
new_lib->name[0] = priority;
strcpy( &(new_lib->name[1]), name );
RingAppend( &libRing, new_lib );
return( new_lib );
}
char *FNameAdd( // ADD AN FNAME
char const *name ) // - name to be added
{
size_t len;
FNAME *p;
len = strlen( name );
p = CMemAlloc( offsetof( FNAME, name ) + len + 1 );
strcpy( p->name, name );
RingAppend( &fnameList, p );
return( p->name );
}
void HFileAppend( // APPEND HFILE TO LIST
const char *filename, // - file name
size_t len ) // - size of name
{
int old_len; // - length of old H list
char *p; // - points into H list
char *old_list; // - old H list
if( hfile_list != NULL ) {
old_list = hfile_list;
old_len = strlen( old_list );
p = (char *) CMemAlloc( len + old_len + 2 );
hfile_list = p;
p = stpcpy( p, old_list );
p = IoSuppAddIncPathSep( p );
CMemFree( old_list );
} else {
p = (char *) CMemAlloc( len + 1 );
hfile_list = p;
}
p = stvcpy( p, filename, len );
}
static void SwitchStmt( void )
{
SWITCHPTR sw;
TREEPTR tree;
TYPEPTR typ;
int switch_type;
StartNewBlock();
NextToken();
sw = (SWITCHPTR)CMemAlloc( sizeof( SWITCHDEFN ) );
sw->prev_switch = SwitchStack;
sw->low_value = ~0l;
sw->high_value = 0;
sw->case_format = "%ld"; /* assume signed cases */
SwitchStack = sw;
switch_type = TYPE_INT; /* assume int */
tree = RValue( BracketExpr() );
typ = TypeOf( tree );
if( typ->decl_type == TYPE_ENUM ) typ = typ->object;
if( typ->decl_type == TYPE_UFIELD ) {
if( typ->u.f.field_width == (TARGET_INT * 8) ) {
sw->case_format = "%lu";
switch_type = TYPE_UINT;
}
}
switch( typ->decl_type ) {
case TYPE_USHORT:
case TYPE_UINT:
sw->case_format = "%lu";
switch_type = TYPE_UINT;
case TYPE_CHAR:
case TYPE_UCHAR:
case TYPE_SHORT:
case TYPE_INT:
case TYPE_FIELD:
case TYPE_UFIELD:
break;
case TYPE_ULONG:
sw->case_format = "%lu";
switch_type = TYPE_ULONG;
break;
case TYPE_LONG:
switch_type = TYPE_LONG;
break;
default:
CErr1( ERR_INVALID_TYPE_FOR_SWITCH );
}
tree = ExprNode( 0, OPR_SWITCH, tree );
tree->op.switch_info = sw;
AddStmt( tree );
}
