internal override SObject ExecuteMethod(ScriptProcessor processor, string methodName, SObject caller, SObject This, SObject[] parameters)
{
InitializeStatic();
AddObjectPrototypeAsExtends(processor);
bool isStaticCall = ReferenceEquals(caller, this);
// Call any static function defined in this prototype:
if (_prototypeMembers.ContainsKey(methodName) && _prototypeMembers[methodName].IsStatic)
{
if (_prototypeMembers[methodName].IsFunction)
{
var cFunction = (SFunction)_prototypeMembers[methodName].Data;
return cFunction.Call(processor, caller, this, parameters); // For a static method, the "This" attribute is the prototype.
}
else
{
return processor.ErrorHandler.ThrowError(ErrorType.TypeError, ErrorHandler.MESSAGE_TYPE_NOT_A_FUNCTION, methodName);
}
}
// Call the super class prototype, if one exists:
if (Extends != null)
{
return Extends.ExecuteMethod(processor, methodName, caller, This, parameters);
}
return processor.ErrorHandler.ThrowError(ErrorType.ReferenceError, ErrorHandler.MESSAGE_REFERENCE_NOT_DEFINED, methodName);
}
internal override SNumber ToNumber(ScriptProcessor processor)
{
if (Value)
return processor.CreateNumber(1);
else
return processor.CreateNumber(0);
}
internal static string AddOperator(ScriptProcessor processor, SObject left, SObject right)
{
if (left is SString || right is SString)
{
string strLeft, strRight;
if (left is SString)
strLeft = ((SString)left).Value;
else
strLeft = left.ToString(processor).Value;
if (right is SString)
strRight = ((SString)right).Value;
else
strRight = right.ToString(processor).Value;
return strLeft + strRight;
}
else
{
var numbers = GetNumericOperatorParameters(processor, left, right);
return SNumber.ConvertToScriptString(numbers.Item1 + numbers.Item2);
}
}
public static SObject Create(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
Prototype prototype = null;
if (parameters.Length > 0)
{
var protoParam = parameters[0];
if (protoParam.TypeOf() == LITERAL_TYPE_STRING)
{
prototype = processor.Context.GetPrototype(((SString)protoParam).Value);
}
else if (IsPrototype(protoParam.GetType()))
{
prototype = (Prototype)protoParam;
}
else
{
return processor.ErrorHandler.ThrowError(ErrorType.TypeError, ErrorHandler.MESSAGE_REFERENCE_NO_PROTOTYPE, protoParam.TypeOf());
}
}
if (prototype != null)
{
var instParams = new SObject[parameters.Length - 1];
Array.Copy(parameters, 1, instParams, 0, parameters.Length - 1);
return processor.Context.CreateInstance(prototype, instParams);
}
else
{
return processor.ErrorHandler.ThrowError(ErrorType.TypeError, ErrorHandler.MESSAGE_REFERENCE_NO_PROTOTYPE, LITERAL_UNDEFINED);
}
}
internal override SObject GetMember(ScriptProcessor processor, SObject accessor, bool isIndexer)
{
if (isIndexer && accessor.TypeOf() == LITERAL_TYPE_NUMBER)
{
if (IndexerGetFunction != null)
{
return IndexerGetFunction.Call(processor, this, this, new SObject[] { accessor });
}
else
{
return processor.Undefined;
}
}
string memberName;
if (accessor is SString)
memberName = ((SString)accessor).Value;
else
memberName = accessor.ToString(processor).Value;
if (Members.ContainsKey(memberName))
{
return Members[memberName];
}
else if (Prototype != null && Prototype.HasMember(processor, memberName))
{
return Prototype.GetMember(processor, accessor, isIndexer);
}
else if (SuperClass != null)
{
return SuperClass.GetMember(processor, accessor, isIndexer);
}
return processor.Undefined;
}
internal override bool HasMember(ScriptProcessor processor, string memberName)
{
if (_prototypeMembers.ContainsKey(memberName))
return true;
else
return base.HasMember(processor, memberName);
}
/// <summary>
/// Returns the content of a variable, or Undefined, if the variable does not exist.
/// </summary>
public static SObject GetVariable(ScriptProcessor processor, string identifier)
{
if (processor.Context.IsVariable(identifier))
return processor.Context.GetVariable(identifier).Data;
else
return processor.Undefined;
}
public static SObject IndexerSet(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var arr = (SArray)instance;
if (parameters.Length >= 2)
{
var accessor = (int)parameters[0].ToNumber(processor).Value;
if (accessor >= 0)
{
if (accessor < arr.ArrayMembers.Length)
{
arr.ArrayMembers[accessor] = parameters[1];
}
else
{
var arrMembers = arr.ArrayMembers;
Array.Resize(ref arrMembers, accessor + 1);
arrMembers[accessor] = parameters[1];
arr.ArrayMembers = arrMembers;
}
}
}
return processor.Undefined;
}
public ErrorPrototype(ScriptProcessor processor) : base("Error")
{
Constructor = new PrototypeMember(CLASS_METHOD_CTOR, new SFunction(constructor));
AddMember(processor, new PrototypeMember(MEMBER_NAME_MESSAGE, processor.Undefined));
AddMember(processor, new PrototypeMember(MEMBER_NAME_TYPE, processor.Undefined));
AddMember(processor, new PrototypeMember(MEMBER_NAME_LINE, processor.Undefined));
}
/// <summary>
/// Parses a string as an array.
/// </summary>
internal new static SObject Parse(ScriptProcessor processor, string exp)
{
// Format: [item1, item2, ... itemn]
if (Regex.IsMatch(exp, REGEX_EMPTY_ARRAY)) return processor.CreateArray(0);
exp = exp.Remove(exp.Length - 1, 1).Remove(0, 1).Trim(); // Remove [ and ].
var elements = new List<SObject>();
var elementStart = 0;
var index = 0;
var depth = 0;
StringEscapeHelper escaper = new LeftToRightStringEscapeHelper(exp, 0);
string element;
while (index < exp.Length)
{
var t = exp[index];
escaper.CheckStartAt(index);
if (!escaper.IsString)
{
if (t == '{' || t == '[' || t == '(')
{
depth++;
}
else if (t == '}' || t == ']' || t == ')')
{
depth--;
}
else if (t == ',' && depth == 0)
{
element = exp.Substring(elementStart, index - elementStart);
if (string.IsNullOrWhiteSpace(element))
elements.Add(processor.Undefined);
else
elements.Add(processor.ExecuteStatement(new ScriptStatement(element)));
elementStart = index + 1;
}
}
index++;
}
element = exp.Substring(elementStart, index - elementStart);
if (string.IsNullOrWhiteSpace(element))
elements.Add(processor.Undefined);
else
elements.Add(processor.ExecuteStatement(new ScriptStatement(element)));
return processor.CreateArray(elements.ToArray());
}
private static SObject constructor(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var arr = (SArray)instance;
var length = (int)((SNumber)parameters[0]).Value;
arr.ArrayMembers = new SObject[length];
Array.Copy(parameters, 1, arr.ArrayMembers, 0, parameters.Length - 1);
return arr;
}
/// <summary>
/// Translates a .Net object to a script object.
/// </summary>
public static SObject Translate(ScriptProcessor processor, object objIn)
{
// todo: C# 7: put a swtich statement type match instead of aweful if case blocks.
if (objIn == null)
{
return TranslateNull(processor);
}
if (objIn.GetType() == typeof(SObject) || objIn.GetType().IsSubclassOf(typeof(SObject)))
{
// this is already an SObject, return it.
return (SObject)objIn;
}
if (objIn is sbyte || objIn is byte || objIn is short || objIn is ushort || objIn is int || objIn is uint || objIn is long || objIn is ulong || objIn is float || objIn is double)
{
return TranslateNumber(processor, Convert.ToDouble(objIn));
}
else if (objIn is string || objIn is char)
{
return TranslateString(processor, objIn.ToString()); // ToString will return just the string for the string type, and a string from a char.
}
else if (objIn is bool)
{
return TranslateBool(processor, (bool)objIn);
}
else if (objIn is Type)
{
return TranslatePrototype(processor, (Type)objIn);
}
else if (objIn.GetType().IsArray)
{
return TranslateArray(processor, (Array)objIn);
}
else if (objIn is BuiltInMethod || objIn is DotNetBuiltInMethod)
{
return TranslateFunction((Delegate)objIn);
}
else if (objIn is ScriptRuntimeException)
{
return TranslateException((ScriptRuntimeException)objIn);
}
else if (objIn is NetUndefined)
{
return TranslateUndefined(processor);
}
else if (objIn is ExpandoObject)
{
return TranslateExpandoObject(processor, objIn as ExpandoObject);
}
else
{
return TranslateObject(processor, objIn);
}
}
private static SObject constructor(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var obj = (SNumber)instance;
if (parameters[0] is SNumber)
obj.Value = ((SNumber)parameters[0]).Value;
else
obj.Value = parameters[0].ToNumber(processor).Value;
return obj;
}
protected override object OnCalc(IList <object> operands)
{
if (operands.Count > 0)
{
string info = operands[0] as string;
if (null != info)
{
ScriptProcessor.End(info);
}
}
return(0);
}
// TODO: C# 7: put proper Tuple handling in place.
private static Tuple <PrototypeMember, string> ParseVarStatement(ScriptProcessor processor, ScriptStatement statement)
{
var code = statement.Code;
var signature = code.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
string identifier;
var assignment = "";
var isReadOnly = false;
var isStatic = false;
// Read static:
if (signature.Contains(VAR_SIGNATURE_STATIC))
{
isStatic = true;
signature.Remove(VAR_SIGNATURE_STATIC);
}
// Read readonly:
if (signature.Contains(VAR_SIGNATURE_READONLY))
{
isReadOnly = true;
signature.Remove(VAR_SIGNATURE_READONLY);
}
if (signature[0] != "var" || signature.Count < 2)
{
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MESSAGE_SYNTAX_CLASS_INVALID_VAR_DECLARATION);
}
identifier = signature[1];
if (!ScriptProcessor.IsValidIdentifier(identifier))
{
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MESSAGE_SYNTAX_MISSING_VAR_NAME);
}
if (signature.Count > 2)
{
if (signature[2].StartsWith("="))
{
assignment = code.Remove(0, code.IndexOf("=") + 1).Trim();
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MESSAGE_SYNTAX_CLASS_INVALID_VAR_DECLARATION);
}
}
var member = new PrototypeMember(identifier, processor.Undefined, isStatic, isReadOnly, false, false);
return(new Tuple <PrototypeMember, string>(member, assignment));
}
/// <summary>
/// Creates an instance derived from this prototype.
/// </summary>
internal SProtoObject CreateInstance(ScriptProcessor processor, SObject[] parameters, bool executeCtor)
{
SProtoObject obj = CreateBaseObject();
obj.IsProtoInstance = true;
obj.AddMember(MEMBER_NAME_PROTOTYPE, this);
if (typeof(ObjectPrototype) != GetType())
{
// If no extends class is explicitly specified, "Object" is assumed.
if (Extends == null)
{
Extends = processor.Context.GetPrototype("Object");
}
var superInstance = Extends.CreateInstance(processor, null, true);
obj.AddMember(MEMBER_NAME_SUPER, superInstance);
}
foreach (var member in GetInstanceMembers())
{
obj.AddMember(member.Identifier, member.Data);
}
var indexerGetFunction = GetIndexerGetFunction();
if (indexerGetFunction != null)
{
obj.IndexerGetFunction = indexerGetFunction;
}
var indexerSetFunction = GetIndexerSetFunction();
if (indexerSetFunction != null)
{
obj.IndexerSetFunction = indexerSetFunction;
}
if (executeCtor)
{
Constructor?.ToFunction().Call(processor, obj, obj, parameters);
}
// Lock all readonly members after the constructor call, so they can be set in the constructor:
foreach (PrototypeMember member in GetReadOnlyInstanceMembers())
{
obj.Members[member.Identifier].IsReadOnly = true;
}
return(obj);
}
private ScriptProcessor CreateProcessor()
{
if (_prototypeBuffer == null)
{
InitializePrototypeBuffer();
}
var processor = new ScriptProcessor(_prototypeBuffer);
ScriptContextManipulator.SetCallbackExecuteMethod(processor, ExecuteMethod);
return(processor);
}
internal override void SetMember(ScriptProcessor processor, SObject accessor, bool isIndexer, SObject value)
{
if (processor.Context.HasCallback(CallbackType.SetMember))
{
var callback = (DSetMember)processor.Context.GetCallback(CallbackType.SetMember);
var task = Task.Factory.StartNew(() => callback(processor, ModuleName, accessor, isIndexer, value));
task.Wait();
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.APIError, ErrorHandler.MESSAGE_API_NOT_SUPPORTED);
}
}
public static SObject Where(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
if (parameters.Length >= 1)
{
var arr = (SArray)instance;
var comparer = (SFunction)Unbox(parameters[0]);
var results = arr.ArrayMembers.Where((m, i) => ((SBool)comparer.Call(processor, This, This, new[] { m, processor.CreateNumber(i) })).Value);
return(processor.CreateArray(results.ToArray()));
}
return(processor.Undefined);
}
public static SObject Select(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
if (parameters.Length >= 1)
{
var arr = (SArray)instance;
var comparer = (SFunction)Unbox(parameters[0]);
var result = arr.ArrayMembers.Select(m => comparer.Call(processor, This, This, new[] { m }));
return(processor.CreateArray(result.ToArray()));
}
return(processor.Undefined);
}
internal override SObject ExecuteMethod(ScriptProcessor processor, string methodName, SObject caller, SObject This, SObject[] parameters)
{
// The statement that entered this method looks like this: this.varName(), where varName is a variable containing an SFunction object.
if (_context.IsVariable(methodName))
{
var methodVariable = _context.GetVariable(methodName);
var function = methodVariable.Data as SFunction;
return(function != null?function.Call(processor, caller, This, parameters)
: processor.ErrorHandler.ThrowError(ErrorType.TypeError, ErrorHandler.MessageTypeNotAFunction, methodName));
}
return(processor.ErrorHandler.ThrowError(ErrorType.ReferenceError, ErrorHandler.MessageReferenceNotDefined, methodName));
}
public static SObject show(ScriptProcessor processor, SObject[] parameters)
{
// TODO: get correct location from world screen
var screenManager = GetComponent <ScreenManager>();
var townMapScreen = new TownMapScreen(screenManager.ActiveScreen, "johto", "New Bark Town");
townMapScreen.LoadContent();
screenManager.SetScreen(townMapScreen);
ScriptManager.WaitUntil(() => !(screenManager.ActiveScreen is TownMapScreen));
return(ScriptInAdapter.GetUndefined(processor));
}
protected override object OnCalc(IList <object> operands)
{
if (operands.Count > 1)
{
string file = operands[0] as string;
string info = operands[1] as string;
if (!string.IsNullOrEmpty(file) && null != info)
{
ScriptProcessor.BeginFile(file, info);
}
}
return(0);
}
public static SObject All(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
if (parameters.Length >= 1)
{
var arr = (SArray)instance;
var comparer = (SFunction)Unbox(parameters[0]);
var result = arr.ArrayMembers.All(m => ((SBool)comparer.Call(processor, This, This, new[] { m })).Value);
return(processor.CreateBool(result));
}
return(processor.Undefined);
}
internal override void SetMember(ScriptProcessor processor, SObject accessor, bool isIndexer, SObject value)
{
if (processor.Context.HasCallback(CallbackType.SetMember))
{
var callback = (DSetMember)processor.Context.GetCallback(CallbackType.SetMember);
var task = Task.Factory.StartNew(() => callback(processor, ModuleName, accessor, isIndexer, value));
task.Wait();
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.APIError, ErrorHandler.MESSAGE_API_NOT_SUPPORTED);
}
}
public static SObject Replace(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
if (TypeContract.Ensure(parameters, new[] { typeof(SString), typeof(SString) }))
{
var str = ((SString)instance).Value;
var replace = ((SString)parameters[0]).Value;
var with = ((SString)parameters[1]).Value;
return(processor.CreateString(string.IsNullOrWhiteSpace(replace) ? str : str.Replace(replace, with)));
}
return(processor.Undefined);
}
// TODO: C# 7: put proper Tuple handling in place.
private static Tuple <PrototypeMember, string> ParseVarStatement(ScriptProcessor processor, ScriptStatement statement)
{
var code = statement.Code;
var signature = code.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
var assignment = "";
var isReadOnly = false;
var isStatic = false;
// Read static:
if (signature.Contains(VarSignatureStatic))
{
isStatic = true;
signature.Remove(VarSignatureStatic);
}
// Read readonly:
if (signature.Contains(VarSignatureReadonly))
{
isReadOnly = true;
signature.Remove(VarSignatureReadonly);
}
if (signature[0] != "var" || signature.Count < 2)
{
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxClassInvalidVarDeclaration);
}
var identifier = signature[1];
if (!ScriptProcessor.IsValidIdentifier(identifier))
{
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxMissingVarName);
}
if (signature.Count > 2)
{
if (signature[2].StartsWith("="))
{
assignment = code.Remove(0, code.IndexOf("=", StringComparison.Ordinal) + 1).Trim();
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxClassInvalidVarDeclaration);
}
}
var member = new PrototypeMember(identifier, processor.Undefined, isStatic, isReadOnly, false, false);
return(new Tuple <PrototypeMember, string>(member, assignment));
}
public static SObject getEntity(ScriptProcessor processor, SObject[] parameters)
{
object[] netObjects;
if (EnsureTypeContract(parameters, new[] { typeof(string) }, out netObjects))
{
var entity = new EntityWrapper {
id = (string)netObjects[0]
};
return(ScriptInAdapter.Translate(processor, entity));
}
return(ScriptInAdapter.GetUndefined(processor));
}
static Program()
{
var streams = new List <StreamReader>();
logger = new Logger();
presentationLogic = new PresentationLogic();
var encryptionProcessor = new Processor();
IScriptProcessor scriptProcessor = new ScriptProcessor(encryptionProcessor);
IFileProcessor fileProcessor = new FileProcessor(streams);
IEmailProcessor emailProcessor = new EmailProcessor();
IDatabaseLogic databaseLogic = new DatabaseLogic();
businessLogic = new BusinessLogic(logger, scriptProcessor, fileProcessor, emailProcessor, databaseLogic);
}
private static SObject constructor(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var obj = (SError)instance;
if (parameters.Length > 0)
{
SString message;
if (parameters[0] is SString)
message = (SString)parameters[0];
else
message = parameters[0].ToString(processor);
obj.Members[MEMBER_NAME_MESSAGE].Data = message;
}
if (parameters.Length > 1)
{
SString errorType;
if (parameters[1] is SString)
errorType = (SString)parameters[1];
else
errorType = parameters[1].ToString(processor);
obj.Members[MEMBER_NAME_TYPE].Data = errorType;
}
else
{
obj.Members[MEMBER_NAME_TYPE].Data = processor.CreateString("UserError");
}
if (parameters.Length > 2)
{
SNumber errorLine;
if (parameters[2] is SNumber)
errorLine = (SNumber)parameters[2];
else
errorLine = parameters[2].ToNumber(processor);
obj.Members[MEMBER_NAME_LINE].Data = errorLine;
}
else
{
obj.Members[MEMBER_NAME_LINE].Data = processor.CreateNumber(-1);
}
return obj;
}
internal override void SetMember(ScriptProcessor processor, SObject accessor, bool isIndexer, SObject value)
{
var accessorAsString = accessor as SString;
var memberName = accessorAsString != null ? accessorAsString.Value : accessor.ToString(processor).Value;
if (_context.IsVariable(memberName))
{
_context.GetVariable(memberName).Data = value;
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.ReferenceError, ErrorHandler.MessageReferenceNotDefined, memberName);
}
}
private static SObject constructor(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var obj = (SString)instance;
if (parameters[0] is SString)
{
obj.Value = ((SString)parameters[0]).Value;
obj.Escaped = ((SString)parameters[0]).Escaped;
}
else
obj.Value = parameters[0].ToString(processor).Value;
return obj;
}
internal override SObject GetMember(ScriptProcessor processor, SObject accessor, bool isIndexer)
{
if (isIndexer && accessor.TypeOf() == LITERAL_TYPE_NUMBER)
{
if (Prototype.GetIndexerGetFunction() != IndexerGetFunction)
{
IndexerGetFunction = Prototype.GetIndexerGetFunction();
}
if (IndexerGetFunction != null)
{
return(IndexerGetFunction.Call(processor, this, this, new SObject[] { accessor }));
}
else
{
return(processor.Undefined);
}
}
string memberName;
if (accessor is SString)
{
memberName = ((SString)accessor).Value;
}
else
{
memberName = accessor.ToString(processor).Value;
}
if (Members.ContainsKey(PROPERTY_GET_PREFIX + memberName)) // getter property
{
return(((SFunction)Members[PROPERTY_GET_PREFIX + memberName].Data).Call(processor, this, this, new SObject[] { }));
}
else if (Members.ContainsKey(memberName))
{
return(Members[memberName]);
}
else if (Prototype != null && Prototype.HasMember(processor, memberName))
{
return(Prototype.GetMember(processor, accessor, isIndexer));
}
else if (SuperClass != null)
{
return(SuperClass.GetMember(processor, accessor, isIndexer));
}
return(processor.Undefined);
}
private IEnumerable <string> physicalPathsOf(IEnumerable <AutoBundleItem> autoBundleItems, HashSet <string> excludedFiles)
{
var baseUrl = Path.Combine(ProjectPath, "Scripts");
foreach (var item in autoBundleItems)
{
// check if the file path is actually an URL
if (!string.IsNullOrEmpty(item.File) && !item.File.Contains("?"))
{
item.File = ScriptProcessor.ExpandPaths(item.File, Configuration);
if (!excludedFiles.Contains(item.File))
{
var physicalPath = this.ResolvePhysicalPath(item.File, baseUrl);
if (physicalPath == null)
{
Log?.LogError($"Could not to resolve path for {item.File}. File does not exist in {baseUrl}! Did you forget to include it in the project?");
}
yield return(physicalPath);
}
else
{
Log?.LogMessage(LogLevel, $" - EXCLUDING {item.File}");
}
}
else if (!string.IsNullOrEmpty(item.Directory))
{
item.Directory = ScriptProcessor.ExpandPaths(item.Directory, Configuration);
var absDirectory = this.GetAbsoluteDirectory(item.Directory);
Log?.LogMessage(LogLevel, $" - Directory '{item.Directory}' -> {absDirectory}");
// not using filter for this since we're going to use the one the user provided in the future
var dirFiles = Directory.GetFiles(absDirectory, "*", SearchOption.AllDirectories).Where(r => Path.GetExtension(r) == ".js").ToList();
foreach (var file in dirFiles)
{
#warning We try to match absolute paths here while we match relative paths above?!
if (!excludedFiles.Contains(file))
{
yield return(file);
}
else
{
Log?.LogMessage(LogLevel, $" - EXCLUDING {file} from {item.Directory}");
}
}
}
}
}
private static SObject constructor(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var obj = (SNumber)instance;
if (parameters[0] is SNumber)
{
obj.Value = ((SNumber)parameters[0]).Value;
}
else
{
obj.Value = parameters[0].ToNumber(processor).Value;
}
return(obj);
}
internal static string IncrementOperator(ScriptProcessor processor, SObject obj)
{
// Only variables can be incremented:
var variable = obj as SVariable;
if (variable != null)
{
var svar = variable;
svar.Data = processor.CreateNumber(svar.Data.ToNumber(processor).Value + 1D);
return(svar.Identifier);
}
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MessageSyntaxInvalidIncrement);
return("");
}
/// <summary>
/// Multiplies an object with -1.
/// </summary>
internal static SObject NegateNumber(ScriptProcessor processor, SObject obj)
{
double number;
if (obj is SNumber)
{
number = ((SNumber)obj).Value;
}
else
{
number = obj.ToNumber(processor).Value;
}
return(processor.CreateNumber(number * -1));
}
public static void Main(string[] args)
{
int totalTests = 0;
int passedTests = 0;
var goodScripts = Directory.GetFiles("test-scripts", "T*");
foreach (var script in goodScripts)
{
var pass = true;
Console.Write(script + ":");
try {
var scriptParser = new ScriptProcessor(new StreamReader(File.OpenRead(script)), new VendingMachineFactory());
scriptParser.Parse();
}
catch {
pass = false;
}
Console.WriteLine(pass ? " PASS=Good" : " FAIL=Bad");
if (pass)
{
passedTests++;
}
totalTests++;
}
var badScripts = Directory.GetFiles("test-scripts", "U*");
foreach (var script in badScripts)
{
var pass = true;
Console.Write(script + ":");
try {
var scriptParser = new ScriptProcessor(new StreamReader(File.OpenRead(script)), new VendingMachineFactory());
scriptParser.Parse();
}
catch {
pass = false;
}
Console.WriteLine(pass ? " PASS=Bad" : " FAIL=Good");
if (!pass)
{
passedTests++;
}
totalTests++;
}
Console.WriteLine("{0}/{1} tests passed", passedTests, totalTests);
Console.ReadLine();
}
private static Tuple<double, double> GetNumericOperatorParameters(ScriptProcessor processor, SObject left, SObject right)
{
double numLeft, numRight;
if (left is SNumber)
numLeft = ((SNumber)left).Value;
else
numLeft = left.ToNumber(processor).Value;
if (right is SNumber)
numRight = ((SNumber)right).Value;
else
numRight = right.ToNumber(processor).Value;
return new Tuple<double, double>(numLeft, numRight);
}
public void ServerScriptValidate()
{
IDataScripter scripter = new VueDataScripter(_host, _localizer);
var sp = new ScriptProcessor(scripter, _host);
var ssi = new ServerScriptInfo()
{
DataModel = _dbContext.LoadModel(null, "a2test.[Document.Load]"),
Template = "document.template",
Path = "document/server",
RawData = "{Document: {Id:173}}",
Parameter = new { Id = 123, Text = "ParamText" }
};
var result = sp.ValidateModel(ssi);
Assert.IsNull(result);
}
private static Tuple<bool, bool> GetBooleanicOperatorParameters(ScriptProcessor processor, SObject left, SObject right)
{
bool boolLeft, boolRight;
if (left is SBool)
boolLeft = ((SBool)left).Value;
else
boolLeft = left.ToBool(processor).Value;
if (right is SBool)
boolRight = ((SBool)right).Value;
else
boolRight = right.ToBool(processor).Value;
return new Tuple<bool, bool>(boolLeft, boolRight);
}
private static void InitializePrototypeBuffer()
{
// load all defined prototypes once to store them in a buffer.
// these prototypes get added to all newly created ScriptProcessors.
_prototypeBuffer = new List <SObject>();
var processor = new ScriptProcessor();
foreach (var assembly in GetSourceAssemblies())
{
foreach (var t in assembly.GetTypes().Where(t => t.GetCustomAttributes(typeof(ScriptPrototypeAttribute), true).Length > 0))
{
_prototypeBuffer.Add(ScriptInAdapter.Translate(processor, t));
}
}
}
internal override bool HasMember(ScriptProcessor processor, string memberName)
{
if (Members.ContainsKey(memberName))
{
return(true);
}
else if (Prototype != null && Prototype.HasMember(processor, memberName))
{
return(true);
}
else if (SuperClass != null)
{
return(SuperClass.HasMember(processor, memberName));
}
return(false);
}
private static SObject ExecuteMethod(ScriptProcessor processor, string className, string methodName, SObject[] parameters)
{
if (_apiClasses.ContainsKey(className))
{
var method = _apiClasses[className].FirstOrDefault(m => m.Name == methodName);
if (method != null)
{
var result = method.Invoke(null, new object[] { processor, parameters });
return((SObject)result);
}
}
// fallback, in case no class/method was found:
return(ScriptInAdapter.GetUndefined(processor));
}
internal override bool HasMember(ScriptProcessor processor, string memberName)
{
if (processor.Context.HasCallback(CallbackType.HasMember))
{
var callback = (DHasMember)processor.Context.GetCallback(CallbackType.HasMember);
var task = Task<bool>.Factory.StartNew(() => callback(processor, ModuleName, memberName));
task.Wait();
return task.Result;
}
else
{
// If no API callback function is added to check for member existence, then we just assume that no member exists and return false.
return false;
}
}
public static SObject load(ScriptProcessor processor, SObject[] parameters)
{
object[] netObjects;
if (EnsureTypeContract(parameters, new[] { typeof(string), typeof(Vector3Wrapper) }, out netObjects))
{
var screen = (OverworldScreen)GameProvider.GameInstance.GetService <ScreenManager>().CurrentScreen;
var position = netObjects[1] as Vector3Wrapper;
if (position != null)
{
screen.ActiveWorld.LoadMap(netObjects[0] as string, position.X, position.Y, position.Z);
}
}
return(ScriptInAdapter.GetUndefined(processor));
}
internal override SObject ExecuteMethod(ScriptProcessor processor, string methodName, SObject caller, SObject This, SObject[] parameters)
{
if (processor.Context.HasCallback(CallbackType.ExecuteMethod))
{
var callback = (DExecuteMethod)processor.Context.GetCallback(CallbackType.ExecuteMethod);
var task = Task<SObject>.Factory.StartNew(() => callback(processor, ModuleName, methodName, parameters));
task.Wait();
return task.Result;
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.APIError, ErrorHandler.MESSAGE_API_NOT_SUPPORTED);
return processor.Undefined;
}
}
internal override SObject GetMember(ScriptProcessor processor, SObject accessor, bool isIndexer)
{
if (processor.Context.HasCallback(CallbackType.GetMember))
{
var callback = (DGetMember)processor.Context.GetCallback(CallbackType.GetMember);
var task = Task<SObject>.Factory.StartNew(() => callback(processor, ModuleName, accessor, isIndexer));
task.Wait();
return task.Result;
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.APIError, ErrorHandler.MESSAGE_API_NOT_SUPPORTED);
return processor.Undefined;
}
}
internal override bool HasMember(ScriptProcessor processor, string memberName)
{
if (Members.ContainsKey(memberName))
{
return true;
}
else if (Prototype != null && Prototype.HasMember(processor, memberName))
{
return true;
}
else if (SuperClass != null)
{
return SuperClass.HasMember(processor, memberName);
}
return false;
}
public static SObject Pop(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var arr = (SArray)instance;
if (arr.ArrayMembers.Length > 0)
{
var newItems = new SObject[arr.ArrayMembers.Length - 1];
var returnItem = arr.ArrayMembers.Last();
Array.Copy(arr.ArrayMembers, newItems, arr.ArrayMembers.Length - 1);
arr.ArrayMembers = newItems;
return(returnItem);
}
return(processor.Undefined);
}
internal static string DecrementOperator(ScriptProcessor processor, SObject obj)
{
// Only variables can be decremented:
if (obj is SVariable)
{
var svar = (SVariable)obj;
svar.Data = processor.CreateNumber(svar.Data.ToNumber(processor).Value - 1D);
return(svar.Identifier);
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.SyntaxError, ErrorHandler.MESSAGE_SYNTAX_INVALID_DECREMENT);
return("");
}
}
private static SObject constructor(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var obj = (SString)instance;
if (parameters[0] is SString)
{
obj.Value = ((SString)parameters[0]).Value;
obj.Escaped = ((SString)parameters[0]).Escaped;
}
else
{
obj.Value = parameters[0].ToString(processor).Value;
}
return(obj);
}
internal override SObject GetMember(ScriptProcessor processor, SObject accessor, bool isIndexer)
{
string memberName;
if (accessor is SString)
memberName = ((SString)accessor).Value;
else
memberName = accessor.ToString(processor).Value;
if (_context.IsVariable(memberName))
{
return _context.GetVariable(memberName);
}
else
{
return processor.ErrorHandler.ThrowError(ErrorType.ReferenceError, ErrorHandler.MESSAGE_REFERENCE_NOT_DEFINED, new object[] { memberName });
}
}
public static SObject IndexerGet(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var arr = (SArray)instance;
if (parameters.Length >= 1)
{
var accessor = (int)parameters[0].ToNumber(processor).Value;
if (accessor >= 0 && accessor < arr.ArrayMembers.Length)
{
return arr.ArrayMembers[accessor] ??
processor.Undefined;
}
}
return processor.Undefined;
}
internal override void SetMember(ScriptProcessor processor, SObject accessor, bool isIndexer, SObject value)
{
string memberName;
if (accessor is SString)
memberName = ((SString)accessor).Value;
else
memberName = accessor.ToString(processor).Value;
if (_context.IsVariable(memberName))
{
_context.GetVariable(memberName).Data = value;
}
else
{
processor.ErrorHandler.ThrowError(ErrorType.ReferenceError, ErrorHandler.MESSAGE_REFERENCE_NOT_DEFINED, memberName );
}
}
public static SObject Concat(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
if (parameters.Length > 0)
{
var str = instance as SString;
string result = str.Value;
foreach (var param in parameters)
{
string concatStr = param.ToString(processor).Value;
result += concatStr;
}
return processor.CreateString(result);
}
return processor.CreateString((instance as SString).Value);
}
internal override SObject GetMember(ScriptProcessor processor, SObject accessor, bool isIndexer)
{
InitializeStatic();
string memberName;
if (accessor is SString)
memberName = ((SString)accessor).Value;
else
memberName = accessor.ToString(processor).Value;
if (_prototypeMembers.ContainsKey(memberName))
{
return _prototypeMembers[memberName].Data;
}
else
{
return processor.Undefined;
}
}
/// <summary>
/// Compares two objects for equality, respecting their typings.
/// </summary>
/// <remarks>Used by the === and !== equality operators.</remarks>
public static bool StrictEquals(ScriptProcessor processor, SObject left, SObject right)
{
left = SObject.Unbox(left);
right = SObject.Unbox(right);
if (left.TypeOf() != right.TypeOf())
{
return false;
}
// If they are undefined or null, return true:
else if (left.TypeOf() == SObject.LITERAL_UNDEFINED || left.TypeOf() == SObject.LITERAL_NULL)
{
return true;
}
// Both are numbers:
else if (left.TypeOf() == SObject.LITERAL_TYPE_NUMBER)
{
double numLeft = ((SNumber)left).Value;
double numRight = ((SNumber)right).Value;
return numLeft == numRight;
}
// Both are string:
else if (left.TypeOf() == SObject.LITERAL_TYPE_STRING)
{
string strLeft = ((SString)left).Value;
string strRight = ((SString)right).Value;
return strLeft == strRight;
}
// Both are bool:
else if (left.TypeOf() == SObject.LITERAL_TYPE_BOOL)
{
bool boolLeft = ((SBool)left).Value;
bool boolRight = ((SBool)right).Value;
return boolLeft == boolRight;
}
else
{
return ReferenceEquals(left, right);
}
}
internal override SObject ExecuteMethod(ScriptProcessor processor, string methodName, SObject caller, SObject This, SObject[] parameters)
{
// The statement that entered this method looks like this: this.varName(), where varName is a variable containing an SFunction object.
if (_context.IsVariable(methodName))
{
var methodVariable = _context.GetVariable(methodName);
var method = methodVariable.Data;
if (method is SFunction)
{
return ((SFunction)method).Call(processor, caller, This, parameters);
}
else
{
return processor.ErrorHandler.ThrowError(ErrorType.TypeError, ErrorHandler.MESSAGE_TYPE_NOT_A_FUNCTION, methodName );
}
}
return processor.ErrorHandler.ThrowError(ErrorType.ReferenceError, ErrorHandler.MESSAGE_REFERENCE_NOT_DEFINED, methodName );
}
public static SObject CharAt(ScriptProcessor processor, SObject instance, SObject This, SObject[] parameters)
{
var str = (instance as SString).Value;
if (str == "")
return processor.CreateString("");
if (TypeContract.Ensure(parameters, typeof(SNumber)))
{
var index = (int)(parameters[0] as SNumber).Value;
if (index < 0 || index >= str.Length)
return processor.CreateString("");
return processor.CreateString(str[index].ToString());
}
else
{
return processor.CreateString(str[0].ToString());
}
}
