home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-bin / info / id-utils.info < prev    next >
Encoding:
GNU Info File  |  1996-10-12  |  47.0 KB  |  1,179 lines
  1. This is Info file id-utils.info, produced by Makeinfo-1.64 from the
  2. input file /ade-src/fsf/id-utils/doc/id-utils.texi.
  3.  
  4. START-INFO-DIR-ENTRY
  5. * ID database: (id-utils).              Identifier database utilities.
  6. * mkid: (id-utils)mkid invocation.      Creating an ID database.
  7. * lid: (id-utils)lid invocation.        Matching words and patterns.
  8. * fid: (id-utils)fid invocation.        Listing a file's tokens.
  9. * fnid: (id-utils)fnid invocation.      Looking up file names.
  10. * xtokid: (id-utils)xtokid invocation.  Testing mkid scanners.
  11. END-INFO-DIR-ENTRY
  12.  
  13.    This file documents the `id-utils' database utilities.
  14.  
  15.    Copyright (C) 1996 Free Software Foundation, Inc.
  16.  
  17.    Permission is granted to make and distribute verbatim copies of this
  18. manual provided the copyright notice and this permission notice are
  19. preserved on all copies.
  20.  
  21.    Permission is granted to copy and distribute modified versions of
  22. this manual under the conditions for verbatim copying, provided that
  23. the entire resulting derived work is distributed under the terms of a
  24. permission notice identical to this one.
  25.  
  26.    Permission is granted to copy and distribute translations of this
  27. manual into another language, under the above conditions for modified
  28. versions, except that this permission notice may be stated in a
  29. translation.
  30.  
  31. 
  32. File: id-utils.info,  Node: Top,  Next: Introduction,  Up: (dir)
  33.  
  34. ID utilities
  35. ************
  36.  
  37.    This manual documents version 3.2 of the ID utilities.
  38.  
  39. * Menu:
  40.  
  41. * Introduction::                Overview of the tools with tutorial.
  42. * Quick start::                 Quick start procedure.
  43. * Common options::              Common command-line options.
  44. * mkid invocation::             Creating an ID database.
  45. * lid invocation::              Querying an ID database by token.
  46. * fid invocation::              Listing a file's tokens.
  47. * fnid invocation::             Looking up file names.
  48. * xtokid invocation::           Testing language scanners.
  49. * Past and Future::             History and future directions.
  50. * Index::                       General index.
  51.  
  52. 
  53. File: id-utils.info,  Node: Introduction,  Next: Quick start,  Prev: Top,  Up: Top
  54.  
  55. Introduction
  56. ************
  57.  
  58.    An "ID database" is a binary file containing a list of file names, a
  59. list of tokens, and a sparse matrix indicating which tokens appear in
  60. which files.
  61.  
  62.    With this database and some tools to query it (described in this
  63. manual), many text-searching tasks become simpler and faster.  For
  64. example, you can list all files that reference a particular `#include'
  65. file throughout a huge source hierarchy, search for all the memos
  66. containing references to a project, or automatically invoke an editor
  67. on all files containing references to some function or variable.
  68. Anyone with a large software project to maintain, or a large set of text
  69. files to organize, can benefit from the ID utilities.
  70.  
  71.    Although the name `ID' is short for `identifier', the ID utilities
  72. handle more than just identifiers; they also treat other kinds of
  73. tokens, most notably numeric constants, and the contents of certain
  74. character strings.  Thus, this manual will use the word "token" as a
  75. term that is inclusive of identifiers, numbers and strings.
  76.  
  77.    There are several programs in the ID utilities family:
  78.  
  79. `mkid'
  80.      scans files for tokens and builds the ID database file.
  81.  
  82. `lid'
  83.      queries the ID database for tokens, then reports matching file
  84.      names or matching lines.
  85.  
  86. `fid'
  87.      lists all tokens recorded in the database for given files, or
  88.      tokens common to two files.
  89.  
  90. `fnid'
  91.      matches the file names in the database, rather than the tokens.
  92.  
  93. `xtokid'
  94.      extracts raw tokens--helps with testing of new `mkid' scanners.
  95.  
  96.    In addition, the ID utilities have historically provided several
  97. query programs which are specializations of `lid':
  98.  
  99. `gid'
  100.      (alias for `lid -R grep') lists all lines containing the requested
  101.      pattern.
  102.  
  103. `eid'
  104.      (alias for `lid -R edit') invokes an editor on all files
  105.      containing the requested pattern, and if possible, initiates a
  106.      text search for that pattern.
  107.  
  108. `aid'
  109.      (alias for `lid -ils') treats the requested pattern as a
  110.      case-insensitive literal substring.
  111.  
  112.    Please report bugs to `bug-gnu-utils@gnu.ai.mit.edu'.  Remember to
  113. include the version number, machine architecture, input files, and any
  114. other information needed to reproduce the bug: your input, what you
  115. expected, what you got, and why it is wrong.  Diffs are welcome, but
  116. please include a description of the problem as well, since this is
  117. sometimes difficult to infer.  *Note Bugs: (gcc)Bugs.
  118.  
  119. 
  120. File: id-utils.info,  Node: Quick start,  Next: Common options,  Prev: Introduction,  Up: Top
  121.  
  122. Quick Start Procedure
  123. *********************
  124.  
  125.      Unpack the distribution.
  126.  
  127.      Type `./configure'
  128.  
  129.      Type `make'
  130.  
  131.      Type `make install' as a user with the appropriate privileges
  132.      (e.g., `bin' or perhaps even `root').
  133.  
  134.      Type `cd /usr/include; mkid' to build an ID database covering all
  135.      of the system header files.
  136.  
  137.      Type `lid FILE', then `gid strtok', then `aid stdout'.
  138.  
  139.    You have just built, installed and used the most common commands of
  140. the GNU ID utilities.  If you ever need help remembering which system
  141. header files contain a particular declaration, or reference a
  142. particular symbol, you'll want to keep the ID file you built in
  143. `/usr/include' for later use.  If your working directory is elsewhere
  144. at the time, simply provide the `-f /usr/include' option to `lid'
  145. (*note Reading options::.).
  146.  
  147. 
  148. File: id-utils.info,  Node: Common options,  Next: mkid invocation,  Prev: Quick start,  Up: Top
  149.  
  150. Common command-line options
  151. ***************************
  152.  
  153.    Certain options, and regular expression syntax, are shared by various
  154. groupings of the ID utilities.  We describe these in the sections below,
  155. rather than repeating them for each program.
  156.  
  157. * Menu:
  158.  
  159. * Universal options::     Options common to all programs.
  160. * Extraction options::    Options for programs that extract tokens from source files.
  161. * Walker options::        Options for programs that walk file and directory trees.
  162. * Reading options::       Options for programs that read ID databases.
  163. * Writing options::       Options for programs that write ID databases.
  164. * File listing options::  Options for programs that list file names.
  165.  
  166. 
  167. File: id-utils.info,  Node: Universal options,  Next: Extraction options,  Up: Common options
  168.  
  169. Options Common to All Programs
  170. ==============================
  171.  
  172. `--help'
  173.      Print a usage message listing all available options, then exit
  174.      successfully.
  175.  
  176. `--version'
  177.      Print the version number, then exit successfully.
  178.  
  179. 
  180. File: id-utils.info,  Node: Reading options,  Next: Writing options,  Prev: Walker options,  Up: Common options
  181.  
  182. Options for Programs that Read ID Databases
  183. ===========================================
  184.  
  185. `-f FILENAME'
  186. `--file=FILENAME'
  187.      FILENAME is the ID database to read when processing queries.  At
  188.      present, only a single `--file' option is processed, but in future
  189.      releases, more than one ID database may be named on the command
  190.      line.
  191.  
  192. `$IDPATH'
  193.      `IDPATH' is an environment variable that contains a
  194.      colon-separated list of ID database names.  If this variable is
  195.      present, and no `--file' options are presented on the command
  196.      line, the ID databases named in `IDPATH' are implied.(1)
  197.  
  198.    If no ID databases are specified either on the command line or via
  199. the `IDPATH' environment variable, then the ID utilities search for a
  200. file named `ID' in the current working directory, and then in
  201. successive parent directories.
  202.  
  203.    ---------- Footnotes ----------
  204.  
  205.    (1)  At present, this feature is fully implemented, since only the
  206. first of a list of ID database names is processed.
  207.  
  208. 
  209. File: id-utils.info,  Node: Writing options,  Next: File listing options,  Prev: Reading options,  Up: Common options
  210.  
  211. Options for Programs that Write ID Databases
  212. ============================================
  213.  
  214. `-o FILENAME'
  215. `--output=FILENAME'
  216.      The `--output' option names the file in which to write a new ID
  217.      database.  If no `--output' (or `--file') option is present, an
  218.      output file named `ID' is implied.
  219.  
  220. `-f FILENAME'
  221. `--file=FILENAME'
  222.      This is a synonym for `--output'
  223.  
  224. 
  225. File: id-utils.info,  Node: Walker options,  Next: Reading options,  Prev: Extraction options,  Up: Common options
  226.  
  227. Options for Programs that Walk File and Directory Trees.
  228. ========================================================
  229.  
  230.    The programs `mkid' and `xtokid' accept the names of files and
  231. directories on the command line.  Files are scanned if there is a
  232. scanner available and enabled for the file's source language.
  233. Directories are recursively descended, searching for files whose names
  234. match the rules listed in the *language map* file (*note Language
  235. map::.).
  236.  
  237.    The following option controls the file tree walker:
  238.  
  239. `-p NAMES'
  240. `--prune=NAMES'
  241.      One or more file or directory names may appear in NAMES.  The file
  242.      tree walker will stop short at these files and directories and
  243.      their contents will not be scanned.
  244.  
  245. 
  246. File: id-utils.info,  Node: File listing options,  Prev: Writing options,  Up: Common options
  247.  
  248. Options for Programs that List File Names
  249. =========================================
  250.  
  251.    The programs `lid' and `fnid' can print lists of file names as the
  252. result of queries.  The following option controls how these lists are
  253. formatted:
  254.  
  255. `-S STYLE'
  256. `--separator=STYLE'
  257.      STYLE may be one of `braces', `space' or `newline'.
  258.  
  259.      The STYLE of `braces' means that file names with common directory
  260.      prefix and common suffix are printed using the shell's brace
  261.      notation in order to compress the output.  For example,
  262.      `../src/foo.c ../src/bar.c' can be printed in brace notation as
  263.      `../src/{foo,bar}.c'.
  264.  
  265.      The STYLEs of `space' and `newline' mean that file names are
  266.      separated spaces or by newlines, respectively.
  267.  
  268.      If the list of files is being printed on a terminal, brace
  269.      notation is the default.  If not, file names are separated by
  270.      spaces if the KEY is included in the output, and by newlines the
  271.      KEY STYLE is `none' (*note lid invocation::.).
  272.  
  273. 
  274. File: id-utils.info,  Node: Extraction options,  Next: Walker options,  Prev: Universal options,  Up: Common options
  275.  
  276. Options for Programs that Scan Source Files
  277. ===========================================
  278.  
  279.    `mkid' and `xtokid' walk file trees, select source files by name,
  280. and extract tokens from source files.  They accept the following
  281. options:
  282.  
  283. `-m MAPFILE'
  284. `--lang-map=MAPFILE'
  285.      MAPFILE contains rules for determining the source languages from
  286.      file names.  *Note Language map::
  287.  
  288. `-i LANGUAGES'
  289. `--include=LANGUAGES'
  290.      The `--include' option names LANGUAGES whose source files should
  291.      be scanned and incorporated into the ID database.  By default, all
  292.      languages known to the ID utilities are enabled.
  293.  
  294. `-x LANGUAGES'
  295. `--exclude=LANGUAGES'
  296.      The `--exclude' option names LANGUAGES whose source files should
  297.      NOT be scanned.  The default list of excluded languages is empty.
  298.      Note that only one of `--include' or `--exclude' may be specified
  299.      on the command line for a single run.
  300.  
  301. `-l LANGUAGE:OPTIONS'
  302. `--lang-option=LANGUAGE:OPTIONS'
  303.      Language-specific scanners also accept options.  LANGUAGE denotes
  304.      the desired scanner, and OPTION are the command-line options that
  305.      should be passed through to it.  For example, to pass the -X
  306.      -COKE-BOTTLE options to the scanner for the language SWIZZLE, pass
  307.      this: -L SWIZZLE:"-X -COKE-BOTTLE", or this:
  308.      -LANG-OPTION=SWIZZLE:"-X -COKE-BOTTLE", or this: -L SWIZZLE-X -L
  309.      SWIZZLE:-COKE-BOTTLE.  Use the `--help' option to see the
  310.      command-line option summary for
  311.  
  312.    To determine which tokens to extract from a file and store in the
  313. database, `mkid' calls a "scanner"; we say a scanner "recognizes" a
  314. particular language.  Scanners for several languages are built-in to
  315. `mkid'; you can add your own scanners as well, as explained in *Note
  316. Defining scanners::.
  317.  
  318.    The ID utilities determine which scanner to use for a particular
  319. file by consulting the language-map file.  Scanners for several are
  320. already built-in to the ID utilities.  You can see which languages have
  321. built-in scanners, and examine their language-specific options by
  322. invoking `mkid --help' or `xtokid --help'.
  323.  
  324. * Menu:
  325.  
  326. * Language map::                Mapping file names to source languages.
  327. * C/C++ scanner::               For the C and C++ programming language.
  328. * Assembler scanner::           For assembly language.
  329. * Text scanner::                For documents or other non-source code.
  330. * Defining scanners::           Defining new scanners in the source code.
  331.  
  332. 
  333. File: id-utils.info,  Node: Language map,  Next: C/C++ scanner,  Up: Extraction options
  334.  
  335. Mapping file names to source languages
  336. --------------------------------------
  337.  
  338.    The file `id-lang.map', installed by default in
  339. `$(prefix)/share/id-lang.map', contains rules for mapping file names to
  340. source languages.  Each rule comprises three parts: a shell GLOB
  341. pattern, a language name, and language-specific scanner options.
  342.  
  343.    The special pattern `**' denotes the default source language.  This
  344. is the language that's assigned to file names that don't match any other
  345. pattern.
  346.  
  347.    The special pattern `***' should be followed by a file name.  The
  348. named file should contain more language-map rules and is included at
  349. this point.
  350.  
  351.    The order in which rules are presented in a language-map file is
  352. significant.  This order influences the order in which files are
  353. displayed as the result of queries.  For example, the distributed
  354. language-map file places all rules for C .H files ahead of .C files, so
  355. that in general, declarations will precede definitions in query output.
  356. The same thing is done for C++ and its many different source file name
  357. extensions.
  358.  
  359.    Here is a pared-down version of the `id-lang.map' file distributed
  360. with the ID utilities:
  361.  
  362.  
  363.      # Default language
  364.      **            IGNORE    # Although this is listed first,
  365.                      # the default language pattern is
  366.                      # logically matched last.
  367.      
  368.      # Backup files
  369.      *~            IGNORE
  370.      *.bak            IGNORE
  371.      *.bk[0-9]        IGNORE
  372.      
  373.      # SCCS files
  374.      [sp].*            IGNORE
  375.      
  376.      # list header files before code files
  377.      *.h            C
  378.      *.h.in            C
  379.      *.H            C++
  380.      *.hh            C++
  381.      *.hpp            C++
  382.      *.hxx            C++
  383.      
  384.      # list C `meta' files next
  385.      *.l            C
  386.      *.lex            C
  387.      *.y            C
  388.      *.yacc            C
  389.      
  390.      # list C code files after header files
  391.      *.c            C
  392.      *.C            C++
  393.      *.cc            C++
  394.      *.cpp            C++
  395.      *.cxx            C++
  396.      
  397.      # list assembly language after C
  398.      *.[sS]            asm --comment=;
  399.      *.asm            asm --comment=;
  400.      
  401.      # [nt]roff
  402.      *.[0-9]            roff
  403.      *.ms            roff
  404.      *.me            roff
  405.      *.mm            roff
  406.      
  407.      # TeX and friends
  408.      *.tex            TeX
  409.      *.ltx            TeX
  410.      *.texi            texinfo
  411.      *.texinfo        texinfo
  412.  
  413. 
  414. File: id-utils.info,  Node: C/C++ scanner,  Next: Assembler scanner,  Prev: Language map,  Up: Extraction options
  415.  
  416. C/C++ Language Scanner
  417. ----------------------
  418.  
  419.    The C scanner is the most commonly used.  Files that match the glob
  420. pattern `*.h', `*.c', as well as `yacc' files that match `*.y' or
  421. `*.yacc', and `lex' files that match `*.l' or `*.lex', are processed
  422. with this scanner.
  423.  
  424.    Scanner-specific options (Note, these options are presented WITHOUT
  425. the required `-l' or `--lang-option=' prefix):
  426.  
  427. `-k CHARACTER-CLASS'
  428. `--keep=CHARACTER-CLASS'
  429.      Consider the characters in CHARACTER-CLASS as valid constituents of
  430.      identifier names.  For example, if you are indexing C code that
  431.      contains `$' in some of its identifiers, you can include these by
  432.      using `--lang-option=C:--keep=$', or `-l C:"-k $"' (if you don't
  433.      like to type so much).
  434.  
  435. `-i CHARACTER-CLASS'
  436. `--ignore=CHARACTER-CLASS'
  437.      x mkiConsider the characters in CHARACTER-CLASS as valid
  438.      constituents of identifier names, but discard all tokens
  439.      containing these characters.  For example, if some C code has
  440.      identifiers containing `$', but you don't want these cluttering up
  441.      your ID database, use `--lang-option=C:--ignore=$', or the terser
  442.      equivalent `-l C:"-i $"'.
  443.  
  444. `-u'
  445. `--strip-underscore'
  446.      Strip one leading underscore from C identifiers encapsulated as
  447.      character strings.  This option is useful if you are indexing C
  448.      code that contains symbol-table name strings for systems that
  449.      prepend an underscore to external symbols.  By default, the
  450.      leading underscore is retained.
  451.  
  452. 
  453. File: id-utils.info,  Node: Assembler scanner,  Next: Text scanner,  Prev: C/C++ scanner,  Up: Extraction options
  454.  
  455. Assembly Language Scanner
  456. -------------------------
  457.  
  458.    Assembly languages use a variety of commenting conventions, and
  459. allow a variety of special characters to *dirty up* local symbols,
  460. preventing name space conflicts with symbols defined by higher-level
  461. languages.  Also, some compilation systems prepend an underscore to
  462. external symbols.  The options listed below are designed to address
  463. these differences.
  464.  
  465. `-c CHARACTER-CLASS'
  466. `--comment=CHARACTER-CLASS'
  467.      The characters in CHARACTER-CLASS are considered left delimiters
  468.      for comments that extend until the end of the current line.
  469.  
  470. `-k CHARACTER-CLASS'
  471. `--keep=CHARACTER-CLASS'
  472.      Consider the characters of CHARACTER-CLASS as valid constituents of
  473.      identifier names.  For example, if you are indexing assembly code
  474.      that prepends `.' to assembler directives, and prepends `%' to
  475.      register names, you can keep these characters in the tokens by
  476.      specifying `--lang-option=asm:--keep=.%', or `-l asm:"-k .%"'.
  477.  
  478. `-i CHARACTER-CLASS'
  479. `--ignore=CHARACTER-CLASS'
  480.      Consider the characters of CHARACTER-CLASS as valid consituents of
  481.      identifier names, but discard all tokens containing these
  482.      characters.  For example, if you don't want to clutter your ID
  483.      database with assembler directives that begin with a leading `.'
  484.      or with assembler labels that contain `@', use
  485.      `--lang-option=asm:--ignore=.@', or `-l asm:"-i .@"'.
  486.  
  487. `-u'
  488. `--strip-underscore'
  489.      Strip one leading underscore from identifiers.  This option is
  490.      useful if your compilation system prepends an underscore to
  491.      external symbols.  By stripping the underscore, you can
  492.      canonicalize such names and bring them into conformance the way
  493.      they are expressed in the C language.  By default, the leading
  494.      underscore is retained.
  495.  
  496. `-n'
  497. `--no-cpp'
  498.      Do not recognize C preprocessor directives.  By default, such
  499.      lines are handled in the same way as they are by the C language
  500.      scanner.
  501.  
  502. 
  503. File: id-utils.info,  Node: Text scanner,  Next: Defining scanners,  Prev: Assembler scanner,  Up: Extraction options
  504.  
  505. Text Scanner
  506. ------------
  507.  
  508.    The plain text scanner is intended for human-language documents, or
  509. as the scanner of last resort for files that have no scanner that is
  510. more specific.  It is customizable to the extent that character classes
  511. can be designated as token constituents or as token delimiters.  The
  512. default token constituents are the alpha-numerics; all other characters
  513. are considered token delimiters.
  514.  
  515. `-i CHARACTER-CLASS'
  516. `--include=CHARACTER-CLASS'
  517.      Include characters belonging to CHARACTER-CLASS in tokens.
  518.  
  519. `-x CHARACTER-CLASS'
  520. `--exclude=CHARACTER-CLASS'
  521.      Exclude characters belonging to CHARACTER-CLASS from tokens, i.e.,
  522.      treat them as token delimiters.
  523.  
  524. 
  525. File: id-utils.info,  Node: Defining scanners,  Prev: Text scanner,  Up: Extraction options
  526.  
  527. Defining New Scanners in the Source Code
  528. ----------------------------------------
  529.  
  530.    To add a new scanner in source code, you should add a new section to
  531. the file `scanners.c'.  It might be easiest to clone one of the
  532. existing scanners and modify it as necessary.  For the hypothetical
  533. language FOO, you must define the functions `get_token_foo',
  534. `parse_args_foo', `help_me_foo', as well as the tables
  535. `long_options_foo' and `args_foo'.  If your scanner is modelled after
  536. one of the existing scanners, you'll also need a character-attribute
  537. table `ctype_foo'.
  538.  
  539.    This is not a terribly difficult programming task, but it requires
  540. recompiling and installing the new version of `mkid' and `xtokid'.  You
  541. should use `xtokid' to test the operation of the new scanner.
  542.  
  543.    Once these functions and tables are ready, add function prototypes
  544. and an entry to to the `languages_0' table near the beginning of the
  545. file.
  546.  
  547.    Be warned that the existing scanners are built for speed, not
  548. elegance or readability.  You might wish to create a new scanner that's
  549. easier to read and understand if you don't feel that speed is so
  550. important.
  551.  
  552. 
  553. File: id-utils.info,  Node: mkid invocation,  Next: lid invocation,  Prev: Common options,  Up: Top
  554.  
  555. `mkid': Creating an ID Database
  556. *******************************
  557.  
  558.    `mkid' builds an ID database.  It accepts the names of files and/or
  559. directories on the command line, selects files that have an enabled
  560. scanner, then extracts and stores tokens from those files.  The
  561. resulting ID database is architecture- and byte-order-independent so it
  562. can be shared among all systems.
  563.  
  564.    The primary virtues of `mkid' are speed and high capacity.  The size
  565. of the source trees it can index is limited only by available system
  566. memory.  `mkid''s indexing algorithm is very space-efficient and
  567. exhibits excellent locality-of-reference, and so is capable of
  568. operating with a working-set size that is only half the size of its
  569. virtual address space.  A typical UNIX-like operating system with 16
  570. megabytes of system memory should be able to build an ID database
  571. covering approximately 12,000-14,000 source files totalling
  572. approximately 50-100 Megabytes.  A 66 Mhz 486 computer can build such a
  573. large ID database in approximately 10-15 minutes.
  574.  
  575.    In a future release, `mkid' will be able to incrementally update an
  576. ID database much faster than it can build one from scratch.  Until this
  577. feature becomes available, it might be a good idea to schedule a `cron'
  578. job to regularly update large ID databases during off-hours.
  579.  
  580.    `mkid' writes the ID file, therefore it accepts the `--output' (and
  581. `--file') options as described in *Note Writing options::.  `mkid'
  582. extracts tokens from source files, therefore it accepts the
  583. `--lang-map', `--include', `--exclude', and `--lang-option' options, as
  584. well as the language-specific scanner options, all of which are
  585. described in *Note Extraction options::.  `mkid' walks file trees,
  586. therefore it handles file and directory names on its command line and
  587. the `--prune' option as described in *Note Walker options::.
  588.  
  589.    In addition, `mkid' accepts the following command-line options:
  590.  
  591. `-s'
  592. `--statistics'
  593.      `mkid' reports statistics about resource usage at the end of its
  594.      run.
  595.  
  596. `-v'
  597. `--verbose'
  598.      `mkid' reports statistics about each file as it is scanned, and
  599.      about the resource usage of its indexing algorithm at regular
  600.      intervals.
  601.  
  602. 
  603. File: id-utils.info,  Node: lid invocation,  Next: fid invocation,  Prev: mkid invocation,  Up: Top
  604.  
  605. `lid': Querying an ID Database by Token
  606. ***************************************
  607.  
  608.    The `lid' program accepts PATTERNS on the command line which it
  609. matches against the tokens stored in an ID database.  The
  610. interpretation of a PATTERN is determined by the makeup of the PATTERN
  611. string itself, or can be overridden by command-line options.  If a
  612. PATTERN contains regular expression meta-characters, it is used to
  613. perform a regular-expression substring search.  If no such
  614. meta-characters are present, PATTERN is used to perform a literal word
  615. search.  (By default, all searches are sensitive to alphabetic case.)
  616. If no PATTERN is supplied on the command line, `lid' lists every entry
  617. in the ID database.
  618.  
  619.    `lid' reads the ID database, therefore it accepts the `--file'
  620. option, and consults the `IDPATH' environment variable, as described in
  621. *Note Reading options::.  `lid' lists file names, therefore it accepts
  622. the `--separator' option, as described in *Note File listing options::.
  623.  
  624.    In addition, `lid' accepts the following command-line options:
  625.  
  626. `-i'
  627. `--ignore-case'
  628.      Ignoring differences in alphabetic case between the PATTERN and
  629.      the tokens in the ID database.
  630.  
  631. `-l'
  632. `--literal'
  633.      Match PATTERN as a literal string.  Use this option if PATTERN
  634.      contains regular-expression meta-characters, but you don't wish to
  635.      perform a regular-expression search.
  636.  
  637. `-r'
  638. `--regexp'
  639.      Match PATTERN as an *extended* regular expression(1).  Use this
  640.      option if no regular-expression expression meta-characters are
  641.      present in PATTERN, but you wish to force a regular-expression
  642.      search (note: in this case, a *literal substring* search might be
  643.      faster).
  644.  
  645. `-w'
  646. `--word'
  647.      Match PATTERN using a word-delimited (non substring) search.  This
  648.      is the default for literal searches.
  649.  
  650. `-s'
  651. `--substring'
  652.      Match PATTERN using a substring (non word-delimited) search.  This
  653.      is the default for regular expression searches.
  654.  
  655. `-k STYLE'
  656. `--key=STYLE'
  657.      STYLE can be one of `token', `pattern' or `none'.  This option
  658.      controls how the subject of the query is presented.  This is best
  659.      illustrated by example:
  660.  
  661.           $ lid --key=token '^dest.'
  662.           destaddr       libsys/memcpy.c
  663.           destination    libsys/regex.c
  664.           destlst        libsys/rx.c
  665.           destpos        libsys/rx.c
  666.           destset        libsys/rx.h libsys/rx.c
  667.           
  668.           $ lid --key=pattern '^dest.'
  669.           ^dest.         libsys/rx.h libsys/{memcpy,regex,rx}.c
  670.           
  671.           $ lid --key=none '^dest.'
  672.           libsys/rx.h libsys/{memcpy,regex,rx}.c
  673.  
  674.      When `--key' is either `token' or `pattern', the first column of
  675.      output is a TOKEN or PATTERN, respectively.  When `--key' is
  676.      `none', neither of these is printed, and the file name list begins
  677.      immediately.  The default is `token'.
  678.  
  679. `-R STYLE'
  680. `--result=STYLE'
  681.      STYLE can be one of `filenames', `grep', `edit' or `none'.  This
  682.      option controls how the value associated with the query's KEY
  683.      presented.  When STYLE is `filenames', a list of file names is
  684.      printed (this is the default).  When STYLE is `grep', the lines
  685.      that match PATTERN are printed in the same format as `egrep -n'.
  686.      When STYLE is `edit', the file names are passed to an editor, and
  687.      if possible PATTERN is passed as an initial search string (*note
  688.      eid invocation::.).  When STYLE is `none', the file names are not
  689.      processed in any way.  This can be useful if you wish to see what
  690.      tokens match a PATTERN, but don't care about where they reside.
  691.  
  692. `-d'
  693. `-o'
  694. `-x'
  695.      These options may be used in any combination to specify the radix
  696.      of numeric matches.  `-d' allows matching on decimal numbers, `-o'
  697.      on octal numbers, and `-x' on hexadecimal numbers.  Any
  698.      combination of these options may be used.  The default is to match
  699.      all three radixes.
  700.  
  701. `-F RANGE'
  702. `--frequency=RANGE'
  703.      Match tokens whose occurrence count falls in RANGE.  RANGE may be
  704.      expressed as a single number N, or as a range N`..'M.  Either
  705.      limit of the range may be omitted (e.g., `..'M, or N..`..').  If
  706.      the lower limit N is omitted, it defaults to `1'.  If the upper
  707.      limit is omitted, it defaults in the present implementation to
  708.      `65535', the maximum value of an unsigned 16-bit integer.
  709.  
  710.      Particularly useful queries are `lid -F1', which helps locate
  711.      identifiers that are defined but never used, or are used but never
  712.      defined.  Similarly, `lid -F2' can help find functions that possess
  713.      a prototype declaration and a definition, but are never called.
  714.  
  715. `-a NUMBER'
  716. `--ambiguous=NUMBER'
  717.      List identifiers (not numbers) that are ambiguous for the first
  718.      NUMBER characters.  This feature might be in useful when porting
  719.      programs to ancient pea-brained compilers that don't support long
  720.      identifier names.  However, the best long-term option is to set
  721.      such systems on fire.
  722.  
  723. * Menu:
  724.  
  725. * lid aliases::                 Aliases for specialized lid queries
  726. * Emacs gid interface::         GNU Emacs query interface
  727. * eid invocation::              Invoking an editor on query results
  728.  
  729.    ---------- Footnotes ----------
  730.  
  731.    (1)  Extended regular expressions are the same as those accepted by
  732. `egrep'.
  733.  
  734. 
  735. File: id-utils.info,  Node: lid aliases,  Next: Emacs gid interface,  Up: lid invocation
  736.  
  737. Aliases for Specialized `lid' Queries
  738. =====================================
  739.  
  740.    Historically, the ID utilities have provided several query interfaces
  741. which are specializations of `lid' (*note lid invocation::.).
  742.  
  743. `gid'
  744.      (alias for `lid -R grep') lists all lines containing the requested
  745.      pattern.
  746.  
  747. `eid'
  748.      (alias for `lid -R edit') invokes an editor on all files
  749.      containing the requested pattern, and optionally initiates a text
  750.      search for that pattern.
  751.  
  752. `aid'
  753.      (alias for `lid -ils') treats the requested pattern as a
  754.      case-insensitive literal substring.
  755.  
  756. 
  757. File: id-utils.info,  Node: Emacs gid interface,  Next: eid invocation,  Prev: lid aliases,  Up: lid invocation
  758.  
  759. GNU Emacs query interface
  760. =========================
  761.  
  762.    The `id-utils' source distribution comes with a file `id-utils.el',
  763. which defines a GNU Emacs interface to `gid'.  To install it, put
  764. `id-utils.el' somewhere that Emacs will find it (i.e., in your
  765. `load-path') and put
  766.  
  767.      (autoload 'gid "gid" nil t)
  768.  
  769. in one of Emacs' initialization files, e.g., `~/.emacs'.  You will then
  770. be able to use `M-x gid' to run the command.
  771.  
  772.    The `gid' function prompts you with the word around point.  If you
  773. want to search for something else, simply delete the line and type the
  774. pattern of interest.
  775.  
  776.    The function then runs the `gid' program in a `*compilation*'
  777. buffer, so the normal `next-error' function can be used to visit all
  778. the places the identifier is found (*note Compilation:
  779. (emacs)Compilation.).
  780.  
  781. 
  782. File: id-utils.info,  Node: eid invocation,  Prev: Emacs gid interface,  Up: lid invocation
  783.  
  784. `eid': Invoking an Editor on Query Results
  785. ==========================================
  786.  
  787.    `lid -R edit' is an editing interface for the ID utilities that is
  788. most commonly used with `vi'.  Emacs users should use the interface
  789. defined in `id-utils.el' (*note Emacs gid interface::.).  The ID
  790. utilities include an alias called `eid', and for the sake of brevity,
  791. we'll use this alias for the remainder of this section.  `eid' performs
  792. a `lid'-style, then asks if you wish to edit the files.  If your query
  793. yields more than one line of output, you will be prompted after each
  794. line.  This is the prompt you'll see:
  795.  
  796.      Edit? [y1-9^S/nq]
  797.  
  798. You may respond with:
  799.  
  800. `y'
  801.      Edit all files listed.
  802.  
  803. `1...9'
  804.      Edit all files starting at the N + 1'st file.
  805.  
  806. `/STRING or `CTRL-S'REGEXP'
  807.      Search into the file list, and begin editing with the first file
  808.      name that matches the regular expression REGEXP.
  809.  
  810. `n'
  811.      Don't edit any files.  If another line of query output is pending,
  812.      advance to that line, for which another `Edit?' prompt will appear.
  813.  
  814. `q'
  815.      Quit--don't edit any files, and don't process any more lines of
  816.      query output.
  817.  
  818.    Here is an example:
  819.  
  820.      prompt$ eid FILE \^print
  821.      FILE           {ansi2knr,fid,filenames,idfile,idx,lid,misc,...}.c
  822.      Edit? [y1-9^S/nq] n
  823.      ^print         {ansi2knr,fid,getopt,getopt1,lid,mkid,regex,scanners}.c
  824.      Edit? [y1-9^S/nq] 2
  825.  
  826. This will start editing at `getopt'.c.
  827.  
  828.    `eid' invokes the editor defined by the environment variable
  829. `VISUAL'.  If `VISUAL' is undefined, it uses the environment variable
  830. `EDITOR' instead.  If `EDITOR' is undefined, it defaults to `vi'.  It
  831. is possible for `eid' to pass the editor an initial search pattern so
  832. that your cursor will immediately alight on the token of interest.
  833. This feature is controlled by the following environment variables:
  834.  
  835. `EIDARG'
  836.      A printf(3) format string for the editor argument to search for the
  837.      matching token.  For `vi', this should be `+/%s/'.
  838.  
  839. `EIDLDEL'
  840.      The regular-expression meta-character(s) for delimiting the
  841.      beginning of a word (the ``eid' Left DELimiter').  `eid' inserts
  842.      this in front of the matching token when a word-search is desired.
  843.      For `vi', this should be `\<'.
  844.  
  845. `EIDRDEL'
  846.      The regular-expression meta-character(s) for delimiting the end of
  847.      a word (the ``eid' Right DELimiter').  `eid' inserts this in end
  848.      of the matching token when a word-search is desired.  For `vi',
  849.      this should be `\>'.
  850.  
  851. 
  852. File: id-utils.info,  Node: fid invocation,  Next: fnid invocation,  Prev: lid invocation,  Up: Top
  853.  
  854. `fid': Listing a file's tokens
  855. ******************************
  856.  
  857.    `fid' prints the tokens found in a given file.  If two file names
  858. are passed on the command line, `fid' prints the tokens that are common
  859. to both files (i.e., the *set intersection* of the two token sets).
  860.  
  861.    `lid' reads the ID database, therefore it accepts the `--file'
  862. option, and consults the `IDPATH' environment variable, as described in
  863. *Note Reading options::.
  864.  
  865.    If the standard output is attached to a terminal, the printed tokens
  866. are separated by spaces.  Otherwise, the tokens are printed one per
  867. line.
  868.  
  869. 
  870. File: id-utils.info,  Node: fnid invocation,  Next: xtokid invocation,  Prev: fid invocation,  Up: Top
  871.  
  872. `fnid': Looking up filenames
  873. ****************************
  874.  
  875.    `fnid' queries the list of file names stored in the ID database.  It
  876. accepts shell *wildcard* patterns on the command line.  If no pattern
  877. is supplied, `*' is implied.  `fnid' prints the file names that match
  878. the given patterns.
  879.  
  880.    `fnid' prints file names, and as such accepts the `--separator'
  881. option as described in *Note File listing options::.
  882.  
  883.    For example, the command:
  884.  
  885.      fnid \*.c
  886.  
  887. lists all the `.c' files in the database.  (The `\' here protects the
  888. `*' from being expanded by the shell.)
  889.  
  890. 
  891. File: id-utils.info,  Node: xtokid invocation,  Next: Past and Future,  Prev: fnid invocation,  Up: Top
  892.  
  893. `xtokid': Testing Language Scanners
  894. ***********************************
  895.  
  896.    `xtokid' accepts the names of files and/or directories on the
  897. command line, then extracts and prints a stream of tokens from those
  898. files for which it has a valid, enabled scanner.  This is useful
  899. primarily for debugging new `mkid' scanners (*note Defining
  900. scanners::.).
  901.  
  902.    `xtokid' extracts tokens from source files, therefore it accepts the
  903. `--lang-map', `--include', `--exclude', and `--lang-option' options, as
  904. well as the language-specific scanner options, all of which are
  905. described in *Note Extraction options::.  `xtokid' walks file trees,
  906. therefore it handles file and directory names on its command line and
  907. the `--prune' option as described in *Note Walker options::.
  908.  
  909.    The name `xtokid' indicates that it is the "eXtract TOKens ID
  910. utility".
  911.  
  912. 
  913. File: id-utils.info,  Node: Past and Future,  Next: Index,  Prev: xtokid invocation,  Up: Top
  914.  
  915. Past and Future
  916. ***************
  917.  
  918.    Greg McGary conceived of the ideas behind the ID utilities when he
  919. began working on the Unix kernel in 1984.  He needed a navigation tool
  920. to help him find his way around the expansive, unfamiliar landscape.
  921. The first `id-utils'-like tools were shell scripts, and produced an
  922. ASCII database that looks much like the output of `lid ".*"'.  It took
  923. over an hour on a VAX 11/750 to build a database for a 4.1BSD derived
  924. kernel.  The first version of `lid' used the UNIX system utility
  925. `look', modified to handle very long lines.
  926.  
  927.    In 1986, Greg rewrote the shell scripts in C to improve performance.
  928. Build times for the ID file were shortened by an order of magnitude.
  929. The ID utilities were first posted to `comp.sources.unix' in September
  930. 1987 under the name `id'.
  931.  
  932.    Over the next few years, several versions diverged from the original
  933. source.  Tom Horsley at Harris Computer Systems Division stepped forward
  934. to take over maintenance and integrated some of the fixes from divergent
  935. versions.  A first release of the renamed `mkid' version 2 was posted
  936. to `alt.sources' near the end of 1990.  At that time, Tom wrote a
  937. Texinfo manual with the encouragement the net community.  (Tom
  938. especially thanks Doug Scofield and Bill Leonard whom he dragooned into
  939. helping poorfraed and edit--they found several problems in the initial
  940. version.)  Karl Berry revamped the manual for Texinfo style, indexing,
  941. and organization in 1995.
  942.  
  943.    In January 1995, Greg McGary reemerged as the primary maintainer and
  944. launched development of `mkid' version 3, whose primary new feature is
  945. an efficient algorithm for building databases that is linear in both
  946. time and space over the size of the input text.  (The old algorithm was
  947. quadratic in space so it was incapable of handling very large source
  948. trees.)  For the first time, the code was released under the GNU Public
  949. License.
  950.  
  951.    In June 1996, the package was renamed again to `id-utils' and was
  952. released for the first time under FSF copyright as part of the GNU
  953. system.  All programs had their command-line arguments completely
  954. revised.  The `mkid' and `xtokid' programs also gained a file-tree
  955. walker, so that directory names can be passed on the command line
  956. instead of the names of every individual file.  Greg reorganized and
  957. rewrote most of the Texinfo manual to reflect these changes.
  958.  
  959.    Future releases of `id-utils' might include:
  960.  
  961.      an optional coupling with GNU `grep', so that `grep' can use an ID
  962.      database for hints
  963.  
  964.      a `cscope' work-alike query interface
  965.  
  966.      incremental update of the ID database.
  967.  
  968. 
  969. File: id-utils.info,  Node: Index,  Prev: Past and Future,  Up: Top
  970.  
  971. Index
  972. *****
  973.  
  974. * Menu:
  975.  
  976. * *compilation* Emacs buffer:           Emacs gid interface.
  977. * -ambiguous:                           lid invocation.
  978. * -comment:                             Assembler scanner.
  979. * -exclude <1>:                         Extraction options.
  980. * -exclude:                             Text scanner.
  981. * -file <1>:                            Writing options.
  982. * -file:                                Reading options.
  983. * -frequency:                           lid invocation.
  984. * -help:                                Universal options.
  985. * -ignore <1>:                          Assembler scanner.
  986. * -ignore:                              C/C++ scanner.
  987. * -ignore-case:                         lid invocation.
  988. * -include <1>:                         Extraction options.
  989. * -include:                             Text scanner.
  990. * -keep <1>:                            Assembler scanner.
  991. * -keep:                                C/C++ scanner.
  992. * -lang-map:                            Extraction options.
  993. * -lang-option:                         Extraction options.
  994. * -lang-option=asm:-comment:            Assembler scanner.
  995. * -lang-option=asm:-ignore:             Assembler scanner.
  996. * -lang-option=asm:-keep:               Assembler scanner.
  997. * -lang-option=asm:-no-cpp:             Assembler scanner.
  998. * -lang-option=asm:-strip-underscore:   Assembler scanner.
  999. * -lang-option=asm:-c:                  Assembler scanner.
  1000. * -lang-option=asm:-i:                  Assembler scanner.
  1001. * -lang-option=asm:-k:                  Assembler scanner.
  1002. * -lang-option=asm:-n:                  Assembler scanner.
  1003. * -lang-option=asm:-u:                  Assembler scanner.
  1004. * -lang-option=C:-ignore:               C/C++ scanner.
  1005. * -lang-option=C:-keep:                 C/C++ scanner.
  1006. * -lang-option=C:-strip-underscore:     C/C++ scanner.
  1007. * -lang-option=C:-i:                    C/C++ scanner.
  1008. * -lang-option=C:-k:                    C/C++ scanner.
  1009. * -lang-option=C:-u:                    C/C++ scanner.
  1010. * -lang-option=text:-exclude:           Text scanner.
  1011. * -lang-option=text:-include:           Text scanner.
  1012. * -lang-option=text:-i:                 Text scanner.
  1013. * -lang-option=text:-x:                 Text scanner.
  1014. * -literal:                             lid invocation.
  1015. * -no-cpp:                              Assembler scanner.
  1016. * -output:                              Writing options.
  1017. * -prune:                               Walker options.
  1018. * -regexp:                              lid invocation.
  1019. * -result:                              lid invocation.
  1020. * -separator:                           File listing options.
  1021. * -statistics:                          mkid invocation.
  1022. * -strip-underscore <1>:                Assembler scanner.
  1023. * -strip-underscore:                    C/C++ scanner.
  1024. * -substring:                           lid invocation.
  1025. * -verbose:                             mkid invocation.
  1026. * -version:                             Universal options.
  1027. * -word:                                lid invocation.
  1028. * -a:                                   lid invocation.
  1029. * -c:                                   Assembler scanner.
  1030. * -d:                                   lid invocation.
  1031. * -F:                                   lid invocation.
  1032. * -f <1>:                               Reading options.
  1033. * -f:                                   Writing options.
  1034. * -i <1>:                               Extraction options.
  1035. * -i <2>:                               lid invocation.
  1036. * -i <3>:                               Text scanner.
  1037. * -i <4>:                               Assembler scanner.
  1038. * -i:                                   C/C++ scanner.
  1039. * -k <1>:                               Assembler scanner.
  1040. * -k <2>:                               lid invocation.
  1041. * -k:                                   C/C++ scanner.
  1042. * -l <1>:                               Extraction options.
  1043. * -l:                                   lid invocation.
  1044. * -l asm:-comment:                      Assembler scanner.
  1045. * -l asm:-ignore:                       Assembler scanner.
  1046. * -l asm:-keep:                         Assembler scanner.
  1047. * -l asm:-no-cpp:                       Assembler scanner.
  1048. * -l asm:-strip-underscore:             Assembler scanner.
  1049. * -l asm:-c:                            Assembler scanner.
  1050. * -l asm:-i:                            Assembler scanner.
  1051. * -l asm:-k:                            Assembler scanner.
  1052. * -l asm:-n:                            Assembler scanner.
  1053. * -l asm:-u:                            Assembler scanner.
  1054. * -l C:-ignore:                         C/C++ scanner.
  1055. * -l C:-keep:                           C/C++ scanner.
  1056. * -l C:-strip-underscore:               C/C++ scanner.
  1057. * -l C:-i:                              C/C++ scanner.
  1058. * -l C:-k:                              C/C++ scanner.
  1059. * -l C:-u:                              C/C++ scanner.
  1060. * -l text:-exclude:                     Text scanner.
  1061. * -l text:-include:                     Text scanner.
  1062. * -l text:-i:                           Text scanner.
  1063. * -l text:-x:                           Text scanner.
  1064. * -m:                                   Extraction options.
  1065. * -n:                                   Assembler scanner.
  1066. * -o <1>:                               lid invocation.
  1067. * -o:                                   Writing options.
  1068. * -p:                                   Walker options.
  1069. * -R:                                   lid invocation.
  1070. * -s:                                   lid invocation.
  1071. * -S:                                   File listing options.
  1072. * -s:                                   mkid invocation.
  1073. * -u <1>:                               C/C++ scanner.
  1074. * -u:                                   Assembler scanner.
  1075. * -v:                                   mkid invocation.
  1076. * -w:                                   lid invocation.
  1077. * -x <1>:                               Extraction options.
  1078. * -x <2>:                               lid invocation.
  1079. * -x:                                   Text scanner.
  1080. * mkid progress:                        mkid invocation.
  1081. * alphabetic case, ignoring differences in: lid invocation.
  1082. * ambiguous identifier names, finding:  lid invocation.
  1083. * architecture-independence:            mkid invocation.
  1084. * assembler scanner:                    Assembler scanner.
  1085. * assembly language scanner:            Assembler scanner.
  1086. * beginning-of-word editor argument:    eid invocation.
  1087. * Berry, Karl:                          Past and Future.
  1088. * bugs, reporting:                      Introduction.
  1089. * C scanner, predefined:                C/C++ scanner.
  1090. * common command-line options:          Common options.
  1091. * creating databases:                   mkid invocation.
  1092. * cron:                                 mkid invocation.
  1093. * cscope:                               Past and Future.
  1094. * databases, creating:                  mkid invocation.
  1095. * eid:                                  eid invocation.
  1096. * EIDARG:                               eid invocation.
  1097. * EIDLDEL:                              eid invocation.
  1098. * EIDRDEL:                              eid invocation.
  1099. * Emacs interface to gid:               Emacs gid interface.
  1100. * end-of-word editor argument:          eid invocation.
  1101. * exclude languages:                    Extraction options.
  1102. * fid:                                  fid invocation.
  1103. * file name separator:                  File listing options.
  1104. * file tree pruning:                    Walker options.
  1105. * filenames, matching:                  fnid invocation.
  1106. * fnid:                                 fnid invocation.
  1107. * future:                               Past and Future.
  1108. * gid Emacs function:                   Emacs gid interface.
  1109. * grep:                                 Past and Future.
  1110. * help, online:                         Universal options.
  1111. * history:                              Past and Future.
  1112. * Horsley, Tom:                         Past and Future.
  1113. * ID database file name <1>:            Reading options.
  1114. * ID database file name <2>:            Writing options.
  1115. * ID database file name <3>:            Reading options.
  1116. * ID database file name:                Writing options.
  1117. * ID database, definition of:           Introduction.
  1118. * ID file format:                       mkid invocation.
  1119. * id-utils.el interface to Emacs:       Emacs gid interface.
  1120. * ignoring differences in alphabetic case: lid invocation.
  1121. * include languages:                    Extraction options.
  1122. * introduction:                         Introduction.
  1123. * language map file:                    Extraction options.
  1124. * language-specific option:             Extraction options.
  1125. * languages_0:                          Defining scanners.
  1126. * left delimiter editor argument:       eid invocation.
  1127. * Leonard, Bill:                        Past and Future.
  1128. * load-path:                            Emacs gid interface.
  1129. * look and mkid 1:                      Past and Future.
  1130. * matching filenames:                   fnid invocation.
  1131. * McGary, Greg:                         Past and Future.
  1132. * numeric matches, specifying radix of: lid invocation.
  1133. * overview:                             Introduction.
  1134. * radix of numeric matches, specifying: lid invocation.
  1135. * right delimiter editor argument:      eid invocation.
  1136. * scanners:                             Extraction options.
  1137. * scanners, defining in source code:    Defining scanners.
  1138. * scanners.c:                           Defining scanners.
  1139. * Scofield, Doug:                       Past and Future.
  1140. * search for token, initial:            eid invocation.
  1141. * sharing ID files:                     mkid invocation.
  1142. * single matches, showing:              lid invocation.
  1143. * statistics:                           mkid invocation.
  1144. * text scanner:                         Text scanner.
  1145. * tokens common to two files:           fid invocation.
  1146. * tokens in a file:                     fid invocation.
  1147. * version number, finding:              Universal options.
  1148.  
  1149.  
  1150. 
  1151. Tag Table:
  1152. Node: Top1304
  1153. Node: Introduction2057
  1154. Node: Quick start4586
  1155. Node: Common options5511
  1156. Node: Universal options6309
  1157. Node: Reading options6634
  1158. Node: Writing options7751
  1159. Node: Walker options8247
  1160. Node: File listing options9086
  1161. Node: Extraction options10177
  1162. Node: Language map12727
  1163. Node: C/C++ scanner14933
  1164. Node: Assembler scanner16548
  1165. Node: Text scanner18644
  1166. Node: Defining scanners19452
  1167. Node: mkid invocation20674
  1168. Node: lid invocation22955
  1169. Node: lid aliases28340
  1170. Node: Emacs gid interface29018
  1171. Node: eid invocation29935
  1172. Node: fid invocation32519
  1173. Node: fnid invocation33206
  1174. Node: xtokid invocation33881
  1175. Node: Past and Future34820
  1176. Node: Index37512
  1177. 
  1178. End Tag Table
  1179.