private CodeStatementCollection GenerateImperativeAssignStatement(BinaryOperatorExpression node)
{
//if (node.RightOperand.Type == AphidNodeType.CallExpression)
//{
// var call = (CallExpression)node.RightOperand;
// if (call.FunctionExpression.Type == AphidNodeType.IdentifierExpression &&
// ((IdentifierExpression)call.FunctionExpression).Identifier == "NextToken")
// {
// var assignStatements = GenerateImperativeStatement(new BinaryOperatorExpression(
// node.LeftOperand,
// node.Operator,
// new IdentifierExpression(_tokenTypeId)));
// var statements = assignStatements
// .OfType<CodeStatement>()
// .Concat(new CodeStatement[] { GetNextTokenStatement(), })
// .ToArray();
// return new CodeStatementCollection(statements);
// }
//}
if (node.LeftOperand.Type == AphidExpressionType.IdentifierExpression)
{
var id = ((IdentifierExpression)node.LeftOperand).Identifier;
if (!_scope.TryResolve(id, out _))
{
_scope.Add(id, AphidObject.Complex());
return(new CodeStatementCollection(new[] { CodeHelper.VarDecl(id, GenerateImperativeExpression(node.RightOperand)) }));
}
}
var leftExp = GenerateImperativeExpression(node.LeftOperand);
var assignStmt = CodeHelper.Assign(leftExp, GenerateImperativeExpression(node.RightOperand));
return(new CodeStatementCollection(new[] { assignStmt }));
}
private CodeStatement GenerateContextAssign() => CodeHelper.Assign(
ParserName.ContextField,
CodeHelper.New(CodeHelper.TypeRef(_config.ExpressionContextClass)));
public Type BuildType(string typeName)
{
var nameTable = _sourcePropertyTable.Value;
var type2 = new CodeTypeDeclaration(typeName)
{
CustomAttributes = new CodeAttributeDeclarationCollection(
new[] { new CodeAttributeDeclaration(CodeHelper.TypeRef <SerializableAttribute>()) })
};
var fields = nameTable
.ToDictionary(
x => x.Key,
x => new CodeMemberField(x.Value.PropertyType, string.Format("_autoField_{0}", x.Key)));
var props = nameTable
.Select(x => new CodeMemberProperty
{
Attributes = MemberAttributes.Public,
Type = CodeHelper.TypeRef(x.Value.PropertyType),
Name = x.Key,
HasGet = true,
HasSet = true,
CustomAttributes = new CodeAttributeDeclarationCollection(
new[] { new CodeAttributeDeclaration(CodeHelper.TypeRef <TAttribute>()) })
})
.ToArray();
foreach (var p in props)
{
var field = CodeHelper.FieldRef(fields[p.Name].Name);
p.GetStatements.Add(CodeHelper.Return(field));
p.SetStatements.Add(CodeHelper.Assign(field, CodeHelper.VarRef("value")));
}
type2.Members.AddRange(fields.Select(x => x.Value).ToArray());
type2.Members.AddRange(props);
var code = CSharpHelper.GenerateCode(type2);
using (var provider = new CSharpCodeProvider())
{
var options = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
};
var references = nameTable
.Select(x => x.Value.PropertyType.Assembly.Location)
.Concat(new[] { typeof(SerializableAttribute), typeof(TAttribute) }
.Select(x => x.Assembly.Location))
.Distinct()
.ToArray();
options.ReferencedAssemblies.AddRange(references);
var results = provider.CompileAssemblyFromSource(options, code);
return(results.CompiledAssembly.GetType(typeName));
}
}
