static ret_code GetToken( hll_list * hll, int *i, bool is_true, expr_list * opndx )
/*********************************************************************************/
{
int end_tok;
/* scan for the next C operator in the token array.
because the ASM evaluator will report an error if such a thing
is found */
for ( end_tok = *i; end_tok < Token_Count; end_tok++ ) {
int j = end_tok;
if ( ( GetCOp( &j ) ) != COP_NONE )
break;
}
opndx->kind = EXPR_EMPTY;
if ( end_tok > *i )
if ( ERROR == EvalOperand( i, end_tok, opndx, TRUE ) )
return( ERROR );
return( NOT_ERROR );
}
static ret_code GetNumber( char *string, int *pi, struct asm_tok tokenarray[] )
/*****************************************************************************/
{
struct expr opndx;
int i;
int last;
last = Tokenize( string, Token_Count+1, tokenarray, TOK_RESCAN );
i = Token_Count+1;
if( EvalOperand( &i, tokenarray, last, &opndx, EXPF_NOUNDEF ) == ERROR ) {
return( ERROR );
}
/* v2.11: string constants are accepted ( although hardly useful ) */
//if( opndx.kind != EXPR_CONST || opndx.quoted_string != NULL || tokenarray[i].token != T_FINAL ) {
if( opndx.kind != EXPR_CONST || tokenarray[i].token != T_FINAL ) {
return( EmitErr( SYNTAX_ERROR_EX, string ) );
}
*pi = opndx.value;
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 AssumeDirective( int i, struct asm_tok tokenarray[] )
/************************************************************/
/* Handles ASSUME
* syntax is :
* - ASSUME
* - ASSUME NOTHING
* - ASSUME segregister : seglocation [, segregister : seglocation ]
* - ASSUME dataregister : qualified type [, dataregister : qualified type ]
* - ASSUME register : ERROR | NOTHING | FLAT
*/
{
int reg;
int j;
int size;
uint_32 flags;
struct assume_info *info;
bool segtable;
struct qualified_type ti;
DebugMsg1(( "AssumeDirective enter, pass=%u\n", Parse_Pass+1 ));
for( i++; i < Token_Count; i++ ) {
if( ( tokenarray[i].token == T_ID )
&& (0 == _stricmp( tokenarray[i].string_ptr, szNothing )) ) {
AssumeInit();
i++;
break;
}
/*---- get the info ptr for the register ----*/
info = NULL;
if ( tokenarray[i].token == T_REG ) {
reg = tokenarray[i].tokval;
j = GetRegNo( reg );
flags = GetValueSp( reg );
if ( flags & OP_SR ) {
info = &SegAssumeTable[j];
segtable = TRUE;
} else if ( flags & OP_R ) {
info = &StdAssumeTable[j];
segtable = FALSE;
}
}
if ( info == NULL ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr );
return( ERROR );
}
if( ( ModuleInfo.curr_cpu & P_CPU_MASK ) < GetCpuSp( reg ) ) {
EmitError( INSTRUCTION_OR_REGISTER_NOT_ACCEPTED_IN_CURRENT_CPU_MODE );
return( ERROR );
}
i++; /* go past register */
if( tokenarray[i].token != T_COLON ) {
EmitError( COLON_EXPECTED );
return( ERROR );
}
i++;
if( tokenarray[i].token == T_FINAL ) {
EmitError( SYNTAX_ERROR );
return( ERROR );
}
/* check for ERROR and NOTHING */
if( 0 == _stricmp( tokenarray[i].string_ptr, szError )) {
if ( segtable ) {
info->flat = FALSE;
info->error = TRUE;
} else
info->error |= (( reg >= T_AH && reg <= T_BH ) ? RH_ERROR : ( flags & OP_R ));
info->symbol = NULL;
i++;
} else if( 0 == _stricmp( tokenarray[i].string_ptr, szNothing )) {
if ( segtable ) {
info->flat = FALSE;
info->error = FALSE;
} else
info->error &= ~(( reg >= T_AH && reg <= T_BH ) ? RH_ERROR : ( flags & OP_R ));
info->symbol = NULL;
i++;
} else if ( segtable == FALSE ) {
/* v2.05: changed to use new GetQualifiedType() function */
ti.size = 0;
ti.is_ptr = 0;
ti.is_far = FALSE;
ti.mem_type = MT_EMPTY;
ti.ptr_memtype = MT_EMPTY;
ti.symtype = NULL;
ti.Ofssize = ModuleInfo.Ofssize;
if ( GetQualifiedType( &i, tokenarray, &ti ) == ERROR )
return( ERROR );
/* v2.04: check size of argument! */
size = OperandSize( flags, NULL );
if ( ( ti.is_ptr == 0 && size != ti.size ) ||
( ti.is_ptr > 0 && size < CurrWordSize ) ) {
EmitError( TYPE_IS_WRONG_SIZE_FOR_REGISTER );
return( ERROR );
}
info->error &= ~(( reg >= T_AH && reg <= T_BH ) ? RH_ERROR : ( flags & OP_R ));
if ( stdsym[j] == NULL ) {
stdsym[j] = CreateTypeSymbol( NULL, "", FALSE );
stdsym[j]->typekind = TYPE_TYPEDEF;
}
stdsym[j]->total_size = ti.size;
stdsym[j]->mem_type = ti.mem_type;
stdsym[j]->is_ptr = ti.is_ptr;
stdsym[j]->isfar = ti.is_far;
stdsym[j]->Ofssize = ti.Ofssize;
stdsym[j]->ptr_memtype = ti.ptr_memtype; /* added v2.05 rc13 */
if ( ti.mem_type == MT_TYPE )
stdsym[j]->type = ti.symtype;
else
stdsym[j]->target_type = ti.symtype;
info->symbol = stdsym[j];
} else { /* segment register */
struct expr opnd;
/* v2.08: read expression with standard evaluator */
if( EvalOperand( &i, tokenarray, Token_Count, &opnd, 0 ) == ERROR )
return( ERROR );
switch ( opnd.kind ) {
case EXPR_ADDR:
if ( opnd.sym == NULL || opnd.indirect == TRUE || opnd.value ) {
EmitError( SEGMENT_GROUP_OR_SEGREG_EXPECTED );
return( ERROR );
} else if ( opnd.sym->state == SYM_UNDEFINED ) {
/* ensure that directive is rerun in pass 2
* so an error msg can be emitted.
*/
FStoreLine(0);
info->symbol = opnd.sym;
} else if ( ( opnd.sym->state == SYM_SEG || opnd.sym->state == SYM_GRP ) && opnd.instr == EMPTY ) {
info->symbol = opnd.sym;
} else if ( opnd.instr == T_SEG ) {
info->symbol = opnd.sym->segment;
} else {
EmitError( SEGMENT_GROUP_OR_SEGREG_EXPECTED );
return( ERROR );
}
info->flat = ( info->symbol == &ModuleInfo.flat_grp->sym );
break;
case EXPR_REG:
if ( GetValueSp( opnd.base_reg->tokval ) & OP_SR ) {
info->symbol = SegAssumeTable[ GetRegNo( opnd.base_reg->tokval ) ].symbol;
info->flat = SegAssumeTable[ GetRegNo( opnd.base_reg->tokval ) ].flat;
break;
}
default:
EmitError( SEGMENT_GROUP_OR_SEGREG_EXPECTED );
return( ERROR );
}
info->error = FALSE;
}
/* comma expected */
if( i < Token_Count && tokenarray[i].token != T_COMMA )
break;
}
if ( i < Token_Count ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].tokpos );
return( ERROR );
}
return( NOT_ERROR );
}
ret_code LoopDirective( int i, struct asm_tok tokenarray[] )
/**********************************************************/
{
int directive = tokenarray[i].tokval;
int arg_loc;
int len;
//int skipcomma;
char *parmstring;
char *ptr;
struct dsym *macro;
bool is_exitm;
struct expr opnd;
struct macro_info macinfo;
struct dsym tmpmacro;
#ifdef DEBUG_OUT
uint_32 count = 0;
#endif
/* v2.08: use myalloca() to get space to store the argument */
//char line[MAX_LINE_LEN];
char buffer[4];
DebugMsg1(("LoopDirective(%s) enter\n", GetResWName( directive, NULL ) ));
i++; /* skip directive */
if ( ModuleInfo.list == TRUE ) LstWriteSrcLine();
switch ( directive ) {
case T_WHILE:
arg_loc = i;
/* no break */
case T_REPT:
case T_REPEAT:
/* the expression is "critical", that is, no forward
* referenced symbols may be used here!
*/
if ( EvalOperand( &i, tokenarray, Token_Count, &opnd, EXPF_NOUNDEF ) == ERROR ) {
opnd.value = 0;
i = Token_Count;
} else if ( opnd.kind != EXPR_CONST ) { /* syntax <REPEAT|WHILE 'A'> is valid! */
DebugMsg(( "LoopDirective(%s): invalid argument type %u\n", GetResWName( directive, NULL ), opnd.kind ));
EmitError( CONSTANT_EXPECTED );
opnd.value = 0;
} else if( tokenarray[i].token != T_FINAL ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].tokpos );
/* v2.09: don't exit, the macro lines must be read first. */
//return( ERROR );
opnd.value = 0;
}
break;
default: /* FOR, FORC, IRP, IRPC */
/* get the formal parameter and the argument list */
/* the format parameter will become a macro parameter, so it can
* be a simple T_ID, but also an instruction or something else.
* v2.02: And it can begin with a '.'!
*/
if( tokenarray[i].token == T_FINAL ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i-1].tokpos ) );
}
/* v2.02: allow parameter name to begin with a '.' */
//c = *tokenarray[i].string_ptr;
//if( ( is_valid_id_char(c) == FALSE ) || ( isdigit(c) == TRUE ) ) {
if( is_valid_id_first_char( *tokenarray[i].string_ptr ) == FALSE ) {
DebugMsg(( "LoopDirective(FOR/FORC): token %s is not a valid parameter name\n", tokenarray[i].string_ptr ));
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].tokpos ) );
}
arg_loc = i;
i++;
if( directive == T_FORC || directive == T_IRPC ) {
if( tokenarray[i].token != T_COMMA ) {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
i++;
/* FORC/IRPC accepts anything as "argument list", even nothing! */
if( tokenarray[i].token == T_STRING && tokenarray[i].string_delim == '<' ) {
len = tokenarray[i+1].tokpos - (tokenarray[i].tokpos+1);
parmstring = myalloca( len );
//GetLiteralValue( parmstring, tokenarray[i].string_ptr );
memcpy( parmstring, tokenarray[i].tokpos+1, len );
while( *(parmstring+len-1) != '>' ) len--;
*(parmstring+len-1) = NULLC;
/* v2.02: if there's additional stuff behind the <> literal,
* it's an error!
*/
if ( tokenarray[i+1].token != T_FINAL )
EmitErr( SYNTAX_ERROR_EX, tokenarray[i+1].tokpos );
} else {
char *ptr2;
ptr = tokenarray[i].tokpos;
ptr2 = ptr;
/* this is what Masm does: use the string until a space
* is detected. Anything beyond the space is ignored.
*/
while ( *ptr2 && ( isspace( *ptr2 ) == FALSE ) )
ptr2++;
len = ptr2 - ptr;
parmstring = myalloca( len + 1 );
memcpy( parmstring, ptr, len );
*(parmstring+len) = NULLC;
}
} else {
/* for FOR/IRP, skip everything between the name and the comma!
* these items will be stored as (first) macro parameter.
* for example, valid syntax is:
* FOR xxx,<a, ...>
* FOR xxx:REQ,<a, ...>
*/
while ( tokenarray[i].token != T_FINAL && tokenarray[i].token != T_COMMA )
i++;
if( tokenarray[i].token != T_COMMA ) {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
i++;
/* FOR/IRP accepts a literal enclosed in <> only */
if( tokenarray[i].token != T_STRING || tokenarray[i].string_delim != '<' ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].tokpos ) );
}
/* v2.03: also ensure that the literal is the last item */
if( tokenarray[i+1].token != T_FINAL ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i+1].tokpos ) );
}
/* v2.08: use myalloca() instead of a fixed-length buffer.
* the loop directives are often nested, they call RunMacro()
* and hence should be careful with stack usage because of JWASMR!
*/
//parmstring = myalloca( tokenarray[i].stringlen + 1 );
/* v2.0: use GetLiteralValue() instead of memcpy!!! */
//memcpy( line, tokenarray[i].string_ptr, tokenarray[i].stringlen + 1 );
//GetLiteralValue( parmstring, tokenarray[i].string_ptr );
parmstring = tokenarray[i].string_ptr;
DebugMsg1(("LoopDirective(FOR): param string >%s<\n", parmstring));
}
/* to run StoreMacro(), tokenarray must be setup correctly. */
/* clear contents beginning with the comma! */
i--;
tokenarray[i].token = T_FINAL;
Token_Count = i;
i = arg_loc;
}
/* now make a temporary macro */
macro = &tmpmacro;
memset( &tmpmacro, 0, sizeof(tmpmacro) );
tmpmacro.sym.name = "";
tmpmacro.e.macroinfo = &macinfo;
memset( &macinfo, 0, sizeof(macinfo) );
macinfo.srcfile = get_curr_srcfile();
#if 0 //DEBUG_OUT
if ( directive == T_WHILE )
tmpmacro.sym.name = "<WHILE>";
else if ( directive == T_REPEAT || directive == T_REPT )
tmpmacro.sym.name = "<REPT>";
else if ( directive == T_FORC || directive == T_IRPC )
tmpmacro.sym.name = "<FORC>";
else
tmpmacro.sym.name = "<FOR>";
#endif
DebugMsg1(("LoopDirective(%s): calling StoreMacro\n", GetResWName( directive, NULL )));
if( StoreMacro( macro, i, tokenarray, TRUE ) == ERROR ) {
ReleaseMacroData( macro );
return( ERROR );
}
/* EXITM <> is allowed inside a macro loop.
* This doesn't make the loop a macro function, reset the bit!
*/
macro->sym.isfunc = FALSE;
/* now run the just created macro in a loop */
/* don't run the macro if there are no lines (macroinfo->data == NULL)!
* this isn't exactly what Masm does; an empty 'WHILE 1'
* will loop "forever" in Masm,
*/
if ( macinfo.data ) /* added in v2.01 */
switch ( directive ) {
case T_REPEAT:
case T_REPT:
/* negative repeat counts are accepted and are treated like 0 */
for ( ; macro->sym.value < opnd.value; macro->sym.value++ ) {
/* v2.10: Token_Count becomes volatile if MF_NOSAVE is set */
tokenarray[0].token = T_FINAL;
Token_Count = 0;
//RunMacro( macro, Token_Count, tokenarray, NULL, MF_NOSAVE, &is_exitm );
RunMacro( macro, 0, tokenarray, NULL, MF_NOSAVE, &is_exitm );
if ( is_exitm )
break;
DebugMsg1(("LoopDirective REPT: iteration=%" I32_SPEC "u\n", ++count ));
}
break;
case T_WHILE:
while ( opnd.kind == EXPR_CONST && opnd.value != 0 ) {
DebugMsg1(("LoopDirective WHILE: cnt=%u\n", count++ ));
RunMacro( macro, Token_Count, tokenarray, NULL, 0, &is_exitm );
if ( is_exitm )
break;
i = arg_loc;
if ( EvalOperand( &i, tokenarray, Token_Count, &opnd, 0 ) == ERROR )
break;
macro->sym.value++;
}
break;
case T_FORC:
case T_IRPC:
for( ptr = parmstring; *ptr; ptr++, macro->sym.value++ ) {
tokenarray[0].token = T_STRING;
tokenarray[0].string_delim = NULLC;
tokenarray[0].string_ptr = buffer;
tokenarray[0].tokpos = buffer;
tokenarray[1].token = T_FINAL;
buffer[2] = NULLC;
Token_Count = 1;
if ( *ptr == '!' ) {
buffer[0] = *ptr++;
buffer[1] = *ptr;
if ( *ptr == NULLC ) /* ensure the macro won't go beyond the 00 */
ptr--;
tokenarray[0].stringlen = 2;
tokenarray[1].tokpos = buffer+2;
} else if ( isspace( *ptr ) ) {
buffer[0] = '!';
buffer[1] = *ptr;
tokenarray[0].stringlen = 2;
tokenarray[1].tokpos = buffer+2;
} else {
buffer[0] = *ptr;
tokenarray[0].stringlen = 1;
tokenarray[1].tokpos = buffer+1;
buffer[1] = NULLC;
}
RunMacro( macro, 0, tokenarray, NULL, MF_NOSAVE, &is_exitm );
if ( is_exitm )
break;
DebugMsg1(("LoopDirective FORC: call RunMacro(), cnt=%" I32_SPEC "u, param=>%s<\n", count++, buffer ));
}
break;
default: /* T_FOR, T_IRP */
i = Token_Count + 1;
Token_Count = Tokenize( parmstring, i, tokenarray, TOK_RESCAN | TOK_NOCURLBRACES );
DebugMsg1(("LoopDirective FOR: full param=>%s<\n", tokenarray[i].tokpos ));
/* v2.09: if a trailing comma is followed by white space(s), add a blank token */
if ( i != Token_Count && tokenarray[Token_Count-1].token == T_COMMA &&
*(tokenarray[Token_Count-1].tokpos+1) ) {
tokenarray[Token_Count].token = T_STRING;
tokenarray[Token_Count].string_delim = NULLC;
tokenarray[Token_Count].stringlen = strlen( tokenarray[Token_Count].tokpos );
tokenarray[Token_Count+1].tokpos = tokenarray[Token_Count].tokpos + tokenarray[Token_Count].stringlen;
Token_Count++;
tokenarray[Token_Count].token = T_FINAL;
}
/* a FOR/IRP parameter can be a macro function call */
/* that's why the macro calls must be run synchronously */
/* v2.05: reset an optional VARARG attribute for the macro
* parameter.
* take care of a trailing comma, this is to make another
* RunMacro() call with a "blank" argument.
*/
macro->sym.mac_vararg = FALSE;
/* v2.09: flag MF_IGNARGS introduced. This allows RunMacro() to
* parse the full argument and trigger macro expansion if necessary.
* No need anymore to count commas here. */
for( ; i < Token_Count; i++, macro->sym.value++ ) {
DebugMsg1(("LoopDirective FOR: cnt=%" I32_SPEC "u, calling RunMacro( param=>%s< )\n", count++, tokenarray[i].tokpos ));
i = RunMacro( macro, i, tokenarray, NULL, MF_IGNARGS, &is_exitm );
if ( i < 0 || is_exitm )
break;
}
}
ReleaseMacroData( macro );
DebugMsg1(("LoopDirective(%s) exit\n", GetResWName( directive, NULL ) ));
return( NOT_ERROR );
}
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() );
}
/* InStr()
* defines a numeric variable which contains position of substring.
* syntax:
* name INSTR [pos,]string, substr
*/
ret_code InStrDir( int i, struct asm_tok tokenarray[] )
/*****************************************************/
{
struct asym *sym;
int sizestr;
int j;
/* int commas; */
char *src;
char *p;
char *q;
char *string1;
struct expr opndx;
int start = 1;
int strpos;
DebugMsg1(("InStrDir entry\n"));
DebugCmd( instrcnt++ );
if ( i != 1) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
#if 0 /* this is checked in ParseLine() */
if ( tokenarray[0].token != T_ID ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[0].string_ptr ) );
}
#endif
i++; /* go past INSTR */
if ( tokenarray[i].token != T_STRING || tokenarray[i].string_delim != '<' ) {
/* v2.11: flag NOUNDEF added - no forward reference accepted */
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, EXPF_NOUNDEF ) == ERROR )
return( ERROR );
if ( opndx.kind != EXPR_CONST ) {
return( EmitError( CONSTANT_EXPECTED ) );
}
start = opndx.value;
if ( start <= 0 ) {
/* v2.05: don't change the value. if it's invalid, the result
* is to be 0. Emit a level 3 warning instead.
*/
//start = 1;
EmitWarn( 3, POSITIVE_VALUE_EXPECTED );
}
if ( tokenarray[i].token != T_COMMA ) {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
i++; /* skip comma */
}
if ( tokenarray[i].token != T_STRING || tokenarray[i].string_delim != '<' ) {
return( TextItemError( &tokenarray[i] ) );
}
/* to compare the strings, the "visible" format is needed, since
* the possible '!' operators inside the strings is optional and
* must be ignored.
*/
//src = StringBufferEnd;
//sizestr = GetLiteralValue( src, tokenarray[i].string_ptr );
src = tokenarray[i].string_ptr;
sizestr = tokenarray[i].stringlen;
DebugMsg1(("InStrDir: first string >%s< \n", src ));
if ( start > sizestr ) {
return( EmitErr( INDEX_VALUE_PAST_END_OF_STRING, start ) );
}
p = src + start - 1;
i++;
if ( tokenarray[i].token != T_COMMA ) {
return( EmitErr( EXPECTING_COMMA, tokenarray[i].tokpos ) );
}
i++;
if ( tokenarray[i].token != T_STRING || tokenarray[i].string_delim != '<' ) {
return( TextItemError( &tokenarray[i] ) );
}
//q = GetAlignedPointer( src, sizestr );
//j = GetLiteralValue( q, tokenarray[i].string_ptr );
q = tokenarray[i].string_ptr;
j = tokenarray[i].stringlen;
DebugMsg1(("InStrDir: second string >%s< \n", q ));
i++;
if ( tokenarray[i].token != T_FINAL ) {
return( EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr ) );
}
strpos = 0;
/* v2.05: check for start > 0 added */
/* v2.08: check for j > 0 added */
if ( ( start > 0 ) && ( sizestr >= j ) && j && ( string1 = strstr( p, q ) ))
strpos = string1 - src + 1;
if ( sym = CreateVariable( tokenarray[0].string_ptr, strpos ) ) {
DebugMsg1(("InStrDir(%s) exit, value=%u\n", tokenarray[0].string_ptr, strpos));
LstWrite( LSTTYPE_EQUATE, 0, sym );
return ( NOT_ERROR );
}
return( 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 );
}
ret_code SimplifiedSegDir( int i, struct asm_tok tokenarray[] )
/*************************************************************/
/*
Handles simplified segment directives:
.CODE, .STACK, .DATA, .DATA?, .FARDATA, .FARDATA?, .CONST
*/
{
const char *name = NULL;
char init;
int type;
struct expr opndx;
DebugMsg1(("SimplifiedSegDir(%s) enter\n", tokenarray[i].string_ptr ));
LstWrite( LSTTYPE_DIRECTIVE, 0, NULL );
if( ModuleInfo.model == MODEL_NONE ) {
EmitError( MODEL_IS_NOT_DECLARED );
return( ERROR );
}
//type = tokenarray[i].value;
type = GetSflagsSp( tokenarray[i].tokval );
i++; /* get past the directive token */
if( type == SIM_STACK ) {
if ( EvalOperand( &i, tokenarray, Token_Count, &opndx, 0 ) == ERROR )
return( ERROR );
if( opndx.kind == EXPR_EMPTY )
opndx.value = DEFAULT_STACK_SIZE;
else if( opndx.kind != EXPR_CONST ) {
EmitError( CONSTANT_EXPECTED );
return( ERROR );
}
} else {
/* Masm accepts a name argument for .CODE and .FARDATA[?] only.
* JWasm also accepts this for .DATA[?] and .CONST unless
* option -Zne is set.
*/
if( tokenarray[i].token == T_ID &&
( type == SIM_CODE || type == SIM_FARDATA || type == SIM_FARDATA_UN
|| ( Options.strict_masm_compat == FALSE &&
( type == SIM_DATA || type == SIM_DATA_UN || type == SIM_CONST )))) {
name = tokenarray[i].string_ptr;
i++;
}
}
if ( tokenarray[i].token != T_FINAL ) {
EmitErr( SYNTAX_ERROR_EX, tokenarray[i].string_ptr );
return( ERROR );
}
NewLineQueue();
if( type != SIM_STACK )
close_currseg(); /* emit a "xxx ENDS" line to close current seg */
if ( name == NULL )
init = ( ModuleInfo.simseg_init & ( 1 << type ) );
switch( type ) {
case SIM_CODE: /* .code */
SetSimSeg( SIM_CODE, name );
if( ModuleInfo.model == MODEL_TINY ) {
/* v2.05: add the named code segment to DGROUP */
if ( name )
AddToDgroup( SIM_CODE, name );
name = szDgroup;
} else if( ModuleInfo.model == MODEL_FLAT ) {
name = "FLAT";
} else {
if( name == NULL )
name = SegmNames[SIM_CODE];
}
AddLineQueueX( "%r %r:%s", T_ASSUME, T_CS, name );
break;
case SIM_STACK: /* .stack */
/* if code is generated which does "emit" bytes,
* the original source line has to be saved.
* v2.05: must not be done after LstWrite() has been called!
* Also, there are no longer bytes "emitted".
*/
//FStoreLine();
SetSimSeg( SIM_STACK, NULL );
AddLineQueueX( "ORG 0%xh", NUMQUAL opndx.value );
EndSimSeg( SIM_STACK );
/* add stack to dgroup for some segmented models */
if ( !init )
if ( ModuleInfo.distance != STACK_FAR )
AddToDgroup( SIM_STACK, NULL );
break;
case SIM_DATA: /* .data */
case SIM_DATA_UN: /* .data? */
case SIM_CONST: /* .const */
SetSimSeg( type, name );
AddLineQueueX( "%r %r:ERROR", T_ASSUME, T_CS );
if ( name || (!init) )
AddToDgroup( type, name );
break;
case SIM_FARDATA: /* .fardata */
case SIM_FARDATA_UN: /* .fardata? */
SetSimSeg( type, name );
AddLineQueueX( "%r %r:ERROR", T_ASSUME, T_CS );
break;
default: /* shouldn't happen */
/**/myassert( 0 );
break;
}
RunLineQueue();
DebugMsg1(("SimplifiedSegDir exit\n"));
return( NOT_ERROR );
}
