Example #1
0
 internal static HebrewNumberParsingState ParseByChar(char ch, ref HebrewNumberParsingContext context)
 {
     HebrewNumber.HebrewToken hebrewToken;
     if ((int)ch == 39)
     {
         hebrewToken = HebrewNumber.HebrewToken.SingleQuote;
     }
     else if ((int)ch == 34)
     {
         hebrewToken = HebrewNumber.HebrewToken.DoubleQuote;
     }
     else
     {
         int index = (int)ch - 1488;
         if (index < 0 || index >= HebrewNumber.HebrewValues.Length)
         {
             return(HebrewNumberParsingState.NotHebrewDigit);
         }
         hebrewToken = HebrewNumber.HebrewValues[index].token;
         if (hebrewToken == HebrewNumber.HebrewToken.Invalid)
         {
             return(HebrewNumberParsingState.NotHebrewDigit);
         }
         context.result += HebrewNumber.HebrewValues[index].value;
     }
     context.state = HebrewNumber.NumberPasingState[(int)context.state][(int)hebrewToken];
     if (context.state == HebrewNumber.HS._err)
     {
         return(HebrewNumberParsingState.InvalidHebrewNumber);
     }
     return(context.state == HebrewNumber.HS.END ? HebrewNumberParsingState.FoundEndOfHebrewNumber : HebrewNumberParsingState.ContinueParsing);
 }
Example #2
0
        ////////////////////////////////////////////////////////////////////////
        //
        //  Actions:
        //      Parse the Hebrew number by passing one character at a time.
        //      The state between characters are maintained at HebrewNumberPasingContext.
        //  Returns:
        //      Return a enum of HebrewNumberParsingState.
        //          NotHebrewDigit: The specified ch is not a valid Hebrew digit.
        //          InvalidHebrewNumber: After parsing the specified ch, it will lead into
        //              an invalid Hebrew number text.
        //          FoundEndOfHebrewNumber: A terminal state is reached.  This means that
        //              we find a valid Hebrew number text after the specified ch is parsed.
        //          ContinueParsing: The specified ch is a valid Hebrew digit, and
        //              it will lead into a valid state in the state machine, we should
        //              continue to parse incoming characters.
        //
        ////////////////////////////////////////////////////////////////////////

        internal static HebrewNumberParsingState ParseByChar(char ch, ref HebrewNumberParsingContext context)
        {
            Debug.Assert(s_numberPasingState.Length == HebrewTokenCount * ((int)HS.S9_DQ + 1));

            HebrewToken token;

            if (ch == '\'')
            {
                token = HebrewToken.SingleQuote;
            }
            else if (ch == '\"')
            {
                token = HebrewToken.DoubleQuote;
            }
            else
            {
                int index = (int)ch - minHebrewNumberCh;
                if (index >= 0 && index < s_hebrewValues.Length)
                {
                    token = s_hebrewValues[index].token;
                    if (token == HebrewToken.Invalid)
                    {
                        return(HebrewNumberParsingState.NotHebrewDigit);
                    }
                    context.result += s_hebrewValues[index].value;
                }
                else
                {
                    // Not in valid Hebrew digit range.
                    return(HebrewNumberParsingState.NotHebrewDigit);
                }
            }
            context.state = s_numberPasingState[(int)context.state * (int)HebrewTokenCount + (int)token];
            if (context.state == HS._err)
            {
                // Invalid Hebrew state.  This indicates an incorrect Hebrew number.
                return(HebrewNumberParsingState.InvalidHebrewNumber);
            }
            if (context.state == HS.END)
            {
                // Reach a terminal state.
                return(HebrewNumberParsingState.FoundEndOfHebrewNumber);
            }
            // We should continue to parse.
            return(HebrewNumberParsingState.ContinueParsing);
        }
Example #3
0
        internal static HebrewNumberParsingState ParseByChar(char ch, ref HebrewNumberParsingContext context)
        {
            HebrewToken singleQuote;

            if (ch == '\'')
            {
                singleQuote = HebrewToken.SingleQuote;
            }
            else if (ch == '"')
            {
                singleQuote = HebrewToken.DoubleQuote;
            }
            else
            {
                int index = ch - 'א';
                if ((index < 0) || (index >= HebrewValues.Length))
                {
                    return(HebrewNumberParsingState.NotHebrewDigit);
                }
                singleQuote = HebrewValues[index].token;
                if (singleQuote == HebrewToken.Invalid)
                {
                    return(HebrewNumberParsingState.NotHebrewDigit);
                }
                context.result += HebrewValues[index].value;
            }
            context.state = NumberPasingState[(int)context.state][(int)singleQuote];
            if (context.state == HS._err)
            {
                return(HebrewNumberParsingState.InvalidHebrewNumber);
            }
            if (context.state == HS.END)
            {
                return(HebrewNumberParsingState.FoundEndOfHebrewNumber);
            }
            return(HebrewNumberParsingState.ContinueParsing);
        }
Example #4
0
 // Token: 0x060031BF RID: 12735 RVA: 0x000BFA7C File Offset: 0x000BDC7C
 internal static HebrewNumberParsingState ParseByChar(char ch, ref HebrewNumberParsingContext context)
 {
     HebrewNumber.HebrewToken hebrewToken;
     if (ch == '\'')
     {
         hebrewToken = HebrewNumber.HebrewToken.SingleQuote;
     }
     else if (ch == '"')
     {
         hebrewToken = HebrewNumber.HebrewToken.DoubleQuote;
     }
     else
     {
         int num = (int)(ch - 'א');
         if (num < 0 || num >= HebrewNumber.HebrewValues.Length)
         {
             return(HebrewNumberParsingState.NotHebrewDigit);
         }
         hebrewToken = HebrewNumber.HebrewValues[num].token;
         if (hebrewToken == HebrewNumber.HebrewToken.Invalid)
         {
             return(HebrewNumberParsingState.NotHebrewDigit);
         }
         context.result += HebrewNumber.HebrewValues[num].value;
     }
     context.state = HebrewNumber.NumberPasingState[(int)context.state][(int)hebrewToken];
     if (context.state == HebrewNumber.HS._err)
     {
         return(HebrewNumberParsingState.InvalidHebrewNumber);
     }
     if (context.state == HebrewNumber.HS.END)
     {
         return(HebrewNumberParsingState.FoundEndOfHebrewNumber);
     }
     return(HebrewNumberParsingState.ContinueParsing);
 }
 internal static HebrewNumberParsingState ParseByChar(char ch, ref HebrewNumberParsingContext context)
 {
     HebrewToken singleQuote;
     if (ch == '\'')
     {
         singleQuote = HebrewToken.SingleQuote;
     }
     else if (ch == '"')
     {
         singleQuote = HebrewToken.DoubleQuote;
     }
     else
     {
         int index = ch - 'א';
         if ((index < 0) || (index >= HebrewValues.Length))
         {
             return HebrewNumberParsingState.NotHebrewDigit;
         }
         singleQuote = HebrewValues[index].token;
         if (singleQuote == HebrewToken.Invalid)
         {
             return HebrewNumberParsingState.NotHebrewDigit;
         }
         context.result += HebrewValues[index].value;
     }
     context.state = NumberPasingState[(int) context.state][(int) singleQuote];
     if (context.state == HS._err)
     {
         return HebrewNumberParsingState.InvalidHebrewNumber;
     }
     if (context.state == HS.END)
     {
         return HebrewNumberParsingState.FoundEndOfHebrewNumber;
     }
     return HebrewNumberParsingState.ContinueParsing;
 }
        ////////////////////////////////////////////////////////////////////////
        //
        // Actions:
        // Try to parse the current word to see if it is a Hebrew number.
        // Tokens will be updated accordingly.
        // This is called by the Lexer of DateTime.Parse().
        //
        // Unlike most of the functions in this class, the return value indicates
        // whether or not it started to parse. The badFormat parameter indicates
        // if parsing began, but the format was bad.
        //
        ////////////////////////////////////////////////////////////////////////

        private static bool TryParseHebrewNumber(
            ref __DTString str,
            out Boolean badFormat,
            out int number)  {

            number = -1;
            badFormat = false;

            int i = str.Index;
            if (!HebrewNumber.IsDigit(str.Value[i])) {
                // If the current character is not a Hebrew digit, just return false.
                // There is no chance that we can parse a valid Hebrew number from here.
                return (false);
            }
            // The current character is a Hebrew digit.  Try to parse this word as a Hebrew number.
            HebrewNumberParsingContext context = new HebrewNumberParsingContext(0);
            HebrewNumberParsingState state;

            do {
                state = HebrewNumber.ParseByChar(str.Value[i++], ref context);
                switch (state) {
                    case HebrewNumberParsingState.InvalidHebrewNumber:    // Not a valid Hebrew number.
                    case HebrewNumberParsingState.NotHebrewDigit:         // The current character is not a Hebrew digit character.
                        // Break out so that we don't continue to try parse this as a Hebrew number.
                        return (false);
                }
            } while (i < str.Value.Length && (state != HebrewNumberParsingState.FoundEndOfHebrewNumber));

            // When we are here, we are either at the end of the string, or we find a valid Hebrew number.
            Contract.Assert(state == HebrewNumberParsingState.ContinueParsing || state == HebrewNumberParsingState.FoundEndOfHebrewNumber,
                "Invalid returned state from HebrewNumber.ParseByChar()");

            if (state != HebrewNumberParsingState.FoundEndOfHebrewNumber) {
                // We reach end of the string but we can't find a terminal state in parsing Hebrew number.
                return (false);
            }

            // We have found a valid Hebrew number.  Update the index.
            str.Advance(i - str.Index);

            // Get the final Hebrew number value from the HebrewNumberParsingContext.
            number = context.result;

            return (true);
        }
		internal static bool MatchHebrewDigits(ref __DTString str, int digitLen, out int number)
		{
			number = 0;
			HebrewNumberParsingContext hebrewNumberParsingContext = new HebrewNumberParsingContext(0);
			HebrewNumberParsingState hebrewNumberParsingState = HebrewNumberParsingState.ContinueParsing;
			while (hebrewNumberParsingState == HebrewNumberParsingState.ContinueParsing && str.GetNext())
			{
				hebrewNumberParsingState = HebrewNumber.ParseByChar(str.GetChar(), ref hebrewNumberParsingContext);
			}
			if (hebrewNumberParsingState == HebrewNumberParsingState.FoundEndOfHebrewNumber)
			{
				number = hebrewNumberParsingContext.result;
				return true;
			}
			return false;
		}
Example #8
0
        ////////////////////////////////////////////////////////////////////////
        //
        // Actions:
        //    Parse the current word as a Hebrew number.
        //      This is used by DateTime.ParseExact().
        //
        ////////////////////////////////////////////////////////////////////////

        internal static bool MatchHebrewDigits(ref __DTString str, int digitLen, out int number) {
            number = 0;

            // Create a context object so that we can parse the Hebrew number text character by character.
            HebrewNumberParsingContext context = new HebrewNumberParsingContext(0);

            // Set this to ContinueParsing so that we will run the following while loop in the first time.
            HebrewNumberParsingState state = HebrewNumberParsingState.ContinueParsing;

            while (state == HebrewNumberParsingState.ContinueParsing && str.GetNext()) {
                state = HebrewNumber.ParseByChar(str.GetChar(), ref context);
            }

            if (state == HebrewNumberParsingState.FoundEndOfHebrewNumber) {
                // If we have reached a terminal state, update the result and returns.
                number = context.result;
                return (true);
            }

            // If we run out of the character before reaching FoundEndOfHebrewNumber, or
            // the state is InvalidHebrewNumber or ContinueParsing, we fail to match a Hebrew number.
            // Return an error.
            return false;
        }
Example #9
0
 ////////////////////////////////////////////////////////////////////////
 //  
 //  Actions:
 //      Parse the Hebrew number by passing one character at a time.
 //      The state between characters are maintained at HebrewNumberPasingContext.
 //  Returns:
 //      Return a enum of HebrewNumberParsingState.
 //          NotHebrewDigit: The specified ch is not a valid Hebrew digit.
 //          InvalidHebrewNumber: After parsing the specified ch, it will lead into
 //              an invalid Hebrew number text.
 //          FoundEndOfHebrewNumber: A terminal state is reached.  This means that
 //              we find a valid Hebrew number text after the specified ch is parsed.
 //          ContinueParsing: The specified ch is a valid Hebrew digit, and
 //              it will lead into a valid state in the state machine, we should
 //              continue to parse incoming characters.
 //
 ////////////////////////////////////////////////////////////////////////
 
 internal static HebrewNumberParsingState ParseByChar(char ch, ref HebrewNumberParsingContext context) {
     HebrewToken token;
     if (ch == '\'') {
         token = HebrewToken.SingleQuote;
     } else if (ch == '\"') {
         token = HebrewToken.DoubleQuote;
     } else {
         int index = (int)ch - minHebrewNumberCh;                
         if (index >= 0 && index < HebrewValues.Length ) {
             token = HebrewValues[index].token;
             if (token == HebrewToken.Invalid) {
                 return (HebrewNumberParsingState.NotHebrewDigit);
             }
             context.result += HebrewValues[index].value;
         } else {
             // Not in valid Hebrew digit range.
             return (HebrewNumberParsingState.NotHebrewDigit);
         }
     }
     context.state = NumberPasingState[(int)context.state][(int)token];
     if (context.state == HS._err) {
         // Invalid Hebrew state.  This indicates an incorrect Hebrew number.
         return (HebrewNumberParsingState.InvalidHebrewNumber);
     }                 
     if (context.state == HS.END) {
         // Reach a terminal state.
         return (HebrewNumberParsingState.FoundEndOfHebrewNumber);
     }
     // We should continue to parse.
     return (HebrewNumberParsingState.ContinueParsing);
 }
 private static bool TryParseHebrewNumber(ref __DTString str, out bool badFormat, out int number)
 {
     number = -1;
       badFormat = false;
       int index = str.Index;
       if (!HebrewNumber.IsDigit(str.Value[index]))
     return false;
       HebrewNumberParsingContext context = new HebrewNumberParsingContext(0);
       HebrewNumberParsingState numberParsingState;
       do
       {
     numberParsingState = HebrewNumber.ParseByChar(str.Value[index++], ref context);
     switch (numberParsingState)
     {
       case HebrewNumberParsingState.InvalidHebrewNumber:
       case HebrewNumberParsingState.NotHebrewDigit:
     return false;
       default:
     continue;
     }
       }
       while (index < str.Value.Length && numberParsingState != HebrewNumberParsingState.FoundEndOfHebrewNumber);
       if (numberParsingState != HebrewNumberParsingState.FoundEndOfHebrewNumber)
     return false;
       str.Advance(index - str.Index);
       number = context.result;
       return true;
 }