[JEDI.NET-commits] main/run Jedi.Math.Evaluation.Base.pas,1.1,1.2 Jedi.Math.Evaluation.Tokenization.pas,1.1,1.2 Jedi.Math.Evaluation.Tokens.pas,1.1,1.2 Jedi.Math.Resources.pas,1.1,1.2

[Marcel B. <jed...@us...>]

Update of /cvsroot/jedidotnet/main/run
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24559/main/run

Modified Files:
	Jedi.Math.Evaluation.Base.pas 
	Jedi.Math.Evaluation.Tokenization.pas 
	Jedi.Math.Evaluation.Tokens.pas Jedi.Math.Resources.pas 
Log Message:
Adapted to redesigned tokenization

Index: Jedi.Math.Evaluation.Base.pas
===================================================================
RCS file: /cvsroot/jedidotnet/main/run/Jedi.Math.Evaluation.Base.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** Jedi.Math.Evaluation.Base.pas	22 Aug 2005 17:27:08 -0000	1.1
--- Jedi.Math.Evaluation.Base.pas	25 Sep 2005 11:28:07 -0000	1.2
***************
*** 30,34 ****
    Jedi.System.SourceVersioning,
    Jedi.System.Strings,
!   Jedi.Text.Tokenization.Base,
    System.Collections,
    System.Globalization,
--- 30,35 ----
    Jedi.System.SourceVersioning,
    Jedi.System.Strings,
!   Jedi.Text.Tokenization.ProviderBase,
!   Jedi.Text.Tokenization.TokenBase,
    System.Collections,
    System.Globalization,
***************
*** 547,551 ****
    al: ArrayList;
    oldEndTypes: IList;
!   openParToken: IToken;
  begin
    al := ArrayList.Create;
--- 548,552 ----
    al: ArrayList;
    oldEndTypes: IList;
!   openParToken: Token;
  begin
    al := ArrayList.Create;
***************
*** 647,650 ****
--- 648,652 ----
    FProcessor := processor;
    FTokens := tokens;
+   FTokens.Next; // initialize to first token
  end;
  
***************
*** 666,670 ****
    namespace: Namespace): &Object;
  begin
!   Result := Parse(MathLexer.Tokenize(s, numberFormat), processor, namespace);
  end;
  
--- 668,672 ----
    namespace: Namespace): &Object;
  begin
!   Result := Parse(MathLexer.Tokenize(s, CultureInfo.InvariantCulture), processor, namespace);
  end;
  
***************
*** 833,837 ****
    // we have either reached the end of the token stream or one of the EndTypes tokens.
    // TODO: add check for correct end of parsing
!   if ((EndTypes = nil) or (EndTypes.Count = 0)) and not (Tokens.Current is EndOfTokenizerToken) then
      raise ParserException.Create('Operator or end of string expected.');
  end;
--- 835,839 ----
    // we have either reached the end of the token stream or one of the EndTypes tokens.
    // TODO: add check for correct end of parsing
!   if ((EndTypes = nil) or (EndTypes.Count = 0)) and not (Tokens.Current is TokenizerEndToken) then
      raise ParserException.Create('Operator or end of string expected.');
  end;
***************
*** 899,903 ****
  var
    tmpEndTypes: IList;
!   startToken: IToken;
    sym: Symbol;
  begin
--- 901,905 ----
  var
    tmpEndTypes: IList;
!   startToken: Token;
    sym: Symbol;
  begin

Index: Jedi.Math.Evaluation.Tokenization.pas
===================================================================
RCS file: /cvsroot/jedidotnet/main/run/Jedi.Math.Evaluation.Tokenization.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** Jedi.Math.Evaluation.Tokenization.pas	22 Aug 2005 17:27:08 -0000	1.1
--- Jedi.Math.Evaluation.Tokenization.pas	25 Sep 2005 11:28:07 -0000	1.2
***************
*** 30,36 ****
    Jedi.System.SourceVersioning,
    Jedi.System.Strings,
!   Jedi.Text.Tokenization.Base,
    System.Globalization,
!   System.IO;
  {$ENDREGION}
  
--- 30,40 ----
    Jedi.System.SourceVersioning,
    Jedi.System.Strings,
!   Jedi.Text.Tokenization.InputBase,
!   Jedi.Text.Tokenization.ProviderBase,
!   Jedi.Text.Tokenization.TokenBase,
!   Jedi.Text.Tokenization.TokenizerBase,
    System.Globalization,
!   System.IO,
!   System.Text;
  {$ENDREGION}
  
***************
*** 41,78 ****
      '$Revision$',
      '$Date$')]
!   MathLexer = class (&Object, ITokenProvider)
    {$REGION 'Constructors'}
    strict protected
!     constructor Create(tokenizer: ITokenizer);
    {$ENDREGION}
    {$REGION 'Data'}
    strict private
!     FFromStack: Boolean;
!     FList: ITokenProvider;
!     FTokenizer: ITokenizer;
    {$ENDREGION}
!   {$REGION 'ITokenProvider methods'}
    strict protected
!     function get_Current: IToken;
!     function Next: Boolean;
!     procedure RestorePointer;
!     procedure SavePointer;
    {$ENDREGION}
    {$REGION 'Static methods'}
    public
      class function Tokenize(s: string): ITokenProvider; overload; static;
!     class function Tokenize(s: string; formatProvider: IFormatProvider): ITokenProvider; overload; static;
  
      class function Tokenize(reader: TextReader): ITokenProvider; overload; static;
!     class function Tokenize(reader: TextReader; formatProvider: IFormatProvider): ITokenProvider; overload; static;
! 
!     class function Tokenize(reader: TextReader; ownsReader: Boolean): ITokenProvider; overload; static;
!     class function Tokenize(reader: TextReader; ownsReader: Boolean;
!       formatProvider: IFormatProvider): ITokenProvider; overload; static;
    {$ENDREGION}
    end;
  {$ENDREGION}
  
! {$REGION 'Math tokenizer'}
  type
    [JediSourceInfo(
--- 45,92 ----
      '$Revision$',
      '$Date$')]
!   MathLexer = class (Tokenizer)
    {$REGION 'Constructors'}
    strict protected
!     constructor Create(input: TokenizerInputProvider; culture: CultureInfo);
    {$ENDREGION}
    {$REGION 'Data'}
    strict private
!     FCulture: CultureInfo;
    {$ENDREGION}
!   {$REGION 'Individual tokenization methods'}
    strict protected
!     function CheckGreaterThanBasedTokens(out token: Token): Boolean;
!     function CheckLessThanBasedTokens(out token: Token): Boolean;
!     function CheckLogicalTokens(out token: Token): Boolean;
!     function CheckNumberToken(out token: Token): Boolean;
!     function CheckSingleCharTokens(out token: Token): Boolean;
!   {$ENDREGION}
!   {$REGION 'Overrides'}
!   strict protected
!     function InputToken: Token; override;
!   {$ENDREGION}
!   {$REGION 'Properties'}
!   public
!     property Culture: CultureInfo read FCulture;
    {$ENDREGION}
    {$REGION 'Static methods'}
    public
      class function Tokenize(s: string): ITokenProvider; overload; static;
!     class function Tokenize(s: string; culture: CultureInfo): ITokenProvider; overload; static;
  
      class function Tokenize(reader: TextReader): ITokenProvider; overload; static;
!     class function Tokenize(reader: TextReader; culture: CultureInfo): ITokenProvider; overload; static;
    {$ENDREGION}
    end;
  {$ENDREGION}
  
! implementation
! 
! {$REGION 'internal uses'}
! uses
!   Jedi.Math.Evaluation.Tokens;
! {$ENDREGION}
! 
! {$REGION 'Token skipper class'}
  type
    [JediSourceInfo(
***************
*** 80,194 ****
      '$Revision$',
      '$Date$')]
!   MathTokenizer = class (TextTokenizer)
!   {$REGION 'Constructors'}
!   protected
!     constructor Create(reader: TextReader; ownsReader: Boolean; formatProvider: IFormatProvider);
!   {$ENDREGION}
!   {$REGION 'Property accessors'}
    public
!     function get_FormatProvider: IFormatProvider;
    {$ENDREGION}
!   {$REGION 'Properties'}
!   public
!     property FormatProvider: IFormatProvider read get_FormatProvider;
    {$ENDREGION}
    end;
  {$ENDREGION}
  
- implementation
- 
- {$REGION 'internal uses'}
- uses
-   Jedi.Math.Evaluation.Tokens;
- {$ENDREGION}
- 
  {$REGION 'MathLexer'}
! constructor MathLexer.Create(tokenizer: ITokenizer);
  begin
!   inherited Create;
!   FTokenizer := tokenizer;
!   Next; // make sure we're properly intialized
  end;
  
! function MathLexer.get_Current: IToken;
  begin
!   if FFromStack then
!     Result := FList.Current
!   else
!     Result := ITokenProvider(FTokenizer).Current;
  end;
  
! function MathLexer.Next: Boolean;
  begin
!   if FFromStack then
!     Result := FList.Next
!   else
!     Result := False;
!   if not Result then
    begin
!     FFromStack := False;
!     Result := TokenProviderUtils.Next(ITokenProvider(FTokenizer), [TypeOf(WhiteSpaceToken), TypeOf(ControlToken)]);
    end;
-   if (FList <> nil) and not FFromStack and Result then
-     TokenList(FList).AddToken(ITokenProvider(FTokenizer).Current);
  end;
  
! procedure MathLexer.RestorePointer;
  begin
!   if (FList <> nil) and (TokenList(FList).CanRestorePointer) then
    begin
!     FList.RestorePointer;
!     FFromStack := True;
    end;
  end;
  
! procedure MathLexer.SavePointer;
  begin
!   if FList = nil then
!     FList := TokenList.Create;
!   FList.SavePointer;
  end;
  
  class function MathLexer.Tokenize(s: string): ITokenProvider;
  begin
!   Result := Tokenize(StringReader.Create(s), True, NumberFormatInfo.InvariantInfo);
  end;
  
! class function MathLexer.Tokenize(s: string; formatProvider: IFormatProvider): ITokenProvider;
  begin
!   Result := Tokenize(StringReader.Create(s), True, formatProvider);
  end;
  
  class function MathLexer.Tokenize(reader: TextReader): ITokenProvider;
  begin
!   Result := Tokenize(reader, True, NumberFormatInfo.InvariantInfo);
  end;
  
! class function MathLexer.Tokenize(reader: TextReader; formatProvider: IFormatProvider): ITokenProvider;
  begin
!   Result := Tokenize(reader, True, formatProvider);
  end;
  
! class function MathLexer.Tokenize(reader: TextReader; ownsReader: Boolean): ITokenProvider;
  begin
!   Result := Tokenize(reader, ownsReader, NumberFormatInfo.InvariantInfo);
  end;
  
! class function MathLexer.Tokenize(reader: TextReader; ownsReader: Boolean;
!   formatProvider: IFormatProvider): ITokenProvider;
  begin
!   Result := MathLexer.Create(MathTokenizer.Create(reader, ownsReader, formatProvider));
  end;
- {$ENDREGION}
  
! {$REGION 'MathTokenizer'}
! constructor MathTokenizer.Create(reader: TextReader; ownsReader: Boolean; formatProvider: IFormatProvider);
  begin
!   inherited Create(reader, ownsReader, MathTokenSet.Default, StringUtils.TabSet.Create(2), formatProvider);
  end;
  
! function MathTokenizer.get_FormatProvider: IFormatProvider;
  begin
!   Result := IFormatProvider(Context);
  end;
  {$ENDREGION}
--- 94,414 ----
      '$Revision$',
      '$Date$')]
!   TokenSkipper = class (&Object, ITokenProvider)
!   {$REGION 'TokenSkipper'}
    public
!     constructor Create(input: ITokenProvider);
    {$ENDREGION}
!   {$REGION 'Data'}
!   strict private
!     FInput: ITokenProvider;
!   {$ENDREGION}
!   {$REGION 'ITokenProvider methods'}
!   strict protected
!     procedure DiscardPointer;
!     function get_Current: Token;
!     function HasSavedPointer: Boolean;
!     function Next: Boolean;
!     procedure RestorePointer;
!     procedure SavePointer;
    {$ENDREGION}
    end;
  {$ENDREGION}
  
  {$REGION 'MathLexer'}
! constructor MathLexer.Create(input: TokenizerInputProvider; culture: CultureInfo);
  begin
!   inherited Create(nil, input);
!   FCulture := culture;
  end;
  
! function MathLexer.CheckGreaterThanBasedTokens(out token: Token): Boolean;
! var
!   line: Integer;
!   column: Integer;
  begin
!   Result := Input.Sequence.StartsWith('>');
!   if Result then
!   begin
!     line := Input.Line;
!     column := Input.Column;
!     if Input.Next then
!     begin
!       case Input.Sequence.Chars[0] of
!         '=':
!           begin
!             token := GreaterThanOrEqualToken.Create(context, line, column);
!             Input.Next;
!           end;
!         '>':
!           begin
!             token := RightShiftToken.Create(context, line, column);
!             Input.Next;
!           end;
!         else
!           token := GreaterThanToken.Create(context, line, column);
!       end;
!     end
!     else
!     begin
!       token := GreaterThanToken.Create(context, line, column);
!       Input.Next;
!     end;
!   end;
  end;
  
! function MathLexer.CheckLessThanBasedTokens(out token: Token): Boolean;
! var
!   line: Integer;
!   column: Integer;
  begin
!   Result := Input.Sequence.StartsWith('<');
!   if Result then
    begin
!     line := Input.Line;
!     column := Input.Column;
!     if Input.Next then
!     begin
!       case Input.Sequence.Chars[0] of
!         '=':
!           begin
!             token := LessThanOrEqualToken.Create(context, line, column);
!             Input.Next;
!           end;
!         '<':
!           begin
!             token := LeftShiftToken.Create(context, line, column);
!             Input.Next;
!           end;
!         '>':
!           begin
!             token := NotEqualToken.Create(context, line, column);
!             Input.Next;
!           end;
!         else
!           token := LessThanToken.Create(context, line, column);
!       end;
!     end
!     else
!     begin
!       token := LessThanToken.Create(context, line, column);
!       Input.Next;
!     end;
    end;
  end;
  
! function MathLexer.CheckLogicalTokens(out token: Token): Boolean;
! var
!   line: Integer;
!   column: Integer;
  begin
!   Result := Input.Sequence.Length > 0;
!   if Result then
    begin
!     line := Input.Line;
!     column := Input.Column;
!     case Input.Sequence.Chars[0] of
!       '^':
!         begin
!           token := XorToken.Create(Context, line, column);
!           Input.Next;
!         end;
!       '|':
!         begin
!           if Input.Next and (Input.Sequence.Chars[0] = '|') then
!           begin
!             token := ConditionalOrToken.Create(Context, line, column);
!             Input.Next;
!           end
!           else
!             token := OrToken.Create(Context, line, column);
!         end;
!       '&':
!         begin
!           if Input.Next and (Input.Sequence.Chars[0] = '&') then
!           begin
!             token := ConditionalAndToken.Create(Context, line, column);
!             Input.Next;
!           end
!           else
!             token := AndToken.Create(Context, line, column);
!         end;
!       else
!         Result := False;
!     end;
    end;
  end;
  
! function MathLexer.CheckNumberToken(out token: Token): Boolean;
! var
!   decSep: Char;
!   startLine: Integer;
!   startColumn: Integer;
!   hasDecSep: Boolean;
!   hasExp: Boolean;
!   hasExpSgn: Boolean;
!   numberLiteral: StringBuilder;
!   curChar: Char;
  begin
!   decSep := Culture.NumberFormat.NumberDecimalSeparator.Chars[0];
!   startLine := Input.Line;
!   startColumn := Input.Column;
!   hasDecSep := False;
!   hasExp := False;
!   hasExpSgn := False;
!   numberLiteral := StringBuilder.Create;
!   Result := False;
!   if Input.Sequence.Length > 0 then
!   begin
!     repeat
!       curChar := Input.Sequence.Chars[0];
!       if curChar = decSep then
!       begin
!         if not hasDecSep then
!         begin
!           hasDecSep := True;
!           if numberLiteral.Length = 0 then
!             numberLiteral.Append('0');
!           numberLiteral.Append(decSep);
!         end
!         else
!           Result := True;
!       end
!       else
!       if (curChar = 'e') or (curChar = 'E') then
!       begin
!         if numberLiteral.Length = 0 then
!           Result := True
!         else
!         begin
!           hasExp := True;
!           numberLiteral.Append('e');
!         end;
!       end
!       else
!       if (curChar = '+') or (curChar = '-') then
!       begin
!         if hasExp and not hasExpSgn then
!         begin
!           hasExpSgn := True;
!           numberLiteral.Append(curChar);
!         end
!         else
!           Result := True;
!       end
!       else
!       if (curChar >= '0') and (curChar <= '9') then
!       begin
!         hasExpSgn := hasExp;
!         numberLiteral.Append(curChar);
!       end
!       else
!         Result := True;
!     until Result or not Input.Next;
!     Result := numberLiteral.Length > 0;
!   end
!   else
!     Result := False;
!   if Result then
!     token := NumberToken.Create(Context, startLine, startColumn, System.Double.Parse(numberLiteral.ToString,
!       Culture.NumberFormat));
! end;
! 
! function MathLexer.CheckSingleCharTokens(out token: Token): Boolean;
! begin
!   Result := True;
!   case Input.Sequence.Chars[0] of
!     '!':
!       token := NotToken.Create(Context, Input.Line, Input.Column);
!     '=':
!       token := EqualToken.Create(Context, Input.Line, Input.Column);
!     '(':
!       token := OpenParenthesisToken.Create(Context, Input.Line, Input.Column);
!     ')':
!       token := CloseParenthesisToken.Create(Context, Input.Line, Input.Column);
!     ',':
!       token := CommaToken.Create(Context, Input.Line, Input.Column);
!     '?':
!       token := ConditionToken.Create(Context, Input.Line, Input.Column);
!     ':':
!       token := ConditionValueSeparatorToken.Create(Context, Input.Line, Input.Column);
!     '+':
!       token := PlusToken.Create(Context, Input.Line, Input.Column);
!     '-':
!       token := MinusToken.Create(Context, Input.Line, Input.Column);
!     '*':
!       token := AsterixToken.Create(Context, Input.Line, Input.Column);
!     '/':
!       token := ForwardSlashToken.Create(Context, Input.Line, Input.Column);
!     else
!       Result := False;
!   end;
!   if Result then
!     Input.Next;
! end;
! 
! function MathLexer.InputToken: Token;
! begin
!   CheckWhitespace(Result) or CheckNumberToken(Result) or CheckGreaterThanBasedTokens(Result) or
!     CheckLessThanBasedTokens(Result) or CheckLogicalTokens(Result) or CheckSingleCharTokens(Result);
  end;
  
  class function MathLexer.Tokenize(s: string): ITokenProvider;
  begin
!   Result := Tokenize(StringReader.Create(s), CultureInfo.InvariantCulture);
  end;
  
! class function MathLexer.Tokenize(s: string; culture: CultureInfo): ITokenProvider;
  begin
!   Result := Tokenize(StringReader.Create(s), culture);
  end;
  
  class function MathLexer.Tokenize(reader: TextReader): ITokenProvider;
  begin
!   Result := Tokenize(reader, CultureInfo.InvariantCulture);
  end;
  
! class function MathLexer.Tokenize(reader: TextReader; culture: CultureInfo): ITokenProvider;
  begin
!   Result := TokenSkipper.Create(MathLexer.Create(TokenizerInputProvider.FromReader(reader), culture));
  end;
+ {$ENDREGION}
  
! {$REGION 'TokenSkipper'}
! constructor TokenSkipper.Create(input: ITokenProvider);
  begin
!   inherited Create;
!   FInput := input;
  end;
  
! procedure TokenSkipper.DiscardPointer;
  begin
!   FInput.DiscardPointer;
  end;
  
! function TokenSkipper.get_Current: Token;
  begin
!   Result := FInput.Current;
  end;
  
! function TokenSkipper.HasSavedPointer: Boolean;
  begin
!   Result := FInput.HasSavedPointer;
! end;
! 
! function TokenSkipper.Next: Boolean;
! begin
!   repeat
!     Result := FInput.Next;
!   until not Result or not ((FInput.Current is WhitespaceToken) or (FInput.Current is ControlToken));
! end;
! 
! procedure TokenSkipper.RestorePointer;
! begin
!   FInput.RestorePointer;
! end;
! 
! procedure TokenSkipper.SavePointer;
! begin
!   FInput.SavePointer;
  end;
  {$ENDREGION}

Index: Jedi.Math.Evaluation.Tokens.pas
===================================================================
RCS file: /cvsroot/jedidotnet/main/run/Jedi.Math.Evaluation.Tokens.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** Jedi.Math.Evaluation.Tokens.pas	22 Aug 2005 17:27:08 -0000	1.1
--- Jedi.Math.Evaluation.Tokens.pas	25 Sep 2005 11:28:07 -0000	1.2
***************
*** 30,34 ****
    Jedi.Math.Evaluation.Tokenization,
    Jedi.System.SourceVersioning,
!   Jedi.Text.Tokenization.Base,
    System.Globalization;
  {$ENDREGION}
--- 30,35 ----
    Jedi.Math.Evaluation.Tokenization,
    Jedi.System.SourceVersioning,
!   Jedi.Text.Tokenization.TokenBase,
!   System.Collections,
[...2055 lines suppressed...]
  begin
    Result := '^';
--- 899,915 ----
  
  {$REGION 'ShiftToken'}
! constructor ShiftToken.Create(context: &Object; line, column: Integer);
  begin
!   inherited Create(context, line, column);
  end;
  {$ENDREGION}
  
  {$REGION 'XorToken'}
! constructor XorToken.Create(context: &Object; line, column: Integer);
  begin
!   inherited Create(context, line, column);
  end;
  
! function XorToken.get_Literal: string;
  begin
    Result := '^';

Index: Jedi.Math.Resources.pas
===================================================================
RCS file: /cvsroot/jedidotnet/main/run/Jedi.Math.Resources.pas,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** Jedi.Math.Resources.pas	22 Aug 2005 17:27:08 -0000	1.1
--- Jedi.Math.Resources.pas	25 Sep 2005 11:28:07 -0000	1.2
***************
*** 29,33 ****
  uses
    Jedi.System.SourceVersioning,
!   Jedi.Text.Tokenization.Base,
    System.Globalization,
    System.Resources;
--- 29,33 ----
  uses
    Jedi.System.SourceVersioning,
!   Jedi.Text.Tokenization.TokenBase,
    System.Globalization,
    System.Resources;
***************
*** 72,93 ****
    {$REGION 'Helper methods'}
    strict protected
!     class function ParserExpectedMsg(culture: CultureInfo; currentToken: IToken; expectedId: string;
        args: ObjectArray): string; static;
    {$ENDREGION}
    {$REGION 'Parser exception messages'}
    public
!     class function ParserExpectedClosingParenthesis(currentToken, openParenthesis: IToken): string; overload; static;
      class function ParserExpectedClosingParenthesis(culture: CultureInfo; currentToken,
!       openParenthesis: IToken): string; overload; static;
!     class function ParserExpectedConditionalValueSeparator(currentToken: IToken): string; overload; static;
      class function ParserExpectedConditionalValueSeparator(culture: CultureInfo;
!       currentToken: IToken): string; overload; static;
!     class function ParserExpectedArgumentSeparator(currentToken: IToken): string; overload; static;
      class function ParserExpectedArgumentSeparator(culture: CultureInfo;
!       currentToken: IToken): string; overload; static;
!     class function ParserExpectedPrimary(currentToken: IToken): string; overload; static;
!     class function ParserExpectedPrimary(culture: CultureInfo; currentToken: IToken): string; overload; static;
!     class function ParserUnknownIdentifier(currentToken: IToken): string; overload; static;
!     class function ParserUnknownIdentifier(culture: CultureInfo; currentToken: IToken): string; overload; static;
    {$ENDREGION}
    end;
--- 72,93 ----
    {$REGION 'Helper methods'}
    strict protected
!     class function ParserExpectedMsg(culture: CultureInfo; currentToken: Token; expectedId: string;
        args: ObjectArray): string; static;
    {$ENDREGION}
    {$REGION 'Parser exception messages'}
    public
!     class function ParserExpectedClosingParenthesis(currentToken, openParenthesis: Token): string; overload; static;
      class function ParserExpectedClosingParenthesis(culture: CultureInfo; currentToken,
!       openParenthesis: Token): string; overload; static;
!     class function ParserExpectedConditionalValueSeparator(currentToken: Token): string; overload; static;
      class function ParserExpectedConditionalValueSeparator(culture: CultureInfo;
!       currentToken: Token): string; overload; static;
!     class function ParserExpectedArgumentSeparator(currentToken: Token): string; overload; static;
      class function ParserExpectedArgumentSeparator(culture: CultureInfo;
!       currentToken: Token): string; overload; static;
!     class function ParserExpectedPrimary(currentToken: Token): string; overload; static;
!     class function ParserExpectedPrimary(culture: CultureInfo; currentToken: Token): string; overload; static;
!     class function ParserUnknownIdentifier(currentToken: Token): string; overload; static;
!     class function ParserUnknownIdentifier(culture: CultureInfo; currentToken: Token): string; overload; static;
    {$ENDREGION}
    end;
***************
*** 159,163 ****
  end;
  
! class function Resources.ParserExpectedClosingParenthesis(currentToken, openParenthesis: IToken): string;
  begin
    Result := ParserExpectedClosingParenthesis(CultureInfo.CurrentCulture, currentToken, openParenthesis);
--- 159,163 ----
  end;
  
! class function Resources.ParserExpectedClosingParenthesis(currentToken, openParenthesis: Token): string;
  begin
    Result := ParserExpectedClosingParenthesis(CultureInfo.CurrentCulture, currentToken, openParenthesis);
***************
*** 165,169 ****
  
  class function Resources.ParserExpectedClosingParenthesis(culture: CultureInfo; currentToken,
!   openParenthesis: IToken): string;
  begin
    Result := GetResourceString(culture, 'ParserExpBase', GetResourceString(culture, 'ParserExpClosePar',
--- 165,169 ----
  
  class function Resources.ParserExpectedClosingParenthesis(culture: CultureInfo; currentToken,
!   openParenthesis: Token): string;
  begin
    Result := GetResourceString(culture, 'ParserExpBase', GetResourceString(culture, 'ParserExpClosePar',
***************
*** 171,195 ****
  end;
  
! class function Resources.ParserExpectedConditionalValueSeparator(currentToken: IToken): string;
  begin
    Result := ParserExpectedConditionalValueSeparator(CultureInfo.CurrentCulture, currentToken);
  end;
  
! class function Resources.ParserExpectedConditionalValueSeparator(culture: CultureInfo; currentToken: IToken): string;
  begin
    Result := ParserExpectedMsg(culture, currentToken, 'ParserExpCondValueSep', nil);
  end;
  
! class function Resources.ParserExpectedArgumentSeparator(currentToken: IToken): string;
  begin
    Result := ParserExpectedArgumentSeparator(CultureInfo.CurrentCulture, currentToken);
  end;
  
! class function Resources.ParserExpectedArgumentSeparator(culture: CultureInfo; currentToken: IToken): string;
  begin
    Result := ParserExpectedMsg(culture, currentToken, 'parserExpArgSep', nil);
  end;
  
! class function Resources.ParserExpectedMsg(culture: CultureInfo; currentToken: IToken; expectedId: string;
    args: ObjectArray): string;
  begin
--- 171,195 ----
  end;
  
! class function Resources.ParserExpectedConditionalValueSeparator(currentToken: Token): string;
  begin
    Result := ParserExpectedConditionalValueSeparator(CultureInfo.CurrentCulture, currentToken);
  end;
  
! class function Resources.ParserExpectedConditionalValueSeparator(culture: CultureInfo; currentToken: Token): string;
  begin
    Result := ParserExpectedMsg(culture, currentToken, 'ParserExpCondValueSep', nil);
  end;
  
! class function Resources.ParserExpectedArgumentSeparator(currentToken: Token): string;
  begin
    Result := ParserExpectedArgumentSeparator(CultureInfo.CurrentCulture, currentToken);
  end;
  
! class function Resources.ParserExpectedArgumentSeparator(culture: CultureInfo; currentToken: Token): string;
  begin
    Result := ParserExpectedMsg(culture, currentToken, 'parserExpArgSep', nil);
  end;
  
! class function Resources.ParserExpectedMsg(culture: CultureInfo; currentToken: Token; expectedId: string;
    args: ObjectArray): string;
  begin
***************
*** 201,220 ****
  end;
  
! class function Resources.ParserExpectedPrimary(currentToken: IToken): string;
  begin
    Result := ParserExpectedPrimary(CultureInfo.CurrentCulture, currentToken);
  end;
  
! class function Resources.ParserExpectedPrimary(culture: CultureInfo; currentToken: IToken): string;
  begin
    Result := ParserExpectedMsg(culture, currentToken, 'ParserExpPrimary', nil);
  end;
  
! class function Resources.ParserUnknownIdentifier(currentToken: IToken): string;
  begin
    Result := ParserUnknownIdentifier(CultureInfo.InvariantCulture, currentToken);
  end;
  
! class function Resources.ParserUnknownIdentifier(culture: CultureInfo; currentToken: IToken): string;
  begin
    Result := GetResourceString(culture, 'ParserUnknownIdent', currentToken.Literal, currentToken.Line,
--- 201,220 ----
  end;
  
! class function Resources.ParserExpectedPrimary(currentToken: Token): string;
  begin
    Result := ParserExpectedPrimary(CultureInfo.CurrentCulture, currentToken);
  end;
  
! class function Resources.ParserExpectedPrimary(culture: CultureInfo; currentToken: Token): string;
  begin
    Result := ParserExpectedMsg(culture, currentToken, 'ParserExpPrimary', nil);
  end;
  
! class function Resources.ParserUnknownIdentifier(currentToken: Token): string;
  begin
    Result := ParserUnknownIdentifier(CultureInfo.InvariantCulture, currentToken);
  end;
  
! class function Resources.ParserUnknownIdentifier(culture: CultureInfo; currentToken: Token): string;
  begin
    Result := GetResourceString(culture, 'ParserUnknownIdent', currentToken.Literal, currentToken.Line,