home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / flex-2.5.2-src.tgz / tar.out / fsf / flex / NEWS < prev    next >
Text File  |  1996-09-28  |  45KB  |  1,207 lines
  1. Changes between release 2.5.2 (25Apr95) and release 2.5.1:
  2.  
  3.     - The --prefix configuration option now works.
  4.  
  5.     - A bug that completely broke the "-Cf" table compression
  6.       option has been fixed.
  7.  
  8.     - A major headache involving "const" declarators and Solaris
  9.       systems has been fixed.
  10.  
  11.     - An octal escape sequence in a flex regular expression must
  12.       now contain only the digits 0-7.
  13.  
  14.     - You can now use "--" on the flex command line to mark the
  15.       end of flex options.
  16.  
  17.     - You can now specify the filename '-' as a synonym for stdin.
  18.  
  19.     - By default, the scanners generated by flex no longer
  20.       statically initialize yyin and yyout to stdin and stdout.
  21.       This change is necessary because in some ANSI environments,
  22.       stdin and stdout are not compile-time constant.  You can
  23.       force the initialization using "%option stdinit" in the first
  24.       section of your flex input.
  25.  
  26.     - "%option nounput" now correctly omits the unput() routine
  27.       from the output.
  28.  
  29.     - "make clean" now removes config.log, config.cache, and the
  30.       flex binary.  The fact that it removes the flex binary means
  31.       you should take care if making changes to scan.l, to make
  32.       sure you don't wind up in a bootstrap problem.
  33.  
  34.     - In general, the Makefile has been reworked somewhat (thanks
  35.       to Francois Pinard) for added flexibility - more changes will
  36.       follow in subsequent releases.
  37.  
  38.     - The .texi and .info files in MISC/texinfo/ have been updated,
  39.       thanks also to Francois Pinard.
  40.  
  41.     - The FlexLexer::yylex(istream* new_in, ostream* new_out) method
  42.       now does not have a default for the first argument, to disambiguate
  43.       it from FlexLexer::yylex().
  44.  
  45.     - A bug in destructing a FlexLexer object before doing any scanning
  46.       with it has been fixed.
  47.  
  48.     - A problem with including FlexLexer.h multiple times has been fixed.
  49.  
  50.     - The alloca() chud necessary to accommodate bison has grown
  51.       even uglier, but hopefully more correct.
  52.  
  53.     - A portability tweak has been added to accommodate compilers that
  54.       use char* generic pointers.
  55.  
  56.     - EBCDIC contact information in the file MISC/EBCDIC has been updated.
  57.  
  58.     - An OS/2 Makefile and config.h for flex 2.5 is now available in
  59.       MISC/OS2/, contributed by Kai Uwe Rommel.
  60.  
  61.     - The descrip.mms file for building flex under VMS has been updated,
  62.       thanks to Pat Rankin.
  63.  
  64.     - The notes on building flex for the Amiga have been updated for
  65.       flex 2.5, contributed by Andreas Scherer.
  66.  
  67.  
  68. Changes between release 2.5.1 (28Mar95) and release 2.4.7:
  69.  
  70.     - A new concept of "start condition" scope has been introduced.
  71.       A start condition scope is begun with:
  72.  
  73.         <SCs>{
  74.  
  75.       where SCs is a list of one or more start conditions.  Inside
  76.       the start condition scope, every rule automatically has the
  77.       prefix <SCs> applied to it, until a '}' which matches the
  78.       initial '{'.  So, for example:
  79.  
  80.         <ESC>{
  81.             "\\n"    return '\n';
  82.             "\\r"    return '\r';
  83.             "\\f"    return '\f';
  84.             "\\0"    return '\0';
  85.         }
  86.  
  87.       is equivalent to:
  88.  
  89.         <ESC>"\\n"    return '\n';
  90.         <ESC>"\\r"    return '\r';
  91.         <ESC>"\\f"    return '\f';
  92.         <ESC>"\\0"    return '\0';
  93.  
  94.       As indicated in this example, rules inside start condition scopes
  95.       (and any rule, actually, other than the first) can be indented,
  96.       to better show the extent of the scope.
  97.  
  98.       Start condition scopes may be nested.
  99.  
  100.     - The new %option directive can be used in the first section of
  101.       a flex scanner to control scanner-generation options.  Most
  102.       options are given simply as names, optionally preceded by the
  103.       word "no" (with no intervening whitespace) to negate their
  104.       meaning.  Some are equivalent to flex flags, so putting them
  105.       in your scanner source is equivalent to always specifying
  106.       the flag (%option's take precedence over flags):
  107.  
  108.         7bit    -7 option
  109.         8bit    -8 option
  110.         align    -Ca option
  111.         backup    -b option
  112.         batch    -B option
  113.         c++    -+ option
  114.         caseful    opposite of -i option (caseful is the default);
  115.         case-sensitive    same as above
  116.         caseless    -i option;
  117.         case-insensitive    same as above
  118.         debug    -d option
  119.         default    opposite of -s option
  120.         ecs    -Ce option
  121.         fast    -F option
  122.         full    -f option
  123.         interactive    -I option
  124.         lex-compat    -l option
  125.         meta-ecs    -Cm option
  126.         perf-report    -p option
  127.         read    -Cr option
  128.         stdout    -t option
  129.         verbose    -v option
  130.         warn    opposite of -w option (so use "%option nowarn" for -w)
  131.  
  132.         array    equivalent to "%array"
  133.         pointer    equivalent to "%pointer" (default)
  134.  
  135.       Some provide new features:
  136.  
  137.         always-interactive    generate a scanner which always
  138.             considers its input "interactive" (no call to isatty()
  139.             will be made when the scanner runs)
  140.         main    supply a main program for the scanner, which
  141.             simply calls yylex().  Implies %option noyywrap.
  142.         never-interactive    generate a scanner which never
  143.             considers its input "interactive" (no call to isatty()
  144.             will be made when the scanner runs)
  145.         stack    if set, enable start condition stacks (see below)
  146.         stdinit    if unset ("%option nostdinit"), initialize yyin
  147.             and yyout statically to nil FILE* pointers, instead
  148.             of stdin and stdout
  149.         yylineno    if set, keep track of the current line
  150.             number in global yylineno (this option is expensive
  151.             in terms of performance).  The line number is available
  152.             to C++ scanning objects via the new member function
  153.             lineno().
  154.         yywrap    if unset ("%option noyywrap"), scanner does not
  155.             call yywrap() upon EOF but simply assumes there
  156.             are no more files to scan
  157.  
  158.       Flex scans your rule actions to determine whether you use the
  159.       REJECT or yymore features (this is not new).  Two %options can be
  160.       used to override its decision, either by setting them to indicate
  161.       the feature is indeed used, or unsetting them to indicate it
  162.       actually is not used:
  163.  
  164.         reject
  165.         yymore
  166.  
  167.       Three %option's take string-delimited values, offset with '=':
  168.  
  169.         outfile="<name>"    equivalent to -o<name>
  170.         prefix="<name>"        equivalent to -P<name>
  171.         yyclass="<name>"    set the name of the C++ scanning class
  172.                     (see below)
  173.  
  174.       A number of %option's are available for lint purists who
  175.       want to suppress the appearance of unneeded routines in
  176.       the generated scanner.  Each of the following, if unset,
  177.       results in the corresponding routine not appearing in the
  178.       generated scanner:
  179.  
  180.         input, unput
  181.         yy_push_state, yy_pop_state, yy_top_state
  182.         yy_scan_buffer, yy_scan_bytes, yy_scan_string
  183.  
  184.       You can specify multiple options with a single %option directive,
  185.       and multiple directives in the first section of your flex input file.
  186.  
  187.     - The new function:
  188.  
  189.         YY_BUFFER_STATE yy_scan_string( const char *str )
  190.  
  191.       returns a YY_BUFFER_STATE (which also becomes the current input
  192.       buffer) for scanning the given string, which occurs starting
  193.       with the next call to yylex().  The string must be NUL-terminated.
  194.       A related function:
  195.  
  196.         YY_BUFFER_STATE yy_scan_bytes( const char *bytes, int len )
  197.  
  198.       creates a buffer for scanning "len" bytes (including possibly NUL's)
  199.       starting at location "bytes".
  200.  
  201.       Note that both of these functions create and scan a *copy* of
  202.       the string/bytes.  (This may be desirable, since yylex() modifies
  203.       the contents of the buffer it is scanning.)  You can avoid the
  204.       copy by using:
  205.  
  206.         YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  207.  
  208.       which scans in place the buffer starting at "base", consisting
  209.       of "size" bytes, the last two bytes of which *must* be
  210.       YY_END_OF_BUFFER_CHAR (these bytes are not scanned; thus, scanning
  211.       consists of base[0] through base[size-2], inclusive).  If you
  212.       fail to set up "base" in this manner, yy_scan_buffer returns a
  213.       nil pointer instead of creating a new input buffer.
  214.  
  215.       The type yy_size_t is an integral type to which you can cast
  216.       an integer expression reflecting the size of the buffer.
  217.  
  218.     - Three new routines are available for manipulating stacks of
  219.       start conditions:
  220.  
  221.         void yy_push_state( int new_state )
  222.  
  223.       pushes the current start condition onto the top of the stack
  224.       and BEGIN's "new_state" (recall that start condition names are
  225.       also integers).
  226.  
  227.         void yy_pop_state()
  228.  
  229.       pops the top of the stack and BEGIN's to it, and
  230.  
  231.         int yy_top_state()
  232.  
  233.       returns the top of the stack without altering the stack's
  234.       contents.
  235.  
  236.       The start condition stack grows dynamically and so has no built-in
  237.       size limitation.  If memory is exhausted, program execution
  238.       is aborted.
  239.  
  240.       To use start condition stacks, your scanner must include
  241.       a "%option stack" directive.
  242.  
  243.     - flex now supports POSIX character class expressions.  These
  244.       are expressions enclosed inside "[:" and ":]" delimiters (which
  245.       themselves must appear between the '[' and ']' of a character
  246.       class; other elements may occur inside the character class, too).
  247.       The expressions flex recognizes are:
  248.  
  249.         [:alnum:] [:alpha:] [:blank:] [:cntrl:] [:digit:] [:graph:]    
  250.         [:lower:] [:print:] [:punct:] [:space:] [:upper:] [:xdigit:]
  251.  
  252.       These expressions all designate a set of characters equivalent to
  253.       the corresponding isXXX function (for example, [:alnum:] designates
  254.       those characters for which isalnum() returns true - i.e., any
  255.       alphabetic or numeric).  Some systems don't provide isblank(),
  256.       so flex defines [:blank:] as a blank or a tab.
  257.  
  258.       For example, the following character classes are all equivalent:
  259.  
  260.         [[:alnum:]]
  261.         [[:alpha:][:digit:]
  262.         [[:alpha:]0-9]
  263.         [a-zA-Z0-9]
  264.  
  265.       If your scanner is case-insensitive (-i flag), then [:upper:]
  266.       and [:lower:] are equivalent to [:alpha:].
  267.  
  268.     - The promised rewrite of the C++ FlexLexer class has not yet
  269.       been done.  Support for FlexLexer is limited at the moment to
  270.       fixing show-stopper bugs, so, for example, the new functions
  271.       yy_scan_string() & friends are not available to FlexLexer
  272.       objects.
  273.  
  274.     - The new macro
  275.  
  276.         yy_set_interactive(is_interactive)
  277.  
  278.       can be used to control whether the current buffer is considered
  279.       "interactive".  An interactive buffer is processed more slowly,
  280.       but must be used when the scanner's input source is indeed
  281.       interactive to avoid problems due to waiting to fill buffers
  282.       (see the discussion of the -I flag in flex.1).  A non-zero value
  283.       in the macro invocation marks the buffer as interactive, a zero
  284.       value as non-interactive.  Note that use of this macro overrides
  285.       "%option always-interactive" or "%option never-interactive".
  286.  
  287.       yy_set_interactive() must be invoked prior to beginning to
  288.       scan the buffer.
  289.  
  290.     - The new macro
  291.  
  292.         yy_set_bol(at_bol)
  293.  
  294.       can be used to control whether the current buffer's scanning
  295.       context for the next token match is done as though at the
  296.       beginning of a line (non-zero macro argument; makes '^' anchored
  297.       rules active) or not at the beginning of a line (zero argument,
  298.       '^' rules inactive).
  299.  
  300.     - Related to this change, the mechanism for determining when a scan is
  301.       starting at the beginning of a line has changed.  It used to be
  302.       that '^' was active iff the character prior to that at which the
  303.       scan started was a newline.  The mechanism now is that '^' is
  304.       active iff the last token ended in a newline (or the last call to
  305.       input() returned a newline).  For most users, the difference in
  306.       mechanisms is negligible.  Where it will make a difference,
  307.       however, is if unput() or yyless() is used to alter the input
  308.       stream.  When in doubt, use yy_set_bol().
  309.  
  310.     - The new beginning-of-line mechanism involved changing some fairly
  311.       twisted code, so it may have introduced bugs - beware ...
  312.  
  313.     - The macro YY_AT_BOL() returns true if the next token scanned from
  314.       the current buffer will have '^' rules active, false otherwise.
  315.  
  316.     - The new function
  317.  
  318.         void yy_flush_buffer( struct yy_buffer_state* b )
  319.  
  320.       flushes the contents of the current buffer (i.e., next time
  321.       the scanner attempts to match a token using b as the current
  322.       buffer, it will begin by invoking YY_INPUT to fill the buffer).
  323.       This routine is also available to C++ scanners (unlike some
  324.       of the other new routines).
  325.  
  326.       The related macro
  327.  
  328.         YY_FLUSH_BUFFER
  329.  
  330.       flushes the contents of the current buffer.
  331.  
  332.     - A new "-ooutput" option writes the generated scanner to "output".
  333.       If used with -t, the scanner is still written to stdout, but
  334.       its internal #line directives (see previous item) use "output".
  335.  
  336.     - Flex now generates #line directives relating the code it
  337.       produces to the output file; this means that error messages
  338.       in the flex-generated code should be correctly pinpointed.
  339.  
  340.     - When generating #line directives, filenames with embedded '\'s
  341.       have those characters escaped (i.e., turned into '\\').  This
  342.       feature helps with reporting filenames for some MS-DOS and OS/2
  343.       systems.
  344.  
  345.     - The FlexLexer class includes two new public member functions:
  346.  
  347.         virtual void switch_streams( istream* new_in = 0,
  348.                         ostream* new_out = 0 )
  349.  
  350.       reassigns yyin to new_in (if non-nil) and yyout to new_out
  351.       (ditto), deleting the previous input buffer if yyin is
  352.       reassigned.  It is used by:
  353.  
  354.         int yylex( istream* new_in = 0, ostream* new_out = 0 )
  355.  
  356.       which first calls switch_streams() and then returns the value
  357.       of calling yylex().
  358.  
  359.     - C++ scanners now have yy_flex_debug as a member variable of
  360.       FlexLexer rather than a global, and member functions for testing
  361.       and setting it.
  362.  
  363.     - When generating a C++ scanning class, you can now use
  364.  
  365.         %option yyclass="foo"
  366.  
  367.       to inform flex that you have derived "foo" as a subclass of
  368.       yyFlexLexer, so flex will place your actions in the member
  369.       function foo::yylex() instead of yyFlexLexer::yylex().  It also
  370.       generates a yyFlexLexer::yylex() member function that generates a
  371.       run-time error if called (by invoking yyFlexLexer::LexerError()).
  372.       This feature is necessary if your subclass "foo" introduces some
  373.       additional member functions or variables that you need to access
  374.       from yylex().
  375.  
  376.     - Current texinfo files in MISC/texinfo, contributed by Francois
  377.       Pinard.
  378.  
  379.     - You can now change the name "flex" to something else (e.g., "lex")
  380.       by redefining $(FLEX) in the Makefile.
  381.  
  382.     - Two bugs (one serious) that could cause "bigcheck" to fail have
  383.       been fixed.
  384.  
  385.     - A number of portability/configuration changes have been made
  386.       for easier portability.
  387.  
  388.     - You can use "YYSTATE" in your scanner as an alias for YY_START
  389.       (for AT&T lex compatibility).
  390.  
  391.     - input() now maintains yylineno.
  392.  
  393.     - input() no longer trashes yytext.
  394.  
  395.     - interactive scanners now read characters in YY_INPUT up to a
  396.       newline, a large performance gain.
  397.  
  398.     - C++ scanner objects now work with the -P option.  You include
  399.       <FlexLexer.h> once per scanner - see comments in <FlexLexer.h>
  400.       (or flex.1) for details.
  401.  
  402.     - C++ FlexLexer objects now use the "cerr" stream to report -d output
  403.       instead of stdio.
  404.  
  405.     - The -c flag now has its full glorious POSIX interpretation (do
  406.       nothing), rather than being interpreted as an old-style -C flag.
  407.  
  408.     - Scanners generated by flex now include two #define's giving
  409.       the major and minor version numbers (YY_FLEX_MAJOR_VERSION,
  410.       YY_FLEX_MINOR_VERSION).  These can then be tested to see
  411.       whether certain flex features are available.
  412.  
  413.     - Scanners generated using -l lex compatibility now have the symbol
  414.       YY_FLEX_LEX_COMPAT #define'd.
  415.  
  416.     - When initializing (i.e., yy_init is non-zero on entry to yylex()),
  417.       generated scanners now set yy_init to zero before executing
  418.       YY_USER_INIT.  This means that you can set yy_init back to a
  419.       non-zero value in YY_USER_INIT if you need the scanner to be
  420.       reinitialized on the next call.
  421.  
  422.     - You can now use "#line" directives in the first section of your
  423.       scanner specification.
  424.  
  425.     - When generating full-table scanners (-Cf), flex now puts braces
  426.       around each row of the 2-d array initialization, to silence warnings
  427.       on over-zealous compilers.
  428.  
  429.     - Improved support for MS-DOS.  The flex sources have been successfully
  430.       built, unmodified, for Borland 4.02 (all that's required is a
  431.       Borland Makefile and config.h file, which are supplied in
  432.       MISC/Borland - contributed by Terrence O Kane).
  433.  
  434.     - Improved support for Macintosh using Think C - the sources should
  435.       build for this platform "out of the box".  Contributed by Scott
  436.       Hofmann.
  437.  
  438.     - Improved support for VMS, in MISC/VMS/, contributed by Pat Rankin.
  439.  
  440.     - Support for the Amiga, in MISC/Amiga/, contributed by Andreas
  441.       Scherer.  Note that the contributed files were developed for
  442.       flex 2.4 and have not been tested with flex 2.5.
  443.  
  444.     - Some notes on support for the NeXT, in MISC/NeXT, contributed
  445.       by Raf Schietekat.
  446.  
  447.     - The MISC/ directory now includes a preformatted version of flex.1
  448.       in flex.man, and pre-yacc'd versions of parse.y in parse.{c,h}.
  449.  
  450.     - The flex.1 and flexdoc.1 manual pages have been merged.  There
  451.       is now just one document, flex.1, which includes an overview
  452.       at the beginning to help you find the section you need.
  453.  
  454.     - Documentation now clarifies that start conditions persist across
  455.       switches to new input files or different input buffers.  If you
  456.       want to e.g., return to INITIAL, you must explicitly do so.
  457.  
  458.     - The "Performance Considerations" section of the manual has been
  459.       updated.
  460.  
  461.     - Documented the "yy_act" variable, which when YY_USER_ACTION is
  462.       invoked holds the number of the matched rule, and added an
  463.       example of using yy_act to profile how often each rule is matched.
  464.  
  465.     - Added YY_NUM_RULES, a definition that gives the total number
  466.       of rules in the file, including the default rule (even if you
  467.       use -s).
  468.  
  469.     - Documentation now clarifies that you can pass a nil FILE* pointer
  470.       to yy_create_buffer() or yyrestart() if you've arrange YY_INPUT
  471.       to not need yyin.
  472.  
  473.     - Documentation now clarifies that YY_BUFFER_STATE is a pointer to
  474.       an opaque "struct yy_buffer_state".
  475.  
  476.     - Documentation now stresses that you gain the benefits of removing
  477.       backing-up states only if you remove *all* of them.
  478.  
  479.     - Documentation now points out that traditional lex allows you
  480.       to put the action on a separate line from the rule pattern if
  481.       the pattern has trailing whitespace (ugh!), but flex doesn't
  482.       support this.
  483.  
  484.     - A broken example in documentation of the difference between
  485.       inclusive and exclusive start conditions is now fixed.
  486.  
  487.     - Usage (-h) report now goes to stdout.
  488.  
  489.     - Version (-V) info now goes to stdout.
  490.  
  491.     - More #ifdef chud has been added to the parser in attempt to
  492.       deal with bison's use of alloca().
  493.  
  494.     - "make clean" no longer deletes emacs backup files (*~).
  495.  
  496.     - Some memory leaks have been fixed.
  497.  
  498.     - A bug was fixed in which dynamically-expanded buffers were
  499.       reallocated a couple of bytes too small.
  500.  
  501.     - A bug was fixed which could cause flex to read and write beyond
  502.       the end of the input buffer.
  503.  
  504.     - -S will not be going away.
  505.  
  506.  
  507. Changes between release 2.4.7 (03Aug94) and release 2.4.6:
  508.  
  509.     - Fixed serious bug in reading multiple files.
  510.  
  511.     - Fixed bug in scanning NUL's.
  512.  
  513.     - Fixed bug in input() returning 8-bit characters.
  514.  
  515.     - Fixed bug in matching text with embedded NUL's when
  516.       using %array or lex compatibility.
  517.  
  518.     - Fixed multiple invocations of YY_USER_ACTION when using '|'
  519.       continuation action.
  520.  
  521.     - Minor prototyping fixes.
  522.  
  523. Changes between release 2.4.6 (04Jan94) and release 2.4.5:
  524.  
  525.     - Linking with -lfl no longer required if your program includes
  526.       its own yywrap() and main() functions.  (This change will cause
  527.       problems if you have a non-ANSI compiler on a system for which
  528.       sizeof(int) != sizeof(void*) or sizeof(int) != sizeof(size_t).)
  529.  
  530.     - The use of 'extern "C++"' in FlexLexer.h has been modified to
  531.       get around an incompatibility with g++'s header files.
  532.  
  533. Changes between release 2.4.5 (11Dec93) and release 2.4.4:
  534.  
  535.     - Fixed bug breaking C++ scanners that use REJECT or variable
  536.       trailing context.
  537.  
  538.     - Fixed serious input problem for interactive scanners on
  539.       systems for which char is unsigned.
  540.  
  541.     - Fixed bug in incorrectly treating '$' operator as variable
  542.       trailing context.
  543.  
  544.     - Fixed bug in -CF table representation that could lead to
  545.       corrupt tables.
  546.  
  547.     - Fixed fairly benign memory leak.
  548.  
  549.     - Added `extern "C++"' wrapper to FlexLexer.h header.  This
  550.       should overcome the g++ 2.5.X problems mentioned in the
  551.       NEWS for release 2.4.3.
  552.  
  553.     - Changed #include of FlexLexer.h to use <> instead of "".
  554.  
  555.     - Added feature to control whether the scanner attempts to
  556.       refill the input buffer once it's exhausted.  This feature
  557.       will be documented in the 2.5 release.
  558.  
  559.  
  560. Changes between release 2.4.4 (07Dec93) and release 2.4.3:
  561.  
  562.     - Fixed two serious bugs in scanning 8-bit characters.
  563.  
  564.     - Fixed bug in YY_USER_ACTION that caused it to be executed
  565.       inappropriately (on the scanner's own internal actions, and
  566.       with incorrect yytext/yyleng values).
  567.  
  568.     - Fixed bug in pointing yyin at a new file and resuming scanning.
  569.  
  570.     - Portability fix regarding min/max/abs macros conflicting with
  571.       function definitions in standard header files.
  572.  
  573.     - Added a virtual LexerError() method to the C++ yyFlexLexer class
  574.       for reporting error messages instead of always using cerr.
  575.  
  576.     - Added warning in flexdoc that the C++ scanning class is presently
  577.       experimental and subject to considerable change between major
  578.       releases.
  579.  
  580.  
  581. Changes between release 2.4.3 (03Dec93) and release 2.4.2:
  582.  
  583.     - Fixed bug causing fatal scanner messages to fail to print.
  584.  
  585.     - Fixed things so FlexLexer.h can be included in other C++
  586.       sources.  One side-effect of this change is that -+ and -CF
  587.       are now incompatible.
  588.  
  589.     - libfl.a now supplies private versions of the the <string.h>/
  590.       <strings.h> string routines needed by flex and the scanners
  591.       it generates, to enhance portability to some BSD systems.
  592.  
  593.     - More robust solution to 2.4.2's flexfatal() bug fix.
  594.  
  595.     - Added ranlib of installed libfl.a.
  596.  
  597.     - Some lint tweaks.
  598.  
  599.     - NOTE: problems have been encountered attempting to build flex
  600.       C++ scanners using g++ version 2.5.X.  The problem is due to an
  601.       unfortunate heuristic in g++ 2.5.X that attempts to discern between
  602.       C and C++ headers.  Because FlexLexer.h is installed (by default)
  603.       in /ade/include and not /ade/lib/g++-include, g++ 2.5.X
  604.       decides that it's a C header :-(.  So if you have problems, install
  605.       the header in /ade/lib/g++-include instead.
  606.  
  607.  
  608. Changes between release 2.4.2 (01Dec93) and release 2.4.1:
  609.  
  610.     - Fixed bug in libfl.a referring to non-existent "flexfatal" function.
  611.  
  612.     - Modified to produce both compress'd and gzip'd tar files for
  613.       distributions (you probably don't care about this change!).
  614.  
  615.  
  616. Changes between release 2.4.1 (30Nov93) and release 2.3.8:
  617.  
  618.     - The new '-+' flag instructs flex to generate a C++ scanner class
  619.       (thanks to Kent Williams).  flex writes an implementation of the
  620.       class defined in FlexLexer.h to lex.yy.cc.  You may include
  621.       multiple scanner classes in your program using the -P flag.  Note
  622.       that the scanner class also provides a mechanism for creating
  623.       reentrant scanners.  The scanner class uses C++ streams for I/O
  624.       instead of FILE*'s (thanks to Tom Epperly).  If the flex executable's
  625.       name ends in '+' then the '-+' flag is automatically on, so creating
  626.       a symlink or copy of "flex" to "flex++" results in a version of
  627.       flex that can be used exclusively for C++ scanners.
  628.  
  629.       Note that without the '-+' flag, flex-generated scanners can still
  630.       be compiled using C++ compilers, though they use FILE*'s for I/O
  631.       instead of streams.
  632.  
  633.       See the "GENERATING C++ SCANNERS" section of flexdoc for details.
  634.  
  635.     - The new '-l' flag turns on maximum AT&T lex compatibility.  In
  636.       particular, -l includes support for "yylineno" and makes yytext
  637.       be an array instead of a pointer.  It does not, however, do away
  638.       with all incompatibilities.  See the "INCOMPATIBILITIES WITH LEX
  639.       AND POSIX" section of flexdoc for details.
  640.  
  641.     - The new '-P' option specifies a prefix to use other than "yy"
  642.       for the scanner's globally-visible variables, and for the
  643.       "lex.yy.c" filename.  Using -P you can link together multiple
  644.       flex scanners in the same executable.
  645.  
  646.     - The distribution includes a "texinfo" version of flexdoc.1,
  647.       contributed by Roland Pesch (thanks also to Marq Kole, who
  648.       contributed another version).  It has not been brought up to
  649.       date, but reflects version 2.3.  See MISC/flex.texinfo.
  650.  
  651.       The flex distribution will soon include G.T. Nicol's flex
  652.       manual; he is presently bringing it up-to-date for version 2.4.
  653.  
  654.     - yywrap() is now a function, and you now *must* link flex scanners
  655.       with libfl.a.
  656.  
  657.     - Site-configuration is now done via an autoconf-generated
  658.       "configure" script contributed by Francois Pinard.
  659.  
  660.     - Scanners now use fread() (or getc(), if interactive) and not
  661.       read() for input.  A new "table compression" option, -Cr,
  662.       overrides this change and causes the scanner to use read()
  663.       (because read() is a bit faster than fread()).  -f and -F
  664.       are now equivalent to -Cfr and -CFr; i.e., they imply the
  665.       -Cr option.
  666.  
  667.     - In the blessed name of POSIX compliance, flex supports "%array"
  668.       and "%pointer" directives in the definitions (first) section of
  669.       the scanner specification.  The former specifies that yytext
  670.       should be an array (of size YYLMAX), the latter, that it should
  671.       be a pointer.  The array version of yytext is universally slower
  672.       than the pointer version, but has the advantage that its contents
  673.       remain unmodified across calls to input() and unput() (the pointer
  674.       version of yytext is, still, trashed by such calls).
  675.  
  676.       "%array" cannot be used with the '-+' C++ scanner class option.
  677.  
  678.     - The new '-Ca' option directs flex to trade off memory for
  679.       natural alignment when generating a scanner's tables.  In
  680.       particular, table entries that would otherwise be "short"
  681.       become "long".
  682.  
  683.     - The new '-h' option produces a summary of the flex flags.
  684.  
  685.     - The new '-V' option reports the flex version number and exits.
  686.  
  687.     - The new scanner macro YY_START returns an integer value
  688.       corresponding to the current start condition.  You can return
  689.       to that start condition by passing the value to a subsequent
  690.       "BEGIN" action.  You also can implement "start condition stacks"
  691.       by storing the values in an integer stack.
  692.  
  693.     - You can now redefine macros such as YY_INPUT by just #define'ing
  694.       them to some other value in the first section of the flex input;
  695.       no need to first #undef them.
  696.  
  697.     - flex now generates warnings for rules that can't be matched.
  698.       These warnings can be turned off using the new '-w' flag.  If
  699.       your scanner uses REJECT then you will not get these warnings.
  700.  
  701.     - If you specify the '-s' flag but the default rule can be matched,
  702.       flex now generates a warning.
  703.  
  704.     - "yyleng" is now a global, and may be modified by the user (though
  705.       doing so and then using yymore() will yield weird results).
  706.  
  707.     - Name definitions in the first section of a scanner specification
  708.       can now include a leading '^' or trailing '$' operator.  In this
  709.       case, the definition is *not* pushed back inside of parentheses.
  710.  
  711.     - Scanners with compressed tables are now "interactive" (-I option)
  712.       by default.  You can suppress this attribute (which makes them
  713.       run slightly slower) using the new '-B' flag.
  714.  
  715.     - Flex now generates 8-bit scanners by default, unless you use the
  716.       -Cf or -CF compression options (-Cfe  and -CFe result in 8-bit
  717.       scanners).  You can force it to generate a 7-bit scanner using
  718.       the new '-7' flag.  You can build flex to generate 8-bit scanners
  719.       for -Cf and -CF, too, by adding -DDEFAULT_CSIZE=256 to CFLAGS
  720.       in the Makefile.
  721.  
  722.     - You no longer need to call the scanner routine yyrestart() to
  723.       inform the scanner that you have switched to a new file after
  724.       having seen an EOF on the current input file.  Instead, just
  725.       point yyin at the new file and continue scanning.
  726.  
  727.     - You no longer need to invoke YY_NEW_FILE in an <<EOF>> action
  728.       to indicate you wish to continue scanning.  Simply point yyin
  729.       at a new file.
  730.  
  731.     - A leading '#' no longer introduces a comment in a flex input.
  732.  
  733.     - flex no longer considers formfeed ('\f') a whitespace character.
  734.  
  735.     - %t, I'm happy to report, has been nuked.
  736.  
  737.     - The '-p' option may be given twice ('-pp') to instruct flex to
  738.       report minor performance problems as well as major ones.
  739.  
  740.     - The '-v' verbose output no longer includes start/finish time
  741.       information.
  742.  
  743.     - Newlines in flex inputs can optionally include leading or
  744.       trailing carriage-returns ('\r'), in support of several PC/Mac
  745.       run-time libraries that automatically include these.
  746.  
  747.     - A start condition of the form "<*>" makes the following rule
  748.       active in every start condition, whether exclusive or inclusive.
  749.  
  750.     - The following items have been corrected in the flex documentation:
  751.  
  752.         - '-C' table compression options *are* cumulative.
  753.  
  754.         - You may modify yytext but not lengthen it by appending
  755.           characters to the end.  Modifying its final character
  756.           will affect '^' anchoring for the next rule matched
  757.           if the character is changed to or from a newline.
  758.  
  759.         - The term "backtracking" has been renamed "backing up",
  760.           since it is a one-time repositioning and not a repeated
  761.           search.  What used to be the "lex.backtrack" file is now
  762.           "lex.backup".
  763.  
  764.         - Unindented "/* ... */" comments are allowed in the first
  765.           flex input section, but not in the second.
  766.  
  767.         - yyless() can only be used in the flex input source, not
  768.           externally.
  769.  
  770.         - You can use "yyrestart(yyin)" to throw away the
  771.           current contents of the input buffer.
  772.  
  773.         - To write high-speed scanners, attempt to match as much
  774.           text as possible with each rule.  See MISC/fastwc/README
  775.           for more information.
  776.  
  777.         - Using the beginning-of-line operator ('^') is fairly
  778.           cheap.  Using unput() is expensive.  Using yyless() is
  779.           cheap.
  780.  
  781.         - An example of scanning strings with embedded escape
  782.           sequences has been added.
  783.  
  784.         - The example of backing-up in flexdoc was erroneous; it
  785.           has been corrected.
  786.  
  787.     - A flex scanner's internal buffer now dynamically grows if needed
  788.       to match large tokens.  Note that growing the buffer presently
  789.       requires rescanning the (large) token, so consuming a lot of
  790.       text this way is a slow process.  Also note that presently the
  791.       buffer does *not* grow if you unput() more text than can fit
  792.       into the buffer.
  793.  
  794.     - The MISC/ directory has been reorganized; see MISC/README for
  795.       details.
  796.  
  797.     - yyless() can now be used in the third (user action) section
  798.       of a scanner specification, thanks to Ceriel Jacobs.  yyless()
  799.       remains a macro and cannot be used outside of the scanner source.
  800.  
  801.     - The skeleton file is no longer opened at run-time, but instead
  802.       compiled into a large string array (thanks to John Gilmore and
  803.       friends at Cygnus).  You can still use the -S flag to point flex
  804.       at a different skeleton file.
  805.  
  806.     - flex no longer uses a temporary file to store the scanner's
  807.       actions.
  808.  
  809.     - A number of changes have been made to decrease porting headaches.
  810.       In particular, flex no longer uses memset() or ctime(), and
  811.       provides a single simple mechanism for dealing with C compilers
  812.       that still define malloc() as returning char* instead of void*.
  813.  
  814.     - Flex now detects if the scanner specification requires the -8 flag
  815.       but the flag was not given or on by default.
  816.  
  817.     - A number of table-expansion fencepost bugs have been fixed,
  818.       making flex more robust for generating large scanners.
  819.  
  820.     - flex more consistently identifies the location of errors in
  821.       its input.
  822.  
  823.     - YY_USER_ACTION is now invoked only for "real" actions, not for
  824.       internal actions used by the scanner for things like filling
  825.       the buffer or handling EOF.
  826.  
  827.     - The rule "[^]]" now matches any character other than a ']';
  828.       formerly it matched any character at all followed by a ']'.
  829.       This change was made for compatibility with AT&T lex.
  830.  
  831.     - A large number of miscellaneous bugs have been found and fixed
  832.       thanks to Gerhard Wilhelms.
  833.  
  834.     - The source code has been heavily reformatted, making patches
  835.       relative to previous flex releases no longer accurate.
  836.  
  837.  
  838. Changes between 2.3 Patch #8 (21Feb93) and 2.3 Patch #7:
  839.  
  840.     - Fixed bugs in dynamic memory allocation leading to grievous
  841.       fencepost problems when generating large scanners.
  842.     - Fixed bug causing infinite loops on character classes with 8-bit
  843.       characters in them.
  844.     - Fixed bug in matching repetitions with a lower bound of 0.
  845.     - Fixed bug in scanning NUL characters using an "interactive" scanner.
  846.     - Fixed bug in using yymore() at the end of a file.
  847.     - Fixed bug in misrecognizing rules with variable trailing context.
  848.     - Fixed bug compiling flex on Suns using gcc 2.
  849.     - Fixed bug in not recognizing that input files with the character
  850.       ASCII 128 in them require the -8 flag.
  851.     - Fixed bug that could cause an infinite loop writing out
  852.       error messages.
  853.     - Fixed bug in not recognizing old-style lex % declarations if
  854.       followed by a tab instead of a space.
  855.     - Fixed potential crash when flex terminated early (usually due
  856.       to a bad flag) and the -v flag had been given.
  857.     - Added some missing declarations of void functions.
  858.     - Changed to only use '\a' for __STDC__ compilers.
  859.     - Updated mailing addresses.
  860.  
  861.  
  862. Changes between 2.3 Patch #7 (28Mar91) and 2.3 Patch #6:
  863.  
  864.     - Fixed out-of-bounds array access that caused bad tables
  865.       to be produced on machines where the bad reference happened
  866.       to yield a 1.  This caused problems installing or running
  867.       flex on some Suns, in particular.
  868.  
  869.  
  870. Changes between 2.3 Patch #6 (29Aug90) and 2.3 Patch #5:
  871.  
  872.     - Fixed a serious bug in yymore() which basically made it
  873.       completely broken.  Thanks goes to Jean Christophe of
  874.       the Nethack development team for finding the problem
  875.       and passing along the fix.
  876.  
  877.  
  878. Changes between 2.3 Patch #5 (16Aug90) and 2.3 Patch #4:
  879.  
  880.     - An up-to-date version of initscan.c so "make test" will
  881.       work after applying the previous patches
  882.  
  883.  
  884. Changes between 2.3 Patch #4 (14Aug90) and 2.3 Patch #3:
  885.  
  886.     - Fixed bug in hexadecimal escapes which allowed only digits,
  887.       not letters, in escapes
  888.     - Fixed bug in previous "Changes" file!
  889.  
  890.  
  891. Changes between 2.3 Patch #3 (03Aug90) and 2.3 Patch #2:
  892.  
  893.     - Correction to patch #2 for gcc compilation; thanks goes to
  894.       Paul Eggert for catching this.
  895.  
  896.  
  897. Changes between 2.3 Patch #2 (02Aug90) and original 2.3 release:
  898.  
  899.     - Fixed (hopefully) headaches involving declaring malloc()
  900.       and free() for gcc, which defines __STDC__ but (often) doesn't
  901.       come with the standard include files such as <stdlib.h>.
  902.       Reordered #ifdef maze in the scanner skeleton in the hope of
  903.       getting the declarations right for cfront and g++, too.
  904.  
  905.     - Note that this patch supercedes patch #1 for release 2.3,
  906.       which was never announced but was available briefly for
  907.       anonymous ftp.
  908.  
  909.  
  910. Changes between 2.3 (full) release of 28Jun90 and 2.2 (alpha) release:
  911.  
  912.     User-visible:
  913.  
  914.     - A lone <<EOF>> rule (that is, one which is not qualified with
  915.       a list of start conditions) now specifies the EOF action for
  916.       *all* start conditions which haven't already had <<EOF>> actions
  917.       given.  To specify an end-of-file action for just the initial
  918.       state, use <INITIAL><<EOF>>.
  919.  
  920.     - -d debug output is now contigent on the global yy_flex_debug
  921.       being set to a non-zero value, which it is by default.
  922.  
  923.     - A new macro, YY_USER_INIT, is provided for the user to specify
  924.       initialization action to be taken on the first call to the
  925.       scanner.  This action is done before the scanner does its
  926.       own initialization.
  927.  
  928.     - yy_new_buffer() has been added as an alias for yy_create_buffer()
  929.  
  930.     - Comments beginning with '#' and extending to the end of the line
  931.       now work, but have been deprecated (in anticipation of making
  932.       flex recognize #line directives).
  933.  
  934.     - The funky restrictions on when semi-colons could follow the
  935.       YY_NEW_FILE and yyless macros have been removed.  They now
  936.       behave identically to functions.
  937.  
  938.     - A bug in the sample redefinition of YY_INPUT in the documentation
  939.       has been corrected.
  940.  
  941.     - A bug in the sample simple tokener in the documentation has
  942.       been corrected.
  943.  
  944.     - The documentation on the incompatibilities between flex and
  945.       lex has been reordered so that the discussion of yylineno
  946.       and input() come first, as it's anticipated that these will
  947.       be the most common source of headaches.
  948.  
  949.  
  950.     Things which didn't used to be documented but now are:
  951.  
  952.     - flex interprets "^foo|bar" differently from lex.  flex interprets
  953.       it as "match either a 'foo' or a 'bar', providing it comes at the
  954.       beginning of a line", whereas lex interprets it as "match either
  955.       a 'foo' at the beginning of a line, or a 'bar' anywhere".
  956.  
  957.     - flex initializes the global "yyin" on the first call to the
  958.       scanner, while lex initializes it at compile-time.
  959.  
  960.     - yy_switch_to_buffer() can be used in the yywrap() macro/routine.
  961.  
  962.     - flex scanners do not use stdio for their input, and hence when
  963.       writing an interactive scanner one must explictly call fflush()
  964.       after writing out a prompt.
  965.  
  966.     - flex scanner can be made reentrant (after a fashion) by using
  967.       "yyrestart( yyin );".  This is useful for interactive scanners
  968.       which have interrupt handlers that long-jump out of the scanner.
  969.  
  970.     - a defense of why yylineno is not supported is included, along
  971.       with a suggestion on how to convert scanners which rely on it.
  972.  
  973.  
  974.     Other changes:
  975.  
  976.     - Prototypes and proper declarations of void routines have
  977.       been added to the flex source code, courtesy of Kevin B. Kenny.
  978.  
  979.     - Routines dealing with memory allocation now use void* pointers
  980.       instead of char* - see Makefile for porting implications.
  981.  
  982.     - Error-checking is now done when flex closes a file.
  983.  
  984.     - Various lint tweaks were added to reduce the number of gripes.
  985.  
  986.     - Makefile has been further parameterized to aid in porting.
  987.  
  988.     - Support for SCO Unix added.
  989.  
  990.     - Flex now sports the latest & greatest UC copyright notice
  991.       (which is only slightly different from the previous one).
  992.  
  993.     - A note has been added to flexdoc.1 mentioning work in progress
  994.       on modifying flex to generate straight C code rather than a
  995.       table-driven automaton, with an email address of whom to contact
  996.       if you are working along similar lines.
  997.  
  998.  
  999. Changes between 2.2 Patch #3 (30Mar90) and 2.2 Patch #2:
  1000.  
  1001.     - fixed bug which caused -I scanners to bomb
  1002.  
  1003.  
  1004. Changes between 2.2 Patch #2 (27Mar90) and 2.2 Patch #1:
  1005.  
  1006.     - fixed bug writing past end of input buffer in yyunput()
  1007.     - fixed bug detecting NUL's at the end of a buffer
  1008.  
  1009.  
  1010. Changes between 2.2 Patch #1 (23Mar90) and 2.2 (alpha) release:
  1011.  
  1012.     - Makefile fixes: definition of MAKE variable for systems
  1013.       which don't have it; installation of flexdoc.1 along with
  1014.       flex.1; fixed two bugs which could cause "bigtest" to fail.
  1015.  
  1016.     - flex.skel fix for compiling with g++.
  1017.  
  1018.     - README and flexdoc.1 no longer list an out-of-date BITNET address
  1019.       for contacting me.
  1020.  
  1021.     - minor typos and formatting changes to flex.1 and flexdoc.1.
  1022.  
  1023.  
  1024. Changes between 2.2 (alpha) release of March '90 and previous release:
  1025.  
  1026.     User-visible:
  1027.  
  1028.     - Full user documentation now available.
  1029.  
  1030.     - Support for 8-bit scanners.
  1031.  
  1032.     - Scanners now accept NUL's.
  1033.  
  1034.     - A facility has been added for dealing with multiple
  1035.       input buffers.
  1036.  
  1037.     - Two manual entries now.  One which fully describes flex
  1038.       (rather than just its differences from lex), and the
  1039.       other for quick(er) reference.
  1040.  
  1041.     - A number of changes to bring flex closer into compliance
  1042.       with the latest POSIX lex draft:
  1043.  
  1044.         %t support
  1045.         flex now accepts multiple input files and concatenates
  1046.             them together to form its input
  1047.         previous -c (compress) flag renamed -C
  1048.         do-nothing -c and -n flags added
  1049.         Any indented code or code within %{}'s in section 2 is
  1050.             now copied to the output
  1051.  
  1052.     - yyleng is now a bona fide global integer.
  1053.  
  1054.     - -d debug information now gives the line number of the
  1055.       matched rule instead of which number rule it was from
  1056.       the beginning of the file.
  1057.  
  1058.     - -v output now includes a summary of the flags used to generate
  1059.       the scanner.
  1060.  
  1061.     - unput() and yyrestart() are now globally callable.
  1062.  
  1063.     - yyrestart() no longer closes the previous value of yyin.
  1064.  
  1065.     - C++ support; generated scanners can be compiled with C++ compiler.
  1066.  
  1067.     - Primitive -lfl library added, containing default main()
  1068.       which calls yylex().  A number of routines currently living
  1069.       in the scanner skeleton will probably migrate to here
  1070.       in the future (in particular, yywrap() will probably cease
  1071.       to be a macro and instead be a function in the -lfl library).
  1072.  
  1073.     - Hexadecimal (\x) escape sequences added.
  1074.  
  1075.     - Support for MS-DOS, VMS, and Turbo-C integrated.
  1076.  
  1077.     - The %used/%unused operators have been deprecated.  They
  1078.       may go away soon.
  1079.  
  1080.  
  1081.     Other changes:
  1082.  
  1083.     - Makefile enhanced for easier testing and installation.
  1084.     - The parser has been tweaked to detect some erroneous
  1085.       constructions which previously were missed.
  1086.     - Scanner input buffer overflow is now detected.
  1087.     - Bugs with missing "const" declarations fixed.
  1088.     - Out-of-date Minix/Atari patches provided.
  1089.     - Scanners no longer require printf() unless FLEX_DEBUG is being used.
  1090.     - A subtle input() bug has been fixed.
  1091.     - Line numbers for "continued action" rules (those following
  1092.       the special '|' action) are now correct.
  1093.     - unput() bug fixed; had been causing problems porting flex to VMS.
  1094.     - yymore() handling rewritten to fix bug with interaction
  1095.       between yymore() and trailing context.
  1096.     - EOF in actions now generates an error message.
  1097.     - Bug involving -CFe and generating equivalence classes fixed.
  1098.     - Bug which made -CF be treated as -Cf fixed.
  1099.     - Support for SysV tmpnam() added.
  1100.     - Unused #define's for scanner no longer generated.
  1101.     - Error messages which are associated with a particular input
  1102.       line are now all identified with their input line in standard
  1103.       format.
  1104.     - % directives which are valid to lex but not to flex are
  1105.       now ignored instead of generating warnings.
  1106.     - -DSYS_V flag can now also be specified -DUSG for System V
  1107.       compilation.
  1108.  
  1109.  
  1110. Changes between 2.1 beta-test release of June '89 and previous release:
  1111.  
  1112.     User-visible:
  1113.  
  1114.     - -p flag generates a performance report to stderr.  The report
  1115.       consists of comments regarding features of the scanner rules
  1116.       which result in slower scanners.
  1117.  
  1118.     - -b flag generates backtracking information to lex.backtrack.
  1119.       This is a list of scanner states which require backtracking
  1120.       and the characters on which they do so.  By adding rules
  1121.       one can remove backtracking states.  If all backtracking states
  1122.       are eliminated, the generated scanner will run faster.
  1123.       Backtracking is not yet documented in the manual entry.
  1124.  
  1125.     - Variable trailing context now works, i.e., one can have
  1126.       rules like "(foo)*/[ \t]*bletch".  Some trailing context
  1127.       patterns still cannot be properly matched and generate
  1128.       error messages.  These are patterns where the ending of the
  1129.       first part of the rule matches the beginning of the second
  1130.       part, such as "zx*/xy*", where the 'x*' matches the 'x' at
  1131.       the beginning of the trailing context.  Lex won't get these
  1132.       patterns right either.
  1133.  
  1134.     - Faster scanners.
  1135.  
  1136.     - End-of-file rules.  The special rule "<<EOF>>" indicates
  1137.       actions which are to be taken when an end-of-file is
  1138.       encountered and yywrap() returns non-zero (i.e., indicates
  1139.       no further files to process).  See manual entry for example.
  1140.  
  1141.     - The -r (reject used) flag is gone.  flex now scans the input
  1142.       for occurrences of the string "REJECT" to determine if the
  1143.       action is needed.  It tries to be intelligent about this but
  1144.       can be fooled.  One can force the presence or absence of
  1145.       REJECT by adding a line in the first section of the form
  1146.       "%used REJECT" or "%unused REJECT".
  1147.  
  1148.     - yymore() has been implemented.  Similarly to REJECT, flex
  1149.       detects the use of yymore(), which can be overridden using
  1150.       "%used" or "%unused".
  1151.  
  1152.     - Patterns like "x{0,3}" now work (i.e., with lower-limit == 0).
  1153.  
  1154.     - Removed '\^x' for ctrl-x misfeature.
  1155.  
  1156.     - Added '\a' and '\v' escape sequences.
  1157.  
  1158.     - \<digits> now works for octal escape sequences; previously
  1159.       \0<digits> was required.
  1160.  
  1161.     - Better error reporting; line numbers are associated with rules.
  1162.  
  1163.     - yyleng is a macro; it cannot be accessed outside of the
  1164.       scanner source file.
  1165.  
  1166.     - yytext and yyleng should not be modified within a flex action.
  1167.  
  1168.     - Generated scanners #define the name FLEX_SCANNER.
  1169.  
  1170.     - Rules are internally separated by YY_BREAK in lex.yy.c rather
  1171.       than break, to allow redefinition.
  1172.  
  1173.     - The macro YY_USER_ACTION can be redefined to provide an action
  1174.       which is always executed prior to the matched rule's action.
  1175.     
  1176.     - yyrestart() is a new action which can be used to restart
  1177.       the scanner after it has seen an end-of-file (a "real" one,
  1178.       that is, one for which yywrap() returned non-zero).  It takes
  1179.       a FILE* argument indicating a new file to scan and sets
  1180.       things up so that a subsequent call to yylex() will start
  1181.       scanning that file.
  1182.  
  1183.     - Internal scanner names all preceded by "yy_"
  1184.  
  1185.     - lex.yy.c is deleted if errors are encountered during processing.
  1186.  
  1187.     - Comments may be put in the first section of the input by preceding
  1188.       them with '#'.
  1189.  
  1190.  
  1191.  
  1192.     Other changes:
  1193.  
  1194.     - Some portability-related bugs fixed, in particular for machines
  1195.       with unsigned characters or sizeof( int* ) != sizeof( int ).
  1196.       Also, tweaks for VMS and Microsoft C (MS-DOS), and identifiers all
  1197.       trimmed to be 31 or fewer characters.  Shortened file names
  1198.       for dinosaur OS's.  Checks for allocating > 64K memory
  1199.       on 16 bit'ers.  Amiga tweaks.  Compiles using gcc on a Sun-3.
  1200.     - Compressed and fast scanner skeletons merged.
  1201.     - Skeleton header files done away with.
  1202.     - Generated scanner uses prototypes and "const" for __STDC__.
  1203.     - -DSV flag is now -DSYS_V for System V compilation.
  1204.     - Removed all references to FTL language.
  1205.     - Software now covered by BSD Copyright.
  1206.     - flex will replace lex in subsequent BSD releases.
  1207.