We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Globalization \ HS

SSCLI

// ==++==
//
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
namespace System.Globalization
{
using System;
using System.Text;
////////////////////////////////////////////////////////////////////////////
//
// Used in HebrewNumber.ParseByChar to maintain the context information (
// the state in the state machine and current Hebrew number values, etc.)
// when parsing Hebrew number character by character.
//
////////////////////////////////////////////////////////////////////////////
internal struct HebrewNumberParsingContext
{
// The current state of the state machine for parsing Hebrew numbers.
internal HebrewNumber.HS state;
// The current value of the Hebrew number.
// The final value is determined when state is FoundEndOfHebrewNumber.
internal int result;
public HebrewNumberParsingContext(int result)
{
// Set the start state of the state machine for parsing Hebrew numbers.
state = HebrewNumber.HS.Start;
this.result = 0;
}
}
////////////////////////////////////////////////////////////////////////////
//
// Please see ParseByChar() for comments about different states defined here.
//
////////////////////////////////////////////////////////////////////////////
internal enum HebrewNumberParsingState
{
InvalidHebrewNumber,
NotHebrewDigit,
FoundEndOfHebrewNumber,
ContinueParsing
}
////////////////////////////////////////////////////////////////////////////
//
// class HebrewNumber
//
// Provides static methods for formatting integer values into
// Hebrew text and parsing Hebrew number text.
//
// Limitations:
// Parse can only handles value 1 ~ 999.
// ToString() can only handles 1 ~ 999. If value is greater than 5000,
// 5000 will be subtracted from the value.
//
////////////////////////////////////////////////////////////////////////////
internal class HebrewNumber
{
// This class contains only static methods. Add a private ctor so that
// compiler won't generate a default one for us.
private HebrewNumber()
{
}
////////////////////////////////////////////////////////////////////////////
//
// ToString
//
// Converts the given number to Hebrew letters according to the numeric
// value of each Hebrew letter. Basically, this converts the lunar year
// and the lunar month to letters.
//
// The character of a year is described by three letters of the Hebrew
// alphabet, the first and third giving, respectively, the days of the
// weeks on which the New Year occurs and Passover begins, while the
// second is the initial of the Hebrew word for defective, normal, or
// complete.
//
// Defective Year : Both Heshvan and Kislev are defective (353 or 383 days)
// Normal Year : Heshvan is defective, Kislev is full (354 or 384 days)
// Complete Year : Both Heshvan and Kislev are full (355 or 385 days)
//
////////////////////////////////////////////////////////////////////////////
static internal string ToString(int Number)
{
char cTens = '\0';
char cUnits;
// tens and units chars
int Hundreds;
int Tens;
// hundreds and tens values
StringBuilder szHebrew = new StringBuilder();
//
// Adjust the number if greater than 5000.
//
if (Number > 5000) {
Number -= 5000;
}
BCLDebug.Assert(Number > 0 && Number <= 999, "Number is out of range.");
;
//
// Get the Hundreds.
//
Hundreds = Number / 100;
if (Hundreds > 0) {
Number -= Hundreds * 100;
// \x05e7 = 100
// \x05e8 = 200
// \x05e9 = 300
// \x05ea = 400
// If the number is greater than 400, use the multiples of 400.
for (int i = 0; i < (Hundreds / 4); i++) {
szHebrew.Append('ת');
}
int remains = Hundreds % 4;
if (remains > 0) {
szHebrew.Append((char)((int)'צ' + remains));
}
}
//
// Get the Tens.
//
Tens = Number / 10;
Number %= 10;
switch (Tens) {
case (0):
cTens = '\0';
break;
case (1):
cTens = 'י';
// Hebrew Letter Yod
break;
case (2):
cTens = 'כ';
// Hebrew Letter Kaf
break;
case (3):
cTens = 'ל';
// Hebrew Letter Lamed
break;
case (4):
cTens = 'מ';
// Hebrew Letter Mem
break;
case (5):
cTens = 'נ';
// Hebrew Letter Nun
break;
case (6):
cTens = 'ס';
// Hebrew Letter Samekh
break;
case (7):
cTens = 'ע';
// Hebrew Letter Ayin
break;
case (8):
cTens = 'פ';
// Hebrew Letter Pe
break;
case (9):
cTens = 'צ';
// Hebrew Letter Tsadi
break;
}
//
// Get the Units.
//
cUnits = (char)(Number > 0 ? ((int)'א' + Number - 1) : 0);
// Hebrew Letter He (5)
if ((cUnits == 'ה') && (cTens == 'י')) {
// Hebrew Letter Yod (10)
cUnits = 'ו';
// Hebrew Letter Vav (6)
cTens = 'ט';
// Hebrew Letter Tet (9)
}
// Hebrew Letter Vav (6)
if ((cUnits == 'ו') && (cTens == 'י')) {
// Hebrew Letter Yod (10)
cUnits = 'ז';
// Hebrew Letter Zayin (7)
cTens = 'ט';
// Hebrew Letter Tet (9)
}
//
// Copy the appropriate info to the given buffer.
//
if (cTens != '\0') {
szHebrew.Append(cTens);
}
if (cUnits != '\0') {
szHebrew.Append(cUnits);
}
if (szHebrew.Length > 1) {
szHebrew.Insert(szHebrew.Length - 1, '"');
}
else {
szHebrew.Append('\'');
}
//
// Return success.
//
return (szHebrew.ToString());
}
////////////////////////////////////////////////////////////////////////////
//
// Token used to tokenize a Hebrew word into tokens so that we can use in the
// state machine.
//
////////////////////////////////////////////////////////////////////////////
enum HebrewToken
{
Invalid = -1,
Digit400 = 0,
Digit200_300 = 1,
Digit100 = 2,
Digit10 = 3,
// 10 ~ 90
Digit1 = 4,
// 1, 2, 3, 4, 5, 8,
Digit6_7 = 5,
Digit7 = 6,
Digit9 = 7,
SingleQuote = 8,
DoubleQuote = 9
}
////////////////////////////////////////////////////////////////////////////
//
// This class is used to map a token into its Hebrew digit value.
//
////////////////////////////////////////////////////////////////////////////
class HebrewValue
{
internal HebrewToken token;
internal int value;
internal HebrewValue(HebrewToken token, int value)
{
this.token = token;
this.value = value;
}
}
//
// Map a Hebrew character from U+05D0 ~ U+05EA to its digit value.
// The value is -1 if the Hebrew character does not have a associated value.
//
static HebrewValue[] HebrewValues = {new HebrewValue(HebrewToken.Digit1, 1), new HebrewValue(HebrewToken.Digit1, 2), new HebrewValue(HebrewToken.Digit1, 3), new HebrewValue(HebrewToken.Digit1, 4), new HebrewValue(HebrewToken.Digit1, 5), new HebrewValue(HebrewToken.Digit6_7, 6), new HebrewValue(HebrewToken.Digit6_7, 7), new HebrewValue(HebrewToken.Digit1, 8), new HebrewValue(HebrewToken.Digit9, 9), new HebrewValue(HebrewToken.Digit10, 10),
new HebrewValue(HebrewToken.Invalid, -1), new HebrewValue(HebrewToken.Digit10, 20), new HebrewValue(HebrewToken.Digit10, 30), new HebrewValue(HebrewToken.Invalid, -1), new HebrewValue(HebrewToken.Digit10, 40), new HebrewValue(HebrewToken.Invalid, -1), new HebrewValue(HebrewToken.Digit10, 50), new HebrewValue(HebrewToken.Digit10, 60), new HebrewValue(HebrewToken.Digit10, 70), new HebrewValue(HebrewToken.Invalid, -1),
// '\x05d0
// '\x05d1
// '\x05d2
// '\x05d3
// '\x05d4
// '\x05d5
// '\x05d6
// '\x05d7
// '\x05d8
// '\x05d9; // Hebrew Letter Yod
// '\x05da;
// '\x05db; // Hebrew Letter Kaf
// '\x05dc; // Hebrew Letter Lamed
// '\x05dd;
// '\x05de; // Hebrew Letter Mem
// '\x05df;
// '\x05e0; // Hebrew Letter Nun
// '\x05e1; // Hebrew Letter Samekh
// '\x05e2; // Hebrew Letter Ayin
// '\x05e3;
// '\x05e4; // Hebrew Letter Pe
// '\x05e5;
// '\x05e6; // Hebrew Letter Tsadi
// '\x05e7;
// '\x05e8;
// '\x05e9;
// '\x05ea;
new HebrewValue(HebrewToken.Digit10, 80), new HebrewValue(HebrewToken.Invalid, -1), new HebrewValue(HebrewToken.Digit10, 90), new HebrewValue(HebrewToken.Digit100, 100), new HebrewValue(HebrewToken.Digit200_300, 200), new HebrewValue(HebrewToken.Digit200_300, 300), new HebrewValue(HebrewToken.Digit400, 400)};
const int minHebrewNumberCh = 1488;
static char maxHebrewNumberCh = (char)(minHebrewNumberCh + HebrewValues.Length - 1);
////////////////////////////////////////////////////////////////////////////
//
// Hebrew number parsing State
// The current state and the next token will lead to the next state in the state machine.
// DQ = Double Quote
//
////////////////////////////////////////////////////////////////////////////
internal enum HS
{
_err = -1,
// an error state
Start = 0,
S400 = 1,
// a Hebrew digit 400
S400_400 = 2,
// Two Hebrew digit 400
S400_X00 = 3,
// Two Hebrew digit 400 and followed by 100
S400_X0 = 4,
// Hebrew digit 400 and followed by 10 ~ 90
X00_DQ = 5,
// A hundred number and followed by a double quote.
S400_X00_X0 = 6,
X0_DQ = 7,
// A two-digit number and followed by a double quote.
X = 8,
// A single digit Hebrew number.
X0 = 9,
// A two-digit Hebrew number
X00 = 10,
// A three-digit Hebrew number
S400_DQ = 11,
// A Hebrew digit 400 and followed by a double quote.
S400_400_DQ = 12,
S400_400_100 = 13,
S9 = 14,
// Hebrew digit 9
X00_S9 = 15,
// A hundered number and followed by a digit 9
S9_DQ = 16,
// Hebrew digit 9 and followed by a double quote
END = 100
// A terminial state is reached.
}
//
// The state machine for Hebrew number pasing.
//
static HS[][] m_numberPasingState = {new HS[] {HS.S400, HS.X00, HS.X00, HS.X0, HS.X, HS.X, HS.X, HS.S9, HS._err, HS._err
}, new HS[] {HS.S400_400, HS.S400_X00, HS.S400_X00, HS.S400_X0, HS._err, HS._err, HS._err, HS.X00_S9, HS.END, HS.S400_DQ
}, new HS[] {HS._err, HS._err, HS.S400_400_100, HS.S400_X0, HS._err, HS._err, HS._err, HS.X00_S9, HS._err, HS.S400_400_DQ
}, new HS[] {HS._err, HS._err, HS._err, HS.S400_X00_X0, HS._err, HS._err, HS._err, HS.X00_S9, HS._err, HS.X00_DQ
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS.X0_DQ
}, new HS[] {HS._err, HS._err, HS._err, HS.END, HS.END, HS.END, HS.END, HS.END, HS._err, HS._err
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS.X0_DQ
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS.END, HS.END, HS.END, HS.END, HS._err, HS._err
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS.END, HS._err
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS.END, HS.X0_DQ
},
new HS[] {HS._err, HS._err, HS._err, HS.S400_X0, HS._err, HS._err, HS._err, HS.X00_S9, HS.END, HS.X00_DQ
}, new HS[] {HS.END, HS.END, HS.END, HS.END, HS.END, HS.END, HS.END, HS.END, HS._err, HS._err
}, new HS[] {HS._err, HS._err, HS.END, HS.END, HS.END, HS.END, HS.END, HS.END, HS._err, HS._err
}, new HS[] {HS._err, HS._err, HS._err, HS.S400_X00_X0, HS._err, HS._err, HS._err, HS.X00_S9, HS._err, HS.X00_DQ
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS.END, HS.S9_DQ
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS._err, HS.S9_DQ
}, new HS[] {HS._err, HS._err, HS._err, HS._err, HS._err, HS.END, HS.END, HS._err, HS._err, HS._err
// 400 300/200 100 90~10 8~1 6, 7, 9, ' "
/* 0 */ /* 1: S400 */ /* 2: S400_400 */ /* 3: S400_X00 */ /* 4: S400_X0 */ /* 5: X00_DQ */ /* 6: S400_X00_X0 */ /* 7: X0_DQ */ /* 8: X */ /* 9: X0 */ /* 10: X00 */ /* 11: S400_DQ */ /* 12: S400_400_DQ*/ /* 13: S400_400_100*/ /* 14: S9 */ /* 15: X00_S9 */ /* 16: S9_DQ */ }};
////////////////////////////////////////////////////////////////////////
//
// Actions:
// Parse a Hebrew number string.
// Returns:
// -1 if this is not a valid Hebrew string.
// Otherwise, a positive number is returned.
// Limitations:
// The state machine only parses Hebrew number from 1 ~ 999.
//
////////////////////////////////////////////////////////////////////////
/*
internal static int Parse(String str) {
BCLDebug.Assert(str != null, "str != null");
HebrewNumberParsingContext context = new HebrewNumberParsingContext();
HebrewNumberParsingState result = 0;
int i;
for (i = 0; i < str.Length; i++) {
result = ParseByChar(str[i], context);
if (result == HebrewNumberParsingState.NotHebrewDigit || result == HebrewNumberParsingState.InvalidHebrewNumber) {
return (-1);
}
if (result == HebrewNumberParsingState.FoundEndOfHebrewNumber) {
// Reach the terminal state.
break;
}
}
if (result == HebrewNumberParsingState.FoundEndOfHebrewNumber && i == str.Length - 1) {
return (context.result);
}
// There are still characters left in the string or a terminal state is not reached.
return (-1);
}
*/
////////////////////////////////////////////////////////////////////////
//
// 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.
//
////////////////////////////////////////////////////////////////////////
static internal 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 = m_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);
}
////////////////////////////////////////////////////////////////////////
//
// Actions:
// Check if the ch is a valid Hebrew number digit.
// This function will return true if the specified char is a legal Hebrew
// digit character, single quote, or double quote.
// Returns:
// true if the specified character is a valid Hebrew number character.
//
////////////////////////////////////////////////////////////////////////
static internal bool IsDigit(char ch)
{
if (ch >= minHebrewNumberCh && ch <= maxHebrewNumberCh) {
return (HebrewValues[ch - minHebrewNumberCh].value >= 0);
}
return (ch == '\'' || ch == '"');
}
}
}