public ValidationBuilder(CompilerOptions options, CodeDOMModule global,
String scriptExt,
String basePath, String workingBasePath = null)
{
Ca = new ContextAnalyzation.ContextAnalyzer(options, global);
if (workingBasePath == null)
{
workingBasePath = basePath;
}
try
{
Base = new DirectoryInfo(basePath);
if (!Base.Exists)
{
throw new FileNotFoundException("Base path directory does not exist: {0}".Fmt(basePath));
}
}
catch (Exception e)
{
throw new Exception("Cannot get directory information on \"{0}\"".Fmt(Base), e);
}
try
{
Working = new DirectoryInfo(workingBasePath);
if (!Working.Exists)
{
throw new FileNotFoundException("Working base path directory does not exist: {0}".Fmt(workingBasePath));
}
}
catch (Exception e)
{
throw new Exception("Cannot get directory information on \"{0}\"".Fmt(workingBasePath), e);
}
ScriptExt = scriptExt;
Current = Working.EnumerateFiles("*.{0}".Fmt(ScriptExt), SearchOption.AllDirectories).GetEnumerator();
}
static int _Main(string[] args)
{
ColorInit();
var fields = Args.GetFieldsFromPrefix <Program>("param");
List <String> targets = new List <string>();
var r = Args.SetArgs(null, args, ref targets, fields);
if (args.Length == 0 || r == Args.ArgResult.IncompleteOrInvalid)
{
Console.WriteLine("Need arguments or invalid arguments.");
Console.WriteLine();
Console.WriteLine(Args.GetUsage(fields, null));
return(0);
}
if (paramBasePath != null && targets.Count > 0)
{
WriteLine(ConCol.Warning, "Cannot build syntax targets and perform validation together. Either provide just syntax targets "
+ "or provide a base path for validation with /BasePath.");
return(1);
}
CompilerFrontEnd cfe = new CompilerFrontEnd();
//Get the settings file from the current module directory, not working directory. Or else D&D would use incorrect paths.
if (paramSettings == null)
{
paramSettings = Path.Combine((new FileInfo(Assembly.GetExecutingAssembly().Location)).DirectoryName, defaultSettings);
}
if (!File.Exists(paramSettings))
{
using (FileStream fs = new FileStream(paramSettings, FileMode.Create))
cfe.Options.SaveOptions(fs);
WriteLine(ConCol.Info, "Writing settings to [{0}]".Fmt(paramSettings));
}
else
{
using (FileStream fs = new FileStream(paramSettings, FileMode.Open))
cfe.Options.LoadOptions(fs);
WriteLine(ConCol.Info, "Loaded settings from [{0}]".Fmt(paramSettings));
using (FileStream fs = new FileStream(paramSettings, FileMode.Create))
cfe.Options.SaveOptions(fs);
}
if (paramClearOutput)
{
WriteLine(ConCol.Info, "Clearing output folder");
var di = new DirectoryInfo(paramOutputFolder);
if (di.Exists)
{
di.Delete(true);
}
di.Create();
}
if (paramSetGlobal != null)
{
try
{
if (!ProcessFile(cfe, new FileInfo(paramSetGlobal), 1, 0))
{
return(1);
}
}
catch (Exception e)
{
WriteLine(ConCol.Error, "Error reading global file [{0}]: {1}", paramSetGlobal, e.Message);
e.BreakException();
}
global = cfe.UserDefinedDOM;
if (!global.IsDeclarative)
{
WriteLine(ConCol.Error, "Global module must be set declarative with \"#set_global_declarative\".");
Console.ReadKey(true);
return(1);
}
}
foreach (var file in targets)
{
try
{
if (File.Exists(file))
{
pending.Add(new FileInfo(file));
}
else
if (Directory.Exists(file))
{
foreach (var _file in (new DirectoryInfo(file)).EnumerateFiles(fileMask, SearchOption.AllDirectories))
{
pending.Add(_file);
}
}
else
{
WriteLine(ConCol.Warning, "Could not find file/folder [{0}]".Fmt(file));
}
}
catch (Exception e)
{
WriteLine(ConCol.Error, "Could not add file [{0}] to pending: {1}".Fmt(file, e.Message));
e.BreakException();
}
}
if (paramBasePath == null)
{
BuildSyntax(cfe);
}
else
{
Validate(cfe);
}
return(0);
}
/// <summary>
/// Compares two CodeDOM graphs. Will list differences according to scope
/// of scope. i.e. root, declaration, function definition, statement, constant, etc.
/// </summary>
/// <param name="a">Operand A</param>
/// <param name="b">Operand B</param>
/// <returns>Returns a list of differences, an empty list means both modules are equal in code graphs.</returns>
public static List <ExprCompareData.Set> CompareDOM(CodeDOMModule a, CodeDOMModule b)
{
ExprCompareData ecd = new ExprCompareData();
/*if (!a.Name.Equals(b.Name, StringComparison.OrdinalIgnoreCase))
* ecd.RaiseSingle("Different module name");*/
if (a.Imports.Length != b.Imports.Length)
{
return(ecd.RaiseSingle("Different import count ({0}) ({1})".Fmt(a.Imports.Length, b.Imports.Length)));
}
IEnumerator <ImportDirective> ie = b.Imports.AsEnumerable().GetEnumerator();
foreach (var i in a.Imports)
{
ie.MoveNext();
if (i.CompareDecl(ecd, ie.Current) == ExprCompareData.Result.False)
{
return(ecd.RaiseSingle("Different import directive ({0}) ({1})"
.Fmt(i.Reference, ie.Current.Reference)));
}
}
if (a.Imports.Length != b.Imports.Length)
{
return(ecd.RaiseSingle("Different import lengths ({0}) ({1})"
.Fmt(a.Constants.Length, b.Imports.Length)));
}
IEnumerator <DeclaredConstant> de = b.Constants.AsEnumerable().GetEnumerator();
foreach (var c in a.Constants)
{
de.MoveNext();
if (!c.CompareDeclConstant(ecd, de.Current))
{
return(ecd.RaiseSingle("Different constants ({0}) ({1})"
.Fmt(c.Value, de.Current.Value), c.Location));
}
}
if (a.Declarations.Length != b.Declarations.Length)
{
return(ecd.RaiseSingle("Different declaration lengths ({0}) ({1})"
.Fmt(a.Declarations.Length, b.Declarations.Length)));
}
IEnumerator <Declaration> ed = b.Declarations.AsEnumerable().GetEnumerator();
foreach (var d in a.Declarations)
{
ed.MoveNext();
if (d.CompareDecl(ecd, ed.Current) == ExprCompareData.Result.False)
{
return(ecd.RaiseSingle("Different function/directive declarations"));
}
}
return(ecd.UneqList);
}
