char.IsLetterOrDigit(char)

Here are the examples of the csharp api char.IsLetterOrDigit(char) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

542 Examples 7

19 View Source File : XMLConfiguration.cs
License : MIT License
Project Creator : azist

protected override string AdjustNodeName(string name)
    {
      var result = new StringBuilder(32);//average id size is 16-20 chars

      foreach (var c in name)
        if (char.IsLetterOrDigit(c) || c == '_' || c == '.')
          result.Append(c);
        else
          result.Append('-');

      return result.ToString();
    }

19 View Source File : DataEntryUtils.cs
License : MIT License
Project Creator : azist

[MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool IsValidEMailLocalPartChar(char c)
    {
      const string validLocalPartChars = "!#$%&'*+-/=?^_`{|}~";
      return (Char.IsLetterOrDigit(c) || validLocalPartChars.IndexOf(c) >= 0);
    }

19 View Source File : CodeEditorView.xaml.cs
License : MIT License
Project Creator : Aminator

private bool IsValidCSharpIdentifierCharacter(char value)
        {
            return value == '_' || char.IsLetterOrDigit(value);
        }

19 View Source File : IndentationReformatter.cs
License : MIT License
Project Creator : AvaloniaUI

public void Step(IDoreplacedentAccessor doc, IndentationSettings set)
        {
            var line = doc.Text;
            if (set.LeaveEmptyLines && line.Length == 0) return; // leave empty lines empty
            line = line.TrimStart();

            var indent = new StringBuilder();
            if (line.Length == 0)
            {
                // Special treatment for empty lines:
                if (_blockComment || (_inString && _verbatim))
                    return;
                indent.Append(_block.InnerIndent);
                indent.Append(Repeat(set.IndentString, _block.OneLineBlock));
                
                if (doc.Text != indent.ToString())
                    doc.Text = indent.ToString();
                return;
            }

            if (TrimEnd(doc))
                line = doc.Text.TrimStart();

            var oldBlock = _block;
            var startInComment = _blockComment;
            var startInString = (_inString && _verbatim);

            #region Parse char by char
            _lineComment = false;
            _inChar = false;
            _escape = false;
            if (!_verbatim) _inString = false;

            _lastRealChar = '\n';

            var c = ' ';
            var nextchar = line[0];
            for (var i = 0; i < line.Length; i++)
            {
                if (_lineComment) break; // cancel parsing current line

                var lastchar = c;
                c = nextchar;
                nextchar = i + 1 < line.Length ? line[i + 1] : '\n';

                if (_escape)
                {
                    _escape = false;
                    continue;
                }

                #region Check for comment/string chars
                switch (c)
                {
                    case '/':
                        if (_blockComment && lastchar == '*')
                            _blockComment = false;
                        if (!_inString && !_inChar)
                        {
                            if (!_blockComment && nextchar == '/')
                                _lineComment = true;
                            if (!_lineComment && nextchar == '*')
                                _blockComment = true;
                        }
                        break;
                    case '#':
                        if (!(_inChar || _blockComment || _inString))
                            _lineComment = true;
                        break;
                    case '"':
                        if (!(_inChar || _lineComment || _blockComment))
                        {
                            _inString = !_inString;
                            if (!_inString && _verbatim)
                            {
                                if (nextchar == '"')
                                {
                                    _escape = true; // skip escaped quote
                                    _inString = true;
                                }
                                else
                                {
                                    _verbatim = false;
                                }
                            }
                            else if (_inString && lastchar == '@')
                            {
                                _verbatim = true;
                            }
                        }
                        break;
                    case '\'':
                        if (!(_inString || _lineComment || _blockComment))
                        {
                            _inChar = !_inChar;
                        }
                        break;
                    case '\\':
                        if ((_inString && !_verbatim) || _inChar)
                            _escape = true; // skip next character
                        break;
                }
                #endregion

                if (_lineComment || _blockComment || _inString || _inChar)
                {
                    if (_wordBuilder.Length > 0)
                        _block.LastWord = _wordBuilder.ToString();
                    _wordBuilder.Length = 0;
                    continue;
                }

                if (!char.IsWhiteSpace(c) && c != '[' && c != '/')
                {
                    if (_block.Bracket == '{')
                        _block.Continuation = true;
                }

                if (char.IsLetterOrDigit(c))
                {
                    _wordBuilder.Append(c);
                }
                else
                {
                    if (_wordBuilder.Length > 0)
                        _block.LastWord = _wordBuilder.ToString();
                    _wordBuilder.Length = 0;
                }

                #region Push/Pop the blocks
                switch (c)
                {
                    case '{':
                        _block.ResetOneLineBlock();
                        _blocks.Push(_block);
                        _block.StartLine = doc.LineNumber;
                        if (_block.LastWord == "switch")
                        {
                            _block.Indent(set.IndentString + set.IndentString);
                            /* oldBlock refers to the previous line, not the previous block
							 * The block we want is not available anymore because it was never pushed.
							 * } else if (oldBlock.OneLineBlock) {
							// Inside a one-line-block is another statement
							// with a full block: indent the inner full block
							// by one additional level
							block.Indent(set, set.IndentString + set.IndentString);
							block.OuterIndent += set.IndentString;
							// Indent current line if it starts with the '{' character
							if (i == 0) {
								oldBlock.InnerIndent += set.IndentString;
							}*/
                        }
                        else
                        {
                            _block.Indent(set);
                        }
                        _block.Bracket = '{';
                        break;
                    case '}':
                        while (_block.Bracket != '{')
                        {
                            if (_blocks.Count == 0) break;
                            _block = _blocks.Pop();
                        }
                        if (_blocks.Count == 0) break;
                        _block = _blocks.Pop();
                        _block.Continuation = false;
                        _block.ResetOneLineBlock();
                        break;
                    case '(':
                    case '[':
                        _blocks.Push(_block);
                        if (_block.StartLine == doc.LineNumber)
                            _block.InnerIndent = _block.OuterIndent;
                        else
                            _block.StartLine = doc.LineNumber;
                        _block.Indent(Repeat(set.IndentString, oldBlock.OneLineBlock) +
                                     (oldBlock.Continuation ? set.IndentString : "") +
                                     (i == line.Length - 1 ? set.IndentString : new string(' ', i + 1)));
                        _block.Bracket = c;
                        break;
                    case ')':
                        if (_blocks.Count == 0) break;
                        if (_block.Bracket == '(')
                        {
                            _block = _blocks.Pop();
                            if (IsSingleStatementKeyword(_block.LastWord))
                                _block.Continuation = false;
                        }
                        break;
                    case ']':
                        if (_blocks.Count == 0) break;
                        if (_block.Bracket == '[')
                            _block = _blocks.Pop();
                        break;
                    case ';':
                    case ',':
                        _block.Continuation = false;
                        _block.ResetOneLineBlock();
                        break;
                    case ':':
                        if (_block.LastWord == "case"
                            || line.StartsWith("case ", StringComparison.Ordinal)
                            || line.StartsWith(_block.LastWord + ":", StringComparison.Ordinal))
                        {
                            _block.Continuation = false;
                            _block.ResetOneLineBlock();
                        }
                        break;
                }

                if (!char.IsWhiteSpace(c))
                {
                    // register this char as last char
                    _lastRealChar = c;
                }
                #endregion
            }
            #endregion

            if (_wordBuilder.Length > 0)
                _block.LastWord = _wordBuilder.ToString();
            _wordBuilder.Length = 0;

            if (startInString) return;
            if (startInComment && line[0] != '*') return;
            if (doc.Text.StartsWith("//\t", StringComparison.Ordinal) || doc.Text == "//")
                return;

            if (line[0] == '}')
            {
                indent.Append(oldBlock.OuterIndent);
                oldBlock.ResetOneLineBlock();
                oldBlock.Continuation = false;
            }
            else
            {
                indent.Append(oldBlock.InnerIndent);
            }

            if (indent.Length > 0 && oldBlock.Bracket == '(' && line[0] == ')')
            {
                indent.Remove(indent.Length - 1, 1);
            }
            else if (indent.Length > 0 && oldBlock.Bracket == '[' && line[0] == ']')
            {
                indent.Remove(indent.Length - 1, 1);
            }

            if (line[0] == ':')
            {
                oldBlock.Continuation = true;
            }
            else if (_lastRealChar == ':' && indent.Length >= set.IndentString.Length)
            {
                if (_block.LastWord == "case" || line.StartsWith("case ", StringComparison.Ordinal) || line.StartsWith(_block.LastWord + ":", StringComparison.Ordinal))
                    indent.Remove(indent.Length - set.IndentString.Length, set.IndentString.Length);
            }
            else if (_lastRealChar == ')')
            {
                if (IsSingleStatementKeyword(_block.LastWord))
                {
                    _block.OneLineBlock++;
                }
            }
            else if (_lastRealChar == 'e' && _block.LastWord == "else")
            {
                _block.OneLineBlock = Math.Max(1, _block.PreviousOneLineBlock);
                _block.Continuation = false;
                oldBlock.OneLineBlock = _block.OneLineBlock - 1;
            }

            if (doc.IsReadOnly)
            {
                // We can't change the current line, but we should accept the existing
                // indentation if possible (=if the current statement is not a multiline
                // statement).
                if (!oldBlock.Continuation && oldBlock.OneLineBlock == 0 &&
                    oldBlock.StartLine == _block.StartLine &&
                    _block.StartLine < doc.LineNumber && _lastRealChar != ':')
                {
                    // use indent StringBuilder to get the indentation of the current line
                    indent.Length = 0;
                    line = doc.Text; // get untrimmed line
                    foreach (var t in line)
                    {
                        if (!char.IsWhiteSpace(t))
                            break;
                        indent.Append(t);
                    }
                    // /* */ multiline comments have an extra space - do not count it
                    // for the block's indentation.
                    if (startInComment && indent.Length > 0 && indent[indent.Length - 1] == ' ')
                    {
                        indent.Length -= 1;
                    }
                    _block.InnerIndent = indent.ToString();
                }
                return;
            }

            if (line[0] != '{')
            {
                if (line[0] != ')' && oldBlock.Continuation && oldBlock.Bracket == '{')
                    indent.Append(set.IndentString);
                indent.Append(Repeat(set.IndentString, oldBlock.OneLineBlock));
            }

            // this is only for blockcomment lines starting with *,
            // all others keep their old indentation
            if (startInComment)
                indent.Append(' ');

            if (indent.Length != (doc.Text.Length - line.Length) ||
                !doc.Text.StartsWith(indent.ToString(), StringComparison.Ordinal) ||
                char.IsWhiteSpace(doc.Text[indent.Length]))
            {
                doc.Text = indent + line;
            }
        }

19 View Source File : AsbStringExtensions.cs
License : MIT License
Project Creator : ARKlab

public static string ToValidAzureServiceBusEnreplacedyName(this string topic)
        {
            return string.Concat(topic
                .Select(c => char.IsLetterOrDigit(c) || c == '/' ? char.ToLower(c) : '_'));
        }

19 View Source File : CharExtension.cs
License : MIT License
Project Creator : AlphaYu

public static bool IsLetterOrDigit(this char c)
        {
            return char.IsLetterOrDigit(c);
        }

19 View Source File : NaturalTextGenerator.cs
License : MIT License
Project Creator : azist

private static bool filter(char chr)
    {
      return chr=='\'' || chr=='-' || Char.IsLetterOrDigit(chr);
    }

19 View Source File : JsonTextReader.cs
License : MIT License
Project Creator : akaskela

private void ParseConstructor()
        {
            if (MatchValueWithTrailingSeparator("new"))
            {
                EatWhitespace(false);

                int initialPosition = _charPos;
                int endPosition;

                while (true)
                {
                    char currentChar = _chars[_charPos];
                    if (currentChar == '\0')
                    {
                        if (_charsUsed == _charPos)
                        {
                            if (ReadData(true) == 0)
                            {
                                throw JsonReaderException.Create(this, "Unexpected end while parsing constructor.");
                            }
                        }
                        else
                        {
                            endPosition = _charPos;
                            _charPos++;
                            break;
                        }
                    }
                    else if (char.IsLetterOrDigit(currentChar))
                    {
                        _charPos++;
                    }
                    else if (currentChar == StringUtils.CarriageReturn)
                    {
                        endPosition = _charPos;
                        ProcessCarriageReturn(true);
                        break;
                    }
                    else if (currentChar == StringUtils.LineFeed)
                    {
                        endPosition = _charPos;
                        ProcessLineFeed();
                        break;
                    }
                    else if (char.IsWhiteSpace(currentChar))
                    {
                        endPosition = _charPos;
                        _charPos++;
                        break;
                    }
                    else if (currentChar == '(')
                    {
                        endPosition = _charPos;
                        break;
                    }
                    else
                    {
                        throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, currentChar));
                    }
                }

                _stringReference = new StringReference(_chars, initialPosition, endPosition - initialPosition);
                string constructorName = _stringReference.ToString();

                EatWhitespace(false);

                if (_chars[_charPos] != '(')
                {
                    throw JsonReaderException.Create(this, "Unexpected character while parsing constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
                }

                _charPos++;

                ClearRecentString();

                SetToken(JsonToken.StartConstructor, constructorName);
            }
            else
            {
                throw JsonReaderException.Create(this, "Unexpected content while parsing JSON.");
            }
        }

19 View Source File : GenericLexer.cs
License : MIT License
Project Creator : b3b00

public void AddStringLexem(IN token,  BuildResult<ILexer<IN>> result , string stringDelimiter,
            string escapeDelimiterChar = "\\")
        {
            if (string.IsNullOrEmpty(stringDelimiter) || stringDelimiter.Length > 1)
                result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
                    I18N.Instance.GetText(I18n,Message.StringDelimiterMustBe1Char,stringDelimiter,token.ToString()),
                    ErrorCodes.LEXER_STRING_DELIMITER_MUST_BE_1_CHAR));
            if (stringDelimiter.Length == 1 && char.IsLetterOrDigit(stringDelimiter[0]))
                result.AddError(new InitializationError(ErrorLevel.FATAL,
                    I18N.Instance.GetText(I18n,Message.StringDelimiterCannotBeLetterOrDigit,stringDelimiter,token.ToString()),
                    ErrorCodes.LEXER_STRING_DELIMITER_CANNOT_BE_LETTER_OR_DIGIT));

            if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
                result.AddError(new InitializationError(ErrorLevel.FATAL,
                    I18N.Instance.GetText(I18n,Message.StringEscapeCharMustBe1Char,escapeDelimiterChar,token.ToString()),
                    ErrorCodes.LEXER_STRING_ESCAPE_CHAR_MUST_BE_1_CHAR));
            if (escapeDelimiterChar.Length == 1 && char.IsLetterOrDigit(escapeDelimiterChar[0]))
                result.AddError(new InitializationError(ErrorLevel.FATAL,
                    I18N.Instance.GetText(I18n,Message.StringEscapeCharCannotBeLetterOrDigit,escapeDelimiterChar,token.ToString()),
                    ErrorCodes.LEXER_STRING_ESCAPE_CHAR_CANNOT_BE_LETTER_OR_DIGIT));

            StringDelimiterChar = (char)0;
            var stringDelimiterChar = (char)0;

            EscapeStringDelimiterChar = (char)0;
            var escapeStringDelimiterChar = (char)0;
            
            if (stringDelimiter.Length == 1)
            {
                StringCounter++;

                StringDelimiterChar = stringDelimiter[0];
                stringDelimiterChar = stringDelimiter[0];

                EscapeStringDelimiterChar = escapeDelimiterChar[0];
                escapeStringDelimiterChar = escapeDelimiterChar[0];
            }


            NodeCallback<GenericToken> callback = match =>
            {
                match.Properties[DerivedToken] = token;
                var value = match.Result.SpanValue;

                match.Result.SpanValue = value;

                match.StringDelimiterChar = stringDelimiterChar;
                match.IsString = true;
                if (stringDelimiterChar != escapeStringDelimiterChar)
                {
                    match.Result.SpanValue = diffCharEscaper(escapeStringDelimiterChar,stringDelimiterChar, match.Result.SpanValue);
                }
                else
                {                   
                    match.Result.SpanValue = sameCharEscaper(escapeStringDelimiterChar,stringDelimiterChar, match.Result.SpanValue);
                }

                return match;
            };

            if (stringDelimiterChar != escapeStringDelimiterChar)
            {

                FSMBuilder.GoTo(start);
                FSMBuilder.Transition(stringDelimiterChar)
                    .Mark(in_string + StringCounter)
                    .ExceptTransitionTo(new[] { stringDelimiterChar, escapeStringDelimiterChar },
                        in_string + StringCounter)
                    .Transition(escapeStringDelimiterChar)
                    .Mark(escape_string + StringCounter)
                    .ExceptTransitionTo(new[] { stringDelimiterChar }, in_string + StringCounter)
                    .GoTo(escape_string + StringCounter)
                    .TransitionTo(stringDelimiterChar, in_string + StringCounter)
                    .Transition(stringDelimiterChar)
                    .End(GenericToken.String)
                    .Mark(string_end + StringCounter)
                    .CallBack(callback);
                FSMBuilder.Fsm.StringDelimiter = stringDelimiterChar;
            }
            else
            {
                var exceptDelimiter = new[] { stringDelimiterChar };
                var in_string = "in_string_same";
                var escaped = "escaped_same";
                var delim = "delim_same";

                FSMBuilder.GoTo(start)
                    .Transition(stringDelimiterChar)
                    .Mark(in_string + StringCounter)
                    .ExceptTransitionTo(exceptDelimiter, in_string + StringCounter)
                    .Transition(stringDelimiterChar)
                    .Mark(escaped + StringCounter)
                    .End(GenericToken.String)
                    .CallBack(callback)
                    .Transition(stringDelimiterChar)
                    .Mark(delim + StringCounter)
                    .ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);

                FSMBuilder.GoTo(delim + StringCounter)
                    .TransitionTo(stringDelimiterChar, escaped + StringCounter)
                    .ExceptTransitionTo(exceptDelimiter, in_string + StringCounter);
            }
        }

19 View Source File : Scanner.cs
License : Apache License 2.0
Project Creator : alaatm

private void ReadIdentifier()
        {
            while (char.IsLetterOrDigit(Peek()))
            {
                Advance();
            }

            var text = _source.Substring(_start, _current - _start);

            // "not" can only be used with "like"
            if (text.ToLower() == "not")
            {
                while (char.IsWhiteSpace(Peek()))
                {
                    Advance();
                }

                var start = _current;

                while (char.IsLetter(Peek()))
                {
                    Advance();
                }

                text = _source.Substring(start, _current - start).ToLower();
                if (text == "like")
                {
                    AddToken(TokenType.NotLike);
                }
                else
                {
                    throw new QueryEngineException($"Unexpected character at position '{start + 1}': \"not\" keyword may only be used with \"like\" keyword.");
                }
            }
            else
            {
                var type = _keywords.ContainsKey(text.ToLower()) ? _keywords[text.ToLower()] : (TokenType?)null;
                AddToken(type is null ? TokenType.Identifier : type.Value);
            }
        }

19 View Source File : Tokeniser.cs
License : MIT License
Project Creator : atifaziz

State GetDirectiveName ()
        {
            int start = position;
            for (; position < content.Length; position++) {
                char c = content [position];
                if (!Char.IsLetterOrDigit (c)) {
                    value = content.Substring (start, position - start);
                    return State.Directive;
                }
                nextStateLocation = nextStateLocation.AddCol ();
            }
            throw new ParserException ("Unexpected end of file.", nextStateLocation);
        }

19 View Source File : AddonWindow.xaml.cs
License : GNU General Public License v3.0
Project Creator : armandoalonso

private void AddonTextEditor_TextEntering(object sender, TextCompositionEventArgs e)
        {
            if (e.Text.Length > 0 && completionWindow != null)
            {
                if (!char.IsLetterOrDigit(e.Text[0]) && !char.IsWhiteSpace(e.Text[0]) && !char.IsSymbol(e.Text[0]))
                {
                    // Whenever a non-letter is typed while the completion window is open,
                    // insert the currently selected element.
                    completionWindow.CompletionList.RequestInsertion(e);
                }
            }
            // Do not set e.Handled=true.
            // We still want to insert the character that was typed.
        }

19 View Source File : StringExtensions.cs
License : MIT License
Project Creator : allisterb

public static bool IsAlphaNumeric(this string value)
        {
            return value.All(c => Char.IsLetterOrDigit(c));
        }

19 View Source File : GLSLESPreprocessor.cs
License : GNU Lesser General Public License v2.1
Project Creator : axiom3d

public Token GetToken( bool expand )
		{
			int index = 0;
			char c = this.Source[ index ];
			if ( c == '\n' || this.Source == System.Environment.NewLine )
			{
				this.Line++;
				this.BOL = true;
				if ( c == '\r' )
				{
					index++;
				}
				return new Token( Token.Kind.Newline, this.Source, this.Source.Length - index );
			}
			else if ( Char.IsWhiteSpace( c ) )
			{
				while ( index < this.Source.Length && this.Source[ index ] != '\r' && this.Source[ index ] != '\n' && Char.IsWhiteSpace( this.Source[ index ] ) )
				{
					index++;
				}

				return new Token( Token.Kind.Whitespace, this.Source, index );
			}
			else if ( Char.IsDigit( c ) )
			{
				this.BOL = false;
				if ( c == '0' && this.Source[ 1 ] == 'x' ) //hex numbers
				{
					index++;
					while ( index < this.Source.Length && char.IsNumber( this.Source[ index ] ) )
					{
						index++;
					}
				}
				else
				{
					while ( index < this.Source.Length && Char.IsDigit( this.Source[ index ] ) )
					{
						index++;
					}
				}

				return new Token( Token.Kind.Number, this.Source, index );
			}
			else if ( c == '_' || Char.IsLetterOrDigit( c ) )
			{
				this.BOL = false;

				while ( index < this.Source.Length && ( this.Source[ index ] == '_' || Char.IsLetterOrDigit( this.Source[ index ] ) ) )
				{
					index++;
				}

				return new Token( Token.Kind.Number, this.Source, index );
			}
			else if ( c == '"' || c == '\'' )
			{
				this.BOL = false;
				while ( index < this.Source.Length && this.Source[ index ] != c )
				{
					if ( this.Source[ index ] == '\\' )
					{
						index++;
						if ( index >= this.Source.Length )
						{
							break;
						}
					}
					if ( this.Source[ index ] == '\n' )
					{
						this.Line++;
					}
					index++;
				}
				if ( index < this.Source.Length )
				{
					index++;
				}
				return new Token( Token.Kind.String, this.Source, index );
			}
			else if ( c == '/' && this.Source[ index ] == '/' )
			{
				this.BOL = false;
				index++;
				while ( index < this.Source.Length && this.Source[ index ] != '\r' && this.Source[ index ] != '\n' )
				{
					return new Token( Token.Kind.Linecomment, this.Source, index );
				}
			}
			else if ( c == '/' && this.Source[ index ] == '*' )
			{
				this.BOL = false;
				index++;

				while ( index < this.Source.Length && ( this.Source[ 0 ] != '*' || this.Source[ 1 ] != '/' ) )
				{
					if ( this.Source[ index ] == '\n' )
					{
						this.Line++;
					}
					index++;
				}
				if ( index < this.Source.Length && this.Source[ index ] == '*' )
				{
					index++;
				}
				if ( index < this.Source.Length && this.Source[ index ] == '/' )
				{
					index++;
				}
				return new Token( Token.Kind.Comment, this.Source, index );
			}
			else if ( c == '#' && this.BOL )
			{
				//Skip all whitespaces after '#'
				while ( index < this.Source.Length && Char.IsWhiteSpace( this.Source[ index ] ) )
				{
					index++;
				}
				while ( index < this.Source.Length && !char.IsWhiteSpace( this.Source[ index ] ) )
				{
					index++;
				}
				return new Token( Token.Kind.Directive, this.Source, index );
			}
			else if ( c == '\\' && index < this.Source.Length && ( this.Source[ index ] == '\r' || this.Source[ index ] == '\n' ) )
			{
				//Treat backslash-newline as a whole token
				if ( this.Source[ index ] == '\r' )
				{
					index++;
				}
				if ( this.Source[ index ] == '\n' )
				{
					index++;
				}
				this.Line++;
				this.BOL = true;
				return new Token( Token.Kind.Linecont, this.Source, index );
			}
			else
			{
				this.BOL = false;
				//Handle double-char operators here

				if ( c == '>' && this.Source[ index ] == '>' || this.Source[ index ] == '=' )
				{
					index++;
				}
				else if ( c == '<' && this.Source[ index ] == '<' || this.Source[ index ] == '=' )
				{
					index++;
				}
				else if ( c == '!' && this.Source[ index ] == '=' )
				{
					index++;
				}
				else if ( c == '=' && this.Source[ index ] == '=' )
				{
					index++;
				}
				else if ( ( c == '|' || c == '&' || c == '^' ) && this.Source[ index ] == c )
				{
					index++;
				}

				return new Token( Token.Kind.Punctuation, this.Source, index );
			}

			return Token.Error;
		}

19 View Source File : Wallet.cs
License : Apache License 2.0
Project Creator : ajuna-network

public bool IsValidWalletName(string walletName)
        {
            return walletName.Length > 4 && walletName.Length < 21 &&
                   walletName.All(c => char.IsLetterOrDigit(c) || c.Equals('_'));
        }

19 View Source File : Sources.cs
License : MIT License
Project Creator : azist

public string InferClreplacedName()
      {
          var name = Path.GetFileNameWithoutExtension(FileName).Trim();

          var result = new StringBuilder(name.Length);
          var first = true;
          foreach(var c in name)
          {
             if ((first && !char.IsLetter(c)) || !char.IsLetterOrDigit(c))
                result.Append("_");
             else
                result.Append(c);

             first = false;
          }

          return result.ToString();
      }

19 View Source File : CsharpFromJsonExampleFactory.cs
License : BSD 3-Clause "New" or "Revised" License
Project Creator : Altinn

private static IEnumerable<char> SafeCsNameCharacters(string name, bool upperCaseFirstCharacter)
        {
            if (string.IsNullOrEmpty(name))
            {
                yield break;
            }

            var first = true;
            foreach (var c in name)
            {
                if (first)
                {
                    if (c == '_' || char.IsLetter(c))
                    {
                        yield return upperCaseFirstCharacter ? char.ToUpper(c) : c;
                    }
                    else
                    {
                        yield return '_';
                    }

                    first = false;
                }
                else
                {
                    yield return c == '_' || char.IsLetterOrDigit(c) ? c : '_';
                }
            }
        }

19 View Source File : NaturalTextGenerator.cs
License : MIT License
Project Creator : azist

private static void scrollToWordStart(string text, ref int i)
    {
      while(true)
      {
        var chr = text[i];
        if (chr==' ' || chr=='.' || chr==',' || chr=='?' || chr=='!' || chr=='\r' || chr=='\n') break;

        i++;
        if (i==text.Length) i=0;
      }

      while(!Char.IsLetterOrDigit(text[i]))
      {
        i++;
        if (i==text.Length) i=0;
      }
    }

19 View Source File : XmlHighlightingDefinition.cs
License : MIT License
Project Creator : Abdesol

static bool IsSimpleWord(string word)
			{
				return char.IsLetterOrDigit(word[0]) && char.IsLetterOrDigit(word, word.Length - 1);
			}

19 View Source File : TypeLookupHandler.cs
License : MIT License
Project Creator : azist

private bool isValidTypeNameKey(string key)
            {
              if (key==null) return false;

              for(var i=0; i<key.Length; i++)
              {
                var c = key[i];
                if (char.IsLetterOrDigit(c)) continue;
                if (c=='/' || c=='\\' || c=='-' || c=='_' || c=='.') continue;
                return false;
              }

              return true;
            }

19 View Source File : TemplateProcessor.cs
License : MIT License
Project Creator : ansel86castro

static string ReadSymbol(string template, ref int i)
        {
            if (IsSymbol(template, i, out bool matchCloseBracket))
            {
                StringBuilder sb = new StringBuilder();
                i += 2;

                if (matchCloseBracket)
                {
                    SkipSpaces(template, ref i);
                }

                while (i < template.Length && char.IsLetterOrDigit(template[i]) || template[i] == '_')
                {
                    sb.Append(template[i]);
                    i++;
                }

                if (matchCloseBracket)
                {
                    SkipSpaces(template, ref i);

                    if (template[i] != '}')
                        throw new InvalidOperationException($"Invalid Macro definition {sb.ToString()}{template[i]}");
                    i++;
                }

                return sb.ToString();
            }

            return null;
        }

19 View Source File : Program.cs
License : GNU General Public License v3.0
Project Creator : antman1p

public static void MemDump(string pidString, string memAddrStr)
        {

            int buffWidth = 16;
            int pid;
            int offset = 0x1000;
            int bytesRead = 0;

            Int64 baseAddr;
            var byteArray = new byte[offset];

            // Ensure the input pid is an integer
            try
            {
                pid = Convert.ToInt32(pidString);

            }
            // If not go to the help and alert the user
            catch (Exception ex)
            {
                Console.WriteLine("\nInput not an integer.  Please try again");
                help();
                pid = 0;
            }

            // Ensure the pid is to a running process
            try
            {
                Process proc = Process.GetProcessById(pid);
            }
            // If not go to the help an dinform the user
            catch(Exception ex)
            {
                Console.WriteLine("Not a valid process. \nError: {0}", ex);
                help();
            }

            // Ensure the input is a memory address in hex
            try
            {
                Convert.ToInt64(memAddrStr, 16);
            }
            // if not go to the help and alert the user
            catch (Exception ex)
            {
                Console.WriteLine("\nInvalid Memory address format.  Must be in hex, 0x... format.  \nError: {0}", ex);
                help();
            }

            // Create a new pointer from converting the user input string to a 64 bit integer 
            IntPtr base_mem_address = new IntPtr(Convert.ToInt64(memAddrStr, 16));

            

            try
            {
                // Windows API fucntion call opening the process with desired access level and saving the handle to the process 
                IntPtr pHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_WM_READ, false, pid);

                // Windows API call fucntion to read the process memory into a byte array
                ReadProcessMemory(pHandle, base_mem_address, byteArray, offset, ref bytesRead);

            }
            // If it fails, go to help and alert the user
            catch(Exception ex)
            {
                Console.WriteLine("Unable to dump memory.  \nError: {0}", ex);
                help();
            }

            int position = 0;
            int padding = (buffWidth * 2) + buffWidth;

            Console.WriteLine("\n");

            // Loop to print the memory dump to the consol ein "Hex Dump" typre format
            while (position < offset)
            {
                string line = "";
                line = "0x" + position.ToString("X8") + " ";
                string printBytes = "";
                string text = "";

                for(int i = 0; i < (buffWidth-1); i++)
                {
                    if(position >= offset) { break; }

                    printBytes += byteArray[position].ToString("X2") + " ";

                    if (char.IsLetterOrDigit((char)byteArray[position]) || char.IsPunctuation((char)byteArray[position]) || char.IsSymbol((char)byteArray[position]))
                    {
                        text += (char)byteArray[position];
                    }   
                    else
                    {
                        text += '.';
                    }
                    position++;

                }
                line += printBytes.PadRight(padding, ' ');
                line += " " + text;
                Console.WriteLine(line);

            }
        }

19 View Source File : ParentLexer.cs
License : MIT License
Project Creator : Actipro

protected virtual int ParseIdentifier(ITextBufferReader reader, char ch) {
			// Get the entire word
			int startOffset = reader.Offset - 1;
			while (!reader.IsAtEnd) {
				char ch2 = reader.Read();
				if ((!char.IsLetterOrDigit(ch2)) && (ch2 != '_')) {
					reader.ReadReverse();
					break;
				}
			}

			// This language only has one keyword named "date"
			if (reader.GetSubstring(startOffset, reader.Offset - startOffset) == "date")
				return ParentTokenId.DateKeyword;

			// Word is an identifier
			return ParentTokenId.Identifier;
		}

19 View Source File : ActionWindow.xaml.cs
License : GNU General Public License v3.0
Project Creator : armandoalonso

private void TextEditor_TextEntering(object sender, TextCompositionEventArgs e)
        {
            if (e.Text.Length > 0 && completionWindow != null)
            {
                if (!char.IsLetterOrDigit(e.Text[0]) && !char.IsWhiteSpace(e.Text[0]) && !char.IsSymbol(e.Text[0]))
                {
                    // Whenever a non-letter is typed while the completion window is open,
                    // insert the currently selected element.
                    completionWindow.CompletionList.RequestInsertion(e);
                }
            }
            // Do not set e.Handled=true.
            // We still want to insert the character that was typed.
        }

19 View Source File : AppUserService.cs
License : MIT License
Project Creator : alexyakunin

private async Task<string> NormalizeName(AppDbContext dbContext, string name, long userId, CancellationToken cancellationToken = default)
        {
            // Normalizing name
            var sb = StringBuilderEx.Acquire();
            foreach (var c in name) {
                if (char.IsLetterOrDigit(c) || c == '_' || c == '-')
                    sb.Append(c);
                else if (sb.Length == 0 || char.IsLetterOrDigit(sb[^1]))
                    sb.Append('_');
            }
            name = sb.ToStringAndRelease();
            if (name.Length < 4 || !char.IsLetter(name[0]))
                name = "user-" + name;

            // Finding the number @ the tail
            var numberStartIndex = name.Length;
            for (; numberStartIndex >= 1; numberStartIndex--) {
                if (!char.IsNumber(name[numberStartIndex - 1]))
                    break;
            }

            // Iterating through these tail numbers to get the unique user name
            var namePrefix = name.Substring(0, numberStartIndex);
            var nameSuffix = name.Substring(numberStartIndex);
            var nextNumber = long.TryParse(nameSuffix, out var number) ? number + 1 : 1;
            while (true) {
                var isNameUsed = await dbContext.Users.AsQueryable()
                    .AnyAsync(u => u.Name == name && u.Id != userId, cancellationToken);
                if (!isNameUsed)
                    break;
                name = namePrefix + nextNumber++;
            }
            return name;
        }

19 View Source File : NDesk.Options.cs
License : Apache License 2.0
Project Creator : atifaziz

private static bool IsEolChar (char c)
		{
			return !char.IsLetterOrDigit (c);
		}

19 View Source File : TextDefineProcessor.cs
License : GNU General Public License v3.0
Project Creator : arycama

public static string ProcessText(string text, Character player, Character npc)
	{
		// Loop through all characters of the original string
		var isReadingDefine = false;
		for(var i = 0; i < text.Length; i++)
		{
			if (isReadingDefine)
			{
				defineBuilder.Append(text[i]);

				if (!char.IsLetterOrDigit(text[i]))
				{
					var currentDefine = defineBuilder.ToString();
					defineBuilder.Clear();
					resultBuilder.Append(ProcessDefineInternal(currentDefine, player, npc));
					isReadingDefine = false;
				}
			}
			else
			{
				if (text[i] == '%')
					isReadingDefine = true;
				else
					resultBuilder.Append(text[i]);
			}
		}

		var result = resultBuilder.ToString();
		resultBuilder.Clear();
		return result;
	}

19 View Source File : Lexer.cs
License : MIT License
Project Creator : alirezanet

public SyntaxToken NextToken()
      {
         if (_position >= _text.Length) return new SyntaxToken(SyntaxKind.End, _position, "\0");

         var peek = Peek(1);
         switch (Current)
         {
            case '(':
               return new SyntaxToken(SyntaxKind.OpenParenthesisToken, _position++, "(");
            case ')':
               return new SyntaxToken(SyntaxKind.CloseParenthesis, _position++, ")");
            case ',':
               return new SyntaxToken(SyntaxKind.And, _position++, ",");
            case '|':
               return new SyntaxToken(SyntaxKind.Or, _position++, "|");
            case '^':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.StartsWith, _position++, "^");
            }
            case '$':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.EndsWith, _position++, "$");
            }
            case '!' when peek == '^':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.NotStartsWith, _position += 2, "!^");
            }
            case '!' when peek == '$':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.NotEndsWith, _position += 2, "!$");
            }
            case '=' when peek == '*':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.Like, _position += 2, "=*");
            }
            case '=':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.Equal, _position ++ , "=");
            }
            case '!' when peek == '=':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.NotEqual, _position += 2, "!=");
            }
            case '!' when peek == '*':
            {
               _waitingForValue = true;
               return new SyntaxToken(SyntaxKind.NotLike, _position += 2, "!*");
            }
            case '/' when peek == 'i':
               return new SyntaxToken(SyntaxKind.CaseInsensitive, _position += 2, "/i");
            case '<':
            {
               _waitingForValue = true;
               return peek == '=' ? new SyntaxToken(SyntaxKind.LessOrEqualThan, _position += 2, "<=") :
                  new SyntaxToken(SyntaxKind.LessThan, _position++, "<");
            }
            case '>':
            {
               _waitingForValue = true;
               return peek == '=' ? new SyntaxToken(SyntaxKind.GreaterOrEqualThan, _position += 2, ">=") : 
                  new SyntaxToken(SyntaxKind.GreaterThan, _position++, ">");
            }
         }

         if (Current == '[')
         {
            Next();
            var start = _position; 
            while (char.IsDigit(Current))  
               Next();
      
            var length = _position - start;
            var text = _text.Substring(start, length);

            if (Current == ']')
            {
               _position++;
               return new SyntaxToken(SyntaxKind.FieldIndexToken, start, text);
            }
            
            _diagnostics.Add($"bad character input: '{peek.ToString()}' at {_position++.ToString()}. expected ']' ");
            return new SyntaxToken(SyntaxKind.BadToken, _position, Current.ToString());

         }

         if (char.IsLetter(Current) && !_waitingForValue)
         {
            var start = _position;

            while (char.IsLetterOrDigit(Current) || Current is '_')  
               Next();

            var length = _position - start;
            var text = _text.Substring(start, length);
            
            return new SyntaxToken(SyntaxKind.FieldToken, start, text);
         }
         

         if (char.IsWhiteSpace(Current))
         {
            var start = _position;

            // skipper
            while (char.IsWhiteSpace(Current))
               Next();

            var length = _position - start;
            var text = _text.Substring(start, length);

            return new SyntaxToken(SyntaxKind.WhiteSpace, start, text);
         }

         if (_waitingForValue)
         {
            var start = _position;

            var exitCharacters = new[] {'(', ')', ',', '|'};
            var lastChar = '\0';
            while ((!exitCharacters.Contains(Current) || exitCharacters.Contains(Current) && lastChar == '\\') &&
                   _position < _text.Length &&
                   (!(Current == '/' && Peek(1) == 'i') || (Current == '/' && Peek(1) == 'i') && lastChar == '\\')) // exit on case-insensitive operator
            {
               lastChar = Current;
               Next();
            }

            var text = new StringBuilder();
            for (var i = start; i < _position; i++)
            {
               var current = _text[i];

               if (current != '\\') // ignore escape character
                  text.Append(current);
               else if (current == '\\' && i > 0) // escape escape character
                  if (_text[i - 1] == '\\')
                     text.Append(current);
            }

            _waitingForValue = false;
            return new SyntaxToken(SyntaxKind.ValueToken, start, text.ToString());
         }

         _diagnostics.Add($"bad character input: '{Current.ToString()}' at {_position.ToString()}");
         return new SyntaxToken(SyntaxKind.BadToken, _position++, string.Empty);
      }

19 View Source File : XmlHighlightingDefinition.cs
License : MIT License
Project Creator : AvaloniaUI

private static bool IsSimpleWord(string word)
            {
                return char.IsLetterOrDigit(word[0]) && char.IsLetterOrDigit(word, word.Length - 1);
            }

19 View Source File : Utils.cs
License : MIT License
Project Creator : agens-no

static bool DontNeedQuotes(string src)
        {
            // using a regex instead of explicit matching slows down common cases by 40%
            if (src.Length == 0)
                return false;

            bool hreplacedlash = false;
            for (int i = 0; i < src.Length; ++i)
            {
                char c = src[i];
                if (Char.IsLetterOrDigit(c) || c == '.' || c == '*' || c == '_')
                    continue;
                if (c == '/')
                {
                    hreplacedlash = true;
                    continue;
                }
                return false;
            }
            if (hreplacedlash)
            {
                if (src.Contains("//") || src.Contains("/*") || src.Contains("*/"))
                    return false;
            }
            return true;
        }

19 View Source File : Utilities.cs
License : Apache License 2.0
Project Creator : aws

public static bool TryGenerateECRRepositoryName(string projectName, out string repositoryName)
        {
            repositoryName = null;
            if (Directory.Exists(projectName))
            {
                projectName = new DirectoryInfo(projectName).Name;
            }
            else if(File.Exists(projectName))
            {
                projectName = Path.GetFileNameWithoutExtension(projectName);
            }

            projectName = projectName.ToLower();
            var sb = new StringBuilder();

            foreach(var c in projectName)
            {
                if(char.IsLetterOrDigit(c))
                {
                    sb.Append(c);
                }
                else if(sb.Length > 0 && (c == '.' || c == '_' || c == '-'))
                {
                    sb.Append(c);
                }
            }

            // Repository name must be at least 2 characters
            if(sb.Length > 1)
            {
                repositoryName = sb.ToString();

                // Max length of repository name is 256 characters.
                if (Constants.MAX_ECR_REPOSITORY_NAME_LENGTH < repositoryName.Length)
                {
                    repositoryName = repositoryName.Substring(0, Constants.MAX_ECR_REPOSITORY_NAME_LENGTH);
                }
            }

            return !string.IsNullOrEmpty(repositoryName);
        }

19 View Source File : StringExtensions.cs
License : MIT License
Project Creator : allisterb

public static string ToAlphaNumeric(this string s)
        {
            char[] chars = s.Where(c => Char.IsLetterOrDigit(c)).ToArray();
            return new String(chars);
        }

19 View Source File : AyExpression.cs
License : MIT License
Project Creator : ay2015

public static StringBuilder GetMaskedValue(string ayexpression, string text)
        {
            if (text.IsNull())
            {
                return new StringBuilder();
            }
            //版权引入TODO
            if (ayexpression.IsNull())
            {
                return new StringBuilder(text);
            }
            int ulength = text.Length;
            StringBuilder result = new StringBuilder();
            int uIndex = 0;
            int axlength = ayexpression.Length;
            for (int i = 0; i < axlength; i++)
            {
                if (uIndex >= ulength)
                {
                    int sd = ayexpression.Length - i;
                    if (sd > 0)
                    {
                        string _d = ayexpression.Substring(i, sd);
                        StringBuilder sbNext = new StringBuilder();
                        //检测剩余表达式,直接过滤
                        MatchCollection m0 = Regex.Matches(_d, @"\*\((?<ch>.+)\)");

                        List<string> filterString = new List<string>();
                        foreach (Match match in m0)
                        {
                            GroupCollection groups = match.Groups;
                            filterString.Add(groups[0].Value);
                        }
                        MatchCollection m1 = Regex.Matches(_d, @"\#\((?<ch>.+)\)");
                        foreach (Match match in m1)
                        {
                            GroupCollection groups = match.Groups;
                            filterString.Add(groups[0].Value);
                        }
                        MatchCollection m2 = Regex.Matches(_d, @"\%\((?<ch>.+)\)");
                        foreach (Match match in m2)
                        {
                            GroupCollection groups = match.Groups;
                            filterString.Add(groups[0].Value);
                        }
                        MatchCollection m3 = Regex.Matches(_d, @"\@\((?<ch>.+)\)");
                        foreach (Match match in m3)
                        {
                            GroupCollection groups = match.Groups;
                            filterString.Add(groups[0].Value);
                        }
                        foreach (var item in filterString)
                        {
                            _d = _d.Replace(item, "");
                        }
                        _d = _d.TrimStart(' ').TrimEnd(' ');
                        if (_d.Length > 0)
                        {
                            foreach (var subChar in specChar)
                            {
                                if (subChar == '\\')
                                {
                                    _d = _d.Replace("\\\\", "≌");
                                }
                                else
                                {
                                    _d = _d.Replace("\\" + subChar, "◇");
                                    _d = _d.Replace(subChar.ToString(), "");
                                    _d = _d.Replace("◇", subChar.ToString());
                                }
                            }
                            _d = _d.Replace("≌", "\\");
                        }

                        result.Append(_d);
                    }
                    break;
                }
                char _char = ayexpression[i];
                if (_char == '\\')
                {
                    char next = ayexpression[i + 1];
                    bool isOk = false;
                    foreach (char subChar in specChar)
                    {
                        if (next == subChar)
                        {
                            result.Append(subChar);
                            i++;
                            isOk = true;
                            break;
                        }
                    }
                    if (!isOk)
                    {
                        //判断是不是UL
                        if (next == 'U')
                        {
                            result.Append(char.ToUpper(text[uIndex]));
                            uIndex++;
                            i++;

                        }
                        else if (next == 'L')
                        {
                            result.Append(char.ToLower(text[uIndex]));
                            uIndex++;
                            i++;

                        }
                    }
                }
                else
                {
                    if (_char == '#') //匹配数字
                    {
                        int ds_1 = i + 1;
                        char next = ' ';
                        bool isEnd = false;
                        if (ds_1 == axlength)
                        {
                            isEnd = true;
                        }
                        else
                        {
                            next = ayexpression[i + 1];
                        }

                        if (!isEnd && next == '(')
                        {
                            int nextEndHu = ayexpression.IndexOfAny(new char[] { ')' }, i);
                            if (nextEndHu < 0)
                            {
                                throw new Exception("掩码规则不正确,错误位置:" + i + ",是否少了个右括号?");
                            }
                            string subAd = ayexpression.Substring(i, (nextEndHu - i + 1));
                            MatchCollection matches = Regex.Matches(subAd, @"\#\((?<ch>.+)\)");
                            int xingVal = 0;
                            string xingValue = null;
                            foreach (Match match in matches)
                            {
                                GroupCollection groups = match.Groups;
                                xingValue = groups["ch"].Value;
                                if (string.IsNullOrEmpty(xingValue))
                                {
                                    throw new Exception("#(number)掩码规则出错,错误位置:" + i + ",缺少限定值数字");
                                }
                                xingVal = xingValue.ToInt();
                                if (xingVal == 0)
                                {
                                    throw new Exception("掩码规则不正确,错误位置:" + i + ",括号内数字不能为0或者其他非数字字符");
                                }
                            }
                            for (int mm = 0; mm < xingVal; mm++)
                            {
                                bool _dig = false;
                                for (int j = uIndex; j < ulength; j++)
                                {
                                    if (char.IsDigit(text[j]))
                                    {
                                        _dig = true;
                                        result.Append(text[j]);
                                    }
                                    if (_dig)
                                    {
                                        uIndex++;
                                        break;
                                    }
                                    else
                                    {
                                        uIndex++;
                                    }
                                }
                            }
                            i = i + xingValue.Length + 2;
                        }
                        else
                        {

                            bool _dig = false;
                            for (int j = uIndex; j < ulength; j++)
                            {
                                if (char.IsDigit(text[j]))
                                {
                                    _dig = true;
                                    result.Append(text[j]);
                                }
                                if (_dig)
                                {
                                    uIndex++;
                                    break;
                                }
                                else
                                {
                                    uIndex++;
                                }

                            }
                        }

                    }
                    else if (_char == '@') //匹配字母
                    {

                        int ds_1 = i + 1;
                        char next = ' ';
                        bool isEnd = false;
                        if (ds_1 == axlength)
                        {
                            isEnd = true;
                        }
                        else
                        {
                            next = ayexpression[i + 1];
                        }

                        if (!isEnd && next == '(')
                        {
                            int nextEndHu = ayexpression.IndexOfAny(new char[] { ')' }, i);
                            if (nextEndHu < 0)
                            {
                                throw new Exception("掩码规则不正确,错误位置:" + i + ",是否少了个右括号?");
                            }
                            string subAd = ayexpression.Substring(i, (nextEndHu - i + 1));
                            MatchCollection matches = Regex.Matches(subAd, @"\@\((?<ch>.+)\)");
                            int xingVal = 0;
                            string xingValue = null;
                            foreach (Match match in matches)
                            {
                                GroupCollection groups = match.Groups;
                                xingValue = groups["ch"].Value;
                                if (string.IsNullOrEmpty(xingValue))
                                {
                                    throw new Exception("@(number)掩码规则出错,错误位置:" + i + ",缺少限定值数字");
                                }
                                xingVal = xingValue.ToInt();
                                if (xingVal == 0)
                                {
                                    throw new Exception("掩码规则不正确,错误位置:" + i + ",括号内数字不能为0或者其他非数字字符");
                                }
                            }
                            for (int mm = 0; mm < xingVal; mm++)
                            {
                                bool _dig = false;
                                for (int j = uIndex; j < ulength; j++)
                                {
                                    if (char.IsLetter(text[j]))
                                    {
                                        _dig = true;
                                        result.Append(text[j]);
                                    }
                                    if (_dig)
                                    {
                                        uIndex++;
                                        break;
                                    }
                                    else
                                    {
                                        uIndex++;
                                    }
                                }
                            }
                            i = i + xingValue.Length + 2;

                        }
                        else
                        {
                            bool _dig = false;
                            for (int j = uIndex; j < ulength; j++)
                            {
                                if (char.IsLetter(text[j]))
                                {
                                    _dig = true;
                                    result.Append(text[j]);
                                }
                                if (_dig)
                                {
                                    uIndex++;
                                    break;
                                }
                                else
                                {
                                    uIndex++;
                                }
                            }
                        }
                    }
                    else if (_char == '%') //匹配字母和数字
                    {
                        int ds_1 = i + 1;
                        char next = ' ';
                        bool isEnd = false;
                        if (ds_1 == axlength)
                        {
                            isEnd = true;
                        }
                        else
                        {
                            next = ayexpression[i + 1];
                        }

                        if (!isEnd && next == '(')
                        {
                            int nextEndHu = ayexpression.IndexOfAny(new char[] { ')' }, i);
                            if (nextEndHu < 0)
                            {
                                throw new Exception("掩码规则不正确,错误位置:" + i + ",是否少了个右括号?");
                            }
                            string subAd = ayexpression.Substring(i, (nextEndHu - i + 1));
                            MatchCollection matches = Regex.Matches(subAd, @"\%\((?<ch>.+)\)");
                            int xingVal = 0;
                            string xingValue = null;
                            foreach (Match match in matches)
                            {
                                GroupCollection groups = match.Groups;
                                xingValue = groups["ch"].Value;
                                if (string.IsNullOrEmpty(xingValue))
                                {
                                    throw new Exception("%(number)掩码规则出错,错误位置:" + i + ",缺少限定值数字");
                                }
                                xingVal = xingValue.ToInt();
                                if (xingVal == 0)
                                {
                                    throw new Exception("掩码规则不正确,错误位置:" + i + ",括号内数字不能为0或者其他非数字字符");
                                }
                            }
                            for (int mm = 0; mm < xingVal; mm++)
                            {
                                bool _dig = false;
                                for (int j = uIndex; j < ulength; j++)
                                {
                                    if (char.IsLetterOrDigit(text[j]))
                                    {
                                        _dig = true;
                                        result.Append(text[j]);
                                    }
                                    if (_dig)
                                    {
                                        uIndex++;
                                        break;
                                    }
                                    else
                                    {
                                        uIndex++;
                                    }
                                }
                            }
                            i = i + xingValue.Length + 2;

                        }
                        else
                        {
                            bool _dig = false;
                            for (int j = uIndex; j < ulength; j++)
                            {
                                if (char.IsLetterOrDigit(text[j]))
                                {
                                    _dig = true;
                                    result.Append(text[j]);
                                }
                                if (_dig)
                                {
                                    uIndex++;
                                    break;
                                }
                                else
                                {
                                    uIndex++;
                                }
                            }
                        }
                    }
                    else if (_char == '*') //匹配任意
                    {
                        //判断下一个是不是括号
                        int ds_1 = i + 1;
                        char next = ' ';
                        bool isEnd = false;
                        if (ds_1 == axlength)
                        {
                            isEnd = true;
                        }
                        else
                        {
                            next = ayexpression[i + 1];
                        }

                        if (!isEnd && next == '(')
                        {
                            int nextEndHu = 0;
                            bool isFindRightHu = false;
                            int _i = i;
                            int max_i = 30;
                            int max_i_i = 0;
                            do
                            {
                                nextEndHu = ayexpression.IndexOfAny(new char[] { ')' }, _i);
                                var ch = ayexpression[nextEndHu - 1];
                                if (ch != '\\')
                                {
                                    isFindRightHu = true;
                                }
                                _i = nextEndHu + 1;
                                max_i_i++;
                                if (max_i_i == max_i)
                                {
                                    throw new Exception("掩码规则不正确,错误位置:" + i + ",请检查你的表达式");
                                }
                            } while (!isFindRightHu);

                            if (nextEndHu < 0)
                            {
                                throw new Exception("掩码规则不正确,错误位置:" + i + ",是否少了个右括号?");
                            }
                            string subAd = ayexpression.Substring(i, (nextEndHu - i + 1));
                            MatchCollection matches = Regex.Matches(subAd, @"\*\((?<cha>.+)\)");
                            int xingVal = 0;
                            string xingValue = null;
                            foreach (Match match in matches)
                            {
                                GroupCollection groups = match.Groups;
                                xingValue = groups["cha"].Value;
                                if (string.IsNullOrEmpty(xingValue))
                                {
                                    throw new Exception("*(number)掩码规则出错,错误位置:" + i + ",缺少限定值数字");
                                }

                            }
                            xingVal = xingValue.ToInt();
                            if (xingVal == 0)
                            {
                                if (subAd.Contains(" ^> "))
                                {
                                    string[] _resultString = Regex.Split(xingValue, @" \^> ", RegexOptions.IgnoreCase);
                                    if (_resultString.Length != 2)
                                    {
                                        throw new Exception("*前置替换规则出错,错误位置:" + i);
                                    }
                                    var _r1 = _resultString[0];
                                    string dstr = null;
                                    int _otherLen = ulength - uIndex;
                                    if (_r1 == "?")
                                    {
                                        dstr = text.Substring(uIndex, _otherLen - 1);
                                    }
                                    else
                                    {
                                        dstr = text.Substring(uIndex, Math.Min(_r1.ToInt(), Math.Min(_otherLen, text.Length)));
                                    }
                                    string _d = _resultString[1];
                                    var _d1 = _d.Split('^');
                                    var _d11 = _d1[0];

                                    var _d12 = _d1[1];
                                    var _e1 = Regex.Split(_d12, " -> ", RegexOptions.IgnoreCase);
                                    var _e11 = _e1[0];
                                    var _e12 = _e1[1];
                                    //处理 _e11 和 _e12
                                    foreach (var subChar in specChar)
                                    {
                                        if (subChar == '\\')
                                        {
                                            _e11 = _e11.Replace("\\\\", "≌");
                                            _e12 = _e12.Replace("\\\\", "≌");
                                        }
                                        else
                                        {
                                            _e11 = _e11.Replace("\\" + subChar, "◇");
                                            _e11 = _e11.Replace(subChar.ToString(), "");
                                            _e11 = _e11.Replace("◇", subChar.ToString());

                                            _e12 = _e12.Replace("\\" + subChar, "◇");
                                            _e12 = _e12.Replace(subChar.ToString(), "");
                                            _e12 = _e12.Replace("◇", subChar.ToString());
                                        }
                                    }
                                    _e11 = _e11.Replace("≌", "\\");

                                    if (_d11 == "?")
                                    {
                                        dstr = dstr.Replace(_e11, _e12);
                                        result.Append(dstr);
                                        uIndex = ulength;
                                        i = i + xingValue.Length + 2;
                                    }
                                    else
                                    if (_d11.Contains("+"))  //连续替换
                                    {
                                        string end = dstr;
                                        int _f = (_d11.Substring(1, _d11.Length - 1)).ToInt();
                                        int _f_index = 0;
                                        int _f_count = GetSubStrCountInStr(dstr, _e11, 0).Length;
                                        for (int _g = 0; _g < _f_count; _g++)
                                        {
                                            end = AyReplaceByPlace(end, _e11, _e12, 1);
                                            _f_index++;
                                            if (_f_index == _f)
                                            {
                                                break;
                                            }
                                        }

                                        result.Append(end);

                                        uIndex = ulength;
                                        i = i + xingValue.Length + 2;
                                    }
                                    else //指定第几个替换
                                    {
                                        int _f = _d11.ToInt();
                                        var end = AyReplaceByPlace(dstr, _e11, _e12, _f);
                                        result.Append(end);

                                        uIndex = ulength;
                                        i = i + xingValue.Length + 2;
                                    }
                                }
                                else if (subAd.Contains(" ^< "))  //开始
                                {

                                    string[] _resultString = Regex.Split(xingValue, @" \^< ", RegexOptions.IgnoreCase);
                                    if (_resultString.Length != 2)
                                    {
                                        throw new Exception("*后置替换规则出错,错误位置:" + i);
                                    }
                                    var _r1 = _resultString[0];
                                    string dstr = null;
                                    int _otherLen = ulength - uIndex;
                                    if (_r1 == "?")
                                    {
                                        //dstr = text.Substring(i, _otherLen);
                                        dstr = text.Substring(uIndex, _otherLen);
                                    }
                                    else
                                    {
                                        dstr = text.Substring(uIndex, Math.Min(_r1.ToInt(), Math.Min(_otherLen, text.Length)));
                                    }
                                    string _d = _resultString[1];
                                    var _d1 = _d.Split('^');
                                    var _d11 = _d1[0];

                                    var _d12 = _d1[1];
                                    var _e1 = Regex.Split(_d12, " -> ", RegexOptions.IgnoreCase);
                                    var _e11 = _e1[0];
                                    var _e12 = _e1[1];
                                    //处理 _e11 和 _e12
                                    foreach (var subChar in specChar)
                                    {
                                        if (subChar == '\\')
                                        {
                                            _e11 = _e11.Replace("\\\\", "≌");
                                            _e12 = _e12.Replace("\\\\", "≌");
                                        }
                                        else
                                        {
                                            _e11 = _e11.Replace("\\" + subChar, "◇");
                                            _e11 = _e11.Replace(subChar.ToString(), "");
                                            _e11 = _e11.Replace("◇", subChar.ToString());

                                            _e12 = _e12.Replace("\\" + subChar, "◇");
                                            _e12 = _e12.Replace(subChar.ToString(), "");
                                            _e12 = _e12.Replace("◇", subChar.ToString());
                                        }
                                    }
                                    _e11 = _e11.Replace("≌", "\\");



                                    if (_d11 == "?")
                                    {
                                        dstr = dstr.Replace(_e11, _e12);
                                        result.Append(dstr);
                                        uIndex = ulength;
                                        i = i + xingValue.Length + 2;
                                    }
                                    else
                                    if (_d11.Contains("+"))  //连续替换
                                    {
                                        string end = dstr;
                                        int _f = (_d11.Substring(1, _d11.Length - 1)).ToInt();  // 连续次数
                                        int _f_count = GetSubStrCountInStr(dstr, _e11, 0).Length;
                                        if (_f_count == 0) { }
                                        else if (_f_count <= _f)
                                        {
                                            dstr = dstr.Replace(_e11, _e12);
                                            result.Append(dstr);
                                            uIndex = ulength;
                                            i = i + xingValue.Length + 2;
                                        }
                                        else
                                        {
                                            for (int _g = 0; _g < _f; _g++)
                                            {
                                                end = AyReplaceByPlace(end, _e11, _e12, _f_count--);
                                            }
                                        }

                                        result.Append(end);
                                        uIndex = ulength;
                                        i = i + xingValue.Length + 2;
                                    }
                                    else //指定第几个替换
                                    {
                                        int _f = _d11.ToInt();
                                        int _f_count = GetSubStrCountInStr(dstr, _e11, 0).Length;
                                        if (_f_count == 0 || _f_count <= _f)
                                        {
                                            result.Append(dstr);
                                            uIndex = ulength;
                                            i = i + xingValue.Length + 2;
                                        }
                                        else
                                        {
                                            var end = AyReplaceByPlace(dstr, _e11, _e12, (_f_count - _f + 1));
                                            result.Append(end);
                                            uIndex = ulength;
                                            i = i + xingValue.Length + 2;
                                        }
                                    }
                                }
                                else   //正常替换
                                {

                                    if (xingValue.IndexOf(" -> ") < 0)
                                    {
                                        if (xingValue == "?")
                                        {
                                            int utlen = ulength - uIndex;
                                            result.Append(text.Substring(uIndex, utlen));
                                            uIndex = ulength;
                                            //掩码跳过位数()+值的length;
                                            i = i + xingValue.Length + 2;
                                        }
                                        else
                                        {
                                            throw new Exception("*(规则) 掩码规则出错,错误位置:" + i + ",限定值不合法");
                                        }

                                    }

                                    else
                                    {
                                        string[] _resultString = Regex.Split(xingValue, " -> ", RegexOptions.IgnoreCase);
                                        string _d = _resultString[1];
                                        foreach (var subChar in specChar)
                                        {
                                            if (subChar == '\\')
                                            {
                                                _d = _d.Replace("\\\\", "≌");
                                            }
                                            else
                                            {
                                                _d = _d.Replace("\\" + subChar, "◇");
                                                _d = _d.Replace(subChar.ToString(), "");
                                                _d = _d.Replace("◇", subChar.ToString());
                                            }
                                        }
                                        _d = _d.Replace("≌", "\\");

                                        if (_resultString[0] == "?")
                                        {
                                            int utlen = ulength - uIndex;
                                            StringBuilder sb1 = new StringBuilder();
                                            for (int k = 0; k < utlen; k++)
                                            {
                                                sb1.Append(_d);
                                            }
                                            result.Append(sb1.ToString());

                                            uIndex = ulength;
                                            //掩码跳过位数()+值的length;
                                            i = i + xingValue.Length + 2;
                                        }
                                        else
                                        {
                                            int _ind = _resultString[0].ToInt();
                                            int utlen = ulength - uIndex;
                                            int minXin = Math.Min(_ind, utlen);
                                            StringBuilder sb1 = new StringBuilder();
                                            for (int k = 0; k < _ind; k++)
                                            {
                                                sb1.Append(_d);
                                            }
                                            result.Append(sb1.ToString());
                                            if (minXin == utlen) break; //如果要取的字符已经不够了,下次直接终止掩码过程了
                                            uIndex = uIndex + minXin;
                                            //掩码跳过位数()+值的length;
                                            i = i + xingValue.Length + 2;
                                        }
                                    }

                                }

                            }
                            else
                            {
                                int utlen = ulength - uIndex;
                                int minXin = Math.Min(xingVal, utlen);
                                result.Append(text.Substring(uIndex, minXin));
                                if (minXin == utlen) break; //如果要取的字符已经不够了,下次直接终止掩码过程了
                                uIndex = uIndex + minXin;
                                //掩码跳过位数()+值的length;
                                i = i + xingValue.Length + 2;
                            }
                        }
                        else
                        {
                            result.Append(text[uIndex]);
                            uIndex++;
                        }

                    }
                    else if (_char == '$') //终止
                    {
                        break;
                    }
                    else
                    {
                        result.Append(_char);
                    }
                }
            }
            return result;
        }

19 View Source File : IndentationReformatter.cs
License : MIT License
Project Creator : Abdesol

public void Step(IDoreplacedentAccessor doc, IndentationSettings set)
		{
			string line = doc.Text;
			if (set.LeaveEmptyLines && line.Length == 0) return; // leave empty lines empty
			line = line.TrimStart();

			StringBuilder indent = new StringBuilder();
			if (line.Length == 0) {
				// Special treatment for empty lines:
				if (blockComment || (inString && verbatim))
					return;
				indent.Append(block.InnerIndent);
				indent.Append(Repeat(set.IndentString, block.OneLineBlock));
				if (block.Continuation)
					indent.Append(set.IndentString);
				if (doc.Text != indent.ToString())
					doc.Text = indent.ToString();
				return;
			}

			if (TrimEnd(doc))
				line = doc.Text.TrimStart();

			Block oldBlock = block;
			bool startInComment = blockComment;
			bool startInString = (inString && verbatim);

			#region Parse char by char
			lineComment = false;
			inChar = false;
			escape = false;
			if (!verbatim) inString = false;

			lastRealChar = '\n';

			char lastchar = ' ';
			char c = ' ';
			char nextchar = line[0];
			for (int i = 0; i < line.Length; i++) {
				if (lineComment) break; // cancel parsing current line

				lastchar = c;
				c = nextchar;
				if (i + 1 < line.Length)
					nextchar = line[i + 1];
				else
					nextchar = '\n';

				if (escape) {
					escape = false;
					continue;
				}

				#region Check for comment/string chars
				switch (c) {
					case '/':
						if (blockComment && lastchar == '*')
							blockComment = false;
						if (!inString && !inChar) {
							if (!blockComment && nextchar == '/')
								lineComment = true;
							if (!lineComment && nextchar == '*')
								blockComment = true;
						}
						break;
					case '#':
						if (!(inChar || blockComment || inString))
							lineComment = true;
						break;
					case '"':
						if (!(inChar || lineComment || blockComment)) {
							inString = !inString;
							if (!inString && verbatim) {
								if (nextchar == '"') {
									escape = true; // skip escaped quote
									inString = true;
								} else {
									verbatim = false;
								}
							} else if (inString && lastchar == '@') {
								verbatim = true;
							}
						}
						break;
					case '\'':
						if (!(inString || lineComment || blockComment)) {
							inChar = !inChar;
						}
						break;
					case '\\':
						if ((inString && !verbatim) || inChar)
							escape = true; // skip next character
						break;
				}
				#endregion

				if (lineComment || blockComment || inString || inChar) {
					if (wordBuilder.Length > 0)
						block.LastWord = wordBuilder.ToString();
					wordBuilder.Length = 0;
					continue;
				}

				if (!Char.IsWhiteSpace(c) && c != '[' && c != '/') {
					if (block.Bracket == '{')
						block.Continuation = true;
				}

				if (Char.IsLetterOrDigit(c)) {
					wordBuilder.Append(c);
				} else {
					if (wordBuilder.Length > 0)
						block.LastWord = wordBuilder.ToString();
					wordBuilder.Length = 0;
				}

				#region Push/Pop the blocks
				switch (c) {
					case '{':
						block.ResetOneLineBlock();
						blocks.Push(block);
						block.StartLine = doc.LineNumber;
						if (block.LastWord == "switch") {
							block.Indent(set.IndentString + set.IndentString);
							/* oldBlock refers to the previous line, not the previous block
							 * The block we want is not available anymore because it was never pushed.
							 * } else if (oldBlock.OneLineBlock) {
							// Inside a one-line-block is another statement
							// with a full block: indent the inner full block
							// by one additional level
							block.Indent(set, set.IndentString + set.IndentString);
							block.OuterIndent += set.IndentString;
							// Indent current line if it starts with the '{' character
							if (i == 0) {
								oldBlock.InnerIndent += set.IndentString;
							}*/
						} else {
							block.Indent(set);
						}
						block.Bracket = '{';
						break;
					case '}':
						while (block.Bracket != '{') {
							if (blocks.Count == 0) break;
							block = blocks.Pop();
						}
						if (blocks.Count == 0) break;
						block = blocks.Pop();
						block.Continuation = false;
						block.ResetOneLineBlock();
						break;
					case '(':
					case '[':
						blocks.Push(block);
						if (block.StartLine == doc.LineNumber)
							block.InnerIndent = block.OuterIndent;
						else
							block.StartLine = doc.LineNumber;
						block.Indent(Repeat(set.IndentString, oldBlock.OneLineBlock) +
									 (oldBlock.Continuation ? set.IndentString : "") +
									 (i == line.Length - 1 ? set.IndentString : new String(' ', i + 1)));
						block.Bracket = c;
						break;
					case ')':
						if (blocks.Count == 0) break;
						if (block.Bracket == '(') {
							block = blocks.Pop();
							if (IsSingleStatementKeyword(block.LastWord))
								block.Continuation = false;
						}
						break;
					case ']':
						if (blocks.Count == 0) break;
						if (block.Bracket == '[')
							block = blocks.Pop();
						break;
					case ';':
					case ',':
						block.Continuation = false;
						block.ResetOneLineBlock();
						break;
					case ':':
						if (block.LastWord == "case"
							|| line.StartsWith("case ", StringComparison.Ordinal)
							|| line.StartsWith(block.LastWord + ":", StringComparison.Ordinal)) {
							block.Continuation = false;
							block.ResetOneLineBlock();
						}
						break;
				}

				if (!Char.IsWhiteSpace(c)) {
					// register this char as last char
					lastRealChar = c;
				}
				#endregion
			}
			#endregion

			if (wordBuilder.Length > 0)
				block.LastWord = wordBuilder.ToString();
			wordBuilder.Length = 0;

			if (startInString) return;
			if (startInComment && line[0] != '*') return;
			if (doc.Text.StartsWith("//\t", StringComparison.Ordinal) || doc.Text == "//")
				return;

			if (line[0] == '}') {
				indent.Append(oldBlock.OuterIndent);
				oldBlock.ResetOneLineBlock();
				oldBlock.Continuation = false;
			} else {
				indent.Append(oldBlock.InnerIndent);
			}

			if (indent.Length > 0 && oldBlock.Bracket == '(' && line[0] == ')') {
				indent.Remove(indent.Length - 1, 1);
			} else if (indent.Length > 0 && oldBlock.Bracket == '[' && line[0] == ']') {
				indent.Remove(indent.Length - 1, 1);
			}

			if (line[0] == ':') {
				oldBlock.Continuation = true;
			} else if (lastRealChar == ':' && indent.Length >= set.IndentString.Length) {
				if (block.LastWord == "case" || line.StartsWith("case ", StringComparison.Ordinal) || line.StartsWith(block.LastWord + ":", StringComparison.Ordinal))
					indent.Remove(indent.Length - set.IndentString.Length, set.IndentString.Length);
			} else if (lastRealChar == ')') {
				if (IsSingleStatementKeyword(block.LastWord)) {
					block.OneLineBlock++;
				}
			} else if (lastRealChar == 'e' && block.LastWord == "else") {
				block.OneLineBlock = Math.Max(1, block.PreviousOneLineBlock);
				block.Continuation = false;
				oldBlock.OneLineBlock = block.OneLineBlock - 1;
			}

			if (doc.IsReadOnly) {
				// We can't change the current line, but we should accept the existing
				// indentation if possible (=if the current statement is not a multiline
				// statement).
				if (!oldBlock.Continuation && oldBlock.OneLineBlock == 0 &&
					oldBlock.StartLine == block.StartLine &&
					block.StartLine < doc.LineNumber && lastRealChar != ':') {
					// use indent StringBuilder to get the indentation of the current line
					indent.Length = 0;
					line = doc.Text; // get untrimmed line
					for (int i = 0; i < line.Length; ++i) {
						if (!Char.IsWhiteSpace(line[i]))
							break;
						indent.Append(line[i]);
					}
					// /* */ multiline comments have an extra space - do not count it
					// for the block's indentation.
					if (startInComment && indent.Length > 0 && indent[indent.Length - 1] == ' ') {
						indent.Length -= 1;
					}
					block.InnerIndent = indent.ToString();
				}
				return;
			}

			if (line[0] != '{') {
				if (line[0] != ')' && oldBlock.Continuation && oldBlock.Bracket == '{')
					indent.Append(set.IndentString);
				indent.Append(Repeat(set.IndentString, oldBlock.OneLineBlock));
			}

			// this is only for blockcomment lines starting with *,
			// all others keep their old indentation
			if (startInComment)
				indent.Append(' ');

			if (indent.Length != (doc.Text.Length - line.Length) ||
				!doc.Text.StartsWith(indent.ToString(), StringComparison.Ordinal) ||
				Char.IsWhiteSpace(doc.Text[indent.Length])) {
				doc.Text = indent.ToString() + line;
			}
		}

19 View Source File : Compiler.cs
License : MIT License
Project Creator : azist

public string EscapeFileName(string fn)
            {
                var result = new StringBuilder();

                foreach(var c in fn)
                {
                    if ( char.IsLetterOrDigit(c) || c=='-' || c=='_' || c=='.') result.Append(c);
                    else
                      result.Append('_');
                }

                return result.ToString();
            }

19 View Source File : Lexer.cs
License : MIT License
Project Creator : Alprog

public IEnumerator<Token> Tokenize(string line)
        {
            var token = new Token(TokenType.Invalid, 0, line.Length);
            int i = 0;
            while (i < line.Length)
            {
                var c = line[i];
                if (Char.IsWhiteSpace(c))
                {
                    // WhiteSpace
                    i++;
                    continue;
                }
                else if (Char.IsLetter(c) || c.Equals('_'))
                {
                    // Identifier or Keyword
                    int si = i; i++;
                    while (i < line.Length)
                    {
                        c = line[i];
                        if (Char.IsLetterOrDigit(c) || c.Equals('_'))
                        {
                            i++;
                        }
                        else
                        {
                            break;
                        }
                    }
                    var tokenText = line.Substring(si, i - si);
                    if (tokenText.ToLower() == "true")
                    {
                        token = ValueToken(si, i - si, true);
                    }
                    else if (tokenText.ToLower() == "false")
                    {
                        token = ValueToken(si, i - si, false);
                    }
                    else if (tokenText.ToLower() == "null")
                    {
                        token = ValueToken(si, i - si, null);
                    }
                    else
                    {
                        if (i < line.Length && line[i].Equals('…'))
                        {
                            token = new Token(TokenType.Autocomplete, si, i - si, tokenText);
                            i++;
                        }
                        else
                        {
                            token = new Token(TokenType.Identifier, si, i - si, tokenText);
                        }
                    }
                }
                else if (c.Equals('\"'))
                {
                    // String
                    int si = i; i++;
                    bool ended = false;
                    while (i < line.Length)
                    {
                        c = line[i];
                        if (!c.Equals('\"'))
                        {
                            i++;
                        }
                        else
                        {
                            ended = true;
                            i++;
                            break;
                        }
                    }
                    if (ended)
                    {
                        var text = line.Substring(si + 1, i - si - 2);
                        token = ValueToken(si, i - si, text);
                    }
                    else
                    {
                        token = new Token(TokenType.Invalid, si, i - si);
                    }
                }
                else if (Char.IsDigit(c) || c.Equals('-'))
                {
                    // Minus or digit
                    if (c.Equals('-'))
                    {
                        if (token.Type == TokenType.Value ||
                            token.Type == TokenType.Identifier ||
                            token.Type == TokenType.ClosedBracket)
                        {
                            // force minus operator
                            i++;
                            token = new Token(TokenType.Operator, i, 1, Operator.Get("-"));
                            yield return token;
                            continue;
                        }
                    }

                    int si = i; i++;
                    while (i < line.Length)
                    {
                        c = line[i];
                        if (Char.IsDigit(c) || c.Equals('.'))
                        {
                            i++;
                        }
                        else
                        {
                            break;
                        }
                    }
                    var tokenText = line.Substring(si, i - si);
                    if (tokenText == "-")
                    {
                        token = new Token(TokenType.Operator, si, i - si, Operator.Get(tokenText));
                        i++;
                    }
                    else
                    {
                        float number;
                        if (Single.TryParse(tokenText, NumberStyles.Any, CultureInfo.InvariantCulture, out number))
                        {
                            token = ValueToken(si, i - si, number);
                        }
                        else
                        {
                            token = new Token(TokenType.Invalid, si, i - si);
                        }
                    }
                }
                else if (operators.Contains(c.ToString()))
                {
                    // Operator
                    int si = i; i++;
                    while (i < line.Length)
                    {
                        c = line[i];
                        if (operators.Contains(c.ToString()))
                        {
                            i++;
                        }
                        else
                        {
                            break;
                        }
                    }
                    var tokenText = line.Substring(si, i - si);
                    if (tokenText == "=")
                    {
                        token = new Token(TokenType.replacedignmentOperator, si, i - si);
                    }
                    else
                    {
                        token = new Token(TokenType.Operator, si, i - si, Operator.Get(tokenText));
                    }
                }
                else if (c.Equals('.'))
                {
                    token = new Token(TokenType.Dot, i, 1);
                    i++;
                }
                else if (c.Equals('('))
                {
                    token = new Token(TokenType.OpenBracket, i, 1);
                    i++;
                }
                else if (c.Equals(')'))
                {
                    token = new Token(TokenType.ClosedBracket, i, 1);
                    i++;
                }
                else if (c.Equals(','))
                {
                    token = new Token(TokenType.Comma, i, 1);
                    i++;
                }
                else if (c.Equals('…'))
                {
                    token = new Token(TokenType.Autocomplete, i, 1, String.Empty);
                    i++;
                }
                else
                {
                    token = new Token(TokenType.Invalid, i, 1);
                    i++;
                }

                yield return token;
            }

            yield return new Token(TokenType.EndOfLine, i, 0);
        }

19 View Source File : DataEntryUtils.cs
License : MIT License
Project Creator : azist

public static bool CheckEMail(string email)
    {
      if (email.IsNullOrWhiteSpace()) return false;

      var lastPos = email.Length - 1;

      var atPos = email.IndexOf('@');
      if (atPos <= 0 || atPos == lastPos)
        return false;

      char c;

      // local part
      var prevIsDot = false;
      var end = atPos - 1;
      for (int i = 0; i <= end; i++)
      {
        c = email[i];
        if (i == 0 || i == end)
        {
          if (!IsValidEMailLocalPartChar(c)) return false;
          continue;
        }
        if (c == '.')
        {
          if (prevIsDot) return false;
          prevIsDot = true;
        }
        else
        {
          if (!IsValidEMailLocalPartChar(c)) return false;
          prevIsDot = false;
        }
      }

      // domain part
      var prevIsHyphen = false;
      prevIsDot = false;
      var start = atPos + 1;
      end = lastPos;
      for (int i = start; i <= end; i++)
      {
        c = email[i];
        if (i == start || i == end)
        {
          if (!Char.IsLetterOrDigit(c)) return false;
          continue;
        }
        if (c == '.')
        {
          if (prevIsDot || prevIsHyphen) return false;
          prevIsDot = true;
          continue;
        }
        if (c == '-')
        {
          if (prevIsDot) return false;
          prevIsHyphen = true;
          continue;
        }
        if (!Char.IsLetterOrDigit(c)) return false;
        prevIsDot = false;
        prevIsHyphen = false;
      }
      return true;
    }

19 View Source File : JsonTextReader.cs
License : MIT License
Project Creator : akaskela

private bool ValidIdentifierChar(char value)
        {
            return (char.IsLetterOrDigit(value) || value == '_' || value == '$');
        }

19 View Source File : CoreUtils.cs
License : MIT License
Project Creator : azist

public static bool IsValidXMLName(this string name)
    {
      if (name.IsNullOrWhiteSpace()) return false;
      for (int i = 0; i < name.Length; i++)
      {
        char c = name[i];
        if (c == '-' || c == '_') continue;
        if (!Char.IsLetterOrDigit(c) || (i == 0 && !Char.IsLetter(c))) return false;
      }

      return true;
    }

19 View Source File : StringExtension.cs
License : MIT License
Project Creator : AlturosDestinations

public static string ReplaceSpecialCharacters(this string str, char replacementChar = '_')
        {
            var sb = new StringBuilder();

            foreach (var c in str)
            {
                sb.Append(char.IsLetterOrDigit(c) ? c : replacementChar);
            }

            return sb.ToString();
        }

19 View Source File : WebUtils.cs
License : MIT License
Project Creator : azist

public static bool IsValidJSIdentifier(this string id)
    {
      if (id.IsNullOrWhiteSpace()) return false;

      if (JS_RESERVED_WORDS.Contains(id)) return false;

      for (int i = 0; i < id.Length; i++)
      {
        char c = id[i];
        if (c == '$' || c == '_') continue;
        if (!Char.IsLetterOrDigit(c) || (i == 0 && !Char.IsLetter(c))) return false;
      }

      return true;
    }

19 View Source File : StringHelper.cs
License : MIT License
Project Creator : 0x1000000

public static string DeSnake(string input)
        {
            if (string.IsNullOrEmpty(input))
            {
                return input;
            }

            char[]? result = null;
            int nextResultIndex = 0;

            bool afterSymbol = true;

            for (int i = 0; i < input.Length; i++)
            {
                var ch = input[i];

                if (!char.IsLetterOrDigit(ch))
                {
                    afterSymbol = true;
                    EnsureResult(i);
                }
                else
                {
                    if (afterSymbol && char.IsLower(ch))
                    {
                        OutResult(i, char.ToUpper(ch), true);
                    }
                    else
                    {
                        OutResult(i, ch, false);
                    }
                    afterSymbol = false;
                }

                if (result == null)
                {
                    nextResultIndex = i;
                }
            }

            return result == null ? input : new string(result, 0, nextResultIndex);

            void EnsureResult(int index)
            {
                if (result == null)
                {
                    result = new char[input.Length + 1];
                    input.CopyTo(0, result, 0, input.Length);
                    nextResultIndex = index;
                }
            }

            void OutResult(int index, char ch, bool changed)
            {
                var isFirstDigit = nextResultIndex == 0 && char.IsDigit(ch);
                if (result == null)
                {
                    if (!changed && !isFirstDigit)
                    {
                        return;
                    }

                    EnsureResult(index);
                }

                if (isFirstDigit)
                {
                    result![nextResultIndex++] = 'D';
                }

                result![nextResultIndex++] = ch;
            }
        }

19 View Source File : DataEntryUtils.cs
License : MIT License
Project Creator : azist

public static string NormalizeUSPhone(string value)
    {
      if (value == null) return null;

      value = value.Trim();

      if (value.Length == 0) return value;


      bool isArea = false;
      bool isExt = false;

      string area = string.Empty;
      string number = string.Empty;
      string ext = string.Empty;


      if (value.StartsWith("+")) //international phone, just return as-is
        return value;

      Char chr;
      for (int i = 0; i < value.Length; i++)
      {
        chr = value[i];

        if (!isArea && chr == '(' && area.Length == 0)
        {
          isArea = true;
          continue;
        }

        if (isArea && chr == ')')
        {
          isArea = false;
          continue;
        }

        if (isArea && area.Length == 3)
          isArea = false;


        if (number.Length > 0 && !isExt)
        {  //check extension
          if (chr == 'x' || chr == 'X' || (chr == '.' && number.Length>6))
          {
            isExt = true;
            continue;
          }
          string trailer = value.Substring(i).ToUpperInvariant();

          if (trailer.StartsWith("EXT") && number.Length >= 7)
          {
            isExt = true;
            i += 2;
            continue;
          }
          if (trailer.StartsWith("EXT.") && number.Length >= 7)
          {
            isExt = true;
            i += 3;
            continue;
          }

        }

        if (!Char.IsLetterOrDigit(chr)) continue;


        if (isArea)
          area += chr;
        else
          if (isExt)
            ext += chr;
          else
            number += chr;
      }

      while (number.Length < 7)
        number += '?';

      if (area.Length == 0)
      {
        if (number.Length >= 10)
        {
          area = number.Substring(0, 3);
          number = number.Substring(3);
        }
        else
          area = "???";
      }

      if (number.Length > 7 && ext.Length == 0)
      {
        ext = number.Substring(7);
        number = number.Substring(0, 7);
      }

      number = number.Substring(0, 3) + "-" + number.Substring(3);

      if (ext.Length > 0) ext = "x" + ext;

      return string.Format("({0}) {1}{2}", area, number, ext);
    }

19 View Source File : QueryLexicalAnalizer.cs
License : MIT License
Project Creator : ansel86castro

private String ReadWord(int simbol)
        {
            StringBuilder sb = new StringBuilder();
            int c = Peek();
            while (c > 0)
            {
                c = Peek();
                if (c == -1)
                {
                    break;
                }

                if (IsWhiteSpace(c) || IsSymbol(c) != TokenType.UNKNOW || c == '\'')
                {
                    break;
                }
                else if (!Char.IsLetterOrDigit((char)c) && c != '_')
                {
                    throw new TokenMismatchException(String.Format("Expecting ID '{0}' at COL {1} ROW {2}", sb.ToString(), Col, Row));
                }

                sb.Append((char)c);
                Read();
            }
            return sb.ToString();
        }

19 View Source File : HtmlCssParser.cs
License : GNU Affero General Public License v3.0
Project Creator : akshinmustafayev

private static bool ParseWord(string word, string styleValue, ref int nextIndex)
        {
            ParseWhiteSpace(styleValue, ref nextIndex);

            for (int i = 0; i < word.Length; i++)
            {
                if (!(nextIndex + i < styleValue.Length && word[i] == styleValue[nextIndex + i]))
                {
                    return false;
                }
            }

            if (nextIndex + word.Length < styleValue.Length && Char.IsLetterOrDigit(styleValue[nextIndex + word.Length]))
            {
                return false;
            }

            nextIndex += word.Length;
            return true;
        }

19 View Source File : IndexAndSearchHandler.cs
License : MIT License
Project Creator : 0ffffffffh

private string NormalizeTerm(string s)
        {
            StringBuilder sb = new StringBuilder();

            foreach (var c in s)
            {
                if (char.IsLetterOrDigit(c) || c == ' ')
                    sb.Append(char.ToLower(c));
                else if (char.IsSeparator(c))
                    sb.Append(' ');
            }

            s = sb.ToString();
            sb.Clear();
            sb = null;

            return s;
        }

19 View Source File : XmlHighlightingDefinition.cs
License : MIT License
Project Creator : Abdesol

public object VisitKeywords(XshdKeywords keywords)
			{
				if (keywords.Words.Count == 0)
					return Error(keywords, "Keyword group must not be empty.");
				foreach (string keyword in keywords.Words) {
					if (string.IsNullOrEmpty(keyword))
						throw Error(keywords, "Cannot use empty string as keyword");
				}
				StringBuilder keyWordRegex = new StringBuilder();
				// We can use "\b" only where the keyword starts/ends with a letter or digit, otherwise we don't
				// highlight correctly. (example: ILAsm-Mode.xshd with ".maxstack" keyword)
				if (keywords.Words.All(IsSimpleWord)) {
					keyWordRegex.Append(@"\b(?>");
					// (?> = atomic group
					// atomic groups increase matching performance, but we
					// must ensure that the keywords are sorted correctly.
					// "\b(?>in|int)\b" does not match "int" because the atomic group captures "in".
					// To solve this, we are sorting the keywords by descending length.
					int i = 0;
					foreach (string keyword in keywords.Words.OrderByDescending(w => w.Length)) {
						if (i++ > 0)
							keyWordRegex.Append('|');
						keyWordRegex.Append(Regex.Escape(keyword));
					}
					keyWordRegex.Append(@")\b");
				} else {
					keyWordRegex.Append('(');
					int i = 0;
					foreach (string keyword in keywords.Words) {
						if (i++ > 0)
							keyWordRegex.Append('|');
						if (char.IsLetterOrDigit(keyword[0]))
							keyWordRegex.Append(@"\b");
						keyWordRegex.Append(Regex.Escape(keyword));
						if (char.IsLetterOrDigit(keyword[keyword.Length - 1]))
							keyWordRegex.Append(@"\b");
					}
					keyWordRegex.Append(')');
				}
				return new HighlightingRule {
					Color = GetColor(keywords, keywords.ColorReference),
					Regex = CreateRegex(keywords, keyWordRegex.ToString(), XshdRegexType.Default)
				};
			}

19 View Source File : SimpleLexer.cs
License : MIT License
Project Creator : Actipro

protected virtual int ParseIdentifier(ITextBufferReader reader, char ch) {
			// Get the entire word
			int startOffset = reader.Offset - 1;
			while (!reader.IsAtEnd) {
				char ch2 = reader.Read();
				// NOTE: This could be improved by supporting \u escape sequences
				if ((!char.IsLetterOrDigit(ch2)) && (ch2 != '_')) {
					reader.ReadReverse();
					break;
				}
			}

			// Determine if the word is a keyword
			if (Char.IsLetter(ch)) {
				int value;
				String subString = reader.GetSubstring(startOffset, reader.Offset - startOffset);
				if (!caseSensitive)
					subString = subString.ToLowerInvariant();

				return keywords.TryGetValue(subString, out value) ? value : SimpleTokenId.Identifier;
			}
			else
				return SimpleTokenId.Identifier;
		}

19 View Source File : UserNameService.cs
License : MIT License
Project Creator : alexyakunin

public string ParseName(string text, int startIndex = 0)
        {
            string name;
            for (var i = startIndex; i < text.Length; i++) {
                var c = text[i];
                if (i == startIndex) {
                    if (char.IsLetter(c))
                        continue;
                    return "";
                }
                if (char.IsLetterOrDigit(c) || c == '_' || c == '-')
                    continue;
                name = text.Substring(startIndex, i - startIndex);
                return ValidateName(name) == null ? name : "";
            }
            name = text.Substring(startIndex);
            return ValidateName(name) == null ? name : "";
        }

19 View Source File : Lexer.cs
License : GNU General Public License v2.0
Project Creator : Asixa

public static Token Scan()
        {
            //remove spaces
            for (; !stream_reader.EndOfStream; ReadChar())
            {
                if (peek == ' ' || peek == '\t')
                {
                }
                else if (peek == '\r')
                {
                    ReadChar();
                    ++line;
                    ch = 0;
                }
                else break;
            }

            if (stream_reader.EndOfStream) return null;

            //remove comments
            if (peek == '/')
            {
                ReadChar();
                switch (peek)
                {
                    case '/':
                        for (;; ReadChar())
                            if (peek == '\r' || peek == '\uffff')
                                return Scan();
                    case '*':
                        for (ReadChar();; ReadChar())
                        {
                            switch (peek)
                            {
                                case '\r':
                                    line++;
                                    ch = 0;
                                    ReadChar();
                                    break;
                                case '*':
                                    ReadChar();
                                    if (peek == '/')
                                    {
                                        ReadChar();
                                        return Scan();
                                    }

                                    break;
                                case '\uffff':
                                    return Scan();
                            }
                        }
                }

                return new Token(TT.SLASH, "/");
            }

            //Operators
            switch (peek)
            {
                case '+': return ReadChar('=') ? Plusreplacedign : Plus;
                case '-': return ReadChar('=') ? Minusreplacedign : Minus;
                case '*': return ReadChar('=') ? Timereplacedign : Time;
                case '/': return ReadChar('=') ? Devidereplacedign : Devide;
                case '&': return ReadChar('&') ? And : BitAnd;
                case '|': return ReadChar('|') ? Or : BitInOr;
                case '=': return ReadChar('=') ? Equal : replacedign;
                case '!': return ReadChar('=') ? NotEqual : Not;
                case '<': return ReadChar('=') ? LessEqual : Less;
                case '>': return ReadChar('=') ? GreaterEqual : Greater;
                case '%': return ReadChar('=') ? Moldingreplacedign : Molding;
                case ':': return ReadChar(':') ?null: Colon;
                case ';':
                    ReadChar(); return Semicolon;
                case ',': ReadChar(); return Comma;
                case '(': ReadChar(); return LeftParentheses;
                case ')': ReadChar(); return RightParentheses;
                case '{': ReadChar(); return LeftBraces;
                case '}': ReadChar(); return RightBraces;
                case '[': ReadChar(); return LeftSquareBracket;
                case ']': ReadChar(); return RightSquareBracket;
                case '.': ReadChar(); return Dot;
                case '#': ReadChar(); return Preprocessor;
                case '^': ReadChar(); return BitExOr;
                case '~': ReadChar(); return Tilde;
            }

            //Digits
            if (char.IsDigit(peek))
            {
                var val = 0;
                do
                {
                    val = 10 * val + (peek - '0');
                    ReadChar();
                } while (char.IsDigit(peek));

                if (peek != '.') return new Token(TT.INTCONSTANT, val.ToString());

                float float_val = val;
                for (float d = 10;; d *= 10)
                {
                    ReadChar();
                    if (!char.IsDigit(peek)) break;
                    float_val += (peek - 48) / d;
                }

                return new Token(TT.FLOATCONSTANT, float_val.ToString(CultureInfo.InvariantCulture));
            }

            //Identifiers
            
            if (char.IsLetter(peek) || peek == '_')
            {
                var s = "";
                do
                {
                    s += peek;
                    ReadChar();
                } while (char.IsLetterOrDigit(peek)||peek=='_');

                //GLSL identifiers starts with "gl_" or contains "__" is not allowed
                if (s.Length >= 3)
                {
                    if (s.Substring(0, 3).ToLower() == "gl_") Error(4);
                    if (s.Contains("__")) Error(3);
                }
                return new Token(Keywords.ContainsKey(s) ? Keywords[s] : TT.IDENTIFIER, s);
            }

           return new Token(TT.UNEXPECTED,peek.ToString());
        }

See More Examples