void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(Element* element, bool& changedDefaultStyle) { if (simpleDefaultStyleSheet && !elementCanUseSimpleDefaultStyle(element)) { loadFullDefaultStyle(); changedDefaultStyle = true; } // FIXME: We should assert that the sheet only styles SVG elements. if (element->isSVGElement() && !svgStyleSheet) { svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet)); defaultStyle->addRulesFromSheet(svgStyleSheet, screenEval()); defaultPrintStyle->addRulesFromSheet(svgStyleSheet, printEval()); changedDefaultStyle = true; } // FIXME: We should assert that this sheet only contains rules for <video> and <audio>. if (!mediaControlsStyleSheet && (isHTMLVideoElement(element) || element->hasTagName(audioTag))) { String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::themeForPage(element->document()->page())->extraMediaControlsStyleSheet(); mediaControlsStyleSheet = parseUASheet(mediaRules); defaultStyle->addRulesFromSheet(mediaControlsStyleSheet, screenEval()); defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet, printEval()); changedDefaultStyle = true; } if (!fullscreenStyleSheet && FullscreenElementStack::isFullScreen(element->document())) { String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraFullScreenStyleSheet(); fullscreenStyleSheet = parseUASheet(fullscreenRules); defaultStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval()); defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval()); changedDefaultStyle = true; } ASSERT(defaultStyle->features().idsInRules.isEmpty()); ASSERT(mathMLStyleSheet || defaultStyle->features().siblingRules.isEmpty()); }
void StyleElement::createSheet(Element* e, const String& text) { ASSERT(e); ASSERT(e->inDocument()); Document& document = e->document(); if (m_sheet) clearSheet(e); // If type is empty or CSS, this is a CSS style sheet. const AtomicString& type = this->type(); if (isCSS(e, type)) { RefPtr<MediaQuerySet> mediaQueries = MediaQuerySet::create(media()); MediaQueryEvaluator screenEval("screen", true); MediaQueryEvaluator printEval("print", true); if (screenEval.eval(mediaQueries.get()) || printEval.eval(mediaQueries.get())) { m_loading = true; TextPosition startPosition = m_startPosition == TextPosition::belowRangePosition() ? TextPosition::minimumPosition() : m_startPosition; m_sheet = document.styleEngine()->createSheet(e, text, startPosition, m_createdByParser); m_sheet->setMediaQueries(mediaQueries.release()); m_loading = false; } } document.styleResolverMayHaveChanged(); }
void CSSDefaultStyleSheets::loadDefaultStyle() { ASSERT(!defaultStyle); defaultStyle = RuleSet::create().leakPtr(); defaultViewportStyle = RuleSet::create().leakPtr(); defaultPrintStyle = RuleSet::create().leakPtr(); defaultQuirksStyle = RuleSet::create().leakPtr(); // Strict-mode rules. String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::theme().extraDefaultStyleSheet(); defaultStyleSheet = parseUASheet(defaultRules); defaultStyle->addRulesFromSheet(defaultStyleSheet, screenEval()); #if OS(ANDROID) String viewportRules(viewportAndroidUserAgentStyleSheet, sizeof(viewportAndroidUserAgentStyleSheet)); #else String viewportRules; #endif viewportStyleSheet = parseUASheet(viewportRules); defaultViewportStyle->addRulesFromSheet(viewportStyleSheet, screenEval()); defaultPrintStyle->addRulesFromSheet(defaultStyleSheet, printEval()); // Quirks-mode rules. String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::theme().extraQuirksStyleSheet(); quirksStyleSheet = parseUASheet(quirksRules); defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet, screenEval()); }
void CSSDefaultStyleSheets::loadFullDefaultStyle() { if (simpleDefaultStyleSheet) { ASSERT(defaultStyle); ASSERT(defaultPrintStyle == defaultStyle); delete defaultStyle; simpleDefaultStyleSheet->deref(); defaultStyle = RuleSet::create().leakPtr(); defaultPrintStyle = RuleSet::create().leakPtr(); simpleDefaultStyleSheet = 0; } else { ASSERT(!defaultStyle); defaultStyle = RuleSet::create().leakPtr(); defaultPrintStyle = RuleSet::create().leakPtr(); defaultQuirksStyle = RuleSet::create().leakPtr(); } // Strict-mode rules. String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraDefaultStyleSheet(); defaultStyleSheet = parseUASheet(defaultRules); defaultStyle->addRulesFromSheet(defaultStyleSheet, screenEval()); defaultPrintStyle->addRulesFromSheet(defaultStyleSheet, printEval()); // Quirks-mode rules. String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::defaultTheme()->extraQuirksStyleSheet(); quirksStyleSheet = parseUASheet(quirksRules); defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet, screenEval()); }
void SVGStyleElement::childrenChanged() { SVGElement::childrenChanged(); if(m_sheet) m_sheet = 0; m_loading = false; MediaQueryEvaluator screenEval("screen", true); MediaQueryEvaluator printEval("print", true); RefPtr<MediaList> mediaList = new MediaList((CSSStyleSheet*)0, media()); if ((type().isEmpty() || type() == "text/css") && (screenEval.eval(mediaList.get()) || printEval.eval(mediaList.get()))) { ownerDocument()->addPendingSheet(); m_loading = true; m_sheet = new CSSStyleSheet(this); m_sheet->parseString(textContent()); // SVG css is always parsed in strict mode m_sheet->setMedia(mediaList.get()); m_loading = false; } if(!isLoading() && m_sheet) document()->stylesheetLoaded(); }
int main (int argc, char *argv[]) { if (argc != 2) { std::cout << "Usage: ./numerics inputFileName" << std::endl; return EXIT_SUCCESS; } std::string line; Functions * functions = new Functions(); std::fstream f(argv[1]); while (std::getline(f, line)) { std::size_t pos = 0; if ((pos = line.find("define")) != std::string::npos) { parse(line, functions); } else if (((pos = line.find("evaluate")) != std::string::npos)) { //compute the value of a function double res = evaluate(line, functions); printEval(line, res); } else if (((pos = line.find("numint")) != std::string::npos)) { pos += 6; skipSpace(line, pos); std::string s = line.substr(pos); double res = integeral(s, functions); printInte(line, res); } else if (((pos = line.find("mcint")) != std::string::npos)) { pos += 5; skipSpace(line, pos); std::string s = line.substr(pos); double res = mcint(s, functions); printMcint(line, res); } else if (((pos = line.find("max")) != std::string::npos)) { pos += 3; skipSpace(line, pos); std::string s = line.substr(pos); double res = gradAsc(s, functions, 0); printGrad(line, res, 0); } else if (((pos = line.find("min")) != std::string::npos)) { //std::cout << "This is a Gradient Descent" << std::endl; pos += 3; skipSpace(line, pos); std::string s = line.substr(pos); double res = gradAsc(s, functions, 1); printGrad(line, res, 1); } else if (((pos = line.find("exit")) != std::string::npos)) { delete functions; f.close(); return EXIT_SUCCESS; } } delete functions; f.close(); return EXIT_SUCCESS; }
void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(Element* element, bool& changedDefaultStyle) { // FIXME: We should assert that the sheet only styles SVG elements. if (element->isSVGElement() && !m_svgStyleSheet) { m_svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet)); m_defaultStyle->addRulesFromSheet(svgStyleSheet(), screenEval()); m_defaultPrintStyle->addRulesFromSheet(svgStyleSheet(), printEval()); changedDefaultStyle = true; } // FIXME: We should assert that the sheet only styles MathML elements. if (element->namespaceURI() == MathMLNames::mathmlNamespaceURI && !m_mathmlStyleSheet) { m_mathmlStyleSheet = parseUASheet(mathmlUserAgentStyleSheet, sizeof(mathmlUserAgentStyleSheet)); m_defaultStyle->addRulesFromSheet(mathmlStyleSheet(), screenEval()); m_defaultPrintStyle->addRulesFromSheet(mathmlStyleSheet(), printEval()); changedDefaultStyle = true; } // FIXME: We should assert that this sheet only contains rules for <video> and <audio>. if (!m_mediaControlsStyleSheet && (isHTMLVideoElement(*element) || isHTMLAudioElement(*element))) { String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::theme().extraMediaControlsStyleSheet(); m_mediaControlsStyleSheet = parseUASheet(mediaRules); m_defaultStyle->addRulesFromSheet(mediaControlsStyleSheet(), screenEval()); m_defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet(), printEval()); changedDefaultStyle = true; } // FIXME: This only works because we Force recalc the entire document so the new sheet // is loaded for <html> and the correct styles apply to everyone. if (!m_fullscreenStyleSheet && FullscreenElementStack::isFullScreen(element->document())) { String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::theme().extraFullScreenStyleSheet(); m_fullscreenStyleSheet = parseUASheet(fullscreenRules); m_defaultStyle->addRulesFromSheet(fullscreenStyleSheet(), screenEval()); m_defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet(), screenEval()); changedDefaultStyle = true; } ASSERT(!m_defaultStyle->features().hasIdsInSelectors()); ASSERT(m_defaultStyle->features().siblingRules.isEmpty()); }
void CSSDefaultStyleSheets::ensureDefaultStyleSheetsForElement(Element* element, bool& changedDefaultStyle) { // FIXME: We should assert that the sheet only styles SVG elements. if (element->isSVGElement() && !svgStyleSheet) { svgStyleSheet = parseUASheet(svgUserAgentStyleSheet, sizeof(svgUserAgentStyleSheet)); defaultStyle->addRulesFromSheet(svgStyleSheet, screenEval()); defaultPrintStyle->addRulesFromSheet(svgStyleSheet, printEval()); changedDefaultStyle = true; } #if ENABLE(WML) // FIXME: We should assert that the sheet only styles WML elements. if (element->isWMLElement() && !wmlStyleSheet) { wmlStyleSheet = parseUASheet(wmlUserAgentStyleSheet, sizeof(wmlUserAgentStyleSheet)); defaultStyle->addRulesFromSheet(wmlStyleSheet, screenEval()); defaultPrintStyle->addRulesFromSheet(wmlStyleSheet, printEval()); changedDefaultStyle = true; } #endif // FIXME: We should assert that this sheet only contains rules for <video> and <audio>. if (!mediaControlsStyleSheet && (isHTMLVideoElement(element) || element->hasTagName(audioTag))) { String mediaRules = String(mediaControlsUserAgentStyleSheet, sizeof(mediaControlsUserAgentStyleSheet)) + RenderTheme::theme().extraMediaControlsStyleSheet(); mediaControlsStyleSheet = parseUASheet(mediaRules); defaultStyle->addRulesFromSheet(mediaControlsStyleSheet, screenEval()); defaultPrintStyle->addRulesFromSheet(mediaControlsStyleSheet, printEval()); changedDefaultStyle = true; } // FIXME: This only works because we Force recalc the entire document so the new sheet // is loaded for <html> and the correct styles apply to everyone. if (!fullscreenStyleSheet && FullscreenElementStack::isFullScreen(&element->document())) { String fullscreenRules = String(fullscreenUserAgentStyleSheet, sizeof(fullscreenUserAgentStyleSheet)) + RenderTheme::theme().extraFullScreenStyleSheet(); fullscreenStyleSheet = parseUASheet(fullscreenRules); defaultStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval()); defaultQuirksStyle->addRulesFromSheet(fullscreenStyleSheet, screenEval()); changedDefaultStyle = true; } ASSERT(defaultStyle->features().idsInRules.isEmpty()); ASSERT(defaultStyle->features().siblingRules.isEmpty()); }
StyleElement::ProcessingResult StyleElement::createSheet(Element& element, const String& text) { DCHECK(element.isConnected()); Document& document = element.document(); const ContentSecurityPolicy* csp = document.contentSecurityPolicy(); bool passesContentSecurityPolicyChecks = shouldBypassMainWorldCSP(element) || csp->allowStyleWithHash(text, ContentSecurityPolicy::InlineType::Block) || csp->allowInlineStyle(&element, document.url(), element.fastGetAttribute(HTMLNames::nonceAttr), m_startPosition.m_line, text); // Clearing the current sheet may remove the cache entry so create the new // sheet first CSSStyleSheet* newSheet = nullptr; // If type is empty or CSS, this is a CSS style sheet. const AtomicString& type = this->type(); if (isCSS(element, type) && passesContentSecurityPolicyChecks) { MediaQuerySet* mediaQueries = MediaQuerySet::create(media()); MediaQueryEvaluator screenEval("screen"); MediaQueryEvaluator printEval("print"); if (screenEval.eval(mediaQueries) || printEval.eval(mediaQueries)) { m_loading = true; TextPosition startPosition = m_startPosition == TextPosition::belowRangePosition() ? TextPosition::minimumPosition() : m_startPosition; newSheet = document.styleEngine().createSheet( element, text, startPosition, m_styleEngineContext); newSheet->setMediaQueries(mediaQueries); m_loading = false; } } if (m_sheet) clearSheet(element); m_sheet = newSheet; if (m_sheet) m_sheet->contents()->checkLoaded(); return passesContentSecurityPolicyChecks ? ProcessingSuccessful : ProcessingFatalError; }
void InlineStyleSheetOwner::createSheet(Element& element, const String& text) { ASSERT(element.inDocument()); Document& document = element.document(); if (m_sheet) { if (m_sheet->isLoading()) document.authorStyleSheets().removePendingSheet(); clearSheet(); } if (!isValidCSSContentType(element, m_contentType)) return; ASSERT(document.contentSecurityPolicy()); const ContentSecurityPolicy& contentSecurityPolicy = *document.contentSecurityPolicy(); bool hasKnownNonce = contentSecurityPolicy.allowStyleWithNonce(element.fastGetAttribute(HTMLNames::nonceAttr), element.isInUserAgentShadowTree()); if (!contentSecurityPolicy.allowInlineStyle(document.url(), m_startTextPosition.m_line, text, hasKnownNonce)) return; RefPtr<MediaQuerySet> mediaQueries; if (element.isHTMLElement()) mediaQueries = MediaQuerySet::createAllowingDescriptionSyntax(m_media); else mediaQueries = MediaQuerySet::create(m_media); MediaQueryEvaluator screenEval(ASCIILiteral("screen"), true); MediaQueryEvaluator printEval(ASCIILiteral("print"), true); if (!screenEval.evaluate(*mediaQueries) && !printEval.evaluate(*mediaQueries)) return; authorStyleSheetsForElement(element).addPendingSheet(); m_loading = true; m_sheet = CSSStyleSheet::createInline(element, URL(), m_startTextPosition, document.encoding()); m_sheet->setMediaQueries(mediaQueries.releaseNonNull()); m_sheet->setTitle(element.title()); m_sheet->contents().parseStringAtPosition(text, m_startTextPosition, m_isParsingChildren); m_loading = false; if (m_sheet) m_sheet->contents().checkLoaded(); }
void InlineStyleSheetOwner::createSheet(Element* element, const String& text) { ASSERT(element); ASSERT(element->inDocument()); Document& document = element->document(); if (m_sheet) { if (m_sheet->isLoading()) document.styleSheetCollection()->removePendingSheet(); clearSheet(); } if (!isValidCSSContentType(element, m_contentType)) return; if (!document.contentSecurityPolicy()->allowInlineStyle(document.url(), m_startLineNumber)) return; RefPtr<MediaQuerySet> mediaQueries; if (element->isHTMLElement()) mediaQueries = MediaQuerySet::createAllowingDescriptionSyntax(m_media); else mediaQueries = MediaQuerySet::create(m_media); MediaQueryEvaluator screenEval(ASCIILiteral("screen"), true); MediaQueryEvaluator printEval(ASCIILiteral("print"), true); if (!screenEval.eval(mediaQueries.get()) && !printEval.eval(mediaQueries.get())) return; document.styleSheetCollection()->addPendingSheet(); m_loading = true; m_sheet = CSSStyleSheet::createInline(element, KURL(), document.inputEncoding()); m_sheet->setMediaQueries(mediaQueries.release()); m_sheet->setTitle(element->title()); m_sheet->contents()->parseStringAtLine(text, m_startLineNumber.zeroBasedInt(), m_isParsingChildren); m_loading = false; if (m_sheet) m_sheet->contents()->checkLoaded(); }
CSSDefaultStyleSheets::CSSDefaultStyleSheets() : m_defaultStyle(nullptr) , m_defaultViewportStyle(nullptr) , m_defaultQuirksStyle(nullptr) , m_defaultPrintStyle(nullptr) , m_defaultViewSourceStyle(nullptr) , m_defaultXHTMLMobileProfileStyle(nullptr) , m_defaultStyleSheet(nullptr) , m_viewportStyleSheet(nullptr) , m_quirksStyleSheet(nullptr) , m_svgStyleSheet(nullptr) , m_mathmlStyleSheet(nullptr) , m_mediaControlsStyleSheet(nullptr) , m_fullscreenStyleSheet(nullptr) { m_defaultStyle = RuleSet::create(); m_defaultViewportStyle = RuleSet::create(); m_defaultPrintStyle = RuleSet::create(); m_defaultQuirksStyle = RuleSet::create(); // Strict-mode rules. String defaultRules = String(htmlUserAgentStyleSheet, sizeof(htmlUserAgentStyleSheet)) + RenderTheme::theme().extraDefaultStyleSheet(); m_defaultStyleSheet = parseUASheet(defaultRules); m_defaultStyle->addRulesFromSheet(defaultStyleSheet(), screenEval()); #if OS(ANDROID) String viewportRules(viewportAndroidUserAgentStyleSheet, sizeof(viewportAndroidUserAgentStyleSheet)); #else String viewportRules; #endif m_viewportStyleSheet = parseUASheet(viewportRules); m_defaultViewportStyle->addRulesFromSheet(viewportStyleSheet(), screenEval()); m_defaultPrintStyle->addRulesFromSheet(defaultStyleSheet(), printEval()); // Quirks-mode rules. String quirksRules = String(quirksUserAgentStyleSheet, sizeof(quirksUserAgentStyleSheet)) + RenderTheme::theme().extraQuirksStyleSheet(); m_quirksStyleSheet = parseUASheet(quirksRules); m_defaultQuirksStyle->addRulesFromSheet(quirksStyleSheet(), screenEval()); }
void StyleElement::createSheet(Element* e, const String& text) { ASSERT(e); ASSERT(e->inDocument()); Document& document = e->document(); if (m_sheet) { if (m_sheet->isLoading()) document.styleEngine()->removePendingSheet(e); clearSheet(); } // If type is empty or CSS, this is a CSS style sheet. const AtomicString& type = this->type(); bool passesContentSecurityPolicyChecks = document.contentSecurityPolicy()->allowStyleNonce(e->fastGetAttribute(HTMLNames::nonceAttr)) || document.contentSecurityPolicy()->allowInlineStyle(e->document().url(), m_startPosition.m_line); if (isCSS(e, type) && passesContentSecurityPolicyChecks) { RefPtr<MediaQuerySet> mediaQueries = MediaQuerySet::create(media()); MediaQueryEvaluator screenEval("screen", true); MediaQueryEvaluator printEval("print", true); if (screenEval.eval(mediaQueries.get()) || printEval.eval(mediaQueries.get())) { document.styleEngine()->addPendingSheet(); m_loading = true; TextPosition startPosition = m_startPosition == TextPosition::belowRangePosition() ? TextPosition::minimumPosition() : m_startPosition; m_sheet = CSSStyleSheet::createInline(e, KURL(), startPosition, document.inputEncoding()); m_sheet->setMediaQueries(mediaQueries.release()); m_sheet->setTitle(e->title()); m_sheet->contents()->parseStringAtPosition(text, startPosition, m_createdByParser); m_loading = false; } } if (m_sheet) m_sheet->contents()->checkLoaded(); }
// ------------------------------------------------------------------- Error comments. double expErrorEval( const_Eval ev ) { printf( "\tIllegal expression.\n" ); printEval( ev ); return HUGE_VAL; }
void StyleElement::createSheet(Element* e, const String& text) { Document* document = e->document(); if (m_sheet) { if (static_cast<CSSStyleSheet*>(m_sheet.get())->isLoading()) document->removePendingSheet(); m_sheet = 0; } // If type is empty or CSS, this is a CSS style sheet. const AtomicString& type = this->type(); if (type.isEmpty() || (e->isHTMLElement() ? equalIgnoringCase(type, "text/css") : (type == "text/css"))) { RefPtr<MediaList> mediaList = MediaList::create(media(), e->isHTMLElement()); MediaQueryEvaluator screenEval("screen", true); MediaQueryEvaluator printEval("print", true); if (screenEval.eval(mediaList.get()) || printEval.eval(mediaList.get())) { document->addPendingSheet(); setLoading(true); m_sheet = CSSStyleSheet::create(e, String(), document->inputEncoding()); m_sheet->parseString(text, !document->inCompatMode()); m_sheet->setMedia(mediaList.get()); m_sheet->setTitle(e->title()); setLoading(false); } } if (m_sheet) m_sheet->checkLoaded(); }
void StyleElement::createSheet(Element* e, int startLineNumber, const String& text) { ASSERT(e); ASSERT(e->inDocument()); Document* document = e->document(); if (m_sheet) { if (m_sheet->isLoading()) document->removePendingSheet(); m_sheet = 0; } // If type is empty or CSS, this is a CSS style sheet. const AtomicString& type = this->type(); if (document->contentSecurityPolicy()->allowInlineStyle() && isCSS(e, type)) { RefPtr<MediaList> mediaList = MediaList::create(media(), e->isHTMLElement()); MediaQueryEvaluator screenEval("screen", true); MediaQueryEvaluator printEval("print", true); if (screenEval.eval(mediaList.get()) || printEval.eval(mediaList.get())) { document->addPendingSheet(); m_loading = true; m_sheet = CSSStyleSheet::create(e, String(), KURL(), document->inputEncoding()); m_sheet->parseStringAtLine(text, !document->inQuirksMode(), startLineNumber); m_sheet->setMedia(mediaList.get()); m_sheet->setTitle(e->title()); m_loading = false; } } if (m_sheet) m_sheet->checkLoaded(); }