Exemple #1
0
        BasicNode Call(BasicEnvironment env, ConstantNode[] args)
        {
            if (!env.SaveContext())
            {
                return(env.LastError);
            }
            if (argCount != args.Length)
            {
                return(env.RuntimeError("Argument count mismatch"));
            }
            for (int i = 0; i < args.Length; i++)
            {
                var prop = new ConstantProperty()
                {
                    Value = args[i],
                    Name  = parNames[i],
                };
                env.SetProperty(prop);
            }
            var result = expr.Eval(env);

            env.RestoreContext();
            return(result);
        }
Exemple #2
0
        public BasicNode SetValue(BasicEnvironment env, BasicNode value)
        {
            env.InstructionCount++;
            var prop = env.GetProperty(Name);

            if (prop == null)
            {
                if (Arguments.Length == 0)
                {
                    prop = new ConstantProperty();
                }
                else
                {
                    prop = IsStringName ? (Property) new ArrayProperty <StringConstantNode>(Arguments.Length)
                                                : new ArrayProperty <NumericConstantNode>(Arguments.Length);
                }
                prop.Name = Name;
                env.SetProperty(prop);
            }

            var consProp = prop as ConstantProperty;

            if (consProp != null)
            {
                if (Arguments.Length > 0)
                {
                    return(env.RuntimeError($"simple variable '{Name}' is not an array"));
                }
                var consValue = value as ConstantNode;
                if (consValue == null)
                {
                    return(env.RuntimeError());
                }
                consProp.Value = consValue;
                return(value);
            }
            var arrProp = prop as IArrayProperty;

            if (Arguments.Length == 0)
            {
                return(env.RuntimeError($"array '{Name}' should not be used like a simple variable"));
            }
            if (arrProp.DimCount != Arguments.Length)
            {
                return(env.RuntimeError(ERuntimeErrors.ArrayDimensionMismatch));
            }
            int[] indexes;
            var   result = BuildArrayIndexes(env, out indexes);

            if (result.IsError())
            {
                return(result);
            }
            if (IsStringName)
            {
                var sar  = arrProp as ArrayProperty <StringConstantNode>;
                var sval = value as StringConstantNode;
                if (sval == null)
                {
                    return(env.RuntimeError("type mismatch"));
                }
                if (!sar.SetValue(indexes, sval))
                {
                    return(env.RuntimeError(ERuntimeErrors.ArrayIndexOutOfRange, Name));
                }
                return(sval);
            }
            else
            {
                var sar  = arrProp as ArrayProperty <NumericConstantNode>;
                var sval = value as NumericConstantNode;
                if (sval == null)
                {
                    return(env.RuntimeError("type mismatch"));
                }
                if (!sar.SetValue(indexes, sval))
                {
                    return(env.RuntimeError(ERuntimeErrors.ArrayIndexOutOfRange, Name));
                }
                return(sval);
            }
        }