def validate(self, romfile, cont=None):
if not self.args.romless:
romstream = helper.stream(romfile)
roms = self.rpl.childrenByType("ROM")
totalfails = []
for x in roms:
successes, fails = x.validate(romstream)
totalfails += fails
#endfor
if totalfails:
self.romsec.note("Failed the following checks: %s" % helper.list2english([
("%s[%i]" % fail
if type(fail) is tuple else
fail) for fail in totalfails
]))
if cont:
self.ieframe.pack_forget()
self.ccframe.pack(fill=Tk.X)
self.cont = cont
#endif
return False
#endif
#endif
return True
def main():
global debug
parser = argparse.ArgumentParser(
description = TITLE + " by Wa (logicplace.com)\n"
"Easily replace resources in ROMs (or other binary formats) by use of"
" a standard descriptor format.",
usage = "Usage: %(prog)s [options] {-x | -i | -m} ROM RPL [Struct names...]\n"
" %(prog)s -h [RPL | lib]\n"
" %(prog)s -t [RPL] [-l libs] [-s Struct types...]",
formatter_class=argparse.RawDescriptionHelpFormatter,
add_help = False,
)
action = parser.add_mutually_exclusive_group()
action.add_argument("--help", "-h", "-?", #"/?", "/h",
help = argparse.SUPPRESS,
action = "store_true"
)
action.add_argument("--version", #"/v",
help = "Show version number and exit.",
action = "store_true"
)
action.add_argument("--import", "-i", #"/i",
dest = "importing",
help = "Import resources in the ROM via the descriptor.",
nargs = 2,
metavar = ("ROM", "RPL")
)
action.add_argument("--export", "-x", #"/x",
help = "Export resources from the ROM via the descriptor.",
nargs = 2,
metavar = ("ROM", "RPL")
)
action.add_argument("--makefile", "-m", "--binary", "-b", #"/m", "/b",
help = "Create a new file. This will overwrite an existing file.\n"
"Implies -r",
nargs = 2,
metavar = ("ROM", "RPL")
)
action.add_argument("--template", "-t", #"/t",
help = "Generate a descriptor skeleton for the given module.\n"
'Use "rpl" to generate the basic one.\n'
"If no destination is given, result is printed to stdout.",
action = "store_true"
)
action.add_argument("--run",
help = "Run a RPL without involving a ROM. Implies --romless",
nargs = 1,
metavar = ("RPL")
)
action.add_argument("--gui",
help = "Open the GUI.",
action = "store_true"
)
parser.add_argument("--libs", "-l", #"/l",
help = "What libs to load for template creation.",
nargs = "*"
)
parser.add_argument("--structs", "-s", #"/s",
help = "What structs to include in the template.",
nargs = "*"
)
parser.add_argument("--romless", "-r", #"/r",
help = "Do not perform validations in ROM struct, and"
" do not warn if there isn't a ROM struct.",
action = "store_true"
)
parser.add_argument("--blank",
help = "Run action without creating or modifying a ROM file.",
action = "store_true"
)
parser.add_argument("--define", "-d", #"/d",
help = "Define a value that can be referenced by @Defs.name\n"
"Values are interpreted as RPL data, be aware of this in regards to"
" strings vs. literals.",
action = "append",
nargs = 2,
metavar = ("name", "value"),
default = []
)
parser.add_argument("--folder", "-f", #"/f",
help = "Folder to export to, or import from. By default this is the"
" current folder.",
default = "."
)
parser.add_argument("--debug",
help = argparse.SUPPRESS,
action = "store_true"
)
parser.add_argument("args", nargs="*", help=argparse.SUPPRESS)
args = parser.parse_args(sys.argv[1:])
debug = args.debug
# Windows help flag.
if args.args and args.args[0] == "/?":
args.help = True
args.args.pop(0)
#endif
if args.help:
if len(args.args) >= 1:
if args.args[0][-3:] == "rpl":
# Load a RPL file's help.
thing = rpl.RPL()
thing.parse(args.args[0], ["RPL"])
rplStruct = thing.childrenByType("RPL")
if not rplStruct: return 0
help = rplStruct[0]["help"].get()
# Abuse argparse's help generator.
filehelp = argparse.ArgumentParser(
description = help[0].get(),
usage = argparse.SUPPRESS
)
for x in help[1:]:
defkey, defhelp = tuple([y.get() for y in x.get()])
filehelp.add_argument("-d" + defkey, help=defhelp)
#endfor
filehelp.print_help()
else:
# Load a lib's help.
tmp = getattr(__import__("rpl." + args.args[0], globals(), locals()), args.args[0])
tmp.printHelp(args.args[1:])
#endif
else: parser.print_help()
elif args.version:
print(TITLE + " - v" + VERSION)
elif args.template:
thing = rpl.RPL()
# Load requested libs.
if args.libs:
rplStruct = rpl.StructRPL()
rplStruct["lib"] = rpl.List(map(rpl.String, args.libs))
thing.load(rplStruct)
#endif
structs = args.structs
if structs and not args.romless: structs = ["ROM"] + structs
print(thing.template(structs))
elif args.run:
thing = rpl.RPL()
thing.parse(args.run[0])
# Do defines.
for x in args.define: thing.addDef(*x)
# Run RPL.
start = time()
thing.run(args.folder, args.args)
print("Finished executing. Time taken: %.3fs" % (time() - start))
elif args.importing or args.export or args.makefile:
# Regular form.
thing = rpl.RPL()
# Grab filenames.
if args.importing: romfile, rplfile = tuple(args.importing)
elif args.export: romfile, rplfile = tuple(args.export)
elif args.makefile: romfile, rplfile = tuple(args.makefile)
thing.parse(rplfile)
if not args.romless and not args.makefile:
romstream = helper.stream(romfile)
roms = thing.childrenByType("ROM")
for x in roms:
successes, fails = x.validate(romstream)
if fails:
print("Failed the following checks: %s" % helper.list2english([
("%s[%i]" % fail
if type(fail) is tuple else
fail) for fail in fails
]))
answer = "."
while answer not in "yYnN": answer = raw_input("Continue anyway (y/n)? ")
if answer in "nN": return 1
#endif
#endfor
#endif
# Do defines.
for x in args.define: thing.addDef(*x)
# Run imports.
start = time()
if args.importing:
thing.importData(romstream, args.folder, args.args, args.blank)
helper.prntc("Finished %s." % ("blank import" if args.blank else "importing"))
romstream.close()
elif args.export:
thing.exportData(romstream, args.folder, args.args, args.blank)
helper.prntc("Finished %s." % ("blank export" if args.blank else "exporting"))
romstream.close()
elif args.makefile:
try: os.unlink(romfile)
except OSError as err:
if err.errno == 2: pass
else:
helper.err('Could not delete "%s": %s' % (romfile, err.strerror))
return 1
#endif
#endtry
thing.importData(romfile, args.folder, args.args, args.blank)
helper.prntc("Finished %s." % ("build test" if args.blank else "building"))
#endif
print("Time taken: %.3fs" % (time() - start))
else:
return GUI().run(args)
#endif
return 0
