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