static void Main(string[] args) { if (args.Length != 1) { DisplayDirections(); } else if (!File.Exists(args[0])) { Console.WriteLine("Could not find {0}", args[0]); Environment.Exit(1); } var code = File.ReadAllText(args[0]); EnvironmentLibrary.SetEnvArgs(true); var interpreter = new AphidInterpreter(); try { interpreter.Interpret(code); } catch (AphidParserException exception) { Console.WriteLine(ParserErrorMessage.Create(code, exception)); } catch (AphidRuntimeException exception) { Console.WriteLine("Unexpected runtime exception\r\n\r\n{0}\r\n", exception.Message); } }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); interpreter.Interpret("add = @(x, y) x + y;"); var x = interpreter.CallFunction("add", 3, 7).Value; Console.WriteLine(x); }
private static SelfTestAssembly[] LoadAssemblies() { var interpreter = new AphidInterpreter(); interpreter.InterpretFile(PathHelper.GetEntryPath("Tests.alx")); var retVal = interpreter.GetReturnValue(); return retVal.ConvertToArray<SelfTestAssembly>(); }
public static void Lock(AphidInterpreter interpreter, AphidObject obj, AphidFunction body) { lock (obj) { interpreter.CallFunction(body); } }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); interpreter.Interpret(@" #'Std'; print('Hello, world'); "); }
private AphidObject Execute(string script) { script = PrefixScript(script); var interpreter = new AphidInterpreter(); interpreter.Loader.SearchPaths.Add(Path.Combine(Environment.CurrentDirectory, "Library")); interpreter.Interpret(script); return interpreter.GetReturnValue(); }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); interpreter.CurrentScope.Add("x", new AphidObject("foo")); interpreter.Interpret(@" #'Std'; print(x); "); }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); interpreter.Interpret(@" #'Std'; add = @(x, y) x + y; print(add(3, 7)); "); }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); interpreter.Interpret(@" #'Std'; call = @(func) func(); foo = @() print('foo() called'); call(foo); "); }
static void Main(string[] args) { var interprer = new AphidInterpreter(); interprer.Loader.LoadModule(Assembly.GetExecutingAssembly()); interprer.Interpret(@" #'Std'; ##'InteropFunctionSample.AphidMath'; print(math.add(3, 7)); "); }
private static ManualResetEvent ThreadCore(AphidInterpreter interpreter, Action<Action> start, AphidFunction function, params object[] parms) { var reset = new ManualResetEvent(false); var interpreter2 = new AphidInterpreter(interpreter.CurrentScope); Action call = () => { interpreter2.CallFunction(function, parms); reset.Set(); }; start(call); return reset; }
public static AphidObject Execute(string filename) { AphidObject obj; if (_executeCache.TryGetValue(filename, out obj)) { return obj; } var interpreter = new AphidInterpreter(); Cli.WriteLine("Executing ~Cyan~{0}~R~", filename); interpreter.InterpretFile(filename); obj = interpreter.GetReturnValue();; _executeCache.Add(filename, obj); return obj; }
public CodeObject CreateCodeObject() { var interpreter = new AphidInterpreter(); interpreter.InterpretFile("ParserRules.alx"); var methods = interpreter .GetReturnValue() .ConvertTo<AphidParserRules>().BinaryOperatorExpressions .Select(CreateBinOpParseFunction) .ToArray(); var t = CreateParserType(methods); var ns = new CodeNamespace("Components.Aphid.Parser"); ns.Types.Add(t); return ns; }
public AphidObject Deserialize(string obj) { var lexer = new AphidObjectLexer(obj); var tokens = lexer.GetTokens(); tokens.Add(new AphidToken(AphidTokenType.EndOfStatement, null, 0)); var ast = new AphidParser(tokens).Parse(); if (ast.Count != 1) { throw new AphidRuntimeException("Invalid Aphid object string: {0}", obj); } ast[0] = new UnaryOperatorExpression(AphidTokenType.retKeyword, ast[0]); var objInterpreter = new AphidInterpreter(); objInterpreter.Interpret(ast); return objInterpreter.GetReturnValue(); }
public static void Extend(AphidInterpreter interpreter, string type, AphidObject extensions) { foreach (var extension in extensions) { var nameStr = extension.Key; var key = GetName(type, nameStr); if (interpreter.CurrentScope.ContainsKey(key)) { interpreter.CurrentScope[key] = extension.Value; } else { interpreter.CurrentScope.Add(key, extension.Value); } } }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); interpreter.Interpret(@" #'Std'; ret { name: 'My Widget', location: { x: 10, y: 20 } }; "); var widget = interpreter.GetReturnValue().ConvertTo<Widget>(); Console.WriteLine(widget); widget.Location.X = 40; var aphidWidget = AphidObject.ConvertFrom(widget); interpreter.CurrentScope.Add("w", aphidWidget); interpreter.Interpret(@"printf('New X value: {0}', w.location.x);"); }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); foreach (var test in _tests) { RunTest(test, 1); } foreach (var test in _tests) { Console.Write("Running {0} test {1:n0} times... ", test.Name, test.Iterations); var sw = new Stopwatch(); sw.Start(); RunTest(test, test.Iterations); sw.Stop(); Console.WriteLine("finished in {0:n0}ms", sw.ElapsedMilliseconds); } }
static void Main(string[] args) { var interpreter = new AphidInterpreter(); interpreter.Interpret("x = 'foo';"); Console.WriteLine(interpreter.CurrentScope["x"].Value); }
public static ManualResetEvent ThreadPoolQueue(AphidInterpreter interpreter, AphidFunction function, params object[] parms) { return ThreadCore(interpreter, x => ThreadPool.QueueUserWorkItem(y => x()), function, parms); }
public static ManualResetEvent StartThread(AphidInterpreter interpreter, AphidFunction function, params object[] parms) { return ThreadCore(interpreter, x => new Thread(y => x()).Start(), function, parms); }
static void Main(string[] args) { WriteHeader("Loading release settings"); var script = "PhpVH.alx"; Cli.WriteLine("Executing ~Cyan~{0}~R~", script); var interpreter = new AphidInterpreter(); interpreter.InterpretFile(script); _currentRelease = interpreter.GetReturnValue().ConvertTo<Release>(); var projects = _currentRelease.Projects; Cli.WriteLine(); WriteHeader("Copying binaries"); var outputDir = new DirectoryInfo(_currentRelease.Output) .Combine(GetReleaseVersion(projects).ToString()); if (outputDir.Exists) { Cli.WriteLine("Deleting ~Yellow~{0}~R~", outputDir.FullName); outputDir.Delete(true); } Cli.WriteLine(); WriteProgressHeader("Copying"); var progress = new CliProgressBar(projects.Length); progress.Write(); projects .Iter(x => { new DirectoryInfo(x.OutputPath).CopyTo(outputDir.FullName, true); progress.Value++; progress.Write(); }); Cli.WriteLine(); Cli.WriteLine(); WriteHeader("Cleaning up"); Cli.WriteLine("Searching..."); var fsos = new List<FileSystemInfo>(); if (_currentRelease.Cleanup.FilePatterns != null && _currentRelease.Cleanup.FilePatterns.Any()) { fsos.AddRange( outputDir .GetFiles("*", SearchOption.AllDirectories) .Where(x => _currentRelease.Cleanup.FilePatterns.Any(y => Regex.IsMatch(x.FullName, y)))); } if (_currentRelease.Cleanup.Files != null && _currentRelease.Cleanup.Files.Any()) { fsos.AddRange(_currentRelease.Cleanup.Files.Select(x => new FileInfo(Path.Combine(outputDir.FullName, x)))); } if (_currentRelease.Cleanup.Directories != null && _currentRelease.Cleanup.Directories.Any()) { fsos.AddRange(_currentRelease.Cleanup.Directories.Select(x => outputDir.Combine(x))); } Cli.WriteLine("~Cyan~{0}~R~ files and directories found", fsos.Count); Cli.WriteLine(); WriteProgressHeader("Deleting"); progress = new CliProgressBar(fsos.Count); progress.Write(); fsos.Iter(x => { var dir = x as DirectoryInfo; if (dir != null) { dir.Delete(true); } else { x.Delete(); } progress.Value++; progress.Write(); }); }
public static string Interpret(string file) { var interpreter = new AphidInterpreter(); interpreter.InterpretFile(file); var retVal = interpreter.GetReturnValue(); var llexFile = new LLexFile(); retVal.Bind(llexFile); var tokenTable = new TokenTable(); tokenTable.Ignore = llexFile.Ignore; var nameInfo = LLexNameInfo.Parse(llexFile.Name); int z = 0; var modeTable = llexFile.Modes.ToDictionary(x => x.Mode, x => z++); var tokenTypes = new List<string>(); foreach (var mode in llexFile.Modes) { tokenTable.SetMode(modeTable[mode.Mode]); foreach (var token in mode.Tokens) { if (token.Regex != null) { var regexLexer = new RegexLexer(token.Regex); var tokens = regexLexer.GetTokens(); var parser = new RegexParser(tokens.ToArray()); var ast = parser.Parse(); var compiler = new RegexCompiler(ast); var strings = compiler.ExpandRegex(); foreach (var l in strings) { if (token.Code != null) { tokenTable.AddLexemeCode(l, token.Code); continue; } if (!tokenTypes.Contains(token.TokenType)) tokenTypes.Add(token.TokenType); if (!string.IsNullOrEmpty(token.NewMode)) { tokenTable.Add(l, token.TokenType, modeTable[token.NewMode]); } else { tokenTable.Add(l, token.TokenType); } } } else if (token.Code != null) { tokenTable.AddCode(token.Code); } } foreach (var keyword in mode.Keywords) { tokenTable.AddKeyword(keyword); var t = keyword + "Keyword"; if (mode.KeywordTail != null) { tokenTable.AddLexemeCode(keyword, mode.KeywordTail.Replace("{Keyword}", t)); } else { tokenTable.Add(keyword, t); } } if (!string.IsNullOrEmpty(mode.KeywordDefault)) { var k = mode.Keywords .SelectMany(x => Enumerable .Range(1, x.Length - 1) .Select(y => x.Remove(y)) .ToArray()) .Distinct() .ToArray(); foreach (var i in k) { if (tokenTable.Lists.Any(x => x.Value.Any(y => y.Lexeme == i))) { continue; } tokenTable.AddLexemeCode(i, mode.KeywordDefault); } } } var generator = new LexerGenerator(tokenTable) { IgnoreCase = llexFile.IgnoreCase }; var lexer = generator.Generate(); return lexer .Replace("{Lexer}", nameInfo.LexerName) .Replace("{Token}", nameInfo.TokenName) .Replace("{TokenType}", nameInfo.TokenTypeName) .Replace("{LexerNamespace}", nameInfo.Namespace); }
public static void Extend(AphidInterpreter interpreter, AphidObject type, AphidObject extensions) { var typeStr = (string)type.Value; TypeExtender.Extend(interpreter, (string)type.Value, extensions); }
private static List<AphidObject> ListOrderByDescending(AphidInterpreter interpreter, AphidObject items, AphidObject keySelector) { return ListOrder(interpreter, items, keySelector, Enumerable.OrderByDescending); }
private static List<AphidObject> ListOrder( AphidInterpreter interpreter, AphidObject items, AphidObject keySelector, Func<IEnumerable<AphidObject>, Func<AphidObject, object>, IOrderedEnumerable<AphidObject>> action) { var list = (List<AphidObject>)items.Value; var func = (AphidFunction)keySelector.Value; return action(list, x => interpreter.CallFunction(func, x).Value).ToList(); }
private static object Eval(AphidInterpreter interpreter, string code) { interpreter.EnterChildScope(); interpreter.Interpret(code); var retVal = interpreter.GetReturnValue(); interpreter.LeaveChildScope(); return retVal; }
public static void Dump(AphidInterpreter interpreter, AphidObject obj) { AphidObject vmObj; interpreter.CurrentScope.TryResolve(ViewModelName, out vmObj); var vm = (AphidReplViewModel)vmObj.Value; var serializer = new AphidSerializer() { IgnoreFunctions = false }; vm._codeViewer.Dispatcher.Invoke(() => { if (obj != null) { vm._codeViewer.AppendCode(serializer.Serialize(obj)); } else { throw new InvalidOperationException(); } }); }
public object Invoke(AphidInterpreter interpreter, params object[] parms) { return _invoke(interpreter, parms); }
private static void LoadSettings() { WriteHeader("Loading release settings"); var script = "PhpVH.alx"; Cli.WriteLine("Executing ~Cyan~{0}~R~", script); var interpreter = new AphidInterpreter(); interpreter.InterpretFile(script); _currentRelease = interpreter.GetReturnValue().ConvertTo<Release>(); var projects = _currentRelease.Projects; Cli.WriteLine(); }
public void ResetInterpreter() { _interpreter = new AphidInterpreter(); InitInterpreter(); }