155 lines
5.0 KiB
Python
155 lines
5.0 KiB
Python
import re, rehelper as h, path
|
|
|
|
SUB = 1
|
|
IF_PARAMETER = 11
|
|
FUNC_PER_ROW = 101
|
|
FUNC_PER_FILE = 102
|
|
|
|
class Params:
|
|
def __init__(self, regexprules, *other):
|
|
self.regexps = []
|
|
self.other = other
|
|
|
|
self.addRegexps(regexprules)
|
|
|
|
def addRegexps(self, rules):
|
|
self.regexps.extend(rules)
|
|
|
|
def GetPackageInfo(x):
|
|
try:
|
|
pkg = re.search("package (.*?);", x, re.M)
|
|
return pkg.span()[0], pkg.groups()[0].split(".")
|
|
except: return -1, []
|
|
|
|
def ImportToInclude(env, x):
|
|
if not x.startswith("import"):
|
|
return x
|
|
|
|
x = x.rstrip().rstrip(";")
|
|
if x.endswith("*"):
|
|
return "/* " + x + " */"
|
|
|
|
packages = x[7:].replace(".", "/")
|
|
basepath = "/".join(env['package'])
|
|
relpath = path.Path(basepath).relpathto(packages).replace("\\", "/")
|
|
|
|
"""
|
|
print packages
|
|
print basepath
|
|
print relpath
|
|
raw_input()
|
|
"""
|
|
|
|
return '#include "' + relpath + '.h"';
|
|
|
|
def PackageToGuards(x):
|
|
try:
|
|
b, pkg = GetPackageInfo(x)
|
|
if b == -1: raise Exception("Package not found")
|
|
package = "_".join(pkg)
|
|
x = x[:b] + "//" + x[b:]
|
|
clazz = re.search("(class|interface) (%s)"%h.identifier(), x, re.M).groups()[1]
|
|
full = "%s__%s_H__"%(package.upper(), clazz)
|
|
return "#ifndef %s\n#define %s\n\n%s\n#endif /*%s*/\n"%(full,full,x,full)
|
|
except:
|
|
import traceback
|
|
traceback.print_exc()
|
|
return x
|
|
|
|
def convert(infilename, outfilename, params):
|
|
ins = outs = file(infilename, 'r').read()
|
|
env = {"package": GetPackageInfo(outs)[1]}
|
|
|
|
for ot, of in params.other:
|
|
if ot == FUNC_PER_ROW:
|
|
l = outs = "\n".join([of(env, line) for line in outs.split("\n")])
|
|
|
|
if ot == FUNC_PER_FILE: outs = of(outs)
|
|
|
|
def _ifParameter(dst):
|
|
def checkIfParam(b, e):
|
|
eaten = []
|
|
for x in outs[:b][::-1]:
|
|
if x == "(": break
|
|
if x in "){}": return False
|
|
eaten.append(x)
|
|
for x in outs[e+1:]:
|
|
if x == ")": break
|
|
if x in "({}": return False
|
|
eaten.append(x)
|
|
return "=" not in eaten
|
|
return lambda m: dst if checkIfParam(*m.span()) else m.group()
|
|
F = {IF_PARAMETER : _ifParameter
|
|
}
|
|
for rexp in params.regexps:
|
|
type, src, dst = rexp[:3]
|
|
try: dstFunc = F.get(rexp[3], None)(dst)
|
|
except: dstFunc = None
|
|
if type == SUB: outs = re.sub(src, dstFunc or dst, outs)
|
|
|
|
file(outfilename, 'w').write(outs)
|
|
|
|
def compileRegexpRules(ruleList): return ruleList
|
|
|
|
JavaToCppRules = compileRegexpRules([
|
|
(SUB, h.wholeWord("boolean"), "bool"),
|
|
(SUB, h.wholeWord("double"), "float"),
|
|
(SUB, h.wholeWord("byte"), "char"),
|
|
(SUB, h.wholeWord("String"), "const std::string&", IF_PARAMETER),
|
|
(SUB, h.wholeWord("String"), "std::string"),
|
|
(SUB, h.wholeWord("null"), "NULL"),
|
|
(SUB, h.wholeWord("private"), "/*private*/"),
|
|
(SUB, h.wholeWord("protected"), "/*protected*/"),
|
|
(SUB, h.wholeWord("public"), "/*public*/"),
|
|
(SUB, h.wholeWord("interface"), "/*interface*/ class"),
|
|
(SUB, h.wholeWord("final"), "const"),
|
|
(SUB, h.wholeWord("new"), "/*new*/"),
|
|
(SUB, h.wholeWord(" implements "),": /*implements-interface*/ public "),
|
|
(SUB, h.wholeWord(" extends "),": public "),
|
|
(SUB, "@Override", "/*@Override*/"),
|
|
(SUB, "\\bthis[.]", "this->"),
|
|
(SUB, "\\bsuper[.]","super::"),
|
|
(SUB, "\\btag[.]","tag->"),
|
|
(SUB, "\\bentityTag[.]","entityTag->")
|
|
])
|
|
|
|
JavaToCppParams = Params(JavaToCppRules,
|
|
(FUNC_PER_ROW, ImportToInclude),
|
|
(FUNC_PER_FILE,PackageToGuards))
|
|
|
|
if __name__ == "__main__":
|
|
import os, sys
|
|
import glob
|
|
|
|
MinecraftRules = compileRegexpRules([
|
|
(SUB, "\\blevel[.]","level->"),
|
|
(SUB, "\\bentity[.]","entity->"),
|
|
(SUB, "\\bplayer[.]","player->"),
|
|
(SUB, h.wholeWord("Mob"), "Mob*", IF_PARAMETER),
|
|
(SUB, h.wholeWord("Player"), "Player*", IF_PARAMETER),
|
|
(SUB, h.wholeWord("Tile"), "Tile*", IF_PARAMETER),
|
|
(SUB, h.wholeWord("Level"), "Level*", IF_PARAMETER),
|
|
(SUB, h.wholeWord("Entity"), "Entity*", IF_PARAMETER),
|
|
(SUB, "\\bTile[.](%s)[.]"%h.identifier(),"Tile::\\1->"),
|
|
(SUB, "\\bItem[.](%s)[.]"%h.identifier(),"Item::\\1->"),
|
|
(SUB, "\\b[^/]?Tile[.]","Tile::"),
|
|
(SUB, "\\b[^/]?Item[.]","Item::"),
|
|
(SUB, "\\b[^/]?Material[.]","Material::"),
|
|
(SUB, "\\b[^/]?Mth[.]","Mth::")
|
|
])
|
|
|
|
# Java to C++
|
|
params = JavaToCppParams
|
|
# add more params here if needed
|
|
params.addRegexps(MinecraftRules)
|
|
|
|
fns = glob.glob(sys.argv[1])
|
|
for full in fns:
|
|
fn, ext = os.path.splitext(full)
|
|
outfn = "%s.h"%fn
|
|
|
|
if os.path.exists(outfn):
|
|
continue
|
|
|
|
convert("%s.java"%fn, outfn, params)
|