static public void GenerateCode(string base_filename, Process <CSTextDocumentBuilder> process, GeneratedCodeType type)
{
CSTextDocument document = new CSTextDocument(new CSHeader_SimpleStatement());
CSTextDocumentBuilder builder = document.CreateCSTextBuilder();
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs();
writer.Write("using System;");
writer.Write("using System.Collections;");
writer.Write("using System.Collections.Generic;");
writer.Write("using UnityEngine;");
writer.Write("#if UNITY_EDITOR");
writer.Write("using UnityEditor;");
writer.Write("using Crunchy.SandwichBag;");
writer.Write("#endif");
writer.Write("using Crunchy.Dough;");
writer.Write("using Crunchy.Salt;");
writer.Write("using Crunchy.Noodle;");
writer.Write("using Crunchy.Bread;");
writer.Write("using Crunchy.Sandwich;");
process(builder);
if (document.RenderDocument().SaveChanges(type.GetDirectory(), base_filename + ".cs", true))
{
REGENERATION_COUNT++;
}
}
private void GenerateVariableGetFunction(CSTextDocumentBuilder text, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
if (settings.IsNot("get", "none"))
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"GET_ACCESS", settings.Lookup("get"),
"GET_OVERRIDE", settings.ConvertBool("get_override", "override"),
"GET_VIRTUAL", settings.ConvertBool("get_virtual", "virtual"),
"TYPE", GetTypeConcept().GetRetrieveTypeName(),
"RETURN_CONTAINER_TYPE", GenerateVariableGetFunctionReturnContainerType(GetTypeConcept().GetRetrieveTypeName()),
"VARIABLE", variable.GetVariableName(),
"GET_VARIABLE_FUNCTION", "Get" + variable.GetVariableFunctionName()
);
code.Write("?GET_ACCESS ?GET_OVERRIDE ?GET_VIRTUAL ?RETURN_CONTAINER_TYPE ?GET_VARIABLE_FUNCTION()", delegate() {
string return_expression = GenerateVariableGetFunctionBodyGetReturnExpression(text, variable, settings);
if (GetTypeConcept().GetStoreTypeName() != GetTypeConcept().GetRetrieveTypeName())
{
return_expression = return_expression + ".Convert(i => (?TYPE)i)";
}
code.Write("return " + return_expression + ";");
});
}
}
private void GenerateStubClasses()
{
foreach (DOMEClass_Generated @class in this.GetDeepChildren <DOMEClass_Generated>())
{
CSTextDocument document = new CSTextDocument();
CSTextDocumentBuilder text = document.CreateCSTextBuilder();
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"NAMESPACE", settings.GetNamespaceName()
);
code.Write("using System;");
code.Write("using System.Collections;");
code.Write("using System.Collections.Generic;");
code.SkipLine();
code.Write("using Crunchy.Dough;");
code.Write("using Crunchy.Salt;");
code.Write("using Crunchy.Noodle;");
code.SkipLine();
if (code.Write("namespace ?NAMESPACE", delegate() {
return(@class.GenerateStubClass(text));
}))
{
document.RenderDocument().SaveClass(settings.GetOutputDirectory(), @class.GetTypeName(), false);
}
}
}
protected override void GenerateTypeMembers(Type type, CSTextDocumentBuilder builder)
{
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs(
"TYPE", type.Name
);
foreach (MethodInfo method in type.GetFilteredInstanceMethods(
Filterer_MethodInfo.IsNamed("Initialize"),
Filterer_MethodInfo.IsOriginalMethodOf(type)
))
{
string parameters = method.GetParameters()
.Convert(p => p.ParameterType.GetCleanName() + " " + p.Name)
.Prepend("this ?TYPE item")
.Join(", ");
string arguments = method.GetParameters()
.Convert(p => p.Name)
.Join(", ");
writer.Write("static public void Draw(" + parameters + ")", delegate() {
writer.Write("EphemeralSystem.Next(item).Initialize(" + arguments + ");");
});
}
}
public override void GenerateMainClass(CSTextDocumentBuilder text)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeName(),
"BASE_TYPE", GetBaseType().GetTypeName()
);
code.Write("public abstract partial class ?TYPE : ?BASE_TYPE, Relatable", delegate() {
code.Write("[RelatableParent]private ?TYPE parent;");
code.Write("public ?TYPE()", delegate() {
code.Write("parent = null;");
code.Write("OnConstruct();");
});
code.Write("partial void OnConstruct();");
code.Write("public void SetParent(?TYPE p)", delegate() {
code.Write("parent = p;");
});
code.Write("public ?TYPE GetParent()", delegate() {
code.Write("return parent;");
});
});
}
public void GenerateCode(string filename)
{
CSTextDocument document = new CSTextDocument(new CSHeader_SimpleDated("MMMM dd, yyyy"));
CSTextDocumentBuilder builder = document.CreateCSTextBuilder();
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs();
writer.Write("using System;");
writer.Write("using System.Collections;");
writer.Write("using System.Collections.Generic;");
writer.Write("using Crunchy.Dough;");
writer.Write("using Crunchy.Salt;");
writer.Write("using Crunchy.Noodle;");
writer.Write("using Crunchy.Bread;");
writer.Write("using Crunchy.Sandwich;");
GenerateSatelliteClass(builder);
typeof(GamepadComponentType).GetEnumValues <GamepadComponentType>()
.Process(t => GenerateInputDeviceIds(builder, t));
GenerateClass(builder);
document.RenderDocument().Save(filename, true);
}
protected override void GenerateAdditionalObjectMembers(UnityEngine.Object value, CSTextDocumentBuilder builder)
{
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs(
"TYPE", value.GetType().Name,
"NAME", value.name.StyleAsVariableName(),
"FUNCTION", ("Draw_" + value.name).StyleAsFunctionName()
);
foreach (MethodInfo method in value.GetType().GetFilteredInstanceMethods(
Filterer_MethodInfo.IsNamed("Initialize"),
Filterer_MethodInfo.IsOriginalMethod()
))
{
string parameters = method.GetParameters()
.Convert(p => p.ParameterType.GetCleanName() + " " + p.Name)
.Join(", ");
string arguments = method.GetParameters()
.Convert(p => p.Name)
.Join(", ");
writer.Write("static public void ?FUNCTION(" + parameters + ")", delegate() {
writer.Write("GetInstance().?NAME.Draw(" + arguments + ");");
});
}
}
private void GenerateVariableLoadContextInternal(CSTextDocumentBuilder text, string context, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
IndexSituation index_situation = variable.GetVariableContextIndexSituation();
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeConcept().GetStoreTypeName(),
"SET_FUNCTION", settings.ConvertBool("custom_load_context", "LoadContextIntermediate" + variable.GetVariableFunctionName(), "Set" + variable.GetVariableFunctionName()),
"CONTEXT", context,
"GET_CONTEXT_FUNCTION", variable.GetVariableContext().GetGetContextFunctionName(),
"INDEX", index_situation.GetIndex().ToString()
);
string context_expression = "?CONTEXT.?GET_CONTEXT_FUNCTION()";
if (index_situation.IsShared())
{
context_expression = "?CONTEXT.?GET_CONTEXT_FUNCTION(?INDEX)";
}
if (settings.IsTrue("skip_context_conversion"))
{
code.Write("?SET_FUNCTION(" + context_expression + ");");
}
else
{
string value_expression = GetTypeConcept().GetContextToTypeExpression(context_expression);
if (GetTypeConcept().GetTypeName() != GetTypeConcept().GetStoreTypeName())
{
value_expression = "(?TYPE)" + value_expression;
}
code.Write("?SET_FUNCTION(" + value_expression + ");");
}
}
public override void GenerateMainClass(CSTextDocumentBuilder text)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeName(),
"BASE_TYPE", GetBaseType().GetTypeName()
);
code.Write("public partial class ?TYPE : ?BASE_TYPE", delegate() {
code.Write("private int line;");
code.Write("private string base_message;");
code.Write("public override string Message { get{ return GetMessage(); } }");
code.Write("public ?TYPE(int l, string m) : base()", delegate() {
code.Write("line = l;");
code.Write("base_message = m;");
});
code.Write("public int GetLine()", delegate() {
code.Write("return line;");
});
code.Write("public string GetBaseMessage()", delegate() {
code.Write("return base_message;");
});
code.Write("public string GetMessage()", delegate() {
code.Write("return \"(\" + line + \")\" + base_message;");
});
});
}
protected void GenerateBasicDOMifyFunctions(CSTextDocumentBuilder text, bool use_new)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"USE_NEW", use_new.ConvertBool("new"),
"ACCESS", this.GetInfoValue("domify"),
"TYPE", GetTypeName(),
"UTILITIES", GetGrammarDefinition().GetUtilities().GetTypeName(),
"CONTEXT", GetContextName(),
"GET_CONTEXT_FUNCTION", GetGetContextFunctionName()
);
code.Write("static ?USE_NEW ?ACCESS ?TYPE DOMify(IParseTree parse_tree)", delegate() {
code.Write("return DOMify(parse_tree as ?CONTEXT);");
});
code.Write("static ?USE_NEW ?ACCESS ?TYPE DOMify(Stream stream)", delegate() {
code.Write("return DOMify(?UTILITIES.CreateParser(stream).?GET_CONTEXT_FUNCTION());");
});
code.Write("static ?USE_NEW ?ACCESS ?TYPE DOMify(string text)", delegate() {
code.Write("return DOMify(?UTILITIES.CreateParser(text).?GET_CONTEXT_FUNCTION());");
});
code.Write("static ?USE_NEW ?ACCESS ?TYPE DOMifyFile(string filename)", delegate() {
code.Write("return DOMify(?UTILITIES.CreateFileParser(filename).?GET_CONTEXT_FUNCTION());");
});
}
private void GenerateVariableSetFunction(CSTextDocumentBuilder text, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
if (settings.IsNot("set", "none"))
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"SET_ACCESS", settings.Lookup("set"),
"SET_OVERRIDE", settings.ConvertBool("set_override", "override"),
"SET_VIRTUAL", settings.ConvertBool("set_virtual", "virtual"),
"TYPE", GetTypeConcept().GetStoreTypeName(),
"VARIABLE", variable.GetVariableName(),
"SET_VARIABLE_FUNCTION", "Set" + variable.GetVariableFunctionName(),
"CLEAR_VARIABLE_FUNCTION", "Clear" + variable.GetVariableFunctionName(),
"ADD_VARIABLES_FUNCTION", "Add" + variable.GetVariableFunctionName().StyleAsPluralWord()
);
code.Write("?SET_ACCESS ?SET_OVERRIDE ?SET_VIRTUAL void ?SET_VARIABLE_FUNCTION(IEnumerable<?TYPE> input)", delegate() {
code.Write("?CLEAR_VARIABLE_FUNCTION();");
code.Write("?ADD_VARIABLES_FUNCTION(input);");
});
code.Write("?SET_ACCESS void ?SET_VARIABLE_FUNCTION(params ?TYPE[] input)", delegate() {
code.Write("?SET_VARIABLE_FUNCTION((IEnumerable<?TYPE>)input);");
});
}
}
public override void GenerateMainClass(CSTextDocumentBuilder text)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeName(),
"BASE_TYPE", GetBaseType().GetTypeName()
);
code.Write("public abstract partial class ?TYPE : ?BASE_TYPE, Relatable, Holdable<?TYPE>", delegate() {
code.Write("[HoldingContainer]private HoldingContainer<?TYPE> holding_container;");
code.Write("public ?TYPE()", delegate() {
code.Write("holding_container = null;");
code.Write("OnConstruct();");
});
code.Write("partial void OnConstruct();");
code.Write("[RelatableParent]");
code.Write("public ?TYPE GetParent()", delegate() {
code.Write("if(holding_container != null)", delegate() {
code.Write("return holding_container.GetParent();");
}, false);
code.Write("return null;");
});
});
}
static private void GenerateSequencedSpriteMenuItems()
{
CodeGenerator.GenerateStaticClass("SequencedSpriteMenuItems", delegate(CSTextDocumentBuilder builder) {
foreach (SequencedSpriteFormat format in CustomAssets.GetExternalCustomAssetsOfType <SequencedSpriteFormat>())
{
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs(
"PATH", ("Assets/Sprite/Create/Sequenced/" + format.name).StyleAsDoubleQuoteLiteral(),
"FUNCTION_EXECUTE", ("Execute" + format.name).StyleAsFunctionName(),
"FUNCTION_VALIDATE", ("Validate" + format.name).StyleAsFunctionName(),
"FORMAT_PATH", format.GetAssetPath().StyleAsDoubleQuoteLiteral()
);
writer.Write("[MenuItem(?PATH)]");
writer.Write("static public void ?FUNCTION_EXECUTE()", delegate() {
writer.Write("AssetDatabase.LoadAssetAtPath<SequencedSpriteFormat>(?FORMAT_PATH).CreateSequencedSprite(Selection.activeObject as Texture2D);");
});
writer.Write("[MenuItem(?PATH, true)]");
writer.Write("static public bool ?FUNCTION_VALIDATE()", delegate() {
writer.Write("if(Selection.activeObject is Texture2D)", delegate() {
writer.Write("return true;");
});
writer.Write("return false;");
});
}
}, GeneratedCodeType.EditorOnlyLeaf);
}
public override void GenerateMainClass(CSTextDocumentBuilder text)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeName(),
"PARSER", GetGrammarDefinition().GetParserName(),
"LEXER", GetGrammarDefinition().GetLexerName(),
"SYNTAX_EXCEPTION_THROWER", GetGrammarDefinition().GetSyntaxExceptionThrower().GetTypeName()
);
code.Write("static public class ?TYPE", delegate() {
code.Write("static public ?PARSER CreateParser(ICharStream stream)", delegate() {
code.Write("?PARSER parser = new ?PARSER(new CommonTokenStream(new ?LEXER(stream)));");
code.Write("parser.RemoveErrorListeners();");
code.Write("parser.AddErrorListener(?SYNTAX_EXCEPTION_THROWER.INSTANCE);");
code.Write("return parser;");
});
code.Write("static public ?PARSER CreateParser(Stream stream)", delegate() {
code.Write("return CreateParser(new AntlrInputStream(stream));");
});
code.Write("static public ?PARSER CreateParser(TextReader text_reader)", delegate() {
code.Write("return CreateParser(new AntlrInputStream(text_reader));");
});
code.Write("static public ?PARSER CreateParser(string text)", delegate() {
code.Write("return CreateParser(new StringReader(text));");
});
code.Write("static public ?PARSER CreateFileParser(string filename)", delegate() {
code.Write("return CreateParser(new AntlrFileStream(filename));");
});
});
}
private void GenerateMainFile()
{
CSTextDocument document = new CSTextDocument();
CSTextDocumentBuilder text = document.CreateCSTextBuilder();
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"NAMESPACE", settings.GetNamespaceName()
);
code.Write("using System;");
code.Write("using System.IO;");
code.Write("using System.Collections;");
code.Write("using System.Collections.Generic;");
code.SkipLine();
code.Write("using Crunchy.Dough;");
code.Write("using Crunchy.Salt;");
code.Write("using Crunchy.Noodle;");
code.SkipLine();
code.Write("using Antlr4.Runtime;");
code.Write("using Antlr4.Runtime.Tree;");
code.SkipLine();
code.Write("namespace ?NAMESPACE", delegate() {
this.GetDeepChildren <DOMEClass_Generated>().Process(g => g.GenerateMainClass(text));
});
document.RenderDocument().Save(settings.GetOutputDirectory(), GetMainFilename(), true);
}
public void GenerateGetComponentFunction(CSTextDocumentBuilder builder)
{
CSTextDocumentWriter writer = CreateWriter(builder);
writer.Write("public ?TYPE ?GET_FUNCTION()", delegate() {
writer.Write("return ?VARIABLE;");
});
}
protected override void GenerateVariableClearFunctionBody(CSTextDocumentBuilder text, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"VARIABLE", variable.GetVariableName()
);
code.Write("?VARIABLE.Clear();");
}
protected override void GenerateVariableSetFunctionBody(CSTextDocumentBuilder text, DOMEVariable variable, string input, LookupBackedSet <string, string> settings)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"VARIABLE", variable.GetVariableName(),
"INPUT", input
);
code.Write("?VARIABLE.Set(?INPUT);");
}
protected override void GenerateVariableDeclarationInternalBody(CSTextDocumentBuilder text, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeName(),
"VARIABLE", variable.GetVariableName()
);
code.Write("[RelatableChild]private ?TYPE ?VARIABLE;");
}
protected override void GenerateVariableConstructionInternalBody(CSTextDocumentBuilder text, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"VARIABLE", variable.GetVariableName(),
"TYPE", GetTypeName()
);
code.Write("?VARIABLE = new ?TYPE(this);");
}
protected override void GenerateVariableConstructionInternalBody(CSTextDocumentBuilder text, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"VARIABLE", variable.GetVariableName(),
"EXPRESSION", GetTypeConcept().GetDefaultConstructionExpression()
);
code.Write("?VARIABLE = ?EXPRESSION;");
}
private void GenerateMainClassVariableDeclarations(CSTextDocumentBuilder text)
{
if (this.IsInfoValueTrue("store_text"))
{
CSTextDocumentWriter code = text.CreateWriter();
code.Write("private string stored_text;");
}
GetVariables().Process(g => g.GenerateVariableDeclaration(text));
}
protected override void GenerateVariableAddFunctionBody(CSTextDocumentBuilder text, DOMEVariable variable, string input, LookupBackedSet <string, string> settings)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"VARIABLE", variable.GetVariableName(),
"INPUT", input
);
code.Write("?VARIABLE.Add(?INPUT);");
code.Write("if(?INPUT != null)", delegate() {
code.Write("?INPUT.SetParent(this);");
}, false);
}
static private void ProvokeRecompile()
{
CodeGenerator.GenerateCode("CompileControl", delegate(CSTextDocumentBuilder builder) {
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs(
"DATE", DateTime.UtcNow.ToString(),
"JUNK", Strings.PseudoRandom(32)
);
writer.Write("//?DATE");
writer.Write("//?JUNK");
}, GeneratedCodeType.RuntimeDefinition);
}
public override bool GenerateStubClass(CSTextDocumentBuilder text)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeName(),
"BASE_TYPE", GetBaseType().GetTypeName()
);
code.Write("public partial class ?TYPE : ?BASE_TYPE", delegate() {
});
return(true);
}
private void GenerateSatelliteClass(CSTextDocumentBuilder builder)
{
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs(
);
writer.Write("[ApplicationEXSatellite]");
writer.Write("static public class GamepadSatellite", delegate() {
writer.Write("static private void Update()", delegate() {
writer.Write("Gamepad.GetGamepads().Process(d => d.Update());");
});
});
}
private void GenerateVariableDuplicateInternal(CSTextDocumentBuilder text, string instance, DOMEVariable variable, LookupBackedSet <string, string> settings)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"INSTANCE", instance,
"SET_VARIABLE_FUNCTION", "Set" + variable.GetVariableFunctionName()
);
string input_expression = "Get" + variable.GetVariableFunctionName() + "()";
string duplicate_expression = GenerateVariableDuplicateExpression(input_expression);
code.Write("?INSTANCE.?SET_VARIABLE_FUNCTION(" + duplicate_expression + ");");
}
static public void GenerateStaticClass(string class_name, Process <CSTextDocumentBuilder> process, GeneratedCodeType type)
{
GenerateCode(class_name, delegate(CSTextDocumentBuilder builder) {
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs(
"CLASS", class_name.StyleAsClassName()
);
writer.Write("static public class ?CLASS", delegate() {
process(builder);
});
}, type);
}
public override bool GenerateStubClass(CSTextDocumentBuilder text)
{
CSTextDocumentWriter code = text.CreateWriterWithVariablePairs(
"TYPE", GetTypeName(),
"VISITOR", GetGrammarDefinition().GetVisitorName(),
"ELEMENT", GetGrammarDefinition().GetElement().GetTypeName()
);
code.Write("public partial class ?TYPE : ?VISITOR<?ELEMENT>", delegate() {
});
return(true);
}
static private void GenerateLayersClass()
{
CodeGenerator.GenerateStaticClass("Layers", delegate(CSTextDocumentBuilder builder) {
LayerEXExtensions.GetAllLayers().Process(delegate(LayerEX layer) {
CSTextDocumentWriter writer = builder.CreateWriterWithVariablePairs(
"NAME", layer.GetName().StyleAsConstantName(),
"VALUE", layer.GetName().StyleAsDoubleQuoteLiteral()
);
writer.Write("static public readonly LayerEX ?NAME = new LayerEX(?VALUE);");
});
}, GeneratedCodeType.RuntimeDefinition);
}
