static void SetSimSeg( enum sim_seg segm, const char *name )
/**********************************************************/
{
char *pAlign = "WORD";
char *pAlignSt = "PARA";
char *pUse = "";
struct asym *sym;
const char *pFmt;
const char *pClass;
if ( ModuleInfo.defOfssize > USE16 ) {
if ( ModuleInfo.model == MODEL_FLAT )
pUse = "FLAT";
else
pUse = "USE32";
if (( ModuleInfo.curr_cpu & P_CPU_MASK ) <= P_386 )
pAlign = "DWORD";
else
pAlign = "PARA";
pAlignSt = pAlign;
}
if ( segm == SIM_CODE )
pClass = GetCodeClass();
else
pClass = SegmClass[segm];
if ( segm == SIM_STACK || segm == SIM_FARDATA || segm == SIM_FARDATA_UN )
pAlign = pAlignSt;
pFmt = "%s %r %s %s %s '%s'";
if ( name == NULL ) {
name = SegmNames[segm];
if ( ModuleInfo.simseg_init & ( 1 << segm ) )
pFmt = "%s %r";
else {
ModuleInfo.simseg_init |= ( 1 << segm );
/* v2.05: if segment exists already, use the current attribs.
* This allows a better mix of full and simplified segment
* directives. Masm behaves differently: the attributes
* of the simplified segment directives have highest priority.
*/
sym = SymSearch( name );
if ( sym && sym->state == SYM_SEG && ((struct dsym *)sym)->e.seginfo->lname_idx != 0 )
pFmt = "%s %r";
}
} else {
sym = SymSearch( name );
/* v2.04: testing for state SYM_SEG isn't enough. The segment
* might have been "defined" by a GROUP directive. Additional
* check for segment's lname index is needed.
*/
//if ( sym && sym->state == SYM_SEG )
if ( sym && sym->state == SYM_SEG && ((struct dsym *)sym)->e.seginfo->lname_idx != 0 )
pFmt = "%s %r";
}
AddLineQueueX( pFmt, name, T_SEGMENT, pAlign, pUse, SegmCombine[segm], pClass );
return;
}
static struct asym *CreateProto( int i, struct asm_tok tokenarray[], const char *name, enum lang_type langtype )
/**************************************************************************************************************/
{
struct asym *sym;
struct dsym *dir;
DebugMsg1(("CreateProto( i=%u, name=%s, lang=%u )\n", i, name ? name : "NULL", langtype ));
sym = SymSearch( name );
/* the symbol must be either NULL or state
* - SYM_UNDEFINED
* - SYM_EXTERNAL + isproc == FALSE ( previous EXTERNDEF )
* - SYM_EXTERNAL + isproc == TRUE ( previous PROTO )
* - SYM_INTERNAL + isproc == TRUE ( previous PROC )
*/
if( sym == NULL ||
sym->state == SYM_UNDEFINED ||
( sym->state == SYM_EXTERNAL && sym->weak == TRUE && sym->isproc == FALSE )) {
if ( NULL == ( sym = CreateProc( sym, name, SYM_EXTERNAL ) ) )
return( NULL ); /* name was probably invalid */
} else if ( sym->isproc == FALSE ) {
EmitErr( SYMBOL_REDEFINITION, sym->name );
return( NULL );
}
dir = (struct dsym *)sym;
/* a PROTO typedef may be used */
if ( tokenarray[i].token == T_ID ) {
struct asym * sym2;
sym2 = SymSearch( tokenarray[i].string_ptr );
if ( sym2 && sym2->state == SYM_TYPE && sym2->mem_type == MT_PROC ) {
i++;
if ( tokenarray[i].token != T_FINAL ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr );
return( NULL );
}
CopyPrototype( dir, (struct dsym *)sym2->target_type );
return( sym );
}
}
/* sym->isproc is set inside ParseProc() */
//sym->isproc = TRUE;
if ( Parse_Pass == PASS_1 ) {
if ( ParseProc( dir, i, tokenarray, FALSE, langtype ) == ERROR )
return( NULL );
#if DLLIMPORT
sym->dll = ModuleInfo.CurrDll;
#endif
} else {
sym->isdefined = TRUE;
}
return( sym );
}
struct asym *CreateIntSegment( const char *name, const char *classname, uint_8 alignment, uint_8 Ofssize, bool add_global )
/*************************************************************************************************************************/
{
struct dsym *seg;
if ( add_global ) {
seg = (struct dsym *)SymSearch( name );
if ( seg == NULL || seg->sym.state == SYM_UNDEFINED )
seg = CreateSegment( seg, name, add_global );
else if ( seg->sym.state != SYM_SEG ) {
EmitErr( SYMBOL_REDEFINITION, name );
return( NULL );
}
} else
seg = CreateSegment( NULL, name, FALSE );
if ( seg ) {
if( seg->e.seginfo->lname_idx == 0 ) {
seg->e.seginfo->seg_idx = ++ModuleInfo.g.num_segs;
seg->e.seginfo->lname_idx = ++LnamesIdx;
AddLnameData( &seg->sym );
}
seg->sym.segment = &seg->sym;
seg->e.seginfo->alignment = alignment;
seg->e.seginfo->Ofssize = Ofssize;
SetSegmentClass( (struct asym *)seg, classname );
return( &seg->sym );
}
return( NULL );
}
static ret_code SetCurrSeg( int i, struct asm_tok tokenarray[] )
/**************************************************************/
{
struct asym *sym;
sym = SymSearch( tokenarray[0].string_ptr );
DebugMsg1(("SetCurrSeg(%s) sym=%p\n", tokenarray[0].string_ptr, sym));
if ( sym == NULL || sym->state != SYM_SEG ) {
EmitErr( SEG_NOT_DEFINED, tokenarray[0].string_ptr );
return( ERROR );
}
/* v2.04: added */
sym->isdefined = TRUE;
if ( CurrSeg && Options.output_format == OFORMAT_OMF ) {
omf_FlushCurrSeg();
if ( Options.no_comment_data_in_code_records == FALSE )
omf_OutSelect( FALSE );
}
push_seg( (struct dsym *)sym );
if ( ModuleInfo.list )
LstWrite( LSTTYPE_LABEL, 0, NULL );
return( SetOfssize() );
}
static struct dsym *CreateGroup( const char *name )
/*************************************************/
{
struct dsym *grp;
grp = (struct dsym *)SymSearch( name );
if( grp == NULL || grp->sym.state == SYM_UNDEFINED ) {
if ( grp == NULL )
grp = (struct dsym *)SymCreate( name );
else
sym_remove_table( &SymTables[TAB_UNDEF], grp );
grp->sym.state = SYM_GRP;
grp->e.grpinfo = LclAlloc( sizeof( struct grp_info ) );
grp->e.grpinfo->seglist = NULL;
//grp->e.grpinfo->grp_idx = 0;
//grp->e.grpinfo->lname_idx = 0;
grp->e.grpinfo->numseg = 0;
sym_add_table( &SymTables[TAB_GRP], grp );
grp->sym.list = TRUE;
grp->e.grpinfo->grp_idx = ++grpdefidx;
grp->e.grpinfo->lname_idx = ++LnamesIdx;
AddLnameData( &grp->sym );
} else if( grp->sym.state != SYM_GRP ) {
EmitErr( SYMBOL_REDEFINITION, name );
return( NULL );
}
grp->sym.isdefined = TRUE;
return( grp );
}
void AddFloatingPointEmulationFixup( struct code_info *CodeInfo )
/***************************************************************/
{
int i;
enum fp_patches patch;
struct asym *sym[2];
struct fixup *fixup;
int_32 data;
char name[8] = "F__RQQ";
DebugMsg(("AddFloatingPointEmulationFixup enter, token=%u, regoverride=%d\n", CodeInfo->token, CodeInfo->prefix.RegOverride ));
if( CodeInfo->token == T_FWAIT ) {
patch = FPP_WAIT;
} else if ( CodeInfo->prefix.RegOverride == EMPTY ) {
patch = FPP_NORMAL;
} else {
patch = CodeInfo->prefix.RegOverride + 2;
}
/* emit 1-2 externals for the patch if not done already */
for ( i = 0; i < 2; i++ ) {
sym[i] = NULL;
if ( patchmask & ( 1 << ( i*8+patch ) ) ) {
name[1] = 'I' + i;
name[2] = patchchr2[patch];
sym[i] = SymSearch( name );
if( sym[i] == NULL || sym[i]->state == SYM_UNDEFINED ) {
sym[i] = MakeExtern( name, MT_FAR, NULL, sym[i], USE16 );
sym[i]->langtype = LANG_NONE;
}
}
}
/* no need for fixups if no object file is written */
if ( write_to_file == FALSE )
return;
/* make sure the next 3 bytes in code stream aren't separated.
* The first fixup covers bytes $+0 and $+1, the (possible) second
* fixup covers bytes $+1 and $+2.
*/
if( Options.output_format == OFORMAT_OMF &&
( CurrSeg->e.seginfo->current_loc - CurrSeg->e.seginfo->start_loc + 3 ) > MAX_LEDATA_THRESHOLD )
omf_FlushCurrSeg();
for ( i = 0; i < 2 ; i++ ) {
if ( sym[i] ) {
fixup = CreateFixup( sym[i], FIX_OFF16, OPTJ_NONE );
fixup->frame_type = FRAME_TARG;
/* assume locofs has been set inside CreateFixup() */
//fixup->locofs = CurrSeg->e.seginfo->current_loc + i;
fixup->locofs += i;
data = 0;
store_fixup( fixup, CurrSeg, &data );
}
}
return;
}
int TextItemError( struct asm_tok *item )
/***************************************/
{
if ( item->token == T_STRING && *item->string_ptr == '<' ) {
return( EmitError( MISSING_ANGLE_BRACKET_OR_BRACE_IN_LITERAL ) );
}
/* v2.05: better error msg if (text) symbol isn't defined */
if ( item->token == T_ID ) {
struct asym *sym = SymSearch( item->string_ptr );
if ( sym == NULL || sym->state == SYM_UNDEFINED ) {
return( EmitErr( SYMBOL_NOT_DEFINED, item->string_ptr ) );
}
}
return( EmitError( TEXT_ITEM_REQUIRED ) );
}
ret_code ProtoDirective( int i, struct asm_tok tokenarray[] )
/***********************************************************/
{
if( Parse_Pass != PASS_1 ) {
struct asym *sym;
/* v2.04: set the "defined" flag */
if ( ( sym = SymSearch( tokenarray[0].string_ptr ) ) && sym->isproc == TRUE )
sym->isdefined = TRUE;
return( NOT_ERROR );
}
if( i != 1 ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
return( CreateProto( 2, tokenarray, tokenarray[0].string_ptr, ModuleInfo.langtype ) ? NOT_ERROR : ERROR );
}
/* create a (predefined) text macro.
* used to create @code, @data, ...
* there are 2 more locations where predefined text macros may be defined:
* - assemble.c, add_cmdline_tmacros()
* - symbols.c, SymInit()
* this should be changed eventually.
*/
struct asym *AddPredefinedText( const char *name, const char *value )
/*******************************************************************/
{
struct asym *sym;
DebugMsg1(("AddPredefinedText(%s): >%s<\n", name, value ));
/* v2.08: ignore previous setting */
if ( NULL == ( sym = SymSearch( name ) ) )
sym = SymCreate( name );
sym->state = SYM_TMACRO;
sym->isdefined = TRUE;
sym->predefined = TRUE;
sym->string_ptr = (char *)value;
/* to ensure that a new buffer is used if the string is modified */
sym->total_size = 0;
return( sym );
}
ret_code SafeSEHDirective( int i, struct asm_tok tokenarray[] )
/*************************************************************/
{
struct asym *sym;
struct qnode *node;
if ( Options.output_format != OFORMAT_COFF ) {
if ( Parse_Pass == PASS_1)
EmitWarn( 2, DIRECTIVE_IGNORED_WITHOUT_X, "coff" );
return( NOT_ERROR );
}
if ( Options.safeseh == FALSE ) {
if ( Parse_Pass == PASS_1)
EmitWarn( 2, DIRECTIVE_IGNORED_WITHOUT_X, "safeseh" );
return( NOT_ERROR );
}
i++;
if ( tokenarray[i].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
sym = SymSearch( tokenarray[i].string_ptr );
/* make sure the argument is a true PROC */
if ( sym == NULL || sym->state == SYM_UNDEFINED ) {
if ( Parse_Pass != PASS_1 ) {
return( EmitErr( SYMBOL_NOT_DEFINED, tokenarray[i].string_ptr ) );
}
} else if ( sym->isproc == FALSE ) {
return( EmitErr( SAFESEH_ARGUMENT_MUST_BE_A_PROC, tokenarray[i].string_ptr ) );
}
if ( Parse_Pass == PASS_1 ) {
if ( sym ) {
for ( node = ModuleInfo.g.SafeSEHQueue.head; node; node = node->next )
if ( node->elmt == sym )
break;
} else {
sym = SymCreate( tokenarray[i].string_ptr );
node = NULL;
}
if ( node == NULL ) {
sym->used = TRUE; /* make sure an external reference will become strong */
#if 0 /* v2.11: use QAddItem() */
node = LclAlloc( sizeof( struct qnode ) );
node->elmt = sym;
node->next = NULL;
if ( ModuleInfo.g.SafeSEHQueue.head == 0 )
ModuleInfo.g.SafeSEHQueue.head = ModuleInfo.g.SafeSEHQueue.tail = node;
else {
((struct qnode *)ModuleInfo.g.SafeSEHQueue.tail)->next = node;
ModuleInfo.g.SafeSEHQueue.tail = node;
}
#else
QAddItem( &ModuleInfo.g.SafeSEHQueue, sym );
#endif
}
}
i++;
if ( tokenarray[i].token != T_FINAL ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
return( NOT_ERROR );
}
ret_code PublicDirective( int i, struct asm_tok tokenarray[] )
/************************************************************/
{
#if MANGLERSUPP
char *mangle_type = NULL;
#endif
char *token;
struct asym *sym;
//struct dsym *dir;
char skipitem;
enum lang_type langtype;
DebugMsg1(("PublicDirective(%u) enter\n", i));
i++; /* skip PUBLIC directive */
#if MANGLERSUPP
mangle_type = Check4Mangler( &i, tokenarray );
#endif
do {
/* read the optional language type */
langtype = ModuleInfo.langtype;
GetLangType( &i, tokenarray, &langtype );
if ( tokenarray[i].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
/* get the symbol name */
token = tokenarray[i++].string_ptr;
DebugMsg1(("PublicDirective: sym=%s\n", token ));
/* Add the public name */
sym = SymSearch( token );
if ( Parse_Pass == PASS_1 ) {
if ( sym == NULL ) {
if ( sym = SymCreate( token ) ) {
sym_add_table( &SymTables[TAB_UNDEF], (struct dsym *)sym );
DebugMsg1(("PublicDirective(%s): new symbol\n", sym->name ));
} else
return( ERROR ); /* name was too long */
}
skipitem = FALSE;
} else {
if ( sym == NULL || sym->state == SYM_UNDEFINED ) {
EmitErr( SYMBOL_NOT_DEFINED, token );
//return( ERROR ); /* v2.04: dont exit */
}
}
if ( sym ) {
switch ( sym->state ) {
case SYM_UNDEFINED:
break;
case SYM_INTERNAL:
if ( sym->scoped == TRUE ) {
EmitErr( CANNOT_DECLARE_SCOPED_CODE_LABEL_AS_PUBLIC, sym->name );
skipitem = TRUE;
//return( ERROR );
}
break;
case SYM_EXTERNAL:
if ( sym->iscomm == TRUE ) {
EmitErr( CANNOT_DEFINE_AS_PUBLIC_OR_EXTERNAL, sym->name );
skipitem = TRUE;
//return( ERROR );
} else if ( sym->weak == FALSE ) {
/* for EXTERNs, emit a different error msg */
EmitErr( SYMBOL_REDEFINITION, sym->name );
skipitem = TRUE;
//return( ERROR );
}
break;
default:
EmitErr( CANNOT_DEFINE_AS_PUBLIC_OR_EXTERNAL, sym->name );
skipitem = TRUE;
//return( ERROR );
}
if( Parse_Pass == PASS_1 && skipitem == FALSE ) {
if ( sym->ispublic == FALSE ) {
sym->ispublic = TRUE;
AddPublicData( sym ); /* put it into the public table */
}
SetMangler( sym, langtype, mangle_type );
}
}
if ( tokenarray[i].token != T_FINAL )
if ( tokenarray[i].token == T_COMMA ) {
if ( (i + 1) < Token_Count )
i++;
} else {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].tokpos ) );
}
} while ( i < Token_Count );
return( NOT_ERROR );
}
ret_code CommDirective( int i, struct asm_tok tokenarray[] )
/**********************************************************/
{
char *token;
#if MANGLERSUPP
char *mangle_type = NULL;
#endif
bool isfar;
//int distance;
int tmp;
uint_32 size; /* v2.12: changed from 'int' to 'uint_32' */
uint_32 count; /* v2.12: changed from 'int' to 'uint_32' */
struct asym *sym;
struct expr opndx;
enum lang_type langtype;
DebugMsg1(("CommDirective(%u) enter\n", i));
i++; /* skip COMM token */
for( ; i < Token_Count; i++ ) {
#if MANGLERSUPP
mangle_type = Check4Mangler( &i, tokenarray );
#endif
/* get the symbol language type if present */
langtype = ModuleInfo.langtype;
GetLangType( &i, tokenarray, &langtype );
/* get the -optional- distance ( near or far ) */
isfar = FALSE;
if ( tokenarray[i].token == T_STYPE )
switch ( tokenarray[i].tokval ) {
case T_FAR:
case T_FAR16:
case T_FAR32:
if ( ModuleInfo.model == MODEL_FLAT ) {
EmitError( FAR_NOT_ALLOWED_IN_FLAT_MODEL_COMM_VARIABLES );
} else
isfar = TRUE;
/* no break */
case T_NEAR:
case T_NEAR16:
case T_NEAR32:
i++;
}
/* v2.08: ensure token is a valid id */
if( tokenarray[i].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
/* get the symbol name */
token = tokenarray[i++].string_ptr;
/* go past the colon */
if( tokenarray[i].token != T_COLON ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
i++;
/* the evaluator cannot handle a ':' so scan for one first */
for ( tmp = i; tmp < Token_Count;tmp++ )
if ( tokenarray[tmp].token == T_COLON )
break;
/* v2.10: expression evaluator isn't to accept forward references */
//if ( EvalOperand( &i, tokenarray, tmp, &opndx, 0 ) == ERROR )
if ( EvalOperand( &i, tokenarray, tmp, &opndx, EXPF_NOUNDEF ) == ERROR )
return( ERROR );
/* v2.03: a string constant is accepted by Masm */
/* v2.11: don't accept NEAR or FAR */
/* v2.12: check for too large value added */
//if ( opndx.kind != EXPR_CONST || opndx.string != NULL ) {
if ( opndx.kind != EXPR_CONST )
EmitError( CONSTANT_EXPECTED );
else if ( ( opndx.mem_type & MT_SPECIAL_MASK) == MT_ADDRESS )
EmitErr( INVALID_TYPE_FOR_DATA_DECLARATION, token );
else if ( opndx.hvalue != 0 && opndx.hvalue != -1 )
EmitConstError( &opndx );
else if ( opndx.uvalue == 0 )
EmitError( POSITIVE_VALUE_EXPECTED );
size = opndx.uvalue;
count = 1;
if( tokenarray[i].token == T_COLON ) {
i++;
/* get optional count argument */
/* v2.10: expression evaluator isn't to accept forward references */
//if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, 0 ) == ERROR )
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, EXPF_NOUNDEF ) == ERROR )
return( ERROR );
/* v2.03: a string constant is acceptable! */
/* v2.12: check for too large value added */
//if ( opndx.kind != EXPR_CONST || opndx.string != NULL ) {
if ( opndx.kind != EXPR_CONST )
EmitError( CONSTANT_EXPECTED );
else if ( opndx.hvalue != 0 && opndx.hvalue != -1 )
EmitConstError( &opndx );
else if ( opndx.uvalue == 0 )
EmitError( POSITIVE_VALUE_EXPECTED );
count = opndx.uvalue;
}
sym = SymSearch( token );
if( sym == NULL || sym->state == SYM_UNDEFINED ) {
sym = MakeComm( token, sym, size, count, isfar );
if ( sym == NULL )
return( ERROR );
} else if ( sym->state != SYM_EXTERNAL || sym->iscomm != TRUE ) {
return( EmitErr( SYMBOL_REDEFINITION, sym->name ) );
} else {
tmp = sym->total_size / sym->total_length;
if( count != sym->total_length || size != tmp ) {
return( EmitErr( NON_BENIGN_XXX_REDEFINITION, szCOMM, sym->name ) );
}
}
sym->isdefined = TRUE;
SetMangler( sym, langtype, mangle_type );
if ( tokenarray[i].token != T_FINAL && tokenarray[i].token != T_COMMA ) {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
}
return( NOT_ERROR );
}
ret_code ExternDirective( int i, struct asm_tok tokenarray[] )
/************************************************************/
{
char *token;
#if MANGLERSUPP
char *mangle_type = NULL;
#endif
char *altname;
struct asym *sym;
enum lang_type langtype;
struct qualified_type ti;
DebugMsg1(("ExternDirective(%u) enter\n", i));
i++; /* skip EXT[E]RN token */
#if MANGLERSUPP
mangle_type = Check4Mangler( &i, tokenarray );
#endif
do {
altname = NULL;
/* get the symbol language type if present */
langtype = ModuleInfo.langtype;
GetLangType( &i, tokenarray, &langtype );
/* get the symbol name */
if( tokenarray[i].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
token = tokenarray[i++].string_ptr;
/* go past the optional alternative name (weak ext, default resolution) */
if( tokenarray[i].token == T_OP_BRACKET ) {
i++;
if ( tokenarray[i].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
altname = tokenarray[i].string_ptr;
i++;
if( tokenarray[i].token != T_CL_BRACKET ) {
return( EmitErr( EXPECTED, ")" ) );
}
i++;
}
/* go past the colon */
if( tokenarray[i].token != T_COLON ) {
return( EmitError( COLON_EXPECTED ) );
}
i++;
sym = SymSearch( token );
ti.mem_type = MT_EMPTY;
ti.size = 0;
ti.is_ptr = 0;
ti.is_far = FALSE;
ti.ptr_memtype = MT_EMPTY;
ti.symtype = NULL;
ti.Ofssize = ModuleInfo.Ofssize;
if ( tokenarray[i].token == T_ID && ( 0 == _stricmp( tokenarray[i].string_ptr, "ABS" ) ) ) {
//ti.mem_type = MT_ABS;
i++;
} else if ( tokenarray[i].token == T_DIRECTIVE && tokenarray[i].tokval == T_PROTO ) {
/* dont scan this line further */
/* CreateProto() will define a SYM_EXTERNAL */
sym = CreateProto( i + 1, tokenarray, token, langtype );
DebugMsg1(("ExternDirective(%s): CreateProto()=%X\n", token, sym));
if ( sym == NULL )
return( ERROR );
if ( sym->state == SYM_EXTERNAL ) {
sym->weak = FALSE;
return( HandleAltname( altname, sym ) );
} else {
/* unlike EXTERNDEF, EXTERN doesn't allow a PROC for the same name */
return( EmitErr( SYMBOL_REDEFINITION, sym->name ) );
}
} else if ( tokenarray[i].token != T_FINAL && tokenarray[i].token != T_COMMA ) {
if ( GetQualifiedType( &i, tokenarray, &ti ) == ERROR )
return( ERROR );
}
DebugMsg1(("ExternDirective(%s): mem_type=%Xh\n", token, ti.mem_type ));
if( sym == NULL || sym->state == SYM_UNDEFINED ) {
/* v2.04: emit the error at the PUBLIC directive */
//if ( sym && sym->public == TRUE ) {
// EmitErr( CANNOT_DEFINE_AS_PUBLIC_OR_EXTERNAL, sym->name );
// return( ERROR );
//}
if(( sym = MakeExtern( token, ti.mem_type,
ti.mem_type == MT_TYPE ? ti.symtype : NULL, sym,
ti.is_ptr ? ModuleInfo.Ofssize : ti.Ofssize )) == NULL )
return( ERROR );
/* v2.05: added to accept type prototypes */
if ( ti.is_ptr == 0 && ti.symtype && ti.symtype->isproc ) {
CreateProc( sym, NULL, SYM_EXTERNAL );
sym->weak = FALSE; /* v2.09: reset the weak bit that has been set inside CreateProc() */
CopyPrototype( (struct dsym *)sym, (struct dsym *)ti.symtype );
ti.mem_type = ti.symtype->mem_type;
ti.symtype = NULL;
DebugMsg1(("ExternDirective(%s): prototype copied, memtype=%X\n", token, ti.mem_type ));
}
} else {
#if MASM_EXTCOND
/* allow internal AND external definitions for equates */
//if ( sym->state == SYM_INTERNAL && sym->mem_type == MT_ABS )
if ( sym->state == SYM_INTERNAL && sym->mem_type == MT_EMPTY )
;
else
#endif
if ( sym->state != SYM_EXTERNAL ) {
DebugMsg(("ExternDirective: symbol %s redefinition, state=%u\n", token, sym->state ));
return( EmitErr( SYMBOL_REDEFINITION, token ) );
}
/* v2.05: added to accept type prototypes */
if ( ti.is_ptr == 0 && ti.symtype && ti.symtype->isproc ) {
ti.mem_type = ti.symtype->mem_type;
ti.symtype = NULL;
}
if( sym->mem_type != ti.mem_type ||
sym->is_ptr != ti.is_ptr ||
sym->isfar != ti.is_far ||
( sym->is_ptr && sym->ptr_memtype != ti.ptr_memtype ) ||
((sym->mem_type == MT_TYPE) ? sym->type : sym->target_type) != ti.symtype ||
( langtype != LANG_NONE && sym->langtype != LANG_NONE && sym->langtype != langtype )) {
DebugMsg(("ExternDirective: memtype:%X-%X ptr=%X-%X far=%X-%X ptr_memtype=%X-%X lang=%u-%u\n",
sym->mem_type, ti.mem_type,
sym->is_ptr, ti.is_ptr,
sym->isfar, ti.is_far,
sym->ptr_memtype, ti.ptr_memtype,
sym->langtype, langtype
));
return( EmitErr( SYMBOL_TYPE_CONFLICT, token ) );
}
}
sym->isdefined = TRUE;
sym->Ofssize = ti.Ofssize;
if ( ti.is_ptr == 0 && ti.Ofssize != ModuleInfo.Ofssize ) {
sym->seg_ofssize = ti.Ofssize;
if ( sym->segment && ((struct dsym *)sym->segment)->e.seginfo->Ofssize != sym->seg_ofssize )
sym->segment = NULL;
}
sym->mem_type = ti.mem_type;
sym->is_ptr = ti.is_ptr;
sym->isfar = ti.is_far;
sym->ptr_memtype = ti.ptr_memtype;
if ( ti.mem_type == MT_TYPE )
sym->type = ti.symtype;
else
sym->target_type = ti.symtype;
HandleAltname( altname, sym );
SetMangler( sym, langtype, mangle_type );
if ( tokenarray[i].token != T_FINAL )
if ( tokenarray[i].token == T_COMMA && ( (i + 1) < Token_Count ) ) {
i++;
} else {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
} while ( i < Token_Count );
return( NOT_ERROR );
}
static ret_code HandleAltname( char *altname, struct asym *sym )
/**************************************************************/
{
struct asym *symalt;
if ( altname && sym->state == SYM_EXTERNAL ) {
symalt = SymSearch( altname );
/* altname symbol changed? */
if ( sym->altname && sym->altname != symalt ) {
return( EmitErr( SYMBOL_REDEFINITION, sym->name ) );
}
if ( Parse_Pass > PASS_1 ) {
if ( symalt->state == SYM_UNDEFINED ) {
EmitErr( SYMBOL_NOT_DEFINED, altname );
} else if (symalt->state != SYM_INTERNAL && symalt->state != SYM_EXTERNAL ) {
EmitErr( SYMBOL_TYPE_CONFLICT, altname );
} else {
#if COFF_SUPPORT || ELF_SUPPORT
if ( symalt->state == SYM_INTERNAL && symalt->ispublic == FALSE )
if ( Options.output_format == OFORMAT_COFF
#if ELF_SUPPORT
|| Options.output_format == OFORMAT_ELF
#endif
) {
EmitErr( MUST_BE_PUBLIC_OR_EXTERNAL, altname );
}
#endif
if ( sym->mem_type != symalt->mem_type )
EmitErr( SYMBOL_TYPE_CONFLICT, altname );
}
} else {
if ( symalt ) {
DebugMsg(("HandleAltname: symbol '%s' found, state=%u\n", altname, symalt->state ));
if ( symalt->state != SYM_INTERNAL &&
symalt->state != SYM_EXTERNAL &&
symalt->state != SYM_UNDEFINED ) {
return( EmitErr( SYMBOL_TYPE_CONFLICT, altname ) );
}
} else {
symalt = SymCreate( altname );
sym_add_table( &SymTables[TAB_UNDEF], (struct dsym *)symalt );
}
/* make sure the alt symbol becomes strong if it is an external
* v2.11: don't do this for OMF ( maybe neither for COFF/ELF? )
*/
if ( Options.output_format != OFORMAT_OMF )
symalt->used = TRUE;
/* symbol inserted in the "weak external" queue?
* currently needed for OMF only.
*/
if ( sym->altname == NULL ) {
sym->altname = symalt;
#if 0 /* v2.11: removed. Member nextext wasn't free to use */
DebugMsg1(("HandleAltname: symbol '%s' added to AltQueue\n", sym->name ));
((struct dsym *)sym)->nextext = NULL;
if ( ModuleInfo.g.AltQueue.head == NULL )
ModuleInfo.g.AltQueue.head = ModuleInfo.g.AltQueue.tail = (struct dsym *)sym;
else {
((struct dsym *)ModuleInfo.g.AltQueue.tail)->nextext = (struct dsym *)sym;
ModuleInfo.g.AltQueue.tail = (struct dsym *)sym;
}
#endif
}
}
}
return( NOT_ERROR );
}
ret_code ExterndefDirective( int i, struct asm_tok tokenarray[] )
/***************************************************************/
{
char *token;
#if MANGLERSUPP
char *mangle_type = NULL;
#endif
struct asym *sym;
enum lang_type langtype;
char isnew;
struct qualified_type ti;
DebugMsg1(("ExterndefDirective(%u) enter\n", i));
i++; /* skip EXTERNDEF token */
#if MANGLERSUPP
mangle_type = Check4Mangler( &i, tokenarray );
#endif
do {
ti.Ofssize = ModuleInfo.Ofssize;
/* get the symbol language type if present */
langtype = ModuleInfo.langtype;
GetLangType( &i, tokenarray, &langtype );
/* get the symbol name */
if( tokenarray[i].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
token = tokenarray[i++].string_ptr;
/* go past the colon */
if( tokenarray[i].token != T_COLON ) {
return( EmitError( COLON_EXPECTED ) );
}
i++;
sym = SymSearch( token );
//typetoken = tokenarray[i].string_ptr;
ti.mem_type = MT_EMPTY;
ti.size = 0;
ti.is_ptr = 0;
ti.is_far = FALSE;
ti.ptr_memtype = MT_EMPTY;
ti.symtype = NULL;
ti.Ofssize = ModuleInfo.Ofssize;
if ( tokenarray[i].token == T_ID && ( 0 == _stricmp( tokenarray[i].string_ptr, "ABS" ) ) ) {
/* v2.07: MT_ABS is obsolete */
//ti.mem_type = MT_ABS;
i++;
} else if ( tokenarray[i].token == T_DIRECTIVE && tokenarray[i].tokval == T_PROTO ) {
/* dont scan this line further!
* CreateProto() will either define a SYM_EXTERNAL or fail
* if there's a syntax error or symbol redefinition.
*/
sym = CreateProto( i + 1, tokenarray, token, langtype );
#if 0 /* global queue is obsolete */
if ( sym && sym->isglobal == FALSE ) {
sym->isglobal = TRUE;
QAddItem( &ModuleInfo.g.GlobalQueue, sym );
}
#endif
return( sym ? NOT_ERROR : ERROR );
} else if ( tokenarray[i].token != T_FINAL && tokenarray[i].token != T_COMMA ) {
if ( GetQualifiedType( &i, tokenarray, &ti ) == ERROR )
return( ERROR );
}
isnew = FALSE;
if ( sym == NULL || sym->state == SYM_UNDEFINED ) {
sym = CreateExternal( sym, token, TRUE );
isnew = TRUE;
}
/* new symbol? */
if ( isnew ) {
DebugMsg1(("ExterndefDirective(%s): memtype=%X set, ofssize=%X\n", token, ti.mem_type, ti.Ofssize ));
/* v2.05: added to accept type prototypes */
if ( ti.is_ptr == 0 && ti.symtype && ti.symtype->isproc ) {
CreateProc( sym, NULL, SYM_EXTERNAL );
CopyPrototype( (struct dsym *)sym, (struct dsym *)ti.symtype );
ti.mem_type = ti.symtype->mem_type;
ti.symtype = NULL;
}
switch ( ti.mem_type ) {
//case MT_ABS:
case MT_EMPTY:
/* v2.04: hack no longer necessary */
//if ( sym->weak == TRUE )
// sym->equate = TRUE; /* allow redefinition by EQU, = */
break;
case MT_FAR:
/* v2.04: don't inherit current segment for FAR externals
* if -Zg is set.
*/
if ( Options.masm_compat_gencode )
break;
/* fall through */
default:
//SetSymSegOfs( sym );
sym->segment = &CurrSeg->sym;
}
sym->Ofssize = ti.Ofssize;
if ( ti.is_ptr == 0 && ti.Ofssize != ModuleInfo.Ofssize ) {
sym->seg_ofssize = ti.Ofssize;
if ( sym->segment && ((struct dsym *)sym->segment)->e.seginfo->Ofssize != sym->seg_ofssize )
sym->segment = NULL;
}
sym->mem_type = ti.mem_type;
sym->is_ptr = ti.is_ptr;
sym->isfar = ti.is_far;
sym->ptr_memtype = ti.ptr_memtype;
if ( ti.mem_type == MT_TYPE )
sym->type = ti.symtype;
else
sym->target_type = ti.symtype;
/* v2.04: only set language if there was no previous definition */
SetMangler( sym, langtype, mangle_type );
} else if ( Parse_Pass == PASS_1 ) {
/* v2.05: added to accept type prototypes */
if ( ti.is_ptr == 0 && ti.symtype && ti.symtype->isproc ) {
ti.mem_type = ti.symtype->mem_type;
ti.symtype = NULL;
}
/* ensure that the type of the symbol won't change */
if ( sym->mem_type != ti.mem_type ) {
/* if the symbol is already defined (as SYM_INTERNAL), Masm
won't display an error. The other way, first externdef and
then the definition, will make Masm complain, however */
DebugMsg(("ExterndefDirective: type conflict for %s. mem_types old-new: %X-%X\n", sym->name, sym->mem_type, ti.mem_type));
EmitWarn( 1, SYMBOL_TYPE_CONFLICT, sym->name );
} else if ( sym->mem_type == MT_TYPE && sym->type != ti.symtype ) {
struct asym *sym2 = sym;
/* skip alias types and compare the base types */
DebugMsg(("ExterndefDirective(%s): types differ: %X (%s) - %X (%s)\n", sym->name, sym->type, sym->type->name, ti.symtype, ti.symtype->name));
while ( sym2->type )
sym2 = sym2->type;
while ( ti.symtype->type )
ti.symtype = ti.symtype->type;
if ( sym2 != ti.symtype ) {
DebugMsg(("ExterndefDirective(%s): type conflict old-new: %X (%s) - %X (%s)\n", sym->name, sym2, sym2->name, ti.symtype, ti.symtype->name));
EmitWarn( 1, SYMBOL_TYPE_CONFLICT, sym->name );
}
}
/* v2.04: emit a - weak - warning if language differs.
* Masm doesn't warn.
*/
if ( langtype != LANG_NONE && sym->langtype != langtype )
EmitWarn( 3, LANGUAGE_ATTRIBUTE_CONFLICT, sym->name );
}
sym->isdefined = TRUE;
#if 0
/* write a global entry if none has been written yet */
if ( sym->state == SYM_EXTERNAL && sym->weak == FALSE )
;/* skip EXTERNDEF if a real EXTERN/COMM was done */
else if ( sym->isglobal == FALSE ) {
sym->isglobal = TRUE;
DebugMsg1(("ExterndefDirective(%s): writing a global entry\n", sym->name));
QAddItem( &ModuleInfo.g.GlobalQueue, sym );
}
#else
if ( sym->state == SYM_INTERNAL && sym->ispublic == FALSE ) {
sym->ispublic = TRUE;
AddPublicData( sym );
}
#endif
if ( tokenarray[i].token != T_FINAL )
if ( tokenarray[i].token == T_COMMA ) {
if ( (i + 1) < Token_Count )
i++;
} else {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
} while ( i < Token_Count );
return( NOT_ERROR );
}
/* SubStr()
* defines a text equate.
* syntax: name SUBSTR <string>, pos [, size]
*/
ret_code SubStrDir( int i, struct asm_tok tokenarray[] )
/******************************************************/
{
struct asym *sym;
char *name;
char *p;
//char *newvalue;
int pos;
int size;
int cnt;
bool chksize;
struct expr opndx;
DebugMsg1(("SubStrDir enter\n"));
DebugCmd( substrcnt++ );
/* at least 5 items are needed
* 0 1 2 3 4 5 6
* ID SUBSTR SRC_ID , POS [, LENGTH]
*/
#if 0 /* can't happen */
if ( i != 1 ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
if ( tokenarray[0].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[0].string_ptr ) );
}
#endif
name = tokenarray[0].string_ptr;
i++; /* go past SUBSTR */
/* third item must be a string */
if ( tokenarray[i].token != T_STRING || tokenarray[i].string_delim != '<' ) {
DebugMsg(("SubStrDir: error, no text item\n"));
return( TextItemError( &tokenarray[i] ) );
}
p = tokenarray[i].string_ptr;
cnt = tokenarray[i].stringlen;
i++;
DebugMsg1(("SubStrDir(%s): src=>%s<\n", name, p));
if ( tokenarray[i].token != T_COMMA ) {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
i++;
/* get pos, must be a numeric value and > 0 */
/* v2.11: flag NOUNDEF added - no forward ref possible */
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, EXPF_NOUNDEF ) == ERROR ) {
DebugMsg(("SubStrDir(%s): invalid pos value\n", name));
return( ERROR );
}
/* v2.04: "string" constant allowed as second argument */
//if ( opndx.kind != EXPR_CONST || opndx.string != NULL ) {
if ( opndx.kind != EXPR_CONST ) {
DebugMsg(("SubStrDir(%s): pos value is not a constant\n", name));
return( EmitError( CONSTANT_EXPECTED ) );
}
/* pos is expected to be 1-based */
pos = opndx.value;
if ( pos <= 0 ) {
return( EmitError( POSITIVE_VALUE_EXPECTED ) );
}
if ( tokenarray[i].token != T_FINAL ) {
if ( tokenarray[i].token != T_COMMA ) {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
i++;
/* get size, must be a constant */
/* v2.11: flag NOUNDEF added - no forward ref possible */
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, EXPF_NOUNDEF ) == ERROR ) {
DebugMsg(("SubStrDir(%s): invalid size value\n", name));
return( ERROR );
}
/* v2.04: string constant ok */
//if ( opndx.kind != EXPR_CONST || opndx.string != NULL ) {
if ( opndx.kind != EXPR_CONST ) {
DebugMsg(("SubStrDir(%s): size value is not a constant\n", name));
return( EmitError( CONSTANT_EXPECTED ) );
}
size = opndx.value;
if ( tokenarray[i].token != T_FINAL ) {
DebugMsg(("SubStrDir(%s): additional items found\n", name));
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
if ( size < 0 ) {
return( EmitError( COUNT_MUST_BE_POSITIVE_OR_ZERO ) );
}
chksize = TRUE;
} else {
size = -1;
chksize = FALSE;
}
#if 0
cnt = pos;
/* position p to start of substring */
for ( pos--; pos > 0 && *p ; pos--, p++ )
if ( *p == '!' && *(p+1) != NULLC )
p++;
if ( *p == NULLC ) {
return( EmitErr( INDEX_VALUE_PAST_END_OF_STRING, cnt ) );
}
if ( *p == '!' && *(p+1) != NULLC )
p++;
for ( newvalue = p, cnt = size; *p && cnt; cnt--, p++ )
if ( *p == '!' && *(p+1) != NULLC )
p++;
/* v2.04: check added */
if ( chksize && cnt ) {
return( EmitError( COUNT_VALUE_TOO_LARGE ) );
}
size = p - newvalue;
p = newvalue;
#else
if ( pos > cnt ) {
return( EmitErr( INDEX_VALUE_PAST_END_OF_STRING, pos ) );
}
if ( chksize && (pos+size-1) > cnt ) {
return( EmitError( COUNT_VALUE_TOO_LARGE ) );
}
p += pos - 1;
if ( size == -1 )
size = cnt - pos + 1;
#endif
sym = SymSearch( name );
/* if we've never seen it before, put it in */
if( sym == NULL ) {
sym = SymCreate( name );
} else if( sym->state == SYM_UNDEFINED ) {
/* it was referenced before being defined. This is
* a bad idea for preprocessor text items, because it
* will require a full second pass!
*/
sym_remove_table( &SymTables[TAB_UNDEF], (struct dsym *)sym );
#if FASTPASS
SkipSavedState();
EmitWarn( 2, TEXT_MACRO_USED_PRIOR_TO_DEFINITION, sym->name );
#endif
} else if( sym->state != SYM_TMACRO ) {
/* it is defined as something incompatible, get out */
DebugMsg(( "SubStrDir(%s) error, incompatible type\n", sym->name));
return( EmitErr( SYMBOL_REDEFINITION, sym->name ) );
}
sym->state = SYM_TMACRO;
sym->isdefined = TRUE;
#if FASTMEM==0
if ( sym->string_ptr )
LclFree( sym->string_ptr );
sym->string_ptr = (char *)LclAlloc( size + 1 );
#else
if ( sym->total_size < ( size + 1 ) ) {
LclFree( sym->string_ptr );
sym->string_ptr = LclAlloc ( size + 1 );
sym->total_size = size + 1;
}
#endif
memcpy( sym->string_ptr, p, size );
*(sym->string_ptr + size) = NULLC;
DebugMsg1(("SubStrDir(%s): result=>%s<\n", sym->name, sym->string_ptr ));
LstWrite( LSTTYPE_TMACRO, 0, sym );
return( NOT_ERROR );
}
void AddLinnumDataRef( unsigned srcfile, uint_32 line_num )
/*********************************************************/
{
struct line_num_info *curr;
#if COFF_SUPPORT
/* COFF line number info is related to functions/procedures. Since
* assembly allows code lines outside of procs, "dummy" procs must
* be generated. A dummy proc lasts until
* - a true PROC is detected or
* - the source file changes or
* - the segment/section changes ( added in v2.11 )
*/
if ( Options.output_format == OFORMAT_COFF &&
CurrProc == NULL &&
( dmyproc == NULL ||
dmyproc->debuginfo->file != srcfile ||
dmyproc->segment != (struct asym *)CurrSeg ) ) {
char procname[12];
if ( dmyproc ) {
/**/myassert( dmyproc->segment );
dmyproc->total_size =
((struct dsym *)dmyproc->segment)->e.seginfo->current_loc -
dmyproc->offset;
}
sprintf( procname, "$$$%05u", procidx );
DebugMsg1(("AddLinnumDataRef(src=%u.%u): CurrProc==NULL, dmyproc=%s searching proc=%s\n", srcfile, line_num, dmyproc ? dmyproc->name : "NULL", procname ));
dmyproc = SymSearch( procname );
/* in pass 1, create the proc */
if ( dmyproc == NULL ) {
dmyproc = CreateProc( NULL, procname, SYM_INTERNAL );
DebugMsg1(("AddLinnumDataRef: new proc %s created\n", procname ));
dmyproc->isproc = TRUE; /* flag is usually set inside ParseProc() */
dmyproc->included = TRUE;
AddPublicData( dmyproc );
} else
procidx++; /* for passes > 1, adjust procidx */
/* if the symbols isn't a PROC, the symbol name has been used
* by the user - bad! A warning should be displayed */
if ( dmyproc->isproc == TRUE ) {
SetSymSegOfs( dmyproc );
dmyproc->Ofssize = ModuleInfo.Ofssize;
dmyproc->langtype = ModuleInfo.langtype;
if ( write_to_file == TRUE ) {
curr = LclAlloc( sizeof( struct line_num_info ) );
curr->sym = dmyproc;
curr->line_number = GetLineNumber();
curr->file = srcfile;
curr->number = 0;
DebugMsg1(("AddLinnumDataRef: CURRPROC=NULL, sym=%s, calling AddLinnumData(src=%u.%u)\n", curr->sym->name, curr->file, curr->line_number ));
AddLinnumData( curr );
}
}
}
#endif
if( line_num && ( write_to_file == FALSE || lastLineNumber == line_num )) {
#ifdef DEBUG_OUT
if ( write_to_file == TRUE )
DebugMsg1(("AddLinnumDataRef(src=%u.%u) line skipped, lastline=%u\n", srcfile, line_num, lastLineNumber ));
#endif
return;
}
DebugMsg1(("AddLinnumDataRef(src=%u.%u): currofs=%Xh, CurrProc=%s, GeneratedCode=%u\n", srcfile, line_num, GetCurrOffset(), CurrProc ? CurrProc->sym.name : "NULL", ModuleInfo.GeneratedCode ));
curr = LclAlloc( sizeof( struct line_num_info ) );
curr->number = line_num;
#if COFF_SUPPORT
if ( line_num == 0 ) { /* happens for COFF only */
/* changed v2.03 (CurrProc might have been NULL) */
/* if ( Options.output_format == OFORMAT_COFF && CurrProc->sym.public == FALSE ) { */
/* v2.09: avoid duplicates, check for pass 1 */
//if ( Options.output_format == OFORMAT_COFF && CurrProc && CurrProc->sym.public == FALSE ) {
if ( Parse_Pass == PASS_1 &&
Options.output_format == OFORMAT_COFF && CurrProc && CurrProc->sym.ispublic == FALSE ) {
CurrProc->sym.included = TRUE;
AddPublicData( (struct asym *)CurrProc );
}
/* changed v2.03 */
/* curr->sym = (struct asym *)CurrProc; */
curr->sym = ( CurrProc ? (struct asym *)CurrProc : dmyproc );
curr->line_number = GetLineNumber();
curr->file = srcfile;
/* set the function's size! */
if ( dmyproc ) {
/**/myassert( dmyproc->segment );
dmyproc->total_size =
((struct dsym *)dmyproc->segment)->e.seginfo->current_loc -
dmyproc->offset;
dmyproc = NULL;
}
/* v2.11: write a 0x7fff line item if prologue exists */
if ( CurrProc && CurrProc->e.procinfo->size_prolog ) {
DebugMsg1(("AddLinnumDataRef: calling AddLinnumData(src=%u.%u) sym=%s\n", curr->file, curr->line_number, curr->sym->name ));
AddLinnumData( curr );
curr = LclAlloc( sizeof( struct line_num_info ) );
curr->number = GetLineNumber();
curr->offset = GetCurrOffset();
curr->srcfile = srcfile;
}
} else {
#endif
curr->offset = GetCurrOffset();
curr->srcfile = srcfile;
#if COFF_SUPPORT
}
#endif
lastLineNumber = line_num;
/* v2.11: added, improved multi source support for CV.
* Also, the size of line number info could have become > 1024,
* ( even > 4096, thus causing an "internal error in omfint.c" )
*/
if ( Options.output_format == OFORMAT_OMF )
omf_check_flush( curr );
/* v2.10: warning if line-numbers for segments without class code! */
if ( CurrSeg->e.seginfo->linnum_init == FALSE ) {
CurrSeg->e.seginfo->linnum_init = TRUE;
if ( TypeFromClassName( CurrSeg, CurrSeg->e.seginfo->clsym ) != SEGTYPE_CODE ) {
EmitWarn( 2, LINNUM_INFO_FOR_SEGMENT_WITHOUT_CLASS_CODE, CurrSeg->sym.name );
}
}
DebugMsg1(("AddLinnumDataRef: calling AddLinnumData(src=%u.%u ofs=%X)\n", curr->number == 0 ? curr->file : curr->srcfile, curr->number, curr->offset ));
AddLinnumData( curr );
return;
}
ret_code SegmentDir( int i, struct asm_tok tokenarray[] )
/*******************************************************/
{
char is_old;
char *token;
int typeidx;
const struct typeinfo *type; /* type of option */
int temp;
int temp2;
uint initstate = 0; /* flags for attribute initialization */
unsigned char oldreadonly; /* readonly value of a defined segment */
//unsigned char oldsegtype;
unsigned char oldOfssize;
char oldalign;
char oldcombine;
uint oldclassidx;
uint_8 oldcharacteristics;
struct dsym *dir;
char *name;
struct asym *sym;
struct expr opndx;
if ( Parse_Pass != PASS_1 )
return( SetCurrSeg( i, tokenarray ) );
if( i != 1 ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr );
return( ERROR );
}
name = tokenarray[0].string_ptr;
DebugMsg1(("SegmentDir(%s) enter: ModuleInfo.Ofssize=%u, num_seg=%u\n", name, ModuleInfo.Ofssize, ModuleInfo.g.num_segs ));
/* See if the segment is already defined */
sym = SymSearch( name );
if( sym == NULL || sym->state == SYM_UNDEFINED ) {
/* segment is not defined (yet) */
sym = (struct asym *)CreateSegment( (struct dsym *)sym, name, TRUE );
sym->list = TRUE; /* always list segments */
dir = (struct dsym *)sym;
dir->e.seginfo->seg_idx = ++ModuleInfo.g.num_segs;
is_old = FALSE;
/*
* initialize segment with values from the one without suffix
*/
#if COFF_SUPPORT || ELF_SUPPORT
if (Options.output_format == OFORMAT_COFF
#if ELF_SUPPORT
|| Options.output_format == OFORMAT_ELF
#endif
) {
char *p;
if ( p = strchr(sym->name, '$') ) {
char buffer[MAX_ID_LEN+1];
struct dsym *dir2;
memcpy(buffer, sym->name, p - sym->name);
buffer[p - sym->name] = NULLC;
if ((dir2 = (struct dsym *)SymSearch(buffer)) && dir2->sym.state == SYM_SEG) {
dir->e.seginfo->readonly = dir2->e.seginfo->readonly;
dir->e.seginfo->segtype = dir2->e.seginfo->segtype;
dir->e.seginfo->Ofssize = dir2->e.seginfo->Ofssize;
dir->e.seginfo->alignment= dir2->e.seginfo->alignment;
dir->e.seginfo->characteristics = dir2->e.seginfo->characteristics;
dir->e.seginfo->combine = dir2->e.seginfo->combine;
dir->e.seginfo->class_name_idx = dir2->e.seginfo->class_name_idx;
}
}
}
#endif
} else if ( sym->state == SYM_SEG ) {
/* segment already defined */
dir = (struct dsym *)sym;
is_old = TRUE;
oldreadonly = dir->e.seginfo->readonly;
//oldsegtype = dir->e.seginfo->segtype;
oldOfssize = dir->e.seginfo->Ofssize;
oldalign = dir->e.seginfo->alignment;
oldcharacteristics = dir->e.seginfo->characteristics;
oldcombine = dir->e.seginfo->combine;
oldclassidx = dir->e.seginfo->class_name_idx;
if( dir->e.seginfo->lname_idx == 0 ) {
/* segment was mentioned in a group statement, but not really set up */
is_old = FALSE;
/* the segment list is to be sorted.
* So unlink the segment and add it at the end.
*/
UnlinkSeg( dir );
dir->e.seginfo->seg_idx = ++ModuleInfo.g.num_segs;
dir->next = NULL;
if ( SymTables[TAB_SEG].head == NULL )
SymTables[TAB_SEG].head = SymTables[TAB_SEG].tail = dir;
else {
SymTables[TAB_SEG].tail->next = dir;
SymTables[TAB_SEG].tail = dir;
}
}
} else {
/* symbol is different kind, error */
DebugMsg(("SegmentDir(%s): symbol redefinition\n", name ));
EmitErr( SYMBOL_REDEFINITION, name );
return( ERROR );
}
i++; /* go past SEGMENT */
for( ; i < Token_Count; i++ ) {
token = tokenarray[i].string_ptr;
DebugMsg1(("SegmentDir(%s): i=%u, string=%s token=%X\n", name, i, token, tokenarray[i].token ));
if( tokenarray[i].token == T_STRING ) {
/* the class name - the only token which is of type STRING */
/* string must be delimited by [double]quotes */
if ( tokenarray[i].string_delim != '"' &&
tokenarray[i].string_delim != '\'' ) {
EmitErr( SYNTAX_ERROR_EX, token );
continue;
}
/* remove the quote delimiters */
token++;
*(token+tokenarray[i].stringlen) = NULLC;
SetSegmentClass( &dir->sym, token );
DebugMsg1(("SegmentDir(%s): class found: %s\n", name, token ));
continue;
}
/* check the rest of segment attributes.
*/
typeidx = FindToken( token, SegAttrToken, sizeof( SegAttrToken )/sizeof( SegAttrToken[0] ) );
if( typeidx < 0 ) {
EmitErr( UNKNOWN_SEGMENT_ATTRIBUTE, token );
continue;
}
type = &SegAttrValue[typeidx];
/* initstate is used to check if any field is already
* initialized
*/
if( initstate & INIT_EXCL_MASK & type->init ) {
EmitErr( SEGMENT_ATTRIBUTE_DEFINED_ALREADY, token );
continue;
} else {
initstate |= type->init; /* mark it initialized */
}
switch ( type->init ) {
case INIT_ATTR:
dir->e.seginfo->readonly = TRUE;
break;
case INIT_ALIGN:
DebugMsg1(("SegmentDir(%s): align attribute found\n", name ));
dir->e.seginfo->alignment = type->value;
break;
case INIT_ALIGN_PARAM:
DebugMsg1(("SegmentDir(%s): ALIGN() found\n", name ));
if ( Options.output_format == OFORMAT_OMF ) {
EmitErr( NOT_SUPPORTED_WITH_OMF_FORMAT, tokenarray[i].string_ptr );
i = Token_Count; /* stop further parsing of this line */
break;
}
i++;
if ( tokenarray[i].token != T_OP_BRACKET ) {
EmitErr( EXPECTED, "(" );
break;
}
i++;
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, 0 ) == ERROR )
break;
if ( tokenarray[i].token != T_CL_BRACKET ) {
EmitErr( EXPECTED, ")" );
break;
}
if ( opndx.kind != EXPR_CONST ) {
EmitError( CONSTANT_EXPECTED );
break;
}
/*
COFF allows alignment values
1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192
*/
for( temp = 1, temp2 = 0; temp < opndx.value && temp < 8192 ; temp <<= 1, temp2++ );
if( temp != opndx.value ) {
EmitError( POWER_OF_2 );
}
dir->e.seginfo->alignment = temp2;
break;
case INIT_COMBINE:
DebugMsg1(("SegmentDir(%s): combine attribute found\n", name ));
dir->e.seginfo->combine = type->value;
break;
case INIT_COMBINE_AT:
DebugMsg1(("SegmentDir(%s): AT found\n", name ));
dir->e.seginfo->combine = type->value;
/* v2.05: always use MAX_SEGALIGNMENT */
//dir->e.seginfo->alignment = -1;
dir->e.seginfo->alignment = MAX_SEGALIGNMENT;
i++;
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, 0 ) != ERROR ) {
if ( opndx.kind == EXPR_CONST ) {
dir->e.seginfo->abs_frame = opndx.value;
dir->e.seginfo->abs_offset = 0;
} else {
EmitError( CONSTANT_EXPECTED );
}
}
break;
#if COMDATSUPP
case INIT_COMBINE_COMDAT:
DebugMsg1(("SegmentDir(%s): COMDAT found\n", name ));
if ( Options.output_format != OFORMAT_COFF ) {
EmitErr( NOT_SUPPORTED_WITH_CURR_FORMAT, tokenarray[i].string_ptr );
i = Token_Count; /* stop further parsing of this line */
break;
}
i++;
if ( tokenarray[i].token != T_OP_BRACKET ) {
EmitErr( EXPECTED, "(" );
break;
}
i++;
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, 0 ) == ERROR )
break;
if ( opndx.kind != EXPR_CONST ) {
EmitError( CONSTANT_EXPECTED );
i = Token_Count; /* stop further parsing of this line */
break;
}
if ( opndx.value < 1 || opndx.value > 6 ) {
EmitErr( VALUE_NOT_WITHIN_ALLOWED_RANGE, "1-6" );
} else {
/* if value is IMAGE_COMDAT_SELECT_ASSOCIATIVE,
* get the associated segment name argument.
*/
if ( opndx.value == 5 ) {
struct asym *sym2;
if ( tokenarray[i].token != T_COMMA ) {
EmitError( EXPECTING_COMMA );
i = Token_Count; /* stop further parsing of this line */
break;
}
i++;
if ( tokenarray[i].token != T_ID ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr );
i = Token_Count; /* stop further parsing of this line */
break;
}
/* associated segment must be COMDAT, but not associative */
sym2 = SymSearch( tokenarray[i].string_ptr );
if ( sym2 == NULL ||
sym2->state != SYM_SEG ||
((struct dsym *)sym2)->e.seginfo->comdat_selection == 0 ||
((struct dsym *)sym2)->e.seginfo->comdat_selection == 5 )
EmitErr( INVALID_ASSOCIATED_SEGMENT, tokenarray[i].string_ptr );
else
dir->e.seginfo->comdat_number = ((struct dsym *)sym2)->e.seginfo->seg_idx;
i++;
}
}
if ( tokenarray[i].token != T_CL_BRACKET ) {
EmitErr( EXPECTED, ")" );
break;
}
dir->e.seginfo->comdat_selection = opndx.value;
dir->e.seginfo->combine = type->value;
break;
#endif
case INIT_OFSSIZE:
case INIT_OFSSIZE_FLAT:
/* v2.07: check for compatible cpu mode */
if ( type->value == USE32 && ( ( ModuleInfo.curr_cpu & P_CPU_MASK ) < P_386 )
#if AMD64_SUPPORT
|| type->value == USE64 && ( ( ModuleInfo.curr_cpu & P_CPU_MASK ) < P_64 )
#endif
) {
EmitError( INSTRUCTION_OR_REGISTER_NOT_ACCEPTED_IN_CURRENT_CPU_MODE );
break;
}
if ( type->init == INIT_OFSSIZE_FLAT ) {
DefineFlatGroup();
#if AMD64_SUPPORT
dir->e.seginfo->Ofssize = ModuleInfo.defOfssize;
#else
dir->e.seginfo->Ofssize = USE32;
#endif
/* put the segment into the FLAT group.
* this is not quite Masm-compatible, because trying to put
* the segment into another group will cause an error.
*/
dir->e.seginfo->group = &ModuleInfo.flat_grp->sym;
} else
dir->e.seginfo->Ofssize = type->value;
break;
#if COFF_SUPPORT || ELF_SUPPORT
case INIT_CHAR_INFO:
dir->e.seginfo->info = TRUE;
break;
case INIT_CHAR:
DebugMsg1(("SegmentDir(%s): characteristics found\n", name ));
; /* characteristics are restricted to COFF/ELF */
if ( Options.output_format == OFORMAT_OMF || Options.output_format == OFORMAT_BIN ) {
EmitErr( NOT_SUPPORTED_WITH_CURR_FORMAT, tokenarray[i].string_ptr );
} else
dir->e.seginfo->characteristics |= type->value;
break;
case INIT_ALIAS:
DebugMsg1(("SegmentDir(%s): ALIAS found\n", name ));
if ( Options.output_format != OFORMAT_COFF &&
Options.output_format != OFORMAT_ELF ) {
EmitErr( NOT_SUPPORTED_WITH_CURR_FORMAT, tokenarray[i].string_ptr );
i = Token_Count; /* stop further parsing of this line */
break;
}
i++;
if ( tokenarray[i].token != T_OP_BRACKET ) {
EmitErr( EXPECTED, "(" );
break;
}
i++;
if ( tokenarray[i].token != T_STRING ||
( tokenarray[i].string_delim != '"' &&
tokenarray[i].string_delim != '\'' ) ) {
EmitErr( SYNTAX_ERROR_EX, token );
i = Token_Count; /* stop further parsing of this line */
break;
}
temp = i;
i++;
if ( tokenarray[i].token != T_CL_BRACKET ) {
EmitErr( EXPECTED, ")" );
break;
}
dir->e.seginfo->aliasname = LclAlloc( tokenarray[temp].stringlen );
memcpy( dir->e.seginfo->aliasname, tokenarray[temp].string_ptr+1, tokenarray[temp].stringlen );
*(dir->e.seginfo->aliasname+tokenarray[temp].stringlen) = NULLC;
break;
#endif
#ifdef DEBUG_OUT
default: /* shouldn't happen */
myassert( 0 );
break;
#endif
}
} /* end for */
/* make a guess about the segment's type */
if( dir->e.seginfo->segtype != SEGTYPE_CODE ) {
enum seg_type res;
token = GetLname( dir->e.seginfo->class_name_idx );
res = TypeFromClassName( dir, token );
if( res != SEGTYPE_UNDEF ) {
dir->e.seginfo->segtype = res;
}
#if 0 /* v2.03: removed */
else {
res = TypeFromSegmentName( name );
dir->e.seginfo->segtype = res;
}
#endif
}
if( is_old ) {
int txt = 0;
/* Check if new definition is different from previous one */
// oldobj = dir->e.seginfo->segrec;
if( oldreadonly != dir->e.seginfo->readonly )
txt = TXT_READONLY;
else if ( oldalign != dir->e.seginfo->alignment )
txt = TXT_ALIGNMENT;
else if ( oldcombine != dir->e.seginfo->combine )
txt = TXT_COMBINE;
else if ( oldOfssize != dir->e.seginfo->Ofssize )
txt = TXT_SEG_WORD_SIZE;
else if ( oldclassidx != dir->e.seginfo->class_name_idx )
txt = TXT_CLASS; /* Masm warns only! */
else if ( oldcharacteristics != dir->e.seginfo->characteristics )
txt = TXT_CHARACTERISTICS;
if ( txt ) {
EmitErr( SEGDEF_CHANGED, dir->sym.name, MsgGetEx( txt ) );
//return( ERROR ); /* v2: display error, but continue */
}
} else {
/* A new definition */
sym = &dir->sym;
sym->isdefined = TRUE;
sym->segment = sym;
sym->offset = 0;
if( dir->e.seginfo->lname_idx == 0 ) {
dir->e.seginfo->lname_idx = ++LnamesIdx;
AddLnameData( sym );
}
}
push_seg( dir ); /* set CurrSeg */
if ( ModuleInfo.list )
LstWrite( LSTTYPE_LABEL, 0, NULL );
return( SetOfssize() );
}
ret_code CatStrDir( int i, struct asm_tok tokenarray[] )
/******************************************************/
{
struct asym *sym;
int count;
char *p;
/* struct expr opndx; */
DebugMsg1(("CatStrDir(%u) enter\n", i ));
DebugCmd( catstrcnt++ );
#if 0 /* can't happen */
/* syntax must be <id> CATSTR textitem[,textitem,...] */
if ( i != 1 ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
if ( tokenarray[0].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[0].string_ptr ) );
}
#endif
i++; /* go past CATSTR/TEXTEQU */
/* v2.08: don't copy to temp buffer */
//*StringBufferEnd = NULLC;
/* check correct syntax and length of items */
for ( count = 0; i < Token_Count; ) {
DebugMsg1(("CatStrDir(%s): item[%u]=%s delim=0x%x\n", tokenarray[0].string_ptr, i, tokenarray[i].string_ptr, tokenarray[i].string_delim ));
if ( tokenarray[i].token != T_STRING || tokenarray[i].string_delim != '<' ) {
DebugMsg(("CatStrDir: error, not a <>-literal: %s\n", tokenarray[i].tokpos ));
return( TextItemError( &tokenarray[i] ) );
}
/* v2.08: using tokenarray.stringlen is not quite correct, since some chars
* are stored in 2 bytes (!) */
if ( ( count + tokenarray[i].stringlen ) >= MAX_LINE_LEN ) {
DebugMsg(("CatStrDir: error, literal too long: %u + %u >= %u\n", count, tokenarray[i].stringlen, MAX_LINE_LEN ));
return( EmitError( STRING_OR_TEXT_LITERAL_TOO_LONG ) );
}
/* v2.08: don't copy to temp buffer */
//strcpy( StringBufferEnd + count, tokenarray[i].string_ptr );
count = count + tokenarray[i].stringlen;
i++;
if ( ( tokenarray[i].token != T_COMMA ) &&
( tokenarray[i].token != T_FINAL ) ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
i++;
}
sym = SymSearch( tokenarray[0].string_ptr );
if ( sym == NULL ) {
sym = SymCreate( tokenarray[0].string_ptr );
DebugMsg1(( "CatStrDir: new symbol %s created\n", sym->name));
} else if( sym->state == SYM_UNDEFINED ) {
/* v2.01: symbol has been used already. Using
* a textmacro before it has been defined is
* somewhat problematic.
*/
sym_remove_table( &SymTables[TAB_UNDEF], (struct dsym *)sym );
#if FASTPASS
SkipSavedState(); /* further passes must be FULL! */
#endif
EmitWarn( 2, TEXT_MACRO_USED_PRIOR_TO_DEFINITION, sym->name );
} else if( sym->state != SYM_TMACRO ) {
/* it is defined as something else, get out */
DebugMsg(( "CatStrDir(%s) exit, symbol redefinition\n", sym->name));
return( EmitErr( SYMBOL_REDEFINITION, sym->name ) );
}
sym->state = SYM_TMACRO;
sym->isdefined = TRUE;
#if FASTMEM==0
if ( sym->string_ptr )
LclFree( sym->string_ptr );
sym->string_ptr = (char *)LclAlloc( count + 1 );
#else
/* v2.08: reuse string space if fastmem is on */
if ( sym->total_size < ( count+1 ) ) {
LclFree( sym->string_ptr ); /* is a noop if fastmem is on */
sym->string_ptr = (char *)LclAlloc( count + 1 );
sym->total_size = count + 1;
}
#endif
/* v2.08: don't use temp buffer */
//memcpy( sym->string_ptr, StringBufferEnd, count + 1 );
for ( i = 2, p = sym->string_ptr; i < Token_Count; i += 2 ) {
memcpy( p, tokenarray[i].string_ptr, tokenarray[i].stringlen );
p += tokenarray[i].stringlen;
}
*p = NULLC;
DebugMsg1(("CatStrDir(%s) (new) value: >%s<\n", sym->name, sym->string_ptr ));
if ( ModuleInfo.list )
LstWrite( LSTTYPE_TMACRO, 0, sym );
return( NOT_ERROR );
}
ret_code GrpDir( int i, struct asm_tok tokenarray[] )
/***************************************************/
{
char *name;
struct dsym *grp;
struct dsym *seg;
/* GROUP directive must be at pos 1, needs a name at pos 0 */
if( i != 1 ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr );
return( ERROR );
}
#if COFF_SUPPORT || ELF_SUPPORT
/* GROUP valid for OMF + BIN only */
if ( Options.output_format == OFORMAT_COFF
#if ELF_SUPPORT
|| Options.output_format == OFORMAT_ELF
#endif
) {
EmitError( GROUP_DIRECTIVE_INVALID_FOR_COFF );
return( ERROR );
}
#endif
grp = CreateGroup( tokenarray[0].string_ptr );
if( grp == NULL )
return( ERROR );
i++; /* go past GROUP */
do {
/* get segment name */
if ( tokenarray[i].token != T_ID ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr );
return( ERROR );
}
name = tokenarray[i].string_ptr;
i++;
seg = (struct dsym *)SymSearch( name );
if ( Parse_Pass == PASS_1 ) {
if( seg == NULL || seg->sym.state == SYM_UNDEFINED ) {
seg = CreateSegment( seg, name, TRUE );
/* inherit the offset magnitude from the group */
if ( grp->e.grpinfo->seglist )
seg->e.seginfo->Ofssize = grp->sym.Ofssize;
} else if( seg->sym.state != SYM_SEG ) {
EmitErr( SEGMENT_EXPECTED, name );
return( ERROR );
} else if( seg->e.seginfo->group != NULL &&
seg->e.seginfo->group != &grp->sym ) {
/* segment is in another group */
DebugMsg(("GrpDir: segment >%s< is in group >%s< already\n", name, seg->e.seginfo->group->name));
EmitErr( SEGMENT_IN_ANOTHER_GROUP, name );
return( ERROR );
}
/* the first segment will define the group's word size */
if( grp->e.grpinfo->seglist == NULL ) {
grp->sym.Ofssize = seg->e.seginfo->Ofssize;
} else if ( grp->sym.Ofssize != seg->e.seginfo->Ofssize ) {
EmitErr( GROUP_SEGMENT_SIZE_CONFLICT, grp->sym.name, seg->sym.name );
return( ERROR );
}
} else {
/* v2.04: don't check the "defined" flag. It's for IFDEF only! */
//if( seg == NULL || seg->sym.state != SYM_SEG || seg->sym.defined == FALSE ) {
/* v2.07: check the "segment" field instead of "defined" flag! */
//if( seg == NULL || seg->sym.state != SYM_SEG ) {
if( seg == NULL || seg->sym.state != SYM_SEG || seg->sym.segment == NULL ) {
EmitErr( SEG_NOT_DEFINED, name );
return( ERROR );
}
}
/* insert segment in group if it's not there already */
if ( seg->e.seginfo->group == NULL ) {
struct seg_item *si;
/* set the segment's grp */
seg->e.seginfo->group = &grp->sym;
si = LclAlloc( sizeof( struct seg_item ) );
si->seg = seg;
si->next = NULL;
grp->e.grpinfo->numseg++;
/* insert the segment at the end of linked list */
if( grp->e.grpinfo->seglist == NULL ) {
grp->e.grpinfo->seglist = si;
} else {
struct seg_item *curr;
curr = grp->e.grpinfo->seglist;
while( curr->next != NULL ) {
curr = curr->next;
}
curr->next = si;
}
}
if ( i < Token_Count ) {
if ( tokenarray[i].token != T_COMMA || tokenarray[i+1].token == T_FINAL ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].tokpos );
return( ERROR );
}
i++;
}
} while ( i < Token_Count );
return( NOT_ERROR );
}
