bool StocksUpdateFromUDF(const UniversalDataFormat& udf) { StocksPrefs& prefs = GetPreferences()->stocksPrefs; StocksPortfolio& p = prefs.portfolio(prefs.currentPortfolio); ulong_t len = udf.getItemsCount(); assert(len == p.size()); for (ulong_t i = 0; i < len; ++i) { StocksEntry& e = p.entry(i); assert(udf.getItemElementsCount(i) >= 2); free(e.url); e.url = StringCopy(udf.getItemData(i, stocksListItemUrlIndex)); if (NULL == e.url) return false; const char_t* symbol = udf.getItemText(i, stocksListItemSymbolIndex); if (equalsIgnoreCase(symbol, e.symbol)) { assert(stocksListElementsCount == udf.getItemElementsCount(i)); e.status = e.statusReady; const char* trade = udf.getItemData(i, stocksListItemTradeIndex); const char* change = udf.getItemData(i, stocksListItemChangeIndex); const char* percent = udf.getItemData(i, stocksListItemPercentChangeIndex); if (errNone != numericValue(trade, -1, e.trade)) return false; if (errNone != numericValue(change, -1, e.change)) return false; ulong_t len = Len(percent); if (0 == len || '%' != percent[len - 1]) return false; if (errNone != numericValue(percent, len - 1, e.percentChange)) return false; } else if (equalsIgnoreCase(symbol, _T("?"))) { assert(stocksListNotFoundElementsCount == udf.getItemElementsCount(i)); e.status = e.statusAmbiguous; } else { assert(stocksListNotFoundElementsCount == udf.getItemElementsCount(i)); free(e.data); e.data = StringCopy(symbol); if (NULL == e.data) return false; e.status = e.statusChanged; } } return true; }
void DBNumberEdit::setValue(const QVariant &value) { bool ok; double v = value.toDouble(&ok); double orig = numericValue(); if ( ok && v != orig ) { setNumericValue(value.toDouble()); } }
double postfix (String exp) { int i, l = strlen(exp); TSNODE_p_t stack = NULL; TNODE_p_t root = NULL; for (i = 0; i < l; ++i) { char z = *(exp + i); if (isNumber(z)) { String str = initString; snprintf(str, SIZE, "%d", numericValue(z)); root = initTNode(str); root->type = TYPE_OPERAND; push(&stack, root); } else if (isAlphabet(z)) { double numz; printf("\n\tEnter the value of '%c': ", z); scanf(" %lf", &numz); String str = initString; snprintf(str, SIZE, "%lf", numz); root = initTNode(str); root->type = TYPE_OPERAND; push(&stack, root); } else if (isOperator(z)) { TNODE_p_t b = pop(&stack); TNODE_p_t a = pop(&stack); String str = initString; snprintf(str, SIZE, "%c", z); root = initTNode(str); root->right = b; root->left = a; root->type = TYPE_OPERATOR; push(&stack, root); } } root = pop(&stack); return evaulate(root); }
static status_t validateAddress(const NarrowString& origAddress, NarrowString& validAddress, ushort_t& port) { NarrowString::size_type pos = origAddress.find(':', 1); if (origAddress.npos == pos) return netErrParamErr; ushort_t portLength = origAddress.length() - pos - 1; if (portLength>0) { long value=0; status_t error = numericValue(origAddress.data()+pos+1, origAddress.data()+pos+1+portLength, value); if ((errNone != error) || (value > ushort_t(-1))) return netErrParamErr; port = ushort_t(value); } if (0 == port) return netErrParamErr; validAddress.assign(origAddress, 0, pos); return errNone; }
void CSSParserToken::serialize(StringBuilder& builder) const { // This is currently only used for @supports CSSOM. To keep our implementation // simple we handle some of the edge cases incorrectly (see comments below). switch (type()) { case IdentToken: serializeIdentifier(value(), builder); break; case FunctionToken: serializeIdentifier(value(), builder); return builder.append('('); case AtKeywordToken: builder.append('@'); serializeIdentifier(value(), builder); break; case HashToken: // This will always serialize as a hash-token with 'id' type instead of // preserving the type of the input. builder.append('#'); serializeIdentifier(value(), builder); break; case UrlToken: builder.append("url("); serializeIdentifier(value(), builder); return builder.append(")"); case DelimiterToken: if (delimiter() == '\\') return builder.append("\\\n"); return builder.append(delimiter()); case NumberToken: // These won't properly preserve the NumericValueType flag return builder.appendNumber(numericValue()); case PercentageToken: builder.appendNumber(numericValue()); return builder.append('%'); case DimensionToken: // This will incorrectly serialize e.g. 4e3e2 as 4000e2 builder.appendNumber(numericValue()); serializeIdentifier(value(), builder); break; case UnicodeRangeToken: return builder.append(String::format("U+%X-%X", unicodeRangeStart(), unicodeRangeEnd())); case StringToken: return serializeString(value(), builder); case IncludeMatchToken: return builder.append("~="); case DashMatchToken: return builder.append("|="); case PrefixMatchToken: return builder.append("^="); case SuffixMatchToken: return builder.append("$="); case SubstringMatchToken: return builder.append("*="); case ColumnToken: return builder.append("||"); case CDOToken: return builder.append("<!--"); case CDCToken: return builder.append("-->"); case BadStringToken: return builder.append("'\n"); case BadUrlToken: return builder.append("url(()"); case WhitespaceToken: return builder.append(' '); case ColonToken: return builder.append(':'); case SemicolonToken: return builder.append(';'); case CommaToken: return builder.append(','); case LeftParenthesisToken: return builder.append('('); case RightParenthesisToken: return builder.append(')'); case LeftBracketToken: return builder.append('['); case RightBracketToken: return builder.append(']'); case LeftBraceToken: return builder.append('{'); case RightBraceToken: return builder.append('}'); case EOFToken: case CommentToken: ASSERT_NOT_REACHED(); return; } }
/* static */ PRInt32 nsMathMLFrame::MapAttributesIntoCSS(nsPresContext* aPresContext, nsIContent* aContent) { // normal case, quick return if there are no attributes NS_ASSERTION(aContent, "null arg"); PRUint32 attrCount = 0; if (aContent) attrCount = aContent->GetAttrCount(); if (!attrCount) return 0; // need to initialize here -- i.e., after registering nsMathMLAtoms static const nsCSSMapping kCSSMappingTable[] = { {kMathMLversion2, nsMathMLAtoms::mathcolor_, "color:"}, {kMathMLversion1, nsMathMLAtoms::color_, "color:"}, {kMathMLversion2, nsMathMLAtoms::mathsize_, "font-size:"}, {kMathMLversion1, nsMathMLAtoms::fontsize_, "font-size:"}, {kMathMLversion1, nsMathMLAtoms::fontfamily_, "font-family:"}, {kMathMLversion2, nsMathMLAtoms::mathbackground_, "background-color:"}, {kMathMLversion1, nsMathMLAtoms::background_, "background-color:"}, {0, nsnull, nsnull} }; nsCOMPtr<nsIDocument> doc; nsCOMPtr<nsIStyleSheet> sheet; nsCOMPtr<nsICSSStyleSheet> cssSheet; nsCOMPtr<nsIDOMCSSStyleSheet> domSheet; PRInt32 nameSpaceID; nsCOMPtr<nsIAtom> prefix; nsCOMPtr<nsIAtom> attrAtom; PRInt32 ruleCount = 0; for (PRUint32 i = 0; i < attrCount; ++i) { aContent->GetAttrNameAt(i, &nameSpaceID, getter_AddRefs(attrAtom), getter_AddRefs(prefix)); // lookup the equivalent CSS property const nsCSSMapping* map = kCSSMappingTable; while (map->attrAtom && map->attrAtom != attrAtom) ++map; if (!map->attrAtom) continue; nsAutoString cssProperty(NS_ConvertASCIItoUCS2(map->cssProperty)); nsAutoString attrValue; aContent->GetAttr(nameSpaceID, attrAtom, attrValue); if (attrValue.IsEmpty()) continue; nsAutoString escapedAttrValue; nsStyleUtil::EscapeCSSString(attrValue, escapedAttrValue); // don't add rules that are already in mathml.css // (this will also clean up whitespace before units - see bug 125303) if (attrAtom == nsMathMLAtoms::fontsize_ || attrAtom == nsMathMLAtoms::mathsize_) { nsCSSValue cssValue; nsAutoString numericValue(attrValue); if (!ParseNumericValue(numericValue, cssValue)) continue; // on exit, ParseNumericValue also returns a nicer string // in which the whitespace before the unit is cleaned up cssProperty.Append(numericValue); } else cssProperty.Append(attrValue); nsAutoString attrName; attrAtom->ToString(attrName); // make a style rule that maps to the equivalent CSS property nsAutoString cssRule; cssRule.Assign(NS_LITERAL_STRING("[") + attrName + NS_LITERAL_STRING("='") + escapedAttrValue + NS_LITERAL_STRING("']{") + cssProperty + NS_LITERAL_STRING("}")); if (!sheet) { // first time... we do this to defer the lookup up to the // point where we encounter attributes that actually matter doc = aContent->GetDocument(); if (!doc) return 0; GetMathMLAttributeStyleSheet(aPresContext, getter_AddRefs(sheet)); if (!sheet) return 0; // by construction, these cannot be null at this point cssSheet = do_QueryInterface(sheet); domSheet = do_QueryInterface(sheet); NS_ASSERTION(cssSheet && domSheet, "unexpected null pointers"); // we will keep the sheet orphan as we populate it. This way, // observers of the document won't be notified and we avoid any troubles // that may come from reconstructing the frame tree. Our rules only need // a re-resolve of style data and a reflow, not a reconstruct-all... sheet->SetOwningDocument(nsnull); } // check for duplicate, if a similar rule is already there, don't bother to add another one nsAutoString selector; selector.Assign(NS_LITERAL_STRING("*[") + attrName + NS_LITERAL_STRING("=\"") + escapedAttrValue + NS_LITERAL_STRING("\"]")); PRInt32 k, count; cssSheet->StyleRuleCount(count); for (k = 0; k < count; ++k) { nsAutoString tmpSelector; nsCOMPtr<nsICSSRule> tmpRule; cssSheet->GetStyleRuleAt(k, *getter_AddRefs(tmpRule)); nsCOMPtr<nsICSSStyleRule> tmpStyleRule = do_QueryInterface(tmpRule); if (tmpStyleRule) { tmpStyleRule->GetSelectorText(tmpSelector); if (tmpSelector.Equals(selector)) { k = -1; break; } } } if (k >= 0) { // insert the rule (note: when the sheet already has @namespace and // friends, insert after them, e.g., at the end, otherwise it won't work) // For MathML 2, insert at the end to give it precedence PRInt32 pos = (map->compatibility == kMathMLversion2) ? count : 1; PRUint32 index; domSheet->InsertRule(cssRule, pos, &index); ++ruleCount; } } // restore the sheet to its owner if (sheet) { sheet->SetOwningDocument(doc); } return ruleCount; }
status_t parseUniversalDataFormatTextLine(const char* line, ulong_t len, UniversalDataFormat& out, ulong_t& lineNo, ulong_t& controlDataLength) { long resultLong; const char* data = line; UniversalDataFormat::Vector_t vec; ErrTry { if (lineNo == 0) { if (errNone != numericValue(data, data + len, resultLong)) ErrReturn(SocketConnection::errResponseMalformed); out.setHeaderSize(resultLong); } else if (lineNo <= out.headerSize_) { //read values from vector const char* dataOffset = data; while (data + len > dataOffset) { const char* dataOffsetEnd = dataOffset; while (dataOffsetEnd < data + len && dataOffsetEnd[0] != ' ') dataOffsetEnd++; if (errNone != numericValue(dataOffset, dataOffsetEnd, resultLong)) ErrReturn(SocketConnection::errResponseMalformed); vec.push_back(resultLong); controlDataLength += resultLong + 1; dataOffset = dataOffsetEnd + 1; } out.header_.push_back(vec); } else { if (lineNo == out.headerSize_ + 1) { free(out.data_); out.dataLen_ = 0; out.data_ = StringCopyN(line, len); if (NULL == out.data_) ErrReturn(memErrNotEnoughSpace); out.dataLen_ = len; } else { out.data_ = StrAppend(out.data_, out.dataLen_, "\n", 1); if (NULL == out.data_) ErrReturn(memErrNotEnoughSpace); ++out.dataLen_; out.data_ = StrAppend(out.data_, out.dataLen_, line, len); if (NULL == out.data_) ErrReturn(memErrNotEnoughSpace); out.dataLen_ += len; } } lineNo++; } ErrCatch (ex) { return ex; } ErrEndCatch return errNone; }
QVariant DBNumberEdit::value() { QVariant v(numericValue()); return v; }
bool CSSParserToken::isValidNumericValue() const { return isValidNumericValue(numericValue()); }