objemit.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 807 行 · 第 1/2 页

        case EASY_EXEC_ONLY:    Emit( "EO " );  break;
        case EASY_EXEC_READ:    Emit( "ER " );  break;
        case EASY_READ_WRITE:   Emit( "RW " );  break;
        }
    }
}


static  void  EmitSegCombine( void )
/**********************************/

{
    char                combine;

    if( Segment->class == TYPE_COMDAT ) return;
    combine = _SegCombine( Segment );
    switch( combine ) {
    case 0:
        if( ( Options & FORM_ASSEMBLER ) == 0 ) {
            Emit( "PRIVATE " );
        }
        break;
    case 2:
        Emit( "PUBLIC " );
        break;
    case 5:
        Emit( "STACK " );
        break;
    case 6:
        Emit( "COMMON " );
        break;
    }
}


void  EmitEndSeg()
/****************/

{
    if( !DO_UNIX ) {
        if( Segment->name != NULL ) {
            if( Options & FORM_ASSEMBLER ) {
                if( Segment->start != 0 ) {
                    EmitOrg( Segment->start );
                }
                EmitSegName( Segment, LABEL_LEN );
                EmitLine( "ENDS" );
                EmitNL();
            } else {
                DumpImpList();
                EmitDashes( LINE_LEN );
            }
        }
    } else {
        EmitNL();
    }
}


void  EmitLabel( char *lbl, uint_32 origin )
/******************************************/

{
    if( DO_UNIX ) {
        EmitSpaced( ".bss", LABEL_LEN );
        EmitSym( lbl, 0 );
        EmitSpaced( ", ", OPCODE_LEN - strlen( lbl ) );
        EmitOrg( origin );
    } else {
        EmitOrg( origin );
        EmitSym( lbl, LABEL_LEN );
        if( Segment->data_seg ) {
            EmitLine( "LABEL   BYTE" );
        } else {
            EmitLine( "LABEL   NEAR" );
        }
    }
}

void EmitHex( uint_32 val )
/*************************/
{
    char                numbuff[ 16 ];

    DoIToHS( numbuff, val, WORD_SIZE );
    Emit( numbuff );
}


static void EmitOrg( uint_32 origin )
/***********************************/

{
    if( !DO_UNIX ) {
        EmitBlanks( LABEL_LEN );
        EmitSpaced( "ORG", OPCODE_LEN );
    }
    EmitHex( origin );
    EmitNL();
}


void  DoEmit( int msg_num )
/***************/
{
    char        msg_buff[MAX_RESOURCE_SIZE];

    MsgGet( msg_num, msg_buff );
    Emit( msg_buff );
}


void  Emit( str )
/***************/

    char                *str;
{
    if( ( Pass == 2 ) && ( str != NULL ) ) {
        PutString( str );
    }
}


void  EmitNL()
/************/

{
    if( Pass == 2 ) {
        FPutEnd( Output );
    }
}


void  EmitLine( ptr )
/*******************/

    char                *ptr;
{
    Emit( ptr );
    EmitNL();
}


void  EmitAddr( uint_32 addr, int len, char *straddr )
/*************************************/
{
    char                buff[ 16 ];

    Emit( " " );
    IToHS( buff, addr, len );
    buff[ len ] = NULLCHAR;
    if( straddr == NULL ){
        Emit( buff );
    } else {
        strcpy( straddr, buff );
    }
}


void  EmitDashes( int length )
/****************************/
{
    int                 i;

    i = 0;
    while( ++i <= length ) {
        Emit( "-" );
    }
    EmitNL();
}


void  EmitBlanks( int blanks )
/****************************/
{
    do {
        Emit( " " );
    } while( --blanks > 0 );
}


void  DoEmitSpaced( int msgnum, int spacing )
/******************************************/
{
    char        rc_buff[MAX_RESOURCE_SIZE];

    MsgGet( msgnum, rc_buff );
    EmitSpaced( rc_buff, spacing );
}


int  EmitSpaced( char *str, int spacing )
/***************************************/
{
    int                 length;
    int                 over;

    if( str == NULL ) {
        length = 0;
    } else {
        length = strlen( str );
        Emit( str );
    }
    over = (length >= spacing);
    do {
        Emit( " " );
    } while( ++length < spacing );
    return( over );
}

int EmitSym( char *sym, unsigned spacing )
{
    return( EmitSpaced( FormSym( sym ), spacing ) );
}

void EmitSegName( segment *seg, unsigned spacing )
{
    if( seg->class == TYPE_COMDAT ) {
        EmitSym( seg->name, spacing );
    } else {
        EmitSpaced( seg->name, spacing );
    }
}


void  DoEmitError( int msg_num )
/**************************/
{
    char        msg_buff[MAX_RESOURCE_SIZE];

    MsgGet( msg_num, msg_buff );
    EmitError( msg_buff );
}


void  EmitError( char *msg )
/**************************/
{
    if( Options & FORM_ASSEMBLER ) {
        Emit( "; " );
    }
    DoEmit( MSG_ERROR );
    EmitLine( msg );
    ++ErrCount;
}


void  EmitLoc()
/*************/

{
    if( ( Options & FORM_ASSEMBLER ) == 0 ) {
        EmitAddr( InsAddr, 4, NULL );
        Emit( "  " );
    }
}


void  EmitBytes()
/***************/

{
    int                 len, curr_len;
    char                DataBuff[ 3 ];

    if( ( Options & FORM_ASSEMBLER ) == 0 ) {
        len = 0;
        curr_len = 0;
        if( DataBytes != 0 ) {
            for( ;; ) {
                IToHS( DataBuff, DataString[ len ], 2 );
                DataBuff[ 2 ] = NULLCHAR;
                Emit( DataBuff );
                Emit( " " );
                ++len;
                ++curr_len;
                if( len >= DataBytes ) break;
                if( curr_len == DataLen ) {
                    EmitNL();
                    Emit( "       " );
                    curr_len = 0;
                }
            }
        }
        while( ++curr_len <= DataLen ) {
            Emit( "   " );
        }
    }
}


void  EmitSrc()
/*************/

{
    if( Source != NULL && Pass == 2 ) {
        FindSrcLine( GetOffset() );
    }
}


void  InitAsm()
/*************/

{
    ErrCount = 0;
    InitBuffs();
    if( Segment->data_seg ) {
        DataLen = 8;
    } else {
        DataLen = 6;
    }
}


static  void  InitBuffs()
/***********************/

{
    NameBuff[ 0 ] = NULLCHAR;
}


void  FiniAsm()
/*************/

{
    char                numbuff[ 16 ];

    if( ( Options & FORM_ASSEMBLER ) == 0 && Pass != 1 ) {
        EmitNL();
        if( ErrCount == 0 ) {
            DoEmit( MSG_NO_DISASM_ERR );
        } else {
            itoa( ErrCount, numbuff, 10 );
            SubStrEmit( MSG_DISASM_ERR, numbuff, 's' );
        }
        EmitNL();
        EmitNL();
    }
}


void  EmitDups()
/**************/

{
    int                 i;
    char                numbuff[ 16 ];

    itoa( Repeats - 1, numbuff, 10 );
    if( Options & FORM_ASSEMBLER ) {
        EmitBlanks( LABEL_LEN );
        Emit( DBstring() );
        Emit( numbuff );
        Emit( " DUP(" );
        i = 0;
        do {
            if( i > 0 ) {
                Emit( "," );
            }
            DoIToHS( numbuff, PrevString[ i ], 2 );
            Emit( numbuff );
        } while( ++i != MAX_DATA_LEN );
        EmitLine( ")" );
    } else {
        SubStrEmit( MSG_ABOVE_LN_REPEAT, numbuff, 's' );
        EmitNL();
    }
    Repeats = 0;
}


static void EmitRetFMacro( void )
/*******************************/

{
    char                **str;
    char                tmp_buff[ 8 ];

    strcpy( tmp_buff, "retf" );
    if( Options & FORM_NAME_UPPER ) {
        ZapUpper( tmp_buff );
    }
    Emit( tmp_buff );
    str = RetFMacro;
    while( *str != NULL ) {
        EmitLine( *str );
        ++str;
    }
}


static void SubStrEmit( int msgnum, char *para, char specifier )
/**************************************************************/
{
    char        msg_buff[MAX_RESOURCE_SIZE];

    MsgGet( msgnum, msg_buff );
    MsgSubStr( msg_buff, para, specifier );
    Emit( msg_buff );
}