gecko-dev/js/js2/icodeasm.cpp
rogerl%netscape.com 9250f428f3 Fixes to support ICodeModule operand type (via name in global object) and
TRUE/FALSE/NULL/CLASS instructions.
2001-01-25 23:34:33 +00:00

550 lines
20 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is the JavaScript 2 Prototype.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the
* terms of the GNU Public License (the "GPL"), in which case the
* provisions of the GPL are applicable instead of those above.
* If you wish to allow use of your version of this file only
* under the terms of the GPL and not to allow others to use your
* version of this file under the NPL, indicate your decision by
* deleting the provisions above and replace them with the notice
* and other provisions required by the GPL. If you do not delete
* the provisions above, a recipient may use your version of this
* file under either the NPL or the GPL.
*/
#include <stdio.h>
#include "icodeasm.h"
#include "icodemap.h"
#include "utilities.h"
#include "lexutils.h"
#include "exception.h"
namespace JavaScript {
namespace ICodeASM {
using namespace LexUtils;
static char *keyword_offset = "offset";
static char *keyword_exprNodeKinds[] = {"add", "subtract", "multiply", "divide",
"remainder", "leftshift", "rightshift",
"logicalrightshift", "bitwiseor",
"bitwisexor", "bitwiseand", "less",
"lessorequal", "equal", "identical", 0};
static ExprNode::Kind exprNodeOps[] =
{ ExprNode::add, ExprNode::subtract, ExprNode::multiply, ExprNode::divide,
ExprNode::modulo, ExprNode::leftShift, ExprNode::rightShift,
ExprNode::logicalRightShift, ExprNode::bitwiseOr,
ExprNode::bitwiseXor, ExprNode::bitwiseAnd, ExprNode::lessThan,
ExprNode::lessThanOrEqual, ExprNode::equal, ExprNode::identical };
void
ICodeParser::parseSourceFromString (const string8 &source)
{
uint statementNo = 0;
string8_citer begin = source.begin();
string8_citer end = source.end();
mInstructions = new VM::InstructionStream();
mMaxRegister = 0;
mInstructionCount = 0;
mLabels.clear();
mNamedLabels.clear();
while (begin < end)
{
try
{
++statementNo;
begin = parseNextStatement (begin, end);
}
catch (JSException &e)
{
string8 etext;
e.toString8(etext);
fprintf (stderr, "%s at statement %u\n",
etext.c_str(), statementNo);
return;
}
}
if (begin > end)
NOT_REACHED ("Overran source buffer!");
}
/**********************************************************************
* operand parse functions (see comment in the .h file) ...
*/
string8_citer
ICodeParser::parseArgumentListOperand (string8_citer begin,
string8_citer end,
VM::ArgumentList **rval)
{
/* parse argument list on the format "(['argname': ]register[, ...])" */
TokenLocation tl = seekTokenStart (begin, end);
VM::ArgumentList *al = new VM::ArgumentList();
if (tl.estimate != teOpenParen)
throw JSParseException (eidExpectArgList);
tl = seekTokenStart (tl.begin + 1, end);
StringFormatter s_fmt;
while (tl.estimate == teString || tl.estimate == teAlpha) {
string *argName = 0;
if (tl.estimate == teString) {
/* look for the argname in quotes */
begin = lexString8 (tl.begin, end, &argName);
/* look for the : */
tl = seekTokenStart (begin, end);
if (tl.estimate != teColon)
throw JSParseException (eidExpectColon);
/* and now the register */
tl = seekTokenStart (tl.begin + 1, end);
}
if (tl.estimate != teAlpha)
throw JSParseException (eidExpectRegister);
JSTypes::Register r;
begin = lexRegister (tl.begin, end, &r);
if (r != VM::NotARegister && r > mMaxRegister)
mMaxRegister = r;
/* pass 0 (null) as the "type" because it is
* not actually used by the interpreter, only in (the current)
* codegen (acording to rogerl.)
*/
VM::TypedRegister tr = VM::TypedRegister(r, 0);
StringAtom *sap = 0;
if (argName) {
sap = &(mCx->getWorld().identifiers[argName->c_str()]);
delete argName;
}
else {
/* if an argument name was not specified, use the position
* to build a default name.
*/
s_fmt << (uint32)al->size();
sap = &(mCx->getWorld().identifiers[s_fmt.getString()]);
s_fmt.clear();
}
VM::Argument arg = VM::Argument (tr, sap);
al->push_back(arg);
tl = seekTokenStart (begin, end);
/* if the next token is a comma,
* seek to the next one and go again */
if (tl.estimate == teComma) {
tl = seekTokenStart (tl.begin + 1, end);
}
}
if (tl.estimate != teCloseParen)
throw JSParseException (eidExpectCloseParen);
*rval = al;
return tl.begin + 1;
}
string8_citer
ICodeParser::parseExprNodeKindOperand (string8_citer begin, string8_citer end,
ExprNode::Kind *rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teAlpha)
throw JSParseException (eidExpectBinaryOp);
string8 *str;
end = lexAlpha (tl.begin, end, &str);
for (int i = 0; keyword_exprNodeKinds[i] != 0; ++i)
if (cmp_nocase (*str, keyword_exprNodeKinds[i], keyword_exprNodeKinds[i] +
strlen (keyword_exprNodeKinds[i])) == 0) {
*rval = exprNodeOps[i];
delete str;
return end;
}
delete str;
throw JSParseException (eidUnknownBinaryOp);
}
string8_citer
ICodeParser::parseBoolOperand (string8_citer begin, string8_citer end,
bool *rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teAlpha)
throw JSParseException (eidExpectBool);
return lexBool (tl.begin, end, rval);
}
string8_citer
ICodeParser::parseDoubleOperand (string8_citer begin, string8_citer end,
double *rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if ((tl.estimate != teNumeric) && (tl.estimate != teMinus) &&
(tl.estimate != tePlus))
throw JSParseException (eidExpectDouble);
return lexDouble (tl.begin, end, rval);
}
string8_citer
ICodeParser::parseICodeModuleOperand (string8_citer begin,
string8_citer end,
VM::ICodeModule **rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teString)
throw JSParseException (eidExpectString);
string8 *str;
end = lexString8 (tl.begin, end, &str);
StringAtom &typename_atom = mCx->getWorld().identifiers[str->c_str()];
delete str;
JSTypes::JSValue jsv =
mCx->getGlobalObject()->getVariable(typename_atom);
if (!jsv.isFunction()) {
ASSERT(false);
}
*rval = jsv.function->getICode();
return end;
// NOT_REACHED ("ICode modules are hard, lets go shopping.");
// return end;
}
string8_citer
ICodeParser::parseJSClassOperand (string8_citer begin,
string8_citer end, JSTypes::JSType **rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teString)
throw JSParseException (eidExpectString);
string8 *str;
end = lexString8 (tl.begin, end, &str);
StringAtom &typename_atom = mCx->getWorld().identifiers[str->c_str()];
delete str;
JSTypes::JSValue jsv =
mCx->getGlobalObject()->getVariable(typename_atom);
if (jsv.isType())
*rval = jsv.type;
else
*rval = &(JSTypes::Any_Type);
return end;
// NOT_REACHED ("JSClasses are hard, lets go shopping.");
// return end;
}
string8_citer
ICodeParser::parseJSStringOperand (string8_citer begin, string8_citer end,
JSTypes::JSString **rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teString)
throw JSParseException (eidExpectString);
string8 *str;
end = lexString8 (tl.begin, end, &str);
*rval = new JSTypes::JSString (str->c_str());
delete str;
return end;
}
string8_citer
ICodeParser::parseJSFunctionOperand (string8_citer /*begin*/,
string8_citer end,
string ** /*rval*/)
{
NOT_REACHED ("JSFunctions are hard, lets go shopping.");
return end;
}
string8_citer
ICodeParser::parseJSTypeOperand (string8_citer begin, string8_citer end,
JSTypes::JSType **rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teString)
throw JSParseException (eidExpectString);
string8 *str;
end = lexString8 (tl.begin, end, &str);
StringAtom &typename_atom = mCx->getWorld().identifiers[str->c_str()];
delete str;
JSTypes::JSValue jsv =
mCx->getGlobalObject()->getVariable(typename_atom);
if (jsv.isType())
*rval = jsv.type;
else
*rval = &(JSTypes::Any_Type);
return end;
}
string8_citer
ICodeParser::parseLabelOperand (string8_citer begin, string8_citer end,
VM::Label **rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teAlpha)
throw JSParseException (eidExpectLabel);
string8 *str;
begin = lexAlpha (tl.begin, end, &str);
if (cmp_nocase(*str, keyword_offset, keyword_offset +
strlen(keyword_offset)) == 0) {
delete str;
/* got the "Offset" keyword, treat next thing as a jump offset
* expressed as "Offset +/-N" */
tl = seekTokenStart (begin, end);
if (tl.estimate != teNumeric)
throw JSParseException (eidExpectUInt32);
uint32 ofs;
begin = lexUInt32 (tl.begin, end, &ofs);
VM::Label *new_label = new VM::Label(mInstructions);
new_label->mOffset = ofs;
mLabels.push_back (new_label);
*rval = new_label;
} else {
/* label expressed as "label_name", look for it in the
* namedlabels map */
LabelMap::const_iterator l = mNamedLabels.find(str->c_str());
if (l != mNamedLabels.end()) {
/* found the label, use it */
*rval = (*l).second;
} else {
/* havn't seen the label definition yet, put a placeholder
* in the namedlabels map */
VM::Label *new_label = new VM::Label(mInstructions);
new_label->mOffset = VM::NotALabel;
*rval = new_label;
mNamedLabels[str->c_str()] = new_label;
mLabels.push_back (new_label);
}
delete str;
}
return begin;
}
string8_citer
ICodeParser::parseUInt32Operand (string8_citer begin,
string8_citer end, uint32 *rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teNumeric)
throw JSParseException (eidExpectUInt32);
return lexUInt32 (tl.begin, end, rval);
}
string8_citer
ICodeParser::parseRegisterOperand (string8_citer begin, string8_citer end,
JSTypes::Register *rval)
{
TokenLocation tl = seekTokenStart (begin, end);
end = lexRegister (tl.begin, end, rval);
if (*rval != VM::NotARegister && *rval > mMaxRegister)
mMaxRegister = *rval;
return end;
}
string8_citer
ICodeParser::parseStringAtomOperand (string8_citer begin, string8_citer end,
StringAtom **rval)
{
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate != teString)
throw JSParseException (eidExpectString);
string8 *str;
end = lexString8 (tl.begin, end, &str);
*rval = &(mCx->getWorld().identifiers[str->c_str()]);
delete str;
return end;
}
/* "High Level" parse functions ... */
string8_citer
ICodeParser::parseInstruction (uint icodeID, string8_citer begin,
string8_citer end)
{
string8_citer curpos = begin;
StatementNode node;
node.icodeID = icodeID;
# define CASE_TYPE(T, C, CTYPE) \
case ot##T: \
{ \
C rval; \
node.operand[i].type = ot##T; \
curpos = parse##T##Operand (curpos, end, &rval); \
node.operand[i].data = CTYPE<int64>(rval); \
break; \
}
for (uint i = 0; i < 4; ++i)
{
switch (icodemap[icodeID].otype[i])
{
CASE_TYPE(ArgumentList, VM::ArgumentList *, reinterpret_cast);
CASE_TYPE(ExprNodeKind, ExprNode::Kind, static_cast);
CASE_TYPE(Bool, bool, static_cast);
CASE_TYPE(Double, double, static_cast);
CASE_TYPE(ICodeModule, VM::ICodeModule *, reinterpret_cast);
CASE_TYPE(JSClass, JSTypes::JSType *, reinterpret_cast);
CASE_TYPE(JSString, JSTypes::JSString *, reinterpret_cast);
CASE_TYPE(JSFunction, string *, reinterpret_cast);
CASE_TYPE(JSType, JSTypes::JSType *, reinterpret_cast);
CASE_TYPE(Label, VM::Label *, reinterpret_cast);
CASE_TYPE(UInt32, uint32, static_cast);
CASE_TYPE(Register, JSTypes::Register, static_cast);
CASE_TYPE(StringAtom, StringAtom *, reinterpret_cast);
default:
node.operand[i].type = otNone;
break;
}
if (i != 3 && icodemap[icodeID].otype[i + 1] != otNone) {
/* if the instruction has more arguments, eat a comma and
* locate the next token */
TokenLocation tl = seekTokenStart (curpos, end);
if (tl.estimate != teComma)
throw JSParseException (eidExpectComma);
tl = seekTokenStart (tl.begin + 1, end);
curpos = tl.begin;
}
}
# undef CASE_TYPE
mInstructions->push_back (InstructionFromNode(&node));
++mInstructionCount;
TokenLocation tl = seekTokenStart (curpos, end);
if (tl.estimate != teNewline && tl.estimate != teEOF)
throw JSParseException (eidExpectNewline);
if (tl.estimate == teEOF)
return tl.begin;
else
return tl.begin + 1;
}
string8_citer
ICodeParser::parseNextStatement (string8_citer begin, string8_citer end)
{
bool isLabel = false;
string8_citer firstTokenEnd = end;
TokenLocation tl = seekTokenStart (begin, end);
if (tl.estimate == teNewline) {
/* empty statement, do nothing */
return tl.begin + 1;
}
if (tl.estimate != teAlpha)
throw JSParseException (eidExpectIdentifier);
for (string8_citer curpos = tl.begin; curpos < end; ++curpos) {
switch (*curpos)
{
case ':':
isLabel = true;
firstTokenEnd = ++curpos;
goto scan_done;
default:
if (!IS_ALPHA(*curpos)) {
firstTokenEnd = curpos;
goto scan_done;
}
}
}
scan_done:
if (isLabel) {
/* the thing we scanned was a label...
* ignore the trailing : */
string8 label_str(tl.begin, firstTokenEnd - 1);
/* check to see if it was already referenced... */
LabelMap::const_iterator l = mNamedLabels.find(label_str.c_str());
if (l == mNamedLabels.end()) {
/* if it wasn't already referenced, add it */
VM::Label *new_label = new VM::Label (mInstructions);
new_label->mOffset = mInstructionCount;
mNamedLabels[label_str.c_str()] = new_label;
mLabels.push_back(new_label);
} else {
/* if it was already referenced, check to see if the offset
* was already set */
if ((*l).second->mOffset == VM::NotALabel) {
/* offset not set yet, set it and move along */
(*l).second->mOffset = mInstructionCount;
} else {
/* offset was already set, this must be a dupe! */
throw JSParseException (eidDuplicateLabel);
}
}
} else {
/* the thing we scanned was an instruction, search the icode map
* for a matching instruction */
string8 icode_str(tl.begin, firstTokenEnd);
for (uint i = 0; i < icodemap_size; ++i)
if (cmp_nocase(icode_str, &icodemap[i].name[0],
&icodemap[i].name[0] +
strlen(icodemap[i].name)) == 0)
/* if match found, parse it's operands */
return parseInstruction (i, firstTokenEnd, end);
/* otherwise, choke on it */
throw JSParseException (eidUnknownICode);
}
return firstTokenEnd;
}
}
}