xref: /netbsd-src/external/apache2/llvm/dist/clang/utils/FindSpecRefs (revision 7330f729ccf0bd976a06f95fad452fe774fc7fd1)
1*7330f729Sjoerg#!/usr/bin/env python
2*7330f729Sjoerg
3*7330f729Sjoergimport os
4*7330f729Sjoergimport re
5*7330f729Sjoergimport time
6*7330f729Sjoergfrom pprint import pprint
7*7330f729Sjoerg
8*7330f729Sjoerg###
9*7330f729Sjoerg
10*7330f729Sjoergc99URL = 'http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf'
11*7330f729Sjoergc99TOC = [('Foreword', 'xi'),
12*7330f729Sjoerg('Introduction', 'xiv'),
13*7330f729Sjoerg('1. Scope', '1'),
14*7330f729Sjoerg('2. Normative references', '2'),
15*7330f729Sjoerg('3. Terms, definitions, and symbols', '3'),
16*7330f729Sjoerg('4. Conformance', '7'),
17*7330f729Sjoerg('5. Environment', '9'),
18*7330f729Sjoerg('5.1 Conceptual models', '9'),
19*7330f729Sjoerg('5.1.1 Translation environment', '9'),
20*7330f729Sjoerg('5.1.2 Execution environments', '11'),
21*7330f729Sjoerg('5.2 Environmental considerations', '17'),
22*7330f729Sjoerg('5.2.1 Character sets', '17'),
23*7330f729Sjoerg('5.2.2 Character display semantics', '19'),
24*7330f729Sjoerg('5.2.3 Signals and interrupts', '20'),
25*7330f729Sjoerg('5.2.4 Environmental limits', '20'),
26*7330f729Sjoerg('6. Language', '29'),
27*7330f729Sjoerg('6.1 Notation', '29'),
28*7330f729Sjoerg('6.2 Concepts', '29'),
29*7330f729Sjoerg('6.2.1 Scopes of identifiers', '29'),
30*7330f729Sjoerg('6.2.2 Linkages of identifiers', '30'),
31*7330f729Sjoerg('6.2.3 Name spaces of identifiers', '31'),
32*7330f729Sjoerg('6.2.4 Storage durations of objects', '32'),
33*7330f729Sjoerg('6.2.5 Types', '33'),
34*7330f729Sjoerg('6.2.6 Representations of types', '37'),
35*7330f729Sjoerg('6.2.7 Compatible type and composite type', '40'),
36*7330f729Sjoerg('6.3 Conversions', '42'),
37*7330f729Sjoerg('6.3.1 Arithmetic operands', '42'),
38*7330f729Sjoerg('6.3.2 Other operands', '46'),
39*7330f729Sjoerg('6.4 Lexical elements', '49'),
40*7330f729Sjoerg('6.4.1 Keywords', '50'),
41*7330f729Sjoerg('6.4.2 Identifiers', '51'),
42*7330f729Sjoerg('6.4.3 Universal character names', '53'),
43*7330f729Sjoerg('6.4.4 Constants', '54'),
44*7330f729Sjoerg('6.4.5 String literals', '62'),
45*7330f729Sjoerg('6.4.6 Punctuators', '63'),
46*7330f729Sjoerg('6.4.7 Header names', '64'),
47*7330f729Sjoerg('6.4.8 Preprocessing numbers', '65'),
48*7330f729Sjoerg('6.4.9 Comments', '66'),
49*7330f729Sjoerg('6.5 Expressions', '67'),
50*7330f729Sjoerg('6.5.1 Primary expressions', '69'),
51*7330f729Sjoerg('6.5.2 Postfix operators', '69'),
52*7330f729Sjoerg('6.5.3 Unary operators', '78'),
53*7330f729Sjoerg('6.5.4 Cast operators', '81'),
54*7330f729Sjoerg('6.5.5 Multiplicative operators', '82'),
55*7330f729Sjoerg('6.5.6 Additive operators', '82'),
56*7330f729Sjoerg('6.5.7 Bitwise shift operators', '84'),
57*7330f729Sjoerg('6.5.8 Relational operators', '85'),
58*7330f729Sjoerg('6.5.9 Equality operators', '86'),
59*7330f729Sjoerg('6.5.10 Bitwise AND operator', '87'),
60*7330f729Sjoerg('6.5.11 Bitwise exclusive OR operator', '88'),
61*7330f729Sjoerg('6.5.12 Bitwise inclusive OR operator', '88'),
62*7330f729Sjoerg('6.5.13 Logical AND operator', '89'),
63*7330f729Sjoerg('6.5.14 Logical OR operator', '89'),
64*7330f729Sjoerg('6.5.15 Conditional operator', '90'),
65*7330f729Sjoerg('6.5.16 Assignment operators', '91'),
66*7330f729Sjoerg('6.5.17 Comma operator', '94'),
67*7330f729Sjoerg('6.6 Constant expressions', '95'),
68*7330f729Sjoerg('6.7 Declarations', '97'),
69*7330f729Sjoerg('6.7.1 Storage-class specifiers', '98'),
70*7330f729Sjoerg('6.7.2 Type specifiers', '99'),
71*7330f729Sjoerg('6.7.3 Type qualifiers', '108'),
72*7330f729Sjoerg('6.7.4 Function specifiers', '112'),
73*7330f729Sjoerg('6.7.5 Declarators', '114'),
74*7330f729Sjoerg('6.7.6 Type names', '122'),
75*7330f729Sjoerg('6.7.7 Type definitions', '123'),
76*7330f729Sjoerg('6.7.8 Initialization', '125'),
77*7330f729Sjoerg('6.8 Statements and blocks', '131'),
78*7330f729Sjoerg('6.8.1 Labeled statements', '131'),
79*7330f729Sjoerg('6.8.2 Compound statement', '132'),
80*7330f729Sjoerg('6.8.3 Expression and null statements', '132'),
81*7330f729Sjoerg('6.8.4 Selection statements', '133'),
82*7330f729Sjoerg('6.8.5 Iteration statements', '135'),
83*7330f729Sjoerg('6.8.6 Jump statements', '136'),
84*7330f729Sjoerg('6.9 External definitions', '140'),
85*7330f729Sjoerg('6.9.1 Function definitions', '141'),
86*7330f729Sjoerg('6.9.2 External object definitions', '143'),
87*7330f729Sjoerg('6.10 Preprocessing directives', '145'),
88*7330f729Sjoerg('6.10.1 Conditional inclusion', '147'),
89*7330f729Sjoerg('6.10.2 Source file inclusion', '149'),
90*7330f729Sjoerg('6.10.3 Macro replacement', '151'),
91*7330f729Sjoerg('6.10.4 Line control', '158'),
92*7330f729Sjoerg('6.10.5 Error directive', '159'),
93*7330f729Sjoerg('6.10.6 Pragma directive', '159'),
94*7330f729Sjoerg('6.10.7 Null directive', '160'),
95*7330f729Sjoerg('6.10.8 Predefined macro names', '160'),
96*7330f729Sjoerg('6.10.9 Pragma operator', '161'),
97*7330f729Sjoerg('6.11 Future language directions', '163'),
98*7330f729Sjoerg('6.11.1 Floating types', '163'),
99*7330f729Sjoerg('6.11.2 Linkages of identifiers', '163'),
100*7330f729Sjoerg('6.11.3 External names', '163'),
101*7330f729Sjoerg('6.11.4 Character escape sequences', '163'),
102*7330f729Sjoerg('6.11.5 Storage-class specifiers', '163'),
103*7330f729Sjoerg('6.11.6 Function declarators', '163'),
104*7330f729Sjoerg('6.11.7 Function definitions', '163'),
105*7330f729Sjoerg('6.11.8 Pragma directives', '163'),
106*7330f729Sjoerg('6.11.9 Predefined macro names', '163'),
107*7330f729Sjoerg('7. Library', '164'),
108*7330f729Sjoerg('7.1 Introduction', '164'),
109*7330f729Sjoerg('7.1.1 Definitions of terms', '164'),
110*7330f729Sjoerg('7.1.2 Standard headers', '165'),
111*7330f729Sjoerg('7.1.3 Reserved identifiers', '166'),
112*7330f729Sjoerg('7.1.4 Use of library functions', '166'),
113*7330f729Sjoerg('7.2 Diagnostics <assert.h>', '169'),
114*7330f729Sjoerg('7.2.1 Program diagnostics', '169'),
115*7330f729Sjoerg('7.3 Complex arithmetic <complex.h>', '170'),
116*7330f729Sjoerg('7.3.1 Introduction', '170'),
117*7330f729Sjoerg('7.3.2 Conventions', '170'),
118*7330f729Sjoerg('7.3.3 Branch cuts', '171'),
119*7330f729Sjoerg('7.3.4 The CX_LIMITED_RANGE pragma', '171'),
120*7330f729Sjoerg('7.3.5 Trigonometric functions', '172'),
121*7330f729Sjoerg('7.3.6 Hyperbolic functions', '174'),
122*7330f729Sjoerg('7.3.7 Exponential and logarithmic functions', '176'),
123*7330f729Sjoerg('7.3.8 Power and absolute-value functions', '177'),
124*7330f729Sjoerg('7.3.9 Manipulation functions', '178'),
125*7330f729Sjoerg('7.4 Character handling <ctype.h>', '181'),
126*7330f729Sjoerg('7.4.1 Character classification functions', '181'),
127*7330f729Sjoerg('7.4.2 Character case mapping functions', '184'),
128*7330f729Sjoerg('7.5 Errors <errno.h>', '186'),
129*7330f729Sjoerg('7.6 Floating-point environment <fenv.h>', '187'),
130*7330f729Sjoerg('7.6.1 The FENV_ACCESS pragma', '189'),
131*7330f729Sjoerg('7.6.2 Floating-point exceptions', '190'),
132*7330f729Sjoerg('7.6.3 Rounding', '193'),
133*7330f729Sjoerg('7.6.4 Environment', '194'),
134*7330f729Sjoerg('7.7 Characteristics of floating types <float.h>', '197'),
135*7330f729Sjoerg('7.8 Format conversion of integer types <inttypes.h>', '198'),
136*7330f729Sjoerg('7.8.1 Macros for format specifiers', '198'),
137*7330f729Sjoerg('7.8.2 Functions for greatest-width integer types', '199'),
138*7330f729Sjoerg('7.9 Alternative spellings <iso646.h>', '202'),
139*7330f729Sjoerg('7.10 Sizes of integer types <limits.h>', '203'),
140*7330f729Sjoerg('7.11 Localization <locale.h>', '204'),
141*7330f729Sjoerg('7.11.1 Locale control', '205'),
142*7330f729Sjoerg('7.11.2 Numeric formatting convention inquiry', '206'),
143*7330f729Sjoerg('7.12 Mathematics <math.h>', '212'),
144*7330f729Sjoerg('7.12.1 Treatment of error conditions', '214'),
145*7330f729Sjoerg('7.12.2 The FP_CONTRACT pragma', '215'),
146*7330f729Sjoerg('7.12.3 Classification macros', '216'),
147*7330f729Sjoerg('7.12.4 Trigonometric functions', '218'),
148*7330f729Sjoerg('7.12.5 Hyperbolic functions', '221'),
149*7330f729Sjoerg('7.12.6 Exponential and logarithmic functions', '223'),
150*7330f729Sjoerg('7.12.7 Power and absolute-value functions', '228'),
151*7330f729Sjoerg('7.12.8 Error and gamma functions', '230'),
152*7330f729Sjoerg('7.12.9 Nearest integer functions', '231'),
153*7330f729Sjoerg('7.12.10 Remainder functions', '235'),
154*7330f729Sjoerg('7.12.11 Manipulation functions', '236'),
155*7330f729Sjoerg('7.12.12 Maximum, minimum, and positive difference functions', '238'),
156*7330f729Sjoerg('7.12.13 Floating multiply-add', '239'),
157*7330f729Sjoerg('7.12.14 Comparison macros', '240'),
158*7330f729Sjoerg('7.13 Nonlocal jumps <setjmp.h>', '243'),
159*7330f729Sjoerg('7.13.1 Save calling environment', '243'),
160*7330f729Sjoerg('7.13.2 Restore calling environment', '244'),
161*7330f729Sjoerg('7.14 Signal handling <signal.h>', '246'),
162*7330f729Sjoerg('7.14.1 Specify signal handling', '247'),
163*7330f729Sjoerg('7.14.2 Send signal', '248'),
164*7330f729Sjoerg('7.15 Variable arguments <stdarg.h>', '249'),
165*7330f729Sjoerg('7.15.1 Variable argument list access macros', '249'),
166*7330f729Sjoerg('7.16 Boolean type and values <stdbool.h>', '253'),
167*7330f729Sjoerg('7.17 Common definitions <stddef.h>', '254'),
168*7330f729Sjoerg('7.18 Integer types <stdint.h>', '255'),
169*7330f729Sjoerg('7.18.1 Integer types', '255'),
170*7330f729Sjoerg('7.18.2 Limits of specified-width integer types', '257'),
171*7330f729Sjoerg('7.18.3 Limits of other integer types', '259'),
172*7330f729Sjoerg('7.18.4 Macros for integer constants', '260'),
173*7330f729Sjoerg('7.19 Input/output <stdio.h>', '262'),
174*7330f729Sjoerg('7.19.1 Introduction', '262'),
175*7330f729Sjoerg('7.19.2 Streams', '264'),
176*7330f729Sjoerg('7.19.3 Files', '266'),
177*7330f729Sjoerg('7.19.4 Operations on files', '268'),
178*7330f729Sjoerg('7.19.5 File access functions', '270'),
179*7330f729Sjoerg('7.19.6 Formatted input/output functions', '274'),
180*7330f729Sjoerg('7.19.7 Character input/output functions', '296'),
181*7330f729Sjoerg('7.19.8 Direct input/output functions', '301'),
182*7330f729Sjoerg('7.19.9 File positioning functions', '302'),
183*7330f729Sjoerg('7.19.10 Error-handling functions', '304'),
184*7330f729Sjoerg('7.20 General utilities <stdlib.h>', '306'),
185*7330f729Sjoerg('7.20.1 Numeric conversion functions', '307'),
186*7330f729Sjoerg('7.20.2 Pseudo-random sequence generation functions', '312'),
187*7330f729Sjoerg('7.20.3 Memory management functions', '313'),
188*7330f729Sjoerg('7.20.4 Communication with the environment', '315'),
189*7330f729Sjoerg('7.20.5 Searching and sorting utilities', '318'),
190*7330f729Sjoerg('7.20.6 Integer arithmetic functions', '320'),
191*7330f729Sjoerg('7.20.7 Multibyte/wide character conversion functions', '321'),
192*7330f729Sjoerg('7.20.8 Multibyte/wide string conversion functions', '323'),
193*7330f729Sjoerg('7.21 String handling <string.h>', '325'),
194*7330f729Sjoerg('7.21.1 String function conventions', '325'),
195*7330f729Sjoerg('7.21.2 Copying functions', '325'),
196*7330f729Sjoerg('7.21.3 Concatenation functions', '327'),
197*7330f729Sjoerg('7.21.4 Comparison functions', '328'),
198*7330f729Sjoerg('7.21.5 Search functions', '330'),
199*7330f729Sjoerg('7.21.6 Miscellaneous functions', '333'),
200*7330f729Sjoerg('7.22 Type-generic math <tgmath.h>', '335'),
201*7330f729Sjoerg('7.23 Date and time <time.h>', '338'),
202*7330f729Sjoerg('7.23.1 Components of time', '338'),
203*7330f729Sjoerg('7.23.2 Time manipulation functions', '339'),
204*7330f729Sjoerg('7.23.3 Time conversion functions', '341'),
205*7330f729Sjoerg('7.24 Extended multibyte and wide character utilities <wchar.h>', '348'),
206*7330f729Sjoerg('7.24.1 Introduction', '348'),
207*7330f729Sjoerg('7.24.2 Formatted wide character input/output functions', '349'),
208*7330f729Sjoerg('7.24.3 Wide character input/output functions', '367'),
209*7330f729Sjoerg('7.24.4 General wide string utilities', '371'),
210*7330f729Sjoerg('7.24.5 Wide character time conversion functions', '385'),
211*7330f729Sjoerg('7.24.6 Extended multibyte/wide character conversion utilities', '386'),
212*7330f729Sjoerg('7.25 Wide character classification and mapping utilities <wctype.h>',
213*7330f729Sjoerg  '393'),
214*7330f729Sjoerg('7.25.1 Introduction', '393'),
215*7330f729Sjoerg('7.25.2 Wide character classification utilities', '394'),
216*7330f729Sjoerg('7.25.3 Wide character case mapping utilities', '399'),
217*7330f729Sjoerg('7.26 Future library directions', '401'),
218*7330f729Sjoerg('7.26.1 Complex arithmetic <complex.h>', '401'),
219*7330f729Sjoerg('7.26.2 Character handling <ctype.h>', '401'),
220*7330f729Sjoerg('7.26.3 Errors <errno.h>', '401'),
221*7330f729Sjoerg('7.26.4 Format conversion of integer types <inttypes.h>', '401'),
222*7330f729Sjoerg('7.26.5 Localization <locale.h>', '401'),
223*7330f729Sjoerg('7.26.6 Signal handling <signal.h>', '401'),
224*7330f729Sjoerg('7.26.7 Boolean type and values <stdbool.h>', '401'),
225*7330f729Sjoerg('7.26.8 Integer types <stdint.h>', '401'),
226*7330f729Sjoerg('7.26.9 Input/output <stdio.h>', '402'),
227*7330f729Sjoerg('7.26.10 General utilities <stdlib.h>', '402'),
228*7330f729Sjoerg('7.26.11 String handling <string.h>', '402'),
229*7330f729Sjoerg('<wchar.h>', '402'),
230*7330f729Sjoerg('<wctype.h>', '402'),
231*7330f729Sjoerg('Annex A (informative) Language syntax summary', '403'),
232*7330f729Sjoerg('A.1 Lexical grammar', '403'),
233*7330f729Sjoerg('A.2 Phrase structure grammar', '409'),
234*7330f729Sjoerg('A.3 Preprocessing directives', '416'),
235*7330f729Sjoerg('Annex B (informative) Library summary', '418'),
236*7330f729Sjoerg('B.1 Diagnostics <assert.h>', '418'),
237*7330f729Sjoerg('B.2 Complex <complex.h>', '418'),
238*7330f729Sjoerg('B.3 Character handling <ctype.h>', '420'),
239*7330f729Sjoerg('B.4 Errors <errno.h>', '420'),
240*7330f729Sjoerg('B.5 Floating-point environment <fenv.h>', '420'),
241*7330f729Sjoerg('B.6 Characteristics of floating types <float.h>', '421'),
242*7330f729Sjoerg('B.7 Format conversion of integer types <inttypes.h>', '421'),
243*7330f729Sjoerg('B.8 Alternative spellings <iso646.h>', '422'),
244*7330f729Sjoerg('B.9 Sizes of integer types <limits.h>', '422'),
245*7330f729Sjoerg('B.10 Localization <locale.h>', '422'),
246*7330f729Sjoerg('B.11 Mathematics <math.h>', '422'),
247*7330f729Sjoerg('B.12 Nonlocal jumps <setjmp.h>', '427'),
248*7330f729Sjoerg('B.13 Signal handling <signal.h>', '427'),
249*7330f729Sjoerg('B.14 Variable arguments <stdarg.h>', '427'),
250*7330f729Sjoerg('B.15 Boolean type and values <stdbool.h>', '427'),
251*7330f729Sjoerg('B.16 Common definitions <stddef.h>', '428'),
252*7330f729Sjoerg('B.17 Integer types <stdint.h>', '428'),
253*7330f729Sjoerg('B.18 Input/output <stdio.h>', '428'),
254*7330f729Sjoerg('B.19 General utilities <stdlib.h>', '430'),
255*7330f729Sjoerg('B.20 String handling <string.h>', '432'),
256*7330f729Sjoerg('B.21 Type-generic math <tgmath.h>', '433'),
257*7330f729Sjoerg('B.22 Date and time <time.h>', '433'),
258*7330f729Sjoerg('B.23 Extended multibyte/wide character utilities <wchar.h>', '434'),
259*7330f729Sjoerg('B.24 Wide character classification and mapping utilities <wctype.h>',
260*7330f729Sjoerg  '436'),
261*7330f729Sjoerg('Annex C (informative) Sequence points', '438'),
262*7330f729Sjoerg('Annex D (normative) Universal character names for identifiers', '439'),
263*7330f729Sjoerg('Annex E (informative) Implementation limits', '441'),
264*7330f729Sjoerg('Annex F (normative) IEC 60559 floating-point arithmetic', '443'),
265*7330f729Sjoerg('F.1 Introduction', '443'),
266*7330f729Sjoerg('F.2 Types', '443'),
267*7330f729Sjoerg('F.3 Operators and functions', '444'),
268*7330f729Sjoerg('F.4 Floating to integer conversion', '446'),
269*7330f729Sjoerg('F.5 Binary-decimal conversion', '446'),
270*7330f729Sjoerg('F.6 Contracted expressions', '447'),
271*7330f729Sjoerg('F.7 Floating-point environment', '447'),
272*7330f729Sjoerg('F.8 Optimization', '450'),
273*7330f729Sjoerg('F.9 Mathematics <math.h>', '453'),
274*7330f729Sjoerg('Annex G (informative) IEC 60559-compatible complex arithmetic', '466'),
275*7330f729Sjoerg('G.1 Introduction', '466'),
276*7330f729Sjoerg('G.2 Types', '466'),
277*7330f729Sjoerg('G.3 Conventions', '466'),
278*7330f729Sjoerg('G.4 Conversions', '467'),
279*7330f729Sjoerg('G.5 Binary operators', '467'),
280*7330f729Sjoerg('G.6 Complex arithmetic <complex.h>', '471'),
281*7330f729Sjoerg('G.7 Type-generic math <tgmath.h>', '479'),
282*7330f729Sjoerg('Annex H (informative) Language independent arithmetic', '480'),
283*7330f729Sjoerg('H.1 Introduction', '480'),
284*7330f729Sjoerg('H.2 Types', '480'),
285*7330f729Sjoerg('H.3 Notification', '484'),
286*7330f729Sjoerg('Annex I (informative) Common warnings', '486'),
287*7330f729Sjoerg('Annex J (informative) Portability issues', '488'),
288*7330f729Sjoerg('J.1 Unspecified behavior', '488'),
289*7330f729Sjoerg('J.2 Undefined behavior', '491'),
290*7330f729Sjoerg('J.3 Implementation-defined behavior', '504'),
291*7330f729Sjoerg('J.4 Locale-specific behavior', '511'),
292*7330f729Sjoerg('J.5 Common extensions', '512'),
293*7330f729Sjoerg('Bibliography', '515'),
294*7330f729Sjoerg('Index', '517')]
295*7330f729Sjoerg
296*7330f729SjoergcXXURL = 'http://open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf'
297*7330f729SjoergcXXTOC = [('Contents', 'ii'),
298*7330f729Sjoerg('List of Tables', 'ix'),
299*7330f729Sjoerg('1 General', '1'),
300*7330f729Sjoerg('1.1 Scope', '1'),
301*7330f729Sjoerg('1.2 Normative references', '1'),
302*7330f729Sjoerg('1.3 Definitions', '2'),
303*7330f729Sjoerg('1.4 Implementation compliance', '4'),
304*7330f729Sjoerg('1.5 Structure of this International Standard', '5'),
305*7330f729Sjoerg('1.6 Syntax notation', '5'),
306*7330f729Sjoerg('1.7 The C++ memory model', '6'),
307*7330f729Sjoerg('1.8 The C++ object model', '6'),
308*7330f729Sjoerg('1.9 Program execution', '7'),
309*7330f729Sjoerg('1.10 Multi-threaded executions and data races', '10'),
310*7330f729Sjoerg('1.11 Acknowledgments', '13'),
311*7330f729Sjoerg('2 Lexical conventions', '15'),
312*7330f729Sjoerg('2.1 Phases of translation', '15'),
313*7330f729Sjoerg('2.2 Character sets', '16'),
314*7330f729Sjoerg('2.3 Trigraph sequences', '17'),
315*7330f729Sjoerg('2.4 Preprocessing tokens', '17'),
316*7330f729Sjoerg('2.5 Alternative tokens', '18'),
317*7330f729Sjoerg('2.6 Tokens', '19'),
318*7330f729Sjoerg('2.7 Comments', '19'),
319*7330f729Sjoerg('2.8 Header names', '19'),
320*7330f729Sjoerg('2.9 Preprocessing numbers', '20'),
321*7330f729Sjoerg('2.10 Identifiers', '20'),
322*7330f729Sjoerg('2.11 Keywords', '20'),
323*7330f729Sjoerg('2.12 Operators and punctuators', '21'),
324*7330f729Sjoerg('2.13 Literals', '21'),
325*7330f729Sjoerg('3 Basic concepts', '29'),
326*7330f729Sjoerg('3.1 Declarations and definitions', '29'),
327*7330f729Sjoerg('3.2 One definition rule', '31'),
328*7330f729Sjoerg('3.3 Declarative regions and scopes', '33'),
329*7330f729Sjoerg('3.4 Name lookup', '38'),
330*7330f729Sjoerg('3.5 Program and linkage', '51'),
331*7330f729Sjoerg('3.6 Start and termination', '54'),
332*7330f729Sjoerg('3.7 Storage duration', '58'),
333*7330f729Sjoerg('3.8 Object Lifetime', '62'),
334*7330f729Sjoerg('3.9 Types', '65'),
335*7330f729Sjoerg('3.10 Lvalues and rvalues', '70'),
336*7330f729Sjoerg('3.11 Alignment', '72'),
337*7330f729Sjoerg('4 Standard conversions', '73'),
338*7330f729Sjoerg('4.1 Lvalue-to-rvalue conversion', '74'),
339*7330f729Sjoerg('4.2 Array-to-pointer conversion', '74'),
340*7330f729Sjoerg('4.3 Function-to-pointer conversion', '74'),
341*7330f729Sjoerg('4.4 Qualification conversions', '74'),
342*7330f729Sjoerg('4.5 Integral promotions', '75'),
343*7330f729Sjoerg('4.6 Floating point promotion', '76'),
344*7330f729Sjoerg('4.7 Integral conversions', '76'),
345*7330f729Sjoerg('4.8 Floating point conversions', '76'),
346*7330f729Sjoerg('4.9 Floating-integral conversions', '77'),
347*7330f729Sjoerg('4.10 Pointer conversions', '77'),
348*7330f729Sjoerg('4.11 Pointer to member conversions', '77'),
349*7330f729Sjoerg('4.12 Boolean conversions', '78'),
350*7330f729Sjoerg('4.13 Integer conversion rank', '78'),
351*7330f729Sjoerg('5 Expressions', '79'),
352*7330f729Sjoerg('5.1 Primary expressions', '80'),
353*7330f729Sjoerg('5.2 Postfix expressions', '85'),
354*7330f729Sjoerg('5.3 Unary expressions', '96'),
355*7330f729Sjoerg('5.4 Explicit type conversion (cast notation)', '104'),
356*7330f729Sjoerg('5.5 Pointer-to-member operators', '105'),
357*7330f729Sjoerg('5.6 Multiplicative operators', '106'),
358*7330f729Sjoerg('5.7 Additive operators', '106'),
359*7330f729Sjoerg('5.8 Shift operators', '107'),
360*7330f729Sjoerg('5.9 Relational operators', '108'),
361*7330f729Sjoerg('5.10 Equality operators', '109'),
362*7330f729Sjoerg('5.11 Bitwise AND operator', '110'),
363*7330f729Sjoerg('5.12 Bitwise exclusive OR operator', '110'),
364*7330f729Sjoerg('5.13 Bitwise inclusive OR operator', '110'),
365*7330f729Sjoerg('5.14 Logical AND operator', '110'),
366*7330f729Sjoerg('5.15 Logical OR operator', '110'),
367*7330f729Sjoerg('5.16 Conditional operator', '111'),
368*7330f729Sjoerg('5.17 Assignment and compound assignment operators', '112'),
369*7330f729Sjoerg('5.18 Comma operator', '113'),
370*7330f729Sjoerg('5.19 Constant expressions', '113'),
371*7330f729Sjoerg('6 Statements', '116'),
372*7330f729Sjoerg('6.1 Labeled statement', '116'),
373*7330f729Sjoerg('6.2 Expression statement', '116'),
374*7330f729Sjoerg('6.3 Compound statement or block', '116'),
375*7330f729Sjoerg('6.4 Selection statements', '117'),
376*7330f729Sjoerg('6.5 Iteration statements', '118'),
377*7330f729Sjoerg('6.6 Jump statements', '121'),
378*7330f729Sjoerg('6.7 Declaration statement', '122'),
379*7330f729Sjoerg('6.8 Ambiguity resolution', '123'),
380*7330f729Sjoerg('7 Declarations', '125'),
381*7330f729Sjoerg('7.1 Specifiers', '126'),
382*7330f729Sjoerg('7.2 Enumeration declarations', '140'),
383*7330f729Sjoerg('7.3 Namespaces', '143'),
384*7330f729Sjoerg('7.4 The asm declaration', '156'),
385*7330f729Sjoerg('7.5 Linkage specifications', '156'),
386*7330f729Sjoerg('8 Declarators', '160'),
387*7330f729Sjoerg('8.1 Type names', '161'),
388*7330f729Sjoerg('8.2 Ambiguity resolution', '161'),
389*7330f729Sjoerg('8.3 Meaning of declarators', '163'),
390*7330f729Sjoerg('8.4 Function definitions', '175'),
391*7330f729Sjoerg('8.5 Initializers', '177'),
392*7330f729Sjoerg('9 Classes', '191'),
393*7330f729Sjoerg('9.1 Class names', '193'),
394*7330f729Sjoerg('9.2 Class members', '194'),
395*7330f729Sjoerg('9.3 Member functions', '197'),
396*7330f729Sjoerg('9.4 Static members', '200'),
397*7330f729Sjoerg('9.5 Unions', '202'),
398*7330f729Sjoerg('9.6 Bit-fields', '203'),
399*7330f729Sjoerg('9.7 Nested class declarations', '204'),
400*7330f729Sjoerg('9.8 Local class declarations', '205'),
401*7330f729Sjoerg('9.9 Nested type names', '206'),
402*7330f729Sjoerg('10 Derived classes', '207'),
403*7330f729Sjoerg('10.1 Multiple base classes', '208'),
404*7330f729Sjoerg('10.2 Member name lookup', '210'),
405*7330f729Sjoerg('10.3 Virtual functions', '213'),
406*7330f729Sjoerg('10.4 Abstract classes', '217'),
407*7330f729Sjoerg('11 Member access control', '219'),
408*7330f729Sjoerg('11.1 Access specifiers', '221'),
409*7330f729Sjoerg('11.2 Accessibility of base classes and base class members', '222'),
410*7330f729Sjoerg('11.3 Access declarations', '224'),
411*7330f729Sjoerg('11.4 Friends', '225'),
412*7330f729Sjoerg('11.5 Protected member access', '228'),
413*7330f729Sjoerg('11.6 Access to virtual functions', '229'),
414*7330f729Sjoerg('11.7 Multiple access', '230'),
415*7330f729Sjoerg('11.8 Nested classes', '230'),
416*7330f729Sjoerg('12 Special member functions', '231'),
417*7330f729Sjoerg('12.1 Constructors', '231'),
418*7330f729Sjoerg('12.2 Temporary objects', '233'),
419*7330f729Sjoerg('12.3 Conversions', '235'),
420*7330f729Sjoerg('12.4 Destructors', '238'),
421*7330f729Sjoerg('12.5 Free store', '240'),
422*7330f729Sjoerg('12.6 Initialization', '242'),
423*7330f729Sjoerg('12.7 Construction and destruction', '247'),
424*7330f729Sjoerg('12.8 Copying class objects', '250'),
425*7330f729Sjoerg('12.9 Inheriting Constructors', '255'),
426*7330f729Sjoerg('13 Overloading', '259'),
427*7330f729Sjoerg('13.1 Overloadable declarations', '259'),
428*7330f729Sjoerg('13.2 Declaration matching', '261'),
429*7330f729Sjoerg('13.3 Overload resolution', '262'),
430*7330f729Sjoerg('13.4 Address of overloaded function', '281'),
431*7330f729Sjoerg('13.5 Overloaded operators', '282'),
432*7330f729Sjoerg('13.6 Built-in operators', '286'),
433*7330f729Sjoerg('14 Templates', '290'),
434*7330f729Sjoerg('14.1 Template parameters', '291'),
435*7330f729Sjoerg('14.2 Names of template specializations', '294'),
436*7330f729Sjoerg('14.3 Template arguments', '296'),
437*7330f729Sjoerg('14.4 Type equivalence', '302'),
438*7330f729Sjoerg('14.5 Template declarations', '303'),
439*7330f729Sjoerg('14.6 Name resolution', '318'),
440*7330f729Sjoerg('14.7 Template instantiation and specialization', '331'),
441*7330f729Sjoerg('14.8 Function template specializations', '343'),
442*7330f729Sjoerg('15 Exception handling', '363'),
443*7330f729Sjoerg('15.1 Throwing an exception', '364'),
444*7330f729Sjoerg('15.2 Constructors and destructors', '366'),
445*7330f729Sjoerg('15.3 Handling an exception', '366'),
446*7330f729Sjoerg('15.4 Exception specifications', '368'),
447*7330f729Sjoerg('15.5 Special functions', '371'),
448*7330f729Sjoerg('15.6 Exceptions and access', '372'),
449*7330f729Sjoerg('16 Preprocessing directives', '373'),
450*7330f729Sjoerg('16.1 Conditional inclusion', '375'),
451*7330f729Sjoerg('16.2 Source file inclusion', '376'),
452*7330f729Sjoerg('16.3 Macro replacement', '377'),
453*7330f729Sjoerg('16.4 Line control', '382'),
454*7330f729Sjoerg('16.5 Error directive', '383'),
455*7330f729Sjoerg('16.6 Pragma directive', '383'),
456*7330f729Sjoerg('16.7 Null directive', '383'),
457*7330f729Sjoerg('16.8 Predefined macro names', '383'),
458*7330f729Sjoerg('16.9 Pragma operator', '384'),
459*7330f729Sjoerg('17 Library introduction', '386'),
460*7330f729Sjoerg('17.1 General', '386'),
461*7330f729Sjoerg('17.2 Overview', '386'),
462*7330f729Sjoerg('17.3 Definitions', '386'),
463*7330f729Sjoerg('17.4 Additional definitions', '390'),
464*7330f729Sjoerg('17.5 Method of description (Informative)', '390'),
465*7330f729Sjoerg('17.6 Library-wide requirements', '396'),
466*7330f729Sjoerg('18 Language support library', '407'),
467*7330f729Sjoerg('18.1 Types', '407'),
468*7330f729Sjoerg('18.2 Implementation properties', '408'),
469*7330f729Sjoerg('18.3 Integer types', '417'),
470*7330f729Sjoerg('18.4 Start and termination', '418'),
471*7330f729Sjoerg('18.5 Dynamic memory management', '420'),
472*7330f729Sjoerg('18.6 Type identification', '424'),
473*7330f729Sjoerg('18.7 Exception handling', '427'),
474*7330f729Sjoerg('18.8 Initializer lists', '432'),
475*7330f729Sjoerg('18.9 Other runtime support', '434'),
476*7330f729Sjoerg('19 Diagnostics library', '435'),
477*7330f729Sjoerg('19.1 Exception classes', '435'),
478*7330f729Sjoerg('19.2 Assertions', '439'),
479*7330f729Sjoerg('19.3 Error numbers', '440'),
480*7330f729Sjoerg('19.4 System error support', '440'),
481*7330f729Sjoerg('20 General utilities library', '452'),
482*7330f729Sjoerg('20.1 Requirements', '452'),
483*7330f729Sjoerg('20.2 Utility components', '457'),
484*7330f729Sjoerg('20.3 Compile-time rational arithmetic', '463'),
485*7330f729Sjoerg('20.4 Tuples', '465'),
486*7330f729Sjoerg('20.5 Metaprogramming and type traits', '473'),
487*7330f729Sjoerg('20.6 Function objects', '486'),
488*7330f729Sjoerg('20.7 Memory', '509'),
489*7330f729Sjoerg('20.8 Time utilities', '548'),
490*7330f729Sjoerg('20.9 Date and time functions', '562'),
491*7330f729Sjoerg('21 Strings library', '563'),
492*7330f729Sjoerg('21.1 Character traits', '563'),
493*7330f729Sjoerg('21.2 String classes', '569'),
494*7330f729Sjoerg('21.3 Class template basic_string', '572'),
495*7330f729Sjoerg('21.4 Numeric Conversions', '599'),
496*7330f729Sjoerg('21.5 Null-terminated sequence utilities', '600'),
497*7330f729Sjoerg('22 Localization library', '604'),
498*7330f729Sjoerg('22.1 Locales', '604'),
499*7330f729Sjoerg('22.2 Standard locale categories', '617'),
500*7330f729Sjoerg('22.3 Standard code conversion facets', '657'),
501*7330f729Sjoerg('22.4 C Library Locales', '659'),
502*7330f729Sjoerg('23 Containers library', '660'),
503*7330f729Sjoerg('23.1 Container requirements', '660'),
504*7330f729Sjoerg('23.2 Sequence containers', '681'),
505*7330f729Sjoerg('23.3 Associative containers', '719'),
506*7330f729Sjoerg('23.4 Unordered associative containers', '744'),
507*7330f729Sjoerg('24 Iterators library', '759'),
508*7330f729Sjoerg('24.1 Iterator requirements', '759'),
509*7330f729Sjoerg('24.2 Header <iterator> synopsis', '764'),
510*7330f729Sjoerg('24.3 Iterator primitives', '767'),
511*7330f729Sjoerg('24.4 Predefined iterators', '770'),
512*7330f729Sjoerg('24.5 Stream iterators', '784'),
513*7330f729Sjoerg('25 Algorithms library', '792'),
514*7330f729Sjoerg('25.1 Non-modifying sequence operations', '802'),
515*7330f729Sjoerg('25.2 Mutating sequence operations', '806'),
516*7330f729Sjoerg('25.3 Sorting and related operations', '815'),
517*7330f729Sjoerg('25.4 C library algorithms', '829'),
518*7330f729Sjoerg('26 Numerics library', '831'),
519*7330f729Sjoerg('26.1 Numeric type requirements', '831'),
520*7330f729Sjoerg('26.2 The floating-point environment', '832'),
521*7330f729Sjoerg('26.3 Complex numbers', '833'),
522*7330f729Sjoerg('26.4 Random number generation', '842'),
523*7330f729Sjoerg('26.5 Numeric arrays', '884'),
524*7330f729Sjoerg('26.6 Generalized numeric operations', '904'),
525*7330f729Sjoerg('26.7 C Library', '907'),
526*7330f729Sjoerg('27 Input/output library', '912'),
527*7330f729Sjoerg('27.1 Iostreams requirements', '912'),
528*7330f729Sjoerg('27.2 Forward declarations', '912'),
529*7330f729Sjoerg('27.3 Standard iostream objects', '915'),
530*7330f729Sjoerg('27.4 Iostreams base classes', '916'),
531*7330f729Sjoerg('27.5 Stream buffers', '934'),
532*7330f729Sjoerg('27.6 Formatting and manipulators', '944'),
533*7330f729Sjoerg('27.7 String-based streams', '972'),
534*7330f729Sjoerg('27.8 File-based streams', '984'),
535*7330f729Sjoerg('28 Regular expressions library', '1000'),
536*7330f729Sjoerg('28.1 Definitions', '1000'),
537*7330f729Sjoerg('28.2 Requirements', '1000'),
538*7330f729Sjoerg('28.3 Regular expressions summary', '1002'),
539*7330f729Sjoerg('28.4 Header <regex> synopsis', '1003'),
540*7330f729Sjoerg('28.5 Namespace std::regex_constants', '1009'),
541*7330f729Sjoerg('28.6 Class regex_error', '1012'),
542*7330f729Sjoerg('28.7 Class template regex_traits', '1012'),
543*7330f729Sjoerg('28.8 Class template basic_regex', '1015'),
544*7330f729Sjoerg('28.9 Class template sub_match', '1020'),
545*7330f729Sjoerg('28.10Class template match_results', '1025'),
546*7330f729Sjoerg('28.11Regular expression algorithms', '1029'),
547*7330f729Sjoerg('28.12Regular expression Iterators', '1033'),
548*7330f729Sjoerg('28.13Modified ECMAScript regular expression grammar', '1039'),
549*7330f729Sjoerg('29 Atomic operations library', '1042'),
550*7330f729Sjoerg('29.1 Order and Consistency', '1044'),
551*7330f729Sjoerg('29.2 Lock-free Property', '1046'),
552*7330f729Sjoerg('29.3 Atomic Types', '1046'),
553*7330f729Sjoerg('29.4 Operations on Atomic Types', '1051'),
554*7330f729Sjoerg('29.5 Flag Type and Operations', '1054'),
555*7330f729Sjoerg('30 Thread support library', '1057'),
556*7330f729Sjoerg('30.1 Requirements', '1057'),
557*7330f729Sjoerg('30.2 Threads', '1058'),
558*7330f729Sjoerg('30.3 Mutual exclusion', '1063'),
559*7330f729Sjoerg('30.4 Condition variables', '1077'),
560*7330f729Sjoerg('A Grammar summary', '1085'),
561*7330f729Sjoerg('A.1 Keywords', '1085'),
562*7330f729Sjoerg('A.2 Lexical conventions', '1085'),
563*7330f729Sjoerg('A.3 Basic concepts', '1089'),
564*7330f729Sjoerg('A.4 Expressions', '1090'),
565*7330f729Sjoerg('A.5 Statements', '1093'),
566*7330f729Sjoerg('A.6 Declarations', '1094'),
567*7330f729Sjoerg('A.7 Declarators', '1097'),
568*7330f729Sjoerg('A.8 Classes', '1098'),
569*7330f729Sjoerg('A.9 Derived classes', '1099'),
570*7330f729Sjoerg('A.10 Special member functions', '1099'),
571*7330f729Sjoerg('A.11 Overloading', '1100'),
572*7330f729Sjoerg('A.12 Templates', '1100'),
573*7330f729Sjoerg('A.13 Exception handling', '1101'),
574*7330f729Sjoerg('A.14 Preprocessing directives', '1101'),
575*7330f729Sjoerg('B Implementation quantities', '1103'),
576*7330f729Sjoerg('C Compatibility', '1105'),
577*7330f729Sjoerg('C.1 C++ and ISO C', '1105'),
578*7330f729Sjoerg('C.2 Standard C library', '1114'),
579*7330f729Sjoerg('D Compatibility features', '1119'),
580*7330f729Sjoerg('D.1 Increment operator with bool operand', '1119'),
581*7330f729Sjoerg('D.2 static keyword', '1119'),
582*7330f729Sjoerg('D.3 Access declarations', '1119'),
583*7330f729Sjoerg('D.4 Implicit conversion from const strings', '1119'),
584*7330f729Sjoerg('D.5 C standard library headers', '1119'),
585*7330f729Sjoerg('D.6 Old iostreams members', '1120'),
586*7330f729Sjoerg('D.7 char* streams', '1121'),
587*7330f729Sjoerg('D.8 Binders', '1130'),
588*7330f729Sjoerg('D.9 auto_ptr', '1132'),
589*7330f729Sjoerg('E Universal-character-names', '1135'),
590*7330f729Sjoerg('F Cross references', '1137'),
591*7330f729Sjoerg('Index', '1153')]
592*7330f729Sjoerg
593*7330f729SjoergkDocuments = {
594*7330f729Sjoerg    'C99' : (c99URL, c99TOC, 12),
595*7330f729Sjoerg    'C++' : (cXXURL, cXXTOC, 12),
596*7330f729Sjoerg}
597*7330f729Sjoerg
598*7330f729Sjoergdef findClosestTOCEntry(data, target):
599*7330f729Sjoerg    # FIXME: Fix for named spec references
600*7330f729Sjoerg    if isinstance(target[0],str):
601*7330f729Sjoerg        return ('.'.join(target),'<named>',1)
602*7330f729Sjoerg
603*7330f729Sjoerg    offset = data[2]
604*7330f729Sjoerg    best = None
605*7330f729Sjoerg    for (name,page) in data[1]:
606*7330f729Sjoerg        if ' ' in name:
607*7330f729Sjoerg            section,name = name.split(' ',1)
608*7330f729Sjoerg            if section == 'Annex':
609*7330f729Sjoerg                section,name = name.split(' ',1)
610*7330f729Sjoerg                section = 'Annex '+section
611*7330f729Sjoerg        else:
612*7330f729Sjoerg            section = None
613*7330f729Sjoerg        try:
614*7330f729Sjoerg            page = int(page) + offset
615*7330f729Sjoerg        except:
616*7330f729Sjoerg            page = 1
617*7330f729Sjoerg        try:
618*7330f729Sjoerg            spec = SpecIndex.fromstring(section)
619*7330f729Sjoerg        except:
620*7330f729Sjoerg            spec = None
621*7330f729Sjoerg
622*7330f729Sjoerg        # Meh, could be better...
623*7330f729Sjoerg        if spec is not None:
624*7330f729Sjoerg            dist = spec - target
625*7330f729Sjoerg            if best is None or dist < best[0]:
626*7330f729Sjoerg                best = (dist, (section, name, page))
627*7330f729Sjoerg    return best[1]
628*7330f729Sjoerg
629*7330f729Sjoerg# What a hack. Slow to boot.
630*7330f729SjoergdoxyLineRefRE = re.compile(r"<a name=\"l([0-9]+)\"></a>")
631*7330f729Sjoergdef findClosestLineReference(clangRoot, doxyName, target):
632*7330f729Sjoerg    try:
633*7330f729Sjoerg        f = open(os.path.join(clangRoot, 'docs', 'doxygen', 'html', doxyName))
634*7330f729Sjoerg    except:
635*7330f729Sjoerg        return None
636*7330f729Sjoerg
637*7330f729Sjoerg    best = None
638*7330f729Sjoerg    for m in doxyLineRefRE.finditer(f.read()):
639*7330f729Sjoerg        line = int(m.group(1), 10)
640*7330f729Sjoerg        dist = abs(line - target)
641*7330f729Sjoerg        if best is None or dist < best[0]:
642*7330f729Sjoerg            best = (dist,'l'+m.group(1))
643*7330f729Sjoerg    f.close()
644*7330f729Sjoerg    if best is not None:
645*7330f729Sjoerg        return best[1]
646*7330f729Sjoerg    return None
647*7330f729Sjoerg
648*7330f729Sjoerg###
649*7330f729Sjoerg
650*7330f729SjoergnameAndSpecRefRE = re.compile(r"(C99|C90|C\+\+|H\&S) ((([0-9]+)(\.[0-9]+)*|\[[^]]+\])(p[0-9]+)?)")
651*7330f729SjoergloneSpecRefRE = re.compile(r" (([0-9]+)(\.[0-9]+){2,100}(p[0-9]+)?)")
652*7330f729Sjoergdef scanFile(path, filename):
653*7330f729Sjoerg    try:
654*7330f729Sjoerg        f = open(path)
655*7330f729Sjoerg    except IOError:
656*7330f729Sjoerg        print >>sys.stderr,'WARNING: Unable to open:',path
657*7330f729Sjoerg        return
658*7330f729Sjoerg
659*7330f729Sjoerg    for i,ln in enumerate(f):
660*7330f729Sjoerg        ignore = set()
661*7330f729Sjoerg        for m in nameAndSpecRefRE.finditer(ln):
662*7330f729Sjoerg            section = m.group(2)
663*7330f729Sjoerg            name = m.group(1)
664*7330f729Sjoerg            if section.endswith('.'):
665*7330f729Sjoerg                section = section[:-1]
666*7330f729Sjoerg            yield RefItem(name, section, filename, path, i+1)
667*7330f729Sjoerg            ignore.add(section)
668*7330f729Sjoerg        for m in loneSpecRefRE.finditer(ln):
669*7330f729Sjoerg            section = m.group(1)
670*7330f729Sjoerg            if section.endswith('.'):
671*7330f729Sjoerg                section = section[:-1]
672*7330f729Sjoerg            if section not in ignore:
673*7330f729Sjoerg                yield RefItem(None, section, filename, path, i+1)
674*7330f729Sjoerg
675*7330f729Sjoerg###
676*7330f729Sjoerg
677*7330f729Sjoergclass SpecIndex:
678*7330f729Sjoerg    @staticmethod
679*7330f729Sjoerg    def fromstring(str):
680*7330f729Sjoerg        # Check for named sections
681*7330f729Sjoerg        if str[0] == '[':
682*7330f729Sjoerg            assert ']' in str
683*7330f729Sjoerg            secs = str[1:str.index(']')].split('.')
684*7330f729Sjoerg            tail = str[str.index(']')+1:]
685*7330f729Sjoerg            if tail:
686*7330f729Sjoerg                assert tail[0] == 'p'
687*7330f729Sjoerg                paragraph = int(tail[1:])
688*7330f729Sjoerg            else:
689*7330f729Sjoerg                paragraph = None
690*7330f729Sjoerg            indices = secs
691*7330f729Sjoerg        else:
692*7330f729Sjoerg            secs = str.split('.')
693*7330f729Sjoerg            paragraph = None
694*7330f729Sjoerg            if 'p' in secs[-1]:
695*7330f729Sjoerg                secs[-1],p = secs[-1].split('p',1)
696*7330f729Sjoerg                paragraph = int(p)
697*7330f729Sjoerg            indices = map(int, secs)
698*7330f729Sjoerg        return SpecIndex(indices, paragraph)
699*7330f729Sjoerg
700*7330f729Sjoerg    def __init__(self, indices, paragraph=None):
701*7330f729Sjoerg        assert len(indices)>0
702*7330f729Sjoerg        self.indices = tuple(indices)
703*7330f729Sjoerg        self.paragraph = paragraph
704*7330f729Sjoerg
705*7330f729Sjoerg    def __str__(self):
706*7330f729Sjoerg        s =  '.'.join(map(str,self.indices))
707*7330f729Sjoerg        if self.paragraph is not None:
708*7330f729Sjoerg            s += '.p%d'%(self.paragraph,)
709*7330f729Sjoerg        return s
710*7330f729Sjoerg
711*7330f729Sjoerg    def __repr__(self):
712*7330f729Sjoerg        return 'SpecIndex(%s, %s)'%(self.indices, self.paragraph)
713*7330f729Sjoerg
714*7330f729Sjoerg    def __cmp__(self, b):
715*7330f729Sjoerg        return cmp((self.indices,self.paragraph),
716*7330f729Sjoerg                   (b.indices,b.paragraph))
717*7330f729Sjoerg
718*7330f729Sjoerg    def __hash__(self):
719*7330f729Sjoerg        return hash((self.indices,self.paragraph))
720*7330f729Sjoerg
721*7330f729Sjoerg    def __sub__(self, indices):
722*7330f729Sjoerg        def sub(a,b):
723*7330f729Sjoerg            a = a or 0
724*7330f729Sjoerg            b = b or 0
725*7330f729Sjoerg            return abs(a-b)
726*7330f729Sjoerg        return map(sub,self.indices,indices)
727*7330f729Sjoerg
728*7330f729Sjoergclass RefItem:
729*7330f729Sjoerg    def __init__(self, name, section, filename, path, line):
730*7330f729Sjoerg        self.name = name
731*7330f729Sjoerg        self.section = SpecIndex.fromstring(section)
732*7330f729Sjoerg        self.filename = filename
733*7330f729Sjoerg        self.path = path
734*7330f729Sjoerg        self.line = line
735*7330f729Sjoerg
736*7330f729Sjoerg    def __str__(self):
737*7330f729Sjoerg        if self.name is not None:
738*7330f729Sjoerg            return '%s %s'%(self.name, self.section)
739*7330f729Sjoerg        else:
740*7330f729Sjoerg            return '--- %s'%(self.section,)
741*7330f729Sjoerg
742*7330f729Sjoerg    def __repr__(self):
743*7330f729Sjoerg        return 'RefItem(%s, %r, "%s", "%s", %d)'%(self.name,
744*7330f729Sjoerg                                              self.section,
745*7330f729Sjoerg                                              self.filename,
746*7330f729Sjoerg                                              self.path,
747*7330f729Sjoerg                                              self.line)
748*7330f729Sjoerg
749*7330f729Sjoerg    def __cmp__(self, b):
750*7330f729Sjoerg        return cmp((self.name,self.section,self.filename,self.path,self.line),
751*7330f729Sjoerg                   (b.name,b.section,self.filename,self.path,self.line))
752*7330f729Sjoerg
753*7330f729Sjoerg    def __hash__(self):
754*7330f729Sjoerg        return hash((self.name,self.section,self.filename,self.path,self.line))
755*7330f729Sjoerg
756*7330f729Sjoerg###
757*7330f729Sjoerg
758*7330f729Sjoergdef sorted(l):
759*7330f729Sjoerg    l = list(l)
760*7330f729Sjoerg    l.sort()
761*7330f729Sjoerg    return l
762*7330f729Sjoerg
763*7330f729Sjoergdef getRevision(path):
764*7330f729Sjoerg    import subprocess
765*7330f729Sjoerg    p = subprocess.Popen(['svn', 'info', path],
766*7330f729Sjoerg                         stdin=open('/dev/null','r'),
767*7330f729Sjoerg                         stdout=subprocess.PIPE)
768*7330f729Sjoerg    for ln in p.stdout.read(1024).split('\n'):
769*7330f729Sjoerg        if ln.startswith('Revision:'):
770*7330f729Sjoerg            return ln.split(':',1)[1].strip()
771*7330f729Sjoerg    return None
772*7330f729Sjoerg
773*7330f729Sjoergdef buildRefTree(references):
774*7330f729Sjoerg    root = (None, {}, [])
775*7330f729Sjoerg
776*7330f729Sjoerg    def getNode(keys):
777*7330f729Sjoerg        if not keys:
778*7330f729Sjoerg            return root
779*7330f729Sjoerg        key,parent = keys[-1],getNode(keys[:-1])
780*7330f729Sjoerg        node = parent[1].get(key)
781*7330f729Sjoerg        if node is None:
782*7330f729Sjoerg            parent[1][key] = node = (key, {}, [])
783*7330f729Sjoerg        return node
784*7330f729Sjoerg
785*7330f729Sjoerg    for ref in references:
786*7330f729Sjoerg        n = getNode((ref.name,) + ref.section.indices)
787*7330f729Sjoerg        n[2].append(ref)
788*7330f729Sjoerg
789*7330f729Sjoerg    def flatten((key, children, data)):
790*7330f729Sjoerg        children = sorted(map(flatten,children.values()))
791*7330f729Sjoerg        return (key, children, sorted(data))
792*7330f729Sjoerg
793*7330f729Sjoerg    return flatten(root)
794*7330f729Sjoerg
795*7330f729Sjoergdef preorder(node,parents=(),first=True):
796*7330f729Sjoerg    (key,children,data) = node
797*7330f729Sjoerg    if first:
798*7330f729Sjoerg        yield parents+(node,)
799*7330f729Sjoerg    for c in children:
800*7330f729Sjoerg        for item in preorder(c, parents+(node,)):
801*7330f729Sjoerg            yield item
802*7330f729Sjoerg
803*7330f729Sjoergdef main():
804*7330f729Sjoerg    global options
805*7330f729Sjoerg    from optparse import OptionParser
806*7330f729Sjoerg    parser = OptionParser("usage: %prog [options] CLANG_ROOT <output-dir>")
807*7330f729Sjoerg    parser.add_option("", "--debug", dest="debug",
808*7330f729Sjoerg                      help="Print extra debugging output",
809*7330f729Sjoerg                      action="store_true",
810*7330f729Sjoerg                      default=False)
811*7330f729Sjoerg    (opts, args) = parser.parse_args()
812*7330f729Sjoerg
813*7330f729Sjoerg    if len(args) != 2:
814*7330f729Sjoerg        parser.error("incorrect number of arguments")
815*7330f729Sjoerg
816*7330f729Sjoerg    references = []
817*7330f729Sjoerg    root,outputDir = args
818*7330f729Sjoerg    if os.path.isdir(root):
819*7330f729Sjoerg        for (dirpath, dirnames, filenames) in os.walk(root):
820*7330f729Sjoerg            for filename in filenames:
821*7330f729Sjoerg                name,ext = os.path.splitext(filename)
822*7330f729Sjoerg                if ext in ('.c', '.cpp', '.h', '.def'):
823*7330f729Sjoerg                    fullpath = os.path.join(dirpath, filename)
824*7330f729Sjoerg                    references.extend(list(scanFile(fullpath, filename)))
825*7330f729Sjoerg    else:
826*7330f729Sjoerg        references.extend(list(scanFile(root, root)))
827*7330f729Sjoerg
828*7330f729Sjoerg    refTree = buildRefTree(references)
829*7330f729Sjoerg
830*7330f729Sjoerg    specs = {}
831*7330f729Sjoerg    for ref in references:
832*7330f729Sjoerg        spec = specs[ref.name] = specs.get(ref.name,{})
833*7330f729Sjoerg        items = spec[ref.section] = spec.get(ref.section,[])
834*7330f729Sjoerg        items.append(ref)
835*7330f729Sjoerg
836*7330f729Sjoerg    print 'Found %d references.'%(len(references),)
837*7330f729Sjoerg
838*7330f729Sjoerg    if opts.debug:
839*7330f729Sjoerg        pprint(refTree)
840*7330f729Sjoerg
841*7330f729Sjoerg    referencesPath = os.path.join(outputDir,'references.html')
842*7330f729Sjoerg    print 'Writing: %s'%(referencesPath,)
843*7330f729Sjoerg    f = open(referencesPath,'w')
844*7330f729Sjoerg    print >>f, '<html><head><title>clang: Specification References</title></head>'
845*7330f729Sjoerg    print >>f, '<body>'
846*7330f729Sjoerg    print >>f, '\t<h2>Specification References</h2>'
847*7330f729Sjoerg    for i,node in enumerate(refTree[1]):
848*7330f729Sjoerg        specName = node[0] or 'Unknown'
849*7330f729Sjoerg        print >>f, '<a href="#spec%d">%s</a><br>'%(i,specName)
850*7330f729Sjoerg    for i,node in enumerate(refTree[1]):
851*7330f729Sjoerg        specName = node[0] or 'Unknown'
852*7330f729Sjoerg        print >>f, '<hr>'
853*7330f729Sjoerg        print >>f, '<a name="spec%d">'%(i,)
854*7330f729Sjoerg        print >>f, '<h3>Document: %s</h3>'%(specName or 'Unknown',)
855*7330f729Sjoerg        print >>f, '<table border="1" cellspacing="2" width="80%">'
856*7330f729Sjoerg        print >>f, '<tr><th width="20%">Name</th><th>References</th></tr>'
857*7330f729Sjoerg        docData = kDocuments.get(specName)
858*7330f729Sjoerg        for path in preorder(node,first=False):
859*7330f729Sjoerg            if not path[-1][2]:
860*7330f729Sjoerg                continue
861*7330f729Sjoerg            components = '.'.join([str(p[0]) for p in path[1:]])
862*7330f729Sjoerg            print >>f, '\t<tr>'
863*7330f729Sjoerg            tocEntry = None
864*7330f729Sjoerg            if docData is not None:
865*7330f729Sjoerg                tocEntry = findClosestTOCEntry(docData, [p[0] for p in path[1:]])
866*7330f729Sjoerg            if tocEntry is not None:
867*7330f729Sjoerg                section,name,page = tocEntry
868*7330f729Sjoerg                # If section is exact print the TOC name
869*7330f729Sjoerg                if page is not None:
870*7330f729Sjoerg                    linkStr = '<a href="%s#page=%d">%s</a> (pg.%d)'%(docData[0],page,components,page)
871*7330f729Sjoerg                else:
872*7330f729Sjoerg                    linkStr = components
873*7330f729Sjoerg                if section == components:
874*7330f729Sjoerg                    print >>f, '\t\t<td valign=top>%s<br>%s</td>'%(linkStr,name)
875*7330f729Sjoerg                else:
876*7330f729Sjoerg                    print >>f, '\t\t<td valign=top>%s</td>'%(linkStr,)
877*7330f729Sjoerg            else:
878*7330f729Sjoerg                print >>f, '\t\t<td valign=top>%s</td>'%(components,)
879*7330f729Sjoerg            print >>f, '\t\t<td valign=top>'
880*7330f729Sjoerg            for item in path[-1][2]:
881*7330f729Sjoerg                # XXX total hack
882*7330f729Sjoerg                relativePath = item.path[len(root):]
883*7330f729Sjoerg                if relativePath.startswith('/'):
884*7330f729Sjoerg                    relativePath = relativePath[1:]
885*7330f729Sjoerg                # XXX this is broken, how does doxygen mangle w/ multiple
886*7330f729Sjoerg                # refs? Can we just read its map?
887*7330f729Sjoerg                filename = os.path.basename(relativePath)
888*7330f729Sjoerg                doxyName = '%s-source.html'%(filename.replace('.','_8'),)
889*7330f729Sjoerg                # Grrr, why can't doxygen write line number references.
890*7330f729Sjoerg                lineReference = findClosestLineReference(root,doxyName,item.line)
891*7330f729Sjoerg                if lineReference is not None:
892*7330f729Sjoerg                    linkStr = 'http://clang.llvm.org/doxygen/%s#%s'%(doxyName,lineReference)
893*7330f729Sjoerg                else:
894*7330f729Sjoerg                    linkStr = 'http://clang.llvm.org/doxygen/%s'%(doxyName,)
895*7330f729Sjoerg                if item.section.paragraph is not None:
896*7330f729Sjoerg                    paraText = '&nbsp;(p%d)'%(item.section.paragraph,)
897*7330f729Sjoerg                else:
898*7330f729Sjoerg                    paraText = ''
899*7330f729Sjoerg                print >>f,'<a href="%s">%s:%d</a>%s<br>'%(linkStr,relativePath,item.line,paraText)
900*7330f729Sjoerg            print >>f, '\t\t</td>'
901*7330f729Sjoerg            print >>f, '\t</tr>'
902*7330f729Sjoerg        print >>f, '</table>'
903*7330f729Sjoerg    print >>f, '<hr>'
904*7330f729Sjoerg    print >>f, 'Generated: %s<br>'%(time.strftime('%Y-%m-%d %H:%M'),)
905*7330f729Sjoerg    print >>f, 'SVN Revision: %s'%(getRevision(root),)
906*7330f729Sjoerg    print >>f, '</body>'
907*7330f729Sjoerg    f.close()
908*7330f729Sjoerg
909*7330f729Sjoergif __name__=='__main__':
910*7330f729Sjoerg   main()
911