← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to third_party/CppHeaderParser/PKG-INFO

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
third_party/CppHeaderParser/PKG-INFO
 
1
Metadata-Version: 1.1
 
2
Name: CppHeaderParser
 
3
Version: 1.9
 
4
Summary: Parse C++ header files and generate a data structure representing the class
 
5
Home-page: http://sourceforge.net/projects/cppheaderparser/
 
6
Author: Jashua Cloutier
 
7
Author-email: jashuac@bellsouth.net
 
8
License: BSD
 
9
Description: Python package "CppHeaderParser"
 
10
        --------------------------------
 
11
        **Purpose:** Parse C++ header files and generate a data structure representing the class
 
12
        
 
13
        **Author:** Jashua Cloutier (jashuac@bellsouth.net)
 
14
        
 
15
        **Licence:** BSD
 
16
        
 
17
        **External modules required:** PLY
 
18
        
 
19
        **Quick start**::
 
20
        
 
21
            #include <vector>
 
22
            #include <string>
 
23
            using namespace std;
 
24
            class SampleClass
 
25
            {
 
26
            public:
 
27
                SampleClass();
 
28
                /*!
 
29
                 * Method 1
 
30
                 */
 
31
                string meth1();
 
32
            
 
33
                ///
 
34
                /// Method 2 description
 
35
                ///
 
36
                /// @param v1 Variable 1
 
37
                ///
 
38
                int meth2(int v1);
 
39
            
 
40
                /**
 
41
                 * Method 3 description
 
42
                 *
 
43
                 * \param v1 Variable 1
 
44
                 * \param v2 Variable 2
 
45
                 */
 
46
                void meth3(const string & v1, vector<string> & v2);
 
47
            
 
48
                /**********************************
 
49
                 * Method 4 description
 
50
                 *
 
51
                 * @return Return value
 
52
                 *********************************/
 
53
                unsigned int meth4();
 
54
            private:
 
55
                void * meth5(){return NULL};
 
56
            
 
57
                /// prop1 description
 
58
                string prop1;
 
59
                //! prop5 description
 
60
                int prop5;
 
61
            };
 
62
            namespace Alpha
 
63
            {
 
64
                class AlphaClass
 
65
                {
 
66
                public:
 
67
                    AlphaClass();
 
68
            
 
69
                    void alphaMethod();
 
70
            
 
71
                    string alphaString;
 
72
                };
 
73
            
 
74
                namespace Omega
 
75
                {
 
76
                    class OmegaClass
 
77
                    {
 
78
                    public:
 
79
                        OmegaClass();
 
80
            
 
81
                        string omegaString;
 
82
                    };
 
83
                };
 
84
            }
 
85
            
 
86
        
 
87
        **Python code**::
 
88
        
 
89
            #!/usr/bin/python
 
90
            import sys
 
91
            sys.path = ["../"] + sys.path
 
92
            import CppHeaderParser
 
93
            try:
 
94
                cppHeader = CppHeaderParser.CppHeader("SampleClass.h")
 
95
            except CppHeaderParser.CppParseError,  e:
 
96
                print e
 
97
                sys.exit(1)
 
98
            
 
99
            print "CppHeaderParser view of %s"%cppHeader
 
100
            
 
101
            sampleClass = cppHeader.classes["SampleClass"]
 
102
            print "Number of public methods %d"%(len(sampleClass["methods"]["public"]))
 
103
            print "Number of private properties %d"%(len(sampleClass["properties"]["private"]))
 
104
            meth3 = [m for m in sampleClass["methods"]["public"] if m["name"] == "meth3"][0] #get meth3
 
105
            meth3ParamTypes = [t["type"] for t in meth3["parameters"]] #get meth3s parameters
 
106
            print "Parameter Types for public method meth3 %s"%(meth3ParamTypes)
 
107
            
 
108
            print "\nReturn type for meth1:"
 
109
            print cppHeader.classes["SampleClass"]["methods"]["public"][1]["rtnType"]
 
110
            
 
111
            print "\nDoxygen for meth2:"
 
112
            print cppHeader.classes["SampleClass"]["methods"]["public"][2]["doxygen"]
 
113
            
 
114
            print "\nParameters for meth3:"
 
115
            print cppHeader.classes["SampleClass"]["methods"]["public"][3]["parameters"]
 
116
            
 
117
            print "\nDoxygen for meth4:"
 
118
            print cppHeader.classes["SampleClass"]["methods"]["public"][4]["doxygen"]
 
119
            
 
120
            print "\nReturn type for meth5:"
 
121
            print cppHeader.classes["SampleClass"]["methods"]["private"][0]["rtnType"]
 
122
            
 
123
            print "\nDoxygen type for prop1:"
 
124
            print cppHeader.classes["SampleClass"]["properties"]["private"][0]["doxygen"]
 
125
            
 
126
            print "\nType for prop5:"
 
127
            print cppHeader.classes["SampleClass"]["properties"]["private"][1]["type"]
 
128
            
 
129
            print "\nNamespace for AlphaClass is:"
 
130
            print cppHeader.classes["AlphaClass"]["namespace"]
 
131
            
 
132
            print "\nReturn type for alphaMethod is:"
 
133
            print cppHeader.classes["AlphaClass"]["methods"]["public"][0]["rtnType"]
 
134
            
 
135
            print "\nNamespace for OmegaClass is:"
 
136
            print cppHeader.classes["OmegaClass"]["namespace"]
 
137
            
 
138
            print "\nType for omegaString is:"
 
139
            print cppHeader.classes["AlphaClass"]["properties"]["public"][0]["type"]
 
140
        
 
141
        **Output**::
 
142
        
 
143
            CppHeaderParser view of class SampleClass
 
144
            Inherits: 
 
145
            {
 
146
            public
 
147
                // Method
 
148
                {'name': 'SampleClass', 'parameters': [], 'rtnType': 'void'}
 
149
                {'doxygen': '/*!\n* Method 1\n*/', 'name': 'meth1', 'parameters': [], 'rtnType': 'string'}
 
150
                {'doxygen': '///\n/// Method 2 description\n///\n/// @param v1 Variable 1\n///', 'name': 'meth2', 'parameters': [{'type': 'int', 'name': 'v1', 'desc': 'Variable 1'}], 'rtnType': 'int'}
 
151
                {'doxygen': '/**\n* Method 3 description\n*\n* \\param v1 Variable 1\n* \\param v2 Variable 2\n*/', 'name': 'meth3', 'parameters': [{'type': 'const string &', 'name': 'v1', 'desc': 'Variable 1'}, {'type': 'vector<string> &', 'name': 'v2', 'desc': 'Variable 2'}], 'rtnType': 'void'}
 
152
                {'doxygen': '/**********************************\n* Method 4 description\n*\n* @return Return value\n*********************************/', 'name': 'meth4', 'parameters': [], 'rtnType': 'unsigned int'}
 
153
            protected
 
154
            private
 
155
                // Properties
 
156
                {'doxygen': '/// prop1 description', 'type': 'string', 'name': 'prop1'}
 
157
                {'doxygen': '//! prop5 description', 'type': 'int', 'name': 'prop5'}
 
158
                // Method
 
159
                {'name': 'meth5', 'parameters': [], 'rtnType': 'void *'}
 
160
            }
 
161
            class Alpha::AlphaClass
 
162
            Inherits: 
 
163
            {
 
164
            public
 
165
                // Properties
 
166
                {'type': 'string', 'name': 'alphaString'}
 
167
                // Method
 
168
                {'name': 'AlphaClass', 'parameters': [], 'rtnType': 'void'}
 
169
                {'name': 'alphaMethod', 'parameters': [], 'rtnType': 'void'}
 
170
            protected
 
171
            private
 
172
            }
 
173
            class Alpha::Omega::OmegaClass
 
174
            Inherits: 
 
175
            {
 
176
            public
 
177
                // Properties
 
178
                {'type': 'string', 'name': 'omegaString'}
 
179
                // Method
 
180
                {'name': 'OmegaClass', 'parameters': [], 'rtnType': 'void'}
 
181
            protected
 
182
            private
 
183
            }
 
184
            
 
185
            Number of public methods 5
 
186
            Number of private properties 2
 
187
            Parameter Types for public method meth3 ['const string &', 'vector<string> &']
 
188
            
 
189
            Return type for meth1:
 
190
            string
 
191
            
 
192
            Doxygen for meth2:
 
193
            ///
 
194
            /// Method 2 description
 
195
            ///
 
196
            /// @param v1 Variable 1
 
197
            ///
 
198
            
 
199
            Parameters for meth3:
 
200
            [{'type': 'const string &', 'name': 'v1', 'desc': 'Variable 1'}, {'type': 'vector<string> &', 'name': 'v2', 'desc': 'Variable 2'}]
 
201
            
 
202
            Doxygen for meth4:
 
203
            /**********************************
 
204
            * Method 4 description
 
205
            *
 
206
            * @return Return value
 
207
            *********************************/
 
208
            
 
209
            Return type for meth5:
 
210
            void *
 
211
            
 
212
            Doxygen type for prop1:
 
213
            /// prop1 description
 
214
            
 
215
            Type for prop5:
 
216
            int
 
217
            
 
218
            Namespace for AlphaClass is:
 
219
            Alpha
 
220
            
 
221
            Return type for alphaMethod is:
 
222
            void
 
223
            
 
224
            Namespace for OmegaClass is:
 
225
            Alpha::Omega
 
226
            
 
227
            Type for omegaString is:
 
228
            string
 
229
            
 
230
        
 
231
        
 
232
        Contributors
 
233
        ------------
 
234
        Chris Love
 
235
Keywords: c++ header parser ply
 
236
Platform: Platform Independent
 
237
Classifier: Operating System :: OS Independent
 
238
Classifier: Programming Language :: Python
 
239
Classifier: Programming Language :: Python :: 2
 
240
Classifier: Programming Language :: Python :: 3
 
241
Classifier: Programming Language :: C++
 
242
Classifier: License :: OSI Approved :: BSD License
 
243
Classifier: Development Status :: 5 - Production/Stable
 
244
Classifier: Intended Audience :: Developers
 
245
Classifier: Topic :: Software Development
 
246
Classifier: Topic :: Software Development :: Code Generators
 
247
Classifier: Topic :: Software Development :: Compilers
 
248
Classifier: Topic :: Software Development :: Disassemblers
 
249
Requires: ply