コード例 #1
0
ファイル: MeshClass.cs プロジェクト: brianex/osu-sgl
		public override Value InvokeMethod(String name, List<Value> param) {
			switch (name) {
				case "getVertexCount":
					return new Value(mesh.Vertices.Count, ValType.Integer);

				case "getVertex":
					if (Value.TypeCompare(param, ValType.Integer)) {
						return new Value(new VertexClass(mesh.Vertices[param[0].IntValue]), ValType.Object);
					} else
						throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

				case "getEdgeCount":
					return new Value(mesh.Edges.Count, ValType.Integer);

				case "getEdge":
					if (Value.TypeCompare(param, ValType.Integer)) {
						return new Value(new EdgeClass(mesh.Edges[param[0].IntValue]), ValType.Object);
					} else
						throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

				case "getFaceCount":
					return new Value(mesh.Faces.Count, ValType.Integer);

				case "getFace":
					if (Value.TypeCompare(param, ValType.Integer)) {
						return new Value(new FaceClass(mesh.Faces[param[0].IntValue]), ValType.Object);
					} else
						throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

				default:
					throw new CompilerException(-1, 314, Name, name);
			}
		}
コード例 #2
0
ファイル: LayerFactory.cs プロジェクト: brianex/osu-sgl
 public override object CreateNewInstance(List<Elements.Value> parameters)
 {
     ListFactory<Visual> layerObjects = new List<Visual>();
     foreach (Elements.Value parameter in parameters) {
         layerObjects.Add((Visual)parameter.ObjectValue);
     }
     return new LayerFactory(layerObjects);
 }
コード例 #3
0
ファイル: LayerClass.cs プロジェクト: brianex/osu-sgl
 public override object CreateInstance(List<Elements.Value> parameters)
 {
     List<AbstractVisualClass> LayerGenerators = new List<AbstractVisualClass>();
     foreach (Elements.Value parameter in parameters) {
         LayerGenerators.Add((AbstractVisualClass)parameter.ObjectValue);
     }
     return new LayerClass(LayerGenerators);
 }
コード例 #4
0
ファイル: InvokeFunctionNode.cs プロジェクト: brianex/osu-sgl
 public InvokeFunctionNode(String objectVar, List<AbstractNode> indexes, String funcName,
                           List<AbstractNode> parameters, Scope scope, int line)
 {
     this.funcName = funcName;
     this.parameters = parameters != null ? parameters : new List<AbstractNode>();
     this.objectVar = objectVar;
     this.scope = scope;
     this.line = line;
 }
コード例 #5
0
ファイル: LayerGenerator.cs プロジェクト: brianex/osu-sgl
 public LayerGenerator(List<AbstractVisualClass> layerClasses)
 {
     List<AbstractVisualGenerator> LayerGeneratorsTemp = new List<AbstractVisualGenerator>();
     foreach (AbstractVisualClass obj in layerClasses)
     {
         LayerGeneratorsTemp.Add(obj.Object);
     }
     this.LayerGenerators = LayerGeneratorsTemp;
 }
コード例 #6
0
ファイル: Layer.cs プロジェクト: brianex/osu-sgl
 public Layer(List<Visual> layerClasses)
 {
     ListFactory<Sprite> layerObjectsTemp = new List<Sprite>();
     foreach (Visual obj in layerClasses)
     {
         layerObjectsTemp.Add(obj.Object);
     }
     this.layerObjects = layerObjectsTemp;
 }
コード例 #7
0
ファイル: SpriteClass.cs プロジェクト: brianex/osu-sgl
 public override object CreateInstance(List<Value> param)
 {
     if (Value.TypeCompare(param, ValType.String)) return new SpriteClass(param[0].StringValue);
     else if (Value.TypeCompare(param, ValType.String, ValType.Layer))
         return new SpriteClass(param[0].StringValue, param[1].StringValue);
     else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Origin))
         return new SpriteClass(param[0].StringValue, param[1].StringValue, param[2].StringValue);
     else throw new CompilerException(-1, 312);
 }
コード例 #8
0
ファイル: InvokeFunctionNode.cs プロジェクト: brianex/osu-sgl
 public InvokeFunctionNode(String funcName, List<AbstractNode> parameters, int line)
 {
     // It's checked weather or not the function name itself exists in order to avoid typos at an early state
     if (!LibraryManager.Instance.IsFunctionKnown(funcName) && !GlobalMemory.Instance.IsFunctionKnown(funcName))
     {
         throw new CompilerException(line, 301, funcName);
     }
     this.funcName = funcName;
     this.parameters = parameters != null ? parameters : new List<AbstractNode>();
     this.line = line;
 }
コード例 #9
0
ファイル: AnimationFactory.cs プロジェクト: brianex/osu-sgl
 public override object CreateNewInstance(List<Value> param)
 {
     if (Value.TypeCompare(param, ValType.String, ValType.Integer, ValType.Integer))
         return new AnimationFactory(param[0].StringValue, param[1].IntValue, param[2].IntValue);
     else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Integer, ValType.Integer))
         return new AnimationFactory(param[0].StringValue, param[1].StringValue, param[2].IntValue,
                              param[3].IntValue);
     else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Origin, ValType.Integer,
                                ValType.Integer))
         return new AnimationFactory(param[0].StringValue, param[1].StringValue, param[2].StringValue,
                              param[3].IntValue, param[4].IntValue);
     else if (Value.TypeCompare(param, ValType.String, ValType.Layer, ValType.Origin, ValType.Integer,
                                ValType.Integer, ValType.LoopType))
         return new AnimationFactory(param[0].StringValue, param[1].StringValue, param[2].StringValue,
                              param[3].IntValue, param[4].IntValue, param[5].StringValue);
     else throw new CompilerException(-1, 312);
 }
コード例 #10
0
ファイル: MeshClass.cs プロジェクト: brianex/osu-sgl
			public override Value InvokeMethod(string name, List<Value> param) {
				switch (name) {
					case "getVertexCount":
						return new Value(face.VertexIndices.Count, ValType.Integer);

					case "getVertex":
						if (Value.TypeCompare(param, ValType.Integer)) {
							return new Value(new VertexClass(face.getVertex(param[0].IntValue)), ValType.Object);
						} else
							throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

					case "getVertexIndex":
						if (Value.TypeCompare(param, ValType.Integer)) {
							return new Value(face.VertexIndices[param[0].IntValue], ValType.Integer);
						} else
							throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

					default:
						throw new CompilerException(-1, 314, Name, name);
				}
			}
コード例 #11
0
ファイル: LibraryManager.cs プロジェクト: Bannersean/osu-sgl
 /// <summary>
 /// Returns the class 
 /// </summary>
 /// <param name="name"></param>
 /// <param name="parameters"></param>
 /// <returns></returns>
 public object GetClass(string name, List<Value> parameters)
 {
     // look if the class exists
     if (classes.ContainsKey(name))
     {
         try
         {
             return classes[name].CreateInstance(parameters);
         }
         catch (CompilerException ce)
         {
             if (ce.ErrorCode == 312)
             {
                 ce.SetArguments(name, Value.PrintTypeList(parameters));
             }
             throw ce;
         }
     }
     else
     {
         throw new CompilerException(-1, 311, name, Value.PrintTypeList(parameters));
     }
 }
コード例 #12
0
        public override Value InvokeMethod(String name, List<Value> param)
        {
            switch (name)
            {
                case "fade":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        visualObject.fade(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        visualObject.fade(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        visualObject.fade(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                          param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        visualObject.fade(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                          param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "scale":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        visualObject.scale(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        visualObject.scale(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        visualObject.scale(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                           param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        visualObject.scale(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "rotate":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        visualObject.rotate(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        visualObject.rotate(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        visualObject.rotate(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                            param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        visualObject.rotate(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                            param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "moveX":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        visualObject.moveX(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        visualObject.moveX(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        visualObject.moveX(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                           param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        visualObject.moveX(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "moveY":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        visualObject.moveY(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        visualObject.moveY(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        visualObject.moveY(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                           param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        visualObject.moveY(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "move":
                    if (Value.TypeCompare(param, ValType.Integer, ValType.Integer))
                    {
                        visualObject.move(param[0].IntValue, param[1].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        visualObject.move(param[0].IntValue, param[1].IntValue, param[2].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer))
                    {
                        visualObject.move(param[0].IntValue, param[1].IntValue, param[2].IntValue, param[3].IntValue,
                                          param[4].IntValue, param[5].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        visualObject.move(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                          param[3].IntValue, param[4].IntValue, param[5].IntValue,
                                          param[6].IntValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "scaleVec":
                    if (Value.TypeCompare(param, ValType.Double, ValType.Double))
                    {
                        visualObject.scaleVec(param[0].DoubleValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        visualObject.scaleVec(param[0].IntValue, param[1].DoubleValue, param[2].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double,
                                               ValType.Double, ValType.Double))
                    {
                        visualObject.scaleVec(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                              param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Double, ValType.Double, ValType.Double, ValType.Double))
                    {
                        visualObject.scaleVec(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                              param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
                                              param[6].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "color":
                    if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer))
                    {
                        visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].IntValue, param[4].IntValue, param[5].IntValue,
                                           param[6].IntValue, param[7].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer))
                    {
                        visualObject.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].IntValue, param[4].IntValue, param[5].IntValue,
                                           param[6].IntValue, param[7].IntValue, param[8].IntValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

				case "colorHsv":
				case "colorHsb":
					if (Value.TypeCompare(param, ValType.Integer, ValType.Double, ValType.Double)) {
						visualObject.colorHsb(param[0].DoubleValue, param[1].DoubleValue, param[2].DoubleValue);
						return Value.VOID;
					} else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double)) {
						visualObject.colorHsb(param[0].IntValue, param[1].DoubleValue, param[2].DoubleValue,
										   param[3].DoubleValue);
						return Value.VOID;
					} else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
												 ValType.Double, ValType.Double, ValType.Integer, ValType.Double,
												 ValType.Double)) {
						visualObject.colorHsb(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
										   param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
										   param[6].DoubleValue, param[7].DoubleValue);
						return Value.VOID;
					} else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
												 ValType.Double, ValType.Double, ValType.Double, ValType.Double,
												 ValType.Double, ValType.Double)) {
						visualObject.colorHsb(param[0].IntValue, param[1].IntValue, param[2].IntValue,
										   param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
										   param[6].DoubleValue, param[7].DoubleValue, param[8].DoubleValue);
						return Value.VOID;
					} else
						throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

				case "additive":
					if (Value.TypeCompare(param, ValType.Integer, ValType.Integer)) {
						visualObject.additive(param[0].IntValue, param[1].IntValue);
						return Value.VOID;
					} else
						throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
				
				case "flipH":
					if (Value.TypeCompare(param, ValType.Integer, ValType.Integer)) {
						visualObject.flipH(param[0].IntValue, param[1].IntValue);
						return Value.VOID;
					} else
						throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

				case "flipV":
					if (Value.TypeCompare(param, ValType.Integer, ValType.Integer)) {
						visualObject.flipV(param[0].IntValue, param[1].IntValue);
						return Value.VOID;
					} else
						throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "startLoop":
                    if (Value.TypeCompare(param, ValType.Integer, ValType.Integer))
                    {
                        visualObject.startLoop(param[0].IntValue, param[1].IntValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
                case "startTriggerLoop":
                    if (Value.TypeCompare(param, ValType.LoopTrigger, ValType.Integer, ValType.Integer))
                    {
                        visualObject.startTriggerLoop(param[0].StringValue, param[1].IntValue, param[2].IntValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
                case "endLoop":
                    if (param.Count == 0)
                    {
                        visualObject.endLoop();
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));
                default:
                    throw new CompilerException(-1, 314, Name, name);
            }
            //TODO: Exception
            throw new Exception();
        }
コード例 #13
0
ファイル: ListClass.cs プロジェクト: brianex/osu-sgl
 public override object CreateInstance(List<Value> param)
 {
     return new Value(param, ValType.List);
     //else throw new CompilerException(-1, 312);
 }
コード例 #14
0
 public abstract object CreateNewInstance(List<Value> parameters);
コード例 #15
0
ファイル: AbstractClass.cs プロジェクト: brianex/osu-sgl
 public abstract Value InvokeMethod(String name, List<Value> parameters);
コード例 #16
0
ファイル: MeshClass.cs プロジェクト: brianex/osu-sgl
		public override object CreateInstance(List<Value> param) {
			if (Value.TypeCompare(param, ValType.String))
				return new MeshClass(param[0].StringValue);
			else
				throw new CompilerException(-1, 312);
		}
コード例 #17
0
ファイル: LayerClass.cs プロジェクト: brianex/osu-sgl
 public LayerClass(List<AbstractVisualClass> LayerGenerators)
 {
     this.LayerGenerators = LayerGenerators;
     visualObject = new LayerGenerator(LayerGenerators);
 }
コード例 #18
0
ファイル: MeshClass.cs プロジェクト: brianex/osu-sgl
			public override Value InvokeMethod(string name, List<Value> parameters) {
				switch (name) {
					case "getX":
						return new Value(vertex.X, ValType.Double);

					case "getY":
						return new Value(vertex.Y, ValType.Double);

					case "getZ":
						return new Value(vertex.Z, ValType.Double);

					default:
						throw new CompilerException(-1, 314, Name, name);
				}
			}
コード例 #19
0
ファイル: SampleClass.cs プロジェクト: brianex/osu-sgl
 public override Value InvokeMethod(String name, List<Value> param)
 {
     throw new CompilerException(-1, 314, Name, name);
 }
コード例 #20
0
ファイル: LayerFactory.cs プロジェクト: brianex/osu-sgl
 public LayerFactory(List<Visual> layerObjects)
 {
     this.layerObjects = layerObjects;
     Sprite = new LayerFactory(layerObjects);
 }
コード例 #21
0
ファイル: MeshClass.cs プロジェクト: brianex/osu-sgl
			public override object CreateInstance(List<Value> parameters) {
				// This should never be called
				throw new NotSupportedException();
			}
コード例 #22
0
ファイル: InvokeFunctionNode.cs プロジェクト: brianex/osu-sgl
        protected override Value Invoke()
        {
            if (objectVar != null && scope != null)
            {
                var values = new List<Value>();
                foreach (AbstractNode node in parameters)
                {
                    values.Add(node.Evaluate());
                }

                Value resolvedValue = scope.Resolve(objectVar);
                if (resolvedValue == null)
                {
                    throw new CompilerException(line, 211, objectVar);
                }
                if (resolvedValue.Type == ValType.Object)
                {
                    try
                    {
                        AbstractClass objectInstance = resolvedValue.ObjectValue;
                        return objectInstance.InvokeMethod(funcName, values);
                    }
                    catch (CompilerException ce)
                    {
                        if (ce.ErrorCode == 314)
                        {
                            if (GlobalMemory.Instance.IsFunctionKnown(funcName))
                            {
                                Function function = GlobalMemory.Instance.GetFunction(funcName, values);
                                if (function is UserFunction)
                                {
                                    GlobalMemory.Instance.AddCallToStack(new CallItem(funcName, Line));
                                    Value returnValue = ((UserFunction) function).Invoke(resolvedValue, values);
                                    GlobalMemory.Instance.PopLastCall();
                                    return returnValue;
                                }
                                else
                                {
                                    throw;
                                }
                            }
                            else
                            {
                                throw;
                            }
                        }
                        else
                        {
                            throw;
                        }
                    }
                }
                throw new CompilerException(line, 316, resolvedValue.TypeString);
            }
            else
            {
                var values = new List<Value>();
                foreach (AbstractNode node in parameters)
                {
                    values.Add(node.Evaluate());
                }

                Function function;
                if (LibraryManager.Instance.IsFunctionKnown(funcName))
                {
                    function = LibraryManager.Instance.GetFunction(funcName, values);
                    return function.Invoke(values);
                }
                else
                {
                    GlobalMemory.Instance.AddCallToStack(new CallItem(funcName, Line));
                    function = GlobalMemory.Instance.GetFunction(funcName, values);
                    Value returnValue = function.Invoke(values);
                    GlobalMemory.Instance.PopLastCall();
                    return returnValue;
                }
            }
        }
コード例 #23
0
ファイル: SpriteFactory.cs プロジェクト: brianex/osu-sgl
        public override Value InvokeMethod(String name, List<Value> param)
        {
            switch (name)
            {
                case "fade":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        Sprite.fade(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        Sprite.fade(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        Sprite.fade(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                          param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        Sprite.fade(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                          param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "scale":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        Sprite.scale(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        Sprite.scale(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        Sprite.scale(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                           param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        Sprite.scale(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "rotate":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        Sprite.rotate(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        Sprite.rotate(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        Sprite.rotate(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                            param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        Sprite.rotate(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                            param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "moveX":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        Sprite.moveX(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        Sprite.moveX(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        Sprite.moveX(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                           param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        Sprite.moveX(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "moveY":
                    if (Value.TypeCompare(param, ValType.Double))
                    {
                        Sprite.moveY(param[0].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double))
                    {
                        Sprite.moveY(param[0].IntValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        Sprite.moveY(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                           param[3].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Double,
                                               ValType.Double))
                    {
                        Sprite.moveY(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].DoubleValue, param[4].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "move":
                    if (Value.TypeCompare(param, ValType.Integer, ValType.Integer))
                    {
                        Sprite.move(param[0].IntValue, param[1].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        Sprite.move(param[0].IntValue, param[1].IntValue, param[2].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer))
                    {
                        Sprite.move(param[0].IntValue, param[1].IntValue, param[2].IntValue, param[3].IntValue,
                                          param[4].IntValue, param[5].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        Sprite.move(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                          param[3].IntValue, param[4].IntValue, param[5].IntValue,
                                          param[6].IntValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "scaleVec":
                    if (Value.TypeCompare(param, ValType.Double, ValType.Double))
                    {
                        Sprite.scaleVec(param[0].DoubleValue, param[1].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Double, ValType.Double))
                    {
                        Sprite.scaleVec(param[0].IntValue, param[1].DoubleValue, param[2].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Double, ValType.Double,
                                               ValType.Double, ValType.Double))
                    {
                        Sprite.scaleVec(param[0].IntValue, param[1].IntValue, param[2].DoubleValue,
                                              param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Double, ValType.Double, ValType.Double, ValType.Double))
                    {
                        Sprite.scaleVec(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                              param[3].DoubleValue, param[4].DoubleValue, param[5].DoubleValue,
                                              param[6].DoubleValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));

                case "color":
                    if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer))
                    {
                        Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer))
                    {
                        Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].IntValue, param[4].IntValue, param[5].IntValue,
                                           param[6].IntValue, param[7].IntValue);
                        return Value.VOID;
                    }
                    else if (Value.TypeCompare(param, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer, ValType.Integer, ValType.Integer,
                                               ValType.Integer, ValType.Integer))
                    {
                        Sprite.color(param[0].IntValue, param[1].IntValue, param[2].IntValue,
                                           param[3].IntValue, param[4].IntValue, param[5].IntValue,
                                           param[6].IntValue, param[7].IntValue, param[8].IntValue);
                        return Value.VOID;
                    }
                    else
                        throw new CompilerException(-1, 313, Name, name, Value.PrintTypeList(param));


                default:
                    throw new CompilerException(-1, 314, Name, name);
            }
            //TODO: Exception
            throw new Exception();
        }
コード例 #24
0
ファイル: LibraryManager.cs プロジェクト: Bannersean/osu-sgl
 public Function GetFunction(string name, List<Value> parameters)
 {
     // look if the function exists
     if (functions.ContainsKey(name))
     {
         try
         {
             return functions[name];
         }
         catch (CompilerException ce)
         {
             if (ce.ErrorCode == 312)
             {
                 ce.SetArguments(name, Value.PrintTypeList(parameters));
             }
             throw ce;
         }
     }
     else
     {
         throw new CompilerException(-1, 311, name, Value.PrintTypeList(parameters));
     }
 }
コード例 #25
0
ファイル: MeshClass.cs プロジェクト: brianex/osu-sgl
			public override Value InvokeMethod(string name, List<Value> parameters) {
				switch (name) {
					case "getV0":
					case "getVertex0":
						return new Value(new VertexClass(edge.V0), ValType.Object);

					case "getV1":
					case "getVertex1":
						return new Value(new VertexClass(edge.V1), ValType.Object);

					case "getV0Index":
					case "getVertex0Index":
						return new Value(edge.V0Index, ValType.Integer);

					case "getV1Index":
					case "getVertex1Index":
						return new Value(edge.V0Index, ValType.Integer);

					default:
						throw new CompilerException(-1, 314, Name, name);
				}
			}