atria-tools/lutin
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] Parser c++ start to be interesting

Browse Source
This commit is contained in:
Edouard DUPIN 2013-12-19 21:54:12 +01:00
parent 397f9eb124
commit 61610b3a13
12 changed files with 319 additions and 2479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
cppParser/Class.py
View File

@ -14,10 +14,13 @@ def concatenate_template(list):
class Class(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
# check input :
if len(stack) < 2:
debug.error("Can not parse class : " + str(stack))
return
Node.Node.__init__(self, 'class', stack[1], file, lineNumber)
self.subList = []
self.access = "private"
# heritage list :
self.inherit = []
if len(stack) == 2:
@ -30,7 +33,7 @@ class Class(Node.Node):
debug.error("error in parsing class : " + str(stack) + " missing ':' at the 3rd position ...")
list = concatenate_template(stack[3:])
debug.info("inherit : " + str(list))
debug.verbose("inherit : " + str(list))
access = "private"
for element in list:
if element in ['private', 'protected', 'public']:
@ -40,7 +43,7 @@ class Class(Node.Node):
else:
self.inherit.append({'access' : access, 'class' : element})
debug.info("class : " + self.to_str())
debug.verbose("class : " + self.to_str())
def to_str(self) :
ret = "class " + self.name

33
cppParser/Enum.py
View File

@ -4,12 +4,39 @@ import Node
class Enum(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
name = ""
Node.Node.__init__(self, 'enum', name, file, lineNumber)
# CPP section:
self.baseValue = 0;
# check input :
if len(stack) < 2:
debug.error("Can not parse class : " + str(stack))
return
self.typedef = False
if stack[0] == 'typedef':
self.typedef = True
stack[1:]
Node.Node.__init__(self, 'enum', stack[1], file, lineNumber)
self.listElement = []
def to_str(self) :
return "enum " + self.name + " { ... };"
def enum_append(self, stack):
subList = []
tmp = []
for element in stack:
if element == ',':
subList.append(tmp)
tmp = []
else:
tmp.append(element)
if len(tmp) != 0:
subList.append(tmp)
debug.verbose(" TODO : Need to append enum : " + str(subList))
# TODO : Set the value at the enum ...
for element in subList:
self.listElement.append(element[0])
debug.info("enum list : " + str(self.listElement))

79
cppParser/Methode.py
View File

@ -2,20 +2,83 @@
import lutinDebug as debug
import Node
import Type
import Variable
class Methode(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
name = ""
Node.Node.__init__(self, 'methode', name, file, lineNumber)
self.name = ""
self.returnType = Type.TypeVoid()
self.virtual = False # only for C++
type = 'methode'
self.virtual = False
self.virtualPure = False
self.static = False
self.inline = False
self.const = False # the end of line cont methode is sont for the class ...
self.doc = None
self.variable = None
self.visibility = "private" # only for C++ : "public" "protected" "private"
# remove constructer inside declaration ...
if ':' in stack:
res = []
for element in stack:
if element != ':':
res.append(element)
else:
break
stack = res
if stack[len(stack)-2] == '=' \
and stack[len(stack)-1] == '0':
stack = stack[:len(stack)-2]
self.virtualPure = True
if stack[0] == 'virtual':
self.virtual = True
stack = stack[1:]
if stack[0] == 'static':
self.static = True
stack = stack[1:]
if stack[0] == 'inline':
self.inline = True
stack = stack[1:]
if stack[len(stack)-1] == 'const':
self.const = True
stack = stack[:len(stack)-1]
namePos = -1
debug.verbose("methode parse : " + str(stack))
for iii in range(0, len(stack)-2):
if stack[iii+1] == '(':
name = stack[iii]
namePos = iii
break;
if namePos == 0:
debug.verbose("start with '" + str(name[0]) + "'")
if name[0] == '~':
type = 'destructor'
else:
type = 'constructor'
debug.verbose("methode name : " + name)
Node.Node.__init__(self, type, name, file, lineNumber)
self.returnType = Type.TypeNone()
self.variable = []
# create the return Type (Can be Empty)
retTypeStack = stack[:namePos]
debug.verbose("return : " + str(retTypeStack))
self.returnType = Type.Type(retTypeStack)
parameterStack = stack[namePos+2:len(stack)-1]
debug.verbose("parameter : " + str(parameterStack))
paramTmp = []
for element in parameterStack:
if element == ',':
self.variable.append(Variable.Variable(paramTmp))
paramTmp = []
else:
paramTmp.append(element)
if len(paramTmp) != 0:
self.variable.append(Variable.Variable(paramTmp))
def to_str(self):
ret = ""
@ -31,6 +94,8 @@ class Methode(Node.Node):
ret += "("
# ...
ret += ")"
if self.virtualPure == True:
ret += " = 0"
if self.const == True:
ret += " const"
return ret

4
cppParser/Namespace.py
View File

@ -7,8 +7,10 @@ class Namespace(Node.Node):
if len(stack) != 2:
debug.error("Can not parse namespace : " + str(stack))
Node.Node.__init__(self, 'namespace', stack[1], file, lineNumber)
# enable sub list
self.subList = []
debug.verbose("find class : " + self.to_str())
debug.verbose("find namespace : " + self.to_str())
def to_str(self) :
return "namespace " + self.name + " { ... };"

82
cppParser/Node.py
View File

@ -1,6 +1,14 @@
#!/usr/bin/python
import lutinDebug as debug
accessList = ['private', 'protected', 'public']
def debug_space(level):
ret = ""
for iii in range(0,level):
ret += " "
return ret
class Node():
def __init__(self, type, name="", file="", lineNumber=0):
self.nodeType = type
@ -8,13 +16,83 @@ class Node():
self.doc = None
self.fileName = file
self.lineNumber = lineNumber
self.subList = []
self.subList = None
self.access = None
def to_str(self):
return ""
def str(self):
return self.to_str()
def get_node_type(self):
return self.nodeType
def get_name(self):
return self.name
def debug_display(self, level=0, access = None):
if access == 'private':
debug.info(debug_space(level) + "- " + self.nodeType + " => " + self.name)
elif access == 'protected':
debug.info(debug_space(level) + "# " + self.nodeType + " => " + self.name)
elif access == 'public':
debug.info(debug_space(level) + "+ " + self.nodeType + " => " + self.name)
else:
debug.info(debug_space(level) + self.nodeType + " => " + self.name)
if self.subList!= None:
for element in self.subList:
if 'access' in element.keys():
element['node'].debug_display(level+1, element['access'])
else:
element['node'].debug_display(level+1)
def set_access(self, access):
if access not in accessList:
debug.warning("This is not a valid access : '" + access + "' : availlable : " + str(accessList))
return
if self.access == None:
debug.error("This Node does not support acces configuration...")
return
self.access = access
def get_access(self):
return self.access
def append(self, newSubElement):
# just add it in a sub List :
self.subList.append(newSubElement)
if self.subList == None:
debug.error("can not add a '" + newSubElement.nodeType + "' at this '" + self.nodeType + "'")
return
if newSubElement.get_node_type() != 'namespace':
if self.access == None:
self.subList.append({'node' : newSubElement})
else:
self.subList.append({'access' : self.access, 'node' : newSubElement})
return
# check if the element already exist
for element in self.subList:
if element['node'].get_node_type() == 'namespace':
if element['node'].get_name() == newSubElement.get_name():
debug.verbose("fusionate with previous declaration")
element['node'].fusion(newSubElement)
return
# normal case adding :
if self.access == None:
self.subList.append({'node' : newSubElement})
else:
self.subList.append({'access' : self.access, 'node' : newSubElement})
## @ brief only for namespace :
def fusion(self, addedElement):
for element in addedElement.subList:
self.append(element['node'])
class MainNode(Node):
def __init__(self, type="library", name=""):
Node.__init__(self, type, name)
self.subList = []

121
cppParser/Parse.py
View File

@ -15,6 +15,7 @@ import Union
import Methode
import Enum
import Variable
import Node
tokens = [
'NUMBER',
@ -114,11 +115,6 @@ lex.lex()
doxygenCommentCache = ""
supportedAccessSpecifier = [
'public',
'protected',
'private'
]
##
## @brief Join the class name element : ['class', 'Bar', ':', ':', 'Foo'] -> ['class', 'Bar::Foo']
@ -168,10 +164,14 @@ class parse_file():
ret += " "
return ret
def fusion(self, baseNode):
baseNode.fusion(self.mainNode)
return baseNode
def __init__(self, fileName):
self.m_classes = []
self.mainNode = Node.MainNode("main-node", "tmp")
self.m_elementParseStack = []
debug.info("Parse File tod document : '" + fileName + "'")
debug.debug("Parse file : '" + fileName + "'")
self.headerFileName = fileName
@ -179,11 +179,6 @@ class parse_file():
# load all the file data :
headerFileStr = lutinTools.FileReadData(fileName)
# Make sure supportedAccessSpecifier are sane
for i in range(0, len(supportedAccessSpecifier)):
if " " not in supportedAccessSpecifier[i]: continue
supportedAccessSpecifier[i] = re.sub("[ ]+", " ", supportedAccessSpecifier[i]).strip()
# Strip out template declarations
# TODO : What is the real need ???
headerFileStr = re.sub("template[\t ]*<[^>]*>", "", headerFileStr)
@ -193,8 +188,12 @@ class parse_file():
headerFileStr = re.sub("\r", "", headerFileStr)
# TODO : Can generate some error ...
headerFileStr = re.sub("\#if 0(.*?)(\#endif|\#else)", "", headerFileStr, flags=re.DOTALL)
headerFileafter = re.sub("\@interface(.*?)\@end", "", headerFileStr, flags=re.DOTALL)
if headerFileStr != headerFileafter :
debug.debug(" Objective C interface ... ==> not supported")
return
debug.debug(headerFileStr)
debug.verbose(headerFileStr)
# Change multi line #defines and expressions to single lines maintaining line nubmers
matches = re.findall(r'(?m)^(?:.*\\\n)+.*$', headerFileStr)
@ -278,7 +277,7 @@ class parse_file():
elif tok.type == 'CLOSE_BRACE':
if len(self.nameStack) != 0:
if self.previous_is('enum') == True:
debug.info(self.gen_debug_space() + "enum list... : " + str(self.nameStack));
self.brace_type_append('enum list', self.nameStack);
else:
debug.warning(self.gen_debug_space() + "end brace DROP : " + str(self.nameStack));
self.stack = []
@ -325,7 +324,7 @@ class parse_file():
or tok.type == 'CHAR_LITERAL':
self.nameStack.append(tok.value)
elif tok.type == 'COLON':
if self.nameStack[0] in ['private', 'protected', 'public']:
if self.nameStack[0] in Node.accessList:
debug.debug(self.gen_debug_space() + "change visibility : " + self.nameStack[0]);
self.brace_type_change_access(self.nameStack[0])
self.nameStack = []
@ -336,7 +335,7 @@ class parse_file():
if len(self.nameStack) != 0:
self.nameStack = create_compleate_class_name(self.nameStack)
if is_a_function(self.nameStack):
debug.info(self.gen_debug_space() + "function : " + str(self.nameStack));
self.brace_type_append('function', self.nameStack);
elif 'namespace' in self.nameStack:
debug.debug(self.gen_debug_space() + "find a namespace DECLARATION : " + str(self.nameStack));
elif 'class' in self.nameStack:
@ -351,17 +350,23 @@ class parse_file():
debug.debug(self.gen_debug_space() + "find a union DECLARATION : " + str(self.nameStack));
else:
if self.previous_is('enum') == True:
debug.info(self.gen_debug_space() + "enum list : " + str(self.nameStack));
self.brace_type_append('enum list', self.nameStack);
else:
# TODO : Check if it is true in all case :
self.brace_type_append('variable', self.nameStack);
#debug.warning(self.gen_debug_space() + "semicolumn : " + str(self.nameStack));
self.stack = []
self.nameStack = []
#self.debug_display();
def debug_display(self):
debug.info("Debug display :")
self.mainNode.debug_display(1)
def create_element(self, type, stack):
ret = None
if type == 'empty':
if type == 'empty' \
or type == 'enum list':
pass
elif type == 'namespace':
ret = Namespace.Namespace(stack, self.headerFileName, self.curLine)
@ -386,46 +391,75 @@ class parse_file():
return ret
def brace_type_push(self, type, stack):
debug.info(self.gen_debug_space() + "find a <<" + type + ">> : " + str(stack));
debug.debug(self.gen_debug_space() + "find a <<" + type + ">> : " + str(stack));
myClassElement = self.create_element(type, stack)
element = { 'type' : type,
'stack' : stack,
'access' : None,
'node' : myClassElement
}
if type == 'class':
element['access'] = "private"
elif type == 'struct':
element['access'] = "public"
self.braceDepthType.append(element)
#debug.info ("append : " + str(element))
def brace_type_append_current(self, element, id = -50):
if id == -50:
id = len(self.braceDepthType)-1
if id >= 0:
while self.braceDepthType[id]['node'] == None:
# special case for empty brace, just add it to the upper
id -=1
if id < 0:
break;
if id < 0:
self.mainNode.append(element)
else:
self.braceDepthType[id]['node'].append(element)
def brace_type_append(self, type, stack):
debug.info(self.gen_debug_space() + " append a <<" + type + ">> : " + str(stack));
debug.debug(self.gen_debug_space() + " append a <<" + type + ">> : " + str(stack));
lastType = self.get_last_type()
newType = self.create_element(type, stack)
if newType == None:
if newType != None:
self.brace_type_append_current(newType)
return
# enum sub list:
if lastType == 'enum' \
and type == 'enum list':
id = len(self.braceDepthType)-1
self.braceDepthType[id]['node'].enum_append(stack)
return
debug.info("TODO : Parse the special type")
return
if len(self.braceDepthType) == 0:
debug.info("TODO : Append in glocal directly ...")
return
self.braceDepthType[len(self.braceDepthType)-1]['node'].append(newType)
def brace_type_pop(self):
id = len(self.braceDepthType)-1
if id < 0:
debug.warning("Try to pop the stack with No more element ...")
return
if self.braceDepthType[id]['node'] == None:
# nothing to add at the upper ...
pass
else:
# add it on the previous
self.brace_type_append_current(self.braceDepthType[id]['node'], id-1)
self.braceDepthType.pop()
def brace_type_change_access(self, newOne):
if len(self.braceDepthType) == 0:
debug.error("set access in nothing ... ")
return
if newOne not in supportedAccessSpecifier:
if newOne not in Node.accessList:
debug.error("unknow access type : " + newOne)
return
if self.braceDepthType[len(self.braceDepthType)-1]['access'] == None:
debug.error("Can not set access in other as : 'class' or 'struct' :" + str(self.braceDepthType[len(self.braceDepthType)-1]))
id = len(self.braceDepthType)-1
if id >= 0:
while self.braceDepthType[id]['node'] == None:
# special case for empty brace, just add it to the upper
id -=1
if id < 0:
break;
if id < 0:
debug.warning("can not change the main access on the library")
else:
if self.braceDepthType[id]['node'].get_access() == None:
debug.error("Can not set access in other as : 'class' or 'struct' :" + str(self.braceDepthType[id]))
return
self.braceDepthType[len(self.braceDepthType)-1]['access'] = newOne
self.braceDepthType[id]['node'].set_access(newOne)
def previous_is(self, type):
if self.get_last_type() == type:
@ -441,6 +475,17 @@ def is_a_function(stack) :
# in a function we need to have functionName + ( + )
if len(stack) < 3:
return False
if ':' in stack:
res = []
for element in stack:
if element != ':':
res.append(element)
else:
break
stack = res
if stack[len(stack)-2] == '=' \
and stack[len(stack)-1] == '0':
stack = stack[:len(stack)-2]
#can end with 2 possibilities : ')', 'const' or ')'
if stack[len(stack)-1] == ')' \
or ( stack[len(stack)-2] == ')' \

0
cppParser/Resolver.py
View File

11
cppParser/Struct.py
View File

@ -6,15 +6,8 @@ class Struct(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
name = ""
Node.Node.__init__(self, 'struct', name, file, lineNumber)
# CPP section:
self.namespaces = []
self.classes = []
# C section:
self.structs = []
self.variables = []
self.methodes = []
self.unions = []
self.types = []
self.access = "public"
def to_str(self) :
return "struct " + self.name + " { ... };"

10
cppParser/Type.py
View File

@ -5,12 +5,14 @@ import Node
class Type():
def __init__(self, stack=[]):
if len(stack) == 0:
debug.error("Can not parse Type : " + str(stack))
self.name = ""
self.const = False # the const xxxxx
self.reference = False
self.constVar = False # the char* const VarName
if len(stack) == 0:
# None type
return
if len(stack) == 1:
self.name = stack[0]
return;
@ -46,3 +48,7 @@ class TypeVoid(Type):
def __init__(self):
Type.__init__(self, ['void'])
class TypeNone(Type):
def __init__(self):
Type.__init__(self)

19
cppParser/Variable.py
View File

@ -5,8 +5,24 @@ import Node
class Variable(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
name = ""
# TODO : better manageement for xxx[**][**] element:
res = []
for element in stack:
if element == '[':
break
else:
res.append(element)
stack = res
if len(stack) < 2:
if stack[0] == 'void':
pass
else:
debug.error("Can not parse variable : " + str(stack))
else:
name = stack[len(stack)-1]
Node.Node.__init__(self, 'variable', stack[len(stack)-1], file, lineNumber)
# force the sublist error generation ...
self.subList = None
@ -15,6 +31,9 @@ class Variable(Node.Node):
self.static = False
self.external = False
self.volatile = False
#empty name ... ==> this is really bad ...
if name == "":
return
if 'static' in stack:
self.static = True

2411
cppParser/parserCpp.py
View File

File diff suppressed because it is too large Load Diff

13
lutinDoc.py
View File

@ -8,6 +8,7 @@ sys.path.append(lutinTools.GetCurrentPath(__file__) + "/cppParser/")
sys.path.append(lutinTools.GetCurrentPath(__file__) + "/codeBB/")
sys.path.append(lutinTools.GetCurrentPath(__file__) + "/codeHL/")
import Parse
import Node
import lutinDocHtml
import lutinDocMd
import os
@ -21,6 +22,7 @@ class doc:
def __init__(self, moduleName):
self.moduleName = moduleName
self.listDocFile = []
self.structureLib = Node.MainNode("library", moduleName)
self.listTutorialFile = []
self.listClass = dict()
self.listEnum = dict()
@ -90,6 +92,8 @@ class doc:
fileCompleteName = os.path.join(root, filename)
debug.debug(" Find a file : '" + fileCompleteName + "'")
self.add_file(fileCompleteName)
self.structureLib.debug_display()
debug.error("ended")
if self.pathGlobalDoc != "":
for root, dirnames, filenames in os.walk(self.pathGlobalDoc):
tmpList = fnmatch.filter(filenames, "*.bb")
@ -131,6 +135,15 @@ class doc:
##
def add_file(self, filename):
debug.debug("adding file in documantation : '" + filename + "'");
#plop = Parse.parse_file('ewol/sources/ewol/context/MacOs/OpenglView.h')
#debug.error("parse done");
parsedFile = Parse.parse_file(filename)
self.structureLib = parsedFile.fusion(self.structureLib)
def deprecate(self):
plop = Parse.parse_file('Widget.h')
debug.error("parse done");