/// <summary>
/// Initializes a new instance of the <see cref="StringRules"/> class.
/// </summary>
/// <param name="minLength">The minimum string length allowed.</param>
/// <param name="maxLength">The maximum string length allowed.</param>
/// <param name="allowedChars">The set of allowed characters.</param>
/// <param name="regexOptions">The additional regex options to use.</param>
/// <param name="customerFilters">An optional collection of custom <see cref="Regex"/> patterns that describe
/// additional restrictions.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="minLength"/> is less than 0.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="maxLength"/> is less than
/// <paramref name="minLength"/>.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="minLength"/> is greater than
/// <see cref="ushort.MaxValue"/>.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="maxLength"/> is greater than
/// <see cref="ushort.MaxValue"/>.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="allowedChars"/> contains no defined groups.</exception>
/// <exception cref="ArgumentException">At least one character group must be allowed.</exception>
public StringRules(int minLength, int maxLength, CharType allowedChars, RegexOptions regexOptions = RegexOptions.None,
IEnumerable<Regex> customerFilters = null)
{
if (minLength < 0)
throw new ArgumentOutOfRangeException("minLength");
if (maxLength < minLength)
throw new ArgumentOutOfRangeException("maxLength");
if (minLength > ushort.MaxValue)
throw new ArgumentOutOfRangeException("minLength");
if (maxLength > ushort.MaxValue)
throw new ArgumentOutOfRangeException("maxLength");
if ((int)allowedChars == 0)
throw new ArgumentException("At least one character group must be allowed.", "allowedChars");
_minLength = (ushort)minLength;
_maxLength = (ushort)maxLength;
_allowedChars = allowedChars;
var regexStr = BuildRegexString(minLength, maxLength, allowedChars);
_regex = new Regex(regexStr, RegexOptions.Compiled | regexOptions);
if (customerFilters != null)
_customFilters = customerFilters.ToCompact();
}
static void SetFlags (string values, CharType bit, CharType bitcopy, bool remove)
{
int i;
if (remove) {
for (i = 0; i < 128; i++)
table[i] |= bit;
for (i = 0; i < values.Length; i++)
table[values[i]] &= ~bit;
if (bitcopy != CharType.None) {
for (i = 0; i < 256; i++) {
if ((table[i] & bitcopy) != 0)
table[i] &= ~bit;
}
}
} else {
for (i = 0; i < values.Length; i++)
table[values[i]] |= bit;
if (bitcopy != CharType.None) {
for (i = 0; i < 256; i++) {
if ((table[i] & bitcopy) != 0)
table[i] |= bit;
}
}
}
}
public StringGenerator(int minUpperCaseChars, int minLowerCaseChars,
int minNumericChars, int minSpecialChars, CharType fillRest)
{
this.MinUpperCaseChars = minUpperCaseChars;
this.MinLowerCaseChars = minLowerCaseChars;
this.MinNumericChars = minNumericChars;
this.MinSpecialChars = minSpecialChars;
this.FillRest = fillRest;
}
static void Main( )
{
CharType a = new CharType( 'a' );
List<CharType> b = new List<CharType>();
b.Add(a);
SearchHelper.Initialize<CharType>( b, b );
int result = SearchHelper.Search(b);
Console.WriteLine(result);
Console.ReadKey();
}
public static ElementStringFormat GetFormat(string applicationIdentifier, CharType dataType, int dataLength, bool fnc1, string description)
{
ElementStringFormat format = new ElementStringFormat();
format.AI = applicationIdentifier;
format.DataType = dataType;
format.DataLength = dataLength;
format.FNC1 = fnc1;
format.Description = description;
format.NumberOfDecimal = -1;
return format;
}
/// <summary>
/// Returns a random character.
/// </summary>
/// <param name="random">The current instance.</param>
/// <param name="mode">What kind of characters are allowed.</param>
/// <returns>A random character.</returns>
public static char NextChar(this Random random, CharType mode)
{
Contract.Requires(random != null);
switch (mode)
{
case CharType.AlphabeticAny: return random.NextAlphabeticChar();
case CharType.AlphabeticLower: return random.NextAlphabeticChar(false);
case CharType.AlphabeticUpper: return random.NextAlphabeticChar(true);
case CharType.AlphanumericAny: return random.NextAlphanumericChar();
case CharType.AlphanumericLower: return random.NextAlphanumericChar(false);
case CharType.AlphanumericUpper: return random.NextAlphanumericChar(true);
case CharType.Numeric: return random.NextNumericChar();
default: return random.NextAlphanumericChar();
}
}
public static void addActor(Vector2 pos, float Z, CharType Char_Type, ControlType Cont_Type, string name, bool randParts)
{
try
{
character[] old = world.levels[world.i_currentLvl].char_living;
world.levels[world.i_currentLvl].char_living = new character[old.Length + 1];
for (int i = 0; i != old.Length; i++)
{
world.levels[world.i_currentLvl].char_living[i] = old[i];
}
if (randParts)
{
world.levels[world.i_currentLvl].char_living[old.Length] = CreateActor(pos, Z, Char_Type, Cont_Type, true);
world.levels[world.i_currentLvl].char_living[old.Length].attrib = new skill(100);
//world.levels[world.i_currentLvl].char_living[old.Length].attrib.hp_current = world.levels[world.i_currentLvl].char_living[old.Length].attrib.hp_max = 100;
}
else
{
world.levels[world.i_currentLvl].char_living[old.Length] = CreateActor(pos, Z, Char_Type, Cont_Type, name);
world.levels[world.i_currentLvl].char_living[old.Length].attrib = new skill(100);
//world.levels[world.i_currentLvl].char_living[old.Length].attrib.hp_current = world.levels[world.i_currentLvl].char_living[old.Length].attrib.hp_max = 100;
}
thisPlayerLiving = true;
}
catch
{
world.levels[world.i_currentLvl].char_living = new character[1];
if (randParts)
{
world.levels[world.i_currentLvl].char_living[0] = CreateActor(pos, Z, Char_Type, Cont_Type, true);
world.levels[world.i_currentLvl].char_living[0].attrib = new skill(100);
//world.levels[world.i_currentLvl].char_living[0].attrib.hp_current = world.levels[world.i_currentLvl].char_living[0].attrib.hp_max = 100;
}
else
{
world.levels[world.i_currentLvl].char_living[0] = CreateActor(pos, Z, Char_Type, Cont_Type, name);
world.levels[world.i_currentLvl].char_living[0].attrib = new skill(100);
//world.levels[world.i_currentLvl].char_living[0].attrib.hp_current = world.levels[world.i_currentLvl].char_living[0].attrib.hp_max = 100;
}
thisPlayerLiving = true;
}
}
static void Main( )
{
CharType a = new CharType( 'a' );
List<CharType> b = new List<CharType>();
b.Add(a);
//
SuffixTree tree = SuffixTreeHelper.BuildSuffixTree<CharType>(b, b);
int result = SearchHelper.Search(b, tree);
Console.WriteLine(result);
//
Node parent = new Node( 5 );
Node son = new Node( ref parent, 9 );
parent.AddChildren( ref son );
foreach(var child in parent.GetChildren())
{
Console.WriteLine( child.GetParent().GetPositionInText() );
}
Console.ReadKey();
}
public currentChar(char c)
{
val = c;
if (char.IsNumber(c)) {
currentCharTokenType = CharType.number;
}
if (char.IsLetter(c) || c == '_')
currentCharTokenType = CharType.letter;
if (syntaxChars.Contains(c))
currentCharTokenType = CharType.syntaxChar;
if (arithmeticOperations.Contains(c)) {
currentCharTokenType = CharType.arithmeticOp;
}
if (c == '(' || c == ')')
currentCharTokenType = CharType.brace;
if (c == ' ')
currentCharTokenType = CharType.whitespace;
if (c == '+' || c == '-')
currentCharTokenType = CharType.plusOrMinusSign;
}
public SpecialCharacter(BackReference back)
{
if (!back.IsOctal)
{
Utility.ExpressoError("Error trying to convert a Backreference item to a Special Character");
return;
}
this.Description = string.Concat("Octal ", back.Contents);
this.CharacterType = CharType.Octal;
this.character = back.Contents;
this.Literal = string.Concat("\\", back.Contents);
this.Escaped = false;
this.End = back.End;
this.AsFewAsPossible = back.AsFewAsPossible;
this.m = back.m;
this.n = back.n;
this.MatchIfAbsent = back.MatchIfAbsent;
this.RepeatType = back.RepeatType;
this.Start = back.Start;
}
private BreakPosition MatchBreak(CharType aPrevType, CharType aPosType, string aText, int aIndex)
{
switch (aPosType)
{
case CharType.jctHZ:
{
if ((aPrevType == CharType.jctZM) ||
(aPrevType == CharType.jctSZ) ||
(aPrevType == CharType.jctHZ) ||
(aPrevType == CharType.jctFH)) // 当前位置是汉字，前一个是字母、数字、汉字
{
return(BreakPosition.jbpPrev);
}
}
break;
case CharType.jctZM:
{
if ((aPrevType != CharType.jctZM) && (aPrevType != CharType.jctSZ)) // 当前是字母，前一个不是数字、字母
{
return(BreakPosition.jbpPrev);
}
}
break;
case CharType.jctSZ:
{
switch (aPrevType)
{
case CharType.jctZM:
case CharType.jctSZ:
break;
case CharType.jctFH:
{
string vChar = aText.Substring(aIndex - 1 - 1, 1);
if (vChar == "￠")
{
}
else
{
if ((vChar != ".") && (vChar != ":") && (vChar != "-") && (vChar != "^") && (vChar != "*") && (vChar != "/"))
{
return(BreakPosition.jbpPrev);
}
}
}
break;
default:
return(BreakPosition.jbpPrev);
}
}
break;
case CharType.jctFH:
{
switch (aPrevType)
{
case CharType.jctFH:
break;
case CharType.jctSZ:
{
string vChar = aText.Substring(aIndex - 1, 1);
if ((vChar != ".") && (vChar != ":") && (vChar != "-") && (vChar != "^") && (vChar != "*") && (vChar != "/"))
{
return(BreakPosition.jbpPrev);
}
}
break;
case CharType.jctZM:
{
if (aText.Substring(aIndex - 1, 1) != ":")
{
return(BreakPosition.jbpPrev);
}
}
break;
default:
return(BreakPosition.jbpPrev);
}
}
break;
}
return(BreakPosition.jbpNone);
}
static void Main(string[] args)
{
int nLines = 4;
int[] llen = new int[4];
string[] lines = new string[] {
" first 123 and then -.1234 but you'll need 123.456 and 7e-4 plus one like +321. all quite avant-",
"garde whereas ellen's true favourites are 123.654E-2 exponent-form which can also be -54321E-03 or this -.9E+5",
"We'll prefer items like fmt1-decimal +.1234567e+05 or fmt2-dec -765.3245 or fmt1-int -837465 and vice-",
"versa or even format2-integers -19283746 making one think of each state's behaviour for 9 or even 3471e-7 states "
};
// PRINT OUT THE TEXT LINES AS SINGLE STRINGS FOLLOWED BY THIER LENGTH.
Console.WriteLine("\n\nHERE ARE THE TEXT LINES PRINTED OUT AS SINGLE STRINGS ... EACH FOLLOWED BY ITS LENGTH. \n\n");
for (int k = 0; k < nLines; k++)
{
Console.WriteLine(lines[k], "\n");
llen[k] = lines[k].Length;
Console.WriteLine(llen[k]);
}
Console.WriteLine("\n\n");
Console.ReadLine();
//NOW PRINT OUT THE LINES 1 CHARACTER AT A TIME.
Console.WriteLine("\nHERE ARE THE SAME LINES AGAIN ... this time printed character by character.\n\n");
for (int i = 0; i < nLines; i++)
{
Console.WriteLine("\n" + lines[i] + "\n");
line = lines[i].ToCharArray();
len = line.Length;
k = 0;
if (state != StateType.word || type != CharType.minus)
{
state = StateType.white;
}
ch = line[0];
type = getType(ch);
while (k < len - 1)
{
switch (state)
{
case StateType.white:
WhiteState();
break;
case StateType.word:
WordState();
break;
case StateType.num:
NumState();
break;
case StateType.dble:
DblState();
break;
case StateType.expt:
ExpoState();
break;
}
}
Console.Write("\nPress any key to continue...");
Console.ReadKey();
}
Console.WriteLine("\n");
Console.ReadLine();
}
static void RemoveFlags (string values, CharType bit)
{
for (int i = 0; i < values.Length; i++)
table[(byte) values[i]] &= ~bit;
}
public static char GetBorderChar(BorderType borderType, CharType charType)
{
switch (charType)
{
case CharType.TopLeftCorner:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('┌');
case BorderType.SingleThickBorder:
return('┏');
case BorderType.SingleToDoubleBorder:
return('╒');
case BorderType.DoubleBorder:
return('╔');
case BorderType.DoubleToSingleBorder:
return('╓');
default:
return('╔');
}
case CharType.Horizontal:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('─');
case BorderType.SingleThickBorder:
return('━');
case BorderType.SingleToDoubleBorder:
return('═');
case BorderType.DoubleBorder:
return('═');
case BorderType.DoubleToSingleBorder:
return('─');
default:
return('═');
}
case CharType.TopRightCorner:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('┐');
case BorderType.SingleThickBorder:
return('┓');
case BorderType.SingleToDoubleBorder:
return('╕');
case BorderType.DoubleBorder:
return('╗');
case BorderType.DoubleToSingleBorder:
return('╖');
default:
return('╗');
}
case CharType.LeftT:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('├');
case BorderType.SingleThickBorder:
return('┣');
case BorderType.SingleToDoubleBorder:
return('╞');
case BorderType.DoubleBorder:
return('╠');
case BorderType.DoubleToSingleBorder:
return('╟');
default:
return('╠');
}
case CharType.CentreCross:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('┼');
case BorderType.SingleThickBorder:
return('╋');
case BorderType.SingleToDoubleBorder:
return('╪');
case BorderType.DoubleBorder:
return('╬');
case BorderType.DoubleToSingleBorder:
return('╫');
default:
return('╬');
}
case CharType.RightT:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('┤');
case BorderType.SingleThickBorder:
return('┫');
case BorderType.SingleToDoubleBorder:
return('╡');
case BorderType.DoubleBorder:
return('╣');
case BorderType.DoubleToSingleBorder:
return('╢');
default:
return('╣');
}
case CharType.Vertical:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('│');
case BorderType.SingleThickBorder:
return('┃');
case BorderType.SingleToDoubleBorder:
return('│');
case BorderType.DoubleBorder:
return('║');
case BorderType.DoubleToSingleBorder:
return('║');
default:
return('║');
}
case CharType.BottomLeftCorner:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('└');
case BorderType.SingleThickBorder:
return('┗');
case BorderType.SingleToDoubleBorder:
return('╘');
case BorderType.DoubleBorder:
return('╚');
case BorderType.DoubleToSingleBorder:
return('╙');
default:
return('╚');
}
case CharType.BottomRightCorner:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('┘');
case BorderType.SingleThickBorder:
return('┛');
case BorderType.SingleToDoubleBorder:
return('╛');
case BorderType.DoubleBorder:
return('╝');
case BorderType.DoubleToSingleBorder:
return('╜');
default:
return('╝');
}
case CharType.BottomT:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('┴');
case BorderType.SingleThickBorder:
return('┻');
case BorderType.SingleToDoubleBorder:
return('╧');
case BorderType.DoubleBorder:
return('╩');
case BorderType.DoubleToSingleBorder:
return('╨');
default:
return('╩');
}
case CharType.TopT:
switch (borderType)
{
case BorderType.SingleThinBorder:
return('┬');
case BorderType.SingleThickBorder:
return('┳');
case BorderType.SingleToDoubleBorder:
return('╤');
case BorderType.DoubleBorder:
return('╦');
case BorderType.DoubleToSingleBorder:
return('╥');
default:
return('╦');
}
default:
return(' ');
}
}
public static bool IsType(this byte c, CharType type)
{
return((table[c] & type) != 0);
}
public static List <SkillTypeInfo> GetSkillInfosUnderDisciplines(CharType.CHARTYPE chartype)
{
return(GetSkillInfosUnderDisciplines(CharType.GetDisciplines(chartype)));
}
private void ResolveNeutrals()
{
CharType strongType = _sos;
BidiLink neutralLink = null;
for (BidiLink link = _roller.Next; link != _roller; link = link.Next)
{
CharType type = link.type;
#if DEBUG
ValidateTypeForNeutralRules(type);
#endif
switch (type)
{
case CharType.L:
strongType = CharType.L;
break;
case CharType.R:
case CharType.EN:
case CharType.AN:
strongType = CharType.R;
break;
case CharType.B:
case CharType.S:
case CharType.WS:
case CharType.ON:
case CharType.LRI:
case CharType.RLI:
case CharType.FSI:
case CharType.PDI:
if (neutralLink == null)
{
neutralLink = link;
}
CharType nextType = link.Next.type;
switch (nextType)
{
case CharType.Nil:
nextType = _eos;
break;
case CharType.EN:
case CharType.AN:
nextType = CharType.R;
break;
}
if (nextType == CharType.R || nextType == CharType.L)
{
// Rules N1, N2
CharType resolvedType = (strongType == nextType
? strongType
: Level.MakeEmbeddingType(_level)
);
do
{
neutralLink.type = resolvedType;
neutralLink = neutralLink.Next;
} while (neutralLink != link.Next);
neutralLink = null;
}
break;
}
}
}
public void Segment(string text, List <NodeBase.Element> widths, Func <char, float> fontwidth)
{
// 判断标准，如果全英文的，那么都尽量在同一行显示
using (PD <StringBuilder> psb = Pool.GetSB())
{
StringBuilder sb = psb.value;
char current;
CharType lasttype = CharType.Null;
for (int i = 0; i < text.Length; ++i)
{
current = text[i];
CharType ct = GetCharType(current);
switch (ct)
{
case CharType.English:
{
switch (lasttype)
{
case CharType.Chinese: // 中文接英文，那么先把中文的保存起来
widths.Add(Create(sb, fontwidth));
break;
case CharType.Punctuation: // 英文接标点符号的
widths.Add(Create(sb, fontwidth));
break;
case CharType.English:
break;
}
sb.Append(current);
}
break;
case CharType.Chinese:
{
switch (lasttype)
{
case CharType.Chinese: // 中文接英文，那么先把中文的保存起来
widths.Add(Create(sb, fontwidth));
break;
case CharType.Punctuation:
case CharType.English:
break;
}
sb.Append(current);
}
break;
case CharType.Punctuation: // 标点符号
{
sb.Append(current);
widths.Add(Create(sb, fontwidth));
}
break;
}
lasttype = ct;
}
if (sb.Length != 0)
{
widths.Add(Create(sb, fontwidth));
}
}
}
public override object Exec(CharType ct, object arg)
{
this.codeGenerator.convToChar(this.indent);
return(null);
}
private void ShowPage()
{
GUI.skin.label.wordWrap = true;
if (pageNumber == 0)
{
if (Resource.ACLogo != null)
{
GUILayout.Label(Resource.ACLogo);
}
GUILayout.Space(5f);
GUILayout.Label("This window can assist with the creation of a Player or NPC.");
GUILayout.Label("To begin, click 'Next'.");
}
else if (pageNumber == 1)
{
GUILayout.Label("Is this a Player or an NPC?");
charType = (CharType)EditorGUILayout.EnumPopup(charType);
if (charType == CharType.NPC)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Label("The character's name:", GUILayout.Width(150f));
charName = GUILayout.TextField(charName);
EditorGUILayout.EndHorizontal();
}
else
{
if (AdvGame.GetReferences().settingsManager&& AdvGame.GetReferences().settingsManager.movementMethod == MovementMethod.FirstPerson)
{
return;
}
}
GUILayout.Label("Assign your character's base GameObject (such as a skinned mesh renderer or 'idle' sprite):");
baseObject = (GameObject)EditorGUILayout.ObjectField(baseObject, typeof(GameObject), true);
if (baseObject != null && !IsFirstPerson())
{
if (baseObject.GetComponent <AC.Char>())
{
EditorGUILayout.HelpBox("The wizard cannot modify an existing character!", MessageType.Warning);
}
else if (PrefabUtility.GetPrefabType(baseObject) == PrefabType.Prefab || !baseObject.activeInHierarchy)
{
EditorGUILayout.HelpBox("The object must be in the scene and enabled for the wizard to work.", MessageType.Warning);
}
}
}
else if (pageNumber == 2)
{
GUILayout.Label("How should your " + charType.ToString() + "' should be animated?");
animationEngine = (AnimationEngine)EditorGUILayout.EnumPopup(animationEngine);
if (animationEngine == AnimationEngine.Custom)
{
EditorGUILayout.HelpBox("This option is intended for characters that make use of a custom/third-party animation system that will require additional coding.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.Legacy)
{
EditorGUILayout.HelpBox("Legacy animation is for 3D characters that do not require complex animation trees or multiple layers. Its easier to use than Mecanim, but not as powerful.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.Mecanim)
{
EditorGUILayout.HelpBox("Mecanim animation is the standard option for 3D characters. You will need to define Mecanim parameters and transitions, but will have full control over how the character is animated.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.Sprites2DToolkit)
{
EditorGUILayout.HelpBox("This option allows you to animate characters using the 3rd-party 2D Toolkit asset.", MessageType.Info);
if (!tk2DIntegration.IsDefinePresent())
{
EditorGUILayout.HelpBox("The 'tk2DIsPresent' preprocessor define must be declared in your game's Scripting Define Symbols, found in File -> Build -> Player settings.", MessageType.Warning);
}
}
else if (animationEngine == AnimationEngine.SpritesUnity)
{
EditorGUILayout.HelpBox("This option is the standard option for 2D characters. Animation clips are played automatically, without the need to define Mecanim parameters, but you will not be able to make e.g. smooth transitions between the different movement animations.", MessageType.Info);
}
else if (animationEngine == AnimationEngine.SpritesUnityComplex)
{
EditorGUILayout.HelpBox("This option is harder to use than 'Sprites Unity', but gives you more control over how your character animates - allowing you to control animations using Mecanim parameters and transitions.", MessageType.Info);
}
}
else if (pageNumber == 3)
{
EditorGUILayout.LabelField("Chosen animation engine: " + animationEngine.ToString(), EditorStyles.boldLabel);
if (!IsFirstPerson())
{
if (animationEngine == AnimationEngine.Custom)
{
EditorGUILayout.HelpBox("A subclass of 'AnimEngine' will be used to bridge AC with an external animation engine. The subclass script defined above must exist for the character to animate. Once created, enter its name in the box below:", MessageType.Info);
customAnimationClass = EditorGUILayout.TextField("Subclass script name:", customAnimationClass);
}
else if (animationEngine == AnimationEngine.Mecanim || animationEngine == AnimationEngine.SpritesUnityComplex || animationEngine == AnimationEngine.SpritesUnity)
{
if (baseObject.GetComponent <Animator>() == null)
{
EditorGUILayout.HelpBox("This chosen method will make use of an Animator Controller asset.\nOnce the wizard has finished, you will need to create such an asset and assign it in your character's 'Animator' component.", MessageType.Info);
}
else
{
EditorGUILayout.HelpBox("This chosen method will make use of an Animator component, and one has already been detected on the base object.\nThis will be assumed to be the correct Animator to make use of.", MessageType.Info);
}
}
if (animationEngine == AnimationEngine.Sprites2DToolkit || animationEngine == AnimationEngine.SpritesUnityComplex || animationEngine == AnimationEngine.SpritesUnity)
{
if (AdvGame.GetReferences() != null && AdvGame.GetReferences().settingsManager != null && AdvGame.GetReferences().settingsManager.cameraPerspective != CameraPerspective.TwoD)
{
EditorGUILayout.LabelField("It has been detected that you are attempting\nto create a 2D character in a 3D game.\nIs this correct?", GUILayout.Height(40f));
enforce3D = EditorGUILayout.Toggle("Yes!", enforce3D);
}
}
}
EditorGUILayout.HelpBox("Click 'Finish' below to create the character and complete the wizard.", MessageType.Info);
}
else if (pageNumber == 4)
{
GUILayout.Label("Congratulations, your " + charType.ToString() + " has been created! Check the '" + charType.ToString() + "' Inspector to set up animation and other properties, as well as modify any generated Colliders / Rigidbody components.");
if (charType == CharType.Player)
{
GUILayout.Space(5f);
GUILayout.Label("To register this is as the main player character, turn it into a prefab and assign it in your Settings Manager, underneath 'Player settings'.");
}
}
}
public void LogCharacterSelections(int iPlayer)
{
for (int iChr = 0; iChr < Player.MAXCHRS; iChr++)
{
CharType.CHARTYPE chartype = NetworkMatchSetup.GetCharacterSelection(iPlayer, iChr);
WriteToMatchLogFile(string.Format("cs:{0}:{1}:{2}:{3}", iPlayer, iChr, (int)chartype, CharType.GetChrName(chartype)));
}
}
void HandleChar_PrevWordMode(CharType charType, int charIdx)
{
switch (state)
{
case State.Initial:
if (charType == CharType.Word)
{
SetState(State.InWord);
}
else if (charType == CharType.Other || charType == CharType.Space)
{
SetState(State.Searching);
}
else if (charType == CharType.EOF)
{
SetState(State.Final, charIdx);
}
break;
case State.InWord:
if (charType == CharType.Word)
{
SetState(State.SkippingWord);
}
else if (charType == CharType.Space)
{
SetState(State.Searching);
}
else if (charType == CharType.Other || charType == CharType.EOF)
{
SetState(State.Final, charIdx);
}
break;
case State.SkippingWord:
if (charType == CharType.Word)
{
SetState(State.SkippingWord);
}
else if (charType == CharType.Other || charType == CharType.Space)
{
SetState(State.Final, charIdx + 1);
}
else if (charType == CharType.EOF)
{
SetState(State.Final, 0);
}
break;
case State.Searching:
if (charType == CharType.Word)
{
SetState(State.SkippingWord);
}
else if (charType == CharType.Space)
{
SetState(State.Searching);
}
else if (charType == CharType.Other || charType == CharType.EOF)
{
SetState(State.Final, charIdx);
}
break;
}
}
public Ninja(CharType type) :
base(type)
{
}
/// <summary>
/// Parse(): This function kicks off the parsing process of the provided function.
/// </summary>
private void Parse()
{
m_alTokens = new ArrayList();
CharType chType = CharType.CT_UNDEF;
string sToken = "";
CharEnumerator chEnum = m_sFunction.GetEnumerator();
while (chEnum.MoveNext())
{
if (m_sWhitespace.IndexOf(chEnum.Current) > -1)
{
if (sToken.Length > 0)
{
m_alTokens.Add(new Token(sToken, chType));
}
sToken = "";
continue;
}
if (m_sDelimiters.IndexOf(chEnum.Current) > -1)
{
if (sToken.Length > 0)
{
m_alTokens.Add(new Token(sToken, chType));
}
m_alTokens.Add(new Token(chEnum.Current, CharType.CT_DELIM));
sToken = "";
chType = CharType.CT_UNDEF;
continue;
}
if (m_sBrackets.IndexOf(chEnum.Current) > -1)
{
if (sToken.Length > 0)
{
m_alTokens.Add(new Token(sToken, chType));
}
m_alTokens.Add(new Token(chEnum.Current, CharType.CT_BRACKETS));
sToken = "";
chType = CharType.CT_UNDEF;
continue;
}
if (m_sNumbers.IndexOf(chEnum.Current) > -1)
{
if (sToken.Length == 0)
{
chType = CharType.CT_NUMBER;
}
sToken += chEnum.Current;
continue;
}
if (m_sLetters.IndexOf(chEnum.Current) > -1)
{
if (sToken.Length == 0)
{
chType = CharType.CT_LETTER;
}
else
{
if (chType != CharType.CT_LETTER)
{
chType = CharType.CT_UNDEF;
}
}
sToken += chEnum.Current;
continue;
}
if (sToken.Length > 0)
{
m_alTokens.Add(new Token(sToken, chType));
}
sToken = "";
chType = CharType.CT_UNDEF;
}
if (sToken.Length > 0)
{
m_alTokens.Add(new Token(sToken, chType));
}
CheckMultiCharOps();
}
private static void InitializeFourthEditionCharTypeTable()
{
CurrentCharType = CharType.XmlChar;// ranges
{
addCharRange(new char[] { '\u0009', '\u000a' }); addCharRange(new char[] { '\u000d', '\u000d' }); addCharRange(new char[] { '\u0020', '\ud7ff' }); addCharRange(new char[] { '\ue000', '\ufffd' });
}
CurrentCharType = CharType.SurrogateHighChar;// ranges
{
addCharRange(new char[] { '\ud800', '\udbff' });
}
CurrentCharType = CharType.SurrogateLowChar;// ranges
{
addCharRange(new char[] { '\udc00', '\udfff' });
}
//[3] S ::= (#x20 | #x9 | #xD | #xA)+
CurrentCharType = CharType.WhiteSpace;// ranges
{
addCharRange(new char[] { '\u0009', '\u000a' }); addCharRange(new char[] { '\u000d', '\u000d' }); addCharRange(new char[] { '\u0020', '\u0020' });
}
//[5] Name ::= (Letter | '_' | ':') ...
//[84] Letter ::= BaseChar | Ideographic
CurrentCharType = CharType.NameStartChar;// ranges
{
addCharRange(new char[] { ':', ':' }); addCharRange(new char[] { '_', '_' });
// BaseChar
addCharRange(new char[] { '\u0041', '\u005A' }); addCharRange(new char[] { '\u0061', '\u007A' }); addCharRange(new char[] { '\u00C0', '\u00D6' }); addCharRange(new char[] { '\u00D8', '\u00F6' }); addCharRange(new char[] { '\u00F8', '\u00FF' }); addCharRange(new char[] { '\u0100', '\u0131' }); addCharRange(new char[] { '\u0134', '\u013E' }); addCharRange(new char[] { '\u0141', '\u0148' });
addCharRange(new char[] { '\u014A', '\u017E' }); addCharRange(new char[] { '\u0180', '\u01C3' }); addCharRange(new char[] { '\u01CD', '\u01F0' }); addCharRange(new char[] { '\u01F4', '\u01F5' }); addCharRange(new char[] { '\u01FA', '\u0217' }); addCharRange(new char[] { '\u0250', '\u02A8' }); addCharRange(new char[] { '\u02BB', '\u02C1' }); addCharRange(new char[] { '\u0386', '\u0386' });
addCharRange(new char[] { '\u0388', '\u038A' }); addCharRange(new char[] { '\u038C', '\u038C' }); addCharRange(new char[] { '\u038E', '\u03A1' }); addCharRange(new char[] { '\u03A3', '\u03CE' }); addCharRange(new char[] { '\u03D0', '\u03D6' }); addCharRange(new char[] { '\u03DA', '\u03DA' }); addCharRange(new char[] { '\u03DC', '\u03DC' }); addCharRange(new char[] { '\u03DE', '\u03DE' });
addCharRange(new char[] { '\u03E0', '\u03E0' }); addCharRange(new char[] { '\u03E2', '\u03F3' }); addCharRange(new char[] { '\u0401', '\u040C' }); addCharRange(new char[] { '\u040E', '\u044F' }); addCharRange(new char[] { '\u0451', '\u045C' }); addCharRange(new char[] { '\u045E', '\u0481' }); addCharRange(new char[] { '\u0490', '\u04C4' }); addCharRange(new char[] { '\u04C7', '\u04C8' });
addCharRange(new char[] { '\u04CB', '\u04CC' }); addCharRange(new char[] { '\u04D0', '\u04EB' }); addCharRange(new char[] { '\u04EE', '\u04F5' }); addCharRange(new char[] { '\u04F8', '\u04F9' }); addCharRange(new char[] { '\u0531', '\u0556' }); addCharRange(new char[] { '\u0559', '\u0559' }); addCharRange(new char[] { '\u0561', '\u0586' }); addCharRange(new char[] { '\u05D0', '\u05EA' });
addCharRange(new char[] { '\u05F0', '\u05F2' }); addCharRange(new char[] { '\u0621', '\u063A' }); addCharRange(new char[] { '\u0641', '\u064A' }); addCharRange(new char[] { '\u0671', '\u06B7' }); addCharRange(new char[] { '\u06BA', '\u06BE' }); addCharRange(new char[] { '\u06C0', '\u06CE' }); addCharRange(new char[] { '\u06D0', '\u06D3' }); addCharRange(new char[] { '\u06D5', '\u06D5' });
addCharRange(new char[] { '\u06E5', '\u06E6' }); addCharRange(new char[] { '\u0905', '\u0939' }); addCharRange(new char[] { '\u093D', '\u093D' }); addCharRange(new char[] { '\u0958', '\u0961' }); addCharRange(new char[] { '\u0985', '\u098C' }); addCharRange(new char[] { '\u098F', '\u0990' }); addCharRange(new char[] { '\u0993', '\u09A8' }); addCharRange(new char[] { '\u09AA', '\u09B0' });
addCharRange(new char[] { '\u09B2', '\u09B2' }); addCharRange(new char[] { '\u09B6', '\u09B9' }); addCharRange(new char[] { '\u09DC', '\u09DD' }); addCharRange(new char[] { '\u09DF', '\u09E1' }); addCharRange(new char[] { '\u09F0', '\u09F1' }); addCharRange(new char[] { '\u0A05', '\u0A0A' }); addCharRange(new char[] { '\u0A0F', '\u0A10' }); addCharRange(new char[] { '\u0A13', '\u0A28' });
addCharRange(new char[] { '\u0A2A', '\u0A30' }); addCharRange(new char[] { '\u0A32', '\u0A33' }); addCharRange(new char[] { '\u0A35', '\u0A36' }); addCharRange(new char[] { '\u0A38', '\u0A39' }); addCharRange(new char[] { '\u0A59', '\u0A5C' }); addCharRange(new char[] { '\u0A5E', '\u0A5E' }); addCharRange(new char[] { '\u0A72', '\u0A74' }); addCharRange(new char[] { '\u0A85', '\u0A8B' });
addCharRange(new char[] { '\u0A8D', '\u0A8D' }); addCharRange(new char[] { '\u0A8F', '\u0A91' }); addCharRange(new char[] { '\u0A93', '\u0AA8' }); addCharRange(new char[] { '\u0AAA', '\u0AB0' }); addCharRange(new char[] { '\u0AB2', '\u0AB3' }); addCharRange(new char[] { '\u0AB5', '\u0AB9' }); addCharRange(new char[] { '\u0ABD', '\u0ABD' }); addCharRange(new char[] { '\u0AE0', '\u0AE0' });
addCharRange(new char[] { '\u0B05', '\u0B0C' }); addCharRange(new char[] { '\u0B0F', '\u0B10' }); addCharRange(new char[] { '\u0B13', '\u0B28' }); addCharRange(new char[] { '\u0B2A', '\u0B30' }); addCharRange(new char[] { '\u0B32', '\u0B33' }); addCharRange(new char[] { '\u0B36', '\u0B39' }); addCharRange(new char[] { '\u0B3D', '\u0B3D' }); addCharRange(new char[] { '\u0B5C', '\u0B5D' });
addCharRange(new char[] { '\u0B5F', '\u0B61' }); addCharRange(new char[] { '\u0B85', '\u0B8A' }); addCharRange(new char[] { '\u0B8E', '\u0B90' }); addCharRange(new char[] { '\u0B92', '\u0B95' }); addCharRange(new char[] { '\u0B99', '\u0B9A' }); addCharRange(new char[] { '\u0B9C', '\u0B9C' }); addCharRange(new char[] { '\u0B9E', '\u0B9F' }); addCharRange(new char[] { '\u0BA3', '\u0BA4' });
addCharRange(new char[] { '\u0BA8', '\u0BAA' }); addCharRange(new char[] { '\u0BAE', '\u0BB5' }); addCharRange(new char[] { '\u0BB7', '\u0BB9' }); addCharRange(new char[] { '\u0C05', '\u0C0C' }); addCharRange(new char[] { '\u0C0E', '\u0C10' }); addCharRange(new char[] { '\u0C12', '\u0C28' }); addCharRange(new char[] { '\u0C2A', '\u0C33' }); addCharRange(new char[] { '\u0C35', '\u0C39' });
addCharRange(new char[] { '\u0C60', '\u0C61' }); addCharRange(new char[] { '\u0C85', '\u0C8C' }); addCharRange(new char[] { '\u0C8E', '\u0C90' }); addCharRange(new char[] { '\u0C92', '\u0CA8' }); addCharRange(new char[] { '\u0CAA', '\u0CB3' }); addCharRange(new char[] { '\u0CB5', '\u0CB9' }); addCharRange(new char[] { '\u0CDE', '\u0CDE' }); addCharRange(new char[] { '\u0CE0', '\u0CE1' });
addCharRange(new char[] { '\u0D05', '\u0D0C' }); addCharRange(new char[] { '\u0D0E', '\u0D10' }); addCharRange(new char[] { '\u0D12', '\u0D28' }); addCharRange(new char[] { '\u0D2A', '\u0D39' }); addCharRange(new char[] { '\u0D60', '\u0D61' }); addCharRange(new char[] { '\u0E01', '\u0E2E' }); addCharRange(new char[] { '\u0E30', '\u0E30' }); addCharRange(new char[] { '\u0E32', '\u0E33' });
addCharRange(new char[] { '\u0E40', '\u0E45' }); addCharRange(new char[] { '\u0E81', '\u0E82' }); addCharRange(new char[] { '\u0E84', '\u0E84' }); addCharRange(new char[] { '\u0E87', '\u0E88' }); addCharRange(new char[] { '\u0E8A', '\u0E8A' }); addCharRange(new char[] { '\u0E8D', '\u0E8D' }); addCharRange(new char[] { '\u0E94', '\u0E97' }); addCharRange(new char[] { '\u0E99', '\u0E9F' });
addCharRange(new char[] { '\u0EA1', '\u0EA3' }); addCharRange(new char[] { '\u0EA5', '\u0EA5' }); addCharRange(new char[] { '\u0EA7', '\u0EA7' }); addCharRange(new char[] { '\u0EAA', '\u0EAB' }); addCharRange(new char[] { '\u0EAD', '\u0EAE' }); addCharRange(new char[] { '\u0EB0', '\u0EB0' }); addCharRange(new char[] { '\u0EB2', '\u0EB3' }); addCharRange(new char[] { '\u0EBD', '\u0EBD' });
addCharRange(new char[] { '\u0EC0', '\u0EC4' }); addCharRange(new char[] { '\u0F40', '\u0F47' }); addCharRange(new char[] { '\u0F49', '\u0F69' }); addCharRange(new char[] { '\u10A0', '\u10C5' }); addCharRange(new char[] { '\u10D0', '\u10F6' }); addCharRange(new char[] { '\u1100', '\u1100' }); addCharRange(new char[] { '\u1102', '\u1103' }); addCharRange(new char[] { '\u1105', '\u1107' });
addCharRange(new char[] { '\u1109', '\u1109' }); addCharRange(new char[] { '\u110B', '\u110C' }); addCharRange(new char[] { '\u110E', '\u1112' }); addCharRange(new char[] { '\u113C', '\u113C' }); addCharRange(new char[] { '\u113E', '\u113E' }); addCharRange(new char[] { '\u1140', '\u1140' }); addCharRange(new char[] { '\u114C', '\u114C' }); addCharRange(new char[] { '\u114E', '\u114E' });
addCharRange(new char[] { '\u1150', '\u1150' }); addCharRange(new char[] { '\u1154', '\u1155' }); addCharRange(new char[] { '\u1159', '\u1159' }); addCharRange(new char[] { '\u115F', '\u1161' }); addCharRange(new char[] { '\u1163', '\u1163' }); addCharRange(new char[] { '\u1165', '\u1165' }); addCharRange(new char[] { '\u1167', '\u1167' }); addCharRange(new char[] { '\u1169', '\u1169' });
addCharRange(new char[] { '\u116D', '\u116E' }); addCharRange(new char[] { '\u1172', '\u1173' }); addCharRange(new char[] { '\u1175', '\u1175' }); addCharRange(new char[] { '\u119E', '\u119E' }); addCharRange(new char[] { '\u11A8', '\u11A8' }); addCharRange(new char[] { '\u11AB', '\u11AB' }); addCharRange(new char[] { '\u11AE', '\u11AF' }); addCharRange(new char[] { '\u11B7', '\u11B8' });
addCharRange(new char[] { '\u11BA', '\u11BA' }); addCharRange(new char[] { '\u11BC', '\u11C2' }); addCharRange(new char[] { '\u11EB', '\u11EB' }); addCharRange(new char[] { '\u11F0', '\u11F0' }); addCharRange(new char[] { '\u11F9', '\u11F9' }); addCharRange(new char[] { '\u1E00', '\u1E9B' }); addCharRange(new char[] { '\u1EA0', '\u1EF9' }); addCharRange(new char[] { '\u1F00', '\u1F15' });
addCharRange(new char[] { '\u1F18', '\u1F1D' }); addCharRange(new char[] { '\u1F20', '\u1F45' }); addCharRange(new char[] { '\u1F48', '\u1F4D' }); addCharRange(new char[] { '\u1F50', '\u1F57' }); addCharRange(new char[] { '\u1F59', '\u1F59' }); addCharRange(new char[] { '\u1F5B', '\u1F5B' }); addCharRange(new char[] { '\u1F5D', '\u1F5D' }); addCharRange(new char[] { '\u1F5F', '\u1F7D' });
addCharRange(new char[] { '\u1F80', '\u1FB4' }); addCharRange(new char[] { '\u1FB6', '\u1FBC' }); addCharRange(new char[] { '\u1FBE', '\u1FBE' }); addCharRange(new char[] { '\u1FC2', '\u1FC4' }); addCharRange(new char[] { '\u1FC6', '\u1FCC' }); addCharRange(new char[] { '\u1FD0', '\u1FD3' }); addCharRange(new char[] { '\u1FD6', '\u1FDB' }); addCharRange(new char[] { '\u1FE0', '\u1FEC' });
addCharRange(new char[] { '\u1FF2', '\u1FF4' }); addCharRange(new char[] { '\u1FF6', '\u1FFC' }); addCharRange(new char[] { '\u2126', '\u2126' }); addCharRange(new char[] { '\u212A', '\u212B' }); addCharRange(new char[] { '\u212E', '\u212E' }); addCharRange(new char[] { '\u2180', '\u2182' }); addCharRange(new char[] { '\u3041', '\u3094' }); addCharRange(new char[] { '\u30A1', '\u30FA' });
addCharRange(new char[] { '\u3105', '\u312C' }); addCharRange(new char[] { '\uAC00', '\uD7A3' });
//Ideographic
addCharRange(new char[] { '\u3007', '\u3007' }); addCharRange(new char[] { '\u3021', '\u3029' }); addCharRange(new char[] { '\u4E00', '\u9FA5' });
}
//[4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender
//[84] Letter ::= BaseChar | Ideographic
CurrentCharType = CharType.NameChar;// ranges
{
addCharRange(new char[] { ':', ':' }); addCharRange(new char[] { '_', '_' }); addCharRange(new char[] { '-', '-' }); addCharRange(new char[] { '.', '.' });
// BaseChar
addCharRange(new char[] { '\u0041', '\u005A' }); addCharRange(new char[] { '\u0061', '\u007A' }); addCharRange(new char[] { '\u00C0', '\u00D6' }); addCharRange(new char[] { '\u00D8', '\u00F6' }); addCharRange(new char[] { '\u00F8', '\u00FF' }); addCharRange(new char[] { '\u0100', '\u0131' }); addCharRange(new char[] { '\u0134', '\u013E' }); addCharRange(new char[] { '\u0141', '\u0148' });
addCharRange(new char[] { '\u014A', '\u017E' }); addCharRange(new char[] { '\u0180', '\u01C3' }); addCharRange(new char[] { '\u01CD', '\u01F0' }); addCharRange(new char[] { '\u01F4', '\u01F5' }); addCharRange(new char[] { '\u01FA', '\u0217' }); addCharRange(new char[] { '\u0250', '\u02A8' }); addCharRange(new char[] { '\u02BB', '\u02C1' }); addCharRange(new char[] { '\u0386', '\u0386' });
addCharRange(new char[] { '\u0388', '\u038A' }); addCharRange(new char[] { '\u038C', '\u038C' }); addCharRange(new char[] { '\u038E', '\u03A1' }); addCharRange(new char[] { '\u03A3', '\u03CE' }); addCharRange(new char[] { '\u03D0', '\u03D6' }); addCharRange(new char[] { '\u03DA', '\u03DA' }); addCharRange(new char[] { '\u03DC', '\u03DC' }); addCharRange(new char[] { '\u03DE', '\u03DE' });
addCharRange(new char[] { '\u03E0', '\u03E0' }); addCharRange(new char[] { '\u03E2', '\u03F3' }); addCharRange(new char[] { '\u0401', '\u040C' }); addCharRange(new char[] { '\u040E', '\u044F' }); addCharRange(new char[] { '\u0451', '\u045C' }); addCharRange(new char[] { '\u045E', '\u0481' }); addCharRange(new char[] { '\u0490', '\u04C4' }); addCharRange(new char[] { '\u04C7', '\u04C8' });
addCharRange(new char[] { '\u04CB', '\u04CC' }); addCharRange(new char[] { '\u04D0', '\u04EB' }); addCharRange(new char[] { '\u04EE', '\u04F5' }); addCharRange(new char[] { '\u04F8', '\u04F9' }); addCharRange(new char[] { '\u0531', '\u0556' }); addCharRange(new char[] { '\u0559', '\u0559' }); addCharRange(new char[] { '\u0561', '\u0586' }); addCharRange(new char[] { '\u05D0', '\u05EA' });
addCharRange(new char[] { '\u05F0', '\u05F2' }); addCharRange(new char[] { '\u0621', '\u063A' }); addCharRange(new char[] { '\u0641', '\u064A' }); addCharRange(new char[] { '\u0671', '\u06B7' }); addCharRange(new char[] { '\u06BA', '\u06BE' }); addCharRange(new char[] { '\u06C0', '\u06CE' }); addCharRange(new char[] { '\u06D0', '\u06D3' }); addCharRange(new char[] { '\u06D5', '\u06D5' });
addCharRange(new char[] { '\u06E5', '\u06E6' }); addCharRange(new char[] { '\u0905', '\u0939' }); addCharRange(new char[] { '\u093D', '\u093D' }); addCharRange(new char[] { '\u0958', '\u0961' }); addCharRange(new char[] { '\u0985', '\u098C' }); addCharRange(new char[] { '\u098F', '\u0990' }); addCharRange(new char[] { '\u0993', '\u09A8' }); addCharRange(new char[] { '\u09AA', '\u09B0' });
addCharRange(new char[] { '\u09B2', '\u09B2' }); addCharRange(new char[] { '\u09B6', '\u09B9' }); addCharRange(new char[] { '\u09DC', '\u09DD' }); addCharRange(new char[] { '\u09DF', '\u09E1' }); addCharRange(new char[] { '\u09F0', '\u09F1' }); addCharRange(new char[] { '\u0A05', '\u0A0A' }); addCharRange(new char[] { '\u0A0F', '\u0A10' }); addCharRange(new char[] { '\u0A13', '\u0A28' });
addCharRange(new char[] { '\u0A2A', '\u0A30' }); addCharRange(new char[] { '\u0A32', '\u0A33' }); addCharRange(new char[] { '\u0A35', '\u0A36' }); addCharRange(new char[] { '\u0A38', '\u0A39' }); addCharRange(new char[] { '\u0A59', '\u0A5C' }); addCharRange(new char[] { '\u0A5E', '\u0A5E' }); addCharRange(new char[] { '\u0A72', '\u0A74' }); addCharRange(new char[] { '\u0A85', '\u0A8B' });
addCharRange(new char[] { '\u0A8D', '\u0A8D' }); addCharRange(new char[] { '\u0A8F', '\u0A91' }); addCharRange(new char[] { '\u0A93', '\u0AA8' }); addCharRange(new char[] { '\u0AAA', '\u0AB0' }); addCharRange(new char[] { '\u0AB2', '\u0AB3' }); addCharRange(new char[] { '\u0AB5', '\u0AB9' }); addCharRange(new char[] { '\u0ABD', '\u0ABD' }); addCharRange(new char[] { '\u0AE0', '\u0AE0' });
addCharRange(new char[] { '\u0B05', '\u0B0C' }); addCharRange(new char[] { '\u0B0F', '\u0B10' }); addCharRange(new char[] { '\u0B13', '\u0B28' }); addCharRange(new char[] { '\u0B2A', '\u0B30' }); addCharRange(new char[] { '\u0B32', '\u0B33' }); addCharRange(new char[] { '\u0B36', '\u0B39' }); addCharRange(new char[] { '\u0B3D', '\u0B3D' }); addCharRange(new char[] { '\u0B5C', '\u0B5D' });
addCharRange(new char[] { '\u0B5F', '\u0B61' }); addCharRange(new char[] { '\u0B85', '\u0B8A' }); addCharRange(new char[] { '\u0B8E', '\u0B90' }); addCharRange(new char[] { '\u0B92', '\u0B95' }); addCharRange(new char[] { '\u0B99', '\u0B9A' }); addCharRange(new char[] { '\u0B9C', '\u0B9C' }); addCharRange(new char[] { '\u0B9E', '\u0B9F' }); addCharRange(new char[] { '\u0BA3', '\u0BA4' });
addCharRange(new char[] { '\u0BA8', '\u0BAA' }); addCharRange(new char[] { '\u0BAE', '\u0BB5' }); addCharRange(new char[] { '\u0BB7', '\u0BB9' }); addCharRange(new char[] { '\u0C05', '\u0C0C' }); addCharRange(new char[] { '\u0C0E', '\u0C10' }); addCharRange(new char[] { '\u0C12', '\u0C28' }); addCharRange(new char[] { '\u0C2A', '\u0C33' }); addCharRange(new char[] { '\u0C35', '\u0C39' });
addCharRange(new char[] { '\u0C60', '\u0C61' }); addCharRange(new char[] { '\u0C85', '\u0C8C' }); addCharRange(new char[] { '\u0C8E', '\u0C90' }); addCharRange(new char[] { '\u0C92', '\u0CA8' }); addCharRange(new char[] { '\u0CAA', '\u0CB3' }); addCharRange(new char[] { '\u0CB5', '\u0CB9' }); addCharRange(new char[] { '\u0CDE', '\u0CDE' }); addCharRange(new char[] { '\u0CE0', '\u0CE1' });
addCharRange(new char[] { '\u0D05', '\u0D0C' }); addCharRange(new char[] { '\u0D0E', '\u0D10' }); addCharRange(new char[] { '\u0D12', '\u0D28' }); addCharRange(new char[] { '\u0D2A', '\u0D39' }); addCharRange(new char[] { '\u0D60', '\u0D61' }); addCharRange(new char[] { '\u0E01', '\u0E2E' }); addCharRange(new char[] { '\u0E30', '\u0E30' }); addCharRange(new char[] { '\u0E32', '\u0E33' });
addCharRange(new char[] { '\u0E40', '\u0E45' }); addCharRange(new char[] { '\u0E81', '\u0E82' }); addCharRange(new char[] { '\u0E84', '\u0E84' }); addCharRange(new char[] { '\u0E87', '\u0E88' }); addCharRange(new char[] { '\u0E8A', '\u0E8A' }); addCharRange(new char[] { '\u0E8D', '\u0E8D' }); addCharRange(new char[] { '\u0E94', '\u0E97' }); addCharRange(new char[] { '\u0E99', '\u0E9F' });
addCharRange(new char[] { '\u0EA1', '\u0EA3' }); addCharRange(new char[] { '\u0EA5', '\u0EA5' }); addCharRange(new char[] { '\u0EA7', '\u0EA7' }); addCharRange(new char[] { '\u0EAA', '\u0EAB' }); addCharRange(new char[] { '\u0EAD', '\u0EAE' }); addCharRange(new char[] { '\u0EB0', '\u0EB0' }); addCharRange(new char[] { '\u0EB2', '\u0EB3' }); addCharRange(new char[] { '\u0EBD', '\u0EBD' });
addCharRange(new char[] { '\u0EC0', '\u0EC4' }); addCharRange(new char[] { '\u0F40', '\u0F47' }); addCharRange(new char[] { '\u0F49', '\u0F69' }); addCharRange(new char[] { '\u10A0', '\u10C5' }); addCharRange(new char[] { '\u10D0', '\u10F6' }); addCharRange(new char[] { '\u1100', '\u1100' }); addCharRange(new char[] { '\u1102', '\u1103' }); addCharRange(new char[] { '\u1105', '\u1107' });
addCharRange(new char[] { '\u1109', '\u1109' }); addCharRange(new char[] { '\u110B', '\u110C' }); addCharRange(new char[] { '\u110E', '\u1112' }); addCharRange(new char[] { '\u113C', '\u113C' }); addCharRange(new char[] { '\u113E', '\u113E' }); addCharRange(new char[] { '\u1140', '\u1140' }); addCharRange(new char[] { '\u114C', '\u114C' }); addCharRange(new char[] { '\u114E', '\u114E' });
addCharRange(new char[] { '\u1150', '\u1150' }); addCharRange(new char[] { '\u1154', '\u1155' }); addCharRange(new char[] { '\u1159', '\u1159' }); addCharRange(new char[] { '\u115F', '\u1161' }); addCharRange(new char[] { '\u1163', '\u1163' }); addCharRange(new char[] { '\u1165', '\u1165' }); addCharRange(new char[] { '\u1167', '\u1167' }); addCharRange(new char[] { '\u1169', '\u1169' });
addCharRange(new char[] { '\u116D', '\u116E' }); addCharRange(new char[] { '\u1172', '\u1173' }); addCharRange(new char[] { '\u1175', '\u1175' }); addCharRange(new char[] { '\u119E', '\u119E' }); addCharRange(new char[] { '\u11A8', '\u11A8' }); addCharRange(new char[] { '\u11AB', '\u11AB' }); addCharRange(new char[] { '\u11AE', '\u11AF' }); addCharRange(new char[] { '\u11B7', '\u11B8' });
addCharRange(new char[] { '\u11BA', '\u11BA' }); addCharRange(new char[] { '\u11BC', '\u11C2' }); addCharRange(new char[] { '\u11EB', '\u11EB' }); addCharRange(new char[] { '\u11F0', '\u11F0' }); addCharRange(new char[] { '\u11F9', '\u11F9' }); addCharRange(new char[] { '\u1E00', '\u1E9B' }); addCharRange(new char[] { '\u1EA0', '\u1EF9' }); addCharRange(new char[] { '\u1F00', '\u1F15' });
addCharRange(new char[] { '\u1F18', '\u1F1D' }); addCharRange(new char[] { '\u1F20', '\u1F45' }); addCharRange(new char[] { '\u1F48', '\u1F4D' }); addCharRange(new char[] { '\u1F50', '\u1F57' }); addCharRange(new char[] { '\u1F59', '\u1F59' }); addCharRange(new char[] { '\u1F5B', '\u1F5B' }); addCharRange(new char[] { '\u1F5D', '\u1F5D' }); addCharRange(new char[] { '\u1F5F', '\u1F7D' });
addCharRange(new char[] { '\u1F80', '\u1FB4' }); addCharRange(new char[] { '\u1FB6', '\u1FBC' }); addCharRange(new char[] { '\u1FBE', '\u1FBE' }); addCharRange(new char[] { '\u1FC2', '\u1FC4' }); addCharRange(new char[] { '\u1FC6', '\u1FCC' }); addCharRange(new char[] { '\u1FD0', '\u1FD3' }); addCharRange(new char[] { '\u1FD6', '\u1FDB' }); addCharRange(new char[] { '\u1FE0', '\u1FEC' });
addCharRange(new char[] { '\u1FF2', '\u1FF4' }); addCharRange(new char[] { '\u1FF6', '\u1FFC' }); addCharRange(new char[] { '\u2126', '\u2126' }); addCharRange(new char[] { '\u212A', '\u212B' }); addCharRange(new char[] { '\u212E', '\u212E' }); addCharRange(new char[] { '\u2180', '\u2182' }); addCharRange(new char[] { '\u3041', '\u3094' }); addCharRange(new char[] { '\u30A1', '\u30FA' });
addCharRange(new char[] { '\u3105', '\u312C' }); addCharRange(new char[] { '\uAC00', '\uD7A3' });
//Ideographic
addCharRange(new char[] { '\u3007', '\u3007' }); addCharRange(new char[] { '\u3021', '\u3029' }); addCharRange(new char[] { '\u4E00', '\u9FA5' });
//Digit
addCharRange(new char[] { '\u0030', '\u0039' }); addCharRange(new char[] { '\u0660', '\u0669' }); addCharRange(new char[] { '\u06F0', '\u06F9' }); addCharRange(new char[] { '\u0966', '\u096F' }); addCharRange(new char[] { '\u09E6', '\u09EF' }); addCharRange(new char[] { '\u0A66', '\u0A6F' }); addCharRange(new char[] { '\u0AE6', '\u0AEF' }); addCharRange(new char[] { '\u0B66', '\u0B6F' });
addCharRange(new char[] { '\u0BE7', '\u0BEF' }); addCharRange(new char[] { '\u0C66', '\u0C6F' }); addCharRange(new char[] { '\u0CE6', '\u0CEF' }); addCharRange(new char[] { '\u0D66', '\u0D6F' }); addCharRange(new char[] { '\u0E50', '\u0E59' }); addCharRange(new char[] { '\u0ED0', '\u0ED9' }); addCharRange(new char[] { '\u0F20', '\u0F29' });
//Combination
addCharRange(new char[] { '\u0300', '\u0345' }); addCharRange(new char[] { '\u0360', '\u0361' }); addCharRange(new char[] { '\u0483', '\u0486' }); addCharRange(new char[] { '\u0591', '\u05A1' }); addCharRange(new char[] { '\u05A3', '\u05B9' }); addCharRange(new char[] { '\u05BB', '\u05BD' }); addCharRange(new char[] { '\u05BF', '\u05BF' }); addCharRange(new char[] { '\u05C1', '\u05C2' });
addCharRange(new char[] { '\u05C4', '\u05C4' }); addCharRange(new char[] { '\u064B', '\u0652' }); addCharRange(new char[] { '\u0670', '\u0670' }); addCharRange(new char[] { '\u06D6', '\u06DC' }); addCharRange(new char[] { '\u06DD', '\u06DF' }); addCharRange(new char[] { '\u06E0', '\u06E4' }); addCharRange(new char[] { '\u06E7', '\u06E8' }); addCharRange(new char[] { '\u06EA', '\u06ED' });
addCharRange(new char[] { '\u0901', '\u0903' }); addCharRange(new char[] { '\u093C', '\u093C' }); addCharRange(new char[] { '\u093E', '\u094C' }); addCharRange(new char[] { '\u094D', '\u094D' }); addCharRange(new char[] { '\u0951', '\u0954' }); addCharRange(new char[] { '\u0962', '\u0963' }); addCharRange(new char[] { '\u0981', '\u0983' }); addCharRange(new char[] { '\u09BC', '\u09BC' });
addCharRange(new char[] { '\u09BE', '\u09BE' }); addCharRange(new char[] { '\u09BF', '\u09BF' }); addCharRange(new char[] { '\u09C0', '\u09C4' }); addCharRange(new char[] { '\u09C7', '\u09C8' }); addCharRange(new char[] { '\u09CB', '\u09CD' }); addCharRange(new char[] { '\u09D7', '\u09D7' }); addCharRange(new char[] { '\u09E2', '\u09E3' }); addCharRange(new char[] { '\u0A02', '\u0A02' });
addCharRange(new char[] { '\u0A3C', '\u0A3C' }); addCharRange(new char[] { '\u0A3E', '\u0A3E' }); addCharRange(new char[] { '\u0A3F', '\u0A3F' }); addCharRange(new char[] { '\u0A40', '\u0A42' }); addCharRange(new char[] { '\u0A47', '\u0A48' }); addCharRange(new char[] { '\u0A4B', '\u0A4D' }); addCharRange(new char[] { '\u0A70', '\u0A71' }); addCharRange(new char[] { '\u0A81', '\u0A83' });
addCharRange(new char[] { '\u0ABC', '\u0ABC' }); addCharRange(new char[] { '\u0ABE', '\u0AC5' }); addCharRange(new char[] { '\u0AC7', '\u0AC9' }); addCharRange(new char[] { '\u0ACB', '\u0ACD' }); addCharRange(new char[] { '\u0B01', '\u0B03' }); addCharRange(new char[] { '\u0B3C', '\u0B3C' }); addCharRange(new char[] { '\u0B3E', '\u0B43' }); addCharRange(new char[] { '\u0B47', '\u0B48' });
addCharRange(new char[] { '\u0B4B', '\u0B4D' }); addCharRange(new char[] { '\u0B56', '\u0B57' }); addCharRange(new char[] { '\u0B82', '\u0B83' }); addCharRange(new char[] { '\u0BBE', '\u0BC2' }); addCharRange(new char[] { '\u0BC6', '\u0BC8' }); addCharRange(new char[] { '\u0BCA', '\u0BCD' }); addCharRange(new char[] { '\u0BD7', '\u0BD7' }); addCharRange(new char[] { '\u0C01', '\u0C03' });
addCharRange(new char[] { '\u0C3E', '\u0C44' }); addCharRange(new char[] { '\u0C46', '\u0C48' }); addCharRange(new char[] { '\u0C4A', '\u0C4D' }); addCharRange(new char[] { '\u0C55', '\u0C56' }); addCharRange(new char[] { '\u0C82', '\u0C83' }); addCharRange(new char[] { '\u0CBE', '\u0CC4' }); addCharRange(new char[] { '\u0CC6', '\u0CC8' }); addCharRange(new char[] { '\u0CCA', '\u0CCD' });
addCharRange(new char[] { '\u0CD5', '\u0CD6' }); addCharRange(new char[] { '\u0D02', '\u0D03' }); addCharRange(new char[] { '\u0D3E', '\u0D43' }); addCharRange(new char[] { '\u0D46', '\u0D48' }); addCharRange(new char[] { '\u0D4A', '\u0D4D' }); addCharRange(new char[] { '\u0D57', '\u0D57' }); addCharRange(new char[] { '\u0E31', '\u0E31' }); addCharRange(new char[] { '\u0E34', '\u0E3A' });
addCharRange(new char[] { '\u0E47', '\u0E4E' }); addCharRange(new char[] { '\u0EB1', '\u0EB1' }); addCharRange(new char[] { '\u0EB4', '\u0EB9' }); addCharRange(new char[] { '\u0EBB', '\u0EBC' }); addCharRange(new char[] { '\u0EC8', '\u0ECD' }); addCharRange(new char[] { '\u0F18', '\u0F19' }); addCharRange(new char[] { '\u0F35', '\u0F35' }); addCharRange(new char[] { '\u0F37', '\u0F37' });
addCharRange(new char[] { '\u0F39', '\u0F39' }); addCharRange(new char[] { '\u0F3E', '\u0F3E' }); addCharRange(new char[] { '\u0F3F', '\u0F3F' }); addCharRange(new char[] { '\u0F71', '\u0F84' }); addCharRange(new char[] { '\u0F86', '\u0F8B' }); addCharRange(new char[] { '\u0F90', '\u0F95' }); addCharRange(new char[] { '\u0F97', '\u0F97' }); addCharRange(new char[] { '\u0F99', '\u0FAD' });
addCharRange(new char[] { '\u0FB1', '\u0FB7' }); addCharRange(new char[] { '\u0FB9', '\u0FB9' }); addCharRange(new char[] { '\u20D0', '\u20DC' }); addCharRange(new char[] { '\u20E1', '\u20E1' }); addCharRange(new char[] { '\u302A', '\u302F' }); addCharRange(new char[] { '\u3099', '\u3099' }); addCharRange(new char[] { '\u309A', '\u309A' });
//Extender
addCharRange(new char[] { '\u00B7', '\u00B7' }); addCharRange(new char[] { '\u02D0', '\u02D0' }); addCharRange(new char[] { '\u02D1', '\u02D1' }); addCharRange(new char[] { '\u0387', '\u0387' }); addCharRange(new char[] { '\u0640', '\u0640' }); addCharRange(new char[] { '\u0E46', '\u0E46' }); addCharRange(new char[] { '\u0EC6', '\u0EC6' }); addCharRange(new char[] { '\u3005', '\u3005' });
addCharRange(new char[] { '\u3031', '\u3035' }); addCharRange(new char[] { '\u309D', '\u309E' }); addCharRange(new char[] { '\u30FC', '\u30FE' });
};
// Same thing as NameStartChar but no ':' character
CurrentCharType = CharType.NCNameStartChar;// ranges
{
addCharRange(new char[] { '_', '_' });
// BaseChar
addCharRange(new char[] { '\u0041', '\u005A' }); addCharRange(new char[] { '\u0061', '\u007A' }); addCharRange(new char[] { '\u00C0', '\u00D6' }); addCharRange(new char[] { '\u00D8', '\u00F6' }); addCharRange(new char[] { '\u00F8', '\u00FF' }); addCharRange(new char[] { '\u0100', '\u0131' }); addCharRange(new char[] { '\u0134', '\u013E' }); addCharRange(new char[] { '\u0141', '\u0148' });
addCharRange(new char[] { '\u014A', '\u017E' }); addCharRange(new char[] { '\u0180', '\u01C3' }); addCharRange(new char[] { '\u01CD', '\u01F0' }); addCharRange(new char[] { '\u01F4', '\u01F5' }); addCharRange(new char[] { '\u01FA', '\u0217' }); addCharRange(new char[] { '\u0250', '\u02A8' }); addCharRange(new char[] { '\u02BB', '\u02C1' }); addCharRange(new char[] { '\u0386', '\u0386' });
addCharRange(new char[] { '\u0388', '\u038A' }); addCharRange(new char[] { '\u038C', '\u038C' }); addCharRange(new char[] { '\u038E', '\u03A1' }); addCharRange(new char[] { '\u03A3', '\u03CE' }); addCharRange(new char[] { '\u03D0', '\u03D6' }); addCharRange(new char[] { '\u03DA', '\u03DA' }); addCharRange(new char[] { '\u03DC', '\u03DC' }); addCharRange(new char[] { '\u03DE', '\u03DE' });
addCharRange(new char[] { '\u03E0', '\u03E0' }); addCharRange(new char[] { '\u03E2', '\u03F3' }); addCharRange(new char[] { '\u0401', '\u040C' }); addCharRange(new char[] { '\u040E', '\u044F' }); addCharRange(new char[] { '\u0451', '\u045C' }); addCharRange(new char[] { '\u045E', '\u0481' }); addCharRange(new char[] { '\u0490', '\u04C4' }); addCharRange(new char[] { '\u04C7', '\u04C8' });
addCharRange(new char[] { '\u04CB', '\u04CC' }); addCharRange(new char[] { '\u04D0', '\u04EB' }); addCharRange(new char[] { '\u04EE', '\u04F5' }); addCharRange(new char[] { '\u04F8', '\u04F9' }); addCharRange(new char[] { '\u0531', '\u0556' }); addCharRange(new char[] { '\u0559', '\u0559' }); addCharRange(new char[] { '\u0561', '\u0586' }); addCharRange(new char[] { '\u05D0', '\u05EA' });
addCharRange(new char[] { '\u05F0', '\u05F2' }); addCharRange(new char[] { '\u0621', '\u063A' }); addCharRange(new char[] { '\u0641', '\u064A' }); addCharRange(new char[] { '\u0671', '\u06B7' }); addCharRange(new char[] { '\u06BA', '\u06BE' }); addCharRange(new char[] { '\u06C0', '\u06CE' }); addCharRange(new char[] { '\u06D0', '\u06D3' }); addCharRange(new char[] { '\u06D5', '\u06D5' });
addCharRange(new char[] { '\u06E5', '\u06E6' }); addCharRange(new char[] { '\u0905', '\u0939' }); addCharRange(new char[] { '\u093D', '\u093D' }); addCharRange(new char[] { '\u0958', '\u0961' }); addCharRange(new char[] { '\u0985', '\u098C' }); addCharRange(new char[] { '\u098F', '\u0990' }); addCharRange(new char[] { '\u0993', '\u09A8' }); addCharRange(new char[] { '\u09AA', '\u09B0' });
addCharRange(new char[] { '\u09B2', '\u09B2' }); addCharRange(new char[] { '\u09B6', '\u09B9' }); addCharRange(new char[] { '\u09DC', '\u09DD' }); addCharRange(new char[] { '\u09DF', '\u09E1' }); addCharRange(new char[] { '\u09F0', '\u09F1' }); addCharRange(new char[] { '\u0A05', '\u0A0A' }); addCharRange(new char[] { '\u0A0F', '\u0A10' }); addCharRange(new char[] { '\u0A13', '\u0A28' });
addCharRange(new char[] { '\u0A2A', '\u0A30' }); addCharRange(new char[] { '\u0A32', '\u0A33' }); addCharRange(new char[] { '\u0A35', '\u0A36' }); addCharRange(new char[] { '\u0A38', '\u0A39' }); addCharRange(new char[] { '\u0A59', '\u0A5C' }); addCharRange(new char[] { '\u0A5E', '\u0A5E' }); addCharRange(new char[] { '\u0A72', '\u0A74' }); addCharRange(new char[] { '\u0A85', '\u0A8B' });
addCharRange(new char[] { '\u0A8D', '\u0A8D' }); addCharRange(new char[] { '\u0A8F', '\u0A91' }); addCharRange(new char[] { '\u0A93', '\u0AA8' }); addCharRange(new char[] { '\u0AAA', '\u0AB0' }); addCharRange(new char[] { '\u0AB2', '\u0AB3' }); addCharRange(new char[] { '\u0AB5', '\u0AB9' }); addCharRange(new char[] { '\u0ABD', '\u0ABD' }); addCharRange(new char[] { '\u0AE0', '\u0AE0' });
addCharRange(new char[] { '\u0B05', '\u0B0C' }); addCharRange(new char[] { '\u0B0F', '\u0B10' }); addCharRange(new char[] { '\u0B13', '\u0B28' }); addCharRange(new char[] { '\u0B2A', '\u0B30' }); addCharRange(new char[] { '\u0B32', '\u0B33' }); addCharRange(new char[] { '\u0B36', '\u0B39' }); addCharRange(new char[] { '\u0B3D', '\u0B3D' }); addCharRange(new char[] { '\u0B5C', '\u0B5D' });
addCharRange(new char[] { '\u0B5F', '\u0B61' }); addCharRange(new char[] { '\u0B85', '\u0B8A' }); addCharRange(new char[] { '\u0B8E', '\u0B90' }); addCharRange(new char[] { '\u0B92', '\u0B95' }); addCharRange(new char[] { '\u0B99', '\u0B9A' }); addCharRange(new char[] { '\u0B9C', '\u0B9C' }); addCharRange(new char[] { '\u0B9E', '\u0B9F' }); addCharRange(new char[] { '\u0BA3', '\u0BA4' });
addCharRange(new char[] { '\u0BA8', '\u0BAA' }); addCharRange(new char[] { '\u0BAE', '\u0BB5' }); addCharRange(new char[] { '\u0BB7', '\u0BB9' }); addCharRange(new char[] { '\u0C05', '\u0C0C' }); addCharRange(new char[] { '\u0C0E', '\u0C10' }); addCharRange(new char[] { '\u0C12', '\u0C28' }); addCharRange(new char[] { '\u0C2A', '\u0C33' }); addCharRange(new char[] { '\u0C35', '\u0C39' });
addCharRange(new char[] { '\u0C60', '\u0C61' }); addCharRange(new char[] { '\u0C85', '\u0C8C' }); addCharRange(new char[] { '\u0C8E', '\u0C90' }); addCharRange(new char[] { '\u0C92', '\u0CA8' }); addCharRange(new char[] { '\u0CAA', '\u0CB3' }); addCharRange(new char[] { '\u0CB5', '\u0CB9' }); addCharRange(new char[] { '\u0CDE', '\u0CDE' }); addCharRange(new char[] { '\u0CE0', '\u0CE1' });
addCharRange(new char[] { '\u0D05', '\u0D0C' }); addCharRange(new char[] { '\u0D0E', '\u0D10' }); addCharRange(new char[] { '\u0D12', '\u0D28' }); addCharRange(new char[] { '\u0D2A', '\u0D39' }); addCharRange(new char[] { '\u0D60', '\u0D61' }); addCharRange(new char[] { '\u0E01', '\u0E2E' }); addCharRange(new char[] { '\u0E30', '\u0E30' }); addCharRange(new char[] { '\u0E32', '\u0E33' });
addCharRange(new char[] { '\u0E40', '\u0E45' }); addCharRange(new char[] { '\u0E81', '\u0E82' }); addCharRange(new char[] { '\u0E84', '\u0E84' }); addCharRange(new char[] { '\u0E87', '\u0E88' }); addCharRange(new char[] { '\u0E8A', '\u0E8A' }); addCharRange(new char[] { '\u0E8D', '\u0E8D' }); addCharRange(new char[] { '\u0E94', '\u0E97' }); addCharRange(new char[] { '\u0E99', '\u0E9F' });
addCharRange(new char[] { '\u0EA1', '\u0EA3' }); addCharRange(new char[] { '\u0EA5', '\u0EA5' }); addCharRange(new char[] { '\u0EA7', '\u0EA7' }); addCharRange(new char[] { '\u0EAA', '\u0EAB' }); addCharRange(new char[] { '\u0EAD', '\u0EAE' }); addCharRange(new char[] { '\u0EB0', '\u0EB0' }); addCharRange(new char[] { '\u0EB2', '\u0EB3' }); addCharRange(new char[] { '\u0EBD', '\u0EBD' });
addCharRange(new char[] { '\u0EC0', '\u0EC4' }); addCharRange(new char[] { '\u0F40', '\u0F47' }); addCharRange(new char[] { '\u0F49', '\u0F69' }); addCharRange(new char[] { '\u10A0', '\u10C5' }); addCharRange(new char[] { '\u10D0', '\u10F6' }); addCharRange(new char[] { '\u1100', '\u1100' }); addCharRange(new char[] { '\u1102', '\u1103' }); addCharRange(new char[] { '\u1105', '\u1107' });
addCharRange(new char[] { '\u1109', '\u1109' }); addCharRange(new char[] { '\u110B', '\u110C' }); addCharRange(new char[] { '\u110E', '\u1112' }); addCharRange(new char[] { '\u113C', '\u113C' }); addCharRange(new char[] { '\u113E', '\u113E' }); addCharRange(new char[] { '\u1140', '\u1140' }); addCharRange(new char[] { '\u114C', '\u114C' }); addCharRange(new char[] { '\u114E', '\u114E' });
addCharRange(new char[] { '\u1150', '\u1150' }); addCharRange(new char[] { '\u1154', '\u1155' }); addCharRange(new char[] { '\u1159', '\u1159' }); addCharRange(new char[] { '\u115F', '\u1161' }); addCharRange(new char[] { '\u1163', '\u1163' }); addCharRange(new char[] { '\u1165', '\u1165' }); addCharRange(new char[] { '\u1167', '\u1167' }); addCharRange(new char[] { '\u1169', '\u1169' });
addCharRange(new char[] { '\u116D', '\u116E' }); addCharRange(new char[] { '\u1172', '\u1173' }); addCharRange(new char[] { '\u1175', '\u1175' }); addCharRange(new char[] { '\u119E', '\u119E' }); addCharRange(new char[] { '\u11A8', '\u11A8' }); addCharRange(new char[] { '\u11AB', '\u11AB' }); addCharRange(new char[] { '\u11AE', '\u11AF' }); addCharRange(new char[] { '\u11B7', '\u11B8' });
addCharRange(new char[] { '\u11BA', '\u11BA' }); addCharRange(new char[] { '\u11BC', '\u11C2' }); addCharRange(new char[] { '\u11EB', '\u11EB' }); addCharRange(new char[] { '\u11F0', '\u11F0' }); addCharRange(new char[] { '\u11F9', '\u11F9' }); addCharRange(new char[] { '\u1E00', '\u1E9B' }); addCharRange(new char[] { '\u1EA0', '\u1EF9' }); addCharRange(new char[] { '\u1F00', '\u1F15' });
addCharRange(new char[] { '\u1F18', '\u1F1D' }); addCharRange(new char[] { '\u1F20', '\u1F45' }); addCharRange(new char[] { '\u1F48', '\u1F4D' }); addCharRange(new char[] { '\u1F50', '\u1F57' }); addCharRange(new char[] { '\u1F59', '\u1F59' }); addCharRange(new char[] { '\u1F5B', '\u1F5B' }); addCharRange(new char[] { '\u1F5D', '\u1F5D' }); addCharRange(new char[] { '\u1F5F', '\u1F7D' });
addCharRange(new char[] { '\u1F80', '\u1FB4' }); addCharRange(new char[] { '\u1FB6', '\u1FBC' }); addCharRange(new char[] { '\u1FBE', '\u1FBE' }); addCharRange(new char[] { '\u1FC2', '\u1FC4' }); addCharRange(new char[] { '\u1FC6', '\u1FCC' }); addCharRange(new char[] { '\u1FD0', '\u1FD3' }); addCharRange(new char[] { '\u1FD6', '\u1FDB' }); addCharRange(new char[] { '\u1FE0', '\u1FEC' });
addCharRange(new char[] { '\u1FF2', '\u1FF4' }); addCharRange(new char[] { '\u1FF6', '\u1FFC' }); addCharRange(new char[] { '\u2126', '\u2126' }); addCharRange(new char[] { '\u212A', '\u212B' }); addCharRange(new char[] { '\u212E', '\u212E' }); addCharRange(new char[] { '\u2180', '\u2182' }); addCharRange(new char[] { '\u3041', '\u3094' }); addCharRange(new char[] { '\u30A1', '\u30FA' });
addCharRange(new char[] { '\u3105', '\u312C' }); addCharRange(new char[] { '\uAC00', '\uD7A3' });
//Ideographic
addCharRange(new char[] { '\u3007', '\u3007' }); addCharRange(new char[] { '\u3021', '\u3029' }); addCharRange(new char[] { '\u4E00', '\u9FA5' });
}
// Same thing as NameChar but no ':' character
CurrentCharType = CharType.NCNameChar;// ranges
{
addCharRange(new char[] { '_', '_' }); addCharRange(new char[] { '-', '-' }); addCharRange(new char[] { '.', '.' });
// BaseChar
addCharRange(new char[] { '\u0041', '\u005A' }); addCharRange(new char[] { '\u0061', '\u007A' }); addCharRange(new char[] { '\u00C0', '\u00D6' }); addCharRange(new char[] { '\u00D8', '\u00F6' }); addCharRange(new char[] { '\u00F8', '\u00FF' }); addCharRange(new char[] { '\u0100', '\u0131' }); addCharRange(new char[] { '\u0134', '\u013E' }); addCharRange(new char[] { '\u0141', '\u0148' });
addCharRange(new char[] { '\u014A', '\u017E' }); addCharRange(new char[] { '\u0180', '\u01C3' }); addCharRange(new char[] { '\u01CD', '\u01F0' }); addCharRange(new char[] { '\u01F4', '\u01F5' }); addCharRange(new char[] { '\u01FA', '\u0217' }); addCharRange(new char[] { '\u0250', '\u02A8' }); addCharRange(new char[] { '\u02BB', '\u02C1' }); addCharRange(new char[] { '\u0386', '\u0386' });
addCharRange(new char[] { '\u0388', '\u038A' }); addCharRange(new char[] { '\u038C', '\u038C' }); addCharRange(new char[] { '\u038E', '\u03A1' }); addCharRange(new char[] { '\u03A3', '\u03CE' }); addCharRange(new char[] { '\u03D0', '\u03D6' }); addCharRange(new char[] { '\u03DA', '\u03DA' }); addCharRange(new char[] { '\u03DC', '\u03DC' }); addCharRange(new char[] { '\u03DE', '\u03DE' });
addCharRange(new char[] { '\u03E0', '\u03E0' }); addCharRange(new char[] { '\u03E2', '\u03F3' }); addCharRange(new char[] { '\u0401', '\u040C' }); addCharRange(new char[] { '\u040E', '\u044F' }); addCharRange(new char[] { '\u0451', '\u045C' }); addCharRange(new char[] { '\u045E', '\u0481' }); addCharRange(new char[] { '\u0490', '\u04C4' }); addCharRange(new char[] { '\u04C7', '\u04C8' });
addCharRange(new char[] { '\u04CB', '\u04CC' }); addCharRange(new char[] { '\u04D0', '\u04EB' }); addCharRange(new char[] { '\u04EE', '\u04F5' }); addCharRange(new char[] { '\u04F8', '\u04F9' }); addCharRange(new char[] { '\u0531', '\u0556' }); addCharRange(new char[] { '\u0559', '\u0559' }); addCharRange(new char[] { '\u0561', '\u0586' }); addCharRange(new char[] { '\u05D0', '\u05EA' });
addCharRange(new char[] { '\u05F0', '\u05F2' }); addCharRange(new char[] { '\u0621', '\u063A' }); addCharRange(new char[] { '\u0641', '\u064A' }); addCharRange(new char[] { '\u0671', '\u06B7' }); addCharRange(new char[] { '\u06BA', '\u06BE' }); addCharRange(new char[] { '\u06C0', '\u06CE' }); addCharRange(new char[] { '\u06D0', '\u06D3' }); addCharRange(new char[] { '\u06D5', '\u06D5' });
addCharRange(new char[] { '\u06E5', '\u06E6' }); addCharRange(new char[] { '\u0905', '\u0939' }); addCharRange(new char[] { '\u093D', '\u093D' }); addCharRange(new char[] { '\u0958', '\u0961' }); addCharRange(new char[] { '\u0985', '\u098C' }); addCharRange(new char[] { '\u098F', '\u0990' }); addCharRange(new char[] { '\u0993', '\u09A8' }); addCharRange(new char[] { '\u09AA', '\u09B0' });
addCharRange(new char[] { '\u09B2', '\u09B2' }); addCharRange(new char[] { '\u09B6', '\u09B9' }); addCharRange(new char[] { '\u09DC', '\u09DD' }); addCharRange(new char[] { '\u09DF', '\u09E1' }); addCharRange(new char[] { '\u09F0', '\u09F1' }); addCharRange(new char[] { '\u0A05', '\u0A0A' }); addCharRange(new char[] { '\u0A0F', '\u0A10' }); addCharRange(new char[] { '\u0A13', '\u0A28' });
addCharRange(new char[] { '\u0A2A', '\u0A30' }); addCharRange(new char[] { '\u0A32', '\u0A33' }); addCharRange(new char[] { '\u0A35', '\u0A36' }); addCharRange(new char[] { '\u0A38', '\u0A39' }); addCharRange(new char[] { '\u0A59', '\u0A5C' }); addCharRange(new char[] { '\u0A5E', '\u0A5E' }); addCharRange(new char[] { '\u0A72', '\u0A74' }); addCharRange(new char[] { '\u0A85', '\u0A8B' });
addCharRange(new char[] { '\u0A8D', '\u0A8D' }); addCharRange(new char[] { '\u0A8F', '\u0A91' }); addCharRange(new char[] { '\u0A93', '\u0AA8' }); addCharRange(new char[] { '\u0AAA', '\u0AB0' }); addCharRange(new char[] { '\u0AB2', '\u0AB3' }); addCharRange(new char[] { '\u0AB5', '\u0AB9' }); addCharRange(new char[] { '\u0ABD', '\u0ABD' }); addCharRange(new char[] { '\u0AE0', '\u0AE0' });
addCharRange(new char[] { '\u0B05', '\u0B0C' }); addCharRange(new char[] { '\u0B0F', '\u0B10' }); addCharRange(new char[] { '\u0B13', '\u0B28' }); addCharRange(new char[] { '\u0B2A', '\u0B30' }); addCharRange(new char[] { '\u0B32', '\u0B33' }); addCharRange(new char[] { '\u0B36', '\u0B39' }); addCharRange(new char[] { '\u0B3D', '\u0B3D' }); addCharRange(new char[] { '\u0B5C', '\u0B5D' });
addCharRange(new char[] { '\u0B5F', '\u0B61' }); addCharRange(new char[] { '\u0B85', '\u0B8A' }); addCharRange(new char[] { '\u0B8E', '\u0B90' }); addCharRange(new char[] { '\u0B92', '\u0B95' }); addCharRange(new char[] { '\u0B99', '\u0B9A' }); addCharRange(new char[] { '\u0B9C', '\u0B9C' }); addCharRange(new char[] { '\u0B9E', '\u0B9F' }); addCharRange(new char[] { '\u0BA3', '\u0BA4' });
addCharRange(new char[] { '\u0BA8', '\u0BAA' }); addCharRange(new char[] { '\u0BAE', '\u0BB5' }); addCharRange(new char[] { '\u0BB7', '\u0BB9' }); addCharRange(new char[] { '\u0C05', '\u0C0C' }); addCharRange(new char[] { '\u0C0E', '\u0C10' }); addCharRange(new char[] { '\u0C12', '\u0C28' }); addCharRange(new char[] { '\u0C2A', '\u0C33' }); addCharRange(new char[] { '\u0C35', '\u0C39' });
addCharRange(new char[] { '\u0C60', '\u0C61' }); addCharRange(new char[] { '\u0C85', '\u0C8C' }); addCharRange(new char[] { '\u0C8E', '\u0C90' }); addCharRange(new char[] { '\u0C92', '\u0CA8' }); addCharRange(new char[] { '\u0CAA', '\u0CB3' }); addCharRange(new char[] { '\u0CB5', '\u0CB9' }); addCharRange(new char[] { '\u0CDE', '\u0CDE' }); addCharRange(new char[] { '\u0CE0', '\u0CE1' });
addCharRange(new char[] { '\u0D05', '\u0D0C' }); addCharRange(new char[] { '\u0D0E', '\u0D10' }); addCharRange(new char[] { '\u0D12', '\u0D28' }); addCharRange(new char[] { '\u0D2A', '\u0D39' }); addCharRange(new char[] { '\u0D60', '\u0D61' }); addCharRange(new char[] { '\u0E01', '\u0E2E' }); addCharRange(new char[] { '\u0E30', '\u0E30' }); addCharRange(new char[] { '\u0E32', '\u0E33' });
addCharRange(new char[] { '\u0E40', '\u0E45' }); addCharRange(new char[] { '\u0E81', '\u0E82' }); addCharRange(new char[] { '\u0E84', '\u0E84' }); addCharRange(new char[] { '\u0E87', '\u0E88' }); addCharRange(new char[] { '\u0E8A', '\u0E8A' }); addCharRange(new char[] { '\u0E8D', '\u0E8D' }); addCharRange(new char[] { '\u0E94', '\u0E97' }); addCharRange(new char[] { '\u0E99', '\u0E9F' });
addCharRange(new char[] { '\u0EA1', '\u0EA3' }); addCharRange(new char[] { '\u0EA5', '\u0EA5' }); addCharRange(new char[] { '\u0EA7', '\u0EA7' }); addCharRange(new char[] { '\u0EAA', '\u0EAB' }); addCharRange(new char[] { '\u0EAD', '\u0EAE' }); addCharRange(new char[] { '\u0EB0', '\u0EB0' }); addCharRange(new char[] { '\u0EB2', '\u0EB3' }); addCharRange(new char[] { '\u0EBD', '\u0EBD' });
addCharRange(new char[] { '\u0EC0', '\u0EC4' }); addCharRange(new char[] { '\u0F40', '\u0F47' }); addCharRange(new char[] { '\u0F49', '\u0F69' }); addCharRange(new char[] { '\u10A0', '\u10C5' }); addCharRange(new char[] { '\u10D0', '\u10F6' }); addCharRange(new char[] { '\u1100', '\u1100' }); addCharRange(new char[] { '\u1102', '\u1103' }); addCharRange(new char[] { '\u1105', '\u1107' });
addCharRange(new char[] { '\u1109', '\u1109' }); addCharRange(new char[] { '\u110B', '\u110C' }); addCharRange(new char[] { '\u110E', '\u1112' }); addCharRange(new char[] { '\u113C', '\u113C' }); addCharRange(new char[] { '\u113E', '\u113E' }); addCharRange(new char[] { '\u1140', '\u1140' }); addCharRange(new char[] { '\u114C', '\u114C' }); addCharRange(new char[] { '\u114E', '\u114E' });
addCharRange(new char[] { '\u1150', '\u1150' }); addCharRange(new char[] { '\u1154', '\u1155' }); addCharRange(new char[] { '\u1159', '\u1159' }); addCharRange(new char[] { '\u115F', '\u1161' }); addCharRange(new char[] { '\u1163', '\u1163' }); addCharRange(new char[] { '\u1165', '\u1165' }); addCharRange(new char[] { '\u1167', '\u1167' }); addCharRange(new char[] { '\u1169', '\u1169' });
addCharRange(new char[] { '\u116D', '\u116E' }); addCharRange(new char[] { '\u1172', '\u1173' }); addCharRange(new char[] { '\u1175', '\u1175' }); addCharRange(new char[] { '\u119E', '\u119E' }); addCharRange(new char[] { '\u11A8', '\u11A8' }); addCharRange(new char[] { '\u11AB', '\u11AB' }); addCharRange(new char[] { '\u11AE', '\u11AF' }); addCharRange(new char[] { '\u11B7', '\u11B8' });
addCharRange(new char[] { '\u11BA', '\u11BA' }); addCharRange(new char[] { '\u11BC', '\u11C2' }); addCharRange(new char[] { '\u11EB', '\u11EB' }); addCharRange(new char[] { '\u11F0', '\u11F0' }); addCharRange(new char[] { '\u11F9', '\u11F9' }); addCharRange(new char[] { '\u1E00', '\u1E9B' }); addCharRange(new char[] { '\u1EA0', '\u1EF9' }); addCharRange(new char[] { '\u1F00', '\u1F15' });
addCharRange(new char[] { '\u1F18', '\u1F1D' }); addCharRange(new char[] { '\u1F20', '\u1F45' }); addCharRange(new char[] { '\u1F48', '\u1F4D' }); addCharRange(new char[] { '\u1F50', '\u1F57' }); addCharRange(new char[] { '\u1F59', '\u1F59' }); addCharRange(new char[] { '\u1F5B', '\u1F5B' }); addCharRange(new char[] { '\u1F5D', '\u1F5D' }); addCharRange(new char[] { '\u1F5F', '\u1F7D' });
addCharRange(new char[] { '\u1F80', '\u1FB4' }); addCharRange(new char[] { '\u1FB6', '\u1FBC' }); addCharRange(new char[] { '\u1FBE', '\u1FBE' }); addCharRange(new char[] { '\u1FC2', '\u1FC4' }); addCharRange(new char[] { '\u1FC6', '\u1FCC' }); addCharRange(new char[] { '\u1FD0', '\u1FD3' }); addCharRange(new char[] { '\u1FD6', '\u1FDB' }); addCharRange(new char[] { '\u1FE0', '\u1FEC' });
addCharRange(new char[] { '\u1FF2', '\u1FF4' }); addCharRange(new char[] { '\u1FF6', '\u1FFC' }); addCharRange(new char[] { '\u2126', '\u2126' }); addCharRange(new char[] { '\u212A', '\u212B' }); addCharRange(new char[] { '\u212E', '\u212E' }); addCharRange(new char[] { '\u2180', '\u2182' }); addCharRange(new char[] { '\u3041', '\u3094' }); addCharRange(new char[] { '\u30A1', '\u30FA' });
addCharRange(new char[] { '\u3105', '\u312C' }); addCharRange(new char[] { '\uAC00', '\uD7A3' });
//Ideographic
addCharRange(new char[] { '\u3007', '\u3007' }); addCharRange(new char[] { '\u3021', '\u3029' }); addCharRange(new char[] { '\u4E00', '\u9FA5' });
//Digit
addCharRange(new char[] { '\u0030', '\u0039' }); addCharRange(new char[] { '\u0660', '\u0669' }); addCharRange(new char[] { '\u06F0', '\u06F9' }); addCharRange(new char[] { '\u0966', '\u096F' }); addCharRange(new char[] { '\u09E6', '\u09EF' }); addCharRange(new char[] { '\u0A66', '\u0A6F' }); addCharRange(new char[] { '\u0AE6', '\u0AEF' }); addCharRange(new char[] { '\u0B66', '\u0B6F' });
addCharRange(new char[] { '\u0BE7', '\u0BEF' }); addCharRange(new char[] { '\u0C66', '\u0C6F' }); addCharRange(new char[] { '\u0CE6', '\u0CEF' }); addCharRange(new char[] { '\u0D66', '\u0D6F' }); addCharRange(new char[] { '\u0E50', '\u0E59' }); addCharRange(new char[] { '\u0ED0', '\u0ED9' }); addCharRange(new char[] { '\u0F20', '\u0F29' });
//Combination
addCharRange(new char[] { '\u0300', '\u0345' }); addCharRange(new char[] { '\u0360', '\u0361' }); addCharRange(new char[] { '\u0483', '\u0486' }); addCharRange(new char[] { '\u0591', '\u05A1' }); addCharRange(new char[] { '\u05A3', '\u05B9' }); addCharRange(new char[] { '\u05BB', '\u05BD' }); addCharRange(new char[] { '\u05BF', '\u05BF' }); addCharRange(new char[] { '\u05C1', '\u05C2' });
addCharRange(new char[] { '\u05C4', '\u05C4' }); addCharRange(new char[] { '\u064B', '\u0652' }); addCharRange(new char[] { '\u0670', '\u0670' }); addCharRange(new char[] { '\u06D6', '\u06DC' }); addCharRange(new char[] { '\u06DD', '\u06DF' }); addCharRange(new char[] { '\u06E0', '\u06E4' }); addCharRange(new char[] { '\u06E7', '\u06E8' }); addCharRange(new char[] { '\u06EA', '\u06ED' });
addCharRange(new char[] { '\u0901', '\u0903' }); addCharRange(new char[] { '\u093C', '\u093C' }); addCharRange(new char[] { '\u093E', '\u094C' }); addCharRange(new char[] { '\u094D', '\u094D' }); addCharRange(new char[] { '\u0951', '\u0954' }); addCharRange(new char[] { '\u0962', '\u0963' }); addCharRange(new char[] { '\u0981', '\u0983' }); addCharRange(new char[] { '\u09BC', '\u09BC' });
addCharRange(new char[] { '\u09BE', '\u09BE' }); addCharRange(new char[] { '\u09BF', '\u09BF' }); addCharRange(new char[] { '\u09C0', '\u09C4' }); addCharRange(new char[] { '\u09C7', '\u09C8' }); addCharRange(new char[] { '\u09CB', '\u09CD' }); addCharRange(new char[] { '\u09D7', '\u09D7' }); addCharRange(new char[] { '\u09E2', '\u09E3' }); addCharRange(new char[] { '\u0A02', '\u0A02' });
addCharRange(new char[] { '\u0A3C', '\u0A3C' }); addCharRange(new char[] { '\u0A3E', '\u0A3E' }); addCharRange(new char[] { '\u0A3F', '\u0A3F' }); addCharRange(new char[] { '\u0A40', '\u0A42' }); addCharRange(new char[] { '\u0A47', '\u0A48' }); addCharRange(new char[] { '\u0A4B', '\u0A4D' }); addCharRange(new char[] { '\u0A70', '\u0A71' }); addCharRange(new char[] { '\u0A81', '\u0A83' });
addCharRange(new char[] { '\u0ABC', '\u0ABC' }); addCharRange(new char[] { '\u0ABE', '\u0AC5' }); addCharRange(new char[] { '\u0AC7', '\u0AC9' }); addCharRange(new char[] { '\u0ACB', '\u0ACD' }); addCharRange(new char[] { '\u0B01', '\u0B03' }); addCharRange(new char[] { '\u0B3C', '\u0B3C' }); addCharRange(new char[] { '\u0B3E', '\u0B43' }); addCharRange(new char[] { '\u0B47', '\u0B48' });
addCharRange(new char[] { '\u0B4B', '\u0B4D' }); addCharRange(new char[] { '\u0B56', '\u0B57' }); addCharRange(new char[] { '\u0B82', '\u0B83' }); addCharRange(new char[] { '\u0BBE', '\u0BC2' }); addCharRange(new char[] { '\u0BC6', '\u0BC8' }); addCharRange(new char[] { '\u0BCA', '\u0BCD' }); addCharRange(new char[] { '\u0BD7', '\u0BD7' }); addCharRange(new char[] { '\u0C01', '\u0C03' });
addCharRange(new char[] { '\u0C3E', '\u0C44' }); addCharRange(new char[] { '\u0C46', '\u0C48' }); addCharRange(new char[] { '\u0C4A', '\u0C4D' }); addCharRange(new char[] { '\u0C55', '\u0C56' }); addCharRange(new char[] { '\u0C82', '\u0C83' }); addCharRange(new char[] { '\u0CBE', '\u0CC4' }); addCharRange(new char[] { '\u0CC6', '\u0CC8' }); addCharRange(new char[] { '\u0CCA', '\u0CCD' });
addCharRange(new char[] { '\u0CD5', '\u0CD6' }); addCharRange(new char[] { '\u0D02', '\u0D03' }); addCharRange(new char[] { '\u0D3E', '\u0D43' }); addCharRange(new char[] { '\u0D46', '\u0D48' }); addCharRange(new char[] { '\u0D4A', '\u0D4D' }); addCharRange(new char[] { '\u0D57', '\u0D57' }); addCharRange(new char[] { '\u0E31', '\u0E31' }); addCharRange(new char[] { '\u0E34', '\u0E3A' });
addCharRange(new char[] { '\u0E47', '\u0E4E' }); addCharRange(new char[] { '\u0EB1', '\u0EB1' }); addCharRange(new char[] { '\u0EB4', '\u0EB9' }); addCharRange(new char[] { '\u0EBB', '\u0EBC' }); addCharRange(new char[] { '\u0EC8', '\u0ECD' }); addCharRange(new char[] { '\u0F18', '\u0F19' }); addCharRange(new char[] { '\u0F35', '\u0F35' }); addCharRange(new char[] { '\u0F37', '\u0F37' });
addCharRange(new char[] { '\u0F39', '\u0F39' }); addCharRange(new char[] { '\u0F3E', '\u0F3E' }); addCharRange(new char[] { '\u0F3F', '\u0F3F' }); addCharRange(new char[] { '\u0F71', '\u0F84' }); addCharRange(new char[] { '\u0F86', '\u0F8B' }); addCharRange(new char[] { '\u0F90', '\u0F95' }); addCharRange(new char[] { '\u0F97', '\u0F97' }); addCharRange(new char[] { '\u0F99', '\u0FAD' });
addCharRange(new char[] { '\u0FB1', '\u0FB7' }); addCharRange(new char[] { '\u0FB9', '\u0FB9' }); addCharRange(new char[] { '\u20D0', '\u20DC' }); addCharRange(new char[] { '\u20E1', '\u20E1' }); addCharRange(new char[] { '\u302A', '\u302F' }); addCharRange(new char[] { '\u3099', '\u3099' }); addCharRange(new char[] { '\u309A', '\u309A' });
//Extender
addCharRange(new char[] { '\u00B7', '\u00B7' }); addCharRange(new char[] { '\u02D0', '\u02D0' }); addCharRange(new char[] { '\u02D1', '\u02D1' }); addCharRange(new char[] { '\u0387', '\u0387' }); addCharRange(new char[] { '\u0640', '\u0640' }); addCharRange(new char[] { '\u0E46', '\u0E46' }); addCharRange(new char[] { '\u0EC6', '\u0EC6' }); addCharRange(new char[] { '\u3005', '\u3005' });
addCharRange(new char[] { '\u3031', '\u3035' }); addCharRange(new char[] { '\u309D', '\u309E' }); addCharRange(new char[] { '\u30FC', '\u30FE' });
}
// Leaving these here but these are not used for fourth edition as we have disabled the API below
CurrentCharType = CharType.NameStartSurrogateHighChar;// ranges
{
addCharRange(new char[] { '\ud800', '\udb7f' });
}
// Leaving these here but these are not used for fourth edition as we have disabled the API below
CurrentCharType = CharType.NameStartSurrogateLowChar;// ranges
{
addCharRange(new char[] { '\udc00', '\udfff' });
}
// Leaving these here but these are not used for fourth edition as we have disabled the API below
CurrentCharType = CharType.NameSurrogateHighChar;// ranges
{
addCharRange(new char[] { '\ud800', '\udb7f' });
}
// Leaving these here but these are not used for fourth edition as we have disabled the API below
CurrentCharType = CharType.NameSurrogateLowChar;// ranges
{
addCharRange(new char[] { '\udc00', '\udfff' });
}
//[13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
CurrentCharType = CharType.PubidChar;// ranges
{
addCharRange(new char[] { '\u0020', '\u0020' }); addCharRange(new char[] { '\u000D', '\u000D' }); addCharRange(new char[] { '\u000A', '\u000A' });
addCharRange(new char[] { 'a', 'z' }); addCharRange(new char[] { 'A', 'Z' }); addCharRange(new char[] { '0', '9' }); addCharRange(new char[] { '-', '-' }); addCharRange(new char[] { '-', '-' });
addCharRange(new char[] { '\'', '\'' }); addCharRange(new char[] { '(', '(' }); addCharRange(new char[] { ')', ')' }); addCharRange(new char[] { '+', '+' }); addCharRange(new char[] { ',', ',' });
addCharRange(new char[] { '.', '.' }); addCharRange(new char[] { '/', '/' }); addCharRange(new char[] { ':', ':' }); addCharRange(new char[] { '=', '=' }); addCharRange(new char[] { '?', '?' });
addCharRange(new char[] { ';', ';' }); addCharRange(new char[] { '!', '!' }); addCharRange(new char[] { '*', '*' }); addCharRange(new char[] { '#', '#' }); addCharRange(new char[] { '@', '@' });
addCharRange(new char[] { '$', '$' }); addCharRange(new char[] { '_', '_' }); addCharRange(new char[] { '%', '%' });
}
}
/// <summary>Consume text that has been provided to the class constructor, splitting it into
/// a list of tokens.</summary>
/// <param name="lineNumber">Line number for diagnostics and debugging.</param>
/// <returns>The resulting tokens list.</returns>
protected TokenList Parse(int lineNumber)
{
// Save in comment, might be useful in future. Already had to dig it out of TFS once
//var xRegex = new System.Text.RegularExpressions.Regex(@"(\W)");
var xResult = new TokenList();
CharType xLastCharType = CharType.WhiteSpace;
char xChar;
CharType xCharType = CharType.WhiteSpace;
int i = 0;
for (i = 0; i < mData.Length; i++)
{
xChar = mData[i];
// Extract string literal (surrounded with single quote characters).
if (xChar == '\'')
{
// Take data before the ' as a token.
NewToken(xResult, lineNumber, ref i);
// Now scan to the next ' taking into account escaped single quotes.
bool escapedCharacter = false;
for (i = i + 1; i < mData.Length; i++)
{
bool done = false;
switch (mData[i])
{
case '\'':
if (!escapedCharacter)
{
done = true;
}
break;
case '\\':
escapedCharacter = !escapedCharacter;
break;
default:
escapedCharacter = false;
break;
}
if (done)
{
break;
}
}
if (i == mData.Length)
{
throw new Exception("Unterminated string.");
}
i++;
xCharType = CharType.String;
}
else if (xChar == '(')
{
for (i += 1; i < mData.Length; i++)
{
if (mData[i] == ')' && mData.LastIndexOf(")") <= i)
{
i++;
NewToken(xResult, lineNumber, ref i);
break;
}
}
}
else if (char.IsWhiteSpace(xChar))
{
xCharType = CharType.WhiteSpace;
}
else if (IsAlphaNum(xChar))
{
// _ and . were never likely to stand on their own. ie ESP _ 2 and ESP . 2 are never likely to be used.
// Having them on their own required a lot of code
// to treat them as a single unit where we did use them. So we treat them as AlphaNum.
xCharType = CharType.Identifier;
}
else
{
xCharType = CharType.Symbol;
}
// i > 0 - Never do NewToken on first char. i = 0 is just a pass to get char and set lastchar.
// But its faster as the second short circuit rather than a separate if.
if ((xCharType != xLastCharType) && (0 < i))
{
NewToken(xResult, lineNumber, ref i);
}
xLastCharType = xCharType;
}
// Last token
if (mStart < mData.Length)
{
NewToken(xResult, lineNumber, ref i);
}
return(xResult);
}
public static string GetNameWithChar(char c, CharType charType)
{
switch (charType)
{
case CharType.NameStartChar:
return new string(new char[] { c, 'a', 'b' });
case CharType.NameChar:
return new string(new char[] { 'a', c, 'b' });
case CharType.NameStartSurrogateHighChar:
return new string(new char[] { c, '\udc00', 'a', 'b' });
case CharType.NameStartSurrogateLowChar:
return new string(new char[] { '\udb7f', c, 'a', 'b' });
case CharType.NameSurrogateHighChar:
return new string(new char[] { 'a', 'b', c, '\udc00' });
case CharType.NameSurrogateLowChar:
return new string(new char[] { 'a', 'b', '\udb7f', c });
default:
throw new CTestFailedException("TEST ISSUE: CharType FAILURE!");
}
}
public Monster(CharType type) :
base(type)
{
}
private void ResolveBrackets()
{
BidiLink strongLink = null;
_bracketQueue.Clear(Level.MakeEmbeddingType(_level));
for (BidiLink link = _roller.Next; link != _roller; link = link.Next)
{
CharType type = link.type;
switch (type)
{
case CharType.ON:
BracketType bracketType;
char ch = Text[link.offset];
int bracketValue = PairingLookup.DetermineBracketPair((int)ch, out bracketType);
switch (bracketType)
{
case BracketType.Open:
BracketPair bracketPair = new BracketPair()
{
bracketUnicode = ch,
openingLink = link,
priorStrongLink = strongLink
};
_bracketQueue.Enqueue(bracketPair);
break;
case BracketType.Close:
if (!_bracketQueue.IsEmpty)
{
_bracketQueue.ClosePair(link, bracketValue);
if (_bracketQueue.ShouldDequeue)
{
ResolveAvailableBracketPairs();
}
}
break;
}
break;
case CharType.L:
case CharType.R:
case CharType.AL:
case CharType.EN:
case CharType.AN:
if (!_bracketQueue.IsEmpty)
{
if (type == CharType.EN || type == CharType.AN)
{
type = CharType.R;
}
_bracketQueue.SetStrongType(type);
}
strongLink = link;
break;
}
}
ResolveAvailableBracketPairs();
}
public TextInput(CharType charType = DEFAULT_CHAR_TYPE, int maxLength = DEFAULT_MAX_LENGTH)
{
this.charType = charType;
this.maxLength = maxLength;
}
/// <summary>
/// Token() constructor: creates an empty token
/// </summary>
public Token()
{
m_sToken = "";
m_chType = CharType.CT_UNDEF;
}
public int GetGlue(CharType leftType, CharType rightType)
{
return(glueTable[(int)leftType * 10 + (int)rightType]);
}
// constructors.
public CharDescriptor(int maskPos, CharType charType)
{
MaskPosition = maskPos;
CharType = charType;
}
private static int findClosestNPC(character input, CharType type)
{
int tag = -1;
float currentLowest = 9999f;
for (int i = 0; i != world.levels[world.i_currentLvl].char_living.Length; i++)
{
if (world.levels[world.i_currentLvl].char_living[i].Type == type && world.levels[world.i_currentLvl].char_living[i].attrib.hp_current > 0)
{
float dist = Vector2.Distance(input.B_baseProps.v_position, world.levels[world.i_currentLvl].char_living[i].B_baseProps.v_position);
if (dist < input.brain.ais_senses.radius_sight)
{
if (dist < currentLowest)
{
tag = i;
currentLowest = dist;
}
}
}
}
return tag;
}
public IState Transfer(CharType charType)
{
return(States.IllegalState);
}
public character(string Name, Vector2 Position, skill Skill, ControlType CType, CharType type)
{
controlType = CType;
action = "idle";
special_tag = -1;
Type = type;
name = Name;
B_baseProps = new Base(Position, 70f);
f_currentFrame = 0;
body = null;
currentAnim = new Animation();
angle = 0;
accuracy = 1;
attrib = Skill;
armor = 0;
pointingRight = true;
Primary_weap = Secondary_weap = SideArm_weap = current_weap = new weapon();
Inventory = new inventory(5, null);
weaponInUse = "unarmed";
brain = new AInode(false);
reordered = false;
}
public static bool IsType (this byte c, CharType type)
{
return (table[c] & type) != 0;
}
public override bool Visit(CharType node)
{
Visit((IntegralType)node);
return(true);
}
public static character CreateActor(Vector2 pos, float Z, CharType type, ControlType ctype, string name)
{
character output = new character();
int tag = 0;
if (name == "")
{
int CharID =6;
while(world.characters[CharID].name == "SPECOPS")
{
CharID = (int)gfunc.roundUp(gfunc.RandomNumber(0, world.characters.Length - 1));
}
//output = world.characters[CharID];
output = character.setTo(world.characters[CharID]);
}
else
{
for (int i = 0; i != world.characters.Length; i++)
{
if (world.characters[i].name == name)
{
tag = i;
}
}
//output = world.characters[tag];
output = character.setTo(world.characters[tag]);
}
for (int i = 0; i != output.body.Length; i++)
{
if (output.body[i].name == "HEAD")
{
output.body[i].maxHP = output.body[i].currentHP = 250;
}
output.body[i].maxHP = output.body[i].currentHP = 250;
}
output.attrib.hp_current = output.attrib.hp_max = 1000;
output = setAnimation(output, "human_idle_stand");
output.B_baseProps.v_position = pos;
output.B_baseProps.f_Position_Z = Z;
output.Type = type;
output.controlType = ctype;
if (ctype == ControlType.player_current)
{
output.name = Gamer.SignedInGamers[0].Gamertag;
}
else
{
output.name = gfunc.RandomName(true);
}
output.special_tag = -1;
output.Inventory.maxWeight = 20;
if (output.controlType == ControlType.NPC)
{
output.brain.active = true;
output.brain.ais_senses = new aiSenses(500, 700, 40, 0, 0, 0);
}
return output;
}
/// <summary>
/// Token() constructor: creates an empty token
/// </summary>
public Token()
{
m_sToken = "";
m_chType = CharType.CT_UNDEF;
}
public static string GetInvalidCharacters(CharType charType)
{
StringBuilder sb = new StringBuilder();
for (int charIdx = 0; charIdx < s_charTypeTable.Length; charIdx++)
{
if ((s_charTypeTable[charIdx] & charType) == 0)
{
sb.Append((char)charIdx);
}
}
return sb.ToString();
}
/// <devdoc>
/// Finds a position in the test string according to the needed position type (needEditPos).
/// The positions are relative to the test string.
/// Returns InvalidIndex if it doesn't find one.
/// </devdoc>
private int FindPositionInRange(int startPosition, int endPosition, bool direction, CharType charTypeFlags)
{
if (startPosition < 0)
{
startPosition = 0;
}
if (endPosition >= this.testString.Length)
{
endPosition = this.testString.Length - 1;
}
if (startPosition > endPosition)
{
return invalidIndex;
}
// Iterate through the test string until we find an edit char position.
int testPosition;
while (startPosition <= endPosition)
{
testPosition = (direction == forward) ? startPosition++ : endPosition--;
CharDescriptor chDex = this.stringDescriptor[testPosition];
if ((chDex.CharType & charTypeFlags) == chDex.CharType)
{
return testPosition;
}
}
return invalidIndex;
}
public static IEnumerable<string> GenerateNames(int count, bool isValid, CharType charType)
{
Func<CharType, string> generator = isValid ? (Func<CharType, string>)UnicodeCharHelper.GetValidCharacters : (Func<CharType, string>)UnicodeCharHelper.GetInvalidCharacters;
string chars = generator(charType);
for (int i = 0; i < count; i++)
{
char c = chars[s_rand.Next(chars.Length)];
yield return GetNameWithChar(c, charType);
}
}
void TypeAndToken(out IToken tok, out Type ty)
{
Contract.Ensures(Contract.ValueAtReturn(out tok)!=null); Contract.Ensures(Contract.ValueAtReturn(out ty) != null);
tok = Token.NoToken; ty = new BoolType(); /*keep compiler happy*/
List<Type> gt; List<Type> tupleArgTypes = null;
switch (la.kind) {
case 6: {
Get();
tok = t;
break;
}
case 7: {
Get();
tok = t; ty = new CharType();
break;
}
case 9: {
Get();
tok = t; ty = new NatType();
break;
}
case 8: {
Get();
tok = t; ty = new IntType();
break;
}
case 10: {
Get();
tok = t; ty = new RealType();
break;
}
case 11: {
Get();
tok = t; ty = new ObjectType();
break;
}
case 13: {
Get();
tok = t; gt = new List<Type>();
if (la.kind == 52) {
GenericInstantiation(gt);
}
if (gt.Count > 1) {
SemErr("set type expects only one type argument");
}
ty = new SetType(true, gt.Count == 1 ? gt[0] : null);
break;
}
case 14: {
Get();
tok = t; gt = new List<Type>();
if (la.kind == 52) {
GenericInstantiation(gt);
}
if (gt.Count > 1) {
SemErr("set type expects only one type argument");
}
ty = new SetType(false, gt.Count == 1 ? gt[0] : null);
break;
}
case 15: {
Get();
tok = t; gt = new List<Type>();
if (la.kind == 52) {
GenericInstantiation(gt);
}
if (gt.Count > 1) {
SemErr("multiset type expects only one type argument");
}
ty = new MultiSetType(gt.Count == 1 ? gt[0] : null);
break;
}
case 16: {
Get();
tok = t; gt = new List<Type>();
if (la.kind == 52) {
GenericInstantiation(gt);
}
if (gt.Count > 1) {
SemErr("seq type expects only one type argument");
}
ty = new SeqType(gt.Count == 1 ? gt[0] : null);
break;
}
case 12: {
Get();
tok = t; ty = new UserDefinedType(tok, tok.val, null);
break;
}
case 17: {
Get();
tok = t; gt = new List<Type>();
if (la.kind == 52) {
GenericInstantiation(gt);
}
if (gt.Count == 0) {
ty = new MapType(true, null, null);
} else if (gt.Count != 2) {
SemErr("map type expects two type arguments");
ty = new MapType(true, gt[0], gt.Count == 1 ? new InferredTypeProxy() : gt[1]);
} else {
ty = new MapType(true, gt[0], gt[1]);
}
break;
}
case 18: {
Get();
tok = t; gt = new List<Type>();
if (la.kind == 52) {
GenericInstantiation(gt);
}
if (gt.Count == 0) {
ty = new MapType(false, null, null);
} else if (gt.Count != 2) {
SemErr("imap type expects two type arguments");
ty = new MapType(false, gt[0], gt.Count == 1 ? new InferredTypeProxy() : gt[1]);
} else {
ty = new MapType(false, gt[0], gt[1]);
}
break;
}
case 5: {
Get();
tok = t; gt = null;
if (la.kind == 52) {
gt = new List<Type>();
GenericInstantiation(gt);
}
int dims = tok.val.Length == 5 ? 1 : int.Parse(tok.val.Substring(5));
ty = theBuiltIns.ArrayType(tok, dims, gt, true);
break;
}
case 50: {
Get();
tok = t; tupleArgTypes = new List<Type>();
if (StartOf(3)) {
Type(out ty);
tupleArgTypes.Add(ty);
while (la.kind == 22) {
Get();
Type(out ty);
tupleArgTypes.Add(ty);
}
}
Expect(51);
if (tupleArgTypes.Count == 1) {
// just return the type 'ty'
} else {
var dims = tupleArgTypes.Count;
var tmp = theBuiltIns.TupleType(tok, dims, true); // make sure the tuple type exists
ty = new UserDefinedType(tok, BuiltIns.TupleTypeName(dims), dims == 0 ? null : tupleArgTypes);
}
break;
}
case 1: {
Expression e; tok = t;
NameSegmentForTypeName(out e);
tok = t;
while (la.kind == 27) {
Get();
Expect(1);
tok = t; List<Type> typeArgs = null;
if (la.kind == 52) {
typeArgs = new List<Type>();
GenericInstantiation(typeArgs);
}
e = new ExprDotName(tok, e, tok.val, typeArgs);
}
ty = new UserDefinedType(e.tok, e);
break;
}
default: SynErr(164); break;
}
if (la.kind == 30) {
Type t2;
Get();
tok = t;
Type(out t2);
if (tupleArgTypes != null) {
gt = tupleArgTypes;
} else {
gt = new List<Type>{ ty };
}
ty = new ArrowType(tok, gt, t2);
theBuiltIns.CreateArrowTypeDecl(gt.Count);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MimeKit.Encodings.QEncoder"/> class.
/// </summary>
/// <remarks>
/// Creates a new rfc2047 quoted-printable encoder.
/// </remarks>
/// <param name="mode">The rfc2047 encoding mode.</param>
public QEncoder(QEncodeMode mode)
{
mask = mode == QEncodeMode.Phrase ? CharType.IsEncodedPhraseSafe : CharType.IsEncodedWordSafe;
}
public SpecialCharacter(CharacterBuffer buffer)
{
//this.Image = ImageType.SpecialCharacter;
this.Escaped = false;
this.Start = buffer.IndexInOriginalBuffer;
if (buffer.IsAtEnd)
{
this.CharacterType = CharType.Invalid;
this.character = "\\";
this.Literal = "\\";
this.Description = "Illegal \\ at end of pattern";
this.IsValid = false;
this.Start = this.Start - 1;
this.End = this.Start + 1;
}
else if (buffer.CurrentCharacter == '[')
{
buffer.MoveNext();
if (buffer.CurrentCharacter != '\u005E')
{
buffer.MoveNext();
this.Literal = string.Concat("[\\", buffer.CurrentCharacter);
}
else
{
this.MatchIfAbsent = true;
buffer.Move(2);
this.Literal = string.Concat("[^\\", buffer.CurrentCharacter);
}
this.S = buffer.CurrentCharacter.ToString();
if (this.MatchIfAbsent)
{
this.Description = string.Concat("Any character other than ", this.Description);
}
buffer.MoveNext();
SpecialCharacter specialCharacter = this;
specialCharacter.Literal = string.Concat(specialCharacter.Literal, buffer.CurrentCharacter);
buffer.MoveNext();
}
else if (buffer.CurrentCharacter != '\\')
{
this.S = buffer.CurrentCharacter.ToString();
this.Literal = this.S;
buffer.MoveNext();
}
else
{
buffer.MoveNext();
if (!buffer.IsAtEnd)
{
Match match = SpecialCharacter.RegNumeric.Match(buffer.GetToEnd());
if (!match.Success)
{
this.Escaped = true;
this.S = buffer.CurrentCharacter.ToString();
this.Literal = string.Concat("\\", this.S);
buffer.MoveNext();
}
else
{
string str = match.Value.Substring(0, 1);
string str1 = str;
if (str != null)
{
if (str1 == "x")
{
this.Description = string.Concat("Hex ", match.Value.Substring(1));
this.CharacterType = CharType.Hex;
this.character = match.Value.Substring(1);
goto Label0;
}
else if (str1 == "u")
{
this.Description = string.Concat("Unicode ", match.Value.Substring(1));
this.CharacterType = CharType.Unicode;
this.character = match.Value.Substring(1);
goto Label0;
}
else
{
if (str1 != "c")
{
goto Label2;
}
this.Description = string.Concat("Control ", match.Value.Substring(1, 1));
this.CharacterType = CharType.Control;
this.character = match.Value.Substring(1);
goto Label0;
}
}
Label2:
this.Description = string.Concat("Octal ", match.Value);
this.CharacterType = CharType.Octal;
this.character = match.Value.Substring(2);
Label0:
this.Literal = string.Concat("\\", match.Value);
buffer.Move(match.Length);
}
}
else
{
Utility.ParseError("Illegal \\ at end of pattern", buffer);
}
}
base.ParseRepetitions(buffer);
}
private BidiLink ResolveWeakTypes()
{
BidiLink priorLink = _roller;
CharType w1PriorType = _sos;
CharType w2StrongType = _sos;
for (BidiLink link = _roller.Next; link != _roller; link = link.Next)
{
CharType type = link.type;
// Rule W1
if (type == CharType.NSM)
{
// Change the 'type' variable as well because it can be EN on which
// W2 depends.
switch (w1PriorType)
{
case CharType.LRI:
case CharType.RLI:
case CharType.FSI:
case CharType.PDI:
link.type = type = CharType.ON;
break;
default:
link.type = type = w1PriorType;
break;
}
}
w1PriorType = type;
// Rule W2
if (type == CharType.EN)
{
if (w2StrongType == CharType.AL)
{
link.type = CharType.AN;
}
}
// Rule W3
// Note: It is safe to apply W3 in 'else-if' statement because it only
// depends on type AL. Even if W2 changes EN to AN, there won't
// be any harm.
else if (type == CharType.AL)
{
link.type = CharType.R;
}
// Save the strong type for W2.
switch (type)
{
case CharType.L:
case CharType.AL:
case CharType.R:
w2StrongType = type;
break;
}
if (type != CharType.ON && priorLink.type == type)
{
priorLink.MergeNext();
}
else
{
priorLink = link;
}
}
priorLink = _roller;
CharType w4PriorType = _sos;
CharType w5PriorType = _sos;
CharType w7StrongType = _sos;
for (BidiLink link = _roller.Next; link != _roller; link = link.Next)
{
CharType type = link.type;
CharType nextType = link.Next.type;
// Rule W4
if (link.length == 1 &&
(type == CharType.ES || type == CharType.CS) &&
(w4PriorType == CharType.EN || w4PriorType == CharType.AN) &&
(w4PriorType == nextType) &&
(w4PriorType == CharType.EN || type == CharType.CS))
{
// Change the current type as well because it can be EN on which W7
// depends.
link.type = type = w4PriorType;
}
w4PriorType = type;
// Rule W5
if (type == CharType.ET &&
(w5PriorType == CharType.EN || nextType == CharType.EN))
{
// Change the current type as well because it is EN on which W7
// depends.
link.type = type = CharType.EN;
}
w5PriorType = type;
switch (type)
{
// Rule W6
case CharType.ET:
case CharType.CS:
case CharType.ES:
link.type = CharType.ON;
break;
// Rule W7
// Note: W7 is expected to be applied after W6. However this is not the
// case here. The reason is that W6 can only create the type ON
// which is not tested in W7 by any means. So it won't affect the
// algorithm.
case CharType.EN:
if (w7StrongType == CharType.L)
{
link.type = CharType.L;
}
break;
// Save the strong type for W7.
// Note: The strong type is expected to be saved after applying W7
// because W7 itself creates a strong type. However the strong type
// being saved here is based on the type after W5.
// This won't effect the algorithm because a single link contains
// all consecutive EN types. This means that even if W7 creates a
// strong type, it will be saved in next iteration.
case CharType.L:
case CharType.R:
w7StrongType = type;
break;
}
if (type != CharType.ON && priorLink.type == type)
{
priorLink.MergeNext();
}
else
{
priorLink = link;
}
}
return(priorLink);
}
/// <summary>
/// Initializes a new instance of the <see cref="CharAnim"/> class.
/// </summary>
/// <param name="ch">Znak</param>
/// <param name="t">Rodzaj znaku</param>
public CharAnim(char ch, CharType t)
{
this.goalChar = ch;
this.type = t;
}
private void ResolveAvailableBracketPairs()
{
CharType embeddingDirection = Level.MakeEmbeddingType(_level);
CharType oppositeDirection = Level.MakeOppositeType(_level);
while (!_bracketQueue.IsEmpty)
{
BracketPair pair = _bracketQueue.Peek();
if (pair.IsComplete)
{
CharType innerStrongType = pair.innerStrongType;
CharType pairType;
// Rule: N0.b
if (innerStrongType == embeddingDirection)
{
pairType = innerStrongType;
}
// Rule: N0.c
else if (innerStrongType == oppositeDirection)
{
BidiLink priorStrongLink;
CharType priorStrongType;
priorStrongLink = pair.priorStrongLink;
if (priorStrongLink != null)
{
priorStrongType = priorStrongLink.type;
if (priorStrongType == CharType.EN || priorStrongType == CharType.AN)
{
priorStrongType = CharType.R;
}
BidiLink link = priorStrongLink.Next;
BidiLink start = pair.openingLink;
while (link != start)
{
CharType type = link.type;
if (type == CharType.L || type == CharType.R)
{
priorStrongType = type;
}
link = link.Next;
}
}
else
{
priorStrongType = _sos;
}
// Rule: N0.c.1
if (priorStrongType == oppositeDirection)
{
pairType = oppositeDirection;
}
// Rule: N0.c.2
else
{
pairType = embeddingDirection;
}
}
// Rule: N0.d
else
{
pairType = CharType.Nil;
}
if (pairType != CharType.Nil)
{
// Do the substitution
pair.openingLink.type = pairType;
pair.closingLink.type = pairType;
}
}
_bracketQueue.Dequeue();
}
}
public static void PrintBox(uint startX, uint startY, uint width, uint height, BorderType borderType = BorderType.DoubleBorder, CharType topLeftCorner = CharType.TopLeftCorner, CharType topRightCorner = CharType.TopRightCorner, CharType bottomLeftCorner = CharType.BottomLeftCorner, CharType bottomRightCorner = CharType.BottomRightCorner, string title = "")
{
for (int index = 0; (long)index < (long)height; ++index)
{
SetCursorPosition(GetCoordinates((int)startX, index + (int)startY));
Console.Write(GetBorderChar(borderType, CharType.Vertical));
SetCursorPosition(GetCoordinates((int)startX + (int)width, index + (int)startY));
Console.Write(GetBorderChar(borderType, CharType.Vertical));
}
for (int index = 0; (long)index < (long)width; ++index)
{
SetCursorPosition(GetCoordinates((int)startX + index, (int)startY));
Console.Write(GetBorderChar(borderType, CharType.Horizontal));
SetCursorPosition(GetCoordinates((int)startX + index, (int)startY + (int)height - 1));
Console.Write(GetBorderChar(borderType, CharType.Horizontal));
}
SetCursorPosition(GetCoordinates((int)startX, (int)startY));
Console.Write(GetBorderChar(borderType, topLeftCorner));
SetCursorPosition(GetCoordinates((int)startX, (int)startY + (int)height - 1));
Console.Write(GetBorderChar(borderType, bottomLeftCorner));
SetCursorPosition(GetCoordinates((int)startX + (int)width, (int)startY));
Console.Write(GetBorderChar(borderType, topRightCorner));
SetCursorPosition(GetCoordinates((int)startX + (int)width, (int)startY + (int)height - 1));
Console.Write(GetBorderChar(borderType, bottomRightCorner));
if (string.IsNullOrEmpty(title))
{
return;
}
PrintCentre(title, (int)width, (int)startY, ConsoleColor.Black, ConsoleColor.White);
}
/// <summary>
/// Token(string, CharType) constructor: A constructor that creates a new token object with the
/// passed token string and character type information.
/// </summary>
/// <param name="sToken">string representing the token value</param>
/// <param name="chType">Character enumeration describing the type of data in the token.</param>
public Token(string sToken, CharType chType)
{
m_sToken = sToken;
m_chType = chType;
}
/// <summary>
/// Token(string, CharType) constructor: A constructor that creates a new token object with the
/// passed token string and character type information.
/// </summary>
/// <param name="sToken">string representing the token value</param>
/// <param name="chType">Character enumeration describing the type of data in the token.</param>
public Token(string sToken, CharType chType)
{
m_sToken = sToken;
m_chType = chType;
}
/// <summary>
/// Token(char, CharType) constructor: create a single character token with type info
/// </summary>
/// <param name="chToken">Single character token value</param>
/// <param name="chType">Token Type information</param>
public Token(char chToken, CharType chType)
{
m_sToken = "";
m_sToken += chToken;
m_chType = chType;
}
/// <summary>
/// Create a random string in the desired range and options
/// </summary>
/// <param name="minLength">The minimum length of the string</param>
/// <param name="maxLength">The maximum length of the string</param>
/// <param name="charType">what type of characters will be used for the string</param>
/// <returns>A random string with length in the desired range and using the char type specified </returns>
public static string RandString(int minLength, int maxLength, CharType charType = CharType.WORDY_ONLY)
{
// Set to maximum possible length, will fail if min is greater than length
return(RandString(RandInt(minLength, maxLength), charType));
}
// constructors.
public CharDescriptor(int maskPos, CharType charType )
{
this.MaskPosition = maskPos;
this.CharType = charType;
}
// 비동기 함수를 호출합니다.
public static void AddChar(CharType charType, int tableIdx, Vector3 pos, Quaternion rot,
Transform parent, BaseChar baseChar)
{
m_gameHelper.StartCoroutine(AddCharAsync(charType, tableIdx, pos, rot, parent, baseChar));
}
/// <summary>
/// Initializes a new instance of the <see cref="MimeKit.Encodings.QEncoder"/> class.
/// </summary>
/// <remarks>
/// Creates a new rfc2047 quoted-printable encoder.
/// </remarks>
/// <param name="mode">The rfc2047 encoding mode.</param>
public QEncoder (QEncodeMode mode)
{
mask = mode == QEncodeMode.Phrase ? CharType.IsEncodedPhraseSafe : CharType.IsEncodedWordSafe;
}
/// <summary>
/// Takes fileName like annieSquare.dds, AnnieSquare.dds, annie_square_dds, ANNIE_SQUARE.dds and
/// outputs an array such as ["annie", "square", "dds"]. Non-alphanumeric values are deemed
/// as delimiters as well.
///
/// Delimiters:
/// non-alphanumerics
/// In the middle of two (and only two) uppercase characters that are followed by lowercase characters
/// Ie: "ACar" => ["A", "Car"]
/// On switch from uppercase string of 3+ to lowercase
/// Ie: "MANmode" => ["MAN", "mode"]
/// On switch from lowercase string to uppercase
/// Ie: "ExampleText" => ["Example", "Text"]
/// On switch from number to alphabet or vice versa
/// Ie: "IHave10Apples" => ["I", "Have", "10", "Apples"]
/// On reaching a non-alphanumeric value
/// Ie; "RADS_USER_Kernel.exe" => ["RADS", "USER", "Kernel", "exe"]
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static IEnumerable <string> ExtractFileNameTokens(string fileName)
{
StringBuilder sb = new StringBuilder();
// We start as if we were just at position -1
CharType lastlastCharType = CharType.Invalid;
CharType lastCharType = CharType.Invalid;
CharType charType = CharType.Invalid;
CharType nextCharType = fileName.Length >= 1 ? GetCharType(fileName[0]) : CharType.Invalid;
for (int i = 0; i < fileName.Length; i++)
{
lastlastCharType = lastCharType;
lastCharType = charType;
charType = nextCharType;
nextCharType = fileName.Length > i + 1 ? GetCharType(fileName[i + 1]) : CharType.Invalid;
char c = fileName[i];
//Console.WriteLine("Got char " + c + " current sb " + sb.ToString());
if (sb.Length == 0)
{
if (charType != CharType.Invalid)
{
sb.Append(c);
}
}
else
{
// Check delimit condition: In the middle of two (and only two) uppercase characters that are followed by lowercase characters
if (lastlastCharType != CharType.Uppercase && //e, current string builder = "A"
lastCharType == CharType.Uppercase && //A
charType == CharType.Uppercase && //C
nextCharType == CharType.Lowercase) //a
{
yield return(sb.ToString());
sb.Clear();
sb.Append(c);
}
else // Check delimit condition: On switch from uppercase string of 3+ to lowercase
if (lastlastCharType == CharType.Uppercase && //M, current string builder = "A"
lastCharType == CharType.Uppercase && //A
charType == CharType.Uppercase && //N
nextCharType == CharType.Lowercase) //m
{
sb.Append(c);
yield return(sb.ToString());
sb.Clear();
}
else // Check delimit condition: On switch from lowercase string to uppercase
if (charType == CharType.Lowercase && //n
nextCharType == CharType.Uppercase) //M
{
sb.Append(c);
yield return(sb.ToString());
sb.Clear();
}
else // Check delimit condition: On switch from number to alphabet or vice versa
if ((charType == CharType.Number && (nextCharType == CharType.Lowercase || nextCharType == CharType.Uppercase)) ||
(nextCharType == CharType.Number && (charType == CharType.Lowercase || charType == CharType.Uppercase)))
{
sb.Append(c);
yield return(sb.ToString());
sb.Clear();
}
else // Check delimit condition: On reaching a non-alphanumeric value
if (charType == CharType.Invalid)
{
if (sb.Length > 0)
{
yield return(sb.ToString());
}
sb.Clear();
}
else // Check delimit condition: On reaching a non-alphanumeric value
if (nextCharType == CharType.Invalid)
{
sb.Append(c);
yield return(sb.ToString());
sb.Clear();
}
else // Didn't get delimited!
{
// Console.WriteLine("Appending " + c + " " + lastlastCharType + " " + lastCharType + " " + charType + " " + nextCharType);
sb.Append(c);
}
}
} // for
if (sb.Length > 0)
{
yield return(sb.ToString());
}
yield break;
}
/// <summary>
/// Returns a random string with the specified length.
/// </summary>
/// <param name="random">The current instance.</param>
/// <param name="numChars">The length of the string.</param>
/// <param name="mode">The type of characters in the string.</param>
/// <returns>A random string with the specified length.</returns>
public static string NextString(this Random random, int numChars, CharType mode = CharType.AlphanumericAny)
{
#if DOTNET4
Contract.Requires(random != null);
#endif
char[] chars = new char[numChars];
for (int i = 0; i < numChars; ++i)
chars[i] = random.NextChar(mode);
return new string(chars);
}
public currentChar(char c)
{
val = c;
if (char.IsNumber(c)) {
currentCharTokenType = CharType.number;
}
if (c == '.') {
currentCharTokenType = CharType.period;
}
if (char.IsLetter(c) || c == '_')
currentCharTokenType = CharType.letter;
if (argumentSeperator.Contains(c))
currentCharTokenType = CharType.comma;
if (infixArithmeticOperations.Contains(c)) {
currentCharTokenType = CharType.infixArithmeticOp;
}
if (c == '(' || c == ')')
currentCharTokenType = CharType.brace;
if (c == ' ')
currentCharTokenType = CharType.whitespace;
if (c == '+' || c == '-')
currentCharTokenType = CharType.plusOrMinusSign;
if (suffixOperation.Contains(c))
currentCharTokenType = CharType.suffixOp;
}
