public AphidObject GetReturnValue([PexAssumeUnderTest] AphidInterpreter target)
{
AphidObject result = target.GetReturnValue();
return(result);
// TODO: add assertions to method AphidInterpreterTest.GetReturnValue(AphidInterpreter)
}
private static object Eval(AphidInterpreter interpreter, string code)
{
interpreter.EnterChildScope();
interpreter.Interpret(code);
var retVal = interpreter.GetReturnValue();
interpreter.LeaveChildScope();
return(retVal);
}
public static string Interpret(string file)
{
var interpreter = new AphidInterpreter();
interpreter.InterpretFile(file);
var retVal = interpreter.GetReturnValue();
return(From(retVal));
}
private static SelfTestAssembly[] LoadAssemblies()
{
var interpreter = new AphidInterpreter();
interpreter.InterpretFile(PathHelper.GetEntryPath("Tests.alx"));
var retVal = interpreter.GetReturnValue();
return(retVal.ConvertToArray <SelfTestAssembly>());
}
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());
}
private void AssertEquality(object lhs, object rhs, bool areEqual)
{
var interpreter = new AphidInterpreter();
interpreter.CurrentScope.Add("lhs", AphidObject.Scalar(lhs));
interpreter.CurrentScope.Add("rhs", AphidObject.Scalar(rhs));
interpreter.Interpret("ret lhs == rhs");
var result = interpreter.GetReturnValue().GetBool();
Assert.AreEqual(result, areEqual);
}
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();
}
private static object Eval(AphidInterpreter interpreter, string code)
{
interpreter.EnterScope();
try
{
interpreter.Interpret(code);
return(interpreter.GetReturnValue());
}
finally
{
interpreter.LeaveScope();
}
}
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 AphidObject EvalExpression(AphidInterpreter interpreter, string code)
{
AphidObject result = null;
void action()
{
if (code.Trim()?.Length == 0)
{
return;
}
var lexer = new AphidLexer(code);
var tokens = lexer.GetTokens();
var exp = AphidParser.ParseExpression(tokens, code);
var retExp = new UnaryOperatorExpression(AphidTokenType.retKeyword, exp);
//new AphidCodeVisitor(code).VisitExpression(retExp);
interpreter.Interpret(retExp);
result = interpreter.GetReturnValue(true);
if (result != null && (result.Value != null || result.Any()))
{
WriteLineHighlighted(
SerializingFormatter.Format(
interpreter,
result,
ignoreNull: false,
ignoreClrObj: false));
}
}
if (AphidErrorHandling.HandleErrors)
{
TryAction(interpreter, code, action);
}
else
{
action();
}
return(result);
}
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);");
}
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);
var lexer = generator.Generate();
return(lexer
.Replace("{Lexer}", nameInfo.LexerName)
.Replace("{Token}", nameInfo.TokenName)
.Replace("{TokenType}", nameInfo.TokenTypeName)
.Replace("{LexerNamespace}", nameInfo.Namespace));
}
private string GenerateLexer(List <AphidExpression> nodes, string code)
{
var lexerCall = nodes.SingleOrDefault(x =>
x.Type == AphidExpressionType.CallExpression &&
x.ToCall().FunctionExpression.Type == AphidExpressionType.IdentifierExpression &&
x.ToCall().FunctionExpression.ToIdentifier().Identifier == "Lexer");
if (lexerCall == null)
{
throw new InvalidOperationException();
}
if (!(lexerCall.ToCall().Args.SingleOrDefault() is ObjectExpression lexerObj))
{
throw new InvalidOperationException();
}
nodes.Remove(lexerCall);
var ast = new List <AphidExpression>();
var initKvp = lexerObj.Pairs.SingleOrDefault(x =>
x.LeftOperand.Type == AphidExpressionType.IdentifierExpression &&
x.LeftOperand.ToIdentifier().Identifier == "init");
if (initKvp != null)
{
if (!(initKvp.RightOperand is FunctionExpression initFunc))
{
throw new InvalidOperationException();
}
ast.AddRange(initFunc.Body);
}
ast.Add(new UnaryOperatorExpression(AphidTokenType.retKeyword, lexerObj)
.WithPositionFrom(lexerObj));
var interpreter = new AphidInterpreter();
interpreter.CurrentScope.Add("nodes", AphidObject.Scalar(nodes));
interpreter.Interpret(ast);
var lexerCode = AlxFile.From(interpreter.GetReturnValue());
var tokenTypeEnum = Regex.Match(
lexerCode,
@"public\s+enum\s+" + _config.TokenType + @"(.|\s)*?\{((.|\s)*?)\}");
if (!tokenTypeEnum.Success)
{
throw new InvalidOperationException(string.Format(
"[Parser Generation] Could not find token type: {0}",
_config.TokenType));
}
_tokenTypes = tokenTypeEnum.Groups[2].Value
.Split(new[] { '\r', '\n', ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.Where(x => x.Length > 0)
.ToArray();
return(lexerCode);
}
private void ExecuteExpression()
{
if (string.IsNullOrEmpty(Code))
{
return;
}
AddHistoricalCode();
var tokens = new AphidLexer(Code + " ").GetTokens();
if (!tokens.Any(x => x.TokenType == AphidTokenType.EndOfStatement))
{
tokens.Add(new AphidToken(AphidTokenType.EndOfStatement, "", 0));
}
List <Components.Aphid.Parser.Expression> ast = null;
try
{
ast = new AphidParser(tokens).Parse();
}
catch (AphidParserException ex)
{
InvokeDispatcher(() => _codeViewer.AppendParserException(Code, ex));
return;
}
if (ast.Count != 1)
{
throw new InvalidOperationException();
}
var exp = ast.First();
var unary = exp as UnaryOperatorExpression;
if (unary == null ||
unary.Operator != AphidTokenType.retKeyword)
{
ast.Clear();
ast.Add(new UnaryOperatorExpression(
AphidTokenType.retKeyword,
exp));
}
try
{
_interpreter.Interpret(ast);
}
catch (AphidRuntimeException ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendException(Code, "Runtime error", ex));
return;
}
catch (AphidParserException ex)
{
InvokeDispatcher(() =>
_codeViewer.AppendParserException(Code, ex));
return;
}
var retVal = _interpreter.GetReturnValue();
var serializer = new AphidSerializer()
{
IgnoreFunctions = false
};
InvokeDispatcher(() =>
_codeViewer.AppendOutput(Code, serializer.Serialize(retVal)));
UpdateVariables();
ExecuteWatchExpressions();
}
public static object Interpret(AphidInterpreter interpreter, Type targetType)
{
interpreter.Interpret(
AphidParser.ParseExpression(
$"using {targetType.FullName.RemoveAtLastIndexOf('.')}"));
var converterName = $"{targetType.Name}Converter";
var converterRef = new IdentifierExpression(converterName);
_memoizer.Call(
x =>
{
var prop = new IdentifierExpression(
"Value",
new List <IdentifierExpression>
{
new IdentifierExpression(targetType.Name)
});
return(interpreter.Interpret(
new ObjectExpression(
new List <BinaryOperatorExpression>
{
new BinaryOperatorExpression(prop, ColonOperator, prop),
},
new IdentifierExpression(
converterName,
new List <IdentifierExpression> {
new IdentifierExpression("class")
}))));
},
targetType);
var resultId = new IdentifierExpression("_result");
var converterVarName = $"{targetType.Name}ConverterInstance";
var converterVarId = new IdentifierExpression(converterVarName);
var valuePath = new BinaryOperatorExpression(
converterVarId,
MemberOperator,
new IdentifierExpression("Value"));
var ast = new List <AphidExpression>
{
new BinaryOperatorExpression(
new IdentifierExpression(
converterVarName,
new List <IdentifierExpression> {
new IdentifierExpression("var")
}),
AssignmentOperator,
new UnaryOperatorExpression(
newKeyword,
new CallExpression(converterRef))),
new BinaryOperatorExpression(valuePath, @operator: AssignmentOperator, resultId),
new UnaryOperatorExpression(retKeyword, valuePath),
};
interpreter.Interpret(ast);
var retObj = interpreter.GetReturnValue();
var retVal = ValueHelper.Unwrap(retObj);
return(retVal);
}
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();
});
}
