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();
}
