///////////////////////////////////////////////////////////////////////////
////scvalConvToDouble//////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalConvToDouble(_value * val)
{
if (scvalGetValType(val) == valDOUBLE)
return;
if (scvalIsImmidiate(val)) {
switch ((int) scvalGetValType(val)) {
case valINT:
val->adr.val.dval = val->adr.val.ival;
break;
case valFIXED:
val->adr.val.dval = val->adr.val.ival / 65536.0;
break;
case valFLOAT:
val->adr.val.dval = val->adr.val.fval;
break;
}
scAssert(scvalConvToDouble,
(val->type.flags & typTYPE) == typPREDEFINED);
(valTYPE) val->type.main = valDOUBLE;
} else //-----------------------------------------------------------
{
_value v1 = { { /*ADDRESS*/ 0, adrREGISTER, {0}
}
, { /*type */ typPREDEFINED, NULL, (void *) valDOUBLE}, NULL };
switch (scvalGetValType(val)) {
case valINT:
v1.adr.address = scvalFindFreeDoubleRegister(val);
Gen_Opcode(opvcpuIDBL, &v1, val);
*val = v1;
break;
case valSHORT:
case valCHAR:
scvalConvToInt(val);
scvalConvToDouble(val);
return;
break;
case valFLOAT:
v1.adr.address = scvalFindFreeDoubleRegister(val);
Gen_Opcode(opvcpuFDBL, &v1, val);
*val = v1;
break;
case valFIXED:
v1.adr.address = scvalFindFreeDoubleRegister(val);
Gen_Opcode(opvcpuFIXDBL, &v1, val);
*val = v1;
break;
default:
serr2(scErr_Cast, illegal_type_conversion, " to double");
}
}
}
///////////////////////////////////////////////////////////////////////////
////scvalConvToFloat///////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalConvToFloat(_value * val)
{
if (scvalGetValType(val) == valFLOAT)
return;
deb0("ToFloat\n");
if (scvalIsImmidiate(val)) {
switch (scvalGetValType(val)) {
case valDOUBLE:
val->adr.val.fval = (float) val->adr.val.dval;
break;
case valINT:
val->adr.val.fval = (float) val->adr.val.ival;
break;
case valFIXED:
val->adr.val.fval = (float) (val->adr.val.ival / 65536.0);
break;
default:
// (float)val->val=val->val;
// val->vald=val->val;
scError(scvalConvToFloat);
}
scAssert(scvalConvToFloat,
(val->type.flags & typTYPE) == typPREDEFINED);
(valTYPE) val->type.main = valFLOAT;
} else {
_value v1 = { { /*ADDRESS*/ 0, adrREGISTER, {0}
}
, { /*type */ typPREDEFINED, NULL, (void *) valFLOAT}, NULL };
switch (scvalGetValType(val)) {
case valDOUBLE:
Gen_Opcode(opvcpuDFLT, &v1, val);
*val = v1;
break;
case valSHORT:
case valCHAR:
case valFIXED:
case valINT:
scvalConvToDouble(val);
scvalConvToFloat(val);
return;
break;
default:
serr2(scErr_Cast, illegal_type_conversion, " to float");
}
}
}
nsresult
nsExpatDriver::HandleError()
{
PRInt32 code = XML_GetErrorCode(mExpatParser);
NS_ASSERTION(code > XML_ERROR_NONE, "unexpected XML error code");
// Map Expat error code to an error string
// XXX Deal with error returns.
nsAutoString description;
nsParserMsgUtils::GetLocalizedStringByID(XMLPARSER_PROPERTIES, code,
description);
if (code == XML_ERROR_TAG_MISMATCH) {
/**
* Expat can send the following:
* localName
* namespaceURI<separator>localName
* namespaceURI<separator>localName<separator>prefix
*
* and we use 0xFFFF for the <separator>.
*
*/
const PRUnichar *mismatch = MOZ_XML_GetMismatchedTag(mExpatParser);
const PRUnichar *uriEnd = nsnull;
const PRUnichar *nameEnd = nsnull;
const PRUnichar *pos;
for (pos = mismatch; *pos; ++pos) {
if (*pos == kExpatSeparatorChar) {
if (uriEnd) {
nameEnd = pos;
}
else {
uriEnd = pos;
}
}
}
nsAutoString tagName;
if (uriEnd && nameEnd) {
// We have a prefix.
tagName.Append(nameEnd + 1, pos - nameEnd - 1);
tagName.Append(PRUnichar(':'));
}
const PRUnichar *nameStart = uriEnd ? uriEnd + 1 : mismatch;
tagName.Append(nameStart, (nameEnd ? nameEnd : pos) - nameStart);
nsAutoString msg;
nsParserMsgUtils::GetLocalizedStringByName(XMLPARSER_PROPERTIES,
"Expected", msg);
// . Expected: </%S>.
PRUnichar *message = nsTextFormatter::smprintf(msg.get(), tagName.get());
if (!message) {
return NS_ERROR_OUT_OF_MEMORY;
}
description.Append(message);
nsTextFormatter::smprintf_free(message);
}
// Adjust the column number so that it is one based rather than zero based.
PRUint32 colNumber = XML_GetCurrentColumnNumber(mExpatParser) + 1;
PRUint32 lineNumber = XML_GetCurrentLineNumber(mExpatParser);
nsAutoString errorText;
CreateErrorText(description.get(), XML_GetBase(mExpatParser), lineNumber,
colNumber, errorText);
NS_ASSERTION(mSink, "no sink?");
nsAutoString sourceText(mLastLine);
AppendErrorPointer(colNumber, mLastLine.get(), sourceText);
// Try to create and initialize the script error.
nsCOMPtr<nsIScriptError> serr(do_CreateInstance(NS_SCRIPTERROR_CONTRACTID));
nsresult rv = NS_ERROR_FAILURE;
if (serr) {
nsCOMPtr<nsIScriptError2> serr2(do_QueryInterface(serr));
rv = serr2->InitWithWindowID(description.get(),
mURISpec.get(),
mLastLine.get(),
lineNumber, colNumber,
nsIScriptError::errorFlag, "malformed-xml",
mInnerWindowID);
}
// If it didn't initialize, we can't do any logging.
PRBool shouldReportError = NS_SUCCEEDED(rv);
if (mSink && shouldReportError) {
rv = mSink->ReportError(errorText.get(),
sourceText.get(),
serr,
&shouldReportError);
if (NS_FAILED(rv)) {
shouldReportError = PR_TRUE;
}
}
if (shouldReportError) {
nsCOMPtr<nsIConsoleService> cs
(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
if (cs) {
cs->LogMessage(serr);
}
}
return NS_ERROR_HTMLPARSER_STOPPARSING;
}
///////////////////////////////////////////////////////////////////////////
////scsReadDirectInitialization///////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//returns 0, if all was read and nothing (but push init_end) remains to be
//done, else returns number of bytes to be copied
static int scsReadDirectInitialization(scSymbol * deli, scType * type,
bool packed, pmem * dest,
int type_size, scSymbol * sym)
{
_value val;
/* write to inits or consts*/
#if DEBUGLEVEL==0
deb2(": %s%s", sciValTypeStr(sctypGetValType(type)),
packed ? " as packed" : "");
deb1(" (%db)", type_size);
if (deli) //inside a function - initialize on the stack
{
deb0(" on the stack\n");
} else {
deb0(" on the heap\n");
}
#endif
if (type->params && type->params[0]) {
/*******************************************Pointer - OK*/
if (type->params[0] == '*' /*||(type->params[0]=='['&&type->params[1]==']') */ ) { //x* t;
scType inner_type = *type;
inner_type.params++;
sctypSimplifyType(&inner_type);
#if DEBUGLEVEL==0
deb0("* Pointer");
//Advance;
deb1(" %s ", ST->lexema);
#endif
scAssert(scsReadDirectInitialization, type_size == 4);
scget_back(ST);
/*as STRING*/
if (ST->lexema[0] == '"') {
if (sctypGetValType(&inner_type) != valCHAR)
serr(scErr_Declaration,
"Illegal array initialization with string");
if (deli) {
_value val1, val2;
char *s = ST->lexema + 1;
s[strlen(s) - 1] = 0;
// j=4;
#if DEBUGLEVEL==0
deb1("Storing %s\n", s);
#endif
if (sym) {
init_start = act.consts.pos; //inits will be earlier by 4 bytes.
s = scStrdup(s);
scvalConstantString(&val2, s);
// pushstr_pmem(&act.consts,s);
Gen_Opcode(opvcpuPUSH, &val2, NULL);
} else {
pushstr_pmem(&init_end, s);
push_pmem(&act.consts, 4, s); //copy to consts anything as pointer
Gen_Opcode(opvcpuMOV,
scvalSetRegister(&val1, valINT, 0),
scvalSetRegister(&val2, valINT, regES));
Gen_Opcode(opvcpuADD,
scvalSetRegister(&val1, valINT, 0),
scvalSetINT(&val2, init_start));
scvalSetINT(&val1, init_pos);
val1.adr.flags = adrBP;
val1.adr.address = init_pos;
Gen_Opcode(opvcpuMOV, &val1,
scvalSetRegister(&val2, valINT, 0));
}
init_start += strlen(s) + 1;
if (sym) {
Advance;
Advance;
return 0;
} //all done
} else {
int x = -2, y = init_start + act.inits.pos;
char *s = ST->lexema + 1;
// j=4;
s[strlen(s) - 1] = 0;
#if DEBUGLEVEL==0
deb1("Storing %s\n", s);
deb3("(%d,%d,%d)", y, x, act.consts.pos);
#endif
push_pmem(&act.inits, 4, &y); //can be anything
push_pmem(&init_end, 4, &y); //destination position
push_pmem(&init_end, 4, &x); //size=-2:ES
//copy to consts segment
push_pmem(&init_end, 4, &act.consts.pos);
#if DEBUGLEVEL==0
deb1("after %d,", init_end.pos);
#endif
pushstr_pmem(&act.consts, s);
}
Advance;
Advance;
return 4;
} else if (lexeq("{")) {
serr(scErr_Declaration,
"Don't use {} in initialization of pointer.");
} else
/*as VARIABLE*/
{ //exit to primitive read
}
} //Pointer*
else
/*******************************************Table*/
if (type->params[0] == '[') { //x t[xx];
scType tp = *type;
int tabsize, initsize = 0, inner_type_size;
#if DEBUGLEVEL==0
deb0("Table");
#endif
tp.params++;
tabsize = strtoul(tp.params, &tp.params, 10);
scAssert(Read_Init_Type[], *tp.params == ']');
tp.params++;
sctypSimplifyType(&tp);
inner_type_size = sctypSizeOf(&tp);
#if DEBUGLEVEL==0
deb2("[%d] of %d bytes;\n", tabsize, inner_type_size);
#endif
//Advance;
if (ST->lexema[0] == '"') {
char *data;
/*as STRING*/
if (sctypGetValType(&tp) != valCHAR)
serr(scErr_Declaration,
"Illegal array initialization with string");
#if DEBUGLEVEL==0
deb1("char[%d] init\n", tabsize);
#endif
data = scStrdup(ST->lexema + 1);
data[strlen(data) - 1] = 0; //erase "
pushstr_pmem(dest, data);
/* {char temp[100];
int i=tabsize-strlen(data)-1;
while(i)
if (i>100)
{push_pmem(dest,100,temp);i-=100;}
else
{push_pmem(dest,i,temp);i=0;}
}*/
initsize = strlen(data) + 1;
/*initialize all the data, if packed */
if (packed && initsize < type_size) {
char c = 0;
int i;
for (i = initsize; i < type_size; i++)
push_pmem(dest, 1, &c);
initsize = type_size;
}
scFree(data);
Advance;
return initsize;
} else if (lexeq("{")) {
int i = 0, j;
for (; i < tabsize; i++) {
Advance;
j =
scsReadDirectInitialization(deli, &tp, true, dest,
inner_type_size, NULL);
init_pos += inner_type_size;
scAssert(scsReadDirectInitialization[], j); //same here
initsize += j;
if (i < tabsize - 1) {
if (!lexeq(","))
serr2(scErr_Parse, parse_error, ST->lexema);
}
}
if (lexeq(",")) {
Advance;
}
if (!lexeq("}"))
serr2(scErr_Parse, parse_error, ST->lexema);
Advance;
return initsize;
} else //VARIABLE
{
serr2(scErr_Parse, parse_error, ST->lexema);
}
} //Table[]
}
