From 825875dd129887598b28d9a71ba39d9672578857 Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Thu, 19 Dec 2013 01:07:30 +0100 Subject: [PATCH] [DEV] start parse of all sub elements --- cppParser/Class.py | 75 +++++--- cppParser/Enum.py | 31 ++-- cppParser/Methode.py | 25 ++- cppParser/Namespace.py | 35 ++-- cppParser/Node.py | 26 ++- cppParser/Parse.py | 412 ++++++++++++++++++++--------------------- cppParser/Struct.py | 38 ++-- cppParser/Type.py | 56 ++++-- cppParser/Union.py | 22 ++- cppParser/Variable.py | 52 ++++-- lutinDoc.py | 4 +- lutinDocHtml.py | 2 +- lutinDocMd.py | 2 +- lutinTarget.py | 2 +- lutinTargetWindows.py | 4 +- 15 files changed, 403 insertions(+), 383 deletions(-) diff --git a/cppParser/Class.py b/cppParser/Class.py index 755bdfb..c485358 100644 --- a/cppParser/Class.py +++ b/cppParser/Class.py @@ -1,38 +1,59 @@ #!/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 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>' +## +def concatenate_template(list): + # TODO ... + return list 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'], ...]) - self.parents = [] - - # CPP section: - self.namespaces = [] - self.classes = [] - # C section: - self.structs = [] - self.variables = [] - self.methodes = [] - self.unions = [] - self.types = [] + list = concatenate_template(stack[3:]) + debug.info("inherit : " + str(list)) + access = "private" + for element in list: + if element in ['private', 'protected', 'public']: + access = element + elif element == ',': + pass + else: + self.inherit.append({'access' : access, 'class' : element}) + debug.info("class : " + self.to_str()) - - def to_str(self): - return "" + def to_str(self) : + ret = "class " + self.name + 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 diff --git a/cppParser/Enum.py b/cppParser/Enum.py index 21cc38f..c31c5b3 100644 --- a/cppParser/Enum.py +++ b/cppParser/Enum.py @@ -1,24 +1,15 @@ #!/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 lutinDebug as debug import Node -import inspect - - -class Enum(Node): - def __init__(self): - self.name = libName - - #List is contituated of 3 element : {'name':"plop", 'value':5, 'doc'=""}, ...] - self.list = [] - +class Enum(Node.Node): + def __init__(self, stack=[], file="", lineNumber=0): + name = "" + Node.Node.__init__(self, 'enum', name, file, lineNumber) + # CPP section: + self.listElement = [] + def to_str(self) : + return "enum " + self.name + " { ... };" + + diff --git a/cppParser/Methode.py b/cppParser/Methode.py index 5f198da..c41214b 100644 --- a/cppParser/Methode.py +++ b/cppParser/Methode.py @@ -1,23 +1,18 @@ -#!/usr/bin/python -try : - # normal install module - import ply.lex as lex -except ImportError : - # local module - import lex -import os -import sys -import re +##!/usr/bin/python +import lutinDebug as debug +import Node +import Type - - -class Methode(): - def __init__(self): +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++ 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" @@ -36,5 +31,7 @@ class Methode(): ret += "(" # ... ret += ")" + if self.const == True: + ret += " const" return ret diff --git a/cppParser/Namespace.py b/cppParser/Namespace.py index 54df3c8..7b9d08f 100644 --- a/cppParser/Namespace.py +++ b/cppParser/Namespace.py @@ -1,29 +1,16 @@ #!/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 lutinDebug as debug +import Node -import inspect - -class Namespace(): - def __init__(self): - self.name = "" - # CPP section: - self.namespaces = [] - self.classes = [] - # C section: - self.structs = [] - self.variables = [] - self.methodes = [] - self.unions = [] - self.types = [] +class Namespace(Node.Node): + def __init__(self, stack=[], file="", lineNumber=0): + if len(stack) != 2: + debug.error("Can not parse namespace : " + str(stack)) + Node.Node.__init__(self, 'namespace', stack[1], file, lineNumber) + + debug.verbose("find class : " + self.to_str()) def to_str(self) : - return "" + return "namespace " + self.name + " { ... };" + diff --git a/cppParser/Node.py b/cppParser/Node.py index 56ab8ab..796c4a1 100644 --- a/cppParser/Node.py +++ b/cppParser/Node.py @@ -1,22 +1,20 @@ #!/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 lutinDebug as debug class Node(): - def __init__(self): - self.name = "" + def __init__(self, type, name="", file="", lineNumber=0): + self.nodeType = type + self.name = name self.doc = None - self.fileName = "" - self.lineNumber = "" + self.fileName = file + self.lineNumber = lineNumber + self.subList = [] - def to_str(): + def to_str(self): return "" + + def append(self, newSubElement): + # just add it in a sub List : + self.subList.append(newSubElement) diff --git a/cppParser/Parse.py b/cppParser/Parse.py index 0fa4b1d..2d95073 100644 --- a/cppParser/Parse.py +++ b/cppParser/Parse.py @@ -3,12 +3,18 @@ import os import sys import re -import ply.lex as lex +import lex import inspect import lutinDebug as debug import lutinTools import Class +import Namespace +import Struct +import Union +import Methode +import Enum +import Variable tokens = [ 'NUMBER', @@ -106,215 +112,62 @@ def t_error(v): 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 = "" -#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 = [ 'public', 'protected', 'private' ] - ## ## @brief Join the class name element : ['class', 'Bar', ':', ':', 'Foo'] -> ['class', 'Bar::Foo'] ## @param table Input table to convert. ex: [':', '\t', 'class', 'Bar', ':', ':', 'Foo'] ## @return The new table. ex: ['class', 'Bar::Foo'] ## def create_compleate_class_name(table): - compleateLine = "" - compleateLine = compleateLine.join(table); - if "::" not in compleateLine: - return table - # we need to convert it : - out = [] - for name in table: - if len(out) == 0: - out.append(name) - elif name == ":" \ - and out[-1].endswith(":"): - out[-1] += name - elif out[-1].endswith("::"): - out[-2] += out[-1] + name - del out[-1] - else: - out.append(name) + if "::" not in "".join(table): + out = table + else: + # we need to convert it : + out = [] + for name in table: + if len(out) == 0: + out.append(name) + elif name == ":" \ + and out[-1].endswith(":"): + out[-1] += name + elif out[-1].endswith("::"): + out[-2] += out[-1] + name + del out[-1] + else: + 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 + 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): self.m_classes = [] self.m_elementParseStack = [] @@ -365,57 +218,73 @@ class parse_file(): self.stack = [] # token stack to find the namespace and the element name ... self.nameStack = [] # self.braceDepth = 0 + self.braceDepthType = [] + self.subModuleCountBrace = 0; lex.lex() lex.input(headerFileStr) - global curLine - global curChar - curLine = 0 - curChar = 0 + self.curLine = 0 + self.curChar = 0 while True: tok = lex.token() if not tok: break - tok.value = TagStr(tok.value, lineno=tok.lineno) debug.debug("TOK: " + str(tok)) self.stack.append( tok.value ) - curLine = tok.lineno - curChar = tok.lexpos + self.curLine = tok.lineno + 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')): debug.debug("PRECOMP: " + str(tok)) self.stack = [] self.nameStack = [] # Do nothing for macro ==> many time not needed ... continue - if (tok.type == 'OPEN_BRACE'): + if tok.type == 'OPEN_BRACE': # 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', self.nameStack = create_compleate_class_name(self.nameStack) if len(self.nameStack) <= 0: #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: - debug.info("[" + str(self.braceDepth) + "] find a namespace : " + str(self.nameStack)); + self.brace_type_push('namespace', 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: - debug.info("[" + str(self.braceDepth) + "] find a enum : " + str(self.nameStack)); + self.brace_type_push('enum', 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: - debug.info("[" + str(self.braceDepth) + "] find a typedef : " + str(self.nameStack)); + self.brace_type_push('typedef', 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: - debug.warning("[" + str(self.braceDepth) + "] find an unknow stack : " + str(self.nameStack)) + self.brace_type_push('unknow', self.nameStack) self.stack = [] self.nameStack = [] - self.braceDepth += 1 elif tok.type == 'CLOSE_BRACE': - self.braceDepth -= 1 - debug.info("[" + str(self.braceDepth) + "] close brace"); - if len(self.m_elementParseStack) != 0 \ - and self.m_elementParseStack[len(self.m_elementParseStack)-1]['level'] == self.braceDepth : - self.m_elementParseStack.pop() + if len(self.nameStack) != 0: + if self.previous_is('enum') == True: + debug.info(self.gen_debug_space() + "enum list... : " + str(self.nameStack)); + else: + 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': self.nameStack.append(tok.value) elif tok.type == 'CLOSE_PAREN': @@ -457,13 +326,124 @@ class parse_file(): self.nameStack.append(tok.value) elif tok.type == 'COLON': 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.stack = [] else : self.nameStack.append(tok.value) elif tok.type == 'SEMI_COLON': 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.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 \ No newline at end of file diff --git a/cppParser/Struct.py b/cppParser/Struct.py index 7393540..f4e0dff 100644 --- a/cppParser/Struct.py +++ b/cppParser/Struct.py @@ -1,22 +1,22 @@ #!/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 lutinDebug as debug +import Node -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 diff --git a/cppParser/Type.py b/cppParser/Type.py index 1f7c3ef..f197bc2 100644 --- a/cppParser/Type.py +++ b/cppParser/Type.py @@ -1,28 +1,48 @@ #!/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 inspect +import lutinDebug as debug +import Type +import Node class Type(): - def __init__(self): + 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.constVar = False # the char* const VarName - self.static = False - self.inline = 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): def __init__(self): - Type.__init__() - self.name = "void" + Type.__init__(self, ['void']) diff --git a/cppParser/Union.py b/cppParser/Union.py index def346b..3fcb529 100644 --- a/cppParser/Union.py +++ b/cppParser/Union.py @@ -1,10 +1,14 @@ #!/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 lutinDebug as debug +import Node + +class Union(Node.Node): + def __init__(self, stack=[], file="", lineNumber=0): + name = "" + Node.Node.__init__(self, 'union', name, file, lineNumber) + self.list = [] + + def to_str(self) : + return "union " + self.name + " { ... };" + + diff --git a/cppParser/Variable.py b/cppParser/Variable.py index a126e27..ce47959 100644 --- a/cppParser/Variable.py +++ b/cppParser/Variable.py @@ -1,23 +1,45 @@ #!/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 lutinDebug as debug +import Type +import Node -class Variable(): - def __init__(self): - self.name = "" +class Variable(Node.Node): + def __init__(self, stack=[], file="", lineNumber=0): + 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.const = False # the const xxxxx - self.constVar = False # the char* const VarName self.static = 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) : - 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 diff --git a/lutinDoc.py b/lutinDoc.py index 449c548..b3e4d21 100644 --- a/lutinDoc.py +++ b/lutinDoc.py @@ -4,11 +4,9 @@ import sys import lutinTools # TODO : Add try of generic input ... 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__) + "/codeBB/") sys.path.append(lutinTools.GetCurrentPath(__file__) + "/codeHL/") -import CppHeaderParser import Parse import lutinDocHtml import lutinDocMd @@ -133,7 +131,7 @@ class doc: ## def add_file(self, 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"); try: diff --git a/lutinDocHtml.py b/lutinDocHtml.py index 50c3cc0..49f6511 100644 --- a/lutinDocHtml.py +++ b/lutinDocHtml.py @@ -2,7 +2,7 @@ import lutinDebug as debug import sys import lutinTools -import CppHeaderParser +#import CppHeaderParser import re import codeBB import collections diff --git a/lutinDocMd.py b/lutinDocMd.py index a553546..0f80178 100644 --- a/lutinDocMd.py +++ b/lutinDocMd.py @@ -2,7 +2,7 @@ import lutinDebug as debug import sys import lutinTools -import CppHeaderParser +#import CppHeaderParser def parse_doxygen(data) : pos = data.find("/*"); diff --git a/lutinTarget.py b/lutinTarget.py index e78a72d..734d3da 100644 --- a/lutinTarget.py +++ b/lutinTarget.py @@ -38,7 +38,7 @@ class Target: self.global_flags_xx=['-std=c++11'] self.global_flags_mm=['-std=c++11'] 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_m=[] self.global_flags_ar=['rcs'] diff --git a/lutinTargetWindows.py b/lutinTargetWindows.py index e9a7383..f5a10d5 100644 --- a/lutinTargetWindows.py +++ b/lutinTargetWindows.py @@ -17,7 +17,9 @@ class Target(lutinTarget.Target): sys.path.append("c:\\MinGW\\bin" ) os.environ['PATH'] += ";c:\\MinGW\\bin\\" else: - cross = "i586-mingw32msvc-" + #cross = "i586-mingw32msvc-" + cross = "x86_64-w64-mingw32-" + #cross = "i686-w64-mingw32-" if typeCompilator!="gcc": debug.error("Android does not support '" + typeCompilator + "' compilator ... availlable : [gcc]")