def build(classfile):
global dclass
global vclass
global fclass
global allclasses
global allheaders
global withoutpath
#print "adding", classfile + "'s members to dictionary"
# Reading the header file
f = open(classfile, 'r')
lines = f.readlines()
f.close()
vlist = [] # List of members and methods
classname = ""
COMMENT = FALSE
INMACRO = FALSE
INRECORD = FALSE
INCLASS = FALSE
for line in lines:
line = wstring.chop(line) # Remove line separators
if wstring.strip(line) == "": continue
if not INCLASS: INCLASS = lexer.openclass(line)
if not INCLASS: continue
INCLASS = lexer.closeclass(line)
if not INCLASS: continue
# Skip typedef and struct blocks
if not INRECORD: INRECORD = lexer.openrecord(line)
if INRECORD:
INRECORD = lexer.closerecord(line)
continue
# If we are inside a macro or pragma block, skip it
if not INMACRO: INMACRO = lexer.opendef(line)
if INMACRO:
INMACRO = lexer.closedef(line)
continue
words = string.split(line)
if len(words) > 1:
w = words[0]
if w == "class": # First of new class found
if len(vlist) > 0:
if classname == "":
print "Error, members without class", vlist
sys.exit(0)
classname = words[1]
if classname not in allclasses:
allclasses[classname] = classfile
if classfile not in allheaders:
allheaders[classfile] = classname
dummy, fname = os.path.split(classfile)
withoutpath[fname] = classname
print "class", classname, "in", classfile
INCLASS = TRUE
continue
# Processing comment block
if not COMMENT:
if not lexer.embeddedcomment(line):
COMMENT = lexer.opencomment(line)
else:
test = lexer.removecomment(line)
if wstring.strip(test) == "": continue
# Inside a multi-line comment
if COMMENT: # Comment opened
COMMENT = lexer.closecomment(line) # Always inside comment?
# End of multi-line comment
if not COMMENT: # Terminator reached
i = string.find(line, "*/")
if i == -1:
print "Error in parsing header"
sys.exit(0)
line = line[i + 2:] # Keeping the code is exists
# Start of multi-line comment
if COMMENT:
i = string.find(line, "/*")
if i != -1:
line = line[:i]
else:
continue
line = wstring.strip(line)
if line == "": continue
# Define statement are ignored
if line[0:7] == "#define": continue
if lexer.isdeclaration(line):
# Processing simple var declarations
if lexer.isvardecl(line):
nlist = lexer.splitvardecl(line)
for n in nlist:
vlist.append(n)
n = lexer.getident(n)
vclass[n] = classname
dclass[n] = classname
#print "append var", n
continue
# Processing function declaration
if lexer.isprototype(line):
f = lexer.prototype
vlist.append(f)
fkey = lexer.getident(f)
fclass[fkey] = classname
dclass[fkey] = classname
#print "append function", f
continue
def transform(cfile):
global cpp
global hpp
global locals
global linenumber
global lastinclude
global included
global omitted
global allclasses
global allheaders
global withoutpath
# I guess the header file name
node, ext = os.path.splitext(cfile)
hppname = node + ".hpp"
# I guess the class name to create an instance
dummy, instance = os.path.split(node)
instance = allheaders[hppname]
print "mkcpp - converting", cfile, "with" , hppname
infile = open(cfile, "rb")
if infile is None:
print "Enable to open", cfile
sys.exit(0)
cpp = []
hpp = []
varlist = []
funclist = []
staticlist = []
included = []
omitted = []
linenumber = 0
# Internal function: add a line to cpp file
def addit(line):
global linenumber
line = wstring.chop(line)
cpp.append(line)
linenumber += 1
return
# Processing the C file
COMMENT = FALSE # This flag is true inside a comment
INSBLK = FALSE # This one inside a function's body
INSMAC = FALSE
NOCASE = (os.name == "nt") | (os.name == "dos")
while(1):
line = infile.readline()
if not line: break
line = wstring.chop(line) # Removing line separators
if len(wstring.strip(line)) == 0:
addit("")
continue # Empty line ignored
# Updating include statements
if len(line) > 11: # min is #include "a"
if line[:9] == "#include ":
# get last include linenumber
lastinclude = linenumber
i = string.find(line, '\"') # locate first "
if i == -1:
#print "no valid"
addit(line)
continue
j = string.find(line, '\"', i + 1) # locate second "
if j == -1:
print "Error, quotes not closed"
print line
sys.exit(0)
hpath = line[i + 1:j]
if len(hpath) > 2:
node, ext = os.path.splitext(hpath)
hppath = node + ".hpp"
if NOCASE: hppath = string.lower(hppath)
# add this path to the list of included header files
if hppath not in included:
included.append(hppath)
line = string.replace(line, hpath, hppath)
#print "replaced", line
addit(line)
continue
# If we enter a comment block, append it and
# process other code on the same line
if not COMMENT:
if not lexer.embeddedcomment(line):
COMMENT = lexer.opencomment(line)
else:
test = lexer.removecomment(line)
if wstring.strip(test) == "": # Simple one-line comment
addit(line)
continue
# Inside a comment block if multi-lines
if COMMENT: # Comment opened
#print "inside c comment", line
COMMENT = lexer.closecomment(line) # Always inside comment?
# End of multi-line comment
if not COMMENT: # Terminator reached
i = string.find(line, "*/")
if i == -1:
print "Error in parsing header"
sys.exit(0)
addit(line[:i+2])
line = line[i + 2:] # Keeping the code is exists
# Start of multi-line comment
if COMMENT:
i = string.find(line, "/*")
if i != -1:
addit(line[i:])
line = line[:i]
else:
addit(line) # A line of the comment block
continue
if line is None: continue
if wstring.strip(line) == "":
addit(line)
continue
# If we are inside a macro or pragma block, skip it
if not INSMAC: INSMAC = lexer.opendef(line)
if INSMAC:
INSMAC = lexer.closedef(line)
addit(line)
continue
# Comment unterminated are removed
if lexer.unterminated(line):
line = lexer.removecomment(line)
# Simple keywords of type on the line
if lexer.typeonly(line):
#print "type only", line
while(1):
next = infile.readline()
if not next: break
next = wstring.clean(next)
if next == "": continue
line = line + ' ' + next
break
#print "type only now", line
# A function's prototype: remove it
if lexer.isprototype(line):
continue
# A local one line typedef
if lexer.linetypedef(line):
addit(line)
continue
if lexer.linestruct(line):
addit(line)
continue
# A function's definition
if lexer.isfunction(line) == TRUE:
#print "is function ", line
# The heading may use several lines
while string.find(line, ')') == -1:
next = infile.readline()
if next == None:
print "Error, function uncomplete"
exit()
next = wstring.chop(next)
next = wstring.strip(next)
line = line + next
# Handling the old format with declarations on next lines
nextline = line
if lexer.oldformat(line):
#print "old format", line
tlist = []
counter = lexer.argscount(line)
while(counter):
l = infile.readline()
if not l: break
l = wstring.clean(l)
l = lexer.getdecl(l)
if lexer.isvardecl(l):
tlist.append(l)
counter = counter - 1
else:
break
if '{' in l:
i = string.find(l, '{')
nextline = l[i:]
break
# Rebuilding the heading according to the new format
line = lexer.argreplace(line, tlist)
#print "args replace", line, "with list", tlist
# With the class prefix, a function becomes a method
# but for the main function
funcname = lexer.getident(line)
if funcname is None:
print "Error, no ident in", line
sys.exit(0)
funcname = string.lower(funcname)
# add the class prefix, but for the main function
# for wich classname (used further) must be defined
if funcname != "main":
line, classname = setmethod(line)
else:
classname = getclass("main")
line = lexer.removestatic(line)
addit(line)
#print "Added method", line
# Now making a list from the block,
# for scanning variables inside local scope
blocklist = []
# Adding the arguments in the list of local variables
plist, pi, pj = lexer.getargs(line)
arglist = []
if not plist is None:
for p in plist:
arglist.append(lexer.addsemicolon(p))
locals = []
processlocals(arglist)
# Handling already skiped lines by giving the last line
# read from the file, for following tests
line = nextline
if not INSBLK: INSBLK = '{' in line
# reading next lines, skipping empty or comment lines
while not INSBLK:
line = infile.readline()
if not line:
print "Error, end of file in block"
print line
sys.exit(0)
blocklist.append(line)
INSBLK = lexer.openblock(line)
while(INSBLK):
INSBLK = lexer.closeblock(line)
if INSBLK:
#print "inside c block", line
line = infile.readline() # Skipping the content
if not line: INSBLK = FALSE
else:
blocklist.append(line)
# Making a list of local variables into the "locals" list
processlocals(blocklist)
# Now performing replacements
newblock = processblock(blocklist, classname)
for line in newblock:
addit(line)
continue # Continue in main loop
# An external declaration should be ignored
# since all vars now have declaration in headers
# this works if the declaration is a single line
elif lexer.isextern(line): continue
# An array declaration
# - static: remain global, static removed
# - with initializer: become static attribute definition
# - without initializer: declared in class, removed here
elif lexer.isarray(line):
# print "is array", line
# One line declaration, save it and continue
i = string.find(line, ';')
if i != -1:
# one line global array with initializer or not
if lexer.isstatic(line):
line = lexer.removestatic(line)
addit(line)
continue
# attribute with initalizer, transformed
j = string.find(line, '=');
if j != -1:
ahead = line[:j] + ";"
line = setmember(line)
addit(line)
staticlist.append(ahead[:i+1])
# other attribute, removed from source file
# but added to list of attributes
else:
ahead = line
varlist.append(ahead[:i + 1])
#print "one line", line[:i + 1]
continue
# Multiline array with assignment
fulldecl = line + "\n"
initflag = FALSE
globalflag = lexer.isstatic(line)
j = string.find(line, "=")
if j != -1:
ahead = line[:j] + ";"
initflag = TRUE
else:
ahead = line
ARRAY = lexer.openarray(line)
#print "open?", ARRAY
while ARRAY == FALSE:
line = infile.readline()
#line = lexer.removecomment(line)
if wstring.clean(line) != "":
fulldecl = fulldecl + line
ARRAY = lexer.openarray(line)
ARRAY = lexer.closearray(line)
while(ARRAY):
line = infile.readline()
#line = lexer.removecomment(line)
fulldecl = fulldecl + line
ARRAY = lexer.closearray(line)
varlist.append(ahead)
if globalflag == TRUE: # a global array
fulldecl = lexer.removestatic(fulldecl)
addit(fulldecl)
continue
if initflag == TRUE:
fulldecl = setmember(fulldecl)
addit(fulldecl)
staticlist.append(ahead)
continue
# A variable definition
else:
if lexer.isvardef(line):
#print "var in source", line
globalflag = lexer.isstatic(line)
if globalflag:
line = lexer.removestatic(line)
nlist = []
if lexer.multivar(line):
nlist = lexer.splitvardef(line)
else:
nlist.append(line)
for n in nlist:
j = string.find(n, '=')
if j != -1:
ahead = n[:j] + ";"
if not globalflag:
n = setmember(n)
addit(n)
staticlist.append(ahead)
else:
if globalflag: addit(n)
ahead = n
varlist.append(ahead)
#print "append var", n
#print line
continue
# Save a compound block not previously handled
if not INSBLK: INSBLK = lexer.openblock(line)
if INSBLK:
INSBLK = lexer.closeblock(line)
#print "open block >", line
addit(line)
while INSBLK:
line = infile.readline() # Skipping the content
if not line: break
#print "block >", line
addit(line)
INSBLK = lexer.closeblock(line)
continue
# other statement
#print "other", line
addit(line)
# end main while
addit("")
# add the instance of the class
addit(instance + " " + instance + "Obj;\n")
infile.close()
# Processing the header file
# It is rebuilt
# Reading the file and removing end of file code if exists
header = []
if os.path.exists(hppname):
hfile = open(hppname, "rb")
header = hfile.readlines()
hfile.close
# Removing EOF 0x1a ctrl-z is presents
if len(header) != 0:
l = header[-1]
l = wstring.strip(l)
if l < ' ':
header = header[:-1]
hpp = [] # To rebuild the file
defheader = {} # Define declarations inside header file
rcount = 0 # Replacements
COMMENT = FALSE # This flag is true while inside a comment block
INSMAC = FALSE # This one inside a macro
INSTYP = FALSE # This one inside a typedef or struct
# Now the header file is rebuilt
for o in header: # Scanning the header file
line = wstring.chop(o) # Remove annoying line separators
if wstring.strip(line) == "": # Empty line, keep it
hpp.append(line)
continue
# If we enter a comment block, append it and process other code
if not COMMENT:
if not lexer.embeddedcomment(line):
COMMENT = lexer.opencomment(line)
else:
test = lexer.removecomment(line)
if wstring.strip(test) == "": # Simple one-line comment
hpp.append(line)
continue
# Inside comment, this is a multi-line comment
if COMMENT: # Comment opened
#print "inside comment", line
COMMENT = lexer.closecomment(line) # Always inside comment?
# End of multi-line comment
if not COMMENT: # Terminator reached
i = string.find(line, "*/")
if i == -1:
print "Error in parsing header"
sys.exit(0)
hpp.append(line[:i+2])
line = line[i + 2:] # Keeping the code is exists
# Start of multi-line comment
if COMMENT:
i = string.find(line, "/*")
if i != -1:
hpp.append(line[i:])
line = line[:i]
else:
hpp.append(line) # A line of the comment block
continue
line = wstring.strip(line)
if line == "": continue
# If we are inside a macro or pragma block, skip it
if not INSMAC: INSMAC = lexer.opendef(line)
if INSMAC:
#print "inside macro", line
INSMAC = lexer.closedef(line)
hpp.append(line)
continue
# If we are inside struct or typedef, skip it
if not INSTYP: INSTYP = lexer.openrecord(line)
if INSTYP:
INSTYP = lexer.closerecord(line)
hpp.append(line)
continue
# Define statement are memorized
if line[0:7] == "#define":
key, value = lexer.splitdefine(line)
#print "in header", line, key, value
if key != None: defheader[key] = value # Add to dictionary
# get the class name from the header
if string.find(line, "class") != -1:
classname = lexer.getclassname(line)
if lexer.isprototype(line):
if lexer.isglobal(line):
line = lexer.removeglobal(line)
hpp.append(line)
continue
if lexer.isvardecl(line):
# print "var in header", line
if not lexer.isextern(line):
for n in staticlist[:]:
#print "var in source", n
if lexer.samevar(line, n): # Same name
line = lexer.addstatic(line)
staticlist.remove(n)
break # exit for loop
# In all case, adding the line, either changed or not
hpp.append(line)
# Adding one instance of this class
# it must to be defined in the cpp source also
# as: classname classnameObj;
obj = classname + "Obj"
hpp.append("extern " + classname + " " + obj + ';')
# Rewriting the updated header file
hfile = open(hppname, "wb")
for o in hpp:
hfile.write(o + "\n")
hfile.close()
# For each include directive
# I get header path, and with it the class name
# and I test if the class is in the list of classes used by this source
# if not, I add the missing header in which this class is declared
for hname in included: # get the path from an include directive
if allheaders.has_key(hname): # if this path in allheaders?
clname = allheaders[hname] # get the class name the header contains
else:
dummy, fname = os.path.split(hname) # get the filename
if withoutpath.has_key(fname): # perhaps path missing in directive?
clname = withoutpath[fname] # get the class from the second list
else:
print "*", fname, "not in list of headers"
continue
if clname in omitted: # is class in the list of used classes?
omitted.remove(clname) # class already included, remove it
#print "already included", clname
continue
# now adding all omitted include statements
for cname in omitted: # get a class name
if allclasses.has_key(cname): # is it in the dict
hname = allclasses[cname] # get the header filename
s = "#include \"" + hname + "\"" # build an include statement
cpp.insert(lastinclude + 1, s) # insert it in last position
print "added ", s
# Creating the C++ code file
node, ext = os.path.splitext(cfile)
cppname = node + ".cpp"
cppfile = open(cppname, "wb")
for o in cpp:
cppfile.write(o + "\n")
cppfile.close()
dummy, cppname = os.path.split(cppname)
#dummy, hppname = os.path.split(hppname)
print cppname, "created,", "and", hppname, "updated"
print ""
return