clang/utils/FindSpecRefs

   1 #!/usr/bin/env python
   2
   3 import os
   4 import re
   5 import time
   6 from pprint import pprint
   7
   8 ###
   9
  10 c99URL = 'http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf'
  11 c99TOC = [('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
 296 cXXURL = 'http://open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf'
 297 cXXTOC = [('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
 593 kDocuments = {
 594     'C99' : (c99URL, c99TOC, 12),
 595     'C++' : (cXXURL, cXXTOC, 12),
 596 }
 597
 598 def 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.
 630 doxyLineRefRE = re.compile(r"<a name=\"l([0-9]+)\"></a>")
 631 def 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
 650 nameAndSpecRefRE = re.compile(r"(C99|C90|C\+\+|H\&S) ((([0-9]+)(\.[0-9]+)*|\[[^]]+\])(p[0-9]+)?)")
 651 loneSpecRefRE = re.compile(r" (([0-9]+)(\.[0-9]+){2,100}(p[0-9]+)?)")
 652 def 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
 677 class 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
 728 class 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
 758 def sorted(l):
 759     l = list(l)
 760     l.sort()
 761     return l
 762
 763 def 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
 773 def 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
 795 def 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
 803 def 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
 909 if __name__=='__main__':
 910    main()