public DirectiveHandler(IncludeFileSearcher includeSearcher, IncludeFileSearcher toolSearcher)
{
directives = new Dictionary <string, IDirective>
{
{ "include", new IncludeDirective {
FileSearcher = includeSearcher
} },
{ "incbin", new IncludeBinaryDirective {
FileSearcher = includeSearcher
} },
{ "incext", new IncludeExternalDirective {
FileSearcher = toolSearcher
} },
{ "inctext", new IncludeToolEventDirective {
FileSearcher = toolSearcher
} },
{ "inctevent", new IncludeToolEventDirective {
FileSearcher = toolSearcher
} },
{ "ifdef", new IfDefinedDirective() },
{ "ifndef", new IfNotDefinedDirective() },
{ "else", new ElseDirective() },
{ "endif", new EndIfDirective() },
{ "define", new DefineDirective() },
{ "pool", new PoolDirective() },
{ "undef", new UndefineDirective() },
};
}
public EAInterpreter(IOutput output, string game, string rawsFolder, string rawsExtension, Stream sin, string inFileName, Log log)
{
this.game = game;
this.output = output;
try
{
allRaws = ProcessRaws(game, ListAllRaws(rawsFolder, rawsExtension));
}
catch (RawReader.RawParseException e)
{
Location loc = new Location
{
file = e.FileName,
lineNum = e.LineNumber,
colNum = 1
};
log.Message(Log.MsgKind.ERROR, loc, "An error occured while parsing raws");
log.Message(Log.MsgKind.ERROR, loc, e.Message);
Environment.Exit(-1); // ew?
}
this.sin = sin;
this.log = log;
iFile = inFileName;
IncludeFileSearcher includeSearcher = new IncludeFileSearcher();
includeSearcher.IncludeDirectories.Add(AppDomain.CurrentDomain.BaseDirectory);
foreach (string path in EAOptions.Instance.includePaths)
{
includeSearcher.IncludeDirectories.Add(path);
}
IncludeFileSearcher toolSearcher = new IncludeFileSearcher {
AllowRelativeInclude = false
};
toolSearcher.IncludeDirectories.Add(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Tools"));
foreach (string path in EAOptions.Instance.toolsPaths)
{
includeSearcher.IncludeDirectories.Add(path);
}
myParser = new EAParser(allRaws, log, new Preprocessor.DirectiveHandler(includeSearcher, toolSearcher));
myParser.Definitions['_' + game + '_'] = new Definition();
myParser.Definitions["__COLORZ_CORE__"] = new Definition();
}
static int Main(string[] args)
{
IncludeFileSearcher rawSearcher = new IncludeFileSearcher();
rawSearcher.IncludeDirectories.Add(AppDomain.CurrentDomain.BaseDirectory);
Stream inStream = Console.OpenStandardInput();
string inFileName = "stdin";
IOutput?output = null;
string outFileName = "none";
string ldsFileName = "none";
TextWriter errorStream = Console.Error;
Maybe <string> rawsFolder = rawSearcher.FindDirectory("Language Raws");
string rawsExtension = ".txt";
if (args.Length < 2)
{
Console.WriteLine("Required parameters missing.");
return(EXIT_FAILURE);
}
bool outputASM = false;
if (args[0] == "AA")
{
outputASM = true;
}
else
if (args[0] != "A")
{
Console.WriteLine("Only assembly is supported currently.");
return(EXIT_FAILURE);
}
for (int i = 2; i < args.Length; i++)
{
if (args[i][0] != '-')
{
Console.Error.WriteLine("Unrecognized paramter: " + args[i]);
}
else
{
string[] flag = args[i].Substring(1).Split(new char[] { ':' }, 2);
try
{
switch (flag[0])
{
case "raws":
rawsFolder = rawSearcher.FindDirectory(flag[1]);
break;
case "rawsExt":
rawsExtension = flag[1];
break;
case "output":
outFileName = flag[1];
if (outputASM)
{
ldsFileName = Path.ChangeExtension(outFileName, "lds");
output = new ASM(new StreamWriter(outFileName, false),
new StreamWriter(ldsFileName, false));
}
else
{
FileStream outStream;
if (File.Exists(outFileName) && !File.GetAttributes(outFileName).HasFlag(FileAttributes.ReadOnly))
{
outStream = File.Open(outFileName, FileMode.Open, FileAccess.ReadWrite);
}
else if (!File.Exists(outFileName))
{
outStream = File.Create(outFileName);
}
else
{
Console.Error.WriteLine("Output file is read-only.");
return(EXIT_FAILURE);
}
output = new ROM(outStream);
}
break;
case "input":
inFileName = flag[1];
inStream = File.OpenRead(flag[1]);
break;
case "error":
errorStream = new StreamWriter(File.OpenWrite(flag[1]));
EAOptions.Instance.noColoredLog = true;
break;
case "debug":
Debug = true;
break;
case "werr":
EAOptions.Instance.werr = true;
break;
case "-no-mess":
EAOptions.Instance.nomess = true;
break;
case "-no-warn":
EAOptions.Instance.nowarn = true;
break;
case "-no-colored-log":
EAOptions.Instance.noColoredLog = true;
break;
case "quiet":
EAOptions.Instance.nomess = true;
EAOptions.Instance.nowarn = true;
break;
case "-nocash-sym":
EAOptions.Instance.nocashSym = true;
break;
case "-build-times":
EAOptions.Instance.buildTimes = true;
break;
case "I":
case "-include":
EAOptions.Instance.includePaths.Add(flag[1]);
break;
case "T":
case "-tools":
EAOptions.Instance.toolsPaths.Add(flag[1]);
break;
case "IT":
case "TI":
EAOptions.Instance.includePaths.Add(flag[1]);
EAOptions.Instance.toolsPaths.Add(flag[1]);
break;
case "h":
case "-help":
Console.Out.WriteLine(helpstring);
return(EXIT_SUCCESS);
case "D":
case "def":
case "define":
try {
string[] def_args = flag[1].Split(new char[] { '=' }, 2);
EAOptions.Instance.defs.Add(Tuple.Create(def_args[0], def_args[1]));
} catch (IndexOutOfRangeException)
{
Console.Error.WriteLine("Improperly formed -define directive.");
}
break;
case "romoffset":
try
{
EAOptions.Instance.romOffset = Convert.ToInt32(flag[1], 16);
} catch {
Console.Error.WriteLine("Invalid hex offset given for ROM.");
}
break;
default:
Console.Error.WriteLine("Unrecognized flag: " + flag[0]);
return(EXIT_FAILURE);
}
}
catch (IOException e)
{
Console.Error.WriteLine("Exception: " + e.Message);
return(EXIT_FAILURE);
}
}
}
if (output == null)
{
Console.Error.WriteLine("No output specified for assembly.");
return(EXIT_FAILURE);
}
if (rawsFolder.IsNothing)
{
Console.Error.WriteLine("Couldn't find raws folder");
return(EXIT_FAILURE);
}
string game = args[1];
//FirstPass(Tokenizer.Tokenize(inputStream));
Log log = new Log {
Output = errorStream,
WarningsAreErrors = EAOptions.Instance.werr,
NoColoredTags = EAOptions.Instance.noColoredLog
};
if (EAOptions.Instance.nowarn)
{
log.IgnoredKinds.Add(Log.MsgKind.WARNING);
}
if (EAOptions.Instance.nomess)
{
log.IgnoredKinds.Add(Log.MsgKind.MESSAGE);
}
EAInterpreter myInterpreter = new EAInterpreter(output, game, rawsFolder.FromJust, rawsExtension, inStream, inFileName, log);
ExecTimer.Timer.AddTimingPoint(ExecTimer.KEY_RAWPROC);
bool success = myInterpreter.Interpret();
if (success && EAOptions.Instance.nocashSym)
{
using (var symOut = File.CreateText(Path.ChangeExtension(outFileName, "sym")))
{
if (!(success = myInterpreter.WriteNocashSymbols(symOut)))
{
log.Message(Log.MsgKind.ERROR, "Error trying to write no$gba symbol file.");
}
}
}
if (EAOptions.Instance.buildTimes)
{
// Print times
log.Output.WriteLine();
log.Output.WriteLine("Times:");
foreach (KeyValuePair <TimeSpan, string> time in ExecTimer.Timer.SortedTimes)
{
log.Output.WriteLine(" " + time.Value + ": " + time.Key.ToString() + " (" + ExecTimer.Timer.Counts[time.Value] + ")");
}
// Print total time
log.Output.WriteLine();
log.Output.WriteLine("Total:");
log.Output.WriteLine(" " + ExecTimer.Timer.TotalTime.ToString());
}
inStream.Close();
output.Close();
errorStream.Close();
return(success ? EXIT_SUCCESS : EXIT_FAILURE);
}