/////////////////////////////////////////////////////////////////////////// ////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[] }