Start to share SWIG interface files between languages.

Summary:
Move scripts/Python/interface to scripts/interface so that we
can start making iterative improvements towards sharing the
interface files between multiple languages (each of which would
have their own directory as now).

Test Plan: Build and see.

Reviewers: zturner, emaste, clayborg

Reviewed By: clayborg

Subscribers: mjsabby, lldb-commits

Differential Revision: http://reviews.llvm.org/D9212

llvm-svn: 235676

1 files changed, 0 insertions, 530 deletions

diff --git a/lldb/scripts/Python/interface/SBModule.i b/lldb/scripts/Python/interface/SBModule.i
deleted file mode 100644
index 43aab6a6b4c..00000000000
--- a/lldb/scripts/Python/interface/SBModule.i
+++ /dev/null
@@ -1,530 +0,0 @@
-//===-- SWIG Interface for SBModule -----------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-namespace lldb {
-
-%feature("docstring",
-"Represents an executable image and its associated object and symbol files.
-
-The module is designed to be able to select a single slice of an
-executable image as it would appear on disk and during program
-execution.
-
-You can retrieve SBModule from SBSymbolContext, which in turn is available
-from SBFrame.
-
-SBModule supports symbol iteration, for example,
-
-    for symbol in module:
-        name = symbol.GetName()
-        saddr = symbol.GetStartAddress()
-        eaddr = symbol.GetEndAddress()
-
-and rich comparion methods which allow the API program to use,
-
-    if thisModule == thatModule:
-        print 'This module is the same as that module'
-
-to test module equality.  A module also contains object file sections, namely
-SBSection.  SBModule supports section iteration through section_iter(), for
-example,
-
-    print 'Number of sections: %d' % module.GetNumSections()
-    for sec in module.section_iter():
-        print sec
-
-And to iterate the symbols within a SBSection, use symbol_in_section_iter(),
-
-    # Iterates the text section and prints each symbols within each sub-section.
-    for subsec in text_sec:
-        print INDENT + repr(subsec)
-        for sym in exe_module.symbol_in_section_iter(subsec):
-            print INDENT2 + repr(sym)
-            print INDENT2 + 'symbol type: %s' % symbol_type_to_str(sym.GetType())
-
-produces this following output:
-
-    [0x0000000100001780-0x0000000100001d5c) a.out.__TEXT.__text
-        id = {0x00000004}, name = 'mask_access(MaskAction, unsigned int)', range = [0x00000001000017c0-0x0000000100001870)
-        symbol type: code
-        id = {0x00000008}, name = 'thread_func(void*)', range = [0x0000000100001870-0x00000001000019b0)
-        symbol type: code
-        id = {0x0000000c}, name = 'main', range = [0x00000001000019b0-0x0000000100001d5c)
-        symbol type: code
-        id = {0x00000023}, name = 'start', address = 0x0000000100001780
-        symbol type: code
-    [0x0000000100001d5c-0x0000000100001da4) a.out.__TEXT.__stubs
-        id = {0x00000024}, name = '__stack_chk_fail', range = [0x0000000100001d5c-0x0000000100001d62)
-        symbol type: trampoline
-        id = {0x00000028}, name = 'exit', range = [0x0000000100001d62-0x0000000100001d68)
-        symbol type: trampoline
-        id = {0x00000029}, name = 'fflush', range = [0x0000000100001d68-0x0000000100001d6e)
-        symbol type: trampoline
-        id = {0x0000002a}, name = 'fgets', range = [0x0000000100001d6e-0x0000000100001d74)
-        symbol type: trampoline
-        id = {0x0000002b}, name = 'printf', range = [0x0000000100001d74-0x0000000100001d7a)
-        symbol type: trampoline
-        id = {0x0000002c}, name = 'pthread_create', range = [0x0000000100001d7a-0x0000000100001d80)
-        symbol type: trampoline
-        id = {0x0000002d}, name = 'pthread_join', range = [0x0000000100001d80-0x0000000100001d86)
-        symbol type: trampoline
-        id = {0x0000002e}, name = 'pthread_mutex_lock', range = [0x0000000100001d86-0x0000000100001d8c)
-        symbol type: trampoline
-        id = {0x0000002f}, name = 'pthread_mutex_unlock', range = [0x0000000100001d8c-0x0000000100001d92)
-        symbol type: trampoline
-        id = {0x00000030}, name = 'rand', range = [0x0000000100001d92-0x0000000100001d98)
-        symbol type: trampoline
-        id = {0x00000031}, name = 'strtoul', range = [0x0000000100001d98-0x0000000100001d9e)
-        symbol type: trampoline
-        id = {0x00000032}, name = 'usleep', range = [0x0000000100001d9e-0x0000000100001da4)
-        symbol type: trampoline
-    [0x0000000100001da4-0x0000000100001e2c) a.out.__TEXT.__stub_helper
-    [0x0000000100001e2c-0x0000000100001f10) a.out.__TEXT.__cstring
-    [0x0000000100001f10-0x0000000100001f68) a.out.__TEXT.__unwind_info
-    [0x0000000100001f68-0x0000000100001ff8) a.out.__TEXT.__eh_frame
-"
-) SBModule;
-class SBModule
-{
-public:
-
-    SBModule ();
-
-    SBModule (const lldb::SBModule &rhs);
-     
-    SBModule (const lldb::SBModuleSpec &module_spec);
-    
-    SBModule (lldb::SBProcess &process, 
-              lldb::addr_t header_addr);
-
-    ~SBModule ();
-
-    bool
-    IsValid () const;
-
-    void
-    Clear();
-
-    %feature("docstring", "
-    //------------------------------------------------------------------
-    /// Get const accessor for the module file specification.
-    ///
-    /// This function returns the file for the module on the host system
-    /// that is running LLDB. This can differ from the path on the 
-    /// platform since we might be doing remote debugging.
-    ///
-    /// @return
-    ///     A const reference to the file specification object.
-    //------------------------------------------------------------------
-    ") GetFileSpec;
-    lldb::SBFileSpec
-    GetFileSpec () const;
-
-    %feature("docstring", "
-    //------------------------------------------------------------------
-    /// Get accessor for the module platform file specification.
-    ///
-    /// Platform file refers to the path of the module as it is known on
-    /// the remote system on which it is being debugged. For local 
-    /// debugging this is always the same as Module::GetFileSpec(). But
-    /// remote debugging might mention a file '/usr/lib/liba.dylib'
-    /// which might be locally downloaded and cached. In this case the
-    /// platform file could be something like:
-    /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
-    /// The file could also be cached in a local developer kit directory.
-    ///
-    /// @return
-    ///     A const reference to the file specification object.
-    //------------------------------------------------------------------
-    ") GetPlatformFileSpec;
-    lldb::SBFileSpec
-    GetPlatformFileSpec () const;
-
-    bool
-    SetPlatformFileSpec (const lldb::SBFileSpec &platform_file);
-             
-    lldb::SBFileSpec
-    GetRemoteInstallFileSpec ();
-
-    bool
-    SetRemoteInstallFileSpec (lldb::SBFileSpec &file);
-
-    %feature("docstring", "Returns the UUID of the module as a Python string."
-    ) GetUUIDString;
-    const char *
-    GetUUIDString () const;
-
-    lldb::SBSection
-    FindSection (const char *sect_name);
-
-    lldb::SBAddress
-    ResolveFileAddress (lldb::addr_t vm_addr);
-
-    lldb::SBSymbolContext
-    ResolveSymbolContextForAddress (const lldb::SBAddress& addr, 
-                                    uint32_t resolve_scope);
-
-    bool
-    GetDescription (lldb::SBStream &description);
-
-    uint32_t
-    GetNumCompileUnits();
-
-    lldb::SBCompileUnit
-    GetCompileUnitAtIndex (uint32_t);
-
-    size_t
-    GetNumSymbols ();
-    
-    lldb::SBSymbol
-    GetSymbolAtIndex (size_t idx);
-
-    lldb::SBSymbol
-    FindSymbol (const char *name,
-                lldb::SymbolType type = eSymbolTypeAny);
-
-    lldb::SBSymbolContextList
-    FindSymbols (const char *name,
-                 lldb::SymbolType type = eSymbolTypeAny);
-             
-
-    size_t
-    GetNumSections ();
-
-    lldb::SBSection
-    GetSectionAtIndex (size_t idx);
-
-
-    %feature("docstring", "
-    //------------------------------------------------------------------
-    /// Find functions by name.
-    ///
-    /// @param[in] name
-    ///     The name of the function we are looking for.
-    ///
-    /// @param[in] name_type_mask
-    ///     A logical OR of one or more FunctionNameType enum bits that
-    ///     indicate what kind of names should be used when doing the
-    ///     lookup. Bits include fully qualified names, base names,
-    ///     C++ methods, or ObjC selectors. 
-    ///     See FunctionNameType for more details.
-    ///
-    /// @return
-    ///     A symbol context list that gets filled in with all of the
-    ///     matches.
-    //------------------------------------------------------------------
-    ") FindFunctions;
-    lldb::SBSymbolContextList
-    FindFunctions (const char *name, 
-                   uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
-    
-    lldb::SBType
-    FindFirstType (const char* name);
-
-    lldb::SBTypeList
-    FindTypes (const char* type);
-
-    lldb::SBType
-    GetTypeByID (lldb::user_id_t uid);
-
-    lldb::SBType
-    GetBasicType(lldb::BasicType type);
-
-    %feature("docstring", "
-    //------------------------------------------------------------------
-    /// Get all types matching \a type_mask from debug info in this
-    /// module.
-    ///
-    /// @param[in] type_mask
-    ///     A bitfield that consists of one or more bits logically OR'ed
-    ///     together from the lldb::TypeClass enumeration. This allows
-    ///     you to request only structure types, or only class, struct
-    ///     and union types. Passing in lldb::eTypeClassAny will return
-    ///     all types found in the debug information for this module.
-    ///
-    /// @return
-    ///     A list of types in this module that match \a type_mask
-    //------------------------------------------------------------------
-    ") GetTypes;
-    lldb::SBTypeList
-    GetTypes (uint32_t type_mask = lldb::eTypeClassAny);
-
-    %feature("docstring", "
-    //------------------------------------------------------------------
-    /// Find global and static variables by name.
-    ///
-    /// @param[in] target
-    ///     A valid SBTarget instance representing the debuggee.
-    ///
-    /// @param[in] name
-    ///     The name of the global or static variable we are looking
-    ///     for.
-    ///
-    /// @param[in] max_matches
-    ///     Allow the number of matches to be limited to \a max_matches.
-    ///
-    /// @return
-    ///     A list of matched variables in an SBValueList.
-    //------------------------------------------------------------------
-    ") FindGlobalVariables;
-    lldb::SBValueList
-    FindGlobalVariables (lldb::SBTarget &target, 
-                         const char *name, 
-                         uint32_t max_matches);
-    
-    %feature("docstring", "
-    //------------------------------------------------------------------
-    /// Find the first global (or static) variable by name.
-    ///
-    /// @param[in] target
-    ///     A valid SBTarget instance representing the debuggee.
-    ///
-    /// @param[in] name
-    ///     The name of the global or static variable we are looking
-    ///     for.
-    ///
-    /// @return
-    ///     An SBValue that gets filled in with the found variable (if any).
-    //------------------------------------------------------------------
-    ") FindFirstGlobalVariable;
-    lldb::SBValue
-    FindFirstGlobalVariable (lldb::SBTarget &target, const char *name);
-             
-    lldb::ByteOrder
-    GetByteOrder ();
-    
-    uint32_t
-    GetAddressByteSize();
-    
-    const char *
-    GetTriple ();
-    
-    uint32_t
-    GetVersion (uint32_t *versions, 
-                uint32_t num_versions);
-
-    lldb::SBFileSpec
-    GetSymbolFileSpec() const;
-
-    lldb::SBAddress
-    GetObjectFileHeaderAddress() const;
-
-    bool
-    operator == (const lldb::SBModule &rhs) const;
-             
-    bool
-    operator != (const lldb::SBModule &rhs) const;
-             
-    %pythoncode %{
-        class symbols_access(object):
-            re_compile_type = type(re.compile('.'))
-            '''A helper object that will lazily hand out lldb.SBSymbol objects for a module when supplied an index, name, or regular expression.'''
-            def __init__(self, sbmodule):
-                self.sbmodule = sbmodule
-        
-            def __len__(self):
-                if self.sbmodule:
-                    return int(self.sbmodule.GetNumSymbols())
-                return 0
-        
-            def __getitem__(self, key):
-                count = len(self)
-                if type(key) is int:
-                    if key < count:
-                        return self.sbmodule.GetSymbolAtIndex(key)
-                elif type(key) is str:
-                    matches = []
-                    sc_list = self.sbmodule.FindSymbols(key)
-                    for sc in sc_list:
-                        symbol = sc.symbol
-                        if symbol:
-                            matches.append(symbol)
-                    return matches
-                elif isinstance(key, self.re_compile_type):
-                    matches = []
-                    for idx in range(count):
-                        symbol = self.sbmodule.GetSymbolAtIndex(idx)
-                        added = False
-                        name = symbol.name
-                        if name:
-                            re_match = key.search(name)
-                            if re_match:
-                                matches.append(symbol)
-                                added = True
-                        if not added:
-                            mangled = symbol.mangled
-                            if mangled:
-                                re_match = key.search(mangled)
-                                if re_match:
-                                    matches.append(symbol)
-                    return matches
-                else:
-                    print "error: unsupported item type: %s" % type(key)
-                return None
-        
-        def get_symbols_access_object(self):
-            '''An accessor function that returns a symbols_access() object which allows lazy symbol access from a lldb.SBModule object.'''
-            return self.symbols_access (self)
-        
-        def get_compile_units_access_object (self):
-            '''An accessor function that returns a compile_units_access() object which allows lazy compile unit access from a lldb.SBModule object.'''
-            return self.compile_units_access (self)
-        
-        def get_symbols_array(self):
-            '''An accessor function that returns a list() that contains all symbols in a lldb.SBModule object.'''
-            symbols = []
-            for idx in range(self.num_symbols):
-                symbols.append(self.GetSymbolAtIndex(idx))
-            return symbols
-
-        class sections_access(object):
-            re_compile_type = type(re.compile('.'))
-            '''A helper object that will lazily hand out lldb.SBSection objects for a module when supplied an index, name, or regular expression.'''
-            def __init__(self, sbmodule):
-                self.sbmodule = sbmodule
-        
-            def __len__(self):
-                if self.sbmodule:
-                    return int(self.sbmodule.GetNumSections())
-                return 0
-        
-            def __getitem__(self, key):
-                count = len(self)
-                if type(key) is int:
-                    if key < count:
-                        return self.sbmodule.GetSectionAtIndex(key)
-                elif type(key) is str:
-                    for idx in range(count):
-                        section = self.sbmodule.GetSectionAtIndex(idx)
-                        if section.name == key:
-                            return section
-                elif isinstance(key, self.re_compile_type):
-                    matches = []
-                    for idx in range(count):
-                        section = self.sbmodule.GetSectionAtIndex(idx)
-                        name = section.name
-                        if name:
-                            re_match = key.search(name)
-                            if re_match:
-                                matches.append(section)
-                    return matches
-                else:
-                    print "error: unsupported item type: %s" % type(key)
-                return None
-
-        class compile_units_access(object):
-            re_compile_type = type(re.compile('.'))
-            '''A helper object that will lazily hand out lldb.SBCompileUnit objects for a module when supplied an index, full or partial path, or regular expression.'''
-            def __init__(self, sbmodule):
-                self.sbmodule = sbmodule
-        
-            def __len__(self):
-                if self.sbmodule:
-                    return int(self.sbmodule.GetNumCompileUnits())
-                return 0
-        
-            def __getitem__(self, key):
-                count = len(self)
-                if type(key) is int:
-                    if key < count:
-                        return self.sbmodule.GetCompileUnitAtIndex(key)
-                elif type(key) is str:
-                    is_full_path = key[0] == '/'
-                    for idx in range(count):
-                        comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx)
-                        if is_full_path:
-                            if comp_unit.file.fullpath == key:
-                                return comp_unit
-                        else:
-                            if comp_unit.file.basename == key:
-                                return comp_unit
-                elif isinstance(key, self.re_compile_type):
-                    matches = []
-                    for idx in range(count):
-                        comp_unit = self.sbmodule.GetCompileUnitAtIndex(idx)
-                        fullpath = comp_unit.file.fullpath
-                        if fullpath:
-                            re_match = key.search(fullpath)
-                            if re_match:
-                                matches.append(comp_unit)
-                    return matches
-                else:
-                    print "error: unsupported item type: %s" % type(key)
-                return None
-
-        def get_sections_access_object(self):
-            '''An accessor function that returns a sections_access() object which allows lazy section array access.'''
-            return self.sections_access (self)
-        
-        def get_sections_array(self):
-            '''An accessor function that returns an array object that contains all sections in this module object.'''
-            if not hasattr(self, 'sections_array'):
-                self.sections_array = []
-                for idx in range(self.num_sections):
-                    self.sections_array.append(self.GetSectionAtIndex(idx))
-            return self.sections_array
-
-        def get_compile_units_array(self):
-            '''An accessor function that returns an array object that contains all compile_units in this module object.'''
-            if not hasattr(self, 'compile_units_array'):
-                self.compile_units_array = []
-                for idx in range(self.GetNumCompileUnits()):
-                    self.compile_units_array.append(self.GetCompileUnitAtIndex(idx))
-            return self.compile_units_array
-
-        __swig_getmethods__["symbols"] = get_symbols_array
-        if _newclass: symbols = property(get_symbols_array, None, doc='''A read only property that returns a list() of lldb.SBSymbol objects contained in this module.''')
-
-        __swig_getmethods__["symbol"] = get_symbols_access_object
-        if _newclass: symbol = property(get_symbols_access_object, None, doc='''A read only property that can be used to access symbols by index ("symbol = module.symbol[0]"), name ("symbols = module.symbol['main']"), or using a regular expression ("symbols = module.symbol[re.compile(...)]"). The return value is a single lldb.SBSymbol object for array access, and a list() of lldb.SBSymbol objects for name and regular expression access''')
-
-        __swig_getmethods__["sections"] = get_sections_array
-        if _newclass: sections = property(get_sections_array, None, doc='''A read only property that returns a list() of lldb.SBSection objects contained in this module.''')
-
-        __swig_getmethods__["compile_units"] = get_compile_units_array
-        if _newclass: compile_units = property(get_compile_units_array, None, doc='''A read only property that returns a list() of lldb.SBCompileUnit objects contained in this module.''')
-
-        __swig_getmethods__["section"] = get_sections_access_object
-        if _newclass: section = property(get_sections_access_object, None, doc='''A read only property that can be used to access symbols by index ("section = module.section[0]"), name ("sections = module.section[\'main\']"), or using a regular expression ("sections = module.section[re.compile(...)]"). The return value is a single lldb.SBSection object for array access, and a list() of lldb.SBSection objects for name and regular expression access''')
-
-        __swig_getmethods__["compile_unit"] = get_compile_units_access_object
-        if _newclass: section = property(get_sections_access_object, None, doc='''A read only property that can be used to access compile units by index ("compile_unit = module.compile_unit[0]"), name ("compile_unit = module.compile_unit[\'main.cpp\']"), or using a regular expression ("compile_unit = module.compile_unit[re.compile(...)]"). The return value is a single lldb.SBCompileUnit object for array access or by full or partial path, and a list() of lldb.SBCompileUnit objects regular expressions.''')
-
-        def get_uuid(self):
-            return uuid.UUID (self.GetUUIDString())
-        
-        __swig_getmethods__["uuid"] = get_uuid
-        if _newclass: uuid = property(get_uuid, None, doc='''A read only property that returns a standard python uuid.UUID object that represents the UUID of this module.''')
-        
-        __swig_getmethods__["file"] = GetFileSpec
-        if _newclass: file = property(GetFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented where it is being debugged.''')
-        
-        __swig_getmethods__["platform_file"] = GetPlatformFileSpec
-        if _newclass: platform_file = property(GetPlatformFileSpec, None, doc='''A read only property that returns an lldb object that represents the file (lldb.SBFileSpec) for this object file for this module as it is represented on the current host system.''')
-        
-        __swig_getmethods__["byte_order"] = GetByteOrder
-        if _newclass: byte_order = property(GetByteOrder, None, doc='''A read only property that returns an lldb enumeration value (lldb.eByteOrderLittle, lldb.eByteOrderBig, lldb.eByteOrderInvalid) that represents the byte order for this module.''')
-        
-        __swig_getmethods__["addr_size"] = GetAddressByteSize
-        if _newclass: addr_size = property(GetAddressByteSize, None, doc='''A read only property that returns the size in bytes of an address for this module.''')
-        
-        __swig_getmethods__["triple"] = GetTriple
-        if _newclass: triple = property(GetTriple, None, doc='''A read only property that returns the target triple (arch-vendor-os) for this module.''')
-
-        __swig_getmethods__["num_symbols"] = GetNumSymbols
-        if _newclass: num_symbols = property(GetNumSymbols, None, doc='''A read only property that returns number of symbols in the module symbol table as an integer.''')
-        
-        __swig_getmethods__["num_sections"] = GetNumSections
-        if _newclass: num_sections = property(GetNumSections, None, doc='''A read only property that returns number of sections in the module as an integer.''')
-        
-    %}
-
-};
-
-} // namespace lldb