winxedst1.winxed

#! winxed

/***********************************************************************
                   Winxed stage 1 compiler
***********************************************************************/

namespace Winxed
{
namespace Compiler
{

//*********************************************
//          Character test functions
//*********************************************

function isspace(string c)
{
    return c == ' ' || c == "\n" || c == "\t";
}

function isdigit(string c)
{
    return indexof('0123456789', c) > -1;
}

function hexdigit(string c)
{
    int i = indexof('0123456789abcdef0123456789ABCDEF', c);
    if (i >= 0) i = i % 16;
    return i;
}

function isidentstart(string c)
{
    return indexof(
        'abcdefghijklmnopqrstuvwxyz' +
        'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + '_',
        c) > -1;
}

function isident(string c)
{
    return indexof(
        'abcdefghijklmnopqrstuvwxyz' +
        'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + '_$' +
        '0123456789',
        c) > -1;
}


//*********************************************
//        Error handling exceptions
//*********************************************

const string
    ERR_INTERNAL = 'internal',
    ERR_TOKEN    = 'tokenizer',
    ERR_PARSER   = 'parser';

class WinxedCompilerError
{
    // Payload for compiler exceptions.
    var type;     // internal, tokenizer, parser
    var filename;
    var line;
    var message;

    function WinxedCompilerError(
            string type,
            string message,
            string filename[optional],
            int line[optional])
    {
        self.type = type;
        self.message = message;
        self.filename = filename;
        self.line = line;
    }
}

function Warn(string msg, var pos [optional], int has_pos [opt_flag])
{
    var stderr = getstderr();
    stderr.print('WARNING: ');
    stderr.print(msg);
    if (has_pos) {
        stderr.print(' near ');
        stderr.print(pos.show());
    }
    stderr.print("\n");
}

function InternalError(string msg, var pos [optional], int has_pos [opt_flag])
{
    if (has_pos) {
        string desc = pos.show();
        msg = msg + ' near ' + desc;
    }
    var payload = has_pos ?
        new WinxedCompilerError(ERR_INTERNAL, msg,
                pos.filename(), pos.linenum()) :
        new WinxedCompilerError(ERR_INTERNAL, msg);
    throw Error(msg, 2, __WINXED_ERROR__, payload);
}

function TokenError(string msg, tk, int line)
{
    throw Error(msg + ' in ' + string(tk.filename) + ' line ' + string(line),
            2, __WINXED_ERROR__,
            new WinxedCompilerError(ERR_TOKEN, msg, tk.filename, line));
}

function SyntaxError(string msg, var pos)
{
    int line = pos.linenum();
    string file = pos.filename();
    string desc = ' near ' + string(pos.viewable());
    throw Error(msg + ' in ' + file + ' line ' + string(line) + desc,
            2, __WINXED_ERROR__,
            new WinxedCompilerError(ERR_PARSER, msg + desc,
                   file, line));
}

function NoLeftSide(var pos)
{
    SyntaxError('Not a left-side expression', pos);
}

function Expected(string msg, var t)
{
    SyntaxError("Expected " + msg, t);
}

function Unexpected(string msg, var t)
{
    SyntaxError("Unexpected " + msg, t);
}

function ExpectedIdentifier(var t)
{
    SyntaxError("Expected identifier", t);
}

function ExpectedOp(string msg, var t)
{
    SyntaxError("Expected '" + msg + "'", t);
}

function RequireOp(string name, var t)
{
    if (! t.isop(name))
        ExpectedOp(name, t);
}

function RequireKeyword(string name, var t)
{
    if (! t.iskeyword(name))
        ExpectedOp(name, t);
}

function RequireIdentifier(var t)
{
    if (! t.isidentifier())
        ExpectedIdentifier(t);
}

function ExpectOp(string name, var tk)
{
    var t = tk.get();
    RequireOp(name, t);
}

function ExpectKeyword(string name, var tk)
{
    var t = tk.get();
    RequireKeyword(name, t);
}

function UndefinedVariable(name)
{
    SyntaxError("Variable '" + string(name) + "' is not defined", name);
}

//*********************************************
//                Token
//*********************************************

class Token
{
    var file;
    var line;
    function Token(string file, int line)
    {
        self.file = file;
        self.line = line;
    }

    function iseof()          { return false; }
    function iscomment()      { return false; }
    function isidentifier()   { return false; }
    function isint()          { return false; }
    function isfloat()        { return false; }
    function isstring()       { return false; }
    function issinglequoted() { return false; }

    function getintvalue()
    {
        InternalError('Not a literal int', self);
    }
    function rawstring()
    {
        InternalError('Not a literal string', self);
    }
    function getidentifier()
    {
        ExpectedIdentifier(self);
    }
    function iskeyword(string name) { return false; }
    function checkkeyword()         { return false; }
    function isop(string name)      { return false; }
    function checkop() { return ''; }
    function viewable() { return '(unknown)'; }
    function filename() { return self.file; }
    function linenum() { return self.line; }
    function show()
    {
        string r = self.viewable();
        return r + ' at ' + string(self.file) + ' line ' + string(self.line);
    }
}

class TokenEof : Token
{
    function TokenEof(string file)
    {
        self.Token(file, 0);
    }
    function iseof() { return true; }
    function viewable() { return '(End of file)'; }
}

class TokenWithVal : Token
{
    var str;
    function TokenWithVal(string file, int line, string str)
    {
        self.Token(file, line);
        self.str = str;
    }
    function get_string[vtable]() { return self.str; }
    function viewable()
    {
        return self.str;
    }
}

class TokenComment : TokenWithVal
{
    function TokenComment(string file, int line, string str)
    {
        self.TokenWithVal(file, line, str);
    }
    function iscomment() { return true; }
}

class TokenOp : TokenWithVal
{
    function TokenOp(string file, int line, string str)
    {
        self.TokenWithVal(file, line, str);
    }
    function isop(string name)
    {
        return self.str == name;
    }
    function checkop()
    {
        return string(self.str);
    }
}

class TokenIdentifier : TokenWithVal
{
    function TokenIdentifier(string file, int line, string str)
    {
        self.TokenWithVal(file, line, str);
    }
    function isidentifier() { return true; }
    function getidentifier()
    {
        return self.str;
    }
    function checkkeyword()
    {
        return string(self.str);
    }
    function iskeyword(string name)
    {
        return self.str == name;
    }
}

class TokenString : TokenWithVal
{
    function isstring() { return true; }
    function rawstring()
    {
        return self.str;
    }
}

class TokenQuoted : TokenString
{
    function TokenQuoted(string file, int line, string str)
    {
        self.TokenWithVal(file, line, str);
    }
    function get_string[vtable]()
    {
        return '"' + string(self.str) + '"';
    }
    function viewable()
    {
        return '"' + string(self.str) + '"';
    }
    function getasquoted()
    {
        return self.str;
    }
    function getPirString()
    {
        string str = self.str;
        var s = str;
        string strunesc;
        try {
            strunesc = s.unescape('utf8');
        }
        catch () {
            SyntaxError("Invalid escape sequence in literal string", self);
        }
        int need_encoding = false;
        for (int code in strunesc) {
            if (code > 127) {
                need_encoding = true;
                break;
            }
        }
        str = escape(strunesc);
        string encoding = need_encoding ? "utf8:" : "";
        return encoding + '"' + str + '"';
    }
}

class TokenSingleQuoted : TokenString
{
    function TokenSingleQuoted(string file, int line, string str)
    {
        self.TokenWithVal(file, line, str);
    }
    function issinglequoted() { return true; }
    function get_string[vtable]()
    {
        return "'" + string(self.str) + "'";
    }
    function viewable()
    {
        return "'" + string(self.str) + "'";
    }
    function getasquoted()
    {
        string s = '';
        for (string c in self.str) {
            switch (c) {
              case '"':
              case '\':
              case "'":
                c = '\' + c;
                break;
            }
            s += c;
        }
        return s;
    }
    function getPirString()
    {
        string str = self.str;
        string quote = "'";
        int need_escape = false;
        for (int code in str) {
            if (code < 32 || code > 127) {
                need_escape = true;
                break;
            }
        }
        int need_encoding = false;
        if (need_escape) {
            quote = '"';
            string result = '';
            for (string c in str) {
                if (c == '\')
                    result += '\\';
                else
                {
                    int n = ord(c);
                    if (n < 32 || n > 127) {
                        if (n > 127)
                            need_encoding = true;
                        string h = n.get_as_base(16);
                        result += '\x{' + h + '}';
                    }
                    else
                        result += c;
                }
            }
            str = result;
        }
        str = quote + str + quote;
        if (need_encoding)
            str = 'utf8:' + str;
        return str;
    }
}

class TokenInteger : TokenWithVal
{
    function TokenInteger(string file, int line, string str)
    {
        self.TokenWithVal(file, line, str);
    }
    function isint() { return true; }
    function getintvalue()
    {
        return int(self.str);
    }
}

class TokenFloat : TokenWithVal
{
    function TokenFloat(string file, int line, string str)
    {
        self.TokenWithVal(file, line, str);
    }
    function isfloat() { return true; }
    function getfloatvalue()
    {
        return float(self.str);
    }
}


//*********************************************
//       Tokenizer auxiliar functions
//*********************************************

function getquoted(tk, string start, int line)
{
    string s = '';
    string c;
    for (c = tk.getchar(); c != '"'; c = tk.getchar()) {
        switch (c) {
          case "":
          case "\n":
            TokenError('Unterminated string', tk, line);
          case '\':
            // Quick fix for escaped double quotes.
            string c2 = tk.getchar();
            if (c2 == '' || c2 == "\n")
                TokenError('Unterminated string', tk, line);
            s += c + c2;
            break;
          default:
            s += c;
        }
    }
    return new TokenQuoted(tk.filename, line, s);
}

function getsinglequoted(tk, string start, int line)
{
    string s = '';
    string c;
    for (c = tk.getchar(); c != "'"; c = tk.getchar()) {
        if (c == "" || c == "\n")
            TokenError('Unterminated string', tk, line);
        s += c;
    }
    return new TokenSingleQuoted(tk.filename, line, s);
}

function getheredoc(tk, string start, int linenum)
{
    string mark = '';
    string c;
    for (c = tk.getchar(); c != "\n"; c = tk.getchar()) {
        switch (c) {
          case '':
            TokenError('Unterminated heredoc', tk, linenum);
          case '"':
          case '\':
            // Encode the mark the same way as the heredoc content
            // to simplify its detection
            c = '\' + c;
            break;
        }
        mark = mark + c;
    }
    mark = mark + ':>>';

    string content = '';
    string line;
    do {
        line = '';
        for (c = tk.getchar(); c != "\n"; c = tk.getchar()) {
            switch (c) {
              case '':
                TokenError('Unterminated heredoc', tk, linenum);
              case '"':
              case '\':
                c = '\' + c;
                break;
            }
            line += c;
        }
        if (line != mark)
            content += line + '\n';
    } while (line != mark);
    return new TokenQuoted(tk.filename, linenum, content);
}

function getident(tk, string start, int line)
{
    string s = start;
    string c;
    for (c = tk.getchar(); isident(c); c = tk.getchar())
        s += c;
    tk.ungetchar(c);
    return new TokenIdentifier(tk.filename, line, s);
}

function getnumber(tk, string start, int line)
{
    string s;
    string c = start;
    do {
        s += c;
        c = tk.getchar();
    } while (isdigit(c));
    if (s == '0' && (c == 'x' || c == 'X')) {
        int hexval = 0, h;
        for (c = tk.getchar(); (h = hexdigit(c)) >= 0; c = tk.getchar()) {
            hexval = hexval * 16 + h;
            s += c;
        }
        tk.ungetchar(c);
        s = hexval;
        return new TokenInteger(tk.filename, line, s);
    }
    if (c == '.') {
        do {
            s += c;
            c = tk.getchar();
        } while (isdigit(c));
        if (c == 'e' || c == 'E') {
            s += 'E';
            if ((c = tk.getchar()) == '+' || c == '-') {
                s += c;
                c = tk.getchar();
            }
            for ( ; isdigit(c); c = tk.getchar())
                s += c;
        }
        tk.ungetchar(c);
        return new TokenFloat(tk.filename, line, s);
    }
    else {
        if (c == 'e' || c == 'E') {
            s += 'E';
            if ((c = tk.getchar()) == '+' || c == '-') {
                s += c;
                c = tk.getchar();
            }
            for ( ; isdigit(c); c = tk.getchar())
                s += c;
            tk.ungetchar(c);
            return new TokenFloat(tk.filename, line, s);
        }
        else {
            tk.ungetchar(c);
            return new TokenInteger(tk.filename, line, s);
        }
    }
}

function getlinecomment(tk, string start, int line)
{
    string s = start;
    for (string c = tk.getchar(); c != '' && c != "\n"; c = tk.getchar())
        s += c;
    return new TokenComment(tk.filename, line, s);
}

function getcomment(tk, string start, int line)
{
    string s = start;
    string c = tk.getchar();
    do {
       for ( ; c != '' && c != '*'; c = tk.getchar())
            s += c;
        if (c == '')
            TokenError("Unclosed comment", tk, line);
        s += c;
        c = tk.getchar();
        if (c == '')
            TokenError("Unclosed comment", tk, line);
    } while (c != '/');
    s += '/';
    return new TokenComment(tk.filename, line, s);
}

function getop(tk, string start, int line)
{
    string s = start;
    return new TokenOp(tk.filename, line, s);
}

//*********************************************
//              Tokenizer
//*********************************************

class Tokenizer
{
    var h;
    var pending;
    var select;
    var stacked;
    var filename;
    var line;
    function Tokenizer(handle, string filename)
    {
        self.h = handle;
        self.pending = '';
        self.stacked = [];
        self.filename = filename;
        self.line = 1;
        var select = {
            '$': { '': getident, '{': getop },
            '"': getquoted,
            "'": getsinglequoted,
            '=': {
                '=': { '': getop, '=': getop },
                ':': getop
            },
            '+': { '+': getop, '=': getop },
            '-': { '-': getop, '=': getop },
            '*': { '=': getop },
            '|': { '|': getop },
            '&': { '&': getop },
            '<': {
                '<': { '': getop, ':': getheredoc },
                '=': getop
            },
            '>': { '>': getop, '=': getop },
            '!': {
                '=': { '': getop, '=': getop }
            },
            '%': { '%': getop, '=': getop },
            '/': { '=': getop, '/': getlinecomment, '*': getcomment },
            '#': getlinecomment
        };
        self.select = select;
    }
    function getchar()
    {
        var pending = self.pending;
        string c = pending;
        if (c != '')
            pending =: '';
        else {
            var h = self.h;
            c = h.read(1);
            if (c == "\n")
                ++self.line;
        }
        return c;
    }
    function ungetchar(string c)
    {
        self.pending =: c;
    }
    function get_token()
    {
        if (self.stacked)
            return self.stacked.pop();

        string c = self.getchar();
        while (isspace(c))
                c = self.getchar();
        int line = self.line;
        if (c == '')
            return new TokenEof(self.filename);
        if (isidentstart(c))
            return getident(self, c, line);
        if (isdigit(c))
            return getnumber(self, c, line);

        string op = c;
        var select = self.select;
        var current = select[c];

        while (current != null && (current instanceof 'Hash')) {
            c = self.getchar();
            select = current;
            current = select[c];
            if (current == null) {
                self.ungetchar(c);
                current = select[''];
            }
            else
                op += c;
        }
        if (current)
            return current(self, op, line);
        return getop(self, op, line);
    }
    function get(int withcomments [optional])
    {
        var t = self.get_token();
        while (!t.iseof() && !withcomments && t.iscomment())
           t = self.get_token();
        return t;
    }
    function unget(t)
    {
        push(self.stacked, t);
    }
}

//*********************************************
//          PIR generation values
//*********************************************

// Register types
const string
    REGint =     'I',
    REGfloat =   'N',
    REGstring =  'S',
    REGvar =     'P',
// Pseudotypes for predefined functions
    REGarglist = '*',
    REGany     = '?',
    REGs_v     = 'p', // string or var
    REGraw1    = '!', // raw mode one arg
    REGnone    = 'v'; // void return

function typetoregcheck(string type)
{
    switch (type) {
    case 'int':    return REGint;
    case 'float':  return REGfloat;
    case 'string': return REGstring;
    case 'var':    return REGvar;
    default:       return '';
    }
}

function typetopirname(string regtype)
{
    switch(regtype) {
    case REGint:    return 'int';
    case REGfloat:  return 'num';
    case REGstring: return 'string';
    case REGvar:    return 'pmc';
    default:        InternalError('Invalid reg type');
    }
}

//*********************************************
//            Emit
//*********************************************

const string INDENT =      '    ';
const string INDENTLABEL = '  ';

class Emit
{
    var handle;
    var file;
    var line;
    var pendingf;
    var pendingl;
    var noan;

    function Emit(var handle)
    {
        self.handle = handle;
        self.file = '';
        self.line = 0;
        self.pendingf = false;
        self.pendingl = false;
    }
    function disable_annotations()
    {
        self.noan = 1;
    }
    function close()
    {
        self.handle = null;
    }
    function updateannot()
    {
        if (self.pendingf) {
            self.handle.print(join("", [
                ".annotate 'file', '",
                self.file,
                "'\n" ]
            ));
            self.pendingf =: false;
        }
        if (self.pendingl) {
            self.handle.print(join("", [
                ".annotate 'line', ",
                self.line,
                "\n" ]
            ));
            self.pendingl =: false;
        }
    }
    function vprint(var args)
    {
        for (var s in args)
            self.handle.print(s);
    }
    function print(var args [slurpy])
    {
        self.updateannot();
        self.vprint(args);
    }
    function say(var args [slurpy])
    {
        self.updateannot();
        self.vprint(args);
        self.handle.print("\n");
    }
    function annotate(var t)
    {
        if (self.noan == null)
        {
            var file = self.file;
            var line = self.line;
            string tfile = t.file;
            int tline = t.line;
            if (file != tfile) {
                file =: tfile;
                self.pendingf =: true;
                line =: 0;
            }
            if (line != tline) {
                line =: tline;
                self.pendingl =: true;
            }
        }
    }
    function comment(string s)
    {
        self.updateannot();
        self.handle.print('# ' + s + "\n");
    }
    function emitlabel(string label, string comment [optional])
    {
        var handle = self.handle;
        handle.print(INDENTLABEL);
        handle.print(label);
        handle.print(':');
        if (comment != null)
            handle.print(' # ' + comment);
        handle.print("\n");
    }
    function emitgoto(string label, string comment [optional])
    {
        var handle = self.handle;
        handle.print(INDENT + 'goto ');
        handle.print(label);
        if (comment != null)
            handle.print(' # ' + comment);
        handle.print("\n");
    }

    function emitarg1(string op, string arg1)
    {
        self.say(INDENT + op + ' ' + arg1);
    }
    function emitarg2(string op, string arg1, string arg2)
    {
        self.say(INDENT + op + ' ' + arg1 + ', ' + arg2);
    }
    function emitcompare(string op, string arg1, string arg2, string label)
    {
        self.say(INDENT + op + ' ' + arg1 + ', ' + arg2 + ', ' + label);
    }
    function emitif(string value, string label)
    {
        self.say(INDENT + 'if ', value, ' goto ', label);
    }
    function emitunless(string value, string label)
    {
        self.say(INDENT + 'unless ', value, ' goto ', label);
    }
    function emitif_null(string value, string label)
    {
        self.say(INDENT + 'if_null ', value, ', ', label);
    }
    function emitnull(string dst)
    {
        self.say(INDENT + "null ", dst);
    }

    function emitinc(string arg)
    {
        self.say(INDENT + 'inc ', arg);
    }
    function emitdec(string arg)
    {
        self.say(INDENT + 'dec ', arg);
    }
    function emitset(string dst, string src)
    {
        self.say(INDENT + "set ", dst, ", ", src);
    }
    function emitassign(string dst, string src)
    {
        self.say(INDENT + "assign ", dst, ", ", src);
    }
    function emitbox(string dst, string src)
    {
        self.say(INDENT + "box ", dst, ", ", src);
    }
    function emitunbox(string dst, string src)
    {
        self.say(INDENT + "unbox ", dst, ", ", src);
    }
    function emitbinop(string op, string res, string dst, string src)
    {
        self.say(INDENT, op, " ", res, ", ", dst, ", ", src);
    }
    function emitaddto(string dst, string src)
    {
        self.say(INDENT + "add ", dst, ", ", src);
    }
    function emitsubto(string dst, string src)
    {
        self.say(INDENT + "sub ", dst, ", ", src);
    }
    function emitadd(string dst, string src1, string src2)
    {
        self.say(INDENT + "add ", dst, ", ", src1, ", ", src2);
    }
    function emitsub(string dst, string src1, string src2)
    {
        self.say(INDENT + "sub ", dst, ", ", src1, ", ", src2);
    }
    function emitmul(string dst, string src1, string src2)
    {
        self.say(INDENT + "mul ", dst, ", ", src1, ", ", src2);
    }
    function emitdiv(string dst, string src1, string src2)
    {
        self.say(INDENT + "div ", dst, ", ", src1, ", ", src2);
    }
    function emitconcat1(string dst, string src)
    {
        self.say(INDENT + "concat ", dst, ", ", dst, ", ", src);
    }
    function emitconcat(string dst, string src1, string src2)
    {
        self.say(INDENT + "concat ", dst, ", ", src1, ", ", src2);
    }
    function emitrepeat(string dst, string src1, string src2)
    {
        self.say(INDENT + "repeat ", dst, ", ", src1, ", ", src2);
    }
    function emitprint(string arg)
    {
        self.say(INDENT + 'print ', arg);
    }
    function emitsay(string arg)
    {
        self.say(INDENT + 'say ', arg);
    }
    function emitget_hll_global(string reg, string name, string key[optional])
    {
        self.print(INDENT + "get_hll_global " + reg );
        if (key != null)
            self.print(", " + key);
        self.say(", '" + name + "'");
    }
    function emitfind_lex(string reg, string name)
    {
        self.say(INDENT + "find_lex " + reg + ", '" + name + "'");
    }
    function emitstore_lex(string name, string reg)
    {
        self.say("store_lex '", name, "', ", reg);
    }
}

//*********************************************
//         Helper functions and constants
//*********************************************

function integerValue(var owner, var start, int value)
{
    return new IntegerLiteral(owner, start, value);
}

function floatValue(var owner, var start, float value)
{
    var t = new TokenFloat(start.file, start.line, value);
    return new FloatLiteral(owner, t);
}

function floatresult(string r1, string r2)
/*
    Check if the passed types can give a float result in arithmetic
    operations.
*/
{
    int result = (r1 == REGfloat && (r2 == REGfloat || r2 == REGint)) ||
           (r2 == REGfloat && (r1 == REGfloat || r1 == REGint));
    return result;
}

function floatAsString(float n)
/*
    Make sure that a float value is recognized as such by the
    PIR compiler, adding a dot if needed.
*/
{
    string aux = n;
    if (indexof(aux, '.') < 0)
        aux += '.0';
    return aux;
}

const string NULL = 'null', SELF = 'self';

// Var flags
const int
    VAR_is_volatile = 1, // volatile qualifier
    VAR_is_lexical  = 2, // lexicalized local variable
    VAR_is_extern   = 4; // externaly defined constant, do not export

// Predefined constants

// Fake filename and line number for the tokens.
const string PREDEFCONST_FILENAME = '__predefconst__';
const int PREDEFCONST_LINENUM = 0;

function createPredefConstInt(scope, string name, int value)
{
    var tid = new TokenIdentifier(PREDEFCONST_FILENAME, PREDEFCONST_LINENUM,
        name);
    var cst = scope.createconst(tid, REGint, VAR_is_extern);
    cst.setvalue(integerValue(scope, tid, value));
}

function createPredefConstString(scope, string name, string value)
{
    var tid = new TokenIdentifier(PREDEFCONST_FILENAME, PREDEFCONST_LINENUM,
        name);
    var cst = scope.createconst(tid, REGstring, VAR_is_extern);
    cst.setvalue(new StringLiteral(scope,
        new TokenQuoted(PREDEFCONST_FILENAME, PREDEFCONST_LINENUM, value)));
}

//*********************************************
//         Predefined functions
//*********************************************

// Set this to non-zero to enable sanity checks of predef definitions.
const int __DEBUG_PREDEFS = 0;

const int PREDEF_arglist = -1, PREDEF_raw1 = -2;

// Invokable object generated from a string body
class Predef_frombody
{
    const string resultmark = '%0';
    var body;
    var typeresult;
    function Predef_frombody(string typeresult, string bodystr)
    {
        if (__DEBUG_PREDEFS) {
            // Minimal sanity check
            int pos = indexof(bodystr, resultmark);
            if (typeresult == REGnone && pos != -1)
                InternalError('void predef with ' + resultmark);
            if (typeresult != REGnone && pos == -1)
                InternalError('non void predef without ' + resultmark);
        }

        // Predecorate output
        int l = length(bodystr) - 1;
        if (substr(bodystr, l, 1) == "\n")
            bodystr = substr(bodystr, 0, l);
        bodystr = INDENT + join("\n" + INDENT, split("\n", bodystr));
        self.body = bodystr;
        self.typeresult = typeresult;
    }
    function invoke [vtable](e, start, string result, args)
    {
        string typeresult = self.typeresult;

        if (typeresult == REGnone) {
            if (result != null && result != '')
                SyntaxError('using return value from void predef');
        }
        else {
            if (result == null || result == '')
                InternalError('Bad result in non void predef');
        }

        var builder = new ['StringBuilder'];
        builder.append_format(self.body, result, args:[flat]);
        e.annotate(start);
        e.say(string(builder));
    }
}

class PredefBase
{
    var name;
    var body;
    var typeresult;
    var type0;
    var type1;
    var type2;
    var type3;
    var nparams;

    function PredefBase(string name, body,
        string typeresult,
        string type0,
        string type1,
        string type2,
        string type3)
    {
        self.name = name;
        if (body instanceof 'String')
            self.body = new Predef_frombody(typeresult, body);
        else
            self.body = body;
        self.typeresult = typeresult;
        int n = 0;
        if (type0 != null) {
            self.type0 = type0;
            switch (type0) {
              case REGarglist:
                n = PREDEF_arglist;
                break;
              case REGraw1:
                n = PREDEF_raw1;
                if (type1 != null)
                    InternalError("Invalid predef '" + name + '"');
                break;
              default:
                n = 1;
                if (type1 != null) {
                    self.type1 = type1;
                    ++n;
                }
                if (type2 != null) {
                    self.type2 = type2;
                    ++n;
                }
                if (type3 != null) {
                    self.type3 = type3;
                    ++n;
                }
            }
        }
        self.nparams = n;
    }
    function name()
    {
        string name = self.name;
        return name;
    }
    function result()
    {
        return self.typeresult;
    }
    function params() { return self.nparams; }
    function paramtype(int i)
    {
        string type;
        switch (i) {
        case 0: type = self.type0; break;
        case 1: type = self.type1; break;
        case 2: type = self.type2; break;
        case 3: type = self.type3; break;
        default:
            InternalError('Invalid predef arg');
        }
        return type;
    }
    function expand(var e, var owner, var start, string result, args)
    {
        e.comment('predefined ' + string(self.name));
        string typeresult = self.typeresult;
        if (typeresult != REGnone && result == '')
            result = owner.tempreg(typeresult);
        var fun = self.body;
        fun(e, start, result, args);
    }
}

class PredefFunction : PredefBase
{
    function PredefFunction(string name, body,
        string typeresult,
        string type0[optional],
        string type1[optional],
        string type2[optional],
        string type3[optional])
    {
        self.PredefBase(name, body, typeresult, type0, type1, type2, type3);
    }
}

class PredefFunctionEval : PredefBase
{
    var evalfun;
    function PredefFunctionEval(string name, evalfun, body,
        string typeresult,
        string type0[optional],
        string type1[optional],
        string type2[optional],
        string type3[optional])
    {
        self.PredefBase(name, body, typeresult, type0, type1, type2, type3);
        self.evalfun = evalfun;
    }
}

class Predef_typecast
{
    var type;
    function Predef_typecast(string type)
    {
        self.type = type;
    }
    function invoke [vtable](e, start, result, args)
    {
        string type = self.type;
        if (elements(args) != 1)
            InternalError("Invalid Predef_typecast.invoke call");
        var rawarg = args[0];
        string argtype = rawarg.checkresult();
        switch {
          case argtype == type:
          case rawarg instanceof IndexExpr:
            rawarg.emit(e, result);
            break;
          default:
            string arg = rawarg.emit_get(e);
            e.annotate(start);
            // Special case
            if (arg == NULL)
                e.emitnull(result);
            else
                e.emitset(result, arg);
        }
    }
}

function Predef_say(e, start, string result, args)
{
    e.annotate(start);
    int n = elements(args) - 1;
    if (n >= 0) {
        for (int i = 0; i < n; ++i)
            e.emitprint(args[i]);
        e.emitsay(args[n]);
    }
    else
        e.emitsay("''");
}

function Predef_cry(e, start, string result, args)
{
    e.annotate(start);
    e.say(INDENT, "getstderr $P0");
    for (string arg in args)
        e.say(INDENT, "print $P0, ", arg);
    e.say(INDENT, "print $P0, \"\\n\"");
}

function Predef_print(e, start, string result, args)
{
    e.annotate(start);
    for (string arg in args)
        e.emitprint(arg);
}

// invoke is a quick & dirty way to allow use of multiple return values.
// It's a wrap around the call that gives the signature object returned.
function Predef_invoke(e, start, string result, args)
{
    var arg = args[0];
    if (! (arg instanceof CallExpr))
        SyntaxError("invoke argument must be callable", start);
    arg.emit(e, "(" + result + " :call_sig)");
}

function predefeval_length(var owner, var start, var args)
{
    var arg = args[0].arg;
    string s = arg.get_value();
    return integerValue(owner, start, length(s));
}

function predefeval_bytelength(var owner, var start, var args)
{
    var arg = args[0].arg;
    string s = arg.get_value();
    return integerValue(owner, start, bytelength(s));
}

function predefeval_ord(var owner, var start, var args)
{
    var arg = args[0].arg;
    string s = arg.get_value();
    return integerValue(owner, start, ord(s));
}

function predefeval_ord_n(var owner, var start, var args)
{
    var arg = args[0].arg;
    string s = arg.get_value();
    var argn = args[1].arg;
    int n = argn.numval;
    return integerValue(owner, start, ord(s, n));
}

function predefeval_chr(var owner, var start, var args)
{
    var arg = args[0].arg;

    int n = arg.numval;
    string s = chr(n);

    var t = new TokenQuoted(start.file, start.line, s);
    return new StringLiteral(owner, t);
}

function predefeval_substr(var owner, var start, var args)
{
    var argstr = args[0].arg;
    var argpos = args[1].arg;
    string str = argstr.get_value();
    int pos = argpos.numval;

    var t = new TokenQuoted(start.file, start.line, substr(str, pos));
    return new StringLiteral(owner, t);
}

function predefeval_substr_l(var owner, var start, var args)
{
    var argstr = args[0].arg;
    var argpos = args[1].arg;
    var arglen = args[2].arg;
    string str = argstr.get_value();
    int pos = argpos.numval;
    int len = arglen.numval;

    var t = new TokenQuoted(start.file, start.line, substr(str, pos, len));
    return new StringLiteral(owner, t);
}

function predefeval_indexof(var owner, var start, var args)
{
    var argstrfrom = args[0].arg;
    var argstrsearch = args[1].arg;
    string strfrom = argstrfrom.get_value();
    string strsearch = argstrsearch.get_value();
    return integerValue(owner, start, indexof(strfrom, strsearch));
}

function predefeval_indexof_pos(var owner, var start, var args)
{
    var argstrfrom = args[0].arg;
    var argstrsearch = args[1].arg;
    var argpos = args[2].arg;
    string strfrom = argstrfrom.get_value();
    string strsearch = argstrsearch.get_value();
    int pos = argpos.numval;
    return integerValue(owner, start, indexof(strfrom, strsearch, pos));
}

function getpredefs()
{
    var predefs = [
        new PredefFunction('int',
            new Predef_typecast(REGint),
            REGint, REGraw1
        ),
        new PredefFunction('float',
            new Predef_typecast(REGfloat),
            REGfloat, REGraw1
        ),
        new PredefFunction('string',
            new Predef_typecast(REGstring),
            REGstring, REGraw1
        ),
        new PredefFunction('die',
            'die %1',
            REGnone, REGstring
        ),
        new PredefFunction('exit',
            'exit %1',
            REGnone, REGint
        ),
        new PredefFunction('time',
            'time %0',
            REGint
        ),
        new PredefFunction('floattime',
            'time %0',
            REGfloat
        ),
        new PredefFunction('spawnw',
            'spawnw %0, %1',
            REGint, REGvar
        ),
        new PredefFunction('getstdin',
            'getstdin %0',
            REGvar
        ),
        new PredefFunction('getstdout',
            'getstdout %0',
            REGvar
        ),
        new PredefFunction('getstderr',
            'getstderr %0',
            REGvar
        ),
        new PredefFunction('open',
<<:
root_new %0, ['parrot';'FileHandle']
%0.'open'(%1)
:>>
            , REGvar, REGstring
        ),
        new PredefFunction('open',
<<:
root_new %0, ['parrot';'FileHandle']
%0.'open'(%1,%2)
:>>
            , REGvar, REGstring, REGstring
        ),
        new PredefFunction('Error',
<<:
root_new %0, ['parrot';'Exception']
%0['message'] = %1
:>>
            , REGvar, REGstring
        ),
        new PredefFunction('Error',
<<:
root_new %0, ['parrot';'Exception']
%0['message'] = %1
%0['severity'] = %2
:>>
            , REGvar, REGstring, REGint
        ),
        new PredefFunction('Error',
<<:
root_new %0, ['parrot';'Exception']
%0['message'] = %1
%0['severity'] = %2
%0['type'] = %3
:>>
            , REGvar, REGstring, REGint, REGint
        ),
        new PredefFunction('Error',
<<:
root_new %0, ['parrot';'Exception']
%0['message'] = %1
%0['severity'] = %2
%0['type'] = %3
%0['payload'] = %4
:>>
            , REGvar, REGstring, REGint, REGint, REGvar
        ),
        new PredefFunction('elements',
            'elements %0, %1',
            REGint, REGvar
        ),
        new PredefFunctionEval('length',
            predefeval_length,
            'length %0, %1',
            REGint, REGstring
        ),
        new PredefFunctionEval('bytelength',
            predefeval_bytelength,
            'bytelength %0, %1',
            REGint, REGstring
        ),
        new PredefFunctionEval('chr',
            predefeval_chr,
<<:
chr $S0, %1
find_encoding $I0, 'utf8'
trans_encoding %0, $S0, $I0
:>>
            , REGstring, REGint
        ),
        new PredefFunctionEval('ord',
            predefeval_ord,
            'ord %0, %1',
            REGint, REGstring
        ),
        new PredefFunctionEval('ord',
            predefeval_ord_n,
            'ord %0, %1, %2',
            REGint, REGstring, REGint
        ),
        new PredefFunctionEval('substr',
            predefeval_substr,
            'substr %0, %1, %2',
            REGstring, REGstring, REGint
        ),
        new PredefFunctionEval('substr',
            predefeval_substr_l,
            'substr %0, %1, %2, %3',
            REGstring, REGstring, REGint, REGint
        ),
        new PredefFunction('replace',
            'replace %0, %1, %2, %3, %4',
            REGstring, REGstring, REGint, REGint, REGstring
        ),
        new PredefFunctionEval('indexof',
            predefeval_indexof,
            'index %0, %1, %2',
            REGint, REGstring, REGstring
        ),
        new PredefFunctionEval('indexof',
            predefeval_indexof_pos,
            'index %0, %1, %2, %3',
            REGint, REGstring, REGstring, REGint
        ),
        new PredefFunction('join',
            'join %0, %1, %2',
            REGstring, REGstring, REGvar
        ),
        new PredefFunction('escape',
            'escape %0, %1',
            REGstring, REGstring
        ),
        new PredefFunction('upcase',
            'upcase %0, %1',
            REGstring, REGstring
        ),
        new PredefFunction('downcase',
            'downcase %0, %1',
            REGstring, REGstring
        ),
        new PredefFunction('titlecase',
            'titlecase %0, %1',
            REGstring, REGstring
        ),
        new PredefFunction('split',
            'split %0, %1, %2',
            REGvar, REGstring, REGstring
        ),
        new PredefFunction('chomp',
<<:
$P0 = get_root_global ['parrot';'String';'Utils'], 'chomp'
%0 = $P0(%1)
:>>
            , REGstring, REGstring
        ),
        new PredefFunction('chomp',
<<:
$P0 = get_root_global ['parrot';'String';'Utils'], 'chomp'
%0 = $P0(%1, %2)
:>>
            , REGstring, REGstring, REGstring
        ),
        new PredefFunction('push',
            'push %1, %2',
            REGnone, REGvar, REGany
        ),
        new PredefFunction('sqrt',
            'sqrt %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('pow',
            'pow %0, %1, %2',
            REGfloat, REGfloat, REGfloat
        ),
        new PredefFunction('exp',
            'exp %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('ln',
            'ln %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('sin',
            'sin %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('cos',
            'cos %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('tan',
            'tan %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('asin',
            'asin %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('acos',
            'acos %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('atan',
            'atan %0, %1',
            REGfloat, REGfloat
        ),
        new PredefFunction('atan',
            'atan %0, %1, %2',
            REGfloat, REGfloat, REGfloat
        ),
        new PredefFunction('getinterp',
            'getinterp %0',
            REGvar
        ),
        new PredefFunction('getcontext',
/* Experimental:
Parrot will probably have a getcontext op in the near future.
At that point this bulitin will just map to that op.
In the meantime, get the conext via getinterp and the
ParrotInterpreter PMC.
*/
<<:
getinterp $P0
%0 = $P0["context"]
:>>
            , REGvar
        ),
        new PredefFunction('get_class',
            'get_class %0, %1',
            REGvar, REGs_v
        ),
        new PredefFunction('typeof',
            'typeof %0, %1',
            REGvar, REGvar
        ),
        new PredefFunction('getattribute',
            'getattribute %0, %1, %2',
            REGvar, REGvar, REGstring
        ),
        new PredefFunction('getattribute',
            'getattribute %0, %1, %2, %3',
            REGvar, REGvar, REGvar, REGstring
        ),
        new PredefFunction('setattribute',
            'setattribute %1, %2, %3, %4',
            REGnone, REGvar, REGvar, REGstring, REGvar
        ),
        new PredefFunction('find_method',
            'find_method %0, %1, %2',
            REGvar, REGvar, REGstring
        ),
        new PredefFunction('callmethodwithargs',
            '%0 = %1.%2(%3 :flat)',
            REGvar, REGvar, REGvar, REGvar
        ),
        new PredefFunction('clone',
            'clone %0, %1',
            REGvar, REGvar
        ),
        new PredefFunction('compreg',
            'compreg %0, %1',
            REGvar, REGstring
        ),
        new PredefFunction('compreg',
            'compreg %1, %2',
            REGnone, REGstring, REGvar
        ),
        new PredefFunction('load_language',
<<:
load_language %1
compreg %0, %1
:>>
            , REGvar, REGstring
        ),
        new PredefFunction('load_language',
<<:
load_language %1
compreg %0, %2
:>>
            , REGvar, REGstring, REGstring
        ),
        new PredefFunction('loadlib',
            'loadlib %0, %1',
            REGvar, REGstring
        ),
        new PredefFunction('load_bytecode',
            'load_bytecode %1',
            REGnone, REGstring
        ),
        new PredefFunction('dlfunc',
            'dlfunc %0, %1, %2, %3',
            REGvar, REGvar, REGstring, REGstring
        ),
        new PredefFunction('sprintf',
            'sprintf %0, %1, %2',
            REGstring, REGstring, REGvar
        ),
        new PredefFunction('sprintf',
            'sprintf %0, %1, %2',
            REGvar, REGvar, REGvar
        ),
        new PredefFunction('print',
            Predef_print,
            REGnone, REGarglist
        ),
        new PredefFunction('say',
            Predef_say,
            REGnone, REGarglist
        ),
        new PredefFunction('cry',
            Predef_cry,
            REGnone, REGarglist
        ),
        new PredefFunction('invoke',
            Predef_invoke,
            REGvar, REGraw1
        )
    ];
    for (;;)
        yield predefs;
}

function findpredef(string name, int nargs)
{
    for (var p in getpredefs())
        if (p.name == name) {
            int pargs = p.nparams;
            if (pargs == nargs ||
                    pargs == PREDEF_arglist ||
                    (pargs == PREDEF_raw1 && nargs == 1))
                return p;
        }
    return null;
}

//*********************************************
//               Auxiliar functions
//*********************************************

function optimize_array(var arr)
{
    if (arr != null) {
        int n = elements(arr);
        for (int i = 0; i < n; ++i)
            arr[i] = arr[i].optimize();
    }
}

function emit_array(e, arr)
{
    for (var item in arr)
        item.emit(e);
}

function parseDotted(tk)
{
    var list = [];
    var t = tk.get();
    if (t.isidentifier()) {
        push(list, t);
        while ((t = tk.get()).isop('.')) {
            t = tk.get();
            push(list, t);
        }
    }
    tk.unget(t);
    return list;
}

function parseList(tk, owner, fn, string oper_end[optional])
/*
  Parse a comma separated list of items.
  Calls the passed fn to parse each item.
*/
{
    var list = [];
    var t;
    do {
        var value = fn(tk, owner);
        push(list, value);
    } while ((t = tk.get()).isop(','));
    if (oper_end == null)
        tk.unget(t);
    else
        if (! t.isop(oper_end))
            SyntaxError("Unfinished argument list", t);
    return list;
}

// Helper to parse identifier lists using parseList
function parseIdentifier(tk, unused)
{
    var t = tk.get();
    if (!t.isidentifier())
        ExpectedIdentifier(t);
    return t;
}

function toIdentifierList(var tlist)
{
    string list[];
    for (var t in tlist)
        push(list, t.getidentifier());
    return list;
}

//*********************************************
//               CommonBase
//*********************************************

class CommonBase
{
    var start;
    var owner;

    function initbase(start, owner)
    {
        self.start = start;
        self.owner = owner;
    }
    function filename()
    {
        if (self.start != null)
            return self.start.filename();
        else
            return "unknown";
    }
    function linenum()
    {
        if (self.start != null)
            return self.start.linenum();
        else
            return 0;
    }
    function viewable()
    {
        if (self.start != null)
            return self.start.viewable();
        else
            return "";
    }
    function annotate(e)
    {
        e.annotate(self.start);
    }
    function use_predef(string name)
    {
        self.owner.use_predef(name);
    }
    function generatesubid()
    {
        return self.owner.generatesubid();
    }
    function usesubid(string id)
    {
        self.owner.usesubid(id);
    }
    function addlocalfunction(fn)
    {
        return self.owner.addlocalfunction(fn);
    }
    function findns(nskey)
    {
        return self.owner.findns(nskey);
    }
    function findsymbol(classkey)
    {
        return self.owner.findsymbol(classkey);
    }
    function findclasskey(classkey)
    {
        return self.owner.findclasskey(classkey);
    }
    function dowarnings()
    {
        return self.owner.dowarnings();
    }
}

//*********************************************
//          SimpleArgList
//*********************************************

// A list of arguments without modifiers.

class SimpleArgList
{
    var args;

    function SimpleArgList(var tk, var owner, string oper_end)
    {
        self.args = parseList(tk, owner, parseExpr, oper_end);
    }

    function numargs()
    {
        return elements(self.args);
    }
    function getarg(int i)
    {
        var args = self.args;
        return args[i];
    }

    function optimizeargs()
    {
        optimize_array(self.args);
    }
    function getargvalues(var e)
    {
        var argreg = [];
        for (var a in self.args)
            push(argreg, a.emit_get(e));
        return argreg;
    }
    function emitargs(var e)
    {
        e.print(join(', ', self.getargvalues(e)));
    }
}

//*********************************************
//            Modifiers
//*********************************************

class Modifier
{
    var name;
    var args;

    function getname() { return self.name; }
    function numargs()
    {
        var args = self.args;
        int nargs = args == null ? 0 : args.numargs();
        return nargs;
    }
    function getarg(int argnum)
    {
        var args = self.args;
        if (argnum >= args.numargs())
            InternalError('Wrong modifier arg number');
        return args.getarg(argnum);
    }
    function Modifier(string name, var args)
    {
        self.name = name;
        if (args != null)
            self.args = args;
    }
    function optimize()
    {
        if (self.args != null)
            self.args.optimizeargs();
        return self;
    }
}

function parseModifier(tk, owner)
{
    var t = tk.get();
    string name = t.getidentifier();
    t = tk.get();
    var args;
    if (t.isop('('))
        args = new SimpleArgList(tk, owner, ')');
    else
        tk.unget(t);
    return new Modifier(name, args);
}


class ModifierList
{
    var list;

    function ModifierList(var tk, var owner)
    {
        self.list = parseList(tk, owner, parseModifier, ']');
    }
    function optimize()
    {
        optimize_array(self.list);
    }
    function getlist() { return self.list; }
    function pick(string name)
    {
        for (var mod in self.list) {
            if (mod.getname() == name)
                return mod;
        }
        return null;
    }
}

//*********************************************
//       Auxiliary classes and functions
//*********************************************

function getparrotkey(var path)
{
    string s = join("'; '", path);
    return "[ '" + s + "' ]";
}

function getparrotnamespacekey(var path)
{
    if (elements(path) == 0)
        return ".namespace [ ]";
    else {
        string s = join("'; '", path);
        return ".namespace [ '" + s + "' ]";
    }
}

function parseUsing(t, tk, owner)
{
    var taux = tk.get();
    switch {
      case taux.iskeyword('extern'):
        return new ExternStatement(t, tk, owner);
      case taux.iskeyword('static'):
        return new StaticStatement(t, tk, owner);
      case taux.iskeyword('namespace'):
        return new UsingNamespaceStatement(taux, tk, owner);
      default:
        tk.unget(taux);
        return new UsingStatement(t, tk, owner);
    }
}

function parseSig(start, tk, owner)
{
    var params = new SigParameterList(tk, owner);
    var t = tk.get();
    if (! t.isop('='))
        Expected("'='", t);
    var expr = parseExpr(tk, owner);
    return new MultiAssignStatement(start, owner, params, expr);
}

function parseStatement(tk, owner)
{
    var t = tk.get();
    if (t.isop(';'))
        return new EmptyStatement;
    if (t.isop('{'))
        return new CompoundStatement(t, tk, owner);
    if (t.isop('${'))
        return new PiropStatement(t, tk, owner);
    if (t.isop(':')) {
        var open = tk.get();
        if (! open.isop('('))
            Unexpected("':'", t);
        return parseSig(t, tk, owner);
    }

    switch (t.checkkeyword()) {
      case 'using':
        return parseUsing(t, tk, owner);
      case 'const':
        return parseConst(t, tk, owner);
        break;
      case 'volatile':
        return parseVolatile(t, tk, owner);
        break;
      case 'var':
        return parseVar(t, tk, owner);
      case 'string':
        return parseString(t, tk, owner);
      case 'int':
        return parseInt(t, tk, owner);
      case 'float':
        return parseFloat(t, tk, owner);
      case 'return':
        return new ReturnStatement(t, tk, owner);
      case 'yield':
        return new YieldStatement(t, tk, owner);
      case 'goto':
        return new GotoStatement(t, tk, owner);
      case 'if':
        return new IfStatement(t, tk, owner);
      case 'while':
        return new WhileStatement(t, tk, owner);
      case 'do':
        return new DoStatement(t, tk, owner);
      case 'continue':
        return new ContinueStatement(t, tk, owner);
      case 'break':
        return new BreakStatement(t, tk, owner);
      case 'switch':
        return parseSwitch(t, tk, owner);
      case 'for':
        return parseFor(t, tk, owner);
      case 'throw':
        return new ThrowStatement(t, tk, owner);
      case 'try':
        return new TryStatement(t, tk, owner);
      default:
        if (t.isidentifier()) {
            var t2 = tk.get();
            if (t2.isop(':'))
                return new LabelStatement(t, owner);
            tk.unget(t2);
        }
        tk.unget(t);
        return new ExprStatement(t, tk, owner);
    }
    InternalError('parseStatement failure', t);
}

//*********************************************
//            Statement
//*********************************************

class Statement : CommonBase
{
    function Statement(start, owner)
    {
        self.initbase(start, owner);
    }
    function isempty() { return false; }
    function createreg(string type)
    {
        return self.owner.createreg(type);
    }
    function tempreg(string type)
    {
        return self.owner.tempreg(type);
    }
    function freetemps()
    {
        self.owner.freetemps();
    }
    function genlabel()
    {
        return self.owner.genlabel();
    }
    function getlabel(name)
    {
        return self.owner.getlabel(name);
    }
    function createlabel(name)
    {
        return self.owner.createlabel(name);
    }
    function createconst(name, string type, int flags [optional])
    {
        return self.owner.createconst(name, type, flags);
    }
    function createvar(name, string type, int flags[optional])
    {
        return self.owner.createvar(name, type, flags);
    }
    function createvarused(name, data)
    {
        return self.owner.createvarused(name, data);
    }
    function createvarnamed(name, string type, string pirname)
    {
        return self.owner.createvarnamed(name, type, pirname);
    }
    function getvar(name)
    {
        return self.owner.getvar(name);
    }
    function checkclass(string name)
    {
        return self.owner.checkclass(name);
    }
    function usenamespace(ns)
    {
        self.owner.usenamespace(ns);
    }

    function getouter()
    {
        // Returns the nearest outer scope. In this base case,
        // just propagate it. Deriveds that are appropiate
        // scopes will override.
        return self.owner.getouter();
    }
    function getcontinuelabel(pos)
    {
        return self.owner.getcontinuelabel(pos);
    }
    function getbreaklabel(pos)
    {
        return self.owner.getbreaklabel(pos);
    }
    function optimize()
    {
        InternalError('**checking**', self.start);
        // Return unchanged by default
        return self;
    }
}

class EmptyStatement : Statement
{
    function isempty() { return true; }
    function annotate(e)
    {
        InternalError('Attempt to annotate empty statement');
    }
    function optimize() { return self; }
    function emit(e)
    {
        // Do nothing
    }
}

class MultiStatementBase
{
    var statements;

    function optimize()
    {
        var statements = self.statements;
        int n = elements(statements);
        int empty = true;
        for (int i = 0; i < n; ++i) {
            var st = statements[i].optimize();
            if (empty && ! st.isempty())
                empty = false;
            statements[i] = st;
        }
        if (empty)
            return new EmptyStatement;
        else
            return self;
    }
}

class MultiStatement : MultiStatementBase
{
    function MultiStatement(var st1, var st2)
    {
        var statements = [st1, st2];
        self.statements = statements;
    }
    function isempty() { return false; }
    function push(var statement)
    {
        push(self.statements, statement);
        return self;
    }
    function emit(e)
    {
        emit_array(e, self.statements);
    }
}

function addtomulti(var multi, var newst)
{
    if (multi == null)
        return newst;
    else if (multi instanceof MultiStatement)
        return multi.push(newst);
    else
        return new MultiStatement(multi, newst);
}

//*********************************************
//           PiropStatement
//*********************************************

function parsePiropArg(tk, owner)
{
    var arg;
    var t = tk.get();
    if (t.isop(':')) {
        t = tk.get();
        string label = t.getidentifier();
        arg = new Reflabel(owner, label);
    }
    else {
        tk.unget(t);
        arg = parseExpr(tk, owner);
    }
    return arg;
}

class PiropStatement : Statement
{
    var opname;
    var args;

    function PiropStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        var t = tk.get();
        int dotted = t.isop('.');
        if (dotted)
            t = tk.get();
        string opname = t.getidentifier();
        self.opname = (dotted ? '.' : '') + opname;
        t = tk.get();
        if (! t.isop('}')) {
            tk.unget(t);
            self.args = parseList(tk, owner, parsePiropArg, '}');
        }
        ExpectOp(';', tk);
    }
    function optimize()
    {
        optimize_array(self.args);
        return self;
    }
    function emit(e)
    {
        string opname = self.opname;
        self.annotate(e);
        e.comment('pirop ' + opname);
        var args = self.args;
        e.print(INDENT);
        if (args == null)
            e.say(opname);
        else {
            var argreg = [];
            for (var a in  args)
                push(argreg, a.emit_get(e));
            e.say(opname, ' ', join(', ', argreg));
        }
    }
}

//*********************************************
//            ExternStatement
//*********************************************

class ExternStatement : Statement
{
    var path;
    function ExternStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        var path = parseDotted(tk);
        if (elements(path) == 0)
            ExpectedIdentifier(tk.get());
        ExpectOp(';', tk);
        self.path = toIdentifierList(path);
        return self;
    }
    function optimize() { return self; }
    function emit(e)
    {
        self.annotate(e);
        e.say(INDENT, "load_bytecode '", join('/', self.path), ".pbc'");
    }
}

//*********************************************
//            StaticStatement
//*********************************************

class StaticStatement : Statement
{
    var names;
    function StaticStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        var names = parseList(tk, null, parseIdentifier, ';');
        for (var name in names) {
            string id = self.generatesubid();
            self.createvarnamed(name, REGvar, id);
        }
        self.names = names;
    }
    function optimize()
    {
        return self;
    }
    function emit(e)
    {
        self.annotate(e);
        for (var name in self.names) {
            var v = self.getvar(name);
            e.say(".const 'Sub' ", v.getreg(), " = '", name, "'");
        }
    }
}

//*********************************************
//            UsingStatement
//*********************************************

class UsingStatement : Statement
{
    var path;
    var subid;

    function UsingStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        var path = parseDotted(tk);
        if (elements(path) == 0)
            ExpectedIdentifier(tk.get());
        ExpectOp(';', tk);
        self.path = path;
    }
    function optimize()
    {
        var path = self.path;
        var name = path[-1];

        var symbol = self.findsymbol(path);
        switch {
          case symbol == null:
            if (elements(path) > 0) {
                var p = clone(path);
                p.pop();
                var ns = self.findns(p);
                if (ns != null) {
                    symbol = ns.getvar(name);
                    if (symbol != null) {
                        self.createvarused(name, symbol);
                        return new EmptyStatement;
                    }
                }
            }
            break;
          case symbol instanceof FunctionStatement:
            string subid = symbol.makesubid();
            self.createvarnamed(name, REGvar, subid);
            self.subid = subid;
            self.usesubid(subid);
            return self;
        }
        self.createvar(name, REGvar);
        return self;
    }
    function emit(e)
    {
        var path = self.path;
        string name = path[-1];
        var vdata = self.getvar(name);
        if (self.subid == null) {
            self.annotate(e);
            string key;
            if (elements(path) > 1) {
                path.pop();
                key = getparrotkey(path);
            }
            e.emitget_hll_global(vdata.getreg(), name, key);
        }
    }
}

//*********************************************
//            UsingNamespaceStatement
//*********************************************

class UsingNamespaceStatement : Statement
{
    function UsingNamespaceStatement(start, tk, owner)
    {
        self.Statement(tk, owner);
        var nskey = parseDotted(tk);
        int nlems = elements(nskey);
        if (nlems < 1)
            Expected('namespace identifier', start);
        var nssym = owner.findns(toIdentifierList(nskey));

        if (nssym == null)
            SyntaxError('unknow namespace', start);
        owner.usenamespace(nssym);

        ExpectOp(';', tk);
    }
    function optimize()
    {
        return self;
    }
    function emit(e)
    {
    }
}

//*********************************************
//            ExprStatement
//*********************************************

class ExprStatement : Statement
{
    var expr;
    function ExprStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        self.expr = parseExpr(tk, self);
        ExpectOp(';', tk);
    }
    function optimize()
    {
        self.expr = self.expr.optimize();
        return self;
    }
    function emit(e)
    {
        self.expr.emit(e, '');
    }
}

//*********************************************
//            VarContainer
//*********************************************

class VarData
{
    var type;
    var reg;
    var scope;
    var flags;
    var lexname;

    function VarData(type, reg, scope, int flags)
    {
        self.type = type;
        self.reg = reg;
        self.scope = scope;
        self.flags = flags;
    }
    function setlex(string name)
    {
        self.lexname = name;
    }
    function gettype() { return self.type; }
    function getreg() { return self.reg; }
    function getscope() { return self.scope; }
    function getvalue() { return self.value; }
    function isconst() { return false; }
    function getlex() { return self.lexname; }
    function getflags() { return self.flags; }
}

class ConstantInternalFail
{
    var name;
    function ConstantInternalFail(var name)
    {
        self.name = name;
    }
    function get_string[vtable]()
    {
        InternalError('Attempt to use unexpanded constant!!!', self.name);
    }
}

class VarData_const : VarData
{
    var value;

    function VarData_const(type, name, scope, flags)
    {
        self.VarData(type, new ConstantInternalFail(name), scope, flags);
    }
    function isconst() { return true; }
    function setvalue(value)
    {
        if (self.value != null)
            InternalError('Attempt change value of constant!!!');
        self.value = value;
    }
}


class VarContainer
{
    var locals;
    var usednamespaces;

    function init [vtable] ()
    {
        self.locals = {};
    }
    function createvar(var name, string type, int flags[optional])
    {
        var locals = self.locals;
        string sname = name;
        var exist = locals[sname];
        if (exist != null)
            SyntaxError("Redeclared '" + sname + "'", name);
        string reg = self.createreg(type);
        var data = new VarData(type, reg, self, flags);
        locals[sname] = data;
        return data;
    }
    function createvarused(name, data)
    {
        var locals = self.locals;
        string sname = name;
        var exist = locals[sname];
        if (exist != null)
            SyntaxError("Redeclared '" + sname + "'", name);
        locals[sname] = data;
    }
    function createvarnamed(var name, string type, string pirname)
    {
        var locals = self.locals;
        string sname = name;
        var exist = locals[sname];
        if (exist != null)
            SyntaxError("Redeclared '" + sname + "'", name);
        locals[sname] = new VarData(type, pirname, self, 0);
    }
    function createconst(var name, string type, int flags[optional])
    {
        var locals = self.locals;
        string sname = name;
        var exist = locals[sname];
        if (exist != null)
            SyntaxError("Redeclared '" + sname + "'", name);
        var data = new VarData_const(type, name, self, flags);
        locals[sname] = data;
        return data;
    }
    function getlocalvar(var name)
    {
        var locals = self.locals;
        return locals[string(name)];
    }
    function getusedvar(var name)
    {
        var sym;
        for (var ns in self.usednamespaces) {
            if ((sym = ns.getlocalvar(name)) != null)
                return sym;
        }
        return null;
    }
    function getvar(var name)
    {
        var sym;
        if ((sym = self.getlocalvar(name)) != null)
            return sym;
        if ((sym = self.getusedvar(name)) != null)
            return sym;
        var owner = self.owner;
        if (owner != null)
            return owner.getvar(name);
        return null;
    }
    function makelexical(vardesc)
    {
        var lexowner = self.getouter();
        string lexname = lexowner.createlex(vardesc);
        return lexname;
    }
    function makelexicalself()
    {
        var lexowner = self;
        const string lexname = '__WLEX_self';
        self.setlex(lexname, SELF);
        return lexname;
    }
}

//*********************************************
//            BlockStatement
//*********************************************

// A BlockStatement is a Statement that can have local variables.

class BlockStatement : VarContainer, Statement
{
}

//*********************************************
//            Expr
//*********************************************

class Expr : CommonBase
{
    function Expr(owner, start)
    {
        self.initbase(start, owner);
    }
    function issimple() { return false; }
    function isliteral() { return false; }
    function isintegerliteral() { return false; }
    function isfloatliteral() { return false; }
    function isstringliteral() { return false; }
    function isidentifier() { return false; }
    function isnull() { return false; }
    function hascompilevalue() { return false; }
    function isnegable() { return false; }
    function tempreg(type)
    {
        return self.owner.tempreg(type);
    }
    function optimize()
    {
        // By default return same expression unchanged
        return self;
    }
    function cantailcall() { return false; }
    function emit_get(e)
    {
        string type = self.checkresult();
        string reg = type == REGnone ? '' : self.tempreg(type);
        self.emit(e, reg);
        return reg;
    }
    function emit_get_nonull(e)
    {
        if (self.isnull())
            SyntaxError("Invalid 'null' usage", self);
        return self.emit_get(e);
    }
    function emit_getint(e)
    {
        string reg;
        if (self.checkresult() == REGint)
            reg = self.emit_get(e);
        else {
            reg = self.tempreg(REGint);
            self.emit(e, reg);
        }
        return reg;
    }
    function emit_assign_get(e, expr)
    {
        NoLeftSide(self);
    }
}

class SimpleExpr : Expr
{
    function issimple() { return true; }
}

//**********************************************************************

class FunctionExpr : Expr
{
    var fn;
    function FunctionExpr(tk, owner, start)
    {
        self.Expr(owner, start);
        var t = tk.get();
        if (!t.isop('('))
            Expected('anonymous function', t);
        self.fn = new LocalFunctionStatement(start, tk, owner);
    }
    function checkresult() { return REGvar; }
    function optimize()
    {
        self.fn = self.fn.optimize();
        self.usesubid(self.fn.getsubid());
        return self;
    }
    function emit(e, result)
    {
        self.annotate(e);
        var fn = self.fn;
        if (result != '') {
            string subid = fn.getsubid();
            if (fn.needclosure())
                e.emitarg2('newclosure', result, subid);
            else
                e.emitset(result, subid);
        }
    }
}

//*********************************************

// Condition class, contains and works with expressions used in
// conditional operators and statements.

const int CONDisruntime = 0, CONDistrue = 1, CONDisfalse = 2;

class Condition
{
    var condexpr;
    function set(expr)
    {
        self.condexpr = expr;
        return self;
    }
    function optimize_condition()
    {
        self.condexpr = self.condexpr.optimize();
    }
    function optimize()
    {
        self.condexpr = self.condexpr.optimize();
        return self;
    }
    function getvalue()
    {
        var condexpr = self.condexpr;
        if (condexpr.isliteral()) {
            switch (condexpr.checkresult()) {
              case REGint:
               int n = condexpr.getIntegerValue();
                if (n == 0)
                    return CONDisfalse;
                else
                    return CONDistrue;
            }
        }
        return CONDisruntime;
    }
    function emit_if(e, string labeltrue, string labelfalse)
    {
        var condexpr = self.condexpr;

        if ((condexpr instanceof ComparatorBaseExpr) ||
                (condexpr instanceof NullCheckerExpr))
            condexpr.emit_if(e, labeltrue);
        else {
            string reg = condexpr.emit_get(e);
            switch (condexpr.checkresult()) {
              case REGstring:
              case REGvar:
                e.emitif_null(reg, labelfalse);
              case REGint:
              case REGfloat:
                e.emitif(reg, labeltrue);
                break;
              default:
                InternalError('Invalid if condition');
            }
        }
    }
    function emit_else(e, string labelfalse)
    {
        var condexpr = self.condexpr;

        if ((condexpr instanceof ComparatorBaseExpr) ||
                (condexpr instanceof NullCheckerExpr))
            condexpr.emit_else(e, labelfalse);
        else {
            string reg = condexpr.emit_get(e);
            switch (condexpr.checkresult()) {
              case REGstring:
              case REGvar:
                e.emitif_null(reg, labelfalse);
              case REGint:
              case REGfloat:
                e.emitunless(reg, labelfalse);
                break;
              default:
                InternalError('Invalid if condition');
            }
        }
    }
}

//*********************************************

class Literal : SimpleExpr
{
    function isliteral() { return true; }
    function hascompilevalue() { return true; }
}

//*********************************************

class StringLiteral : Literal
{
    var strval;
    function StringLiteral(owner, t)
    {
        self.Expr(owner, t);
        self.strval = t;
    }
    function isstringliteral() { return true; }
    function checkresult() { return REGstring; }
    function getPirString()
    {
        var strtok = self.strval;
        string str = strtok.getPirString();
        return str;
    }
    function get_value()
    {
        var strtok = self.strval;
        string str = strtok.str;
        if (strtok instanceof TokenQuoted) {
            var s = str;
            str = s.unescape('utf8');
        }
        return str;
    }
    function emit(e, result)
    {
        if (result != '')
            e.emitset(result, self.getPirString());
    }
    function emit_get(e)
    {
        return self.getPirString();
    }
}

//*********************************************

class IntegerLiteral : Literal
{
    var pos;
    var numval;
    function IntegerLiteral(owner, t, value)
    {
        self.Expr(owner, t);
        self.pos = t;
        int n = value;
        self.numval = n;
    }
    function isintegerliteral() { return true; }
    function checkresult() { return REGint; }
    function getIntegerValue()
    {
        return self.numval;
    }
    function getFloatValue()
    {
        float value = self.getIntegerValue();
        return value;
    }
    function emit(e, result)
    {
        if (result != '') {
            int value = self.getIntegerValue();
            if (value == 0)
                e.emitnull(result);
            else
                e.emitset(result, value);
        }
    }
    function emit_get(e)
    {
        return self.getIntegerValue();
    }
}

//*********************************************

class FloatLiteral : Literal
{
    var numval;
    function FloatLiteral(owner, t)
    {
        self.Expr(owner, t);
        self.numval = t;
    }
    function isfloatliteral() { return true; }
    function checkresult() { return REGfloat; }
    function getFloatValue()
    {
        float value = self.numval.getfloatvalue();
        return value;
    }
    function emit(e, result)
    {
        if (result != '') {
            string n = self.emit_get(e);
            e.emitset(result, n);
        }
    }
    function emit_get(e)
    {
        float value = self.getFloatValue();
        return floatAsString(value);
    }
}

//*********************************************

class IdentifierExpr : SimpleExpr
{
    var name;
    var subid;
    function isidentifier() { return true; }
    function IdentifierExpr(owner, t)
    {
        self.Expr(owner, t);
        self.name = t;
    }
    function isnull()
    {
        var name = self.name;
        if (self.owner.getvar(name) != null)
            return false;
        return name.iskeyword(NULL);
    }
    function checkresult()
    {
        var name = self.name;
        var desc = self.owner.getvar(name);
        if (desc != null)
            return desc.gettype();
        else {
            switch (name) {
              case SELF:
              case NULL:
                return REGvar;
              default:
                return '';
            }
        }
    }
    function getName()
    {
        string s = self.name;
        return s;
    }
    function checkIdentifier()
    {
        var name = self.name;
        if (name == null)
            InternalError('Bad thing');
        var desc = self.owner.getvar(name);
        string s;
        if (desc == null) {
            switch (name) {
              case SELF:
              case NULL:
                s = name; break;
              default:
                s = '';
            }
        }
        else
            s = desc.getreg();
        return s;
    }
    function getIdentifier()
    {
        var value = self.checkIdentifier();
        if (value == '')
            UndefinedVariable(self.name);
        return value;
    }
    function optimize()
    {
        var name = self.name;
        var desc = self.owner.getvar(name);
        if (desc != null) {
            if (desc.isconst())
                return desc.getvalue();
            int flags = desc.getflags();
            if (flags & VAR_is_volatile) {
                if (flags & VAR_is_lexical)
                    return new LexicalVolatileExpr(self, desc);
            }
            else {
                // const Sub previous definition may be in a code path
                // not taken. Better allow redundant definitions than
                // leave undefined depending on runtime conditions.
                // TODO: improve this.
                var reg = desc.getreg();
                if (reg != null && substr(reg, 0, 7) == 'WSubId_')
                    self.subid = string(reg);
            }
        }
        else {
            var sym = self.findsymbol([name]);
            if (sym != null && sym instanceof FunctionStatement) {
                string id = sym.makesubid();
                self.subid = id;
                self.usesubid(id);
                self.owner.createvarnamed(name, REGvar, id);
            }
        }
        return self;
    }
    function emit_getid(e)
    {
        string id;
        if (self.subid != null)
            id = self.subid;
        else {
            id = self.getIdentifier();
            var desc = self.owner.getvar(self.name);
            int flags = desc == null ? 0 : desc.getflags();
            if (flags & VAR_is_volatile) {
                if (flags & VAR_is_lexical) {
                    string lexname = desc.getlex();
                    if (lexname != null && lexname != '')
                        e.emitfind_lex(id, lexname);
                }
            }
        }
        return id;
    }
    function emit(e, result)
    {
        if (result != '') {
            self.annotate(e);
            string id = self.emit_getid(e);
            e.emitset(result, id);
        }
    }
    function emit_get(e)
    {
        self.annotate(e);
        return self.emit_getid(e);
    }
    function emit_assign_get(e, expr)
    {
        self.annotate(e);
        if (self.isnull())
            SyntaxError("Cannot assign to null", self);
        string typeleft = self.checkresult();
        string lreg = self.getIdentifier();
        if (expr.isnull()) {
            switch (typeleft) {
              case REGstring:
              case REGvar:
                e.emitnull(lreg);
                break;
              default:
                SyntaxError("Can't assign null to that type", self);
            }
        }
        else if (expr instanceof IndexExpr)
            expr.emit(e, lreg);
        else {
            string typeright = expr.checkresult();
            if (typeright == REGnone)
                SyntaxError("Can't assign from void expression", self);
            if (typeleft == typeright) {
                expr.emit(e, lreg);
            }
            else {
                string rreg = expr.emit_get(e);
                self.annotate(e);
                if (typeleft == REGvar && typeright != REGvar)
                    e.emitbox(lreg, rreg);
                else
                    e.emitset(lreg, rreg);
            }
        }
        return lreg;
    }
}

//*********************************************

class LexicalVolatileExpr : Expr
{
    var desc;
    function LexicalVolatileExpr(idexpr, desc)
    {
        self.Expr(idexpr.owner, idexpr.start);
        self.desc = desc;
    }
    function checkresult()
    {
        return self.desc.gettype();
    }
    function emit_get(e)
    {
        var desc = self.desc;
        string lexname = desc.getlex();
        string reg = self.owner.tempreg(desc.gettype());
        e.emitfind_lex(reg, lexname);
        return reg;
    }
    function emit(e, result)
    {
        if (result != '') {
            self.annotate(e);
            string reg = self.emit_get(e);
            e.emitset(result, reg);
        }
    }
    function emit_assign_get(e, expr)
    {
        var desc = self.desc;
        string typelex = desc.gettype();
        string lreg = self.owner.tempreg(desc.gettype());
        switch {
          case expr.isnull():
            e.emitnull(lreg);
            break;
          case expr instanceof IndexExpr:
            expr.emit(e, lreg);
            break;
          default:
            string typeright = expr.checkresult();
            if (typelex == typeright || typelex != REGvar)
                expr.emit(e, lreg);
            else {
                string rreg = expr.emit_get(e);
                self.annotate(e);
                e.emitbox(lreg, rreg);
            }
        }

        e.emitstore_lex(desc.getlex(), lreg);
    }
    function emit_store(e, reg)
    {
        e.emitstore_lex(self.desc.getlex(), reg);
    }
}

//*********************************************

class OpExpr : Expr
{
    function initop(owner, start)
    {
        self.Expr(owner, start);
    }
}

//*********************************************

class OpClassExpr : OpExpr
{
    var clspec;

    function OpClassExpr(tk, owner, start)
    {
        self.initop(owner, start);
        self.clspec = parseClassSpecifier(tk, owner);
    }
    function checkresult() { return REGvar; }
    function emit(e, result)
    {
        var clspec = self.clspec;
        // In void context use a temporary and get it anyway,
        // to avoid discarding side effects.
        if (result == '')
            result = self.owner.tempreg(REGvar);
        e.print(INDENT + 'get_class ', result, ', ');
        clspec.emit(e, self.owner);
        e.say();
    }
}

//*********************************************

class OpUnaryExpr : OpExpr
{
    var subexpr;
    function OpUnaryExpr(owner, start, subexpr)
    {
        self.initop(owner, start);
        self.subexpr = subexpr;
    }
    function optimizearg()
    {
        self.subexpr = self.subexpr.optimize();
    }
    function optimize()
    {
        self.optimizearg();
        return self;
    }
}

//*********************************************

class OpBinaryExpr : OpExpr
{
    var lexpr;
    var rexpr;
    function initbinary(owner, start, lexpr, rexpr)
    {
        self.initop(owner, start);
        self.lexpr = lexpr;
        self.rexpr = rexpr;
    }
    function set(owner, t, lexpr, rexpr)
    {
        self.initbinary(owner, t, lexpr, rexpr);
        return self;
    }
    function setfrom(from)
    {
        return self.set(from.owner, from.start, from.lexpr, from.rexpr);
    }
    function optimizearg()
    {
        self.lexpr = self.lexpr.optimize();
        self.rexpr = self.rexpr.optimize();
    }
    function optimize()
    {
        self.optimizearg();
        return self;
    }
    function emit_intleft(e)
    {
        return self.lexpr.emit_getint(e);
    }
    function emit_intright(e)
    {
        return self.rexpr.emit_getint(e);
    }
}

//*********************************************

class OpBinaryIntExpr : OpBinaryExpr
{
    function checkresult()
    {
        return REGint;
    }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        if (lexpr.isintegerliteral() && rexpr.isintegerliteral()) {
            int li = lexpr.getIntegerValue();
            int ri = rexpr.getIntegerValue();
            return integerValue(self.owner, self.start, self.do_op(li, ri));
        }
        return self;
    }
}

//*********************************************

class OpDelExBase : OpUnaryExpr
{
    function checkresult()
    {
        return REGint;
    }
}


class OpDeleteExpr : OpDelExBase
{
    function OpDeleteExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function emit(e, result)
    {
        var expr = self.subexpr;
        if (expr instanceof IndexExpr && expr.checkresult() != REGstring) {
            expr.emit_prep(e);
            self.annotate(e);
            e.print(INDENT + 'delete ');
            expr.emit_aux(e);
            e.say();
            if (result != '')
                e.emitset(result, '1');
        }
        else
            SyntaxError("delete with invalid operator", self);
    }
}

class OpExistsExpr : OpDelExBase
{
    function OpExistsExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function emit(e, result)
    {
        var expr = self.subexpr;
        string reg = result != '' ? result : self.tempreg(REGint);
        if (expr instanceof IndexExpr && expr.checkresult() != REGstring) {
            expr.emit_prep(e);
            self.annotate(e);
            e.print(INDENT + 'exists ', reg, ', ');
            expr.emit_aux(e);
            e.say();
        }
        else
            SyntaxError("exists with invalid operator", self);
    }
}

//*********************************************

class OpUnaryMinusExpr : OpUnaryExpr
{
    function OpUnaryMinusExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function checkresult()
    {
        return self.subexpr.checkresult();
    }
    function set(owner, t, subexpr)
    {
        self.OpUnaryExpr(owner, t, subexpr);
        return self;
    }
    function optimize()
    {
        var subexpr = self.subexpr;
        self.optimizearg();
        if (subexpr.isintegerliteral()) {
            int i = subexpr.getIntegerValue();
            return integerValue(self.owner, subexpr.start, -i);
        }
        if (__STAGE__ != '0') {
            if (subexpr.isfloatliteral()) {
                float n = subexpr.getFloatValue();
                return floatValue(self.owner, subexpr.start, -n);
            }
        }
        return self;
    }
    function emit(e, result)
    {
        string reg = self.subexpr.emit_get(e);
        self.annotate(e);
        e.emitarg2('neg', result, reg);
    }
}

//*********************************************

class OpNotExpr : OpUnaryExpr
{
    function OpNotExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function isnegable() { return true; }
    function checkresult()
    {
        return REGint;
    }
    function set(owner, t, subexpr)
    {
        self.OpUnaryExpr(owner, t, subexpr);
        return self;
    }
    function optimize()
    {
        self.optimizearg();
        var subexpr = self.subexpr;
        if (subexpr.isintegerliteral()) {
            int n = subexpr.getIntegerValue();
            return integerValue(self.owner, subexpr.start, ! n);
        }
        if (subexpr.isnegable())
            return subexpr.negated();
        return self;
    }
    function negated()
    {
        return self.subexpr;
    }
    function emit(e, result)
    {
        var subexpr = self.subexpr;
        string reg = subexpr.emit_get(e);
        self.annotate(e);
        switch (subexpr.checkresult()) {
          case REGint:
            e.emitarg2('not', result, reg);
            break;
          case REGvar:
            e.emitarg2('isfalse', result, reg);
            break;
          default:
            e.emitarg2('isfalse', result, reg);
        }
    }
}

//*********************************************

class OpIncDec : OpUnaryExpr
{
    function checkresult()
    {
        return self.subexpr.checkresult();
    }
    function iflexical(e, reg)
    {
        var expr = self.subexpr;
        if (expr instanceof LexicalVolatileExpr)
            expr.emit_store(e, reg);
    }
}

//*********************************************

class OpPreIncDec : OpIncDec
{
    function emit(e, result)
    {
        string reg = self.emit_get(e);
        if (result != '')
            e.emitset(result, reg);
    }
}

class OpPreIncExpr : OpPreIncDec
{
    function OpPreIncExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function emit_get(e)
    {
        string reg = self.subexpr.emit_get(e);
        self.annotate(e);
        e.emitinc(reg);
        self.iflexical(e, reg);
        return reg;
    }
}

class OpPreDecExpr : OpPreIncDec
{
    function OpPreDecExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function emit_get(e)
    {
        string reg = self.subexpr.emit_get(e);
        self.annotate(e);
        e.emitdec(reg);
        self.iflexical(e, reg);
        return reg;
    }
}

//*********************************************

class OpPostIncExpr : OpIncDec
{
    function OpPostIncExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function emit(e, result)
    {
        string reg = self.subexpr.emit_get(e);
        self.annotate(e);
        if (result != '')
            e.emitset(result, reg);
        e.emitinc(reg);
        self.iflexical(e, reg);
        return reg;
    }
}

class OpPostDecExpr : OpIncDec
{
    function OpPostDecExpr(owner, start, subexpr)
    {
        self.OpUnaryExpr(owner, start, subexpr);
    }
    function emit(e, result)
    {
        string reg = self.subexpr.emit_get(e);
        self.annotate(e);
        if (result != '')
            e.emitset(result, reg);
        e.emitdec(reg);
        self.iflexical(e, reg);
        return reg;
    }
}

//*********************************************

class OpBaseAssignExpr : Expr
{
    var lexpr;
    var rexpr;
    function set(owner, start, lexpr, rexpr)
    {
        self.Expr(owner, start);
        self.lexpr = lexpr;
        self.rexpr = rexpr;
        return self;
    }
    function checkresult()
    {
        return self.lexpr.checkresult();
    }
    function optimize_base()
    {
        self.lexpr = self.lexpr.optimize();
        self.rexpr = self.rexpr.optimize();
        return self;
    }
    function optimize()
    {
        return self.optimize_base();
    }
    function checkleft()
    {
        var lexpr = self.lexpr;
        if (lexpr.isnull() || lexpr.isliteral())
            NoLeftSide(lexpr);
    }
    function emit(e, result)
    {
        string reg = self.emit_get(e);
        if (result != '') {
            self.annotate(e);
            e.emitset(result, reg);
        }
    }
}

//*********************************************

class OpAssignExpr : OpBaseAssignExpr
{
    function emit_get(e)
    {
        self.annotate(e);
        var lexpr = self.lexpr;
        return lexpr.emit_assign_get(e, self.rexpr);
    }
}

//*********************************************

class OpAssignToExpr : OpBaseAssignExpr
{
    function emit(e, result)
    {
        self.annotate(e);
        string reg = self.emit_get(e);
        if (result != null && result != '')
            e.emitassign(result, reg);
    }
    function emit_get(e)
    {
        self.checkleft();
        var lexpr = self.lexpr;
        if (lexpr.checkresult() != REGvar)
            SyntaxError("Wrong dest type in =:", lexpr);
        string reg = lexpr.emit_get(e);
        string reg2 = self.rexpr.emit_get(e);
        self.annotate(e);
        e.emitassign(reg, reg2);
        return reg;
    }
}

//*********************************************

class OpAddToExpr : OpBaseAssignExpr
{
    function emit_get(e)
    {
        self.checkleft();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        string ltype = lexpr.checkresult();
        string rtype = rexpr.checkresult();
        string reg = lexpr.emit_get(e);
        if (ltype == REGstring && (rexpr instanceof ConcatString))
            rexpr.emit_concat_to(e, reg);
        else {
            string reg2 = rexpr.emit_get(e);
            string aux;
            self.annotate(e);
            switch (ltype) {
              case REGstring:
                if (rtype != REGstring) {
                    aux = self.tempreg(REGstring);
                    e.emitset(aux, reg2);
                    reg2 = aux;
                }
                e.emitconcat1(reg, reg2);
                break;
              case REGint:
              case REGfloat:
                if (ltype != rtype) {
                    aux = self.tempreg(ltype);
                    e.emitset(aux, reg2);
                    reg2 = aux;
                }
                e.emitaddto(reg, reg2);
                break;
              default:
                e.emitaddto(reg, reg2);
            }
        }
        return reg;
    }
}

//*********************************************

class OpSubToExpr : OpBaseAssignExpr
{
    function emit_get(e)
    {
        self.checkleft();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        string ltype = lexpr.checkresult();
        string rtype = rexpr.checkresult();
        string reg = lexpr.emit_get(e);
        string reg2 = rexpr.emit_get(e);
        string aux;
        self.annotate(e);
        switch (ltype) {
          case REGstring:
            SyntaxError("-= can't be applied to string", self);
          case REGint:
          case REGfloat:
            if (ltype != rtype) {
                aux = self.tempreg(ltype);
                e.emitset(aux, reg2);
                reg2 = aux;
            }
            e.emitsubto(reg, reg2);
            break;
          default:
            e.emitsubto(reg, reg2);
        }
        return reg;
    }
}

//*********************************************

class OpMulToExpr : OpBaseAssignExpr
{
    function emit_get(e)
    {
        self.checkleft();
        string ltype = self.lexpr.checkresult();
        string rtype = self.lexpr.checkresult();
        string lreg = self.lexpr.emit_get(e);
        string rreg;
        switch (ltype) {
          case REGstring:
            if (rtype == REGint)
                rreg = self.rexpr.emit_get(e);
            else {
                rreg = self.tempreg(REGint);
                self.rexpr.emit(e, rreg);
            }
            self.annotate(e);
            e.emitrepeat(lreg, lreg, rreg);
            break;
          default:
            rreg = self.rexpr.emit_get(e);
            self.annotate(e);
            e.emitarg2('mul', lreg, rreg);
        }
        return lreg;
    }
}

//*********************************************

class OpDivToExpr : OpBaseAssignExpr
{
    function emit_get(e)
    {
        self.checkleft();
        string type = self.lexpr.checkresult();
        string reg = self.lexpr.emit_get(e);
        string reg2 = self.rexpr.emit_get(e);
        self.annotate(e);
        e.emitarg2('div', reg, reg2);
        return reg;
    }
}

//*********************************************

class OpModToExpr : OpBaseAssignExpr
{
    function emit_get(e)
    {
        self.checkleft();
        string type = self.lexpr.checkresult();
        string reg = self.lexpr.emit_get(e);
        string reg2 = self.rexpr.emit_get(e);
        self.annotate(e);
        e.emitarg2('mod', reg, reg2);
        return reg;
    }
}

//*********************************************

class ComparatorBaseExpr : OpBinaryExpr
{
    function checkresult() { return REGint; }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        if (lexpr.isintegerliteral() && rexpr.isintegerliteral()) {
            int li = lexpr.getIntegerValue();
            int ri = rexpr.getIntegerValue();
            return integerValue(self.owner, self.start, self.int_op(li, ri));
        }
        return self;
    }
    function emit_comparator(e, result, int doifelse[optional])
    {
        string rl = self.lexpr.checkresult();
        string rr = self.rexpr.checkresult();
        string regl = self.lexpr.emit_get(e);
        string regr = self.rexpr.emit_get(e);
        self.annotate(e);
        string aux;
        switch {
          case rl == REGint && rr == REGfloat:
            aux = self.tempreg(REGfloat);
            e.emitset(aux, regl);
            regl = aux;
            break;
          case rl == REGfloat && rr == REGint:
            aux = self.tempreg(REGfloat);
            e.emitset(aux, regr);
            regr = aux;
            break;
          case rr == REGint && rl == REGvar:
            aux = self.tempreg(REGint);
            e.emitset( aux, regl);
            regl = aux;
            break;
          case rr == REGvar && rl == REGint:
            aux = self.tempreg(REGint);
            e.emitset(aux, regr);
            regr = aux;
            break;
          case rr == REGstring && rl == REGvar:
            aux = self.tempreg(REGstring);
            e.emitset(aux, regl);
            regl = aux;
            break;
          case rr == REGvar && rl == REGstring:
            aux = self.tempreg(REGstring);
            e.emitset(aux, regr);
            regr = aux;
            break;
        }

        switch (doifelse) {
          case 0:
            self.emitop(e, result, regl, regr);
            break;
          case 1:
            self.emitop_if(e, result, regl, regr);
            break;
          case 2:
            self.emitop_else(e, result, regl, regr);
            break;
        }
    }
    function emit(e, result)
    {
        self.emit_comparator(e, result);
    }
    function emit_if(e, string labeltrue)
    {
        self.emit_comparator(e, labeltrue, 1);
    }
    function emit_else(e, string labelfalse)
    {
        self.emit_comparator(e, labelfalse, 2);
    }
}

//*********************************************

// Null checkers, created during optimize of Equal and NotEqual
// to simplify its emit functions.

class NullCheckerExpr : Expr
{
    var expr;
    var checknull;

    function NullCheckerExpr(base, expr, int checknull)
    {
        self.Expr(base.owner, base.start);
        self.expr = expr;
        self.checknull = checknull;
    }
    function checkresult() { return REGint; }
    function isnegable() { return true; }
    function negated()
    {
        int checkneg = ! self.checknull;
        self.checknull = checkneg;
        return self;
    }
    function emit(e, result)
    {
        string reg = self.expr.emit_get(e);
        self.annotate(e);
        e.emitarg2('isnull', result, reg);
        if (! self.checknull)
            e.emitarg1('not', result);
    }
    function emit_else(e, string labelelse)
    {
        string reg = self.expr.emit_get(e);
        self.annotate(e);
        e.say(INDENT, self.checknull ? 'unless' : 'if', '_null ', reg, ', ', labelelse);
    }
}

//*********************************************

class OpEqualExpr : ComparatorBaseExpr
{
    function isnegable() { return true; }
    function negated()
    {
        return (new OpNotEqualExpr).setfrom(self);
    }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        int lnull = lexpr.isnull();
        int rnull = rexpr.isnull();
        if (lnull) {
            if (rnull)
                return integerValue(self.owner, self.start, 1);
            else
                return new NullCheckerExpr(self, self.rexpr, true);
        }
        if (rnull)
            return new NullCheckerExpr(self, self.lexpr, true);
        if (lexpr.isliteral() && rexpr.isliteral()) {
            string ltype = lexpr.checkresult();
            string rtype = rexpr.checkresult();
            if (ltype == rtype) {
                switch (ltype) {
                  case REGint:
                    int li = lexpr.getIntegerValue();
                    int ri = rexpr.getIntegerValue();
                    return integerValue(self.owner, self.start, li == ri);
                  case REGstring:
                    string ls = (lexpr.strval).str;
                    string rs = (rexpr.strval).str;
                    return integerValue(self.owner, self.start, ls == rs);
                }
            }
        }
        return self;
    }
    function emitop(e, string result, string regl, string regr)
    {
        e.emitbinop('iseq', result, regl, regr);
    }
    function emit(e, result)
    {
        self.emit_comparator(e, result);
    }
    function emitop_if(e, string labeltrue, string regl, string regr)
    {
        e.emitcompare('eq', regl, regr, labeltrue);
    }
    function emitop_else(e, string labelelse, string regl, string regr)
    {
        e.emitcompare('ne', regl, regr, labelelse);
    }
}

//*********************************************

class OpNotEqualExpr : ComparatorBaseExpr
{
    function isnegable() { return true; }
    function negated()
    {
        return (new OpEqualExpr).setfrom(self);
    }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        int lnull = lexpr.isnull();
        int rnull = rexpr.isnull();
        if (lnull) {
            if (rnull)
                return integerValue(self.owner, self.start, 0);
            else
                return new NullCheckerExpr(self, self.rexpr, false);
        }
        if (rnull)
            return new NullCheckerExpr(self, self.lexpr, false);
        if (lexpr.isliteral() && rexpr.isliteral()) {
            string ltype = lexpr.checkresult();
            string rtype = rexpr.checkresult();
            if (ltype == rtype) {
                switch (ltype) {
                  case REGint:
                    int li = lexpr.getIntegerValue();
                    int ri = rexpr.getIntegerValue();
                    return integerValue(self.owner, self.start, li != ri);
                  case REGstring:
                    string ls = (lexpr.strval).str;
                    string rs = (rexpr.strval).str;
                    return integerValue(self.owner, self.start, ls != rs);
                }
            }
        }
        return self;
    }
    function emitop(e, string result, string regl, string regr)
    {
        e.emitbinop('isne', result, regl, regr);
    }
    function emit(e, result)
    {
        self.emit_comparator(e, result);
    }
    function emitop_if(e, string labeltrue, string regl, string regr)
    {
        e.emitcompare('ne', regl, regr, labeltrue);
    }
    function emitop_else(e, string labelelse, string regl, string regr)
    {
        e.emitcompare('eq', regl, regr, labelelse);
    }
}

//**********************************************************************

class OpSameExpr : ComparatorBaseExpr
{
    var positive;
    function OpSameExpr(int positiveform, owner, t, lexpr, rexpr)
    {
        self.initbinary(owner, t, lexpr, rexpr);
        self.positive = positiveform;
    }
    function isnegable() { return true; }
    function negated()
    {
        int positive = self.positive;
        return new OpSameExpr(! positive, self.owner, self.start, self.lexpr, self.rexpr);
    }
    function int_op(int left, int right)
    {
        return self.positive ? (left == right) : (left != right);
    }
    function emitop(e, string result, string regl, string regr)
    {
        int positive = self.positive;
        string op = positive ? 'issame' : 'isntsame';
        e.emitbinop(op, result, regl, regr);
    }
    function emit(e, result)
    {
        self.emit_comparator(e, result);
    }
    function emitop_if(e, string labeltrue, string regl, string regr)
    {
        int positive = self.positive;
        string op = positive ? 'eq_addr' : 'ne_addr';
        e.emitcompare(op, regl, regr, labeltrue);
    }
    function emitop_else(e, string labelelse, string regl, string regr)
    {
        int positive = self.positive;
        string op = positive ? 'ne_addr' : 'eq_addr';
        e.emitcompare(op, regl, regr, labelelse);
    }
}

//*********************************************

class OpLessExpr : ComparatorBaseExpr
{
    function isnegable() { return true; }
    function negated()
    {
        return (new OpGreaterEqualExpr).setfrom(self);
    }
    function int_op(int left, int right)
    {
        return left < right;
    }
    function emitop(e, string result, string regl, string regr)
    {
        e.emitbinop('islt', result, regl, regr);
    }
    function emitop_if(e, string labeltrue, string regl, string regr)
    {
        e.emitcompare('lt', regl, regr, labeltrue);
    }
    function emitop_else(e, string labelelse, string regl, string regr)
    {
        e.emitcompare('ge', regl, regr, labelelse);
    }
}

//*********************************************

class OpGreaterExpr : ComparatorBaseExpr
{
    function isnegable() { return true; }
    function negated()
    {
        return (new OpLessEqualExpr).setfrom(self);
    }
    function int_op(int left, int right)
    {
        return left > right;
    }
    function emitop(e, string result, string regl, string regr)
    {
        e.emitbinop('isgt', result, regl, regr);
    }
    function emitop_if(e, string labeltrue, string regl, string regr)
    {
        e.emitcompare('gt', regl, regr, labeltrue);
    }
    function emitop_else(e, string labelelse, string regl, string regr)
    {
        e.emitcompare('le', regl, regr, labelelse);
    }
}

//*********************************************

class OpLessEqualExpr : ComparatorBaseExpr
{
    function isnegable() { return true; }
    function negated()
    {
        return (new OpGreaterExpr).setfrom(self);
    }
    function int_op(int left, int right)
    {
        return left <= right;
    }
    function emitop(e, string result, string regl, string regr)
    {
        e.emitbinop('isle', result, regl, regr);
    }
    function emitop_if(e, string labeltrue, string regl, string regr)
    {
        e.emitcompare('le', regl, regr, labeltrue);
    }
    function emitop_else(e, string labelelse, string regl, string regr)
    {
        e.emitcompare('gt', regl, regr, labelelse);
    }
}

//*********************************************

class OpGreaterEqualExpr : ComparatorBaseExpr
{
    function isnegable() { return true; }
    function negated()
    {
        return (new OpLessExpr).setfrom(self);
    }
    function int_op(int left, int right)
    {
        return left >= right;
    }
    function emitop(e, string result, string regl, string regr)
    {
        e.emitbinop('isge', result, regl, regr);
    }
    function emitop_if(e, string labeltrue, string regl, string regr)
    {
        e.emitcompare('ge', regl, regr, labeltrue);
    }
    function emitop_else(e, string labelelse, string regl, string regr)
    {
        e.emitcompare('lt', regl, regr, labelelse);
    }
}

//*********************************************

class OpBaseBoolExpr : OpBinaryExpr
{
    function checkresult()
    {
        return REGint;
    }
}

//*********************************************

class OpBoolAndExpr : OpBaseBoolExpr
{
    function OpBoolAndExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function optimize()
    {
        self.optimizearg();
        if (self.lexpr.isintegerliteral() ) {
            int ln = self.lexpr.getIntegerValue();
            if (ln != 0)
               return self.rexpr;
            else
                return integerValue(self.owner, self.start, ln);
        }
        return self;
    }
    function emit(e, result)
    {
        string res = result != null ? result : self.tempreg(REGint);
        if (self.lexpr.issimple() && self.rexpr.issimple()) {
            string lreg = self.emit_intleft(e);
            string rreg = self.emit_intright(e);
            e.emitbinop('and', res, lreg, rreg);
        }
        else {
            string l = self.owner.genlabel();
            self.lexpr.emit(e, res);
            e.emitunless(res, l);
            self.rexpr.emit(e, res);
            e.emitlabel(l);
        }
    }
}

//*********************************************

class OpBoolOrExpr : OpBaseBoolExpr
{
    function OpBoolOrExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function optimize()
    {
        self.optimizearg();
        if (self.lexpr.isintegerliteral() ) {
            int ln = self.lexpr.getIntegerValue();
            if (ln == 0)
               return self.rexpr;
            else
                return integerValue(self.owner, self.start, ln);
        }
        return self;
    }
    function emit(e, result)
    {
        string res;
        if (result != null)
            res = result;
        else
            res = self.tempreg(REGint);
        if (self.lexpr.issimple() && self.rexpr.issimple()) {
            string lreg = self.emit_intleft(e);
            string rreg = self.emit_intright(e);
            e.emitbinop('or', res, lreg, rreg);
        }
        else {
            string l = self.owner.genlabel();
            self.lexpr.emit(e, res);
            e.emitif(res, l);
            self.rexpr.emit(e, res);
            e.emitlabel(l);
        }
    }
}

//*********************************************

class OpBaseBinExpr : OpBinaryIntExpr
{
}

//*********************************************

class OpBinAndExpr : OpBaseBinExpr
{
    function OpBinAndExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function emit(e, result)
    {
        string res = result != null ? result : self.tempreg(REGint);
        string lreg = self.emit_intleft(e);
        string rreg = self.emit_intright(e);
        self.annotate(e);
        e.emitbinop('band', res, lreg, rreg);
    }
    function do_op(int left, int right)
    {
        return left & right;
    }
}

//*********************************************

class OpBinOrExpr : OpBaseBinExpr
{
    function OpBinOrExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function emit(e, result)
    {
        string res = result != null ? result : self.tempreg(REGint);
        string lreg = self.emit_intleft(e);
        string rreg = self.emit_intright(e);
        self.annotate(e);
        e.emitbinop('bor', res, lreg, rreg);
    }
    function do_op(int left, int right)
    {
        return left | right;
    }
}

//*********************************************

class OpBinXorExpr : OpBaseBinExpr
{
    function OpBinXorExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function emit(e, result)
    {
        string res = result != null ? result : self.tempreg(REGint);
        string lreg = self.emit_intleft(e);
        string rreg = self.emit_intright(e);
        self.annotate(e);
        e.emitbinop('bxor', res, lreg, rreg);
    }
    function do_op(int left, int right)
    {
        return left ^ right;
    }
}

//*********************************************

class ConcatString : Expr
{
    var values;
    function ConcatString(owner, start, lexpr, rexpr)
    {
        self.Expr(owner, start);
        switch {
          case lexpr instanceof ConcatString:
            self.values = lexpr.values;
            if (rexpr instanceof ConcatString)
                self.values.append(rexpr.values);
            else
                push(self.values, rexpr);
            break;
          case rexpr instanceof ConcatString:
            self.values = rexpr.values;
            self.values.unshift(lexpr);
            break;
          default:
            self.values = [lexpr, rexpr];
        }
    }
    function checkresult() { return REGstring; }
    function getregs(e)
    {
        var values = self.values;
        int nvalues = elements(values);
        string regvalues[nvalues];
        int i;
        for (i = 0; i < nvalues; ++i)
            regvalues[i] = string(values[i].emit_get(e));
        return regvalues;
    }
    function emit(e, result)
    {
        var regvalues = self.getregs(e);
        int nvalues = elements(regvalues);
        string auxreg = result != '' ? result : '$S0';
        self.annotate(e);
        e.emitconcat(auxreg, regvalues[0], regvalues[1]);
        for (int i = 2; i < nvalues; ++i)
            e.emitconcat1(auxreg, regvalues[i]);
    }
    function emit_get(e)
    {
        var regvalues = self.getregs(e);
        int nvalues = elements(regvalues);
        string auxreg = self.tempreg(REGstring);
        self.annotate(e);
        e.emitconcat(auxreg, regvalues[0], regvalues[1]);
        for (int i = 2; i < nvalues; ++i)
            e.emitconcat1(auxreg, regvalues[i]);
        return auxreg;
    }
    function emit_concat_to(e, result)
    {
        var regvalues = self.getregs(e);
        int nvalues = elements(regvalues);
        self.annotate(e);
        for (int i = 0; i < nvalues; ++i)
            e.emitconcat1(result, regvalues[i]);
    }
}

//*********************************************

class RepeatString : OpBinaryExpr
{
    function RepeatString(from)
    {
        self.set(from.owner, from.start, from.lexpr, from.rexpr);
    }
    function checkresult() { return REGstring; }
    function emit(e, result)
    {
        var rexpr = self.rexpr;
        string lreg = self.lexpr.emit_get(e);
        string rreg = rexpr.emit_get(e);
        string rval;
        switch (rexpr.checkresult()) {
          case REGint:
            rval = rreg;
            break;
          default:
            rval = self.tempreg(REGint);
            e.emitset(rval, rreg);
        }
        self.annotate(e);
        e.emitrepeat(result, lreg, rval);
    }
}

//*********************************************

class OpAddExpr : OpBinaryExpr
{
    function OpAddExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        string ltype = lexpr.checkresult();
        string rtype = rexpr.checkresult();
        if (lexpr.isliteral() && rexpr.isliteral()) {
            if (ltype == REGstring && rtype == REGstring) {
                // Compile time add two literal strings:
                // If both are single quoted, result is single quoted.
                // If one is double quoted, result is double quoted,
                // adding escape char '\' when needed.
                var etok = lexpr.strval;
                var rtok = rexpr.strval;
                var t = etok.issinglequoted() && rtok.issinglequoted()
                    ?
                    new TokenSingleQuoted(etok.file, etok.line,
                            string(etok.str) + string(rtok.str))
                    :
                    new TokenQuoted(etok.file, etok.line,
                            string(etok.getasquoted()) + string(rtok.getasquoted()));
                return new StringLiteral(self.owner, t);
            }
            if (ltype == REGint && rtype == REGint) {
                int ln = lexpr.getIntegerValue();
                int rn = rexpr.getIntegerValue();
                return integerValue(self.owner, self.start, ln + rn);
            }
            if (__STAGE__ != '0') {
                if (floatresult(ltype, rtype)) {
                    float lf = lexpr.getFloatValue();
                    float rf = rexpr.getFloatValue();
                    return floatValue(self.owner, self.start, lf + rf);
                }
            }
        }
        if (ltype == REGstring && rtype == REGstring) {
            return new ConcatString(self.owner, self.start, lexpr, rexpr);
        }
        return self;
    }
    function checkresult()
    {
        string rl = self.lexpr.checkresult();
        string rr = self.rexpr.checkresult();
        if (rl == rr)
            return rl;
        if (rl == REGint && rr == REGstring)
            return REGstring;
        if (rl == REGstring && rr == REGint)
            return REGstring;
        if (floatresult(rl, rr))
            return REGfloat;
        return REGint;
    }
    function emit(e, result)
    {
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        string restype = self.checkresult();
        string ltype = lexpr.checkresult();
        string rtype = rexpr.checkresult();

        string rleft = lexpr.emit_get(e);
        string rright = rexpr.emit_get(e);
        if (restype == REGstring) {
            if (ltype != REGstring || rtype != REGstring) {
                string aux = self.tempreg(REGstring);
                if (ltype != REGstring) {
                    e.emitset(aux, rleft);
                    rleft = aux;
                }
                else {
                    e.emitset(aux, rright);
                    rright = aux;
                }
            }
            e.emitconcat(result, rleft, rright);
        }
        else {
            if (restype == REGint && (ltype != REGint || rtype != REGint)) {
                string l;
                if (ltype == REGint) l = rleft;
                else {
                    l = self.tempreg(REGint);
                    e.emitset(l, rleft);
                }
                string r;
                if (rtype == REGint) r = rright;
                else {
                    r = self.tempreg(REGint);
                    e.emitset(r, rright);
                }
                e.emitadd(result, l, r);
            }
            else
                e.emitadd(result, rleft, rright);
        }
    }
}

//*********************************************

class OpSubExpr : OpBinaryExpr
{
    function OpSubExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        if (lexpr.isliteral() && rexpr.isliteral()) {
            string ltype = lexpr.checkresult();
            string rtype = rexpr.checkresult();
            if (ltype == REGint && rtype == REGint) {
                int ln = lexpr.getIntegerValue();
                int rn = rexpr.getIntegerValue();
                return integerValue(self.owner, self.start, ln - rn);
            }
        }
        return self;
    }
    function checkresult()
    {
        string rl = self.lexpr.checkresult();
        string rr = self.rexpr.checkresult();
        if (rl == rr)
            return rl;
        if (rl == REGint && rr == REGfloat)
            return REGfloat;
        if (rl == REGfloat && rr == REGint)
            return REGfloat;
        return REGint;
    }
    function emit(e, result)
    {
        string lreg = self.lexpr.emit_get(e);
        string rreg = self.rexpr.emit_get(e);
        e.emitsub(result, lreg, rreg);
    }
}

//*********************************************

class OpMulExpr : OpBinaryExpr
{
    function OpMulExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        string ltype = lexpr.checkresult();
        string rtype = rexpr.checkresult();
        if (lexpr.isliteral() && rexpr.isliteral()) {
            if (ltype == REGint && rtype == REGint) {
                int ln = lexpr.getIntegerValue();
                int rn = rexpr.getIntegerValue();
                return integerValue(self.owner, self.start, ln * rn);
            }
            if (__STAGE__ != '0') {
                if (floatresult(ltype, rtype)) {
                    float lf = lexpr.getFloatValue();
                    float rf = rexpr.getFloatValue();
                    return floatValue(self.owner, self.start, lf * rf);
                }
            }
        }
        if (ltype == REGstring)
            return new RepeatString(self);
        return self;
    }
    function checkresult()
    {
        var lexpr = self.lexpr;
        string rl = self.lexpr.checkresult();
        string rr = self.rexpr.checkresult();
        if (rl == rr)
            return rl;
        if (rl == REGstring)
            return REGstring;
        else
            return REGfloat;
    }
    function emit(e, result)
    {
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        string ltype = lexpr.checkresult();
        string rtype = rexpr.checkresult();
        string lreg, rreg;
        if (ltype == rtype && (ltype == REGint || ltype == REGfloat || ltype == REGvar)) {
            lreg = lexpr.emit_get(e);
            rreg = rexpr.emit_get(e);
            e.emitmul(result, lreg, rreg);
            return;
        }

        // Quick fix for some float mul
        // TODO: rewrite this mess
        if (ltype == REGfloat) {
            lreg = lexpr.emit_get(e);
            rreg = rexpr.emit_get(e);
            string rval;
            switch (rtype) {
              case REGint:
                rval = self.tempreg(REGfloat);
                e.emitset(rval, rreg);
                rval = rreg;
                break;
              case REGfloat:
                rval = rreg;
                break;
              default:
                rval = self.tempreg(REGfloat);
                e.emitset(rval, rreg);
            }
            if (result != '') {
                self.annotate(e);
                e.emitmul(result, lreg, rval);
            }
            return;
        }

        int nleft, nright;
        if ((!lexpr.issimple()) || lexpr.isidentifier()) {
            lreg = self.tempreg(self.checkresult());
            lexpr.emit(e, lreg);
        }
        else {
            nleft = lexpr.getIntegerValue();
            lreg = nleft;
        }
        if ((!rexpr.issimple()) || rexpr.isidentifier()) {
            rreg = self.tempreg(self.checkresult());
            rexpr.emit(e, rreg);
        }
        else {
            switch (rtype) {
              case REGstring:
                rreg = self.tempreg(self.checkresult());
                rexpr.emit(e, rreg);
                break;
              case REGfloat:
                rreg = rexpr.emit_get(e);
                break;
              case REGint:
              default:
                nright = rexpr.getIntegerValue();
                rreg = nright;
                break;
            }
        }
        self.annotate(e);
        if (result == '')
            result = self.tempreg(self.checkresult());
        e.emitmul(result, lreg, rreg);
    }
}

//*********************************************

class OpDivExpr : OpBinaryExpr
{
    function OpDivExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function optimize()
    {
        self.optimizearg();
        var lexpr = self.lexpr;
        var rexpr = self.rexpr;
        if (lexpr.isliteral() && rexpr.isliteral()) {
            string ltype = lexpr.checkresult();
            string rtype = rexpr.checkresult();
            var lval;
            var rval;
            if (ltype == REGint && rtype == REGint) {
                int ln = lexpr.getIntegerValue();
                int rn = rexpr.getIntegerValue();
                if (rn != 0)
                    return integerValue(self.owner, self.start, ln / rn);
            }
            if (__STAGE__ != '0') {
                if (floatresult(ltype, rtype)) {
                    float lf = lexpr.getFloatValue();
                    float rf = rexpr.getFloatValue();
                    if (rf != 0)
                        return floatValue(self.owner, self.start, lf / rf);
                }
            }
        }
        return self;
    }
    function checkresult()
    {
        return REGfloat;
    }
    function emit(e, result)
    {
        var lexpr = self.lexpr;
        var aux;
        var lreg = lexpr.emit_get(e);
        if (lexpr.checkresult() != REGfloat) {
            aux = self.tempreg(REGfloat);
            e.emitset(aux, lreg);
            lreg = aux;
        }
        var rexpr = self.rexpr;
        var rreg = rexpr.emit_get(e);
        if (rexpr.checkresult() != REGfloat) {
            aux = self.tempreg(REGfloat);
            e.emitset(aux, rreg);
            rreg = aux;
        }
        self.annotate(e);
        e.emitdiv(result, lreg, rreg);
    }
}

//*********************************************

class OpModExpr : OpBinaryIntExpr
{
    function OpModExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function emit(e, result)
    {
        string lreg = self.emit_intleft(e);
        string rreg = self.emit_intright(e);
        self.annotate(e);
        e.emitbinop('mod', result, lreg, rreg);
    }
    function do_op(int left, int right)
    {
        return left % right;
    }
}

//*********************************************

class OpCModExpr : OpBinaryExpr
{
    function OpCModExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function checkresult()
    {
        return REGint;
    }
    function emit(e, result)
    {
        string lreg = self.emit_intleft(e);
        string rreg = self.emit_intright(e);
        self.annotate(e);

        // WORKAROUND:
        // e.say('cmod ', result, ', ', lreg, ', ', rreg);
        // cmod is now a dynop. Silly workaround, use mod instead.
        e.emitbinop('mod', result, lreg, rreg);
    }
}

//*********************************************

class OpShiftleftExpr : OpBinaryIntExpr
{
    function OpShiftleftExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function emit(e, result)
    {
        string res = result != null ? result : self.tempreg(REGint);
        string lreg = self.emit_intleft(e);
        string rreg = self.emit_intright(e);
        self.annotate(e);
        e.emitbinop('shl', res, lreg, rreg);
    }
    function do_op(int left, int right)
    {
        return left << right;
    }
}

//*********************************************

class OpShiftrightExpr : OpBinaryIntExpr
{
    function OpShiftrightExpr(owner, start, lexpr, rexpr)
    {
        self.set(owner, start, lexpr, rexpr);
    }
    function emit(e, result)
    {
        string res = result != null ? result : self.tempreg(REGint);
        string lreg = self.emit_intleft(e);
        string rreg = self.emit_intright(e);
        self.annotate(e);
        e.emitbinop('shr', res, lreg, rreg);
    }
    function do_op(int left, int right)
    {
        return left >> right;
    }
}

//*********************************************

class ArgumentModifierList : ModifierList
{
    function ArgumentModifierList(tk, owner)
    {
        self.ModifierList(tk, owner);
    }
    function emitmodifiers(e)
    {
        int isflat = 0, isnamed = 0;
        string setname = '';
        for (var modif in self.getlist()) {
            switch (modif.getname()) {
              case 'flat':
                isflat = 1;
                break;
              case 'named':
                isnamed = 1;
                switch (modif.numargs()) {
                  case 0:
                    break;
                  case 1:
                    var argmod = modif.getarg(0);
                    if (! argmod.isstringliteral())
                        SyntaxError('Invalid modifier', self);
                    setname = argmod.getPirString();
                    break;
                  default:
                    SyntaxError('Invalid modifier', self);
                }
            }
        }
        switch {
          case isflat && isnamed:
            e.print(' :flat :named');
            break;
          case isflat:
            e.print(' :flat');
            break;
          case isnamed:
            e.print(' :named');
            if (setname != '')
                e.print("(", setname, ")");
            break;
        }
    }
}

class Argument
{
    var arg;
    var modifiers;
    function Argument(var arg, var modifiers)
    {
        self.arg = arg;
        self.modifiers = modifiers;
    }
    function optimize()
    {
        self.arg = self.arg.optimize();
        return self;
    }
    function hascompilevalue()
    {
        return self.arg.hascompilevalue();
    }
}

function parseArgument(tk, owner)
{
    var modifier = null;
    var expr = parseExpr(tk, owner);
    var t = tk.get();
    if (t.isop(':')) {
        t = tk.get();
        if (t.isop('[')) {
            modifier = new ArgumentModifierList(tk, owner);
        }
        else
            Expected('modifier list', t);
    }
    else
        tk.unget(t);
    return new Argument(expr, modifier);
}

class ArgumentList
{
    var owner;
    var start;
    var args;
    var argregs;

    function ArgumentList(owner, start, tk, string delimiter)
    {
        self.owner = owner;
        self.start = start;
        var t = tk.get();
        if (! t.isop(delimiter)) {
            tk.unget(t);
            self.args = parseList(tk, owner, parseArgument, delimiter);
        }
    }
    function numargs()
    {
        var args = self.args;
        return args == null ? 0 : elements(args);
    }
    function getrawargs()
    {
        return self.args;
    }
    function getarg(int i)
    {
        var args = self.args;
        return args[i];
    }
    function getfreearg(int i)
    {
        var args = self.args;
        return args[i].arg;
    }
    function optimize()
    {
        optimize_array(self.args);
        return self;
    }
    function getargvalues(var e)
    {
        var argregs = self.argregs;
        if (argregs == null) {
            string argregs[];
            string pnull = '';
            for (var argitem in self.args) {
                var arg = argitem.arg;
                string reg;
                if (arg.isnull()) {
                    if (pnull == '') {
                        pnull = self.owner.tempreg(REGvar);
                        e.emitnull(pnull);
                    }
                    reg = pnull;
                }
                else
                    reg = arg.emit_get(e);
                push(argregs, reg);
            }
            self.argregs = argregs;
        }
        return argregs;
    }
    function emitargs(var e)
    {
        var args = self.args;
        var argreg = self.getargvalues(e);

        string sep = '';
        int n = self.numargs();
        for (int i = 0; i < n; ++i) {
            e.print(sep, argreg[i]);
            var modifiers = args[i].modifiers;
            if (modifiers != null)
                modifiers.emitmodifiers(e);
            sep = ', ';
        }
    }
}

function arglist_hascompilevalue(var arglist)
{
    for (var arg in arglist)
        if (! arg.hascompilevalue())
            return false;
    return true;
}

//*********************************************

class CallPredefExpr : Expr
{
    var predef;
    var args;

    function CallPredefExpr(owner, start, predef, args)
    {
        self.Expr(owner, start);
        self.predef = predef;
        self.args = args;
    }
    function checkresult()
    {
        return self.predef.result();
    }
    function emit(e, result)
    {
        var predef = self.predef;
        var args = self.args;
        string argreg[];
        var arg;
        string pnull = '';
        switch (predef.params()) {
          case PREDEF_arglist:
            for (arg in args) {
                string reg = arg.arg.emit_get(e);
                // Special case
                if (reg == NULL) {
                    if (pnull == '') {
                        pnull = self.tempreg(REGvar);
                        e.emitnull(pnull);
                    }
                    reg = pnull;
                }
                push(argreg, reg);
            }
            break;
          case PREDEF_raw1:
            var rawargs = [];
            for (arg in args)
                push(rawargs, arg.arg);
            self.predef.expand(e, self, self.start, result, rawargs);
            return;
          default:
            int n = self.args;
            for (int i = 0; i < n; ++i) {
                arg = args[i].arg;
                string argtype = arg.checkresult();
                string paramtype = predef.paramtype(i);
                string argr;
                if (arg.isnull()) {
                    switch (paramtype) {
                      case REGint:
                      case REGfloat:
                      case REGstring:
                        argr = self.tempreg(paramtype);
                        e.emitnull(argr);
                        break;
                      default:
                        if (pnull == '') {
                            pnull = self.tempreg(REGvar);
                            e.emitnull(pnull);
                        }
                        argr = pnull;
                    }
                }
                else {
                    if (argtype == paramtype || paramtype == REGany ||
                            (paramtype == REGs_v &&
                             (argtype == REGstring || argtype == REGvar)))
                        argr = arg.emit_get(e);
                    else {
                        string aux;
                        if (paramtype == REGs_v)
                            paramtype = REGvar;
                        argr = self.tempreg(paramtype);
                        switch (paramtype) {
                          case REGvar:
                            switch (argtype) {
                              case REGint:
                              case REGfloat:
                              case REGstring:
                                aux = arg.emit_get(e);
                                e.emitbox(argr, aux);
                                break;
                              default:
                                arg.emit(e, argr);
                            }
                            break;
                          case REGint:
                          case REGfloat:
                          case REGstring:
                            aux = arg.emit_get(e);
                            e.emitset(argr, aux);
                            break;
                          default:
                            arg.emit(e, argr);
                        }
                    }
                }
                push(argreg, argr);
            }
        }
        self.predef.expand(e, self, self.start, result, argreg);
    }
}

//*********************************************

function genpredefcallexpr(owner, predef, args)
{
    string callname = predef.name();
    owner.use_predef(callname);
    int nargs = args == null ? 0 : args.numargs();
    var rawargs = nargs == 0 ? [] : args.getrawargs();

    // Check for compile time evaluation.
    if (predef instanceof PredefFunctionEval) {
        if (arglist_hascompilevalue(rawargs)) {
            var evalfun = predef.evalfun;
            return evalfun(owner.owner, owner.start, rawargs);
        }
    }

    return new CallPredefExpr(owner.owner, owner.start, predef, rawargs);
}

class CallExpr : Expr
{
    var funref;
    var args;

    function CallExpr(tk, owner, start, subexp)
    {
        self.Expr(owner, start);
        self.funref = subexp;
        var t = tk.get();
        if (! t.isop(')')) {
            tk.unget(t);
            self.args = new ArgumentList(owner, start, tk, ')');
        }
    }
    function checkresult() { return REGvar; }
    function optimize()
    {
        var funref = self.funref.optimize();
        var args = self.args;
        int nargs = 0;
        if (args != null) {
            args = args.optimize();
            nargs = args.numargs();
        }

        if (funref instanceof MemberExpr)
            return new CallMemberExpr(self, funref, args);
        if (funref instanceof MemberRefExpr)
            return new CallMemberRefExpr(self, funref, args);

        // Check for predefined functions
        if (funref.isidentifier()) {
            string callname = funref.getName();
            var predef = findpredef(callname, nargs);
            if (predef != null)
                return genpredefcallexpr(self.owner, predef, args);
        }

        self.funref = funref;
        self.args = args;
        return self;
    }
    function cantailcall()
    {
        return true;
    }
    function emitcall(e)
    {
        var funref = self.funref;
        string call;

        if (funref.isidentifier() && funref.subid == null) {
            call = funref.checkIdentifier();
            if (call == '') {
                var sym = self.findsymbol([ funref.getName() ]);
                if (sym != null && sym instanceof FunctionExtern)
                    call = sym.emit_get(e, self);
                else
                    call = join("", [ "'", funref.getName(), "'" ] );
            }
        }
        else
            call = funref.emit_get(e);
        return call;
    }
    function prepareargs(e)
    {
        var args = self.args;
        if (args != null)
            args.getargvalues(e);
    }
    function emitargs(e)
    {
        e.print('(');
        var args = self.args;
        if (args != null)
            args.emitargs(e);
        e.say(')');
    }
    function emit(e, result)
    {
        string call = self.emitcall(e);
        self.prepareargs(e);

        self.annotate(e);

        e.print(INDENT);
        if (result != null && result != '') {
            if (result == '.tailcall')
                e.print('.tailcall ');
            else
                e.print(result, ' = ');
        }

        e.print(call);
        self.emitargs(e);
    }
}

//*********************************************

// Method calls. Always created from CallExpr, never directly.

// Method call by name.
class CallMemberExpr : CallExpr
{
    var sym;
    var subid;
    function CallMemberExpr(callst, funref, args)
    {
        self.Expr(callst.owner, callst.start);
        self.funref = funref;
        self.args = args;

        // Check if the first element of the member expression
        // is an identfier. In that case, if it's not in scope
        // look for a function in accessible namespaces.
        var first = funref.left;
        while (first instanceof MemberExpr)
            first = first.left;
        if (first instanceof IdentifierExpr) {
            var idfirst = first.checkIdentifier();
            if (idfirst == null || idfirst == '') {
                var key = [ ];
                funref.buildkey(key);
                var sym = self.findsymbol(key);
                if (sym != null) {
                    self.sym = sym;
                    if (sym instanceof FunctionStatement) {
                        self.subid = sym.makesubid();
                        self.usesubid(self.subid);
                    }
                }
            }
        }
    }
    function emitcall(e)
    {
        if (self.sym != null) {
            if (self.subid != null)
                return self.subid;
            var sym = self.sym;
            if (sym instanceof FunctionExtern)
                return sym.emit_get(e, self);
        }
        var funref = self.funref;
        return join("", [ funref.emit_left_get(e),
                ".'", funref.get_member(), "'" ] );
    }
}

// Method call by reference.
// The reference is a expression, its result must be a var containing a
// invokable or a string with the method name.
class CallMemberRefExpr : CallExpr
{
    function CallMemberRefExpr(callst, funref, args)
    {
        self.Expr(callst.owner, callst.start);
        self.funref = funref;
        self.args = args;
    }
    function emitcall(e)
    {
        var funref = self.funref;
        var right = funref.right;
        var type = right.checkresult();
        if (type != REGvar && type != REGstring)
            SyntaxError("Invalid expression type in '.*'", funref);
        // We want a well defined order of evaluation here, so use variables
        // to store intermediate results.
        string lreg = funref.emit_left_get(e);
        string rreg = right.emit_get(e);
        return lreg + '.' + rreg;
    }
}

//*********************************************

class MemberExprBase : Expr
{
    var left;
    function MemberExprBase(owner, start, subexp)
    {
        self.Expr(owner, start);
        self.left = subexp;
    }
    function emit_left_get(e)
    {
        var left = self.left;
        string type = left.checkresult();
        string reg = left.emit_get(e);
        if (type != REGvar) {
            string auxreg = reg;
            reg = self.tempreg(REGvar);
            e.emitbox(reg, auxreg);
        }
        return reg;
    }
}

class MemberExpr : MemberExprBase
{
    var right;

    function MemberExpr(owner, start, subexp, right)
    {
        self.MemberExprBase(owner, start, subexp);
        self.right = right;
    }
    function checkresult() { return REGvar; }
    function optimize()
    {
        self.left = self.left.optimize();
        return self;
    }
    function buildkey(key)
    {
        var left = self.left;
        if (left instanceof IdentifierExpr)
            push(key, left.getName());
        else
            left.buildkey(key);
        push(key, self.right.getidentifier());
    }
    function get_member()
    {
        return self.right;
    }
    function __emit_assign_aux(e, string obj, string value)
    {
        string ident = self.right.getidentifier();
        self.annotate(e);
        e.say(INDENT, "setattribute ", obj, ", '", ident, "', ", value);
    }
    function emit_get(e)
    {
        string result = self.tempreg(REGvar);
        self.emit(e, result);
        return result;
    }
    function emit(e, result)
    {
        string obj = self.left.emit_get(e);
        string ident = self.right.getidentifier();
        self.annotate(e);
        e.say(INDENT, 'getattribute ', result, ', ', obj, ", '", ident, "'");
    }
    function emit_init(e, result)
    {
        self.emit(e, result);
    }
    function emit_assign(e, string typeright, string rreg)
    {
        string obj = self.left.emit_get_nonull(e);
        string value;
        if (typeright == REGvar) {
            // Special case temporarily
            if (rreg == NULL) {
                rreg = self.tempreg(REGvar);
                e.emitnull(rreg);
            }
            value = rreg;
        }
        else {
            value = self.tempreg(REGvar);
            e.emitbox(value, rreg);
        }
        self.__emit_assign_aux(e, obj, value);
    }
    function emit_assign_get(e, expr)
    {
        string obj = self.left.emit_get_nonull(e);
        string value = self.tempreg(REGvar);
        if (expr.isnull())
            e.emitnull(value);
        else {
            string rreg = expr.emit_get(e);
            if (expr.checkresult() != REGvar)
                e.emitbox(value, rreg);
            else
                value = rreg;
        }
        self.__emit_assign_aux(e, obj, value);
        return value;
    }
}

// Member dereference via a var or string expresion.
// When used for method calls is handled by CallMemberRefExpr.
// For attribute access only string is allowed.
class MemberRefExpr : MemberExprBase
{
    var right;
    function MemberRefExpr(owner, start, left, right)
    {
        self.MemberExprBase(owner, start, left);
        self.right = right;
    }
    function checkresult() { return REGvar; }
    function optimize()
    {
        self.left = self.left.optimize();
        self.right = self.right.optimize();
        return self;
    }
    function emit(e, result)
    {
        var left = self.left;
        var right = self.right;
        if (right.checkresult() != REGstring)
            Expected("string expression", right);
        string lreg = left.emit_get_nonull(e);
        string rreg = right.emit_get(e);
        self.annotate(e);
        if (result == '')
            result = self.tempreg(REGvar);
        e.say(INDENT, 'getattribute ', result, ', ', lreg, ", ", rreg);
    }
    function emit_assign_get(e, expr)
    {
        var left = self.left;
        var right = self.right;
        if (right.checkresult() != REGstring)
            Expected("string expression", right);
        string lreg = left.emit_get_nonull(e);
        string rreg = right.emit_get(e);
        string vreg;
        switch (expr.checkresult()) {
          case REGvar:
            vreg = expr.emit_get(e);
            // Special case
            if (vreg == NULL) {
                vreg = self.tempreg(REGvar);
                e.emitnull(vreg);
            }
            break;
          default:
            vreg = self.tempreg(REGvar);
            string aux = expr.emit_get(e);
            e.emitbox(vreg, aux);
        }

        self.annotate(e);
        e.say(INDENT, "setattribute ",  lreg, ", ", rreg, ", ", vreg);
        return vreg;
    }
}

//*********************************************

class IndexExpr : Expr
{
    var left;
    var regleft;
    var args;
    var argregs;

    function IndexExpr(tk, owner, start, subexp)
    {
        self.Expr(owner, start);
        self.left = subexp;
        self.args = new SimpleArgList(tk, owner, ']');
    }
    function checkresult()
    {
        if (self.left.checkresult() == REGstring)
            return REGstring;
        else
            return REGvar;
    }
    function optimize()
    {
        var left = self.left.optimize();
        self.left = left;
        var args = self.args;
        args.optimizeargs();

        // Optimize case of string constant indexed with int constant
        // evaluating it at compile time.
        if (left.isstringliteral() && args.numargs() == 1) {
            var arg = args.getarg(0);
            if (arg.isintegerliteral()) {
                int ival = arg.getIntegerValue();
                string sval = left.get_value();
                var t = new TokenQuoted(self.start.file, self.start.line,
                        substr(sval, ival, 1));
                return new StringLiteral(self.owner, t);
            }
        }
        return self;
    }
    function emit_prep(e)
    {
        if (self.regleft != null || self.argregs != null)
            InternalError('wrong call to IndexExpr.emit_args', self.start);
        var left = self.left;
        self.regleft = left.isidentifier() ?
            left.getIdentifier() :
            left.emit_get(e);
        self.argregs = self.args.getargvalues(e);
    }
    function emit_aux(e)
    {
        var regleft = self.regleft;
        var argregs = self.argregs;
        if (regleft == null || argregs == null)
            InternalError('wrong call to IndexExpr.emit_aux', self.start);
        e.print(self.regleft, '[');
        e.print(join('; ', argregs));
        e.print(']');
    }
    function emit(e, result)
    {
        self.emit_prep(e);
        string type = self.checkresult();
        if (type == REGstring) {
            var argregs = self.argregs;
            int nargs = elements(argregs);
            if (nargs != 1)
               SyntaxError('Bad string index', self);
            if (result == '')
                result = self.tempreg(REGstring);
            e.say(INDENT, 'substr ', result, ', ', self.regleft, ', ', argregs[0], ', ', 1);
        }
        else {
            self.annotate(e);
            e.print(INDENT, result, ' = ');
            self.emit_aux(e);
            e.say('');
        }
    }
    function emit_assign(e, string typeright, string rreg)
    {
        self.emit_prep(e);
        self.annotate(e);
        e.print(INDENT);
        self.emit_aux(e);
        e.say(' = ', rreg);
    }
    function emit_assign_get(e, expr)
    {
        self.emit_prep(e);
        string rreg;
        if (expr.isnull()) {
            rreg = self.tempreg(REGvar);
            e.emitnull(rreg);
        }
        else
            rreg = expr.emit_get(e);
        self.annotate(e);
        e.print(INDENT);
        self.emit_aux(e);
        e.say(' = ', rreg);
        return rreg;
    }
}

//*********************************************

class ArrayExpr : Expr
{
    var values;

    function ArrayExpr(tk, owner, start)
    {
        self.Expr(owner, start);
        var t = tk.get();
        if (! t.isop(']')) {
            tk.unget(t);
            self.values = parseList(tk, owner, parseExpr, ']');
        }
    }
    function checkresult() { return REGvar; }
    function optimize()
    {
        optimize_array(self.values);
        return self;
    }
    function emit(e, result)
    {
        if (result != '') {
            string value = self.emit_get(e);
            e.emitset(result, value);
        }
        else {
            // No need to create the container, but the
            // initializers may have secondary effects,
            // so they should be evaluated.
            self.emit_init(e, '');
        }
    }
    function emit_get(e)
    {
        string container = self.tempreg(REGvar);
        self.emit_init(e, container);
        return container;
    }
    function emit_init(e, string container)
    {
        self.annotate(e);
        string itemreg;
        string it_p;
        if (container != '') {
            e.say(INDENT, 'root_new ', container, ", ['parrot';'ResizablePMCArray']");
            it_p = self.tempreg(REGvar);
        }
        for (var item in self.values) {
            switch (item.checkresult()) {
              case REGint: case REGfloat: case REGstring:
                string aux = item.emit_get(e);
                if (container != '') {
                    e.emitbox(it_p, aux);
                    itemreg = it_p;
                }
                break;
              default:
                if (item.isnull()) {
                    if (container != '') {
                        itemreg = self.tempreg(REGvar);
                        e.emitnull(itemreg);
                    }
                }
                else
                    itemreg = item.emit_get(e);
            }
            if (container != '') {
                self.annotate(e);
                e.emitarg2('push', container, itemreg);
            }
        }
    }
}

//*********************************************

class HashExpr : Expr
{
    var keys;
    var values;

    function HashExpr(tk, owner, start)
    {
        self.Expr(owner, start);
        var t = tk.get();
        var keys = [];
        var values = [];
        if (!t.isop('}')) {
            tk.unget(t);
            do {
                var key = parseExpr(tk, owner);
                ExpectOp(':', tk);
                var value = parseExpr(tk, owner);
                push(keys, key);
                push(values, value);

            } while ((t = tk.get()).isop(','));
            if (! t.isop('}'))
                Expected("',' or '}'", t);
        }
        self.keys = keys;
        self.values = values;
    }
    function checkresult() { return REGvar; }
    function optimize()
    {
        optimize_array(self.keys);
        optimize_array(self.values);
        return self;
    }
    function emit(e, result)
    {
        self.annotate(e);

        // In void context there is no need to create the container,
        // but the keys and values may have secondary effects,
        // so they should ve evaluated.
        if (result != '')
            e.say(INDENT, 'root_new ', result, ", ['parrot';'Hash']");

        var keys = self.keys;
        var values = self.values;
        int n = keys;
        for (int i = 0; i < n; ++i) {
            var key = keys[i];
            string item;
            if (key.isidentifier()) {
                string id = key.getName();
                item = self.tempreg(REGvar);
                e.emitget_hll_global(item, id);
            }
            else
                item = key.emit_get(e);

            var value = values[i];
            string itemreg;
            string it_p;
            if (result != '')
                it_p = self.tempreg(REGvar);
            string aux;
            switch (value.checkresult()) {
                  case REGint: case REGfloat: case REGstring:
                    aux = value.emit_get(e);
                    if (result != '') {
                        e.emitbox(it_p, aux);
                        itemreg = it_p;
                    }
                    break;
                  default:
                    if (value.isnull()) {
                        if (result != '') {
                            itemreg = self.tempreg(REGvar);
                            e.emitnull(itemreg);
                        }
                    }
                    else
                        itemreg = value.emit_get(e);
            }
            if (result != '')
                e.say(INDENT, result, '[', item, '] = ', itemreg);
        }
    }
    function emit_get(e)
    {
        string container = self.tempreg(REGvar);
        self.emit(e, container);
        return container;
    }
}

//**********************************************************************

class NewBaseExpr : Expr
{
    var initializer;
    // The value of initializer is:
    // * null if no arguments          -> no parenthesis
    // * empty array if zero arguments -> parenthesized empty list
    // * non empty array otherwise     -> parenthesized non empty list

    function checkresult() { return REGvar; }
    function parseinitializer(tk)
    {
        // Called with the tokenizer pointing right after the
        // opening parenthesis
        self.initializer = new ArgumentList(self.owner, self.start, tk, ')');
    }
    function optimize_initializer()
    {
        var initializer = self.initializer;
        if (initializer != null)
            self.initializer = initializer.optimize();
    }
    function optimize()
    {
        self.optimize_initializer();
        return self;
    }
    function emit_constructor(e, string regnew, string constructor)
    {
        var initializer = self.initializer;
        if (initializer != null)
            initializer.getargvalues(e);
        e.print(INDENT, regnew, ".'", constructor, "'(");
        if (initializer != null)
            initializer.emitargs(e);
        e.say(")");
    }
}

//**********************************************************************

class NewExpr : NewBaseExpr
{
    var value;

    function NewExpr(var tk, var owner, var start, var firstvalue)
    {
        self.Expr(owner, start);

        if (! (firstvalue.isstring() || firstvalue.isidentifier()))
            SyntaxError("Unimplemented", firstvalue);
        self.value = firstvalue;
        var t = tk.get();

        if (t.isop('('))
            self.parseinitializer(tk);
        else
            tk.unget(t);
    }
    function optimize()
    {
        var value = self.value;
        if ((value instanceof Token) && value.isidentifier()) {
            // The identifier can be a string constant, check for that case
            // and obtain the string value.
            var desc = self.owner.getvar(value.getidentifier());
            if (desc != null && desc.isconst()) {
                value = desc.getvalue();
                if (! (value instanceof StringLiteral))
                    SyntaxError('Constant value must evaluate to a string', value);
                self.value = value.strval;
            }
        }
        self.optimize_initializer();
        return self;
    }
    function emit(e, result, int is_init[optional])
    {
        self.annotate(e);

        var initializer = self.initializer;
        int numinits = initializer == null ? -1 : initializer.numargs();

        const int BYNAME = 0, BYIDENT = 1;
        int type = self.value.isstring() ? BYNAME :
                self.value.isidentifier() ? BYIDENT : -1;

        string reginit = '';
        string regnew = result;
        string constructor;
        switch (numinits) {
          case -1:
          case 0:
            break;
          case 1:
            if (type == BYIDENT) {
                if (! is_init)
                    regnew = self.tempreg(REGvar);
            }
            else {
                var initval = initializer.getfreearg(0);
                reginit = initval.emit_get(e);
                reginit = ', ' + reginit;
            }
            break;
          default:
            if (type != BYIDENT)
                SyntaxError('Multiple init arguments not allowed here', self);
            if (! is_init)
                regnew = self.tempreg(REGvar);
        }

        switch (type) {
          case BYNAME:
            // By name, usually a pmc.
            string name = self.value.rawstring();
            var aux = get_class(name);
            if (aux == null && self.dowarnings())
                Warn("Can't locate class " + name + " at compile time", self.value);

            // Avoid using root_new here for a now.
            //e.say('root_new ', regnew, ", ['parrot'; ", self.value, " ]", reginit);
            e.say(INDENT, 'new ', regnew, ", [ ", self.value, " ]", reginit);
            if (numinits > 1) {
                e.say(regnew, ".'", self.value, "'()");
            }
            break;
          case BYIDENT:
            var id = self.owner.getvar(self.value);
            if (id == null) {
                //say('new with no var');
                var cl = self.owner.checkclass(self.value);
                if (cl != null) {
                    e.say(INDENT, 'new ', regnew, ", ", cl.getclasskey(), reginit);
                }
                else {
                    if (self.dowarnings())
                        Warn('Checking: new unknown type');
                    e.say(INDENT, 'new ', regnew, ", ['", self.value, "']", reginit);
                }
                constructor = self.value;
            }
            else {
                //say('new with var');
                e.say(INDENT, 'new ', regnew, ", ", id.getreg(), "", reginit);
            }
            break;
          default:
            InternalError('Unexpected type in new');
        }
        if (numinits > 1 || (numinits >= 0 && type == BYIDENT)) {
            self.emit_constructor(e, regnew, constructor);
            if (! is_init)
                e.emitset(result, regnew);
        }
    }
    function emit_init(e, result)
    {
        return self.emit(e, result, true);
    }
}

//**********************************************************************

class NewIndexedExpr : NewBaseExpr
{
    var nskey;

    function NewIndexedExpr(var tk, var owner, var start)
    {
        self.Expr(owner, start);
        self.owner = owner;
        var nskey = new ClassSpecifierParrotKey(tk, owner, start);
        self.nskey = nskey;
        var t = tk.get();
        if (t.isop('('))
            self.parseinitializer(tk);
        else
            tk.unget(t);
    }
    function emit(e, result)
    {
        string reginit;
        var initializer = self.initializer;
        int numinits = initializer == null ? 0 : initializer.numargs();
        switch (numinits) {
          case 0:
            break;
          case 1:
            var initval = initializer.getfreearg(0);
            reginit = initval.emit_get(e);
            break;
          default:
            SyntaxError('Multiple init arguments not allowed here', self);
        }
        var nskey = self.nskey;
        e.print(INDENT);
        if (nskey.hasHLL())
            e.print("root_");
        e.print("new ", result, ", ");
        nskey.emit(e, null);
        if (reginit != null)
            e.print(', ', reginit);
        e.say();
    }
}

//**********************************************************************

class NewQualifiedExpr : NewBaseExpr
{
    var nskey;

    function NewQualifiedExpr(var tk, var owner, var start)
    {
        self.Expr(owner, start);
        self.owner = owner;
        var nskey = new ClassSpecifierId(tk, owner, start);
        self.nskey = nskey;
        var t = tk.get();
        if (t.isop('('))
            self.parseinitializer(tk);
        else
            tk.unget(t);
    }
    function emit(e, result)
    {
        string reginit;
        var initializer = self.initializer;

        int numinits = initializer == null ? -1 : initializer.numargs();
        string regnew = result;
        if (numinits > 0)
            regnew = self.tempreg(REGvar);
        var nskey = self.nskey;
        e.print(INDENT, 'new ', regnew, ", ");
        nskey.emit(e, self.owner);
        e.say();

        if (numinits >= 0) {
            string constructor = nskey.last();
            self.emit_constructor(e, regnew, constructor);
            e.emitset(result, regnew);
        }
    }
}

//**********************************************************************

function parseNew(var tk, var owner, var start)
{
    var t = tk.get();

    switch {
      case t.isop('('):
        // Not a new operator, but a call to a function called new.
        return new CallExpr(tk, owner, start,
                new StringLiteral(owner, start));
      case t.isop('['):
        // Class specifier is a key
        return new NewIndexedExpr(tk, owner, start);
      case t.isidentifier():
        // Special case here. It can be an id, a qualified id or
        // a const string
        var t2 = tk.get();
        tk.unget(t2);
        if (t2.isop('.')) {
            // Qualified id
            return new NewQualifiedExpr(tk, owner, t);
        }
        // Else let the default handle it
      default:
        // Remainig cases
        return new NewExpr(tk, owner, start, t);
    }
}

//**********************************************************************

class OpInstanceOfExpr : Expr
{
    var lexpr;
    var checked;

    function OpInstanceOfExpr(owner, start, lexpr, tk)
    {
        self.Expr(owner, start);
        self.lexpr = lexpr;
        self.checked = parseClassSpecifier(tk, self);
    }
    function optimize()
    {
        self.lexpr = self.lexpr.optimize();
        return self;
    }
    function checkresult() { return REGint; }
    function emit(e, result)
    {
        var lexpr = self.lexpr;
        string ltype = lexpr.checkresult();
        if (ltype != REGvar)
            SyntaxError('Invalid instanceof left operand', lexpr);
        var checked = self.checked;

        string r = result == '' ? self.tempreg(REGint) : result;
        string check = lexpr.emit_get(e);
        self.annotate(e);
        e.print(INDENT + 'isa ', r, ', ', check, ', ');
        checked.emit(e, self.owner);
        e.say();
    }
}

//*********************************************

class OpConditionalExpr : Expr
{
    // TODO
    // Allow true and false branches to have different types,
    // or give an error in that case.

    var condition;
    var etrue;
    var efalse;

    function OpConditionalExpr(owner, start, condition, etrue, efalse)
    {
        self.Expr(owner, start);
        self.condition = (new Condition).set(condition);
        self.etrue = etrue;
        self.efalse = efalse;
        return self;
    }
    function optimize()
    {
        self.condition = self.condition.optimize();
        switch (self.condition.getvalue()) {
          case CONDistrue:
            return self.etrue.optimize();
          case CONDisfalse:
            return self.efalse.optimize();
          default:
            self.etrue = self.etrue.optimize();
            self.efalse = self.efalse.optimize();
            return self;
        }
    }
    function checkresult()
    {
        var etrue = self.etrue;
        if (etrue.isnull())
            return self.efalse.checkresult();
        else
            return etrue.checkresult();
    }
    function emit(e, result)
    {
        string cond_end = self.owner.genlabel();
        string cond_false = self.owner.genlabel();
        self.condition.emit_else(e, cond_false);
        var etrue = self.etrue;
        string tres = self.checkresult();
        if (etrue.isnull())
            e.emitnull(result);
        else
            etrue.emit(e, result);
        e.emitgoto(cond_end);
        e.emitlabel(cond_false);
        var efalse = self.efalse;
        if (efalse.isnull())
            e.emitnull(result);
        else {
            string tfalse = efalse.checkresult();
            if (tres == REGvar && tfalse != REGvar) {
                string r = efalse.emit_get(e);
                e.emitbox(result, r);
            }
            else
                efalse.emit(e, result);
        }
        e.emitlabel(cond_end);
    }
}

//*********************************************
//           Expressions parser
//*********************************************

const int
    Code_none          =  0,
    Code_paren         =  1,
    Code_bracket       =  2,
    Code_dot           =  3,
    Code_assign        =  4,
    Code_assign_to     =  5,
    Code_add_assign    =  6,
    Code_add           =  7,
    Code_minus         =  8,
    Code_inc           =  9,
    Code_dec           = 10,
    Code_not           = 11,
    Code_equal         = 12,
    Code_not_equal     = 13,
    Code_less          = 14,
    Code_less_equal    = 15,
    Code_greater       = 16,
    Code_greater_equal = 17,
    Code_sub_assign    = 18,
    Code_mul           = 19,
    Code_div           = 20,
    Code_mod           = 21,
    Code_cmod          = 22,
    Code_mul_assign    = 23,
    Code_div_assign    = 24,
    Code_same          = 25,
    Code_not_same      = 26,
    Code_instanceof    = 27,
    Code_shiftleft     = 28,
    Code_shiftright    = 29,
    Code_mod_assign    = 30,
    Code_delete        = 31,
    Code_exists        = 32;

function getOpCode_2(t)
{
    switch (t.checkop()) {
    case '(': return Code_paren;
    case '[': return Code_bracket;
    case '.': return Code_dot;
    default:  return Code_none;
    }
}

function getOpCode_4(t)
{
    switch (t.checkop()) {
    case '-':  return Code_minus;
    case '!':  return Code_not;
    case '++': return Code_inc;
    case '--': return Code_dec;
    default:
        if (t.iskeyword('delete')) return Code_delete;
        else if (t.iskeyword('exists')) return Code_exists;
        else return Code_none;
    }
}

function getOpCode_5(t)
{
    switch (t.checkop()) {
    case '*':  return Code_mul;
    case '/':  return Code_div;
    case '%':  return Code_mod;
    case '%%': return Code_cmod;
    default:   return Code_none;
    }
}

function getOpCode_7(t)
{
    switch (t.checkop()) {
    case '<<':  return Code_shiftleft;
    case '>>':  return Code_shiftright;
    default:   return Code_none;
    }
}

function getOpCode_8(t)
{
    switch (t.checkop()) {
    case '<':  return Code_less;
    case '>':  return Code_greater;
    case '<=': return Code_less_equal;
    case '>=': return Code_greater_equal;
    default:
        if (t.iskeyword('instanceof')) return Code_instanceof;
        else return Code_none;
    }
}

function getOpCode_9(t)
{
    switch (t.checkop()) {
    case '==':  return Code_equal;
    case '!=':  return Code_not_equal;
    case '===':  return Code_same;
    case '!==':  return Code_not_same;
    default:   return Code_none;
    }
}

function getOpCode_16(t)
{
    switch (t.checkop()) {
    case '=':  return Code_assign;
    case '=:': return Code_assign_to;
    case '+=': return Code_add_assign;
    case '-=': return Code_sub_assign;
    case '*=': return Code_mul_assign;
    case '/=': return Code_div_assign;
    case '%=': return Code_mod_assign;
    default:   return Code_none;
    }
}

function parseExpr_0(tk, owner)
{
    var t = tk.get();
    var expr;

    switch {
      case t.isop('('):
        expr = parseExpr(tk, owner);
        ExpectOp(')', tk);
        return expr;
      case t.isop('['):
        return new ArrayExpr(tk, owner, t);
      case t.isop('{'):
        return new HashExpr(tk, owner, t);
      case t.isstring():
        return new StringLiteral(owner, t);
      case t.isint():
        return integerValue(owner, t, t.getintvalue());
      case t.isfloat():
        return new FloatLiteral(owner, t);
      case t.iskeyword('new'):
        return parseNew(tk, owner, t);
      case t.iskeyword('function'):
        return new FunctionExpr(tk, owner, t);
      case t.iskeyword('class'):
        return new OpClassExpr(tk, owner, t);
      case t.isidentifier():
        return new IdentifierExpr(owner, t);
      default:
        Expected('expression', t);
    }
}

function parseExpr_2(tk, owner)
{
    var subexp = parseExpr_0(tk, owner);
    var t;
    var start;
    int code;
    while ((code = getOpCode_2(t = tk.get())) != Code_none ) {
        switch(code) {
          case Code_paren:
            subexp = new CallExpr(tk, owner, t, subexp);
            break;
          case Code_bracket:
            subexp = new IndexExpr(tk, owner, t, subexp);
            break;
          case Code_dot:
            start = t;
            t = tk.get();
            if (t.isop('*')) {
                var right = parseExpr_0(tk, owner);
                subexp = new MemberRefExpr(owner, t, subexp, right);
            }
            else
                subexp = new MemberExpr(owner, start, subexp, t);
            break;
          default:
            InternalError('Unexpected code in parseExpr_2');
        }
    }
    tk.unget(t);
    return subexp;
}

function parseExpr_3(tk, owner)
{
    var subexp = parseExpr_2(tk, owner);
    var t = tk.get();
    switch {
      case t.isop('++'):
        return new OpPostIncExpr(owner, t, subexp);
      case t.isop('--'):
        return new OpPostDecExpr(owner, t, subexp);
      default:
        tk.unget(t);
        return subexp;
    }
}

function parseExpr_4(tk, owner)
{
    var t = tk.get();
    int code = getOpCode_4(t);
    if (code != Code_none) {
        var subexpr = parseExpr_4(tk, owner);
        switch (code) {
          case Code_minus:
            return new OpUnaryMinusExpr(owner, t, subexpr);
          case Code_not:
            return new OpNotExpr(owner, t, subexpr);
          case Code_inc:
            return new OpPreIncExpr(owner, t, subexpr);
          case Code_dec:
            return new OpPreDecExpr(owner, t, subexpr);
          case Code_delete:
            return new OpDeleteExpr(owner, t, subexpr);
          case Code_exists:
            return new OpExistsExpr(owner, t, subexpr);
          default:
            InternalError('Invalid code in parseExpr_4', t);
        }
    }
    else {
        tk.unget(t);
        return  parseExpr_3(tk, owner);
    }
}

function parseExpr_5(tk, owner)
{
    var lexpr = parseExpr_4(tk, owner);
    var t;
    int code;
    while ((code = getOpCode_5(t = tk.get())) != Code_none) {
        var rexpr = parseExpr_4(tk, owner);
        switch (code) {
          case Code_mul:
            lexpr = new OpMulExpr(owner, t, lexpr, rexpr);
            break;
          case Code_div:
            lexpr = new OpDivExpr(owner, t, lexpr, rexpr);
            break;
          case Code_mod:
            lexpr = new OpModExpr(owner, t, lexpr, rexpr);
            break;
          case Code_cmod:
            lexpr = new OpCModExpr(owner, t, lexpr, rexpr);
            break;
          default:
            InternalError('Invalid code in parseExpr_5', t);
        }
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_6(tk, owner)
{
    var lexpr = parseExpr_5(tk, owner);
    var t;
    while ((t = tk.get()).isop('+') || t.isop('-')) {
        var rexpr = parseExpr_5(tk, owner);
        var expr;
        if (t.isop('+'))
            expr = new OpAddExpr(owner, t, lexpr, rexpr);
        else
            expr = new OpSubExpr(owner, t, lexpr, rexpr);
        lexpr = expr;
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_7(tk, owner)
{
    var lexpr = parseExpr_6(tk, owner);
    var rexpr;
    var t;
    int code;
    while ((code = getOpCode_7(t = tk.get())) != Code_none) {
        switch (code) {
          case Code_shiftleft:
            rexpr = parseExpr_6(tk, owner);
            lexpr = new OpShiftleftExpr(owner, t, lexpr, rexpr);
            break;
          case Code_shiftright:
            rexpr = parseExpr_6(tk, owner);
            lexpr = new OpShiftrightExpr(owner, t, lexpr, rexpr);
            break;
          default:
            InternalError('Invalid code in parseExpr_7', t);
        }
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_8(tk, owner)
{
    var lexpr = parseExpr_7(tk, owner);
    var rexpr;
    var t;
    int code;
    while ((code = getOpCode_8(t = tk.get())) != Code_none) {
        switch (code) {
          case Code_less:
            rexpr = parseExpr_7(tk, owner);
            lexpr = (new OpLessExpr).set(owner, t, lexpr, rexpr);
            break;
          case Code_greater:
            rexpr = parseExpr_7(tk, owner);
            lexpr = (new OpGreaterExpr).set(owner, t, lexpr, rexpr);
            break;
          case Code_less_equal:
            rexpr = parseExpr_7(tk, owner);
            lexpr = (new OpLessEqualExpr).set(owner, t, lexpr, rexpr);
            break;
          case Code_greater_equal:
            rexpr = parseExpr_7(tk, owner);
            lexpr = (new OpGreaterEqualExpr).set(owner, t, lexpr, rexpr);
            break;
          case Code_instanceof:
            lexpr = new OpInstanceOfExpr(owner, t, lexpr, tk);
            break;
          default:
            InternalError('Invalid code in parseExpr_9', t);
        }
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_9(tk, owner)
{
    var lexpr = parseExpr_8(tk, owner);
    var rexpr;
    var t;
    int code;
    while ((code = getOpCode_9(t = tk.get())) != Code_none) {
        switch (code) {
          case Code_equal:
            rexpr = parseExpr_8(tk, owner);
            lexpr = (new OpEqualExpr).set(owner, t, lexpr, rexpr);
            break;
          case Code_not_equal:
            rexpr = parseExpr_8(tk, owner);
            lexpr = (new OpNotEqualExpr).set(owner, t, lexpr, rexpr);
            break;
          case Code_same:
            rexpr = parseExpr_8(tk, owner);
            lexpr = new OpSameExpr(true, owner, t, lexpr, rexpr);
            break;
          case Code_not_same:
            rexpr = parseExpr_8(tk, owner);
            lexpr = new OpSameExpr(false, owner, t, lexpr, rexpr);
            break;
          default:
            InternalError('Invalid code in parseExpr_8', t);
        }
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_10(tk, owner)
{
    var lexpr = parseExpr_9(tk, owner);
    var t;
    while ((t = tk.get()).isop('&')) {
        var rexpr = parseExpr_9(tk, owner);
        lexpr = new OpBinAndExpr(owner, t, lexpr, rexpr);
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_11(tk, owner)
{
    var lexpr = parseExpr_10(tk, owner);
    var t;
    while ((t = tk.get()).isop('^')) {
        var rexpr = parseExpr_10(tk, owner);
        lexpr = new OpBinXorExpr(owner, t, lexpr, rexpr);
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_12(tk, owner)
{
    var lexpr = parseExpr_11(tk, owner);
    var t;
    while ((t = tk.get()).isop('|')) {
        var rexpr = parseExpr_11(tk, owner);
        lexpr = new OpBinOrExpr(owner, t, lexpr, rexpr);
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_13(tk, owner)
{
    var lexpr = parseExpr_12(tk, owner);
    var t;
    while ((t = tk.get()).isop('&&')) {
        var rexpr = parseExpr_12(tk, owner);
        lexpr = new OpBoolAndExpr(owner, t, lexpr, rexpr);
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_14(tk, owner)
{
    var lexpr = parseExpr_13(tk, owner);
    var t;
    while ((t = tk.get()).isop('||')) {
        var rexpr = parseExpr_12(tk, owner);
        lexpr = new OpBoolOrExpr(owner, t, lexpr, rexpr);
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr_15(tk, owner)
{
    var econd = parseExpr_14(tk, owner);
    var t = tk.get();
    if (t.isop('?')) {
        var etrue = parseExpr_16(tk, owner);
        ExpectOp(':', tk);
        var efalse = parseExpr_16(tk, owner);
        return new OpConditionalExpr(owner, t, econd, etrue, efalse);
    }
    else {
        tk.unget(t);
        return econd;
    }
}

function parseExpr_16(tk, owner)
{
    var lexpr = parseExpr_15(tk, owner);
    var t;
    int code;
    while ((code = getOpCode_16(t = tk.get())) != Code_none ) {
        var rexpr = parseExpr_16(tk, owner);
        var expr;
        switch (code) {
          case Code_assign:
            expr = new OpAssignExpr;
            break;
          case Code_assign_to:
            expr = new OpAssignToExpr;
            break;
          case Code_add_assign:
            expr = new OpAddToExpr;
            break;
          case Code_sub_assign:
            expr = new OpSubToExpr;
            break;
          case Code_mul_assign:
            expr = new OpMulToExpr;
            break;
          case Code_div_assign:
            expr = new OpDivToExpr;
            break;
          case Code_mod_assign:
            expr = new OpModToExpr;
            break;
          default:
            InternalError('Unexpected code in parseExpr_16', t);
        }
        expr.set(owner, t, lexpr, rexpr);
        lexpr = expr;
    }
    tk.unget(t);
    return lexpr;
}

function parseExpr(tk, owner)
{
    return parseExpr_16(tk, owner);
}

//*********************************************
//         Breakable and Continuable
//*********************************************

// Abstract base class for statments that can contain break
// and continue statments. Continuable is always breakable.

class Breakable
{
    var brlabel;

    function genbreaklabel()
    {
        if (self.brlabel != null)
            InternalError('attempt to generate break label twice');
        string label = self.genlabel();
        self.brlabel = label;
        return label;
    }
    function getbreaklabel(pos)
    {
        var label = self.brlabel;
        if (label == null)
            InternalError('attempt to get break label before creating it');
        return label;
    }
}

class Continuable : Breakable
{
    var cntlabel;

    function gencontinuelabel()
    {
        if (self.cntlabel != null)
            InternalError('attempt to generate continue label twice');
        string label = self.genlabel();
        self.cntlabel = label;
        return label;
    }
    function getcontinuelabel(pos)
    {
        var label = self.cntlabel;
        if (label == null)
            InternalError('attempt to get continue label before creating it');
        return label;
    }
}

//*********************************************
//            ReturnYieldStatement
//*********************************************

// Return and Yield statements and a base class
// that does almost all.

class ReturnYieldStatement : Statement
{
    var values;

    function parse(start, tk, owner)
    {
        self.Statement(start, owner);
        var t = tk.get();
        if (! t.isop(';')) {
            tk.unget(t);
            self.values = new ArgumentList(owner, start, tk, ";");
        }
    }
    function optimize()
    {
        var values = self.values;
        if (values != null)
            values = values.optimize();
        return self;
    }
    function emit(e)
    {
        //var args = [];
        var values = self.values;
        int n = values == null ? 0 : int(values.numargs());

        // Experimental tailcall optimization
        if (n == 1 && (self instanceof ReturnStatement)) {
            var func = values.getfreearg(0);
            if (func.cantailcall()) {
                self.annotate(e);
                return func.emit(e, '.tailcall');
            }
        }

        if (n > 0)
            values.getargvalues(e);

        self.annotate(e);
        self.emitret(e);
        if (n > 0)
            values.emitargs(e);
        e.say(')');
    }
}

class ReturnStatement : ReturnYieldStatement
{
    function ReturnStatement(start, tk, owner)
    {
        self.parse(start, tk, owner);
    }
    function emitret(e)
    {
        e.print(INDENT, '.return(');
    }
}

class YieldStatement : ReturnYieldStatement
{
    function YieldStatement(start, tk, owner)
    {
        self.parse(start, tk, owner);
    }
    function emitret(e)
    {
        e.print(INDENT, '.yield(');
    }
}

//*********************************************
//            LabelStatement
//*********************************************

class LabelStatement : Statement
{
    var name;
    var value;
    function LabelStatement(n, owner)
    {
        self.Statement(n, owner);
        self.name = n;
        self.value = self.owner.createlabel(n);
    }
    function optimize() { return self; }
    function emit(e)
    {
        self.annotate(e);
        e.emitlabel(self.value, 'label ' + string(self.name));
    }
}

//*********************************************
//            Reflabel
//*********************************************

class Reflabel
{
    var owner;
    var label;

    function Reflabel(owner, string label)
    {
        self.owner = owner;
        self.label = label;
    }
    function optimize() { return self; }
    function emit_get(e)
    {
        string label = self.label;
        string value = self.owner.getlabel(label);
        return value;
    }
}

//*********************************************
//            GotoStatement
//*********************************************

class GotoStatement : Statement
{
    var label;

    function GotoStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        var t = tk.get();
        RequireIdentifier(t);
        self.label = t;
        ExpectOp(';', tk);
    }
    function optimize() { return self; }
    function emit(e)
    {
        self.annotate(e);
        string label = self.label;
        string value = self.getlabel(label);
        e.emitgoto(value, 'goto ' + label);
    }
}

//*********************************************
//          ConditionalStatement
//*********************************************

class ConditionalStatement : Statement, Condition
{
    function parseconditionshort(tk)
    {
        self.set(parseExpr(tk, self));
    }
    function parsecondition(tk)
    {
        ExpectOp('(', tk);
        self.set(parseExpr(tk, self));
        ExpectOp(')', tk);
    }
}

//*********************************************
//            IfStatement
//*********************************************

class IfStatement : ConditionalStatement
{
    var truebranch;
    var falsebranch;
    function IfStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        self.parsecondition(tk);
        self.truebranch = parseStatement(tk, self);
        var t = tk.get();
        if (t.iskeyword("else"))
            self.falsebranch = parseStatement(tk, self);
        else {
            self.falsebranch = new EmptyStatement;
            tk.unget(t);
        }
    }
    function optimize()
    {
        self.optimize_condition();
        self.truebranch = self.truebranch.optimize();
        self.falsebranch = self.falsebranch.optimize();
        switch (self.getvalue()) {
          case CONDistrue:
            return self.truebranch;
          case CONDisfalse:
            return self.falsebranch;
        }
        return self;
    }
    function emit(e)
    {
        var truebranch = self.truebranch;
        var falsebranch = self.falsebranch;
        int t_empty = truebranch.isempty();
        int f_empty = falsebranch.isempty();
        string elselabel = '';
        if (! f_empty)
            elselabel = self.genlabel();
        string endlabel = self.genlabel();
        string cond_false = f_empty ? endlabel : elselabel;
        self.annotate(e);
        self.emit_else(e, cond_false);
        truebranch.emit(e);

        if (! f_empty) {
            e.emitgoto(endlabel);
            e.emitlabel(elselabel, 'else');
            falsebranch.emit(e);
        }
        e.emitlabel(endlabel, 'endif');
    }
}

//*********************************************
//            LoopStatement
//*********************************************

class LoopStatement : Continuable
{
    var body;
    function parsebody(tk)
    {
        self.body = parseStatement(tk, self);
    }
    function emit_infinite(e)
    {
        string breaklabel = self.genbreaklabel();
        string continuelabel = self.gencontinuelabel();

        self.annotate(e);
        e.emitlabel(continuelabel, 'Infinite loop');
        self.body.emit(e);
        e.emitgoto(continuelabel);
        e.emitlabel(breaklabel, 'Infinite loop end');
    }
}

//*********************************************
//            WhileStatement
//*********************************************

class WhileStatement : LoopStatement, ConditionalStatement
{
    function WhileStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        self.parsecondition(tk);
        self.parsebody(tk);
    }
    function optimize()
    {
        self.optimize_condition();
        self.body = self.body.optimize();
        return self;
    }
    function emit(e)
    {
        switch (self.getvalue()) {
          case CONDistrue:
            self.emit_infinite(e);
            break;
          case CONDisfalse:
            e.comment('while(false) optimized out');
            break;
          default:
            string breaklabel = self.genbreaklabel();
            string continuelabel = self.gencontinuelabel();

            self.annotate(e);
            e.emitlabel(continuelabel, 'while');
            self.emit_else(e, breaklabel);
            self.body.emit(e);
            e.emitgoto(continuelabel);
            e.emitlabel(breaklabel, 'endwhile');
        }
    }
}

//*********************************************
//            DoStatement
//*********************************************

class DoStatement : LoopStatement, ConditionalStatement
{
    function DoStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        self.parsebody(tk);
        ExpectKeyword('while', tk);
        self.parsecondition(tk);
    }
    function optimize()
    {
        self.optimize_condition();
        var body = self.body.optimize();
        if (body.isempty() && self.getvalue() == CONDisfalse)
            return new EmptyStatement;
        self.body = body;
        return self;
    }
    function emit(e)
    {
        var body = self.body;
        int condvalue = self.getvalue();
        switch (condvalue) {
          case CONDistrue:
            self.emit_infinite(e);
            break;
          default:
            string looplabel = self.genlabel();
            string breaklabel = self.genbreaklabel();
            string continuelabel = self.gencontinuelabel();

            self.annotate(e);
            e.emitlabel(looplabel, 'do');

            body.emit(e);
            e.emitlabel(continuelabel, 'continue');
            if (condvalue != CONDisfalse)
                self.emit_if(e, looplabel, breaklabel);
            e.emitlabel(breaklabel, 'enddo');
        }
    }
}

//*********************************************
//            ContinueStatement
//*********************************************

class ContinueStatement : Statement
{
    function ContinueStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        ExpectOp(';', tk);
    }
    function optimize() { return self; }
    function emit(e)
    {
        self.annotate(e);
        string label = self.getcontinuelabel(self.start);
        e.emitgoto(label, 'continue');
    }
}

//*********************************************
//            BreakStatement
//*********************************************

class BreakStatement : Statement
{
    function BreakStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        ExpectOp(';', tk);
    }
    function optimize() { return self; }
    function emit(e)
    {
        self.annotate(e);
        string label = self.getbreaklabel(self.start);
        e.emitgoto(label, 'break');
    }
}

//*********************************************
//            SwitchBaseStatement
//*********************************************

class SwitchBaseStatement : Breakable, Statement
{
    var case_value;
    var case_st;
    var default_st;

    function SwitchBaseStatement(start, owner)
    {
        self.Statement(start, owner);
        self.case_value = [];
        self.case_st = [];
        self.default_st = [];
    }
    function parse_cases(tk)
    {
        var t;
        while ((t = tk.get()).iskeyword('case') || t.iskeyword('default')) {
            if (t.iskeyword('case')) {
                push(self.case_value, parseExpr(tk, self));
                t = tk.get();
                if (! t.isop(':'))
                    Expected("':' in case", t);
                var st = [];
                while (! ((t = tk.get()).isop('}') || t.iskeyword('case') || t.iskeyword('default'))) {
                    tk.unget(t);
                    push(st, parseStatement(tk, self));
                }
                push(self.case_st, st);
                tk.unget(t);
            }
            else {
                t = tk.get();
                if (! t.isop(':'))
                    Expected("':' in default", t);
                while (! ((t = tk.get()).isop('}') || t.iskeyword('case') || t.iskeyword('default'))) {
                    tk.unget(t);
                    push(self.default_st, parseStatement(tk, self));
                }
                tk.unget(t);
            }
        }
        if (! t.isop('}'))
            Expected("'}' in switch", t);
    }
    function optimize_cases()
    {
        optimize_array(self.case_value);
        for (var casest in self.case_st)
            optimize_array(casest);
        optimize_array(self.default_st);
    }
}

//*********************************************
//            SwitchStatement
//*********************************************

class SwitchStatement : SwitchBaseStatement
{
    var condition;

    function SwitchStatement(start, tk, owner)
    {
        self.SwitchBaseStatement(start, owner);
        self.condition = parseExpr(tk, self);
        var t = tk.get();
        if (! t.isop(')'))
            Expected("')' in switch", t);
        t = tk.get();
        if (! t.isop('{'))
            Expected("'{' in switch", t);
        self.parse_cases(tk);
    }
    function optimize()
    {
        self.condition = self.condition.optimize();
        self.optimize_cases();
        return self;
    }
    function emit(e)
    {
        // Get case common type
        string type = '';
        for (var value in self.case_value) {
            string t = value.checkresult();
            if (t == REGfloat)
                SyntaxError("Invalid type in case", self);
            if (type == '')
                type = t;
            else if (type != t)
                type = REGvar;
        }
        // Evaluate condition
        var condition = self.condition;
        var condtype = condition.checkresult();

        // This can happen if there isn't any case. Not likely in hand
        // written code but allowing it may simplify code generators.
        if (type == '')
            type = condtype;

        e.comment('switch');
        string reg = self.tempreg(type);
        if (condtype == type)
            condition.emit(e, reg);
        else {
            string regcond = condition.emit_get(e);
            e.emitset(reg, regcond);
        }

        // Prpeare labels and check values
        self.genbreaklabel();
        string defaultlabel = self.genlabel();
        string caselabel[];
        string regval = self.tempreg(type);
        for (var caseval in self.case_value) {
            string label = self.genlabel();
            push(caselabel, label);
            caseval.emit(e, regval);
            e.say(INDENT, 'if ', reg, ' == ', regval, ' goto ', label);
        }
        e.emitgoto(defaultlabel);

        // Emit cases
        self.annotate(e);
        var case_st = self.case_st;
        int n = case_st;
        for (int i = 0; i < n; ++i) {
            e.emitlabel(caselabel[i], 'case');
            emit_array(e, case_st[i]);
        }
        // Emit default
        e.emitlabel(defaultlabel, 'default');
        emit_array(e, self.default_st);

        e.emitlabel(self.getbreaklabel(self.start), 'switch end');
    }
}

//*********************************************
//            SwitchCaseStatement
//*********************************************

class SwitchCaseStatement : SwitchBaseStatement
{

    function SwitchCaseStatement(start, tk, owner)
    {
        self.SwitchBaseStatement(start, owner);
        self.parse_cases(tk);
    }
    function optimize()
    {
        self.optimize_cases();
        return self;
    }
    function emit(e)
    {
        // Prpeare labels and check values
        self.genbreaklabel();
        string defaultlabel = self.genlabel();
        string caselabel[];

        e.comment('switch-case');
        string reg = self.tempreg(REGint);
        for (var caseval in self.case_value) {
            string label = self.genlabel();
            push(caselabel, label);
            caseval.emit(e, reg);
            e.say(INDENT, 'if ', reg, ' goto ', label);
        }
        e.emitgoto(defaultlabel);

        // Emit cases
        self.annotate(e);
        var case_st = self.case_st;
        int n = case_st;
        for (int i = 0; i < n; ++i) {
            e.emitlabel(caselabel[i], 'case');
            emit_array(e, case_st[i]);
        }
        // Emit default
        e.emitlabel(defaultlabel, 'default');
        emit_array(e, self.default_st);

        e.emitlabel(self.getbreaklabel(self.start), 'switch end');
    }
}

//*********************************************

function parseSwitch(start, tk, owner)
{
    var t = tk.get();
    if (t.isop('('))
        return new SwitchStatement(start, tk, owner);
    if (t.isop('{'))
        return new SwitchCaseStatement(start, tk, owner);
    Expected("'(' in switch", t);
}

//*********************************************
//            ForStatement
//*********************************************

class ForStatement : LoopStatement, BlockStatement, ConditionalStatement
{
    var initializer;
    var iteration;

    function ForStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        var t = tk.get();
        if (! t.isop(';')) {
            tk.unget(t);
            self.initializer = parseStatement(tk, self);
        }
        t = tk.get();
        if (! t.isop(';')) {
            tk.unget(t);
            self.parseconditionshort(tk);
            ExpectOp(';', tk);
        }
        t = tk.get();
        if (! t.isop(')')) {
            tk.unget(t);
            self.iteration = parseExpr(tk, self);
            ExpectOp(')', tk);
        }
        self.parsebody(tk);
    }
    function optimize()
    {
        var initializer = self.initializer;
        if (initializer != null)
            self.initializer = initializer = initializer.optimize();
        if (self.condexpr != null) {
            self.optimize_condition();
            if (self.getvalue() == CONDisfalse) {
                if (initializer != null)
                    return initializer;
                else
                    return new EmptyStatement;
            }
        }
        if (self.iteration != null)
            self.iteration = self.iteration.optimize();
        self.body = self.body.optimize();
        return self;
    }
    function emit(e)
    {
        if (self.initializer == null &&
                self.condexpr == null &&
                self.iteration == null) {
            self.emit_infinite(e);
            return;
        }
        e.comment('for loop');
        string continuelabel = self.gencontinuelabel();
        string breaklabel = self.genbreaklabel();
        string condlabel = self.genlabel();
        if (self.initializer != null)
            self.initializer.emit(e);

        e.emitlabel(condlabel, 'for condition');
        if (self.condexpr != null)
            self.emit_else(e, breaklabel);

        self.body.emit(e);
        e.emitlabel(continuelabel, 'for iteration');
        if (self.iteration != null)
            string unused = self.iteration.emit_get(e);
        e.emitgoto(condlabel);

        e.emitlabel(breaklabel, 'for end');
    }
}

//*********************************************
//            ForeachStatement
//*********************************************

class ForeachStatement : LoopStatement, BlockStatement
{
    var deftype;
    var varname;
    var container;

    function ForeachStatement(start, tk, owner, name, string type)
    {
        self.Statement(start, owner);
        string sname = name;
        if (type != '') {
            string deftype = typetoregcheck(type);
            self.createvar(sname, deftype);
            self.deftype = deftype;
        }
        self.varname = name;
        self.container = parseExpr(tk, self);
        ExpectOp(')', tk);
        self.parsebody(tk);
    }
    function optimize()
    {
        var container = self.container.optimize();

        // Optimize out iterating on compile time eveluated
        // null values and empty strings.
        if (container.isnull() ||
                (container.isstringliteral() &&
                length(container.get_value()) == 0))
            return new EmptyStatement;

        self.container = container;
        self.body = self.body.optimize();
        return self;
    }
    function emit(e)
    {
        self.annotate(e);
        string regcont;
        if (self.container.checkresult() == REGstring) {
            string value = self.container.emit_get(e);
            regcont = self.tempreg(REGvar);
            e.emitbox(regcont, value);
        }
        else
            regcont = self.container.emit_get(e);

        var itvar = self.getvar(self.varname);
        if (itvar == null)
            UndefinedVariable(self.varname);

        string iterator = self.createreg(REGvar);
        string continuelabel = self.gencontinuelabel();
        string breaklabel = self.genbreaklabel();
        e.emitif_null(regcont, breaklabel);
        e.emitarg2('iter', iterator, regcont);
        e.emitset(iterator, '0');
        e.emitlabel(continuelabel, 'for iteration');
        e.emitunless(iterator, breaklabel);
        e.emitarg2('shift', itvar.getreg(), iterator);
        self.body.emit(e);
        e.emitgoto(continuelabel);
        e.emitlabel(breaklabel, 'endfor');
    }
}

//*********************************************

function parseFor(t, tk, owner)
{
    ExpectOp('(', tk);
    var aux = tk.get();
    var in1 = tk.get();
    if (in1.iskeyword('in'))
        return new ForeachStatement(t, tk, owner, aux, '');
    else {
        var in2 = tk.get();
        if (in2.iskeyword('in'))
            return new ForeachStatement(t, tk, owner, in1, aux);
        tk.unget(in2);
        tk.unget(in1);
        tk.unget(aux);
    }
    return new ForStatement(t, tk, owner);
}

//*********************************************
//            ThrowStatement
//*********************************************

class ThrowStatement : Statement
{
    var excep;

    function ThrowStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        self.excep = parseExpr(tk, self);
    }
    function optimize()
    {
        self.excep = self.excep.optimize();
        return self;
    }
    function emit(e)
    {
        var excep = self.excep;
        string reg = excep.emit_get(e);
        self.annotate(e);
        switch (excep.checkresult()) {
          case REGvar:
            e.emitarg1('throw', reg);
            break;
          case REGstring:
            e.emitarg1('die', reg);
            break;
          default:
            SyntaxError("Invalid throw argument", self);
        }
    }
}

//*********************************************
//            TryStatement
//*********************************************

class TryModifierList : ModifierList
{
    var start;
    function TryModifierList(start, tk, owner)
    {
        self.start = start;
        self.ModifierList(tk, owner);
    }
    function emitmodifiers(e, string reghandler)
    {
        var modiflist = self.getlist();
        for (var modif in modiflist) {
            string modifname = modif.getname();
            int nargs = modif.numargs();
            switch (modifname) {
              case 'min_severity':
              case 'max_severity':
                if (nargs != 1)
                    SyntaxError('Wrong modifier args', self);
                var arg = modif.getarg(0);
                string argreg = arg.emit_get(e);
                e.say(INDENT, reghandler, ".'", modifname, "'(", argreg, ")");
                break;
              case 'handle_types':
              case 'handle_types_except':
                string argregs [];
                for (int i = 0; i < nargs; ++i) {
                    var arg = modif.getarg(i);
                    push(argregs, arg.emit_get(e));
                }
                e.say(INDENT, reghandler, ".'", modifname,
                        "'(", join(', ', argregs), ")");
                break;
              default:
                SyntaxError("Modifier '" + modifname + "' not valid for try", self);
            }
        }
    }
}

class TryStatement : BlockStatement
{
    var stry;
    var modifiers;
    var exname;
    var scatch;

    function TryStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        var t = tk.get();
        if (t.isop('['))
            self.modifiers = new TryModifierList(t, tk, self);
        else
            tk.unget(t);

        self.stry = parseStatement(tk, self);
        t = tk.get();
        if (! t.iskeyword('catch'))
            ExpectedOp('catch', t);
        t = tk.get();
        if (! t.isop('('))
            Expected("'(' after 'catch'", t);
        t = tk.get();
        if (! t.isop(')')) {
            string exname = t.getidentifier();
            self.exname = t;
            self.createvar(exname, REGvar);
            t = tk.get();
            if (! t.isop(')'))
                Expected("')' in 'catch'", t);
        }
        self.scatch = parseStatement(tk, self);
    }
    function optimize()
    {
        if (self.modifiers != null)
            self.modifiers.optimize();
        self.stry = self.stry.optimize();
        self.scatch = self.scatch.optimize();
        return self;
    }
    function emit(e)
    {
        string reghandler = self.tempreg(REGvar);
        string labelhandler = self.genlabel();
        string labelpasthandler = self.genlabel();
        string exreg = self.exname != null ?
            self.getvar(self.exname).getreg() :
            self.tempreg(REGvar);

        self.annotate(e);
        e.comment('try: create handler');

        e.say(INDENT, 'new ', reghandler, ", 'ExceptionHandler'");
        e.say(INDENT, 'set_label ', reghandler, ', ', labelhandler);

        if (self.modifiers != null)
            self.modifiers.emitmodifiers(e, reghandler);

        e.emitarg1('push_eh', reghandler);
        e.comment('try: begin');
        self.stry.emit(e);
        e.comment('try: end');
        e.say(INDENT, 'pop_eh');

        self.annotate(e);
        e.emitgoto(labelpasthandler);

        e.comment('catch');
        e.emitlabel(labelhandler);
        e.say(INDENT, '.get_results(', exreg, ')');
        e.emitarg1('finalize', exreg);
        e.say(INDENT, 'pop_eh');
        self.scatch.emit(e);

        e.comment('catch end');
        e.emitlabel(labelpasthandler);
    }
}

//*********************************************
//            VarBaseStatement
//*********************************************

class VarBaseStatement : Statement
{
    var name;
    var reg;
    function initvarbase(start, owner, name, int flags[optional])
    {
        self.Statement(start, owner);
        self.name = name;
        var vdata = self.createvar(name, REGvar, flags);
        self.reg = vdata.getreg();
    }
}

//*********************************************
//            Declare Statements
//*********************************************

class DeclareBase : Statement
{
    var name;
    var basetype;
    var reg;

    function DeclareBase(start, owner, name, string basetype)
    {
        self.Statement(start, owner);
        self.name = name;
        self.basetype = basetype;
    }
}

//*********************************************

class DeclareSingleStatement : DeclareBase
{
    var init;

    function DeclareSingleStatement(start, owner, name, string basetype, tk)
    {
        self.DeclareBase(start, owner, name, basetype);
        var vdata = self.createvar(self.name, self.basetype);
        self.reg = vdata.getreg();
        var t = tk.get();
        if (t.isop('=')) {
            // Simple initializer
            self.init = parseExpr(tk, self);
        }
        else
            tk.unget(t);
    }
    function optimize()
    {
        var init = self.init;
        if (init != null)
            self.init = init.optimize();
        return self;
    }
    function emit(var e)
    {
        self.annotate(e);
        string name = self.name;
        string reg = self.reg;
        string basetype = self.basetype;
        var init = self.init;
        e.comment(name + ': ' + reg);

        if (init == null || init.isnull())
            e.emitnull(reg);
        else {
            string itype = init.checkresult();
            if (itype == basetype)
                init.emit(e, reg);
            else {
                if (init instanceof IndexExpr) {
                    // Use the declared type for the indexing
                    init.emit(e, reg);
                }
                else {
                    string ireg;
                    switch (itype) {
                      case REGnone:
                        SyntaxError('Invalid initialization from void value', self);
                      case '':
                        ireg = init.emit_get(e);
                        break;
                      default:
                        ireg = self.tempreg(itype);
                        init.emit(e, ireg);
                    }
                    if (basetype == REGstring && itype == REGvar) {
                        string auxlabel = self.genlabel();
                        e.emitnull(reg);
                        e.emitif_null(ireg, auxlabel);
                        e.emitset(reg, ireg);
                        e.emitlabel(auxlabel);
                    }
                    else
                        e.emitset(reg, ireg);
                }
            }
        }
    }
}

//*********************************************

class DeclareArrayStatement : DeclareBase
{
    var size;
    var initarray;
    var arraytype;

    function DeclareArrayStatement(start, owner,
            name, string basetype, string arraytype,
            tk)
    {
        self.DeclareBase(start, owner, name, basetype);
        self.arraytype = arraytype;
        var vdata = self.createvar(self.name, REGvar);
        self.reg = vdata.getreg();
        var t = tk.get();
        if (! t.isop(']')) {
            // Fixed length
            tk.unget(t);
            self.size = parseExpr(tk, self);
            ExpectOp(']', tk);
        }
        t = tk.get();
        if (t.isop('=')) {
            t = tk.get();
            if (! t.isop('['))
                Expected("array initializer", t);
            t = tk.get();
            if (! t.isop(']')) {
                tk.unget(t);
                self.initarray = parseList(tk, self, parseExpr, ']');
            }
        }
        else
            tk.unget(t);
    }
    function optimize()
    {
        if (self.size != null)
            self.size = self.size.optimize();
        optimize_array(self.initarray);
        return self;
    }
    function emit(e)
    {
        self.annotate(e);

        var reg = self.reg;
        var size = self.size;
        var init = self.initarray;
        var basetype = self.basetype;
        string arraytype = string(self.arraytype) + 'Array';
        if (size != null) {
            // Fixed size array
            string regsize = size.emit_get(e);
            e.say(INDENT, 'new ', reg, ", ['Fixed", arraytype, "'], ", regsize);
        }
        else {
            // Variable size array
            e.say(INDENT, 'new ', reg, ", ['Resizable", arraytype, "']");
        }
        if (init != null) {
            string itemreg = self.tempreg(basetype);
            int n = elements(init);
            if (size == null) {
                if (n > 0) {
                    // Allocate initializers size
                    e.emitset(reg, n);
                }
            }
            int i = 0;
            for (var item in init) {
                item.emit(e, itemreg);
                e.say(INDENT, reg, '[', i , '] = ', itemreg);
                ++i;
            }
        }
    }
}

//*********************************************

function parseDeclareHelper(funsingle, funarray, start, tk, owner)
{
    var next;
    var r = null;
    do {
        var name = tk.get();
        RequireIdentifier(name);
        var t = tk.get();
        var item;
        if (t.isop('['))
            item = funarray(start, owner, tk, name);
        else {
            tk.unget(t);
            item = funsingle(start, owner, name, tk);
        }
        r = addtomulti(r, item);
        next = tk.get();
    } while (next.isop(','));
    RequireOp(';', next);
    return r;
}

//*********************************************

class IntStatement : DeclareSingleStatement
{
    function IntStatement(start, owner, name, tk)
    {
        self.DeclareSingleStatement(start, owner, name, REGint, tk);
    }
}

class IntArrayStatement : DeclareArrayStatement
{
    function IntArrayStatement(start, owner, name, tk)
    {
        self.DeclareArrayStatement(start, owner, name, REGint, 'Integer', tk);
    }
}


function newIntSingle(start, owner, name, tk)
{
    return new IntStatement(start, owner, name, tk);
}

function newIntArray(start, owner, tk, name)
{
    return new IntArrayStatement(start, owner, name, tk);
}

function parseInt(start, tk, owner)
{
    return parseDeclareHelper(newIntSingle, newIntArray, start, tk, owner);
}

//*********************************************

class FloatStatement : DeclareSingleStatement
{
    function FloatStatement(start, owner, name, tk)
    {
        self.DeclareSingleStatement(start, owner, name, REGfloat, tk);
    }
}

class FloatArrayStatement : DeclareArrayStatement
{
    function FloatArrayStatement(start, owner, name, tk)
    {
        self.DeclareArrayStatement(start, owner, name, REGfloat, 'Float', tk);
    }
}


function newFloatSingle(start, owner, name, tk)
{
    return new FloatStatement(start, owner, name, tk);
}

function newFloatArray(start, owner, tk, name)
{
    return new FloatArrayStatement(start, owner, name, tk);
}

function parseFloat(start, tk, owner)
{
    return parseDeclareHelper(newFloatSingle, newFloatArray, start, tk, owner);
}

//*********************************************

class StringStatement : DeclareSingleStatement
{
    function StringStatement(start, owner, name, tk)
    {
        self.DeclareSingleStatement(start, owner, name, REGstring, tk);
    }
}

class StringArrayStatement : DeclareArrayStatement
{
    function StringArrayStatement(start, owner, name, tk)
    {
        self.DeclareArrayStatement(start, owner, name, REGstring, 'String', tk);
    }
}


function newStringSingle(start, owner, name, tk)
{
    return new StringStatement(start, owner, name, tk);
}

function newStringArray(start, owner, tk, name)
{
    return new StringArrayStatement(start, owner, name, tk);
}

function parseString(start, tk, owner)
{
    return parseDeclareHelper(newStringSingle, newStringArray, start, tk, owner);
}

//*********************************************
//            ConstStatement
//*********************************************

class ConstStatement : Statement
{
    var type;
    var name;
    var data;
    var value;

    function ConstStatement(var start, var owner,
            string type, var name, var value)
    {
        self.Statement(start, owner);
        self.type = type;
        self.name = name;
        self.value = value;
        self.data = self.createconst(name, type);
    }
    function optimize()
    {
        var value = self.value;
        var name = self.name;
        string type = self.type;
        value = value.optimize();
        if (! value.hascompilevalue()) {
            SyntaxError('Value for const is not evaluable at compile time',
                self);
        }
        self.data.setvalue(value);
        return self;
    }
    function checkresult()
    {
        InternalError('Direct use of const', self.start);
    }
    function emit(e)
    {
        e.comment('Constant ' + string(self.name) + ' evaluated at compile time');
    }
}

function parseConst(start, tk, owner)
{
    var t = tk.get();
    string type = typetoregcheck(t);
    if (type != REGint && type != REGfloat && type != REGstring)
        SyntaxError('Invalid type for const', start);

    var multi = null;
    do {
        t = tk.get();
        var name = t;
        ExpectOp('=', tk);
        var value = parseExpr(tk, owner);
        multi = addtomulti(multi,
                new ConstStatement(t, owner, type, name, value));
    } while ((t = tk.get()).isop(','));
    return multi;
}

//*********************************************
//            VarStatement
//*********************************************

class VarStatement : VarBaseStatement
{
    var init;
    function VarStatement(start, tk, owner, name, int flags)
    {
        self.initvarbase(start, owner, name, flags);
        var t = tk.get();
        if (t.isop('=')) {
            self.init = parseExpr(tk, self);
            t = tk.get();
        }
        RequireOp(';', t);
    }
    function optimize_init()
    {
        if (self.init != null)
            self.init = self.init.optimize();
        return self;
    }
    function optimize()
    {
        return self.optimize_init();
    }
    function emit(var e)
    {
        self.annotate(e);
        string name =  self.name;
        string reg = self.reg;
        var init = self.init;
        e.comment('var ' + name + ': ' + reg);
        if (init != null)
            if (init.isnull())
                init = null;
        if (init != null) {
            switch (init.checkresult()) {
              case REGvar:
                if ((init instanceof MemberExpr) || (init instanceof ArrayExpr) || (init instanceof NewExpr))
                    init.emit_init(e, reg);
                else
                    init.emit(e, reg);
                break;
              case REGstring:
              case REGint:
              case REGfloat:
                string value = init.emit_get(e);
                e.emitbox(reg, value);
                break;
              case REGnone:
                SyntaxError("Can't use void function as initializer", self.name);
              default:
                SyntaxError("Invalid var initializer", self.name);
            }
        }
        else
            e.emitnull(reg);
    }
}

class ResizableVarStatement : VarStatement
{
    function ResizableVarStatement(start, tk, owner, name)
    {
        self.initvarbase(start, owner, name);
        ExpectOp(';', tk);
    }
    function emit(var e)
    {
        self.annotate(e);
        string reg = self.reg;
        e.comment('var ' + string(self.name) + '[] : ' + reg);
        e.say(INDENT, 'new ', reg, ", 'ResizablePMCArray'");
    }
}

class FixedVarStatement : VarStatement
{
    var exprsize;

    function FixedVarStatement(start, tk, owner, name)
    {
        self.initvarbase(start, owner, name);
        self.exprsize = parseExpr(tk, self);
        ExpectOp(']', tk);
        ExpectOp(';', tk);
    }
    function optimize()
    {
        self.exprsize = self.exprsize.optimize();
        return self.optimize_init();
    }
    function emit(var e)
    {
        string regsize = self.exprsize.emit_get(e);
        self.annotate(e);
        string reg = self.reg;
        e.comment('var ' + string(self.name) + '[] : ' + reg);
        e.say(INDENT, 'new ', reg, ", 'FixedPMCArray', ", regsize);
    }
}

function parseVar(start, tk, owner, int flags[optional])
{
    var name = tk.get();
    RequireIdentifier(name);
    var t = tk.get();
    if (t.isop('[')) {
        t = tk.get();
        if (t.isop(']'))
            return new ResizableVarStatement(start, tk, owner, name);
        else {
            tk.unget(t);
            return new FixedVarStatement(start, tk, owner, name);
        }
    }
    else {
        tk.unget(t);
        return new VarStatement(start, tk, owner, name, flags);
    }
}

function parseVolatile(start, tk, owner)
{
    var t = tk.get();
    if (!t.iskeyword('var'))
        SyntaxError("invalid volatile type", t);
    return parseVar(start, tk, owner, VAR_is_volatile);
}

//*********************************************
//            CompoundStatement
//*********************************************

class CompoundStatement : MultiStatementBase, BlockStatement
{
    var end;
    var labels;

    function CompoundStatement(start, tk, owner)
    {
        self.Statement(start, owner);
        self.labels = {};
        self.statements = [];
        var t;
        while (! (t = tk.get()).isop('}')) {
            tk.unget(t);
            var c = parseStatement(tk, self);
            if (c == null)
                InternalError('Unexpected null statement');
            push(self.statements, c);
        }
        self.end = t;
    }
    function getlabel(var name)
    {
        string s = name;
        var labels = self.labels;
        string exist = labels[s];
        if (exist == null || exist == '')
            exist = self.owner.getlabel(name);
        return exist;
    }
    function createlabel(var name)
    {
        string s = name;
        var labels = self.labels;
        string exist = labels[s];
        if (exist != null && exist != '')
            SyntaxError('Label already defined', name);
        string value = self.genlabel();
        labels[s] = value;
        return value;
    }
    function getend() { return self.end; }
    function emit(var e)
    {
        e.comment('{');
        for (var st in self.statements) {
            st.emit(e);
            self.freetemps();
        }
        e.comment('}');
    }
}

//*********************************************
//            RegisterStore
//*********************************************

class RegisterStore
{
    var type;
    var nreg;
    var tempreg;
    var freereg;
    function RegisterStore(string type)
    {
        self.type = type;
        // Registers number 0 are reserved for temporary usage in predefs.
        self.nreg = 1;
        string tempreg[];
        string freereg[];
        self.tempreg = tempreg;
        self.freereg = freereg;
    }
    function createreg()
    {
        var n = self.nreg;
        int i = n;
        string reg = i++;
        n =: i;
        return '$' + string(self.type) + reg;
    }
    function tempreg()
    {
        var freereg = self.freereg;
        var tempreg = self.tempreg;
        string reg;
        if (elements(freereg) > 0)
            reg = freereg.pop();
        else
            reg = self.createreg();
        push(tempreg, reg);
        return reg;
    }
    function freetemps()
    {
        var freereg = self.freereg;
        var tempreg = self.tempreg;
        int n = elements(tempreg);
        for (int i = n - 1; i >= 0; --i) {
            string s = tempreg[i];
            push(freereg, s);
        }
        tempreg =: 0;
    }
}

//*********************************************
//            FunctionParameter
//*********************************************

class ParameterModifierList : ModifierList
{
    function ParameterModifierList(tk, owner)
    {
        self.ModifierList(tk, owner);
    }
    function emitmodifiers(e, start, string paramname)
    {
        var named = null;
        var slurpy = null;
        var modarglist = self.getlist();
        for (var mod in modarglist) {
            string modname = mod.getname();
            switch (modname) {
              case 'named':
                named = mod;
                break;
              case 'slurpy':
                slurpy = mod;
                break;
              default:
                e.print(' :', modname);
            }
        }
        switch {
          case named != null && slurpy != null:
            // Special case for named slurpy: named refers
            // to the slurpy content, not to the param himself.
            // TODO: check that named has no arguments,
            // or use a different way.
            e.print(" :named :slurpy");
            break;
          case named != null:
            string setname;
            switch (named.numargs()) {
              case 0:
                setname = "'" + paramname + "'";
                break;
              case 1:
                var argmod = named.getarg(0);
                if (! argmod.isstringliteral())
                    SyntaxError('Invalid modifier', start);
                setname = argmod.getPirString();
                break;
              default:
                SyntaxError('Invalid modifier', start);
            }
            e.print(" :named(", setname, ")");
            break;
          case slurpy != null:
            e.print(" :slurpy");
            break;
        }
    }
}

class FunctionParameter
{
    var func;
    var name;
    var modifiers;
    function FunctionParameter(func, tk)
    {
        self.func = func;
        var t = tk.get();
        string type = typetoregcheck(t.checkkeyword());
        if (type != '')
            t = tk.get();
        else
            type = REGvar;
        string argname = '__ARG_' + string(func.getparamnum());
        func.createvarnamed(t, type, argname);

        self.name = string(t);
        t = tk.get();
        if (t.isop('['))
            self.modifiers = new ParameterModifierList(tk, func.owner);
        else
            tk.unget(t);
    }
    function emit(e)
    {
        var func = self.func;
        string paramname = self.name;
        var param = func.getvar(paramname);
        string ptype = typetopirname(param.gettype());
        e.print(INDENT + INDENT + '.param ', ptype, ' ', param.getreg());
        var modarg = self.modifiers;
        if (modarg != null)
            modarg.emitmodifiers(e, func.start, paramname);
        e.say('');
    }
}

function parseParameter(tk, owner)
{
    return new FunctionParameter(owner, tk);
}

//*********************************************
//            FunctionExtern
//*********************************************

class FunctionExtern : CommonBase
{
    var name;
    function FunctionExtern(start, owner)
    {
        self.initbase(start, owner);
        self.name = start;
    }
    function emit_get(e, owner)
    {
        var ns = self.owner;
        var path = ns.getpath();
        string key;
        if (elements(path) > 0)
             key = getparrotkey(path);
        string reg = owner.tempreg(REGvar);
        e.emitget_hll_global(reg, self.name, key);
        return reg;
    }
}

//*********************************************
//            FunctionBase
//*********************************************

class FunctionModifierList : ModifierList
{
    function FunctionModifierList(var tk, var owner)
    {
        self.ModifierList(tk, owner);
    }
    function emit(e)
    {
        for (var m in self.getlist()) {
            int nargmods = m.numargs();
            e.print(' :', m.getname());
            if (nargmods > 0) {
                e.print('(');
                for (int iargmod = 0; iargmod < nargmods; ++iargmod) {
                    var argmod = m.getarg(iargmod);
                    if (!argmod.isstringliteral())
                        SyntaxError('Invalid modifier', argmod);
                    e.print(argmod.getPirString());
                }
                e.print(')');
            }
        }
    }
}

class FunctionBase : BlockStatement
{
    var name;
    var subid;
    var modifiers;
    var params;
    var body;
    var regstI;
    var regstN;
    var regstS;
    var regstP;
    var nlabel;
    var localfun;
    var lexicals;
    var usedlexicals;
    var usedsubids;
    var outer;

    function FunctionBase(start, owner)
    {
        self.Statement(start, owner);
        self.nlabel = 0;
        self.regstI = new RegisterStore(REGint);
        self.regstN = new RegisterStore(REGfloat);
        self.regstS = new RegisterStore(REGstring);
        self.regstP = new RegisterStore(REGvar);
    }

    function getouter() { return self; }
    function makesubid()
    {
        // Return the subid for this function, creating if it doesn't have one
        var subid = self.subid;
        if (subid == null)
            self.subid = subid = self.generatesubid();
        return subid;
    }
    function usesubid(string id)
    {
        var used = self.usedsubids;
        if (used == null)
            self.usedsubids = used = {};
        used[id] = 1;
    }

    function same_scope_as(other)
    {
        int r = self === other;
        return r;
    }
    function parse_parameters(tk)
    {
        var t = tk.get();
        if (! t.isop(')')) {
            tk.unget(t);
            self.params = parseList(tk, self, parseParameter, ')');
        }
    }

    function addlocalfunction(fn)
    {
        var localfun = self.localfun;
        if (localfun == null)
            self.localfun = [ fn ];
        else
            push(localfun, fn);
    }
    function usenamespace(ns)
    {
        var usedns = self.usednamespaces;
        if (usedns == null) {
            //cry('use namespace ', ns.name);
            self.usednamespaces = [ ns ];
        }
        else {
            for (var used in usedns)
                if (ns === used)
                    return;
            push(usedns, ns);
        }
    }
    function findsymbol(key)
    {
        var found;
        for (var ns in self.usednamespaces) {
            found = ns.findsymbol(key);
            if (found != null)
                return found;
        }
        return self.owner.findsymbol(key);
    }

    function optimize()
    {
        for (var used in self.usednamespaces)
            used.fixnamespaces();
        self.body = self.body.optimize();
        return self;
    }

    function setusedlex(string lexname, string localname)
    {
        var lexicals = self.usedlexicals;
        if (lexicals == null)
            self.usedlexicals = lexicals = {};
        lexicals[localname] = lexname;
    }
    function setlex(string lexname, string localname)
    {
        var lexicals = self.lexicals;
        if (lexicals == null)
            self.lexicals = lexicals = {};
        lexicals[localname] = lexname;
    }
    function createlex(vardata)
    {
        // Get the lexname for a variable, creating it on the fly
        // when needed.
        var lex = vardata.getlex();
        string lexname;
        if (lex != null)
            lexname = lex;
        else {
            string reg = vardata.getreg();
            int lexnum = self.getlexnum();
            lexname = '__WLEX_' + string(lexnum);
            self.setlex(lexname, reg);
            vardata.setlex(lexname);
        }
        return lexname;
    }

    function createreg(string type)
    {
        var store;
        switch (type) {
          case REGint:
            store = self.regstI; break;
          case REGfloat:
            store = self.regstN; break;
          case REGstring:
            store = self.regstS; break;
          case REGvar:
            store = self.regstP; break;
          default:
            InternalError('Invalid type in createreg: ' + type);
        }
        string reg = store.createreg();
        return reg;
    }
    function tempreg(string type)
    {
        var store;
        switch (type) {
          case REGint:
            store = self.regstI; break;
          case REGfloat:
            store = self.regstN; break;
          case REGstring:
            store = self.regstS; break;
          case REGvar:
            store = self.regstP; break;
          default:
            InternalError("Invalid type '" + type + "' in tempreg");
        }
        string reg = store.tempreg();
        return reg;
    }
    function freetemps()
    {
        for (var st in [ self.regstI, self.regstN, self.regstS, self.regstP ] )
            st.freetemps();
    }
    function genlabel()
    {
        int n = ++self.nlabel;
        return '__label_' + string(n);
    }
    function getbreaklabel(pos)
    {
        SyntaxError('break not allowed here', pos);
    }
    function getcontinuelabel(pos)
    {
        SyntaxError('continue not allowed here', pos);
    }

    function emit(var e)
    {
        string name = self.name;
        e.say();
        e.print(".sub ");
        if (self.isanonymous())
            e.print("'' :anon");
        else
            e.print ("'", name, "'");
        if (self.subid != null)
            e.print(" :subid('", self.subid, "')");
        if (self.outer != null) {
            var outer = self.outer;
            var outerid = outer.subid;
            if (outerid != null)
                e.print(" :outer('", outerid, "')");
        }

        // Modifiers
        if (self.ismethod())
            e.print(' :method');
        var modifiers = self.modifiers;
        if (modifiers != null)
            modifiers.emit(e);
        else {
            if (name == 'main')
                e.print(' :main');
        }
        e.say();

        // Parameters
        emit_array(e, self.params);

        var lexicals = self.lexicals;
        var usedlexicals = self.usedlexicals;
        if (lexicals != null || usedlexicals != null) {
            e.annotate(self.start);
            // lexicals declared in this function and its inner scopes
            for (string l in lexicals)
                e.say(".lex '", lexicals[l], "', ", l);
            // lexicals from outers used inside
            for (string l in usedlexicals) {
                if (substr(l, 0, 1) != '$')
                    e.say(INDENT + ".local pmc " + l);
                e.emitfind_lex(l, usedlexicals[l]);
            }
        }

        for (string subid in self.usedsubids) {
            //cry("Used: ", subid, ' in ', name);
            e.say(".const 'Sub' ", subid, ' = "', subid, '"');
        }

        var body = self.body;
        if (body.isempty())
            e.comment('Empty body');
        else {
            e.comment('Body');
            body.emit(e);
            e.annotate(body.getend());
        }
        e.say("\n.end # ", name, "\n");

        // Local functions
        for (var fn in self.localfun)
            fn.emit(e);
    }
}

//*********************************************
//            FunctionStatement
//*********************************************

class FunctionStatement : FunctionBase
{
    var paramnum;
    var lexnum;

    function FunctionStatement(start, tk, owner)
    {
        self.FunctionBase(start, owner);
        self.paramnum = 0;
        self.lexnum = 0;
        self.parse(tk);
    }

    function isanonymous() { return false; }
    function getparamnum()
    {
        // Get a number to assign unique internal names to params.
        return int(++self.paramnum);
    }
    function getlexnum()
    {
        // Get a number to assign unique internal names to lexicals.
        return int(++self.lexnum);
    }
    function ismethod() { return false; }

    function parse(tk)
    {
        var name = tk.get();
        self.name = name;
        var t = tk.get();
        if (t.isop('[')) {
            self.modifiers = new FunctionModifierList(tk, self.owner);
            t = tk.get();
        }
        RequireOp('(', t);
        self.parse_parameters(tk);

        var fullname = clone(self.owner.getpath());
        push(fullname, name.getidentifier());
        createPredefConstString(self, '__FUNCTION__', join('.', fullname));

        t = tk.get();
        if (!t.isop('{'))
            ExpectedOp('{', t);
        self.body = new CompoundStatement(t, tk, self);
        return self;
    }
}

//*********************************************
//            LocalFunctionStatement
//*********************************************

class LocalFunctionStatement : FunctionBase
{
    function LocalFunctionStatement(start, tk, owner)
    {
        self.FunctionBase(start, owner);
        self.outer = owner.getouter();
        self.outer.makesubid();
        var subid = self.makesubid();
        self.name = subid;
        self.parse_parameters(tk);
        var t = tk.get();
        RequireOp('{', t);
        self.body = new CompoundStatement(t, tk, self);
        owner.addlocalfunction(self);
    }
    function isanonymous() { return true; }
    function ismethod() { return false; }
    function needclosure()
    {
        if (self.lexicals != null || self.usedlexicals != null)
            return true;
        for (var fn in self.localfun)
            if (fn.needclosure())
                return true;
        return false;
    }
    function getsubid()
    {
        return self.subid;
    }
    function getparamnum()
    {
        // Forward to the outer to avoid duplicate names.
        return self.outer.getparamnum();
    }
    function getlexnum()
    {
        // Forward to the outer to avoid duplicate names.
        return self.outer.getlexnum();
    }
    function checkvarlexical(name, data)
    {
        if (data.isconst())
            return data;
        string reg = data.getreg();
        //TEMPORARY WORKAROUND
        if (substr(reg, 0, 6) == 'WSubId')
            return data;
        var scope = data.getscope();
        var ownerscope = scope.getouter();
        var outer = self.outer;
        if (ownerscope instanceof FunctionBase) {
            if (ownerscope.same_scope_as(outer)) {
                string lexname = scope.makelexical(data);
                int flags = data.getflags() | VAR_is_lexical;
                string type = data.gettype();
                if (type != REGvar)
                    flags = flags | VAR_is_volatile;
                var lexused = self.createvar(name, data.gettype(), flags);
                lexused.lexname = lexname;
                self.setusedlex(lexname, lexused.getreg());
                return lexused;
            }
        }
        return data;
    }
    function getvar(name)
    {
        var r = self.getlocalvar(name);
        if (r == null)
            r = self.getusedvar(name);
        if (r == null) {
            // Not found in function scope, search external scopes
            // and check lexicals.
            r = self.owner.getvar(name);
            if (r == null) {
                // Special case for self in methods
                if (name == SELF) {
                    var ownerscope = self.outer;
                    if (self.outer.ismethod()) {
                        string lexself = ownerscope.makelexicalself();
                        r = self.createvar(name, REGvar);
                        string reg = r.getreg();
                        self.setusedlex(lexself, reg);
                    }
                }
            }
            else r = self.checkvarlexical(name, r);
        }
        if (r != null && !(r instanceof VarData))
            InternalError('Incorrect data for variable in LocalFunction');
        return r;
    }
}

//*********************************************
//            MethodStatement
//*********************************************

class MethodStatement : FunctionStatement
{
    function MethodStatement(t, tk, owner)
    {
        self.FunctionStatement(t, tk, owner);
    }
    function ismethod() { return true; }
}

//*********************************************
//            MultiAssignStatement
//*********************************************

class SigParameter
{
    var name;
    var modifiers;
    var reg;
    function SigParameter(tk, owner)
    {
        var name = tk.get();
        if (! name.isidentifier())
            ExpectedIdentifier(name);
        var t = tk.get();
        if (t.isidentifier()) {
            string type = typetoregcheck(name.checkkeyword());
            name = t;
            owner.createvar(name, type);
            t = tk.get();
        }
        self.name = name;
        var data = owner.getvar(name.getidentifier());
        self.reg = data.getreg();
        if (t.isop('['))
            self.modifiers = new ParameterModifierList(tk, self);
        else
            tk.unget(t);
    }
    function emit(e)
    {
        e.print(self.reg);
        var modifiers = self.modifiers;
        if (modifiers != null) {
            var name = self.name;
            modifiers.emitmodifiers(e, name, name);
        }
    }
}

function parseSigParameter(tk, owner)
{
    return new SigParameter(tk, owner);
}

class SigParameterList
{
    var params;
    function SigParameterList(tk, owner)
    {
        self.params = parseList(tk, owner, parseSigParameter, ')');
    }
    function emit(e)
    {
        e.print('(');
        string sep = '';
        for (var param in self.params) {
            e.print(sep);
            param.emit(e);
            sep = ', ';
        }
        e.print(')');
    }
}

class MultiAssignStatement : Statement
{
    var params;
    var expr;
    function MultiAssignStatement(start, owner, params, expr)
    {
        self.Statement(start, owner);
        self.params = params;
        self.expr = expr;
    }
    function optimize()
    {
        self.expr = self.expr.optimize();
        return self;
    }
    function emit(e)
    {
        var expr = self.expr;
        if (! (expr instanceof CallExpr))
            SyntaxError('multi assignment used with non function call', expr);
        var call = expr.emitcall(e);
        expr.prepareargs(e);
        e.print(INDENT);
        self.params.emit(e);
        e.print(' = ', call);
        expr.emitargs(e);
        e.say();
    }
}

//*********************************************
//            Class specifier
//*********************************************

const int
    CLASSSPECIFIER_invalid   = 0,
    CLASSSPECIFIER_str       = 1, // Literal name
    CLASSSPECIFIER_parrotkey = 2, // Parrot key
    CLASSSPECIFIER_id        = 3; // Identifier, maybe qualified

class ClassSpecifier : CommonBase
{
    function ClassSpecifier(owner, start)
    {
        self.initbase(start, owner);
    }
    function reftype() { return CLASSSPECIFIER_invalid; }

    function annotate(e)
    {
        e.annotate(self.start);
    }
}

class ClassSpecifierStr : ClassSpecifier
{
    var name;
    function ClassSpecifierStr(owner, name)
    {
        self.ClassSpecifier(owner, name);
        self.name = name;
    }
    function reftype() { return CLASSSPECIFIER_str; }

    function emit(e, ns)
    {
        string basestr = self.name;
        e.print(basestr);
    }
}

class ClassSpecifierParrotKey : ClassSpecifier
{
    var key;
    var hll;
    function ClassSpecifierParrotKey(tk, owner, start)
    {
        self.ClassSpecifier(owner, start);
        var key = [];
        var t = tk.get();
        if (!t.isstring())
            Expected('literal string', t);
        push(key, t.rawstring());
        t = tk.get();
        if (! t.isop(']')) {
            switch (t.checkop()) {
              case ':':
                self.hll = true;
              case ',':
                break;
              default:
                Unexpected('token in class key', t);
            }
            do {
                t = tk.get();
                if (!t.isstring())
                    Expected('literal string', t);
                push(key, t.rawstring());
            } while ((t = tk.get()).isop(','));
            RequireOp(']', t);
        }
        self.key = key;
    }
    function reftype() { return CLASSSPECIFIER_parrotkey; }
    function hasHLL()
    {
        return int(self.hll != null);
    }

    function emit(e, ns)
    {
        e.print(getparrotkey(self.key));
    }
}

class ClassSpecifierId : ClassSpecifier
{
    var key;
    function ClassSpecifierId(tk, owner, id)
    {
        self.ClassSpecifier(owner, id);
        var key = [ string(id) ];
        var t;
        while ((t = tk.get()).isop('.')) {
            t = tk.get();
            push(key, string(t));
        }
        tk.unget(t);
        self.key = key;
    }
    function reftype() { return CLASSSPECIFIER_id; }

    function last()
    {
        var key = self.key;
        return key[-1];
    }

    function emit(e, ns)
    {
        var key = ns.findclasskey(self.key);
        if (key == null) {
            if (self.dowarnings())
                Warn("class " + join(".", self.key) + " not found at compile time");
            e.print(getparrotkey(self.key));
        }
        else e.print(key.getclasskey());
    }
}

function parseClassSpecifier(tk, owner)
{
    var t = tk.get();
    if (t.isstring())
        return new ClassSpecifierStr(owner, t);
    if (t.isop('['))
        return new ClassSpecifierParrotKey(tk, owner, t);
    if (t.isidentifier())
        return new ClassSpecifierId(tk, owner, t);
    SyntaxError('Invalid class', t);
}

//*********************************************
//            ClassStatement
//*********************************************

class ClassBase : CommonBase
{
    var name;
    var classns;
    function ClassBase(start, name, parent)
    {
        self.initbase(start, parent);
        self.name = name;
        var classns = clone(parent.getpath());
        push(classns, self.name);
        self.classns = classns;
    }
    function getclasskey()
    {
        return getparrotkey(self.classns);
    }
}

class ClassStatement : ClassBase, VarContainer
{
    var parent;
    var bases;
    var constants;
    var functions;
    var members;

    function ClassStatement(start, name, parent, tk)
    {
        self.ClassBase(start, name, parent);
        self.parent = parent;
        var functions = [];
        self.functions = functions;
        var members = [];
        self.members = members;
        var constants = [];
        self.constants = constants;

        var t = tk.get();
        if (t.isop(':')) {
            self.bases = parseList(tk, self, parseClassSpecifier);
            t = tk.get();
        }
        RequireOp('{', t);
        for (t = tk.get(); !t.isop('}'); t = tk.get()) {
            switch (t.checkkeyword()) {
              case 'function':
                var f = new MethodStatement(t, tk, self);
                push(functions, f);
                break;
              case 'var':
                var name = tk.get();
                if (! name.isidentifier())
                   Expected("member identifier", name);
                push(members, name);
                t = tk.get();
                if (! t.isop(';'))
                    Expected("';' in member declaration", t);
                break;
              case 'const':
                var cst = parseConst(t, tk, self);
                push(constants, cst);
                break;
              default:
                Unexpected("item in class", t);
            }
        }
    }
    function getpath()
    {
        return self.classns;
    }
    function generatesubid()
    {
        return self.owner.generatesubid();
    }
    function findsymbol(classkey)
    {
        return self.parent.findsymbol(classkey);
    }
    function findclasskey(classkey)
    {
        return self.parent.findclasskey(classkey);
    }
    function checkclass(string name)
    {
        return self.parent.checkclass(name);
    }
    function use_predef(string name)
    {
        return self.owner.use_predef(name);
    }
    function optimize()
    {
        optimize_array(self.constants);
        optimize_array(self.functions);
        return self;
    }
    function emit(var e)
    {
        var classns = self.classns;
        e.say(getparrotnamespacekey(classns));
        emit_array(e, self.functions);

        e.say('.sub Winxed_class_init :anon :load :init');

        e.say(INDENT, 'newclass $P0, ', self.getclasskey() );
        int n = 1;
        for (var base in self.bases) {
            base.annotate(e);
            string reg = "$P" + n++;
            e.print(INDENT, 'get_class ', reg, ', ');
            base.emit(e, self.parent);
            e.say();
            e.say(INDENT, 'addparent $P0, ', reg);
        }
        for (var member in self.members) {
            e.annotate(member);
            e.say(INDENT, "addattribute $P0, '", member, "'");
        }

        e.say('.end');
    }
}

class DeclareClassStatement : ClassBase
{
    function DeclareClassStatement(start, name, parent)
    {
        self.ClassBase(start, name, parent);
    }
    function optimize()
    {
        return self;
    }
    function emit(e)
    {
    }
}

function parseClass(start, tk, parent)
{
    var name = tk.get();
    var t = tk.get();
    if (t.isop(';') || t.isop('.')) {
        for ( ; t.isop('.'); t = tk.get()) {
            parent = parent.declarenamespace(name, string(name));
            name = tk.get();
        }
        RequireOp(';', t);
        parent.declareclass(new DeclareClassStatement(start, name, parent));
    }
    else {
        tk.unget(t);
        parent.addclass(new ClassStatement(start, name, parent, tk));
    }
}

//*********************************************
//        Namespace classes and functions
//*********************************************

function include_parrot(var start, var tk, var ns)
{
    var t = tk.get();
    if (!t.isstring())
        Expected('literal string', t);
    ExpectOp(';', tk);
    string filename = t.rawstring();
    var interp = getinterp();

    // Search for the file in the parrot include paths
    const int IGLOBALS_LIB_PATHS = 9;
    const int PARROT_LIB_PATH_INCLUDE = 0;
    var libpaths = interp[IGLOBALS_LIB_PATHS];
    var paths = libpaths[PARROT_LIB_PATH_INCLUDE];
    var file = new ['FileHandle'];
    for (string path in paths) {
        string filepath = path + filename;
        try {
            file.open(filepath, 'r');
            break;
        }
        catch () {
        }
    }
    if (file.is_closed())
        SyntaxError('File not found', t);

    // Parse lines like this: .macro_const CONST_NAME value
    // Assume only integer values for a now
    const string MACRO_CONST = '.macro_const';
    for (string line = file.readline(); !file.eof(); line = file.readline()) {
        if (substr(line, 0, length(MACRO_CONST)) == MACRO_CONST) {
            int pos = length(MACRO_CONST);
            string c;
            while ((c = substr(line, pos, 1)) == " " || c == "\t")
                ++pos;
            int pos2 = pos;
            while ((c = substr(line, pos2, 1)) != " " && c != "\t" &&
                    c != "\n" && c != "\r" && c != "")
                ++pos2;
            if (pos2 == pos)
                continue;
            string name = substr(line, pos, pos2 - pos);
            while ((c = substr(line, pos2, 1)) == " " || c == "\t")
                ++pos2;
            pos = pos2;
            while ((c = substr(line, pos2, 1)) != " " && c != "\t" &&
                    c != "\n" && c != "\r" && c != "")
                ++pos2;
            if (pos2 == pos)
                continue;
            string value = substr(line, pos, pos2- pos);

            int ivalue;
            if (substr(value, 0, 2) == '0x' || substr(value, 0, 2) == '0X')
                ivalue = substr(value, 2).to_int(16);
            else
                ivalue = value;
            var cst = ns.createconst(name, REGint, VAR_is_extern);
            cst.setvalue(integerValue(ns,
                    new TokenInteger(start.file, start.line, name), ivalue));
        }
    }

    file.close();
}

//*********************************************

function parsensUsing(start, tk, ns)
{
    var t = tk.get();
    if (t.iskeyword('namespace')) {
        var nskey = parseDotted(tk);
        int nelems = elements(nskey);
        if (nelems < 1)
            SyntaxError('Unsupported', t);
        ExpectOp(';', tk);
        var nssym = ns.findns(nskey);
        if (nssym == null)
            SyntaxError('unknown namespace', t);
        ns.usenamespace(nssym);
        return;
    }
    if (! t.iskeyword('extern')) {
        tk.unget(t);
        var key = parseDotted(tk);
        int nelems = elements(key);
        if (nelems < 1)
            SyntaxError('Unsupported at namespace level', t);
        ExpectOp(';', tk);
        ns.use(key);
        return;
    }
    t = tk.get();
    switch {
      case t.isstring():
        // This usage will be deprecated, use $loadlib instead.
        string reqlib = t;
        ns.addlib(reqlib);
        ExpectOp(';', tk);
        break;
      case t.isidentifier():
        tk.unget(t);
        var module = parseDotted(tk);
        t = tk.get();
        if (! t.isop(';')) {
            tk.unget(t);
            var names = parseList(tk, null, parseIdentifier, ';');
            ns.addextern(module, names);
        }
        string reqmodule = '"' + join('/', module) + '.pbc"';
        ns.addload(reqmodule);
        break;
      default:
        Expected('string literal or identifier', t);
    }
}

//*********************************************

class External
{
    var module;
    var names;
    function External(module, names)
    {
        self.module = module;
        self.names = names;
    }
    function emit(e)
    {
        // Import external symbols in the current namespace

        e.say(<<:
.sub 'importextern' :anon :load :init
    .local pmc ex, curns, srcns, symbols
    ex = new ['Exporter']
    curns = get_namespace
    symbols = new ['ResizableStringArray']
:>>
        );
        e.print(INDENT + "srcns = get_root_namespace ['parrot'; '");
        e.print(join("'; '", self.module));
        e.say("']");
        for (string name in self.names)
            e.say(INDENT + "push symbols, '", name, "'");
        e.say(<<:
    ex.'destination'(curns)
    ex.'import'(srcns :named('source'), curns :named('destination'), symbols :named('globals'))
.end
:>>
        );
    }
}

//*********************************************
//            NamespaceBase
//*********************************************

class NamespaceBase : VarContainer
{
    var nspath;
    var externals;
    var namespaces;
    var classes;
    var functions;
    var items;
    var owner;

    function NamespaceBase(nspath, previous)
    {
        self.nspath = nspath;
        if (previous == null) {
            self.namespaces = [];
            self.usednamespaces = [];
            self.classes = [];
            self.functions = [];
        }
        else {
            self.locals = previous.locals;
            self.namespaces = previous.namespaces;
            self.usednamespaces = previous.usednamespaces;
            self.classes = previous.classes;
            self.functions = previous.functions;
        }
        self.items = [];
    }
    function fixnamespaces()
    {
        var ns;
        for (ns in self.namespaces)
            ns.fixnamespaces();
        for (ns in self.usednamespaces)
            for (var used in ns.usednamespaces)
                self.usenamespace(used);
    }
    function getpath()
    {
        return self.nspath;
    }
    function usenamespace(nsused)
    {
        if (nsused === self)
            return;
        var usednamespaces = self.usednamespaces;
        for (var used in usednamespaces)
            if (used === nsused)
                return;
        push(usednamespaces, nsused);
    }
    function use(key)
    {
        var sym = self.findsymbol(key);
        if (sym != null) {
            if (sym instanceof FunctionStatement)
                push(self.functions, sym);
        }
        else {
            string name = key.pop();
            var ns = self.findns(key);
            if (ns != null) {
                sym = ns.getvar(name);
                if (sym != null)
                    self.createvarused(name, sym);
            }
        }
    }
    function getusedns(string name)
    {
        for (var ns in self.usednamespaces)
            if (ns.name == name)
                return ns;
        return null;
    }
    function getlocalns(string name)
    {
        for (var ns in self.namespaces)
            if (ns.name == name)
                return ns;
        return self.getusedns(name);
    }

    function addextern(module, names)
    {
        var ext = new External(module, names);
        var externals = self.externals;
        if (externals == null)
            self.externals = externals = [ ext ];
        else
            push(externals, ext);
    }

    function checkclass_base(string name)
    {
        var classes = self.classes;
        var cl;
        for (cl in classes)
            if (cl.name == name)
                return cl;
        for (var ns in self.usednamespaces)
            if ((cl = ns.checkclass_base(name)) != null)
                return cl;
        return null;
    }
    function findclasskey_base(classkey, int offset)
    {
        // Look for a class by its key in this namespace
        // and its childs.
        int nelems = elements(classkey);
        switch (nelems - offset) {
          case 0:
            return null;
          case 1:
            // The key contains the name, look by name
            return self.checkclass_base(classkey[nelems - 1]);
          default:
            // The key is multi: look for a child namespace named
            // as the first key item, and look into it with the
            // remaining.
            string basename = classkey[offset];
            var ns = self.getlocalns(basename);
            if (ns != null) {
                var found = ns.findclasskey(classkey, offset + 1);
                if (found != null)
                    return found;
            }
        }
        return null;
    }
    function findsymbolbyname(string name)
    {
        var sym = self.checkclass_base(name);
        if (sym != null)
            return sym;
        for (sym in self.functions)
            if (sym.name == name)
                return sym;
        return null;
    }
    function findlocalsymbol(classkey, int offset)
    {
        // Look for a symbol by its key in this namespace
        // and its childs.
        int nelems = elements(classkey);
        string name;
        var sym;
        var ns;
        switch (nelems - offset) {
          case 0:
            return null;
          case 1:
            name = classkey[nelems - 1];
            // The key contains the name, look by name
            if ((sym = self.findsymbolbyname(name)) != null)
                return sym;
            for (ns in self.usednamespaces)
                if ((sym = ns.findsymbolbyname(name)) != null)
                    return sym;
            break;
          default:
            // The key is multi: look for a child namespace named
            // as the first key item, and look into it with the
            // remaining.
            name = classkey[offset];
            ns = self.getlocalns(name);
            if (ns != null &&
                    (sym = ns.findlocalsymbol(classkey, offset + 1)) != null)
                return sym;
            ns = self.getusedns(name);
            if (ns != null &&
                    (sym = ns.findlocalsymbol(classkey, offset + 1)) != null)
                return sym;
        }
        return null;
    }
    function findlocalns(nskey, int offset)
    {
        int nelems = elements(nskey);
        switch (nelems - offset) {
          case 0:
            return null;
          default:
            string name = nskey[offset];
            var ns = self.getlocalns(name);
            if (ns != null) {
                if (nelems - offset == 1)
                    return ns;
                else
                    return ns.findlocalns(nskey, offset + 1);
            }
        }
        return null;
    }
    function declarenamespace(var start, string name)
    {
        var child = new NamespaceStatement(self, start, null, name, null);
        push(self.namespaces, child);
        return child;
    }
    function childnamespace(var start, string name, var modifier)
    {
        var existns = self.getlocalns(name);
        var child = new NamespaceStatement(self, start, existns, name, modifier);
        push(self.namespaces, child);
        push(self.items, child);
        return child;
    }
    function declareclass(statement)
    {
        push(self.classes, statement);
    }
    function addclass(statement)
    {
        push(self.classes, statement);
        push(self.items, statement);
    }
    function parsenamespace(start, tk)
    {
        var t = tk.get();
        string name = t;
        t = tk.get();

        var modifier;
        if (t.isop('[')) {
            modifier = new ModifierList(tk, self);
            t = tk.get();
        }

        RequireOp('{', t);
        var child = self.childnamespace(start, name, modifier);
        child.parse(tk);
    }
    function parse(tk)
    {
        var items = self.items;
        var functions = self.functions;
        var classes = self.classes;
        var t;
        for (t = tk.get(); !(t.iseof() || t.isop('}')); t = tk.get())
        {
            switch (t.checkkeyword()) {
              case 'namespace':
                self.parsenamespace(t, tk);
                break;
              case 'const':
                var cst = parseConst(t, tk, self);
                push(items, cst);
                break;
              case 'function':
                var f = new FunctionStatement(t, tk, self);
                push(functions, f);
                push(items, f);
                break;
              case 'class':
                parseClass(t, tk, self);
                break;
              case 'extern':
                var t1 = tk.get();
                if (!t1.iskeyword('function'))
                    SyntaxError('Unsupported extern', t1);
                t1 = tk.get();
                RequireIdentifier(t1);
                ExpectOp(';', tk);
                var fex = new FunctionExtern(t1, self);
                push(functions, fex);
                break;
              case 'using':
                parsensUsing(t, tk, self);
                break;
              case '$include_const':
                include_parrot(t, tk, self);
                break;
              case '$load':
                t = tk.get();
                if (! t.isstring())
                    Expected('string literal', t);
                ExpectOp(';', tk);
                self.addload((new StringLiteral(self, t)).getPirString());
                break;
              case '$loadlib':
                t = tk.get();
                if (! t.isstring())
                    Expected('string literal', t);
                ExpectOp(';', tk);
                self.addlib((new StringLiteral(self, t)).getPirString());
                break;
              default:
                Unexpected("token", t);
            }
        }
        if (t.iseof())
            self.unclosed_ns();
        else
            self.close_ns(t);
    }
    function optimize_base()
    {
        optimize_array(self.items);
    }
    function emit_base(var e)
    {
        var path = self.getpath();
        string s = getparrotnamespacekey(path);

        int activate = 1;

        var externals = self.externals;
        if (externals != null) {
            e.say(s);
            activate = 0;
            emit_array(e, externals);
        }

        for (var item in self.items) {
            if ((item instanceof NamespaceStatement) ||
                    (item instanceof ClassStatement))
                activate = 1;
            else
                if (activate) {
                    e.say(s);
                    activate = 0;
                }
            item.emit(e);
        }
    }
}

//*********************************************
//            NamespaceStatement
//*********************************************

class NamespaceStatement : NamespaceBase
{
    var parent;
    var start;
    var name;
    var modifier;
    var hll;

    function NamespaceStatement(var parent, var start, var previous,
            string name, var modifier)
    {
        var nspath = clone(parent.getpath());
        push(nspath, name);
        self.NamespaceBase(nspath, previous);

        self.parent = parent;
        self.start = start;
        self.owner = parent;
        self.name = name;
        self.modifier = modifier;
        if (modifier != null) {
            if (modifier.pick('HLL') != null)
                self.hll = self.name;
        }
    }
    function dowarnings()
    {
        return self.parent.dowarnings();
    }
    function generatesubid()
    {
        return self.owner.generatesubid();
    }
    function use_predef(string name)
    {
        self.owner.use_predef(name);
    }
    function addlib(string libname)
    {
        self.parent.addlib(libname);
    }
    function addload(string loadname)
    {
        self.parent.addload(loadname);
    }
    function checkclass(string name)
    {
        var cl = self.checkclass_base(name);
        if (cl == null)
            return self.parent.checkclass(name);
        return cl;
    }
    function findclasskey(classkey, int offset[optional])
    {
        // Look for a class bi its key in this namespace and its childs.
        // If not found, look in the parent namespace.
        var cl = self.findclasskey_base(classkey, offset);
        if (cl == null && offset == 0)
            return self.parent.findclasskey(classkey, offset);
        return cl;
    }
    function findsymbol(classkey, int offset[optional])
    {
        var sym = self.findlocalsymbol(classkey, offset);
        if (sym == null && offset <= 0)
            return self.parent.findsymbol(classkey, offset);
        return sym;
    }
    function findns(nskey, int offset[optional])
    {
        var ns = self.findlocalns(nskey, offset);
        if (ns == null && offset <= 0)
            return self.parent.findns(nskey, offset);
        return ns;
    }
    function unclosed_ns()
    {
       SyntaxError('unclosed namespace', self.start);
    }
    function close_ns(t)
    {
        // Do nothing
    }
    function optimize()
    {
        var modifier = self.modifier;
        if (modifier != null)
            self.modifier = modifier.optimize();
        self.optimize_base();
        return self;
    }
    function emit(var e)
    {
        var hll = self.hll;
        if (hll !=  null)
            e.say(".HLL '", hll, "'");

        self.emit_base(e);

        if (hll !=  null)
            e.say(".HLL 'parrot'");
    }
}

//*********************************************
//            RootNamespace
//*********************************************

class RootNamespace : NamespaceBase
{
    var unit;
    var predefs_used;
    var libs;
    var loads;
    var subidgen;

    function RootNamespace(unit)
    {
        string nspath[];
        self.NamespaceBase(nspath, null);
        self.unit = unit;
        self.predefs_used = {};
        self.subidgen = 0;
    }
    function use_predef(string name)
    {
        var predefs_used = self.predefs_used;
        predefs_used[name] = 1;
    }
    function predef_is_used(string name)
    {
        var predefs_used = self.predefs_used;
        return predefs_used[name] == null ? 0 : 1;
    }

    function generatesubid()
    {
        int idgen = ++self.subidgen;
        return 'WSubId_' + string(idgen);
    }

    function addlib(string libname)
    {
        var libs = self.libs;
        if (libs == null)
            self.libs = libs = {};
        libs[libname] = 1;
    }
    function addload(string name)
    {
        var loads = self.loads;
        if (loads == null)
            self.loads = loads = {};
        loads[name] = 1;
    }
    function checkclass(string name)
    {
        return self.checkclass_base(name);
    }
    function findclasskey(classkey, int offset[optional])
    {
        // Look for a class by its key in the root namespace.
        return self.findclasskey_base(classkey, offset);
    }
    function findsymbol(classkey, int offset[optional])
    {
        return self.findlocalsymbol(classkey, offset);
    }
    function findns(nskey, int offset[optional])
    {
        return self.findlocalns(nskey, offset);
    }
    function unclosed_ns()
    {
        // Do nothing
    }
    function close_ns(t)
    {
         SyntaxError('Cannot close root namespace', t);
    }
    function dowarnings()
    {
        return self.unit.dowarnings();
    }
    function optimize()
    {
        self.optimize_base();
        return self;
    }
    function emit(var e)
    {
        var predefs_used = self.predefs_used;

        // chomp uses a library function, load the libray if chomp is used
        if (predefs_used['chomp'] != null)
            self.addload('"String/Utils.pbc"');

        // Load trans opcodes if some of its corresponding predefs are used
        string trfuncs[] = [
            'acos', 'asin', 'atan', 'cos', 'exp', 'ln', 'sin', 'tan', 'pow'
        ];
        for (string trfun in trfuncs)
            if (predefs_used[trfun] != null) {
                self.addlib("'trans_ops'");
                break;
            }

        int somelib = false;
        var libs = self.libs;
        if (libs != null) {
            somelib = true;
            for (string libname in libs)
                e.say('.loadlib ', libname);
        }

        int someload = false;
        var loads = self.loads;
        if (loads != null) {
            someload = true;
            e.print("\n.sub initial_load_bytecode :anon :load :init\n");
            for (string name in loads)
                e.say(INDENT + 'load_bytecode ', name);
            e.print(".end\n\n");
        }
        if (somelib || someload)
            e.comment('end libs');

        self.emit_base(e);
    }
    function emitinclude(var e)
    {
        var locals = self.locals;
        for (string localname in locals) {
            var data = locals[localname];
            if (!(data instanceof VarData) ||
                    data.gettype() != REGint ||
                    data.getflags() & VAR_is_extern)
                continue;
            var value = data.getvalue();
            e.say('.macro_const ', localname, ' ', value.getIntegerValue());
        }
    }
}

//*********************************************
//           Compiler classes
//*********************************************

const string EVAL_NAME = '__eval__';

class WinxedCompileUnit
{
    var rootns;
    var warnings;

    function WinxedCompileUnit(int nowarn)
    {
        self.warnings = ! nowarn;
        var rootns = new RootNamespace(self);

        // Store predefined constants in the root namespace.

        createPredefConstInt(rootns, 'false', 0);
        createPredefConstInt(rootns, 'true', 1);

        // Tricky way of setting __STAGE__: stage 1 is built with
        // stage 0 and stage 2 is built with stage 1. Increment
        // the current stage and we are done.
        createPredefConstString(rootns, '__STAGE__',
                string(int(__STAGE__) + 1));

        // Propagate value for exception type.
        createPredefConstInt(rootns, '__WINXED_ERROR__', __WINXED_ERROR__);

        self.rootns = rootns;
    }
    function dowarnings()
    {
        return int(self.warnings);
    }
    function parse(tk)
    {
        self.rootns.parse(tk);
        self.rootns.fixnamespaces();
    }
    function optimize()
    {
        self.rootns = self.rootns.optimize();
    }
    function emit(var e)
    {
        e.comment('THIS IS A GENERATED FILE! DO NOT EDIT!');
        e.comment('Begin generated code');
        e.say('');

        self.rootns.emit(e);

        e.comment('End generated code');
    }
    function emitinclude(var e)
    {
        e.comment('DO NOT EDIT THIS FILE');
        e.comment('Generated automatically from Winxed sources');

        self.rootns.emitinclude(e);

        e.comment('End');
    }
}

//*********************************************

class WinxedHLL
{
    function __private_compile_tail(winxed, target, output, noan)
    {
        if (target == 'parse')
            return winxed;
        var handleout;
        if (output == null) {
            handleout  = new ['StringHandle'];
            handleout.open(EVAL_NAME, 'w');
        }
        else
            handleout = output;
        var emit = new Emit(handleout);
        if (noan)
            emit.disable_annotations();
        winxed.emit(emit);
        emit.close();
        if (output != null)
            return output;
        else {
            handleout.close();
            string pircode = handleout.read(0);
            var object;
            switch (target) {
              case 'pir':
                object = new ['String'];
                object =: pircode;
                break;
              case 'pbc':
              case '':
                var pircomp = compreg('PIR');
                object = pircomp(pircode);
                break;
              default:
                die('Invalid target: ' + string(target));
            }
            return object;
        }
    }
    function __private_geninclude(winxed)
    {
        var handleout = new ['StringHandle'];
        handleout.open(EVAL_NAME, 'w');
        var emit = new Emit(handleout);
        winxed.emitinclude(emit);
        emit.close();
        handleout.close();
        return handleout.read(0);
    }
    function compile(string code,
            string target[named,optional],
            output[named,optional],
            int noan[named,optional],
            int nowarn[named,optional] )
    {
        if (target == null)
            target = '';
        var handlein = new ['StringHandle'];
        handlein.open(EVAL_NAME, 'w');
        handlein.puts(code);
        handlein.close();
        handlein.open(EVAL_NAME, 'r');
        var tk = new Tokenizer(handlein, EVAL_NAME);
        var winxed = new WinxedCompileUnit(nowarn);
        winxed.parse(tk);
        handlein.close();
        winxed.optimize();
        if (target == 'include')
            return self.__private_geninclude(winxed);
        else
            return self.__private_compile_tail(winxed, target, output, noan);
    }
    function compile_from_file(string filename,
            string target[named,optional],
            output[named,optional],
            int noan[named,optional],
            int nowarn[named,optional] )
    {
        // output is supposed to be used with pir target for a now,.
        if (target == null)
            target = '';
        var handlein = new ['FileHandle'];
        handlein.open(filename, 'r');
        handlein.encoding('utf8');
        var tk = new Tokenizer(handlein, filename);
        var winxed = new WinxedCompileUnit(nowarn);
        winxed.parse(tk);
        handlein.close();
        winxed.optimize();
        if (target == 'include')
            return self.__private_geninclude(winxed);
        else
            return self.__private_compile_tail(winxed, target, output, noan);
    }
}

//*********************************************
//            Initialization
//*********************************************

function initializer [init,load]()
{
    var comp = new WinxedHLL;
    compreg('winxed', comp);
}

//*********************************************

} // namespace Compiler
} // namespace Winxed

// End