public static CodeTypeDeclaration CreateUnmarshalHelperType(CodeNamespace ns, string name, bool type_decode)
{
var type = ns.AddType(name);
type.TypeAttributes = TypeAttributes.NestedAssembly;
type.BaseTypes.Add(typeof(NdrUnmarshalBuffer).ToRef());
var con = type.AddConstructor(MemberAttributes.Public);
con.AddParam(typeof(RpcClientResponse).ToRef(), "r");
var param_var = CodeGenUtils.GetVariable("r");
con.BaseConstructorArgs.Add(new CodePropertyReferenceExpression(param_var, "NdrBuffer"));
con.BaseConstructorArgs.Add(new CodePropertyReferenceExpression(param_var, "Handles"));
con.BaseConstructorArgs.Add(new CodePropertyReferenceExpression(param_var, "DataRepresentation"));
con = type.AddConstructor(MemberAttributes.Public);
con.AddParam(typeof(byte[]).ToRef(), "ba");
con.BaseConstructorArgs.Add(CodeGenUtils.GetVariable("ba"));
if (type_decode)
{
con = type.AddConstructor(MemberAttributes.Public);
con.AddParam(typeof(NdrPickledType).ToRef(), "pickled_type");
con.BaseConstructorArgs.Add(CodeGenUtils.GetVariable("pickled_type"));
}
return(type);
}
public static CodeTypeDeclaration CreateMarshalHelperType(CodeNamespace ns, string name)
{
var marshal_type = new CodeTypeReference(typeof(NdrMarshalBuffer));
var type = ns.AddType(name);
type.TypeAttributes = TypeAttributes.NestedAssembly;
type.BaseTypes.Add(marshal_type);
return(type);
}
public static void Main(string[] args)
{
string directory = "../../NRefactory/Project/Src/Ast/";
string visitorsDir = "../../NRefactory/Project/Src/Visitors/";
Console.WriteLine("AST Generator running...");
if (!File.Exists(directory + "INode.cs"))
{
Console.WriteLine("did not find output directory " + Path.GetFullPath(Path.GetDirectoryName(directory)));
return;
}
if (!File.Exists(visitorsDir + "AbstractAstTransformer.cs"))
{
Console.WriteLine("did not find visitor output directory");
return;
}
List <Type> nodeTypes = new List <Type>();
foreach (Type type in typeof(MainClass).Assembly.GetTypes())
{
if (type.IsClass && typeof(INode).IsAssignableFrom(type))
{
nodeTypes.Add(type);
}
}
nodeTypes.Sort(delegate(Type a, Type b) { return(a.Name.CompareTo(b.Name)); });
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cns = ccu.AddNamespace("ICSharpCode.NRefactory.Ast");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("AgentRalph.Visitors");
foreach (Type type in nodeTypes)
{
if (type.GetCustomAttributes(typeof(CustomImplementationAttribute), false).Length == 0)
{
CodeTypeDeclaration ctd = cns.AddType(type.Name);
if (type.IsAbstract)
{
ctd.TypeAttributes |= TypeAttributes.Abstract;
}
ctd.IsPartial = true;
ctd.BaseTypes.Add(new CodeTypeReference(type.BaseType.Name));
ProcessType(type, ctd);
foreach (object o in type.GetCustomAttributes(false))
{
if (o is TypeImplementationModifierAttribute)
{
(o as TypeImplementationModifierAttribute).ModifyImplementation(cns, ctd, type);
}
}
if (!type.IsAbstract)
{
AddAnAcceptVisitorMethod(type, ctd, "IAstVisitor", typeof(object));
// Create an overload
AddAnAcceptVisitorMethod(type, ctd, "AstComparisonVisitor", typeof(bool));
AddAChillunsGetter(type, ctd);
var method = new CodeMemberMethod();
method.Name = "ToString";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(string));
method.Statements.Add(new CodeMethodReturnStatement(CreateToString(type)));
ctd.Members.Add(method);
}
}
}
System.CodeDom.Compiler.CodeGeneratorOptions settings = new System.CodeDom.Compiler.CodeGeneratorOptions();
settings.IndentString = "\t";
settings.VerbatimOrder = true;
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(directory + "Generated.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "../IAstVisitor.cs", writer.ToString());
}
// My modifications to the generation process are not preserving the creation of these particular files.
// So I just don't regenerate them for the time being.
// ccu = new CodeCompileUnit();
// cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
// cns.AddImport("System");
// cns.AddImport("System.Collections.Generic");
// cns.AddImport("System.Diagnostics");
// cns.AddImport("ICSharpCode.NRefactory.Ast");
// cns.Types.Add(CreateAstVisitorClass(nodeTypes, false));
//
// using (StringWriter writer = new StringWriter()) {
// new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", writer.ToString());
// }
//
// ccu = new CodeCompileUnit();
// cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
// cns.AddImport("System");
// cns.AddImport("System.Collections.Generic");
// cns.AddImport("System.Diagnostics");
// cns.AddImport("ICSharpCode.NRefactory.Ast");
// cns.Types.Add(CreateAstVisitorClass(nodeTypes, true));
//
// using (StringWriter writer = new StringWriter()) {
// new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", writer.ToString());
// }
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNodeTrackingAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// CodeDom cannot output "sealed", so we need to use this hack:
File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs",
writer.ToString().Replace("public override object", "public sealed override object"));
}
//NotImplementedAstVisitor
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNotImplementedAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", writer.ToString());
}
// TwoTreeAbstractAstVisitor
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("AgentRalph.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.AddImport("ICSharpCode.NRefactory");
cns.Types.Add(CreateAstComparisonVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter())
{
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// Put it in the NRefactor project
var path = visitorsDir + "AstComparisonVisitor.Generated.cs";
File.WriteAllText(path, writer.ToString());
Console.WriteLine("Created file " + path);
}
Console.WriteLine("AST Generator done!");
}
public static void Main(string[] args)
{
string directory = "../../../Project/Src/Ast/";
string visitorsDir = "../../../Project/Src/Visitors/";
Debug.WriteLine("AST Generator running...");
if (!File.Exists(directory + "INode.cs"))
{
Debug.WriteLine("did not find output directory");
return;
}
if (!File.Exists(visitorsDir + "AbstractAstTransformer.cs"))
{
Debug.WriteLine("did not find visitor output directory");
return;
}
List <Type> nodeTypes = new List <Type>();
foreach (Type type in typeof(MainClass).Assembly.GetTypes())
{
if (type.IsClass && typeof(INode).IsAssignableFrom(type))
{
nodeTypes.Add(type);
}
}
nodeTypes.Sort(delegate(Type a, Type b) { return(a.Name.CompareTo(b.Name)); });
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cns = ccu.AddNamespace("ICSharpCode.NRefactory.Ast");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
foreach (Type type in nodeTypes)
{
if (type.GetCustomAttributes(typeof(CustomImplementationAttribute), false).Length == 0)
{
CodeTypeDeclaration ctd = cns.AddType(type.Name);
if (type.IsAbstract)
{
ctd.TypeAttributes |= TypeAttributes.Abstract;
}
ctd.BaseTypes.Add(new CodeTypeReference(type.BaseType.Name));
ProcessType(type, ctd);
foreach (object o in type.GetCustomAttributes(false))
{
if (o is TypeImplementationModifierAttribute)
{
(o as TypeImplementationModifierAttribute).ModifyImplementation(cns, ctd, type);
}
}
if (!type.IsAbstract)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "AcceptVisitor";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data"));
method.ReturnType = new CodeTypeReference(typeof(object));
CodeExpression ex = new CodeVariableReferenceExpression("visitor");
ex = new CodeMethodInvokeExpression(ex, VisitPrefix + ctd.Name,
new CodeThisReferenceExpression(),
new CodeVariableReferenceExpression("data"));
method.Statements.Add(new CodeMethodReturnStatement(ex));
ctd.Members.Add(method);
method = new CodeMemberMethod();
method.Name = "ToString";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(string));
method.Statements.Add(new CodeMethodReturnStatement(CreateToString(type)));
ctd.Members.Add(method);
}
}
}
System.CodeDom.Compiler.CodeGeneratorOptions settings = new System.CodeDom.Compiler.CodeGeneratorOptions();
settings.IndentString = "\t";
settings.VerbatimOrder = true;
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(directory + "Generated.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "../IAstVisitor.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorClass(nodeTypes, false));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("System.Collections.Generic");
cns.AddImport("System.Diagnostics");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateAstVisitorClass(nodeTypes, true));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", writer.ToString());
}
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNodeTrackingAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
// CodeDom cannot output "sealed", so we need to use this hack:
File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs",
writer.ToString().Replace("public override object", "public sealed override object"));
}
//NotImplementedAstVisitor
ccu = new CodeCompileUnit();
cns = ccu.AddNamespace("ICSharpCode.NRefactory.Visitors");
cns.AddImport("System");
cns.AddImport("ICSharpCode.NRefactory.Ast");
cns.Types.Add(CreateNotImplementedAstVisitorClass(nodeTypes));
using (StringWriter writer = new StringWriter()) {
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", writer.ToString());
}
Debug.WriteLine("AST Generator done!");
}
public static CodeTypeDeclaration AddClass(this CodeNamespace ns, string className) => ns.AddType(Declare.Class(className));
private void GenerateClient(string name, CodeNamespace ns, int complex_type_count)
{
CodeTypeDeclaration type = ns.AddType(name);
type.IsClass = true;
type.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
type.BaseTypes.Add(typeof(RpcAlpcClientBase));
CodeConstructor constructor = type.AddConstructor(MemberAttributes.Public | MemberAttributes.Final);
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceId.ToString()));
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceVersion.Major));
constructor.BaseConstructorArgs.Add(CodeGenUtils.GetPrimitive(_server.InterfaceVersion.Minor));
foreach (var proc in _server.Procedures)
{
string proc_name = proc.Name;
if (!_proc_names.Add(proc_name))
{
proc_name = $"{proc_name}_{proc.ProcNum}";
if (!_proc_names.Add(proc_name))
{
throw new ArgumentException($"Duplicate name {proc.Name}");
}
}
var method = type.AddMethod(proc_name, MemberAttributes.Public | MemberAttributes.Final);
RpcTypeDescriptor return_type = GetTypeDescriptor(proc.ReturnValue.Type);
if (return_type == null)
{
method.ThrowNotImplemented("Return type unsupported.");
continue;
}
var offset_to_name =
proc.Params.Select(p => Tuple.Create(p.Offset, p.Name)).ToList();
method.ReturnType = return_type.CodeType;
method.CreateMarshalObject(MARSHAL_NAME);
foreach (var p in proc.Params)
{
if (p == proc.Handle)
{
continue;
}
RpcTypeDescriptor p_type = GetTypeDescriptor(p.Type);
List <RpcMarshalArgument> extra_marshal_args = new List <RpcMarshalArgument>();
if (p_type.VarianceDescriptor.IsValid)
{
extra_marshal_args.Add(p_type.VarianceDescriptor.CalculateCorrelationArgument(p.Offset, offset_to_name));
}
var p_obj = method.AddParam(p_type.GetParameterType(), p.Name);
p_obj.Direction = p.GetDirection();
if (!p.IsIn)
{
continue;
}
if (p_type.Pointer)
{
if (p_type.PointerType == RpcPointerType.Reference)
{
method.AddNullCheck(MARSHAL_NAME, p.Name);
}
else
{
method.AddWriteReferent(MARSHAL_NAME, p.Name);
}
}
else if (!p_type.ValueType)
{
method.AddNullCheck(MARSHAL_NAME, p.Name);
}
method.AddMarshalCall(p_type, MARSHAL_NAME, p.Name, extra_marshal_args.ToArray());
// If it's a constructed type then ensure any deferred writes are flushed.
if (p_type.Constructed)
{
method.AddFlushDeferredWrites(MARSHAL_NAME);
}
}
method.SendReceive(MARSHAL_NAME, UNMARSHAL_NAME, proc.ProcNum);
foreach (var p in proc.Params.Where(x => x.IsOut))
{
if (p == proc.Handle)
{
continue;
}
RpcTypeDescriptor p_type = GetTypeDescriptor(p.Type);
if (p_type.Pointer)
{
method.AddPointerUnmarshalCall(p_type, UNMARSHAL_NAME, p.Name);
}
else
{
method.AddUnmarshalCall(p_type, UNMARSHAL_NAME, p.Name);
}
if (p_type.Constructed)
{
method.AddPopluateDeferredPointers(UNMARSHAL_NAME);
}
}
method.AddUnmarshalReturn(return_type, UNMARSHAL_NAME);
}
if (complex_type_count > 0 && HasFlag(RpcClientBuilderFlags.GenerateConstructorProperties))
{
var constructor_type = new CodeTypeReference(CodeGenUtils.MakeIdentifier(CONSTRUCTOR_STRUCT_NAME));
var prop = type.AddProperty("New", constructor_type, MemberAttributes.Public | MemberAttributes.Final,
new CodeMethodReturnStatement(new CodeObjectCreateExpression(constructor_type)));
constructor_type = new CodeTypeReference(CodeGenUtils.MakeIdentifier(ARRAY_CONSTRUCTOR_STRUCT_NAME));
type.AddProperty("NewArray", constructor_type, MemberAttributes.Public | MemberAttributes.Final,
new CodeMethodReturnStatement(new CodeObjectCreateExpression(constructor_type)));
}
}
private int GenerateComplexTypes(CodeNamespace ns)
{
int type_count = 0;
// First populate the type cache.
foreach (var complex_type in _server.ComplexTypes)
{
if (complex_type is NdrBaseStructureTypeReference struct_type)
{
_type_descriptors[complex_type] = new RpcTypeDescriptor(complex_type.Name, true,
"ReadStruct", true, "WriteStruct", complex_type, null, null);
type_count++;
}
}
if (type_count == 0)
{
return(0);
}
bool create_constructor_properties = HasFlag(RpcClientBuilderFlags.GenerateConstructorProperties);
CodeTypeDeclaration constructor_type = null;
CodeTypeDeclaration array_constructor_type = null;
if (create_constructor_properties)
{
constructor_type = ns.AddType(CONSTRUCTOR_STRUCT_NAME);
constructor_type.IsStruct = true;
array_constructor_type = ns.AddType(ARRAY_CONSTRUCTOR_STRUCT_NAME);
array_constructor_type.IsStruct = true;
}
// Now generate the complex types.
foreach (var complex_type in _server.ComplexTypes)
{
if (!(complex_type is NdrBaseStructureTypeReference struct_type))
{
ns.Comments.Add(new CodeCommentStatement($"Unsupported type {complex_type.GetType()} {complex_type.Name}"));
continue;
}
var s_type = ns.AddType(complex_type.Name);
s_type.IsStruct = true;
s_type.BaseTypes.Add(new CodeTypeReference(typeof(INdrStructure)));
var marshal_method = s_type.AddMarshalMethod(MARSHAL_NAME);
marshal_method.AddAlign(MARSHAL_NAME, struct_type.Alignment + 1);
var unmarshal_method = s_type.AddUnmarshalMethod(UNMARSHAL_NAME);
unmarshal_method.AddAlign(UNMARSHAL_NAME, struct_type.Alignment + 1);
var offset_to_name =
struct_type.Members.Select(m => Tuple.Create(m.Offset, m.Name)).ToList();
var default_initialize_expr = new Dictionary <string, CodeExpression>();
var member_parameters = new List <Tuple <CodeTypeReference, string> >();
foreach (var member in struct_type.Members)
{
var f_type = GetTypeDescriptor(member.MemberType);
s_type.AddField(f_type.GetStructureType(), member.Name, MemberAttributes.Public);
member_parameters.Add(Tuple.Create(f_type.GetParameterType(), member.Name));
List <RpcMarshalArgument> extra_marshal_args = new List <RpcMarshalArgument>();
if (f_type.VarianceDescriptor.IsValid)
{
extra_marshal_args.Add(f_type.VarianceDescriptor.CalculateCorrelationArgument(member.Offset, offset_to_name));
}
if (f_type.Pointer)
{
marshal_method.AddDeferredMarshalCall(f_type, MARSHAL_NAME, member.Name, extra_marshal_args.ToArray());
unmarshal_method.AddDeferredEmbeddedUnmarshalCall(f_type, UNMARSHAL_NAME, member.Name);
}
else
{
if (!f_type.ValueType)
{
marshal_method.AddNullCheck(MARSHAL_NAME, member.Name);
}
marshal_method.AddMarshalCall(f_type, MARSHAL_NAME, member.Name, extra_marshal_args.ToArray());
unmarshal_method.AddUnmarshalCall(f_type, UNMARSHAL_NAME, member.Name);
}
if (!f_type.Pointer || f_type.PointerType == RpcPointerType.Reference)
{
if (f_type.CodeType.ArrayRank > 0)
{
default_initialize_expr.Add(member.Name, new CodeArrayCreateExpression(f_type.CodeType, CodeGenUtils.GetPrimitive(f_type.FixedCount)));
}
else if (f_type.BuiltinType == typeof(string) && f_type.FixedCount > 0)
{
default_initialize_expr.Add(member.Name, new CodeObjectCreateExpression(f_type.CodeType, CodeGenUtils.GetPrimitive('\0'),
CodeGenUtils.GetPrimitive(f_type.FixedCount)));
}
}
}
var p_type = _type_descriptors[complex_type];
if (!create_constructor_properties)
{
s_type.AddDefaultConstructorMethod("CreateDefault", MemberAttributes.Public | MemberAttributes.Static, p_type, default_initialize_expr);
s_type.AddConstructorMethod(p_type, member_parameters);
}
else
{
constructor_type.AddDefaultConstructorMethod(complex_type.Name, MemberAttributes.Public | MemberAttributes.Final, p_type, default_initialize_expr);
constructor_type.AddConstructorMethod(complex_type.Name, p_type, member_parameters);
array_constructor_type.AddArrayConstructorMethod(complex_type.Name, p_type);
}
}
return(type_count);
}
