/// <summary> /// The method that represents the 'load' function in the language. /// Loads a script file with the specified file name (given by a TString) and runs it. /// </summary> /// <param name="interpreter">The interpreter that the method is being called from.</param> /// <param name="args">The arguments being passed to the function as a TArgumentList.</param> /// <returns>TNil</returns> public static TType Load(Interpreter interpreter, TArgumentList args) { TString fileName = args[0] as TString; if (fileName == null) { return(new TException(interpreter, "Name of file to load must be given as a string")); } interpreter.LoadFile(fileName.Value); return(TNil.Instance); }
/// <summary> /// The method that represents the 'read' function in the language. /// Reads in a string and converts it into the most suitable TType. /// If the string cannot be converted, it just returns the string as a TString. /// </summary> /// <param name="interpreter">The interpreter that the method is being called from.</param> /// <param name="args">The arguments being passed to the function as a TArgumentList.</param> /// <returns>An TType of the type that the entered string represents best.</returns> public static TType Read(Interpreter interpreter, TArgumentList args) { // Read in a string and convert it to a suitable TType with TType.Parse. string str = System.Console.ReadLine(); TType value = TType.Parse(interpreter, str); if (value is TException) { value = new TString(str); // If the string can't be parsed, return it as a TString } return(value); }
/// <summary> /// The method that represents the 'random' function in the language. /// Generates a random TInteger between 0 and the given value - 1. /// </summary> /// <param name="interpreter">The interpreter that the method is being called from.</param> /// <param name="args">The arguments being passed to the function as a TArgumentList.</param> /// <returns>An TInteger with a value between 0 and the given value - 1</returns> public static TType Random(Interpreter interpreter, TArgumentList args) { // Check if the argument passed is a number, and return a new TInteger from the random value generated TNumber maximum = args[0] as TNumber; if (maximum == null) { return(new TException(interpreter, "Arguments of type '" + args[0].TypeName + "' cannot be used by random function")); } return(new TInteger(randomNumberGenerator.Next((int)maximum.TIntegerValue))); }
/// <summary> /// The method that represents the 'print' function in the language. /// Takes any number of values and writes their string values. /// </summary> /// <param name="interpreter">The interpreter that the method is being called from.</param> /// <param name="args">The arguments being passed to the function as a TArgumentList.</param> /// <returns>TNil</returns> public static TType Print(Interpreter interpreter, TArgumentList args) { // Loop through arguments, append their string values to a StringBuilder, and output the StringBuilder StringBuilder str = new StringBuilder(); for (int i = 0; i < args.Count; ++i) { TString arg = args[i] as TString; if (arg == null) { str.Append(args[i].ToCSString()); } else { str.Append(arg.Value); } } System.Console.WriteLine(str); return(TNil.Instance); }
/// <summary> /// The method that represents the 'exit' function in the language. /// Exits from the current function, returning any value passed to the function. /// </summary> /// <param name="interpreter">The interpreter that the method is being called from.</param> /// <param name="args">The arguments being passed to the function as a TArgumentList.</param> /// <returns>The argument passed to the function. If no arguments were passed, it returns TNil.</returns> public static TType Exit(Interpreter interpreter, TArgumentList args) { // Get the argument passed (if any) to return TType returnValue = TNil.Instance; if (args.Count > 0) { returnValue = args[0]; } // Pops from the function stack or kill the interpreter if the stack level is already at it's lowest // When this method returns, the calling method should check the stack level and exit accordingly if (interpreter.Stack.Level <= 1) { interpreter.Kill(); } else { interpreter.Stack.Pop(); } return(returnValue); }
/// <summary> /// The method that represents the 'read_string' function in the language. /// Reads in a string returns it as a TString. /// </summary> /// <param name="interpreter">The interpreter that the method is being called from.</param> /// <param name="args">The arguments being passed to the function as a TArgumentList.</param> /// <returns>An TString representing the string that was entered.</returns> public static TType ReadString(Interpreter interpreter, TArgumentList args) { return(new TString(System.Console.ReadLine())); }