Beispiel #1
0
        public void CheckEvt(IScope currScope, LSLAst id)
        {
            EventSymbol evt = (EventSymbol)currScope.Resolve(id.Text + "()");

            Debug.Assert(evt != null);

            //try to find this event in our table
            if (!_supportedEvents.HasEventByName(id.Text))
            {
                _listener.Error("line " + id.Token.Line + ":" +
                                id.Token.CharPositionInLine + " No event evailable with name '" + id.Text + "'");

                return;
            }

            //also try to resolve the arguments
            List <VarType> passedEvtArgs = evt.ExtractArgumentTypes();

            if (!_supportedEvents.HasEventBySig(id.Text, VarType.Void, passedEvtArgs))
            {
                string paramList = this.FormatParamTypeList(_supportedEvents.GetArguments(id.Text));
                _listener.Error("line " + id.Token.Line + ":" +
                                id.Token.CharPositionInLine + " Incorrect parameters for event " + id.Text +
                                paramList);
            }
        }
Beispiel #2
0
        public bool IsAssignable(LSLAst lhs)
        {
            //lhs will either be an id direct or an EXPR with an ID child
            if (lhs.Type == LSLParser.ID)
            {
                return(true);
            }

            if (lhs.Type == LSLParser.EXPR &&
                lhs.ChildCount == 1 &&
                lhs.Children[0].Type == LSLParser.ID)
            {
                return(true);
            }

            if (lhs.Type == LSLParser.SUBSCRIPT)
            {
                return(true);
            }


            _listener.Error(
                "line " + lhs.Line + ":" + lhs.CharPositionInLine + " '" +
                lhs.Text + "' is not assignable"
                );

            return(false);
        }
Beispiel #3
0
        public ISymbolType PreDec(LSLAst a)
        {
            if (a.evalType == null)
            {
                _listener.Error(
                    "line " + a.Token.Line + ":" + a.Token.CharPositionInLine +
                    " (--) Unknown type in expression " + a.Text
                    );

                return(VOID);
            }

            if (!IsAssignable(a))
            {
                return(VOID);
            }

            if (!TypeIsIn(a.evalType, new ISymbolType[] { INT, FLOAT }))
            {
                _listener.Error(
                    "line " + a.Token.Line + ":" + a.Token.CharPositionInLine +
                    " -- not valid for type " + a.evalType.Name
                    );

                return(VOID);
            }

            return(a.evalType);
        }
Beispiel #4
0
        public ISymbolType Bop(LSLAst bop, LSLAst lhs, LSLAst rhs)
        {
            ISymbolType[,] symTable;
            string op = bop.Token.Text;

            symTable = FindOperationTable(lhs, op);
            if (symTable == null)
            {
                return(VOID);
            }

            if (HasUnknownTypes(lhs, rhs))
            {
                return(VOID);
            }

            ISymbolType symType = symTable[lhs.evalType.TypeIndex, rhs.evalType.TypeIndex];

            if (symType == VOID)
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " '" + op + "' is not a valid operation between " +
                                lhs.evalType.Name + " and " + rhs.evalType.Name);
                return(VOID);
            }

            return(symType);
        }
Beispiel #5
0
        public bool CheckRotationLiteral(LSLAst e1, LSLAst e2, LSLAst e3, LSLAst e4)
        {
            if (!AllTypesAreResolved(new LSLAst[] { e1, e2, e3, e4 }))
            {
                _listener.Error(
                    "line " + e1.Token.Line + ":" + e1.Token.CharPositionInLine +
                    " Rotation contains expression(s) of unknown type"
                    );

                return(false);
            }

            //try type promotion first
            e1.promoteToType = promoteFromTo[e1.evalType.TypeIndex, FLOAT.TypeIndex];
            e2.promoteToType = promoteFromTo[e2.evalType.TypeIndex, FLOAT.TypeIndex];
            e3.promoteToType = promoteFromTo[e3.evalType.TypeIndex, FLOAT.TypeIndex];
            e4.promoteToType = promoteFromTo[e4.evalType.TypeIndex, FLOAT.TypeIndex];

            if (CanAssignTo(e1.evalType, FLOAT, e1.promoteToType) &&
                CanAssignTo(e2.evalType, FLOAT, e2.promoteToType) &&
                CanAssignTo(e3.evalType, FLOAT, e3.promoteToType) &&
                CanAssignTo(e4.evalType, FLOAT, e4.promoteToType))
            {
                return(true);
            }

            _listener.Error(
                "line " + e1.Token.Line + ":" + e1.Token.CharPositionInLine +
                " Rotation components must be float or implicitly convertable to float "
                );

            return(false);
        }
Beispiel #6
0
        public ISymbolType RelOp(LSLAst lhs, LSLAst rhs)
        {
            if (HasUnknownTypes(lhs, rhs))
            {
                return(VOID);
            }

            //relational operations must be between the same types
            int tlhs = lhs.evalType.TypeIndex; // promote right to left type?
            int trhs = rhs.evalType.TypeIndex;

            rhs.promoteToType = promoteFromTo[trhs, tlhs];
            lhs.promoteToType = promoteFromTo[tlhs, trhs];

            if (!HaveSameTypes(lhs, rhs))
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " Type mismatch, relational operators require arguments of the same type");
            }

            //strings can not be LT/GT compared in LSL
            if (lhs.evalType == STRING || rhs.evalType == STRING)
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " Type mismatch, strings can not be compared with < or >");
            }

            return(INT);
        }
Beispiel #7
0
 public void CheckLogicalExpr(LSLAst expr)
 {
     if (expr.evalType != INT)
     {
         _listener.Error("line " + expr.Token.Line + ":" +
                         expr.Token.CharPositionInLine + " Logical expressions require integer type");
     }
 }
Beispiel #8
0
        public string text(LSLAst t)
        {
            string ts = "";

            //if (t.evalType != null) ts = ":<" + t.evalType + ">";
            return(_tokens.ToString(t.TokenStartIndex,
                                    t.TokenStopIndex) + ts);
        }
Beispiel #9
0
        public ISymbolType SubScript(LSLAst id, LSLAst subScript)
        {
            //the lhs must be an ID and it must be of vector type or rotation type
            //and it must be the letters x, y, z, or s for rotation
            if (id.Type != LSLParser.ID)
            {
                _listener.Error(
                    "line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                    " Use of subscript ." + subScript.Text + " requires a vector or rotation variable "
                    );

                return(VOID);
            }

            if (!TypeIsIn(id.evalType, new ISymbolType[] { VECTOR, ROTATION }))
            {
                _listener.Error(
                    "line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                    " Use of subscript ." + subScript.Text + " requires a vector or rotation variable"
                    );

                return(VOID);
            }

            if (id.evalType == VECTOR)
            {
                if (subScript.Text != "x" &&
                    subScript.Text != "y" &&
                    subScript.Text != "z")
                {
                    _listener.Error(
                        "line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                        " Invalid subscript ." + subScript.Text
                        );

                    return(VOID);
                }
            }

            if (id.evalType == ROTATION)
            {
                if (subScript.Text != "x" &&
                    subScript.Text != "y" &&
                    subScript.Text != "z" &&
                    subScript.Text != "s")
                {
                    _listener.Error(
                        "line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                        " Invalid subscript ." + subScript.Text
                        );

                    return(VOID);
                }
            }

            return(FLOAT);
        }
Beispiel #10
0
        public ISymbolType LogBop(LSLAst lhs, LSLAst rhs)
        {
            if (lhs.evalType != INT || rhs.evalType != INT)
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " Type mismatch, logical operators || and && require integer arguments");
            }

            return(INT);
        }
Beispiel #11
0
        public bool HasUnknownType(LSLAst lhs)
        {
            if (lhs.evalType == null)
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " Invalid operation. At least one type is unknown");
                return(true);
            }

            return(false);
        }
Beispiel #12
0
        public ISymbolType CheckListLiteral(LSLAst start, IList <LSLAst> args)
        {
            foreach (LSLAst node in args)
            {
                if (node.evalType == LIST)
                {
                    _listener.Error("line " + start.Token.Line + ":" +
                                    start.Token.CharPositionInLine + " A list can not contain another list");
                }
            }

            return(LIST);
        }
Beispiel #13
0
        public void CheckStateChange(LSLAst chgNode, LSLAst destID)
        {
            string      stateName = destID != null ? destID.Text + "(*)" : "default(*)";
            StateSymbol state     = _globals.Resolve(stateName) as StateSymbol;

            if (state == null)
            {
                _listener.Error(
                    "line " + chgNode.Token.Line + ":" + chgNode.Token.CharPositionInLine +
                    " Undefined state " + stateName
                    );
            }
        }
Beispiel #14
0
        public void CheckJump(LSLAst jumpStmt, LSLAst id)
        {
            LabelSymbol label = jumpStmt.scope.Resolve("@" + id.Text) as LabelSymbol;

            if (label == null)
            {
                _listener.Error("line " + id.Token.Line + ":" +
                                id.Token.CharPositionInLine + " Undefined label " + id.Text);
            }
            else
            {
                id.symbol = label;
            }
        }
Beispiel #15
0
        public ISymbolType BitOp(LSLAst lhs, LSLAst rhs)
        {
            if (HasUnknownTypes(lhs, rhs))
            {
                return(INT);
            }

            if (lhs.evalType != INT || rhs.evalType != INT)
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " Type mismatch, bitwise operators require arguments of integral type");
            }

            return(INT);
        }
Beispiel #16
0
        private ISymbolType StdAssign(LSLAst lhs, LSLAst rhs, int tlhs, int trhs)
        {
            rhs.promoteToType = promoteFromTo[trhs, tlhs];
            if (!CanAssignTo(rhs.evalType, lhs.evalType, rhs.promoteToType))
            {
                _listener.Error(
                    "line " + lhs.Line + ":" + lhs.CharPositionInLine + " " + text(lhs) + " and " +
                    text(rhs) + " have incompatible types in " +
                    text((LSLAst)lhs.Parent)
                    );

                return(VOID);
            }

            return(lhs.evalType);
        }
Beispiel #17
0
        private ISymbolType[,] FindOperationTable(LSLAst lhs, string op)
        {
            ISymbolType[,] symTable;
            switch (op)
            {
            case "+":
            case "+=":
                symTable = additionResultType;
                break;

            case "-":
            case "-=":
                symTable = subtractionResultType;
                break;

            case "*":
            case "*=":
                symTable = multiplicationResultType;
                break;

            case "/":
            case "/=":
                symTable = divisionResultType;
                break;

            case "%":
            case "%=":
                symTable = modResultType;
                break;

            case "<<":
            case ">>":
            case ">>=":
            case "<<=":
                symTable = shiftResultType;
                break;

            default:
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " Internal error. No such operation '" + op + "'");
                symTable = null;
                break;
            }

            return(symTable);
        }
Beispiel #18
0
        public void DeclInit(LSLAst varName, LSLAst initExpr)
        {
            int tlhs = varName.symbol.Type.TypeIndex; // promote right to left type?

            varName.evalType = varName.symbol.Type;
            int trhs = initExpr.evalType.TypeIndex;

            initExpr.promoteToType = promoteFromTo[trhs, tlhs];
            if (!CanAssignTo(initExpr.evalType, varName.evalType, initExpr.promoteToType))
            {
                _listener.Error(
                    "line " + varName.Line + ":" + varName.CharPositionInLine + " " + text(varName) + " and " +
                    text(initExpr) + " have incompatible types in " +
                    text((LSLAst)initExpr.Parent)
                    );
            }
        }
Beispiel #19
0
        public ISymbolType Assign(string type, LSLAst lhs, LSLAst rhs)
        {
            if (HasUnknownTypes(lhs, rhs))
            {
                return(VOID);
            }

            //the left hand side needs to be assignable
            if (!IsAssignable(lhs))
            {
                return(VOID);
            }

            int tlhs = lhs.evalType.TypeIndex; // promote right to left type?
            int trhs = rhs.evalType.TypeIndex;

            if (type == "=")
            {
                return(StdAssign(lhs, rhs, tlhs, trhs));
            }

            ISymbolType[,] opTable = FindOperationTable(lhs, type);
            if (opTable == null)
            {
                return(VOID);
            }

            ISymbolType symType = opTable[lhs.evalType.TypeIndex, rhs.evalType.TypeIndex];

            if (symType == VOID)
            {
                if (lhs.Type == LSLParser.EXPR)
                {
                    lhs = (LSLAst)lhs.Children[0];
                }

                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " '" + type + "' is not a valid operation between " +
                                lhs.evalType.Name + " and " + rhs.evalType.Name);
                return(VOID);
            }

            return(symType);
        }
Beispiel #20
0
        public bool HaveSameTypes(LSLAst lhs, LSLAst rhs)
        {
            if (lhs.evalType == null || rhs.evalType == null)
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + "Can not compare types, at least one type is unknown " + lhs.Text + ", " + rhs.Text);

                return(false);
            }

            if (lhs.evalType == rhs.evalType ||
                (lhs.promoteToType == rhs.promoteToType && lhs.promoteToType != null && rhs.promoteToType != null) ||
                lhs.evalType == rhs.promoteToType ||
                rhs.evalType == lhs.promoteToType)
            {
                return(true);
            }

            return(false);
        }
Beispiel #21
0
        private bool IsChildNodeOf(LSLAst sym, LSLAst node)
        {
            if (sym == null || sym.Children == null)
            {
                return(false);
            }

            foreach (Antlr.Runtime.Tree.ITree childNode in sym.Children)
            {
                if (childNode == node)
                {
                    return(true);
                }

                if (IsChildNodeOf((LSLAst)childNode, node))
                {
                    return(true);
                }
            }

            return(false);
        }
Beispiel #22
0
        public ISymbolType EqOp(LSLAst lhs, LSLAst rhs)
        {
            if (HasUnknownTypes(lhs, rhs))
            {
                return(VOID);
            }

            //equality operations must be between the same types
            int tlhs = lhs.evalType.TypeIndex; // promote right to left type?
            int trhs = rhs.evalType.TypeIndex;

            rhs.promoteToType = promoteFromTo[trhs, tlhs];
            lhs.promoteToType = promoteFromTo[tlhs, trhs];

            if (!HaveSameTypes(lhs, rhs))
            {
                _listener.Error("line " + lhs.Token.Line + ":" +
                                lhs.Token.CharPositionInLine + " Type mismatch, equality operators == and != require arguments of the same type");
            }

            return(INT);
        }
Beispiel #23
0
        public ISymbolType TypeCast(LSLAst expr, LSLAst type)
        {
            if (HasUnknownType(expr))
            {
                return(VOID);
            }

            int texpr = expr.evalType.TypeIndex;

            //type must be a builtin type
            ISymbolType toType = (ISymbolType)_globals.Resolve(type.Text);
            int         ttype  = toType.TypeIndex;

            if (!CanCast(texpr, ttype))
            {
                _listener.Error(
                    "line " + type.Line + ":" + type.CharPositionInLine + " Can not cast from "
                    + expr.evalType.Name + " to " + type.Text
                    );
            }

            return(toType);
        }
Beispiel #24
0
        public ISymbolType Uminus(LSLAst a)
        {
            if (a.evalType == null)
            {
                _listener.Error(
                    "line " + a.Token.Line + ":" + a.Token.CharPositionInLine +
                    " Unknown type in expression -" + a.Text
                    );

                return(VOID);
            }

            //only integer, float, vector and rotations can be negated
            if (!TypeIsIn(a.evalType, new ISymbolType[] { INT, FLOAT, VECTOR, ROTATION }))
            {
                _listener.Error(
                    "line " + a.Token.Line + ":" + a.Token.CharPositionInLine +
                    " Unary minus (-N) not valid for type " + a.evalType.Name
                    );
            }

            return(a.evalType);
        }
Beispiel #25
0
        public ISymbolType UBitNot(LSLAst a)
        {
            if (a.evalType == null)
            {
                _listener.Error(
                    "line " + a.Token.Line + ":" + a.Token.CharPositionInLine +
                    " Unknown type in expression !" + a.Text
                    );

                return(VOID);
            }

            if (a.evalType != INT)
            {
                _listener.Error(
                    "line " + a.Token.Line + ":" + a.Token.CharPositionInLine +
                    " Bitwise not (~) not valid for type " + a.evalType.Name
                    );

                return(VOID);
            }

            return(INT);
        }
Beispiel #26
0
        public void CheckReturn(LSLAst retStmt, LSLAst retExpr)
        {
            //return must match function type
            if (retExpr == null)
            {
                if (retStmt.symbol.Type == VOID)
                {
                    //void return type with void result
                    return;
                }
                else
                {
                    _listener.Error(
                        "line " + retStmt.Token.Line + ":" + retStmt.Token.CharPositionInLine +
                        " Function must return a value"
                        );

                    return;
                }
            }

            if (HasUnknownType(retExpr))
            {
                return;
            }

            //check promotions and return
            retExpr.promoteToType = promoteFromTo[retExpr.evalType.TypeIndex, retStmt.symbol.Type.TypeIndex];
            if (!CanAssignTo(retExpr.evalType, retStmt.symbol.Type, retExpr.promoteToType))
            {
                _listener.Error(
                    "line " + retStmt.Token.Line + ":" + retStmt.Token.CharPositionInLine +
                    " Invalid return type " + retExpr.evalType.Name + ", expecting " + retStmt.symbol.Type.Name
                    );
            }
        }
Beispiel #27
0
        public ISymbolType MethodCall(LSLAst id, IList <LSLAst> args)
        {
            Symbol s = id.scope.Resolve(id.Text + "()");

            if (s == null)
            {
                _listener.Error(
                    "line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                    " Call to undefined function " + id.Text + "()"
                    );

                return(VOID);
            }

            MethodSymbol ms = (MethodSymbol)s;

            id.symbol = ms;

            //check the call parameters
            if (!AllTypesAreResolved(args))
            {
                _listener.Error(
                    "line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                    " Method call contains expression(s) of unknown type"
                    );

                return(ms.Type);
            }

            //check param count and type
            if (args.Count != ms.Members.Count)
            {
                _listener.Error(
                    "line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                    " Function " + id.Text + "() takes " + Convert.ToString(ms.Members.Count) +
                    " parameters, " + args.Count + " given"
                    );

                return(ms.Type);
            }


            List <ParmAndExpected> erroredParms = new List <ParmAndExpected>();
            IEnumerator <Symbol>   correctParms = ms.Members.GetEnumerator();

            foreach (LSLAst parm in args)
            {
                correctParms.MoveNext();

                //promote if necessary
                parm.promoteToType = promoteFromTo[parm.evalType.TypeIndex, correctParms.Current.Type.TypeIndex];

                if (!CanAssignTo(parm.evalType, correctParms.Current.Type, parm.promoteToType))
                {
                    erroredParms.Add(new ParmAndExpected {
                        Parm = parm, Expected = correctParms.Current
                    });
                }
            }

            //one of the parameter types is incompatible
            if (erroredParms.Count > 0)
            {
                _listener.Error("line " + id.Token.Line + ":" + id.Token.CharPositionInLine +
                                " In call of function " + id.Text + "(): ");

                foreach (ParmAndExpected error in erroredParms)
                {
                    _listener.Error(
                        "line " + error.Parm.Token.Line + ":" + error.Parm.Token.CharPositionInLine +
                        " Parameter " + error.Expected.Name + ", expected " + error.Expected.Type.Name +
                        " got " + error.Parm.evalType.Name
                        );
                }
            }

            return(ms.Type);
        }
Beispiel #28
0
 public ISymbolType Unot(LSLAst a)
 {
     return(INT);
 }
Beispiel #29
0
 public ISymbolType PostDec(LSLAst a)
 {
     return(PreDec(a));
 }
Beispiel #30
0
 public ISymbolType PostInc(LSLAst a)
 {
     return(PreInc(a));
 }