public static List <string> IdentGeneratable(this IGeneratable multiLineGeneratable, int identCount = 1)
{
var lines = multiLineGeneratable.ToLines();
var ret = lines.IdentLines(identCount);
return(ret);
}
public string Finish(string indent)
{
string ret = "";
foreach (Parameter p in parms.Keys)
{
if (parms [p] == false)
{
continue;
}
IGeneratable igen = p.Generatable;
if (igen is CallbackGen)
{
continue;
}
else if (igen is StructBase || igen is ByRefGen)
{
ret += indent + String.Format("if ({0} != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (my{0}, {0}, false);\n", p.Name);
}
else if (igen is IManualMarshaler)
{
ret += String.Format("{0}{1} = {2};", indent, p.Name, (igen as IManualMarshaler).AllocNative("my" + p.Name));
}
else
{
ret += indent + p.Name + " = " + igen.CallByName("my" + p.Name) + ";\n";
}
}
return(ret);
}
public static void GenerateMembers(this IGeneratable gen, IndentWriter writer, Func <IMemberGeneratable, bool> where = null)
{
var array = gen.GetMemberGeneratables().Where(x => where == null || where (x)).ToArray();
for (int i = 0; i < array.Length; ++i)
{
var member = array [i];
// Generate pinvoke signature for a method
if (!(gen is Interface) && member is INativeCallable callable)
{
callable.GenerateImport(gen, writer);
}
// Generate documentation is a member supports it.
if (member is IDocumented doc)
{
doc.GenerateDocumentation(writer);
}
// Call the main member generation implementation.
member.Generate(gen, writer);
if (i != array.Length - 1 && member.NewlineAfterGeneration(writer.Options))
{
writer.WriteLine();
}
}
}
public string Finish(string indent)
{
string ret = "";
for (int i = 0; i < parms.Count; i++)
{
if ((bool)special[i] == false)
{
continue;
}
Parameter p = parms [i] as Parameter;
IGeneratable igen = p.Generatable;
if (igen is CallbackGen)
{
continue;
}
else if (igen is StructBase || igen is ByRefGen)
{
ret += indent + String.Format("if ({0} != IntPtr.Zero) System.Runtime.InteropServices.Marshal.StructureToPtr (my{0}, {0}, false);\n", p.Name);
}
else
{
ret += indent + p.Name + " = " + igen.ToNativeReturn("my" + p.Name) + ";\n";
}
}
return(ret);
}
public static void GenerateCallableDefinition(this INativeCallable callable, IGeneratable gen, IndentWriter writer)
{
callable.ReturnValue.GenerateDocumentation(writer);
writer.WriteIndent();
if (!string.IsNullOrEmpty(callable.GetModifiers(gen, writer.Options)) && !(gen is Interface))
{
writer.Write(callable.GetModifiers(gen, writer.Options) + " ");
}
var returnType = callable.GetReturnCSharpType(writer);
// generate ReturnValue then Parameters
var result = BuildParameters(callable, writer.Options, !callable.IsInstanceCallable(gen, writer.Options));
writer.Write($"{returnType} {callable.Name.ToCSharp ()} ({result.TypesAndNames})");
if (gen is Interface)
{
writer.Write(";");
writer.WriteLine();
return;
}
writer.WriteLine();
writer.WriteLine("{");
using (writer.Indent())
{
string prefix = returnType != "void" ? "return " : string.Empty;
writer.WriteLine($"{prefix}{callable.CIdentifier} ({result.Names});");
}
writer.WriteLine("}");
}
private void Add <T>(IGeneratable <T> generator)
{
if (!Has(typeof(T)) && !generator.GetType().IsInterface)
{
supportedGenerators.Add(typeof(T), generator);
}
}
/// <summary>
/// Gets a case form entity that has been converted to it's .docx form.
/// </summary>
public async Task <byte[]> GetCaseFormAsDocx(int id)
{
_logger.LogInformation(LoggingEvents.GetItem, "Getting case form {Id}", id);
var caseForm = await _caseFormRepo.GetByIdAsync(id);
if (caseForm == null)
{
_logger.LogWarning(LoggingEvents.GetItemNotFound, "Case form {Id} NOT FOUND", id);
}
IGeneratable generatable = null;
if (caseForm is WarrantInDebtForm)
{
generatable = _mapper.Map <WarrantInDebtDocxForm>(caseForm, opt =>
{
opt.Items.Add("court", _serviceRunSettings.CaseFormSettings.CourtName);
opt.Items.Add("courtAddress", _serviceRunSettings.CaseFormSettings.CourtAddress);
// TODO: If above works, can pass in user profile /attorney info here
});
}
else if (caseForm is SummonsForUnlawfulDetainerForm)
{
// todo: map new SummonsForUnlawfulDetainerDocxForm()
}
return(await _docxConverterService.Convert(generatable));
}
string CallCount(string name)
{
string result = CountCast + "(" + name + " == null ? 0 : " + name + ".Length)";
IGeneratable gen = SymbolTable.Table[count_elem.GetAttribute("type")];
return(gen.CallByName(result));
}
public void initExistingModel(IGeneratable data)
{
if (!(data is PropertyData))
{
throw new ArgumentException("parameter must be PropertyData");
}
this.data = (PropertyData)data;
}
// TODO: Decide what to do here if we have functions which work
// on instances (instance-parameter is not set)
public string GetModifiers(IGeneratable parent, GenerationOptions opts)
{
if (CanFirstParameterBeInstance(parent, opts))
{
return("public");
}
return("public static");
}
string EventHandlerQualifiedName(IGeneratable parent)
{
if (IsEventHandler)
{
return("System.EventHandler");
}
return(parent.Name + "." + EventHandlerName);
}
public string GetModifiers(IGeneratable parent, GenerationOptions opts)
{
if (parent is Class @class && @class.Abstract)
{
return("protected");
}
return("public");
}
public override void Generate (GenerationInfo gen_info, string indent)
{
if (Hidden)
return;
visible = Access != "private";
StreamWriter sw = gen_info.Writer;
SymbolTable table = SymbolTable.Table;
string wrapped = table.GetCSType (CType);
string wrapped_name = SymbolTable.Table.MangleName (CName);
IGeneratable gen = table [CType];
if (IsArray && !IsNullTermArray) {
sw.WriteLine (indent + "[MarshalAs (UnmanagedType.ByValArray, SizeConst=" + ArrayLength + ")]");
sw.WriteLine (indent + "{0} {1} {2};", Access, CSType, StudlyName);
} else if (IsArray && IsNullTermArray) {
sw.WriteLine (indent + "private {0} {1};", "IntPtr", StudlyName+ "Ptr");
if ((Readable || Writable) && Access == "public") {
sw.WriteLine (indent + "public {0} {1} {{", CSType, StudlyName);
if (Readable)
sw.WriteLine (indent + "\tget {{ return GLib.Marshaller.StructArrayFromNullTerminatedIntPtr<{0}> ({1}); }}",
base.CSType, StudlyName + "Ptr");
if (Writable)
sw.WriteLine (indent + "\tset {{ {0} = GLib.Marshaller.StructArrayToNullTerminatedStructArrayIntPtr<{1}> (value); }}",
StudlyName + "Ptr", base.CSType);
sw.WriteLine (indent + "}");
}
} else if (IsBitfield) {
base.Generate (gen_info, indent);
} else if (gen is IAccessor) {
sw.WriteLine (indent + "private {0} {1};", gen.MarshalType, Name);
if (Access != "private") {
IAccessor acc = table [CType] as IAccessor;
sw.WriteLine (indent + Access + " " + wrapped + " " + StudlyName + " {");
acc.WriteAccessors (sw, indent + "\t", Name);
sw.WriteLine (indent + "}");
}
} else if (IsPointer && (gen is StructGen || gen is BoxedGen || gen is UnionGen)) {
sw.WriteLine (indent + "private {0} {1};", CSType, Name);
sw.WriteLine ();
if (Access != "private") {
sw.WriteLine (indent + Access + " " + wrapped + " " + wrapped_name + " {");
sw.WriteLine (indent + "\tget { return " + table.FromNative (CType, Name) + "; }");
sw.WriteLine (indent + "}");
}
} else if (IsPointer && CSType != "string") {
// FIXME: probably some fields here which should be visible.
visible = false;
sw.WriteLine (indent + "private {0} {1};", CSType, Name);
} else {
sw.WriteLine (indent + "{0} {1} {2};", Access, CSType, Access == "public" ? StudlyName : Name);
}
}
public override void Generate(GenerationInfo gen_info, string indent)
{
if (Hidden)
{
return;
}
StreamWriter sw = gen_info.Writer;
SymbolTable table = SymbolTable.Table;
string wrapped = table.GetCSType(CType);
string wrapped_name = SymbolTable.Table.MangleName(CName);
IGeneratable gen = table [CType];
if (IsArray)
{
sw.WriteLine(indent + "[MarshalAs (UnmanagedType.ByValArray, SizeConst=" + ArrayLength + ")]");
sw.WriteLine(indent + "{0} {1} {2};", Access, CSType, StudlyName);
}
else if (IsBitfield)
{
base.Generate(gen_info, indent);
}
else if (gen is IAccessor)
{
sw.WriteLine(indent + "private {0} {1};", gen.MarshalType, Name);
if (Access != "private")
{
IAccessor acc = table [CType] as IAccessor;
sw.WriteLine(indent + Access + " " + wrapped + " " + StudlyName + " {");
acc.WriteAccessors(sw, indent + "\t", Name);
sw.WriteLine(indent + "}");
}
}
else if (IsPointer && (gen is StructGen || gen is BoxedGen))
{
sw.WriteLine(indent + "private {0} {1};", CSType, Name);
sw.WriteLine();
if (Access != "private")
{
sw.WriteLine(indent + Access + " " + wrapped + " " + wrapped_name + " {");
sw.WriteLine(indent + "\tget { return " + table.FromNativeReturn(CType, Name) + "; }");
sw.WriteLine(indent + "}");
}
}
else if (IsPointer && CSType != "string")
{
// FIXME: probably some fields here which should be visible.
sw.WriteLine(indent + "private {0} {1};", CSType, Name);
}
else
{
sw.WriteLine(indent + "{0} {1} {2};", Access, CSType, Access == "public" ? StudlyName : Name);
}
}
public string GetToNativeReturnType(string c_type)
{
IGeneratable gen = this[c_type];
if (gen == null)
{
return("");
}
return(gen.ToNativeReturnType);
}
public string ToNativeReturn(string c_type, string val)
{
IGeneratable gen = this[c_type];
if (gen == null)
{
return("");
}
return(gen.ToNativeReturn(val));
}
public string CallByName(string c_type, string var_name)
{
IGeneratable gen = this[c_type];
if (gen == null)
{
return("");
}
return(gen.CallByName(var_name));
}
public string FromNative(string c_type, string val)
{
IGeneratable gen = this[c_type];
if (gen == null)
{
return("");
}
return(gen.FromNative(val));
}
public IGeneratable <T> GetGenerator <T>(Type type)
{
IGeneratable <T> generator = null;
if (Has(type))
{
generator = (IGeneratable <T>)supportedGenerators[type];
}
return(generator);
}
public string GetCSType(string c_type)
{
IGeneratable gen = this[c_type];
if (gen == null)
{
return("");
}
return(gen.QualifiedName);
}
public string GetName(string c_type)
{
IGeneratable gen = this[c_type];
if (gen == null)
{
return("");
}
return(gen.Name);
}
public string GetMarshalType(string c_type)
{
IGeneratable gen = this[c_type];
if (gen == null)
{
return("");
}
return(gen.MarshalType);
}
public void Generate(IGeneratable parent, IndentWriter writer)
{
string value = Value;
if (parent is IEnumFormatter formatter)
{
value = formatter.FormatValue(value);
}
writer.WriteLine(Name.ToCSharp() + " = " + value + ",");
}
public virtual bool IsCPointer()
{
IGeneratable gen = SymbolTable.Table[CType];
return(CType.EndsWith("*") ||
CType.EndsWith("pointer") ||
gen is CallbackGen ||
cstype == "string" ||
(CType == "guint8" && (IsArray && IsNullTermArray)) ||
elem.GetAttributeAsBoolean("is_callback"));
}
public void Generate(IGeneratable parent, IndentWriter writer)
{
// Simple uncorrect gen for now
var managedType = this.Resolve(writer.Options);
// We need something that will tell us the equivalent C# type
// including the number of pointers.
// For now, generate normal info.
writer.WriteLine($"{managedType.CSharpType} {Name.ToCSharp ()};");
}
public string Setup(string indent)
{
string ret = "";
for (int i = 0; i < parms.Count; i++)
{
if ((bool)special[i] == false)
{
continue;
}
Parameter p = parms [i] as Parameter;
IGeneratable igen = p.Generatable;
if (igen is CallbackGen)
{
if (user_data_param == null)
{
ret += indent + String.Format("{0} {1}_invoker = new {0} ({1});\n", (igen as CallbackGen).InvokerName, p.Name);
}
else if (destroy_param == null)
{
ret += indent + String.Format("{0} {1}_invoker = new {0} ({1}, {2});\n", (igen as CallbackGen).InvokerName, p.Name, user_data_param);
}
else
{
ret += indent + String.Format("{0} {1}_invoker = new {0} ({1}, {2}, {3});\n", (igen as CallbackGen).InvokerName, p.Name, user_data_param, destroy_param);
}
}
else if (p.Scope == "call")
{
if (igen is ObjectBase)
{
ret += indent + igen.QualifiedName + " my" + p.Name + " = " + (igen as ObjectBase).FromNative(p.Name, true) + ";\n";
}
else
{
throw new NotImplementedException();
}
}
else
{
ret += indent + igen.QualifiedName + " my" + p.Name;
if (p.PassAs == "ref")
{
ret += " = " + p.FromNative(p.Name);
}
ret += ";\n";
}
}
return(ret);
}
private object DeAlias(string type)
{
type = Trim(type);
while (types [type] is AliasGen)
{
IGeneratable igen = types [type] as AliasGen;
types [type] = types [igen.Name];
type = igen.Name;
}
return(types [type]);
}
// TODO: Unexpose this
public bool CanFirstParameterBeInstance(IGeneratable parent, GenerationOptions opts)
{
var param = Parameters.FirstOrDefault();
if (param == null)
{
return(false);
}
// hacky check for symbol equality
return(param.Resolve(opts).GetType() == parent.GetType());
}
public static void GenerateConstructor(this INativeCallable callable, IGeneratable parent, IndentWriter writer)
{
callable.ReturnValue.GenerateDocumentation(writer);
var modifier = callable.GetModifiers(parent, writer.Options);
var result = BuildParameters(callable, writer.Options, !callable.IsInstanceCallable(parent, writer.Options));
// FIXME, should check to see if it is deprecated
writer.WriteLine($"{modifier} {parent.Name} ({result.TypesAndNames}) : base ({result.Names})");
writer.WriteLine("{");
writer.WriteLine("}");
}
public void Generate(GenerationOptions opts, IGeneratable parent, IndentWriter writer)
{
writer.WriteDocumentation(Doc);
// Simple uncorrect gen for now
var managedType = this.GetSymbol(opts);
// We need something that will tell us the equivalent C# type
// including the number of pointers.
// For now, generate normal info.
writer.WriteLine($"{managedType.Name} {Name};");
}
/// <summary>
/// Generates an item any given times
/// </summary>
/// <param name="item">The item to generate</param>
/// <param name="itemCount">Times the item will be generated</param>
public void Generate(IGeneratable item, int itemCount)
{
int generatedMines = 0;
while (generatedMines < itemCount)
{
int rowToPutMine = RandomNumber.Get(this.field.Rows);
int colToPutMine = RandomNumber.Get(this.field.Columns);
if (field[rowToPutMine, colToPutMine] != item.Symbol)
{
field[rowToPutMine, colToPutMine] = item.Symbol;
generatedMines++;
}
}
}
public static void AddType (IGeneratable gen)
{
complex_types [gen.Name] = gen;
}
public void AddType(IGeneratable gen)
{
types [gen.CName] = gen;
}
public void AddTypes(IGeneratable[] gens)
{
foreach (IGeneratable gen in gens)
types [gen.CName] = gen;
}
public void InitializeMineFieldTests()
{
this.field = new Field(Rows, Columns);
this.generator = new MineGenerator(this.field);
this.item = new Mine('$');
}
public ClassField(XmlElement elem)
{
name = elem.GetAttribute ("name");
igen = SymbolTable.Table [elem.GetAttribute ("type")];
}
/// <summary>
/// Initilizes a new instance of the <see cref="MinesweeperAdjacencyMap"/> class.
/// </summary>
/// <param name="field">The field which will be mapped</param>
/// <param name="item">The item which the mapping will be calculated for</param>
public MinesweeperAdjacencyMap(IField field, IGeneratable item)
{
this.field = field;
this.item = item;
}