private void ParseModeLine(ITokenizer tokenizer, Dictionary <string, string> result)
{
// we expect it to look something like this:
// vim: noai:ts=4:sw=4
// vim: set noai ts=4 sw=4:
if (!tokenizer.Next())
{
return;
}
String tool = tokenizer.Token;
if (!tokenizer.Next())
{
return;
}
if (tokenizer.Token != ":")
{
return; // not what we expect
}
if (!tokenizer.Next())
{
return;
}
if (tokenizer.Token == "set")
{
tokenizer.Next();
ParseListNoDelimiter(tokenizer, result);
}
else
{
ParseList(tokenizer, result, ":");
}
}
public new static Funkcja Parsuj(ITokenizer tokenizer)
{
Funkcja funkcja = new Funkcja();
if (tokenizer.Next() == HCPSToken.Word)
{
funkcja.Nazwa = tokenizer.Value;
List <Argument> argumenty = new List <Argument>();
// odczytanie nazw argumentów
if (tokenizer.Next() == HCPSToken.ParenthesisOpen)
{
do
{
Argument a = Argument.Parsuj(tokenizer);
if (a != null)
{
argumenty.Add(a);
}
} while (tokenizer.LastToken != HCPSToken.ParenthesisClose);
funkcja.argumenty = argumenty.ToArray();
funkcja.Check();
return(funkcja);
}
else
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectFunctionInvocation), tokenizer.GetPosition(tokenizer.Position)));
}
}
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectFunctionInvocation), tokenizer.GetPosition(tokenizer.Position)));
}
public IToken Next(IScanner scanner)
{
if (scanner.MoveNext())
{
var current = scanner.Current;
if (current.IsSpaceCharacter())
{
return(new CharacterToken(TokenType.Space, current, scanner.Position));
}
else if (current.IsNameStart())
{
return(ScanName(scanner));
}
else if (current.IsDigit())
{
return(_number.Next(scanner));
}
else
{
return(ScanSymbol(scanner));
}
}
return(new EndToken(scanner.Position));
}
public new static ZmianaZmiennej Parsuj(ITokenizer tokenizer)
{
ZmianaZmiennej zdarzenie = new ZmianaZmiennej();
if (tokenizer.Next() == HCPSToken.Variable)
{
zdarzenie.Zmienna = new ZmiennaNieistniejaca()
{
Nazwa = tokenizer.Value
};
if (tokenizer.Next() == HCPSToken.BlockBegin)
{
zdarzenie.Akcje = Akcje.Parsuj(tokenizer);
zdarzenie.Check();
}
else
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectEventDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
}
else
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectEventDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
return(zdarzenie);
}
private void ParseList(ITokenizer tokenizer, Dictionary <string, string> result, string delimiter)
{
while (!tokenizer.AtEnd)
{
String p1 = tokenizer.Token;
tokenizer.Next();
String p2 = tokenizer.Token;
if (p2 == "=")
{
tokenizer.Next();
String p3 = tokenizer.Token;
result[p1] = p3;
tokenizer.Next();
}
else
{
result[p1] = "";
}
if (tokenizer.Token != delimiter)
{
break;
}
// consume the delimiter
tokenizer.Next();
}
}
public new static Zmienna Parsuj(ITokenizer tokenizer)
{
Zmienna zmienna = new Zmienna();
HCPSToken token = tokenizer.Next();
if (token == HCPSToken.Variable)
{
zmienna.Nazwa = tokenizer.Value;
if (tokenizer.Next() == HCPSToken.BlockBegin)
{
while ((token = tokenizer.Next()) != HCPSToken.BlockEnd)
{
if (token == HCPSToken.Comment)
{
continue;
}
SimpleAssignment sa = tokenizer.ReadSimpleAssignment(token, tokenizer.Value);
if (sa == null || sa.Left == null || sa.Right == null)
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectVariableDefinition), zmienna.Nazwa));
}
switch (sa.Left.ToLowerInvariant())
{
case "module":
zmienna.Modul = sa.Right;
break;
case "id":
zmienna.ID = sa.Right;
break;
case "direct":
zmienna.Kierunek = Utils.KierunekZmiennejFromString(sa.Right);
break;
case "type":
zmienna.Typ = Utils.VariableTypeFromString(sa.Right);
break;
case "value":
zmienna._Wartosc = zmienna._WartoscPoczatkowa = sa.Right;
break;
case "function":
zmienna._funkcjaNazwa = sa.Right;
break;
default:
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.InvalidVariableDefinitionProperty), sa.Left, zmienna.Nazwa, tokenizer.GetPosition(tokenizer.Position)));
}
}
zmienna.Check();
return(zmienna);
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.CannotParseVariableDefinition), zmienna.Nazwa));
}
}
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.InvalidVariableDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
public new static DefinicjaFunkcji Parsuj(ITokenizer tokenizer)
{
DefinicjaFunkcji funkcja = new DefinicjaFunkcji();
if (tokenizer.Next() == HCPSToken.Word)
{
funkcja.Nazwa = tokenizer.Value;
// odczytanie nazw argumentów
if (tokenizer.Next() == HCPSToken.ParenthesisOpen)
{
List <ZmiennaParametr> argumenty = new List <ZmiennaParametr>();
HCPSToken token = HCPSToken.Unknown;
while ((token = tokenizer.Next()) == HCPSToken.Variable)
{
argumenty.Add(new ZmiennaParametr()
{
Nazwa = tokenizer.Value
});
if (tokenizer.Next() != HCPSToken.CommaSeparator)
{
tokenizer.Back();
}
}
funkcja.argumenty = argumenty.ToArray();
if (token != HCPSToken.ParenthesisClose)
{
throw new Exception(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectFunctionDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
}
else
{
throw new Exception(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectFunctionDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
if (tokenizer.Next() == HCPSToken.BlockBegin)
{
List <Akcje> akcje = new List <Akcje>();
do
{
Akcje a = Akcje.Parsuj(tokenizer);
if (a != null)
{
akcje.Add(a);
}
}while (tokenizer.LastToken != HCPSToken.BlockEnd);
funkcja.akcje = akcje.ToArray();
funkcja.Check();
return(funkcja);
}
}
throw new Exception(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectFunctionDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
public new static ZmianaZmiennych Parsuj(ITokenizer tokenizer)
{
ZmianaZmiennych zdarzenie = new ZmianaZmiennych();
HCPSToken token = tokenizer.Next();
if (token == HCPSToken.Number)
{
if (!int.TryParse(tokenizer.Value, out zdarzenie.Minimum))
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectNumberForVariablesChangeEvent), tokenizer.Value));
}
token = tokenizer.Next();
}
List <Zmienna> zmienne = new List <Zmienna>();
while (token == HCPSToken.Variable)
{
Zmienna z = new ZmiennaNieistniejaca()
{
Nazwa = tokenizer.Value
};
// sprawdzenie czy ta zmienna nie istnieje już na liście
for (int i = 0; i < zmienne.Count; i++)
{
if (zmienne[i].Nazwa == z.Nazwa)
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.RepeatedVariableInVariablesChangeEvent), z.Nazwa));
}
}
zmienne.Add(z);
token = tokenizer.Next();
}
if (zmienne.Count < 1)
{
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.VariablesChangeEventRequireAtLeastTwoVariables));
}
zdarzenie.Zmienne = zmienne.ToArray();
if (token == HCPSToken.BlockBegin)
{
zdarzenie.Akcje = Akcje.Parsuj(tokenizer);
zdarzenie.Check();
}
else
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectVariablesChangeEventDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
return(zdarzenie);
}
public new static Stala Parsuj(ITokenizer tokenizer)
{
Stala stala = new Stala();
HCPSToken token = tokenizer.Next();
if (token == HCPSToken.Variable)
{
stala.Nazwa = tokenizer.Value;
if (tokenizer.Next() == HCPSToken.BlockBegin)
{
while ((token = tokenizer.Next()) != HCPSToken.BlockEnd)
{
SimpleAssignment sa = tokenizer.ReadSimpleAssignment(token, tokenizer.Value);
if (sa == null || sa.Left == null || sa.Right == null)
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectConstantDefinition), stala.Nazwa));
}
switch (sa.Left.ToLowerInvariant())
{
case "type":
stala.Typ = Utils.VariableTypeFromString(sa.Right);
switch (stala.Typ)
{
case HomeSimCockpitSDK.VariableType.Bool:
case HomeSimCockpitSDK.VariableType.Int:
case HomeSimCockpitSDK.VariableType.Double:
case HomeSimCockpitSDK.VariableType.String:
break;
default:
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.InvalidConstantType), Utils.VariableTypeToString(stala.Typ), stala.Nazwa));
}
break;
case "value":
stala._Wartosc = sa.Right;
break;
default:
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.InvalidConstantDefinitionProperty), sa.Left, stala.Nazwa, tokenizer.GetPosition(tokenizer.Position)));
}
}
stala.Check();
return(stala);
}
}
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.CannotParseConstantDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
public new static Jezeli Parsuj(ITokenizer tokenizer)
{
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = Wyrazenie.Parsuj(tokenizer);
HCPSToken token = tokenizer.Next();
if (__tokenyOperatorow.Contains(token))
{
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
jezeli.Check();
return(jezeli);
}
else
{
if (token == HCPSToken.ParenthesisClose)
{
tokenizer.Back();
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogicznyTyp.Prawdziwy
};
jezeli.Check();
return(jezeli);
}
}
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.IncorrectIfStatementDefinition));
}
private void Collect()
{
var tokens = new List <IToken>();
var open = 1;
while (open > 0)
{
var token = _tokenizer.Next(_scanner);
switch (token.Type)
{
case TokenType.OpenScope:
open++;
break;
case TokenType.CloseScope:
open--;
break;
case TokenType.End:
open = 0;
break;
}
tokens.Add(token);
}
tokens.RemoveAt(tokens.Count - 1);
tokens.Add(new EndToken(_scanner.Position));
_parts.Add(tokens);
}
private void ParseListNoDelimiter(ITokenizer tokenizer, Dictionary<string, string> result)
{
while ( !tokenizer.AtEnd && tokenizer.Token != ":" ) {
String p1 = tokenizer.Token;
tokenizer.Next();
String p2 = tokenizer.Token;
if ( p2 == "=" ) {
tokenizer.Next();
String p3 = tokenizer.Token;
result[p1] = p3;
tokenizer.Next();
} else {
result[p1] = "";
// tokenizer.Token contains the next option we want to process
// so don't consume it
}
}
}
private void ParseModeLine(ITokenizer tokenizer, Dictionary<string, string> result)
{
// we expect it to look something like this:
// vim: noai:ts=4:sw=4
// vim: set noai ts=4 sw=4:
if ( !tokenizer.Next() ) return;
String tool = tokenizer.Token;
if ( !tokenizer.Next() ) return;
if ( tokenizer.Token != ":" ) return; // not what we expect
if ( !tokenizer.Next() ) return;
if ( tokenizer.Token == "set" ) {
tokenizer.Next();
ParseListNoDelimiter(tokenizer, result);
} else {
ParseList(tokenizer, result, ":");
}
}
private void ParseList(ITokenizer tokenizer, Dictionary<string, string> result, string delimiter)
{
while ( !tokenizer.AtEnd ) {
String p1 = tokenizer.Token;
tokenizer.Next();
String p2 = tokenizer.Token;
if ( p2 == "=" ) {
tokenizer.Next();
String p3 = tokenizer.Token;
result[p1] = p3;
tokenizer.Next();
} else {
result[p1] = "";
}
if ( tokenizer.Token != delimiter ) break;
// consume the delimiter
tokenizer.Next();
}
}
public static IncludeStatement Parsuj(ITokenizer tokenizer)
{
IncludeStatement result = new IncludeStatement();
HCPSToken token = tokenizer.Next();
if (token == HCPSToken.BlockBegin)
{
while ((token = tokenizer.Next()) != HCPSToken.BlockEnd)
{
if (token == HCPSToken.Comment)
{
continue;
}
SimpleAssignment sa = tokenizer.ReadSimpleAssignment(token, tokenizer.Value);
if (sa == null || sa.Left == null || sa.Right == null)
{
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.IncorrectIncludeDefinition));
}
switch (sa.Left.ToLowerInvariant())
{
case "file":
result.FilePath = sa.Right;
break;
case "script":
result.ScriptName = sa.Right;
break;
default:
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.InvalidIncludePropertyDefinition), sa.Left, tokenizer.GetPosition(tokenizer.Position)));
}
}
// sprawdzenie czy file i script są różne od null i ""
if (string.IsNullOrEmpty(result.FilePath) || string.IsNullOrEmpty(result.ScriptName))
{
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.MissingFileOrScriptPropertyInIncludeDefinition));
}
return(result);
}
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.CannotReadIncludeDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
private void ParseListNoDelimiter(ITokenizer tokenizer, Dictionary <string, string> result)
{
while (!tokenizer.AtEnd && tokenizer.Token != ":")
{
String p1 = tokenizer.Token;
tokenizer.Next();
String p2 = tokenizer.Token;
if (p2 == "=")
{
tokenizer.Next();
String p3 = tokenizer.Token;
result[p1] = p3;
tokenizer.Next();
}
else
{
result[p1] = "";
// tokenizer.Token contains the next option we want to process
// so don't consume it
}
}
}
/// <summary>
/// Main method invoked by the compiler to request tokens from a stream.
/// </summary>
/// <returns>Each token found in your code.</returns>
/// <param name="stream">Stream containing Lizzie code. Notice, this method does not claim ownership over
/// your stream, and you are responsible for correctly disposing it yourself.</param>
/// <param name="encoding">Encoding to use for stream, if not given this defaults to UTF8.</param>
public IEnumerable <string> Tokenize(Stream stream, Encoding encoding = null)
{
// Notice! We do NOT take ownership over stream!
StreamReader reader = new StreamReader(stream, encoding ?? Encoding.UTF8, true, 1024);
while (true)
{
var token = _tokenizer.Next(reader);
if (token == null)
{
break;
}
yield return(token);
}
yield break;
}
public new static Argument Parsuj(ITokenizer tokenizer)
{
Argument argument = new Argument();
argument.argument = Wyrazenie.Parsuj(tokenizer);
if (argument.argument == null)
{
return(null);
}
HCPSToken token = tokenizer.Next();
if (token != HCPSToken.CommaSeparator && token != HCPSToken.ParenthesisClose)
{
tokenizer.Back();
}
argument.Check();
return(argument);
}
/// <summary>
/// Read parse trees from a Reader.
/// </summary>
/// <param name="input">The Reader</param>
/// <param name="tf">TreeFactory -- factory to create some kind of Tree</param>
/// <param name="tn">the method of normalizing trees</param>
/// <param name="st">Tokenizer that divides up Reader</param>
public PennTreeReader(TextReader input, ITreeFactory tf, TreeNormalizer tn, ITokenizer <string> st)
{
reader = input;
treeFactory = tf;
treeNormalizer = tn;
tokenizer = st;
// check for whacked out headers still present in Brown corpus in Treebank 3
string first = (st.HasNext() ? st.Peek() : null);
if (first != null && first.StartsWith("*x*x*x"))
{
int foundCount = 0;
while (foundCount < 4 && st.HasNext())
{
first = st.Next();
if (first != null && first.StartsWith("*x*x*x"))
{
foundCount++;
}
}
}
}
public new static Warunek Parsuj(ITokenizer tokenizer)
{
Warunek warunek = new Warunek();
if (tokenizer.Next() == HCPSToken.ParenthesisOpen)
{
warunek.Jezeli = Jezeli.Parsuj(tokenizer);
if (tokenizer.Next() == HCPSToken.ParenthesisClose && tokenizer.Next() == HCPSToken.BlockBegin)
{
warunek.Prawda = Akcje.Parsuj(tokenizer);
if (tokenizer.Next() == HCPSToken.Word && tokenizer.Value == "else")
{
if (tokenizer.Next() == HCPSToken.BlockBegin)
{
warunek.Falsz = Akcje.Parsuj(tokenizer);
if (tokenizer.LastToken != HCPSToken.BlockEnd)
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectElseStatementInIfStatementDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
if (tokenizer.Next() != HCPSToken.BlockEnd)
{
tokenizer.Back();
}
}
else
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.IncorrectElseStatementInIfStatementDefinition), tokenizer.GetPosition(tokenizer.Position)));
}
}
else
{
if (tokenizer.LastToken != HCPSToken.InstructionEnd && tokenizer.LastToken != HCPSToken.BlockEnd)
{
tokenizer.Back();
}
}
warunek.Check();
return(warunek);
}
}
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.IncorrectIfStatementDefinition));
}
/// <summary>
/// Read parse trees from a Reader.
/// </summary>
/// <param name="input">The Reader</param>
/// <param name="tf">TreeFactory -- factory to create some kind of Tree</param>
/// <param name="tn">the method of normalizing trees</param>
/// <param name="st">Tokenizer that divides up Reader</param>
public PennTreeReader(TextReader input, ITreeFactory tf, TreeNormalizer tn, ITokenizer<string> st)
{
reader = input;
treeFactory = tf;
treeNormalizer = tn;
tokenizer = st;
// check for whacked out headers still present in Brown corpus in Treebank 3
string first = (st.HasNext() ? st.Peek() : null);
if (first != null && first.StartsWith("*x*x*x"))
{
int foundCount = 0;
while (foundCount < 4 && st.HasNext())
{
first = st.Next();
if (first != null && first.StartsWith("*x*x*x"))
{
foundCount++;
}
}
}
}
public new static Wyrazenie Parsuj(ITokenizer tokenizer)
{
long position = tokenizer.Position;
HCPSToken token = tokenizer.Next();
while (token == HCPSToken.Comment)
{
position = tokenizer.Position;
token = tokenizer.Next();
}
switch (token)
{
case HCPSToken.Word:
{
switch (tokenizer.Value)
{
case "if":
return(Warunek.Parsuj(tokenizer));
case "null":
{
Stala stala = new Stala()
{
_Wartosc = null
};
token = tokenizer.Next();
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
{
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = stala;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
return(jezeli);
default:
tokenizer.Back();
break;
}
tokenizer.Back();
return(stala);
}
case HCPSToken.InstructionEnd:
case HCPSToken.ParenthesisClose:
case HCPSToken.CommaSeparator:
{
tokenizer.Back();
break;
}
}
return(stala);
}
case "return":
{
Return r = new Return();
r.Wyrazenie = Wyrazenie.Parsuj(tokenizer);
return(r);
}
default:
{
string wartosc = tokenizer.Value;
token = tokenizer.Next();
if (token == HCPSToken.Colon)
{
token = tokenizer.Next();
if (token != HCPSToken.Word)
{
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.InvalidTokenAfterModuleName), token, wartosc));
}
tokenizer.Position = position;
FunkcjaModulu funkcjaModulu = FunkcjaModulu.Parsuj(tokenizer);
token = tokenizer.Next();
switch (token)
{
case HCPSToken.Assignment:
{
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.OperationNotAllowed));
}
case HCPSToken.InstructionEnd:
case HCPSToken.ParenthesisClose:
case HCPSToken.CommaSeparator:
{
tokenizer.Back();
return(funkcjaModulu);
}
case HCPSToken.Addition:
case HCPSToken.Division:
case HCPSToken.Multiplication:
case HCPSToken.Subtraction:
case HCPSToken.And:
case HCPSToken.Or:
case HCPSToken.Modulo:
{
Wyrazenie w = Wyrazenie.Parsuj(tokenizer);
if (w is Operacja)
{
Wyrazenie w1 = ((Operacja)w).OperandLewy;
((Operacja)w).OperandLewy = new Operacja()
{
OperandLewy = funkcjaModulu,
OperandPrawy = w1,
Operator = Operacja.TokenNaOperator(token)
};
return(w);
}
else
{
Operacja operacja = new Operacja()
{
OperandLewy = funkcjaModulu,
OperandPrawy = w,
Operator = Operacja.TokenNaOperator(token)
};
return(operacja);
}
}
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
{
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = funkcjaModulu;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
return(jezeli);
default:
tokenizer.Back();
break;
}
tokenizer.Back();
return(funkcjaModulu);
}
}
return(funkcjaModulu);
}
else
if (token == HCPSToken.ParenthesisOpen)
{
// jakaś funkcja
tokenizer.Position = position;
Funkcja funkcja = Funkcja.Parsuj(tokenizer);
token = tokenizer.Next();
switch (token)
{
case HCPSToken.Assignment:
{
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.OperationNotAllowed));
}
case HCPSToken.InstructionEnd:
case HCPSToken.ParenthesisClose:
case HCPSToken.CommaSeparator:
{
tokenizer.Back();
return(funkcja);
}
case HCPSToken.Addition:
case HCPSToken.Division:
case HCPSToken.Multiplication:
case HCPSToken.Subtraction:
case HCPSToken.And:
case HCPSToken.Or:
case HCPSToken.Modulo:
{
Wyrazenie w = Wyrazenie.Parsuj(tokenizer);
if (w is Operacja)
{
Wyrazenie w1 = ((Operacja)w).OperandLewy;
((Operacja)w).OperandLewy = new Operacja()
{
OperandLewy = funkcja,
OperandPrawy = w1,
Operator = Operacja.TokenNaOperator(token)
};
return(w);
}
else
{
Operacja operacja = new Operacja()
{
OperandLewy = funkcja,
OperandPrawy = w,
Operator = Operacja.TokenNaOperator(token)
};
return(operacja);
}
}
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
{
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = funkcja;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
return(jezeli);
default:
tokenizer.Back();
break;
}
tokenizer.Back();
return(funkcja);
}
}
return(funkcja);
}
else
{
tokenizer.Back();
}
Stala stala = null;
bool vb = false;
if (Stala.IsBool(wartosc, out vb))
{
stala = new Stala()
{
_Wartosc = vb,
Typ = HomeSimCockpitSDK.VariableType.Bool
};
}
if (stala != null)
{
token = tokenizer.Next();
switch (token)
{
case HCPSToken.Assignment:
{
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.OperationNotAllowed));
}
case HCPSToken.InstructionEnd:
case HCPSToken.ParenthesisClose:
case HCPSToken.CommaSeparator:
{
tokenizer.Back();
return(stala);
}
case HCPSToken.Addition:
case HCPSToken.Division:
case HCPSToken.Multiplication:
case HCPSToken.Subtraction:
case HCPSToken.And:
case HCPSToken.Or:
case HCPSToken.Modulo:
{
Wyrazenie w = Wyrazenie.Parsuj(tokenizer);
if (w is Operacja)
{
Wyrazenie w1 = ((Operacja)w).OperandLewy;
((Operacja)w).OperandLewy = new Operacja()
{
OperandLewy = stala,
OperandPrawy = w1,
Operator = Operacja.TokenNaOperator(token)
};
return(w);
}
else
{
Operacja operacja = new Operacja()
{
OperandLewy = stala,
OperandPrawy = w,
Operator = Operacja.TokenNaOperator(token)
};
return(operacja);
}
}
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
{
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = stala;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
return(jezeli);
default:
tokenizer.Back();
break;
}
tokenizer.Back();
return(stala);
}
}
}
break;
}
}
break;
}
case HCPSToken.Number:
{
Stala stala = null;
double vd = 0;
int vi = 0;
// sprawdzenie czy to liczba double
if (Stala.IsDouble(tokenizer.Value, out vd))
{
stala = new Stala()
{
_Wartosc = vd,
Typ = HomeSimCockpitSDK.VariableType.Double
};
}
// sprawdzenie czy to liczba int
else if (Stala.IsInt(tokenizer.Value, out vi))
{
stala = new Stala()
{
_Wartosc = vi,
Typ = HomeSimCockpitSDK.VariableType.Int
};
}
if (stala != null)
{
token = tokenizer.Next();
switch (token)
{
case HCPSToken.Assignment:
{
throw new ParsingScriptException(UI.Language.Instance.GetString(UI.UIStrings.OperationNotAllowed));
}
case HCPSToken.InstructionEnd:
case HCPSToken.ParenthesisClose:
case HCPSToken.CommaSeparator:
{
tokenizer.Back();
return(stala);
}
case HCPSToken.Addition:
case HCPSToken.Division:
case HCPSToken.Multiplication:
case HCPSToken.Subtraction:
case HCPSToken.And:
case HCPSToken.Or:
case HCPSToken.Modulo:
{
Wyrazenie w = Wyrazenie.Parsuj(tokenizer);
if (w is Operacja)
{
Wyrazenie w1 = ((Operacja)w).OperandLewy;
OperatorDwuargumentowyTyp oper = Operacja.TokenNaOperator(token);
Operacja oo = new Operacja()
{
OperandLewy = stala,
OperandPrawy = w,
Operator = oper
};
return(oo);
}
else
{
Operacja operacja = new Operacja()
{
OperandLewy = stala,
OperandPrawy = w,
Operator = Operacja.TokenNaOperator(token)
};
return(operacja);
}
}
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
{
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = stala;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
return(jezeli);
default:
tokenizer.Back();
break;
}
tokenizer.Back();
return(stala);
}
}
}
break;
}
case HCPSToken.String:
Stala ss = new Stala()
{
_Wartosc = tokenizer.Value,
Typ = HomeSimCockpitSDK.VariableType.String
};
token = tokenizer.Next();
switch (token)
{
case HCPSToken.InstructionEnd:
case HCPSToken.ParenthesisClose:
case HCPSToken.CommaSeparator:
{
tokenizer.Back();
return(ss);
}
case HCPSToken.Addition:
{
Wyrazenie w = Wyrazenie.Parsuj(tokenizer);
if (w is Operacja)
{
Wyrazenie w1 = ((Operacja)w).OperandLewy;
((Operacja)w).OperandLewy = new Operacja()
{
OperandLewy = ss,
OperandPrawy = w1,
Operator = Operacja.TokenNaOperator(token)
};
return(w);
}
else
{
Operacja operacja = new Operacja()
{
OperandLewy = ss,
OperandPrawy = w,
Operator = Operacja.TokenNaOperator(token)
};
return(operacja);
}
}
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
{
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = ss;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
return(jezeli);
default:
tokenizer.Back();
break;
}
tokenizer.Back();
return(ss);
}
}
break;
case HCPSToken.Variable:
{
string zmienna = tokenizer.Value;
token = tokenizer.Next();
switch (token)
{
case HCPSToken.Assignment:
{
Przypisanie przypisanie = new Przypisanie();
przypisanie.Zmienna = new ZmiennaNieistniejaca()
{
Nazwa = zmienna
};
przypisanie.Wyrazenie = Wyrazenie.Parsuj(tokenizer);
token = tokenizer.Next();
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = przypisanie.Wyrazenie;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
przypisanie.Wyrazenie = jezeli;
break;
default:
tokenizer.Back();
break;
}
przypisanie.Check();
return(przypisanie);
}
case HCPSToken.InstructionEnd:
case HCPSToken.ParenthesisClose:
case HCPSToken.CommaSeparator:
{
tokenizer.Back();
return(new ZmiennaNieistniejaca()
{
Nazwa = zmienna
});
}
case HCPSToken.Addition:
case HCPSToken.Division:
case HCPSToken.Multiplication:
case HCPSToken.Subtraction:
case HCPSToken.And:
case HCPSToken.Or:
case HCPSToken.Modulo:
{
Wyrazenie w = Wyrazenie.Parsuj(tokenizer);
if (w is Operacja)
{
Wyrazenie w1 = ((Operacja)w).OperandLewy;
OperatorDwuargumentowyTyp oper = Operacja.TokenNaOperator(token);
Operacja oo = new Operacja()
{
OperandLewy = new ZmiennaNieistniejaca()
{
Nazwa = zmienna
},
OperandPrawy = w,
Operator = oper
};
return(oo);
}
else
{
Operacja operacja = new Operacja()
{
OperandLewy = new ZmiennaNieistniejaca()
{
Nazwa = zmienna
},
OperandPrawy = w,
Operator = Operacja.TokenNaOperator(token)
};
return(operacja);
}
}
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
{
ZmiennaNieistniejaca zn = new ZmiennaNieistniejaca()
{
Nazwa = zmienna
};
switch (token)
{
case HCPSToken.Bigger:
case HCPSToken.BiggerOrEqual:
case HCPSToken.Equal:
case HCPSToken.NotEqual:
case HCPSToken.Smaller:
case HCPSToken.SmallerOrEqual:
Jezeli jezeli = new Jezeli();
jezeli.WyrazenieLewe = zn;
jezeli.WarunekLogiczny = new WarunekLogiczny()
{
Typ = WarunekLogiczny.TokenNaWarunek(token)
};
jezeli.WyrazeniePrawe = Wyrazenie.Parsuj(tokenizer);
return(jezeli);
default:
tokenizer.Back();
break;
}
tokenizer.Back();
return(zn);
}
}
break;
}
case HCPSToken.BlockEnd:
return(null);
case HCPSToken.ParenthesisClose:
return(null);
case HCPSToken.InstructionEnd:
return(null);
case HCPSToken.CommaSeparator:
return(null);
case HCPSToken.Comment:
return(Parsuj(tokenizer));
}
throw new ParsingScriptException(string.Format(UI.Language.Instance.GetString(UI.UIStrings.CannotReadExpression2), token, tokenizer.Value, tokenizer.GetPosition(tokenizer.Position)));
}
private IToken ScanSymbol(IScanner scanner)
{
var start = scanner.Position;
switch (scanner.Current)
{
case CharacterTable.At:
var next = scanner.Peek();
if (next == CharacterTable.CurvedQuotationMark)
{
return(_interpolated.Next(scanner));
}
else if (next == CharacterTable.DoubleQuotationMark)
{
return(_string.Next(scanner));
}
return(ScanName(scanner));
case CharacterTable.FullStop:
return(_number.Next(scanner));
case CharacterTable.Comma:
return(new CharacterToken(TokenType.Comma, CharacterTable.Comma, start));
case CharacterTable.Colon:
return(new CharacterToken(TokenType.Colon, CharacterTable.Colon, start));
case CharacterTable.SemiColon:
return(new CharacterToken(TokenType.SemiColon, CharacterTable.SemiColon, start));
case CharacterTable.Plus:
if (scanner.PeekMoveNext(CharacterTable.Plus))
{
return(new OperatorToken(TokenType.Increment, "++", start, scanner.Position));
}
return(new OperatorToken(TokenType.Add, "+", start));
case CharacterTable.Minus:
if (scanner.PeekMoveNext(CharacterTable.Minus))
{
return(new OperatorToken(TokenType.Decrement, "--", start, scanner.Position));
}
return(new OperatorToken(TokenType.Subtract, "-", start));
case CharacterTable.GreaterThan:
if (scanner.PeekMoveNext(CharacterTable.Equal))
{
return(new OperatorToken(TokenType.GreaterEqual, ">=", start, scanner.Position));
}
return(new OperatorToken(TokenType.Greater, ">", start));
case CharacterTable.LessThan:
if (scanner.PeekMoveNext(CharacterTable.Equal))
{
return(new OperatorToken(TokenType.LessEqual, "<=", start, scanner.Position));
}
return(new OperatorToken(TokenType.Less, "<", start));
case CharacterTable.CircumflexAccent:
return(new OperatorToken(TokenType.Power, "^", start));
case CharacterTable.Tilde:
if (scanner.PeekMoveNext(CharacterTable.Equal))
{
return(new OperatorToken(TokenType.NotEqual, "~=", start, scanner.Position));
}
return(new OperatorToken(TokenType.Negate, "~", start));
case CharacterTable.ExclamationMark:
return(new OperatorToken(TokenType.Factorial, "!", start));
case CharacterTable.Equal:
return(ScanEqual(scanner));
case CharacterTable.Slash:
return(_comment.Next(scanner));
case CharacterTable.Backslash:
return(new OperatorToken(TokenType.LeftDivide, "\\", start));
case CharacterTable.Asterisk:
return(new OperatorToken(TokenType.Multiply, "*", start));
case CharacterTable.Percent:
return(new OperatorToken(TokenType.Modulo, "%", start));
case CharacterTable.Pipe:
if (scanner.PeekMoveNext(CharacterTable.Pipe))
{
return(new OperatorToken(TokenType.Or, "||", start, scanner.Position));
}
return(new OperatorToken(TokenType.Pipe, "|", start));
case CharacterTable.Ampersand:
if (scanner.PeekMoveNext(CharacterTable.Ampersand))
{
return(new OperatorToken(TokenType.And, "&&", start, scanner.Position));
}
return(new OperatorToken(TokenType.Type, "&", start));
case CharacterTable.QuestionMark:
return(new OperatorToken(TokenType.Condition, "?", start));
case CharacterTable.SingleQuotationMark:
return(new OperatorToken(TokenType.Transpose, "'", start));
case CharacterTable.DoubleQuotationMark:
return(_string.Next(scanner));
case CharacterTable.CurvedQuotationMark:
return(_interpolated.Next(scanner));
case CharacterTable.OpenBracket:
return(new CharacterToken(TokenType.OpenGroup, CharacterTable.OpenBracket, start));
case CharacterTable.CloseBracket:
return(new CharacterToken(TokenType.CloseGroup, CharacterTable.CloseBracket, start));
case CharacterTable.OpenArray:
return(new CharacterToken(TokenType.OpenList, CharacterTable.OpenArray, start));
case CharacterTable.CloseArray:
return(new CharacterToken(TokenType.CloseList, CharacterTable.CloseArray, start));
case CharacterTable.OpenScope:
return(new CharacterToken(TokenType.OpenScope, CharacterTable.OpenScope, start));
case CharacterTable.CloseScope:
return(new CharacterToken(TokenType.CloseScope, CharacterTable.CloseScope, start));
case CharacterTable.End:
return(new EndToken(start));
case CharacterTable.Hash:
return(Preprocessor(scanner));
}
return(new CharacterToken(TokenType.Unknown, scanner.Current, start));
}
private Tree GetTreeFromInputStream()
{
int wordIndex = 0;
// FSA
//label:
while (tokenizer.HasNext())
{
string token = tokenizer.Next();
switch (token)
{
case LeftParen:
// cdm 20100225: This next line used to have "" instead of null, but the traditional and current tree normalizers depend on the label being null not "" when there is no label on a tree (like the outermost English PTB level)
string label = (tokenizer.Peek().Equals(LeftParen)) ? null : tokenizer.Next();
if (RightParen.Equals(label))
{
//Skip past empty trees
continue;
}
else if (treeNormalizer != null)
{
label = treeNormalizer.NormalizeNonterminal(label);
}
if (label != null)
{
label = StarPattern.Replace(label, "*");
label = SlashPattern.Replace(label, "/");
}
Tree newTree = treeFactory.NewTreeNode(label, null); // dtrs are added below
if (currentTree == null)
{
stack.Add(newTree);
}
else
{
currentTree.AddChild(newTree);
stack.Add(currentTree);
}
currentTree = newTree;
break;
case RightParen:
if (!stack.Any())
{
// Warn that file has too many right parens
//break label;
goto post_while_label;
}
//Accept
currentTree = stack.Last();
stack.RemoveAt(stack.Count - 1); // i.e., stack.pop()
if (!stack.Any())
{
return(currentTree);
}
break;
default:
if (currentTree == null)
{
// A careful Reader should warn here, but it's kind of useful to
// suppress this because then the TreeReader doesn't print a ton of
// messages if there is a README file in a directory of Trees.
//break label;
goto post_while_label;
}
string terminal = (treeNormalizer == null) ? token : treeNormalizer.NormalizeTerminal(token);
terminal = StarPattern.Replace(terminal, "*");
terminal = SlashPattern.Replace(terminal, "/");
Tree leaf = treeFactory.NewLeaf(terminal);
if (leaf.Label() is IHasIndex)
{
var hi = (IHasIndex)leaf.Label();
hi.SetIndex(wordIndex);
}
if (leaf.Label() is IHasWord)
{
var hw = (IHasWord)leaf.Label();
hw.SetWord(leaf.Label().Value());
}
wordIndex++;
currentTree.AddChild(leaf);
// cdm: Note: this implementation just isn't as efficient as the old recursive descent parser (see 2008 code), where all the daughters are gathered before the tree is made....
break;
}
}
post_while_label:
{
}
//Reject
return(null);
}
