Пример #1
0
        /// <summary>
        /// scan for the first sequence of chars in string after initial whitespace.
        /// </summary>
        /// <param name="InString"></param>
        /// <param name="InWhitespace"></param>
        /// <param name="InMaxReturnChars"></param>
        /// <returns></returns>
        public static ScanStringResults ScanFirstChars(
            string InString, Whitespace InWhitespace, int InMaxReturnChars)
        {
            int ix = 0;
            ScanStringResults res = null;

            ScanCharResults cr = Scanner.ScanNotEqual(InString, 0, InWhitespace.WhitespaceChars);

            if (cr.ResultPos == -1)
            {
                ix = 0;
            }
            else
            {
                ix = cr.ResultPos;
            }

            if (ix >= InString.Length)
            {
                res = new ScanStringResults(-1);
            }
            else
            {
                string fsChars = Stringer.SubstringLenient(InString, ix, InMaxReturnChars);
                res = new ScanStringResults(fsChars, ix);
            }

            return(res);
        }
Пример #2
0
        public WordValue(string InValue, TextTraits InTraits)
        {
            CharObjectPair results = Stringer.CalcWordClassification(InValue, InTraits);

            CommonConstruct(
                InValue, (WordClassification)results.b, InTraits, results.a);
        }
Пример #3
0
        /// <summary>
        /// add a value to the end of the string.
        /// </summary>
        /// <param name="InValue"></param>
        /// <returns></returns>
        public void Append(string InValue)
        {
            // prepare the value to be added to the CSV string.
            string prepValue;

            if (InValue == null)
            {
                InValue = "";
            }
            if ((ShouldQuoteValue(InValue) == true) ||
                (InValue.Length == 0))
            {
                prepValue = Stringer.Enquote(InValue, cQuoteChar, mTraits.QuoteEncapsulation);
                if (EncapsulateValues == true)
                {
                    prepValue = "_qv(" + prepValue + ")";
                }
            }
            else
            {
                prepValue = InValue;
            }

            // add the value to the string.
            AppendAsIs(prepValue);
        }
Пример #4
0
        /// <summary>
        /// add a value to the end of the string.
        /// </summary>
        /// <param name="InValue"></param>
        /// <returns></returns>
        public CsvString Add(string InValue)
        {
            // prepare the value to be added to the CSV string.
            string prepValue;

            if (InValue == null)
            {
                prepValue = "";
            }
            else if ((ShouldQuoteValue(InValue) == true) ||
                     (InValue.Length == 0))
            {
                prepValue = Stringer.Enquote(InValue, '"', QuoteEncapsulation.Escape);
                if (EncapsulateValues == true)
                {
                    prepValue = "_qv(" + prepValue + ")";
                }
            }
            else
            {
                prepValue = InValue;
            }

            // add the value to the string.
            AddString(prepValue);

            return(this);
        }
Пример #5
0
 public bool IsWhitespace(string InString, int InIx, int InEx)
 {
     if (Stringer.CompareSubstringEqualAny(
             InString, InIx, InEx, WhitespacePatterns.StringArray) != -1)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Пример #6
0
            /// <summary>
            /// Return an object holding the CsvString value.
            /// Object can be a string, CsvString or string[].
            /// </summary>
            /// <returns></returns>
            public object ToObject( )
            {
                if (IsAtValue == false)
                {
                    return(null);
                }
                else if (mAtFinalEmptyValue == true)
                {
                    return(null);
                }
                else if (mCsr.Word == null)
                {
                    return(null);
                }
                else if (mCsr.Word.Class == WordClassification.NamedBraced)
                {
                    string braceName = mCsr.Word.BraceName;
                    if (braceName == "_qv")
                    {
                        string text = mCsr.Word.BracedText;
                        return(Stringer.Dequote(text, mCsr.TextTraits.QuoteEncapsulation));
                    }

                    // a string[] is stored as a sequence of strings in CsvString form.
                    else if (braceName == "_sa")                        // string array
                    {
                        CsvString vlu = new CsvString( );
                        vlu.String = mCsr.Word.BracedText;
                        return(vlu.ToStringArray( ));
                    }

                    // is a string of comma seperated values.
                    else if (braceName == "_csv")
                    {
                        CsvString vlu = new CsvString( );
                        vlu.String = mCsr.Word.BracedText;
                        return(vlu);
                    }

                    else
                    {
                        return(mCsr.Word.BracedText);
                    }
                }
                else
                {
                    return(mCsr.Word.ToString( ));
                }
            }
Пример #7
0
        // --------------------------- ScanReverseNotEqual-------------------------------
        // scan reverse for the first location in string not equal to all of the
        // pattern characters.
        public static int ScanReverseNotEqual(
            string InString, int InBx, int InEx,
            int InIx, ScanPatterns InNotEqualPatterns)
        {
            int foundIx = InIx + 1;

            while (true)
            {
                foundIx -= 1;
                if (foundIx < InBx)
                {
                    foundIx = -1;
                    break;
                }

                int  remLx = InEx - foundIx + 1;
                char ch1   = InString[foundIx];

                // the current char is not equal any of the pattern lead chars.
                int patIx = Array.IndexOf <char>(InNotEqualPatterns.LeadChars, ch1);
                if (patIx == -1)
                {
                    break;
                }

                // lead char matches. check the entire pattern string for equality.
                ScanPattern equalPat = null;
                ScanPattern pat      = InNotEqualPatterns.ScanPatternsArray[patIx];
                while (pat != null)
                {
                    bool rv = Stringer.CompareSubstringEqual(InString, foundIx, InEx, pat.PatternValue);
                    if (rv == true)
                    {
                        equalPat = pat;
                        break;
                    }
                    pat = pat.NextSameLeadChar;
                }

                // none of the patterns fully match the substring at the current location.
                if (equalPat == null)
                {
                    break;
                }
            }

            return(foundIx);
        }
Пример #8
0
 /// <summary>
 /// Return the encapsulated value in string form.
 /// </summary>
 /// <returns></returns>
 public override string ToString( )
 {
     if (IsAtValue == false)
     {
         return(null);
     }
     else if (mAtFinalEmptyValue == true)
     {
         return(null);
     }
     else if (mCsr.Word == null)
     {
         return("");
     }
     else if (mCsr.Word.Class == WordClassification.NamedBraced)
     {
         string braceName = mCsr.Word.BraceName;
         if (braceName == "_qv")
         {
             string text = mCsr.Word.BracedText;
             return(Stringer.Dequote(text, mCsr.TextTraits.QuoteEncapsulation));
         }
         else
         {
             return(mCsr.Word.BracedText);
         }
     }
     else if (mCsr.Word.IsQuoted == true)
     {
         return(mCsr.Word.DequotedValue);
     }
     else
     {
         return(mCsr.Word.Value);
     }
 }
        // -------------------- ScanWord_IsolateWord ---------------------------
        // We have a word starting at InBx. Scan to the end of the word.
        // Returns the word in the InOutResults parm.
        // Returns the word delim in the return argument.
        private static ScanPatternResults ScanWord_IsolateWord(
            BoundedString InBoundedString,
            int InBx,
            ref WordCursor InOutResults,
            TextTraits Traits)
        {
            int                Bx, Ix, Lx;
            string             wordText;
            ScanPatternResults spr = null;

            Bx = InBx;
            char ch1 = InBoundedString.String[Bx];

            // is start of a verbatim string literal
            if ((Traits.VerbatimLiteralPattern != null) &&
                (Traits.VerbatimLiteralPattern.Match(InBoundedString, Bx)))
            {
            }

            // is quoted. the word runs to the closing quote.
            else if (IsOpenQuoteChar(ch1) == true)
            {
                Ix = ScanCloseQuote(InBoundedString.String, Bx, Traits.QuoteEncapsulation);
                if ((Ix == -1) || (Ix > InBoundedString.Ex))
                {
                    throw (new ApplicationException(
                               "Closing quote not found starting at position " +
                               Bx.ToString() + " in " + InBoundedString.String));
                }
                Lx       = Ix - Bx + 1;
                wordText = InBoundedString.String.Substring(Bx, Lx);
                InOutResults.SetWord(wordText, WordClassification.Quoted, Bx);

                // setup the non word which follows the closing quote.
                Bx = Ix + 1;
                if (InBoundedString.IsOutsideBounds(Bx))
                {
                    spr = new ScanPatternResults(-1);
                }
                else
                {
                    // the char that follows the closing quote must be a delim
                    spr = ScanEqualAny(InBoundedString, Bx, Traits.NonWordPatterns);
                    if (spr.FoundPos != Bx)
                    {
                        throw new ApplicationException(
                                  "invalid char follows close quote at pos " + Ix.ToString() +
                                  " in " + Stringer.Head(InBoundedString.String, 80));
                    }
                }
            }
            else
            {
                // Scan the string for any of the non word patterns spcfd in Traits.
                DelimClassification sprdc = DelimClassification.None;
                spr = ScanEqualAny(InBoundedString, Bx, Traits.NonWordPatterns);
                if (spr.IsNotFound == false)
                {
                    sprdc = spr.FoundPat.DelimClassification;
                }

                // a quote character within the name.  this is an error.
                if (sprdc == DelimClassification.Quote)
                {
                    throw new ApplicationException(
                              "quote character immed follows name character at position " +
                              spr.FoundPos.ToString() + " in " + InBoundedString.String);
                }

                // no delim found. all word to the end of the string.
                else if (spr.IsNotFound)
                {
                    wordText = InBoundedString.Substring(Bx);
                    InOutResults.SetWord(wordText, WordClassification.Identifier, InBx);
                }

                // found an open named brace char
                else if (sprdc == DelimClassification.OpenNamedBraced)
                {
                    ScanWord_IsolateWord_Braced(
                        InBoundedString, Bx, spr, ref InOutResults, Traits);
                }

                // delim is same position as the word.  so there is no word, only a delim.
                else if (spr.FoundPos == InBx)
                {
                    if (Scanner.IsOpenBraced(sprdc))
                    {
                        InOutResults.SetWord(
                            spr.FoundPat.PatternValue, WordClassification.OpenContentBraced, Bx,
                            spr.FoundPat.LeadChar);
                    }

                    // start of CommentToEnd comment. This is a word, not a delim. Find the
                    // end of the comment and set the delim to that end position.
                    else if (sprdc == DelimClassification.CommentToEnd)
                    {
                        spr = ScanWord_IsolateWord_CommentToEnd(
                            InBoundedString, spr.FoundPos, ref InOutResults, Traits);
                    }

                    else
                    {
                        InOutResults.SetNullWord();
                    }
                }

                // we have a word that ends with a delim.
                else
                {
                    Lx       = spr.FoundPos - InBx;
                    wordText = InBoundedString.Substring(InBx, Lx);
                    InOutResults.SetWord(wordText, WordClassification.Identifier, InBx);
                }
            }

            // return ScanPatternResults of the delim that ends the word.
            return(spr);
        }
Пример #10
0
        // -------------------------------- ScanNotEqual ------------------------
        public static ScanPatternResults ScanNotEqual(
            string InString, int InIx, int InEx, ScanPatterns InScanPatterns)
        {
            // step thru the string 1 char at a time.
            int stringIx = InIx;

            while (true)
            {
                if (stringIx > InEx)
                {
                    stringIx = -1;
                    break;
                }
                char ch1 = InString[stringIx];

                // the current char is not equal any of the pattern lead chars.
                int patIx = Array.IndexOf <char>(InScanPatterns.LeadChars, ch1);
                if (patIx == -1)
                {
                    break;
                }

                ScanPattern equalPat = null;
                ScanPattern pat      = InScanPatterns.ScanPatternsArray[patIx];
                while (pat != null)
                {
                    bool rv = Stringer.CompareSubstringEqual(InString, stringIx, InEx, pat.PatternValue);
                    if (rv == true)
                    {
                        if (equalPat == null)
                        {
                            equalPat = pat;
                        }

                        // Matching pattern already found, but this pattern also matches and it is
                        // longer. Always return the longer pattern.
                        else if (pat.PatternValue.Length > equalPat.PatternValue.Length)
                        {
                            equalPat = pat;
                        }
                    }
                    pat = pat.NextSameLeadChar;
                }

                // check for the substring at the current location in string as not equal any
                // of the ScanNotEqual pattern strings.
                if (equalPat == null)
                {
                    break;
                }

                // advance past the whitespace string.
                stringIx += equalPat.PatternValue.Length;
            }

            // return the scan results
            ScanPatternResults spr = null;

            if (stringIx == -1)
            {
                spr = new ScanPatternResults(-1);
            }
            else
            {
                spr = new ScanPatternResults(stringIx, InString[stringIx]);
            }

            spr.ScannedString = InString;
            spr.ScanStartIx   = InIx;
            spr.ScanBoundsEx  = InEx;

            return(spr);
        }