home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / textprocess / armatures / bibtex / files / !BiBTeX / !Help < prev    next >
Text File  |  1990-05-19  |  13KB  |  396 lines

  1. BIBTEX(1)           UNIX Programmer's Manual            BIBTEX(1)
  2.  
  3.  
  4.  
  5. NAME
  6.      bibtex - make a LaTeX bibliography
  7.  
  8. SYNOPSIS
  9.      bibtex auxname
  10.  
  11. DESCRIPTION
  12.      Bibtex reads the top-level auxilliary (.aux) file output
  13.      during the running of latex (1) and creates a bibliography
  14.      (.bbl) file that can be included in the LaTeX source file.
  15.      The auxname on the command line should be given without an
  16.      extension.  Each \cite in the source file is looked up in
  17.      bibliography files to gather together those used in the
  18.      document.  Then a bibliography style file is executed to
  19.      write a \thebibliography environment.
  20.  
  21.      The source file should have defined the bibliography (.bib)
  22.      files to search with the \bibliography command, and the
  23.      bibliography style (.bst) file to execute with the
  24.      \bibliographystyle command.  Bibtex incorporates the path
  25.      searching mechanism described in the manual page for tex
  26.      (1). It searches the TEXINPUTS path for .aux, .bbl, and .bst
  27.      files.
  28.  
  29.      Eventually there will be a section in the LaTeX manual
  30.      describing the bibliography and bibliography style formats.
  31.      For now, here are brief descriptions.
  32.  
  33.  
  34. Bibliography File
  35.      The bibliography file (.bib) format is just about a subset
  36.      of that allowed in Scribe bibliographies.  Only the delim-
  37.      iter pairs {...} and "..." are allowed inside entries.
  38.      Entries themselves can be delimited by (...) also.  The =
  39.      sign between field names and field values is not optional.
  40.  
  41.      There are a number of conventions that should be followed
  42.      when writing .bib files.  These are not requirements of bib-
  43.      tex, but standard bibliography style files will typically
  44.      expect these conventions to be followed.
  45.  
  46.      References should be categorized as in Scribe into one of
  47.      the categories: article, book, booklet, inbook, incollec-
  48.      tion, inproceedings, manual, mastersthesis, misc, phdthesis,
  49.      proceedings, techreport, and unpublished.  See the Scribe
  50.      manual for the fields that must/can appear in each type of
  51.      reference.
  52.  
  53.      The title field should be entered in uppers-and-lowers for-
  54.      mat, where everything is capitilized except articles and
  55.      unstressed conjunctions and prepositions, and even those are
  56.      capitilized if they are the first word or the first word
  57.  
  58.  
  59.  
  60. Printed 10/11/89                                                1
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67. BIBTEX(1)           UNIX Programmer's Manual            BIBTEX(1)
  68.  
  69.  
  70.  
  71.      after a colon.  Some style files will convert all words
  72.      except the first to all lowercase.  This is a mistake for
  73.      things like proper nouns, so you have to tell bibtex not to
  74.      touch such capital letters by enclosing them in braces, as
  75.      in "Dogs of {A}merica".  It is unlikely that any style file
  76.      would attempt to convert book titles to lowercase, so
  77.      perhaps you can omit braces in such titles.
  78.  
  79.      The author and editor fields should conform to a particular
  80.      format, so that the style file can parse them into parts.  A
  81.      name can have four parts: first, von, last, junior, each of
  82.      which can consist of more than one word.  For example, "John
  83.      Paul von Braun, Jr." has "John Paul" as the first part,
  84.      "von" as the von part, "Braun" as the last part, and "Jr."
  85.      as the junior part.  Use one of these formats for a name:
  86.           First von Last
  87.           von Last, First
  88.           von Last, Junior, First
  89.      The last part is assumed to be one word, or all the words
  90.      after the von part.  Bibtex will treat anything in braces as
  91.      one word, so use braces to surround last names that contain
  92.      more than one word.  The von part is recognized by looking
  93.      for words that begin with lowercase letters.  When possible,
  94.      enter the full first name(s);  style files may abbreviate by
  95.      taking the first letter.  Actually, the rules for isolating
  96.      the name parts are a bit more complicated, so they do the
  97.      right thing for names like "de la Grand Round, Chuck".
  98.      There is no need for a field like Scribe's fullauthor field.
  99.  
  100.      If there are multiple authors or editors, they should all be
  101.      separated by the word and.  Scribe's editors field should
  102.      not be used, since bibtex style files can count how many
  103.      names are in an editor field.
  104.  
  105.  
  106. Bibliography Style File
  107.      Style (.bst) files are written in a postfix stack language.
  108.      A dedicated hacker can probably figure out how to program in
  109.      it by looking at an existing style file.  The following
  110.      descriptions of builtin functions may help.  in the descrip-
  111.      tions, "first", "second", etc., refer to the order popped.
  112.  
  113.      +    Pop the top two (integer) literals and push their sum.
  114.  
  115.      -    Pop the top two (integer) literals and push their
  116.           difference (the first subtracted from the second).
  117.  
  118.      >    Pop the top two (integer) literals, compare them, and
  119.           push the integer 1 if the second is greater than the
  120.           first, 0 otherwise.
  121.  
  122.      <    Pop the top two (integer) literals, compare them, and
  123.  
  124.  
  125.  
  126. Printed 10/11/89                                                2
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133. BIBTEX(1)           UNIX Programmer's Manual            BIBTEX(1)
  134.  
  135.  
  136.  
  137.           push the integer 1 if the second is less than the
  138.           first, 0 otherwise.
  139.  
  140.      =    Pop the top two (integer or string) literals, compare
  141.           them, and push the integer 1 if they're equal, 0 other-
  142.           wise.
  143.  
  144.      *    Pop the top two (string) literals, concatenate them (in
  145.           reverse order, that is, the order in which pushed), and
  146.           push the resulting string back onto the stack.
  147.  
  148.      :=   Pop the top two literals and assign to the second the
  149.           value of the first.  Integer and string variables can
  150.           be declared with "INTEGERS {i1 i2 ...}" and "STRINGS
  151.           {s1 s2 ...}", respectively.
  152.  
  153.      add.period$
  154.           Pop the top (string) literal, add a period to it if the
  155.           last non-right-brace character isn't a period, question
  156.           mark, or exclamation-mark, and push this resulting
  157.           string back onto the stack.
  158.  
  159.      call.type$
  160.           Execute the function corresponding to the reference
  161.           classification of the current entry.  For example, when
  162.           processing an @INBOOK entry, call the "inbook" function
  163.           if it is defined, otherwise call the "default.type"
  164.           function.  Functions are declared with the FUNCTION
  165.           command: the first argument is the function name and
  166.           the second is the body.  An ENTRY command declares the
  167.           variables that may be used in the style file when pro-
  168.           cessing an entry.  It has three brace-surrounded argu-
  169.           ments: a list of field names that may occur in the
  170.           entry (these are read-only variables returning the
  171.           value assigned to the fields in the current entry), a
  172.           list of local integer variables, and a list of local
  173.           string variables.
  174.  
  175.      change.case$
  176.           Pop the top two (string) literals; change the case of
  177.           the second according to the specifications of the
  178.           first, as follows.  (Note: The word `letters' in the
  179.           next sentence refers only to those at brace-level 0,
  180.           the top-most brace level; no other characters are
  181.           changed.)  If the first literal is the string ul, con-
  182.           vert all letters to lower case except the very first
  183.           character in the string, which should be converted to
  184.           upper case; if it's the string uu, convert all letters
  185.           to upper case; if it's the string ll, convert all
  186.           letters to lower case; if it's the string lu, convert
  187.           all letters to upper case except the very first charac-
  188.           ter in the string, which it converts to lower case.
  189.  
  190.  
  191.  
  192. Printed 10/11/89                                                3
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199. BIBTEX(1)           UNIX Programmer's Manual            BIBTEX(1)
  200.  
  201.  
  202.  
  203.           Then push this resulting string.
  204.  
  205.      chr.to.int$
  206.           Pop the top (string) literal, make sure it's a single
  207.           character, convert it to the corresponding ASCII-code
  208.           integer, and push that integer.
  209.  
  210.      cite$
  211.           Push the string used in a cite of the current entry
  212.           (i.e., the codeword that appears at the beginning of
  213.           the entry).
  214.  
  215.      duplicate$
  216.           Push a duplicate of the stack top onto the stack.
  217.  
  218.      format.name$
  219.           Pop the top three literals (they are a string, an
  220.           integer, and a string literal, in that order).  The
  221.           last string literal represents a name list (each name
  222.           corresponding to a person), the integer literal speci-
  223.           fies which name to pick from this list, and the first
  224.           string literal specifies how to format this name.  Push
  225.           the formatted name.  The first string literal should be
  226.           something like "{ff }{vv }{ll}{, jj}", or "{vv }{ll}{,
  227.           jj}{, f}". In such a string, an f stands for the first
  228.           name part, a v stands for the von part, etc.  The dou-
  229.           bled letters mean "put the whole part here" and the
  230.           single letters mean "put an abbreviation (first
  231.           letter(s)) here".  These formatting letters should
  232.           occur at brace level 1.  If any of the corresponding
  233.           parts of the name is missing, everything in the brace
  234.           group corresponding to that part is omitted.
  235.  
  236.      if$  Pop the top three literals (they are two function
  237.           literals and an integer literal, in that order); if the
  238.           integer is greater than 0, execute the second literal,
  239.           else execute the first.
  240.  
  241.      int.to.chr$
  242.           Pop the top (integer) literal interpreted as the ASCII
  243.           code of a single character, convert it to the
  244.           corresponding single-character string, and push that
  245.           string.
  246.  
  247.      int.to.str$
  248.           Pop the top (integer) literal, convert it to its
  249.           (unique) string equivalent, and push that string.
  250.  
  251.      missing$
  252.           Pop the top literal and push the integer 1 if it's a
  253.           missing field (the current entry didn't have an assign-
  254.           ment for it), 0 otherwise.
  255.  
  256.  
  257.  
  258. Printed 10/11/89                                                4
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265. BIBTEX(1)           UNIX Programmer's Manual            BIBTEX(1)
  266.  
  267.  
  268.  
  269.      newline$
  270.           Write whatever has accumulated in the output buffer
  271.           onto the .bbl file, followed by a newline character.
  272.  
  273.      num.names$
  274.           Pop the top (string) literal; push the number of names
  275.           the string represents: one plus the number of
  276.           occurrences of the substring "and" surrounded by non-
  277.           null white-space (ignoring case differences) at the top
  278.           brace level.
  279.  
  280.      purify$
  281.           Pop the top (string) literal, convert upper-case
  282.           letters to lower case, remove nonalphanumeric charac-
  283.           ters except for white-space characters (one or more
  284.           consecutive ones get compressed to a single space), and
  285.           push the resulting string.
  286.  
  287.      quote$
  288.           Push the string consisting of the double-quote charac-
  289.           ter.
  290.  
  291.      skip$
  292.           Do nothing.
  293.  
  294.      stack$
  295.           Pop and print the whole stack on the terminal and log
  296.           file.
  297.  
  298.      substring$
  299.           Pop the top three literals (they are the two integers
  300.           literals len and start and a string literal, in that
  301.           order).  Push the substring of the (at most) len con-
  302.           secutive characters starting at the startth character
  303.           (assuming 1-based indexing) if len is positive, and
  304.           ending at the -startth character from the end if start
  305.           is negative (where the first character from the end is
  306.           the last character).
  307.  
  308.      swap$
  309.           Swap the top two elements of the stack.
  310.  
  311.      top$ Pop and print the top of the stack on the terminal and
  312.           log file.
  313.  
  314.      type$
  315.           Push the reference classification type (book, article,
  316.           etc.), of the current entry onto the stack (unless
  317.           either it's empty or undefined, in which case push the
  318.           null string).
  319.  
  320.      while$
  321.  
  322.  
  323.  
  324. Printed 10/11/89                                                5
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331. BIBTEX(1)           UNIX Programmer's Manual            BIBTEX(1)
  332.  
  333.  
  334.  
  335.           Pop the top two (function) literals, and keep executing
  336.           the second as long as the (integer) value left on the
  337.           stack by executing the first is greater than 0.
  338.  
  339.      width$
  340.           Pop the top (string) literal and push the integer that
  341.           represents its width.  The width is currently calcu-
  342.           lated in hundredths of a point, using the character
  343.           widths of the amr10 font.  The only white-space charac-
  344.           ter with non-zero width is the space.  However, the
  345.           width returned should only be used in comparisons with
  346.           other such widths.
  347.  
  348.      write$
  349.           Pop the top (string) literal and write it on the .bbl
  350.           file.
  351.  
  352.  
  353. SEE ALSO
  354.      latex(1), tex(1).
  355.  
  356. BUGS
  357.      The cacm style file is really just a skeleton so far.
  358.  
  359. HISTORY
  360.      Written by Oren Patashnik under the direction of Leslie Lam-
  361.      port.  Ported to UNIX by Howard Trickey, June 1984.
  362.  
  363.  
  364.  
  365.  
  366.  
  367.  
  368.  
  369.  
  370.  
  371.  
  372.  
  373.  
  374.  
  375.  
  376.  
  377.  
  378.  
  379.  
  380.  
  381.  
  382.  
  383.  
  384.  
  385.  
  386.  
  387.  
  388.  
  389.  
  390. Printed 10/11/89                                                6
  391.  
  392.  
  393.  
  394.  
  395.  
  396.