/ray/src/vm/input/tasm/tasm-scanner.ll

Go to the documentation of this file.

%{
/*
 * vm/input/tasm/tasm-scanner.ll
 * 
 * VM plaintext assembly scanner (lexical analysis). 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */


#include <lib/message/message.h>
#include <lib/lex/basicparse.h>

#include <vm/input/tasm/tasm-scanner.h>

#include <ctype.h>


#define YY_EXTRA_TYPE  class TextAsmScanner*

// Special "trick": include scannerbase.cc for the first time: 
#include <lib/lex/scannerbase.cc>

// Get pointer where to store token info (string/integer/float val...)
#define TOK()    ((TextAsmScanner::Token*)(yyextra->_tok_ptr()))

// Check whether an instruction may be specified now. 
#define CHECK_INST_ALLOWED  if(!yyextra->_CheckInstAllowed()) break;

// Used at start of instruction to keep position info up-to-date. 
#define PI_INST()  do { PI_LINE(); PI_START(); } while(0)

// There some ugly macros for the code lexing. But IMO, code is more 
// readable like that and there is no easy C++ replacement. 
#define SWITCH_BSIL(idx,MNEMO) \
    switch(yytext[idx]) \
    { \
        case 'b':  inst=VM::INST::MNEMO ## B;  break; \
        case 's':  inst=VM::INST::MNEMO ## S;  break; \
        case 'i':  inst=VM::INST::MNEMO ## I;  break; \
        case 'l':  inst=VM::INST::MNEMO ## L;  break; \
        default: Assert(0); \
    }

#define SWITCH_BSILFD(idx,MNEMO) \
    switch(yytext[idx]) \
    { \
        case 'b':  inst=VM::INST::MNEMO ## B;  break; \
        case 's':  inst=VM::INST::MNEMO ## S;  break; \
        case 'i':  inst=VM::INST::MNEMO ## I;  break; \
        case 'l':  inst=VM::INST::MNEMO ## L;  break; \
        case 'f':  inst=VM::INST::MNEMO ## F;  break; \
        case 'd':  inst=VM::INST::MNEMO ## D;  break; \
        default: Assert(0); \
    }

#define SWITCH_BSILPAFD(idx,MNEMO) \
    switch(yytext[idx]) \
    { \
        case 'b':  inst=VM::INST::MNEMO ## B;  break; \
        case 's':  inst=VM::INST::MNEMO ## S;  break; \
        case 'i':  inst=VM::INST::MNEMO ## I;  break; \
        case 'l':  inst=VM::INST::MNEMO ## L;  break; \
        case 'p':  inst=VM::INST::MNEMO ## P;  break; \
        case 'a':  inst=VM::INST::MNEMO ## A;  break; \
        case 'f':  inst=VM::INST::MNEMO ## F;  break; \
        case 'd':  inst=VM::INST::MNEMO ## D;  break; \
        default: Assert(0); \
    }

#define SWITCH_BSILF_D_(idx,MNEMO) \
    switch(yytext[idx]) \
    { \
        case 'b':  inst=VM::INST::MNEMO ## B;  break; \
        case 's':  inst=VM::INST::MNEMO ## S;  break; \
        case 'i':  inst=VM::INST::MNEMO ## I;  break; \
        case 'l':  inst=VM::INST::MNEMO ## L;  break; \
        case 'f': \
            switch(yytext[idx+1]) \
            { \
                case '2':  inst=VM::INST::MNEMO ## F2;  break; \
                case '3':  inst=VM::INST::MNEMO ## F3;  break; \
                case '4':  inst=VM::INST::MNEMO ## F4;  break; \
                default:   inst=VM::INST::MNEMO ## F;   break; \
            } \
            break; \
        case 'd': \
            switch(yytext[idx+1]) \
            { \
                case '2':  inst=VM::INST::MNEMO ## D2;  break; \
                case '3':  inst=VM::INST::MNEMO ## D3;  break; \
                case '4':  inst=VM::INST::MNEMO ## D4;  break; \
                default:   inst=VM::INST::MNEMO ## D;   break; \
            } \
            break; \
        default: Assert(0); \
    }

#define SWITCH_BSILPAF_D_(idx,MNEMO) \
    switch(yytext[idx]) \
    { \
        case 'b':  inst=VM::INST::MNEMO ## B;  break; \
        case 's':  inst=VM::INST::MNEMO ## S;  break; \
        case 'i':  inst=VM::INST::MNEMO ## I;  break; \
        case 'l':  inst=VM::INST::MNEMO ## L;  break; \
        case 'p':  inst=VM::INST::MNEMO ## P;  break; \
        case 'a':  inst=VM::INST::MNEMO ## A;  break; \
        case 'f': \
            switch(yytext[idx+1]) \
            { \
                case '2':  inst=VM::INST::MNEMO ## F2;  break; \
                case '3':  inst=VM::INST::MNEMO ## F3;  break; \
                case '4':  inst=VM::INST::MNEMO ## F4;  break; \
                default:   inst=VM::INST::MNEMO ## F;   break; \
            } \
            break; \
        case 'd': \
            switch(yytext[idx+1]) \
            { \
                case '2':  inst=VM::INST::MNEMO ## D2;  break; \
                case '3':  inst=VM::INST::MNEMO ## D3;  break; \
                case '4':  inst=VM::INST::MNEMO ## D4;  break; \
                default:   inst=VM::INST::MNEMO ## D;   break; \
            } \
            break; \
        default: Assert(0); \
    }

#define SWITCH_PARW(idx,MNEMO) \
    switch(yytext[idx]) \
    { \
        case 'p': \
            switch(yytext[idx+1]) \
            { \
                case 'r':  inst=VM::INST::MNEMO ## PR;  break; \
                case 'w':  inst=VM::INST::MNEMO ## PW;  break; \
                default: Assert(0); \
            } \
            break; \
        case 'a': \
            switch(yytext[idx+1]) \
            { \
                case 'r':  inst=VM::INST::MNEMO ## AR;  break; \
                case 'w':  inst=VM::INST::MNEMO ## AW;  break; \
                default: Assert(0); \
            } \
            break; \
        default: Assert(0); \
    }

static void _CheckCmdEnd(const char *s)
{
    while(isspace(*s))  ++s;
    Assert(*s=='#' || *s=='\0');
}

// These ugly defines make the flex-generated scanner use OUR memory 
// (de)allocation routines. 
#define malloc(p)        ALLOC<char>(p)
#define realloc(p,size)  REALLOC<char>(p,size)
#define free(p)          FREE<char>(p)

%}

/* Generate scanner file by using: 
 * flex -s tasm-scanner.ll    [works with flex >= 2.5.10] */

%pointer
%option 8bit
%option reentrant
/*%option bison-bridge*/
/* option bison-locations does NOT calculate locations; just passes 
 * the structure to store the pos. Then, I don't need it. */
/*%option bison-locations*/
/*%option yylineno*/
%option nodefault
%option noyywrap
%option stack
%option prefix="TASM_"
%option outfile="tasm-scanner.cc"
/*%option header-file="tasm-scanner.hh"*/


/* IN_CMT -> comment */
%x IN_CMT
/* IN_SKIPSPC -> skip until next (white) space [error recovery] */
%x IN_SKIPSPC
/* IN_SKIPSPC -> skip until next newline [error recovery] */
%x IN_SKIPNL

/* IN_SYM -> in object and symbol description */
%s IN_SYM
/* IN_GLOBAL -> in "vglobal"/"pglobal" within IN_SYM */
%s IN_GLOBAL
/* IN_VTABLE -> in "vtable" within IN_SYM */
%s IN_VTBL
/* IN_BASE -> in "base" block within IN_SYM */
%s IN_BASE
/* IN_SYMBS -> in "symbols" block within IN_SYM */
%s IN_SYMBS
/* IN_VARS -> in "size" (=variables) block within IN_SYM */
%s IN_VARS

/* IN_LOC -> in location description */
%s IN_LOC

/* IN_PRG -> in program code (instruction) section */
%x IN_PRG

/* IN_INFO -> in info section */
%s IN_INFO


name        [[:alpha:]_][[:alnum:]_]*
uint        0?([[:digit:]]+|(x[[:xdigit:]]+))
sint        [+-]?{uint}
flt         [+-]?(((([[:digit:]]+\.?)|([[:digit:]]*\.[[:digit:]]+))([eE][+-]?[[:digit:]]+)?)|(0x(([[:xdigit:]]+\.?)|([[:xdigit:]]*\.[[:xdigit:]]+))p[[:digit:]]+))
typeid      {sint}
wspace      [[:space:]]+
wspace_opt  {wspace}?
stype       [bsilfd]|p({wspace_opt}">"{wspace_opt}{typeid})?|a[bsilfdp]
fname       {name}?"~"[[:alnum:]_%]+
ftype       s?("function"|"func"|"method"|"meth"|"vmethod"|"vmeth")
codemark    "&"{wspace_opt}{uint}
symref_ni   "$"{wspace_opt}{uint}
symref_ie   "$"{wspace_opt}{sint}

/* instruction spacing (between args) */
is          [ \t]*
/* instruction begin: */
ib          \t
/* instruction end: my include comment */
ie          {is}("#"[^\n]*)?\n
/* end of a label */
label_end   {is}":"{ie}

bsilpaf_d_  [bsilpa]|f[234]?|d[234]?
bsilf_d_    [bsil]|f[234]?|d[234]?


%%

    /*================================<COMMENT>===============================*/
<IN_CMT>.*\n  {
        PI_LINE();
        PI_START();
        yy_pop_state(yyscanner);
    }
<IN_CMT><<EOF>>  {
        PI_EOF();
        PI_TOK();
        PI_START();
        yy_pop_state(yyscanner);
        return(0);
    }
<IN_CMT>.  {
        /* This rule will normally not match (only if terminated by EOF). */
        PI_CHAR(yytext[0]);
        PI_START();
    }

    /*==========================<SKIP until next SPACE>=======================*/
<IN_SKIPSPC>[^[:space:]]*{wspace}  {
        PI_STR(yytext,yyleng);
        yy_pop_state(yyscanner);
        PI_START();
    }
<IN_SKIPSPC>.  {
        /* This rule will normally not match (only if terminated by EOF). */
        PI_CHAR(yytext[0]);
        yy_pop_state(yyscanner);
        PI_START();
    }

    /*=========================<SKIP until next NEWLINE>======================*/
<IN_SKIPNL>.*\n  {
        PI_LINE();
        yy_pop_state(yyscanner);
        PI_START();
    }
<IN_SKIPNL>.  {
        /* This rule will normally not match (only if terminated by EOF). */
        PI_CHAR(yytext[0]);
        yy_pop_state(yyscanner);
        PI_START();
    }

    /*======================<OBJECT / SYMBOL DESCRIPTION>=====================*/
<IN_INFO>"abiversion"{wspace}[[:alnum:]_\-/.]+  {
        PI_STR(yytext,yyleng);
        TOK()->str_val=yyextra->_ParseNameStr(yytext+10,yytext+yyleng);
        return(TextAsmScanner::TI_abivers);
    }
    
    /*==============================<INFO SECTION>============================*/
<IN_SYM>"namespace"{wspace}{name}  {
        PI_STR(yytext,yyleng);
        TOK()->str_val=yyextra->_ParseNameStr(yytext+9,yytext+yyleng);
        return(TextAsmScanner::TS_namespace);
    }
<IN_SYM>"class"{wspace_opt}{typeid}{wspace_opt}{name}  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseInt(&TOK()->tid,yytext+5);
        TOK()->str_val=yyextra->_ParseNameStr(s,yytext+yyleng);
        return(TextAsmScanner::TS_class);
    }
<IN_SYM>"base"{wspace}{uint}  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseInt(&TOK()->num,yytext+4);
        Assert(!*s);   // lexer rules ensure that
        yy_push_state(IN_BASE,yyscanner);
        return(TextAsmScanner::TS_base);
    }
<IN_SYM>"size"{wspace}{uint}{wspace}{uint}({wspace_opt}","{wspace_opt}{uint})?  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseInt(&TOK()->size,yytext+4);
                    s=yyextra->_ParseInt(&TOK()->num_p,s);
        if(*s)
        {
            while(isspace(*s))  ++s;
            Assert(*s==',');   // lexer rules ensure that
            s=yyextra->_ParseInt(&TOK()->num_v,s+1);
        }
        else
        {  TOK()->num_v=0;  }
        Assert(!*s);   // lexer rules ensure that
        yy_push_state(IN_VARS,yyscanner);
        return(TextAsmScanner::TS_size);
    }
<IN_SYM>"virtual"{wspace}{uint}  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseInt(&TOK()->num,yytext+7);
        Assert(!*s);   // lexer rules ensure that
        return(TextAsmScanner::TS_virtual);
    }
<IN_SYM>"vtable"{wspace}{uint}  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseInt(&TOK()->num,yytext+6);
        Assert(!*s);   // lexer rules ensure that
        yy_push_state(IN_VTBL,yyscanner);
        return(TextAsmScanner::TS_vtable);
    }
<IN_SYM>"symbols"  {
        PI_STR(yytext,yyleng);
        yy_push_state(IN_SYMBS,yyscanner);
        return(TextAsmScanner::TS_symbols);
    }
<IN_SYM>[vp]"global"{wspace}{uint}  {
        PI_TOK();
        const char *s=yyextra->_ParseInt(&TOK()->size,yytext+7);
        Assert(!*s);   // lexer rules ensure that
        yy_push_state(IN_GLOBAL,yyscanner);
        switch(yytext[0])
        {
            case 'v':  return(TextAsmScanner::TS_vglobal);
            case 'p':  return(TextAsmScanner::TS_pglobal);
            default:  Assert(0);
        } // not reached. 
    }
<IN_SYM>"pglobal"  {
        PI_TOK();
        yy_push_state(IN_GLOBAL,yyscanner);
        return(TextAsmScanner::TS_pglobal);
    }
<IN_SYM>";"  {
        PI_TOK();
        return(TextAsmScanner::T_pop);
    }

<IN_GLOBAL>{stype}{wspace}{uint}{wspace_opt}{symref_ni}  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseTypeSpec(&TOK()->t,yytext);
                    s=yyextra->_ParseInt(&TOK()->off,s);
                    s=yyextra->_ParseInt(&TOK()->symref,s,'$');
        Assert(!*s);   // lexer rules ensure that
        return(TextAsmScanner::TS_globvar);
    }
<IN_GLOBAL>";"  {
        PI_TOK();
        yy_pop_state(yyscanner);
        return(TextAsmScanner::T_pop);
    }

<IN_VTBL>{symref_ie}  {
        PI_TOK();
        const char *s=yyextra->_ParseInt(&TOK()->symref,yytext,'$');
        Assert(!*s);   // lexer rules ensure that
        return(TextAsmScanner::TS_symref);
    }
<IN_VTBL>";"  {
        PI_TOK();
        yy_pop_state(yyscanner);
        return(TextAsmScanner::T_pop);
    }

<IN_BASE>","{wspace_opt}{typeid}{wspace}{uint}  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseInt(&TOK()->tid,yytext+1);
                    s=yyextra->_ParseInt(&TOK()->off,s);
        Assert(!*s);   // lexer rules ensure that
        return(TextAsmScanner::TS_baseent);
    }
<IN_BASE>";"  {
        PI_TOK();
        yy_pop_state(yyscanner);
        return(TextAsmScanner::T_pop);
    }

<IN_VARS>{stype}{wspace}{uint}({wspace_opt}","{wspace_opt}{name})?  {
        // type offset and optional name
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseTypeSpec(&TOK()->t,yytext);
                    s=yyextra->_ParseInt(&TOK()->off,s);
        while(isspace(*s))  ++s;
        if(*s==',')
        {  TOK()->str_val=yyextra->_ParseNameStr(s+1,yytext+yyleng);  }
        else Assert(!*s);   // lexer rules ensure that
        return(TextAsmScanner::TS_varent);
    }
<IN_VARS>";"  {
        PI_TOK();
        yy_pop_state(yyscanner);
        return(TextAsmScanner::T_pop);
    }

<IN_SYMBS>{ftype}{wspace_opt}{symref_ni}{wspace}{fname}  {
        PI_STR(yytext,yyleng);
        
        const char *s=yytext;
        if(*s=='s')
        {  TOK()->ftype=s[1]-'a'+'A';  }  // convert to uppercase: non-exported
        else
        {  TOK()->ftype=*s;  }
        while(*s!='$')  ++s;
        
        s=yyextra->_ParseInt(&TOK()->symref,s,'$');
        TOK()->str_val=yyextra->_ParseNameStr(s,yytext+yyleng);
        return(TextAsmScanner::TS_funcsym);
    }
<IN_SYMBS>{stype}{wspace_opt}{symref_ni}{wspace}{name}  {
        PI_STR(yytext,yyleng);
        const char *s=yyextra->_ParseTypeSpec(&TOK()->t,yytext);
                    s=yyextra->_ParseInt(&TOK()->symref,s,'$');
        TOK()->str_val=yyextra->_ParseNameStr(s,yytext+yyleng);
        return(TextAsmScanner::TS_varsym);
    }
<IN_SYMBS>";"  {
        PI_TOK();
        yy_pop_state(yyscanner);
        return(TextAsmScanner::T_pop);
    }

    /*==========================<LOCATION DESCRIPTION>========================*/
<IN_LOC>.  {
        CritAssert(!"location desc not implemented");
    }

    /*==========================<PROGRAM INSTRUCTIONS>========================*/
    /* each of these rules matches one line. */
<IN_PRG>".init"{label_end}  {
        PI_LINE();
        TOK()->str_val=yyextra->_ParseNameStr(yytext,yytext+5);
        return(TextAsmScanner::TP_slabel);
    }
<IN_PRG>".start"{label_end}  {
        PI_LINE();
        TOK()->str_val=yyextra->_ParseNameStr(yytext,yytext+6);
        return(TextAsmScanner::TP_slabel);
    }
<IN_PRG>"&"{uint}{label_end}  {
        PI_LINE();
        yyextra->_ParseInt(&TOK()->codemark,yytext+1);
        return(TextAsmScanner::TP_mlabel);
    }
<IN_PRG>"$"{uint}{label_end}  {
        PI_LINE();
        yyextra->_ParseInt(&TOK()->symref,yytext+1);
        return(TextAsmScanner::TP_rlabel);
    }
    
<IN_PRG>{ib}"nop"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::NOP);
    }
<IN_PRG>{ib}"hlt"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::HLT);
    }
    
<IN_PRG>{ib}"plb"{is}{sint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        uint8 a,z;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLB,a,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"pls"{is}{sint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        uint8 z;
        uint16 a;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLS,a,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"pli"{is}{sint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        uint8 z;
        uint32 a;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLI,a,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"pll"{is}{sint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        uint8 z;
        uint64 a;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLL,a,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"plf"{is}{flt}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        uint8 z;
        flt a;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLF,a,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"pld"{is}{flt}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        uint8 z;
        dbl a;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLD,a,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"plf2"({is}{flt}){2}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint8 z;
        flt a,b;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseFloat(&b,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLF2,a,b,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"pld2"({is}{flt}){2}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint8 z;
        dbl a,b;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseFloat(&b,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLD2,a,b,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"plf3"({is}{flt}){3}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint8 z;
        flt a,b,c;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseFloat(&b,s);
        s=yyextra->_ParseFloat(&c,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLF3,a,b,c,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"pld3"({is}{flt}){3}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint8 z;
        dbl a,b,c;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseFloat(&b,s);
        s=yyextra->_ParseFloat(&c,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLD3,a,b,c,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"plf4"({is}{flt}){4}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint8 z;
        flt a,b,c,d;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseFloat(&b,s);
        s=yyextra->_ParseFloat(&c,s);
        s=yyextra->_ParseFloat(&d,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLF4,a,b,c,d,z);
        _CheckCmdEnd(s);
    }
<IN_PRG>{ib}"pld4"({is}{flt}){4}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint8 z;
        dbl a,b,c,d;
        s=yyextra->_ParseFloat(&a,s);
        s=yyextra->_ParseFloat(&b,s);
        s=yyextra->_ParseFloat(&c,s);
        s=yyextra->_ParseFloat(&d,s);
        s=yyextra->_ParseInt0(&z,s);
        yyextra->InsnStorage()->append(VM::INST::PLD4,a,b,c,d,z);
        _CheckCmdEnd(s);
    }

<IN_PRG>{ib}"pln"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::PLN);
    }

<IN_PRG>{ib}"ps"{bsilpaf_d_}{is}{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;  if(!isspace(*s)) ++s;
        uint8 z;
        VM::Offset a;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILPAF_D_(3,PS)
        yyextra->InsnStorage()->append(inst,a,z);
    }
<IN_PRG>{ib}"ps"{bsilpaf_d_}{is}"-"{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        // It seems we actually do not need this instruction. 
        CritAssert(!"ps* -adr [inc] not implemented");
    }

<IN_PRG>{ib}"pg"{bsilpaf_d_}{is}"$"{sint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;  if(!isspace(*s)) ++s;
        uint8 z;
        VM::SymRef a;
        s=yyextra->_ParseInt(&a,s,'$');
        s=yyextra->_ParseInt0(&z,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILPAF_D_(3,PG)
        yyextra->InsnStorage()->append(inst,a,z);
    }
<IN_PRG>{ib}"pg"{bsilpaf_d_}{is}{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        // We do not need this instruction if we use non-exported symbols. 
        // We could use it, however, to make linking a bit faster. 
        CritAssert(!"pg* offset [inc] not implemented");
    }

<IN_PRG>{ib}"pf"{bsilf_d_}{is}{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;  if(!isspace(*s)) ++s;
        uint8 z;
        VM::Offset a;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILF_D_(3,PF)
        yyextra->InsnStorage()->append(inst,a,z);
    }
<IN_PRG>{ib}"pf"[pa][rw]{is}{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint8 z;
        VM::Offset a;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_PARW(3,PF)
        yyextra->InsnStorage()->append(inst,a,z);
    }

<IN_PRG>{ib}"pa"[bsilfd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(3,PA)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"pa"[pa][rw]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_PARW(3,PA)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"pi"{is}{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+3;
        uint32 a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::PI,a);
    }

<IN_PRG>{ib}"popv"{is}{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint32 a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::POPV,a);
    }
<IN_PRG>{ib}"popp"{is}{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        uint32 a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::POPP,a);
    }

<IN_PRG>{ib}"ss"{bsilpaf_d_}{is}{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;  if(!isspace(*s)) ++s;
        uint8 z;
        VM::Offset a;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILPAF_D_(3,SS)
        yyextra->InsnStorage()->append(inst,a,z);
    }
<IN_PRG>{ib}"ss"{bsilpaf_d_}{is}"-"{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        // It seems we actually do not need this instruction. 
        CritAssert(!"ss* -adr [inc] not implemented");
    }

<IN_PRG>{ib}"sg"{bsilpaf_d_}{is}"$"{sint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;  if(!isspace(*s)) ++s;
        uint8 z;
        VM::SymRef a;
        s=yyextra->_ParseInt(&a,s,'$');
        s=yyextra->_ParseInt0(&z,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILPAF_D_(3,SG)
        yyextra->InsnStorage()->append(inst,a,z);
    }
<IN_PRG>{ib}"sg"{bsilpaf_d_}{is}{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        // We do not need this instruction if we use non-exported symbols. 
        // We could use it, however, to make linking a bit faster. 
        CritAssert(!"sg* offset [inc] not implemented");
    }

<IN_PRG>{ib}"sf"{bsilpaf_d_}{is}{uint}({is}{uint})?{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;  if(!isspace(*s)) ++s;
        VM::Offset a;
        uint8 z;
        s=yyextra->_ParseInt(&a,s);
        s=yyextra->_ParseInt0(&z,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILPAF_D_(3,SF)
        yyextra->InsnStorage()->append(inst,a,z);
    }

<IN_PRG>{ib}"sa"[bsilpafd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILPAFD(3,SA)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"add"{bsilf_d_}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILF_D_(4,ADD)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"sub"{bsilf_d_}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILF_D_(4,SUB)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"mul"([bsilfd]){ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,MUL)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"div"([bsilfd]){ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,DIV)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"mod"([bsilfd]){ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,MOD)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"neg"{bsilf_d_}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILF_D_(4,NEG)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"eq"{bsilpaf_d_}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILPAF_D_(3,EQ)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"and"[bsil]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSIL(4,AND)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"or"[bsil]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSIL(3,OR)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"xor"[bsil]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSIL(4,XOR)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"shl"[bsil]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSIL(4,SHL)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"shr"[bsil]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSIL(4,SHR)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"incs"[bsilfd]{is}{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+6;
        VM::Offset a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILFD(5,INCS)
        yyextra->InsnStorage()->append(inst,a);
    }
<IN_PRG>{ib}"decs"[bsilfd]{is}{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+6;
        VM::Offset a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILFD(5,DECS)
        yyextra->InsnStorage()->append(inst,a);
    }

<IN_PRG>{ib}"jmp"{is}"&"{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        VM::CodeMark a;
        s=yyextra->_ParseInt(&a,s,'&');
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::JMP,a);
    }
<IN_PRG>{ib}"jn"[bsilpafd]{is}"&"{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        VM::CodeMark a;
        s=yyextra->_ParseInt(&a,s,'&');
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILPAFD(3,JN)
        yyextra->InsnStorage()->append(inst,a);
    }
<IN_PRG>{ib}"jz"[bsilpafd]{is}"&"{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+4;
        VM::CodeMark a;
        s=yyextra->_ParseInt(&a,s,'&');
        _CheckCmdEnd(s);
        VM::INST::IID inst;
        SWITCH_BSILPAFD(3,JZ)
        yyextra->InsnStorage()->append(inst,a);
    }

<IN_PRG>{ib}"anew"[bsilpafd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        uint8 a=0,b=0;
        switch(yytext[5])
        {
            case 'b':  a=1;  break;
            case 's':  a=2;  break;
            case 'i':  a=3;  break;
            case 'l':  a=4;  break;
            case 'p':  a=5;  break;
            case 'a':  a=6;  break;
            case 'f':  a=7;  break;
            case 'd':  a=8;  break;
            default: Assert(0);
        }
        yyextra->InsnStorage()->append(VM::INST::ANEW,a,b);
    }

<IN_PRG>{ib}"asize"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::ASIZE);
    }

<IN_PRG>{ib}"onew"{is}{typeid}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        VM::TypeID a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::ONEW,a);
    }

<IN_PRG>{ib}"acpy"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::ACPY);
    }
<IN_PRG>{ib}"ocpy"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::OCPY);
    }

<IN_PRG>{ib}"cvb"[bsilfd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,CVB)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"cvs"[bsilfd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,CVS)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"cvi"[bsilfd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,CVI)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"cvl"[bsilfd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,CVL)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"cvf"[bsilfd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,CVF)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"cvd"[bsilfd]{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILFD(4,CVD)
        yyextra->InsnStorage()->append(inst);
    }

<IN_PRG>{ib}"call"{is}"$"{sint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+5;
        VM::SymRef a;
        s=yyextra->_ParseInt(&a,s,'$');
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::CALL,a);
    }
<IN_PRG>{ib}"mcall"{is}"$"{sint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+6;
        VM::SymRef a;
        s=yyextra->_ParseInt(&a,s,'$');
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::MCALL,a);
    }
<IN_PRG>{ib}"vmcall"{is}{uint}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+7;
        uint32 a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::VMCALL,a);
    }

<IN_PRG>{ib}"ret"{bsilpaf_d_}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        VM::INST::IID inst;
        SWITCH_BSILF_D_(4,RET)
        yyextra->InsnStorage()->append(inst);
    }
<IN_PRG>{ib}"ret"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::RET);
    }

<IN_PRG>{ib}"scast"{is}{typeid}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+6;
        VM::TypeID a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::SCAST,a);
    }
<IN_PRG>{ib}"dcast"{is}{typeid}{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        const char *s=yytext+6;
        VM::TypeID a;
        s=yyextra->_ParseInt(&a,s);
        _CheckCmdEnd(s);
        yyextra->InsnStorage()->append(VM::INST::DCAST,a);
    }

<IN_PRG>{ib}"adel"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::ADEL);
    }
<IN_PRG>{ib}"odel"{ie}  {
        PI_INST(); CHECK_INST_ALLOWED
        yyextra->InsnStorage()->append(VM::INST::ODEL);
    }

<IN_PRG>{ib}{name}{ie}  {
        PI_LINE();
        const char *s=yytext;
        while(isspace(*s)) ++s;
        const char *inst=s;
        while(!isspace(*s))  ++s;
        Error(yyextra->_MakeCurrLoc(),"illegal instruction \"%.*s\" or "
            "format violation",s-inst,inst);
        ++yyextra->n_errors;
        PI_START();
    }
    /* Skip comments which are alone in the line. */
<IN_PRG>[ \t]*"#"[^\n]*\n  {  PI_LINE();  PI_START();  }
    /* Ignore empty lines and single newlines: */
<IN_PRG>[ \t]*\n  {  PI_LINE();  PI_START();  }
    /* "Default" rule */
<IN_PRG>.  {
        PI_TOK();
        Error(yyextra->_MakeCurrLoc(),"illegal instruction or "
            "format violation");
        ++yyextra->n_errors;
        /* Skip until next newline. */
        yy_push_state(IN_SKIPNL,yyscanner);
    }

    /*==========================<INITIAL / TOP LEVEL>=========================*/
    /* Match whitespace: (\r was filtered out earlier) */
[ ]+  {
        PI_TOK();
        /* As this is not a token, re-set token start pos: */
        PI_START();
    }
\n  {  PI_LINE();  PI_START();  }
\t  {  PI_TAB();  PI_START();  }
\f  {  PI_CHAR(yytext[0]);  PI_START();  }
\v  {  PI_CHAR(yytext[0]);  PI_START();  }
    /* Optimized versions: */
[ \t]+\n  {  PI_LINE();  PI_START();  }
\t+[ ]+  {
        int i=0;
        for(; yytext[i]=='\t'; i++)  PI_TAB();
        PI_TOKL(yyleng-i);
        PI_START();
    }
\n\t+[ ]+  {
        PI_LINE();
        int i=0;
        for(; yytext[i]=='\t'; i++)  PI_TAB();
        PI_TOKL(yyleng-i);
        PI_START();
    }

    /* Start comment: */
"#"  {
        PI_TOK();
        yy_push_state(IN_CMT,yyscanner);
    }

    /* Start object/symbol description: */
<INITIAL,IN_SYM,IN_LOC,IN_PRG,IN_INFO>"info"{wspace_opt}":"  {
        PI_STR(yytext,yyleng);
        
        // Pop other section state(s) currently on the stack. 
        while(YY_START!=INITIAL)  yy_pop_state(yyscanner);
        
        yy_push_state(IN_INFO,yyscanner);
        return(TextAsmScanner::T_info);
    }
<INITIAL,IN_SYM,IN_LOC,IN_PRG,IN_INFO>"symbols"{wspace_opt}":"  {
        PI_STR(yytext,yyleng);
        
        // Pop other section state(s) currently on the stack. 
        while(YY_START!=INITIAL)  yy_pop_state(yyscanner);
        
        yy_push_state(IN_SYM,yyscanner);
        return(TextAsmScanner::T_symbols);
    }
<INITIAL,IN_SYM,IN_LOC,IN_PRG,IN_INFO>"locations"{wspace_opt}":"  {
        PI_STR(yytext,yyleng);
        
        // Pop other section state(s) currently on the stack. 
        while(YY_START!=INITIAL)  yy_pop_state(yyscanner);
        
        yy_push_state(IN_LOC,yyscanner);
        return(TextAsmScanner::T_locations);
    }
<INITIAL,IN_SYM,IN_LOC,IN_PRG,IN_INFO>"program"{wspace_opt}":"[ \t]*"\n"  {
        PI_LINE();
        
        // Pop other section state(s) currently on the stack. 
        while(YY_START!=INITIAL)  yy_pop_state(yyscanner);
        
        yy_push_state(IN_PRG,yyscanner);
        return(TextAsmScanner::T_program);
    }

<<EOF>>  {
        /* The normal action would be to YYWarp() here but I cannot */
        /* because of the token buffer. */
        /*if(yyextra->_YYWrap())*/
        /*{  return(0);  }*/
        PI_EOF();
        return(0);
    }

    /* IN_PRG has special syntax: not included here. */
<INITIAL,IN_SYM,IN_LOC,IN_INFO>{name}":"  {
        PI_TOK();
        yytext[yyleng-1]='\0';
        Error(yyextra->_MakeCurrLoc(),"illegal section \"%s\"",yytext);
        ++yyextra->n_errors;
        /* Skip until next whitespace. */
        yy_push_state(IN_SKIPSPC,yyscanner);
    }
{name}  {
        PI_TOK();
        Error(yyextra->_MakeCurrLoc(),"illegal directive \"%s\" or "
            "format violation ",yytext);
        ++yyextra->n_errors;
        /* Skip until next whitespace. */
        yy_push_state(IN_SKIPSPC,yyscanner);
    }
";"  {
        // Should not happen here; only in case of error further up. 
        PI_TOK();
        return(TextAsmScanner::T_pop);
    }
.  {
        PI_TOK();
        Error(yyextra->_MakeCurrLoc(),"illegal directive or format violation");
        ++yyextra->n_errors;
        /* Skip until next whitespace. */
        yy_push_state(IN_SKIPSPC,yyscanner);
    }

%%

// Special "trick"; 2nd time; see comment in scannerbase.h. 
#define PREFIX_FlexScannerBase TASM_FlexScannerBase
#define PREFIX_lex TASM_lex
#define PREFIX_lex_init TASM_lex_init
#define PREFIX_lex_destroy TASM_lex_destroy
#define PREFIX_pop_buffer_state TASM_pop_buffer_state
#define PREFIX_push_buffer_state TASM_push_buffer_state
#define PREFIX_create_buffer TASM__create_buffer
#define PREFIX_switch_to_buffer TASM__switch_to_buffer
inline void PREFIX_set_extra(PREFIX_FlexScannerBase *arg,yyscan_t scanner)
    {  yyset_extra((TextAsmScanner*)arg,scanner);  }
#define FLEX_BOTTOM_PART
#include <lib/lex/scannerbase.cc>


char *TextAsmScanner::_ParseNameStr(const char *str,const char *end)
{
    // Skip any white space. Due to lexer rules, we WILL eventually find 
    // a non-white space. 
    while(isspace(*str))  ++str;
    
    // If end is not set, find it. 
    if(!end) for(end=str; *end; end++);
    
    // Copy string. ~Token() and Token::clear() are responsible for FREEing. 
    Assert(end>str);
    size_t len=end-str;
    char *nstr=ALLOC<char>(len+1);   // +1 for '\0' char
    if(*end=='\0')
    {  strcpy(nstr,str);  }
    else
    {  strncpy(nstr,str,len);  nstr[len]='\0';  }
    
    return(nstr);
}


template<typename T>const char *TextAsmScanner::_ParseInt(T *ret,
    const char *str,char prefix)
{
    // Skip prefix if specified. 
    if(prefix)
    {
        //fprintf(stderr,"<%s,%c>",str,prefix);
        while(isspace(*str)) ++str;
        Assert(*str==prefix);
        ++str;
    }
    
    SError error;
    const char *end=ParseInt(ret,str,error,1);
    if(error)
    {
        Error(_MakeCurrLoc(),"parse error (%s): expected %d bit integer "
            "instead of \"%s\"",error.msg().str(),sizeof(T)*8,str);
        ++n_errors;
    }
    return(end);
}

template<typename T>const char *TextAsmScanner::_ParseInt0(T *ret,
    const char *str)
{
    while(isspace(*str))  ++str;
    if(!*str)
    {  *ret=T(0);  return(str);  }
    
    SError error;
    const char *end=ParseInt(ret,str,error,1);
    if(error)
    {
        Error(_MakeCurrLoc(),"parse error (%s): expected %d bit integer "
            "instead of \"%s\"",error.msg().str(),sizeof(T)*8,str);
        ++n_errors;
    }
    return(end);
}

template<typename T>const char *TextAsmScanner::_ParseFloat(T *ret,
    const char *str)
{
    while(isspace(*str))  ++str;
    if(!*str)
    {  *ret=T(0);  return(str);  }
    
    SError error;
    const char *end=ParseFloat(ret,str,error,1);
    if(error)
    {
        Error(_MakeCurrLoc(),"parse error (%s): expected %d bit float "
            "instead of \"%s\"",error.msg().str(),sizeof(T)*8,str);
        ++n_errors;
    }
    return(end);
}


const char *TextAsmScanner::_ParseTypeSpec(Token::Type *ts,const char *str)
{
    const char *s=str;
    
    // First, parse type chars: max 2. 
    ts->tchar[0]='\0';
    ts->tchar[1]='\0';
    if(isalpha(*s))
    {  ts->tchar[0]=*s;  ++s;  }
    if(isalpha(*s))
    {  ts->tchar[1]=*s;  ++s;  }
    
    while(isspace(*s))  ++s;
    
    // Parse TYPEID if specified. 
    ts->tid=0;
    if(*s=='>')
    {
        Assert(!ts->tchar[1]);  // lexer rules ensure that
        ts->tchar[1]='>';
        
        ++s;
        s=_ParseInt(&ts->tid,s);
    }
    
    return(s);
}


void TextAsmScanner::_CheckInstAllowed_Failed()
{
    Error(_MakeCurrLoc(),
        "cannot specify instruction outside function");
    ++n_errors;
}


const char *TextAsmScanner::TokID2String(TokID t)
{
    switch(t)
    {
        case T_EOF:         return("EOF");
        
        case T_pop:         return("';'");
        case T_symbols:     return("symbol desc section");
        case T_locations:   return("location desc section");
        case T_program:     return("program instruction section");
        case T_info:        return("info section");
        
        case TS_namespace:  return("'namespace'");
        case TS_class:      return("'class'");
        case TS_base:       return("'base'");
        case TS_baseent:    return("base list entry");
        case TS_varent:     return("variable entry");
        case TS_size:       return("'size'");
        case TS_virtual:    return("'virtual'");
        case TS_vtable:     return("'vtable'");
        case TS_symref:     return("vtable block entry");
        case TS_vglobal:    return("'vglobal'");
        case TS_pglobal:    return("'pglobal'");
        case TS_symbols:    return("'symbols'");
        case TS_funcsym:    return("function symbol");
        case TS_varsym:     return("variable symbol");
        case TS_globvar:    return("global variable entry");
        
        case TP_slabel:     return("special label");  // s="string" actually...
        case TP_mlabel:     return("codemark label");
        case TP_rlabel:     return("symref label");
        
        case TI_abivers:    return("ABI version");
    }
    
    return("???");   // Should not happen. 
}


void TextAsmScanner::reset()
{
    Assert(!insn_storage);  // Actually, the parser should take care of it. 
    DELETE(insn_storage);
}


TextAsmScanner::TextAsmScanner() : 
    TASM_FlexScannerBase()
{
    // We do not need lookahead. 
    cfg.ahead_toks_wanted=1;  // (minimum)
    // And only 1 look back since all tokens are processed directly. 
    cfg.old_toks_wanted=1;
    
    insn_storage=NULL;
}

TextAsmScanner::~TextAsmScanner()
{
    Assert(!insn_storage);  // Actually, the parser should take care of it. 
    DELETE(insn_storage);  // be sure
}

//------------------------------------------------------------------------------

bool TextAsmScanner::Token::MayBeCleared() const
{
    // Check magic indication that the token was used: 
    if(!str_val || *str_val=='\0')  return(1);
    return(0);
}

void TextAsmScanner::Token::clear(bool force)
{
    // We need to deallocate the str_val if necessary. 
    if(!force)
    {  Assert(MayBeCleared());  }
    if(str_val)
    {  str_val=FREE(str_val);  }
    
    // Important: call higher level: 
    TokenEntry::clear();
}


#if 0   /* small test proggy */

#include <lib/message/manager.h>
#include <lib/message/handler_console.h>

static const int MyDbg=0x10000000;

static void _DoIt(const TLString &path)
{
    TextAsmScanner scan;
    
    SError error;
    int rv=scan.SetInput(path,error,0);
    Debug(MyDbg,"SetInput=%d (%s)",rv,error.msg().str());
    
    for(;;)
    {
        TextAsmScanner::Token *tok=
            (TextAsmScanner::Token*)scan.LexNextToken();
        
        if(!tok)
        {  Debug(MyDbg,"-EOF-");  break;  }
        
        switch((TextAsmScanner::TokID)tok->token)
        {
            case TextAsmScanner::T_pop:
                Debug(MyDbg,tok->lloc,"  (pop)");
                break;
            case TextAsmScanner::T_symbols:
                Debug(MyDbg,tok->lloc,"symbols:");
                break;
            case TextAsmScanner::T_locations:
                Debug(MyDbg,tok->lloc,"locations:");
                break;
            case TextAsmScanner::T_program:
                Debug(MyDbg,tok->lloc,"program:");
                break;
            case TextAsmScanner::T_info:
                Debug(MyDbg,tok->lloc,"info:");
                break;
            case TextAsmScanner::TS_namespace:
                Debug(MyDbg,tok->lloc,"  namespace: %s",tok->str_val);
                break;
            case TextAsmScanner::TS_class:
                Debug(MyDbg,tok->lloc,"  class: %d %s",tok->tid,tok->str_val);
                break;
            case TextAsmScanner::TS_base:
                Debug(MyDbg,tok->lloc,"  base: %d",tok->num);
                break;
            case TextAsmScanner::TS_baseent:
                Debug(MyDbg,tok->lloc,"  baseent: %d %u",tok->tid,tok->off);
                break;
            case TextAsmScanner::TS_varent:
                Debug(MyDbg,tok->lloc,"  typeent: %.2s%d %u %s",
                    tok->t.tchar,tok->t.tid,tok->off,
                    tok->str_val ? tok->str_val : "");
                break;
            case TextAsmScanner::TS_size:
                Debug(MyDbg,tok->lloc,"  size: %u %u,%u",
                    tok->size,tok->num_p,tok->num_v);
                break;
            case TextAsmScanner::TS_virtual:
                Debug(MyDbg,tok->lloc,"  virtual: %u",tok->num);
                break;
            case TextAsmScanner::TS_vtable:
                Debug(MyDbg,tok->lloc,"  vtable: %u",tok->num);
                break;
            case TextAsmScanner::TS_symref:
                Debug(MyDbg,tok->lloc,"  symref: %d",tok->symref);
                break;
            case TextAsmScanner::TS_vglobal:
                Debug(MyDbg,tok->lloc,"  vglobal: %u",tok->size);
                break;
            case TextAsmScanner::TS_pglobal:
                Debug(MyDbg,tok->lloc,"  pglobal: %u",tok->size);
                break;
            case TextAsmScanner::TS_symbols:
                Debug(MyDbg,tok->lloc,"  symbols:");
                break;
            case TextAsmScanner::TS_funcsym:
                Debug(MyDbg,tok->lloc,"  funcsym: %c $%d %s",
                    tok->ftype,tok->symref,tok->str_val);
                break;
            case TextAsmScanner::TS_varsym:
                Debug(MyDbg,tok->lloc,"  varsym: %.2s%d $%d %s",
                    tok->t.tchar,tok->t.tid,tok->symref,tok->str_val);
                break;
            case TextAsmScanner::TS_globvar:
                Debug(MyDbg,tok->lloc,"  globvar: %.2s%d %d $%d",
                    tok->t.tchar,tok->t.tid,tok->off,tok->symref);
                break;
            case TextAsmScanner::TP_slabel:
                Debug(MyDbg,tok->lloc,"  slabel: %s",tok->str_val);
                break;
            case TextAsmScanner::TP_mlabel:
                Debug(MyDbg,tok->lloc,"  mlabel: &%d",tok->codemark);
                break;
            case TextAsmScanner::TP_rlabel:
                Debug(MyDbg,tok->lloc,"  rlabel: $%d",tok->symref);
                break;
            case TextAsmScanner::TI_abivers:
                Debug(MyDbg,tok->lloc,"  abiversion: %s",tok->str_val);
                break;
            default:
                // This should not happen. 
                Error(tok->lloc,"OOPS: unknown token %d ?!",
                    tok->token);
                break;
        }
        
        // Mark string value in token as used. 
        if(tok->str_val)
        {  *tok->str_val='\0';  }
    }
}

int main(int argc,char **arg)
{
    MessageManager::init();
    MessageHandler_Console cons_hdl(
        Message::MTAll,
        //Message::MTAllNonDebug,
        /*use_color=*/0);
    
    TLString path; // null ref for now
    if(argc>1)  path=arg[1];
    
    _DoIt(path);
    
    MessageManager::cleanup();
    return(0);
}

#endif

---