DoesMatch() public method

public DoesMatch ( char ch ) : bool
ch char
return bool
示例#1
0
        /// <summary>
        /// Strips the special attributes specified at the location of start. Special attributes are a php markdown extension
        /// and specified between {}. Attributes are separated with spaces. It recognizes the following attributes:
        /// id, which start with a '#'. Only the first one is used
        /// css classes, which start with a'.'. All specified are used
        /// name=value pairs, which will end up as attributes on the element.
        /// </summary>
        /// <param name="str">The string we're scanning.</param>
        /// <param name="start">The start (current) position.</param>
        /// <param name="end">The end position. Is only valid if returned list contains at least one value.</param>
        /// <returns>list of special attributes found, or null if none found or error in string format.</returns>
        public static List <string> StripSpecialAttributes(string str, int start, out int end)
        {
            end = start;
            var scanner = new StringScanner(str, start);

            if (!scanner.DoesMatch('{'))
            {
                // not a start of a special attribute block
                return(null);
            }
            // first find the end of the block,
            scanner.SkipForward(1);
            var startOfAttributes = scanner.Position;

            // first find the next EOL, as the closing } has to be on this line.
            scanner.SkipToEol();
            var nextEolPos = scanner.Position;

            scanner.Position = startOfAttributes;
            scanner.Mark();
            if (!scanner.Find('}') || scanner.Position >= nextEolPos)
            {
                // not enclosed properly.
                return(null);
            }
            var attributesString = scanner.Extract();

            if (string.IsNullOrWhiteSpace(attributesString))
            {
                return(null);
            }
            // Position is on enclosing '}' (due to the Find('}'), so we have to skip 1 character
            end = scanner.Position + 1;
            return(attributesString.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s)).ToList());
        }
示例#2
0
        /// <summary>
        /// Skips the font awesome specification at the current specified pos. Pos is inside str at the '@'. font awesome
        /// directives are @fa-iconname. newPos is positioned to character after iconname if successful match. iconname scanned is specified in iconname.
        /// </summary>
        /// <param name="str">The string.</param>
        /// <param name="currentPos">The current position.</param>
        /// <param name="newPos">The new position.</param>
        /// <param name="iconName">Name of the icon.</param>
        /// <returns>
        /// bool if match was found and properly skipped, otherwise false.
        /// </returns>
        public static bool SkipFontAwesome(string str, int currentPos, out int newPos, out string iconName)
        {
            newPos   = currentPos;
            iconName = string.Empty;
            if (str[currentPos] != '@')
            {
                return(false);
            }

            var scanner = new StringScanner(str, currentPos);

            // skip '@'
            scanner.SkipForward(1);
            if (!scanner.DoesMatch("fa-"))
            {
                // not a font awesome specification
                return(false);
            }
            scanner.SkipForward(3);
            iconName = string.Empty;
            if (!scanner.SkipIdentifier(ref iconName))
            {
                // no icon name specified
                return(false);
            }
            if (string.IsNullOrWhiteSpace(iconName))
            {
                return(false);
            }
            // matched a fontawesome specification
            newPos = scanner.Position;
            return(true);
        }
示例#3
0
		// Parse just the link target
		// For reference link definition, this is the bit after "[id]: thisbit"
		// For inline link, this is the bit in the parens: [link text](thisbit)
		internal static LinkDefinition ParseLinkTarget(StringScanner p, string id, bool ExtraMode)
		{
			// Skip whitespace
			p.SkipWhitespace();

			// End of string?
			if (p.eol)
				return null;

			// Create the link definition
			var r = new LinkDefinition(id);

			// Is the url enclosed in angle brackets
			if (p.SkipChar('<'))
			{
				// Extract the url
				p.Mark();

				// Find end of the url
				while (p.current != '>')
				{
					if (p.eof)
						return null;
					p.SkipEscapableChar(ExtraMode);
				}

				string url = p.Extract();
				if (!p.SkipChar('>'))
					return null;

				// Unescape it
				r.url = Utils.UnescapeString(url.Trim(), ExtraMode);

				// Skip whitespace
				p.SkipWhitespace();
			}
			else
			{
				// Find end of the url
				p.Mark();
				int paren_depth = 1;
				while (!p.eol)
				{
					char ch=p.current;
					if (char.IsWhiteSpace(ch))
						break;
					if (id == null)
					{
						if (ch == '(')
							paren_depth++;
						else if (ch == ')')
						{
							paren_depth--;
							if (paren_depth==0)
								break;
						}
					}

					p.SkipEscapableChar(ExtraMode);
				}

				r.url = Utils.UnescapeString(p.Extract().Trim(), ExtraMode);
			}

			p.SkipLinespace();

			// End of inline target
			if (p.DoesMatch(')'))
				return r;

			bool bOnNewLine = p.eol;
			int posLineEnd = p.position;
			if (p.eol)
			{
				p.SkipEol();
				p.SkipLinespace();
			}

			// Work out what the title is delimited with
			char delim;
			switch (p.current)
			{
				case '\'':  
				case '\"':
					delim = p.current;
					break;

				case '(':
					delim = ')';
					break;

				default:
					if (bOnNewLine)
					{
						p.position = posLineEnd;
						return r;
					}
					else
						return null;
			}

			// Skip the opening title delimiter
			p.SkipForward(1);

			// Find the end of the title
			p.Mark();
			while (true)
			{
				if (p.eol)
					return null;

				if (p.current == delim)
				{

					if (delim != ')')
					{
						int savepos = p.position;

						// Check for embedded quotes in title

						// Skip the quote and any trailing whitespace
						p.SkipForward(1);
						p.SkipLinespace();

						// Next we expect either the end of the line for a link definition
						// or the close bracket for an inline link
						if ((id == null && p.current != ')') ||
							(id != null && !p.eol))
						{
							continue;
						}

						p.position = savepos;
					}

					// End of title
					break;
				}

				p.SkipEscapableChar(ExtraMode);
			}

			// Store the title
			r.title = Utils.UnescapeString(p.Extract(), ExtraMode);

			// Skip closing quote
			p.SkipForward(1);

			// Done!
			return r;
		}
示例#4
0
        // Parse just the link target
        // For reference link definition, this is the bit after "[id]: thisbit"
        // For inline link, this is the bit in the parens: [link text](thisbit)
        internal static LinkDefinition ParseLinkTarget(StringScanner p, string id, bool ExtraMode)
        {
            // Skip whitespace
            p.SkipWhitespace();

            // End of string?
            if (p.eol)
            {
                return(null);
            }

            // Create the link definition
            var r = new LinkDefinition(id);

            // Is the url enclosed in angle brackets
            if (p.SkipChar('<'))
            {
                // Extract the url
                p.Mark();

                // Find end of the url
                while (p.current != '>')
                {
                    if (p.eof)
                    {
                        return(null);
                    }
                    p.SkipEscapableChar(ExtraMode);
                }

                string url = p.Extract();
                if (!p.SkipChar('>'))
                {
                    return(null);
                }

                // Unescape it
                r.url = Utils.UnescapeString(url.Trim(), ExtraMode);

                // Skip whitespace
                p.SkipWhitespace();
            }
            else
            {
                // Find end of the url
                p.Mark();
                int paren_depth = 1;
                while (!p.eol)
                {
                    char ch = p.current;
                    if (char.IsWhiteSpace(ch))
                    {
                        break;
                    }
                    if (id == null)
                    {
                        if (ch == '(')
                        {
                            paren_depth++;
                        }
                        else if (ch == ')')
                        {
                            paren_depth--;
                            if (paren_depth == 0)
                            {
                                break;
                            }
                        }
                    }

                    p.SkipEscapableChar(ExtraMode);
                }

                r.url = Utils.UnescapeString(p.Extract().Trim(), ExtraMode);
            }

            p.SkipLinespace();

            // End of inline target
            if (p.DoesMatch(')'))
            {
                return(r);
            }

            bool bOnNewLine = p.eol;
            int  posLineEnd = p.position;

            if (p.eol)
            {
                p.SkipEol();
                p.SkipLinespace();
            }

            // Work out what the title is delimited with
            char delim;

            switch (p.current)
            {
            case '\'':
            case '\"':
                delim = p.current;
                break;

            case '(':
                delim = ')';
                break;

            default:
                if (bOnNewLine)
                {
                    p.position = posLineEnd;
                    return(r);
                }
                else
                {
                    return(null);
                }
            }

            // Skip the opening title delimiter
            p.SkipForward(1);

            // Find the end of the title
            p.Mark();
            while (true)
            {
                if (p.eol)
                {
                    return(null);
                }

                if (p.current == delim)
                {
                    if (delim != ')')
                    {
                        int savepos = p.position;

                        // Check for embedded quotes in title

                        // Skip the quote and any trailing whitespace
                        p.SkipForward(1);
                        p.SkipLinespace();

                        // Next we expect either the end of the line for a link definition
                        // or the close bracket for an inline link
                        if ((id == null && p.current != ')') ||
                            (id != null && !p.eol))
                        {
                            continue;
                        }

                        p.position = savepos;
                    }

                    // End of title
                    break;
                }

                p.SkipEscapableChar(ExtraMode);
            }

            // Store the title
            r.title = Utils.UnescapeString(p.Extract(), ExtraMode);

            // Skip closing quote
            p.SkipForward(1);

            // Done!
            return(r);
        }