public static void Execute(FileCfg fileCfg, StackCfg stackCfg)
{
var runner = new WhomstGlobalJob();
runner.RunJob(fileCfg, stackCfg);
runner.WriteFiles();
}
public static FileCfg ParseCommandLine(string[] args, out string jsonFilename)
{
var firstJob = new FileCfg();
string jsonFilenameLocal = null;
bool showHelp = false;
var options = new OptionSet
{
{ "i|input=", "the file to preprocess", i => firstJob.InputFileName = i },
{ "g|generate", "generate code", g => firstJob.Generate = (g != null) },
{ "c|clean", "deletes generated code", c => firstJob.DeleteOutput = (c != null) },
{ "p|private", "deletes whomst generator code", p => firstJob.DeleteCode = (p != null) },
{ "cfg|config=", "json file holding configuration", f => jsonFilenameLocal = f },
{ "h|help", "show this message and exit", v => showHelp = (v != null) },
{
"x|skip",
"doesn't evaluate whomst code (and therefore does not generate it). Still tries to eval lines beginning " +
$"with force directive (default \"{FormatCfg.Default().ForceDirective}\"",
x => firstJob.SkipCompute = (x != null)
},
{
"o|output=",
"where the file with generated code added gets written to. Leave blank to replace existing file",
o => firstJob.OutputFileName = o
},
};
try { options.Parse(args); }
catch (OptionException e)
{
options.WriteOptionDescriptions(Console.Out);
throw e;
}
if (showHelp)
{
options.WriteOptionDescriptions(Console.Out);
Environment.Exit(0);
}
jsonFilename = jsonFilenameLocal;
return(firstJob);
}
public FileCfg GetProtoFileCfg(string fileExtension)
{
FormatCfg fmtCfg = FormatCfg.Default();
fmtCfg = fmtCfg.MergeOverWith(DefaultFormatCfg);
FormatDict.TryGetValue(fileExtension, out var fromFileExt);
if (fromFileExt != null)
{
fmtCfg = fmtCfg.MergeOverWith(fromFileExt);
}
var fileCfg = new FileCfg()
{
FormatCfg = fmtCfg
};
fileCfg.AddDefines(InitialDefines);
return(fileCfg);
}
public static void OnAppStart(params Assembly[] asms)
{
ControllerBuilder.Current.SetControllerFactory(new JoyControllerFactory());
Identifier.CreateInstance(new FileCfg<AuthConfig>("/configs/auth.json".MapPath()));
Config = new FileCfg<RouterConfig>("/configs/route.json".MapPath());
Config.Instance.Init();
AreaRegistration.RegisterAllAreas();
BindRoutes("{controller}/{action}/{*args}", "{controller}/{*args}", "{*args}");
GlobalFilters.Filters.Add(new HandleErrorAttribute());
GlobalFilters.Filters.Add(new AuthorizeAttribute());
ViewEngines.Engines.Clear();
BindViewEngine(asms);
#if DEBUG
var list = Assembly.GetExecutingAssembly().GetManifestResourceNames();
foreach (var i in list)
{
Logger.Log(i);
}
#endif
}
public void RunJob(FileCfg fileCfg, StackCfg stackCfg)
{
var job = new WhomstJob
{
SharedStackCfg = stackCfg,
SharedFileCfg = fileCfg,
};
{
job.StackCfg = StackCfg.Default().MergeOverWith(job.SharedStackCfg);
job.FileCfg = job.StackCfg.GetProtoFileCfg(job.SharedFileCfg.InputFileExt)
.MergeOverWith(job.SharedFileCfg);
job.FileCfg.Validate();
jobStack.Push(job);
jobWriteList.Add(job);
if (ScriptState == null)
{
ScriptState = CSharpScript.RunAsync(
"",
ScriptOptions.Default
.WithMetadataResolver(ScriptMetadataResolver.Default
.WithBaseDirectory(Environment.CurrentDirectory)
.WithSearchPaths(RuntimeEnvironment.GetRuntimeDirectory())
.WithSearchPaths(job.StackCfg.Includes)
).WithEmitDebugInformation(true),
this, typeof(IWhomstGlobals)).Result;
}
else
{
foreach (var incl in job.StackCfg.Includes.Where(i => Includes.Add(i)))
{
Util.AssertWarning(false,
$"Could not add include directory {incl} midway through Whomst execution");
}
}
StringBuilder setupCode = new StringBuilder();
foreach (var assm in job.StackCfg.Assemblies.Where(a => Assemblies.Add(a)))
{
setupCode.AppendLine($"#r\"{assm}\"");
}
foreach (var using1 in job.StackCfg.Usings.Where(u => Usings.Add(u)))
{
setupCode.AppendLine($"using {using1};");
}
Util.AssertWarning(
InputFiles.Add(job.FileCfg.InputFilePath),
$"{job.FileCfg.InputFilePath} is getting preprocessed twice.");
Util.AssertWarning(
OutputFiles.Add(job.FileCfg.OutputFilePath),
$"{job.FileCfg.OutputFilePath} is getting written twice.");
ScriptState = ScriptState.ContinueWithAsync(setupCode.ToString()).Result;
}
var fmt = job.FileCfg.FormatCfg;
{
var text = File.ReadAllText(job.FileCfg.InputFilePath, fmt.Encoding);
var linesIn = text.EzSplit(fmt.NewL);
void AddLineGroup(int s, int e, LineGroupType t) =>
job.LineGroups.Add(new LineGroup {
InclStart = s, ExclEnd = e, Type = t
});
AddLineGroup(0, -1, LineGroupType.Content);
for (int index = 0; index < linesIn.Length; index++)
{
var line = linesIn[index];
void Assert(bool b, string s) => Util.Assert(
b, s,
job.FileCfg.InputFileName, index + 1);
switch (job.LineGroups.Last().Type)
{
case LineGroupType.Content:
var startTokenInd = line.IndexOf(fmt.StartCodeToken);
if (0 <= startTokenInd)
{
job.LineGroups.Last().ExclEnd = index;
var endTokenInd = line.IndexOf(fmt.StartOutputToken);
if (0 <= endTokenInd)
{
Assert(startTokenInd < endTokenInd,
$"{fmt.StartOutputToken} came before {fmt.StartCodeToken}");
AddLineGroup(index, index + 1, LineGroupType.TwoLiner);
AddLineGroup(index + 1, -1, LineGroupType.GenOutput);
}
else
{
AddLineGroup(index, index + 1, LineGroupType.StartCode);
AddLineGroup(index + 1, -1, LineGroupType.WhomstCode);
}
}
var startOneLinerInd = line.IndexOf(fmt.OneLinerStartCodeToken);
if (0 <= startOneLinerInd && (startTokenInd < 0))
{
var midOneLinerInd = line.IndexOf(fmt.OneLinerStartOutputToken);
var endOneLinerInd = line.IndexOf(fmt.OneLinerEndOutputToken);
Assert(
startOneLinerInd < midOneLinerInd,
$"{fmt.OneLinerStartCodeToken} must be followed with {fmt.OneLinerStartOutputToken}");
Assert(
midOneLinerInd < endOneLinerInd,
$"{fmt.OneLinerStartOutputToken} must be followed with {fmt.OneLinerEndOutputToken}");
job.LineGroups.Last().ExclEnd = index;
AddLineGroup(index, index + 1, LineGroupType.OneLiner);
AddLineGroup(index + 1, -1, LineGroupType.Content);
}
break;
case LineGroupType.WhomstCode:
if (line.Contains(fmt.StartOutputToken))
{
job.LineGroups.Last().ExclEnd = index;
AddLineGroup(index, index + 1, LineGroupType.StartOutput);
AddLineGroup(index + 1, -1, LineGroupType.GenOutput);
}
break;
case LineGroupType.GenOutput:
if (line.Contains(fmt.EndOutputToken))
{
job.LineGroups.Last().ExclEnd = index;
AddLineGroup(index, index + 1, LineGroupType.EndOutput);
AddLineGroup(index + 1, -1, LineGroupType.Content);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
job.LineGroups.Last().ExclEnd = linesIn.Length;
var endingType = job.LineGroups.Last().Type;
Util.Assert(
endingType == LineGroupType.Content || endingType == LineGroupType.OneLiner,
$"Document ends with unclosed {endingType} (missing \"{fmt.EndOutputToken}\"??)",
job.FileCfg.InputFileName, job.LineGroups.Last().InclStart + 1);
List <LineGroup> remove = new List <LineGroup>();
foreach (var lg in job.LineGroups)
{
lg.InLines = linesIn.Slice(lg.InclStart, lg.ExclEnd);
//if (lg.InLines.Count == 0) { remove.Add(lg); }
}
foreach (var rem in remove)
{
job.LineGroups.Remove(rem);
}
}
{
string indent = null;
string oldHash = null;
foreach (var lineGroup in job.LineGroups)
{
string firstLine = lineGroup.InLines.FirstOrDefault();
switch (lineGroup.Type)
{
case LineGroupType.Content:
case LineGroupType.OneLiner:
{
lineGroup.Indent = "";
lineGroup.DeIndentedInLines = lineGroup.InLines;
} break;
case LineGroupType.StartCode:
{
var tokenInd = firstLine.IndexOf(fmt.StartCodeToken);
Util.Assert(
tokenInd + fmt.StartCodeToken.Length == firstLine.Length,
$"Line cannot contain anything after {fmt.StartCodeToken}",
job.FileCfg.InputFileName, lineGroup.StartingLineNumber);
indent = firstLine.Substring(0, tokenInd);
} break;
case LineGroupType.TwoLiner:
{
var tokenInd = firstLine.IndexOf(fmt.StartCodeToken);
indent = firstLine.Substring(0, tokenInd);
} break;
case LineGroupType.WhomstCode: {
} break;
case LineGroupType.StartOutput: {
Util.Assert(
firstLine == $"{indent}{fmt.StartOutputToken}",
"Line with {fmt.StartOutputToken} should contain it, indent, and nothign else",
job.FileCfg.InputFileName, lineGroup.StartingLineNumber);
} break;
case LineGroupType.GenOutput: {
lineGroup.Indent = Regex.Replace(indent, @"[^\s]", " ");
} break;
case LineGroupType.EndOutput: {
Util.Assert(
firstLine.StartsWith($"{indent}{fmt.EndOutputToken}"),
"Indent mismatch",
job.FileCfg.InputFileName, lineGroup.StartingLineNumber);
string restOfLine = firstLine.Substring(indent.Length + fmt.EndOutputToken.Length).Trim();
Util.Assert(!restOfLine.StartsWith(fmt.HashInfix) || restOfLine.Contains(oldHash),
"Code preceding hash does not match hash, which means that generated code has been edited.\n" +
"Undo changes or remove Hash",
job.FileCfg.InputFileName, lineGroup.StartingLineNumber);
} break;
default:
throw new ArgumentOutOfRangeException();
}
lineGroup.Indent = lineGroup.Indent ?? indent;
lineGroup.DeIndentedInLines = lineGroup.DeIndentedInLines
?? lineGroup.InLines.Select((l, ind) =>
{
Util.Assert(l.StartsWith(lineGroup.Indent), "Line not indented",
job.FileCfg.InputFileName, lineGroup.StartingLineNumber + ind);
return(l.Substring(lineGroup.Indent.Length));
}).ToList();
if (lineGroup.Type == LineGroupType.GenOutput)
{
oldHash = Util.CalculateMD5Hash(lineGroup.DeIndentedInLines.AggLines(fmt.NewL));
}
}
}
{
string RunAndRtrn(string code, string file, int lineNumber)
{
ScriptState = Eval(code, file, lineNumber);
var returnValue = ScriptState.ReturnValue;
var returnValueScriptState = returnValue as OneTimeScriptState;
// WhomstLoad or WhomstEval
if (returnValueScriptState != null)
{
ScriptState = returnValueScriptState.ScriptState;
}
else if (returnValue != null)
{
return(returnValue.ToString());
}
return(null);
}
int prevCodeStartLine = -1;
foreach (var lineGroup in job.LineGroups)
{
switch (lineGroup.Type)
{
case LineGroupType.Content: {
job.PrevContentLines = lineGroup.InLines;
} break;
case LineGroupType.OneLiner:
{
var firstLine = lineGroup.InLines[0];
var startInd = firstLine.IndexOf(fmt.OneLinerStartCodeToken);
var midInd = firstLine.IndexOf(fmt.OneLinerStartOutputToken);
var endInd = firstLine.IndexOf(fmt.OneLinerEndOutputToken);
var startIndRight = startInd + fmt.OneLinerStartCodeToken.Length;
var midIndRight = midInd + fmt.OneLinerStartOutputToken.Length;
var endIndRight = endInd + fmt.OneLinerEndOutputToken.Length;
var code = firstLine.Substring(startIndRight, midInd - startIndRight);
var oldOutput = firstLine.Substring(midIndRight, endInd - midIndRight);
var output = RunAndRtrn(code, job.FileCfg.InputFileName, lineGroup.StartingLineNumber)
?.Replace(fmt.NewL, ", ");
// TODO this is shameful
lineGroup.DeIndentedOutLines = new[]
{
firstLine.Substring(0, startInd),
code,
output,
firstLine.Substring(endIndRight, firstLine.Length - endIndRight),
};
// TODO this is shameful
lineGroup.DeIndentedInLines = new[]
{
firstLine.Substring(0, startInd),
code,
oldOutput ?? "",
firstLine.Substring(endIndRight, firstLine.Length - endIndRight),
};
} break;
case LineGroupType.StartCode: {
lineGroup.DeIndentedOutLines = fmt.StartCodeToken.Array1();
} break;
case LineGroupType.TwoLiner:
{
var firstLine = lineGroup.InLines[0];
var startInd = firstLine.IndexOf(fmt.StartCodeToken);
var midInd = firstLine.IndexOf(fmt.StartOutputToken);
var startIndRight = startInd + fmt.StartCodeToken.Length;
var code = firstLine.Substring(startIndRight, midInd - startIndRight);
lineGroup.DeIndentedOutLines = code.Array1();
job.PrevCodeLines = lineGroup.DeIndentedOutLines;
prevCodeStartLine = lineGroup.StartingLineNumber;
} break;
case LineGroupType.WhomstCode: {
job.PrevCodeLines = lineGroup.DeIndentedInLines;
prevCodeStartLine = lineGroup.StartingLineNumber;
} break;
case LineGroupType.StartOutput:
break;
case LineGroupType.GenOutput: {
// TODO past output
job.WhomstOut = new StringWriter();
var codeSb = new StringBuilder();
int lineNumber = prevCodeStartLine;
foreach (var ind in Enumerable.Range(0, job.PrevCodeLines.Count))
{
var lineCpy = job.PrevCodeLines[ind];
if (lineCpy.Contains(fmt.ForceDirective))
{
lineCpy = lineCpy.Replace(fmt.ForceDirective, "");
}
else if (job.FileCfg.ShallSkipCompute)
{
continue;
}
if (lineCpy.Contains(fmt.YieldDirective) || ind == job.PrevCodeLines.Count - 1)
{
codeSb.AppendLine(lineCpy.Replace(fmt.YieldDirective, ""));
var output = RunAndRtrn(codeSb.ToString(), fileCfg.InputFileName, lineNumber);
if (output != null)
{
job.WhomstOut.WriteLine(output);
}
codeSb.Clear();
lineNumber = prevCodeStartLine + ind + 1;
}
else
{
codeSb.AppendLine(lineCpy);
}
}
var outputUnindented = job.WhomstOut.GetStringBuilder().ToString();
if (outputUnindented.EndsWith(Environment.NewLine))
{
outputUnindented =
outputUnindented.Substring(0, outputUnindented.Length - Environment.NewLine.Length);
}
job.WhomstOut.Dispose();
job.WhomstOut = null;
lineGroup.DeIndentedOutLines = outputUnindented.EzSplit(fmt.NewL).ToList();
job.PrevOutputLines = lineGroup.DeIndentedOutLines;
} break;
case LineGroupType.EndOutput:
{
var hash = Util.CalculateMD5Hash(job.PrevOutputLines.AggLines(fmt.NewL));
lineGroup.DeIndentedOutLines = $"{fmt.EndOutputToken}{fmt.HashInfix} {hash}".Array1();
} break;
default:
throw new ArgumentOutOfRangeException();
}
lineGroup.DeIndentedOutLines = lineGroup.DeIndentedOutLines ?? lineGroup.DeIndentedInLines;
OneTimeScriptState.CheckInstancesDisposed();
}
}
// Invalidating stuff which I know I don't want to be used again
job.WhomstOut = null;
job.PrevCodeLines = null;
job.PrevContentLines = null;
job.PrevOutputLines = null;
jobStack.Pop();
}
OneTimeScriptState IWhomstGlobals.WhomstLoad(FileCfg fileCfg, StackCfg stackCfg,
string src, int ln)
{
RunJob(fileCfg, stackCfg ?? CurrentJob.StackCfg.Clone());
return(new OneTimeScriptState(ScriptState, src, ln));
}
public ResController() : base(false, "Load")
{
config = new FileCfg<ExtConfig>("/configs/exts.json".MapPath());
}
static ResHandler()
{
config = new FileCfg<ExtConfig>("/configs/exts.json".MapPath());
}