/ray/src/vm/input/tasm/parser.cc

Go to the documentation of this file.

/*
 * vm/input/tasm/parser.cc
 * 
 * VM plaintext assembly parser (syntactical 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 "tasm-file.h"
#include <lib/message/message.h>
#include <vm/input/classinfo.h>
#include <vm/instruction/instruction.h>


namespace VM
{

void AssemblerFile_Plaintext::_ExpectError(const char *str)
{
    if(tok)
    {  Error(tok->lloc,"parser expects %s not %s",str,
        scan.TokID2String(_CurrTokID()));  }
    else
    {  Error("early EOF; parser expects %s not %s",str,
        scan.TokID2String(TextAsmScanner::T_EOF));  }
    
    ++n_errors;
}


void AssemblerFile_Plaintext::_AlreadySetError()
{
    Assert(tok);
    Error(tok->lloc,"%s already set",scan.TokID2String(_CurrTokID()));
    ++n_errors;
}


void AssemblerFile_Plaintext::_LocFirstDefError(const SCLocation &loc)
{
    Error(loc,"  this is the location of the first definition");
    ++n_errors;
}


VarType AssemblerFile_Plaintext::_ParseVarType(
    const TextAsmScanner::Token::Type *t)
{
    VarType vt;
    
    int idx=0;
    if(t->tchar[idx]=='a')
    {  vt.array=1;  ++idx;  }
    switch(t->tchar[idx])
    {
        case 'b':  vt.id=VarType::Byte;   break;
        case 's':  vt.id=VarType::Short;  break;
        case 'i':  vt.id=VarType::Int;    break;
        case 'l':  vt.id=VarType::Long;   break;
        case 'f':  vt.id=VarType::Flt;    break;
        case 'd':  vt.id=VarType::Dbl;    break;
        case 'p':  vt.id=VarType::Ptr;    break;
        default:  Assert(0);
    }
    if(idx==0)
    {  Assert(!t->tchar[1] || t->tchar[1]=='>');  }
    
    return(vt);
}


FuncType AssemblerFile_Plaintext::_ParseFuncType(char ftype)
{
    // Captial letters are non-exported. 
    switch(ftype)
    {
        case 'f':  return(FuncType(FuncType::Function,1));
        case 'm':  return(FuncType(FuncType::Method,  1));
        case 'v':  return(FuncType(FuncType::VMethod, 1));
        case 'F':  return(FuncType(FuncType::Function,0));
        case 'M':  return(FuncType(FuncType::Method,  0));
        case 'V':  return(FuncType(FuncType::VMethod, 0));
    }
    
    Assert(0);
    return FuncType();  // gcc-3.4 CAN parse return(FuncType());
}


void AssemblerFile_Plaintext::_SkipUntilPop(uint32 /*_unused_ num*/,
    TextAsmScanner::TokID skip_a,TextAsmScanner::TokID skip_b)
{
    if(skip_b==TextAsmScanner::T_EOF)  skip_b=skip_a;
    
    _LexNextToken();
    
    // Skip block. 
    for(/*uint32 cnt=0; cnt<num; cnt++*/;;)
    {
        TextAsmScanner::TokID c=_CurrTokID();
        if(c==skip_a || c==skip_b)
        {  _LexNextToken();  }
        else 
        {
            if(c==TextAsmScanner::T_pop)
            {  _LexNextToken();  }
            break;
        }
    }
    
    if(_CurrTokID()==TextAsmScanner::T_pop)
    {  _LexNextToken();  }
}


void AssemblerFile_Plaintext::_ParseProgram_FinishFunction()
{
    // See if we have a function. 
    if(!scan.insn_storage)  return;
    
    // Warn about empty functions. These will surely make a problem as 
    // they even do not have a return at the end. 
    if(scan.insn_storage->length()<2)
    {
        Warning(scan.insn_storage->loc,
            "empty function with symref $%d",
            (int)scan.insn_storage->symref);
    }
    
    // Resolve CodeMark jumps in the program. 
    for(PrgAdr adr=0; adr<scan.insn_storage->length(); )
    {
        const INST::DescEntry *ide=
            INST::Desc(scan.insn_storage->InstructionAt(adr));
        if(!ide)
        {
            // Unfortunately, we have not yet looked up the name. 
            // Actually, we could do that for the error but it is not 
            // sure that the information was already read in. 
            Error(scan.insn_storage->loc,
                "illegal instruction at address 0x%x (symref $%d)",
                (uint)adr,(int)scan.insn_storage->symref);
            ++n_errors;
            break;  // No use to go on; we cannto compute the size of the skip. 
        }
        
        // Only instructions with a codemark are interesting. 
        if(ide->codemark_off)
        {
            // Extract CodeMark from program memory: 
            char *prg_inst_adr = 
                &scan.insn_storage->index(adr+ide->codemark_off) ;
            CodeMark cmark=*(CodeMark*)prg_inst_adr;
            
            // Look up CodeMark: 
            bool known;  // unset
            PrgAdr mark_adr=codemark2prgadr.lookup(cmark,&known);
            if(!known)
            {
                Error(scan.insn_storage->loc,
                    "unknown CodeMark &%u at address 0x%x",
                    (uint)cmark,(uint)adr);
                ++n_errors;
                // mark_adr=0 in this case. 
            }
            
            // Compute relative jumpaddress; using signed value. 
            int32 delta=int32(mark_adr)-int32(adr);
            //fprintf(stderr,"DELTA=%d\n",delta);
            
            // Write result back into program memory. 
            *(PrgAdr*)prg_inst_adr=(PrgAdr)delta;
        }
        
        // Skip to next instruction. 
        adr+=ide->size;
    }
    
    // Append function to program storage. 
    scan.insn_storage->TightenSize();
    program.AddFunction(scan.insn_storage);
    scan.insn_storage=NULL;
    
    // Purge CodeMark -> PrgAdr lookup table (is per-function). 
    codemark2prgadr.clear();
}


NamespaceInfo *AssemblerFile_Plaintext::_CheckNspcNameKnown(
    NamespaceInfo *parent,const TLString &name)
{
    NamespaceInfo **known=parent->map_name2child.search(name);
    if(known)
    {
        Error(tok->lloc,"duplicate definition of namespace/class \"%s\"",
            (*known)->CompleteName().str());
        _LocFirstDefError((*known)->asm_loc);  // <-- does ++n_errors;
        return(*known);
    }
    return(NULL);
}


void AssemblerFile_Plaintext::_ParseSymbols_Class_Base(ClassInfo *parent)
{
    //Assert(_CurrTokID()==TextAsmScanner::TS_base);
    
    if(parent->base.n())
    {
        _AlreadySetError();
        _SkipUntilPop(parent->base.n(),TextAsmScanner::TS_baseent);
    }
    else
    {
        parent->base.alloc(tok->num);
        _LexNextToken();
        
        uint32 cnt=0;
        for(;;)
        {
            switch(_CurrTokID())
            {
                case TextAsmScanner::T_pop:
                    if(cnt!=parent->base.n())
                    {
                        Error(tok->lloc,"too few (%u/%u) base entries",
                            cnt,parent->base.n());
                        ++n_errors;
                        for(; cnt<parent->base.n(); cnt++)
                        {  parent->base[cnt].tid=0;  parent->base[cnt].off=0;  }
                    }
                    _LexNextToken();
                    goto breakout;
                
                case TextAsmScanner::TS_baseent:
                    if(cnt>=parent->base.n())
                    {
                        if(cnt==parent->base.n())
                        {
                            Error(tok->lloc,"too many (>%u) base entries",
                                parent->base.n());
                            ++n_errors;
                        }
                        _LexNextToken();
                        break;
                    }
                    parent->base[cnt].tid=tok->tid;
                    parent->base[cnt].off=tok->off;
                    ++cnt;
                    _LexNextToken();
                    break;
                
                default:
                    _ExpectError("base entry or ';'");
                    // Assume forgotten ';'. 
                    goto breakout;
            }
        }
        breakout:;
    }
}


void AssemblerFile_Plaintext::_ParseSymbols_Class_VTable(ClassInfo *parent)
{
    //Assert(_CurrTokID()==TextAsmScanner::TS_vtable);
    
    if(parent->vtable.n())
    {
        _AlreadySetError();
        _SkipUntilPop(parent->vtable.n(),TextAsmScanner::TS_symref);
    }
    else
    {
        parent->vtable.alloc(tok->num);
        _LexNextToken();
        
        uint32 cnt=0;
        for(;;)
        {
            switch(_CurrTokID())
            {
                case TextAsmScanner::T_pop:
                    if(cnt!=parent->vtable.n())
                    {
                        Error(tok->lloc,"too few (%u/%u) vtable entries",
                            cnt,parent->vtable.n());
                        ++n_errors;
                        for(; cnt<parent->vtable.n(); cnt++)
                        {  parent->vtable[cnt].symref=0;  }
                    }
                    _LexNextToken();
                    goto breakout;
                
                case TextAsmScanner::TS_symref:
                    if(cnt>=parent->vtable.n())
                    {
                        if(cnt==parent->vtable.n())
                        {
                            Error(tok->lloc,"too many (>%u) vtable entries",
                                parent->vtable.n());
                            ++n_errors;
                        }
                        _LexNextToken();
                        break;
                    }
                    parent->vtable[cnt].symref=tok->symref;
                    ++cnt;
                    
                    _LexNextToken();
                    break;
                
                default:
                    _ExpectError("vtable entry or ';'");
                    // Assume forgotten ';'. 
                    goto breakout;
            }
        }
        breakout:;
    }
}


void AssemblerFile_Plaintext::_ParseSymbols_Class_Size(ClassInfo *parent)
{
    //Assert(_CurrTokID()==TextAsmScanner::TS_size);
    
    if(parent->membvar.n() || parent->size)
    {
        _AlreadySetError();
        _SkipUntilPop(parent->membvar.n(),TextAsmScanner::TS_varent);
    }
    else
    {
        parent->size=tok->size;
        uint32 nmembvars=tok->num_p;
        if(cfg.read_non_pointer_members)
        {  nmembvars+=tok->num_v;  }
        parent->membvar.alloc(nmembvars);
        
        _LexNextToken();
        
        // The VM-Description says: 
        // The "size" spec must be before the member var specs in a class. 
        // The member var specs must be sorted by ascenting offset. 
        
        uint32 cnt=0;
        for(;;)
        {
            switch(_CurrTokID())
            {
                case TextAsmScanner::T_pop:
                    if(cnt!=parent->membvar.n())
                    {
                        Error(tok->lloc,"too few (%u/%u) member var entries",
                            cnt,parent->membvar.n());
                        ++n_errors;
                        for(; cnt<parent->membvar.n(); cnt++)
                        {
                            parent->membvar[cnt].off=0;
                            // vtype and name need not be set. 
                        }
                    }
                    _LexNextToken();
                    goto breakout;
                
                case TextAsmScanner::TS_varent:
                {
                    VarType vt(_ParseVarType(&tok->t));
                    if(vt.IsPointerType() || cfg.read_non_pointer_members)
                    {
                        if(cnt>=parent->membvar.n())
                        {
                            if(cnt==parent->membvar.n())
                            {
                                Error(tok->lloc,
                                    "too many (>%u) member var entries",
                                    parent->membvar.n());
                                ++n_errors;
                            }
                            _LexNextToken();
                            continue;
                        }
                        
                        parent->membvar[cnt].vtype=vt;
                        parent->membvar[cnt].off=tok->off;
                        if(cfg.read_member_var_names)
                        {  parent->membvar[cnt].name=TLString(tok->str_val);  }
                        
                        // Make sure they are sorted in ascenting order. 
                        if(cnt && 
                            parent->membvar[cnt-1].off>=
                                parent->membvar[cnt].off)
                        {
                            Error(tok->lloc,"member var entries not sorted "
                                "in ascenting order");
                            ++n_errors;
                        }
                        
                        ++cnt;
                    }
                    _LexNextToken();
                }   break;
                
                default:
                    _ExpectError("member var entry or ';'");
                    // Assume forgotten ';'. 
                    goto breakout;
            }
        }
        breakout:;
    }
}


void AssemblerFile_Plaintext::_ParseSymbols_Symbols(NamespaceInfo *parent)
{
    //Assert(_CurrTokID()==TextAsmScanner::TS_symbols);
    
    _LexNextToken();
    
    for(;;)
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::T_pop:
                _LexNextToken();
                goto breakout;
            
            case TextAsmScanner::TS_funcsym:   // fall through
            case TextAsmScanner::TS_varsym:
            {
                if(tok->symref<0)
                {
                    // We actually should not see this as the lexer will 
                    // reject negative sign in the matching regexp. 
                    Error(tok->lloc,"symref <0 for symbol \"%s\" is reserved "
                        "for internal use ",tok->str_val);
                    ++n_errors;
                    break;
                }
                
                NamespaceInfo::SymbolEntryE sent(parent);
                
                bool exported=1;
                if(_CurrTokID()==TextAsmScanner::TS_funcsym)
                {
                    sent.extid=NamespaceInfo::SymbolEntryE::ExtFunction;
                    sent.ftype=_ParseFuncType(tok->ftype);
                    exported=sent.ftype.exported;
                }
                else if(_CurrTokID()==TextAsmScanner::TS_varsym)
                {
                    sent.extid=NamespaceInfo::SymbolEntryE::ExtVariable;
                    sent.vtype=_ParseVarType(&tok->t);
                }
                else Assert(0);
                
                TLString name;
                if(exported)
                {
                    char *ptr=strchr(tok->str_val,'%');
                    if(ptr)
                    {
                        Error(tok->lloc,"'%%'-spec not allowed in exported "
                            "symbol \"%s\"",
                            tok->str_val);
                        ++n_errors;
                        *ptr='\0';
                    }
                    
                    name=TLString(tok->str_val);
                }
                else // !exported
                {
                    // Append %-suffix. 
                    name.sprintf("%s%%%x",tok->str_val,(uint)file_num);
                }
                
                sent.name=name;
                sent.symref=tok->symref;
                //sent.nspc=parent;  // <-- set in constructor
                
                // First, add the symbol entry to the "array" (is a queue). 
                // This will copy it and we may then take the address of it. 
                parent->symbol.PushHead(sent);
                NamespaceInfo::SymbolEntryE *se=parent->symbol.head();
                
                // Add symref to the mapping. 
                NamespaceInfo::SymbolEntryE *known=symref2symbol.AddNode(se);
                if(known)
                {
                    Error(tok->lloc,"symref $%d already defined for "
                        "symbol \"%s\"",
                        (int)tok->symref,known->CompleteName().str());
                    ++n_errors;
                }
                
                // Add symbol to the name lookup map. We only have non-internal 
                // symbols here. 
                Assert(se->symref>=0);
                int srv=parent->map_name2symbol.store(se,/*allow_update=*/0);
                if(srv==1)
                {
                    Error(tok->lloc,"duplicate symbol name \"%s\" (symref $%d)"
                        "in %s %s",
                        se->name.str(),(int)tok->symref,
                        NamespaceInfo::NSType2String(parent->nstype),
                        parent->CompleteName().str());
                    ++n_errors;
                }
                else Assert(srv==0);
                
                _LexNextToken();
            }   break;
            
            default:
                _ExpectError("symbol entry or ';'");
                // Assume forgotten ';'. 
                goto breakout;
        }
    }
    breakout:;
}


void AssemblerFile_Plaintext::_ParseSymbols_Global()
{
    //Assert(_CurrTokID()==TextAsmScanner::TS_[vp]global);
    
    _GlobVars *gvar;
    if(_CurrTokID()==TextAsmScanner::TS_pglobal)
    {  gvar=&gvar_p;  }
    else if(_CurrTokID()==TextAsmScanner::TS_vglobal)
    {  gvar=&gvar_v;  }
    else Assert(0);
    
    gvar->size=tok->size;
    _LexNextToken();
    
    for(;;)
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::T_pop:
                _LexNextToken();
                goto breakout;
            
            case TextAsmScanner::TS_globvar:
            {
                if(tok->symref<0)
                {
                    // We actually should not see this as the lexer will 
                    // reject negative sign in the matching regexp. 
                    Error(tok->lloc,"symref <0 for symbol \"%s\" is reserved "
                        "for internal use ",tok->str_val);
                    ++n_errors;
                    break;
                }
                
                {
                    GlobalVarEntry tmp;
                    tmp.vtype=_ParseVarType(&tok->t);
                    tmp.off=tok->off;
                    tmp.symref=tok->symref;
                    
                    gvar->globvarq.PushHead(tmp);
                }
                
                GlobalVarEntry *gve=gvar->globvarq.head();
                GlobalVarEntry *known=symref2globvar.AddNode(tok->symref,gve);
                if(known)
                {
                    Error(tok->lloc,"duplicate definition of global var "
                        "with symref $%d",(int)tok->symref);
                    ++n_errors;
                }
                
                _LexNextToken();
            }   break;
            
            default:
                _ExpectError("global var entry or ';'");
                // Assume forgotten ';'. 
                goto breakout;
        }
    }
    breakout:;
}


void AssemblerFile_Plaintext::_ParseSymbols_Namespace(NamespaceInfo *parent)
{
    NamespaceInfo *nsi=NULL;
    
    do {
        TLString name(tok->str_val);
        if(_CheckNspcNameKnown(parent,name))  break;
        
        // Allocate new child. 
        nsi=new NamespaceInfo(name,parent);
        nsi->asm_loc=tok->lloc.loc0;
    } while(0);
    
    _LexNextToken();
    
    if(!nsi)
    {
        // Read comment at the same position in _ParseSymbols_Class(). (FIXME?)
        return;
    }
    
    for(;;)
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::TS_namespace:
                _ParseSymbols_Namespace(nsi);
                break;
            case TextAsmScanner::TS_class:
                _ParseSymbols_Class(nsi);
                break;
            case TextAsmScanner::TS_symbols:
                _ParseSymbols_Symbols(nsi);
                break;
            
            case TextAsmScanner::T_pop:
                _LexNextToken();
                goto breakout;
            
            default:
                _ExpectError("namespace entry "
                    "(namespace/class/symbols) or ';'");
                // Assume forgotten ';'. 
                goto breakout;
        }
    }
    breakout:;
}


void AssemblerFile_Plaintext::_ParseSymbols_Class(NamespaceInfo *parent)
{
    ClassInfo *nsi=NULL;
    do {
        if(tok->tid<0)
        {
            Error(tok->lloc,"negative typeids (%d) reserved for internal use",
                tok->tid);
            ++n_errors;
            break;
        }
        
        TLString name(tok->str_val);
        if(_CheckNspcNameKnown(parent,name))  break;
        
        // Allocate new child. 
        nsi=new ClassInfo(name,tok->tid,/*parent=*/parent);
        
        ClassInfo *known=tid2classinfo.AddNode(nsi);
        if(known)
        {
            Error(tok->lloc,"typeid %d already defined",(int)tok->tid);
            _LocFirstDefError(known->asm_loc);  // <-- does ++n_errors;
            
            // Need to get rid of the child again. 
            DELETE(nsi);  Assert(!nsi);
            
            break;
        }
        
        nsi->asm_loc=tok->lloc.loc0;
    } while(0);
    
    _LexNextToken();
    
    if(!nsi)
    {
        // In order to handle the error gracefully, we should probably 
        // skip the complete class here. But that is not as easy and 
        // I will not do that now. Anyways, it _is_ an error which 
        // has to be corrected in the input assembly file and there is 
        // not much point in spending much time on delaing with it 
        // in an especially nice way. (FIXME?)
        return;
    }
    
    for(;;)
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::TS_class:
                _ParseSymbols_Class(nsi);
                break;
            case TextAsmScanner::TS_symbols:
                _ParseSymbols_Symbols(nsi);
                break;
            
            case TextAsmScanner::T_pop:
                _LexNextToken();
                goto breakout;
            
            case TextAsmScanner::TS_base:
                _ParseSymbols_Class_Base(nsi);
                break;
            case TextAsmScanner::TS_size:
                _ParseSymbols_Class_Size(nsi);
                break;
            case TextAsmScanner::TS_virtual:
                if(nsi->nvirtuals)  _AlreadySetError();
                else  nsi->nvirtuals=tok->num;
                _LexNextToken();
                break;
            case TextAsmScanner::TS_vtable:
                _ParseSymbols_Class_VTable(nsi);
                break;
            
            default:
                _ExpectError("class entry "
                    "(class/funcent/symbols/...) or ';'");
                // Assume forgotten ';'. 
                goto breakout;
        }
    }
    breakout:;
}


void AssemblerFile_Plaintext::_ParseInfoSection()
{
    while(tok)  // while not EOF
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::TI_abivers:
                abi_version=tok->str_val;  // TLString assignment. 
                _LexNextToken();
                break;
            
            case TextAsmScanner::T_info:        // fall...
            case TextAsmScanner::T_symbols:     //   ...
            case TextAsmScanner::T_locations:   //    ...
            case TextAsmScanner::T_program:     // ...through
                goto breakout;
            
            default:
                _ExpectError("abiversion "
                    "or section marker");
                _LexNextToken();
                break;
        }
    }
    breakout:;
}


void AssemblerFile_Plaintext::_ParseSymbolSection()
{
    // Allocate namespace root if not yet there. 
    if(!nspc_root)
    {
        // The root is always plain NamespaceInfo and name is a NULL ref. 
        nspc_root=new NamespaceInfo(/*name=*/TLString(),/*parent=*/NULL);
        nspc_root->asm_loc=tok->lloc.loc0;
    }
    
    while(tok)  // while not EOF
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::TS_namespace:
                _ParseSymbols_Namespace(nspc_root);
                break;
            case TextAsmScanner::TS_class:
                _ParseSymbols_Class(nspc_root);
                break;
            case TextAsmScanner::TS_symbols:
                _ParseSymbols_Symbols(nspc_root);
                break;
            
            case TextAsmScanner::TS_vglobal:   // fall through
            case TextAsmScanner::TS_pglobal:
                _ParseSymbols_Global();
                break;
            
            case TextAsmScanner::T_info:        // fall...
            case TextAsmScanner::T_symbols:     //   ...
            case TextAsmScanner::T_locations:   //    ...
            case TextAsmScanner::T_program:     // ...through
                goto breakout;
            
            default:
                _ExpectError("namespace/class/funcent/symbols "
                    "or section marker");
                _LexNextToken();
                break;
        }
    }
    breakout:;
}


void AssemblerFile_Plaintext::_ParseLocationSection()
{
    // Not yet implementd. 
    CritAssert(0); // not yet implemented
}


void AssemblerFile_Plaintext::_ParseProgram_Label()
{
    //Assert(_CurrTokID()==TextAsmScanner::TP_[ms]label);
    
    switch(_CurrTokID())
    {
        case TextAsmScanner::TP_mlabel:
        {   // Codemark label. 
            if(!scan.insn_storage)
            {
                Error(tok->lloc,
                    "codemark label &%u outside function",
                    (int)tok->codemark);
                ++n_errors;
            }
            else
            {
                bool is_known;  // Need NOT be set up. 
                codemark2prgadr.AddNode(tok->codemark,
                    scan.insn_storage->length(),&is_known);
                
                // In order to handle codemark labels, we create a map 
                // with the label positions and then resolve all these 
                // labels in _ParseProgram_FinishFunction(). 
                // We can then purge the map again; this makes it possible 
                // to have the same labels multiple times as long as they 
                // appear only once per function. 
                // Should make the compiler easier. And should parse faster. 
                if(is_known)
                {
                    Error(tok->lloc,"duplicate definition of codemark "
                        "label &%u",
                        (uint)tok->codemark);
                    ++n_errors;
                }
            }
        }   break;
        case TextAsmScanner::TP_rlabel:
        {   // Symref label. 
            // This marks the beginning of a function. 
            // If we're currently in a function, finish that off first. 
            _ParseProgram_FinishFunction();
            
            if(tok->symref<0)
            {
                // We actually should not see this as the lexer will 
                // reject negative sign in the matching regexp. 
                Error(tok->lloc,"symref <0 for symbol \"%s\" is reserved "
                    "for internal use ",tok->str_val);
                ++n_errors;
                break;
            }
            
            // Start a new function. 
            scan.insn_storage=new ProgramStorage::Function(
                tok->symref,tok->lloc.loc0);
            
            ProgramStorage::Function *known=symref2function.AddNode(
                tok->symref,scan.insn_storage,NULL);
            if(known)
            {
                Error(tok->lloc,"duplicate definition of function with "
                    "symref $%d",(int)tok->symref);
                _LocFirstDefError(known->loc);  // <-- does ++n_errors;
                DELETE(scan.insn_storage);  Assert(!scan.insn_storage);
                // This will provoke some more errors about instructions 
                // outside functions, but oh well...
            }
            
        }   break;
        case TextAsmScanner::TP_slabel:
        {
            // If we're currently in a function, finish that off first. 
            _ParseProgram_FinishFunction();
            
            SLabelInfo *sa;
            bool exported;
            bool is_init=0;
            if(!strcmp(tok->str_val,".init"))
            {  sa=&slabel_init;  exported=0;  is_init=1;  }
            else if(!strcmp(tok->str_val,".start"))
            {  sa=&slabel_start;  exported=1;  }
            else Assert(0);   // -> see lexer
            
            if(sa->pfunc)
            {
                Error(tok->lloc,"duplicate definition of label %s",
                    tok->str_val);
                ++n_errors;
                // This will provoke some more errors about instructions 
                // outside functions, but oh well...
            }
            else
            {
                // These special functions are (currently) not added to 
                // the symref2function map. They require special treatment 
                // anyways and are never called directly. 
                
                // Set up a nice SymbolEntryE for the function. 
                sa->se.extid=NamespaceInfo::SymbolEntryE::ExtFunction;
                sa->se.ftype=FuncType(FuncType::Function,exported);
                sa->se.nspc=nspc_root;
                if(is_init)
                {
                    // Generate %-suffix. 
                    sa->se.name.sprintf("init~%%%x",(uint)file_num);
                }
                else
                {  sa->se.name=tok->str_val;  }  // <-- Assignment to TLString. 
                
                {
                    NamespaceInfo::SymbolEntryE **known=
                        nspc_root->map_name2symbol.search(sa->se.name);
                    if(known)
                    {
                        Error((*known)->nspc->asm_loc,
                            "cannot use reserved symbol name \"%s\" "
                            "(symref $%d)",
                            sa->se.name.str(),(int)(*known)->symref);
                        ++n_errors;
                    }
                }
                
                // Start a new function. Set symref=0 here as we will 
                // substitute the se pointer immidiately below. 
                sa->pfunc=new ProgramStorage::Function(
                    /*symref=*/0,tok->lloc.loc0);
                sa->pfunc->se=&sa->se;
                
                // Go on adding instructions here: 
                scan.insn_storage=sa->pfunc;
            }
            
        }   break;
        default: Assert(0);
    }
    
    _LexNextToken();
}


void AssemblerFile_Plaintext::_ParseProgramSection()
{
    while(tok)  // while not EOF
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::TP_slabel:  // fall...
            case TextAsmScanner::TP_mlabel:  //   ...through
            case TextAsmScanner::TP_rlabel:
                _ParseProgram_Label();
                break;
            
            case TextAsmScanner::T_info:        // fall...
            case TextAsmScanner::T_symbols:     //   ...
            case TextAsmScanner::T_locations:   //     ...
            case TextAsmScanner::T_program:     // ...through
                goto breakout;
            
            default:
                _ExpectError("label or instruction ");
                _LexNextToken();
                break;
        }
    }
    breakout:;
    
    // Make sure we do not leave a function dangling. 
    _ParseProgram_FinishFunction();
}


int AssemblerFile_Plaintext::ParseFile(const TLString &fname,SError &error,
    uint32 _file_num)
{
    file_num=_file_num;
    
    int rv=scan.SetInput(fname,error,/*included=*/0);
    if(rv)
    {
        // If this fails; attempt to read in more than one file. 
        Assert(rv!=1);
        
        return(1);
    }
    
    // Yeah, then let's parse!
    _LexNextToken();
    
    // Set file name member. 
    this->filename=scan.CurrLoc();
    this->filename.pos->SetLine(-1);
    this->filename.pos->SetLPos(-1);
    
    while(tok)  // while not EOF
    {
        switch(_CurrTokID())
        {
            case TextAsmScanner::T_info:
                _LexNextToken();
                _ParseInfoSection();
                break;
            case TextAsmScanner::T_symbols:
                _LexNextToken();
                _ParseSymbolSection();
                break;
            case TextAsmScanner::T_locations:
                _LexNextToken();
                _ParseLocationSection();
                break;
            case TextAsmScanner::T_program:
                _LexNextToken();
                _ParseProgramSection();
                break;
            default:
                _ExpectError("section marker (symbols/locations/program)");
                _LexNextToken();
                break;
        }
    }
    
    tok=NULL;
    
    return(scan.NErrors()+n_errors);
}

}  // end of namespace VM

---