| 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 = ' (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() |