Esempio n. 1
0
        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));
        }
Esempio n. 2
0
        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)));
        }
Esempio n. 3
0
        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)));
        }
Esempio n. 4
0
        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)));
        }
Esempio n. 5
0
        public new static Akcje Parsuj(ITokenizer tokenizer)
        {
            List <Wyrazenie> wyrazenia = new List <Wyrazenie>();

            do
            {
                Wyrazenie wyrazenie = Wyrazenie.Parsuj(tokenizer);
                if (wyrazenie != null)
                {
                    wyrazenia.Add(wyrazenie);
                }
            }while (tokenizer.LastToken != HCPSToken.BlockEnd);
            Akcje akcje = new Akcje();

            akcje.akcje = wyrazenia.ToArray();
            akcje.Check();
            return(akcje);

            throw new Exception(string.Format(UI.Language.Instance.GetString(UI.UIStrings.CannotReadExpression), tokenizer.GetPosition(tokenizer.Position)));
        }
Esempio n. 6
0
        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)));
        }
Esempio n. 7
0
        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)));
        }
Esempio n. 8
0
        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);
        }
Esempio n. 9
0
        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);
        }
Esempio n. 10
0
        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)));
        }