| # Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights |
| # reserved. Use of this source code is governed by a BSD-style license that |
| # can be found in the LICENSE file. |
| |
| from __future__ import absolute_import |
| from date_util import * |
| from file_util import * |
| import os |
| import re |
| import shutil |
| import string |
| import sys |
| import textwrap |
| import time |
| |
| |
| def notify(msg): |
| """ Display a message. """ |
| sys.stdout.write(' NOTE: ' + msg + '\n') |
| |
| |
| def wrap_text(text, indent='', maxchars=80): |
| """ Wrap the text to the specified number of characters. If |
| necessary a line will be broken and wrapped after a word. |
| """ |
| result = '' |
| lines = textwrap.wrap(text, maxchars - len(indent)) |
| for line in lines: |
| result += indent + line + '\n' |
| return result |
| |
| |
| def is_base_class(clsname): |
| """ Returns true if |clsname| is a known base (root) class in the object |
| hierarchy. |
| """ |
| return clsname == 'CefBaseRefCounted' or clsname == 'CefBaseScoped' |
| |
| |
| def get_capi_file_name(cppname): |
| """ Convert a C++ header file name to a C API header file name. """ |
| return cppname[:-2] + '_capi.h' |
| |
| |
| def get_capi_name(cppname, isclassname, prefix=None): |
| """ Convert a C++ CamelCaps name to a C API underscore name. """ |
| result = '' |
| lastchr = '' |
| for chr in cppname: |
| # add an underscore if the current character is an upper case letter |
| # and the last character was a lower case letter |
| if len(result) > 0 and not chr.isdigit() \ |
| and chr.upper() == chr \ |
| and not lastchr.upper() == lastchr: |
| result += '_' |
| result += chr.lower() |
| lastchr = chr |
| |
| if isclassname: |
| result += '_t' |
| |
| if not prefix is None: |
| if prefix[0:3] == 'cef': |
| # if the prefix name is duplicated in the function name |
| # remove that portion of the function name |
| subprefix = prefix[3:] |
| pos = result.find(subprefix) |
| if pos >= 0: |
| result = result[0:pos] + result[pos + len(subprefix):] |
| result = prefix + '_' + result |
| |
| return result |
| |
| |
| def get_wrapper_type_enum(cppname): |
| """ Returns the wrapper type enumeration value for the specified C++ class |
| name. """ |
| return 'WT_' + get_capi_name(cppname, False)[4:].upper() |
| |
| |
| def get_prev_line(body, pos): |
| """ Retrieve the start and end positions and value for the line immediately |
| before the line containing the specified position. |
| """ |
| end = body.rfind('\n', 0, pos) |
| start = body.rfind('\n', 0, end) + 1 |
| line = body[start:end] |
| return {'start': start, 'end': end, 'line': line} |
| |
| |
| def get_comment(body, name): |
| """ Retrieve the comment for a class or function. """ |
| result = [] |
| |
| pos = body.find(name) |
| in_block_comment = False |
| while pos > 0: |
| data = get_prev_line(body, pos) |
| line = data['line'].strip() |
| pos = data['start'] |
| if len(line) == 0: |
| # check if the next previous line is a comment |
| prevdata = get_prev_line(body, pos) |
| prevline = prevdata['line'].strip() |
| if prevline[0:2] == '//' and prevline[0:3] != '///': |
| result.append(None) |
| else: |
| break |
| # single line /*--cef()--*/ |
| elif line[0:2] == '/*' and line[-2:] == '*/': |
| continue |
| # start of multi line /*--cef()--*/ |
| elif in_block_comment and line[0:2] == '/*': |
| in_block_comment = False |
| continue |
| # end of multi line /*--cef()--*/ |
| elif not in_block_comment and line[-2:] == '*/': |
| in_block_comment = True |
| continue |
| elif in_block_comment: |
| continue |
| elif line[0:2] == '//': |
| # keep the comment line including any leading spaces |
| result.append(line[2:]) |
| else: |
| break |
| |
| result.reverse() |
| return result |
| |
| |
| def validate_comment(file, name, comment): |
| """ Validate the comment array returned by get_comment(). """ |
| # Verify that the comment contains beginning and ending '///' as required by |
| # CppDoc (the leading '//' from each line will already have been removed by |
| # the get_comment() logic). There may be additional comments proceeding the |
| # CppDoc block so we look at the quantity of lines equaling '/' and expect |
| # the last line to be '/'. |
| docct = 0 |
| for line in comment: |
| if not line is None and len(line) > 0 and line == '/': |
| docct = docct + 1 |
| if docct != 2 or len(comment) < 3 or comment[len(comment) - 1] != '/': |
| raise Exception('Missing or incorrect comment in %s for: %s' % \ |
| (file, name)) |
| |
| |
| def format_comment(comment, indent, translate_map=None, maxchars=80): |
| """ Return the comments array as a formatted string. """ |
| if not translate_map is None: |
| # Replace longest keys first in translation. |
| translate_keys = sorted( |
| translate_map.keys(), key=lambda item: (-len(item), item)) |
| |
| result = '' |
| wrapme = '' |
| hasemptyline = False |
| for line in comment: |
| # if the line starts with a leading space, remove that space |
| if not line is None and len(line) > 0 and line[0:1] == ' ': |
| line = line[1:] |
| didremovespace = True |
| else: |
| didremovespace = False |
| |
| if line is None or len(line) == 0 or line[0:1] == ' ' \ |
| or line[0:1] == '/': |
| # the previous paragraph, if any, has ended |
| if len(wrapme) > 0: |
| if not translate_map is None: |
| # apply the translation |
| for key in translate_keys: |
| wrapme = wrapme.replace(key, translate_map[key]) |
| # output the previous paragraph |
| result += wrap_text(wrapme, indent + '// ', maxchars) |
| wrapme = '' |
| |
| if not line is None: |
| if len(line) == 0 or line[0:1] == ' ' or line[0:1] == '/': |
| # blank lines or anything that's further indented should be |
| # output as-is |
| result += indent + '//' |
| if len(line) > 0: |
| if didremovespace: |
| result += ' ' + line |
| else: |
| result += line |
| result += '\n' |
| else: |
| # add to the current paragraph |
| wrapme += line + ' ' |
| else: |
| # output an empty line |
| hasemptyline = True |
| result += '\n' |
| |
| if len(wrapme) > 0: |
| if not translate_map is None: |
| # apply the translation |
| for key in translate_map.keys(): |
| wrapme = wrapme.replace(key, translate_map[key]) |
| # output the previous paragraph |
| result += wrap_text(wrapme, indent + '// ', maxchars) |
| |
| if hasemptyline: |
| # an empty line means a break between comments, so the comment is |
| # probably a section heading and should have an extra line before it |
| result = '\n' + result |
| return result |
| |
| |
| def format_translation_changes(old, new): |
| """ Return a comment stating what is different between the old and new |
| function prototype parts. |
| """ |
| changed = False |
| result = '' |
| |
| # normalize C API attributes |
| oldargs = [x.replace('struct _', '') for x in old['args']] |
| oldretval = old['retval'].replace('struct _', '') |
| newargs = [x.replace('struct _', '') for x in new['args']] |
| newretval = new['retval'].replace('struct _', '') |
| |
| # check if the prototype has changed |
| oldset = set(oldargs) |
| newset = set(newargs) |
| if len(oldset.symmetric_difference(newset)) > 0: |
| changed = True |
| result += '\n // WARNING - CHANGED ATTRIBUTES' |
| |
| # in the implementation set only |
| oldonly = oldset.difference(newset) |
| for arg in oldonly: |
| result += '\n // REMOVED: ' + arg |
| |
| # in the current set only |
| newonly = newset.difference(oldset) |
| for arg in newonly: |
| result += '\n // ADDED: ' + arg |
| |
| # check if the return value has changed |
| if oldretval != newretval: |
| changed = True |
| result += '\n // WARNING - CHANGED RETURN VALUE'+ \ |
| '\n // WAS: '+old['retval']+ \ |
| '\n // NOW: '+new['retval'] |
| |
| if changed: |
| result += '\n #pragma message("Warning: "__FILE__": '+new['name']+ \ |
| ' prototype has changed")\n' |
| |
| return result |
| |
| |
| def format_translation_includes(header, body): |
| """ Return the necessary list of includes based on the contents of the |
| body. |
| """ |
| result = '' |
| |
| # <algorithm> required for VS2013. |
| if body.find('std::min') > 0 or body.find('std::max') > 0: |
| result += '#include <algorithm>\n' |
| |
| if body.find('cef_api_hash(') > 0: |
| result += '#include "include/cef_api_hash.h"\n' |
| |
| # identify what CppToC classes are being used |
| p = re.compile('([A-Za-z0-9_]{1,})CppToC') |
| list = sorted(set(p.findall(body))) |
| for item in list: |
| directory = '' |
| if not is_base_class(item): |
| cls = header.get_class(item) |
| dir = cls.get_file_directory() |
| if not dir is None: |
| directory = dir + '/' |
| result += '#include "libcef_dll/cpptoc/'+directory+ \ |
| get_capi_name(item[3:], False)+'_cpptoc.h"\n' |
| |
| # identify what CToCpp classes are being used |
| p = re.compile('([A-Za-z0-9_]{1,})CToCpp') |
| list = sorted(set(p.findall(body))) |
| for item in list: |
| directory = '' |
| if not is_base_class(item): |
| cls = header.get_class(item) |
| dir = cls.get_file_directory() |
| if not dir is None: |
| directory = dir + '/' |
| result += '#include "libcef_dll/ctocpp/'+directory+ \ |
| get_capi_name(item[3:], False)+'_ctocpp.h"\n' |
| |
| if body.find('shutdown_checker') > 0: |
| result += '#include "libcef_dll/shutdown_checker.h"\n' |
| |
| if body.find('transfer_') > 0: |
| result += '#include "libcef_dll/transfer_util.h"\n' |
| |
| return result |
| |
| |
| def str_to_dict(str): |
| """ Convert a string to a dictionary. If the same key has multiple values |
| the values will be stored in a list. """ |
| dict = {} |
| parts = str.split(',') |
| for part in parts: |
| part = part.strip() |
| if len(part) == 0: |
| continue |
| sparts = part.split('=') |
| if len(sparts) > 2: |
| raise Exception('Invalid dictionary pair format: ' + part) |
| name = sparts[0].strip() |
| if len(sparts) == 2: |
| val = sparts[1].strip() |
| else: |
| val = True |
| if name in dict: |
| # a value with this name already exists |
| curval = dict[name] |
| if not isinstance(curval, list): |
| # convert the string value to a list |
| dict[name] = [curval] |
| dict[name].append(val) |
| else: |
| dict[name] = val |
| return dict |
| |
| |
| def dict_to_str(dict): |
| """ Convert a dictionary to a string. """ |
| str = [] |
| for name in dict.keys(): |
| if not isinstance(dict[name], list): |
| if dict[name] is True: |
| # currently a bool value |
| str.append(name) |
| else: |
| # currently a string value |
| str.append(name + '=' + dict[name]) |
| else: |
| # currently a list value |
| for val in dict[name]: |
| str.append(name + '=' + val) |
| return ','.join(str) |
| |
| |
| # regex for matching comment-formatted attributes |
| _cre_attrib = '/\*--cef\(([A-Za-z0-9_ ,=:\n]{0,})\)--\*/' |
| # regex for matching class and function names |
| _cre_cfname = '([A-Za-z0-9_]{1,})' |
| # regex for matching class and function names including path separators |
| _cre_cfnameorpath = '([A-Za-z0-9_\/]{1,})' |
| # regex for matching function return values |
| _cre_retval = '([A-Za-z0-9_<>:,\*\&]{1,})' |
| # regex for matching typedef value and name combination |
| _cre_typedef = '([A-Za-z0-9_<>:,\*\&\s]{1,})' |
| # regex for matching function return value and name combination |
| _cre_func = '([A-Za-z][A-Za-z0-9_<>:,\*\&\s]{1,})' |
| # regex for matching virtual function modifiers + arbitrary whitespace |
| _cre_vfmod = '([\sA-Za-z0-9_]{0,})' |
| # regex for matching arbitrary whitespace |
| _cre_space = '[\s]{1,}' |
| # regex for matching optional virtual keyword |
| _cre_virtual = '(?:[\s]{1,}virtual){0,1}' |
| |
| # Simple translation types. Format is: |
| # 'cpp_type' : ['capi_type', 'capi_default_value'] |
| _simpletypes = { |
| 'void': ['void', ''], |
| 'void*': ['void*', 'NULL'], |
| 'int': ['int', '0'], |
| 'int16': ['int16', '0'], |
| 'uint16': ['uint16', '0'], |
| 'int32': ['int32', '0'], |
| 'uint32': ['uint32', '0'], |
| 'int64': ['int64', '0'], |
| 'uint64': ['uint64', '0'], |
| 'double': ['double', '0'], |
| 'float': ['float', '0'], |
| 'float*': ['float*', 'NULL'], |
| 'long': ['long', '0'], |
| 'unsigned long': ['unsigned long', '0'], |
| 'long long': ['long long', '0'], |
| 'size_t': ['size_t', '0'], |
| 'bool': ['int', '0'], |
| 'char': ['char', '0'], |
| 'char* const': ['char* const', 'NULL'], |
| 'cef_color_t': ['cef_color_t', '0'], |
| 'cef_json_parser_error_t': ['cef_json_parser_error_t', 'JSON_NO_ERROR'], |
| 'cef_plugin_policy_t': ['cef_plugin_policy_t', 'PLUGIN_POLICY_ALLOW'], |
| 'CefCursorHandle': ['cef_cursor_handle_t', 'kNullCursorHandle'], |
| 'CefCompositionUnderline': [ |
| 'cef_composition_underline_t', 'CefCompositionUnderline()' |
| ], |
| 'CefEventHandle': ['cef_event_handle_t', 'kNullEventHandle'], |
| 'CefWindowHandle': ['cef_window_handle_t', 'kNullWindowHandle'], |
| 'CefPoint': ['cef_point_t', 'CefPoint()'], |
| 'CefRect': ['cef_rect_t', 'CefRect()'], |
| 'CefSize': ['cef_size_t', 'CefSize()'], |
| 'CefRange': ['cef_range_t', 'CefRange()'], |
| 'CefDraggableRegion': ['cef_draggable_region_t', 'CefDraggableRegion()'], |
| 'CefThreadId': ['cef_thread_id_t', 'TID_UI'], |
| 'CefTime': ['cef_time_t', 'CefTime()'], |
| 'CefAudioParameters': ['cef_audio_parameters_t', 'CefAudioParameters()'] |
| } |
| |
| |
| def get_function_impls(content, ident, has_impl=True): |
| """ Retrieve the function parts from the specified contents as a set of |
| return value, name, arguments and body. Ident must occur somewhere in |
| the value. |
| """ |
| # extract the functions |
| find_regex = '\n' + _cre_func + '\((.*?)\)([A-Za-z0-9_\s]{0,})' |
| if has_impl: |
| find_regex += '\{(.*?)\n\}' |
| else: |
| find_regex += '(;)' |
| p = re.compile(find_regex, re.MULTILINE | re.DOTALL) |
| list = p.findall(content) |
| |
| # build the function map with the function name as the key |
| result = [] |
| for retval, argval, vfmod, body in list: |
| if retval.find(ident) < 0: |
| # the identifier was not found |
| continue |
| |
| # remove the identifier |
| retval = retval.replace(ident, '') |
| retval = retval.strip() |
| |
| # Normalize the delimiter. |
| retval = retval.replace('\n', ' ') |
| |
| # retrieve the function name |
| parts = retval.split(' ') |
| name = parts[-1] |
| del parts[-1] |
| retval = ' '.join(parts) |
| |
| # parse the arguments |
| args = [] |
| for v in argval.split(','): |
| v = v.strip() |
| if len(v) > 0: |
| args.append(v) |
| |
| result.append({ |
| 'retval': retval.strip(), |
| 'name': name, |
| 'args': args, |
| 'vfmod': vfmod.strip(), |
| 'body': body if has_impl else '', |
| }) |
| |
| return result |
| |
| |
| def get_next_function_impl(existing, name): |
| result = None |
| for item in existing: |
| if item['name'] == name: |
| result = item |
| existing.remove(item) |
| break |
| return result |
| |
| |
| def get_copyright(full=False, translator=True): |
| if full: |
| result = \ |
| """// Copyright (c) $YEAR$ Marshall A. Greenblatt. All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the name Chromium Embedded |
| // Framework nor the names of its contributors may be used to endorse |
| // or promote products derived from this software without specific prior |
| // written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| """ |
| else: |
| result = \ |
| """// Copyright (c) $YEAR$ The Chromium Embedded Framework Authors. All rights |
| // reserved. Use of this source code is governed by a BSD-style license that |
| // can be found in the LICENSE file. |
| """ |
| |
| if translator: |
| result += \ |
| """// |
| // --------------------------------------------------------------------------- |
| // |
| // This file was generated by the CEF translator tool. If making changes by |
| // hand only do so within the body of existing method and function |
| // implementations. See the translator.README.txt file in the tools directory |
| // for more information. |
| // |
| // $hash=$$HASH$$$ |
| // |
| |
| """ |
| |
| # add the copyright year |
| return result.replace('$YEAR$', get_year()) |
| |
| |
| class obj_header: |
| """ Class representing a C++ header file. """ |
| |
| def __init__(self): |
| self.filenames = [] |
| self.typedefs = [] |
| self.funcs = [] |
| self.classes = [] |
| self.root_directory = None |
| |
| def set_root_directory(self, root_directory): |
| """ Set the root directory. """ |
| self.root_directory = root_directory |
| |
| def get_root_directory(self): |
| """ Get the root directory. """ |
| return self.root_directory |
| |
| def add_directory(self, directory, excluded_files=[]): |
| """ Add all header files from the specified directory. """ |
| files = get_files(os.path.join(directory, '*.h')) |
| for file in files: |
| if len(excluded_files) == 0 or \ |
| not os.path.split(file)[1] in excluded_files: |
| self.add_file(file) |
| |
| def add_file(self, filepath): |
| """ Add a header file. """ |
| |
| if self.root_directory is None: |
| filename = os.path.split(filepath)[1] |
| else: |
| filename = os.path.relpath(filepath, self.root_directory) |
| filename = filename.replace('\\', '/') |
| |
| # read the input file into memory |
| self.add_data(filename, read_file(filepath)) |
| |
| def add_data(self, filename, data): |
| """ Add header file contents. """ |
| |
| added = False |
| |
| # remove space from between template definition end brackets |
| data = data.replace("> >", ">>") |
| |
| # extract global typedefs |
| p = re.compile('\ntypedef' + _cre_space + _cre_typedef + ';', |
| re.MULTILINE | re.DOTALL) |
| list = p.findall(data) |
| if len(list) > 0: |
| # build the global typedef objects |
| for value in list: |
| pos = value.rfind(' ') |
| if pos < 0: |
| raise Exception('Invalid typedef: ' + value) |
| alias = value[pos + 1:].strip() |
| value = value[:pos].strip() |
| self.typedefs.append(obj_typedef(self, filename, value, alias)) |
| |
| # extract global functions |
| p = re.compile('\n' + _cre_attrib + '\n' + _cre_func + '\((.*?)\)', |
| re.MULTILINE | re.DOTALL) |
| list = p.findall(data) |
| if len(list) > 0: |
| added = True |
| |
| # build the global function objects |
| for attrib, retval, argval in list: |
| comment = get_comment(data, retval + '(' + argval + ');') |
| validate_comment(filename, retval, comment) |
| self.funcs.append( |
| obj_function(self, filename, attrib, retval, argval, comment)) |
| |
| # extract includes |
| p = re.compile('\n#include \"include/' + _cre_cfnameorpath + '.h') |
| includes = p.findall(data) |
| |
| # extract forward declarations |
| p = re.compile('\nclass' + _cre_space + _cre_cfname + ';') |
| forward_declares = p.findall(data) |
| |
| # extract empty classes |
| p = re.compile('\n' + _cre_attrib + '\nclass' + _cre_space + _cre_cfname + |
| _cre_space + ':' + _cre_space + 'public' + _cre_virtual + |
| _cre_space + _cre_cfname + _cre_space + '{};', |
| re.MULTILINE | re.DOTALL) |
| list = p.findall(data) |
| if len(list) > 0: |
| added = True |
| |
| # build the class objects |
| for attrib, name, parent_name in list: |
| # Style may place the ':' on the next line. |
| comment = get_comment(data, name + ' :') |
| if len(comment) == 0: |
| comment = get_comment(data, name + "\n") |
| validate_comment(filename, name, comment) |
| self.classes.append( |
| obj_class(self, filename, attrib, name, parent_name, "", comment, |
| includes, forward_declares)) |
| |
| # Remove empty classes from |data| so we don't mess up the non-empty |
| # class search that follows. |
| data = p.sub('', data) |
| |
| # extract classes |
| p = re.compile('\n' + _cre_attrib + '\nclass' + _cre_space + _cre_cfname + |
| _cre_space + ':' + _cre_space + 'public' + _cre_virtual + |
| _cre_space + _cre_cfname + _cre_space + '{(.*?)\n};', |
| re.MULTILINE | re.DOTALL) |
| list = p.findall(data) |
| if len(list) > 0: |
| added = True |
| |
| # build the class objects |
| for attrib, name, parent_name, body in list: |
| # Style may place the ':' on the next line. |
| comment = get_comment(data, name + ' :') |
| if len(comment) == 0: |
| comment = get_comment(data, name + "\n") |
| validate_comment(filename, name, comment) |
| self.classes.append( |
| obj_class(self, filename, attrib, name, parent_name, body, comment, |
| includes, forward_declares)) |
| |
| if added: |
| # a global function or class was read from the header file |
| self.filenames.append(filename) |
| |
| def __repr__(self): |
| result = '' |
| |
| if len(self.typedefs) > 0: |
| strlist = [] |
| for cls in self.typedefs: |
| strlist.append(str(cls)) |
| result += "\n".join(strlist) + "\n\n" |
| |
| if len(self.funcs) > 0: |
| strlist = [] |
| for cls in self.funcs: |
| strlist.append(str(cls)) |
| result += "\n".join(strlist) + "\n\n" |
| |
| if len(self.classes) > 0: |
| strlist = [] |
| for cls in self.classes: |
| strlist.append(str(cls)) |
| result += "\n".join(strlist) |
| |
| return result |
| |
| def get_file_names(self): |
| """ Return the array of header file names. """ |
| return self.filenames |
| |
| def get_typedefs(self): |
| """ Return the array of typedef objects. """ |
| return self.typedefs |
| |
| def get_funcs(self, filename=None): |
| """ Return the array of function objects. """ |
| if filename is None: |
| return self.funcs |
| else: |
| # only return the functions in the specified file |
| res = [] |
| for func in self.funcs: |
| if func.get_file_name() == filename: |
| res.append(func) |
| return res |
| |
| def get_classes(self, filename=None): |
| """ Return the array of class objects. """ |
| if filename is None: |
| return self.classes |
| else: |
| # only return the classes in the specified file |
| res = [] |
| for cls in self.classes: |
| if cls.get_file_name() == filename: |
| res.append(cls) |
| return res |
| |
| def get_class(self, classname, defined_structs=None): |
| """ Return the specified class or None if not found. """ |
| for cls in self.classes: |
| if cls.get_name() == classname: |
| return cls |
| elif not defined_structs is None: |
| defined_structs.append(cls.get_capi_name()) |
| return None |
| |
| def get_class_names(self): |
| """ Returns the names of all classes in this object. """ |
| result = [] |
| for cls in self.classes: |
| result.append(cls.get_name()) |
| return result |
| |
| def get_base_class_name(self, classname): |
| """ Returns the base (root) class name for |classname|. """ |
| cur_cls = self.get_class(classname) |
| while True: |
| parent_name = cur_cls.get_parent_name() |
| if is_base_class(parent_name): |
| return parent_name |
| else: |
| parent_cls = self.get_class(parent_name) |
| if parent_cls is None: |
| break |
| cur_cls = self.get_class(parent_name) |
| return None |
| |
| def get_types(self, list): |
| """ Return a dictionary mapping data types to analyzed values. """ |
| for cls in self.typedefs: |
| cls.get_types(list) |
| |
| for cls in self.classes: |
| cls.get_types(list) |
| |
| def get_alias_translation(self, alias): |
| """ Return a translation of alias to value based on typedef |
| statements. """ |
| for cls in self.typedefs: |
| if cls.alias == alias: |
| return cls.value |
| return None |
| |
| def get_analysis(self, value, named=True): |
| """ Return an analysis of the value based the header file context. """ |
| return obj_analysis([self], value, named) |
| |
| def get_defined_structs(self): |
| """ Return a list of already defined structure names. """ |
| return [ |
| 'cef_print_info_t', 'cef_window_info_t', 'cef_base_ref_counted_t', |
| 'cef_base_scoped_t' |
| ] |
| |
| def get_capi_translations(self): |
| """ Return a dictionary that maps C++ terminology to C API terminology. |
| """ |
| # strings that will be changed in C++ comments |
| map = { |
| 'class': 'structure', |
| 'Class': 'Structure', |
| 'interface': 'structure', |
| 'Interface': 'Structure', |
| 'true': 'true (1)', |
| 'false': 'false (0)', |
| 'empty': 'NULL', |
| 'method': 'function' |
| } |
| |
| # add mappings for all classes and functions |
| funcs = self.get_funcs() |
| for func in funcs: |
| map[func.get_name() + '()'] = func.get_capi_name() + '()' |
| |
| classes = self.get_classes() |
| for cls in classes: |
| map[cls.get_name()] = cls.get_capi_name() |
| |
| funcs = cls.get_virtual_funcs() |
| for func in funcs: |
| map[func.get_name() + '()'] = func.get_capi_name() + '()' |
| |
| funcs = cls.get_static_funcs() |
| for func in funcs: |
| map[func.get_name() + '()'] = func.get_capi_name() + '()' |
| |
| return map |
| |
| |
| class obj_class: |
| """ Class representing a C++ class. """ |
| |
| def __init__(self, parent, filename, attrib, name, parent_name, body, comment, |
| includes, forward_declares): |
| if not isinstance(parent, obj_header): |
| raise Exception('Invalid parent object type') |
| |
| self.parent = parent |
| self.filename = filename |
| self.attribs = str_to_dict(attrib) |
| self.name = name |
| self.parent_name = parent_name |
| self.comment = comment |
| self.includes = includes |
| self.forward_declares = forward_declares |
| |
| # extract typedefs |
| p = re.compile( |
| '\n' + _cre_space + 'typedef' + _cre_space + _cre_typedef + ';', |
| re.MULTILINE | re.DOTALL) |
| list = p.findall(body) |
| |
| # build the typedef objects |
| self.typedefs = [] |
| for value in list: |
| pos = value.rfind(' ') |
| if pos < 0: |
| raise Exception('Invalid typedef: ' + value) |
| alias = value[pos + 1:].strip() |
| value = value[:pos].strip() |
| self.typedefs.append(obj_typedef(self, filename, value, alias)) |
| |
| # extract static functions |
| p = re.compile('\n' + _cre_space + _cre_attrib + '\n' + _cre_space + |
| 'static' + _cre_space + _cre_func + '\((.*?)\)', |
| re.MULTILINE | re.DOTALL) |
| list = p.findall(body) |
| |
| # build the static function objects |
| self.staticfuncs = [] |
| for attrib, retval, argval in list: |
| comment = get_comment(body, retval + '(' + argval + ')') |
| validate_comment(filename, retval, comment) |
| self.staticfuncs.append( |
| obj_function_static(self, attrib, retval, argval, comment)) |
| |
| # extract virtual functions |
| p = re.compile( |
| '\n' + _cre_space + _cre_attrib + '\n' + _cre_space + 'virtual' + |
| _cre_space + _cre_func + '\((.*?)\)' + _cre_vfmod, |
| re.MULTILINE | re.DOTALL) |
| list = p.findall(body) |
| |
| # build the virtual function objects |
| self.virtualfuncs = [] |
| for attrib, retval, argval, vfmod in list: |
| comment = get_comment(body, retval + '(' + argval + ')') |
| validate_comment(filename, retval, comment) |
| self.virtualfuncs.append( |
| obj_function_virtual(self, attrib, retval, argval, comment, |
| vfmod.strip())) |
| |
| def __repr__(self): |
| result = '/* ' + dict_to_str( |
| self.attribs) + ' */ class ' + self.name + "\n{" |
| |
| if len(self.typedefs) > 0: |
| result += "\n\t" |
| strlist = [] |
| for cls in self.typedefs: |
| strlist.append(str(cls)) |
| result += "\n\t".join(strlist) |
| |
| if len(self.staticfuncs) > 0: |
| result += "\n\t" |
| strlist = [] |
| for cls in self.staticfuncs: |
| strlist.append(str(cls)) |
| result += "\n\t".join(strlist) |
| |
| if len(self.virtualfuncs) > 0: |
| result += "\n\t" |
| strlist = [] |
| for cls in self.virtualfuncs: |
| strlist.append(str(cls)) |
| result += "\n\t".join(strlist) |
| |
| result += "\n};\n" |
| return result |
| |
| def get_file_name(self): |
| """ Return the C++ header file name. Includes the directory component, |
| if any. """ |
| return self.filename |
| |
| def get_capi_file_name(self): |
| """ Return the CAPI header file name. Includes the directory component, |
| if any. """ |
| return get_capi_file_name(self.filename) |
| |
| def get_file_directory(self): |
| """ Return the file directory component, if any. """ |
| pos = self.filename.rfind('/') |
| if pos >= 0: |
| return self.filename[:pos] |
| return None |
| |
| def get_name(self): |
| """ Return the class name. """ |
| return self.name |
| |
| def get_capi_name(self): |
| """ Return the CAPI structure name for this class. """ |
| return get_capi_name(self.name, True) |
| |
| def get_parent_name(self): |
| """ Return the parent class name. """ |
| return self.parent_name |
| |
| def get_parent_capi_name(self): |
| """ Return the CAPI structure name for the parent class. """ |
| return get_capi_name(self.parent_name, True) |
| |
| def has_parent(self, parent_name): |
| """ Returns true if this class has the specified class anywhere in its |
| inheritance hierarchy. """ |
| # Every class has a known base class as the top-most parent. |
| if is_base_class(parent_name) or parent_name == self.parent_name: |
| return True |
| if is_base_class(self.parent_name): |
| return False |
| |
| cur_cls = self.parent.get_class(self.parent_name) |
| while True: |
| cur_parent_name = cur_cls.get_parent_name() |
| if is_base_class(cur_parent_name): |
| break |
| elif cur_parent_name == parent_name: |
| return True |
| cur_cls = self.parent.get_class(cur_parent_name) |
| |
| return False |
| |
| def get_comment(self): |
| """ Return the class comment as an array of lines. """ |
| return self.comment |
| |
| def get_includes(self): |
| """ Return the list of classes that are included from this class' |
| header file. """ |
| return self.includes |
| |
| def get_forward_declares(self): |
| """ Return the list of classes that are forward declared for this |
| class. """ |
| return self.forward_declares |
| |
| def get_attribs(self): |
| """ Return all attributes as a dictionary. """ |
| return self.attribs |
| |
| def has_attrib(self, name): |
| """ Return true if the specified attribute exists. """ |
| return name in self.attribs |
| |
| def get_attrib(self, name): |
| """ Return the first or only value for specified attribute. """ |
| if name in self.attribs: |
| if isinstance(self.attribs[name], list): |
| # the value is a list |
| return self.attribs[name][0] |
| else: |
| # the value is a string |
| return self.attribs[name] |
| return None |
| |
| def get_attrib_list(self, name): |
| """ Return all values for specified attribute as a list. """ |
| if name in self.attribs: |
| if isinstance(self.attribs[name], list): |
| # the value is already a list |
| return self.attribs[name] |
| else: |
| # convert the value to a list |
| return [self.attribs[name]] |
| return None |
| |
| def get_typedefs(self): |
| """ Return the array of typedef objects. """ |
| return self.typedefs |
| |
| def has_typedef_alias(self, alias): |
| """ Returns true if the specified typedef alias is defined in the scope |
| of this class declaration. """ |
| for typedef in self.typedefs: |
| if typedef.get_alias() == alias: |
| return True |
| return False |
| |
| def get_static_funcs(self): |
| """ Return the array of static function objects. """ |
| return self.staticfuncs |
| |
| def get_virtual_funcs(self): |
| """ Return the array of virtual function objects. """ |
| return self.virtualfuncs |
| |
| def get_types(self, list): |
| """ Return a dictionary mapping data types to analyzed values. """ |
| for cls in self.typedefs: |
| cls.get_types(list) |
| |
| for cls in self.staticfuncs: |
| cls.get_types(list) |
| |
| for cls in self.virtualfuncs: |
| cls.get_types(list) |
| |
| def get_alias_translation(self, alias): |
| for cls in self.typedefs: |
| if cls.alias == alias: |
| return cls.value |
| return None |
| |
| def get_analysis(self, value, named=True): |
| """ Return an analysis of the value based on the class definition |
| context. |
| """ |
| return obj_analysis([self, self.parent], value, named) |
| |
| def is_library_side(self): |
| """ Returns true if the class is implemented by the library. """ |
| return self.attribs['source'] == 'library' |
| |
| def is_client_side(self): |
| """ Returns true if the class is implemented by the client. """ |
| return self.attribs['source'] == 'client' |
| |
| |
| class obj_typedef: |
| """ Class representing a typedef statement. """ |
| |
| def __init__(self, parent, filename, value, alias): |
| if not isinstance(parent, obj_header) \ |
| and not isinstance(parent, obj_class): |
| raise Exception('Invalid parent object type') |
| |
| self.parent = parent |
| self.filename = filename |
| self.alias = alias |
| self.value = self.parent.get_analysis(value, False) |
| |
| def __repr__(self): |
| return 'typedef ' + self.value.get_type() + ' ' + self.alias + ';' |
| |
| def get_file_name(self): |
| """ Return the C++ header file name. """ |
| return self.filename |
| |
| def get_capi_file_name(self): |
| """ Return the CAPI header file name. """ |
| return get_capi_file_name(self.filename) |
| |
| def get_alias(self): |
| """ Return the alias. """ |
| return self.alias |
| |
| def get_value(self): |
| """ Return an analysis of the value based on the class or header file |
| definition context. |
| """ |
| return self.value |
| |
| def get_types(self, list): |
| """ Return a dictionary mapping data types to analyzed values. """ |
| name = self.value.get_type() |
| if not name in list: |
| list[name] = self.value |
| |
| |
| class obj_function: |
| """ Class representing a function. """ |
| |
| def __init__(self, parent, filename, attrib, retval, argval, comment): |
| self.parent = parent |
| self.filename = filename |
| self.attribs = str_to_dict(attrib) |
| self.retval = obj_argument(self, retval) |
| self.name = self.retval.remove_name() |
| self.comment = comment |
| |
| # build the argument objects |
| self.arguments = [] |
| arglist = argval.split(',') |
| argindex = 0 |
| while argindex < len(arglist): |
| arg = arglist[argindex] |
| if arg.find('<') >= 0 and arg.find('>') == -1: |
| # We've split inside of a template type declaration. Join the |
| # next argument with this argument. |
| argindex += 1 |
| arg += ',' + arglist[argindex] |
| |
| arg = arg.strip() |
| if len(arg) > 0: |
| argument = obj_argument(self, arg) |
| if argument.needs_attrib_count_func() and \ |
| argument.get_attrib_count_func() is None: |
| raise Exception("A 'count_func' attribute is required "+ \ |
| "for the '"+argument.get_name()+ \ |
| "' parameter to "+self.get_qualified_name()) |
| self.arguments.append(argument) |
| |
| argindex += 1 |
| |
| if self.retval.needs_attrib_default_retval() and \ |
| self.retval.get_attrib_default_retval() is None: |
| raise Exception("A 'default_retval' attribute is required for "+ \ |
| self.get_qualified_name()) |
| |
| def __repr__(self): |
| return '/* ' + dict_to_str(self.attribs) + ' */ ' + self.get_cpp_proto() |
| |
| def get_file_name(self): |
| """ Return the C++ header file name. """ |
| return self.filename |
| |
| def get_capi_file_name(self): |
| """ Return the CAPI header file name. """ |
| return get_capi_file_name(self.filename) |
| |
| def get_name(self): |
| """ Return the function name. """ |
| return self.name |
| |
| def get_qualified_name(self): |
| """ Return the fully qualified function name. """ |
| if isinstance(self.parent, obj_header): |
| # global function |
| return self.name |
| else: |
| # member function |
| return self.parent.get_name() + '::' + self.name |
| |
| def get_capi_name(self, prefix=None): |
| """ Return the CAPI function name. """ |
| if 'capi_name' in self.attribs: |
| return self.attribs['capi_name'] |
| return get_capi_name(self.name, False, prefix) |
| |
| def get_comment(self): |
| """ Return the function comment as an array of lines. """ |
| return self.comment |
| |
| def get_attribs(self): |
| """ Return all attributes as a dictionary. """ |
| return self.attribs |
| |
| def has_attrib(self, name): |
| """ Return true if the specified attribute exists. """ |
| return name in self.attribs |
| |
| def get_attrib(self, name): |
| """ Return the first or only value for specified attribute. """ |
| if name in self.attribs: |
| if isinstance(self.attribs[name], list): |
| # the value is a list |
| return self.attribs[name][0] |
| else: |
| # the value is a string |
| return self.attribs[name] |
| return None |
| |
| def get_attrib_list(self, name): |
| """ Return all values for specified attribute as a list. """ |
| if name in self.attribs: |
| if isinstance(self.attribs[name], list): |
| # the value is already a list |
| return self.attribs[name] |
| else: |
| # convert the value to a list |
| return [self.attribs[name]] |
| return None |
| |
| def get_retval(self): |
| """ Return the return value object. """ |
| return self.retval |
| |
| def get_arguments(self): |
| """ Return the argument array. """ |
| return self.arguments |
| |
| def get_types(self, list): |
| """ Return a dictionary mapping data types to analyzed values. """ |
| for cls in self.arguments: |
| cls.get_types(list) |
| |
| def get_capi_parts(self, defined_structs=[], prefix=None): |
| """ Return the parts of the C API function definition. """ |
| retval = '' |
| dict = self.retval.get_type().get_capi(defined_structs) |
| if dict['format'] == 'single': |
| retval = dict['value'] |
| |
| name = self.get_capi_name(prefix) |
| args = [] |
| |
| if isinstance(self, obj_function_virtual): |
| # virtual functions get themselves as the first argument |
| str = 'struct _' + self.parent.get_capi_name() + '* self' |
| if isinstance(self, obj_function_virtual) and self.is_const(): |
| # const virtual functions get const self pointers |
| str = 'const ' + str |
| args.append(str) |
| |
| if len(self.arguments) > 0: |
| for cls in self.arguments: |
| type = cls.get_type() |
| dict = type.get_capi(defined_structs) |
| if dict['format'] == 'single': |
| args.append(dict['value']) |
| elif dict['format'] == 'multi-arg': |
| # add an additional argument for the size of the array |
| type_name = type.get_name() |
| if type.is_const(): |
| # for const arrays pass the size argument by value |
| args.append('size_t ' + type_name + 'Count') |
| else: |
| # for non-const arrays pass the size argument by address |
| args.append('size_t* ' + type_name + 'Count') |
| args.append(dict['value']) |
| |
| return {'retval': retval, 'name': name, 'args': args} |
| |
| def get_capi_proto(self, defined_structs=[], prefix=None): |
| """ Return the prototype of the C API function. """ |
| parts = self.get_capi_parts(defined_structs, prefix) |
| result = parts['retval']+' '+parts['name']+ \ |
| '('+', '.join(parts['args'])+')' |
| return result |
| |
| def get_cpp_parts(self, isimpl=False): |
| """ Return the parts of the C++ function definition. """ |
| retval = str(self.retval) |
| name = self.name |
| |
| args = [] |
| if len(self.arguments) > 0: |
| for cls in self.arguments: |
| args.append(str(cls)) |
| |
| if isimpl and isinstance(self, obj_function_virtual): |
| # enumeration return values must be qualified with the class name |
| # if the type is defined in the class declaration scope. |
| type = self.get_retval().get_type() |
| if type.is_result_struct() and type.is_result_struct_enum() and \ |
| self.parent.has_typedef_alias(retval): |
| retval = self.parent.get_name() + '::' + retval |
| |
| return {'retval': retval, 'name': name, 'args': args} |
| |
| def get_cpp_proto(self, classname=None): |
| """ Return the prototype of the C++ function. """ |
| parts = self.get_cpp_parts() |
| result = parts['retval'] + ' ' |
| if not classname is None: |
| result += classname + '::' |
| result += parts['name'] + '(' + ', '.join(parts['args']) + ')' |
| if isinstance(self, obj_function_virtual) and self.is_const(): |
| result += ' const' |
| return result |
| |
| def is_same_side(self, other_class_name): |
| """ Returns true if this function is on the same side (library or |
| client) and the specified class. """ |
| if isinstance(self.parent, obj_class): |
| # this function is part of a class |
| this_is_library_side = self.parent.is_library_side() |
| header = self.parent.parent |
| else: |
| # this function is global |
| this_is_library_side = True |
| header = self.parent |
| |
| if is_base_class(other_class_name): |
| other_is_library_side = False |
| else: |
| other_class = header.get_class(other_class_name) |
| if other_class is None: |
| raise Exception('Unknown class: ' + other_class_name) |
| other_is_library_side = other_class.is_library_side() |
| |
| return other_is_library_side == this_is_library_side |
| |
| |
| class obj_function_static(obj_function): |
| """ Class representing a static function. """ |
| |
| def __init__(self, parent, attrib, retval, argval, comment): |
| if not isinstance(parent, obj_class): |
| raise Exception('Invalid parent object type') |
| obj_function.__init__(self, parent, parent.filename, attrib, retval, argval, |
| comment) |
| |
| def __repr__(self): |
| return 'static ' + obj_function.__repr__(self) + ';' |
| |
| def get_capi_name(self, prefix=None): |
| """ Return the CAPI function name. """ |
| if prefix is None: |
| # by default static functions are prefixed with the class name |
| prefix = get_capi_name(self.parent.get_name(), False) |
| return obj_function.get_capi_name(self, prefix) |
| |
| |
| class obj_function_virtual(obj_function): |
| """ Class representing a virtual function. """ |
| |
| def __init__(self, parent, attrib, retval, argval, comment, vfmod): |
| if not isinstance(parent, obj_class): |
| raise Exception('Invalid parent object type') |
| obj_function.__init__(self, parent, parent.filename, attrib, retval, argval, |
| comment) |
| if vfmod == 'const': |
| self.isconst = True |
| else: |
| self.isconst = False |
| |
| def __repr__(self): |
| return 'virtual ' + obj_function.__repr__(self) + ';' |
| |
| def is_const(self): |
| """ Returns true if the method declaration is const. """ |
| return self.isconst |
| |
| |
| class obj_argument: |
| """ Class representing a function argument. """ |
| |
| def __init__(self, parent, argval): |
| if not isinstance(parent, obj_function): |
| raise Exception('Invalid parent object type') |
| |
| self.parent = parent |
| self.type = self.parent.parent.get_analysis(argval) |
| |
| def __repr__(self): |
| result = '' |
| if self.type.is_const(): |
| result += 'const ' |
| result += self.type.get_type() |
| if self.type.is_byref(): |
| result += '&' |
| elif self.type.is_byaddr(): |
| result += '*' |
| if self.type.has_name(): |
| result += ' ' + self.type.get_name() |
| return result |
| |
| def get_name(self): |
| """ Return the name for this argument. """ |
| return self.type.get_name() |
| |
| def remove_name(self): |
| """ Remove and return the name value. """ |
| name = self.type.get_name() |
| self.type.name = None |
| return name |
| |
| def get_type(self): |
| """ Return an analysis of the argument type based on the class |
| definition context. |
| """ |
| return self.type |
| |
| def get_types(self, list): |
| """ Return a dictionary mapping data types to analyzed values. """ |
| name = self.type.get_type() |
| if not name in list: |
| list[name] = self.type |
| |
| def needs_attrib_count_func(self): |
| """ Returns true if this argument requires a 'count_func' attribute. """ |
| # A 'count_func' attribute is required for non-const non-string vector |
| # attribute types |
| return self.type.has_name() and \ |
| self.type.is_result_vector() and \ |
| not self.type.is_result_vector_string() and \ |
| not self.type.is_const() |
| |
| def get_attrib_count_func(self): |
| """ Returns the count function for this argument. """ |
| # The 'count_func' attribute value format is name:function |
| if not self.parent.has_attrib('count_func'): |
| return None |
| name = self.type.get_name() |
| vals = self.parent.get_attrib_list('count_func') |
| for val in vals: |
| parts = val.split(':') |
| if len(parts) != 2: |
| raise Exception("Invalid 'count_func' attribute value for "+ \ |
| self.parent.get_qualified_name()+': '+val) |
| if parts[0].strip() == name: |
| return parts[1].strip() |
| return None |
| |
| def needs_attrib_default_retval(self): |
| """ Returns true if this argument requires a 'default_retval' attribute. |
| """ |
| # A 'default_retval' attribute is required for enumeration return value |
| # types. |
| return not self.type.has_name() and \ |
| self.type.is_result_struct() and \ |
| self.type.is_result_struct_enum() |
| |
| def get_attrib_default_retval(self): |
| """ Returns the defualt return value for this argument. """ |
| return self.parent.get_attrib('default_retval') |
| |
| def get_arg_type(self): |
| """ Returns the argument type as defined in translator.README.txt. """ |
| if not self.type.has_name(): |
| raise Exception('Cannot be called for retval types') |
| |
| # simple or enumeration type |
| if (self.type.is_result_simple() and \ |
| self.type.get_type() != 'bool') or \ |
| (self.type.is_result_struct() and \ |
| self.type.is_result_struct_enum()): |
| if self.type.is_byref(): |
| if self.type.is_const(): |
| return 'simple_byref_const' |
| return 'simple_byref' |
| elif self.type.is_byaddr(): |
| return 'simple_byaddr' |
| return 'simple_byval' |
| |
| # boolean type |
| if self.type.get_type() == 'bool': |
| if self.type.is_byref(): |
| return 'bool_byref' |
| elif self.type.is_byaddr(): |
| return 'bool_byaddr' |
| return 'bool_byval' |
| |
| # structure type |
| if self.type.is_result_struct() and self.type.is_byref(): |
| if self.type.is_const(): |
| return 'struct_byref_const' |
| return 'struct_byref' |
| |
| # string type |
| if self.type.is_result_string() and self.type.is_byref(): |
| if self.type.is_const(): |
| return 'string_byref_const' |
| return 'string_byref' |
| |
| # *ptr type |
| if self.type.is_result_ptr(): |
| prefix = self.type.get_result_ptr_type_prefix() |
| same_side = self.parent.is_same_side(self.type.get_ptr_type()) |
| if self.type.is_byref(): |
| if same_side: |
| return prefix + 'ptr_same_byref' |
| return prefix + 'ptr_diff_byref' |
| if same_side: |
| return prefix + 'ptr_same' |
| return prefix + 'ptr_diff' |
| |
| if self.type.is_result_vector(): |
| # all vector types must be passed by reference |
| if not self.type.is_byref(): |
| return 'invalid' |
| |
| if self.type.is_result_vector_string(): |
| # string vector type |
| if self.type.is_const(): |
| return 'string_vec_byref_const' |
| return 'string_vec_byref' |
| |
| if self.type.is_result_vector_simple(): |
| if self.type.get_vector_type() != 'bool': |
| # simple/enumeration vector types |
| if self.type.is_const(): |
| return 'simple_vec_byref_const' |
| return 'simple_vec_byref' |
| |
| # boolean vector types |
| if self.type.is_const(): |
| return 'bool_vec_byref_const' |
| return 'bool_vec_byref' |
| |
| if self.type.is_result_vector_ptr(): |
| # *ptr vector types |
| prefix = self.type.get_result_vector_ptr_type_prefix() |
| same_side = self.parent.is_same_side(self.type.get_ptr_type()) |
| if self.type.is_const(): |
| if same_side: |
| return prefix + 'ptr_vec_same_byref_const' |
| return prefix + 'ptr_vec_diff_byref_const' |
| if same_side: |
| return prefix + 'ptr_vec_same_byref' |
| return prefix + 'ptr_vec_diff_byref' |
| |
| # string single map type |
| if self.type.is_result_map_single(): |
| if not self.type.is_byref(): |
| return 'invalid' |
| if self.type.is_const(): |
| return 'string_map_single_byref_const' |
| return 'string_map_single_byref' |
| |
| # string multi map type |
| if self.type.is_result_map_multi(): |
| if not self.type.is_byref(): |
| return 'invalid' |
| if self.type.is_const(): |
| return 'string_map_multi_byref_const' |
| return 'string_map_multi_byref' |
| |
| return 'invalid' |
| |
| def get_retval_type(self): |
| """ Returns the retval type as defined in translator.README.txt. """ |
| if self.type.has_name(): |
| raise Exception('Cannot be called for argument types') |
| |
| # unsupported modifiers |
| if self.type.is_const() or self.type.is_byref() or \ |
| self.type.is_byaddr(): |
| return 'invalid' |
| |
| # void types don't have a return value |
| if self.type.get_type() == 'void': |
| return 'none' |
| |
| if (self.type.is_result_simple() and \ |
| self.type.get_type() != 'bool') or \ |
| (self.type.is_result_struct() and self.type.is_result_struct_enum()): |
| return 'simple' |
| |
| if self.type.get_type() == 'bool': |
| return 'bool' |
| |
| if self.type.is_result_string(): |
| return 'string' |
| |
| if self.type.is_result_ptr(): |
| prefix = self.type.get_result_ptr_type_prefix() |
| if self.parent.is_same_side(self.type.get_ptr_type()): |
| return prefix + 'ptr_same' |
| else: |
| return prefix + 'ptr_diff' |
| |
| return 'invalid' |
| |
| def get_retval_default(self, for_capi): |
| """ Returns the default return value based on the retval type. """ |
| # start with the default retval attribute, if any. |
| retval = self.get_attrib_default_retval() |
| if not retval is None: |
| if for_capi: |
| # apply any appropriate C API translations. |
| if retval == 'true': |
| return '1' |
| if retval == 'false': |
| return '0' |
| return retval |
| |
| # next look at the retval type value. |
| type = self.get_retval_type() |
| if type == 'simple': |
| return self.get_type().get_result_simple_default() |
| elif type == 'bool': |
| if for_capi: |
| return '0' |
| return 'false' |
| elif type == 'string': |
| if for_capi: |
| return 'NULL' |
| return 'CefString()' |
| elif type == 'refptr_same' or type == 'refptr_diff' or \ |
| type == 'rawptr_same' or type == 'rawptr_diff': |
| if for_capi: |
| return 'NULL' |
| return 'nullptr' |
| elif type == 'ownptr_same' or type == 'ownptr_diff': |
| if for_capi: |
| return 'NULL' |
| return 'CefOwnPtr<' + self.type.get_ptr_type() + '>()' |
| |
| return '' |
| |
| |
| class obj_analysis: |
| """ Class representing an analysis of a data type value. """ |
| |
| def __init__(self, scopelist, value, named): |
| self.value = value |
| self.result_type = 'unknown' |
| self.result_value = None |
| self.result_default = None |
| self.ptr_type = None |
| |
| # parse the argument string |
| partlist = value.strip().split() |
| |
| if named == True: |
| # extract the name value |
| self.name = partlist[-1] |
| del partlist[-1] |
| else: |
| self.name = None |
| |
| if len(partlist) == 0: |
| raise Exception('Invalid argument value: ' + value) |
| |
| # check const status |
| if partlist[0] == 'const': |
| self.isconst = True |
| del partlist[0] |
| else: |
| self.isconst = False |
| |
| if len(partlist) == 0: |
| raise Exception('Invalid argument value: ' + value) |
| |
| # combine the data type |
| self.type = ' '.join(partlist) |
| |
| # extract the last character of the data type |
| endchar = self.type[-1] |
| |
| # check if the value is passed by reference |
| if endchar == '&': |
| self.isbyref = True |
| self.type = self.type[:-1] |
| else: |
| self.isbyref = False |
| |
| # check if the value is passed by address |
| if endchar == '*': |
| self.isbyaddr = True |
| self.type = self.type[:-1] |
| else: |
| self.isbyaddr = False |
| |
| # see if the value is directly identifiable |
| if self._check_advanced(self.type) == True: |
| return |
| |
| # not identifiable, so look it up |
| translation = None |
| for scope in scopelist: |
| if not isinstance(scope, obj_header) \ |
| and not isinstance(scope, obj_class): |
| raise Exception('Invalid scope object type') |
| translation = scope.get_alias_translation(self.type) |
| if not translation is None: |
| break |
| |
| if translation is None: |
| raise Exception('Failed to translate type: ' + self.type) |
| |
| # the translation succeeded so keep the result |
| self.result_type = translation.result_type |
| self.result_value = translation.result_value |
| |
| def _check_advanced(self, value): |
| # check for vectors |
| if value.find('std::vector') == 0: |
| self.result_type = 'vector' |
| val = value[12:-1].strip() |
| self.result_value = [self._get_basic(val)] |
| self.result_value[0]['vector_type'] = val |
| return True |
| |
| # check for maps |
| if value.find('std::map') == 0: |
| self.result_type = 'map' |
| vals = value[9:-1].split(',') |
| if len(vals) == 2: |
| self.result_value = [ |
| self._get_basic(vals[0].strip()), |
| self._get_basic(vals[1].strip()) |
| ] |
| return True |
| |
| # check for multimaps |
| if value.find('std::multimap') == 0: |
| self.result_type = 'multimap' |
| vals = value[14:-1].split(',') |
| if len(vals) == 2: |
| self.result_value = [ |
| self._get_basic(vals[0].strip()), |
| self._get_basic(vals[1].strip()) |
| ] |
| return True |
| |
| # check for basic types |
| basic = self._get_basic(value) |
| if not basic is None: |
| self.result_type = basic['result_type'] |
| self.result_value = basic['result_value'] |
| if 'ptr_type' in basic: |
| self.ptr_type = basic['ptr_type'] |
| if 'result_default' in basic: |
| self.result_default = basic['result_default'] |
| return True |
| |
| return False |
| |
| def _get_basic(self, value): |
| # check for string values |
| if value == "CefString": |
| return {'result_type': 'string', 'result_value': None} |
| |
| # check for simple direct translations |
| if value in _simpletypes.keys(): |
| return { |
| 'result_type': 'simple', |
| 'result_value': _simpletypes[value][0], |
| 'result_default': _simpletypes[value][1], |
| } |
| |
| # check if already a C API structure |
| if value[-2:] == '_t': |
| return {'result_type': 'structure', 'result_value': value} |
| |
| # check for CEF reference pointers |
| p = re.compile('^CefRefPtr<(.*?)>$', re.DOTALL) |
| list = p.findall(value) |
| if len(list) == 1: |
| return { |
| 'result_type': 'refptr', |
| 'result_value': get_capi_name(list[0], True) + '*', |
| 'ptr_type': list[0] |
| } |
| |
| # check for CEF owned pointers |
| p = re.compile('^CefOwnPtr<(.*?)>$', re.DOTALL) |
| list = p.findall(value) |
| if len(list) == 1: |
| return { |
| 'result_type': 'ownptr', |
| 'result_value': get_capi_name(list[0], True) + '*', |
| 'ptr_type': list[0] |
| } |
| |
| # check for CEF raw pointers |
| p = re.compile('^CefRawPtr<(.*?)>$', re.DOTALL) |
| list = p.findall(value) |
| if len(list) == 1: |
| return { |
| 'result_type': 'rawptr', |
| 'result_value': get_capi_name(list[0], True) + '*', |
| 'ptr_type': list[0] |
| } |
| |
| # check for CEF structure types |
| if value[0:3] == 'Cef' and value[-4:] != 'List': |
| return { |
| 'result_type': 'structure', |
| 'result_value': get_capi_name(value, True) |
| } |
| |
| return None |
| |
| def __repr__(self): |
| return '(' + self.result_type + ') ' + str(self.result_value) |
| |
| def has_name(self): |
| """ Returns true if a name value exists. """ |
| return (not self.name is None) |
| |
| def get_name(self): |
| """ Return the name. """ |
| return self.name |
| |
| def get_value(self): |
| """ Return the C++ value (type + name). """ |
| return self.value |
| |
| def get_type(self): |
| """ Return the C++ type. """ |
| return self.type |
| |
| def get_ptr_type(self): |
| """ Return the C++ class type referenced by a CefRefPtr. """ |
| if self.is_result_vector() and self.is_result_vector_ptr(): |
| # return the vector RefPtr type |
| return self.result_value[0]['ptr_type'] |
| # return the basic RefPtr type |
| return self.ptr_type |
| |
| def get_vector_type(self): |
| """ Return the C++ class type referenced by a std::vector. """ |
| if self.is_result_vector(): |
| return self.result_value[0]['vector_type'] |
| return None |
| |
| def is_const(self): |
| """ Returns true if the argument value is constant. """ |
| return self.isconst |
| |
| def is_byref(self): |
| """ Returns true if the argument is passed by reference. """ |
| return self.isbyref |
| |
| def is_byaddr(self): |
| """ Returns true if the argument is passed by address. """ |
| return self.isbyaddr |
| |
| def is_result_simple(self): |
| """ Returns true if this is a simple argument type. """ |
| return (self.result_type == 'simple') |
| |
| def get_result_simple_type_root(self): |
| """ Return the simple structure or basic type name. """ |
| return self.result_value |
| |
| def get_result_simple_type(self): |
| """ Return the simple type. """ |
| result = '' |
| if self.is_const(): |
| result += 'const ' |
| result += self.result_value |
| if self.is_byaddr() or self.is_byref(): |
| result += '*' |
| return result |
| |
| def get_result_simple_default(self): |
| """ Return the default value fo the basic type. """ |
| return self.result_default |
| |
| def is_result_ptr(self): |
| """ Returns true if this is a *Ptr type. """ |
| return self.is_result_refptr() or self.is_result_ownptr() or \ |
| self.is_result_rawptr() |
| |
| def get_result_ptr_type_root(self): |
| """ Return the *Ptr type structure name. """ |
| return self.result_value[:-1] |
| |
| def get_result_ptr_type(self, defined_structs=[]): |
| """ Return the *Ptr type. """ |
| result = '' |
| if not self.result_value[:-1] in defined_structs: |
| result += 'struct _' |
| result += self.result_value |
| if self.is_byref() or self.is_byaddr(): |
| result += '*' |
| return result |
| |
| def get_result_ptr_type_prefix(self): |
| """ Returns the *Ptr type prefix. """ |
| if self.is_result_refptr(): |
| return 'ref' |
| if self.is_result_ownptr(): |
| return 'own' |
| if self.is_result_rawptr(): |
| return 'raw' |
| raise Exception('Not a pointer type') |
| |
| def is_result_refptr(self): |
| """ Returns true if this is a RefPtr type. """ |
| return (self.result_type == 'refptr') |
| |
| def is_result_ownptr(self): |
| """ Returns true if this is a OwnPtr type. """ |
| return (self.result_type == 'ownptr') |
| |
| def is_result_rawptr(self): |
| """ Returns true if this is a RawPtr type. """ |
| return (self.result_type == 'rawptr') |
| |
| def is_result_struct(self): |
| """ Returns true if this is a structure type. """ |
| return (self.result_type == 'structure') |
| |
| def is_result_struct_enum(self): |
| """ Returns true if this struct type is likely an enumeration. """ |
| # structure values that are passed by reference or address must be |
| # structures and not enumerations |
| if not self.is_byref() and not self.is_byaddr(): |
| return True |
| return False |
| |
| def get_result_struct_type(self, defined_structs=[]): |
| """ Return the structure or enumeration type. """ |
| result = '' |
| is_enum = self.is_result_struct_enum() |
| if not is_enum: |
| if self.is_const(): |
| result += 'const ' |
| if not self.result_value in defined_structs: |
| result += 'struct _' |
| result += self.result_value |
| if not is_enum: |
| result += '*' |
| return result |
| |
| def is_result_string(self): |
| """ Returns true if this is a string type. """ |
| return (self.result_type == 'string') |
| |
| def get_result_string_type(self): |
| """ Return the string type. """ |
| if not self.has_name(): |
| # Return values are string structs that the user must free. Use |
| # the name of the structure as a hint. |
| return 'cef_string_userfree_t' |
| elif not self.is_const() and (self.is_byref() or self.is_byaddr()): |
| # Parameters passed by reference or address. Use the normal |
| # non-const string struct. |
| return 'cef_string_t*' |
| # Const parameters use the const string struct. |
| return 'const cef_string_t*' |
| |
| def is_result_vector(self): |
| """ Returns true if this is a vector type. """ |
| return (self.result_type == 'vector') |
| |
| def is_result_vector_string(self): |
| """ Returns true if this is a string vector. """ |
| return self.result_value[0]['result_type'] == 'string' |
| |
| def is_result_vector_simple(self): |
| """ Returns true if this is a string vector. """ |
| return self.result_value[0]['result_type'] == 'simple' |
| |
| def is_result_vector_ptr(self): |
| """ Returns true if this is a *Ptr vector. """ |
| return self.is_result_vector_refptr() or \ |
| self.is_result_vector_ownptr() or \ |
| self.is_result_vector_rawptr() |
| |
| def get_result_vector_ptr_type_prefix(self): |
| """ Returns the *Ptr type prefix. """ |
| if self.is_result_vector_refptr(): |
| return 'ref' |
| if self.is_result_vector_ownptr(): |
| return 'own' |
| if self.is_result_vector_rawptr(): |
| return 'raw' |
| raise Exception('Not a pointer type') |
| |
| def is_result_vector_refptr(self): |
| """ Returns true if this is a RefPtr vector. """ |
| return self.result_value[0]['result_type'] == 'refptr' |
| |
| def is_result_vector_ownptr(self): |
| """ Returns true if this is a OwnPtr vector. """ |
| return self.result_value[0]['result_type'] == 'ownptr' |
| |
| def is_result_vector_rawptr(self): |
| """ Returns true if this is a RawPtr vector. """ |
| return self.result_value[0]['result_type'] == 'rawptr' |
| |
| def get_result_vector_type_root(self): |
| """ Return the vector structure or basic type name. """ |
| return self.result_value[0]['result_value'] |
| |
| def get_result_vector_type(self, defined_structs=[]): |
| """ Return the vector type. """ |
| if not self.has_name(): |
| raise Exception('Cannot use vector as a return type') |
| |
| type = self.result_value[0]['result_type'] |
| value = self.result_value[0]['result_value'] |
| |
| result = {} |
| if type == 'string': |
| result['value'] = 'cef_string_list_t' |
| result['format'] = 'single' |
| return result |
| |
| if type == 'simple': |
| str = value |
| if self.is_const(): |
| str += ' const' |
| str += '*' |
| result['value'] = str |
| elif type == 'refptr' or type == 'ownptr' or type == 'rawptr': |
| str = '' |
| if not value[:-1] in defined_structs: |
| str += 'struct _' |
| str += value |
| if self.is_const(): |
| str += ' const' |
| str += '*' |
| result['value'] = str |
| else: |
| raise Exception('Unsupported vector type: ' + type) |
| |
| # vector values must be passed as a value array parameter |
| # and a size parameter |
| result['format'] = 'multi-arg' |
| return result |
| |
| def is_result_map(self): |
| """ Returns true if this is a map type. """ |
| return (self.result_type == 'map' or self.result_type == 'multimap') |
| |
| def is_result_map_single(self): |
| """ Returns true if this is a single map type. """ |
| return (self.result_type == 'map') |
| |
| def is_result_map_multi(self): |
| """ Returns true if this is a multi map type. """ |
| return (self.result_type == 'multimap') |
| |
| def get_result_map_type(self, defined_structs=[]): |
| """ Return the map type. """ |
| if not self.has_name(): |
| raise Exception('Cannot use map as a return type') |
| if self.result_value[0]['result_type'] == 'string' \ |
| and self.result_value[1]['result_type'] == 'string': |
| if self.result_type == 'map': |
| return {'value': 'cef_string_map_t', 'format': 'single'} |
| elif self.result_type == 'multimap': |
| return {'value': 'cef_string_multimap_t', 'format': 'multi'} |
| raise Exception('Only mappings of strings to strings are supported') |
| |
| def get_capi(self, defined_structs=[]): |
| """ Format the value for the C API. """ |
| result = '' |
| format = 'single' |
| if self.is_result_simple(): |
| result += self.get_result_simple_type() |
| elif self.is_result_ptr(): |
| result += self.get_result_ptr_type(defined_structs) |
| elif self.is_result_struct(): |
| result += self.get_result_struct_type(defined_structs) |
| elif self.is_result_string(): |
| result += self.get_result_string_type() |
| elif self.is_result_map(): |
| resdict = self.get_result_map_type(defined_structs) |
| if resdict['format'] == 'single' or resdict['format'] == 'multi': |
| result += resdict['value'] |
| else: |
| raise Exception('Unsupported map type') |
| elif self.is_result_vector(): |
| resdict = self.get_result_vector_type(defined_structs) |
| if resdict['format'] != 'single': |
| format = resdict['format'] |
| result += resdict['value'] |
| |
| if self.has_name(): |
| result += ' ' + self.get_name() |
| |
| return {'format': format, 'value': result} |
| |
| |
| # test the module |
| if __name__ == "__main__": |
| import pprint |
| import sys |
| |
| # verify that the correct number of command-line arguments are provided |
| if len(sys.argv) != 2: |
| sys.stderr.write('Usage: ' + sys.argv[0] + ' <directory>') |
| sys.exit() |
| |
| pp = pprint.PrettyPrinter(indent=4) |
| |
| # create the header object |
| header = obj_header() |
| header.add_directory(sys.argv[1]) |
| |
| # output the type mapping |
| types = {} |
| header.get_types(types) |
| pp.pprint(types) |
| sys.stdout.write('\n') |
| |
| # output the parsed C++ data |
| sys.stdout.write(str(header)) |
| |
| # output the C API formatted data |
| defined_names = header.get_defined_structs() |
| result = '' |
| |
| # global functions |
| funcs = header.get_funcs() |
| if len(funcs) > 0: |
| for func in funcs: |
| result += func.get_capi_proto(defined_names) + ';\n' |
| result += '\n' |
| |
| classes = header.get_classes() |
| for cls in classes: |
| # virtual functions are inside a structure |
| result += 'struct ' + cls.get_capi_name() + '\n{\n' |
| funcs = cls.get_virtual_funcs() |
| if len(funcs) > 0: |
| for func in funcs: |
| result += '\t' + func.get_capi_proto(defined_names) + ';\n' |
| result += '}\n\n' |
| |
| defined_names.append(cls.get_capi_name()) |
| |
| # static functions become global |
| funcs = cls.get_static_funcs() |
| if len(funcs) > 0: |
| for func in funcs: |
| result += func.get_capi_proto(defined_names) + ';\n' |
| result += '\n' |
| sys.stdout.write(result) |
