msgbuild.cpp

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

{
    char buf[256];              // - buffer
    char* bptr;                 // - buffer ptr

    text = scanOverWS( text );
    char const* symbeg = text;
    text = scanOverBS( text );
    checkEOL( text );
    unsigned size = text - symbeg;
    if( 0 == size ) {
        scanError( "no symbol for :MSGSYM" );
    }
    char* sym = (char*)alloca( size + 1 );
    sym[ size ] = '\0';
    memcpy( sym, symbeg, size );
    bptr = concatStr( buf, "#define " );
    bptr = concatStr( bptr, sym );
    bptr[0] = ' ';
    bptr = concatHex( &bptr[1], ( grp_num << 10 ) + sym_num );
    codes.write( buf );
}


static void processInput        // PROCESS INPUT
    ( void )
{
    char buffer[256];           // - record buffer
    RecType rec_type;           // - record type
    MsgType msg_type;           // - message type
    ProcState proc_state;       // - processing state
    char const *text;           // - scanner in buffer
    unsigned short groupNum;    // - group number
    unsigned short symbolNum;   // - symbol number

    groupNum = 0;
    symbolNum = 0;
    proc_state = START_LINE;
    for( ; ; ) {
        if( gml.getline( buffer, sizeof( buffer ) ) ) {
            ++line_ctr;
            text = scanOverWS( buffer );
            if( text[0] != ':' ) {
                continue;
            } else {
                ++text;
                for( _KwGml const *kwp = kwTable; ; ++ kwp ) {
                    char const *kw = kwp->kw;
                    if( 0 == kw ) {
                        rec_type = REC_NONE;
                        break;
                    } else {
                        unsigned size = kwp->kw_size;
                        if( 0 == memicmp( text, kw, size ) ) {
                            rec_type = kwp->rec_type;
                            msg_type = kwp->msg_type;
                            text += size;
                            if( text[ 0 ] == '.' ) {
                                ++ text;
                            }
                            break;
                        }
                    }
                }
            }
            if( rec_type == REC_NONE ) continue;
        } else {
            rec_type = REC_EOF;
        }
        ProcState next_state = stateTable[ proc_state ][ rec_type ];
        switch( next_state ) {
          case GROUP_LINE :
            groupNum++;
            symbolNum = 0;
//          processGroup( text );
            proc_state = next_state;
            continue;
          case SYM_NO_GRP :
            processSymbol( text, 0, symbolNum  );
            proc_state = next_state;
            continue;
          case SYM_GROUP :
            processSymbol( text, groupNum, symbolNum  );
            proc_state = next_state;
            continue;
          case TEXT_GROUP :
          case TEXT_NO_GRP :
            processText( text, symbolNum );
            ++ symbolNum;
            proc_state = next_state;
            continue;
          case FOUND_PHR :
//          processPhrase( text );
            continue;
          case MOD_GROUP :
          case MOD_NO_GRP :
          { byte level;
            switch( msg_type ) {
              case MSG_TYPE_ERROR :
              case MSG_TYPE_WARNING :
              case MSG_TYPE_ANSI :
              case MSG_TYPE_EXTWARN :
              case MSG_TYPE_ANSIWARN :
                level = scanLevel( text );
                break;
              case MSG_TYPE_INFO :
              case MSG_TYPE_ANSIERR :
              case MSG_TYPE_ANSICOMP :
                level = 0;
                break;
            }
            Msg::setModifier( msg_type, level );
          } continue;
          case PRE_EOF :
            scanError( "Premature End-of-File" );
          case GRP_NOT_FRST :
            scanError( "Group is not first token in file" );
          case MISPL_TXT :
            scanError( "Misplaced text token" );
          case MISPL_SYM :
            scanError( "Misplaced symbol token" );
          case MISPL_MOD :
            scanError( "Misplaced message modifier" );
          case DUP_MOD :
            scanError( "More than one message modifier" );
          case FOUND_EOF :
            break;
          default :
            scanError( "Error when reading new state" );
        }
        break;
    }
}


static void produceMessages     // PRODUCE MESSAGES
    ( void )
{
    char buf[256];              // - buffer
    char* bptr;                 // - buffer ptr

    msgs.write( "#define ENC_BIT 0x80" );
    msgs.write( "#define LARGE_BIT 0x40" );
    bptr = concatStr( buf, "#define MAX_MSG " );
    bptr = concatHex( bptr, stats.max_message );
    msgs.write( buf );
    msgs.write( "" );
    Word::sort();
    unsigned short enced = Word::encode();
    msgs.write( "MSG_SCOPE unsigned short MSG_MEM group_table[]= " );
    stats.size_written = enced;
    stats.delim = '{';
    Msg::writeGroupOffsets( stats, msgs );
    msgs.write( "};\n" );
    msgs.write( "MSG_SCOPE unsigned short MSG_MEM text_table[] = " );
    stats.size_written = 0;
    stats.delim = '{';
    Word::writeOffsets( stats, msgs );
    msgs.write( "// messages" );
    Msg::writeOffsets( stats, msgs );
    msgs.write( "};\n" );
    bptr = concatStr( buf, "MSG_SCOPE unsigned short MSG_MEM word_count = " );
    bptr = concatDec( bptr, enced );
    bptr = concatStr( bptr, ";\n" );
    msgs.write( buf );
    msgs.write( "MSG_SCOPE unsigned char MSG_MEM encoded_text[] =" );
    stats.delim = '{';
    Word::writeEncoded( stats, msgs );
    Msg::writeEncoded( stats, msgs );
    msgs.write( "};\n" );
}


static char const * const levelData[] = // constant level data
{   "typedef enum"
,   "{   MSG_TYPE_ERROR"
,   ",   MSG_TYPE_WARNING"
,   ",   MSG_TYPE_INFO"
,   ",   MSG_TYPE_ANSI"
,   ",   MSG_TYPE_ANSIERR"
,   ",   MSG_TYPE_ANSIWARN"
,   ",   MSG_TYPE_ANSICOMP"
,   ",   MSG_TYPE_EXTWARN"
,   "} MSG_TYPE;"
,   " "
,   "static unsigned char msg_level[] ="
,   0
};

static void produceLevels       // PRODUCE LEVELS
    ( void )
{
    for( char const * const * dp = levelData; *dp != 0; ++dp ) {
        levels.write(  *dp );
    }
    stats.delim = '{';
    Msg::writeLevels( stats, levels );
    levels.write( "};\n" );
}


int main                        // MAIN-LINE
    ( int count                 // - # args
    , char const *args[] )      // - arguments
{
    int retn;                   // - return code
    char buf[256];              // - buffer
    char* bptr;                 // - buffer ptr

    try {
        if( count != 5 ) {
            display_help();
            retn = 1;
        } else {
            gml.open( args[1], "gml" );
            codes.open( args[3], "gh" );
            processInput();
            codes.close();
            gml.close();
            msgs.open( args[2], "gc" );
            produceMessages();
            msgs.close();
            levels.open( args[4], "gh" );
            produceLevels();
            levels.close();
            Space percent = ( stats.space_put_out * 100
                            + stats.space_read_in / 2 )
                            / stats.space_read_in;
            bptr = concatStr( buf, "original size = " );
            bptr = concatDec( bptr, stats.space_read_in );
            bptr = concatStr( bptr, " encoded size = " );
            bptr = concatDec( bptr, stats.space_put_out );
            bptr = concatStr( bptr, " compression = " );
            bptr = concatDec( bptr, percent );
            bptr[0] = '%';
            bptr[1] = '\0';
            puts( buf );
            retn = 0;
        }
    } catch( Exc const& except ) {
        puts( except );
        retn = -1;
    } catch( ... ) {
        puts( "MSGBUILD -- unexpected exception" );
        retn = -1;
    }
    return 0;
}