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

[DEV] start parse of all sub elements

Browse Source
This commit is contained in:
Edouard DUPIN 2013-12-19 01:07:30 +01:00
parent c572dc8c15
commit 825875dd12
15 changed files with 403 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
cppParser/Class.py
View File

@ -1,38 +1,59 @@
#!/usr/bin/python #!/usr/bin/python
try :
# normal install module
import ply.lex as lex
except ImportError :
# local module
import lex
import os
import sys
import re
import Node
import lutinDebug as debug import lutinDebug as debug
import Node
import inspect
##
## @brief transform template descrption in one element.
## @param[in] list of elements. ex : 'public', 'ewol::classee', '<', 'plop', '<', 'uint8_t', ',', 'int32_t', '>', '>'
## @return a simplify list. ex : 'public', 'ewol::classee<plop<uint8_t,int32_t>>'
##
def concatenate_template(list):
# TODO ...
return list
class Class(Node.Node): class Class(Node.Node):
def __init__(self): def __init__(self, stack=[], file="", lineNumber=0):
if len(stack) < 2:
debug.error("Can not parse class : " + str(stack))
return
Node.Node.__init__(self, 'class', stack[1], file, lineNumber)
# heritage list :
self.inherit = []
if len(stack) == 2:
# just a simple class...
return
if len(stack) == 3:
debug.error("error in parsing class : " + str(stack))
return
if stack[2] != ':':
debug.error("error in parsing class : " + str(stack) + " missing ':' at the 3rd position ...")
# List of the class name (with their namespace : [['ewol','widget','plop'], ...]) list = concatenate_template(stack[3:])
self.parents = [] debug.info("inherit : " + str(list))
access = "private"
# CPP section: for element in list:
self.namespaces = [] if element in ['private', 'protected', 'public']:
self.classes = [] access = element
# C section: elif element == ',':
self.structs = [] pass
self.variables = [] else:
self.methodes = [] self.inherit.append({'access' : access, 'class' : element})
self.unions = []
self.types = []
debug.info("class : " + self.to_str())
def to_str(self) :
def to_str(self): ret = "class " + self.name
return "" if len(self.inherit) != 0 :
ret += " : "
isFirst = True
for element in self.inherit:
if isFirst == False:
ret += ", "
isFirst = False
ret += element['access'] + " " + element['class']
ret += " { ... };"
return ret

31
cppParser/Enum.py
View File

@ -1,24 +1,15 @@
#!/usr/bin/python #!/usr/bin/python
try : import lutinDebug as debug
# normal install module
import ply.lex as lex
except ImportError :
# local module
import lex
import os
import sys
import re
import Node import Node
import inspect class Enum(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
name = ""
class Enum(Node): Node.Node.__init__(self, 'enum', name, file, lineNumber)
def __init__(self): # CPP section:
self.name = libName self.listElement = []
#List is contituated of 3 element : {'name':"plop", 'value':5, 'doc'=""}, ...]
self.list = []
def to_str(self) :
return "enum " + self.name + " { ... };"

25
cppParser/Methode.py
View File

@ -1,23 +1,18 @@
#!/usr/bin/python ##!/usr/bin/python
try : import lutinDebug as debug
# normal install module import Node
import ply.lex as lex import Type
except ImportError :
# local module
import lex
import os
import sys
import re
class Methode(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
class Methode(): name = ""
def __init__(self): Node.Node.__init__(self, 'methode', name, file, lineNumber)
self.name = "" self.name = ""
self.returnType = Type.TypeVoid() self.returnType = Type.TypeVoid()
self.virtual = False # only for C++ self.virtual = False # only for C++
self.static = False self.static = False
self.inline = False self.inline = False
self.const = False # the end of line cont methode is sont for the class ...
self.doc = None self.doc = None
self.variable = None self.variable = None
self.visibility = "private" # only for C++ : "public" "protected" "private" self.visibility = "private" # only for C++ : "public" "protected" "private"
@ -36,5 +31,7 @@ class Methode():
ret += "(" ret += "("
# ... # ...
ret += ")" ret += ")"
if self.const == True:
ret += " const"
return ret return ret

35
cppParser/Namespace.py
View File

@ -1,29 +1,16 @@
#!/usr/bin/python #!/usr/bin/python
try : import lutinDebug as debug
# normal install module import Node
import ply.lex as lex
except ImportError :
# local module
import lex
import os
import sys
import re
import inspect class Namespace(Node.Node):
def __init__(self, stack=[], file="", lineNumber=0):
class Namespace(): if len(stack) != 2:
def __init__(self): debug.error("Can not parse namespace : " + str(stack))
self.name = "" Node.Node.__init__(self, 'namespace', stack[1], file, lineNumber)
# CPP section:
self.namespaces = [] debug.verbose("find class : " + self.to_str())
self.classes = []
# C section:
self.structs = []
self.variables = []
self.methodes = []
self.unions = []
self.types = []
def to_str(self) : def to_str(self) :
return "" return "namespace " + self.name + " { ... };"

26
cppParser/Node.py
View File

@ -1,22 +1,20 @@
#!/usr/bin/python #!/usr/bin/python
try : import lutinDebug as debug
# normal install module
import ply.lex as lex
except ImportError :
# local module
import lex
import os
import sys
import re
class Node(): class Node():
def __init__(self): def __init__(self, type, name="", file="", lineNumber=0):
self.name = "" self.nodeType = type
self.name = name
self.doc = None self.doc = None
self.fileName = "" self.fileName = file
self.lineNumber = "" self.lineNumber = lineNumber
self.subList = []
def to_str(): def to_str(self):
return "" return ""
def append(self, newSubElement):
# just add it in a sub List :
self.subList.append(newSubElement)

412
cppParser/Parse.py
View File

@ -3,12 +3,18 @@ import os
import sys import sys
import re import re
import ply.lex as lex import lex
import inspect import inspect
import lutinDebug as debug import lutinDebug as debug
import lutinTools import lutinTools
import Class import Class
import Namespace
import Struct
import Union
import Methode
import Enum
import Variable
tokens = [ tokens = [
'NUMBER', 'NUMBER',
@ -106,215 +112,62 @@ def t_error(v):
lex.lex() lex.lex()
class TagStr(str):
"""Wrapper for a string that allows us to store the line number associated with it"""
lineno_reg = {}
def __new__(cls,*args,**kw):
new_obj = str.__new__(cls,*args)
if "lineno" in kw:
TagStr.lineno_reg[id(new_obj)] = kw["lineno"]
return new_obj
def __del__(self):
try:
del TagStr.lineno_reg[id(self)]
except: pass
def lineno(self):
return TagStr.lineno_reg.get(id(self), -1)
doxygenCommentCache = "" doxygenCommentCache = ""
#Track what was added in what order and at what depth
parseHistory = []
def is_namespace(nameStack):
"""Determines if a namespace is being specified"""
if len(nameStack) == 0:
return False
if nameStack[0] == "namespace":
return True
return False
def is_enum_namestack(nameStack):
"""Determines if a namestack is an enum namestack"""
if len(nameStack) == 0:
return False
if nameStack[0] == "enum":
return True
if len(nameStack) > 1 \
and nameStack[0] == "typedef" \
and nameStack[1] == "enum":
return True
return False
def is_fundamental(s):
for a in s.split():
if a not in ["size_t", \
"struct", \
"union", \
"unsigned", \
"signed", \
"bool", \
"char", \
"short", \
"int", \
"float", \
"double", \
"long", \
"void", \
"*"]:
return False
return True
def is_function_pointer_stack(stack):
"""Count how many non-nested paranthesis are in the stack. Useful for determining if a stack is a function pointer"""
paren_depth = 0
paren_count = 0
star_after_first_paren = False
last_e = None
for e in stack:
if e == "(":
paren_depth += 1
elif e == ")" \
and paren_depth > 0:
paren_depth -= 1
if paren_depth == 0:
paren_count += 1
elif e == "*" \
and last_e == "(" \
and paren_count == 0 \
and paren_depth == 1:
star_after_first_paren = True
last_e = e
if star_after_first_paren and paren_count == 2:
return True
else:
return False
def is_method_namestack(stack):
r = False
if '(' not in stack:
r = False
elif stack[0] == 'typedef':
r = False # TODO deal with typedef function prototypes
#elif '=' in stack and stack.index('=') < stack.index('(') and stack[stack.index('=')-1] != 'operator': r = False #disabled July6th - allow all operators
elif 'operator' in stack:
r = True # allow all operators
elif '{' in stack \
and stack.index('{') < stack.index('('):
r = False # struct that looks like a method/class
elif '(' in stack \
and ')' in stack:
if '{' in stack \
and '}' in stack:
r = True
elif stack[-1] == ';':
if is_function_pointer_stack(stack):
r = False
else:
r = True
elif '{' in stack:
r = True # ideally we catch both braces... TODO
else:
r = False
#Test for case of property set to something with parens such as "static const int CONST_A = (1 << 7) - 1;"
if r \
and "(" in stack \
and "=" in stack \
and 'operator' not in stack:
if stack.index("=") < stack.index("("): r = False
return r
def is_property_namestack(nameStack):
r = False
if '(' not in nameStack \
and ')' not in nameStack:
r = True
elif "(" in nameStack \
and "=" in nameStack \
and nameStack.index("=") < nameStack.index("("):
r = True
#See if we are a function pointer
if not r \
and is_function_pointer_stack(nameStack):
r = True
return r
def detect_lineno(s):
"""Detect the line number for a given token string"""
try:
rtn = s.lineno()
if rtn != -1:
return rtn
except: pass
global curLine
return curLine
def filter_out_attribute_keyword(stack):
"""Strips __attribute__ and its parenthetical expression from the stack"""
if "__attribute__" not in stack:
return stack
try:
debug.debug("Stripping __attribute__ from %s"% stack)
attr_index = stack.index("__attribute__")
attr_end = attr_index + 1 #Assuming not followed by parenthetical expression which wont happen
#Find final paren
if stack[attr_index + 1] == '(':
paren_count = 1
for i in xrange(attr_index + 2, len(stack)):
elm = stack[i]
if elm == '(':
paren_count += 1
elif elm == ')':
paren_count -= 1
if paren_count == 0:
attr_end = i + 1
break
new_stack = stack[0:attr_index] + stack[attr_end:]
debug.debug("stripped stack is %s"% new_stack)
return new_stack
except:
return stack
supportedAccessSpecifier = [ supportedAccessSpecifier = [
'public', 'public',
'protected', 'protected',
'private' 'private'
] ]
## ##
## @brief Join the class name element : ['class', 'Bar', ':', ':', 'Foo'] -> ['class', 'Bar::Foo'] ## @brief Join the class name element : ['class', 'Bar', ':', ':', 'Foo'] -> ['class', 'Bar::Foo']
## @param table Input table to convert. ex: [':', '\t', 'class', 'Bar', ':', ':', 'Foo'] ## @param table Input table to convert. ex: [':', '\t', 'class', 'Bar', ':', ':', 'Foo']
## @return The new table. ex: ['class', 'Bar::Foo'] ## @return The new table. ex: ['class', 'Bar::Foo']
## ##
def create_compleate_class_name(table): def create_compleate_class_name(table):
compleateLine = "" if "::" not in "".join(table):
compleateLine = compleateLine.join(table); out = table
if "::" not in compleateLine: else:
return table # we need to convert it :
# we need to convert it : out = []
out = [] for name in table:
for name in table: if len(out) == 0:
if len(out) == 0: out.append(name)
out.append(name) elif name == ":" \
elif name == ":" \ and out[-1].endswith(":"):
and out[-1].endswith(":"): out[-1] += name
out[-1] += name elif out[-1].endswith("::"):
elif out[-1].endswith("::"): out[-2] += out[-1] + name
out[-2] += out[-1] + name del out[-1]
del out[-1] else:
else: out.append(name)
out.append(name) table = out
if 'operator' not in "".join(table):
out = table
else:
out = []
for name in table:
if len(out) == 0:
out.append(name)
elif name in ['<','>','='] \
and out[-1][:8] == 'operator' \
and len(out[-1])-8 < 2:
out[-1] += name
else:
out.append(name)
return out return out
class parse_file(): class parse_file():
def gen_debug_space(self):
ret = "[" + str(len(self.braceDepthType)+1) + "]"
for iii in range(0,len(self.braceDepthType)):
ret += " "
return ret
def __init__(self, fileName): def __init__(self, fileName):
self.m_classes = [] self.m_classes = []
self.m_elementParseStack = [] self.m_elementParseStack = []
@ -365,57 +218,73 @@ class parse_file():
self.stack = [] # token stack to find the namespace and the element name ... self.stack = [] # token stack to find the namespace and the element name ...
self.nameStack = [] # self.nameStack = [] #
self.braceDepth = 0 self.braceDepth = 0
self.braceDepthType = []
self.subModuleCountBrace = 0;
lex.lex() lex.lex()
lex.input(headerFileStr) lex.input(headerFileStr)
global curLine self.curLine = 0
global curChar self.curChar = 0
curLine = 0
curChar = 0
while True: while True:
tok = lex.token() tok = lex.token()
if not tok: if not tok:
break break
tok.value = TagStr(tok.value, lineno=tok.lineno)
debug.debug("TOK: " + str(tok)) debug.debug("TOK: " + str(tok))
self.stack.append( tok.value ) self.stack.append( tok.value )
curLine = tok.lineno self.curLine = tok.lineno
curChar = tok.lexpos self.curChar = tok.lexpos
# special case to remove internal function define in header:
if self.previous_is('function') == True:
if tok.type == 'OPEN_BRACE':
self.subModuleCountBrace += 1
elif tok.type == 'CLOSE_BRACE':
self.subModuleCountBrace -= 1
if self.subModuleCountBrace <= 0:
self.brace_type_pop()
continue
# normal case:
if (tok.type in ('PRECOMP_MACRO', 'PRECOMP_MACRO_CONT')): if (tok.type in ('PRECOMP_MACRO', 'PRECOMP_MACRO_CONT')):
debug.debug("PRECOMP: " + str(tok)) debug.debug("PRECOMP: " + str(tok))
self.stack = [] self.stack = []
self.nameStack = [] self.nameStack = []
# Do nothing for macro ==> many time not needed ... # Do nothing for macro ==> many time not needed ...
continue continue
if (tok.type == 'OPEN_BRACE'): if tok.type == 'OPEN_BRACE':
# When we open a brace, this is the time to parse the stack ... # When we open a brace, this is the time to parse the stack ...
# Clean the stack : (remove \t\r\n , and concatenate the 'xx', ':', ':', 'yy' in 'xx::yy', # Clean the stack : (remove \t\r\n , and concatenate the 'xx', ':', ':', 'yy' in 'xx::yy',
self.nameStack = create_compleate_class_name(self.nameStack) self.nameStack = create_compleate_class_name(self.nameStack)
if len(self.nameStack) <= 0: if len(self.nameStack) <= 0:
#open brace with no name ... #open brace with no name ...
debug.warning("[" + str(self.braceDepth) + "] find an empty stack ...") self.brace_type_push('empty', [])
elif is_a_function(self.nameStack):
# need to parse sub function internal description...
self.subModuleCountBrace = 1
self.brace_type_push('function', self.nameStack)
elif 'namespace' in self.nameStack: elif 'namespace' in self.nameStack:
debug.info("[" + str(self.braceDepth) + "] find a namespace : " + str(self.nameStack)); self.brace_type_push('namespace', self.nameStack)
elif 'class' in self.nameStack: elif 'class' in self.nameStack:
debug.info("[" + str(self.braceDepth) + "] find a class : " + str(self.nameStack)); self.brace_type_push('class', self.nameStack)
elif 'enum' in self.nameStack: elif 'enum' in self.nameStack:
debug.info("[" + str(self.braceDepth) + "] find a enum : " + str(self.nameStack)); self.brace_type_push('enum', self.nameStack)
elif 'struct' in self.nameStack: elif 'struct' in self.nameStack:
debug.info("[" + str(self.braceDepth) + "] find a struct : " + str(self.nameStack)); self.brace_type_push('struct', self.nameStack)
elif 'typedef' in self.nameStack: elif 'typedef' in self.nameStack:
debug.info("[" + str(self.braceDepth) + "] find a typedef : " + str(self.nameStack)); self.brace_type_push('typedef', self.nameStack)
elif 'union' in self.nameStack: elif 'union' in self.nameStack:
debug.info("[" + str(self.braceDepth) + "] find a union : " + str(self.nameStack)); self.brace_type_push('union', self.nameStack)
else: else:
debug.warning("[" + str(self.braceDepth) + "] find an unknow stack : " + str(self.nameStack)) self.brace_type_push('unknow', self.nameStack)
self.stack = [] self.stack = []
self.nameStack = [] self.nameStack = []
self.braceDepth += 1
elif tok.type == 'CLOSE_BRACE': elif tok.type == 'CLOSE_BRACE':
self.braceDepth -= 1 if len(self.nameStack) != 0:
debug.info("[" + str(self.braceDepth) + "] close brace"); if self.previous_is('enum') == True:
if len(self.m_elementParseStack) != 0 \ debug.info(self.gen_debug_space() + "enum list... : " + str(self.nameStack));
and self.m_elementParseStack[len(self.m_elementParseStack)-1]['level'] == self.braceDepth : else:
self.m_elementParseStack.pop() debug.warning(self.gen_debug_space() + "end brace DROP : " + str(self.nameStack));
self.stack = []
self.nameStack = []
self.brace_type_pop()
self.nameStack = create_compleate_class_name(self.nameStack)
if tok.type == 'OPEN_PAREN': if tok.type == 'OPEN_PAREN':
self.nameStack.append(tok.value) self.nameStack.append(tok.value)
elif tok.type == 'CLOSE_PAREN': elif tok.type == 'CLOSE_PAREN':
@ -457,13 +326,124 @@ class parse_file():
self.nameStack.append(tok.value) self.nameStack.append(tok.value)
elif tok.type == 'COLON': elif tok.type == 'COLON':
if self.nameStack[0] in ['private', 'protected', 'public']: if self.nameStack[0] in ['private', 'protected', 'public']:
debug.info("[" + str(self.braceDepth) + "] change visibility : " + self.nameStack[0]); debug.debug(self.gen_debug_space() + "change visibility : " + self.nameStack[0]);
self.brace_type_change_access(self.nameStack[0])
self.nameStack = [] self.nameStack = []
self.stack = [] self.stack = []
else : else :
self.nameStack.append(tok.value) self.nameStack.append(tok.value)
elif tok.type == 'SEMI_COLON': elif tok.type == 'SEMI_COLON':
if len(self.nameStack) != 0: if len(self.nameStack) != 0:
debug.info("[" + str(self.braceDepth) + "] semicolumn : " + str(self.nameStack)); self.nameStack = create_compleate_class_name(self.nameStack)
if is_a_function(self.nameStack):
debug.info(self.gen_debug_space() + "function : " + str(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:
debug.debug(self.gen_debug_space() + "find a class DECLARATION : " + str(self.nameStack));
elif 'enum' in self.nameStack:
debug.debug(self.gen_debug_space() + "find a enum DECLARATION : " + str(self.nameStack));
elif 'struct' in self.nameStack:
debug.debug(self.gen_debug_space() + "find a struct DECLARATION : " + str(self.nameStack));
elif 'typedef' in self.nameStack:
debug.info(self.gen_debug_space() + "find a typedef DECLARATION : " + str(self.nameStack));
elif 'union' in self.nameStack:
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));
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.stack = []
self.nameStack = [] self.nameStack = []
def create_element(self, type, stack):
ret = None
if type == 'empty':
pass
elif type == 'namespace':
ret = Namespace.Namespace(stack, self.headerFileName, self.curLine)
elif type == 'class':
ret = Class.Class(stack, self.headerFileName, self.curLine)
elif type == 'struct':
ret = Struct.Struct(stack, self.headerFileName, self.curLine)
elif type == 'typedef':
#ret = Namespace.Namespace(stack, self.headerFileName, self.curLine)
# TODO ...
pass
elif type == 'union':
ret = Union.Union(stack, self.headerFileName, self.curLine)
elif type == 'function':
ret = Methode.Methode(stack, self.headerFileName, self.curLine)
elif type == 'enum':
ret = Enum.Enum(stack, self.headerFileName, self.curLine)
elif type == 'variable':
ret = Variable.Variable(stack, self.headerFileName, self.curLine)
else:
debug.error("unknow type ...")
return ret
def brace_type_push(self, type, stack):
debug.info(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(self, type, stack):
debug.info(self.gen_debug_space() + " append a <<" + type + ">> : " + str(stack));
lastType = self.get_last_type()
newType = self.create_element(type, stack)
if newType == None:
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):
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:
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]))
return
self.braceDepthType[len(self.braceDepthType)-1]['access'] = newOne
def previous_is(self, type):
if self.get_last_type() == type:
return True
return False
def get_last_type(self):
if len(self.braceDepthType) > 0:
return self.braceDepthType[len(self.braceDepthType)-1]['type']
return None
def is_a_function(stack) :
# in a function we need to have functionName + ( + )
if len(stack) < 3:
return False
#can end with 2 possibilities : ')', 'const' or ')'
if stack[len(stack)-1] == ')' \
or ( stack[len(stack)-2] == ')' \
and stack[len(stack)-1] == 'const'):
return True
return False

38
cppParser/Struct.py
View File

@ -1,22 +1,22 @@
#!/usr/bin/python #!/usr/bin/python
try : import lutinDebug as debug
# normal install module import Node
import ply.lex as lex
except ImportError :
# local module
import lex
import os
import sys
import re
import inspect 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 = []
def to_str(self) :
return "struct " + self.name + " { ... };"
class CppStruct(dict):
Structs = []
def __init__(self, nameStack):
if len(nameStack) >= 2: self['type'] = nameStack[1]
else: self['type'] = None
self['fields'] = []
self.Structs.append( self )
global curLine
self["line_number"] = curLine

56
cppParser/Type.py
View File

@ -1,28 +1,48 @@
#!/usr/bin/python #!/usr/bin/python
try : import lutinDebug as debug
# normal install module import Type
import ply.lex as lex import Node
except ImportError :
# local module
import lex
import os
import sys
import re
import inspect
class Type(): class Type():
def __init__(self): def __init__(self, stack=[]):
if len(stack) == 0:
debug.error("Can not parse Type : " + str(stack))
self.name = "" self.name = ""
self.const = False # the const xxxxx self.const = False # the const xxxxx
self.constVar = False # the char* const VarName
self.static = False
self.inline = False
self.reference = False self.reference = False
self.constVar = False # the char* const VarName
if len(stack) == 1:
self.name = stack[0]
return;
# check end const
if stack[len(stack)-1] == 'const':
self.constVar = True
stack = stack[:len(stack)-1]
# check if element is a reference ...
if stack[len(stack)-1] == '&':
self.reference = True
stack = stack[:len(stack)-1]
# che k if it start with const ...
if stack[0] == 'const':
self.const = True
stack = stack[1:]
self.name = ""
for element in stack:
self.name += element
def to_str(self) :
ret = ""
if self.const == True:
ret += "const "
ret += self.name
if self.reference == True:
ret += " &"
if self.constVar == True:
ret += " const"
return ret
class TypeVoid(Type): class TypeVoid(Type):
def __init__(self): def __init__(self):
Type.__init__() Type.__init__(self, ['void'])
self.name = "void"

22
cppParser/Union.py
View File

@ -1,10 +1,14 @@
#!/usr/bin/python #!/usr/bin/python
try : import lutinDebug as debug
# normal install module import Node
import ply.lex as lex
except ImportError : class Union(Node.Node):
# local module def __init__(self, stack=[], file="", lineNumber=0):
import lex name = ""
import os Node.Node.__init__(self, 'union', name, file, lineNumber)
import sys self.list = []
import re
def to_str(self) :
return "union " + self.name + " { ... };"

52
cppParser/Variable.py
View File

@ -1,23 +1,45 @@
#!/usr/bin/python #!/usr/bin/python
try : import lutinDebug as debug
# normal install module import Type
import ply.lex as lex import Node
except ImportError :
# local module
import lex
import os
import sys
import re
class Variable(): class Variable(Node.Node):
def __init__(self): def __init__(self, stack=[], file="", lineNumber=0):
self.name = "" if len(stack) < 2:
debug.error("Can not parse variable : " + str(stack))
Node.Node.__init__(self, 'variable', stack[len(stack)-1], file, lineNumber)
# force the sublist error generation ...
self.subList = None
# default variable :
self.type = Type.TypeVoid() self.type = Type.TypeVoid()
self.const = False # the const xxxxx
self.constVar = False # the char* const VarName
self.static = False self.static = False
self.external = False self.external = False
self.volatile = False
if 'static' in stack:
self.static = True
stack = [value for value in stack if value != 'static']
if 'volatile' in stack:
self.volatile = True
stack = [value for value in stack if value != 'volatile']
if 'external' in stack:
self.external = True
stack = [value for value in stack if value != 'external']
self.type = Type.Type(stack[:len(stack)-1])
debug.verbose("find variable : " + self.to_str())
def to_str(self) : def to_str(self) :
return "" ret = ""
if self.external == True:
ret += "external "
if self.volatile == True:
ret += "volatile "
if self.static == True:
ret += "static "
ret += self.type.to_str()
ret += " "
ret += self.name
return ret

4
lutinDoc.py
View File

@ -4,11 +4,9 @@ import sys
import lutinTools import lutinTools
# TODO : Add try of generic input ... # TODO : Add try of generic input ...
sys.path.append(lutinTools.GetCurrentPath(__file__) + "/ply/ply/") sys.path.append(lutinTools.GetCurrentPath(__file__) + "/ply/ply/")
sys.path.append(lutinTools.GetCurrentPath(__file__) + "/cppParser/CppHeaderParser/")
sys.path.append(lutinTools.GetCurrentPath(__file__) + "/cppParser/") sys.path.append(lutinTools.GetCurrentPath(__file__) + "/cppParser/")
sys.path.append(lutinTools.GetCurrentPath(__file__) + "/codeBB/") sys.path.append(lutinTools.GetCurrentPath(__file__) + "/codeBB/")
sys.path.append(lutinTools.GetCurrentPath(__file__) + "/codeHL/") sys.path.append(lutinTools.GetCurrentPath(__file__) + "/codeHL/")
import CppHeaderParser
import Parse import Parse
import lutinDocHtml import lutinDocHtml
import lutinDocMd import lutinDocMd
@ -133,7 +131,7 @@ class doc:
## ##
def add_file(self, filename): def add_file(self, filename):
debug.debug("adding file in documantation : '" + filename + "'"); debug.debug("adding file in documantation : '" + filename + "'");
plop = Parse.parse_file('/home/edupin/dev/perso/Widget.h') plop = Parse.parse_file('Widget.h')
debug.error("parse done"); debug.error("parse done");
try: try:

2
lutinDocHtml.py
View File

@ -2,7 +2,7 @@
import lutinDebug as debug import lutinDebug as debug
import sys import sys
import lutinTools import lutinTools
import CppHeaderParser #import CppHeaderParser
import re import re
import codeBB import codeBB
import collections import collections

2
lutinDocMd.py
View File

@ -2,7 +2,7 @@
import lutinDebug as debug import lutinDebug as debug
import sys import sys
import lutinTools import lutinTools
import CppHeaderParser #import CppHeaderParser
def parse_doxygen(data) : def parse_doxygen(data) :
pos = data.find("/*"); pos = data.find("/*");

2
lutinTarget.py
View File

@ -38,7 +38,7 @@ class Target:
self.global_flags_xx=['-std=c++11'] self.global_flags_xx=['-std=c++11']
self.global_flags_mm=['-std=c++11'] self.global_flags_mm=['-std=c++11']
else: else:
self.global_flags_xx=['-std=c++0X'] self.global_flags_xx=['-static-libgcc', '-static-libstdc++', '-L', '-std=c++11']
self.global_flags_mm=[] self.global_flags_mm=[]
self.global_flags_m=[] self.global_flags_m=[]
self.global_flags_ar=['rcs'] self.global_flags_ar=['rcs']

4
lutinTargetWindows.py
View File

@ -17,7 +17,9 @@ class Target(lutinTarget.Target):
sys.path.append("c:\\MinGW\\bin" ) sys.path.append("c:\\MinGW\\bin" )
os.environ['PATH'] += ";c:\\MinGW\\bin\\" os.environ['PATH'] += ";c:\\MinGW\\bin\\"
else: else:
cross = "i586-mingw32msvc-" #cross = "i586-mingw32msvc-"
cross = "x86_64-w64-mingw32-"
#cross = "i686-w64-mingw32-"
if typeCompilator!="gcc": if typeCompilator!="gcc":
debug.error("Android does not support '" + typeCompilator + "' compilator ... availlable : [gcc]") debug.error("Android does not support '" + typeCompilator + "' compilator ... availlable : [gcc]")