public override void OnParseContent(MLLexer lexer) { lexer.Literal = true; // Keep reading until we hit </script>. StringBuilder codeText = new StringBuilder(); // Let the parser know what line it's really at: codeText.Append("\n#l" + (lexer.LineNumber - 1) + "\n"); // Get the initial "empty" size: int size = codeText.Length; while (!AtEnd(lexer)) { codeText.Append(lexer.Read()); } // Great, good stuff. Add to the Document's code but only if this tag shouldn't be dumped: if (!Dump) { if (codeText.Length != size) { Element.Document.AddCode(codeText.ToString()); } } else { Wrench.Log.Add("Warning: Some script has been ignored due to it's type ('" + Element["type"] + "'). Did you mean 'text/nitro'?"); } lexer.Literal = false; }
public override void OnParseContent(MLLexer lexer) { // Read the content as a string until we hit </var> string variableText = ""; while (!AtEnd(lexer)) { variableText += lexer.Read(); } string name = Element["name"]; if (name == null) { return; } if (Gender == "boy" || Gender == "male") { name += " gender:b"; } else if (Gender == "girl" || Gender == "female") { name += " gender:g"; } Parent.SetValue(name, variableText); }
/// <summary>Attempts to read a block comment from the given lexer.</summary> /// <param name="lexer">The lexer to read it from.</param> /// <param name="currentCharacter">The next character in the lexer.</param> /// <returns>True if a block comment was read.</returns> private bool TryReadBlockComment(MLLexer lexer, char currentCharacter) { if (currentCharacter == '/' && lexer.Peek(1) == '*') { // CSS block comment. lexer.Read(); lexer.Read(); currentCharacter = lexer.Peek(); while (currentCharacter != StringReader.NULL) { if (currentCharacter == '*' && lexer.Peek(1) == '/') { //all done! lexer.Read(); lexer.Read(); break; } lexer.Read(); currentCharacter = lexer.Peek(); } return(true); } return(false); }
/// <summary>Checks if the given lexer has reached the end of the inline style content.</summary> /// <param name="lexer">The lexer to check if it's reached the </style> tag.</param> /// <returns>True if the lexer has reached the end style tag; false otherwise.</returns> private bool AtEnd(MLLexer lexer) { // Up to y will do; we're certainly at the end by that point. return(lexer.Peek() == '<' && lexer.Peek(1) == '/' && lexer.Peek(2) == 's' && lexer.Peek(3) == 't' && lexer.Peek(4) == 'y' ); }
protected override bool AtEnd(MLLexer lexer) { // Three will do; we're certainly at the end by that point. return(lexer.Peek() == '<' && lexer.Peek(1) == '/' && lexer.Peek(2) == 's' && lexer.Peek(3) == 'a' && lexer.Peek(4) == 'm' ); }
/// <summary>Checks if the given lexer has reached the end of the inline pre content.</summary> /// <param name="lexer">The lexer to check if it's reached the </pre> tag.</param> /// <returns>True if the lexer has reached the end pre tag; false otherwise.</returns> protected virtual bool AtEnd(MLLexer lexer) { // Three will do; we're certainly at the end by that point. return(lexer.Peek() == '<' && lexer.Peek(1) == '/' && lexer.Peek(2) == 'p' && lexer.Peek(3) == 'r' && lexer.Peek(4) == 'e' ); }
/// <summary>Checks if the given lexer is at the end of the variable tag currently being parsed.</summary> /// <param name="lexer">The lexer to check.</param> /// <returns>True if the lexer is now at the end of the variable tags content; false otherwise.</returns> private bool AtEnd(MLLexer lexer) { if (lexer.Peek() == '<' && lexer.Peek(1) == '/' && lexer.Peek(2) == 'v') { if (lexer.Peek(3) == '>' || (lexer.Peek(3) == 'a' && lexer.Peek(4) == 'r')) { return(true); } } return(false); }
public override void OnParseContent(MLLexer lexer) { lexer.Literal = true; // Keep reading until we hit </pre>. StringBuilder text = new StringBuilder(); while (!AtEnd(lexer)) { char read = lexer.Read(); // Convert any newlines into <br>eaks. if (read == '\r') { if (lexer.Peek() == '\n') { // It will handle the \n instead. continue; } text.Append("<br>"); } else if (read == '<') { text.Append(">"); } else if (read == '&') { text.Append("&"); } else if (read == '\n') { text.Append("<br>"); } else { text.Append(read); } } // Great, good stuff! Apply to its text content (literally): if (text.Length != 0) { Element.innerHTML = text.ToString(); } lexer.Literal = false; }
public override void OnParseContent(MLLexer lexer) { lexer.Literal = true; // Keep reading until we hit </textarea>. StringBuilder valueText = new StringBuilder(); while (!AtEnd(lexer)) { valueText.Append(lexer.Read()); } // Assign to the value: SetValue(valueText.ToString()); lexer.Literal = false; }
public override void OnParseContent(MLLexer lexer) { lexer.Literal = true; // Keep reading until we hit </style>. StringBuilder styleText = new StringBuilder(); while (!AtEnd(lexer)) { styleText.Append(lexer.Read()); } // Great, good stuff. Add to the document's style: if (styleText.Length != 0) { Element.Document.AddStyle(styleText.ToString()); } lexer.Literal = false; }
/// <summary>Called when the parser is reading the content of this tag for custom reading, e.g. a script/style tag. /// Non-self closing tags only. Anything that's not read by this method is assumed to be a child element.</summary> /// <param name="lexer">The lexer to read the content from.</param> public virtual void OnParseContent(MLLexer lexer) { }
/// <summary>Keeps reading selectors and their properties until a > or the end of the css is reached.</summary> /// <param name="css">The css text to parse.</param> public void ParseCss(string css) { MLLexer lexer = new MLLexer(css); char currentCharacter = lexer.Peek(); while (currentCharacter != '<' && currentCharacter != StringReader.NULL) { if (TryReadBlockComment(lexer, currentCharacter)) { currentCharacter = lexer.Peek(); continue; } // Read a selector: string selector = ""; string modifier = ""; bool inModifier = false; List <Selector> additionalSelectors = null; while (currentCharacter != '{' && currentCharacter != '<' && currentCharacter != StringReader.NULL) { // Read it off: lexer.Read(); if (currentCharacter == ' ') { // Skip spaces here. } else if (currentCharacter == ',') { // We have a series of selectors. if (selector != "") { // Store the current one in the additional list: if (additionalSelectors == null) { additionalSelectors = new List <Selector>(1); } additionalSelectors.Add(new Selector(this, selector, modifier)); // Clear the current one: selector = ""; modifier = ""; inModifier = false; } } else if (currentCharacter == ':') { if (inModifier) { // Already in the modifier - they've been daisy chained. // So, the modifier we've read so far is actually part of the selector: selector += ":" + modifier.ToLower(); modifier = ""; } inModifier = true; } else if (inModifier) { // Add it to the modifier: modifier += currentCharacter; } else { // Add it to the selector: selector += currentCharacter; } // Peek the next one: currentCharacter = lexer.Peek(); } if (currentCharacter == '{') { // Read it off: lexer.Read(); } else { // It must have been a < or null. Halt. break; } // Start the style block: SelectorStyle style = StartSelector(selector, modifier); // Read the properties inside a selectors block. Literal reading after : until ; bool readPropertyName = true; string propertyName = ""; string propertyValue = ""; currentCharacter = lexer.Peek(); while (currentCharacter != '}' && currentCharacter != '<' && currentCharacter != StringReader.NULL) { if (readPropertyName) { if (TryReadBlockComment(lexer, currentCharacter)) { currentCharacter = lexer.Peek(); continue; } if (currentCharacter == ':') { // Bump into literal mode. lexer.Literal = true; readPropertyName = false; } else { propertyName += currentCharacter; } } else { if (currentCharacter == ';') { // Pop out of literal mode, and go back to property names. readPropertyName = true; lexer.Literal = false; // And push our new propertyName/propertyValue set: style.SetDirect(propertyName, propertyValue); if (additionalSelectors != null) { // We have more,than,one selector. // Set to them too: for (int i = additionalSelectors.Count - 1; i >= 0; i--) { additionalSelectors[i].Style.SetDirect(propertyName, propertyValue); } } propertyName = ""; propertyValue = ""; } else { propertyValue += currentCharacter; } } // Read it off: lexer.Read(); // And take a look at what's next: currentCharacter = lexer.Peek(); } // Let the style know it's done loading: style.OnLoaded(); // 'Bake' the new styles into their modified forms, if any have been loaded yet. style.BakeToModifiers(); if (additionalSelectors != null) { // We have more,than,one selector. // Start their blocks too: for (int i = additionalSelectors.Count - 1; i >= 0; i--) { additionalSelectors[i].Style.BakeToModifiers(); } } if (currentCharacter == '}') { // Read it off: lexer.Read(); // And setup the next character: currentCharacter = lexer.Peek(); } else { // Halt - it was a null or <. break; } // Ensure we're out of literal mode: lexer.Literal = false; } }
//--------------------------------------
/// <summary>Called when the parser is reading the content of this tag for custom reading, e.g. a script/style tag. /// Non-self closing tags only. Anything that's not read by this method is assumed to be a child element.</summary> /// <param name="lexer">The lexer to read the content from.</param> public virtual void OnParseContent(MLLexer lexer){}