d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MFV: r362286

Browse Source 
Merge flex 2.6.4.
This commit is contained in:
Jung-uk Kim 2020-06-18 18:09:16 +00:00
commit 7e38239042
47 changed files with 8472 additions and 5188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2772
contrib/flex/ChangeLog
View File

File diff suppressed because it is too large Load Diff

206
contrib/flex/FlexLexer.h
View File

@ -1,206 +0,0 @@
// -*-C++-*-
// FlexLexer.h -- define interfaces for lexical analyzer classes generated
// by flex
// Copyright (c) 1993 The Regents of the University of California.
// All rights reserved.
//
// This code is derived from software contributed to Berkeley by
// Kent Williams and Tom Epperly.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the University nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE.
// This file defines FlexLexer, an abstract class which specifies the
// external interface provided to flex C++ lexer objects, and yyFlexLexer,
// which defines a particular lexer class.
//
// If you want to create multiple lexer classes, you use the -P flag
// to rename each yyFlexLexer to some other xxFlexLexer. You then
// include <FlexLexer.h> in your other sources once per lexer class:
//
// #undef yyFlexLexer
// #define yyFlexLexer xxFlexLexer
// #include <FlexLexer.h>
//
// #undef yyFlexLexer
// #define yyFlexLexer zzFlexLexer
// #include <FlexLexer.h>
// ...
#ifndef __FLEX_LEXER_H
// Never included before - need to define base class.
#define __FLEX_LEXER_H
#include <iostream>
# ifndef FLEX_STD
# define FLEX_STD std::
# endif
extern "C++" {
struct yy_buffer_state;
typedef int yy_state_type;
class FlexLexer {
public:
virtual ~FlexLexer() { }
const char* YYText() const { return yytext; }
int YYLeng() const { return yyleng; }
virtual void
yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
virtual struct yy_buffer_state*
yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
virtual void yyrestart( FLEX_STD istream* s ) = 0;
virtual int yylex() = 0;
// Call yylex with new input/output sources.
int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 )
{
switch_streams( new_in, new_out );
return yylex();
}
// Switch to new input/output streams. A nil stream pointer
// indicates "keep the current one".
virtual void switch_streams( FLEX_STD istream* new_in = 0,
FLEX_STD ostream* new_out = 0 ) = 0;
int lineno() const { return yylineno; }
int debug() const { return yy_flex_debug; }
void set_debug( int flag ) { yy_flex_debug = flag; }
protected:
char* yytext;
int yyleng;
int yylineno; // only maintained if you use %option yylineno
int yy_flex_debug; // only has effect with -d or "%option debug"
};
}
#endif // FLEXLEXER_H
#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
// Either this is the first time through (yyFlexLexerOnce not defined),
// or this is a repeated include to define a different flavor of
// yyFlexLexer, as discussed in the flex manual.
#define yyFlexLexerOnce
extern "C++" {
class yyFlexLexer : public FlexLexer {
public:
// arg_yyin and arg_yyout default to the cin and cout, but we
// only make that assignment when initializing in yylex().
yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );
virtual ~yyFlexLexer();
void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );
void yy_delete_buffer( struct yy_buffer_state* b );
void yyrestart( FLEX_STD istream* s );
void yypush_buffer_state( struct yy_buffer_state* new_buffer );
void yypop_buffer_state();
virtual int yylex();
virtual void switch_streams( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 );
virtual int yywrap();
protected:
virtual int LexerInput( char* buf, int max_size );
virtual void LexerOutput( const char* buf, int size );
virtual void LexerError( const char* msg );
void yyunput( int c, char* buf_ptr );
int yyinput();
void yy_load_buffer_state();
void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream* s );
void yy_flush_buffer( struct yy_buffer_state* b );
int yy_start_stack_ptr;
int yy_start_stack_depth;
int* yy_start_stack;
void yy_push_state( int new_state );
void yy_pop_state();
int yy_top_state();
yy_state_type yy_get_previous_state();
yy_state_type yy_try_NUL_trans( yy_state_type current_state );
int yy_get_next_buffer();
FLEX_STD istream* yyin; // input source for default LexerInput
FLEX_STD ostream* yyout; // output sink for default LexerOutput
// yy_hold_char holds the character lost when yytext is formed.
char yy_hold_char;
// Number of characters read into yy_ch_buf.
int yy_n_chars;
// Points to current character in buffer.
char* yy_c_buf_p;
int yy_init; // whether we need to initialize
int yy_start; // start state number
// Flag which is used to allow yywrap()'s to do buffer switches
// instead of setting up a fresh yyin. A bit of a hack ...
int yy_did_buffer_switch_on_eof;
size_t yy_buffer_stack_top; /**< index of top of stack. */
size_t yy_buffer_stack_max; /**< capacity of stack. */
struct yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
void yyensure_buffer_stack(void);
// The following are not always needed, but may be depending
// on use of certain flex features (like REJECT or yymore()).
yy_state_type yy_last_accepting_state;
char* yy_last_accepting_cpos;
yy_state_type* yy_state_buf;
yy_state_type* yy_state_ptr;
char* yy_full_match;
int* yy_full_state;
int yy_full_lp;
int yy_lp;
int yy_looking_for_trail_begin;
int yy_more_flag;
int yy_more_len;
int yy_more_offset;
int yy_prev_more_offset;
};
}
#endif // yyFlexLexer || ! yyFlexLexerOnce

234
contrib/flex/NEWS
View File

@ -1,7 +1,233 @@
This is the file NEWS for the flex package. It records user -visible
changes between releases of flex.
flex NEWS
See the file COPYING for copying conditions.
* Noteworthy changes in release 2.6.4 (2017-05-06) [stable]
** build
*** The indent target now knows about flex's new (as of 2.6.0)
layout. The indent rules it would apply are not correct and do
need to be fixed.
*** The files included in the flex distribution are now built by the
version of flex that is included in the distribution.
*** The configure script has a better idea of which headers are
required to build flex. It will also error when missing functions
are detected.
*** We have lowered the versions of automake and gettext that
configure.ac lists as required for building flex. In autogen.sh,
we now check for how to call libtoolize and use what we find in
the rest of the script.
*** Since files in lib/ are picked up as needed by src/, we no longer
generate a Makefile for that directory.
*** Flex can be cross compiled.
** documentation
*** Some typos were removed from the manual.
** scanner
*** Some minor performance enhancements.
*** We honor user defined yy_* macros again. We are also more careful
to not leak macro definitions into header files.
*** A number of portability fixes were introduced so building flex is
more reliable on more platforms. Additionally, outdated function
calls were removed.
*** When building the flex executable itself, %# comments from
flex.skl are removed when generating the C source code array. This
reduces the size of flex.
** test suite
*** All scripts in the test suite are now run by $(SHELL) and the
needed portability fixes have been included.
*** Test suite dependencies are handled much better. This only matters
if you are actively developing flex or its test suite.
*** Tests that depend on platform dependent features now properly skip
when those platforms are not present.
*** When running "make check", you can now pas V=0 to silence more of
the build. This is useful when you're less connncerned about the
details of building and linking the test programs themselves.
* Noteworthy changes in release 2.6.3 (2016-12-30) [stable]
** scanner
*** several bug fixes resolved problems introduced in recent flex
versions regarding processing of comments, literals and various
quoting scenarios.
*** If the path to m4 was sufficiently long, a buffer overflow could
occur. This has been resolved. The fix also removes dependence on
the constant PATH_MAX.
** build
*** A new configure option --disable-bootstrap changes the behavior of
the build system when building flex. The default
"--enable-bootstrap" behavior is to build flex, then to use that
flex to build flex again. With --disable-bootstrap, the scanner is
simply built by sedding the scanner source. This is friendlier to
cross compilation.
*** The compatibility functions in lib/ are no longer built as a
library. Instead, they are built as $(LIBOBJ) objects. This is
simpler and friendlier to cross compilation.
*** It is now possible to build flex without building the accompanying
libfl. This is friendlier to cross compilation. See the
--disable-libfl option to configure. Resolves #99.
*** the PIC version of libfl was not correctly built. It is no longer
included in the build/installation targets of flex since it was
unused.
*** the distributed man page is only rebuilt when the relevant source
files change or when the binary doesn't exist. In particular, this
is friendlier to cross compilation. Resolves #108
** test
*** the shell scripts in the test suite are more portable across different shell implementations.
* version 2.6.2 released 2016-10-24
** flex internals
*** a segfalt involving yyrestart(NULL) has been fixed
*** flex should now handle quoting when mixed with m4 processing correctly
*** flex handles `[[' and `]]' correctly
*** flex no longer generates non-ANSI code
*** more compilation warnings were squashed in generated scanners
*** prevented a buffer overflow that could occur when input buffers were the exact wrong size
** test suite
*** input filenames on MSWindows are now calculated correctly
*** general code cleanups in a number of tests now make the test suite compile much more cleanly
** build system
*** the xz archive has been replaced with an lzip archive
*** a new option to configure --enable-warnings to encapsulate passing
of warning-related flags which is useful in testing flex
*** make indent now works for out of source builds
*** Portability warnings when generating Makefile.in files are now suppressed; they were just noise and the use of GNU extensions in Makefile.{am,in,} was intentional and well known.
** bugs
*** resolved gh#67
** new sv translation from the translation project
* version 2.6.1 released 2016-03-01
** flex resources
*** The flex project is now hosted at github. Consider this a "period of transition". In particular, you should start at https://github.com/westes/flex for the flex codebase, issue tracking and pull requests.
*** New releases of flex are to be found at https://github.com/westes/flex/releases.
** flex internals
*** Flex now uses more modern and more standard names for variable types. There's more work to be done on that front yet, though.
*** A number of compiler warnings have been remedied.
*** Line directives should now work as expected and be absent when that is expected.
** test suite
*** When running the test suite, c++ files are compiled with the c++ header inside the flex distribution, rather than relying on the build system's flex header , which might not be installed yet or which might be out of date with respect to what flex tests expect.
*** Some portability fixes in the test suite such as opening files for reading in binary mode
** Building flex
*** The file src/scan.c asdistributed with flex source is now built with the current version of flex. Occasionally this had to be done manually to pick up new flex features. It's now just a part of flex's build system.
*** The pdf version of the manual is no longer distributed with flex, although if you have the texinfo package installed, you can still build it.
*** lots of general build system cleanup
*** the build system tries a bit harder to find libtoolize and texi2dvi.
*** When help2man and texi2dvi are missing, the error messages are now much more helpful.
** bug fixes
*** resolved github issues #53, #54, #55, #61.
*** Resolved sf bugs #128, #129, #155, #160, #184, #187, #195.
* version 2.6.0 released 2015-11-17
** User Visible Changes
*** C++ scanners now use references instead of pointers. See the manual for details.
*** A number of compiler warnings were addressed, so flex generated scanners should be quieter under compiler warning scenarios.
*** Allow error reporting routines to accept varying number of arguments
*** Removed deprecated 'register' storage class specifier
*** Changeed output formats from octal to hexadecimal
*** check limits before using array index cclp; resolves sf-166
*** Suppress clang warning about empty @param paragraph; resolves sf#158
*** Fixed malloc/realloc replacement, resolves sf bug#151.
*** Adjusted buffer sizes on ia64.
*** various documentation and code clean up fixes: resolves sf bugs #167, #168, among other patches.
** Flex Internals
*** flex is now organized into subdirectories. This keeps the tree neater at the top level and puts like things near each other and unlike things away from each other.
*** The test suite has been reorganized and is now run with the parallel test suite harness from automake.
*** Cleaned up the automake parts of the build system to better reflect what automake does on its own. Also added a call to libtoolize in autogen.sh because autoreconf gets confused without a prior run of libtoolize.
*** po/Makefile now includes a rule to fetch the latest translations from the translation project. "make -f po/Makefile getpo" from the top level of the flex tree will fetch the files.
*** New da translation from the translation project
* flex version 2.5.39 released 2014-03-26
** no user visible changes in this release
* version 2.5.38 released 2014-02-14
** internationalization
*** add sr translation from the translation project
*** update da, es, ko, nl, pt_BR, ro, ru, sv, tr, vi, zh_CN translations from the translation project
*** rename zh_tw to its proper zh_TW name
* version 2.5.37 released 2012-08-03
@ -512,6 +738,8 @@ But the inverse is still true
See the file ONEWS for changes in earlier releases.
See the file COPYING for copying conditions.
Local Variables:
mode: text
mode: outline-minor

79
contrib/flex/README
View File

@ -1,79 +0,0 @@
This is flex, the fast lexical analyzer generator.
flex is a tool for generating scanners: programs which recognize
lexical patterns in text.
More information about flex as well as the latest official release of
flex can be found at:
http://flex.sourceforge.net/
Bug reports should be submitted using the SourceForge Bug Tracker
facilities which can be found from flex's SourceForge project page at:
http://sourceforge.net/projects/flex
There are several mailing lists available as well:
flex-announce@lists.sourceforge.net - where posts will be made
announcing new releases of flex.
flex-help@lists.sourceforge.net - where you can post questions about
using flex
flex-devel@lists.sourceforge.net - where you can discuss development of
flex itself
Note that flex is distributed under a copyright very similar to that of
BSD Unix, and not under the GNU General Public License (GPL).
This file is part of flex.
This code is derived from software contributed to Berkeley by
Vern Paxson.
The United States Government has rights in this work pursuant
to contract no. DE-AC03-76SF00098 between the United States
Department of Energy and the University of California.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
Neither the name of the University nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.
The flex distribution contains the following files which may be of interest:
README - This file.
NEWS - current version number and list of user-visible changes.
INSTALL - basic installation information.
ABOUT-NLS - description of internationalization support in flex.
COPYING - flex's copyright and license.
doc/ - user documentation.
examples/ - containing examples of some possible flex scanners and a
few other things. See the file examples/README for more details.
TODO - outstanding bug reports, desired features, etc.
tests/ - regression tests. See TESTS/README for details.
po/ - internationalization support files.

109
contrib/flex/README.md Normal file
View File

@ -0,0 +1,109 @@
This is flex, the fast lexical analyzer generator.
flex is a tool for generating scanners: programs which recognize
lexical patterns in text.
The flex codebase is kept in
[Git on GitHub.](https://github.com/westes/flex)
Use GitHub's [issues](https://github.com/westes/flex/issues) and
[pull request](https://github.com/westes/flex) features to file bugs
and submit patches.
There are several mailing lists available as well:
* flex-announce@lists.sourceforge.net - where posts will be made
announcing new releases of flex.
* flex-help@lists.sourceforge.net - where you can post questions about
using flex
* flex-devel@lists.sourceforge.net - where you can discuss development
of flex itself
Find information on subscribing to the mailing lists at:
http://sourceforge.net/mail/?group_id=97492
The flex distribution contains the following files which may be of
interest:
* README - This file.
* NEWS - current version number and list of user-visible changes.
* INSTALL - basic installation information.
* ABOUT-NLS - description of internationalization support in flex.
* COPYING - flex's copyright and license.
* doc/ - user documentation.
* examples/ - containing examples of some possible flex scanners and a
few other things. See the file examples/README for more
details.
* tests/ - regression tests. See TESTS/README for details.
* po/ - internationalization support files.
You need the following tools to build flex from the maintainer's
repository:
* compiler suite - flex is built with gcc
* bash, or a good Bourne-style shell
* m4 - m4 -p needs to work; GNU m4 and a few others are suitable
* GNU bison; to generate parse.c from parse.y
* autoconf; for handling the build system
* automake; for Makefile generation
* gettext; for i18n support
* help2man; to generate the flex man page
* tar, gzip, lzip, etc.; for packaging of the source distribution
* GNU texinfo; to build and test the flex manual. Note that if you want
to build the dvi/ps/pdf versions of the documentation you will need
texi2dvi and related programs, along with a sufficiently powerful
implementation of TeX to process them. See your operating system
documentation for how to achieve this. The printable versions of the
manual are not built unless specifically requested, but the targets
are included by automake.
* GNU indent; for indenting the flex source the way we want it done
In cases where the versions of the above tools matter, the file
configure.ac will specify the minimum required versions.
Once you have all the necessary tools installed, life becomes
simple. To prepare the flex tree for building, run the script:
```bash
./autogen.sh
```
in the top level of the flex source tree.
This script calls the various tools needed to get flex ready for the
GNU-style configure script to be able to work.
From this point on, building flex follows the usual routine:
```bash
configure && make && make install
```
This file is part of flex.
This code is derived from software contributed to Berkeley by
Vern Paxson.
The United States Government has rights in this work pursuant
to contract no. DE-AC03-76SF00098 between the United States
Department of Energy and the University of California.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
Neither the name of the University nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.

184
contrib/flex/configure.ac Normal file
View File

@ -0,0 +1,184 @@
# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.
# This file is part of flex.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# Neither the name of the University nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE.
# autoconf requirements and initialization
AC_INIT([the fast lexical analyser generator],[2.6.4],[flex-help@lists.sourceforge.net],[flex])
AC_CONFIG_SRCDIR([src/scan.l])
AC_CONFIG_AUX_DIR([build-aux])
LT_INIT
AM_INIT_AUTOMAKE([1.11.3 -Wno-portability foreign check-news std-options dist-lzip parallel-tests subdir-objects])
AC_CONFIG_HEADER([src/config.h])
AC_CONFIG_LIBOBJ_DIR([lib])
AC_CONFIG_MACRO_DIR([m4])
SHARED_VERSION_INFO="2:0:0"
AC_SUBST(SHARED_VERSION_INFO)
# checks for programs
AM_GNU_GETTEXT([external])
AM_GNU_GETTEXT_VERSION([0.18])
AC_PROG_YACC
AS_IF([test "$YACC" != 'bison -y'], [
YACC="\${top_srcdir}/build-aux/missing bison -y"
AC_MSG_NOTICE(no bison program found: only required for maintainers)
])
AM_CONDITIONAL([HAVE_BISON], [test "$YACC" = 'bison -y'])
AM_PROG_LEX
AC_PROG_CC
AX_PROG_CC_FOR_BUILD
AC_PROG_CXX
AM_PROG_CC_C_O
AC_PROG_LN_S
AC_PROG_AWK
AC_PROG_INSTALL
# allow passing a variable `WARNINGFLAGS',
# either when invoking `configure', or when invoking `make'
# default to something useful if GCC was detected
AC_ARG_ENABLE([warnings],
[AS_HELP_STRING([--enable-warnings],
[enable a bunch of compiler warning flags (defaults to GCC warning flags).])],
[AS_IF([test "x$GCC" = xyes],
[ : ${WARNINGFLAGS="-Wall -Wextra -Wmissing-prototypes -Wstrict-prototypes -Wnested-externs -Wold-style-definition -Wredundant-decls -Wconversion -Wno-unused-but-set-variable"} ])])
AC_SUBST([WARNINGFLAGS])
AC_ARG_ENABLE([libfl],
[AS_HELP_STRING([--disable-libfl],
[do not build -lfl runtime support library])],
[], [enable_libfl=yes])
AM_CONDITIONAL([ENABLE_LIBFL], [test "x$enable_libfl" = xyes])
# --disable-bootstrap is intended only to workaround problems with bootstrap
# (e.g. when cross-compiling flex or when bootstrapping has bugs).
# Ideally we should be able to bootstrap even when cross-compiling.
AC_ARG_ENABLE([bootstrap],
[AS_HELP_STRING([--disable-bootstrap],
[don't perform a bootstrap when building flex])],
[], [enable_bootstrap=yes])
AM_CONDITIONAL([ENABLE_BOOTSTRAP], [test "x$enable_bootstrap" = xyes])
AM_CONDITIONAL([CROSS], [test "x$cross_compiling" = xyes])
AC_PATH_PROG([HELP2MAN], help2man, [\${top_srcdir}/build-aux/missing help2man])
AS_IF([test "$HELP2MAN" = "\${top_srcdir}/build-aux/missing help2man"],
AC_MSG_WARN(help2man: program not found: building man page will not work)
)
AC_PATH_PROGS([TEXI2DVI], [gtexi2dvi texi2dvi], [\${top_srcdir}/build-aux/missing texi2dvi])
AS_IF([test "$TEXI2DVI" = "\${top_srcdir}/build-aux/missing texi2dvi"],
AC_MSG_WARN(texi2dvi: program not found: building pdf version of manual will not work)
)
# Check for a m4 that supports -P
AC_CACHE_CHECK([for m4 that supports -P], [ac_cv_path_M4],
[AC_PATH_PROGS_FEATURE_CHECK([M4], [gm4 gnum4 m4],
[[m4out=`echo 'm''4_divnum' | $ac_path_M4 -P`]
[test "x$m4out" = x0 \
&& ac_cv_path_M4=$ac_path_M4 ac_path_M4_found=:]],
[AC_MSG_ERROR([could not find m4 that supports -P])])])
AC_SUBST([M4], [$ac_cv_path_M4])
AC_DEFINE_UNQUOTED([M4], ["$M4"], [Define to the m4 executable name.])
AC_PATH_PROG([INDENT], indent, [\${top_srcdir}/build-aux/missing indent])
AC_MSG_CHECKING(if $INDENT is GNU indent)
AS_IF([$INDENT --version 2>/dev/null | head -n 1 | grep "GNU indent" >/dev/null],
[AC_MSG_RESULT(yes)],
[AC_MSG_RESULT(no)
AC_MSG_WARN($INDENT does not appear to be GNU indent; 'make indent' may not function properly)
])
# checks for headers
AC_CHECK_HEADERS([regex.h strings.h sys/stat.h sys/wait.h unistd.h], [],
[AC_MSG_ERROR(required header not found on your system)])
AC_CHECK_HEADERS([inttypes.h libintl.h limits.h locale.h malloc.h netinet/in.h])
# checks for libraries
# The test test-pthread uses libpthread, so we check for it here, but
# all we need is the preprocessor symbol defined since we don't need
# LIBS to include libpthread for building flex.
LIBPTHREAD=''
AC_CHECK_LIB(pthread, pthread_mutex_lock,
[AC_CHECK_HEADERS([pthread.h], [LIBPTHREAD=-lpthread],
[AC_MSG_WARN([pthread tests will be skipped])])],
[AC_MSG_WARN([pthread tests will be skipped])])
AC_SUBST([LIBPTHREAD])
AC_CHECK_LIB(m, log10)
# Checks for typedefs, structures, and compiler characteristics.
AC_HEADER_STDBOOL
AC_C_CONST
AC_TYPE_SIZE_T
# Checks for library functions.
AC_FUNC_ALLOCA
AC_FUNC_FORK
dnl Autoconf bug: AC_FUNC_MALLOC and AC_FUNC_REALLOC might not warn of cross
dnl compilation. Workaround this.
AC_FUNC_MALLOC
AS_IF([test "$cross_compiling" = yes],
AC_MSG_WARN([result $ac_cv_func_malloc_0_nonnull guessed because of cross compilation]))
AC_FUNC_REALLOC
AS_IF([test "$cross_compiling" = yes],
AC_MSG_WARN([result $ac_cv_func_realloc_0_nonnull guessed because of cross compilation]))
AC_CHECK_FUNCS([dup2 dnl
memset dnl
regcomp dnl
strcasecmp dnl
strchr dnl
strdup dnl
strtol dnl
], [], [AC_MSG_ERROR(required library function not found on your system)])
# Optional library functions
AC_CHECK_FUNCS([dnl
pow dnl Used only by "examples/manual/expr"
setlocale dnl Needed only if NLS is enabled
reallocarray dnl OpenBSD function. We have replacement if not available.
])
AC_CONFIG_FILES(
Makefile
doc/Makefile
examples/Makefile
examples/fastwc/Makefile
examples/manual/Makefile
po/Makefile.in
src/Makefile
tools/Makefile
tests/Makefile
)
AC_OUTPUT

220
contrib/flex/src/FlexLexer.h Normal file
View File

@ -0,0 +1,220 @@
// -*-C++-*-
// FlexLexer.h -- define interfaces for lexical analyzer classes generated
// by flex
// Copyright (c) 1993 The Regents of the University of California.
// All rights reserved.
//
// This code is derived from software contributed to Berkeley by
// Kent Williams and Tom Epperly.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// Neither the name of the University nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE.
// This file defines FlexLexer, an abstract class which specifies the
// external interface provided to flex C++ lexer objects, and yyFlexLexer,
// which defines a particular lexer class.
//
// If you want to create multiple lexer classes, you use the -P flag
// to rename each yyFlexLexer to some other xxFlexLexer. You then
// include <FlexLexer.h> in your other sources once per lexer class:
//
// #undef yyFlexLexer
// #define yyFlexLexer xxFlexLexer
// #include <FlexLexer.h>
//
// #undef yyFlexLexer
// #define yyFlexLexer zzFlexLexer
// #include <FlexLexer.h>
// ...
#ifndef __FLEX_LEXER_H
// Never included before - need to define base class.
#define __FLEX_LEXER_H
#include <iostream>
extern "C++" {
struct yy_buffer_state;
typedef int yy_state_type;
class FlexLexer
{
public:
virtual ~FlexLexer() { }
const char* YYText() const { return yytext; }
int YYLeng() const { return yyleng; }
virtual void
yy_switch_to_buffer( yy_buffer_state* new_buffer ) = 0;
virtual yy_buffer_state* yy_create_buffer( std::istream* s, int size ) = 0;
virtual yy_buffer_state* yy_create_buffer( std::istream& s, int size ) = 0;
virtual void yy_delete_buffer( yy_buffer_state* b ) = 0;
virtual void yyrestart( std::istream* s ) = 0;
virtual void yyrestart( std::istream& s ) = 0;
virtual int yylex() = 0;
// Call yylex with new input/output sources.
int yylex( std::istream& new_in, std::ostream& new_out )
{
switch_streams( new_in, new_out );
return yylex();
}
int yylex( std::istream* new_in, std::ostream* new_out = 0)
{
switch_streams( new_in, new_out );
return yylex();
}
// Switch to new input/output streams. A nil stream pointer
// indicates "keep the current one".
virtual void switch_streams( std::istream* new_in,
std::ostream* new_out ) = 0;
virtual void switch_streams( std::istream& new_in,
std::ostream& new_out ) = 0;
int lineno() const { return yylineno; }
int debug() const { return yy_flex_debug; }
void set_debug( int flag ) { yy_flex_debug = flag; }
protected:
char* yytext;
int yyleng;
int yylineno; // only maintained if you use %option yylineno
int yy_flex_debug; // only has effect with -d or "%option debug"
};
}
#endif // FLEXLEXER_H
#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
// Either this is the first time through (yyFlexLexerOnce not defined),
// or this is a repeated include to define a different flavor of
// yyFlexLexer, as discussed in the flex manual.
# define yyFlexLexerOnce
extern "C++" {
class yyFlexLexer : public FlexLexer {
public:
// arg_yyin and arg_yyout default to the cin and cout, but we
// only make that assignment when initializing in yylex().
yyFlexLexer( std::istream& arg_yyin, std::ostream& arg_yyout );
yyFlexLexer( std::istream* arg_yyin = 0, std::ostream* arg_yyout = 0 );
private:
void ctor_common();
public:
virtual ~yyFlexLexer();
void yy_switch_to_buffer( yy_buffer_state* new_buffer );
yy_buffer_state* yy_create_buffer( std::istream* s, int size );
yy_buffer_state* yy_create_buffer( std::istream& s, int size );
void yy_delete_buffer( yy_buffer_state* b );
void yyrestart( std::istream* s );
void yyrestart( std::istream& s );
void yypush_buffer_state( yy_buffer_state* new_buffer );
void yypop_buffer_state();
virtual int yylex();
virtual void switch_streams( std::istream& new_in, std::ostream& new_out );
virtual void switch_streams( std::istream* new_in = 0, std::ostream* new_out = 0 );
virtual int yywrap();
protected:
virtual int LexerInput( char* buf, int max_size );
virtual void LexerOutput( const char* buf, int size );
virtual void LexerError( const char* msg );
void yyunput( int c, char* buf_ptr );
int yyinput();
void yy_load_buffer_state();
void yy_init_buffer( yy_buffer_state* b, std::istream& s );
void yy_flush_buffer( yy_buffer_state* b );
int yy_start_stack_ptr;
int yy_start_stack_depth;
int* yy_start_stack;
void yy_push_state( int new_state );
void yy_pop_state();
int yy_top_state();
yy_state_type yy_get_previous_state();
yy_state_type yy_try_NUL_trans( yy_state_type current_state );
int yy_get_next_buffer();
std::istream yyin; // input source for default LexerInput
std::ostream yyout; // output sink for default LexerOutput
// yy_hold_char holds the character lost when yytext is formed.
char yy_hold_char;
// Number of characters read into yy_ch_buf.
int yy_n_chars;
// Points to current character in buffer.
char* yy_c_buf_p;
int yy_init; // whether we need to initialize
int yy_start; // start state number
// Flag which is used to allow yywrap()'s to do buffer switches
// instead of setting up a fresh yyin. A bit of a hack ...
int yy_did_buffer_switch_on_eof;
size_t yy_buffer_stack_top; /**< index of top of stack. */
size_t yy_buffer_stack_max; /**< capacity of stack. */
yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
void yyensure_buffer_stack(void);
// The following are not always needed, but may be depending
// on use of certain flex features (like REJECT or yymore()).
yy_state_type yy_last_accepting_state;
char* yy_last_accepting_cpos;
yy_state_type* yy_state_buf;
yy_state_type* yy_state_ptr;
char* yy_full_match;
int* yy_full_state;
int yy_full_lp;
int yy_lp;
int yy_looking_for_trail_begin;
int yy_more_flag;
int yy_more_len;
int yy_more_offset;
int yy_prev_more_offset;
};
}
#endif // yyFlexLexer || ! yyFlexLexerOnce

85
contrib/flex/buf.c → contrib/flex/src/buf.c
View File

@ -73,12 +73,13 @@ struct Buf *buf_prints (struct Buf *buf, const char *fmt, const char *s)
char *t;
size_t tsz;
t = flex_alloc (tsz = strlen (fmt) + strlen (s) + 1);
tsz = strlen(fmt) + strlen(s) + 1;
t = malloc(tsz);
if (!t)
flexfatal (_("Allocation of buffer to print string failed"));
snprintf (t, tsz, fmt, s);
buf = buf_strappend (buf, t);
flex_free (t);
free(t);
return buf;
}
@ -92,21 +93,26 @@ struct Buf *buf_linedir (struct Buf *buf, const char* filename, int lineno)
{
char *dst, *t;
const char *src;
size_t tsz;
t = flex_alloc (strlen ("#line \"\"\n") + /* constant parts */
if (gen_line_dirs)
return buf;
tsz = strlen("#line \"\"\n") + /* constant parts */
2 * strlen (filename) + /* filename with possibly all backslashes escaped */
NUMCHARLINES + /* line number */
1); /* NUL */
1; /* NUL */
t = malloc(tsz);
if (!t)
flexfatal (_("Allocation of buffer for line directive failed"));
for (dst = t + sprintf (t, "#line %d \"", lineno), src = filename; *src; *dst++ = *src++)
for (dst = t + snprintf (t, tsz, "#line %d \"", lineno), src = filename; *src; *dst++ = *src++)
if (*src == '\\') /* escape backslashes */
*dst++ = '\\';
*dst++ = '"';
*dst++ = '\n';
*dst = '\0';
buf = buf_strappend (buf, t);
flex_free (t);
free(t);
return buf;
}
@ -124,10 +130,7 @@ struct Buf *buf_concat(struct Buf* dest, const struct Buf* src)
/* Appends n characters in str to buf. */
struct Buf *buf_strnappend (buf, str, n)
struct Buf *buf;
const char *str;
int n;
struct Buf *buf_strnappend (struct Buf *buf, const char *str, int n)
{
buf_append (buf, str, n + 1);
@ -138,18 +141,13 @@ struct Buf *buf_strnappend (buf, str, n)
}
/* Appends characters in str to buf. */
struct Buf *buf_strappend (buf, str)
struct Buf *buf;
const char *str;
struct Buf *buf_strappend (struct Buf *buf, const char *str)
{
return buf_strnappend (buf, str, strlen (str));
return buf_strnappend (buf, str, (int) strlen (str));
}
/* appends "#define str def\n" */
struct Buf *buf_strdefine (buf, str, def)
struct Buf *buf;
const char *str;
const char *def;
struct Buf *buf_strdefine (struct Buf *buf, const char *str, const char *def)
{
buf_strappend (buf, "#define ");
buf_strappend (buf, " ");
@ -168,12 +166,13 @@ struct Buf *buf_strdefine (buf, str, def)
*/
struct Buf *buf_m4_define (struct Buf *buf, const char* def, const char* val)
{
const char * fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n";
const char * fmt = "m4_define( [[%s]], [[[[%s]]]])m4_dnl\n";
char * str;
size_t strsz;
val = val?val:"";
str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + strlen(val) + 2);
strsz = strlen(fmt) + strlen(def) + strlen(val) + 2;
str = malloc(strsz);
if (!str)
flexfatal (_("Allocation of buffer for m4 def failed"));
@ -193,7 +192,8 @@ struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
char * str;
size_t strsz;
str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(def) + 2);
strsz = strlen(fmt) + strlen(def) + 2;
str = malloc(strsz);
if (!str)
flexfatal (_("Allocation of buffer for m4 undef failed"));
@ -203,23 +203,21 @@ struct Buf *buf_m4_undefine (struct Buf *buf, const char* def)
}
/* create buf with 0 elements, each of size elem_size. */
void buf_init (buf, elem_size)
struct Buf *buf;
size_t elem_size;
void buf_init (struct Buf *buf, size_t elem_size)
{
buf->elts = (void *) 0;
buf->elts = NULL;
buf->nelts = 0;
buf->elt_size = elem_size;
buf->nmax = 0;
}
/* frees memory */
void buf_destroy (buf)
struct Buf *buf;
void buf_destroy (struct Buf *buf)
{
if (buf && buf->elts)
flex_free (buf->elts);
buf->elts = (void *) 0;
if (buf) {
free(buf->elts);
buf->elts = NULL;
}
}
@ -229,10 +227,7 @@ void buf_destroy (buf)
* We grow by mod(512) boundaries.
*/
struct Buf *buf_append (buf, ptr, n_elem)
struct Buf *buf;
const void *ptr;
int n_elem;
struct Buf *buf_append (struct Buf *buf, const void *ptr, int n_elem)
{
int n_alloc = 0;
@ -242,30 +237,30 @@ struct Buf *buf_append (buf, ptr, n_elem)
/* May need to alloc more. */
if (n_elem + buf->nelts > buf->nmax) {
/* exact amount needed... */
n_alloc = (n_elem + buf->nelts) * buf->elt_size;
/* exact count needed... */
n_alloc = n_elem + buf->nelts;
/* ...plus some extra */
if (((n_alloc * buf->elt_size) % 512) != 0
if ((((size_t) n_alloc * buf->elt_size) % 512) != 0
&& buf->elt_size < 512)
n_alloc +=
(512 -
((n_alloc * buf->elt_size) % 512)) /
buf->elt_size;
n_alloc += (int)
((512 -
(((size_t) n_alloc * buf->elt_size) % 512)) /
buf->elt_size);
if (!buf->elts)
buf->elts =
allocate_array (n_alloc, buf->elt_size);
allocate_array ((int) n_alloc, buf->elt_size);
else
buf->elts =
reallocate_array (buf->elts, n_alloc,
reallocate_array (buf->elts, (int) n_alloc,
buf->elt_size);
buf->nmax = n_alloc;
}
memcpy ((char *) buf->elts + buf->nelts * buf->elt_size, ptr,
n_elem * buf->elt_size);
memcpy ((char *) buf->elts + (size_t) buf->nelts * buf->elt_size, ptr,
(size_t) n_elem * buf->elt_size);
buf->nelts += n_elem;
return buf;

15
contrib/flex/ccl.c → contrib/flex/src/ccl.c
View File

@ -52,9 +52,7 @@ ccl_contains (const int cclp, const int ch)
/* ccladd - add a single character to a ccl */
void ccladd (cclp, ch)
int cclp;
int ch;
void ccladd (int cclp, int ch)
{
int ind, len, newpos, i;
@ -85,7 +83,7 @@ void ccladd (cclp, ch)
}
ccllen[cclp] = len + 1;
ccltbl[newpos] = ch;
ccltbl[newpos] = (unsigned char) ch;
}
/* dump_cclp - same thing as list_character_set, but for cclps. */
@ -185,7 +183,7 @@ ccl_set_union (int a, int b)
/* cclinit - return an empty ccl */
int cclinit ()
int cclinit (void)
{
if (++lastccl >= current_maxccls) {
current_maxccls += MAX_CCLS_INCREMENT;
@ -225,8 +223,7 @@ int cclinit ()
/* cclnegate - negate the given ccl */
void cclnegate (cclp)
int cclp;
void cclnegate (int cclp)
{
cclng[cclp] = 1;
ccl_has_nl[cclp] = !ccl_has_nl[cclp];
@ -240,9 +237,7 @@ void cclnegate (cclp)
* has a non-zero value in the cset array.
*/
void list_character_set (file, cset)
FILE *file;
int cset[];
void list_character_set (FILE *file, int cset[])
{
int i;

81
contrib/flex/dfa.c → contrib/flex/src/dfa.c
View File

@ -34,10 +34,10 @@
/* declare functions that have forward references */
void dump_associated_rules PROTO ((FILE *, int));
void dump_transitions PROTO ((FILE *, int[]));
void sympartition PROTO ((int[], int, int[], int[]));
int symfollowset PROTO ((int[], int, int, int[]));
void dump_associated_rules(FILE *, int);
void dump_transitions(FILE *, int[]);
void sympartition(int[], int, int[], int[]);
int symfollowset(int[], int, int, int[]);
/* check_for_backing_up - check a DFA state for backing up
@ -49,9 +49,7 @@ int symfollowset PROTO ((int[], int, int, int[]));
* indexed by equivalence class.
*/
void check_for_backing_up (ds, state)
int ds;
int state[];
void check_for_backing_up (int ds, int state[])
{
if ((reject && !dfaacc[ds].dfaacc_set) || (!reject && !dfaacc[ds].dfaacc_state)) { /* state is non-accepting */
++num_backing_up;
@ -96,10 +94,7 @@ void check_for_backing_up (ds, state)
* accset[1 .. nacc] is the list of accepting numbers for the DFA state.
*/
void check_trailing_context (nfa_states, num_states, accset, nacc)
int *nfa_states, num_states;
int *accset;
int nacc;
void check_trailing_context (int *nfa_states, int num_states, int *accset, int nacc)
{
int i, j;
@ -137,9 +132,7 @@ void check_trailing_context (nfa_states, num_states, accset, nacc)
* and writes a report to the given file.
*/
void dump_associated_rules (file, ds)
FILE *file;
int ds;
void dump_associated_rules (FILE *file, int ds)
{
int i, j;
int num_associated_rules = 0;
@ -161,7 +154,7 @@ void dump_associated_rules (file, ds)
}
}
qsort (&rule_set [1], num_associated_rules, sizeof (rule_set [1]), intcmp);
qsort (&rule_set [1], (size_t) num_associated_rules, sizeof (rule_set [1]), intcmp);
fprintf (file, _(" associated rule line numbers:"));
@ -187,9 +180,7 @@ void dump_associated_rules (file, ds)
* is done to the given file.
*/
void dump_transitions (file, state)
FILE *file;
int state[];
void dump_transitions (FILE *file, int state[])
{
int i, ec;
int out_char_set[CSIZE];
@ -235,8 +226,7 @@ void dump_transitions (file, state)
* hashval is the hash value for the dfa corresponding to the state set.
*/
int *epsclosure (t, ns_addr, accset, nacc_addr, hv_addr)
int *t, *ns_addr, accset[], *nacc_addr, *hv_addr;
int *epsclosure (int *t, int *ns_addr, int accset[], int *nacc_addr, int *hv_addr)
{
int stkpos, ns, tsp;
int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum;
@ -351,7 +341,7 @@ ADD_STATE(state); \
/* increase_max_dfas - increase the maximum number of DFAs */
void increase_max_dfas ()
void increase_max_dfas (void)
{
current_max_dfas += MAX_DFAS_INCREMENT;
@ -378,7 +368,7 @@ void increase_max_dfas ()
* dfa starts out in state #1.
*/
void ntod ()
void ntod (void)
{
int *accset, ds, nacc, newds;
int sym, hashval, numstates, dsize;
@ -400,7 +390,7 @@ void ntod ()
* from 1 to CSIZE, so their size must be CSIZE + 1.
*/
int duplist[CSIZE + 1], state[CSIZE + 1];
int targfreq[CSIZE + 1], targstate[CSIZE + 1];
int targfreq[CSIZE + 1] = {0}, targstate[CSIZE + 1];
/* accset needs to be large enough to hold all of the rules present
* in the input, *plus* their YY_TRAILING_HEAD_MASK variants.
@ -473,13 +463,8 @@ void ntod ()
/* We still may want to use the table if numecs
* is a power of 2.
*/
int power_of_two;
for (power_of_two = 1; power_of_two <= csize;
power_of_two *= 2)
if (numecs == power_of_two) {
if (numecs <= csize && is_power_of_2(numecs)) {
use_NUL_table = true;
break;
}
}
@ -521,15 +506,13 @@ void ntod ()
* So we'll have to realloc() on the way...
* we'll wait until we can calculate yynxt_tbl->td_hilen.
*/
yynxt_tbl =
(struct yytbl_data *) calloc (1,
sizeof (struct
yytbl_data));
yynxt_tbl = calloc(1, sizeof (struct yytbl_data));
yytbl_data_init (yynxt_tbl, YYTD_ID_NXT);
yynxt_tbl->td_hilen = 1;
yynxt_tbl->td_lolen = num_full_table_rows;
yynxt_tbl->td_lolen = (flex_uint32_t) num_full_table_rows;
yynxt_tbl->td_data = yynxt_data =
(flex_int32_t *) calloc (yynxt_tbl->td_lolen *
calloc(yynxt_tbl->td_lolen *
yynxt_tbl->td_hilen,
sizeof (flex_int32_t));
yynxt_curr = 0;
@ -543,12 +526,12 @@ void ntod ()
*/
if (gentables)
out_str_dec
("static yyconst %s yy_nxt[][%d] =\n {\n",
("static const %s yy_nxt[][%d] =\n {\n",
long_align ? "flex_int32_t" : "flex_int16_t",
num_full_table_rows);
else {
out_dec ("#undef YY_NXT_LOLEN\n#define YY_NXT_LOLEN (%d)\n", num_full_table_rows);
out_str ("static yyconst %s *yy_nxt =0;\n",
out_str ("static const %s *yy_nxt =0;\n",
long_align ? "flex_int32_t" : "flex_int16_t");
}
@ -713,7 +696,7 @@ void ntod ()
/* Each time we hit here, it's another td_hilen, so we realloc. */
yynxt_tbl->td_hilen++;
yynxt_tbl->td_data = yynxt_data =
(flex_int32_t *) realloc (yynxt_data,
realloc (yynxt_data,
yynxt_tbl->td_hilen *
yynxt_tbl->td_lolen *
sizeof (flex_int32_t));
@ -805,8 +788,8 @@ void ntod ()
mkdeftbl ();
}
flex_free ((void *) accset);
flex_free ((void *) nset);
free(accset);
free(nset);
}
@ -820,8 +803,7 @@ void ntod ()
* On return, the dfa state number is in newds.
*/
int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
int sns[], numstates, accset[], nacc, hashval, *newds_addr;
int snstods (int sns[], int numstates, int accset[], int nacc, int hashval, int *newds_addr)
{
int didsort = 0;
int i, j;
@ -836,7 +818,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
/* We sort the states in sns so we
* can compare it to oldsns quickly.
*/
qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
didsort = 1;
}
@ -871,7 +853,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
*/
if (!didsort)
qsort (&sns [1], numstates, sizeof (sns [1]), intcmp);
qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp);
for (i = 1; i <= numstates; ++i)
dss[newds][i] = sns[i];
@ -881,7 +863,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
if (nacc == 0) {
if (reject)
dfaacc[newds].dfaacc_set = (int *) 0;
dfaacc[newds].dfaacc_set = NULL;
else
dfaacc[newds].dfaacc_state = 0;
@ -894,7 +876,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
* match in the event of ties will work.
*/
qsort (&accset [1], nacc, sizeof (accset [1]), intcmp);
qsort (&accset [1], (size_t) nacc, sizeof (accset [1]), intcmp);
dfaacc[newds].dfaacc_set =
allocate_integer_array (nacc + 1);
@ -942,8 +924,7 @@ int snstods (sns, numstates, accset, nacc, hashval, newds_addr)
* int transsym, int nset[current_max_dfa_size] );
*/
int symfollowset (ds, dsize, transsym, nset)
int ds[], dsize, transsym, nset[];
int symfollowset (int ds[], int dsize, int transsym, int nset[])
{
int ns, tsp, sym, i, j, lenccl, ch, numstates, ccllist;
@ -1020,9 +1001,7 @@ int symfollowset (ds, dsize, transsym, nset)
* int symlist[numecs], int duplist[numecs] );
*/
void sympartition (ds, numstates, symlist, duplist)
int ds[], numstates;
int symlist[], duplist[];
void sympartition (int ds[], int numstates, int symlist[], int duplist[])
{
int tch, i, j, k, ns, dupfwd[CSIZE + 1], lenccl, cclp, ich;

21
contrib/flex/ecs.c → contrib/flex/src/ecs.c
View File

@ -36,7 +36,7 @@
/* ccl2ecl - convert character classes to set of equivalence classes */
void ccl2ecl ()
void ccl2ecl (void)
{
int i, ich, newlen, cclp, ccls, cclmec;
@ -56,7 +56,8 @@ void ccl2ecl ()
cclmec = ecgroup[ich];
if (cclmec > 0) {
ccltbl[cclp + newlen] = cclmec;
/* Note: range 1..256 is mapped to 1..255,0 */
ccltbl[cclp + newlen] = (unsigned char) cclmec;
++newlen;
}
}
@ -74,8 +75,7 @@ void ccl2ecl ()
* Returned is the number of classes.
*/
int cre8ecs (fwd, bck, num)
int fwd[], bck[], num;
int cre8ecs (int fwd[], int bck[], int num)
{
int i, j, numcl;
@ -100,9 +100,9 @@ int cre8ecs (fwd, bck, num)
/* mkeccl - update equivalence classes based on character class xtions
*
* synopsis
* Char ccls[];
* unsigned char ccls[];
* int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
* void mkeccl( Char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
* void mkeccl( unsigned char ccls[], int lenccl, int fwd[llsiz], int bck[llsiz],
* int llsiz, int NUL_mapping );
*
* ccls contains the elements of the character class, lenccl is the
@ -112,9 +112,7 @@ int cre8ecs (fwd, bck, num)
* NUL_mapping is the value which NUL (0) should be mapped to.
*/
void mkeccl (ccls, lenccl, fwd, bck, llsiz, NUL_mapping)
Char ccls[];
int lenccl, fwd[], bck[], llsiz, NUL_mapping;
void mkeccl (unsigned char ccls[], int lenccl, int fwd[], int bck[], int llsiz, int NUL_mapping)
{
int cclp, oldec, newec;
int cclm, i, j;
@ -191,7 +189,7 @@ void mkeccl (ccls, lenccl, fwd, bck, llsiz, NUL_mapping)
/* Find next ccl member to process. */
for (++cclp; cclflags[cclp] && cclp < lenccl; ++cclp) {
for (++cclp; cclp < lenccl && cclflags[cclp]; ++cclp) {
/* Reset "doesn't need processing" flag. */
cclflags[cclp] = 0;
}
@ -201,8 +199,7 @@ void mkeccl (ccls, lenccl, fwd, bck, llsiz, NUL_mapping)
/* mkechar - create equivalence class for single character */
void mkechar (tch, fwd, bck)
int tch, fwd[], bck[];
void mkechar (int tch, int fwd[], int bck[])
{
/* If until now the character has been a proper subset of
* an equivalence class, break it away to create a new ec

60
contrib/flex/filter.c → contrib/flex/src/filter.c
View File

@ -47,9 +47,9 @@ struct filter *filter_create_ext (struct filter *chain, const char *cmd,
va_list ap;
/* allocate and initialize new filter */
f = (struct filter *) flex_alloc (sizeof (struct filter));
f = malloc(sizeof(struct filter));
if (!f)
flexerror (_("flex_alloc failed (f) in filter_create_ext"));
flexerror(_("malloc failed (f) in filter_create_ext"));
memset (f, 0, sizeof (*f));
f->filter_func = NULL;
f->extra = NULL;
@ -66,23 +66,16 @@ struct filter *filter_create_ext (struct filter *chain, const char *cmd,
/* allocate argv, and populate it with the argument list. */
max_args = 8;
f->argv =
(const char **) flex_alloc (sizeof (char *) *
(max_args + 1));
f->argv = malloc(sizeof(char *) * (size_t) (max_args + 1));
if (!f->argv)
flexerror (_("flex_alloc failed (f->argv) in filter_create_ext"));
flexerror(_("malloc failed (f->argv) in filter_create_ext"));
f->argv[f->argc++] = cmd;
va_start (ap, cmd);
while ((s = va_arg (ap, const char *)) != NULL) {
if (f->argc >= max_args) {
max_args += 8;
f->argv =
(const char **) flex_realloc (f->argv,
sizeof (char
*) *
(max_args +
1));
f->argv = realloc(f->argv, sizeof(char*) * (size_t) (max_args + 1));
}
f->argv[f->argc++] = s;
}
@ -107,9 +100,9 @@ struct filter *filter_create_int (struct filter *chain,
struct filter *f;
/* allocate and initialize new filter */
f = (struct filter *) flex_alloc (sizeof (struct filter));
f = malloc(sizeof(struct filter));
if (!f)
flexerror (_("flex_alloc failed in filter_create_int"));
flexerror(_("malloc failed in filter_create_int"));
memset (f, 0, sizeof (*f));
f->next = NULL;
f->argc = 0;
@ -174,6 +167,8 @@ clearerr(stdin);
flexfatal (_("dup2(pipes[0],0)"));
close (pipes[0]);
fseek (stdin, 0, SEEK_CUR);
ungetc(' ', stdin); /* still an evil hack, but one that works better */
(void)fgetc(stdin); /* on NetBSD than the fseek attempt does */
/* run as a filter, either internally or by exec */
if (chain->filter_func) {
@ -181,16 +176,16 @@ clearerr(stdin);
if ((r = chain->filter_func (chain)) == -1)
flexfatal (_("filter_func failed"));
exit (0);
FLEX_EXIT (0);
}
else {
execvp (chain->argv[0],
(char **const) (chain->argv));
lerrsf_fatal ( _("exec of %s failed"),
lerr_fatal ( _("exec of %s failed"),
chain->argv[0]);
}
exit (1);
FLEX_EXIT (1);
}
/* Parent */
@ -288,9 +283,9 @@ int filter_tee_header (struct filter *chain)
fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n",
outfilename ? outfilename : "<stdout>");
buf = (char *) flex_alloc (readsz);
buf = malloc((size_t) readsz);
if (!buf)
flexerror (_("flex_alloc failed in filter_tee_header"));
flexerror(_("malloc failed in filter_tee_header"));
while (fgets (buf, readsz, stdin)) {
fputs (buf, to_c);
if (write_header)
@ -301,6 +296,7 @@ int filter_tee_header (struct filter *chain)
fprintf (to_h, "\n");
/* write a fake line number. It will get fixed by the linedir filter. */
if (gen_line_dirs)
fprintf (to_h, "#line 4000 \"M4_YY_OUTFILE_NAME\"\n");
fprintf (to_h, "#undef %sIN_HEADER\n", prefix);
@ -309,26 +305,26 @@ int filter_tee_header (struct filter *chain)
fflush (to_h);
if (ferror (to_h))
lerrsf (_("error writing output file %s"),
lerr (_("error writing output file %s"),
(char *) chain->extra);
else if (fclose (to_h))
lerrsf (_("error closing output file %s"),
lerr (_("error closing output file %s"),
(char *) chain->extra);
}
fflush (to_c);
if (ferror (to_c))
lerrsf (_("error writing output file %s"),
lerr (_("error writing output file %s"),
outfilename ? outfilename : "<stdout>");
else if (fclose (to_c))
lerrsf (_("error closing output file %s"),
lerr (_("error closing output file %s"),
outfilename ? outfilename : "<stdout>");
while (wait (0) > 0) ;
exit (0);
FLEX_EXIT (0);
return 0;
}
@ -341,7 +337,7 @@ int filter_tee_header (struct filter *chain)
int filter_fix_linedirs (struct filter *chain)
{
char *buf;
const int readsz = 512;
const size_t readsz = 512;
int lineno = 1;
bool in_gen = true; /* in generated code */
bool last_was_blank = false;
@ -349,11 +345,11 @@ int filter_fix_linedirs (struct filter *chain)
if (!chain)
return 0;
buf = (char *) flex_alloc (readsz);
buf = malloc(readsz);
if (!buf)
flexerror (_("flex_alloc failed in filter_fix_linedirs"));
flexerror(_("malloc failed in filter_fix_linedirs"));
while (fgets (buf, readsz, stdin)) {
while (fgets (buf, (int) readsz, stdin)) {
regmatch_t m[10];
@ -361,11 +357,9 @@ int filter_fix_linedirs (struct filter *chain)
if (buf[0] == '#'
&& regexec (&regex_linedir, buf, 3, m, 0) == 0) {
int num;
char *fname;
/* extract the line number and filename */
num = regmatch_strtol (&m[1], buf, NULL, 0);
fname = regmatch_dup (&m[2], buf);
if (strcmp (fname,
@ -397,7 +391,7 @@ int filter_fix_linedirs (struct filter *chain)
/* Adjust the line directives. */
in_gen = true;
snprintf (buf, readsz, "#line %d \"%s\"\n",
lineno + 1, filename);
lineno, filename);
}
else {
/* it's a #line directive for code we didn't write */
@ -428,11 +422,11 @@ int filter_fix_linedirs (struct filter *chain)
}
fflush (stdout);
if (ferror (stdout))
lerrsf (_("error writing output file %s"),
lerr (_("error writing output file %s"),
outfilename ? outfilename : "<stdout>");
else if (fclose (stdout))
lerrsf (_("error closing output file %s"),
lerr (_("error closing output file %s"),
outfilename ? outfilename : "<stdout>");
return 0;

685
contrib/flex/flex.skl → contrib/flex/src/flex.skl
View File

File diff suppressed because it is too large Load Diff

424
contrib/flex/flexdef.h → contrib/flex/src/flexdef.h
View File

@ -39,29 +39,14 @@
#include <config.h>
#endif
/* AIX requires this to be the first thing in the file. */
#ifndef __GNUC__
# if HAVE_ALLOCA_H
# include <alloca.h>
# else
# ifdef _AIX
#pragma alloca
# else
# ifndef alloca /* predefined by HP cc +Olibcalls */
char *alloca ();
# endif
# endif
# endif
#endif
#ifdef STDC_HEADERS
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <setjmp.h>
#include <ctype.h>
#include <libgen.h> /* for XPG version of basename(3) */
#include <string.h>
#endif
#ifdef HAVE_ASSERT_H
#include <assert.h>
#else
@ -71,28 +56,24 @@ char *alloca ();
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_UNISTD_H
/* Required: dup() and dup2() in <unistd.h> */
#include <unistd.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_SYS_PARAMS_H
#include <sys/params.h>
#endif
#ifdef HAVE_SYS_WAIT_H
/* Required: stat() in <sys/stat.h> */
#include <sys/stat.h>
/* Required: wait() in <sys/wait.h> */
#include <sys/wait.h>
#endif
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#else
#define bool int
#define true 1
#define false 0
#endif
#ifdef HAVE_REGEX_H
#include <stdarg.h>
/* Required: regcomp(), regexec() and regerror() in <regex.h> */
#include <regex.h>
#endif
/* Required: strcasecmp() in <strings.h> */
#include <strings.h>
#include "flexint.h"
/* We use gettext. So, when we write strings which should be translated, we mark them with _() */
@ -108,33 +89,12 @@ char *alloca ();
/* Always be prepared to generate an 8-bit scanner. */
#define CSIZE 256
#define Char unsigned char
/* Size of input alphabet - should be size of ASCII set. */
#ifndef DEFAULT_CSIZE
#define DEFAULT_CSIZE 128
#endif
#ifndef PROTO
#if defined(__STDC__)
#define PROTO(proto) proto
#else
#define PROTO(proto) ()
#endif
#endif
#ifdef VMS
#ifndef __VMS_POSIX
#define unlink remove
#define SHORT_FILE_NAMES
#endif
#endif
#ifdef MS_DOS
#define SHORT_FILE_NAMES
#endif
/* Maximum line length we'll have to deal with. */
#define MAXLINE 2048
@ -148,11 +108,8 @@ char *alloca ();
#define ABS(x) ((x) < 0 ? -(x) : (x))
#endif
/* ANSI C does not guarantee that isascii() is defined */
#ifndef isascii
#define isascii(c) ((c) <= 0177)
#endif
/* Whether an integer is a power of two */
#define is_power_of_2(n) ((n) > 0 && ((n) & ((n) - 1)) == 0)
#define unspecified -1
@ -382,7 +339,7 @@ char *alloca ();
* use_read - if true (-f, -F, or -Cr) then use read() for scanner input;
* otherwise, use fread().
* yytext_is_array - if true (i.e., %array directive), then declare
* yytext as an array instead of a character pointer. Nice and inefficient.
* yytext as a array instead of a character pointer. Nice and inefficient.
* do_yywrap - do yywrap() processing on EOF. If false, EOF treated as
* "no more files".
* csize - size of character set for the scanner we're generating;
@ -397,6 +354,7 @@ char *alloca ();
* yymore_really_used - whether to treat yymore() as really used, regardless
* of what we think based on references to it in the user's actions.
* reject_really_used - same for REJECT
* trace_hex - use hexadecimal numbers in trace/debug outputs instead of octals
*/
extern int printstats, syntaxerror, eofseen, ddebug, trace, nowarn,
@ -405,13 +363,12 @@ extern int interactive, lex_compat, posix_compat, do_yylineno;
extern int useecs, fulltbl, usemecs, fullspd;
extern int gen_line_dirs, performance_report, backing_up_report;
extern int reentrant, bison_bridge_lval, bison_bridge_lloc;
extern bool ansi_func_defs, ansi_func_protos;
extern int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap;
extern int csize;
extern int yymore_used, reject, real_reject, continued_action, in_rule;
extern int yymore_really_used, reject_really_used;
extern int trace_hex;
/* Variables used in the flex input routines:
* datapos - characters on current output line
@ -446,7 +403,7 @@ extern int yymore_really_used, reject_really_used;
*/
extern int datapos, dataline, linenum;
extern FILE *skelfile, *yyin, *backing_up_file;
extern FILE *skelfile, *backing_up_file;
extern const char *skel[];
extern int skel_ind;
extern char *infilename, *outfilename, *headerfilename;
@ -648,7 +605,7 @@ extern int end_of_buffer_state;
extern int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
extern int current_maxccls, current_max_ccl_tbl_size;
extern Char *ccltbl;
extern unsigned char *ccltbl;
/* Variables for miscellaneous information:
@ -676,62 +633,54 @@ extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
extern int num_backing_up, bol_needed;
void *allocate_array PROTO ((int, size_t));
void *reallocate_array PROTO ((void *, int, size_t));
#ifndef HAVE_REALLOCARRAY
void *reallocarray(void *, size_t, size_t);
#endif
void *flex_alloc PROTO ((size_t));
void *flex_realloc PROTO ((void *, size_t));
void flex_free PROTO ((void *));
void *allocate_array(int, size_t);
void *reallocate_array(void *, int, size_t);
#define allocate_integer_array(size) \
(int *) allocate_array( size, sizeof( int ) )
allocate_array(size, sizeof(int))
#define reallocate_integer_array(array,size) \
(int *) reallocate_array( (void *) array, size, sizeof( int ) )
reallocate_array((void *) array, size, sizeof(int))
#define allocate_bool_array(size) \
(bool *) allocate_array( size, sizeof( bool ) )
allocate_array(size, sizeof(bool))
#define reallocate_bool_array(array,size) \
(bool *) reallocate_array( (void *) array, size, sizeof( bool ) )
reallocate_array((void *) array, size, sizeof(bool))
#define allocate_int_ptr_array(size) \
(int **) allocate_array( size, sizeof( int * ) )
allocate_array(size, sizeof(int *))
#define allocate_char_ptr_array(size) \
(char **) allocate_array( size, sizeof( char * ) )
allocate_array(size, sizeof(char *))
#define allocate_dfaacc_union(size) \
(union dfaacc_union *) \
allocate_array(size, sizeof(union dfaacc_union))
#define reallocate_int_ptr_array(array,size) \
(int **) reallocate_array( (void *) array, size, sizeof( int * ) )
reallocate_array((void *) array, size, sizeof(int *))
#define reallocate_char_ptr_array(array,size) \
(char **) reallocate_array( (void *) array, size, sizeof( char * ) )
reallocate_array((void *) array, size, sizeof(char *))
#define reallocate_dfaacc_union(array, size) \
(union dfaacc_union *) \
reallocate_array((void *) array, size, sizeof(union dfaacc_union))
#define allocate_character_array(size) \
(char *) allocate_array( size, sizeof( char ) )
allocate_array( size, sizeof(char))
#define reallocate_character_array(array,size) \
(char *) reallocate_array( (void *) array, size, sizeof( char ) )
reallocate_array((void *) array, size, sizeof(char))
#define allocate_Character_array(size) \
(Char *) allocate_array( size, sizeof( Char ) )
allocate_array(size, sizeof(unsigned char))
#define reallocate_Character_array(array,size) \
(Char *) reallocate_array( (void *) array, size, sizeof( Char ) )
/* Used to communicate between scanner and parser. The type should really
* be YYSTYPE, but we can't easily get our hands on it.
*/
extern int yylval;
reallocate_array((void *) array, size, sizeof(unsigned char))
/* External functions that are cross-referenced among the flex source files. */
@ -739,146 +688,143 @@ extern int yylval;
/* from file ccl.c */
extern void ccladd PROTO ((int, int)); /* add a single character to a ccl */
extern int cclinit PROTO ((void)); /* make an empty ccl */
extern void cclnegate PROTO ((int)); /* negate a ccl */
extern void ccladd(int, int); /* add a single character to a ccl */
extern int cclinit(void); /* make an empty ccl */
extern void cclnegate(int); /* negate a ccl */
extern int ccl_set_diff (int a, int b); /* set difference of two ccls. */
extern int ccl_set_union (int a, int b); /* set union of two ccls. */
/* List the members of a set of characters in CCL form. */
extern void list_character_set PROTO ((FILE *, int[]));
extern void list_character_set(FILE *, int[]);
/* from file dfa.c */
/* Check a DFA state for backing up. */
extern void check_for_backing_up PROTO ((int, int[]));
extern void check_for_backing_up(int, int[]);
/* Check to see if NFA state set constitutes "dangerous" trailing context. */
extern void check_trailing_context PROTO ((int *, int, int *, int));
extern void check_trailing_context(int *, int, int *, int);
/* Construct the epsilon closure of a set of ndfa states. */
extern int *epsclosure PROTO ((int *, int *, int[], int *, int *));
extern int *epsclosure(int *, int *, int[], int *, int *);
/* Increase the maximum number of dfas. */
extern void increase_max_dfas PROTO ((void));
extern void increase_max_dfas(void);
extern void ntod PROTO ((void)); /* convert a ndfa to a dfa */
extern void ntod(void); /* convert a ndfa to a dfa */
/* Converts a set of ndfa states into a dfa state. */
extern int snstods PROTO ((int[], int, int[], int, int, int *));
extern int snstods(int[], int, int[], int, int, int *);
/* from file ecs.c */
/* Convert character classes to set of equivalence classes. */
extern void ccl2ecl PROTO ((void));
extern void ccl2ecl(void);
/* Associate equivalence class numbers with class members. */
extern int cre8ecs PROTO ((int[], int[], int));
extern int cre8ecs(int[], int[], int);
/* Update equivalence classes based on character class transitions. */
extern void mkeccl PROTO ((Char[], int, int[], int[], int, int));
extern void mkeccl(unsigned char[], int, int[], int[], int, int);
/* Create equivalence class for single character. */
extern void mkechar PROTO ((int, int[], int[]));
extern void mkechar(int, int[], int[]);
/* from file gen.c */
extern void do_indent PROTO ((void)); /* indent to the current level */
extern void do_indent(void); /* indent to the current level */
/* Generate the code to keep backing-up information. */
extern void gen_backing_up PROTO ((void));
extern void gen_backing_up(void);
/* Generate the code to perform the backing up. */
extern void gen_bu_action PROTO ((void));
extern void gen_bu_action(void);
/* Generate full speed compressed transition table. */
extern void genctbl PROTO ((void));
extern void genctbl(void);
/* Generate the code to find the action number. */
extern void gen_find_action PROTO ((void));
extern void gen_find_action(void);
extern void genftbl PROTO ((void)); /* generate full transition table */
extern void genftbl(void); /* generate full transition table */
/* Generate the code to find the next compressed-table state. */
extern void gen_next_compressed_state PROTO ((char *));
extern void gen_next_compressed_state(char *);
/* Generate the code to find the next match. */
extern void gen_next_match PROTO ((void));
extern void gen_next_match(void);
/* Generate the code to find the next state. */
extern void gen_next_state PROTO ((int));
extern void gen_next_state(int);
/* Generate the code to make a NUL transition. */
extern void gen_NUL_trans PROTO ((void));
extern void gen_NUL_trans(void);
/* Generate the code to find the start state. */
extern void gen_start_state PROTO ((void));
extern void gen_start_state(void);
/* Generate data statements for the transition tables. */
extern void gentabs PROTO ((void));
extern void gentabs(void);
/* Write out a formatted string at the current indentation level. */
extern void indent_put2s PROTO ((const char *, const char *));
extern void indent_put2s(const char *, const char *);
/* Write out a string + newline at the current indentation level. */
extern void indent_puts PROTO ((const char *));
extern void indent_puts(const char *);
extern void make_tables PROTO ((void)); /* generate transition tables */
extern void make_tables(void); /* generate transition tables */
/* from file main.c */
extern void check_options PROTO ((void));
extern void flexend PROTO ((int));
extern void usage PROTO ((void));
extern void check_options(void);
extern void flexend(int);
extern void usage(void);
/* from file misc.c */
/* Add a #define to the action file. */
extern void action_define PROTO ((const char *defname, int value));
extern void action_define(const char *defname, int value);
/* Add the given text to the stored actions. */
extern void add_action PROTO ((const char *new_text));
extern void add_action(const char *new_text);
/* True if a string is all lower case. */
extern int all_lower PROTO ((char *));
extern int all_lower(char *);
/* True if a string is all upper case. */
extern int all_upper PROTO ((char *));
extern int all_upper(char *);
/* Compare two integers for use by qsort. */
extern int intcmp PROTO ((const void *, const void *));
extern int intcmp(const void *, const void *);
/* Check a character to make sure it's in the expected range. */
extern void check_char PROTO ((int c));
extern void check_char(int c);
/* Replace upper-case letter to lower-case. */
extern Char clower PROTO ((int));
extern unsigned char clower(int);
/* Returns a dynamically allocated copy of a string. */
extern char *copy_string PROTO ((const char *));
/* Returns a dynamically allocated copy of a (potentially) unsigned string. */
extern Char *copy_unsigned_string PROTO ((Char *));
/* strdup() that fails fatally on allocation failures. */
extern char *xstrdup(const char *);
/* Compare two characters for use by qsort with '\0' sorting last. */
extern int cclcmp PROTO ((const void *, const void *));
extern int cclcmp(const void *, const void *);
/* Finish up a block of data declarations. */
extern void dataend PROTO ((void));
extern void dataend(void);
/* Flush generated data statements. */
extern void dataflush PROTO ((void));
extern void dataflush(void);
/* Report an error message and terminate. */
extern void flexerror PROTO ((const char *));
extern void flexerror(const char *);
/* Report a fatal error message and terminate. */
extern void flexfatal PROTO ((const char *));
extern void flexfatal(const char *);
/* Report a fatal error with a pinpoint, and terminate */
#if HAVE_DECL___FUNC__
@ -901,203 +847,195 @@ extern void flexfatal PROTO ((const char *));
}while(0)
#endif /* ! HAVE_DECL___func__ */
/* Convert a hexadecimal digit string to an integer value. */
extern int htoi PROTO ((Char[]));
/* Report an error message formatted */
extern void lerr(const char *, ...)
#if defined(__GNUC__) && __GNUC__ >= 3
__attribute__((__format__(__printf__, 1, 2)))
#endif
;
/* Report an error message formatted with one integer argument. */
extern void lerrif PROTO ((const char *, int));
/* Report an error message formatted with one string argument. */
extern void lerrsf PROTO ((const char *, const char *));
/* Like lerrsf, but also exit after displaying message. */
extern void lerrsf_fatal PROTO ((const char *, const char *));
/* Like lerr, but also exit after displaying message. */
extern void lerr_fatal(const char *, ...)
#if defined(__GNUC__) && __GNUC__ >= 3
__attribute__((__format__(__printf__, 1, 2)))
#endif
;
/* Spit out a "#line" statement. */
extern void line_directive_out PROTO ((FILE *, int));
extern void line_directive_out(FILE *, int);
/* Mark the current position in the action array as the end of the section 1
* user defs.
*/
extern void mark_defs1 PROTO ((void));
extern void mark_defs1(void);
/* Mark the current position in the action array as the end of the prolog. */
extern void mark_prolog PROTO ((void));
extern void mark_prolog(void);
/* Generate a data statement for a two-dimensional array. */
extern void mk2data PROTO ((int));
/* Generate a data statment for a two-dimensional array. */
extern void mk2data(int);
extern void mkdata PROTO ((int)); /* generate a data statement */
extern void mkdata(int); /* generate a data statement */
/* Return the integer represented by a string of digits. */
extern int myctoi PROTO ((const char *));
extern int myctoi(const char *);
/* Return character corresponding to escape sequence. */
extern Char myesc PROTO ((Char[]));
/* Convert an octal digit string to an integer value. */
extern int otoi PROTO ((Char[]));
extern unsigned char myesc(unsigned char[]);
/* Output a (possibly-formatted) string to the generated scanner. */
extern void out PROTO ((const char *));
extern void out_dec PROTO ((const char *, int));
extern void out_dec2 PROTO ((const char *, int, int));
extern void out_hex PROTO ((const char *, unsigned int));
extern void out_str PROTO ((const char *, const char *));
extern void out_str3
PROTO ((const char *, const char *, const char *, const char *));
extern void out_str_dec PROTO ((const char *, const char *, int));
extern void outc PROTO ((int));
extern void outn PROTO ((const char *));
extern void out(const char *);
extern void out_dec(const char *, int);
extern void out_dec2(const char *, int, int);
extern void out_hex(const char *, unsigned int);
extern void out_str(const char *, const char *);
extern void out_str3(const char *, const char *, const char *, const char *);
extern void out_str_dec(const char *, const char *, int);
extern void outc(int);
extern void outn(const char *);
extern void out_m4_define(const char* def, const char* val);
/* Return a printable version of the given character, which might be
* 8-bit.
*/
extern char *readable_form PROTO ((int));
extern char *readable_form(int);
/* Write out one section of the skeleton file. */
extern void skelout PROTO ((void));
extern void skelout(void);
/* Output a yy_trans_info structure. */
extern void transition_struct_out PROTO ((int, int));
extern void transition_struct_out(int, int);
/* Only needed when using certain broken versions of bison to build parse.c. */
extern void *yy_flex_xmalloc PROTO ((int));
/* Set a region of memory to 0. */
extern void zero_out PROTO ((char *, size_t));
extern void *yy_flex_xmalloc(int);
/* from file nfa.c */
/* Add an accepting state to a machine. */
extern void add_accept PROTO ((int, int));
extern void add_accept(int, int);
/* Make a given number of copies of a singleton machine. */
extern int copysingl PROTO ((int, int));
extern int copysingl(int, int);
/* Debugging routine to write out an nfa. */
extern void dumpnfa PROTO ((int));
extern void dumpnfa(int);
/* Finish up the processing for a rule. */
extern void finish_rule PROTO ((int, int, int, int, int));
extern void finish_rule(int, int, int, int, int);
/* Connect two machines together. */
extern int link_machines PROTO ((int, int));
extern int link_machines(int, int);
/* Mark each "beginning" state in a machine as being a "normal" (i.e.,
* not trailing context associated) state.
*/
extern void mark_beginning_as_normal PROTO ((int));
extern void mark_beginning_as_normal(int);
/* Make a machine that branches to two machines. */
extern int mkbranch PROTO ((int, int));
extern int mkbranch(int, int);
extern int mkclos PROTO ((int)); /* convert a machine into a closure */
extern int mkopt PROTO ((int)); /* make a machine optional */
extern int mkclos(int); /* convert a machine into a closure */
extern int mkopt(int); /* make a machine optional */
/* Make a machine that matches either one of two machines. */
extern int mkor PROTO ((int, int));
extern int mkor(int, int);
/* Convert a machine into a positive closure. */
extern int mkposcl PROTO ((int));
extern int mkposcl(int);
extern int mkrep PROTO ((int, int, int)); /* make a replicated machine */
extern int mkrep(int, int, int); /* make a replicated machine */
/* Create a state with a transition on a given symbol. */
extern int mkstate PROTO ((int));
extern int mkstate(int);
extern void new_rule PROTO ((void)); /* initialize for a new rule */
extern void new_rule(void); /* initialize for a new rule */
/* from file parse.y */
/* Build the "<<EOF>>" action for the active start conditions. */
extern void build_eof_action PROTO ((void));
extern void build_eof_action(void);
/* Write out a message formatted with one string, pinpointing its location. */
extern void format_pinpoint_message PROTO ((const char *, const char *));
extern void format_pinpoint_message(const char *, const char *);
/* Write out a message, pinpointing its location. */
extern void pinpoint_message PROTO ((const char *));
extern void pinpoint_message(const char *);
/* Write out a warning, pinpointing it at the given line. */
extern void line_warning PROTO ((const char *, int));
extern void line_warning(const char *, int);
/* Write out a message, pinpointing it at the given line. */
extern void line_pinpoint PROTO ((const char *, int));
extern void line_pinpoint(const char *, int);
/* Report a formatted syntax error. */
extern void format_synerr PROTO ((const char *, const char *));
extern void synerr PROTO ((const char *)); /* report a syntax error */
extern void format_warn PROTO ((const char *, const char *));
extern void warn PROTO ((const char *)); /* report a warning */
extern void yyerror PROTO ((const char *)); /* report a parse error */
extern int yyparse PROTO ((void)); /* the YACC parser */
extern void format_synerr(const char *, const char *);
extern void synerr(const char *); /* report a syntax error */
extern void format_warn(const char *, const char *);
extern void lwarn(const char *); /* report a warning */
extern void yyerror(const char *); /* report a parse error */
extern int yyparse(void); /* the YACC parser */
/* from file scan.l */
/* The Flex-generated scanner for flex. */
extern int flexscan PROTO ((void));
extern int flexscan(void);
/* Open the given file (if NULL, stdin) for scanning. */
extern void set_input_file PROTO ((char *));
/* Wrapup a file in the lexical analyzer. */
extern int yywrap PROTO ((void));
extern void set_input_file(char *);
/* from file sym.c */
/* Save the text of a character class. */
extern void cclinstal PROTO ((Char[], int));
extern void cclinstal(char[], int);
/* Lookup the number associated with character class. */
extern int ccllookup PROTO ((Char[]));
extern int ccllookup(char[]);
extern void ndinstal PROTO ((const char *, Char[])); /* install a name definition */
extern Char *ndlookup PROTO ((const char *)); /* lookup a name definition */
extern void ndinstal(const char *, char[]); /* install a name definition */
extern char *ndlookup(const char *); /* lookup a name definition */
/* Increase maximum number of SC's. */
extern void scextend PROTO ((void));
extern void scinstal PROTO ((const char *, int)); /* make a start condition */
extern void scextend(void);
extern void scinstal(const char *, int); /* make a start condition */
/* Lookup the number associated with a start condition. */
extern int sclookup PROTO ((const char *));
extern int sclookup(const char *);
/* from file tblcmp.c */
/* Build table entries for dfa state. */
extern void bldtbl PROTO ((int[], int, int, int, int));
extern void bldtbl(int[], int, int, int, int);
extern void cmptmps PROTO ((void)); /* compress template table entries */
extern void expand_nxt_chk PROTO ((void)); /* increase nxt/chk arrays */
extern void cmptmps(void); /* compress template table entries */
extern void expand_nxt_chk(void); /* increase nxt/chk arrays */
/* Finds a space in the table for a state to be placed. */
extern int find_table_space PROTO ((int *, int));
extern void inittbl PROTO ((void)); /* initialize transition tables */
extern int find_table_space(int *, int);
extern void inittbl(void); /* initialize transition tables */
/* Make the default, "jam" table entries. */
extern void mkdeftbl PROTO ((void));
extern void mkdeftbl(void);
/* Create table entries for a state (or state fragment) which has
* only one out-transition.
*/
extern void mk1tbl PROTO ((int, int, int, int));
extern void mk1tbl(int, int, int, int);
/* Place a state into full speed transition table. */
extern void place_state PROTO ((int *, int, int));
extern void place_state(int *, int, int);
/* Save states with only one out-transition to be processed later. */
extern void stack1 PROTO ((int, int, int, int));
extern void stack1(int, int, int, int);
/* from file yylex.c */
extern int yylex PROTO ((void));
extern int yylex(void);
/* A growable array. See buf.c. */
struct Buf {
@ -1107,30 +1045,28 @@ struct Buf {
int nmax; /* max capacity of elements. */
};
extern void buf_init PROTO ((struct Buf * buf, size_t elem_size));
extern void buf_destroy PROTO ((struct Buf * buf));
extern struct Buf *buf_append
PROTO ((struct Buf * buf, const void *ptr, int n_elem));
extern struct Buf *buf_concat PROTO((struct Buf* dest, const struct Buf* src));
extern struct Buf *buf_strappend PROTO ((struct Buf *, const char *str));
extern struct Buf *buf_strnappend
PROTO ((struct Buf *, const char *str, int nchars));
extern struct Buf *buf_strdefine
PROTO ((struct Buf * buf, const char *str, const char *def));
extern struct Buf *buf_prints PROTO((struct Buf *buf, const char *fmt, const char* s));
extern struct Buf *buf_m4_define PROTO((struct Buf *buf, const char* def, const char* val));
extern struct Buf *buf_m4_undefine PROTO((struct Buf *buf, const char* def));
extern struct Buf *buf_print_strings PROTO((struct Buf * buf, FILE* out));
extern struct Buf *buf_linedir PROTO((struct Buf *buf, const char* filename, int lineno));
extern void buf_init(struct Buf * buf, size_t elem_size);
extern void buf_destroy(struct Buf * buf);
extern struct Buf *buf_append(struct Buf * buf, const void *ptr, int n_elem);
extern struct Buf *buf_concat(struct Buf* dest, const struct Buf* src);
extern struct Buf *buf_strappend(struct Buf *, const char *str);
extern struct Buf *buf_strnappend(struct Buf *, const char *str, int nchars);
extern struct Buf *buf_strdefine(struct Buf * buf, const char *str, const char *def);
extern struct Buf *buf_prints(struct Buf *buf, const char *fmt, const char* s);
extern struct Buf *buf_m4_define(struct Buf *buf, const char* def, const char* val);
extern struct Buf *buf_m4_undefine(struct Buf *buf, const char* def);
extern struct Buf *buf_print_strings(struct Buf * buf, FILE* out);
extern struct Buf *buf_linedir(struct Buf *buf, const char* filename, int lineno);
extern struct Buf userdef_buf; /* a string buffer for #define's generated by user-options on cmd line. */
extern struct Buf defs_buf; /* a char* buffer to save #define'd some symbols generated by flex. */
extern struct Buf yydmap_buf; /* a string buffer to hold yydmap elements */
extern struct Buf m4defs_buf; /* Holds m4 definitions. */
extern struct Buf top_buf; /* contains %top code. String buffer. */
extern bool no_section3_escape; /* True if the undocumented option --unsafe-no-m4-sect3-escape was passed */
/* For blocking out code from the header file. */
#define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[")
#define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl")
#define OUT_END_CODE() outn("]])")
/* For setjmp/longjmp (instead of calling exit(2)). Linkage in main.c */
@ -1183,14 +1119,14 @@ struct filter {
/* output filter chain */
extern struct filter * output_chain;
extern struct filter *filter_create_ext PROTO((struct filter * chain, const char *cmd, ...));
struct filter *filter_create_int PROTO((struct filter *chain,
extern struct filter *filter_create_ext (struct filter * chain, const char *cmd, ...);
struct filter *filter_create_int(struct filter *chain,
int (*filter_func) (struct filter *),
void *extra));
extern bool filter_apply_chain PROTO((struct filter * chain));
void *extra);
extern bool filter_apply_chain(struct filter * chain);
extern int filter_truncate(struct filter * chain, int max_len);
extern int filter_tee_header PROTO((struct filter *chain));
extern int filter_fix_linedirs PROTO((struct filter *chain));
extern int filter_tee_header(struct filter *chain);
extern int filter_fix_linedirs(struct filter *chain);
/*
@ -1210,9 +1146,9 @@ bool regmatch_empty (regmatch_t * m);
typedef unsigned int scanflags_t;
extern scanflags_t* _sf_stk;
extern size_t _sf_top_ix, _sf_max; /**< stack of scanner flags. */
#define _SF_CASE_INS 0x0001
#define _SF_DOT_ALL 0x0002
#define _SF_SKIP_WS 0x0004
#define _SF_CASE_INS ((scanflags_t) 0x0001)
#define _SF_DOT_ALL ((scanflags_t) 0x0002)
#define _SF_SKIP_WS ((scanflags_t) 0x0004)
#define sf_top() (_sf_stk[_sf_top_ix])
#define sf_case_ins() (sf_top() & _SF_CASE_INS)
#define sf_dot_all() (sf_top() & _SF_DOT_ALL)

4
contrib/flex/flexint.h → contrib/flex/src/flexint.h
View File

@ -59,6 +59,10 @@ typedef unsigned int flex_uint32_t;
#define UINT32_MAX (4294967295U)
#endif
#ifndef SIZE_MAX
#define SIZE_MAX (~(size_t)0)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */

364
contrib/flex/gen.c → contrib/flex/src/gen.c
View File

File diff suppressed because it is too large Load Diff

13
contrib/flex/libmain.c → contrib/flex/src/libmain.c
View File

@ -21,13 +21,16 @@
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/* PURPOSE. */
extern int yylex ();
#include <stdlib.h>
int main (argc, argv)
int argc;
char *argv[];
extern int yylex (void);
int main (int argc, char *argv[])
{
(void)argc;
(void)argv;
while (yylex () != 0) ;
return 0;
exit(0);
}

1
contrib/flex/libyywrap.c → contrib/flex/src/libyywrap.c
View File

@ -22,6 +22,7 @@
/* PURPOSE. */
int yywrap (void);
int yywrap (void)
{
return 1;

220
contrib/flex/main.c → contrib/flex/src/main.c
View File

@ -36,15 +36,15 @@
#include "version.h"
#include "options.h"
#include "tables.h"
#include "parse.h"
static char flex_version[] = FLEX_VERSION;
/* declare functions that have forward references */
void flexinit PROTO ((int, char **));
void readin PROTO ((void));
void set_up_initial_allocations PROTO ((void));
static char *basename2 PROTO ((char *path, int should_strip_ext));
void flexinit(int, char **);
void readin(void);
void set_up_initial_allocations(void);
/* these globals are all defined and commented in flexdef.h */
@ -57,6 +57,7 @@ int C_plus_plus, long_align, use_read, yytext_is_array, do_yywrap,
int reentrant, bison_bridge_lval, bison_bridge_lloc;
int yymore_used, reject, real_reject, continued_action, in_rule;
int yymore_really_used, reject_really_used;
int trace_hex = 0;
int datapos, dataline, linenum;
FILE *skelfile = NULL;
int skel_ind = 0;
@ -93,7 +94,7 @@ int *accsiz, *dhash, numas;
int numsnpairs, jambase, jamstate;
int lastccl, *cclmap, *ccllen, *cclng, cclreuse;
int current_maxccls, current_max_ccl_tbl_size;
Char *ccltbl;
unsigned char *ccltbl;
char nmstr[MAXLINE];
int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs;
int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave;
@ -105,7 +106,6 @@ int num_input_files;
jmp_buf flex_main_jmp_buf;
bool *rule_has_nl, *ccl_has_nl;
int nlch = '\n';
bool ansi_func_defs, ansi_func_protos;
bool tablesext, tablesverify, gentables;
char *tablesfilename=0,*tablesname=0;
@ -116,19 +116,9 @@ struct yytbl_writer tableswr;
*/
char *program_name = "flex";
#ifndef SHORT_FILE_NAMES
static char *outfile_template = "lex.%s.%s";
static char *backing_name = "lex.backup";
static char *tablesfile_template = "lex.%s.tables";
#else
static char *outfile_template = "lex%s.%s";
static char *backing_name = "lex.bck";
static char *tablesfile_template = "lex%s.tbl";
#endif
#ifdef MS_DOS
extern unsigned _stklen = 16384;
#endif
static const char outfile_template[] = "lex.%s.%s";
static const char backing_name[] = "lex.backup";
static const char tablesfile_template[] = "lex.%s.tables";
/* From scan.l */
extern FILE* yyout;
@ -137,18 +127,15 @@ static char outfile_path[MAXLINE];
static int outfile_created = 0;
static char *skelname = NULL;
static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */
const char *escaped_qstart = "[[]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[]]";
const char *escaped_qend = "[[]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[]]";
const char *escaped_qstart = "]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[[";
const char *escaped_qend = "]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[[";
/* For debugging. The max number of filters to apply to skeleton. */
static int preproc_level = 1000;
int flex_main PROTO ((int argc, char *argv[]));
int main PROTO ((int argc, char *argv[]));
int flex_main (int argc, char *argv[]);
int flex_main (argc, argv)
int argc;
char *argv[];
int flex_main (int argc, char *argv[])
{
int i, exit_status, child_status;
@ -208,9 +195,7 @@ int flex_main (argc, argv)
}
/* Wrapper around flex_main, so flex_main can be built as a library. */
int main (argc, argv)
int argc;
char *argv[];
int main (int argc, char *argv[])
{
#if ENABLE_NLS
#if HAVE_LOCALE_H
@ -226,7 +211,7 @@ int main (argc, argv)
/* check_options - check user-specified options */
void check_options ()
void check_options (void)
{
int i;
const char * m4 = NULL;
@ -291,7 +276,7 @@ void check_options ()
flexerror (_("Can't use -+ with -CF option"));
if (C_plus_plus && yytext_is_array) {
warn (_("%array incompatible with -+ option"));
lwarn (_("%array incompatible with -+ option"));
yytext_is_array = false;
}
@ -325,12 +310,6 @@ void check_options ()
}
}
if (!ansi_func_defs)
buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_DEFS", NULL);
if (!ansi_func_protos)
buf_m4_define( &m4defs_buf, "M4_YY_NO_ANSI_FUNC_PROTOS", NULL);
if (extra_type)
buf_m4_define( &m4defs_buf, "M4_EXTRA_TYPE_DEFS", extra_type);
@ -354,7 +333,7 @@ void check_options ()
prev_stdout = freopen (outfilename, "w+", stdout);
if (prev_stdout == NULL)
lerrsf (_("could not create %s"), outfilename);
lerr (_("could not create %s"), outfilename);
outfile_created = 1;
}
@ -362,9 +341,46 @@ void check_options ()
/* Setup the filter chain. */
output_chain = filter_create_int(NULL, filter_tee_header, headerfilename);
if ( !(m4 = getenv("M4")))
if ( !(m4 = getenv("M4"))) {
char *slash;
m4 = M4;
filter_create_ext(output_chain, m4, "-gP", NULL);
if ((slash = strrchr(M4, '/')) != NULL) {
m4 = slash+1;
/* break up $PATH */
const char *path = getenv("PATH");
if (!path) {
m4 = M4;
} else {
int m4_length = strlen(m4);
do {
size_t length = strlen(path);
struct stat sbuf;
const char *endOfDir = strchr(path, ':');
if (!endOfDir)
endOfDir = path+length;
{
char *m4_path = calloc(endOfDir-path + 1 + m4_length + 1, 1);
memcpy(m4_path, path, endOfDir-path);
m4_path[endOfDir-path] = '/';
memcpy(m4_path + (endOfDir-path) + 1, m4, m4_length + 1);
if (stat(m4_path, &sbuf) == 0 &&
(S_ISREG(sbuf.st_mode)) && sbuf.st_mode & S_IXUSR) {
m4 = m4_path;
break;
}
free(m4_path);
}
path = endOfDir+1;
} while (path[0]);
if (!path[0])
m4 = M4;
}
}
}
filter_create_ext(output_chain, m4, "-gP", 0);
filter_create_int(output_chain, filter_fix_linedirs, NULL);
/* For debugging, only run the requested number of filters. */
@ -389,26 +405,25 @@ void check_options ()
FILE *tablesout;
struct yytbl_hdr hdr;
char *pname = 0;
int nbytes = 0;
size_t nbytes = 0;
buf_m4_define (&m4defs_buf, "M4_YY_TABLES_EXTERNAL", NULL);
if (!tablesfilename) {
nbytes = strlen (prefix) + strlen (tablesfile_template) + 2;
tablesfilename = pname = (char *) calloc (nbytes, 1);
tablesfilename = pname = calloc(nbytes, 1);
snprintf (pname, nbytes, tablesfile_template, prefix);
}
if ((tablesout = fopen (tablesfilename, "w")) == NULL)
lerrsf (_("could not create %s"), tablesfilename);
if (pname)
lerr (_("could not create %s"), tablesfilename);
free(pname);
tablesfilename = 0;
yytbl_writer_init (&tableswr, tablesout);
nbytes = strlen (prefix) + strlen ("tables") + 2;
tablesname = (char *) calloc (nbytes, 1);
tablesname = calloc(nbytes, 1);
snprintf (tablesname, nbytes, "%stables", prefix);
yytbl_hdr_init (&hdr, flex_version, tablesname);
@ -417,7 +432,7 @@ void check_options ()
}
if (skelname && (skelfile = fopen (skelname, "r")) == NULL)
lerrsf (_("can't open skeleton file %s"), skelname);
lerr (_("can't open skeleton file %s"), skelname);
if (reentrant) {
buf_m4_define (&m4defs_buf, "M4_YY_REENTRANT", NULL);
@ -431,6 +446,8 @@ void check_options ()
if ( bison_bridge_lloc)
buf_m4_define (&m4defs_buf, "<M4_YY_BISON_LLOC>", NULL);
if (strchr(prefix, '[') || strchr(prefix, ']'))
flexerror(_("Prefix cannot include '[' or ']'"));
buf_m4_define(&m4defs_buf, "M4_YY_PREFIX", prefix);
if (did_outfilename)
@ -451,7 +468,8 @@ void check_options ()
char *str, *fmt = "#define %s %d\n";
size_t strsz;
str = (char*)flex_alloc(strsz = strlen(fmt) + strlen(scname[i]) + NUMCHARLINES + 2);
strsz = strlen(fmt) + strlen(scname[i]) + NUMCHARLINES + 2;
str = malloc(strsz);
if (!str)
flexfatal(_("allocation of macro definition failed"));
snprintf(str, strsz, fmt, scname[i], i - 1);
@ -473,6 +491,7 @@ void check_options ()
m4defs_buf.nelts = 0; /* memory leak here. */
/* Place a bogus line directive, it will be fixed in the filter. */
if (gen_line_dirs)
outn("#line 0 \"M4_YY_OUTFILE_NAME\"\n");
/* Dump the user defined preproc directives. */
@ -489,9 +508,7 @@ void check_options ()
* This routine does not return.
*/
void flexend (exit_status)
int exit_status;
void flexend (int exit_status)
{
static int called_before = -1; /* prevent infinite recursion. */
int tblsiz;
@ -501,11 +518,11 @@ void flexend (exit_status)
if (skelfile != NULL) {
if (ferror (skelfile))
lerrsf (_("input error reading skeleton file %s"),
lerr (_("input error reading skeleton file %s"),
skelname);
else if (fclose (skelfile))
lerrsf (_("error closing skeleton file %s"),
lerr (_("error closing skeleton file %s"),
skelname);
}
@ -538,7 +555,6 @@ void flexend (exit_status)
"EOB_ACT_END_OF_FILE",
"EOB_ACT_LAST_MATCH",
"FLEX_SCANNER",
"FLEX_STD",
"REJECT",
"YYFARGS0",
"YYFARGS1",
@ -625,7 +641,7 @@ void flexend (exit_status)
"yypop_buffer_state",
"yyensure_buffer_stack",
"yyalloc",
"yyconst",
"const",
"yyextra",
"yyfree",
"yyget_debug",
@ -690,7 +706,7 @@ void flexend (exit_status)
fprintf (header_out, "#endif /* %sHEADER_H */\n", prefix);
if (ferror (header_out))
lerrsf (_("error creating header file %s"),
lerr (_("error creating header file %s"),
headerfilename);
fflush (header_out);
fclose (header_out);
@ -698,15 +714,15 @@ void flexend (exit_status)
if (exit_status != 0 && outfile_created) {
if (ferror (stdout))
lerrsf (_("error writing output file %s"),
lerr (_("error writing output file %s"),
outfilename);
else if ((_stdout_closed = 1) && fclose (stdout))
lerrsf (_("error closing output file %s"),
lerr (_("error closing output file %s"),
outfilename);
else if (unlink (outfilename))
lerrsf (_("error deleting output file %s"),
lerr (_("error deleting output file %s"),
outfilename);
}
@ -724,11 +740,11 @@ void flexend (exit_status)
_("Compressed tables always back up.\n"));
if (ferror (backing_up_file))
lerrsf (_("error writing backup file %s"),
lerr (_("error writing backup file %s"),
backing_name);
else if (fclose (backing_up_file))
lerrsf (_("error closing backup file %s"),
lerr (_("error closing backup file %s"),
backing_name);
}
@ -925,9 +941,7 @@ void flexend (exit_status)
/* flexinit - initialize flex */
void flexinit (argc, argv)
int argc;
char **argv;
void flexinit (int argc, char **argv)
{
int i, sawcmpflag, rv, optind;
char *arg;
@ -952,7 +966,6 @@ void flexinit (argc, argv)
tablesext = tablesverify = false;
gentables = true;
tablesfilename = tablesname = NULL;
ansi_func_defs = ansi_func_protos = true;
sawcmpflag = false;
@ -981,9 +994,9 @@ void flexinit (argc, argv)
flex_init_regex();
/* Enable C++ if program name ends with '+'. */
program_name = basename2 (argv[0], 0);
program_name = basename (argv[0]);
if (program_name[0] != '\0' &&
if (program_name != NULL &&
program_name[strlen (program_name) - 1] == '+')
C_plus_plus = true;
@ -1058,9 +1071,9 @@ void flexinit (argc, argv)
break;
default:
lerrif (_
lerr (_
("unknown -C option '%c'"),
(int) arg[i]);
arg[i]);
break;
}
break;
@ -1104,7 +1117,7 @@ void flexinit (argc, argv)
break;
case OPT_PREPROC_LEVEL:
preproc_level = strtol(arg,NULL,0);
preproc_level = (int) strtol(arg,NULL,0);
break;
case OPT_MAIN:
@ -1267,7 +1280,7 @@ void flexinit (argc, argv)
}
else {
buf_strnappend (&userdef_buf, arg,
def - arg);
(int) (def - arg));
buf_strappend (&userdef_buf, " ");
buf_strappend (&userdef_buf,
def + 1);
@ -1329,14 +1342,6 @@ void flexinit (argc, argv)
reject_really_used = false;
break;
case OPT_NO_ANSI_FUNC_DEFS:
ansi_func_defs = false;
break;
case OPT_NO_ANSI_FUNC_PROTOS:
ansi_func_protos = false;
break;
case OPT_NO_YY_PUSH_STATE:
//buf_strdefine (&userdef_buf, "YY_NO_PUSH_STATE", "1");
buf_m4_define( &m4defs_buf, "M4_YY_NO_PUSH_STATE",0);
@ -1421,7 +1426,12 @@ void flexinit (argc, argv)
//buf_strdefine (&userdef_buf, "YY_NO_SET_LLOC", "1");
buf_m4_define( &m4defs_buf, "M4_YY_NO_SET_LLOC",0);
break;
case OPT_HEX:
trace_hex = 1;
break;
case OPT_NO_SECT3_ESCAPE:
no_section3_escape = true;
break;
} /* switch */
} /* while scanopt() */
@ -1454,13 +1464,13 @@ void flexinit (argc, argv)
/* readin - read in the rules section of the input file(s) */
void readin ()
void readin (void)
{
static char yy_stdinit[] = "FILE *yyin = stdin, *yyout = stdout;";
static char yy_nostdinit[] =
"FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;";
"FILE *yyin = NULL, *yyout = NULL;";
line_directive_out ((FILE *) 0, 1);
line_directive_out(NULL, 1);
if (yyparse ()) {
pinpoint_message (_("fatal parse error"));
@ -1494,7 +1504,7 @@ void readin ()
if (backing_up_report) {
backing_up_file = fopen (backing_name, "w");
if (backing_up_file == NULL)
lerrsf (_
lerr (_
("could not create backing-up info file %s"),
backing_name);
}
@ -1577,9 +1587,9 @@ void readin ()
if (!do_yywrap) {
if (!C_plus_plus) {
if (reentrant)
outn ("\n#define yywrap(yyscanner) 1");
out_str ("\n#define %swrap(yyscanner) (/*CONSTCOND*/1)\n", prefix);
else
outn ("\n#define yywrap() 1");
out_str ("\n#define %swrap() (/*CONSTCOND*/1)\n", prefix);
}
outn ("#define YY_SKIP_YYWRAP");
}
@ -1588,10 +1598,7 @@ void readin ()
outn ("\n#define FLEX_DEBUG");
OUT_BEGIN_CODE ();
if (csize == 256)
outn ("typedef unsigned char YY_CHAR;");
else
outn ("typedef char YY_CHAR;");
outn ("typedef flex_uint8_t YY_CHAR;");
OUT_END_CODE ();
if (C_plus_plus) {
@ -1635,7 +1642,7 @@ void readin ()
OUT_BEGIN_CODE ();
if (fullspd)
outn ("typedef yyconst struct yy_trans_info *yy_state_type;");
outn ("typedef const struct yy_trans_info *yy_state_type;");
else if (!C_plus_plus)
outn ("typedef int yy_state_type;");
OUT_END_CODE ();
@ -1684,6 +1691,10 @@ void readin ()
}
else {
outn ("extern char *yytext;");
outn("#ifdef yytext_ptr");
outn("#undef yytext_ptr");
outn("#endif");
outn ("#define yytext_ptr yytext");
}
}
@ -1709,7 +1720,7 @@ void readin ()
/* set_up_initial_allocations - allocate memory for internal tables */
void set_up_initial_allocations ()
void set_up_initial_allocations (void)
{
maximum_mns = (long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS);
current_mns = INITIAL_MNS;
@ -1763,31 +1774,11 @@ void set_up_initial_allocations ()
dss = allocate_int_ptr_array (current_max_dfas);
dfaacc = allocate_dfaacc_union (current_max_dfas);
nultrans = (int *) 0;
nultrans = NULL;
}
/* extracts basename from path, optionally stripping the extension "\.*"
* (same concept as /bin/sh `basename`, but different handling of extension). */
static char *basename2 (path, strip_ext)
char *path;
int strip_ext; /* boolean */
{
char *b, *e = 0;
b = path;
for (b = path; *path; path++)
if (*path == '/')
b = path + 1;
else if (*path == '.')
e = path;
if (strip_ext && e && e > b)
*e = '\0';
return b;
}
void usage ()
void usage (void)
{
FILE *f = stdout;
@ -1819,6 +1810,7 @@ void usage ()
" -T, --trace %s should run in trace mode\n"
" -w, --nowarn do not generate warnings\n"
" -v, --verbose write summary of scanner statistics to stdout\n"
" --hex use hexadecimal numbers instead of octal in debug outputs\n"
"\n" "Files:\n"
" -o, --outfile=FILE specify output filename\n"
" -S, --skel=FILE specify skeleton file\n"
@ -1844,8 +1836,6 @@ void usage ()
" --bison-bridge scanner for bison pure parser.\n"
" --bison-locations include yylloc support.\n"
" --stdinit initialize yyin/yyout to stdin/stdout\n"
" --noansi-definitions old-style function definitions\n"
" --noansi-prototypes empty parameter list in prototypes\n"
" --nounistd do not include <unistd.h>\n"
" --noFUNCTION do not generate a particular FUNCTION\n"
"\n" "Miscellaneous:\n"

357
contrib/flex/misc.c → contrib/flex/src/misc.c
View File

@ -30,7 +30,6 @@
/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/* PURPOSE. */
#include "flexdef.h"
#include "tables.h"
@ -60,14 +59,15 @@ static void sko_push(bool dc)
{
if(!sko_stack){
sko_sz = 1;
sko_stack = (struct sko_state*)flex_alloc(sizeof(struct sko_state)*sko_sz);
sko_stack = malloc(sizeof(struct sko_state) * (size_t) sko_sz);
if (!sko_stack)
flexfatal(_("allocation of sko_stack failed"));
sko_len = 0;
}
if(sko_len >= sko_sz){
sko_sz *= 2;
sko_stack = (struct sko_state*)flex_realloc(sko_stack,sizeof(struct sko_state)*sko_sz);
sko_stack = realloc(sko_stack,
sizeof(struct sko_state) * (size_t) sko_sz);
}
/* initialize to zero and push */
@ -90,9 +90,7 @@ static void sko_pop(bool* dc)
}
/* Append "#define defname value\n" to the running buffer. */
void action_define (defname, value)
const char *defname;
int value;
void action_define (const char *defname, int value)
{
char buf[MAXLINE];
char *cpy;
@ -108,39 +106,14 @@ void action_define (defname, value)
add_action (buf);
/* track #defines so we can undef them when we're done. */
cpy = copy_string (defname);
cpy = xstrdup(defname);
buf_append (&defs_buf, &cpy, 1);
}
#ifdef notdef
/** Append "m4_define([[defname]],[[value]])m4_dnl\n" to the running buffer.
* @param defname The macro name.
* @param value The macro value, can be NULL, which is the same as the empty string.
*/
void action_m4_define (const char *defname, const char * value)
{
char buf[MAXLINE];
flexfatal ("DO NOT USE THIS FUNCTION!");
if ((int) strlen (defname) > MAXLINE / 2) {
format_pinpoint_message (_
("name \"%s\" ridiculously long"),
defname);
return;
}
snprintf (buf, sizeof(buf), "m4_define([[%s]],[[%s]])m4_dnl\n", defname, value?value:"");
add_action (buf);
}
#endif
/* Append "new_text" to the running buffer. */
void add_action (new_text)
const char *new_text;
void add_action (const char *new_text)
{
int len = strlen (new_text);
int len = (int) strlen (new_text);
while (len + action_index >= action_size - 10 /* slop */ ) {
int new_size = action_size * 2;
@ -166,14 +139,17 @@ void add_action (new_text)
/* allocate_array - allocate memory for an integer array of the given size */
void *allocate_array (size, element_size)
int size;
size_t element_size;
void *allocate_array (int size, size_t element_size)
{
void *mem;
size_t num_bytes = element_size * size;
mem = flex_alloc (num_bytes);
#if HAVE_REALLOCARRAY
/* reallocarray has built-in overflow detection */
mem = reallocarray(NULL, (size_t) size, element_size);
#else
size_t num_bytes = (size_t) size * element_size;
mem = (size && SIZE_MAX / (size_t) size < element_size) ? NULL :
malloc(num_bytes);
#endif
if (!mem)
flexfatal (_
("memory allocation failed in allocate_array()"));
@ -184,11 +160,10 @@ void *allocate_array (size, element_size)
/* all_lower - true if a string is all lower-case */
int all_lower (str)
char *str;
int all_lower (char *str)
{
while (*str) {
if (!isascii ((Char) * str) || !islower ((Char) * str))
if (!isascii ((unsigned char) * str) || !islower ((unsigned char) * str))
return 0;
++str;
}
@ -199,11 +174,10 @@ int all_lower (str)
/* all_upper - true if a string is all upper-case */
int all_upper (str)
char *str;
int all_upper (char *str)
{
while (*str) {
if (!isascii ((Char) * str) || !isupper ((Char) * str))
if (!isascii ((unsigned char) * str) || !isupper ((unsigned char) * str))
return 0;
++str;
}
@ -225,15 +199,14 @@ int intcmp (const void *a, const void *b)
* and exits.
*/
void check_char (c)
int c;
void check_char (int c)
{
if (c >= CSIZE)
lerrsf (_("bad character '%s' detected in check_char()"),
lerr (_("bad character '%s' detected in check_char()"),
readable_form (c));
if (c >= csize)
lerrsf (_
lerr (_
("scanner requires -8 flag to use the character %s"),
readable_form (c));
}
@ -242,57 +215,20 @@ void check_char (c)
/* clower - replace upper-case letter to lower-case */
Char clower (c)
int c;
unsigned char clower (int c)
{
return (Char) ((isascii (c) && isupper (c)) ? tolower (c) : c);
return (unsigned char) ((isascii (c) && isupper (c)) ? tolower (c) : c);
}
/* copy_string - returns a dynamically allocated copy of a string */
char *copy_string (str)
const char *str;
char *xstrdup(const char *s)
{
const char *c1;
char *c2;
char *copy;
unsigned int size;
char *s2;
/* find length */
for (c1 = str; *c1; ++c1) ;
if ((s2 = strdup(s)) == NULL)
flexfatal (_("memory allocation failure in xstrdup()"));
size = (c1 - str + 1) * sizeof (char);
copy = (char *) flex_alloc (size);
if (copy == NULL)
flexfatal (_("dynamic memory failure in copy_string()"));
for (c2 = copy; (*c2++ = *str++) != 0;) ;
return copy;
}
/* copy_unsigned_string -
* returns a dynamically allocated copy of a (potentially) unsigned string
*/
Char *copy_unsigned_string (str)
Char *str;
{
Char *c;
Char *copy;
/* find length */
for (c = str; *c; ++c) ;
copy = allocate_Character_array (c - str + 1);
for (c = copy; (*c++ = *str++) != 0;) ;
return copy;
return s2;
}
@ -300,19 +236,19 @@ Char *copy_unsigned_string (str)
int cclcmp (const void *a, const void *b)
{
if (!*(const Char *) a)
if (!*(const unsigned char *) a)
return 1;
else
if (!*(const Char *) b)
if (!*(const unsigned char *) b)
return - 1;
else
return *(const Char *) a - *(const Char *) b;
return *(const unsigned char *) a - *(const unsigned char *) b;
}
/* dataend - finish up a block of data declarations */
void dataend ()
void dataend (void)
{
/* short circuit any output */
if (gentables) {
@ -330,7 +266,7 @@ void dataend ()
/* dataflush - flush generated data statements */
void dataflush ()
void dataflush (void)
{
/* short circuit any output */
if (!gentables)
@ -353,8 +289,7 @@ void dataflush ()
/* flexerror - report an error message and terminate */
void flexerror (msg)
const char *msg;
void flexerror (const char *msg)
{
fprintf (stderr, "%s: %s\n", program_name, msg);
flexend (1);
@ -363,8 +298,7 @@ void flexerror (msg)
/* flexfatal - report a fatal error message and terminate */
void flexfatal (msg)
const char *msg;
void flexfatal (const char *msg)
{
fprintf (stderr, _("%s: fatal internal error, %s\n"),
program_name, msg);
@ -372,67 +306,41 @@ void flexfatal (msg)
}
/* htoi - convert a hexadecimal digit string to an integer value */
/* lerr - report an error message */
int htoi (str)
Char str[];
{
unsigned int result;
(void) sscanf ((char *) str, "%x", &result);
return result;
}
/* lerrif - report an error message formatted with one integer argument */
void lerrif (msg, arg)
const char *msg;
int arg;
void lerr (const char *msg, ...)
{
char errmsg[MAXLINE];
va_list args;
snprintf (errmsg, sizeof(errmsg), msg, arg);
va_start(args, msg);
vsnprintf (errmsg, sizeof(errmsg), msg, args);
va_end(args);
flexerror (errmsg);
}
/* lerrsf - report an error message formatted with one string argument */
/* lerr_fatal - as lerr, but call flexfatal */
void lerrsf (msg, arg)
const char *msg, arg[];
void lerr_fatal (const char *msg, ...)
{
char errmsg[MAXLINE];
va_list args;
va_start(args, msg);
snprintf (errmsg, sizeof(errmsg)-1, msg, arg);
errmsg[sizeof(errmsg)-1] = 0; /* ensure NULL termination */
flexerror (errmsg);
}
/* lerrsf_fatal - as lerrsf, but call flexfatal */
void lerrsf_fatal (msg, arg)
const char *msg, arg[];
{
char errmsg[MAXLINE];
snprintf (errmsg, sizeof(errmsg)-1, msg, arg);
errmsg[sizeof(errmsg)-1] = 0; /* ensure NULL termination */
vsnprintf (errmsg, sizeof(errmsg), msg, args);
va_end(args);
flexfatal (errmsg);
}
/* line_directive_out - spit out a "#line" statement */
void line_directive_out (output_file, do_infile)
FILE *output_file;
int do_infile;
void line_directive_out (FILE *output_file, int do_infile)
{
char directive[MAXLINE], filename[MAXLINE];
char *s1, *s2, *s3;
static const char *line_fmt = "#line %d \"%s\"\n";
static const char line_fmt[] = "#line %d \"%s\"\n";
if (!gen_line_dirs)
return;
@ -446,8 +354,8 @@ void line_directive_out (output_file, do_infile)
s3 = &filename[sizeof (filename) - 2];
while (s2 < s3 && *s1) {
if (*s1 == '\\')
/* Escape the '\' */
if (*s1 == '\\' || *s1 == '"')
/* Escape the '\' or '"' */
*s2++ = '\\';
*s2++ = *s1++;
@ -476,7 +384,7 @@ void line_directive_out (output_file, do_infile)
* representing where the user's section 1 definitions end
* and the prolog begins
*/
void mark_defs1 ()
void mark_defs1 (void)
{
defs1_offset = 0;
action_array[action_index++] = '\0';
@ -488,7 +396,7 @@ void mark_defs1 ()
/* mark_prolog - mark the current position in the action array as
* representing the end of the action prolog
*/
void mark_prolog ()
void mark_prolog (void)
{
action_array[action_index++] = '\0';
action_offset = action_index;
@ -500,8 +408,7 @@ void mark_prolog ()
*
* Generates a data statement initializing the current 2-D array to "value".
*/
void mk2data (value)
int value;
void mk2data (int value)
{
/* short circuit any output */
if (!gentables)
@ -530,8 +437,7 @@ void mk2data (value)
* Generates a data statement initializing the current array element to
* "value".
*/
void mkdata (value)
int value;
void mkdata (int value)
{
/* short circuit any output */
if (!gentables)
@ -556,8 +462,7 @@ void mkdata (value)
/* myctoi - return the integer represented by a string of digits */
int myctoi (array)
const char *array;
int myctoi (const char *array)
{
int val = 0;
@ -569,10 +474,9 @@ int myctoi (array)
/* myesc - return character corresponding to escape sequence */
Char myesc (array)
Char array[];
unsigned char myesc (unsigned char array[])
{
Char c, esc_char;
unsigned char c, esc_char;
switch (array[1]) {
case 'b':
@ -585,19 +489,10 @@ Char myesc (array)
return '\r';
case 't':
return '\t';
#if defined (__STDC__)
case 'a':
return '\a';
case 'v':
return '\v';
#else
case 'a':
return '\007';
case 'v':
return '\013';
#endif
case '0':
case '1':
case '2':
@ -609,18 +504,15 @@ Char myesc (array)
{ /* \<octal> */
int sptr = 1;
while (isascii (array[sptr]) &&
isdigit (array[sptr]))
/* Don't increment inside loop control
* because if isdigit() is a macro it might
* expand into multiple increments ...
*/
while (sptr <= 3 &&
array[sptr] >= '0' && array[sptr] <= '7') {
++sptr;
}
c = array[sptr];
array[sptr] = '\0';
esc_char = otoi (array + 1);
esc_char = (unsigned char) strtoul (array + 1, NULL, 8);
array[sptr] = c;
@ -631,18 +523,18 @@ Char myesc (array)
{ /* \x<hex> */
int sptr = 2;
while (isascii (array[sptr]) &&
isxdigit (array[sptr]))
while (sptr <= 3 && isxdigit (array[sptr])) {
/* Don't increment inside loop control
* because if isdigit() is a macro it might
* because if isxdigit() is a macro it might
* expand into multiple increments ...
*/
++sptr;
}
c = array[sptr];
array[sptr] = '\0';
esc_char = htoi (array + 2);
esc_char = (unsigned char) strtoul (array + 2, NULL, 16);
array[sptr] = c;
@ -655,76 +547,51 @@ Char myesc (array)
}
/* otoi - convert an octal digit string to an integer value */
int otoi (str)
Char str[];
{
unsigned int result;
(void) sscanf ((char *) str, "%o", &result);
return result;
}
/* out - various flavors of outputing a (possibly formatted) string for the
* generated scanner, keeping track of the line count.
*/
void out (str)
const char *str;
void out (const char *str)
{
fputs (str, stdout);
}
void out_dec (fmt, n)
const char *fmt;
int n;
void out_dec (const char *fmt, int n)
{
fprintf (stdout, fmt, n);
}
void out_dec2 (fmt, n1, n2)
const char *fmt;
int n1, n2;
void out_dec2 (const char *fmt, int n1, int n2)
{
fprintf (stdout, fmt, n1, n2);
}
void out_hex (fmt, x)
const char *fmt;
unsigned int x;
void out_hex (const char *fmt, unsigned int x)
{
fprintf (stdout, fmt, x);
}
void out_str (fmt, str)
const char *fmt, str[];
void out_str (const char *fmt, const char str[])
{
fprintf (stdout,fmt, str);
}
void out_str3 (fmt, s1, s2, s3)
const char *fmt, s1[], s2[], s3[];
void out_str3 (const char *fmt, const char s1[], const char s2[], const char s3[])
{
fprintf (stdout,fmt, s1, s2, s3);
}
void out_str_dec (fmt, str, n)
const char *fmt, str[];
int n;
void out_str_dec (const char *fmt, const char str[], int n)
{
fprintf (stdout,fmt, str, n);
}
void outc (c)
int c;
void outc (int c)
{
fputc (c, stdout);
}
void outn (str)
const char *str;
void outn (const char *str)
{
fputs (str,stdout);
fputc('\n',stdout);
@ -733,7 +600,6 @@ void outn (str)
/** Print "m4_define( [[def]], [[val]])m4_dnl\n".
* @param def The m4 symbol to define.
* @param val The definition; may be NULL.
* @return buf
*/
void out_m4_define (const char* def, const char* val)
{
@ -742,15 +608,14 @@ void out_m4_define (const char* def, const char* val)
}
/* readable_form - return the human-readable form of a character
/* readable_form - return the the human-readable form of a character
*
* The returned string is in static storage.
*/
char *readable_form (c)
int c;
char *readable_form (int c)
{
static char rform[10];
static char rform[20];
if ((c >= 0 && c < 32) || c >= 127) {
switch (c) {
@ -764,15 +629,14 @@ char *readable_form (c)
return "\\r";
case '\t':
return "\\t";
#if defined (__STDC__)
case '\a':
return "\\a";
case '\v':
return "\\v";
#endif
default:
if(trace_hex)
snprintf (rform, sizeof(rform), "\\x%.2x", (unsigned int) c);
else
snprintf (rform, sizeof(rform), "\\%.3o", (unsigned int) c);
return rform;
}
@ -782,7 +646,7 @@ char *readable_form (c)
return "' '";
else {
rform[0] = c;
rform[0] = (char) c;
rform[1] = '\0';
return rform;
@ -792,15 +656,17 @@ char *readable_form (c)
/* reallocate_array - increase the size of a dynamic array */
void *reallocate_array (array, size, element_size)
void *array;
int size;
size_t element_size;
void *reallocate_array (void *array, int size, size_t element_size)
{
void *new_array;
size_t num_bytes = element_size * size;
new_array = flex_realloc (array, num_bytes);
#if HAVE_REALLOCARRAY
/* reallocarray has built-in overflow detection */
new_array = reallocarray(array, (size_t) size, element_size);
#else
size_t num_bytes = (size_t) size * element_size;
new_array = (size && SIZE_MAX / (size_t) size < element_size) ? NULL :
realloc(array, num_bytes);
#endif
if (!new_array)
flexfatal (_("attempt to increase array size failed"));
@ -814,7 +680,7 @@ void *reallocate_array (array, size, element_size)
* Copies skelfile or skel array to stdout until a line beginning with
* "%%" or EOF is found.
*/
void skelout ()
void skelout (void)
{
char buf_storage[MAXLINE];
char *buf = buf_storage;
@ -925,9 +791,6 @@ void skelout ()
/* %e end linkage-only code. */
OUT_END_CODE ();
}
else if (buf[1] == '#') {
/* %# a comment in the skel. ignore. */
}
else {
flexfatal (_("bad line in skeleton file"));
}
@ -945,8 +808,7 @@ void skelout ()
* element_n. Formats the output with spaces and carriage returns.
*/
void transition_struct_out (element_v, element_n)
int element_v, element_n;
void transition_struct_out (int element_v, int element_n)
{
/* short circuit any output */
@ -970,12 +832,14 @@ void transition_struct_out (element_v, element_n)
/* The following is only needed when building flex's parser using certain
* broken versions of bison.
*
* XXX: this is should go soon
*/
void *yy_flex_xmalloc (size)
int size;
void *yy_flex_xmalloc (int size)
{
void *result = flex_alloc ((size_t) size);
void *result;
result = malloc((size_t) size);
if (!result)
flexfatal (_
("memory allocation failed in yy_flex_xmalloc()"));
@ -984,29 +848,10 @@ void *yy_flex_xmalloc (size)
}
/* zero_out - set a region of memory to 0
*
* Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
*/
void zero_out (region_ptr, size_in_bytes)
char *region_ptr;
size_t size_in_bytes;
{
char *rp, *rp_end;
rp = region_ptr;
rp_end = region_ptr + size_in_bytes;
while (rp < rp_end)
*rp++ = 0;
}
/* Remove all '\n' and '\r' characters, if any, from the end of str.
* str can be any null-terminated string, or NULL.
* returns str. */
char *chomp (str)
char *str;
char *chomp (char *str)
{
char *p = str;

37
contrib/flex/mkskel.sh → contrib/flex/src/mkskel.sh
View File

@ -21,17 +21,34 @@
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE.
cat <<!
/* File created from flex.skl via mkskel.sh */
if test ! $# = 3; then
echo 'Usage: mkskel.sh srcdir m4 version' >&2
exit 1
fi
echo '/* File created from flex.skl via mkskel.sh */
#include "flexdef.h"
const char *skel[] = {
!
const char *skel[] = {'
srcdir=$1
m4=$2
VERSION=$3
case $VERSION in
*[!0-9.]*) echo 'Invalid version number' >&2; exit 1;;
esac
IFS=.
set $VERSION
sed 's/4_/a4_/g
s/m4preproc_/m4_/g
' "$srcdir/flex.skl" |
"$m4" -P -I "$srcdir" "-DFLEX_MAJOR_VERSION=$1" \
"-DFLEX_MINOR_VERSION=$2" \
"-DFLEX_SUBMINOR_VERSION=$3" |
sed '/^%#/d
s/m4_/m4preproc_/g
s/a4_/4_/g
s/[\\"]/\\&/g
s/.*/ "&",/'
sed 's/\\/&&/g' | sed 's/"/\\"/g' | sed 's/.*/ "&",/'
cat <<!
0
};
!
echo ' 0
};'

72
contrib/flex/nfa.c → contrib/flex/src/nfa.c
View File

@ -36,8 +36,8 @@
/* declare functions that have forward references */
int dupmachine PROTO ((int));
void mkxtion PROTO ((int, int));
int dupmachine(int);
void mkxtion(int, int);
/* add_accept - add an accepting state to a machine
@ -45,8 +45,7 @@ void mkxtion PROTO ((int, int));
* accepting_number becomes mach's accepting number.
*/
void add_accept (mach, accepting_number)
int mach, accepting_number;
void add_accept (int mach, int accepting_number)
{
/* Hang the accepting number off an epsilon state. if it is associated
* with a state that has a non-epsilon out-transition, then the state
@ -77,8 +76,7 @@ void add_accept (mach, accepting_number)
* num - the number of copies of singl to be present in newsng
*/
int copysingl (singl, num)
int singl, num;
int copysingl (int singl, int num)
{
int copy, i;
@ -93,9 +91,7 @@ int copysingl (singl, num)
/* dumpnfa - debugging routine to write out an nfa */
void dumpnfa (state1)
int state1;
void dumpnfa (int state1)
{
int sym, tsp1, tsp2, anum, ns;
@ -148,8 +144,7 @@ void dumpnfa (state1)
* states accessible by the arrays firstst and lastst
*/
int dupmachine (mach)
int mach;
int dupmachine (int mach)
{
int i, init, state_offset;
int state = 0;
@ -196,9 +191,8 @@ int dupmachine (mach)
* context has variable length.
*/
void finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
pcont_act)
int mach, variable_trail_rule, headcnt, trailcnt, pcont_act;
void finish_rule (int mach, int variable_trail_rule, int headcnt, int trailcnt,
int pcont_act)
{
char action_text[MAXLINE];
@ -257,12 +251,23 @@ void finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
("*yy_cp = YY_G(yy_hold_char); /* undo effects of setting up yytext */\n");
if (headcnt > 0) {
if (rule_has_nl[num_rules]) {
snprintf (action_text, sizeof(action_text),
"YY_LINENO_REWIND_TO(%s + %d);\n", scanner_bp, headcnt);
add_action (action_text);
}
snprintf (action_text, sizeof(action_text), "%s = %s + %d;\n",
scanner_cp, scanner_bp, headcnt);
add_action (action_text);
}
else {
if (rule_has_nl[num_rules]) {
snprintf (action_text, sizeof(action_text),
"YY_LINENO_REWIND_TO(yy_cp - %d);\n", trailcnt);
add_action (action_text);
}
snprintf (action_text, sizeof(action_text), "%s -= %d;\n",
scanner_cp, trailcnt);
add_action (action_text);
@ -281,7 +286,8 @@ void finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
if (!continued_action)
add_action ("YY_RULE_SETUP\n");
line_directive_out ((FILE *) 0, 1);
line_directive_out(NULL, 1);
add_action("[[");
}
@ -301,8 +307,7 @@ void finish_rule (mach, variable_trail_rule, headcnt, trailcnt,
* FIRST is set to new by the operation. last is unmolested.
*/
int link_machines (first, last)
int first, last;
int link_machines (int first, int last)
{
if (first == NIL)
return last;
@ -328,8 +333,7 @@ int link_machines (first, last)
* The "beginning" states are the epsilon closure of the first state
*/
void mark_beginning_as_normal (mach)
int mach;
void mark_beginning_as_normal (int mach)
{
switch (state_type[mach]) {
case STATE_NORMAL:
@ -370,8 +374,7 @@ void mark_beginning_as_normal (mach)
* more mkbranch's. Compare with mkor()
*/
int mkbranch (first, second)
int first, second;
int mkbranch (int first, int second)
{
int eps;
@ -398,8 +401,7 @@ int mkbranch (first, second)
* new - a new state which matches the closure of "state"
*/
int mkclos (state)
int state;
int mkclos (int state)
{
return mkopt (mkposcl (state));
}
@ -419,8 +421,7 @@ int mkclos (state)
* 2. mach is destroyed by the call
*/
int mkopt (mach)
int mach;
int mkopt (int mach)
{
int eps;
@ -456,8 +457,7 @@ int mkopt (mach)
* the number of epsilon states needed
*/
int mkor (first, second)
int first, second;
int mkor (int first, int second)
{
int eps, orend;
@ -512,8 +512,7 @@ int mkor (first, second)
* new - a machine matching the positive closure of "state"
*/
int mkposcl (state)
int state;
int mkposcl (int state)
{
int eps;
@ -542,8 +541,7 @@ int mkposcl (state)
* if "ub" is INFINITE_REPEAT then "new" matches "lb" or more occurrences of "mach"
*/
int mkrep (mach, lb, ub)
int mach, lb, ub;
int mkrep (int mach, int lb, int ub)
{
int base_mach, tail, copy, i;
@ -589,12 +587,11 @@ int mkrep (mach, lb, ub)
* that it admittedly is)
*/
int mkstate (sym)
int sym;
int mkstate (int sym)
{
if (++lastnfa >= current_mns) {
if ((current_mns += MNS_INCREMENT) >= maximum_mns)
lerrif (_
lerr(_
("input rules are too complicated (>= %d NFA states)"),
current_mns);
@ -666,8 +663,7 @@ current_mns);
* stateto - the state to which the transition is to be made
*/
void mkxtion (statefrom, stateto)
int statefrom, stateto;
void mkxtion (int statefrom, int stateto)
{
if (trans1[statefrom] == NO_TRANSITION)
trans1[statefrom] = stateto;
@ -684,7 +680,7 @@ void mkxtion (statefrom, stateto)
/* new_rule - initialize for a new rule */
void new_rule ()
void new_rule (void)
{
if (++num_rules >= current_max_rules) {
++num_reallocs;
@ -700,7 +696,7 @@ void new_rule ()
}
if (num_rules > MAX_RULE)
lerrif (_("too many rules (> %d)!"), MAX_RULE);
lerr (_("too many rules (> %d)!"), MAX_RULE);
rule_linenum[num_rules] = linenum;
rule_useful[num_rules] = false;

9
contrib/flex/options.c → contrib/flex/src/options.c
View File

@ -117,6 +117,8 @@ optspec_t flexopts[] = {
,
{"--help", OPT_HELP, 0}
, /* Produce this help message. */
{"--hex", OPT_HEX, 0}
, /* Use hexadecimals in debug/trace outputs */
{"-I", OPT_INTERACTIVE, 0}
,
{"--interactive", OPT_INTERACTIVE, 0}
@ -211,10 +213,6 @@ optspec_t flexopts[] = {
,
{"--nowarn", OPT_NO_WARN, 0}
, /* Suppress warning messages. */
{"--noansi-definitions", OPT_NO_ANSI_FUNC_DEFS, 0}
,
{"--noansi-prototypes", OPT_NO_ANSI_FUNC_PROTOS, 0}
,
{"--yyclass=NAME", OPT_YYCLASS, 0}
,
{"--yylineno", OPT_YYLINENO, 0}
@ -273,7 +271,8 @@ optspec_t flexopts[] = {
,
{"--noyyset_lloc", OPT_NO_YYSET_LLOC, 0}
,
{"--unsafe-no-m4-sect3-escape", OPT_NO_SECT3_ESCAPE, 0}
,
{0, 0, 0} /* required final NULL entry. */
};

6
contrib/flex/options.h → contrib/flex/src/options.h
View File

@ -60,6 +60,7 @@ enum flexopt_flag_t {
OPT_FULL,
OPT_HEADER_FILE,
OPT_HELP,
OPT_HEX,
OPT_INTERACTIVE,
OPT_LEX_COMPAT,
OPT_POSIX_COMPAT,
@ -67,8 +68,6 @@ enum flexopt_flag_t {
OPT_META_ECS,
OPT_NEVER_INTERACTIVE,
OPT_NO_ALIGN,
OPT_NO_ANSI_FUNC_DEFS,
OPT_NO_ANSI_FUNC_PROTOS,
OPT_NO_DEBUG,
OPT_NO_DEFAULT,
OPT_NO_ECS,
@ -126,7 +125,8 @@ enum flexopt_flag_t {
OPT_YYCLASS,
OPT_YYLINENO,
OPT_YYMORE,
OPT_YYWRAP
OPT_YYWRAP,
OPT_NO_SECT3_ESCAPE,
};
#endif

87
contrib/flex/parse.y → contrib/flex/src/parse.y
View File

@ -1,8 +1,8 @@
/* parse.y - parser for flex input */
%token CHAR NUMBER SECTEND SCDECL XSCDECL NAME PREVCCL EOF_OP
%token OPTION_OP OPT_OUTFILE OPT_PREFIX OPT_YYCLASS OPT_HEADER OPT_EXTRA_TYPE
%token OPT_TABLES
%token TOK_OPTION TOK_OUTFILE TOK_PREFIX TOK_YYCLASS TOK_HEADER_FILE TOK_EXTRA_TYPE
%token TOK_TABLES_FILE
%token CCE_ALNUM CCE_ALPHA CCE_BLANK CCE_CNTRL CCE_DIGIT CCE_GRAPH
%token CCE_LOWER CCE_PRINT CCE_PUNCT CCE_SPACE CCE_UPPER CCE_XDIGIT
@ -80,7 +80,7 @@ int previous_continued_action; /* whether the previous rule's action was '|' */
do{ \
char fw3_msg[MAXLINE];\
snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
warn( fw3_msg );\
lwarn( fw3_msg );\
}while(0)
/* Expand a POSIX character class expression. */
@ -140,7 +140,7 @@ goal : initlex sect1 sect1end sect2 initforrule
else
add_action( "ECHO" );
add_action( ";\n\tYY_BREAK\n" );
add_action( ";\n\tYY_BREAK]]\n" );
}
;
@ -184,28 +184,30 @@ namelist1 : namelist1 NAME
{ synerr( _("bad start condition list") ); }
;
options : OPTION_OP optionlist
options : TOK_OPTION optionlist
;
optionlist : optionlist option
|
;
option : OPT_OUTFILE '=' NAME
option : TOK_OUTFILE '=' NAME
{
outfilename = copy_string( nmstr );
outfilename = xstrdup(nmstr);
did_outfilename = 1;
}
| OPT_EXTRA_TYPE '=' NAME
{ extra_type = copy_string( nmstr ); }
| OPT_PREFIX '=' NAME
{ prefix = copy_string( nmstr ); }
| OPT_YYCLASS '=' NAME
{ yyclass = copy_string( nmstr ); }
| OPT_HEADER '=' NAME
{ headerfilename = copy_string( nmstr ); }
| OPT_TABLES '=' NAME
{ tablesext = true; tablesfilename = copy_string( nmstr ); }
| TOK_EXTRA_TYPE '=' NAME
{ extra_type = xstrdup(nmstr); }
| TOK_PREFIX '=' NAME
{ prefix = xstrdup(nmstr);
if (strchr(prefix, '[') || strchr(prefix, ']'))
flexerror(_("Prefix must not contain [ or ]")); }
| TOK_YYCLASS '=' NAME
{ yyclass = xstrdup(nmstr); }
| TOK_HEADER_FILE '=' NAME
{ headerfilename = xstrdup(nmstr); }
| TOK_TABLES_FILE '=' NAME
{ tablesext = true; tablesfilename = xstrdup(nmstr); }
;
sect2 : sect2 scon initforrule flexrule '\n'
@ -303,7 +305,7 @@ flexrule : '^' rule
scon_stk[++scon_stk_ptr] = i;
if ( scon_stk_ptr == 0 )
warn(
lwarn(
"all start conditions already have <<EOF>> rules" );
else
@ -398,7 +400,7 @@ rule : re2 re
* erroneously.
*/
if ( ! varlength || headcnt != 0 )
warn(
lwarn(
"trailing context made variable due to preceding '|' action" );
/* Mark as variable. */
@ -453,7 +455,7 @@ rule : re2 re
/* See the comment in the rule for "re2 re"
* above.
*/
warn(
lwarn(
"trailing context made variable due to preceding '|' action" );
varlength = true;
@ -725,7 +727,7 @@ singleton : singleton '*'
{
/* Sort characters for fast searching.
*/
qsort( ccltbl + cclmap[$1], ccllen[$1], sizeof (*ccltbl), cclcmp );
qsort( ccltbl + cclmap[$1], (size_t) ccllen[$1], sizeof (*ccltbl), cclcmp );
if ( useecs )
mkeccl( ccltbl + cclmap[$1], ccllen[$1],
@ -913,13 +915,13 @@ ccl_expr:
| CCE_NEG_XDIGIT { CCL_NEG_EXPR(isxdigit); }
| CCE_NEG_LOWER {
if ( sf_case_ins() )
warn(_("[:^lower:] is ambiguous in case insensitive scanner"));
lwarn(_("[:^lower:] is ambiguous in case insensitive scanner"));
else
CCL_NEG_EXPR(islower);
}
| CCE_NEG_UPPER {
if ( sf_case_ins() )
warn(_("[:^upper:] ambiguous in case insensitive scanner"));
lwarn(_("[:^upper:] ambiguous in case insensitive scanner"));
else
CCL_NEG_EXPR(isupper);
}
@ -951,7 +953,7 @@ string : string CHAR
* conditions
*/
void build_eof_action()
void build_eof_action(void)
{
int i;
char action_text[MAXLINE];
@ -976,7 +978,8 @@ void build_eof_action()
}
}
line_directive_out( (FILE *) 0, 1 );
line_directive_out(NULL, 1);
add_action("[[");
/* This isn't a normal rule after all - don't count it as
* such, so we don't have any holes in the rule numbering
@ -990,8 +993,7 @@ void build_eof_action()
/* format_synerr - write out formatted syntax error */
void format_synerr( msg, arg )
const char *msg, arg[];
void format_synerr( const char *msg, const char arg[] )
{
char errmsg[MAXLINE];
@ -1002,8 +1004,7 @@ const char *msg, arg[];
/* synerr - report a syntax error */
void synerr( str )
const char *str;
void synerr( const char *str )
{
syntaxerror = true;
pinpoint_message( str );
@ -1012,20 +1013,18 @@ const char *str;
/* format_warn - write out formatted warning */
void format_warn( msg, arg )
const char *msg, arg[];
void format_warn( const char *msg, const char arg[] )
{
char warn_msg[MAXLINE];
snprintf( warn_msg, sizeof(warn_msg), msg, arg );
warn( warn_msg );
lwarn( warn_msg );
}
/* warn - report a warning, unless -w was given */
/* lwarn - report a warning, unless -w was given */
void warn( str )
const char *str;
void lwarn( const char *str )
{
line_warning( str, linenum );
}
@ -1034,8 +1033,7 @@ const char *str;
* pinpointing its location
*/
void format_pinpoint_message( msg, arg )
const char *msg, arg[];
void format_pinpoint_message( const char *msg, const char arg[] )
{
char errmsg[MAXLINE];
@ -1046,8 +1044,7 @@ const char *msg, arg[];
/* pinpoint_message - write out a message, pinpointing its location */
void pinpoint_message( str )
const char *str;
void pinpoint_message( const char *str )
{
line_pinpoint( str, linenum );
}
@ -1055,9 +1052,7 @@ const char *str;
/* line_warning - report a warning at a given line, unless -w was given */
void line_warning( str, line )
const char *str;
int line;
void line_warning( const char *str, int line )
{
char warning[MAXLINE];
@ -1071,9 +1066,7 @@ int line;
/* line_pinpoint - write out a message, pinpointing it at the given line */
void line_pinpoint( str, line )
const char *str;
int line;
void line_pinpoint( const char *str, int line )
{
fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
}
@ -1083,7 +1076,7 @@ int line;
* currently, messages are ignore
*/
void yyerror( msg )
const char *msg;
void yyerror( const char *msg )
{
(void)msg;
}

31
contrib/flex/regex.c → contrib/flex/src/regex.c
View File

@ -54,21 +54,17 @@ void flex_regcomp(regex_t *preg, const char *regex, int cflags)
memset (preg, 0, sizeof (regex_t));
if ((err = regcomp (preg, regex, cflags)) != 0) {
const int errbuf_sz = 200;
char *errbuf, *rxerr;
const size_t errbuf_sz = 200;
char *errbuf;
int n;
errbuf = (char*)flex_alloc(errbuf_sz *sizeof(char));
errbuf = malloc(errbuf_sz * sizeof(char));
if (!errbuf)
flexfatal(_("Unable to allocate buffer to report regcomp"));
rxerr = (char*)flex_alloc(errbuf_sz *sizeof(char));
if (!rxerr)
flexfatal(_("Unable to allocate buffer for regerror"));
regerror (err, preg, rxerr, errbuf_sz);
snprintf (errbuf, errbuf_sz, "regcomp for \"%s\" failed: %s", regex, rxerr);
n = snprintf(errbuf, errbuf_sz, "regcomp for \"%s\" failed: ", regex);
regerror(err, preg, errbuf+n, errbuf_sz-(size_t)n);
flexfatal (errbuf);
free(errbuf);
free(rxerr);
flexfatal (errbuf); /* never returns - no need to free(errbuf) */
}
}
@ -80,12 +76,12 @@ void flex_regcomp(regex_t *preg, const char *regex, int cflags)
char *regmatch_dup (regmatch_t * m, const char *src)
{
char *str;
int len;
size_t len;
if (m == NULL || m->rm_so < 0)
if (m == NULL || m->rm_so < 0 || m->rm_eo < m->rm_so)
return NULL;
len = m->rm_eo - m->rm_so;
str = (char *) flex_alloc ((len + 1) * sizeof (char));
len = (size_t) (m->rm_eo - m->rm_so);
str = malloc((len + 1) * sizeof(char));
if (!str)
flexfatal(_("Unable to allocate a copy of the match"));
strncpy (str, src + m->rm_so, len);
@ -107,13 +103,12 @@ char *regmatch_cpy (regmatch_t * m, char *dest, const char *src)
return dest;
}
snprintf (dest, regmatch_len(m), "%s", src + m->rm_so);
snprintf (dest, (size_t) regmatch_len(m), "%s", src + m->rm_so);
return dest;
}
/** Get the length in characters of the match.
* @param m A match as returned by regexec().
* @param src The source string that was passed to regexec().
* @return The length of the match.
*/
int regmatch_len (regmatch_t * m)
@ -151,7 +146,7 @@ int regmatch_strtol (regmatch_t * m, const char *src, char **endptr,
else
s = regmatch_dup (m, src);
n = strtol (s, endptr, base);
n = (int) strtol (s, endptr, base);
if (s != buf)
free (s);

290
contrib/flex/scan.l → contrib/flex/src/scan.l
View File

@ -37,6 +37,13 @@
extern bool tablesverify, tablesext;
extern int trlcontxt; /* Set in parse.y for each rule. */
extern const char *escaped_qstart, *escaped_qend;
extern int yylval;
#define M4QSTART "[""["
#define M4QEND "]""]"
#define ESCAPED_QSTART "[" M4QEND M4QSTART "[" M4QEND M4QSTART
#define ESCAPED_QEND M4QEND "]" M4QSTART M4QEND "]" M4QSTART
#define ACTION_ECHO add_action( yytext )
#define ACTION_IFDEF(def, should_define) \
@ -45,8 +52,8 @@ extern const char *escaped_qstart, *escaped_qend;
action_define( def, 1 ); \
}
#define ACTION_ECHO_QSTART add_action (escaped_qstart)
#define ACTION_ECHO_QEND add_action (escaped_qend)
#define ACTION_ECHO_QSTART add_action (ESCAPED_QSTART)
#define ACTION_ECHO_QEND add_action (ESCAPED_QEND)
#define ACTION_M4_IFDEF(def, should_define) \
do{ \
@ -59,7 +66,7 @@ extern const char *escaped_qstart, *escaped_qend;
#define MARK_END_OF_PROLOG mark_prolog();
#define YY_DECL \
int flexscan()
int flexscan(void)
#define RETURNCHAR \
yylval = (unsigned char) yytext[0]; \
@ -68,18 +75,20 @@ extern const char *escaped_qstart, *escaped_qend;
#define RETURNNAME \
if(yyleng < MAXLINE) \
{ \
strcpy( nmstr, yytext ); \
strncpy( nmstr, yytext, sizeof(nmstr) ); \
return NAME; \
} \
else \
{ \
do { \
synerr(_("Input line too long\n")); \
FLEX_EXIT(EXIT_FAILURE); \
} \
return NAME;
} while (0)
#define PUT_BACK_STRING(str, start) \
for ( i = strlen( str ) - 1; i >= start; --i ) \
unput((str)[i])
{ size_t i = strlen( str ); \
while ( i > start ) \
unput((str)[--i]); \
}
#define CHECK_REJECT(str) \
if ( all_upper( str ) ) \
@ -93,9 +102,26 @@ extern const char *escaped_qstart, *escaped_qend;
if ( getenv("POSIXLY_CORRECT") ) \
posix_compat = true;
#define START_CODEBLOCK(x) do { \
/* Emit the needed line directive... */\
if (indented_code == false) { \
linenum++; \
line_directive_out(NULL, 1); \
} \
add_action(M4QSTART); \
yy_push_state(CODEBLOCK); \
if ((indented_code = x)) ACTION_ECHO; \
} while(0)
#define END_CODEBLOCK do { \
yy_pop_state();\
add_action(M4QEND); \
if (!indented_code) line_directive_out(NULL, 0);\
} while (0)
%}
%option caseless nodefault stack noyy_top_state
%option caseless nodefault noreject stack noyy_top_state
%option nostdinit
%x SECT2 SECT2PROLOG SECT3 CODEBLOCK PICKUPDEF SC CARETISBOL NUM QUOTE
@ -104,7 +130,9 @@ extern const char *escaped_qstart, *escaped_qend;
%x GROUP_WITH_PARAMS
%x GROUP_MINUS_PARAMS
%x EXTENDED_COMMENT
%x COMMENT_DISCARD
%x COMMENT_DISCARD CODE_COMMENT
%x SECT3_NOESCAPE
%x CHARACTER_CONSTANT
WS [[:blank:]]+
OPTWS [[:blank:]]*
@ -125,8 +153,8 @@ CCL_EXPR ("[:"^?[[:alpha:]]+":]")
LEXOPT [aceknopr]
M4QSTART "[["
M4QEND "]]"
M4QSTART "[""["
M4QEND "]""]"
%%
static int bracelevel, didadef, indented_code;
@ -134,22 +162,17 @@ M4QEND "]]"
static int option_sense;
int doing_codeblock = false;
int i, brace_depth=0, brace_start_line=0;
Char nmdef[MAXLINE];
int brace_depth=0, brace_start_line=0;
char nmdef[MAXLINE];
<INITIAL>{
^{WS} indented_code = true; BEGIN(CODEBLOCK);
^"/*" ACTION_ECHO; yy_push_state( COMMENT );
^{WS} START_CODEBLOCK(true);
^"/*" add_action("/*[""["); yy_push_state( COMMENT );
^#{OPTWS}line{WS} yy_push_state( LINEDIR );
^"%s"{NAME}? return SCDECL;
^"%x"{NAME}? return XSCDECL;
^"%{".*{NL} {
++linenum;
line_directive_out( (FILE *) 0, 1 );
indented_code = false;
BEGIN(CODEBLOCK);
}
^"%{".*{NL} START_CODEBLOCK(false);
^"%top"[[:blank:]]*"{"[[:blank:]]*{NL} {
brace_start_line = linenum;
++linenum;
@ -166,7 +189,7 @@ M4QEND "]]"
sectnum = 2;
bracelevel = 0;
mark_defs1();
line_directive_out( (FILE *) 0, 1 );
line_directive_out(NULL, 1);
BEGIN(SECT2PROLOG);
return SECTEND;
}
@ -174,7 +197,7 @@ M4QEND "]]"
^"%pointer".*{NL} yytext_is_array = false; ++linenum;
^"%array".*{NL} yytext_is_array = true; ++linenum;
^"%option" BEGIN(OPTION); return OPTION_OP;
^"%option" BEGIN(OPTION); return TOK_OPTION;
^"%"{LEXOPT}{OPTWS}[[:digit:]]*{OPTWS}{NL} ++linenum; /* ignore */
^"%"{LEXOPT}{WS}.*{NL} ++linenum; /* ignore */
@ -185,7 +208,7 @@ M4QEND "]]"
^{NAME} {
if(yyleng < MAXLINE)
{
strcpy( nmstr, yytext );
strncpy( nmstr, yytext, sizeof(nmstr) );
}
else
{
@ -203,14 +226,18 @@ M4QEND "]]"
}
<COMMENT>{
"*/" ACTION_ECHO; yy_pop_state();
"*" ACTION_ECHO;
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
[^*\n] ACTION_ECHO;
<COMMENT,CODE_COMMENT>{ /* */
[^\[\]\*\n]* ACTION_ECHO;
. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO;
}
<COMMENT>{
"*/" add_action("*/]""]"); yy_pop_state();
}
<CODE_COMMENT>{
"*/" ACTION_ECHO; yy_pop_state();
}
<COMMENT_DISCARD>{
/* This is the same as COMMENT, but is discarded rather than output. */
@ -231,25 +258,25 @@ M4QEND "]]"
[[:digit:]]+ linenum = myctoi( yytext );
\"[^"\n]*\" {
flex_free( (void *) infilename );
infilename = copy_string( yytext + 1 );
free(infilename);
infilename = xstrdup(yytext + 1);
infilename[strlen( infilename ) - 1] = '\0';
}
. /* ignore spurious characters */
}
<CODEBLOCK>{
^"%}".*{NL} ++linenum; BEGIN(INITIAL);
<ACTION,CODEBLOCK,ACTION_STRING,PERCENT_BRACE_ACTION,CHARACTER_CONSTANT,COMMENT,CODE_COMMENT>{
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
. ACTION_ECHO;
}
<CODEBLOCK>{
^"%}".*{NL} ++linenum; END_CODEBLOCK;
[^\n%\[\]]* ACTION_ECHO;
. ACTION_ECHO;
{NL} {
++linenum;
ACTION_ECHO;
if ( indented_code )
BEGIN(INITIAL);
if ( indented_code ) END_CODEBLOCK;
}
}
@ -272,10 +299,9 @@ M4QEND "]]"
buf_strnappend(&top_buf, yytext, yyleng);
}
{M4QSTART} buf_strnappend(&top_buf, escaped_qstart, strlen(escaped_qstart));
{M4QEND} buf_strnappend(&top_buf, escaped_qend, strlen(escaped_qend));
[^{}\r\n] {
{M4QSTART} buf_strnappend(&top_buf, escaped_qstart, (int) strlen(escaped_qstart));
{M4QEND} buf_strnappend(&top_buf, escaped_qend, (int) strlen(escaped_qend));
([^{}\r\n\[\]]+)|[^{}\r\n] {
buf_strnappend(&top_buf, yytext, yyleng);
}
@ -293,7 +319,7 @@ M4QEND "]]"
{NOT_WS}[^\r\n]* {
if(yyleng < MAXLINE)
{
strcpy( (char *) nmdef, yytext );
strncpy( nmdef, yytext, sizeof(nmdef) );
}
else
{
@ -301,12 +327,12 @@ M4QEND "]]"
FLEX_EXIT(EXIT_FAILURE);
}
/* Skip trailing whitespace. */
for ( i = strlen( (char *) nmdef ) - 1;
i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
--i )
;
nmdef[i + 1] = '\0';
{
size_t i = strlen( nmdef );
while (i > 0 && (nmdef[i-1] == ' ' || nmdef[i-1] == '\t'))
--i;
nmdef[i] = '\0';
}
ndinstal( nmstr, nmdef );
didadef = true;
@ -338,8 +364,6 @@ M4QEND "]]"
interactive = option_sense;
}
array yytext_is_array = option_sense;
ansi-definitions ansi_func_defs = option_sense;
ansi-prototypes ansi_func_protos = option_sense;
backup backing_up_report = option_sense;
batch interactive = ! option_sense;
bison-bridge bison_bridge_lval = option_sense;
@ -364,6 +388,7 @@ M4QEND "]]"
interactive interactive = option_sense;
lex-compat lex_compat = option_sense;
posix-compat posix_compat = option_sense;
line gen_line_dirs = option_sense;
main {
ACTION_M4_IFDEF( "M4""_YY_MAIN", option_sense);
/* Override yywrap */
@ -420,12 +445,12 @@ M4QEND "]]"
yyget_lloc ACTION_M4_IFDEF("M4""_YY_NO_GET_LLOC", ! option_sense);
yyset_lloc ACTION_M4_IFDEF("M4""_YY_NO_SET_LLOC", ! option_sense);
extra-type return OPT_EXTRA_TYPE;
outfile return OPT_OUTFILE;
prefix return OPT_PREFIX;
yyclass return OPT_YYCLASS;
header(-file)? return OPT_HEADER;
tables-file return OPT_TABLES;
extra-type return TOK_EXTRA_TYPE;
outfile return TOK_OUTFILE;
prefix return TOK_PREFIX;
yyclass return TOK_YYCLASS;
header(-file)? return TOK_HEADER_FILE;
tables-file return TOK_TABLES_FILE;
tables-verify {
tablesverify = option_sense;
if(!tablesext && option_sense)
@ -436,7 +461,7 @@ M4QEND "]]"
\"[^"\n]*\" {
if(yyleng-1 < MAXLINE)
{
strcpy( nmstr, yytext + 1 );
strncpy( nmstr, yytext + 1, sizeof(nmstr) );
}
else
{
@ -461,18 +486,19 @@ M4QEND "]]"
^"%{".* ++bracelevel; yyless( 2 ); /* eat only %{ */
^"%}".* --bracelevel; yyless( 2 ); /* eat only %} */
^{WS}.* ACTION_ECHO; /* indented code in prolog */
^{WS} START_CODEBLOCK(true); /* indented code in prolog */
^{NOT_WS}.* { /* non-indented code */
if ( bracelevel <= 0 )
{ /* not in %{ ... %} */
^{NOT_WS}.* {
/* non-indented code */
if ( bracelevel <= 0 ) {
/* not in %{ ... %} */
yyless( 0 ); /* put it all back */
yy_set_bol( 1 );
mark_prolog();
BEGIN(SECT2);
} else {
START_CODEBLOCK(true);
}
else
ACTION_ECHO;
}
. ACTION_ECHO;
@ -527,11 +553,11 @@ M4QEND "]]"
if (sf_skip_ws()){
/* We're in the middle of a (?x: ) pattern. */
/* Push back everything starting at the "|" */
size_t amt;
amt = strchr (yytext, '|') - yytext;
int amt = (int) (strchr (yytext, '|') - yytext);
yyless(amt);
}
else {
add_action("]""]");
continued_action = true;
++linenum;
return '\n';
@ -601,9 +627,10 @@ M4QEND "]]"
^"%%".* {
sectnum = 3;
BEGIN(SECT3);
BEGIN(no_section3_escape ? SECT3_NOESCAPE : SECT3);
outn("/* Begin user sect3 */");
yyterminate(); /* to stop the parser */
}
"["({FIRST_CCL_CHAR}|{CCL_EXPR})({CCL_CHAR}|{CCL_EXPR})* {
@ -611,7 +638,7 @@ M4QEND "]]"
if(yyleng < MAXLINE)
{
strcpy( nmstr, yytext );
strncpy( nmstr, yytext, sizeof(nmstr) );
}
else
{
@ -627,7 +654,7 @@ M4QEND "]]"
* The reason it was disabled is so yacc/bison can parse
* ccl operations, such as ccl difference and union.
*/
&& (cclval = ccllookup( (Char *) nmstr )) != 0 )
&& (cclval = ccllookup( nmstr )) != 0 )
{
if ( input() != ']' )
synerr( _( "bad character class" ) );
@ -641,7 +668,7 @@ M4QEND "]]"
/* We fudge a bit. We know that this ccl will
* soon be numbered as lastccl + 1 by cclinit.
*/
cclinstal( (Char *) nmstr, lastccl + 1 );
cclinstal( nmstr, lastccl + 1 );
/* Push back everything but the leading bracket
* so the ccl can be rescanned.
@ -661,7 +688,7 @@ M4QEND "]]"
* context.
*/
"{"{NAME}"}"[[:space:]]? {
Char *nmdefptr;
char *nmdefptr;
int end_is_ws, end_ch;
end_ch = yytext[yyleng-1];
@ -669,7 +696,7 @@ M4QEND "]]"
if(yyleng-1 < MAXLINE)
{
strcpy( nmstr, yytext + 1 );
strncpy( nmstr, yytext + 1, sizeof(nmstr) );
}
else
{
@ -685,7 +712,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
else
{ /* push back name surrounded by ()'s */
int len = strlen( (char *) nmdefptr );
size_t len = strlen( nmdefptr );
if (end_is_ws)
unput(end_ch);
@ -693,7 +720,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
(len > 0 && nmdefptr[len - 1] == '$')
|| (end_is_ws && trlcontxt && !sf_skip_ws()))
{ /* don't use ()'s after all */
PUT_BACK_STRING((char *) nmdefptr, 0);
PUT_BACK_STRING(nmdefptr, 0);
if ( nmdefptr[0] == '^' )
BEGIN(CARETISBOL);
@ -702,7 +729,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
else
{
unput(')');
PUT_BACK_STRING((char *) nmdefptr, 0);
PUT_BACK_STRING(nmdefptr, 0);
unput('(');
}
}
@ -738,7 +765,13 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
return '(';
}
"(" sf_push(); return '(';
")" sf_pop(); return ')';
")" {
if (_sf_top_ix > 0) {
sf_pop();
return ')';
} else
synerr(_("unbalanced parenthesis"));
}
[/|*+?.(){}] return (unsigned char) yytext[0];
. RETURNCHAR;
@ -870,7 +903,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
<PERCENT_BRACE_ACTION>{
{OPTWS}"%}".* bracelevel = 0;
<ACTION>"/*" ACTION_ECHO; yy_push_state( COMMENT );
<ACTION>"/*" ACTION_ECHO; yy_push_state( CODE_COMMENT );
<CODEBLOCK,ACTION>{
"reject" {
@ -883,17 +916,13 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
}
}
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
. ACTION_ECHO;
{NL} {
++linenum;
ACTION_ECHO;
if ( bracelevel == 0 ||
(doing_codeblock && indented_code) )
{
if (bracelevel <= 0 || (doing_codeblock && indented_code)) {
if ( doing_rule_action )
add_action( "\tYY_BREAK\n" );
add_action( "\tYY_BREAK]""]\n" );
doing_rule_action = doing_codeblock = false;
BEGIN(SECT2);
@ -906,20 +935,17 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
<ACTION>{
"{" ACTION_ECHO; ++bracelevel;
"}" ACTION_ECHO; --bracelevel;
{M4QSTART} ACTION_ECHO_QSTART;
{M4QEND} ACTION_ECHO_QEND;
[^[:alpha:]_{}"'/\n\[\]]+ ACTION_ECHO;
[\[\]] ACTION_ECHO;
[^[:alpha:]_{}\"'/\n\[\]]+ ACTION_ECHO;
{NAME} ACTION_ECHO;
"'"([^'\\\n]|\\.)*"'" ACTION_ECHO; /* character constant */
"'"([^\'\\\n]|\\.)"'" ACTION_ECHO; /* character constant */
"'" ACTION_ECHO; BEGIN(CHARACTER_CONSTANT);
\" ACTION_ECHO; BEGIN(ACTION_STRING);
{NL} {
++linenum;
ACTION_ECHO;
if ( bracelevel == 0 )
{
if (bracelevel <= 0) {
if ( doing_rule_action )
add_action( "\tYY_BREAK\n" );
add_action( "\tYY_BREAK]""]\n" );
doing_rule_action = false;
BEGIN(SECT2);
@ -929,14 +955,21 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
}
<ACTION_STRING>{
[^"\\\n]+ ACTION_ECHO;
\\. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO; BEGIN(ACTION);
[^\[\]\"\\\n]+ ACTION_ECHO;
\" ACTION_ECHO; BEGIN(ACTION);
}
<CHARACTER_CONSTANT>{
[^\[\]\'\\\n]+ ACTION_ECHO;
\' ACTION_ECHO; BEGIN(ACTION);
}
<ACTION_STRING,CHARACTER_CONSTANT>{
(\\\n)* ACTION_ECHO;
\\(\\\n)*. ACTION_ECHO;
{NL} ++linenum; ACTION_ECHO; if (bracelevel <= 0) { BEGIN(SECT2); } else { BEGIN(ACTION); }
. ACTION_ECHO;
}
<COMMENT,COMMENT_DISCARD,ACTION,ACTION_STRING><<EOF>> {
<COMMENT,CODE_COMMENT,COMMENT_DISCARD,ACTION,ACTION_STRING,CHARACTER_CONSTANT><<EOF>> {
synerr( _( "EOF encountered inside an action" ) );
yyterminate();
}
@ -947,7 +980,7 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
}
<SECT2,QUOTE,FIRSTCCL,CCL>{ESCSEQ} {
yylval = myesc( (Char *) yytext );
yylval = myesc( (unsigned char *) yytext );
if ( YY_START == FIRSTCCL )
BEGIN(CCL);
@ -955,21 +988,32 @@ nmstr[yyleng - 2 - end_is_ws] = '\0'; /* chop trailing brace */
return CHAR;
}
<SECT3>{
{M4QSTART} fwrite (escaped_qstart, 1, strlen(escaped_qstart), yyout);
{M4QEND} fwrite (escaped_qend, 1, strlen(escaped_qend), yyout);
[^\[\]\n]*(\n?) ECHO;
(.|\n) ECHO;
<<EOF>> sectnum = 0; yyterminate();
{M4QSTART} fputs(escaped_qstart, yyout);
{M4QEND} fputs(escaped_qend, yyout);
[^\[\]]* ECHO;
[][] ECHO;
<<EOF>> {
sectnum = 0;
yyterminate();
}
}
<SECT3_NOESCAPE>{
{M4QSTART} fprintf(yyout, "[""[%s]""]", escaped_qstart);
{M4QEND} fprintf(yyout, "[""[%s]""]", escaped_qend);
[^][]* ECHO;
[][] ECHO;
<<EOF>> {
sectnum = 0;
yyterminate();
}
}
<*>.|\n format_synerr( _( "bad character: %s" ), yytext );
%%
int yywrap()
int yywrap(void)
{
if ( --num_input_files > 0 )
{
@ -984,46 +1028,22 @@ int yywrap()
/* set_input_file - open the given file (if NULL, stdin) for scanning */
void set_input_file( file )
char *file;
void set_input_file( char *file )
{
if ( file && strcmp( file, "-" ) )
{
infilename = copy_string( file );
infilename = xstrdup(file);
yyin = fopen( infilename, "r" );
if ( yyin == NULL )
lerrsf( _( "can't open %s" ), file );
lerr( _( "can't open %s" ), file );
}
else
{
yyin = stdin;
infilename = copy_string( "<stdin>" );
infilename = xstrdup("<stdin>");
}
linenum = 1;
}
/* Wrapper routines for accessing the scanner's malloc routines. */
void *flex_alloc( size )
size_t size;
{
return (void *) malloc( size );
}
void *flex_realloc( ptr, size )
void *ptr;
size_t size;
{
return (void *) realloc( ptr, size );
}
void flex_free( ptr )
void *ptr;
{
if ( ptr )
free( ptr );
}

12
contrib/flex/scanflags.c → contrib/flex/src/scanflags.c
View File

@ -39,8 +39,10 @@ size_t _sf_top_ix=0, _sf_max=0;
void
sf_push (void)
{
if (_sf_top_ix + 1 >= _sf_max)
_sf_stk = (scanflags_t*) flex_realloc ( (void*) _sf_stk, sizeof(scanflags_t) * (_sf_max += 32));
if (_sf_top_ix + 1 >= _sf_max) {
_sf_max += 32;
_sf_stk = realloc(_sf_stk, sizeof(scanflags_t) * _sf_max);
}
// copy the top element
_sf_stk[_sf_top_ix + 1] = _sf_stk[_sf_top_ix];
@ -59,10 +61,10 @@ void
sf_init (void)
{
assert(_sf_stk == NULL);
_sf_stk = (scanflags_t*) flex_alloc ( sizeof(scanflags_t) * (_sf_max = 32));
_sf_max = 32;
_sf_stk = malloc(sizeof(scanflags_t) * _sf_max);
if (!_sf_stk)
lerrsf_fatal(_("Unable to allocate %ld of stack"),
(void *)(uintptr_t)sizeof(scanflags_t));
lerr_fatal(_("Unable to allocate %zu of stack"), sizeof(scanflags_t));
_sf_stk[_sf_top_ix] = 0;
}

159
contrib/flex/scanopt.c → contrib/flex/src/scanopt.c
View File

@ -37,20 +37,6 @@
/* Internal structures */
#ifdef HAVE_STRCASECMP
#define STRCASECMP(a,b) strcasecmp(a,b)
#else
static int STRCASECMP PROTO ((const char *, const char *));
static int STRCASECMP (a, b)
const char *a;
const char *b;
{
while (tolower (*a++) == tolower (*b++)) ;
return b - a;
}
#endif
#define ARG_NONE 0x01
#define ARG_REQ 0x02
#define ARG_OPT 0x04
@ -77,56 +63,45 @@ struct _scanopt_t {
};
/* Accessor functions. These WOULD be one-liners, but portability calls. */
static const char *NAME PROTO ((struct _scanopt_t *, int));
static int PRINTLEN PROTO ((struct _scanopt_t *, int));
static int RVAL PROTO ((struct _scanopt_t *, int));
static int FLAGS PROTO ((struct _scanopt_t *, int));
static const char *DESC PROTO ((struct _scanopt_t *, int));
static int scanopt_err PROTO ((struct _scanopt_t *, int, int, int));
static int matchlongopt PROTO ((char *, char **, int *, char **, int *));
static int find_opt
PROTO ((struct _scanopt_t *, int, char *, int, int *, int *opt_offset));
static const char *NAME(struct _scanopt_t *, int);
static int PRINTLEN(struct _scanopt_t *, int);
static int RVAL(struct _scanopt_t *, int);
static int FLAGS(struct _scanopt_t *, int);
static const char *DESC(struct _scanopt_t *, int);
static int scanopt_err(struct _scanopt_t *, int, int);
static int matchlongopt(char *, char **, int *, char **, int *);
static int find_opt(struct _scanopt_t *, int, char *, int, int *, int *opt_offset);
static const char *NAME (s, i)
struct _scanopt_t *s;
int i;
static const char *NAME (struct _scanopt_t *s, int i)
{
return s->options[i].opt_fmt +
((s->aux[i].flags & IS_LONG) ? 2 : 1);
}
static int PRINTLEN (s, i)
struct _scanopt_t *s;
int i;
static int PRINTLEN (struct _scanopt_t *s, int i)
{
return s->aux[i].printlen;
}
static int RVAL (s, i)
struct _scanopt_t *s;
int i;
static int RVAL (struct _scanopt_t *s, int i)
{
return s->options[i].r_val;
}
static int FLAGS (s, i)
struct _scanopt_t *s;
int i;
static int FLAGS (struct _scanopt_t *s, int i)
{
return s->aux[i].flags;
}
static const char *DESC (s, i)
struct _scanopt_t *s;
int i;
static const char *DESC (struct _scanopt_t *s, int i)
{
return s->options[i].desc ? s->options[i].desc : "";
}
#ifndef NO_SCANOPT_USAGE
static int get_cols PROTO ((void));
static int get_cols (void);
static int get_cols ()
static int get_cols (void)
{
char *env;
int cols = 80; /* default */
@ -159,15 +134,11 @@ static int get_cols ()
(s)->subscript= 0; \
}while(0)
scanopt_t *scanopt_init (options, argc, argv, flags)
const optspec_t *options;
int argc;
char **argv;
int flags;
scanopt_t *scanopt_init (const optspec_t *options, int argc, char **argv, int flags)
{
int i;
struct _scanopt_t *s;
s = (struct _scanopt_t *) malloc (sizeof (struct _scanopt_t));
s = malloc(sizeof (struct _scanopt_t));
s->options = options;
s->optc = 0;
@ -186,10 +157,10 @@ scanopt_t *scanopt_init (options, argc, argv, flags)
s->optc++;
/* Build auxiliary data */
s->aux = (struct _aux *) malloc (s->optc * sizeof (struct _aux));
s->aux = malloc((size_t) s->optc * sizeof (struct _aux));
for (i = 0; i < s->optc; i++) {
const Char *p, *pname;
const unsigned char *p, *pname;
const struct optspec_t *opt;
struct _aux *aux;
@ -200,36 +171,36 @@ scanopt_t *scanopt_init (options, argc, argv, flags)
if (opt->opt_fmt[0] == '-' && opt->opt_fmt[1] == '-') {
aux->flags |= IS_LONG;
pname = (const Char *)(opt->opt_fmt + 2);
pname = (const unsigned char *)(opt->opt_fmt + 2);
s->has_long = 1;
}
else {
pname = (const Char *)(opt->opt_fmt + 1);
pname = (const unsigned char *)(opt->opt_fmt + 1);
s->has_short = 1;
}
aux->printlen = strlen (opt->opt_fmt);
aux->printlen = (int) strlen (opt->opt_fmt);
aux->namelen = 0;
for (p = pname + 1; *p; p++) {
/* detect required arg */
if (*p == '=' || isspace (*p)
if (*p == '=' || isspace ((unsigned char)*p)
|| !(aux->flags & IS_LONG)) {
if (aux->namelen == 0)
aux->namelen = p - pname;
aux->namelen = (int) (p - pname);
aux->flags |= ARG_REQ;
aux->flags &= ~ARG_NONE;
}
/* detect optional arg. This overrides required arg. */
if (*p == '[') {
if (aux->namelen == 0)
aux->namelen = p - pname;
aux->namelen = (int) (p - pname);
aux->flags &= ~(ARG_REQ | ARG_NONE);
aux->flags |= ARG_OPT;
break;
}
}
if (aux->namelen == 0)
aux->namelen = p - pname;
aux->namelen = (int) (p - pname);
}
return (scanopt_t *) s;
}
@ -255,10 +226,7 @@ typedef struct usg_elem usg_elem;
[indent][option, alias1, alias2...][indent][description line1
description line2...]
*/
int scanopt_usage (scanner, fp, usage)
scanopt_t *scanner;
FILE *fp;
const char *usage;
int scanopt_usage (scanopt_t *scanner, FILE *fp, const char *usage)
{
struct _scanopt_t *s;
int i, columns, indent = 2;
@ -293,7 +261,7 @@ int scanopt_usage (scanner, fp, usage)
fprintf (fp, "\n");
/* Sort by r_val and string. Yes, this is O(n*n), but n is small. */
store = (usg_elem *) malloc (s->optc * sizeof (usg_elem));
store = malloc((size_t) s->optc * sizeof (usg_elem));
for (i = 0; i < s->optc; i++) {
/* grab the next preallocate node. */
@ -319,7 +287,7 @@ int scanopt_usage (scanner, fp, usage)
}
if (!ptr_if_no_alias
&&
STRCASECMP (NAME (s, (*ue_curr)->idx),
strcasecmp (NAME (s, (*ue_curr)->idx),
NAME (s, ue->idx)) > 0) {
ptr_if_no_alias = ue_curr;
}
@ -391,7 +359,7 @@ int scanopt_usage (scanner, fp, usage)
maxlen[0] = len;
/* It's much easier to calculate length for description column! */
len = strlen (DESC (s, ue->idx));
len = (int) strlen (DESC (s, ue->idx));
if (len > maxlen[1])
maxlen[1] = len;
}
@ -481,7 +449,7 @@ int scanopt_usage (scanner, fp, usage)
while (*p && n < maxlen[1]
&& *p != '\n') {
if (isspace ((Char)(*p))
if (isspace ((unsigned char)(*p))
|| *p == '-') lastws =
p;
n++;
@ -529,18 +497,10 @@ int scanopt_usage (scanner, fp, usage)
#endif /* no scanopt_usage */
static int scanopt_err (s, opt_offset, is_short, err)
struct _scanopt_t *s;
int opt_offset;
int is_short;
int err;
static int scanopt_err (struct _scanopt_t *s, int is_short, int err)
{
const char *optname = "";
char optchar[2];
const optspec_t *opt = NULL;
if (opt_offset >= 0)
opt = s->options + opt_offset;
if (!s->no_err_msg) {
@ -592,16 +552,11 @@ static int scanopt_err (s, opt_offset, is_short, err)
* optname will point to str + 2
*
*/
static int matchlongopt (str, optname, optlen, arg, arglen)
char *str;
char **optname;
int *optlen;
char **arg;
int *arglen;
static int matchlongopt (char *str, char **optname, int *optlen, char **arg, int *arglen)
{
char *p;
*optname = *arg = (char *) 0;
*optname = *arg = NULL;
*optlen = *arglen = 0;
/* Match regex /--./ */
@ -610,13 +565,13 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
return 0;
p += 2;
*optname = (char *) p;
*optname = p;
/* find the end of optname */
while (*p && *p != '=')
++p;
*optlen = p - *optname;
*optlen = (int) (p - *optname);
if (!*p)
/* an option with no '=...' part. */
@ -628,7 +583,7 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
*arg = p;
while (*p)
++p;
*arglen = p - *arg;
*arglen = (int) (p - *arg);
return 1;
}
@ -639,13 +594,8 @@ static int matchlongopt (str, optname, optlen, arg, arglen)
* Short options must be exact.
* Return boolean true if found and no error.
* Error stored in err_code or zero if no error. */
static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
struct _scanopt_t *s;
int lookup_long;
char *optstart;
int len;
int *err_code;
int *opt_offset;
static int find_opt (struct _scanopt_t *s, int lookup_long, char *optstart, int
len, int *err_code, int *opt_offset)
{
int nmatch = 0, lastr_val = 0, i;
@ -656,17 +606,15 @@ static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
return 0;
for (i = 0; i < s->optc; i++) {
char *optname;
const char *optname;
optname =
(char *) (s->options[i].opt_fmt +
(lookup_long ? 2 : 1));
optname = s->options[i].opt_fmt + (lookup_long ? 2 : 1);
if (lookup_long && (s->aux[i].flags & IS_LONG)) {
if (len > s->aux[i].namelen)
continue;
if (strncmp (optname, optstart, len) == 0) {
if (strncmp (optname, optstart, (size_t) len) == 0) {
nmatch++;
*opt_offset = i;
@ -704,10 +652,7 @@ static int find_opt (s, lookup_long, optstart, len, err_code, opt_offset)
}
int scanopt (svoid, arg, optindex)
scanopt_t *svoid;
char **arg;
int *optindex;
int scanopt (scanopt_t *svoid, char **arg, int *optindex)
{
char *optname = NULL, *optarg = NULL, *pstart;
int namelen = 0, arglen = 0;
@ -749,7 +694,7 @@ int scanopt (svoid, arg, optindex)
if (!find_opt
(s, 1, optname, namelen, &errcode,
&opt_offset)) {
scanopt_err (s, opt_offset, 0, errcode);
scanopt_err (s, 0, errcode);
return errcode;
}
/* We handle this below. */
@ -784,7 +729,7 @@ int scanopt (svoid, arg, optindex)
if (!find_opt
(s, 0, pstart, namelen, &errcode, &opt_offset)) {
return scanopt_err (s, opt_offset, 1, errcode);
return scanopt_err (s, 1, errcode);
}
optarg = pstart + 1;
@ -793,7 +738,7 @@ int scanopt (svoid, arg, optindex)
arglen = 0;
}
else
arglen = strlen (optarg);
arglen = (int) strlen (optarg);
}
/* At this point, we have a long or short option matched at opt_offset into
@ -812,8 +757,7 @@ int scanopt (svoid, arg, optindex)
/* case: no args allowed */
if (auxp->flags & ARG_NONE) {
if (optarg && !is_short) {
scanopt_err (s, opt_offset, is_short, errcode =
SCANOPT_ERR_ARG_NOT_ALLOWED);
scanopt_err (s, is_short, errcode = SCANOPT_ERR_ARG_NOT_ALLOWED);
INC_INDEX (s, 1);
return errcode;
}
@ -827,8 +771,7 @@ int scanopt (svoid, arg, optindex)
/* case: required */
if (auxp->flags & ARG_REQ) {
if (!optarg && !has_next)
return scanopt_err (s, opt_offset, is_short,
SCANOPT_ERR_ARG_NOT_FOUND);
return scanopt_err (s, is_short, SCANOPT_ERR_ARG_NOT_FOUND);
if (!optarg) {
/* Let the next argv element become the argument. */
@ -855,14 +798,12 @@ int scanopt (svoid, arg, optindex)
}
int scanopt_destroy (svoid)
scanopt_t *svoid;
int scanopt_destroy (scanopt_t *svoid)
{
struct _scanopt_t *s;
s = (struct _scanopt_t *) svoid;
if (s) {
if (s->aux)
if (s != NULL) {
free(s->aux);
free(s);
}

19
contrib/flex/scanopt.h → contrib/flex/src/scanopt.h
View File

@ -47,9 +47,6 @@
#ifdef __cplusplus
extern "C" {
#endif
#ifndef PROTO
#define PROTO(args) args
#endif
/* Error codes. */ enum scanopt_err_t {
SCANOPT_ERR_OPT_UNRECOGNIZED = -1, /* Unrecognized option. */
SCANOPT_ERR_OPT_AMBIGUOUS = -2, /* It matched more than one option name. */
@ -85,12 +82,12 @@ extern "C" {
* flags - Control behavior.
* Return: A malloc'd pointer .
*/
scanopt_t *scanopt_init PROTO ((const optspec_t * options,
int argc, char **argv, int flags));
scanopt_t *scanopt_init (const optspec_t * options, int argc,
char **argv, int flags);
/* Frees memory used by scanner.
* Always returns 0. */
int scanopt_destroy PROTO ((scanopt_t * scanner));
int scanopt_destroy (scanopt_t * scanner);
#ifndef NO_SCANOPT_USAGE
/* Prints a usage message based on contents of optlist.
@ -100,10 +97,7 @@ extern "C" {
* usage - Text to be prepended to option list. May be NULL.
* Return: Always returns 0 (zero).
*/
int scanopt_usage
PROTO (
(scanopt_t * scanner, FILE * fp,
const char *usage));
int scanopt_usage (scanopt_t * scanner, FILE * fp, const char *usage);
#endif
/* Scans command-line options in argv[].
@ -120,10 +114,7 @@ extern "C" {
* < 0 on error (return value is an error code).
*
*/
int scanopt
PROTO (
(scanopt_t * scanner, char **optarg,
int *optindex));
int scanopt (scanopt_t * scanner, char **optarg, int *optindex);
#ifdef __cplusplus
}

69
contrib/flex/sym.c → contrib/flex/src/sym.c
View File

@ -59,12 +59,10 @@ static struct hash_entry *ccltab[CCL_HASH_SIZE];
/* declare functions that have forward references */
static int addsym PROTO ((char[], char *, int, hash_table, int));
static struct hash_entry *findsym PROTO ((const char *sym,
hash_table table,
int table_size));
static int hashfunct PROTO ((const char *, int));
static int addsym(char[], char *, int, hash_table, int);
static struct hash_entry *findsym (const char *sym, hash_table table,
int table_size);
static int hashfunct(const char *, int);
/* addsym - add symbol and definitions to symbol table
@ -72,12 +70,7 @@ static int hashfunct PROTO ((const char *, int));
* -1 is returned if the symbol already exists, and the change not made.
*/
static int addsym (sym, str_def, int_def, table, table_size)
char sym[];
char *str_def;
int int_def;
hash_table table;
int table_size;
static int addsym (char sym[], char *str_def, int int_def, hash_table table, int table_size)
{
int hash_val = hashfunct (sym, table_size);
struct hash_entry *sym_entry = table[hash_val];
@ -93,8 +86,7 @@ static int addsym (sym, str_def, int_def, table, table_size)
}
/* create new entry */
new_entry = (struct hash_entry *)
flex_alloc (sizeof (struct hash_entry));
new_entry = malloc(sizeof(struct hash_entry));
if (new_entry == NULL)
flexfatal (_("symbol table memory allocation failed"));
@ -119,15 +111,13 @@ static int addsym (sym, str_def, int_def, table, table_size)
/* cclinstal - save the text of a character class */
void cclinstal (ccltxt, cclnum)
Char ccltxt[];
int cclnum;
void cclinstal (char ccltxt[], int cclnum)
{
/* We don't bother checking the return status because we are not
* called unless the symbol is new.
*/
(void) addsym ((char *) copy_unsigned_string (ccltxt),
(void) addsym (xstrdup(ccltxt),
(char *) 0, cclnum, ccltab, CCL_HASH_SIZE);
}
@ -137,23 +127,18 @@ void cclinstal (ccltxt, cclnum)
* Returns 0 if there's no CCL associated with the text.
*/
int ccllookup (ccltxt)
Char ccltxt[];
int ccllookup (char ccltxt[])
{
return findsym ((char *) ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
return findsym (ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
}
/* findsym - find symbol in symbol table */
static struct hash_entry *findsym (sym, table, table_size)
const char *sym;
hash_table table;
int table_size;
static struct hash_entry *findsym (const char *sym, hash_table table, int table_size)
{
static struct hash_entry empty_entry = {
(struct hash_entry *) 0, (struct hash_entry *) 0,
(char *) 0, (char *) 0, 0,
NULL, NULL, NULL, NULL, 0,
};
struct hash_entry *sym_entry =
@ -170,9 +155,7 @@ static struct hash_entry *findsym (sym, table, table_size)
/* hashfunct - compute the hash value for "str" and hash size "hash_size" */
static int hashfunct (str, hash_size)
const char *str;
int hash_size;
static int hashfunct (const char *str, int hash_size)
{
int hashval;
int locstr;
@ -191,13 +174,11 @@ static int hashfunct (str, hash_size)
/* ndinstal - install a name definition */
void ndinstal (name, definition)
const char *name;
Char definition[];
void ndinstal (const char *name, char definition[])
{
if (addsym (copy_string (name),
(char *) copy_unsigned_string (definition), 0,
if (addsym (xstrdup(name),
xstrdup(definition), 0,
ndtbl, NAME_TABLE_HASH_SIZE))
synerr (_("name defined twice"));
}
@ -208,16 +189,15 @@ void ndinstal (name, definition)
* Returns a nil pointer if the name definition does not exist.
*/
Char *ndlookup (nd)
const char *nd;
char *ndlookup (const char *nd)
{
return (Char *) findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
return findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
}
/* scextend - increase the maximum number of start conditions */
void scextend ()
void scextend (void)
{
current_max_scs += MAX_SCS_INCREMENT;
@ -237,17 +217,15 @@ void scextend ()
* The start condition is "exclusive" if xcluflg is true.
*/
void scinstal (str, xcluflg)
const char *str;
int xcluflg;
void scinstal (const char *str, int xcluflg)
{
if (++lastsc >= current_max_scs)
scextend ();
scname[lastsc] = copy_string (str);
scname[lastsc] = xstrdup(str);
if (addsym (scname[lastsc], (char *) 0, lastsc,
if (addsym(scname[lastsc], NULL, lastsc,
sctbl, START_COND_HASH_SIZE))
format_pinpoint_message (_
("start condition %s declared twice"),
@ -265,8 +243,7 @@ str);
* Returns 0 if no such start condition.
*/
int sclookup (str)
const char *str;
int sclookup (const char *str)
{
return findsym (str, sctbl, START_COND_HASH_SIZE)->int_val;
}

72
contrib/flex/tables.c → contrib/flex/src/tables.c
View File

@ -55,7 +55,7 @@
int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v);
int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v);
int yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v);
int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len);
int yytbl_writen (struct yytbl_writer *wr, void *v, int len);
static flex_int32_t yytbl_data_geti (const struct yytbl_data *tbl, int i);
/* XXX Not used
static flex_int32_t yytbl_data_getijk (const struct yytbl_data *tbl, int i,
@ -65,7 +65,7 @@ static flex_int32_t yytbl_data_getijk (const struct yytbl_data *tbl, int i,
/** Initialize the table writer.
* @param wr an uninitialized writer
* @param the output file
* @param out the output file
* @return 0 on success
*/
int yytbl_writer_init (struct yytbl_writer *wr, FILE * out)
@ -86,17 +86,17 @@ int yytbl_hdr_init (struct yytbl_hdr *th, const char *version_str,
memset (th, 0, sizeof (struct yytbl_hdr));
th->th_magic = YYTBL_MAGIC;
th->th_hsize = 14 + strlen (version_str) + 1 + strlen (name) + 1;
th->th_hsize = (flex_uint32_t) (14 + strlen (version_str) + 1 + strlen (name) + 1);
th->th_hsize += yypad64 (th->th_hsize);
th->th_ssize = 0; // Not known at this point.
th->th_flags = 0;
th->th_version = copy_string (version_str);
th->th_name = copy_string (name);
th->th_version = xstrdup(version_str);
th->th_name = xstrdup(name);
return 0;
}
/** Allocate and initialize a table data structure.
* @param tbl a pointer to an uninitialized table
* @param td a pointer to an uninitialized table
* @param id the table identifier
* @return 0 on success
*/
@ -115,7 +115,6 @@ int yytbl_data_init (struct yytbl_data *td, enum yytbl_id id)
*/
int yytbl_data_destroy (struct yytbl_data *td)
{
if (td->td_data)
free(td->td_data);
td->td_data = 0;
free (td);
@ -137,7 +136,7 @@ static int yytbl_write_pad64 (struct yytbl_writer *wr)
}
/** write the header.
* @param out the output stream
* @param wr the output stream
* @param th table header to be written
* @return -1 on error, or bytes written on success.
*/
@ -159,12 +158,12 @@ int yytbl_hdr_fwrite (struct yytbl_writer *wr, const struct yytbl_hdr *th)
flex_die (_("th_ssize|th_flags write failed"));
bwritten += 6;
sz = strlen (th->th_version) + 1;
sz = (int) strlen (th->th_version) + 1;
if ((rv = yytbl_writen (wr, th->th_version, sz)) != sz)
flex_die (_("th_version writen failed"));
bwritten += rv;
sz = strlen (th->th_name) + 1;
sz = (int) strlen (th->th_name) + 1;
if ((rv = yytbl_writen (wr, th->th_name, sz)) != sz)
flex_die (_("th_name writen failed"));
bwritten += rv;
@ -183,7 +182,7 @@ int yytbl_hdr_fwrite (struct yytbl_writer *wr, const struct yytbl_hdr *th)
/** Write this table.
* @param out the file writer
* @param wr the file writer
* @param td table data to be written
* @return -1 on error, or bytes written on success.
*/
@ -214,13 +213,13 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
for (i = 0; i < total_len; i++) {
switch (YYTDFLAGS2BYTES (td->td_flags)) {
case sizeof (flex_int8_t):
rv = yytbl_write8 (wr, yytbl_data_geti (td, i));
rv = yytbl_write8 (wr, (flex_uint8_t) yytbl_data_geti (td, i));
break;
case sizeof (flex_int16_t):
rv = yytbl_write16 (wr, yytbl_data_geti (td, i));
rv = yytbl_write16 (wr, (flex_uint16_t) yytbl_data_geti (td, i));
break;
case sizeof (flex_int32_t):
rv = yytbl_write32 (wr, yytbl_data_geti (td, i));
rv = yytbl_write32 (wr, (flex_uint32_t) yytbl_data_geti (td, i));
break;
default:
flex_die (_("invalid td_flags detected"));
@ -233,7 +232,7 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
}
/* Sanity check */
if (bwritten != (int) (12 + total_len * YYTDFLAGS2BYTES (td->td_flags))) {
if (bwritten != (12 + total_len * (int) YYTDFLAGS2BYTES (td->td_flags))) {
flex_die (_("insanity detected"));
return -1;
}
@ -248,14 +247,14 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
/* Now go back and update the th_hsize member */
if (fgetpos (wr->out, &pos) != 0
|| fsetpos (wr->out, &(wr->th_ssize_pos)) != 0
|| yytbl_write32 (wr, wr->total_written) < 0
|| yytbl_write32 (wr, (flex_uint32_t) wr->total_written) < 0
|| fsetpos (wr->out, &pos)) {
flex_die (_("get|set|fwrite32 failed"));
return -1;
}
else
/* Don't count the int we just wrote. */
wr->total_written -= sizeof (flex_int32_t);
wr->total_written -= (int) sizeof (flex_int32_t);
return bwritten;
}
@ -265,11 +264,11 @@ int yytbl_data_fwrite (struct yytbl_writer *wr, struct yytbl_data *td)
* @param len number of bytes
* @return -1 on error. number of bytes written on success.
*/
int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len)
int yytbl_writen (struct yytbl_writer *wr, void *v, int len)
{
int rv;
rv = fwrite (v, 1, len, wr->out);
rv = (int) fwrite (v, 1, (size_t) len, wr->out);
if (rv != len)
return -1;
wr->total_written += len;
@ -284,11 +283,11 @@ int yytbl_writen (struct yytbl_writer *wr, void *v, flex_int32_t len)
int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v)
{
flex_uint32_t vnet;
size_t bytes, rv;
int bytes, rv;
vnet = htonl (v);
bytes = sizeof (flex_uint32_t);
rv = fwrite (&vnet, bytes, 1, wr->out);
bytes = (int) sizeof (flex_uint32_t);
rv = (int) fwrite (&vnet, (size_t) bytes, 1, wr->out);
if (rv != 1)
return -1;
wr->total_written += bytes;
@ -303,11 +302,11 @@ int yytbl_write32 (struct yytbl_writer *wr, flex_uint32_t v)
int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v)
{
flex_uint16_t vnet;
size_t bytes, rv;
int bytes, rv;
vnet = htons (v);
bytes = sizeof (flex_uint16_t);
rv = fwrite (&vnet, bytes, 1, wr->out);
bytes = (int) sizeof (flex_uint16_t);
rv = (int) fwrite (&vnet, (size_t) bytes, 1, wr->out);
if (rv != 1)
return -1;
wr->total_written += bytes;
@ -321,10 +320,10 @@ int yytbl_write16 (struct yytbl_writer *wr, flex_uint16_t v)
*/
int yytbl_write8 (struct yytbl_writer *wr, flex_uint8_t v)
{
size_t bytes, rv;
int bytes, rv;
bytes = sizeof (flex_uint8_t);
rv = fwrite (&v, bytes, 1, wr->out);
bytes = (int) sizeof (flex_uint8_t);
rv = (int) fwrite (&v, (size_t) bytes, 1, wr->out);
if (rv != 1)
return -1;
wr->total_written += bytes;
@ -428,7 +427,7 @@ static void yytbl_data_seti (const struct yytbl_data *tbl, int i,
*/
static size_t min_int_size (struct yytbl_data *tbl)
{
flex_uint32_t i, total_len;
flex_int32_t i, total_len;
flex_int32_t max = 0;
total_len = yytbl_calc_total_len (tbl);
@ -438,7 +437,7 @@ static size_t min_int_size (struct yytbl_data *tbl)
n = abs (yytbl_data_geti (tbl, i));
if (n > max)
if (max < n)
max = n;
}
@ -461,7 +460,8 @@ static size_t min_int_size (struct yytbl_data *tbl)
*/
void yytbl_data_compress (struct yytbl_data *tbl)
{
flex_int32_t i, newsz, total_len;
flex_int32_t i, total_len;
size_t newsz;
struct yytbl_data newtbl;
yytbl_data_init (&newtbl, tbl->td_id);
@ -472,19 +472,19 @@ void yytbl_data_compress (struct yytbl_data *tbl)
newsz = min_int_size (tbl);
if (newsz == (int) YYTDFLAGS2BYTES (tbl->td_flags))
if (newsz == YYTDFLAGS2BYTES (tbl->td_flags))
/* No change in this table needed. */
return;
if (newsz > (int) YYTDFLAGS2BYTES (tbl->td_flags)) {
if (newsz > YYTDFLAGS2BYTES (tbl->td_flags)) {
flex_die (_("detected negative compression"));
return;
}
total_len = yytbl_calc_total_len (tbl);
newtbl.td_data = calloc (total_len, newsz);
newtbl.td_flags =
TFLAGS_CLRDATA (newtbl.td_flags) | BYTES2TFLAG (newsz);
newtbl.td_data = calloc ((size_t) total_len, newsz);
newtbl.td_flags = (flex_uint16_t)
(TFLAGS_CLRDATA (newtbl.td_flags) | BYTES2TFLAG (newsz));
for (i = 0; i < total_len; i++) {
flex_int32_t g;

2
contrib/flex/tables.h → contrib/flex/src/tables.h
View File

@ -45,7 +45,7 @@ extern "C" {
#include "tables_shared.h"
struct yytbl_writer {
FILE *out;
flex_uint32_t total_written;
int total_written;
/**< bytes written so far */
fpos_t th_ssize_pos;
/**< position of th_ssize */

6
contrib/flex/tables_shared.c → contrib/flex/src/tables_shared.c
View File

@ -52,12 +52,12 @@ dnl
/** Get the number of integers in this table. This is NOT the
* same thing as the number of elements.
* @param td the table
* @param tbl the table
* @return the number of integers in the table
*/
yyskel_static flex_int32_t yytbl_calc_total_len (const struct yytbl_data *tbl)
{
flex_int32_t n;
flex_uint32_t n;
/* total number of ints */
n = tbl->td_lolen;
@ -66,5 +66,5 @@ yyskel_static flex_int32_t yytbl_calc_total_len (const struct yytbl_data *tbl)
if (tbl->td_id == YYTD_ID_TRANSITION)
n *= 2;
return n;
return (flex_int32_t) n;
}

0
contrib/flex/tables_shared.h → contrib/flex/src/tables_shared.h
View File

64
contrib/flex/tblcmp.c → contrib/flex/src/tblcmp.c
View File

@ -36,11 +36,11 @@
/* declarations for functions that have forward references */
void mkentry PROTO ((int *, int, int, int, int));
void mkprot PROTO ((int[], int, int));
void mktemplate PROTO ((int[], int, int));
void mv2front PROTO ((int));
int tbldiff PROTO ((int[], int, int[]));
void mkentry(int *, int, int, int, int);
void mkprot(int[], int, int);
void mktemplate(int[], int, int);
void mv2front(int);
int tbldiff(int[], int, int[]);
/* bldtbl - build table entries for dfa state
@ -78,8 +78,7 @@ int tbldiff PROTO ((int[], int, int[]));
* cost only one difference.
*/
void bldtbl (state, statenum, totaltrans, comstate, comfreq)
int state[], statenum, totaltrans, comstate, comfreq;
void bldtbl (int state[], int statenum, int totaltrans, int comstate, int comfreq)
{
int extptr, extrct[2][CSIZE + 1];
int mindiff, minprot, i, d;
@ -221,7 +220,7 @@ void bldtbl (state, statenum, totaltrans, comstate, comfreq)
* classes.
*/
void cmptmps ()
void cmptmps (void)
{
int tmpstorage[CSIZE + 1];
int *tmp = tmpstorage, i, j;
@ -289,7 +288,7 @@ void cmptmps ()
/* expand_nxt_chk - expand the next check arrays */
void expand_nxt_chk ()
void expand_nxt_chk (void)
{
int old_max = current_max_xpairs;
@ -300,8 +299,7 @@ void expand_nxt_chk ()
nxt = reallocate_integer_array (nxt, current_max_xpairs);
chk = reallocate_integer_array (chk, current_max_xpairs);
zero_out ((char *) (chk + old_max),
(size_t) (MAX_XPAIRS_INCREMENT * sizeof (int)));
memset(chk + old_max, 0, MAX_XPAIRS_INCREMENT * sizeof(int));
}
@ -324,8 +322,7 @@ void expand_nxt_chk ()
* and an action number will be added in [-1].
*/
int find_table_space (state, numtrans)
int *state, numtrans;
int find_table_space (int *state, int numtrans)
{
/* Firstfree is the position of the first possible occurrence of two
* consecutive unused records in the chk and nxt arrays.
@ -419,13 +416,11 @@ int find_table_space (state, numtrans)
* Initializes "firstfree" to be one beyond the end of the table. Initializes
* all "chk" entries to be zero.
*/
void inittbl ()
void inittbl (void)
{
int i;
zero_out ((char *) chk,
(size_t) (current_max_xpairs * sizeof (int)));
memset(chk, 0, (size_t) current_max_xpairs * sizeof(int));
tblend = 0;
firstfree = tblend + 1;
@ -451,7 +446,7 @@ void inittbl ()
/* mkdeftbl - make the default, "jam" table entries */
void mkdeftbl ()
void mkdeftbl (void)
{
int i;
@ -494,15 +489,14 @@ void mkdeftbl ()
* (i.e., jam entries) into the table. It is assumed that by linking to
* "JAMSTATE" they will be taken care of. In any case, entries in "state"
* marking transitions to "SAME_TRANS" are treated as though they will be
* taken care of by wherever "deflink" points. "totaltrans" is the total
* taken care of by whereever "deflink" points. "totaltrans" is the total
* number of transitions out of the state. If it is below a certain threshold,
* the tables are searched for an interior spot that will accommodate the
* state array.
*/
void mkentry (state, numchars, statenum, deflink, totaltrans)
int *state;
int numchars, statenum, deflink, totaltrans;
void mkentry (int *state, int numchars, int statenum, int deflink,
int totaltrans)
{
int minec, maxec, i, baseaddr;
int tblbase, tbllast;
@ -616,8 +610,7 @@ void mkentry (state, numchars, statenum, deflink, totaltrans)
* has only one out-transition
*/
void mk1tbl (state, sym, onenxt, onedef)
int state, sym, onenxt, onedef;
void mk1tbl (int state, int sym, int onenxt, int onedef)
{
if (firstfree < sym)
firstfree = sym;
@ -642,8 +635,7 @@ void mk1tbl (state, sym, onenxt, onedef)
/* mkprot - create new proto entry */
void mkprot (state, statenum, comstate)
int state[], statenum, comstate;
void mkprot (int state[], int statenum, int comstate)
{
int i, slot, tblbase;
@ -680,11 +672,10 @@ void mkprot (state, statenum, comstate)
* to it
*/
void mktemplate (state, statenum, comstate)
int state[], statenum, comstate;
void mktemplate (int state[], int statenum, int comstate)
{
int i, numdiff, tmpbase, tmp[CSIZE + 1];
Char transset[CSIZE + 1];
unsigned char transset[CSIZE + 1];
int tsptr;
++numtemps;
@ -712,7 +703,8 @@ void mktemplate (state, statenum, comstate)
if (state[i] == 0)
tnxt[tmpbase + i] = 0;
else {
transset[tsptr++] = i;
/* Note: range 1..256 is mapped to 1..255,0 */
transset[tsptr++] = (unsigned char) i;
tnxt[tmpbase + i] = comstate;
}
@ -732,8 +724,7 @@ void mktemplate (state, statenum, comstate)
/* mv2front - move proto queue element to front of queue */
void mv2front (qelm)
int qelm;
void mv2front (int qelm)
{
if (firstprot != qelm) {
if (qelm == lastprot)
@ -759,8 +750,7 @@ void mv2front (qelm)
* Transnum is the number of out-transitions for the state.
*/
void place_state (state, statenum, transnum)
int *state, statenum, transnum;
void place_state (int *state, int statenum, int transnum)
{
int i;
int *state_ptr;
@ -802,8 +792,7 @@ void place_state (state, statenum, transnum)
* no room, we process the sucker right now.
*/
void stack1 (statenum, sym, nextstate, deflink)
int statenum, sym, nextstate, deflink;
void stack1 (int statenum, int sym, int nextstate, int deflink)
{
if (onesp >= ONE_STACK_SIZE - 1)
mk1tbl (statenum, sym, nextstate, deflink);
@ -832,8 +821,7 @@ void stack1 (statenum, sym, nextstate, deflink)
* number is "numecs" minus the number of "SAME_TRANS" entries in "ext".
*/
int tbldiff (state, pr, ext)
int state[], pr, ext[];
int tbldiff (int state[], int pr, int ext[])
{
int i, *sp = state, *ep = ext, *protp;
int numdiff = 0;

0
contrib/flex/version.h → contrib/flex/src/version.h
View File

29
contrib/flex/yylex.c → contrib/flex/src/yylex.c
View File

@ -37,18 +37,20 @@
/* yylex - scan for a regular expression token */
int yylex ()
extern char *yytext;
extern FILE *yyout;
extern int yylval;
bool no_section3_escape = false;
int yylex (void)
{
int toktype;
static int beglin = false;
extern char *yytext;
if (eofseen)
if (eofseen) {
toktype = EOF;
else
} else {
toktype = flexscan ();
}
if (toktype == EOF || toktype == 0) {
eofseen = 1;
@ -150,11 +152,12 @@ int yylex ()
break;
default:
if (!isascii (yylval) || !isprint (yylval))
fprintf (stderr,
"\\%.3o",
(unsigned int) yylval);
if (!isascii (yylval) || !isprint (yylval)) {
if(trace_hex)
fprintf (stderr, "\\x%02x", (unsigned int) yylval);
else
fprintf (stderr, "\\%.3o", (unsigned int) yylval);
} else
(void) putc (yylval, stderr);
break;
}
@ -173,12 +176,12 @@ int yylex ()
fprintf (stderr, "<<EOF>>");
break;
case OPTION_OP:
case TOK_OPTION:
fprintf (stderr, "%s ", yytext);
break;
case OPT_OUTFILE:
case OPT_PREFIX:
case TOK_OUTFILE:
case TOK_PREFIX:
case CCE_ALNUM:
case CCE_ALPHA:
case CCE_BLANK:

8
usr.bin/lex/Makefile
View File

@ -14,7 +14,7 @@ LINKS+= ${BINDIR}/lex ${BINDIR}/lex++
LINKS+= ${BINDIR}/lex ${BINDIR}/flex
LINKS+= ${BINDIR}/lex ${BINDIR}/flex++
FLEXDIR= ${SRCTOP}/contrib/flex
FLEXDIR= ${SRCTOP}/contrib/flex/src
.PATH: ${FLEXDIR}
@ -42,11 +42,7 @@ SUBDIR= lib
FLEX_VERSION= `awk -f ${.CURDIR}/version.awk ${.CURDIR}/config.h`
skel.c: config.h mkskel.sh flex.skl version.awk
sed 's/m4_/m4postproc_/g; s/m4preproc_/m4_/g' \
${FLEXDIR}/flex.skl | \
m4 -I${FLEXDIR} -P ${FLEX_VERSION} | \
sed 's/m4postproc_/m4_/g' | \
sh ${FLEXDIR}/mkskel.sh > ${.TARGET}
sh ${FLEXDIR}/mkskel.sh ${FLEXDIR} m4 ${FLEX_VERSION} > ${.TARGET}
bootstrap: ${GENFILES:S/^/init/g}
.for _f in ${GENFILES}

97
usr.bin/lex/config.h
View File

@ -1,5 +1,5 @@
/* config.h. Generated from conf.in by configure. */
/* conf.in. Generated from configure.in by autoheader. */
/* src/config.h. Generated from config.h.in by configure. */
/* src/config.h.in. Generated from configure.ac by autoheader. */
/* $FreeBSD$ */
/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
@ -21,27 +21,59 @@
*/
/* #undef HAVE_ALLOCA_H */
/* Define to 1 if you have the `available.' function. */
/* #undef HAVE_AVAILABLE_ */
/* Define to 1 if you have the `by' function. */
/* #undef HAVE_BY */
/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the
CoreFoundation framework. */
/* #undef HAVE_CFLOCALECOPYCURRENT */
/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in
the CoreFoundation framework. */
/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */
/* Define if the GNU dcgettext() function is already present or preinstalled.
*/
/* #undef HAVE_DCGETTEXT */
/* Define to 1 if you have the <dlfcn.h> header file. */
#define HAVE_DLFCN_H 1
/* Define to 1 if you have the `dnl' function. */
/* #undef HAVE_DNL */
/* Define to 1 if you have the `dup2' function. */
#define HAVE_DUP2 1
/* Define to 1 if you have the `enabled' function. */
/* #undef HAVE_ENABLED */
/* Define to 1 if you have the `fork' function. */
#define HAVE_FORK 1
/* Define to 1 if you have the `function.' function. */
/* #undef HAVE_FUNCTION_ */
/* Define if the GNU gettext() function is already present or preinstalled. */
/* #undef HAVE_GETTEXT */
/* Define if you have the iconv() function. */
/* Define to 1 if you have the `have' function. */
/* #undef HAVE_HAVE */
/* Define if you have the iconv() function and it works. */
/* #undef HAVE_ICONV */
/* Define to 1 if you have the `if' function. */
/* #undef HAVE_IF */
/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1
/* Define to 1 if you have the `isascii' function. */
#define HAVE_ISASCII 1
/* Define to 1 if you have the `is' function. */
/* #undef HAVE_IS */
/* Define to 1 if you have the <libintl.h> header file. */
/* #undef HAVE_LIBINTL_H */
@ -49,9 +81,6 @@
/* Define to 1 if you have the `m' library (-lm). */
#define HAVE_LIBM 1
/* pthread library */
#define HAVE_LIBPTHREAD 1
/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1
@ -63,7 +92,7 @@
#define HAVE_MALLOC 1
/* Define to 1 if you have the <malloc.h> header file. */
/* #undef HAVE_MALLOC_H */
#define HAVE_MALLOC_H 1
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
@ -71,9 +100,24 @@
/* Define to 1 if you have the `memset' function. */
#define HAVE_MEMSET 1
/* Define to 1 if you have the `Needed' function. */
/* #undef HAVE_NEEDED */
/* Define to 1 if you have the <netinet/in.h> header file. */
#define HAVE_NETINET_IN_H 1
/* Define to 1 if you have the `NLS' function. */
/* #undef HAVE_NLS */
/* Define to 1 if you have the `not' function. */
/* #undef HAVE_NOT */
/* Define to 1 if you have the `only' function. */
/* #undef HAVE_ONLY */
/* Define to 1 if you have the `OpenBSD' function. */
/* #undef HAVE_OPENBSD */
/* Define to 1 if you have the `pow' function. */
#define HAVE_POW 1
@ -84,30 +128,39 @@
and to 0 otherwise. */
#define HAVE_REALLOC 1
/* Define to 1 if you have the `reallocarray' function. */
#define HAVE_REALLOCARRAY 1
/* Define to 1 if you have the `regcomp' function. */
#define HAVE_REGCOMP 1
/* Define to 1 if you have the <regex.h> header file. */
#define HAVE_REGEX_H 1
/* Define to 1 if you have the `replacement' function. */
/* #undef HAVE_REPLACEMENT */
/* Define to 1 if you have the `setlocale' function. */
#define HAVE_SETLOCALE 1
/* Define to 1 if stdbool.h conforms to C99. */
#define HAVE_STDBOOL_H 1
/* Define to 1 if you have the <stddef.h> header file. */
#define HAVE_STDDEF_H 1
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the `strcasecmp' function. */
#define HAVE_STRCASECMP 1
/* Define to 1 if you have the `strchr' function. */
#define HAVE_STRCHR 1
/* Define to 1 if you have the `strdup' function. */
#define HAVE_STRDUP 1
/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1
@ -123,18 +176,24 @@
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */
/* Define to 1 if you have the <sys/wait.h> header file. */
#define HAVE_SYS_WAIT_H 1
/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
/* Define to 1 if you have the `Used' function. */
/* #undef HAVE_USED */
/* Define to 1 if you have the `vfork' function. */
#define HAVE_VFORK 1
/* Define to 1 if you have the <vfork.h> header file. */
/* #undef HAVE_VFORK_H */
/* Define to 1 if you have the `We' function. */
/* #undef HAVE_WE */
/* Define to 1 if `fork' works. */
#define HAVE_WORKING_FORK 1
@ -144,12 +203,12 @@
/* Define to 1 if the system has the type `_Bool'. */
#define HAVE__BOOL 1
/* Define to the sub-directory where libtool stores uninstalled libraries. */
#define LT_OBJDIR ".libs/"
/* Define to the m4 executable name. */
#define M4 "m4"
/* Define to 1 if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */
/* Name of package */
#define PACKAGE "flex"
@ -160,7 +219,7 @@
#define PACKAGE_NAME "the fast lexical analyser generator"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "the fast lexical analyser generator 2.5.37"
#define PACKAGE_STRING "the fast lexical analyser generator 2.6.4"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "flex"
@ -169,7 +228,7 @@
#define PACKAGE_URL ""
/* Define to the version of this package. */
#define PACKAGE_VERSION "2.5.37"
#define PACKAGE_VERSION "2.6.4"
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
@ -183,7 +242,7 @@
#define STDC_HEADERS 1
/* Version number of package */
#define VERSION "2.5.37"
#define VERSION "2.6.4"
/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a
`char[]'. */

396
usr.bin/lex/initparse.c
View File

File diff suppressed because it is too large Load Diff

14
usr.bin/lex/initparse.h
View File

@ -7,13 +7,13 @@
#define NAME 262
#define PREVCCL 263
#define EOF_OP 264
#define OPTION_OP 265
#define OPT_OUTFILE 266
#define OPT_PREFIX 267
#define OPT_YYCLASS 268
#define OPT_HEADER 269
#define OPT_EXTRA_TYPE 270
#define OPT_TABLES 271
#define TOK_OPTION 265
#define TOK_OUTFILE 266
#define TOK_PREFIX 267
#define TOK_YYCLASS 268
#define TOK_HEADER_FILE 269
#define TOK_EXTRA_TYPE 270
#define TOK_TABLES_FILE 271
#define CCE_ALNUM 272
#define CCE_ALPHA 273
#define CCE_BLANK 274

4282
usr.bin/lex/initscan.c
View File

File diff suppressed because it is too large Load Diff

1267
usr.bin/lex/initskel.c
View File

File diff suppressed because it is too large Load Diff

2
usr.bin/lex/lex.1
View File

@ -1,6 +1,6 @@
.\" $FreeBSD$
.\"
.TH FLEX 1 "May 21, 2013" "Version 2.5.37"
.TH FLEX 1 "May 6, 2017" "Version 2.6.4"
.SH NAME
flex, lex \- fast lexical analyzer generator
.SH SYNOPSIS

2
usr.bin/lex/lib/Makefile
View File

@ -2,7 +2,7 @@
.include <src.opts.mk>
.PATH: ${SRCTOP}/contrib/flex
.PATH: ${SRCTOP}/contrib/flex/src
LIB= ln
SRCS= libmain.c libyywrap.c

4
usr.bin/lex/version.awk
View File

@ -6,8 +6,6 @@ BEGIN {
{
if ($1 ~ /^#define$/ && $2 ~ /^VERSION$/) {
printf("-DFLEX_MAJOR_VERSION=%s\n", $3);
printf("-DFLEX_MINOR_VERSION=%s\n", $4);
printf("-DFLEX_SUBMINOR_VERSION=%s\n", $5);
printf("%s.%s.%s\n", $3, $4, $5);
}
}