lili/qt5
1
0
Fork 0
mirror of git://code.qt.io/qt/qt5.git synced 2026-04-18 02:56:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove gnuwin32 - it is provided through provisioning

Browse Source 
Having a few windows specific tools in qt5.git was always strange. We
now provision the utilities to the machines, so remove them from
qt5.git.

[ChangeLog][General] GnuWin32 is no longer part of the Qt source code repositories.
Instead it can be downloaded from the upstream project at https://gnuwin32.sourceforge.net .
For convenience we also make a copy available here:
https://download.qt.io/development_releases/gnuwin32/gnuwin32.zip
The GnuWin32 tools are needed for building Qt from source on Windows.
Binary package downloads are not affected.

Task-number: QTBUG-73424
Change-Id: I9212cc2923343f4f84bcba9d1444a90e446dfb8a
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
Reviewed-by: Liang Qi <liang.qi@qt.io>
This commit is contained in:
Frederik Gladhorn
2019-06-24 16:01:42 +02:00
parent accc0af6e4
commit f963556794
165 changed files with 0 additions and 27761 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
gnuwin32/README
View File

@@ -1,9 +0,0 @@
This directory contains the Windows binaries of various tools such as bison
from the GnuWin32 project (http://gnuwin32.sourceforge.net/). We've put them
here for your convenience, as they are needed to build projects such as
QtWebKit.
Aside from GnuWin32 binaries this directory also contains a distribution of Win
flex-bison project (http://sourceforge.net/projects/winflexbison/), which provides
much newer ports of Flex and Bison than what GnuWin32 provides.

BIN
gnuwin32/bin/bison.exe
View File

Binary file not shown.

70
gnuwin32/bin/data/README
View File

@@ -1,70 +0,0 @@
-*- outline -*-
This directory contains data needed by Bison.
* Skeletons
Bison skeletons: the general shapes of the different parser kinds,
that are specialized for specific grammars by the bison program.
Currently, the supported skeletons are:
- yacc.c
It used to be named bison.simple: it corresponds to C Yacc
compatible LALR(1) parsers.
- lalr1.cc
Produces a C++ parser class.
- lalr1.java
Produces a Java parser class.
- glr.c
A Generalized LR C parser based on Bison's LALR(1) tables.
- glr.cc
A Generalized LR C++ parser. Actually a C++ wrapper around glr.c.
These skeletons are the only ones supported by the Bison team.
Because the interface between skeletons and the bison program is not
finished, *we are not bound to it*. In particular, Bison is not
mature enough for us to consider that "foreign skeletons" are
supported.
* m4sugar
This directory contains M4sugar, sort of an extended library for M4,
which is used by Bison to instantiate the skeletons.
* xslt
This directory contains XSLT programs that transform Bison's XML output
into various formats.
- bison.xsl
A library of routines used by the other XSLT programs.
- xml2dot.xsl
Conversion into GraphViz's dot format.
- xml2text.xsl
Conversion into text.
- xml2xhtml.xsl
Conversion into XHTML.
-----
Copyright (C) 2002, 2008-2013 Free Software Foundation, Inc.
This file is part of GNU Bison.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

1063
gnuwin32/bin/data/bison.m4
View File

File diff suppressed because it is too large Load Diff

26
gnuwin32/bin/data/c++-skel.m4
View File

@@ -1,26 +0,0 @@
-*- Autoconf -*-
# C++ skeleton dispatching for Bison.
# Copyright (C) 2006-2007, 2009-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
b4_glr_if( [m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.cc]])])
b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.cc]])])
m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[lalr1.cc]])
m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"])
m4_include(b4_used_skeleton)

544
gnuwin32/bin/data/c++.m4
View File

@@ -1,544 +0,0 @@
-*- Autoconf -*-
# C++ skeleton for Bison
# Copyright (C) 2002-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
m4_include(b4_pkgdatadir/[c.m4])
# b4_comment(TEXT, [PREFIX])
# --------------------------
# Put TEXT in comment. Prefix all the output lines with PREFIX.
m4_define([b4_comment],
[b4_comment_([$1], [$2// ], [$2// ])])
## -------- ##
## Checks. ##
## -------- ##
b4_percent_define_check_kind([api.namespace], [code], [deprecated])
b4_percent_define_check_kind([parser_class_name], [code], [deprecated])
## ---------------- ##
## Default values. ##
## ---------------- ##
b4_percent_define_default([[parser_class_name]], [[parser]])
# Don't do that so that we remember whether we're using a user
# request, or the default value.
#
# b4_percent_define_default([[api.location.type]], [[location]])
b4_percent_define_default([[filename_type]], [[std::string]])
# Make it a warning for those who used betas of Bison 3.0.
b4_percent_define_default([[api.namespace]], m4_defn([b4_prefix]))
b4_percent_define_default([[global_tokens_and_yystype]], [[false]])
b4_percent_define_default([[define_location_comparison]],
[m4_if(b4_percent_define_get([[filename_type]]),
[std::string], [[true]], [[false]])])
## ----------- ##
## Namespace. ##
## ----------- ##
m4_define([b4_namespace_ref], [b4_percent_define_get([[api.namespace]])])
# Don't permit an empty b4_namespace_ref. Any '::parser::foo' appended to it
# would compile as an absolute reference with 'parser' in the global namespace.
# b4_namespace_open would open an anonymous namespace and thus establish
# internal linkage. This would compile. However, it's cryptic, and internal
# linkage for the parser would be specified in all translation units that
# include the header, which is always generated. If we ever need to permit
# internal linkage somehow, surely we can find a cleaner approach.
m4_if(m4_bregexp(b4_namespace_ref, [^[ ]*$]), [-1], [],
[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
[[namespace reference is empty]])])
# Instead of assuming the C++ compiler will do it, Bison should reject any
# invalid b4_namepsace_ref that would be converted to a valid
# b4_namespace_open. The problem is that Bison doesn't always output
# b4_namespace_ref to uncommented code but should reserve the ability to do so
# in future releases without risking breaking any existing user grammars.
# Specifically, don't allow empty names as b4_namespace_open would just convert
# those into anonymous namespaces, and that might tempt some users.
m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*::]), [-1], [],
[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
[[namespace reference has consecutive "::"]])])
m4_if(m4_bregexp(b4_namespace_ref, [::[ ]*$]), [-1], [],
[b4_complain_at(b4_percent_define_get_loc([[api.namespace]]),
[[namespace reference has a trailing "::"]])])
m4_define([b4_namespace_open],
[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
[namespace ]m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref),
[^\(.\)[ ]*::], [\1])),
[::], [ { namespace ])[ {]])])
m4_define([b4_namespace_close],
[b4_user_code([b4_percent_define_get_syncline([[api.namespace]])
m4_bpatsubst(m4_dquote(m4_bpatsubst(m4_dquote(b4_namespace_ref[ ]),
[^\(.\)[ ]*\(::\)?\([^][:]\|:[^:]\)*],
[\1])),
[::\([^][:]\|:[^:]\)*], [} ])[} // ]b4_namespace_ref])])
# b4_token_enums
# --------------
# Output the definition of the tokens as enums.
m4_define([b4_token_enums],
[[enum yytokentype
{
]m4_join([,
],
b4_symbol_map([b4_token_enum]))[
};]dnl
])
## ----------------- ##
## Semantic Values. ##
## ----------------- ##
# b4_value_type_declare
# ---------------------
# Declare semantic_type.
m4_define([b4_value_type_declare],
[b4_value_type_setup[]dnl
[ /// Symbol semantic values.
]m4_bmatch(b4_percent_define_get_kind([[api.value.type]]),
[code],
[[ typedef ]b4_percent_define_get([[api.value.type]])[ semantic_type;]],
[m4_bmatch(b4_percent_define_get([[api.value.type]]),
[union\|union-directive],
[[ union semantic_type
{
]b4_user_union_members[
};]])])dnl
])
# b4_public_types_declare
# -----------------------
# Define the public types: token, semantic value, location, and so forth.
# Depending on %define token_lex, may be output in the header or source file.
m4_define([b4_public_types_declare],
[[#ifndef ]b4_api_PREFIX[STYPE
]b4_value_type_declare[
#else
typedef ]b4_api_PREFIX[STYPE semantic_type;
#endif]b4_locations_if([
/// Symbol locations.
typedef b4_percent_define_get([[api.location.type]],
[[location]]) location_type;])[
/// Syntax errors thrown from user actions.
struct syntax_error : std::runtime_error
{
syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m);]b4_locations_if([
location_type location;])[
};
/// Tokens.
struct token
{
]b4_token_enums[
};
/// (External) token type, as returned by yylex.
typedef token::yytokentype token_type;
/// Internal symbol number.
typedef int symbol_number_type;
/// Internal symbol number for tokens (subsumed by symbol_number_type).
typedef ]b4_int_type_for([b4_translate])[ token_number_type;
/// A complete symbol.
///
/// Expects its Base type to provide access to the symbol type
/// via type_get().
///
/// Provide access to semantic value]b4_locations_if([ and location])[.
template <typename Base>
struct basic_symbol : Base
{
/// Alias to Base.
typedef Base super_type;
/// Default constructor.
basic_symbol ();
/// Copy constructor.
basic_symbol (const basic_symbol& other);
]b4_variant_if([[
/// Constructor for valueless symbols, and symbols from each type.
]b4_type_foreach([b4_basic_symbol_constructor_declare])], [[
/// Constructor for valueless symbols.
basic_symbol (typename Base::kind_type t]b4_locations_if([,
const location_type& l])[);]])[
/// Constructor for symbols with semantic value.
basic_symbol (typename Base::kind_type t,
const semantic_type& v]b4_locations_if([,
const location_type& l])[);
~basic_symbol ();
/// Destructive move, \a s is emptied into this.
void move (basic_symbol& s);
/// The semantic value.
semantic_type value;]b4_locations_if([
/// The location.
location_type location;])[
private:
/// Assignment operator.
basic_symbol& operator= (const basic_symbol& other);
};
/// Type access provider for token (enum) based symbols.
struct by_type
{
/// Default constructor.
by_type ();
/// Copy constructor.
by_type (const by_type& other);
/// The symbol type as needed by the constructor.
typedef token_type kind_type;
/// Constructor from (external) token numbers.
by_type (kind_type t);
/// Steal the symbol type from \a that.
void move (by_type& that);
/// The (internal) type number (corresponding to \a type).
/// -1 when this symbol is empty.
symbol_number_type type_get () const;
/// The token.
token_type token () const;
enum { empty = 0 };
/// The symbol type.
/// -1 when this symbol is empty.
token_number_type type;
};
/// "External" symbols: returned by the scanner.
typedef basic_symbol<by_type> symbol_type;
]b4_symbol_constructor_declare])
# b4_public_types_define
# ----------------------
# Provide the implementation needed by the public types.
m4_define([b4_public_types_define],
[[ inline
]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
: std::runtime_error (m)]b4_locations_if([
, location (l)])[
{}
// basic_symbol.
template <typename Base>
inline
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
: value ()
{}
template <typename Base>
inline
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
: Base (other)
, value ()]b4_locations_if([
, location (other.location)])[
{
]b4_variant_if([b4_symbol_variant([other.type_get ()], [value], [copy],
[other.value])],
[value = other.value;])[
}
template <typename Base>
inline
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
[typename Base::kind_type t],
[const semantic_type& v],
b4_locations_if([const location_type& l]))[)
: Base (t)
, value (]b4_variant_if([], [v])[)]b4_locations_if([
, location (l)])[
{]b4_variant_if([[
(void) v;
]b4_symbol_variant([this->type_get ()], [value], [copy], [v])])[}
]b4_variant_if([[
// Implementation of basic_symbol constructor for each type.
]b4_type_foreach([b4_basic_symbol_constructor_define])], [[
/// Constructor for valueless symbols.
template <typename Base>
inline
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
[typename Base::kind_type t],
b4_locations_if([const location_type& l]))[)
: Base (t)
, value ()]b4_locations_if([
, location (l)])[
{}]])[
template <typename Base>
inline
]b4_parser_class_name[::basic_symbol<Base>::~basic_symbol ()
{]b4_variant_if([[
// User destructor.
symbol_number_type yytype = this->type_get ();
switch (yytype)
{
]b4_symbol_foreach([b4_symbol_destructor])dnl
[ default:
break;
}
// Type destructor.
]b4_symbol_variant([[yytype]], [[value]], [[template destroy]])])[
}
template <typename Base>
inline
void
]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
{
super_type::move(s);
]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [move],
[s.value])],
[value = s.value;])[]b4_locations_if([
location = s.location;])[
}
// by_type.
inline
]b4_parser_class_name[::by_type::by_type ()
: type (empty)
{}
inline
]b4_parser_class_name[::by_type::by_type (const by_type& other)
: type (other.type)
{}
inline
]b4_parser_class_name[::by_type::by_type (token_type t)
: type (yytranslate_ (t))
{}
inline
void
]b4_parser_class_name[::by_type::move (by_type& that)
{
type = that.type;
that.type = empty;
}
inline
int
]b4_parser_class_name[::by_type::type_get () const
{
return type;
}
]b4_token_ctor_if([[
inline
]b4_parser_class_name[::token_type
]b4_parser_class_name[::by_type::token () const
{
// YYTOKNUM[NUM] -- (External) token number corresponding to the
// (internal) symbol number NUM (which must be that of a token). */
static
const ]b4_int_type_for([b4_toknum])[
yytoken_number_[] =
{
]b4_toknum[
};
return static_cast<token_type> (yytoken_number_[type]);
}
]])[]dnl
b4_symbol_constructor_define])
# b4_symbol_constructor_declare
# b4_symbol_constructor_define
# -----------------------------
# Declare/define symbol constructors for all the value types.
# Use at class-level. Redefined in variant.hh.
m4_define([b4_symbol_constructor_declare], [])
m4_define([b4_symbol_constructor_define], [])
# b4_yytranslate_define
# ---------------------
# Define yytranslate_. Sometimes used in the header file,
# sometimes in the cc file.
m4_define([b4_yytranslate_define],
[[ // Symbol number corresponding to token number t.
inline
]b4_parser_class_name[::token_number_type
]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type],
[int])[ t)
{
static
const token_number_type
translate_table[] =
{
]b4_translate[
};
const unsigned int user_token_number_max_ = ]b4_user_token_number_max[;
const token_number_type undef_token_ = ]b4_undef_token_number[;
if (static_cast<int>(t) <= yyeof_)
return yyeof_;
else if (static_cast<unsigned int> (t) <= user_token_number_max_)
return translate_table[t];
else
return undef_token_;
}
]])
# b4_lhs_value([TYPE])
# --------------------
# Expansion of $<TYPE>$.
m4_define([b4_lhs_value],
[b4_symbol_value([yyval], [$1])])
# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
# --------------------------------------
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
# symbols on RHS.
m4_define([b4_rhs_value],
[b4_symbol_value([yysemantic_stack_@{($1) - ($2)@}], [$3])])
# b4_lhs_location()
# -----------------
# Expansion of @$.
m4_define([b4_lhs_location],
[(yyloc)])
# b4_rhs_location(RULE-LENGTH, NUM)
# ---------------------------------
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
# on RHS.
m4_define([b4_rhs_location],
[(yylocation_stack_@{($1) - ($2)@})])
# b4_parse_param_decl
# -------------------
# Extra formal arguments of the constructor.
# Change the parameter names from "foo" into "foo_yyarg", so that
# there is no collision bw the user chosen attribute name, and the
# argument name in the constructor.
m4_define([b4_parse_param_decl],
[m4_ifset([b4_parse_param],
[m4_map_sep([b4_parse_param_decl_1], [, ], [b4_parse_param])])])
m4_define([b4_parse_param_decl_1],
[$1_yyarg])
# b4_parse_param_cons
# -------------------
# Extra initialisations of the constructor.
m4_define([b4_parse_param_cons],
[m4_ifset([b4_parse_param],
[
b4_cc_constructor_calls(b4_parse_param)])])
m4_define([b4_cc_constructor_calls],
[m4_map_sep([b4_cc_constructor_call], [,
], [$@])])
m4_define([b4_cc_constructor_call],
[$2 ($2_yyarg)])
# b4_parse_param_vars
# -------------------
# Extra instance variables.
m4_define([b4_parse_param_vars],
[m4_ifset([b4_parse_param],
[
// User arguments.
b4_cc_var_decls(b4_parse_param)])])
m4_define([b4_cc_var_decls],
[m4_map_sep([b4_cc_var_decl], [
], [$@])])
m4_define([b4_cc_var_decl],
[ $1;])
## ---------##
## Values. ##
## ---------##
# b4_yylloc_default_define
# ------------------------
# Define YYLLOC_DEFAULT.
m4_define([b4_yylloc_default_define],
[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
If N is 0, then set CURRENT to the empty location which ends
the previous symbol: RHS[0] (always defined). */
# ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (N) \
{ \
(Current).begin = YYRHSLOC (Rhs, 1).begin; \
(Current).end = YYRHSLOC (Rhs, N).end; \
} \
else \
{ \
(Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \
} \
while (/*CONSTCOND*/ false)
# endif
]])
## -------- ##
## Checks. ##
## -------- ##
b4_token_ctor_if([b4_variant_if([],
[b4_fatal_at(b4_percent_define_get_loc(api.token.constructor),
[cannot use '%s' without '%s'],
[%define api.token.constructor],
[%define api.value.type variant]))])])

65
gnuwin32/bin/data/c-like.m4
View File

@@ -1,65 +0,0 @@
-*- Autoconf -*-
# Common code for C-like languages (C, C++, Java, etc.)
# Copyright (C) 2012-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# b4_comment_(TEXT, OPEN, CONTINUE, END)
# --------------------------------------
# Put TEXT in comment. Avoid trailing spaces: don't indent empty lines.
# Avoid adding indentation to the first line, as the indentation comes
# from OPEN. That's why we don't patsubst([$1], [^\(.\)], [ \1]).
#
# Prefix all the output lines with PREFIX.
m4_define([b4_comment_],
[$2[]m4_bpatsubst(m4_expand([[$1]]), [
\(.\)], [
$3\1])$4])
# b4_comment(TEXT, [PREFIX])
# --------------------------
# Put TEXT in comment. Prefix all the output lines with PREFIX.
m4_define([b4_comment],
[b4_comment_([$1], [$2/* ], [$2 ], [ */])])
# b4_dollar_dollar_(VALUE, FIELD, DEFAULT-FIELD)
# ----------------------------------------------
# If FIELD (or DEFAULT-FIELD) is non-null, return "VALUE.FIELD",
# otherwise just VALUE. Be sure to pass "(VALUE)" is VALUE is a
# pointer.
m4_define([b4_dollar_dollar_],
[b4_symbol_value([$1],
m4_if([$2], [[]],
[[$3]], [[$2]]))])
# b4_dollar_pushdef(VALUE-POINTER, DEFAULT-FIELD, LOCATION)
# b4_dollar_popdef
# ---------------------------------------------------------
# Define b4_dollar_dollar for VALUE and DEFAULT-FIELD,
# and b4_at_dollar for LOCATION.
m4_define([b4_dollar_pushdef],
[m4_pushdef([b4_dollar_dollar],
[b4_dollar_dollar_([$1], m4_dquote($][1), [$2])])dnl
m4_pushdef([b4_at_dollar], [$3])dnl
])
m4_define([b4_dollar_popdef],
[m4_popdef([b4_at_dollar])dnl
m4_popdef([b4_dollar_dollar])dnl
])

26
gnuwin32/bin/data/c-skel.m4
View File

@@ -1,26 +0,0 @@
-*- Autoconf -*-
# C skeleton dispatching for Bison.
# Copyright (C) 2006-2007, 2009-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
b4_glr_if( [m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.c]])])
b4_nondeterministic_if([m4_define([b4_used_skeleton], [b4_pkgdatadir/[glr.c]])])
m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[yacc.c]])
m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"])
m4_include(b4_used_skeleton)

839
gnuwin32/bin/data/c.m4
View File

@@ -1,839 +0,0 @@
-*- Autoconf -*-
# C M4 Macros for Bison.
# Copyright (C) 2002, 2004-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
m4_include(b4_pkgdatadir/[c-like.m4])
# b4_tocpp(STRING)
# ----------------
# Convert STRING into a valid C macro name.
m4_define([b4_tocpp],
[m4_toupper(m4_bpatsubst(m4_quote($1), [[^a-zA-Z0-9]+], [_]))])
# b4_cpp_guard(FILE)
# ------------------
# A valid C macro name to use as a CPP header guard for FILE.
m4_define([b4_cpp_guard],
[[YY_]b4_tocpp(m4_defn([b4_prefix])/[$1])[_INCLUDED]])
# b4_cpp_guard_open(FILE)
# b4_cpp_guard_close(FILE)
# ------------------------
# If FILE does not expand to nothing, open/close CPP inclusion guards for FILE.
m4_define([b4_cpp_guard_open],
[m4_ifval(m4_quote($1),
[#ifndef b4_cpp_guard([$1])
# define b4_cpp_guard([$1])])])
m4_define([b4_cpp_guard_close],
[m4_ifval(m4_quote($1),
[#endif b4_comment([!b4_cpp_guard([$1])])])])
## ---------------- ##
## Identification. ##
## ---------------- ##
# b4_identification
# -----------------
# Depends on individual skeletons to define b4_pure_flag, b4_push_flag, or
# b4_pull_flag if they use the values of the %define variables api.pure or
# api.push-pull.
m4_define([b4_identification],
[[/* Identify Bison output. */
#define YYBISON 1
/* Bison version. */
#define YYBISON_VERSION "]b4_version["
/* Skeleton name. */
#define YYSKELETON_NAME ]b4_skeleton[]m4_ifdef([b4_pure_flag], [[
/* Pure parsers. */
#define YYPURE ]b4_pure_flag])[]m4_ifdef([b4_push_flag], [[
/* Push parsers. */
#define YYPUSH ]b4_push_flag])[]m4_ifdef([b4_pull_flag], [[
/* Pull parsers. */
#define YYPULL ]b4_pull_flag])[
]])
## ---------------- ##
## Default values. ##
## ---------------- ##
# b4_api_prefix, b4_api_PREFIX
# ----------------------------
# Corresponds to %define api.prefix
b4_percent_define_default([[api.prefix]], [[yy]])
m4_define([b4_api_prefix],
[b4_percent_define_get([[api.prefix]])])
m4_define([b4_api_PREFIX],
[m4_toupper(b4_api_prefix)])
# b4_prefix
# ---------
# If the %name-prefix is not given, it is api.prefix.
m4_define_default([b4_prefix], [b4_api_prefix])
# If the %union is not named, its name is YYSTYPE.
m4_define_default([b4_union_name], [b4_api_PREFIX[]STYPE])
## ------------------------ ##
## Pure/impure interfaces. ##
## ------------------------ ##
# b4_lex_formals
# --------------
# All the yylex formal arguments.
# b4_lex_param arrives quoted twice, but we want to keep only one level.
m4_define([b4_lex_formals],
[b4_pure_if([[[[YYSTYPE *yylvalp]], [[&yylval]]][]dnl
b4_locations_if([, [[YYLTYPE *yyllocp], [&yylloc]]])])dnl
m4_ifdef([b4_lex_param], [, ]b4_lex_param)])
# b4_lex
# ------
# Call yylex.
m4_define([b4_lex],
[b4_function_call([yylex], [int], b4_lex_formals)])
# b4_user_args
# ------------
m4_define([b4_user_args],
[m4_ifset([b4_parse_param], [, b4_args(b4_parse_param)])])
# b4_parse_param
# --------------
# If defined, b4_parse_param arrives double quoted, but below we prefer
# it to be single quoted.
m4_define([b4_parse_param],
b4_parse_param)
# b4_parse_param_for(DECL, FORMAL, BODY)
# ---------------------------------------
# Iterate over the user parameters, binding the declaration to DECL,
# the formal name to FORMAL, and evaluating the BODY.
m4_define([b4_parse_param_for],
[m4_foreach([$1_$2], m4_defn([b4_parse_param]),
[m4_pushdef([$1], m4_unquote(m4_car($1_$2)))dnl
m4_pushdef([$2], m4_shift($1_$2))dnl
$3[]dnl
m4_popdef([$2])dnl
m4_popdef([$1])dnl
])])
# b4_parse_param_use([VAL], [LOC])
# --------------------------------
# 'YYUSE' VAL, LOC if locations are enabled, and all the parse-params.
m4_define([b4_parse_param_use],
[m4_ifvaln([$1], [ YYUSE ([$1]);])dnl
b4_locations_if([m4_ifvaln([$2], [ YYUSE ([$2]);])])dnl
b4_parse_param_for([Decl], [Formal], [ YYUSE (Formal);
])dnl
])
## ------------ ##
## Data Types. ##
## ------------ ##
# b4_int_type(MIN, MAX)
# ---------------------
# Return the smallest int type able to handle numbers ranging from
# MIN to MAX (included).
m4_define([b4_int_type],
[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
b4_ints_in($@, [-128], [127]), [1], [signed char],
b4_ints_in($@, [0], [65535]), [1], [unsigned short int],
b4_ints_in($@, [-32768], [32767]), [1], [short int],
m4_eval([0 <= $1]), [1], [unsigned int],
[int])])
# b4_int_type_for(NAME)
# ---------------------
# Return the smallest int type able to handle numbers ranging from
# 'NAME_min' to 'NAME_max' (included).
m4_define([b4_int_type_for],
[b4_int_type($1_min, $1_max)])
# b4_table_value_equals(TABLE, VALUE, LITERAL)
# --------------------------------------------
# Without inducing a comparison warning from the compiler, check if the
# literal value LITERAL equals VALUE from table TABLE, which must have
# TABLE_min and TABLE_max defined.
m4_define([b4_table_value_equals],
[m4_if(m4_eval($3 < m4_indir([b4_]$1[_min])
|| m4_indir([b4_]$1[_max]) < $3), [1],
[[0]],
[(!!(($2) == ($3)))])])
## ----------------- ##
## Compiler issues. ##
## ----------------- ##
# b4_attribute_define
# -------------------
# Provide portability for __attribute__.
m4_define([b4_attribute_define],
[#ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later. */
# if (! defined __GNUC__ || __GNUC__ < 2 \
|| (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
# define __attribute__(Spec) /* empty */
# endif
#endif
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif
#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
_Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
])
## ---------##
## Values. ##
## ---------##
# b4_null_define
# --------------
# Portability issues: define a YY_NULL appropriate for the current
# language (C, C++98, or C++11).
m4_define([b4_null_define],
[# ifndef YY_NULL
# if defined __cplusplus && 201103L <= __cplusplus
# define YY_NULL nullptr
# else
# define YY_NULL 0
# endif
# endif[]dnl
])
# b4_null
# -------
# Return a null pointer constant.
m4_define([b4_null], [YY_NULL])
# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
# -------------------------------------------------------------
# Define "yy<TABLE-NAME>" whose contents is CONTENT.
m4_define([b4_integral_parser_table_define],
[m4_ifvaln([$3], [b4_comment([$3], [ ])])dnl
static const b4_int_type_for([$2]) yy$1[[]] =
{
$2
};dnl
])
## ------------------------- ##
## Assigning token numbers. ##
## ------------------------- ##
# b4_token_define(TOKEN-NUM)
# --------------------------
# Output the definition of this token as #define.
m4_define([b4_token_define],
[b4_token_format([#define %s %s], [$1])])
# b4_token_defines
# ----------------
# Output the definition of the tokens.
m4_define([b4_token_defines],
[b4_any_token_visible_if([/* Tokens. */
m4_join([
], b4_symbol_map([b4_token_define]))
])])
# b4_token_enum(TOKEN-NUM)
# ------------------------
# Output the definition of this token as an enum.
m4_define([b4_token_enum],
[b4_token_format([%s = %s], [$1])])
# b4_token_enums
# --------------
# Output the definition of the tokens (if there are) as enums.
m4_define([b4_token_enums],
[b4_any_token_visible_if([[/* Token type. */
#ifndef ]b4_api_PREFIX[TOKENTYPE
# define ]b4_api_PREFIX[TOKENTYPE
enum ]b4_api_prefix[tokentype
{
]m4_join([,
],
b4_symbol_map([b4_token_enum]))[
};
#endif
]])])
# b4_token_enums_defines
# ----------------------
# Output the definition of the tokens (if there are any) as enums and,
# if POSIX Yacc is enabled, as #defines.
m4_define([b4_token_enums_defines],
[b4_token_enums[]b4_yacc_if([b4_token_defines])])
## ----------------- ##
## Semantic Values. ##
## ----------------- ##
# b4_symbol_value(VAL, [TYPE])
# ----------------------------
# Given a semantic value VAL ($$, $1 etc.), extract its value of type
# TYPE if TYPE is given, otherwise just return VAL. The result can be
# used safetly, it is put in parens to avoid nasty precedence issues.
# TYPE is *not* put in braces, provide some if needed.
m4_define([b4_symbol_value],
[($1[]m4_ifval([$2], [.$2]))])
## ---------------------- ##
## Defining C functions. ##
## ---------------------- ##
# b4_function_define(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
# -----------------------------------------------------------
# Declare the function NAME in C.
m4_define([b4_function_define],
[$2
$1 (b4_formals(m4_shift2($@)))[]dnl
])
# b4_formals([DECL1, NAME1], ...)
# -------------------------------
# The formal arguments of a C function definition.
m4_define([b4_formals],
[m4_if([$#], [0], [void],
[$#$1], [1], [void],
[m4_map_sep([b4_formal], [, ], [$@])])])
m4_define([b4_formal],
[$1])
## ----------------------- ##
## Declaring C functions. ##
## ----------------------- ##
# b4_function_declare(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
# ------------------------------------------------------------
# Declare the function NAME.
m4_define([b4_function_declare],
[$2 $1 (b4_formals(m4_shift2($@)));[]dnl
])
## --------------------- ##
## Calling C functions. ##
## --------------------- ##
# b4_function_call(NAME, RETURN-VALUE, [DECL1, NAME1], ...)
# -----------------------------------------------------------
# Call the function NAME with arguments NAME1, NAME2 etc.
m4_define([b4_function_call],
[$1 (b4_args(m4_shift2($@)))[]dnl
])
# b4_args([DECL1, NAME1], ...)
# ----------------------------
# Output the arguments NAME1, NAME2...
m4_define([b4_args],
[m4_map_sep([b4_arg], [, ], [$@])])
m4_define([b4_arg],
[$2])
## ----------- ##
## Synclines. ##
## ----------- ##
# b4_sync_start(LINE, FILE)
# -------------------------
m4_define([b4_sync_start], [[#]line $1 $2])
## -------------- ##
## User actions. ##
## -------------- ##
# b4_case(LABEL, STATEMENTS)
# --------------------------
m4_define([b4_case],
[ case $1:
$2
b4_syncline([@oline@], [@ofile@])
break;])
# b4_predicate_case(LABEL, CONDITIONS)
# ------------------------------------
m4_define([b4_predicate_case],
[ case $1:
if (! ($2)) YYERROR;
b4_syncline([@oline@], [@ofile@])
break;])
# b4_yydestruct_define
# --------------------
# Define the "yydestruct" function.
m4_define_default([b4_yydestruct_define],
[[/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
]b4_function_define([yydestruct],
[static void],
[[const char *yymsg], [yymsg]],
[[int yytype], [yytype]],
[[YYSTYPE *yyvaluep], [yyvaluep]][]dnl
b4_locations_if( [, [[YYLTYPE *yylocationp], [yylocationp]]])[]dnl
m4_ifset([b4_parse_param], [, b4_parse_param]))[
{
]b4_parse_param_use([yyvaluep], [yylocationp])dnl
[ if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
]b4_symbol_actions([destructor])[
YY_IGNORE_MAYBE_UNINITIALIZED_END
}]dnl
])
# b4_yy_symbol_print_define
# -------------------------
# Define the "yy_symbol_print" function.
m4_define_default([b4_yy_symbol_print_define],
[[
/*----------------------------------------.
| Print this symbol's value on YYOUTPUT. |
`----------------------------------------*/
]b4_function_define([yy_symbol_value_print],
[static void],
[[FILE *yyoutput], [yyoutput]],
[[int yytype], [yytype]],
[[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl
b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
m4_ifset([b4_parse_param], [, b4_parse_param]))[
{
FILE *yyo = yyoutput;
]b4_parse_param_use([yyo], [yylocationp])dnl
[ if (!yyvaluep)
return;]
dnl glr.c does not feature yytoknum.
m4_if(b4_skeleton, ["yacc.c"],
[[# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# endif
]])dnl
b4_symbol_actions([printer])[
}
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
]b4_function_define([yy_symbol_print],
[static void],
[[FILE *yyoutput], [yyoutput]],
[[int yytype], [yytype]],
[[YYSTYPE const * const yyvaluep], [yyvaluep]][]dnl
b4_locations_if([, [[YYLTYPE const * const yylocationp], [yylocationp]]])[]dnl
m4_ifset([b4_parse_param], [, b4_parse_param]))[
{
YYFPRINTF (yyoutput, "%s %s (",
yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
]b4_locations_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp);
YYFPRINTF (yyoutput, ": ");
])dnl
[ yy_symbol_value_print (yyoutput, yytype, yyvaluep]dnl
b4_locations_if([, yylocationp])[]b4_user_args[);
YYFPRINTF (yyoutput, ")");
}]dnl
])
## ---------------- ##
## api.value.type. ##
## ---------------- ##
# ---------------------- #
# api.value.type=union. #
# ---------------------- #
# b4_symbol_type_register(SYMBOL-NUM)
# -----------------------------------
# Symbol SYMBOL-NUM has a type (for variant) instead of a type-tag.
# Extend the definition of %union's body with a field of that type,
# and extend the symbol's "type" field to point to the field name,
# instead of the type name.
m4_define([b4_symbol_type_register],
[m4_define([b4_symbol($1, type_tag)],
[b4_symbol_if([$1], [has_id],
[b4_symbol([$1], [id])],
[yytype_[]b4_symbol([$1], [number])])])dnl
m4_append([b4_user_union_members],
m4_expand([
b4_symbol_tag_comment([$1])dnl
b4_symbol([$1], [type]) b4_symbol([$1], [type_tag]);]))
])
# b4_type_define_tag(SYMBOL1-NUM, ...)
# ------------------------------------
# For the batch of symbols SYMBOL1-NUM... (which all have the same
# type), enhance the %union definition for each of them, and set
# there "type" field to the field tag name, instead of the type name.
m4_define([b4_type_define_tag],
[b4_symbol_if([$1], [has_type],
[m4_map([b4_symbol_type_register], [$@])])
])
# b4_symbol_value_union(VAL, [TYPE])
# ----------------------------------
# Same of b4_symbol_value, but when api.value.type=union.
m4_define([b4_symbol_value_union],
[m4_ifval([$2],
[(*($2*)(&$1))],
[$1])])
])
# b4_value_type_setup_union
# -------------------------
# Setup support for api.value.type=union. Symbols are defined with a
# type instead of a union member name: build the corresponding union,
# and give the symbols their tag.
m4_define([b4_value_type_setup_union],
[m4_define([b4_union_members])
b4_type_foreach([b4_type_define_tag])
m4_copy_force([b4_symbol_value_union], [b4_symbol_value])
])
# ---------------- #
# api.value.type. #
# ---------------- #
# b4_value_type_setup_variant
# ---------------------------
# Setup support for api.value.type=variant. By default, fail, specialized
# by other skeletons.
m4_define([b4_value_type_setup_variant],
[b4_complain_at(b4_percent_define_get_loc([[api.value.type]]),
[['%s' does not support '%s']],
[b4_skeleton],
[%define api.value.type variant])])
# _b4_value_type_setup_keyword
# ----------------------------
# api.value.type is defined with a keyword/string syntax. Check if
# that is properly defined, and prepare its use.
m4_define([_b4_value_type_setup_keyword],
[b4_percent_define_check_values([[[[api.value.type]],
[[none]],
[[union]],
[[union-directive]],
[[variant]],
[[yystype]]]])dnl
m4_case(b4_percent_define_get([[api.value.type]]),
[union], [b4_value_type_setup_union],
[variant], [b4_value_type_setup_variant])])
# b4_value_type_setup
# -------------------
# Check if api.value.type is properly defined, and possibly prepare
# its use.
b4_define_silent([b4_value_type_setup],
[# Define default value.
b4_percent_define_ifdef([[api.value.type]], [],
[# %union => api.value.type=union-directive
m4_ifdef([b4_union_members],
[m4_define([b4_percent_define_kind(api.value.type)], [keyword])
m4_define([b4_percent_define(api.value.type)], [union-directive])],
[# no tag seen => api.value.type={int}
m4_if(b4_tag_seen_flag, 0,
[m4_define([b4_percent_define_kind(api.value.type)], [code])
m4_define([b4_percent_define(api.value.type)], [int])],
[# otherwise api.value.type=yystype
m4_define([b4_percent_define_kind(api.value.type)], [keyword])
m4_define([b4_percent_define(api.value.type)], [yystype])])])])
# Set up.
m4_bmatch(b4_percent_define_get_kind([[api.value.type]]),
[keyword\|string], [_b4_value_type_setup_keyword])
])
## -------------- ##
## Declarations. ##
## -------------- ##
# b4_value_type_define
# --------------------
m4_define([b4_value_type_define],
[b4_value_type_setup[]dnl
/* Value type. */
m4_bmatch(b4_percent_define_get_kind([[api.value.type]]),
[code],
[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED
typedef ]b4_percent_define_get([[api.value.type]])[ ]b4_api_PREFIX[STYPE;
# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1
# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1
#endif
]],
[m4_bmatch(b4_percent_define_get([[api.value.type]]),
[union\|union-directive],
[[#if ! defined ]b4_api_PREFIX[STYPE && ! defined ]b4_api_PREFIX[STYPE_IS_DECLARED
typedef union ]b4_union_name[ ]b4_api_PREFIX[STYPE;
union ]b4_union_name[
{
]b4_user_union_members[
};
# define ]b4_api_PREFIX[STYPE_IS_TRIVIAL 1
# define ]b4_api_PREFIX[STYPE_IS_DECLARED 1
#endif
]])])])
# b4_location_type_define
# -----------------------
m4_define([b4_location_type_define],
[[/* Location type. */
#if ! defined ]b4_api_PREFIX[LTYPE && ! defined ]b4_api_PREFIX[LTYPE_IS_DECLARED
typedef struct ]b4_api_PREFIX[LTYPE ]b4_api_PREFIX[LTYPE;
struct ]b4_api_PREFIX[LTYPE
{
int first_line;
int first_column;
int last_line;
int last_column;
};
# define ]b4_api_PREFIX[LTYPE_IS_DECLARED 1
# define ]b4_api_PREFIX[LTYPE_IS_TRIVIAL 1
#endif
]])
# b4_declare_yylstype
# -------------------
# Declarations that might either go into the header (if --defines) or
# in the parser body. Declare YYSTYPE/YYLTYPE, and yylval/yylloc.
m4_define([b4_declare_yylstype],
[b4_value_type_define[]b4_locations_if([
b4_location_type_define])
b4_pure_if([], [[extern ]b4_api_PREFIX[STYPE ]b4_prefix[lval;
]b4_locations_if([[extern ]b4_api_PREFIX[LTYPE ]b4_prefix[lloc;]])])[]dnl
])
# b4_YYDEBUG_define
# -----------------
m4_define([b4_YYDEBUG_define],
[[/* Debug traces. */
]m4_if(b4_api_prefix, [yy],
[[#ifndef YYDEBUG
# define YYDEBUG ]b4_parse_trace_if([1], [0])[
#endif]],
[[#ifndef ]b4_api_PREFIX[DEBUG
# if defined YYDEBUG
#if YYDEBUG
# define ]b4_api_PREFIX[DEBUG 1
# else
# define ]b4_api_PREFIX[DEBUG 0
# endif
# else /* ! defined YYDEBUG */
# define ]b4_api_PREFIX[DEBUG ]b4_parse_trace_if([1], [0])[
# endif /* ! defined YYDEBUG */
#endif /* ! defined ]b4_api_PREFIX[DEBUG */]])[]dnl
])
# b4_declare_yydebug
# ------------------
m4_define([b4_declare_yydebug],
[b4_YYDEBUG_define[
#if ]b4_api_PREFIX[DEBUG
extern int ]b4_prefix[debug;
#endif][]dnl
])
# b4_yylloc_default_define
# ------------------------
# Define YYLLOC_DEFAULT.
m4_define([b4_yylloc_default_define],
[[/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
If N is 0, then set CURRENT to the empty location which ends
the previous symbol: RHS[0] (always defined). */
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (N) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
} \
else \
{ \
(Current).first_line = (Current).last_line = \
YYRHSLOC (Rhs, 0).last_line; \
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
while (0)
#endif
]])
# b4_yy_location_print_define
# ---------------------------
# Define YY_LOCATION_PRINT.
m4_define([b4_yy_location_print_define],
[b4_locations_if([[
/* YY_LOCATION_PRINT -- Print the location on the stream.
This macro was not mandated originally: define only if we know
we won't break user code: when these are the locations we know. */
#ifndef YY_LOCATION_PRINT
# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
__attribute__((__unused__))
]b4_function_define([yy_location_print_],
[static unsigned],
[[FILE *yyo], [yyo]],
[[YYLTYPE const * const yylocp], [yylocp]])[
{
unsigned res = 0;
int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
if (0 <= yylocp->first_line)
{
res += YYFPRINTF (yyo, "%d", yylocp->first_line);
if (0 <= yylocp->first_column)
res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
}
if (0 <= yylocp->last_line)
{
if (yylocp->first_line < yylocp->last_line)
{
res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
if (0 <= end_col)
res += YYFPRINTF (yyo, ".%d", end_col);
}
else if (0 <= end_col && yylocp->first_column < end_col)
res += YYFPRINTF (yyo, "-%d", end_col);
}
return res;
}
# define YY_LOCATION_PRINT(File, Loc) \
yy_location_print_ (File, &(Loc))
# else
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif]],
[[/* This macro is provided for backward compatibility. */
#ifndef YY_LOCATION_PRINT
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
#endif]])
])
# b4_yyloc_default
# ----------------
# Expand to a possible default value for yylloc.
m4_define([b4_yyloc_default],
[[
# if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
= { ]m4_join([, ],
m4_defn([b4_location_initial_line]),
m4_defn([b4_location_initial_column]),
m4_defn([b4_location_initial_line]),
m4_defn([b4_location_initial_column]))[ }
# endif
]])

2563
gnuwin32/bin/data/glr.c
View File

File diff suppressed because it is too large Load Diff

345
gnuwin32/bin/data/glr.cc
View File

@@ -1,345 +0,0 @@
# C++ GLR skeleton for Bison
# Copyright (C) 2002-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# This skeleton produces a C++ class that encapsulates a C glr parser.
# This is in order to reduce the maintenance burden. The glr.c
# skeleton is clean and pure enough so that there are no real
# problems. The C++ interface is the same as that of lalr1.cc. In
# fact, glr.c can replace yacc.c without the user noticing any
# difference, and similarly for glr.cc replacing lalr1.cc.
#
# The passing of parse-params
#
# The additional arguments are stored as members of the parser
# object, yyparser. The C routines need to carry yyparser
# throughout the C parser; that's easy: make yyparser an
# additional parse-param. But because the C++ skeleton needs to
# know the "real" original parse-param, we save them
# (b4_parse_param_orig). Note that b4_parse_param is overquoted
# (and c.m4 strips one level of quotes). This is a PITA, and
# explains why there are so many levels of quotes.
#
# The locations
#
# We use location.cc just like lalr1.cc, but because glr.c stores
# the locations in a union, the position and location classes
# must not have a constructor. Therefore, contrary to lalr1.cc, we
# must not define "b4_location_constructors". As a consequence the
# user must initialize the first positions (in particular the
# filename member).
# We require a pure interface.
m4_define([b4_pure_flag], [1])
m4_include(b4_pkgdatadir/[c++.m4])
b4_bison_locations_if([m4_include(b4_pkgdatadir/[location.cc])])
m4_define([b4_parser_class_name],
[b4_percent_define_get([[parser_class_name]])])
# Save the parse parameters.
m4_define([b4_parse_param_orig], m4_defn([b4_parse_param]))
# b4_parse_param_wrap
# -------------------
# New ones.
m4_ifset([b4_parse_param],
[m4_define([b4_parse_param_wrap],
[[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]],]
m4_defn([b4_parse_param]))],
[m4_define([b4_parse_param_wrap],
[[b4_namespace_ref::b4_parser_class_name[& yyparser], [[yyparser]]]])
])
# b4_yy_symbol_print_define
# -------------------------
# Bypass the default implementation to generate the "yy_symbol_print"
# and "yy_symbol_value_print" functions.
m4_define([b4_yy_symbol_print_define],
[[
/*--------------------.
| Print this symbol. |
`--------------------*/
]b4_function_define([yy_symbol_print],
[static void],
[[FILE *], []],
[[int yytype], [yytype]],
[[const ]b4_namespace_ref::b4_parser_class_name[::semantic_type *yyvaluep],
[yyvaluep]][]dnl
b4_locations_if([,
[[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
[yylocationp]]]),
b4_parse_param)[
{
]b4_parse_param_use[]dnl
[ yyparser.yy_symbol_print_ (yytype, yyvaluep]b4_locations_if([, yylocationp])[);
}
]])[
# Hijack the initial action to initialize the locations.
]b4_bison_locations_if([m4_define([b4_initial_action],
[yylloc.initialize ();]m4_ifdef([b4_initial_action], [
m4_defn([b4_initial_action])]))])[
# Hijack the post prologue to insert early definition of YYLLOC_DEFAULT
# and declaration of yyerror.
]m4_append([b4_post_prologue],
[b4_syncline([@oline@], [@ofile@])[
]b4_yylloc_default_define[
#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
]b4_function_declare([yyerror],
[static void],b4_locations_if([
[[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
[yylocationp]],])
b4_parse_param,
[[const char* msg], [msg]])])
#undef yynerrs
#undef yychar
#undef yylval]b4_locations_if([
#undef yylloc])
m4_if(b4_prefix, [yy], [],
[[/* Substitute the variable and function names. */
#define yyparse ]b4_prefix[parse
#define yylex ]b4_prefix[lex
#define yyerror ]b4_prefix[error
#define yydebug ]b4_prefix[debug
]]b4_pure_if([], [[
#define yylval ]b4_prefix[lval
#define yychar ]b4_prefix[char
#define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
#define yylloc ]b4_prefix[lloc]])]))
# Hijack the epilogue to define implementations (yyerror, parser member
# functions etc.).
m4_append([b4_epilogue],
[b4_syncline([@oline@], [@ofile@])[
/*------------------.
| Report an error. |
`------------------*/
]b4_function_define([yyerror],
[static void],b4_locations_if([
[[const ]b4_namespace_ref::b4_parser_class_name[::location_type *yylocationp],
[yylocationp]],])
b4_parse_param,
[[const char* msg], [msg]])[
{
]b4_parse_param_use[]dnl
[ yyparser.error (]b4_locations_if([[*yylocationp, ]])[msg);
}
]b4_namespace_open[
]dnl In this section, the parse params are the original parse_params.
m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl
[ /// Build a parser object.
]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)]m4_ifset([b4_parse_param], [
:])[
#if ]b4_api_PREFIX[DEBUG
]m4_ifset([b4_parse_param], [ ], [ :])[yycdebug_ (&std::cerr)]m4_ifset([b4_parse_param], [,])[
#endif]b4_parse_param_cons[
{
}
]b4_parser_class_name::~b4_parser_class_name[ ()
{
}
int
]b4_parser_class_name[::parse ()
{
return ::yyparse (*this]b4_user_args[);
}
#if ]b4_api_PREFIX[DEBUG
/*--------------------.
| Print this symbol. |
`--------------------*/
inline void
]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[)
{]b4_locations_if([[
YYUSE (yylocationp);]])[
YYUSE (yyvaluep);
std::ostream& yyoutput = debug_stream ();
std::ostream& yyo = yyoutput;
YYUSE (yyo);
]b4_symbol_actions([printer])[
}
void
]b4_parser_class_name[::yy_symbol_print_ (int yytype,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[)
{
*yycdebug_ << (yytype < YYNTOKENS ? "token" : "nterm")
<< ' ' << yytname[yytype] << " ("]b4_locations_if([[
<< *yylocationp << ": "]])[;
yy_symbol_value_print_ (yytype, yyvaluep]b4_locations_if([[, yylocationp]])[);
*yycdebug_ << ')';
}
std::ostream&
]b4_parser_class_name[::debug_stream () const
{
return *yycdebug_;
}
void
]b4_parser_class_name[::set_debug_stream (std::ostream& o)
{
yycdebug_ = &o;
}
]b4_parser_class_name[::debug_level_type
]b4_parser_class_name[::debug_level () const
{
return yydebug;
}
void
]b4_parser_class_name[::set_debug_level (debug_level_type l)
{
// Actually, it is yydebug which is really used.
yydebug = l;
}
#endif
]m4_popdef([b4_parse_param])dnl
b4_namespace_close
])
# b4_shared_declarations
# ----------------------
# Declaration that might either go into the header (if --defines)
# or open coded in the parser body.
m4_define([b4_shared_declarations],
[m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_orig]))dnl
b4_percent_code_get([[requires]])[
#include <stdexcept>
#include <string>
#include <iostream>]b4_defines_if([
b4_bison_locations_if([[#include "location.hh"]])])[
]b4_YYDEBUG_define[
]b4_namespace_open[
]b4_defines_if([],
[b4_bison_locations_if([b4_position_define
b4_location_define])])[
/// A Bison parser.
class ]b4_parser_class_name[
{
public:
]b4_public_types_declare[
/// Build a parser object.
]b4_parser_class_name[ (]b4_parse_param_decl[);
virtual ~]b4_parser_class_name[ ();
/// Parse.
/// \returns 0 iff parsing succeeded.
virtual int parse ();
/// The current debugging stream.
std::ostream& debug_stream () const;
/// Set the current debugging stream.
void set_debug_stream (std::ostream &);
/// Type for debugging levels.
typedef int debug_level_type;
/// The current debugging level.
debug_level_type debug_level () const;
/// Set the current debugging level.
void set_debug_level (debug_level_type l);
public:
/// Report a syntax error.]b4_locations_if([[
/// \param loc where the syntax error is found.]])[
/// \param msg a description of the syntax error.
virtual void error (]b4_locations_if([[const location_type& loc, ]])[const std::string& msg);
# if ]b4_api_PREFIX[DEBUG
public:
/// \brief Report a symbol value on the debug stream.
/// \param yytype The token type.
/// \param yyvaluep Its semantic value.]b4_locations_if([[
/// \param yylocationp Its location.]])[
virtual void yy_symbol_value_print_ (int yytype,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[);
/// \brief Report a symbol on the debug stream.
/// \param yytype The token type.
/// \param yyvaluep Its semantic value.]b4_locations_if([[
/// \param yylocationp Its location.]])[
virtual void yy_symbol_print_ (int yytype,
const semantic_type* yyvaluep]b4_locations_if([[,
const location_type* yylocationp]])[);
private:
// Debugging.
std::ostream* yycdebug_;
#endif
]b4_parse_param_vars[
};
]dnl Redirections for glr.c.
b4_percent_define_flag_if([[global_tokens_and_yystype]],
[b4_token_defines])
[
#ifndef ]b4_api_PREFIX[STYPE
# define ]b4_api_PREFIX[STYPE ]b4_namespace_ref[::]b4_parser_class_name[::semantic_type
#endif
#ifndef ]b4_api_PREFIX[LTYPE
# define ]b4_api_PREFIX[LTYPE ]b4_namespace_ref[::]b4_parser_class_name[::location_type
#endif
]b4_namespace_close[
]b4_percent_code_get([[provides]])[
]m4_popdef([b4_parse_param])dnl
])
b4_defines_if(
[b4_output_begin([b4_spec_defines_file])
b4_copyright([Skeleton interface for Bison GLR parsers in C++],
[2002-2013])[
// C++ GLR parser skeleton written by Akim Demaille.
]b4_cpp_guard_open([b4_spec_defines_file])[
]b4_shared_declarations[
]b4_cpp_guard_close([b4_spec_defines_file])[
]b4_output_end()])
# Let glr.c (and b4_shared_declarations) believe that the user
# arguments include the parser itself.
m4_pushdef([b4_parse_param], m4_defn([b4_parse_param_wrap]))
m4_include(b4_pkgdatadir/[glr.c])
m4_popdef([b4_parse_param])

26
gnuwin32/bin/data/java-skel.m4
View File

@@ -1,26 +0,0 @@
-*- Autoconf -*-
# Java skeleton dispatching for Bison.
# Copyright (C) 2007, 2009-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
b4_glr_if( [b4_complain([%%glr-parser not supported for Java])])
b4_nondeterministic_if([b4_complain([%%nondeterministic-parser not supported for Java])])
m4_define_default([b4_used_skeleton], [b4_pkgdatadir/[lalr1.java]])
m4_define_default([b4_skeleton], ["b4_basename(b4_used_skeleton)"])
m4_include(b4_used_skeleton)

342
gnuwin32/bin/data/java.m4
View File

@@ -1,342 +0,0 @@
-*- Autoconf -*-
# Java language support for Bison
# Copyright (C) 2007-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
m4_include(b4_pkgdatadir/[c-like.m4])
# b4_list2(LIST1, LIST2)
# ----------------------
# Join two lists with a comma if necessary.
m4_define([b4_list2],
[$1[]m4_ifval(m4_quote($1), [m4_ifval(m4_quote($2), [[, ]])])[]$2])
# b4_percent_define_get3(DEF, PRE, POST, NOT)
# -------------------------------------------
# Expand to the value of DEF surrounded by PRE and POST if it's %define'ed,
# otherwise NOT.
m4_define([b4_percent_define_get3],
[m4_ifval(m4_quote(b4_percent_define_get([$1])),
[$2[]b4_percent_define_get([$1])[]$3], [$4])])
# b4_flag_value(BOOLEAN-FLAG)
# ---------------------------
m4_define([b4_flag_value], [b4_flag_if([$1], [true], [false])])
# b4_public_if(TRUE, FALSE)
# -------------------------
b4_percent_define_default([[public]], [[false]])
m4_define([b4_public_if],
[b4_percent_define_flag_if([public], [$1], [$2])])
# b4_abstract_if(TRUE, FALSE)
# ---------------------------
b4_percent_define_default([[abstract]], [[false]])
m4_define([b4_abstract_if],
[b4_percent_define_flag_if([abstract], [$1], [$2])])
# b4_final_if(TRUE, FALSE)
# ---------------------------
b4_percent_define_default([[final]], [[false]])
m4_define([b4_final_if],
[b4_percent_define_flag_if([final], [$1], [$2])])
# b4_strictfp_if(TRUE, FALSE)
# ---------------------------
b4_percent_define_default([[strictfp]], [[false]])
m4_define([b4_strictfp_if],
[b4_percent_define_flag_if([strictfp], [$1], [$2])])
# b4_lexer_if(TRUE, FALSE)
# ------------------------
m4_define([b4_lexer_if],
[b4_percent_code_ifdef([[lexer]], [$1], [$2])])
# b4_identification
# -----------------
m4_define([b4_identification],
[ /** Version number for the Bison executable that generated this parser. */
public static final String bisonVersion = "b4_version";
/** Name of the skeleton that generated this parser. */
public static final String bisonSkeleton = b4_skeleton;
])
## ------------ ##
## Data types. ##
## ------------ ##
# b4_int_type(MIN, MAX)
# ---------------------
# Return the smallest int type able to handle numbers ranging from
# MIN to MAX (included).
m4_define([b4_int_type],
[m4_if(b4_ints_in($@, [-128], [127]), [1], [byte],
b4_ints_in($@, [-32768], [32767]), [1], [short],
[int])])
# b4_int_type_for(NAME)
# ---------------------
# Return the smallest int type able to handle numbers ranging from
# 'NAME_min' to 'NAME_max' (included).
m4_define([b4_int_type_for],
[b4_int_type($1_min, $1_max)])
# b4_null
# -------
m4_define([b4_null], [null])
# b4_typed_parser_table_define(TYPE, NAME, DATA, COMMENT)
# -------------------------------------------------------
m4_define([b4_typed_parser_table_define],
[m4_ifval([$4], [b4_comment([$4])
])dnl
[private static final ]$1[ yy$2_[] = yy$2_init();
private static final ]$1[[] yy$2_init()
{
return new ]$1[[]
{
]$3[
};
}]])
# b4_integral_parser_table_define(NAME, DATA, COMMENT)
#-----------------------------------------------------
m4_define([b4_integral_parser_table_define],
[b4_typed_parser_table_define([b4_int_type_for([$2])], [$1], [$2], [$3])])
## ------------------------- ##
## Assigning token numbers. ##
## ------------------------- ##
# b4_token_enum(TOKEN-NUM)
# ------------------------
# Output the definition of this token as an enum.
m4_define([b4_token_enum],
[b4_token_format([ /** Token number, to be returned by the scanner. */
static final int %s = %s;
], [$1])])
# b4_token_enums
# --------------
# Output the definition of the tokens (if there are) as enums.
m4_define([b4_token_enums],
[b4_any_token_visible_if([/* Tokens. */
b4_symbol_foreach([b4_token_enum])])])
# b4-case(ID, CODE)
# -----------------
# We need to fool Java's stupid unreachable code detection.
m4_define([b4_case], [ case $1:
if (yyn == $1)
$2;
break;
])
# b4_predicate_case(LABEL, CONDITIONS)
# ------------------------------------
m4_define([b4_predicate_case], [ case $1:
if (! ($2)) YYERROR;
break;
])
## -------- ##
## Checks. ##
## -------- ##
b4_percent_define_check_kind([[api.value.type]], [code], [deprecated])
b4_percent_define_check_kind([[annotations]], [code], [deprecated])
b4_percent_define_check_kind([[extends]], [code], [deprecated])
b4_percent_define_check_kind([[implements]], [code], [deprecated])
b4_percent_define_check_kind([[init_throws]], [code], [deprecated])
b4_percent_define_check_kind([[lex_throws]], [code], [deprecated])
b4_percent_define_check_kind([[parser_class_name]], [code], [deprecated])
b4_percent_define_check_kind([[throws]], [code], [deprecated])
## ---------------- ##
## Default values. ##
## ---------------- ##
m4_define([b4_yystype], [b4_percent_define_get([[api.value.type]])])
b4_percent_define_default([[api.value.type]], [[Object]])
# %name-prefix
m4_define_default([b4_prefix], [[YY]])
b4_percent_define_default([[parser_class_name]], [b4_prefix[]Parser])
m4_define([b4_parser_class_name], [b4_percent_define_get([[parser_class_name]])])
b4_percent_define_default([[lex_throws]], [[java.io.IOException]])
m4_define([b4_lex_throws], [b4_percent_define_get([[lex_throws]])])
b4_percent_define_default([[throws]], [])
m4_define([b4_throws], [b4_percent_define_get([[throws]])])
b4_percent_define_default([[init_throws]], [])
m4_define([b4_init_throws], [b4_percent_define_get([[init_throws]])])
b4_percent_define_default([[api.location.type]], [Location])
m4_define([b4_location_type], [b4_percent_define_get([[api.location.type]])])
b4_percent_define_default([[api.position.type]], [Position])
m4_define([b4_position_type], [b4_percent_define_get([[api.position.type]])])
## ----------------- ##
## Semantic Values. ##
## ----------------- ##
# b4_lhs_value([TYPE])
# --------------------
# Expansion of $<TYPE>$.
m4_define([b4_lhs_value], [yyval])
# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
# --------------------------------------
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
# symbols on RHS.
#
# In this simple implementation, %token and %type have class names
# between the angle brackets.
m4_define([b4_rhs_value],
[(m4_ifval($3, [($3)])[](yystack.valueAt ($1-($2))))])
# b4_lhs_location()
# -----------------
# Expansion of @$.
m4_define([b4_lhs_location],
[(yyloc)])
# b4_rhs_location(RULE-LENGTH, NUM)
# ---------------------------------
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
# on RHS.
m4_define([b4_rhs_location],
[yystack.locationAt ($1-($2))])
# b4_lex_param
# b4_parse_param
# --------------
# If defined, b4_lex_param arrives double quoted, but below we prefer
# it to be single quoted. Same for b4_parse_param.
# TODO: should be in bison.m4
m4_define_default([b4_lex_param], [[]])
m4_define([b4_lex_param], b4_lex_param)
m4_define([b4_parse_param], b4_parse_param)
# b4_lex_param_decl
# -----------------
# Extra formal arguments of the constructor.
m4_define([b4_lex_param_decl],
[m4_ifset([b4_lex_param],
[b4_remove_comma([$1],
b4_param_decls(b4_lex_param))],
[$1])])
m4_define([b4_param_decls],
[m4_map([b4_param_decl], [$@])])
m4_define([b4_param_decl], [, $1])
m4_define([b4_remove_comma], [m4_ifval(m4_quote($1), [$1, ], [])m4_shift2($@)])
# b4_parse_param_decl
# -------------------
# Extra formal arguments of the constructor.
m4_define([b4_parse_param_decl],
[m4_ifset([b4_parse_param],
[b4_remove_comma([$1],
b4_param_decls(b4_parse_param))],
[$1])])
# b4_lex_param_call
# -----------------
# Delegating the lexer parameters to the lexer constructor.
m4_define([b4_lex_param_call],
[m4_ifset([b4_lex_param],
[b4_remove_comma([$1],
b4_param_calls(b4_lex_param))],
[$1])])
m4_define([b4_param_calls],
[m4_map([b4_param_call], [$@])])
m4_define([b4_param_call], [, $2])
# b4_parse_param_cons
# -------------------
# Extra initialisations of the constructor.
m4_define([b4_parse_param_cons],
[m4_ifset([b4_parse_param],
[b4_constructor_calls(b4_parse_param)])])
m4_define([b4_constructor_calls],
[m4_map([b4_constructor_call], [$@])])
m4_define([b4_constructor_call],
[this.$2 = $2;
])
# b4_parse_param_vars
# -------------------
# Extra instance variables.
m4_define([b4_parse_param_vars],
[m4_ifset([b4_parse_param],
[
/* User arguments. */
b4_var_decls(b4_parse_param)])])
m4_define([b4_var_decls],
[m4_map_sep([b4_var_decl], [
], [$@])])
m4_define([b4_var_decl],
[ protected final $1;])
# b4_maybe_throws(THROWS)
# -----------------------
# Expand to either an empty string or "throws THROWS".
m4_define([b4_maybe_throws],
[m4_ifval($1, [throws $1])])

1161
gnuwin32/bin/data/lalr1.cc
View File

File diff suppressed because it is too large Load Diff

1065
gnuwin32/bin/data/lalr1.java
View File

File diff suppressed because it is too large Load Diff

45
gnuwin32/bin/data/local.mk
View File

@@ -1,45 +0,0 @@
## Copyright (C) 2002, 2005-2013 Free Software Foundation, Inc.
## This program is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program. If not, see <http://www.gnu.org/licenses/>.
dist_pkgdata_DATA = \
data/README \
data/bison.m4 \
data/c++-skel.m4 \
data/c++.m4 \
data/c-like.m4 \
data/c-skel.m4 \
data/c.m4 \
data/glr.c \
data/glr.cc \
data/java-skel.m4 \
data/java.m4 \
data/lalr1.cc \
data/lalr1.java \
data/location.cc \
data/stack.hh \
data/variant.hh \
data/yacc.c
m4sugardir = $(pkgdatadir)/m4sugar
dist_m4sugar_DATA = \
data/m4sugar/foreach.m4 \
data/m4sugar/m4sugar.m4
xsltdir = $(pkgdatadir)/xslt
dist_xslt_DATA = \
data/xslt/bison.xsl \
data/xslt/xml2dot.xsl \
data/xslt/xml2text.xsl \
data/xslt/xml2xhtml.xsl

335
gnuwin32/bin/data/location.cc
View File

@@ -1,335 +0,0 @@
# C++ skeleton for Bison
# Copyright (C) 2002-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
m4_pushdef([b4_copyright_years],
[2002-2013])
# b4_position_define
# ------------------
# Define class position.
m4_define([b4_position_define],
[[ /// Abstract a position.
class position
{
public:]m4_ifdef([b4_location_constructors], [[
/// Construct a position.
explicit position (]b4_percent_define_get([[filename_type]])[* f = YY_NULL,
unsigned int l = ]b4_location_initial_line[u,
unsigned int c = ]b4_location_initial_column[u)
: filename (f)
, line (l)
, column (c)
{
}
]])[
/// Initialization.
void initialize (]b4_percent_define_get([[filename_type]])[* fn = YY_NULL,
unsigned int l = ]b4_location_initial_line[u,
unsigned int c = ]b4_location_initial_column[u)
{
filename = fn;
line = l;
column = c;
}
/** \name Line and Column related manipulators
** \{ */
/// (line related) Advance to the COUNT next lines.
void lines (int count = 1)
{
if (count)
{
column = ]b4_location_initial_column[u;
line = add_ (line, count, ]b4_location_initial_line[);
}
}
/// (column related) Advance to the COUNT next columns.
void columns (int count = 1)
{
column = add_ (column, count, ]b4_location_initial_column[);
}
/** \} */
/// File name to which this position refers.
]b4_percent_define_get([[filename_type]])[* filename;
/// Current line number.
unsigned int line;
/// Current column number.
unsigned int column;
private:
/// Compute max(min, lhs+rhs) (provided min <= lhs).
static unsigned int add_ (unsigned int lhs, int rhs, unsigned int min)
{
return (0 < rhs || -static_cast<unsigned int>(rhs) < lhs
? rhs + lhs
: min);
}
};
/// Add and assign a position.
inline position&
operator+= (position& res, int width)
{
res.columns (width);
return res;
}
/// Add two position objects.
inline position
operator+ (position res, int width)
{
return res += width;
}
/// Add and assign a position.
inline position&
operator-= (position& res, int width)
{
return res += -width;
}
/// Add two position objects.
inline position
operator- (position res, int width)
{
return res -= width;
}
]b4_percent_define_flag_if([[define_location_comparison]], [[
/// Compare two position objects.
inline bool
operator== (const position& pos1, const position& pos2)
{
return (pos1.line == pos2.line
&& pos1.column == pos2.column
&& (pos1.filename == pos2.filename
|| (pos1.filename && pos2.filename
&& *pos1.filename == *pos2.filename)));
}
/// Compare two position objects.
inline bool
operator!= (const position& pos1, const position& pos2)
{
return !(pos1 == pos2);
}
]])[
/** \brief Intercept output stream redirection.
** \param ostr the destination output stream
** \param pos a reference to the position to redirect
*/
template <typename YYChar>
inline std::basic_ostream<YYChar>&
operator<< (std::basic_ostream<YYChar>& ostr, const position& pos)
{
if (pos.filename)
ostr << *pos.filename << ':';
return ostr << pos.line << '.' << pos.column;
}
]])
# b4_location_define
# ------------------
m4_define([b4_location_define],
[[ /// Abstract a location.
class location
{
public:
]m4_ifdef([b4_location_constructors], [
/// Construct a location from \a b to \a e.
location (const position& b, const position& e)
: begin (b)
, end (e)
{
}
/// Construct a 0-width location in \a p.
explicit location (const position& p = position ())
: begin (p)
, end (p)
{
}
/// Construct a 0-width location in \a f, \a l, \a c.
explicit location (]b4_percent_define_get([[filename_type]])[* f,
unsigned int l = ]b4_location_initial_line[u,
unsigned int c = ]b4_location_initial_column[u)
: begin (f, l, c)
, end (f, l, c)
{
}
])[
/// Initialization.
void initialize (]b4_percent_define_get([[filename_type]])[* f = YY_NULL,
unsigned int l = ]b4_location_initial_line[u,
unsigned int c = ]b4_location_initial_column[u)
{
begin.initialize (f, l, c);
end = begin;
}
/** \name Line and Column related manipulators
** \{ */
public:
/// Reset initial location to final location.
void step ()
{
begin = end;
}
/// Extend the current location to the COUNT next columns.
void columns (int count = 1)
{
end += count;
}
/// Extend the current location to the COUNT next lines.
void lines (int count = 1)
{
end.lines (count);
}
/** \} */
public:
/// Beginning of the located region.
position begin;
/// End of the located region.
position end;
};
/// Join two location objects to create a location.
inline location operator+ (location res, const location& end)
{
res.end = end.end;
return res;
}
/// Change end position in place.
inline location& operator+= (location& res, int width)
{
res.columns (width);
return res;
}
/// Change end position.
inline location operator+ (location res, int width)
{
return res += width;
}
/// Change end position in place.
inline location& operator-= (location& res, int width)
{
return res += -width;
}
/// Change end position.
inline location operator- (const location& begin, int width)
{
return begin + -width;
}
]b4_percent_define_flag_if([[define_location_comparison]], [[
/// Compare two location objects.
inline bool
operator== (const location& loc1, const location& loc2)
{
return loc1.begin == loc2.begin && loc1.end == loc2.end;
}
/// Compare two location objects.
inline bool
operator!= (const location& loc1, const location& loc2)
{
return !(loc1 == loc2);
}
]])[
/** \brief Intercept output stream redirection.
** \param ostr the destination output stream
** \param loc a reference to the location to redirect
**
** Avoid duplicate information.
*/
template <typename YYChar>
inline std::basic_ostream<YYChar>&
operator<< (std::basic_ostream<YYChar>& ostr, const location& loc)
{
unsigned int end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
ostr << loc.begin// << "(" << loc.end << ") "
;
if (loc.end.filename
&& (!loc.begin.filename
|| *loc.begin.filename != *loc.end.filename))
ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col;
else if (loc.begin.line < loc.end.line)
ostr << '-' << loc.end.line << '.' << end_col;
else if (loc.begin.column < end_col)
ostr << '-' << end_col;
return ostr;
}
]])
b4_defines_if([
b4_output_begin([b4_dir_prefix[]position.hh])
b4_copyright([Positions for Bison parsers in C++])[
/**
** \file ]b4_dir_prefix[position.hh
** Define the ]b4_namespace_ref[::position class.
*/
]b4_cpp_guard_open([b4_dir_prefix[]position.hh])[
# include <algorithm> // std::max
# include <iostream>
# include <string>
]b4_null_define[
]b4_namespace_open[
]b4_position_define[
]b4_namespace_close[
]b4_cpp_guard_close([b4_dir_prefix[]position.hh])
b4_output_end()
b4_output_begin([b4_dir_prefix[]location.hh])
b4_copyright([Locations for Bison parsers in C++])[
/**
** \file ]b4_dir_prefix[location.hh
** Define the ]b4_namespace_ref[::location class.
*/
]b4_cpp_guard_open([b4_dir_prefix[]location.hh])[
# include "position.hh"
]b4_namespace_open[
]b4_location_define[
]b4_namespace_close[
]b4_cpp_guard_close([b4_dir_prefix[]location.hh])
b4_output_end()
])
m4_popdef([b4_copyright_years])

362
gnuwin32/bin/data/m4sugar/foreach.m4
View File

@@ -1,362 +0,0 @@
# -*- Autoconf -*-
# This file is part of Autoconf.
# foreach-based replacements for recursive functions.
# Speeds up GNU M4 1.4.x by avoiding quadratic $@ recursion, but penalizes
# GNU M4 1.6 by requiring more memory and macro expansions.
#
# Copyright (C) 2008-2013 Free Software Foundation, Inc.
# This file is part of Autoconf. This program is free
# software; you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the
# Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# Under Section 7 of GPL version 3, you are granted additional
# permissions described in the Autoconf Configure Script Exception,
# version 3.0, as published by the Free Software Foundation.
#
# You should have received a copy of the GNU General Public License
# and a copy of the Autoconf Configure Script Exception along with
# this program; see the files COPYINGv3 and COPYING.EXCEPTION
# respectively. If not, see <http://www.gnu.org/licenses/>.
# Written by Eric Blake.
# In M4 1.4.x, every byte of $@ is rescanned. This means that an
# algorithm on n arguments that recurses with one less argument each
# iteration will scan n * (n + 1) / 2 arguments, for O(n^2) time. In
# M4 1.6, this was fixed so that $@ is only scanned once, then
# back-references are made to information stored about the scan.
# Thus, n iterations need only scan n arguments, for O(n) time.
# Additionally, in M4 1.4.x, recursive algorithms did not clean up
# memory very well, requiring O(n^2) memory rather than O(n) for n
# iterations.
#
# This file is designed to overcome the quadratic nature of $@
# recursion by writing a variant of m4_foreach that uses m4_for rather
# than $@ recursion to operate on the list. This involves more macro
# expansions, but avoids the need to rescan a quadratic number of
# arguments, making these replacements very attractive for M4 1.4.x.
# On the other hand, in any version of M4, expanding additional macros
# costs additional time; therefore, in M4 1.6, where $@ recursion uses
# fewer macros, these replacements actually pessimize performance.
# Additionally, the use of $10 to mean the tenth argument violates
# POSIX; although all versions of m4 1.4.x support this meaning, a
# future m4 version may switch to take it as the first argument
# concatenated with a literal 0, so the implementations in this file
# are not future-proof. Thus, this file is conditionally included as
# part of m4_init(), only when it is detected that M4 probably has
# quadratic behavior (ie. it lacks the macro __m4_version__).
#
# Please keep this file in sync with m4sugar.m4.
# _m4_foreach(PRE, POST, IGNORED, ARG...)
# ---------------------------------------
# Form the common basis of the m4_foreach and m4_map macros. For each
# ARG, expand PRE[ARG]POST[]. The IGNORED argument makes recursion
# easier, and must be supplied rather than implicit.
#
# This version minimizes the number of times that $@ is evaluated by
# using m4_for to generate a boilerplate into _m4_f then passing $@ to
# that temporary macro. Thus, the recursion is done in m4_for without
# reparsing any user input, and is not quadratic. For an idea of how
# this works, note that m4_foreach(i,[1,2],[i]) calls
# _m4_foreach([m4_define([i],],[)i],[],[1],[2])
# which defines _m4_f:
# $1[$4]$2[]$1[$5]$2[]_m4_popdef([_m4_f])
# then calls _m4_f([m4_define([i],],[)i],[],[1],[2]) for a net result:
# m4_define([i],[1])i[]m4_define([i],[2])i[]_m4_popdef([_m4_f]).
m4_define([_m4_foreach],
[m4_if([$#], [3], [],
[m4_pushdef([_m4_f], _m4_for([4], [$#], [1],
[$0_([1], [2],], [)])[_m4_popdef([_m4_f])])_m4_f($@)])])
m4_define([_m4_foreach_],
[[$$1[$$3]$$2[]]])
# m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT)
# -----------------------------------------------------------
# Find the first VAL that SWITCH matches, and expand the corresponding
# IF-VAL. If there are no matches, expand DEFAULT.
#
# Use m4_for to create a temporary macro in terms of a boilerplate
# m4_if with final cleanup. If $# is even, we have DEFAULT; if it is
# odd, then rounding the last $# up in the temporary macro is
# harmless. For example, both m4_case(1,2,3,4,5) and
# m4_case(1,2,3,4,5,6) result in the intermediate _m4_case being
# m4_if([$1],[$2],[$3],[$1],[$4],[$5],_m4_popdef([_m4_case])[$6])
m4_define([m4_case],
[m4_if(m4_eval([$# <= 2]), [1], [$2],
[m4_pushdef([_$0], [m4_if(]_m4_for([2], m4_eval([($# - 1) / 2 * 2]), [2],
[_$0_(], [)])[_m4_popdef(
[_$0])]m4_dquote($m4_eval([($# + 1) & ~1]))[)])_$0($@)])])
m4_define([_m4_case_],
[$0_([1], [$1], m4_incr([$1]))])
m4_define([_m4_case__],
[[[$$1],[$$2],[$$3],]])
# m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT)
# -----------------------------------------------------
# m4 equivalent of
#
# if (SWITCH =~ RE1)
# VAL1;
# elif (SWITCH =~ RE2)
# VAL2;
# elif ...
# ...
# else
# DEFAULT
#
# We build the temporary macro _m4_b:
# m4_define([_m4_b], _m4_defn([_m4_bmatch]))_m4_b([$1], [$2], [$3])...
# _m4_b([$1], [$m-1], [$m])_m4_b([], [], [$m+1]_m4_popdef([_m4_b]))
# then invoke m4_unquote(_m4_b($@)), for concatenation with later text.
m4_define([m4_bmatch],
[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])],
[$#], 1, [m4_fatal([$0: too few arguments: $#: $1])],
[$#], 2, [$2],
[m4_pushdef([_m4_b], [m4_define([_m4_b],
_m4_defn([_$0]))]_m4_for([3], m4_eval([($# + 1) / 2 * 2 - 1]),
[2], [_$0_(], [)])[_m4_b([], [],]m4_dquote([$]m4_eval(
[($# + 1) / 2 * 2]))[_m4_popdef([_m4_b]))])m4_unquote(_m4_b($@))])])
m4_define([_m4_bmatch],
[m4_if(m4_bregexp([$1], [$2]), [-1], [], [[$3]m4_define([$0])])])
m4_define([_m4_bmatch_],
[$0_([1], m4_decr([$1]), [$1])])
m4_define([_m4_bmatch__],
[[_m4_b([$$1], [$$2], [$$3])]])
# m4_cond(TEST1, VAL1, IF-VAL1, TEST2, VAL2, IF-VAL2, ..., [DEFAULT])
# -------------------------------------------------------------------
# Similar to m4_if, except that each TEST is expanded when encountered.
# If the expansion of TESTn matches the string VALn, the result is IF-VALn.
# The result is DEFAULT if no tests passed. This macro allows
# short-circuiting of expensive tests, where it pays to arrange quick
# filter tests to run first.
#
# m4_cond already guarantees either 3*n or 3*n + 1 arguments, 1 <= n.
# We only have to speed up _m4_cond, by building the temporary _m4_c:
# m4_define([_m4_c], _m4_defn([m4_unquote]))_m4_c([m4_if(($1), [($2)],
# [[$3]m4_define([_m4_c])])])_m4_c([m4_if(($4), [($5)],
# [[$6]m4_define([_m4_c])])])..._m4_c([m4_if(($m-2), [($m-1)],
# [[$m]m4_define([_m4_c])])])_m4_c([[$m+1]]_m4_popdef([_m4_c]))
# We invoke m4_unquote(_m4_c($@)), for concatenation with later text.
m4_define([_m4_cond],
[m4_pushdef([_m4_c], [m4_define([_m4_c],
_m4_defn([m4_unquote]))]_m4_for([2], m4_eval([$# / 3 * 3 - 1]), [3],
[$0_(], [)])[_m4_c(]m4_dquote(m4_dquote(
[$]m4_eval([$# / 3 * 3 + 1])))[_m4_popdef([_m4_c]))])m4_unquote(_m4_c($@))])
m4_define([_m4_cond_],
[$0_(m4_decr([$1]), [$1], m4_incr([$1]))])
m4_define([_m4_cond__],
[[_m4_c([m4_if(($$1), [($$2)], [[$$3]m4_define([_m4_c])])])]])
# m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...)
# ----------------------------------------------------
# m4 equivalent of
#
# $_ = STRING;
# s/RE1/SUBST1/g;
# s/RE2/SUBST2/g;
# ...
#
# m4_bpatsubsts already validated an odd number of arguments; we only
# need to speed up _m4_bpatsubsts. To avoid nesting, we build the
# temporary _m4_p:
# m4_define([_m4_p], [$1])m4_define([_m4_p],
# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$2], [$3]))m4_define([_m4_p],
# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$4], [$5]))m4_define([_m4_p],...
# m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$m-1], [$m]))m4_unquote(
# _m4_defn([_m4_p])_m4_popdef([_m4_p]))
m4_define([_m4_bpatsubsts],
[m4_pushdef([_m4_p], [m4_define([_m4_p],
]m4_dquote([$]1)[)]_m4_for([3], [$#], [2], [$0_(],
[)])[m4_unquote(_m4_defn([_m4_p])_m4_popdef([_m4_p]))])_m4_p($@)])
m4_define([_m4_bpatsubsts_],
[$0_(m4_decr([$1]), [$1])])
m4_define([_m4_bpatsubsts__],
[[m4_define([_m4_p],
m4_bpatsubst(m4_dquote(_m4_defn([_m4_p])), [$$1], [$$2]))]])
# m4_shiftn(N, ...)
# -----------------
# Returns ... shifted N times. Useful for recursive "varargs" constructs.
#
# m4_shiftn already validated arguments; we only need to speed up
# _m4_shiftn. If N is 3, then we build the temporary _m4_s, defined as
# ,[$5],[$6],...,[$m]_m4_popdef([_m4_s])
# before calling m4_shift(_m4_s($@)).
m4_define([_m4_shiftn],
[m4_if(m4_incr([$1]), [$#], [], [m4_pushdef([_m4_s],
_m4_for(m4_eval([$1 + 2]), [$#], [1],
[[,]m4_dquote($], [)])[_m4_popdef([_m4_s])])m4_shift(_m4_s($@))])])
# m4_do(STRING, ...)
# ------------------
# This macro invokes all its arguments (in sequence, of course). It is
# useful for making your macros more structured and readable by dropping
# unnecessary dnl's and have the macros indented properly.
#
# Here, we use the temporary macro _m4_do, defined as
# $1[]$2[]...[]$n[]_m4_popdef([_m4_do])
m4_define([m4_do],
[m4_if([$#], [0], [],
[m4_pushdef([_$0], _m4_for([1], [$#], [1],
[$], [[[]]])[_m4_popdef([_$0])])_$0($@)])])
# m4_dquote_elt(ARGS)
# -------------------
# Return ARGS as an unquoted list of double-quoted arguments.
#
# _m4_foreach to the rescue.
m4_define([m4_dquote_elt],
[m4_if([$#], [0], [], [[[$1]]_m4_foreach([,m4_dquote(], [)], $@)])])
# m4_reverse(ARGS)
# ----------------
# Output ARGS in reverse order.
#
# Invoke _m4_r($@) with the temporary _m4_r built as
# [$m], [$m-1], ..., [$2], [$1]_m4_popdef([_m4_r])
m4_define([m4_reverse],
[m4_if([$#], [0], [], [$#], [1], [[$1]],
[m4_pushdef([_m4_r], [[$$#]]_m4_for(m4_decr([$#]), [1], [-1],
[[, ]m4_dquote($], [)])[_m4_popdef([_m4_r])])_m4_r($@)])])
# m4_map_args_pair(EXPRESSION, [END-EXPR = EXPRESSION], ARG...)
# -------------------------------------------------------------
# Perform a pairwise grouping of consecutive ARGs, by expanding
# EXPRESSION([ARG1], [ARG2]). If there are an odd number of ARGs, the
# final argument is expanded with END-EXPR([ARGn]).
#
# Build the temporary macro _m4_map_args_pair, with the $2([$m+1])
# only output if $# is odd:
# $1([$3], [$4])[]$1([$5], [$6])[]...$1([$m-1],
# [$m])[]m4_default([$2], [$1])([$m+1])[]_m4_popdef([_m4_map_args_pair])
m4_define([m4_map_args_pair],
[m4_if([$#], [0], [m4_fatal([$0: too few arguments: $#])],
[$#], [1], [m4_fatal([$0: too few arguments: $#: $1])],
[$#], [2], [],
[$#], [3], [m4_default([$2], [$1])([$3])[]],
[m4_pushdef([_$0], _m4_for([3],
m4_eval([$# / 2 * 2 - 1]), [2], [_$0_(], [)])_$0_end(
[1], [2], [$#])[_m4_popdef([_$0])])_$0($@)])])
m4_define([_m4_map_args_pair_],
[$0_([1], [$1], m4_incr([$1]))])
m4_define([_m4_map_args_pair__],
[[$$1([$$2], [$$3])[]]])
m4_define([_m4_map_args_pair_end],
[m4_if(m4_eval([$3 & 1]), [1], [[m4_default([$$2], [$$1])([$$3])[]]])])
# m4_join(SEP, ARG1, ARG2...)
# ---------------------------
# Produce ARG1SEPARG2...SEPARGn. Avoid back-to-back SEP when a given ARG
# is the empty string. No expansion is performed on SEP or ARGs.
#
# Use a self-modifying separator, since we don't know how many
# arguments might be skipped before a separator is first printed, but
# be careful if the separator contains $. _m4_foreach to the rescue.
m4_define([m4_join],
[m4_pushdef([_m4_sep], [m4_define([_m4_sep], _m4_defn([m4_echo]))])]dnl
[_m4_foreach([_$0([$1],], [)], $@)_m4_popdef([_m4_sep])])
m4_define([_m4_join],
[m4_if([$2], [], [], [_m4_sep([$1])[$2]])])
# m4_joinall(SEP, ARG1, ARG2...)
# ------------------------------
# Produce ARG1SEPARG2...SEPARGn. An empty ARG results in back-to-back SEP.
# No expansion is performed on SEP or ARGs.
#
# A bit easier than m4_join. _m4_foreach to the rescue.
m4_define([m4_joinall],
[[$2]m4_if(m4_eval([$# <= 2]), [1], [],
[_m4_foreach([$1], [], m4_shift($@))])])
# m4_list_cmp(A, B)
# -----------------
# Compare the two lists of integer expressions A and B.
#
# m4_list_cmp takes care of any side effects; we only override
# _m4_list_cmp_raw, where we can safely expand lists multiple times.
# First, insert padding so that both lists are the same length; the
# trailing +0 is necessary to handle a missing list. Next, create a
# temporary macro to perform pairwise comparisons until an inequality
# is found. For example, m4_list_cmp([1], [1,2]) creates _m4_cmp as
# m4_if(m4_eval([($1) != ($3)]), [1], [m4_cmp([$1], [$3])],
# m4_eval([($2) != ($4)]), [1], [m4_cmp([$2], [$4])],
# [0]_m4_popdef([_m4_cmp]))
# then calls _m4_cmp([1+0], [0*2], [1], [2+0])
m4_define([_m4_list_cmp_raw],
[m4_if([$1], [$2], 0,
[_m4_list_cmp($1+0_m4_list_pad(m4_count($1), m4_count($2)),
$2+0_m4_list_pad(m4_count($2), m4_count($1)))])])
m4_define([_m4_list_pad],
[m4_if(m4_eval($1 < $2), [1],
[_m4_for(m4_incr([$1]), [$2], [1], [,0*])])])
m4_define([_m4_list_cmp],
[m4_pushdef([_m4_cmp], [m4_if(]_m4_for(
[1], m4_eval([$# >> 1]), [1], [$0_(], [,]m4_eval([$# >> 1])[)])[
[0]_m4_popdef([_m4_cmp]))])_m4_cmp($@)])
m4_define([_m4_list_cmp_],
[$0_([$1], m4_eval([$1 + $2]))])
m4_define([_m4_list_cmp__],
[[m4_eval([($$1) != ($$2)]), [1], [m4_cmp([$$1], [$$2])],
]])
# m4_max(EXPR, ...)
# m4_min(EXPR, ...)
# -----------------
# Return the decimal value of the maximum (or minimum) in a series of
# integer expressions.
#
# _m4_foreach to the rescue; we only need to replace _m4_minmax. Here,
# we need a temporary macro to track the best answer so far, so that
# the foreach expression is tractable.
m4_define([_m4_minmax],
[m4_pushdef([_m4_best], m4_eval([$2]))_m4_foreach(
[m4_define([_m4_best], $1(_m4_best,], [))], m4_shift($@))]dnl
[_m4_best[]_m4_popdef([_m4_best])])
# m4_set_add_all(SET, VALUE...)
# -----------------------------
# Add each VALUE into SET. This is O(n) in the number of VALUEs, and
# can be faster than calling m4_set_add for each VALUE.
#
# _m4_foreach to the rescue. If no deletions have occurred, then
# avoid the speed penalty of m4_set_add.
m4_define([m4_set_add_all],
[m4_if([$#], [0], [], [$#], [1], [],
[m4_define([_m4_set_size($1)], m4_eval(m4_set_size([$1])
+ m4_len(_m4_foreach(m4_ifdef([_m4_set_cleanup($1)],
[[m4_set_add]], [[_$0]])[([$1],], [)], $@))))])])
m4_define([_m4_set_add_all],
[m4_ifdef([_m4_set([$1],$2)], [],
[m4_define([_m4_set([$1],$2)],
[1])m4_pushdef([_m4_set([$1])], [$2])-])])

3307
gnuwin32/bin/data/m4sugar/m4sugar.m4
View File

File diff suppressed because it is too large Load Diff

154
gnuwin32/bin/data/stack.hh
View File

@@ -1,154 +0,0 @@
# C++ skeleton for Bison
# Copyright (C) 2002-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
m4_pushdef([b4_copyright_years],
[2002-2013])
# b4_stack_define
# ---------------
m4_define([b4_stack_define],
[[ template <class T, class S = std::vector<T> >
class stack
{
public:
// Hide our reversed order.
typedef typename S::reverse_iterator iterator;
typedef typename S::const_reverse_iterator const_iterator;
stack ()
: seq_ ()
{
}
stack (unsigned int n)
: seq_ (n)
{
}
inline
T&
operator[] (unsigned int i)
{
return seq_[seq_.size () - 1 - i];
}
inline
const T&
operator[] (unsigned int i) const
{
return seq_[seq_.size () - 1 - i];
}
/// Steal the contents of \a t.
///
/// Close to move-semantics.
inline
void
push (T& t)
{
seq_.push_back (T());
operator[](0).move (t);
}
inline
void
pop (unsigned int n = 1)
{
for (; n; --n)
seq_.pop_back ();
}
void
clear ()
{
seq_.clear ();
}
inline
typename S::size_type
size () const
{
return seq_.size ();
}
inline
const_iterator
begin () const
{
return seq_.rbegin ();
}
inline
const_iterator
end () const
{
return seq_.rend ();
}
private:
stack (const stack&);
stack& operator= (const stack&);
/// The wrapped container.
S seq_;
};
/// Present a slice of the top of a stack.
template <class T, class S = stack<T> >
class slice
{
public:
slice (const S& stack, unsigned int range)
: stack_ (stack)
, range_ (range)
{
}
inline
const T&
operator [] (unsigned int i) const
{
return stack_[range_ - i];
}
private:
const S& stack_;
unsigned int range_;
};
]])
b4_defines_if(
[b4_output_begin([b4_dir_prefix[]stack.hh])
b4_copyright([Stack handling for Bison parsers in C++])[
/**
** \file ]b4_dir_prefix[stack.hh
** Define the ]b4_namespace_ref[::stack class.
*/
]b4_cpp_guard_open([b4_dir_prefix[]stack.hh])[
# include <vector>
]b4_namespace_open[
]b4_stack_define[
]b4_namespace_close[
]b4_cpp_guard_close([b4_dir_prefix[]stack.hh])
b4_output_end()
])
m4_popdef([b4_copyright_years])

362
gnuwin32/bin/data/variant.hh
View File

@@ -1,362 +0,0 @@
# C++ skeleton for Bison
# Copyright (C) 2002-2013 Free Software Foundation, Inc.
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
## --------- ##
## variant. ##
## --------- ##
# b4_symbol_variant(YYTYPE, YYVAL, ACTION, [ARGS])
# ------------------------------------------------
# Run some ACTION ("build", or "destroy") on YYVAL of symbol type
# YYTYPE.
m4_define([b4_symbol_variant],
[m4_pushdef([b4_dollar_dollar],
[$2.$3< $][3 > (m4_shift3($@))])dnl
switch ($1)
{
b4_type_foreach([b4_type_action_])[]dnl
default:
break;
}
m4_popdef([b4_dollar_dollar])dnl
])
# _b4_char_sizeof_counter
# -----------------------
# A counter used by _b4_char_sizeof_dummy to create fresh symbols.
m4_define([_b4_char_sizeof_counter],
[0])
# _b4_char_sizeof_dummy
# ---------------------
# At each call return a new C++ identifier.
m4_define([_b4_char_sizeof_dummy],
[m4_define([_b4_char_sizeof_counter], m4_incr(_b4_char_sizeof_counter))dnl
dummy[]_b4_char_sizeof_counter])
# b4_char_sizeof(SYMBOL-NUMS)
# ---------------------------
# To be mapped on the list of type names to produce:
#
# char dummy1[sizeof(type_name_1)];
# char dummy2[sizeof(type_name_2)];
#
# for defined type names.
m4_define([b4_char_sizeof],
[b4_symbol_if([$1], [has_type],
[
m4_map([ b4_symbol_tag_comment], [$@])dnl
char _b4_char_sizeof_dummy@{sizeof(b4_symbol([$1], [type]))@};
])])
# b4_variant_includes
# -------------------
# The needed includes for variants support.
m4_define([b4_variant_includes],
[b4_parse_assert_if([[#include <typeinfo>]])[
#ifndef YYASSERT
# include <cassert>
# define YYASSERT assert
#endif
]])
# b4_variant_define
# -----------------
# Define "variant".
m4_define([b4_variant_define],
[[ /// A char[S] buffer to store and retrieve objects.
///
/// Sort of a variant, but does not keep track of the nature
/// of the stored data, since that knowledge is available
/// via the current state.
template <size_t S>
struct variant
{
/// Type of *this.
typedef variant<S> self_type;
/// Empty construction.
variant ()]b4_parse_assert_if([
: yytname_ (YY_NULL)])[
{}
/// Construct and fill.
template <typename T>
variant (const T& t)]b4_parse_assert_if([
: yytname_ (typeid (T).name ())])[
{
YYASSERT (sizeof (T) <= S);
new (yyas_<T> ()) T (t);
}
/// Destruction, allowed only if empty.
~variant ()
{]b4_parse_assert_if([
YYASSERT (!yytname_);
])[}
/// Instantiate an empty \a T in here.
template <typename T>
T&
build ()
{]b4_parse_assert_if([
YYASSERT (!yytname_);
YYASSERT (sizeof (T) <= S);
yytname_ = typeid (T).name ();])[
return *new (yyas_<T> ()) T;
}
/// Instantiate a \a T in here from \a t.
template <typename T>
T&
build (const T& t)
{]b4_parse_assert_if([
YYASSERT (!yytname_);
YYASSERT (sizeof (T) <= S);
yytname_ = typeid (T).name ();])[
return *new (yyas_<T> ()) T (t);
}
/// Accessor to a built \a T.
template <typename T>
T&
as ()
{]b4_parse_assert_if([
YYASSERT (yytname_ == typeid (T).name ());
YYASSERT (sizeof (T) <= S);])[
return *yyas_<T> ();
}
/// Const accessor to a built \a T (for %printer).
template <typename T>
const T&
as () const
{]b4_parse_assert_if([
YYASSERT (yytname_ == typeid (T).name ());
YYASSERT (sizeof (T) <= S);])[
return *yyas_<T> ();
}
/// Swap the content with \a other, of same type.
///
/// Both variants must be built beforehand, because swapping the actual
/// data requires reading it (with as()), and this is not possible on
/// unconstructed variants: it would require some dynamic testing, which
/// should not be the variant's responsability.
/// Swapping between built and (possibly) non-built is done with
/// variant::move ().
template <typename T>
void
swap (self_type& other)
{]b4_parse_assert_if([
YYASSERT (yytname_);
YYASSERT (yytname_ == other.yytname_);])[
std::swap (as<T> (), other.as<T> ());
}
/// Move the content of \a other to this.
///
/// Destroys \a other.
template <typename T>
void
move (self_type& other)
{]b4_parse_assert_if([
YYASSERT (!yytname_);])[
build<T> ();
swap<T> (other);
other.destroy<T> ();
}
/// Copy the content of \a other to this.
template <typename T>
void
copy (const self_type& other)
{
build<T> (other.as<T> ());
}
/// Destroy the stored \a T.
template <typename T>
void
destroy ()
{
as<T> ().~T ();]b4_parse_assert_if([
yytname_ = YY_NULL;])[
}
private:
/// Prohibit blind copies.
self_type& operator=(const self_type&);
variant (const self_type&);
/// Accessor to raw memory as \a T.
template <typename T>
T*
yyas_ ()
{
void *yyp = yybuffer_.yyraw;
return static_cast<T*> (yyp);
}
/// Const accessor to raw memory as \a T.
template <typename T>
const T*
yyas_ () const
{
const void *yyp = yybuffer_.yyraw;
return static_cast<const T*> (yyp);
}
union
{
/// Strongest alignment constraints.
long double yyalign_me;
/// A buffer large enough to store any of the semantic values.
char yyraw[S];
} yybuffer_;]b4_parse_assert_if([
/// Whether the content is built: if defined, the name of the stored type.
const char *yytname_;])[
};
]])
## -------------------------- ##
## Adjustments for variants. ##
## -------------------------- ##
# b4_value_type_declare
# ---------------------
# Declare semantic_type.
m4_define([b4_value_type_declare],
[[ /// An auxiliary type to compute the largest semantic type.
union union_type
{]b4_type_foreach([b4_char_sizeof])[};
/// Symbol semantic values.
typedef variant<sizeof(union_type)> semantic_type;][]dnl
])
# How the semantic value is extracted when using variants.
# b4_symbol_value(VAL, [TYPE])
# ----------------------------
m4_define([b4_symbol_value],
[m4_ifval([$2],
[$1.as< $2 > ()],
[$1])])
# b4_symbol_value_template(VAL, [TYPE])
# -------------------------------------
# Same as b4_symbol_value, but used in a template method.
m4_define([b4_symbol_value_template],
[m4_ifval([$2],
[$1.template as< $2 > ()],
[$1])])
## ------------- ##
## make_SYMBOL. ##
## ------------- ##
# b4_symbol_constructor_declare_(SYMBOL-NUMBER)
# ---------------------------------------------
# Declare the overloaded version of make_symbol for the (common) type of
# these SYMBOL-NUMBERS. Use at class-level.
m4_define([b4_symbol_constructor_declare_],
[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
[ static inline
symbol_type
make_[]b4_symbol_([$1], [id]) (dnl
b4_join(b4_symbol_if([$1], [has_type],
[const b4_symbol([$1], [type])& v]),
b4_locations_if([const location_type& l])));
])])])
# b4_symbol_constructor_declare
# -----------------------------
# Declare symbol constructors for all the value types.
# Use at class-level.
m4_define([b4_symbol_constructor_declare],
[ // Symbol constructors declarations.
b4_symbol_foreach([b4_symbol_constructor_declare_])])
# b4_symbol_constructor_define_(SYMBOL-NUMBER)
# --------------------------------------------
# Define symbol constructor for this SYMBOL-NUMBER.
m4_define([b4_symbol_constructor_define_],
[b4_symbol_if([$1], [is_token], [b4_symbol_if([$1], [has_id],
[ b4_parser_class_name::symbol_type
b4_parser_class_name::make_[]b4_symbol_([$1], [id]) (dnl
b4_join(b4_symbol_if([$1], [has_type],
[const b4_symbol([$1], [type])& v]),
b4_locations_if([const location_type& l])))
{
return symbol_type (b4_join([token::b4_symbol([$1], [id])],
b4_symbol_if([$1], [has_type], [v]),
b4_locations_if([l])));
}
])])])
# b4_basic_symbol_constructor_declare
# -----------------------------------
# Generate a constructor declaration for basic_symbol from given type.
m4_define([b4_basic_symbol_constructor_declare],
[[
basic_symbol (]b4_join(
[typename Base::kind_type t],
b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
b4_locations_if([const location_type& l]))[);
]])
# b4_basic_symbol_constructor_define
# ----------------------------------
# Generate a constructor implementation for basic_symbol from given type.
m4_define([b4_basic_symbol_constructor_define],
[[
template <typename Base>
]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
[typename Base::kind_type t],
b4_symbol_if([$1], [has_type], const b4_symbol([$1], [type])[ v]),
b4_locations_if([const location_type& l]))[)
: Base (t)
, value (]b4_symbol_if([$1], [has_type], [v])[)]b4_locations_if([
, location (l)])[
{}
]])
# b4_symbol_constructor_define
# ----------------------------
# Define the overloaded versions of make_symbol for all the value types.
m4_define([b4_symbol_constructor_define],
[ // Implementation of make_symbol for each symbol type.
b4_symbol_foreach([b4_symbol_constructor_define_])])

105
gnuwin32/bin/data/xslt/bison.xsl
View File

@@ -1,105 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
bison.xsl - common templates for Bison XSLT.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
-->
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:bison="http://www.gnu.org/software/bison/">
<xsl:key
name="bison:symbolByName"
match="/bison-xml-report/grammar/nonterminals/nonterminal"
use="@name"
/>
<xsl:key
name="bison:symbolByName"
match="/bison-xml-report/grammar/terminals/terminal"
use="@name"
/>
<xsl:key
name="bison:ruleByNumber"
match="/bison-xml-report/grammar/rules/rule"
use="@number"
/>
<xsl:key
name="bison:ruleByLhs"
match="/bison-xml-report/grammar/rules/rule[
@usefulness != 'useless-in-grammar']"
use="lhs"
/>
<xsl:key
name="bison:ruleByRhs"
match="/bison-xml-report/grammar/rules/rule[
@usefulness != 'useless-in-grammar']"
use="rhs/symbol"
/>
<!-- For the specified state, output: #sr-conflicts,#rr-conflicts -->
<xsl:template match="state" mode="bison:count-conflicts">
<xsl:variable name="transitions" select="actions/transitions"/>
<xsl:variable name="reductions" select="actions/reductions"/>
<xsl:variable
name="terminals"
select="
$transitions/transition[@type='shift']/@symbol
| $reductions/reduction/@symbol
"
/>
<xsl:variable name="conflict-data">
<xsl:for-each select="$terminals">
<xsl:variable name="name" select="."/>
<xsl:if test="generate-id($terminals[. = $name][1]) = generate-id(.)">
<xsl:variable
name="shift-count"
select="count($transitions/transition[@symbol=$name])"
/>
<xsl:variable
name="reduce-count"
select="count($reductions/reduction[@symbol=$name])"
/>
<xsl:if test="$shift-count > 0 and $reduce-count > 0">
<xsl:text>s</xsl:text>
</xsl:if>
<xsl:if test="$reduce-count > 1">
<xsl:text>r</xsl:text>
</xsl:if>
</xsl:if>
</xsl:for-each>
</xsl:variable>
<xsl:value-of select="string-length(translate($conflict-data, 'r', ''))"/>
<xsl:text>,</xsl:text>
<xsl:value-of select="string-length(translate($conflict-data, 's', ''))"/>
</xsl:template>
<xsl:template name="space">
<xsl:param name="repeat">0</xsl:param>
<xsl:param name="fill" select="' '"/>
<xsl:if test="number($repeat) &gt;= 1">
<xsl:call-template name="space">
<xsl:with-param name="repeat" select="$repeat - 1"/>
<xsl:with-param name="fill" select="$fill"/>
</xsl:call-template>
<xsl:value-of select="$fill"/>
</xsl:if>
</xsl:template>
</xsl:stylesheet>

397
gnuwin32/bin/data/xslt/xml2dot.xsl
View File

@@ -1,397 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
xml2dot.xsl - transform Bison XML Report into DOT.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Written by Wojciech Polak <polak@gnu.org>.
-->
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:bison="http://www.gnu.org/software/bison/">
<xsl:import href="bison.xsl"/>
<xsl:output method="text" encoding="UTF-8" indent="no"/>
<xsl:template match="/">
<xsl:apply-templates select="bison-xml-report"/>
</xsl:template>
<xsl:template match="bison-xml-report">
<xsl:text>// Generated by GNU Bison </xsl:text>
<xsl:value-of select="@version"/>
<xsl:text>.&#10;</xsl:text>
<xsl:text>// Report bugs to &lt;</xsl:text>
<xsl:value-of select="@bug-report"/>
<xsl:text>&gt;.&#10;</xsl:text>
<xsl:text>// Home page: &lt;</xsl:text>
<xsl:value-of select="@url"/>
<xsl:text>&gt;.&#10;&#10;</xsl:text>
<xsl:apply-templates select="automaton">
<xsl:with-param name="filename" select="filename"/>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="automaton">
<xsl:param name="filename"/>
<xsl:text>digraph "</xsl:text>
<xsl:call-template name="escape">
<xsl:with-param name="subject" select="$filename"/>
</xsl:call-template>
<xsl:text>"&#10;{
node [fontname = courier, shape = box, colorscheme = paired6]
edge [fontname = courier]
</xsl:text>
<xsl:apply-templates select="state"/>
<xsl:text>}&#10;</xsl:text>
</xsl:template>
<xsl:template match="automaton/state">
<xsl:call-template name="output-node">
<xsl:with-param name="number" select="@number"/>
<xsl:with-param name="label">
<xsl:apply-templates select="itemset/item"/>
</xsl:with-param>
</xsl:call-template>
<xsl:apply-templates select="actions/transitions"/>
<xsl:apply-templates select="actions/reductions">
<xsl:with-param name="staten">
<xsl:value-of select="@number"/>
</xsl:with-param>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="actions/reductions">
<xsl:param name="staten"/>
<xsl:for-each select='reduction'>
<!-- These variables are needed because the current context can't be
refered to directly in XPath expressions. -->
<xsl:variable name="rul">
<xsl:value-of select="@rule"/>
</xsl:variable>
<xsl:variable name="ena">
<xsl:value-of select="@enabled"/>
</xsl:variable>
<!-- The foreach's body is protected by this, so that we are actually
going to iterate once per reduction rule, and not per lookahead. -->
<xsl:if test='not(preceding-sibling::*[@rule=$rul and @enabled=$ena])'>
<xsl:variable name="rule">
<xsl:choose>
<!-- The acceptation state is refered to as 'accept' in the XML, but
just as '0' in the DOT. -->
<xsl:when test="@rule='accept'">
<xsl:text>0</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="@rule"/>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<!-- The edge's beginning -->
<xsl:call-template name="reduction-edge-start">
<xsl:with-param name="state" select="$staten"/>
<xsl:with-param name="rule" select="$rule"/>
<xsl:with-param name="enabled" select="@enabled"/>
</xsl:call-template>
<!-- The edge's tokens -->
<!-- Don't show labels for the default action. In other cases, there will
always be at least one token, so 'label="[]"' will not occur. -->
<xsl:if test='$rule!=0 and not(../reduction[@enabled=$ena and @rule=$rule and @symbol="$default"])'>
<xsl:text>label="[</xsl:text>
<xsl:for-each select='../reduction[@enabled=$ena and @rule=$rule]'>
<xsl:call-template name="escape">
<xsl:with-param name="subject" select="@symbol"/>
</xsl:call-template>
<xsl:if test="position() != last ()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>]", </xsl:text>
</xsl:if>
<!-- The edge's end -->
<xsl:text>style=solid]&#10;</xsl:text>
<!-- The diamond representing the reduction -->
<xsl:call-template name="reduction-node">
<xsl:with-param name="state" select="$staten"/>
<xsl:with-param name="rule" select="$rule"/>
<xsl:with-param name="color">
<xsl:choose>
<xsl:when test='@enabled="true"'>
<xsl:text>3</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>5</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:with-param>
</xsl:call-template>
</xsl:if>
</xsl:for-each>
</xsl:template>
<xsl:template match="actions/transitions">
<xsl:apply-templates select="transition"/>
</xsl:template>
<xsl:template match="item">
<xsl:param name="prev-rule-number"
select="preceding-sibling::item[1]/@rule-number"/>
<xsl:apply-templates select="key('bison:ruleByNumber', @rule-number)">
<xsl:with-param name="point" select="@point"/>
<xsl:with-param name="num" select="@rule-number"/>
<xsl:with-param name="prev-lhs"
select="key('bison:ruleByNumber', $prev-rule-number)/lhs[text()]"
/>
</xsl:apply-templates>
<xsl:apply-templates select="lookaheads"/>
</xsl:template>
<xsl:template match="rule">
<xsl:param name="point"/>
<xsl:param name="num"/>
<xsl:param name="prev-lhs"/>
<xsl:text>&#10;</xsl:text>
<xsl:choose>
<xsl:when test="$num &lt; 10">
<xsl:text> </xsl:text>
</xsl:when>
<xsl:when test="$num &lt; 100">
<xsl:text> </xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text></xsl:text>
</xsl:otherwise>
</xsl:choose>
<xsl:value-of select="$num"/>
<xsl:text> </xsl:text>
<xsl:choose>
<xsl:when test="$prev-lhs = lhs[text()]">
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="'|'"/>
<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 1"/>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="lhs"/>
<xsl:text>:</xsl:text>
</xsl:otherwise>
</xsl:choose>
<xsl:if test="$point = 0">
<xsl:text> .</xsl:text>
</xsl:if>
<xsl:for-each select="rhs/symbol|rhs/empty">
<xsl:apply-templates select="."/>
<xsl:if test="$point = position()">
<xsl:text> .</xsl:text>
</xsl:if>
</xsl:for-each>
</xsl:template>
<xsl:template match="symbol">
<xsl:text> </xsl:text>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="empty"/>
<xsl:template match="lookaheads">
<xsl:text> [</xsl:text>
<xsl:apply-templates select="symbol"/>
<xsl:text>]</xsl:text>
</xsl:template>
<xsl:template match="lookaheads/symbol">
<xsl:value-of select="."/>
<xsl:if test="position() != last()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:template>
<xsl:template name="reduction-edge-start">
<xsl:param name="state"/>
<xsl:param name="rule"/>
<xsl:param name="enabled"/>
<xsl:text> </xsl:text>
<xsl:value-of select="$state"/>
<xsl:text> -> "</xsl:text>
<xsl:value-of select="$state"/>
<xsl:text>R</xsl:text>
<xsl:value-of select="$rule"/>
<xsl:if test='$enabled = "false"'>
<xsl:text>d</xsl:text>
</xsl:if>
<xsl:text>" [</xsl:text>
</xsl:template>
<xsl:template name="reduction-node">
<xsl:param name="state"/>
<xsl:param name="rule"/>
<xsl:param name="color"/>
<xsl:text> "</xsl:text>
<xsl:value-of select="$state"/>
<xsl:text>R</xsl:text>
<xsl:value-of select="$rule"/>
<xsl:if test="$color = 5">
<xsl:text>d</xsl:text>
</xsl:if>
<xsl:text>" [label="</xsl:text>
<xsl:choose>
<xsl:when test="$rule = 0">
<xsl:text>Acc", fillcolor=1</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>R</xsl:text>
<xsl:value-of select="$rule"/>
<xsl:text>", fillcolor=</xsl:text>
<xsl:value-of select="$color"/>
</xsl:otherwise>
</xsl:choose>
<xsl:text>, shape=diamond, style=filled]&#10;</xsl:text>
</xsl:template>
<xsl:template match="transition">
<xsl:call-template name="output-edge">
<xsl:with-param name="src" select="../../../@number"/>
<xsl:with-param name="dst" select="@state"/>
<xsl:with-param name="style">
<xsl:choose>
<xsl:when test="@symbol = 'error'">
<xsl:text>dotted</xsl:text>
</xsl:when>
<xsl:when test="@type = 'shift'">
<xsl:text>solid</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>dashed</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:with-param>
<xsl:with-param name="label">
<xsl:if test="not(@symbol = 'error')">
<xsl:value-of select="@symbol"/>
</xsl:if>
</xsl:with-param>
</xsl:call-template>
</xsl:template>
<xsl:template name="output-node">
<xsl:param name="number"/>
<xsl:param name="label"/>
<xsl:text> </xsl:text>
<xsl:value-of select="$number"/>
<xsl:text> [label="</xsl:text>
<xsl:text>State </xsl:text>
<xsl:value-of select="$number"/>
<xsl:text>\n</xsl:text>
<xsl:call-template name="escape">
<xsl:with-param name="subject" select="$label"/>
</xsl:call-template>
<xsl:text>\l"]&#10;</xsl:text>
</xsl:template>
<xsl:template name="output-edge">
<xsl:param name="src"/>
<xsl:param name="dst"/>
<xsl:param name="style"/>
<xsl:param name="label"/>
<xsl:text> </xsl:text>
<xsl:value-of select="$src"/>
<xsl:text> -> </xsl:text>
<xsl:value-of select="$dst"/>
<xsl:text> [style=</xsl:text>
<xsl:value-of select="$style"/>
<xsl:if test="$label and $label != ''">
<xsl:text> label="</xsl:text>
<xsl:call-template name="escape">
<xsl:with-param name="subject" select="$label"/>
</xsl:call-template>
<xsl:text>"</xsl:text>
</xsl:if>
<xsl:text>]&#10;</xsl:text>
</xsl:template>
<xsl:template name="escape">
<xsl:param name="subject"/> <!-- required -->
<xsl:call-template name="string-replace">
<xsl:with-param name="subject">
<xsl:call-template name="string-replace">
<xsl:with-param name="subject">
<xsl:call-template name="string-replace">
<xsl:with-param name="subject" select="$subject"/>
<xsl:with-param name="search" select="'\'"/>
<xsl:with-param name="replace" select="'\\'"/>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="search" select="'&quot;'"/>
<xsl:with-param name="replace" select="'\&quot;'"/>
</xsl:call-template>
</xsl:with-param>
<xsl:with-param name="search" select="'&#10;'"/>
<xsl:with-param name="replace" select="'\l'"/>
</xsl:call-template>
</xsl:template>
<xsl:template name="string-replace">
<xsl:param name="subject"/>
<xsl:param name="search"/>
<xsl:param name="replace"/>
<xsl:choose>
<xsl:when test="contains($subject, $search)">
<xsl:variable name="before" select="substring-before($subject, $search)"/>
<xsl:variable name="after" select="substring-after($subject, $search)"/>
<xsl:value-of select="$before"/>
<xsl:value-of select="$replace"/>
<xsl:call-template name="string-replace">
<xsl:with-param name="subject" select="$after"/>
<xsl:with-param name="search" select="$search"/>
<xsl:with-param name="replace" select="$replace"/>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$subject"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="lpad">
<xsl:param name="str" select="''"/>
<xsl:param name="pad" select="0"/>
<xsl:variable name="diff" select="$pad - string-length($str)" />
<xsl:choose>
<xsl:when test="$diff &lt; 0">
<xsl:value-of select="$str"/>
</xsl:when>
<xsl:otherwise>
<xsl:call-template name="space">
<xsl:with-param name="repeat" select="$diff"/>
</xsl:call-template>
<xsl:value-of select="$str"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>

569
gnuwin32/bin/data/xslt/xml2text.xsl
View File

@@ -1,569 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
xml2text.xsl - transform Bison XML Report into plain text.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Written by Wojciech Polak <polak@gnu.org>.
-->
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:bison="http://www.gnu.org/software/bison/">
<xsl:import href="bison.xsl"/>
<xsl:output method="text" encoding="UTF-8" indent="no"/>
<xsl:template match="/">
<xsl:apply-templates select="bison-xml-report"/>
</xsl:template>
<xsl:template match="bison-xml-report">
<xsl:apply-templates select="grammar" mode="reductions"/>
<xsl:apply-templates select="grammar" mode="useless-in-parser"/>
<xsl:apply-templates select="automaton" mode="conflicts"/>
<xsl:apply-templates select="grammar"/>
<xsl:apply-templates select="automaton"/>
</xsl:template>
<xsl:template match="grammar" mode="reductions">
<xsl:apply-templates select="nonterminals" mode="useless-in-grammar"/>
<xsl:apply-templates select="terminals" mode="unused-in-grammar"/>
<xsl:apply-templates select="rules" mode="useless-in-grammar"/>
</xsl:template>
<xsl:template match="nonterminals" mode="useless-in-grammar">
<xsl:if test="nonterminal[@usefulness='useless-in-grammar']">
<xsl:text>Nonterminals useless in grammar&#10;&#10;</xsl:text>
<xsl:for-each select="nonterminal[@usefulness='useless-in-grammar']">
<xsl:text> </xsl:text>
<xsl:value-of select="@name"/>
<xsl:text>&#10;</xsl:text>
</xsl:for-each>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="terminals" mode="unused-in-grammar">
<xsl:if test="terminal[@usefulness='unused-in-grammar']">
<xsl:text>Terminals unused in grammar&#10;&#10;</xsl:text>
<xsl:for-each select="terminal[@usefulness='unused-in-grammar']">
<xsl:sort select="@symbol-number" data-type="number"/>
<xsl:text> </xsl:text>
<xsl:value-of select="@name"/>
<xsl:text>&#10;</xsl:text>
</xsl:for-each>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="rules" mode="useless-in-grammar">
<xsl:variable name="set" select="rule[@usefulness='useless-in-grammar']"/>
<xsl:if test="$set">
<xsl:text>Rules useless in grammar&#10;</xsl:text>
<xsl:call-template name="style-rule-set">
<xsl:with-param name="rule-set" select="$set"/>
</xsl:call-template>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="grammar" mode="useless-in-parser">
<xsl:variable
name="set" select="rules/rule[@usefulness='useless-in-parser']"
/>
<xsl:if test="$set">
<xsl:text>Rules useless in parser due to conflicts&#10;</xsl:text>
<xsl:call-template name="style-rule-set">
<xsl:with-param name="rule-set" select="$set"/>
</xsl:call-template>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="grammar">
<xsl:text>Grammar&#10;</xsl:text>
<xsl:call-template name="style-rule-set">
<xsl:with-param
name="rule-set" select="rules/rule[@usefulness!='useless-in-grammar']"
/>
</xsl:call-template>
<xsl:text>&#10;&#10;</xsl:text>
<xsl:apply-templates select="terminals"/>
<xsl:apply-templates select="nonterminals"/>
</xsl:template>
<xsl:template name="style-rule-set">
<xsl:param name="rule-set"/>
<xsl:for-each select="$rule-set">
<xsl:apply-templates select=".">
<xsl:with-param name="pad" select="'3'"/>
<xsl:with-param name="prev-lhs">
<xsl:if test="position()>1">
<xsl:variable name="position" select="position()"/>
<xsl:value-of select="$rule-set[$position - 1]/lhs"/>
</xsl:if>
</xsl:with-param>
</xsl:apply-templates>
</xsl:for-each>
</xsl:template>
<xsl:template match="grammar/terminals">
<xsl:text>Terminals, with rules where they appear&#10;&#10;</xsl:text>
<xsl:apply-templates select="terminal"/>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:template>
<xsl:template match="grammar/nonterminals">
<xsl:text>Nonterminals, with rules where they appear&#10;&#10;</xsl:text>
<xsl:apply-templates select="nonterminal[@usefulness!='useless-in-grammar']"/>
</xsl:template>
<xsl:template match="terminal">
<xsl:value-of select="@name"/>
<xsl:call-template name="line-wrap">
<xsl:with-param name="first-line-length">
<xsl:choose>
<xsl:when test="string-length(@name) &gt; 66">0</xsl:when>
<xsl:otherwise>
<xsl:value-of select="66 - string-length(@name)" />
</xsl:otherwise>
</xsl:choose>
</xsl:with-param>
<xsl:with-param name="line-length" select="66" />
<xsl:with-param name="text">
<xsl:value-of select="concat(' (', @token-number, ')')"/>
<xsl:for-each select="key('bison:ruleByRhs', @name)">
<xsl:value-of select="concat(' ', @number)"/>
</xsl:for-each>
</xsl:with-param>
</xsl:call-template>
</xsl:template>
<xsl:template match="nonterminal">
<xsl:value-of select="@name"/>
<xsl:value-of select="concat(' (', @symbol-number, ')')"/>
<xsl:text>&#10;</xsl:text>
<xsl:variable name="output">
<xsl:call-template name="line-wrap">
<xsl:with-param name="line-length" select="66" />
<xsl:with-param name="text">
<xsl:text> </xsl:text>
<xsl:if test="key('bison:ruleByLhs', @name)">
<xsl:text>on@left:</xsl:text>
<xsl:for-each select="key('bison:ruleByLhs', @name)">
<xsl:value-of select="concat(' ', @number)"/>
</xsl:for-each>
</xsl:if>
<xsl:if test="key('bison:ruleByRhs', @name)">
<xsl:if test="key('bison:ruleByLhs', @name)">
<xsl:text>, </xsl:text>
</xsl:if>
<xsl:text>on@right:</xsl:text>
<xsl:for-each select="key('bison:ruleByRhs', @name)">
<xsl:value-of select="concat(' ', @number)"/>
</xsl:for-each>
</xsl:if>
</xsl:with-param>
</xsl:call-template>
</xsl:variable>
<xsl:value-of select="translate($output, '@', ' ')" />
</xsl:template>
<xsl:template match="automaton" mode="conflicts">
<xsl:variable name="conflict-report">
<xsl:apply-templates select="state" mode="conflicts"/>
</xsl:variable>
<xsl:if test="string-length($conflict-report) != 0">
<xsl:value-of select="$conflict-report"/>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="state" mode="conflicts">
<xsl:variable name="conflict-counts">
<xsl:apply-templates select="." mode="bison:count-conflicts" />
</xsl:variable>
<xsl:variable
name="sr-count" select="substring-before($conflict-counts, ',')"
/>
<xsl:variable
name="rr-count" select="substring-after($conflict-counts, ',')"
/>
<xsl:if test="$sr-count > 0 or $rr-count > 0">
<xsl:value-of select="concat('State ', @number, ' conflicts:')"/>
<xsl:if test="$sr-count > 0">
<xsl:value-of select="concat(' ', $sr-count, ' shift/reduce')"/>
<xsl:if test="$rr-count > 0">
<xsl:value-of select="(',')"/>
</xsl:if>
</xsl:if>
<xsl:if test="$rr-count > 0">
<xsl:value-of select="concat(' ', $rr-count, ' reduce/reduce')"/>
</xsl:if>
<xsl:value-of select="'&#10;'"/>
</xsl:if>
</xsl:template>
<xsl:template match="automaton">
<xsl:apply-templates select="state">
<xsl:with-param name="pad" select="'3'"/>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="automaton/state">
<xsl:param name="pad"/>
<xsl:text>&#10;&#10;</xsl:text>
<xsl:text>State </xsl:text>
<xsl:value-of select="@number"/>
<xsl:text>&#10;&#10;</xsl:text>
<xsl:apply-templates select="itemset/item">
<xsl:with-param name="pad" select="$pad"/>
</xsl:apply-templates>
<xsl:apply-templates select="actions/transitions">
<xsl:with-param name="type" select="'shift'"/>
</xsl:apply-templates>
<xsl:apply-templates select="actions/errors"/>
<xsl:apply-templates select="actions/reductions"/>
<xsl:apply-templates select="actions/transitions">
<xsl:with-param name="type" select="'goto'"/>
</xsl:apply-templates>
<xsl:apply-templates select="solved-conflicts"/>
</xsl:template>
<xsl:template match="actions/transitions">
<xsl:param name="type"/>
<xsl:if test="transition[@type = $type]">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="transition[@type = $type]">
<xsl:with-param name="pad">
<xsl:call-template name="max-width-symbol">
<xsl:with-param name="node" select="transition[@type = $type]"/>
</xsl:call-template>
</xsl:with-param>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:template match="actions/errors">
<xsl:if test="error">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="error">
<xsl:with-param name="pad">
<xsl:call-template name="max-width-symbol">
<xsl:with-param name="node" select="error"/>
</xsl:call-template>
</xsl:with-param>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:template match="actions/reductions">
<xsl:if test="reduction">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="reduction">
<xsl:with-param name="pad">
<xsl:call-template name="max-width-symbol">
<xsl:with-param name="node" select="reduction"/>
</xsl:call-template>
</xsl:with-param>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:template match="item">
<xsl:param name="pad"/>
<xsl:param name="prev-rule-number"
select="preceding-sibling::item[1]/@rule-number"/>
<xsl:apply-templates
select="key('bison:ruleByNumber', current()/@rule-number)"
>
<xsl:with-param name="itemset" select="'true'"/>
<xsl:with-param name="pad" select="$pad"/>
<xsl:with-param
name="prev-lhs"
select="key('bison:ruleByNumber', $prev-rule-number)/lhs[text()]"
/>
<xsl:with-param name="point" select="@point"/>
<xsl:with-param name="lookaheads">
<xsl:apply-templates select="lookaheads"/>
</xsl:with-param>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="rule">
<xsl:param name="itemset"/>
<xsl:param name="pad"/>
<xsl:param name="prev-lhs"/>
<xsl:param name="point"/>
<xsl:param name="lookaheads"/>
<xsl:if test="$itemset != 'true' and not($prev-lhs = lhs[text()])">
<xsl:text>&#10;</xsl:text>
</xsl:if>
<xsl:text> </xsl:text>
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="string(@number)"/>
<xsl:with-param name="pad" select="number($pad)"/>
</xsl:call-template>
<xsl:text> </xsl:text>
<!-- LHS -->
<xsl:choose>
<xsl:when test="$itemset != 'true' and $prev-lhs = lhs[text()]">
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="'|'"/>
<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 1"/>
</xsl:call-template>
</xsl:when>
<xsl:when test="$itemset = 'true' and $prev-lhs = lhs[text()]">
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="'|'"/>
<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 1"/>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="lhs"/>
<xsl:text>:</xsl:text>
</xsl:otherwise>
</xsl:choose>
<!-- RHS -->
<xsl:for-each select="rhs/*">
<xsl:if test="position() = $point + 1">
<xsl:text> .</xsl:text>
</xsl:if>
<xsl:if test="$itemset = 'true' and name(.) != 'empty'">
<xsl:apply-templates select="."/>
</xsl:if>
<xsl:if test="$itemset != 'true'">
<xsl:apply-templates select="."/>
</xsl:if>
<xsl:if test="position() = last() and position() = $point">
<xsl:text> .</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:if test="$lookaheads">
<xsl:value-of select="$lookaheads"/>
</xsl:if>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="symbol">
<xsl:text> </xsl:text>
<xsl:value-of select="."/>
</xsl:template>
<xsl:template match="empty">
<xsl:text> %empty</xsl:text>
</xsl:template>
<xsl:template match="lookaheads">
<xsl:text> [</xsl:text>
<xsl:apply-templates select="symbol"/>
<xsl:text>]</xsl:text>
</xsl:template>
<xsl:template match="lookaheads/symbol">
<xsl:value-of select="."/>
<xsl:if test="position() != last()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="transition">
<xsl:param name="pad"/>
<xsl:text> </xsl:text>
<xsl:call-template name="rpad">
<xsl:with-param name="str" select="string(@symbol)"/>
<xsl:with-param name="pad" select="number($pad) + 2"/>
</xsl:call-template>
<xsl:choose>
<xsl:when test="@type = 'shift'">
<xsl:text>shift, and go to state </xsl:text>
<xsl:value-of select="@state"/>
</xsl:when>
<xsl:when test="@type = 'goto'">
<xsl:text>go to state </xsl:text>
<xsl:value-of select="@state"/>
</xsl:when>
</xsl:choose>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="error">
<xsl:param name="pad"/>
<xsl:text> </xsl:text>
<xsl:call-template name="rpad">
<xsl:with-param name="str" select="string(@symbol)"/>
<xsl:with-param name="pad" select="number($pad) + 2"/>
</xsl:call-template>
<xsl:text>error</xsl:text>
<xsl:text> (</xsl:text>
<xsl:value-of select="text()"/>
<xsl:text>)</xsl:text>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="reduction">
<xsl:param name="pad"/>
<xsl:text> </xsl:text>
<xsl:call-template name="rpad">
<xsl:with-param name="str" select="string(@symbol)"/>
<xsl:with-param name="pad" select="number($pad) + 2"/>
</xsl:call-template>
<xsl:if test="@enabled = 'false'">
<xsl:text>[</xsl:text>
</xsl:if>
<xsl:choose>
<xsl:when test="@rule = 'accept'">
<xsl:text>accept</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>reduce using rule </xsl:text>
<xsl:value-of select="@rule"/>
<xsl:text> (</xsl:text>
<xsl:value-of
select="key('bison:ruleByNumber', current()/@rule)/lhs[text()]"/>
<xsl:text>)</xsl:text>
</xsl:otherwise>
</xsl:choose>
<xsl:if test="@enabled = 'false'">
<xsl:text>]</xsl:text>
</xsl:if>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="solved-conflicts">
<xsl:if test="resolution">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="resolution"/>
</xsl:if>
</xsl:template>
<xsl:template match="resolution">
<xsl:text> Conflict between rule </xsl:text>
<xsl:value-of select="@rule"/>
<xsl:text> and token </xsl:text>
<xsl:value-of select="@symbol"/>
<xsl:text> resolved as </xsl:text>
<xsl:if test="@type = 'error'">
<xsl:text>an </xsl:text>
</xsl:if>
<xsl:value-of select="@type"/>
<xsl:text> (</xsl:text>
<xsl:value-of select="."/>
<xsl:text>).&#10;</xsl:text>
</xsl:template>
<xsl:template name="max-width-symbol">
<xsl:param name="node"/>
<xsl:variable name="longest">
<xsl:for-each select="$node">
<xsl:sort data-type="number" select="string-length(@symbol)"
order="descending"/>
<xsl:if test="position() = 1">
<xsl:value-of select="string-length(@symbol)"/>
</xsl:if>
</xsl:for-each>
</xsl:variable>
<xsl:value-of select="$longest"/>
</xsl:template>
<xsl:template name="lpad">
<xsl:param name="str" select="''"/>
<xsl:param name="pad" select="0"/>
<xsl:variable name="diff" select="$pad - string-length($str)" />
<xsl:choose>
<xsl:when test="$diff &lt; 0">
<xsl:value-of select="$str"/>
</xsl:when>
<xsl:otherwise>
<xsl:call-template name="space">
<xsl:with-param name="repeat" select="$diff"/>
</xsl:call-template>
<xsl:value-of select="$str"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="rpad">
<xsl:param name="str" select="''"/>
<xsl:param name="pad" select="0"/>
<xsl:variable name="diff" select="$pad - string-length($str)"/>
<xsl:choose>
<xsl:when test="$diff &lt; 0">
<xsl:value-of select="$str"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$str"/>
<xsl:call-template name="space">
<xsl:with-param name="repeat" select="$diff"/>
</xsl:call-template>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="line-wrap">
<xsl:param name="line-length"/> <!-- required -->
<xsl:param name="first-line-length" select="$line-length"/>
<xsl:param name="text"/> <!-- required -->
<xsl:choose>
<xsl:when test="normalize-space($text) = ''" />
<xsl:when test="string-length($text) &lt;= $first-line-length">
<xsl:value-of select="concat($text, '&#10;')" />
</xsl:when>
<xsl:otherwise>
<xsl:variable name="break-pos">
<xsl:call-template name="ws-search">
<xsl:with-param name="text" select="$text" />
<xsl:with-param name="start" select="$first-line-length+1" />
</xsl:call-template>
</xsl:variable>
<xsl:value-of select="substring($text, 1, $break-pos - 1)" />
<xsl:text>&#10;</xsl:text>
<xsl:call-template name="line-wrap">
<xsl:with-param name="line-length" select="$line-length" />
<xsl:with-param
name="text" select="concat(' ', substring($text, $break-pos+1))"
/>
</xsl:call-template>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="ws-search">
<xsl:param name="text"/> <!-- required -->
<xsl:param name="start"/> <!-- required -->
<xsl:variable name="search-text" select="substring($text, $start)" />
<xsl:choose>
<xsl:when test="not(contains($search-text, ' '))">
<xsl:value-of select="string-length($text)+1" />
</xsl:when>
<xsl:otherwise>
<xsl:value-of
select="$start + string-length(substring-before($search-text, ' '))"
/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>

745
gnuwin32/bin/data/xslt/xml2xhtml.xsl
View File

@@ -1,745 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
xml2html.xsl - transform Bison XML Report into XHTML.
Copyright (C) 2007-2013 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Written by Wojciech Polak <polak@gnu.org>.
-->
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:bison="http://www.gnu.org/software/bison/">
<xsl:import href="bison.xsl"/>
<xsl:output method="xml" encoding="UTF-8"
doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
indent="yes"/>
<xsl:template match="/">
<html>
<head>
<title>
<xsl:value-of select="bison-xml-report/filename"/>
<xsl:text> - GNU Bison XML Automaton Report</xsl:text>
</title>
<style type="text/css"><![CDATA[
body {
font-family: "Nimbus Sans L", Arial, sans-serif;
font-size: 9pt;
}
a:link {
color: #1f00ff;
text-decoration: none;
}
a:visited {
color: #1f00ff;
text-decoration: none;
}
a:hover {
color: red;
}
#menu a {
text-decoration: underline;
}
.i {
font-style: italic;
}
.pre {
font-family: monospace;
white-space: pre;
}
ol.decimal {
list-style-type: decimal;
}
ol.lower-alpha {
list-style-type: lower-alpha;
}
.point {
color: #cc0000;
}
#footer {
margin-top: 3.5em;
font-size: 7pt;
}
]]></style>
</head>
<body>
<xsl:apply-templates select="bison-xml-report"/>
<xsl:text>&#10;&#10;</xsl:text>
<div id="footer"><hr />This document was generated using
<a href="http://www.gnu.org/software/bison/" title="GNU Bison">
GNU Bison <xsl:value-of select="/bison-xml-report/@version"/></a>
XML Automaton Report.<br />
<!-- default copying notice -->
Verbatim copying and distribution of this entire page is
permitted in any medium, provided this notice is preserved.</div>
</body>
</html>
</xsl:template>
<xsl:template match="bison-xml-report">
<h1>GNU Bison XML Automaton Report</h1>
<p>
input grammar: <span class="i"><xsl:value-of select="filename"/></span>
</p>
<xsl:text>&#10;&#10;</xsl:text>
<h3>Table of Contents</h3>
<ul id="menu">
<li>
<a href="#reductions">Reductions</a>
<ul class="lower-alpha">
<li><a href="#nonterminals_useless_in_grammar">Nonterminals useless in grammar</a></li>
<li><a href="#terminals_unused_in_grammar">Terminals unused in grammar</a></li>
<li><a href="#rules_useless_in_grammar">Rules useless in grammar</a></li>
<xsl:if test="grammar/rules/rule[@usefulness='useless-in-parser']">
<li><a href="#rules_useless_in_parser">Rules useless in parser due to conflicts</a></li>
</xsl:if>
</ul>
</li>
<li><a href="#conflicts">Conflicts</a></li>
<li>
<a href="#grammar">Grammar</a>
<ul class="lower-alpha">
<li><a href="#grammar">Itemset</a></li>
<li><a href="#terminals">Terminal symbols</a></li>
<li><a href="#nonterminals">Nonterminal symbols</a></li>
</ul>
</li>
<li><a href="#automaton">Automaton</a></li>
</ul>
<xsl:apply-templates select="grammar" mode="reductions"/>
<xsl:apply-templates select="grammar" mode="useless-in-parser"/>
<xsl:apply-templates select="automaton" mode="conflicts"/>
<xsl:apply-templates select="grammar"/>
<xsl:apply-templates select="automaton"/>
</xsl:template>
<xsl:template match="grammar" mode="reductions">
<h2>
<a name="reductions"/>
<xsl:text> Reductions</xsl:text>
</h2>
<xsl:apply-templates select="nonterminals" mode="useless-in-grammar"/>
<xsl:apply-templates select="terminals" mode="unused-in-grammar"/>
<xsl:apply-templates select="rules" mode="useless-in-grammar"/>
</xsl:template>
<xsl:template match="nonterminals" mode="useless-in-grammar">
<h3>
<a name="nonterminals_useless_in_grammar"/>
<xsl:text> Nonterminals useless in grammar</xsl:text>
</h3>
<xsl:text>&#10;&#10;</xsl:text>
<xsl:if test="nonterminal[@usefulness='useless-in-grammar']">
<p class="pre">
<xsl:for-each select="nonterminal[@usefulness='useless-in-grammar']">
<xsl:text> </xsl:text>
<xsl:value-of select="@name"/>
<xsl:text>&#10;</xsl:text>
</xsl:for-each>
<xsl:text>&#10;&#10;</xsl:text>
</p>
</xsl:if>
</xsl:template>
<xsl:template match="terminals" mode="unused-in-grammar">
<h3>
<a name="terminals_unused_in_grammar"/>
<xsl:text> Terminals unused in grammar</xsl:text>
</h3>
<xsl:text>&#10;&#10;</xsl:text>
<xsl:if test="terminal[@usefulness='unused-in-grammar']">
<p class="pre">
<xsl:for-each select="terminal[@usefulness='unused-in-grammar']">
<xsl:sort select="@symbol-number" data-type="number"/>
<xsl:text> </xsl:text>
<xsl:value-of select="@name"/>
<xsl:text>&#10;</xsl:text>
</xsl:for-each>
<xsl:text>&#10;&#10;</xsl:text>
</p>
</xsl:if>
</xsl:template>
<xsl:template match="rules" mode="useless-in-grammar">
<h3>
<a name="rules_useless_in_grammar"/>
<xsl:text> Rules useless in grammar</xsl:text>
</h3>
<xsl:text>&#10;</xsl:text>
<xsl:variable name="set" select="rule[@usefulness='useless-in-grammar']"/>
<xsl:if test="$set">
<p class="pre">
<xsl:call-template name="style-rule-set">
<xsl:with-param name="rule-set" select="$set"/>
</xsl:call-template>
<xsl:text>&#10;&#10;</xsl:text>
</p>
</xsl:if>
</xsl:template>
<xsl:template match="grammar" mode="useless-in-parser">
<xsl:variable
name="set" select="rules/rule[@usefulness='useless-in-parser']"
/>
<xsl:if test="$set">
<h2>
<a name="rules_useless_in_parser"/>
<xsl:text> Rules useless in parser due to conflicts</xsl:text>
</h2>
<xsl:text>&#10;</xsl:text>
<p class="pre">
<xsl:call-template name="style-rule-set">
<xsl:with-param name="rule-set" select="$set"/>
</xsl:call-template>
</p>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="grammar">
<h2>
<a name="grammar"/>
<xsl:text> Grammar</xsl:text>
</h2>
<xsl:text>&#10;</xsl:text>
<p class="pre">
<xsl:call-template name="style-rule-set">
<xsl:with-param
name="rule-set" select="rules/rule[@usefulness!='useless-in-grammar']"
/>
</xsl:call-template>
</p>
<xsl:text>&#10;&#10;</xsl:text>
<xsl:apply-templates select="terminals"/>
<xsl:apply-templates select="nonterminals"/>
</xsl:template>
<xsl:template name="style-rule-set">
<xsl:param name="rule-set"/>
<xsl:for-each select="$rule-set">
<xsl:apply-templates select=".">
<xsl:with-param name="pad" select="'3'"/>
<xsl:with-param name="prev-lhs">
<xsl:if test="position()>1">
<xsl:variable name="position" select="position()"/>
<xsl:value-of select="$rule-set[$position - 1]/lhs"/>
</xsl:if>
</xsl:with-param>
</xsl:apply-templates>
</xsl:for-each>
</xsl:template>
<xsl:template match="automaton" mode="conflicts">
<h2>
<a name="conflicts"/>
<xsl:text> Conflicts</xsl:text>
</h2>
<xsl:text>&#10;&#10;</xsl:text>
<xsl:variable name="conflict-report">
<xsl:apply-templates select="state" mode="conflicts"/>
</xsl:variable>
<xsl:if test="string-length($conflict-report) != 0">
<p class="pre">
<xsl:copy-of select="$conflict-report"/>
<xsl:text>&#10;&#10;</xsl:text>
</p>
</xsl:if>
</xsl:template>
<xsl:template match="state" mode="conflicts">
<xsl:variable name="conflict-counts">
<xsl:apply-templates select="." mode="bison:count-conflicts" />
</xsl:variable>
<xsl:variable
name="sr-count" select="substring-before($conflict-counts, ',')"
/>
<xsl:variable
name="rr-count" select="substring-after($conflict-counts, ',')"
/>
<xsl:if test="$sr-count > 0 or $rr-count > 0">
<a>
<xsl:attribute name="href">
<xsl:value-of select="concat('#state_', @number)"/>
</xsl:attribute>
<xsl:value-of select="concat('State ', @number)"/>
</a>
<xsl:text> conflicts:</xsl:text>
<xsl:if test="$sr-count > 0">
<xsl:value-of select="concat(' ', $sr-count, ' shift/reduce')"/>
<xsl:if test="$rr-count > 0">
<xsl:value-of select="(',')"/>
</xsl:if>
</xsl:if>
<xsl:if test="$rr-count > 0">
<xsl:value-of select="concat(' ', $rr-count, ' reduce/reduce')"/>
</xsl:if>
<xsl:value-of select="'&#10;'"/>
</xsl:if>
</xsl:template>
<xsl:template match="grammar/terminals">
<h3>
<a name="terminals"/>
<xsl:text> Terminals, with rules where they appear</xsl:text>
</h3>
<xsl:text>&#10;&#10;</xsl:text>
<p class="pre">
<xsl:apply-templates select="terminal"/>
</p>
<xsl:text>&#10;&#10;</xsl:text>
</xsl:template>
<xsl:template match="grammar/nonterminals">
<h3>
<a name="nonterminals"/>
<xsl:text> Nonterminals, with rules where they appear</xsl:text>
</h3>
<xsl:text>&#10;&#10;</xsl:text>
<p class="pre">
<xsl:apply-templates
select="nonterminal[@usefulness!='useless-in-grammar']"
/>
</p>
</xsl:template>
<xsl:template match="terminal">
<b><xsl:value-of select="@name"/></b>
<xsl:value-of select="concat(' (', @token-number, ')')"/>
<xsl:for-each select="key('bison:ruleByRhs', @name)">
<xsl:apply-templates select="." mode="number-link"/>
</xsl:for-each>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="nonterminal">
<b><xsl:value-of select="@name"/></b>
<xsl:value-of select="concat(' (', @symbol-number, ')')"/>
<xsl:text>&#10; </xsl:text>
<xsl:if test="key('bison:ruleByLhs', @name)">
<xsl:text>on left:</xsl:text>
<xsl:for-each select="key('bison:ruleByLhs', @name)">
<xsl:apply-templates select="." mode="number-link"/>
</xsl:for-each>
</xsl:if>
<xsl:if test="key('bison:ruleByRhs', @name)">
<xsl:if test="key('bison:ruleByLhs', @name)">
<xsl:text>&#10; </xsl:text>
</xsl:if>
<xsl:text>on right:</xsl:text>
<xsl:for-each select="key('bison:ruleByRhs', @name)">
<xsl:apply-templates select="." mode="number-link"/>
</xsl:for-each>
</xsl:if>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="rule" mode="number-link">
<xsl:text> </xsl:text>
<a>
<xsl:attribute name="href">
<xsl:value-of select="concat('#rule_', @number)"/>
</xsl:attribute>
<xsl:value-of select="@number"/>
</a>
</xsl:template>
<xsl:template match="automaton">
<h2>
<a name="automaton"/>
<xsl:text> Automaton</xsl:text>
</h2>
<xsl:apply-templates select="state">
<xsl:with-param name="pad" select="'3'"/>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="automaton/state">
<xsl:param name="pad"/>
<xsl:text>&#10;&#10;</xsl:text>
<h3>
<a>
<xsl:attribute name="name">
<xsl:value-of select="concat('state_', @number)"/>
</xsl:attribute>
</a>
<xsl:text>state </xsl:text>
<xsl:value-of select="@number"/>
</h3>
<xsl:text>&#10;&#10;</xsl:text>
<p class="pre">
<xsl:apply-templates select="itemset/item">
<xsl:with-param name="pad" select="$pad"/>
</xsl:apply-templates>
<xsl:apply-templates select="actions/transitions">
<xsl:with-param name="type" select="'shift'"/>
</xsl:apply-templates>
<xsl:apply-templates select="actions/errors"/>
<xsl:apply-templates select="actions/reductions"/>
<xsl:apply-templates select="actions/transitions">
<xsl:with-param name="type" select="'goto'"/>
</xsl:apply-templates>
<xsl:apply-templates select="solved-conflicts"/>
</p>
</xsl:template>
<xsl:template match="actions/transitions">
<xsl:param name="type"/>
<xsl:if test="transition[@type = $type]">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="transition[@type = $type]">
<xsl:with-param name="pad">
<xsl:call-template name="max-width-symbol">
<xsl:with-param name="node" select="transition[@type = $type]"/>
</xsl:call-template>
</xsl:with-param>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:template match="actions/errors">
<xsl:if test="error">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="error">
<xsl:with-param name="pad">
<xsl:call-template name="max-width-symbol">
<xsl:with-param name="node" select="error"/>
</xsl:call-template>
</xsl:with-param>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:template match="actions/reductions">
<xsl:if test="reduction">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="reduction">
<xsl:with-param name="pad">
<xsl:call-template name="max-width-symbol">
<xsl:with-param name="node" select="reduction"/>
</xsl:call-template>
</xsl:with-param>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:template match="item">
<xsl:param name="pad"/>
<xsl:param name="prev-rule-number"
select="preceding-sibling::item[1]/@rule-number"/>
<xsl:apply-templates
select="key('bison:ruleByNumber', current()/@rule-number)"
>
<xsl:with-param name="itemset" select="'true'"/>
<xsl:with-param name="pad" select="$pad"/>
<xsl:with-param name="prev-lhs"
select="key('bison:ruleByNumber', $prev-rule-number)/lhs[text()]"
/>
<xsl:with-param name="point" select="@point"/>
<xsl:with-param name="lookaheads">
<xsl:apply-templates select="lookaheads"/>
</xsl:with-param>
</xsl:apply-templates>
</xsl:template>
<xsl:template match="rule">
<xsl:param name="itemset"/>
<xsl:param name="pad"/>
<xsl:param name="prev-lhs"/>
<xsl:param name="point"/>
<xsl:param name="lookaheads"/>
<xsl:if test="$itemset != 'true' and not($prev-lhs = lhs[text()])">
<xsl:text>&#10;</xsl:text>
</xsl:if>
<xsl:if test="$itemset != 'true'">
<a>
<xsl:attribute name="name">
<xsl:value-of select="concat('rule_', @number)"/>
</xsl:attribute>
</a>
</xsl:if>
<xsl:text> </xsl:text>
<xsl:choose>
<xsl:when test="$itemset = 'true'">
<a>
<xsl:attribute name="href">
<xsl:value-of select="concat('#rule_', @number)"/>
</xsl:attribute>
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="string(@number)"/>
<xsl:with-param name="pad" select="number($pad)"/>
</xsl:call-template>
</a>
</xsl:when>
<xsl:otherwise>
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="string(@number)"/>
<xsl:with-param name="pad" select="number($pad)"/>
</xsl:call-template>
</xsl:otherwise>
</xsl:choose>
<xsl:text> </xsl:text>
<!-- LHS -->
<xsl:choose>
<xsl:when test="$itemset != 'true' and $prev-lhs = lhs[text()]">
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="'|'"/>
<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 2"/>
</xsl:call-template>
</xsl:when>
<xsl:when test="$itemset = 'true' and $prev-lhs = lhs[text()]">
<xsl:call-template name="lpad">
<xsl:with-param name="str" select="'|'"/>
<xsl:with-param name="pad" select="number(string-length(lhs[text()])) + 2"/>
</xsl:call-template>
</xsl:when>
<xsl:otherwise>
<span class="i">
<xsl:value-of select="lhs"/>
</span>
<xsl:text> &#8594;</xsl:text>
</xsl:otherwise>
</xsl:choose>
<!-- RHS -->
<xsl:for-each select="rhs/*">
<xsl:if test="position() = $point + 1">
<xsl:text> </xsl:text>
<span class="point">.</span>
</xsl:if>
<xsl:if test="$itemset = 'true' and name(.) != 'empty'">
<xsl:apply-templates select="."/>
</xsl:if>
<xsl:if test="$itemset != 'true'">
<xsl:apply-templates select="."/>
</xsl:if>
<xsl:if test="position() = last() and position() = $point">
<xsl:text> </xsl:text>
<span class="point">.</span>
</xsl:if>
</xsl:for-each>
<xsl:if test="$lookaheads">
<xsl:value-of select="$lookaheads"/>
</xsl:if>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="symbol">
<xsl:text> </xsl:text>
<xsl:choose>
<xsl:when test="name(key('bison:symbolByName', .)) = 'nonterminal'">
<span class="i"><xsl:value-of select="."/></span>
</xsl:when>
<xsl:otherwise>
<b><xsl:value-of select="."/></b>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template match="empty">
<xsl:text> &#949;</xsl:text>
</xsl:template>
<xsl:template match="lookaheads">
<xsl:text> [</xsl:text>
<xsl:apply-templates select="symbol"/>
<xsl:text>]</xsl:text>
</xsl:template>
<xsl:template match="lookaheads/symbol">
<xsl:value-of select="."/>
<xsl:if test="position() != last()">
<xsl:text>, </xsl:text>
</xsl:if>
</xsl:template>
<xsl:template match="transition">
<xsl:param name="pad"/>
<xsl:text> </xsl:text>
<xsl:call-template name="rpad">
<xsl:with-param name="str" select="string(@symbol)"/>
<xsl:with-param name="pad" select="number($pad) + 2"/>
</xsl:call-template>
<xsl:choose>
<xsl:when test="@type = 'shift'">
<a>
<xsl:attribute name="href">
<xsl:value-of select="concat('#state_', @state)"/>
</xsl:attribute>
<xsl:value-of select="concat('shift, and go to state ', @state)"/>
</a>
</xsl:when>
<xsl:when test="@type = 'goto'">
<a>
<xsl:attribute name="href">
<xsl:value-of select="concat('#state_', @state)"/>
</xsl:attribute>
<xsl:value-of select="concat('go to state ', @state)"/>
</a>
</xsl:when>
</xsl:choose>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="error">
<xsl:param name="pad"/>
<xsl:text> </xsl:text>
<xsl:call-template name="rpad">
<xsl:with-param name="str" select="string(@symbol)"/>
<xsl:with-param name="pad" select="number($pad) + 2"/>
</xsl:call-template>
<xsl:text>error</xsl:text>
<xsl:text> (</xsl:text>
<xsl:value-of select="text()"/>
<xsl:text>)</xsl:text>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="reduction">
<xsl:param name="pad"/>
<xsl:text> </xsl:text>
<xsl:call-template name="rpad">
<xsl:with-param name="str" select="string(@symbol)"/>
<xsl:with-param name="pad" select="number($pad) + 2"/>
</xsl:call-template>
<xsl:if test="@enabled = 'false'">
<xsl:text>[</xsl:text>
</xsl:if>
<xsl:choose>
<xsl:when test="@rule = 'accept'">
<xsl:text>accept</xsl:text>
</xsl:when>
<xsl:otherwise>
<a>
<xsl:attribute name="href">
<xsl:value-of select="concat('#rule_', @rule)"/>
</xsl:attribute>
<xsl:value-of select="concat('reduce using rule ', @rule)"/>
</a>
<xsl:text> (</xsl:text>
<xsl:value-of
select="key('bison:ruleByNumber', current()/@rule)/lhs[text()]"
/>
<xsl:text>)</xsl:text>
</xsl:otherwise>
</xsl:choose>
<xsl:if test="@enabled = 'false'">
<xsl:text>]</xsl:text>
</xsl:if>
<xsl:text>&#10;</xsl:text>
</xsl:template>
<xsl:template match="solved-conflicts">
<xsl:if test="resolution">
<xsl:text>&#10;</xsl:text>
<xsl:apply-templates select="resolution"/>
</xsl:if>
</xsl:template>
<xsl:template match="resolution">
<xsl:text> Conflict between </xsl:text>
<a>
<xsl:attribute name="href">
<xsl:value-of select="concat('#rule_', @rule)"/>
</xsl:attribute>
<xsl:value-of select="concat('rule ',@rule)"/>
</a>
<xsl:text> and token </xsl:text>
<xsl:value-of select="@symbol"/>
<xsl:text> resolved as </xsl:text>
<xsl:if test="@type = 'error'">
<xsl:text>an </xsl:text>
</xsl:if>
<xsl:value-of select="@type"/>
<xsl:text> (</xsl:text>
<xsl:value-of select="."/>
<xsl:text>).&#10;</xsl:text>
</xsl:template>
<xsl:template name="max-width-symbol">
<xsl:param name="node"/>
<xsl:variable name="longest">
<xsl:for-each select="$node">
<xsl:sort data-type="number" select="string-length(@symbol)"
order="descending"/>
<xsl:if test="position() = 1">
<xsl:value-of select="string-length(@symbol)"/>
</xsl:if>
</xsl:for-each>
</xsl:variable>
<xsl:value-of select="$longest"/>
</xsl:template>
<xsl:template name="lpad">
<xsl:param name="str" select="''"/>
<xsl:param name="pad" select="0"/>
<xsl:variable name="diff" select="$pad - string-length($str)" />
<xsl:choose>
<xsl:when test="$diff &lt; 0">
<xsl:value-of select="$str"/>
</xsl:when>
<xsl:otherwise>
<xsl:call-template name="space">
<xsl:with-param name="repeat" select="$diff"/>
</xsl:call-template>
<xsl:value-of select="$str"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="rpad">
<xsl:param name="str" select="''"/>
<xsl:param name="pad" select="0"/>
<xsl:variable name="diff" select="$pad - string-length($str)"/>
<xsl:choose>
<xsl:when test="$diff &lt; 0">
<xsl:value-of select="$str"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$str"/>
<xsl:call-template name="space">
<xsl:with-param name="repeat" select="$diff"/>
</xsl:call-template>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="space">
<xsl:param name="repeat">0</xsl:param>
<xsl:param name="fill" select="' '"/>
<xsl:if test="number($repeat) &gt;= 1">
<xsl:call-template name="space">
<xsl:with-param name="repeat" select="$repeat - 1"/>
<xsl:with-param name="fill" select="$fill"/>
</xsl:call-template>
<xsl:value-of select="$fill"/>
</xsl:if>
</xsl:template>
</xsl:stylesheet>

1915
gnuwin32/bin/data/yacc.c
View File

File diff suppressed because it is too large Load Diff

BIN
gnuwin32/bin/flex.exe
View File

Binary file not shown.

BIN
gnuwin32/bin/gperf.exe
View File

Binary file not shown.

BIN
gnuwin32/bin/iconv.exe
View File

Binary file not shown.

BIN
gnuwin32/bin/libcharset1.dll
View File

Binary file not shown.

BIN
gnuwin32/bin/libiconv2.dll
View File

Binary file not shown.

BIN
gnuwin32/bin/libintl3.dll
View File

Binary file not shown.

BIN
gnuwin32/bin/m4.exe
View File

Binary file not shown.

BIN
gnuwin32/bin/regex2.dll
View File

Binary file not shown.

3
gnuwin32/contrib/gperf/3.0.1/depends-GnuWin32.lst
View File

@@ -1,3 +0,0 @@
kernel32.dll
msvcrt.dll
ntdll.dll

54
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1-GnuWin32.README
View File

@@ -1,54 +0,0 @@
* Gperf-3.0.1 for Windows *
===========================
What is it?
-----------
Gperf: generate a perfect hash function from a key set
Description
-----------
GNU gperf is a perfect hash function generator. For a given list of
strings, it produces a hash function and hash table in the form of
C or C++ code, for looking up a value depending on the input string.
The hash function is perfect,' which means that the hash table has
no collisions, and the hash table lookup needs a single string
comparison only. GNU gperf is highly customizable. There are options
for generating C and C++ code, for emitting 'switch' statements or
nested 'ifs' instead of a hash table, and for tuning the algorithm
that gperf uses.
Homepage
--------
http://www.gnu.org/software/gperf/gperf.html
System
------
- MS-Windows 95 / 98 / ME / NT / 2000 / XP with msvcrt.dll
- if msvcrt.dll is not in your Windows/System folder, get it from
Microsoft <http://support.microsoft.com/default.aspx?scid=kb;en-us;259403">
or by installing Internet Explorer 4.0 or higher
<http://www.microsoft.com/windows/ie>
Notes
-----
- Bugs and questions on this MS-Windows port: gnuwin32@users.sourceforge.net
Package Availability
--------------------
- in: http://gnuwin32.sourceforge.net
Sources
-------
- gperf-3.0.1-src.zip
Compilation
-----------
The package has been compiled with GNU auto-tools, GNU make, and Mingw
(GCC for MS-Windows). Any differences from the original sources are given
in gperf-3.0.1-GnuWin32.diffs in gperf-3.0.1-src.zip. Libraries needed
for compilation can be found at the lines starting with 'LIBS = ' in the
Makefiles. Usually, these are standard libraries provided with Mingw, or
libraries from the package itself; 'gw32c' refers to the libgw32c package,
which provides MS-Windows substitutes or stubs for functions normally found in
Unix. For more information, see: http://gnuwin32.sourceforge.net/compile.html
and http://gnuwin32.sourceforge.net/packages/libgw32c.htm.

2
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1-src/AUTHORS
View File

@@ -1,2 +0,0 @@
Douglas C. Schmidt <schmidt@ics.uci.edu>
Bruno Haible <bruno@clisp.org>

340
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1-src/COPYING
View File

@@ -1,340 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307,
USA.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

3185
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1-src/ChangeLog
View File

File diff suppressed because it is too large Load Diff

183
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1-src/INSTALL
View File

@@ -1,183 +0,0 @@
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, a file
`config.cache' that saves the results of its tests to speed up
reconfiguring, and a file `config.log' containing compiler output
(useful mainly for debugging `configure').
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If at some point `config.cache'
contains results you don't want to keep, you may remove or edit it.
The file `configure.in' is used to create `configure' by a program
called `autoconf'. You only need `configure.in' if you want to change
it or regenerate `configure' using a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes a while. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Optionally, type `make check' to run any self-tests that come with
the package.
4. Type `make install' to install the programs and any data files and
documentation.
5. You can remove the program binaries and object files from the
source code directory by typing `make clean'. To also remove the
files that `configure' created (so you can compile the package for
a different kind of computer), type `make distclean'. There is
also a `make maintainer-clean' target, but that is intended mainly
for the package's developers. If you use it, you may have to get
all sorts of other programs in order to regenerate files that came
with the distribution.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. You can give `configure'
initial values for variables by setting them in the environment. Using
a Bourne-compatible shell, you can do that on the command line like
this:
CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
Or on systems that have the `env' program, you can do it like this:
env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not supports the `VPATH'
variable, you have to compile the package for one architecture at a time
in the source code directory. After you have installed the package for
one architecture, use `make distclean' before reconfiguring for another
architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
In addition, if you use an unusual directory layout you can give
options like `--bindir=PATH' to specify different values for particular
kinds of files. Run `configure --help' for a list of the directories
you can set and what kinds of files go in them.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' can not figure out
automatically, but needs to determine by the type of host the package
will run on. Usually `configure' can figure that out, but if it prints
a message saying it can not guess the host type, give it the
`--host=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name with three fields:
CPU-COMPANY-SYSTEM
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the host type.
If you are building compiler tools for cross-compiling, you can also
use the `--target=TYPE' option to select the type of system they will
produce code for and the `--build=TYPE' option to select the type of
system on which you are compiling the package.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Operation Controls
==================
`configure' recognizes the following options to control how it
operates.
`--cache-file=FILE'
Use and save the results of the tests in FILE instead of
`./config.cache'. Set FILE to `/dev/null' to disable caching, for
debugging `configure'.
`--help'
Print a summary of the options to `configure', and exit.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made. To
suppress all normal output, redirect it to `/dev/null' (any error
messages will still be shown).
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`--version'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`configure' also accepts some other, not widely useful, options.

80
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1-src/NEWS
View File

@@ -1,80 +0,0 @@
New in 3.0.1:
* Bug fix.
New in 3.0:
* Added option --output that allows to specify the output file name.
* Some options have been renamed:
--hash-fn-name=NAME --> --hash-function-name=NAME
--lookup-fn-name=NAME --> --lookup-function-name=NAME
--compare-strlen --> --compare-lengths
--global --> --global-table
The older variants are still supported for backward compatibility.
* The following options can now be specified inside the input file:
%delimiters=DELIMITER-LIST
%struct-type
%ignore-case
%language=LANGUAGE-NAME
%define slot-name NAME
%define initializer-suffix INITIALIZERS
%define hash-function-name NAME
%define lookup-function-name NAME
%define class-name NAME
%7bit
%compare-lengths
%compare-strncmp
%readonly-tables
%enum
%includes
%global-table
%pic
%define string-pool-name NAME
%null-strings
%define word-array-name NAME
%switch=COUNT
%omit-struct-type
* When the option -k is not given, the default key positions are now
computed depending on the set of keywords.
* If the input file is given by name, the output file will now contain
#line directives referring to the input file.
* Some keyword sets containing permutations, like { "xy", "yx", "xz", "zx" }
or { "abc", "acb", "bca", "cab" }, are now handled by gperf without
requiring the option -D.
* The generated table is usually much smaller than it was with earlier
versions of gperf.
* Added option -m/--multiple-iterations that allows to further reduce the
size of the generated table.
* When the search for a good hash function is not immediately successful,
the table's size will grow as needed. Earlier versions of gperf bailed
out with an "Internal error, duplicate hash code value".
* The options -f/--fast and -o/--occurrence-sort have no effect any more.
* Added options -P/--pic and --null-strings that optimize the generated code
for use in shared libraries. -P/--pic does a perfect optimization but may
require some small code changes (see the documentation for details), whereas
--null-strings does only a half-hearted optimization but works without
needing any change to surrounding code.
* Added option --ignore-case that produces a case independent lookup function.
* Bug fixes.
New in 2.7.2:
* Keywords may now be enclosed in double quotes; this permits the use of
'#', ',', space or NUL inside keywords.
* Bug fixes.
New in 2.7.1:
* Added option "-F" for gcc.
New in 2.7:
* gperf is now a stand-alone package, untied from libg++.
* Autoconfiguring.
* Removed the "-a" and "-g" options, extended the "-L" option instead.
* Removed the "-p" option, it is the default.
* Added long options ("--help", "--version" etc.).
* 8-bit cleanliness is now the default; use "-7" to get the old behaviour.
* Compiles with any C++ compiler.
* Numerous small improvements.

28
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1-src/README
View File

@@ -1,28 +0,0 @@
This is GNU gperf. It is a program that generates perfect hash
functions for sets of key words. A perfect hash function is:
A hash function and a data structure that allows
recognition of a key word in a set of words using
exactly 1 probe into the data structure.
The doc/gperf.html file explains how the program works, the form of
the input, what options are available, and hints on choosing the best
options for particular key words set.
See the file NEWS for a list of major changes in the current release.
See the file INSTALL for compilation and installation instructions.
Output from the GPERF program is used to recognize reserved words in
the GNU C, GNU C++, and GNU Pascal compilers, as well as with the GNU
indent program.
For general documentation on the coding and usage standards
this distribution follows, see the GNU standards document
ftp://ftp.gnu.org/pub/gnu/standards.*, especially the 'Makefile
Conventions', 'Configuration', and 'User Interfaces' sections.
Mail suggestions and bug reports to <bug-gnu-gperf@gnu.org>. When
reporting bugs, please include in the subject line the package name
and version (output of 'gperf --version') for which you found a problem.

156
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1/check.log
View File

@@ -1,156 +0,0 @@
cd lib; make check
make[1]: Entering directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/lib'
make[1]: Niets te doen voor `check'.
make[1]: Leaving directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/lib'
cd src; make check
make[1]: Entering directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/src'
make[1]: Niets te doen voor `check'.
make[1]: Leaving directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/src'
cd tests; make check
make[1]: Entering directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/tests'
performing some tests of the perfect hash generator
gcc -c -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 ../../gperf-3.0.1-src/tests/test.c
../src/gperf -c -l -S1 -I -o ../../gperf-3.0.1-src/tests/c.gperf > cinset.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o cout cinset.c test.o
testing ANSI C reserved words, all items should be found in the set
./cout -v < ../../gperf-3.0.1-src/tests/c.gperf > c.out
diff ../../gperf-3.0.1-src/tests/c.exp c.out
../src/gperf -k1,4,'$' -I ../../gperf-3.0.1-src/tests/ada.gperf > adainset.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o aout adainset.c test.o
testing Ada reserved words, all items should be found in the set
./aout -v < ../../gperf-3.0.1-src/tests/ada.gperf > ada-res.out
diff ../../gperf-3.0.1-src/tests/ada-res.exp ada-res.out
../src/gperf -D -k1,'$' -s 2 -I -o ../../gperf-3.0.1-src/tests/adadefs.gperf > preinset.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o preout preinset.c test.o
testing Ada predefined words, all items should be found in the set
./preout -v < ../../gperf-3.0.1-src/tests/adadefs.gperf > ada-pred.out
diff ../../gperf-3.0.1-src/tests/ada-pred.exp ada-pred.out
../src/gperf -k1,2,'$' -I -o ../../gperf-3.0.1-src/tests/modula3.gperf > m3inset.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o m3out m3inset.c test.o
testing Modula3 reserved words, all items should be found in the set
./m3out -v < ../../gperf-3.0.1-src/tests/modula3.gperf > modula.out
diff ../../gperf-3.0.1-src/tests/modula.exp modula.out
../src/gperf -o -S2 -I < ../../gperf-3.0.1-src/tests/pascal.gperf > pinset.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o pout pinset.c test.o
testing Pascal reserved words, all items should be found in the set
./pout -v < ../../gperf-3.0.1-src/tests/pascal.gperf > pascal.out
diff ../../gperf-3.0.1-src/tests/pascal.exp pascal.out
../src/gperf -k1 -t -I -K foreign_name < ../../gperf-3.0.1-src/tests/lang-utf8.gperf > lu8inset.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o lu8out lu8inset.c test.o
testing UTF-8 encoded languages, all items should be found in the set
sed -e '1,6d' -e 's/,.*//' < ../../gperf-3.0.1-src/tests/lang-utf8.gperf | ./lu8out -v > lang-utf8.out
diff ../../gperf-3.0.1-src/tests/lang-utf8.exp lang-utf8.out
gcc -c -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 ../../gperf-3.0.1-src/tests/test2.c
../src/gperf -k4 -t -l -I -K foreign_name < ../../gperf-3.0.1-src/tests/lang-ucs2.gperf > lu2inset.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o lu2out lu2inset.c test2.o
testing UCS-2 encoded languages, all items should be found in the set
./lu2out -v < ../../gperf-3.0.1-src/tests/lang-ucs2.in > lang-ucs2.out
diff ../../gperf-3.0.1-src/tests/lang-ucs2.exp lang-ucs2.out
testing SMTP keywords, case-insensitive
../src/gperf --struct-type --readonly-table --enum --global -K field_name -N header_entry --ignore-case ../../gperf-3.0.1-src/tests/smtp.gperf > smtp.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o smtp smtp.c
./smtp
../src/gperf --struct-type --readonly-table --enum --global -K field_name -N header_entry --ignore-case --compare-strncmp ../../gperf-3.0.1-src/tests/smtp.gperf > smtp.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o smtp smtp.c
./smtp
../src/gperf --struct-type --readonly-table --enum --global -K field_name -N header_entry --ignore-case --compare-lengths ../../gperf-3.0.1-src/tests/smtp.gperf > smtp.c
gcc -Wall -O3 -fms-extensions -mms-bitfields -fno-exceptions -fomit-frame-pointer -march=i386 -mcpu=i686 -o smtp smtp.c
./smtp
../src/gperf -L C -F ', 0, 0' -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,'$' < ../../gperf-3.0.1-src/tests/c-parse.gperf > c-parse.out
diff ../../gperf-3.0.1-src/tests/c-parse.exp c-parse.out
2c2
< /* Command-line: ../src/gperf -L C -F ', 0, 0' -j1 -i 1 -g -o -t -G -N is_reserved_word -k'1,3,$' */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -L C -F ', 0, 0' -j1 -i 1 -g -o -t -G -N is_reserved_word -k'1,3,$' */
../src/gperf -j1 -i 1 -g -o -t -N is_reserved_word -k1,3,'$' < ../../gperf-3.0.1-src/tests/objc.gperf > objc.out
diff ../../gperf-3.0.1-src/tests/objc.exp objc.out
2c2
< /* Command-line: ../src/gperf -j1 -i 1 -g -o -t -N is_reserved_word -k'1,3,$' */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -j1 -i 1 -g -o -t -N is_reserved_word -k'1,3,$' */
../src/gperf -L C -F ', 0, 0, 0' -D -E -S1 -j1 -i 1 -g -o -t -k'*' < ../../gperf-3.0.1-src/tests/chill.gperf > chill.out
diff ../../gperf-3.0.1-src/tests/chill.exp chill.out
2c2
< /* Command-line: ../src/gperf -L C -F ', 0, 0, 0' -D -E -S1 -j1 -i 1 -g -o -t -k'*' */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -L C -F ', 0, 0, 0' -D -E -S1 -j1 -i 1 -g -o -t -k'*' */
../src/gperf -L C -F ', 0, 0' -j1 -g -o -t -N is_reserved_word -k1,4,7,'$' < ../../gperf-3.0.1-src/tests/cplusplus.gperf > cplusplus.out
diff ../../gperf-3.0.1-src/tests/cplusplus.exp cplusplus.out
2c2
< /* Command-line: ../src/gperf -L C -F ', 0, 0' -j1 -g -o -t -N is_reserved_word -k'1,4,7,$' */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -L C -F ', 0, 0' -j1 -g -o -t -N is_reserved_word -k'1,4,7,$' */
../src/gperf -L C -F ', 0' -t -j1 -i 1 -g -o -N java_keyword -k1,3,'$' < ../../gperf-3.0.1-src/tests/java.gperf > java.out
diff ../../gperf-3.0.1-src/tests/java.exp java.out
2c2
< /* Command-line: ../src/gperf -L C -F ', 0' -t -j1 -i 1 -g -o -N java_keyword -k'1,3,$' */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -L C -F ', 0' -t -j1 -i 1 -g -o -N java_keyword -k'1,3,$' */
../src/gperf -n -k1-8 -l < ../../gperf-3.0.1-src/tests/modula2.gperf > modula2.out
diff ../../gperf-3.0.1-src/tests/modula2.exp modula2.out
2c2
< /* Command-line: ../src/gperf -n -k1-8 -l */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -n -k1-8 -l */
../src/gperf -D -t -k1,'$' < ../../gperf-3.0.1-src/tests/c-parse.gperf > test-4.out
diff ../../gperf-3.0.1-src/tests/test-4.exp test-4.out
2c2
< /* Command-line: ../src/gperf -D -t -k'1,$' */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -D -t -k'1,$' */
../src/gperf -g -o -j1 -t -N is_reserved_word < ../../gperf-3.0.1-src/tests/gpc.gperf > gpc.out
diff ../../gperf-3.0.1-src/tests/gpc.exp gpc.out
2c2
< /* Command-line: ../src/gperf -g -o -j1 -t -N is_reserved_word */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -g -o -j1 -t -N is_reserved_word */
../src/gperf -m5 < ../../gperf-3.0.1-src/tests/permut2.gperf > permut2.out
diff ../../gperf-3.0.1-src/tests/permut2.exp permut2.out
2c2
< /* Command-line: ../src/gperf -m5 */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -m5 */
../src/gperf -m5 < ../../gperf-3.0.1-src/tests/permut3.gperf > permut3.out
diff ../../gperf-3.0.1-src/tests/permut3.exp permut3.out
2c2
< /* Command-line: ../src/gperf -m5 */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -m5 */
../src/gperf -m5 --ignore-case < ../../gperf-3.0.1-src/tests/permutc2.gperf > permutc2.out
diff ../../gperf-3.0.1-src/tests/permutc2.exp permutc2.out
2c2
< /* Command-line: ../src/gperf -m5 --ignore-case */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -m5 --ignore-case */
../src/gperf -C -E -G -I -t < ../../gperf-3.0.1-src/tests/charsets.gperf > charsets.out
diff ../../gperf-3.0.1-src/tests/charsets.exp charsets.out
2c2
< /* Command-line: ../src/gperf -C -E -G -I -t */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -C -E -G -I -t */
../src/gperf -C -E -G -I -t < ../../gperf-3.0.1-src/tests/languages.gperf > languages.out
diff ../../gperf-3.0.1-src/tests/languages.exp languages.out
2c2
< /* Command-line: ../src/gperf -C -E -G -I -t */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -C -E -G -I -t */
../src/gperf -t < ../../gperf-3.0.1-src/tests/incomplete.gperf > incomplete.out
diff ../../gperf-3.0.1-src/tests/incomplete.exp incomplete.out
2c2
< /* Command-line: ../src/gperf -t */
---
> /* Command-line: 'k:\\Devel\\gperf\\3.0.1\\gperf-3.0.1\\src\\gperf.exe' -t */
../src/gperf -h > test-6.out
diff ../../gperf-3.0.1-src/tests/test-6.exp test-6.out
3c3
< Usage: ../src/gperf [OPTION]... [INPUT-FILE]
---
> Usage: k:\Devel\gperf\3.0.1\gperf-3.0.1\src\gperf.exe [OPTION]... [INPUT-FILE]
only if, do, for, case, goto, else, while, and return should be found
./aout -v < ../../gperf-3.0.1-src/tests/c.gperf > test-7.out
diff ../../gperf-3.0.1-src/tests/test-7.exp test-7.out
make[1]: Leaving directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/tests'
cd doc; make check
make[1]: Entering directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/doc'
make[1]: Niets te doen voor `check'.
make[1]: Leaving directory `/cygdrive/k/Devel/gperf/3.0.1/gperf-3.0.1/doc'

21
gnuwin32/contrib/gperf/3.0.1/gperf-3.0.1/check_err.log
View File

@@ -1,21 +0,0 @@
../../gperf-3.0.1-src/tests/test.c: In function `main':
../../gperf-3.0.1-src/tests/test.c:25: warning: implicit declaration of function `in_word_set'
1 input keys have identical hash values, examine output carefully...
../../gperf-3.0.1-src/tests/test2.c: In function `main':
../../gperf-3.0.1-src/tests/test2.c:52: warning: implicit declaration of function `in_word_set'
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
8 input keys have identical hash values, examine output carefully...
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)
make[1]: [check-test] Fout 1 (genegeerd)

9
gnuwin32/contrib/libiconv/1.9.2/depends-GnuWin32.lst
View File

@@ -1,9 +0,0 @@
advapi32.dll
gdi32.dll
kernel32.dll
libintl3.dll
msvcrt.dll
ntdll.dll
ole32.dll
rpcrt4.dll
user32.dll

54
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-1-GnuWin32.README
View File

@@ -1,54 +0,0 @@
* LibIconv-1.9.2 for Windows *
==============================
What is it?
-----------
LibIconv: convert between character encodings
Description
-----------
LibIconv converts from one character encoding to another through Unicode
conversion (see Web page for full list of supported encodings). It has
also limited support for transliteration, i.e. when a character cannot be
represented in the target character set, it is approximated through one
or several similar looking characters. It is useful if your application
needs to support multiple character encodings, but that support lacks from
your system.
- Libiconv-1 is in Libiconv-1.7
Homepage
--------
http://www.gnu.org/software/libiconv
System
------
- MS-Windows 95 / 98 / ME / NT / 2000 / XP with msvcrt.dll
- if msvcrt.dll is not in your Windows/System folder, get it from
Microsoft <http://support.microsoft.com/default.aspx?scid=kb;en-us;259403">
or by installing Internet Explorer 4.0 or higher
<http://www.microsoft.com/windows/ie>- libgw32c <http://gnuwin32.sourceforge.net/packages/libgw32c.htm> (for developing with LibIconv library)
Notes
-----
- Bugs and questions on this MS-Windows port: gnuwin32@users.sourceforge.net
Package Availability
--------------------
- in: http://gnuwin32.sourceforge.net
Sources
-------
- libiconv-1.9.2-1-src.zip
Compilation
-----------
The package has been compiled with GNU auto-tools, GNU make, and Mingw
(GCC for MS-Windows). Any differences from the original sources are given
in libiconv-1.9.2-1-GnuWin32.diffs in libiconv-1.9.2-1-src.zip. Libraries needed
for compilation can be found at the lines starting with 'LIBS = ' in the
Makefiles. Usually, these are standard libraries provided with Mingw, or
libraries from the package itself; 'gw32c' refers to the libgw32c package,
which provides MS-Windows substitutes or stubs for functions normally found in
Unix. For more information, see: http://gnuwin32.sourceforge.net/compile.html
and http://gnuwin32.sourceforge.net/packages/libgw32c.htm.

477
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/ABOUT-NLS
View File

@@ -1,477 +0,0 @@
Notes on the Free Translation Project
*************************************
Free software is going international! The Free Translation Project
is a way to get maintainers of free software, translators, and users all
together, so that will gradually become able to speak many languages.
A few packages already provide translations for their messages.
If you found this `ABOUT-NLS' file inside a distribution, you may
assume that the distributed package does use GNU `gettext' internally,
itself available at your nearest GNU archive site. But you do _not_
need to install GNU `gettext' prior to configuring, installing or using
this package with messages translated.
Installers will find here some useful hints. These notes also
explain how users should proceed for getting the programs to use the
available translations. They tell how people wanting to contribute and
work at translations should contact the appropriate team.
When reporting bugs in the `intl/' directory or bugs which may be
related to internationalization, you should tell about the version of
`gettext' which is used. The information can be found in the
`intl/VERSION' file, in internationalized packages.
Quick configuration advice
==========================
If you want to exploit the full power of internationalization, you
should configure it using
./configure --with-included-gettext
to force usage of internationalizing routines provided within this
package, despite the existence of internationalizing capabilities in the
operating system where this package is being installed. So far, only
the `gettext' implementation in the GNU C library version 2 provides as
many features (such as locale alias, message inheritance, automatic
charset conversion or plural form handling) as the implementation here.
It is also not possible to offer this additional functionality on top
of a `catgets' implementation. Future versions of GNU `gettext' will
very likely convey even more functionality. So it might be a good idea
to change to GNU `gettext' as soon as possible.
So you need _not_ provide this option if you are using GNU libc 2 or
you have installed a recent copy of the GNU gettext package with the
included `libintl'.
INSTALL Matters
===============
Some packages are "localizable" when properly installed; the
programs they contain can be made to speak your own native language.
Most such packages use GNU `gettext'. Other packages have their own
ways to internationalization, predating GNU `gettext'.
By default, this package will be installed to allow translation of
messages. It will automatically detect whether the system already
provides the GNU `gettext' functions. If not, the GNU `gettext' own
library will be used. This library is wholly contained within this
package, usually in the `intl/' subdirectory, so prior installation of
the GNU `gettext' package is _not_ required. Installers may use
special options at configuration time for changing the default
behaviour. The commands:
./configure --with-included-gettext
./configure --disable-nls
will respectively bypass any pre-existing `gettext' to use the
internationalizing routines provided within this package, or else,
_totally_ disable translation of messages.
When you already have GNU `gettext' installed on your system and run
configure without an option for your new package, `configure' will
probably detect the previously built and installed `libintl.a' file and
will decide to use this. This might be not what is desirable. You
should use the more recent version of the GNU `gettext' library. I.e.
if the file `intl/VERSION' shows that the library which comes with this
package is more recent, you should use
./configure --with-included-gettext
to prevent auto-detection.
The configuration process will not test for the `catgets' function
and therefore it will not be used. The reason is that even an
emulation of `gettext' on top of `catgets' could not provide all the
extensions of the GNU `gettext' library.
Internationalized packages have usually many `po/LL.po' files, where
LL gives an ISO 639 two-letter code identifying the language. Unless
translations have been forbidden at `configure' time by using the
`--disable-nls' switch, all available translations are installed
together with the package. However, the environment variable `LINGUAS'
may be set, prior to configuration, to limit the installed set.
`LINGUAS' should then contain a space separated list of two-letter
codes, stating which languages are allowed.
Using This Package
==================
As a user, if your language has been installed for this package, you
only have to set the `LANG' environment variable to the appropriate
`LL_CC' combination. Here `LL' is an ISO 639 two-letter language code,
and `CC' is an ISO 3166 two-letter country code. For example, let's
suppose that you speak German and live in Germany. At the shell
prompt, merely execute `setenv LANG de_DE' (in `csh'),
`export LANG; LANG=de_DE' (in `sh') or `export LANG=de_DE' (in `bash').
This can be done from your `.login' or `.profile' file, once and for
all.
You might think that the country code specification is redundant.
But in fact, some languages have dialects in different countries. For
example, `de_AT' is used for Austria, and `pt_BR' for Brazil. The
country code serves to distinguish the dialects.
The locale naming convention of `LL_CC', with `LL' denoting the
language and `CC' denoting the country, is the one use on systems based
on GNU libc. On other systems, some variations of this scheme are
used, such as `LL' or `LL_CC.ENCODING'. You can get the list of
locales supported by your system for your country by running the command
`locale -a | grep '^LL''.
Not all programs have translations for all languages. By default, an
English message is shown in place of a nonexistent translation. If you
understand other languages, you can set up a priority list of languages.
This is done through a different environment variable, called
`LANGUAGE'. GNU `gettext' gives preference to `LANGUAGE' over `LANG'
for the purpose of message handling, but you still need to have `LANG'
set to the primary language; this is required by other parts of the
system libraries. For example, some Swedish users who would rather
read translations in German than English for when Swedish is not
available, set `LANGUAGE' to `sv:de' while leaving `LANG' to `sv_SE'.
In the `LANGUAGE' environment variable, but not in the `LANG'
environment variable, `LL_CC' combinations can be abbreviated as `LL'
to denote the language's main dialect. For example, `de' is equivalent
to `de_DE' (German as spoken in Germany), and `pt' to `pt_PT'
(Portuguese as spoken in Portugal) in this context.
Translating Teams
=================
For the Free Translation Project to be a success, we need interested
people who like their own language and write it well, and who are also
able to synergize with other translators speaking the same language.
Each translation team has its own mailing list. The up-to-date list of
teams can be found at the Free Translation Project's homepage,
`http://www.iro.umontreal.ca/contrib/po/HTML/', in the "National teams"
area.
If you'd like to volunteer to _work_ at translating messages, you
should become a member of the translating team for your own language.
The subscribing address is _not_ the same as the list itself, it has
`-request' appended. For example, speakers of Swedish can send a
message to `sv-request@li.org', having this message body:
subscribe
Keep in mind that team members are expected to participate
_actively_ in translations, or at solving translational difficulties,
rather than merely lurking around. If your team does not exist yet and
you want to start one, or if you are unsure about what to do or how to
get started, please write to `translation@iro.umontreal.ca' to reach the
coordinator for all translator teams.
The English team is special. It works at improving and uniformizing
the terminology in use. Proven linguistic skill are praised more than
programming skill, here.
Available Packages
==================
Languages are not equally supported in all packages. The following
matrix shows the current state of internationalization, as of February
2003. The matrix shows, in regard of each package, for which languages
PO files have been submitted to translation coordination, with a
translation percentage of at least 50%.
Ready PO files az be bg ca cs da de el en en_GB eo es et fa fi
+-------------------------------------------------+
a2ps | [] [] [] [] [] |
aegis | () |
anubis | |
ap-utils | |
bash | [] [] [] |
batchelor | |
bfd | [] [] |
binutils | [] [] |
bison | [] [] [] [] |
clisp | [] [] [] |
clisp | |
coreutils | [] [] [] [] |
cpio | [] [] [] |
darkstat | () [] |
diffutils | [] [] [] [] [] [] [] |
enscript | [] [] [] |
error | [] [] [] [] |
fetchmail | [] () [] [] [] |
fileutils | [] [] [] [] |
findutils | [] [] [] [] [] [] [] |
flex | [] [] [] [] |
gas | [] |
gawk | [] [] [] |
gcal | [] |
gcc | [] [] |
gettext | [] [] [] [] [] |
gimp-print | |
gliv | |
gnucash | [] () |
gnucash-glossary| [] () [] |
gnupg | [] [] [] [] [] [] [] |
gpe-todo | |
gphoto2 | [] [] |
gprof | [] [] |
gpsdrive | () () () () |
grep | [] [] [] [] [] [] [] |
gretl | [] |
hello | [] [] [] [] [] [] [] [] [] |
id-utils | [] [] |
indent | [] [] [] [] [] [] |
jpilot | () [] [] [] |
jwhois | [] |
kbd | [] [] [] |
ld | [] [] |
libc | [] [] [] [] [] [] [] |
libgpewidget | |
libiconv | [] [] [] [] [] [] |
lifelines | [] () |
lilypond | [] |
lingoteach | [] |
lingoteach_lessons| () () |
lynx | [] [] [] [] [] |
m4 | [] [] [] [] |
mailutils | [] [] |
make | [] [] [] |
man-db | [] () [] () |
mysecretdiary | [] [] [] |
nano | [] () [] [] [] |
nano_1_0 | [] () [] [] [] |
opcodes | [] [] |
parted | [] [] [] [] |
ptx | [] [] [] [] [] [] [] |
python | |
radius | |
recode | [] [] [] [] [] |
sed | [] [] [] [] [] [] |
sh-utils | [] [] [] [] |
sharutils | [] [] [] [] [] [] [] |
sketch | [] () [] |
soundtracker | [] [] [] |
sp | [] |
tar | [] [] [] [] [] [] |
texinfo | [] [] [] [] |
textutils | [] [] [] [] |
tin | () () [] |
util-linux | [] [] [] [] [] [] [] |
vorbis-tools | [] [] |
wastesedge | () |
wdiff | [] [] [] [] [] |
wget | [] [] [] [] [] [] [] [] [] |
xchat | |
xpad | |
+-------------------------------------------------+
az be bg ca cs da de el en en_GB eo es et fa fi
0 1 2 26 9 49 46 9 1 1 11 52 19 1 15
fr gl he hr hu id it ja ko lg lv ms nb nl
+-------------------------------------------+
a2ps | [] () () [] [] |
aegis | () |
anubis | [] [] |
ap-utils | [] |
bash | [] [] |
batchelor | |
bfd | [] [] |
binutils | [] [] |
bison | [] [] [] [] |
clisp | [] [] |
clisp | |
coreutils | [] [] [] |
cpio | [] [] [] [] [] |
darkstat | () [] [] [] |
diffutils | [] [] [] [] [] [] |
enscript | [] [] [] |
error | [] [] [] |
fetchmail | [] |
fileutils | [] [] [] [] |
findutils | [] [] [] [] [] [] [] [] [] |
flex | [] [] |
gas | [] |
gawk | [] [] |
gcal | [] |
gcc | [] |
gettext | [] [] [] |
gimp-print | |
gliv | () |
gnucash | [] [] [] |
gnucash-glossary| [] [] |
gnupg | [] [] [] [] [] |
gpe-todo | |
gphoto2 | [] [] [] |
gprof | [] [] |
gpsdrive | () [] () () |
grep | [] [] [] [] [] [] [] [] |
gretl | [] |
hello | [] [] [] [] [] [] [] [] [] [] [] [] [] |
id-utils | [] [] [] |
indent | [] [] [] [] [] [] |
jpilot | [] () () |
jwhois | [] [] [] [] |
kbd | [] |
ld | [] |
libc | [] [] [] [] [] [] |
libgpewidget | |
libiconv | [] [] [] [] [] [] |
lifelines | () |
lilypond | [] [] |
lingoteach | [] |
lingoteach_lessons| |
lynx | [] [] [] [] |
m4 | [] [] [] [] [] |
mailutils | |
make | [] [] [] [] [] [] [] |
man-db | [] () () |
mysecretdiary | [] [] |
nano | [] [] [] [] [] [] |
nano_1_0 | [] [] [] [] [] [] |
opcodes | [] [] [] |
parted | [] [] [] |
ptx | [] [] [] [] [] [] |
python | |
radius | |
recode | [] [] [] [] [] |
sed | [] [] [] [] [] |
sh-utils | [] [] [] [] [] |
sharutils | [] [] [] [] [] |
sketch | [] |
soundtracker | [] [] [] |
sp | [] () |
tar | [] [] [] [] [] [] [] [] [] |
texinfo | [] [] [] [] |
textutils | [] [] [] [] [] [] |
tin | |
util-linux | [] [] () [] [] |
vorbis-tools | [] |
wastesedge | () |
wdiff | [] [] [] [] [] |
wget | [] [] [] [] [] [] [] |
xchat | |
xpad | |
+-------------------------------------------+
fr gl he hr hu id it ja ko lg lv ms nb nl
59 23 8 10 26 20 18 26 8 0 1 8 7 24
nn no pl pt pt_BR ro ru sk sl sv tr uk zh_CN zh_TW
+----------------------------------------------------+
a2ps | () () () [] [] [] [] [] [] | 14
aegis | () | 0
anubis | [] [] | 4
ap-utils | () () | 1
bash | [] [] | 7
batchelor | | 0
bfd | [] [] | 6
binutils | [] [] | 6
bison | [] [] [] | 11
clisp | | 5
clisp | | 0
coreutils | [] [] [] [] [] | 12
cpio | [] [] [] [] [] | 13
darkstat | [] [] () () | 6
diffutils | [] [] [] [] [] [] | 19
enscript | [] [] [] [] | 10
error | [] [] [] [] | 11
fetchmail | () () [] | 6
fileutils | [] [] [] [] [] [] | 14
findutils | [] [] [] [] [] [] [] [] | 24
flex | [] [] [] [] | 10
gas | [] | 3
gawk | [] [] | 7
gcal | [] [] | 4
gcc | [] | 4
gettext | [] [] [] [] [] [] | 14
gimp-print | | 0
gliv | [] | 1
gnucash | [] [] [] [] [] | 9
gnucash-glossary| [] [] [] [] | 8
gnupg | [] [] [] [] | 16
gpe-todo | | 0
gphoto2 | [] [] | 7
gprof | [] [] [] | 7
gpsdrive | [] [] | 3
grep | [] [] [] [] [] | 20
gretl | | 2
hello | [] [] [] [] [] [] [] [] [] | 31
id-utils | [] [] [] [] | 9
indent | [] [] [] [] [] | 17
jpilot | () [] [] [] [] | 8
jwhois | [] () () [] [] | 8
kbd | [] [] | 6
ld | [] [] | 5
libc | [] [] [] [] [] [] [] | 20
libgpewidget | | 0
libiconv | [] [] [] [] [] [] | 18
lifelines | [] | 2
lilypond | [] | 4
lingoteach | [] [] | 4
lingoteach_lessons| () | 0
lynx | [] [] [] [] | 13
m4 | [] [] [] [] | 13
mailutils | | 2
make | [] [] [] [] [] | 15
man-db | [] | 4
mysecretdiary | [] [] [] | 8
nano | [] [] [] | 13
nano_1_0 | [] [] [] [] [] | 15
opcodes | [] [] [] | 8
parted | [] [] [] [] [] | 12
ptx | [] [] [] [] [] [] [] | 20
python | | 0
radius | | 0
recode | [] [] [] [] [] [] | 16
sed | [] [] [] [] [] | 16
sh-utils | [] [] [] | 12
sharutils | [] [] [] [] | 16
sketch | [] [] | 5
soundtracker | [] | 7
sp | [] | 3
tar | [] [] [] [] [] [] [] [] [] | 24
texinfo | [] [] [] [] | 12
textutils | [] [] [] [] [] | 15
tin | | 1
util-linux | [] [] [] | 14
vorbis-tools | [] | 4
wastesedge | | 0
wdiff | [] [] [] [] [] | 15
wget | [] [] [] [] [] [] [] [] | 24
xchat | | 0
xpad | | 0
+----------------------------------------------------+
43 teams nn no pl pt pt_BR ro ru sk sl sv tr uk zh_CN zh_TW
82 domains 3 4 14 4 34 1 29 14 13 53 46 6 9 13 723
Some counters in the preceding matrix are higher than the number of
visible blocks let us expect. This is because a few extra PO files are
used for implementing regional variants of languages, or language
dialects.
For a PO file in the matrix above to be effective, the package to
which it applies should also have been internationalized and
distributed as such by its maintainer. There might be an observable
lag between the mere existence a PO file and its wide availability in a
distribution.
If February 2003 seems to be old, you may fetch a more recent copy
of this `ABOUT-NLS' file on most GNU archive sites. The most
up-to-date matrix with full percentage details can be found at
`http://www.iro.umontreal.ca/contrib/po/HTML/matrix.html'.
Using `gettext' in new packages
===============================
If you are writing a freely available program and want to
internationalize it you are welcome to use GNU `gettext' in your
package. Of course you have to respect the GNU Library General Public
License which covers the use of the GNU `gettext' library. This means
in particular that even non-free programs can use `libintl' as a shared
library, whereas only free software can use `libintl' as a static
library or use modified versions of `libintl'.
Once the sources are changed appropriately and the setup can handle
the use of `gettext' the only thing missing are the translations. The
Free Translation Project is also available for packages which are not
developed inside the GNU project. Therefore the information given above
applies also for every other Free Software Project. Contact
`translation@iro.umontreal.ca' to make the `.pot' files available to
the translation teams.

1
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/AUTHORS
View File

@@ -1 +0,0 @@
Bruno Haible <bruno@clisp.org>

2633
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/ChangeLog
View File

File diff suppressed because it is too large Load Diff

64
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/DESIGN
View File

@@ -1,64 +0,0 @@
While some other iconv(3) implementations - like FreeBSD iconv(3) - choose
the "many small shared libraries" and dlopen(3) approach, this implementation
packs everything into a single shared library. Here is a comparison of the
two designs.
* Run-time efficiency
1. A dlopen() based approach needs a cache of loaded shared libraries.
Otherwise, every iconv_open() call will result in a call to dlopen()
and thus to file system related system calls - which is prohibitive
because some applications use the iconv_open/iconv/iconv_close sequence
for every single filename, string, or piece of text.
2. In terms of virtual memory use, both approaches are on par. Being shared
libraries, the tables are shared between any processes that use them.
And because of the demand loading used by Unix systems (and because libiconv
does not have initialization functions), only those parts of the tables
which are needed (typically very few kilobytes) will be read from disk and
paged into main memory.
3. Even with a cache of loaded shared libraries, the dlopen() based approach
makes more system calls, because it has to load one or two shared libraries
for every encoding in use.
* Total size
In the dlopen(3) approach, every shared library has a symbol table and
relocation offset. All together, FreeBSD iconv installs more than 200 shared
libraries with a total size of 2.3 MB. Whereas libiconv installs 0.45 MB.
* Extensibility
The dlopen(3) approach is good for guaranteeing extensibility if the iconv
implementation is distributed without source. (Or when, as in glibc, you
cannot rebuild iconv without rebuilding your libc, thus possibly
destabilizing your system.)
The libiconv package achieves extensibility through the LGPL license:
Every user has access to the source of the package and can extend and
replace just libiconv.so.
The places which have to be modified when a new encoding is added are as
follows: add an #include statement in iconv.c, add an entry in the table in
iconv.c, and of course, update the README and iconv_open.3 manual page.
* Use within other packages
If you want to incorporate an iconv implementation into another package
(such as a mail user agent or web browser), the single library approach
is easier, because:
1. In the shared library approach you have to provide the right directory
prefix which will be used at run time.
2. Incorporating iconv as a static library into the executable is easy -
it won't need dynamic loading. (This assumes that your package is under
the LGPL or GPL license.)
All conversions go through Unicode. This is possible because most of the
world's characters have already been allocated in the Unicode standard.
Therefore we have for each encoding two functions:
- For conversion from the encoding to Unicode, a function called xxx_mbtowc.
- For conversion from Unicode to the encoding, a function called xxx_wctomb,
and for stateful encodings, a function called xxx_reset which returns to
the initial shift state.
All our functions operate on a single Unicode character at a time. This is
obviously less efficient than operating on an entire buffer of characters at
a time, but it makes the coding considerably easier and less bug-prone. Those
who wish best performance should install the Real Thing (TM): GNU libc 2.1
or newer.

119
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/NEWS
View File

@@ -1,119 +0,0 @@
New in 1.9:
* Many more transliterations.
* New configuration option --enable-relocatable. See the INSTALL.generic file
for details.
New in 1.8:
* The iconv program has new options -l, -c, -s.
* The iconv program is internationalized.
* Added C99 converter.
* Added KOI8-T converter.
* New configuration option --enable-extra-encodings that enables a bunch of
additional encodings; see the README for details.
* Updated the ISO-8859-16 converter.
* Upgraded BIG5-HKSCS, EUC-TW, ISO-2022-CN, ISO-2022-CN-EXT converters to
Unicode 3.2.
* Upgraded EUC-KR, CP949, JOHAB converters to include the Euro sign.
* Changed the ARMSCII-8 converter.
* Extended the EUC-JP encoder so that YEN SIGN characters don't cause failures
in Shift_JIS to EUC-JP conversion.
* The JAVA converter now handles characters outside the Unicode BMP correctly.
* Fixed a bug in the CP1255, CP1258, TCVN decoders: The base characters of
combining characters could be dropped at the end of the conversion buffer.
* Fixed a bug in the transliteration that could lead to excessive memory
allocations in libintl when transliteration was needed.
* Portability to BSD/OS and SCO 3.2.5.
New in 1.7:
* Added UTF-32, UTF-32BE, UTF-32LE converters.
* Changed CP1255, CP1258 and TCVN converters to handle combining characters.
* Changed EUC-JP, SHIFT_JIS, CP932, ISO-2022-JP, ISO-2022-JP-2, ISO-2022-JP-1
converters to use fullwidth Yen sign instead of halfwidth Yen sign, and
fullwidth tilde instead of halfwidth tilde.
* Upgraded EUC-TW, ISO-2022-CN, ISO-2022-CN-EXT converters to Unicode 3.1.
* Changed the GB18030 converter to not reject unassigned and private-use
Unicode characters.
* Fixed a bug in the byte order mark treatment of the UCS-4 decoder.
* The manual pages are now distributed also in HTML format.
New in 1.6:
* The iconv program's -f and -t options are now optional.
* Many more transliterations.
* Added CP862 converter.
* Changed the GB18030 converter.
* Portability to DOS with DJGPP.
New in 1.5:
* Added an iconv(1) program.
* New locale dependent encodings "char", "wchar_t".
* Transliteration is now off by default. Use a //TRANSLIT suffix to enable it.
* The JOHAB encoding is documented again.
* Changed a few mappings in the CP950 converter.
New in 1.4:
* Added GB18030, BIG5HKSCS converters.
* Portability to OS/2 with emx+gcc.
New in 1.3:
* Added UCS-2BE, UCS-2LE, UCS-4BE, UCS-4LE converters.
* Fixed the definition of EILSEQ on SunOS4.
* Fixed a build problem on OSF/1.
* Support for building as a shared library on Woe32.
New in 1.2:
* Added UTF-16BE and UTF-16LE converters.
* Changed the UTF-16 encoder.
* Fixed the treatment of tab characters in the UTF-7 converter.
* Fixed an internal error when output buffer was not large enough.
New in 1.1:
* Added ISO-8859-16 converter.
* Added CP932 converter, a variant of SHIFT_JIS.
* Added CP949 converter, a variant of EUC-KR.
* Improved the ISO-2022-CN-EXT converter: It now covers the ISO-IR-165 range.
* Updated the ISO-8859-8 conversion table.
* The JOHAB encoding is deprecated and not documented any more.
* Fixed two build problems: 1. "make -n check" failed. 2. When libiconv was
already installed, "make" failed.
New in 1.0:
* Added transliteration facilities.
* Added a test suite.
* Fixed the iconv(3) manual page and function: the return value was not
described correctly.
* Fixed a bug in the CP1258 decoder: invalid bytes now yield EILSEQ instead of
U+FFFD.
* Fixed a bug in the Georgian-PS encoder: accept U+00E6.
* Fixed a bug in the EUC-JP encoder: reject 0x8E5C and 0x8E7E.
* Fixed a bug in the KSC5601 and JOHAB converters: they recognized some Hangul
characters at some invalid code positions.
* Fixed a bug in the EUC-TW decoder; it was severely broken.
* Fixed a bug in the CP950 converter: it recognized a dubious BIG5 range.
New in 0.3:
* Reduced the size of the tables needed for the JOHAB converter.
* Portability to Woe32.
New in 0.2:
* Added KOI8-RU, CP850, CP866, CP874, CP950, ISO-2022-CN-EXT, GBK and
ISO-2022-JP-1 converters.
* Added MACINTOSH as an alias for MAC-ROMAN.
* Added ASMO-708 as an alias for ISO-8859-6.
* Added ELOT_928 as an alias for ISO-8859-7.
* Improved the EUC-TW converter: Treat CNS 11643 plane 3.
* Improved the ISO-2022-KR and EUC-KR converters: Hangul characters are
decomposed into Jamo when needed.
* Improved the CP932 converter.
* Updated the CP1133, MULELAO-1 and ARMSCII-8 mappings.
* The EUC-JP and SHIFT_JIS converters now cover the user-defined range.
* Fixed a possible buffer overrun in the JOHAB converter.
* Fixed a bug in the UTF-7, ISO-2022-*, HZ decoders: a shift sequence a the
end of the input no longer gives an error.
* The HZ encoder now always terminates its output in the ASCII state.
* Use a perfect hash table for looking up the aliases.
New in 0.1:
* Portability to Linux/glibc-2.0.x, Linux/libc5, OSF/1, FreeBSD.
* Fixed a bug in the EUC-JP decoder. Extended the ISO-2022-JP-2 converter.
* Made TIS-620 mapping consistent with glibc-2.1.

392
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/NOTES
View File

@@ -1,392 +0,0 @@
Q: Why does libiconv support encoding XXX? Why does libiconv not support
encoding ZZZ?
A: libiconv, as an internationalization library, supports those character
sets and encodings which are in wide-spread use in at least one territory
of the world.
Hint1: On http://www.w3c.org/International/O-charset-lang.html you find a
page "Languages, countries, and the charsets typically used for them".
From this table, we can conclude that the following are in active use:
ISO-8859-1, CP1252 Afrikaans, Albanian, Basque, Catalan, Danish, Dutch,
English, Faroese, Finnish, French, Galician, German,
Icelandic, Irish, Italian, Norwegian, Portuguese,
Scottish, Spanish, Swedish
ISO-8859-2 Croatian, Czech, Hungarian, Polish, Romanian, Slovak,
Slovenian
ISO-8859-3 Esperanto, Maltese
ISO-8859-5 Bulgarian, Byelorussian, Macedonian, Russian,
Serbian, Ukrainian
ISO-8859-6 Arabic
ISO-8859-7 Greek
ISO-8859-8 Hebrew
ISO-8859-9, CP1254 Turkish
ISO-8859-10 Inuit, Lapp
ISO-8859-13 Latvian, Lithuanian
ISO-8859-15 Estonian
KOI8-R Russian
SHIFT_JIS Japanese
ISO-2022-JP Japanese
EUC-JP Japanese
Ordered by frequency on the web (1997):
ISO-8859-1, CP1252 96%
SHIFT_JIS 1.6%
ISO-2022-JP 1.2%
EUC-JP 0.4%
CP1250 0.3%
CP1251 0.2%
CP850 0.1%
MACINTOSH 0.1%
ISO-8859-5 0.1%
ISO-8859-2 0.0%
Hint2: The character sets mentioned in the XFree86 4.0 locale.alias file.
ISO-8859-1 Afrikaans, Basque, Breton, Catalan, Danish, Dutch,
English, Estonian, Faroese, Finnish, French,
Galician, German, Greenlandic, Icelandic,
Indonesian, Irish, Italian, Lithuanian, Norwegian,
Occitan, Portuguese, Scottish, Spanish, Swedish,
Walloon, Welsh
ISO-8859-2 Albanian, Croatian, Czech, Hungarian, Polish,
Romanian, Serbian, Slovak, Slovenian
ISO-8859-3 Esperanto
ISO-8859-4 Estonian, Latvian, Lithuanian
ISO-8859-5 Bulgarian, Byelorussian, Macedonian, Russian,
Serbian, Ukrainian
ISO-8859-6 Arabic
ISO-8859-7 Greek
ISO-8859-8 Hebrew
ISO-8859-9 Turkish
ISO-8859-14 Breton, Irish, Scottish, Welsh
ISO-8859-15 Basque, Breton, Catalan, Danish, Dutch, Estonian,
Faroese, Finnish, French, Galician, German,
Greenlandic, Icelandic, Irish, Italian, Lithuanian,
Norwegian, Occitan, Portuguese, Scottish, Spanish,
Swedish, Walloon, Welsh
KOI8-R Russian
KOI8-U Russian, Ukrainian
EUC-JP (alias eucJP) Japanese
ISO-2022-JP (alias JIS7) Japanese
SHIFT_JIS (alias SJIS) Japanese
U90 Japanese
S90 Japanese
EUC-CN (alias eucCN) Chinese
EUC-TW (alias eucTW) Chinese
BIG5 Chinese
EUC-KR (alias eucKR) Korean
ARMSCII-8 Armenian
GEORGIAN-ACADEMY Georgian
GEORGIAN-PS Georgian
TIS-620 (alias TACTIS) Thai
MULELAO-1 Laothian
IBM-CP1133 Laothian
VISCII Vietnamese
TCVN Vietnamese
NUNACOM-8 Inuktitut
Hint3: The character sets supported by Netscape Communicator 4.
Where is this documented? For the complete picture, I had to use
"strings netscape" and then a lot of guesswork. For a quick take,
look at the "View - Character set" menu of Netscape Communicator 4.6:
ISO-8859-{1,2,5,7,9,15}
WINDOWS-{1250,1251,1253}
KOI8-R Cyrillic
CP866 Cyrillic
Autodetect Japanese (EUC-JP, ISO-2022-JP, ISO-2022-JP-2, SJIS)
EUC-JP Japanese
SHIFT_JIS Japanese
GB2312 Chinese
BIG5 Chinese
EUC-TW Chinese
Autodetect Korean (EUC-KR, ISO-2022-KR, but not JOHAB)
UTF-8
UTF-7
Hint4: The character sets supported by Microsoft Internet Explorer 4.
ISO-8859-{1,2,3,4,5,6,7,8,9}
WINDOWS-{1250,1251,1252,1253,1254,1255,1256,1257}
KOI8-R Cyrillic
KOI8-RU Ukrainian
ASMO-708 Arabic
EUC-JP Japanese
ISO-2022-JP Japanese
SHIFT_JIS Japanese
GB2312 Chinese
HZ-GB-2312 Chinese
BIG5 Chinese
EUC-KR Korean
ISO-2022-KR Korean
WINDOWS-874 Thai
WINDOWS-1258 Vietnamese
UTF-8
UTF-7
UNICODE actually UNICODE-LITTLE
UNICODEFEFF actually UNICODE-BIG
and various DOS character sets: DOS-720, DOS-862, IBM852, CP866.
We take the union of all these four sets. The result is:
European and Semitic languages
* ASCII.
We implement this because it is occasionally useful to know or to
check whether some text is entirely ASCII (i.e. if the conversion
ISO-8859-x -> UTF-8 is trivial).
* ISO-8859-{1,2,3,4,5,6,7,8,9,10}
We implement this because they are widely used. Except ISO-8859-4
which appears to have been superseded by ISO-8859-13 in the baltic
countries. But it's an ISO standard anyway.
* ISO-8859-13
We implement this because it's a standard in Lithuania and Latvia.
* ISO-8859-14
We implement this because it's an ISO standard.
* ISO-8859-15
We implement this because it's increasingly used in Europe, because
of the Euro symbol.
* ISO-8859-16
We implement this because it's an ISO standard.
* KOI8-R, KOI8-U
We implement this because it appears to be the predominant encoding
on Unix in Russia and Ukraine, respectively.
* KOI8-RU
We implement this because MSIE4 supports it.
* KOI8-T
We implement this because it is the locale encoding in glibc's Tajik
locale.
* CP{1250,1251,1252,1253,1254,1255,1256,1257}
We implement these because they are the predominant Windows encodings
in Europe.
* CP850
We implement this because it is mentioned as occurring in the web
in the aforementioned statistics.
* CP862
We implement this because Ron Aaron says it is sometimes used in web
pages and emails.
* CP866
We implement this because Netscape Communicator does.
* Mac{Roman,CentralEurope,Croatian,Romania,Cyrillic,Greek,Turkish} and
Mac{Hebrew,Arabic}
We implement these because the Sun JDK does, and because Mac users
don't deserve to be punished.
* Macintosh
We implement this because it is mentioned as occurring in the web
in the aforementioned statistics.
Japanese
* EUC-JP, SHIFT_JIS, ISO-2022-JP
We implement these because they are widely used. EUC-JP and SHIFT_JIS
are more used for files, whereas ISO-2022-JP is recommended for email.
* CP932
We implement this because it is the Microsoft variant of SHIFT_JIS,
used on Windows.
* ISO-2022-JP-2
We implement this because it's the common way to represent mails which
make use of JIS X 0212 characters.
* ISO-2022-JP-1
We implement this because it's in the RFCs, but I don't think it is
really used.
* U90, S90
We DON'T implement this because I have no informations about what it
is or who uses it.
Simplified Chinese
* EUC-CN = GB2312
We implement this because it is the widely used representation
of simplified Chinese.
* GBK
We implement this because it appears to be used on Solaris and Windows.
* GB18030
We implement this because it is an official requirement in the
People's Republic of China.
* ISO-2022-CN
We implement this because it is in the RFCs, but I have no idea
whether it is really used.
* ISO-2022-CN-EXT
We implement this because it's in the RFCs, but I don't think it is
really used.
* HZ = HZ-GB-2312
We implement this because the RFCs recommend it for Usenet postings,
and because MSIE4 supports it.
Traditional Chinese
* EUC-TW
We implement it because it appears to be used on Unix.
* BIG5
We implement it because it is the de-facto standard for traditional
Chinese.
* CP950
We implement this because it is the Microsoft variant of BIG5, used
on Windows.
* BIG5+
We DON'T implement this because it doesn't appear to be in wide use.
Only the CWEX fonts use this encoding. Furthermore, the conversion
tables in the big5p package are not coherent: If you convert directly,
you get different results than when you convert via GBK.
* BIG5-HKSCS
We implement it because it is the de-facto standard for traditional
Chinese in Hongkong.
Korean
* EUC-KR
We implement these because they appear to be the widely used
representations for Korean.
* CP949
We implement this because it is the Microsoft variant of EUC-KR, used
on Windows.
* ISO-2022-KR
We implement it because it is in the RFCs and because MSIE4 supports
it, but I have no idea whether it's really used.
* JOHAB
We implement this because it is apparently used on Windows as a locale
encoding (codepage 1361).
* ISO-646-KR
We DON'T implement this because although an old ASCII variant, its
glyph for 0x7E is not clear: RFC 1345 and unicode.org's JOHAB.TXT
say it's a tilde, but Ken Lunde's "CJKV information processing" says
it's an overline. And it is not ISO-IR registered.
Armenian
* ARMSCII-8
We implement it because XFree86 supports it.
Georgian
* Georgian-Academy, Georgian-PS
We implement these because they appear to be both used for Georgian;
Xfree86 supports them.
Thai
* TIS-620
We implement this because it seems to be standard for Thai.
* CP874
We implement this because MSIE4 supports it.
* MacThai
We implement this because the Sun JDK does, and because Mac users
don't deserve to be punished.
Laotian
* MuleLao-1, CP1133
We implement these because XFree86 supports them. I have no idea which
one is used more widely.
Vietnamese
* VISCII, TCVN
We implement these because XFree86 supports them.
* CP1258
We implement this because MSIE4 supports it.
Other languages
* NUNACOM-8 (Inuktitut)
We DON'T implement this because it isn't part of Unicode yet, and
therefore doesn't convert to anything except itself.
Platform specifics
* HP-ROMAN8, NEXTSTEP
We implement these because they were the native character set on HPs
and NeXTs for a long time, and libiconv is intended to be usable on
these old machines.
Full Unicode
* UTF-8, UCS-2, UCS-4
We implement these. Obviously.
* UCS-2BE, UCS-2LE, UCS-4BE, UCS-4LE
We implement these because they are the preferred internal
representation of strings in Unicode aware applications. These are
non-ambiguous names, known to glibc. (glibc doesn't have
UCS-2-INTERNAL and UCS-4-INTERNAL.)
* UTF-16, UTF-16BE, UTF-16LE
We implement these, because UTF-16 is still the favourite encoding of
the president of the Unicode Consortium (for political reasons), and
because they appear in RFC 2781.
* UTF-32, UTF-32BE, UTF-32LE
We implement these because they are part of Unicode 3.1.
* UTF-7
We implement this because it is essential functionality for mail
applications.
* C99
We implement it because it's used for C and C++ programs and because
it's a nice encoding for debugging.
* JAVA
We implement it because it's used for Java programs and because it's
a nice encoding for debugging.
* UNICODE (big endian), UNICODEFEFF (little endian)
We DON'T implement these because they are stupid and not standardized.
Full Unicode, in terms of `uint16_t' or `uint32_t'
(with machine dependent endianness and alignment)
* UCS-2-INTERNAL, UCS-4-INTERNAL
We implement these because they are the preferred internal
representation of strings in Unicode aware applications.
Q: Support encodings mentioned in RFC 1345 ?
A: No, they are not in use any more. Supporting ISO-646 variants is pointless
since ISO-8859-* have been adopted.
Q: Support EBCDIC ?
A: No!
Q: How do I add a new character set?
A: 1. Explain the "why" in this file, above.
2. You need to have a conversion table from/to Unicode. Transform it into
the format used by the mapping tables found on ftp.unicode.org: each line
contains the character code, in hex, with 0x prefix, then whitespace,
then the Unicode code point, in hex, 4 hex digits, with 0x prefix. '#'
counts as a comment delimiter until end of line.
Please also send your table to Mark Leisher <mleisher@crl.nmsu.edu> so he
can include it in his collection.
3. If it's an 8-bit character set, use the '8bit_tab_to_h' program in the
tools directory to generate the C code for the conversion. You may tweak
the resulting C code if you are not satisfied with its quality, but this
is rarely needed.
If it's a two-dimensional character set (with rows and columns), use the
'cjk_tab_to_h' program in the tools directory to generate the C code for
the conversion. You will need to modify the main() function to recognize
the new character set name, with the proper dimensions, but that shouldn't
be too hard. This yields the CCS. The CES you have to write by hand.
4. Store the resulting C code file in the lib directory. Add a #include
directive to converters.h, and add an entry to the encodings.def file.
5. Compile the package, and test your new encoding using a program like
iconv(1) or clisp(1).
6. Augment the testsuite: Add a line to each of tests/Makefile.in,
tests/Makefile.msvc and tests/Makefile.os2. For a stateless encoding,
create the complete table as a TXT file. For a stateful encoding,
provide a text snippet encoded using your new encoding and its UTF-8
equivalent.
7. Update the README and man/iconv_open.3, to mention the new encoding.
Add a note in the NEWS file.
Q: What about bidirectional text? Should it be tagged or reversed when
converting from ISO-8859-8 or ISO-8859-6 to Unicode? Qt appears to do
this, see qt-2.0.1/src/tools/qrtlcodec.cpp.
A: After reading RFC 1556: I don't think so. Support for ISO-8859-8-I and
ISO-8859-E remains to be implemented.
On the other hand, a page on www.w3c.org says that ISO-8859-8 in *email*
is visually encoded, ISO-8859-8 in *HTML* is logically encoded, i.e.
the same as ISO-8859-8-I. I'm confused.
Other character sets not implemented:
"MNEMONIC" = "csMnemonic"
"MNEM" = "csMnem"
"ISO-10646-UCS-Basic" = "csUnicodeASCII"
"ISO-10646-Unicode-Latin1" = "csUnicodeLatin1" = "ISO-10646"
"ISO-10646-J-1"
"UNICODE-1-1" = "csUnicode11"
"csWindows31Latin5"
Other aliases not implemented (and not implemented in glibc-2.1 either):
From MSIE4:
ISO-8859-1: alias ISO8859-1
ISO-8859-2: alias ISO8859-2
KSC_5601: alias KS_C_5601
UTF-8: aliases UNICODE-1-1-UTF-8 UNICODE-2-0-UTF-8
Q: How can I integrate libiconv into my package?
A: Just copy the entire libiconv package into a subdirectory of your package.
At configuration time, call libiconv's configure script with the
appropriate --srcdir option and maybe --enable-static or --disable-shared.
Then "cd libiconv && make && make install-lib libdir=... includedir=...".
'install-lib' is a special (not GNU standardized) target which installs
only the include file - in $(includedir) - and the library - in $(libdir) -
and does not use other directory variables. After "installing" libiconv
in your package's build directory, building of your package can proceed.
Q: Why is the testsuite so big?
A: Because some of the tests are very comprehensive.
If you don't feel like using the testsuite, you can simply remove the
tests/ directory.

46
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/PORTS
View File

@@ -1,46 +0,0 @@
* Linux with libc6 (glibc-2.1):
OK
* Linux with libc6 (glibc-2.0.7):
OK
* Linux with libc5:
OK
* Solaris 2.7:
OK
* Solaris 2.6:
OK
* OSF/1 5.1:
OK
* OSF/1 4.0d:
OK
* Irix 6.5:
OK
* HP-UX 10.20:
OK
* AIX 4.2:
OK
* SunOS 4:
OK when configured --enable-static --disable-shared
(gcc cannot create shared libraries without relocations)
* FreeBSD 3.3:
OK
* BeOS 5:
OK
* Woe32 with MSVC 4.0:
OK
* Woe32 with MSVC 5.0:
OK

149
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/README
View File

@@ -1,149 +0,0 @@
GNU LIBICONV - character set conversion library
This library provides an iconv() implementation, for use on systems which
don't have one, or whose implementation cannot convert from/to Unicode.
It provides support for the encodings:
European languages
ASCII, ISO-8859-{1,2,3,4,5,7,9,10,13,14,15,16},
KOI8-R, KOI8-U, KOI8-RU,
CP{1250,1251,1252,1253,1254,1257}, CP{850,866},
Mac{Roman,CentralEurope,Iceland,Croatian,Romania},
Mac{Cyrillic,Ukraine,Greek,Turkish},
Macintosh
Semitic languages
ISO-8859-{6,8}, CP{1255,1256}, CP862, Mac{Hebrew,Arabic}
Japanese
EUC-JP, SHIFT_JIS, CP932, ISO-2022-JP, ISO-2022-JP-2, ISO-2022-JP-1
Chinese
EUC-CN, HZ, GBK, GB18030, EUC-TW, BIG5, CP950, BIG5-HKSCS,
ISO-2022-CN, ISO-2022-CN-EXT
Korean
EUC-KR, CP949, ISO-2022-KR, JOHAB
Armenian
ARMSCII-8
Georgian
Georgian-Academy, Georgian-PS
Tajik
KOI8-T
Thai
TIS-620, CP874, MacThai
Laotian
MuleLao-1, CP1133
Vietnamese
VISCII, TCVN, CP1258
Platform specifics
HP-ROMAN8, NEXTSTEP
Full Unicode
UTF-8
UCS-2, UCS-2BE, UCS-2LE
UCS-4, UCS-4BE, UCS-4LE
UTF-16, UTF-16BE, UTF-16LE
UTF-32, UTF-32BE, UTF-32LE
UTF-7
C99, JAVA
Full Unicode, in terms of `uint16_t' or `uint32_t'
(with machine dependent endianness and alignment)
UCS-2-INTERNAL, UCS-4-INTERNAL
Locale dependent, in terms of `char' or `wchar_t'
(with machine dependent endianness and alignment, and with OS and
locale dependent semantics)
char, wchar_t
The empty encoding name "" is equivalent to "char": it denotes the
locale dependent character encoding.
When configured with the option --enable-extra-encodings, it also provides
support for a few extra encodings:
European languages
CP{437,737,775,852,853,855,857,858,860,861,863,865,869,1125}
Semitic languages
CP864
Japanese
EUC-JISX0213, Shift_JISX0213, ISO-2022-JP-3
Turkmen
TDS565
Platform specifics
RISCOS-LATIN1
It can convert from any of these encodings to any other, through Unicode
conversion.
It has also some limited support for transliteration, i.e. when a character
cannot be represented in the target character set, it can be approximated
through one or several similarly looking characters. Transliteration is
activated when "//TRANSLIT" is appended to the target encoding name.
libiconv is for you if your application needs to support multiple character
encodings, but that support lacks from your system.
Installation:
As usual for GNU packages:
$ ./configure --prefix=/usr/local
$ make
$ make install
After installing GNU libiconv for the first time, it is recommended to
recompile and reinstall GNU gettext, so that it can take advantage of
libiconv.
On systems other than GNU/Linux, the iconv program will be internationalized
only if GNU gettext has been built and installed before GNU libiconv. This
means that the first time GNU libiconv is installed, we have a circular
dependency between the GNU libiconv and GNU gettext packages, which can be
resolved by building and installing either
- first libiconv, then gettext, then libiconv again,
or (on systems supporting shared libraries, excluding AIX)
- first gettext, then libiconv, then gettext again.
Recall that before building a package for the second time, you need to erase
the traces of the first build by running "make distclean".
This library can be built and installed in two variants:
- The library mode. This works on all systems, and uses a library
`libiconv.so' and a header file `<iconv.h>'. (Both are installed
through "make install".)
To use it, simply #include <iconv.h> and use the functions.
To use it in an autoconfiguring package:
- If you don't use automake, append m4/iconv.m4 to your aclocal.m4
file.
- If you do use automake, add m4/iconv.m4 to your m4 macro repository.
- Add to the link command line of libraries and executables that use
the functions the placeholder @LIBICONV@ (or, if using libtool for
the link, @LTLIBICONV@). If you use automake, the right place for
these additions are the *_LDADD variables.
Note that 'iconv.m4' is also part of the GNU gettext package, which
installs it in /usr/local/share/aclocal/iconv.m4.
- The libc plug/override mode. This works on GNU/Linux, Solaris and OSF/1
systems only. It is a way to get good iconv support without having
glibc-2.1.
It installs a library `libiconv_plug.so'. This library can be used with
LD_PRELOAD, to override the iconv* functions present in the C library.
On GNU/Linux and Solaris:
$ export LD_PRELOAD=/usr/local/lib/libiconv_plug.so
On OSF/1:
$ export _RLD_LIST=/usr/local/lib/libiconv_plug.so:DEFAULT
A program's source need not be modified, the program need not even be
recompiled. Just set the LD_PRELOAD environment variable, that's it!
Distribution:
ftp://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.9.2.tar.gz
Homepage:
http://www.gnu.org/software/libiconv/
Bug reports to:
<bug-gnu-libiconv@gnu.org>
Bruno Haible <bruno@clisp.org>

13
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/THANKS
View File

@@ -1,13 +0,0 @@
Thanks to for
Edmund Grimley Evans <edmundo@rano.org> bug reports
Taro Muraoka <koron@tka.att.ne.jp> Woe32 DLL support
Akira Hatakeyama <akira@sra.co.jp> OS/2 support
Juan Manuel Guerrero <st001906@hrz1.hrz.tu-darmstadt.de>
DOS/DJGPP support
Hironori Sakamoto <hsaka@mth.biglobe.ne.jp> advice on EUC-JP and JISX0213

122
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/djgpp/README
View File

@@ -1,122 +0,0 @@
This is a port of GNU Libiconv 1.8 to MSDOS/DJGPP.
1.: DJGPP specific changes.
=======================
There are no DJGPP specific changes. This package should
configure and compile out-of-the-box.
Please read the documentation to become familiar with this
product.
2.: Installing the binary package.
==============================
2.1.: Copy the binary distribution into the top DJGPP installation
directory and unzip the binary distribution running *ONE* of
the following commands:
unzip32 licv18b.zip or
djtarx licv18b.zip or
pkunzip -d licv18b.zip
3.: Building the binaries from sources.
===================================
3.1.: To build the binaries you will need the following binary packages:
djdev203.zip, bsh204b.zip, gcc2952b.zip,
bnu210b.zip, mak3791b.zip, fil316b.zip,
shl112b.zip, txt20b.zip, txi40b.zip,
grep24b.zip and sed302b.zip
All this packages can be found in the v2gnu directory of any
Simtel.NET mirror.
You will need bsh204b.zip and *NOT* a prior version or the build will fail.
The same applies to djdev203.zip. You *MUST* use the updated versions of
fil316b.zip (date: 2000-05-30) and shl112b.zip (date: 2000-08-11). This
updated versions have been recompiled with djdev203.zip and know about
the "/dev/env" functionality introduced with djdev203.zip. All the other
packages are the ones I have used to build the binaries from this sources.
Previuos and/or later versions of this packages may do the job as well but
I have not tested this.
3.2.: Create a temporary directory and copy the source package: licv18s.zip
into the temporary directory. If you download the source distribution
from one of the DJGPP archives, just unzip it preserving the directory
structure, runnig ONE of the following commands:
unzip32 licv18s.zip or
djtarx licv18s.zip or
pkunzip -d licv18s.zip
Source distributions downloaded from one of the GNU FTP sites need
some more work to unpack. First, you MUST use the `djtar' program to
unzip the package. That's because some file names in the official
distributions need to be changed to avoid problems on the various
platforms supported by DJGPP. `djtar' can rename files on the fly
given a file with name mappings. The distribution includes a file
`djgpp/fnchange.lst' with the necessary mappings. So you need first
to retrieve that file, and then invoke `djtar' to unpack the
distribution. Here's how:
djtar -x -p -o libiconv-1.7/djgpp/fnchange.lst libiconv-1.7.tar.gz > lst
djtar -x -n lst libiconv-1.7.tar.gz
(The name of the distribution archive and the top-level directory will
be different for versions other than 1.7.)
3.3.: The package is preconfigured for djdev203. To build the products you
should run the following command:
make
After the compilation has finished, you can check the products
running the command:
make check
To install the products run the command:
make install
This will install the products (iconv.exe iconv.h localcharset.h libconv.a
libcharset.a iconv.1 iconv.3 iconv_open.3 iconv_close.3) into your DJGPP
installation tree. As usual, prefix is defined as "/dev/env/DJDIR".
If you prefer to install into same other directory run the command:
make install prefix=z:/some/other/dir
Of course, you should replace "z:/some/other/dir" by an appropriate path
that will meet your requeriments.
3.4.: If you need/want to reconfigure the package you will have to run the
following commands:
make distclean
djgpp\config
Please note that you *MUST* use the "distclean" option or the config.cache
file will *NOT* be deleted. In this case you are *NOT* reconfiguring
because the configuration informations is read from the cache file instead
of being newly computed.
To build the programs in a directory other than where the sources are,
you must add the parameter that specifies the source directory,
e.g:
x:\src\gnu\libiconv.18\djgpp\config x:/src/gnu/libiconv.18
Lets assume you want to build the binaries in a directory placed on a
different drive (z:\build in this case) from where the sources are,
then you will run the following commands:
z:
md \build
cd \build
x:\src\gnu\libiconv.18\djgpp\config x:/src/gnu/libiconv.18
You *MUST* use forward slashes to specify the source directory.
After having configured the package run the folowing commands to create
the binaries and docs and install them:
make
make check
make install
Send suggestions and bug reports concerning the DJGPP port to
comp.os.msdos.djgpp or djgpp@delorie.com. Libiconv specific bugs
must be reported to Bruno Haible <haible@clisp.cons.org>.
Guerrero, Juan Manuel <st001906@hrz1.hrz.tu-darmstadt.de>

64
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/extras/ChangeLog
View File

@@ -1,64 +0,0 @@
2003-05-10 Bruno Haible <bruno@clisp.org>
* iconv_string.c (iconv_string): Don't return -1 just because the
string is longer than 4 KB.
2002-02-13 Bruno Haible <bruno@clisp.org>
* iconv.m4: Remove file. Obsoleted by m4/iconv.m4.
2000-06-16 Bruno Haible <haible@clisp.cons.org>
* iconv.m4: Change prefix to AM.
2001-05-23 Bruno Haible <haible@clisp.cons.org>
* iconv.m4 (jm_ICONV): Accept --with-libiconv-prefix option.
2001-03-23 Bruno Haible <haible@clisp.cons.org>
* iconv.m4 (jm_ICONV): Tweak printing of prototype.
2001-03-20 Bruno Haible <haible@clisp.cons.org>
* iconv.m4 (jm_ICONV): Recommend GNU libiconv.
2001-01-03 Bruno Haible <haible@clisp.cons.org>
* iconv.m4 (jm_ICONV): Also check whether the iconv declaration
has const.
2000-02-02 Bruno Haible <haible@clisp.cons.org>
* iconv.m4: New file.
2001-01-29 Bruno Haible <haible@clisp.cons.org>
* locale_charset.c: Remove file. Obsoleted by libcharset.
2000-10-22 Bruno Haible <haible@clisp.cons.org>
* locale_charset.c (get_locale_charset): Accept french and spanish
names in both ISO-8859-1 and UTF-8.
2000-08-24 Jim Blackson <blackson@ontrack-japan.com>
* iconv_string.c (iconv_string): Fix return value for autodetect.
2000-01-24 Bruno Haible <haible@clisp.cons.org>
* iconv_string.c (iconv_string): Stop recognizing JOHAB.
Fix typo for EUC-JP.
1999-12-18 Bruno Haible <haible@clisp.cons.org>
* locale_charset.c (get_locale_charset): Recognize more language codes:
"af" (afrikaans), "ca" (catalan), "eu" (basque), "fo" (faeroese),
"ga" (irish), "gd" (scottish), "gl" (galician), "sq" (albanian),
"eo" (esperanto), "mt" (maltese), "be" (byelorussian),
"et" (estonian), "lt" (lithuanian), "lv" (latvian), "uk" (ukrainian).
Recognize more aliases: "english", "slovenian", "macedonian",
"serbian", "arabic".
Change default: KOI8-R for "ru" (russian) instead of ISO-8859-5,
ISO-8859-5 for "sr" instead of ISO-8859-2.

1
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/AUTHORS
View File

@@ -1 +0,0 @@
Bruno Haible <bruno@clisp.org>

322
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/ChangeLog
View File

@@ -1,322 +0,0 @@
2003-06-18 Bruno Haible <bruno@clisp.org>
* config/install-sh: Update from automake-1.7.5.
2003-06-07 Bruno Haible <bruno@clisp.org>
* Makefile.devel (config.h_vms): Remove INSTALLPREFIX.
Reported by Jouk Jansen <joukj@hrem.stm.tudelft.nl>.
2003-05-19 Bruno Haible <bruno@clisp.org>
* windows/charset.rc: Include <winver.h>.
Reported by Perry Rapp.
2003-05-07 Bruno Haible <bruno@clisp.org>
* Makefile.vms: New file.
* Makefile.devel (config.h_vms): New rule.
(all): Depend on it.
2003-05-06 Bruno Haible <bruno@clisp.org>
* m4/libtool.m4: Update from GNU gettext, based on libtool-1.5.
2003-05-06 Bruno Haible <bruno@clisp.org>
* autoconf/config.guess: Update to GNU version 2003-02-22.
* autoconf/config.sub: Likewise.
2003-05-06 Bruno Haible <bruno@clisp.org>
* autoconf/ltmain.sh: Update from GNU gettext, based on libtool-1.5.
2003-04-12 Bruno Haible <bruno@clisp.org>
* configure.in (mandir): Change default value.
* Makefile.in (datadir): New variable.
2003-04-05 Bruno Haible <bruno@clisp.org>
Support for relocatable installation.
* autoconf/config.libpath: New file, from GNU gettext.
* configure.in: Invoke AC_RELOCATABLE_LIBRARY.
* include/libcharset.h.in: New file.
* Makefile.devel (include/libcharset.h.msvc-shared): New rule.
(all): Depend on it.
(autoconf/aclocal.m4): Update aclocal invocation.
(config.h.msvc): Handle INSTALLPREFIX.
* Makefile.in (include/libcharset.h): New rule.
(all): Depend on it.
(install-lib, install): Also install libcharset.h.
(uninstall): Uninstall libcharset.h.
(distclean, maintainer-clean): Remove include/libcharset.h.
* Makefile.msvc (all): Create include/libcharset.h.
(install): Also install libcharset.h.
(uninstall): Uninstall libcharset.h.
(mostlyclean, clean, distclean, maintainer-clean): Remove
include/libcharset.h.
* INSTALL.generic: Document --enable-relocatable and
--with-libintl-prefix. Remove the recommendation to set CPPFLAGS and
LDFLAGS. The lib-link.m4 macros make this unnecessary.
2003-04-05 Bruno Haible <bruno@clisp.org>
* Makefile.msvc (PREFIX): New variable.
(prefix): Use it.
(distclean, maintainer-clean): Drop Unix specific removals.
* man/Makefile.msvc (PREFIX): New variable.
(prefix): Use it.
(clean): Drop unnecessary removals.
(distclean): Drop Unix specific removal.
2003-04-05 Bruno Haible <bruno@clisp.org>
* configure.in: Invoke AM_LANGINFO_CODESET, not jm_LANGINFO_CODESET.
* autoconf/ltmain.sh: Update from GNU gettext.
2003-02-18 Bruno Haible <bruno@clisp.org>
Fix the 2002-09-16 fix.
* ltmain.sh (install): If "ln -s -f" fails (this is the case
with /usr/bin/ln on Solaris 2.7), fall back to "rm && ln -s".
2003-03-17 Bruno Haible <bruno@clisp.org>
Improved MSVC support.
* windows/charset.rc: New file.
* Makefile.msvc (prefix): Use less Unixy value.
(local_prefix): Remove variable.
(libdir, includedir): Use backslashes.
(bindir): New variable.
(mandir): Remove variable.
(INSTALL, INSTALL_PROGRAM, INSTALL_DATA): New variables.
(mostlyclean, clean): Remove config.h and include/localcharset.h.
(install, installdirs, uninstall): Rewritten.
* README.woe32: Mention automatic installation command.
Rename libcharset.h to localcharset.h.
* include/localcharset.h.in: Renamed from include/libcharset.h.in.
* tools/locale_charset.c: Include localcharset.h, not libcharset.h.
* Makefile.in (include/localcharset.h): Renamed from
include/libcharset.h.
(all): Update dependency.
(install-lib, install, uninstall, distclean, maintainer-clean): Update.
* Makefile.msvc (all): Create include/localcharset.h, not
include/libcharset.h.
* Makefile.devel (include/localcharset.h.msvc-shared): Renamed from
include/libcharset.h.msvc-shared.
(all): Update dependency.
(config.h.in): Touch the file when done; autoheader doesn't do it.
(config.h.msvc): Make rule more robust.
* INTEGRATE: Mention localcharset.h only once.
* djgpp/README.in, djgpp/README: Update.
* djgpp/config.bat: Update.
* djgpp/config.sed: Update.
* djgpp/fnchange.in, djgpp/fnchange.lst: Update.
* configure.in (VERSION): Bump to 1.2.
* NEWS: New file.
2003-02-14 Bruno Haible <bruno@clisp.org>
* Makefile.devel (AUTOCONF): Switch to autoconf-2.57.
(configure, config.h.in): Update rules.
2003-01-03 Albert Chin <libtool@thewrittenword.com>
* autoconf/ltmain.sh: Don't pass -R flags found in a .la's
dependency_libs variable directly down to the linker.
Reported by Tim Mooney <mooney@dogbert.cc.ndsu.nodak.edu>.
2003-01-12 Bruno Haible <bruno@clisp.org>
* INTEGRATE: Mention localcharset.h.
2003-01-01 Bruno Haible <bruno@clisp.org>
* Makefile.in (mkinstalldirs): Renamed from MKINSTALLDIRS.
(install-lib, install, installdirs): Use it.
2002-09-27 Bruno Haible <bruno@clisp.org>
* autoconf/mkinstalldirs: Upgrade to automake-1.7.2 version.
2002-11-07 Bruno Haible <bruno@clisp.org>
* autoconf/ltmain.sh: Upgrade to libtool-1.4.3.
2002-06-12 Bruno Haible <bruno@clisp.org>
* configure.in: Use new AC_* names of libtool macros. Invoke
AC_LIBTOOL_WIN32_DLL.
2002-11-07 Bruno Haible <bruno@clisp.org>
Make "make install" without prior "make" work.
* Makefile.in (install): Depend on include/libcharset.h.
Reported by Martin Mokrejš <mmokrejs@natur.cuni.cz>.
2002-05-12 Bruno Haible <bruno@clisp.org>
* tools/all-charsets: Update for change of lib/config.charset.
2002-05-12 Bruno Haible <bruno@clisp.org>
* Makefile.devel (AUTOCONF): New variable.
(configure): Use the AUTOCONF variable.
2002-05-08 Bruno Haible <bruno@clisp.org>
* README.woe32: Renamed from README.win32.
2002-02-06 Bruno Haible <bruno@clisp.org>
* m4/libtool.m4: Upgrade to libtool-1.4.2.
* autoconf/ltmain.sh: Likewise.
2002-02-02 Bruno Haible <bruno@clisp.org>
* autoconf/ltmain.sh: Add DESTDIR support on ELF systems.
2001-11-03 Bruno Haible <haible@clisp.cons.org>
* autoconf/ltmain.sh: chmod 777 the .libs directory, so that
"make install" succeeds.
2001-12-04 Bruno Haible <bruno@clisp.org>
* INTEGRATE: Change the install rule to not create $(libdir) if
there is no file to install in it.
2001-07-17 Bruno Haible <haible@clisp.cons.org>
* configure.in (VERSION): Bump to 1.1.
2001-06-08 Bruno Haible <haible@clisp.cons.org>
* m4/libtool.m4: Upgrade to libtool-1.4.
* autoconf/ltmain.sh: Likewise.
* autoconf/ltconfig: Remove file.
2001-06-08 Bruno Haible <haible@clisp.cons.org>
* autoconf/config.guess: Update to GNU version 2001-05-11.
* autoconf/config.sub: Likewise.
2001-05-21 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (include/libcharset.h): New target.
(all): Depend on it.
2001-05-11 Bruno Haible <haible@clisp.cons.org>
* INTEGRATE (Makefile.in): Fix syntax error.
2001-05-06 Bruno Haible <haible@clisp.cons.org>
* Makefile.msvc (config.h): Allow the 'del' command to fail.
2001-03-21 Bruno Haible <haible@clisp.cons.org>
* INSTALL.generic (Particular Systems): Add recommendations for AIX 3.
2001-03-10 Bruno Haible <haible@clisp.cons.org>
* INSTALL.generic: New section "Particular Systems".
2001-03-05 Bruno Haible <haible@clisp.cons.org>
* tools/all-charsets: Update for change of lib/config.charset.
2001-03-01 Bruno Haible <haible@clisp.cons.org>
* tools/all-charsets: Update for change of lib/config.charset.
2001-02-25 Bruno Haible <haible@clisp.cons.org>
* autoconf/ltconfig:
sed -e 's/reload object files/produce relocatable object files/'.
2001-02-25 Bruno Haible <haible@clisp.cons.org>
* include/libcharset.h.in (locale_charset): Return value is never
NULL any more.
2001-02-22 Bruno Haible <haible@clisp.cons.org>
* INTEGRATE (Makefile.am): Change $@-t to t-$@. For DJGPP.
Patch by Juan Manuel Guerrero <st001906@hrz1.hrz.tu-darmstadt.de>.
2001-02-20 Bruno Haible <haible@clisp.cons.org>
Better support for DOS/Windows platforms.
* autoconf/ltconfig: Upgrade to libtool-1.3.5.
* autoconf/ltmain.sh: Likewise.
* m4/libtool.m4: Likewise.
* autoconf/aclocal.m4: Likewise.
* configure.in: Call AC_OBJEXT and AC_EXEEXT.
2001-02-20 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (libdir, includedir, mandir): Use the autoconf
determined value, in order to respect the configure arguments.
* lib/Makefile.in (libdir): Likewise.
2000-12-13 Bruno Haible <haible@clisp.cons.org>
* autoconf/install-sh: Update to a newer version from fileutils.
2000-12-12 Bruno Haible <haible@clisp.cons.org>
* Makefile.in: Use $(MAKE) instead of $(MAKE) -r. Needed with Solaris
"make", which doesn't set MAKE as expected by @SET_MAKE@ if -r is
given. Reported by Toshimitsu Fujiwara.
2000-12-08 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (exec_prefix): Use configure's --exec-prefix argument.
2000-12-02 Bruno Haible <haible@clisp.cons.org>
* Makefile.msvc (check): Depend on target 'force' as well.
(mostlyclean, clean, distclean, maintainer-clean): Fix dependency.
* Makefile.msvc: Replace STATIC with its opposite flag, DLL.
2000-11-24 Bruno Haible <haible@clisp.cons.org>
* tools/all-charsets: Update for 2000-10-31 change of
lib/config.charset.
2000-11-23 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (install-lib): Fix for builddir != srcdir.
2000-11-22 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (all): Fix for builddir != srcdir.
2000-11-21 Bruno Haible <haible@clisp.cons.org>
* include/libcharset.h.in: Renamed from include/libcharset.h.
* windows/dllexport.h: New file.
* Makefile.devel (all): Add config.h.msvc,
include/libcharset.h.msvc-shared.
(config.h.msvc, include/libcharset.h.msvc-shared): New targets.
* Makefile.msvc (MFLAGS): New variable.
(all): Create include\libcharset.h.
(distclean, maintainer-clean): Remove include\libcharset.h.
* Makefile.in (CP): New variable.
(all): Create include/libcharset.h.
(distclean, maintainer-clean): Remove include/libcharset.h.
2000-11-18 Bruno Haible <haible@clisp.cons.org>
* Makefile.devel (config.h.in): Rename from config.h.
2000-11-16 Bruno Haible <haible@clisp.cons.org>
* Makefile.in: After "cd", use "&&" not ";".
2000-10-31 Bruno Haible <haible@clisp.cons.org>
* Makefile.msvc: New file.
* README.win32: New file.

2
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/NEWS
View File

@@ -1,2 +0,0 @@
New in 1.2:
* The include file is renamed from "libcharset.h" to "localcharset.h".

60
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/README
View File

@@ -1,60 +0,0 @@
LIBCHARSET - portable character set determination library
This library provides a function which determines the character set / encoding
of text in the currently selected locale (the LC_CTYPE locale facet).
It is useful for portable programs which need to process text in other
encodings and locales than the currently selected one. Possible uses:
* Use of Unicode in POSIX compliant applications.
* Conversion of text between the current locale's encoding and UTF-8 (or
any other given encoding).
* Mail agents.
In theory, this would be very simple: The Single Unix Specification (SUSV2)
provides the nl_langinfo function, in such a way that
nl_langinfo (CODESET)
returns the encoding name. But the nl_langinfo function still does not exist
on some systems, and on those where it exists it returns unstandardized
variations of the encoding names, like (on Solaris) "PCK" for "Shift_JIS".
This library fixes these flaws and provides a function
const char * locale_charset (void);
It determines the current locale's character encoding, and canonicalizes it
into one of the canonical names listed in config.charset. The result must
not be freed; it is statically allocated. If the canonical name cannot be
determined, the result is a non-canonical name.
Installation:
As usual for GNU packages:
$ ./configure --prefix=/usr/local
$ make
$ make install
This library is used in
GNU sh-utils, fileutils, textutils
GNU gettext
GNU clisp
To integrate this library into your package:
See file INTEGRATE.
Distribution:
The libcharset directory of
ftp://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.8.tar.gz
Homepage:
http://www.haible.de/bruno/packages-libcharset.html
Bruno Haible <bruno@clisp.org>

123
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/djgpp/README
View File

@@ -1,123 +0,0 @@
This is a port of GNU Libiconv 1.7 to MSDOS/DJGPP.
1.: DJGPP specific changes.
=======================
There are no DJGPP specific changes. This package should
configure and compile out-of-the-box.
Please read the documentation to become familiar with this
product.
2.: Installing the binary package.
==============================
2.1.: Copy the binary distribution into the top DJGPP installation
directory and unzip the binary distribution running *ONE* of
the following commands:
unzip32 licv16b.zip or
djtarx licv16b.zip or
pkunzip -d licv16b.zip
3.: Building the binaries from sources.
===================================
3.1.: To build the binaries you will need the following binary packages:
djdev203.zip, bsh204b.zip, gcc2952b.zip,
bnu210b.zip, mak3791b.zip, fil316b.zip,
shl112b.zip, txt20b.zip, txi40b.zip,
grep24b.zip and sed302b.zip
All this packages can be found in the v2gnu directory of any
Simtel.NET mirror.
You will need bsh204b.zip and *NOT* a prior version or the build will fail.
The same applies to djdev203.zip. You *MUST* use the updated versions of
fil316b.zip (date: 2000-05-30) and shl112b.zip (date: 2000-08-11). This
updated versions have been recompiled with djdev203.zip and know about
the "/dev/env" functionality introduced with djdev203.zip. All the other
packages are the ones I have used to build the binaries from this sources.
Previuos and/or later versions of this packages may do the job as well but
I have not tested this.
3.2.: Create a temporary directory and copy the source package: licv16s.zip
into the temporary directory. If you download the source distribution
from one of the DJGPP archives, just unzip it preserving the directory
structure, runnig ONE of the following commands:
unzip32 licv16s.zip or
djtarx licv16s.zip or
pkunzip -d licv16s.zip
Source distributions downloaded from one of the GNU FTP sites need
some more work to unpack. First, you MUST use the `djtar' program to
unzip the package. That's because some file names in the official
distributions need to be changed to avoid problems on the various
platforms supported by DJGPP. `djtar' can rename files on the fly
given a file with name mappings. The distribution includes a file
`djgpp/fnchange.lst' with the necessary mappings. So you need first
to retrieve that file, and then invoke `djtar' to unpack the
distribution. Here's how:
djtar -x -p -o libiconv-1.7/djgpp/fnchange.lst libiconv-1.7.tar.gz > lst
djtar -x -n lst libiconv-1.7.tar.gz
(The name of the distribution archive and the top-level directory will
be different for versions other than 1.7.)
3.3.: The package is preconfigured for djdev203. To build the products you
should run the following command:
make
After the compilation has finished, you can check the products
running the command:
make check
To install the products run the command:
make install
This will install the products (iconv.exe iconv.h localcharset.h libconv.a
libcharset.a iconv.1 iconv.3 iconv_open.3 iconv_close.3) into your DJGPP
installation tree. As usual, prefix is defined as "/dev/env/DJDIR".
If you prefer to install into same other directory run the command:
make install prefix=z:/some/other/dir
Of course, you should replace "z:/some/other/dir" by an appropriate path
that will meet your requeriments.
3.4.: If you need/want to reconfigure the package you will have to run the
following commands:
make distclean
djgpp\config
Please note that you *MUST* use the "distclean" option or the config.cache
file will *NOT* be deleted. In this case you are *NOT* reconfiguring
because the configuration informations is read from the cache file instead
of being newly computed.
To build the programs in a directory other than where the sources are,
you must add the parameter that specifies the source directory,
e.g:
x:\src\gnu\libiconv.16\djgpp\config x:/src/gnu/libiconv.16
Lets assume you want to build the binaries in a directory placed on a
different drive (z:\build in this case) from where the sources are,
then you will run the following commands:
z:
md \build
cd \build
x:\src\gnu\libiconv.16\djgpp\config x:/src/gnu/libiconv.16
You *MUST* use forward slashes to specify the source directory.
After having configured the package run the folowing commands to create
the binaries and docs and install them:
make
make check
make install
Send suggestions and bug reports concerning the DJGPP port to
comp.os.msdos.djgpp or djgpp@delorie.com. Libiconv specific bugs
must be reported to Bruno Haible <haible@clisp.cons.org>.
Guerrero, Juan Manuel <st001906@hrz1.hrz.tu-darmstadt.de>

302
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/lib/ChangeLog
View File

@@ -1,302 +0,0 @@
2004-01-21 Bruno Haible <bruno@clisp.org>
Upgrade from gettext-0.14.
2004-01-21 Bruno Haible <bruno@clisp.org>
* config.charset: Add support for MacOS X (Darwin).
2003-12-02 Bruno Haible <bruno@clisp.org>
* config.charset: Treat the new country name CS like the old country
name YU.
2003-08-20 Bruno Haible <bruno@clisp.org>
* config.charset (linux-gnulibc1*): Change hr_HR, ro_RO to ISO-8859-2.
Reported by Alain Guibert <derogaton+bgli@oreka.com>.
2003-08-14 Bruno Haible <bruno@clisp.org>
* config.charset: Add support for Linux libc5. Based on data from
Alain Guibert <derogaton+bgli@oreka.com>.
2003-06-27 Bruno Haible <bruno@clisp.org>
Avoid use of *_unlocked functions on Solaris 2.5.1.
* localcharset.c: Test HAVE_DECL_GETC_UNLOCKED, not HAVE_GETC_UNLOCKED.
Reported by Eric Botcazou <ebotcazou@libertysurf.fr>.
2003-08-20 Bruno Haible <bruno@clisp.org>
* config.charset (linux-gnulibc1*): Change hr_HR, ro_RO to ISO-8859-2.
Reported by Alain Guibert <derogaton+bgli@oreka.com>.
2003-08-14 Bruno Haible <bruno@clisp.org>
* config.charset: Add support for Linux libc5. Based on data from
Alain Guibert <derogaton+bgli@oreka.com>.
2003-08-01 Bruno Haible <bruno@clisp.org>
* relocatable.c (find_shared_library_fullname): Disable the code on
Linux/libc5. Reported by Alain Guibert <derogaton+bgli@oreka.com>.
2003-06-22 Bruno Haible <bruno@clisp.org>
Portability to mingw32.
* relocatable.c [WIN32]: Include <windows.h>.
Reported by Jeff Bonggren <jbon@cfl.rr.com>.
2003-06-22 Bruno Haible <bruno@clisp.org>
* relocatable.c (compute_curr_prefix): Comment out this function in
the case when it is not used.
Reported by Pavel Roskin <proski@gnu.org>.
2003-06-07 Bruno Haible <bruno@clisp.org>
Support for relocatable data files even on VMS.
* Makefile.vms (bindir): New variable.
(DEFS): Add flags for relocatability.
Reported by Jouk Jansen <joukj@hrem.stm.tudelft.nl>.
2003-06-07 Bruno Haible <bruno@clisp.org>
Support for relocatable data files even on Woe32.
* Makefile.msvc (IIPREFIX, IIprefix, IIexec_prefix, IIbindir,
IIlibdir): New variables.
(PICFLAGS): Also define PIC. Define BUILDING_* flags here.
(CFLAGS): ... not here. Add flags for relocatability.
2003-05-18 Bruno Haible <bruno@clisp.org>
* Makefile.msvc (DEBUGFLAGS): New variable.
(charset.lib): Use it.
2003-05-07 Bruno Haible <bruno@clisp.org>
* Makefile.vms: New file.
2003-04-12 Bruno Haible <bruno@clisp.org>
* lib/localcharset.c (get_charset_aliases): Add special case for VMS.
2003-04-05 Bruno Haible <bruno@clisp.org>
Support for relocatable installation.
* relocatable.h: New file, from GNU gettext.
* relocatable.c: New file, from GNU gettext.
* localcharset.c: Update from GNU gettext.
2003-02-28 Bruno Haible <bruno@clisp.org>
* localcharset.c: Include relocatable.h.
(get_charset_aliases): Relocate LIBDIR value.
* localcharset.c: Drop C linkage declaration.
* Makefile.in (DEFS): New variable.
(SOURCES): Add relocatable.c.
(OBJECTS): Add relocatable.lo.
(localcharset.lo): Use $(DEFS).
(relocatable.lo): New rule.
* Makefile.msvc (CFLAGS): Remove $(PICFLAGS).
(INCLUDES): Simplify.
(SOURCES): Remove variable.
(OBJECTS): Add relocatable.obj.
(localcharset.obj): Add $(PICFLAGS).
(relocatable.obj): New rule.
2003-04-05 Bruno Haible <bruno@clisp.org>
* Makefile.msvc (PREFIX): New variable.
(prefix): Use it.
(clean): Drop Unix specific removal.
2003-03-17 Bruno Haible <bruno@clisp.org>
Improved MSVC support.
* Makefile.msvc (prefix): Use less Unixy value.
(local_prefix): Remove variable.
(libdir): Use backslashes.
(bindir): New variable.
(INSTALL, INSTALL_PROGRAM, INSTALL_DATA): Set to real values.
(RESOURCES): Enable charset.res.
(charset.lib): Set the target library name explicitly.
(charset.res): New rule.
(install, installdirs, uninstall): New rules.
Rename libcharset.h to localcharset.h.
* localcharset.c: Include localcharset.h.
* localcharset.h: Remove file.
* Makefile.in (INCLUDES): Add -I../include.
* Makefile.msvc (INCLUDES): Add -I../include.
2003-01-29 Bruno Haible <bruno@clisp.org>
* config.charset: Add an alias for CP1251 on Solaris.
Reported by Hidetoshi Tajima <hidetoshi.tajima@sun.com>.
2003-01-12 Bruno Haible <bruno@clisp.org>
* localcharset.h: New file.
* localcharset.c: Include it.
2003-01-01 Bruno Haible <bruno@clisp.org>
* Makefile.in (mkinstalldirs): Renamed from MKINSTALLDIRS.
(install-lib, install, installdirs): Use it.
2002-05-09 Bruno Haible <bruno@clisp.org>
* config.charset: Update for newest glibc. Add canonical names
ISO-8859-14, KOI8-T, TCVN5712-1, GEORGIAN-PS.
2002-05-09 Bruno Haible <bruno@clisp.org>
* localcharset.c (get_charset_aliases): Add more Windows specific
aliases.
2002-05-08 Owen Taylor <otaylor@redhat.com>
* config.charset: A few additions for Solaris.
2002-02-15 Bruno Haible <bruno@clisp.org>
* config.charset [msdosdjgpp]: For Russian, use CP866.
2002-02-11 Bruno Haible <bruno@clisp.org>
* config.charset: Add support for NetBSD.
2002-01-10 Andrew Zabolotny <zap@cobra.ru>
Bruno Haible <bruno@clisp.org>
* localcharset.c: Rework OS/2 support.
* config.charset: Add OS/2 support.
2001-12-21 Bruno Haible <bruno@clisp.org>
* localcharset.c (ISSLASH): Provide definition for DOS-like systems.
2001-12-15 Bruno Haible <bruno@clisp.org>
* localcharset.c: Add OS/2 support.
2001-12-05 Bruno Haible <bruno@clisp.org>
* localcharset.c (locale_charset): Don't return an empty string.
2001-10-23 Bruno Haible <haible@clisp.cons.org>
* config.charset: msdos in uk_UA uses CP1125.
2001-08-05 Bruno Haible <haible@clisp.cons.org>
Make it possible to build libcharset with CC=gcc CFLAGS="-x c++".
* localcharset.c (locale_charset): Declare as extern "C".
(get_charset_aliases): Cast malloc and realloc results to 'char *'.
2001-06-27 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (clean): Remove also *.o.lock, left there by libtool
on IRIX.
2001-06-25 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (localcharset.lo): Mention $(INCLUDES) before $(CFLAGS)
and $(CPPFLAGS).
* Makefile.msvc (localcharset.obj): Likewise.
2001-06-24 Bruno Haible <haible@clisp.cons.org>
* config.charset: Change canonical name of BIG5HKSCS to BIG5-HKSCS.
Change canonical name of SJIS to SHIFT_JIS.
2001-05-06 Bruno Haible <haible@clisp.cons.org>
* Makefile.msvc (charset.lib): Allow the 'del' command to fail.
2001-05-06 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (CPPFLAGS, LDFLAGS): New variables.
(libcharset.la): Use LDFLAGS.
(localcharset.lo): Use CPPFLAGS.
2001-04-30 Bruno Haible <haible@clisp.cons.org>
Silence "gcc -Wall -Wwrite-strings" warnings.
* localcharset.c (charset_aliases): Change type to 'const char *'.
(get_charset_aliases): Change type of 'cp' to 'const char *'.
2001-03-10 Bruno Haible <haible@clisp.cons.org>
* localcharset.c (locale_charset): Allow wildcard syntax. Also resolve
alias if codeset is empty.
* config.charset (BeOS): Use wildcard syntax.
* Makefile.in (libcharset.la): Pass flag -no-undefined. Needed on
platforms like BeOS.
* Makefile.in (RM): New variable.
2001-01-05 Bruno Haible <haible@clisp.cons.org>
* localcharset.c (volatile): Define to empty if not using ANSI C.
2001-03-05 Bruno Haible <haible@clisp.cons.org>
* config.charset: Update for OSF/1 5.1.
2001-03-01 Bruno Haible <haible@clisp.cons.org>
* config.charset: For DOS/DJGPP, add CP775.
2001-02-24 Bruno Haible <haible@clisp.cons.org>
* config.charset: Add support for DOS/DJGPP.
2001-02-25 Bruno Haible <haible@clisp.cons.org>
* localcharset.c (locale_charset): Don't return NULL.
2001-02-24 Bruno Haible <haible@clisp.cons.org>
* localcharset.c (locale_charset): Don't use setlocale(LC_CTYPE,NULL).
2001-01-30 Bruno Haible <haible@clisp.cons.org>
* config.charset: Update for FreeBSD 4.2.
2000-12-19 Jim Meyering <jim@meyering.net>
* localcharset.c: Improve WIN32 macrology.
(locale_charset): Increase size of buffer.
2000-12-18 Bruno Haible <haible@clisp.cons.org>
* config.charset: Add support for BeOS.
2000-12-12 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (ref-add.sed, ref-del.sed): Don't use $<, not understood
by Solaris "make". Reported by Toshimitsu Fujiwara.
2000-12-08 Bruno Haible <haible@clisp.cons.org>
* Makefile.in (exec_prefix): Use configure's --exec-prefix argument.
2000-12-02 Bruno Haible <haible@clisp.cons.org>
* Makefile.msvc: Replace STATIC with its opposite flag, DLL.
2000-11-21 Bruno Haible <haible@clisp.cons.org>
* Makefile.msvc (MFLAGS): New variable.
(CFLAGS, charset.lib): Use it.
(INCLUDES): Use "..", not "..\include".
2000-10-31 Bruno Haible <haible@clisp.cons.org>
* Makefile.msvc: New file.
2000-10-31 Bruno Haible <haible@clisp.cons.org>
* config.charset: Add ISO-8859-3, BIG5HKSCS, GB18030, JOHAB, VISCII,
CP874, CP949, CP950, CP1250, CP1253, CP1254, CP1255, CP1256, CP1257
to the list of canonical encodings. Rename EUC-CN to GB2312.
* localcharset.c (locale_charset): Add support for Win32.

18
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/m4/ChangeLog
View File

@@ -1,18 +0,0 @@
2003-04-05 Bruno Haible <bruno@clisp.org>
Support for relocatable installation.
* relocatable.m4: New file, from GNU gettext.
2003-04-05 Bruno Haible <bruno@clisp.org>
* codeset.m4: Update from GNU gettext-0.10.40.
* glibc21.m4: Update from GNU gettext-0.10.40.
2002-11-07 Bruno Haible <bruno@clisp.org>
* libtool.m4: Upgrade to libtool-1.4.3.
2002-07-14 Bruno Haible <bruno@clisp.org>
* libtool.m4 (_LT_AC_LTCONFIG_HACK): Add support for GNU/FreeBSD.

25
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/libcharset/tools/README
View File

@@ -1,25 +0,0 @@
This directory contains tools for maintaining the config.charset file.
The main script is "all-charsets". Before using it, you must configure
this package. For all installed locales, it prints
- the result of the command "locale charmap",
- the result of "nl_langinfo (CODESET)",
- the result of "locale_charset ()".
It uses the following auxiliary scripts and programs:
- all-locales
Prints all usable locales in the system, one per line.
- locale_charmap
Executes "locale charmap".
- locale_codeset.c
Prints nl_langinfo (CODESET).
- locale_charset.c
Prints locale_charset().
A second main script is "all-charsets-X11". It also prints the X11
encoding name. Before using it, you must tweak the X11 paths needed
for compiling locale_x11encoding (a simple X11 program), and let your
DISPLAY environment variable point to a running X11 screen.
The other files are test results from various operating systems.

148
gnuwin32/contrib/libiconv/1.9.2/libiconv-1.9.2-src/po/ChangeLog
View File

@@ -1,148 +0,0 @@
2003-11-13 Bruno Haible <bruno@clisp.org>
* sr.po: New file, from Aleksandar Jelenak <jelenak@netlinkplus.net>.
* LINGUAS: Add sr.
2003-10-14 Bruno Haible <bruno@clisp.org>
* pl.po: New file, from Arkadiusz Lipiec <A.Lipiec@elka.pw.edu.pl>.
* LINGUAS: Add pl.
2003-08-22 Bruno Haible <bruno@clisp.org>
* wa.po: New file, from Pablo Saratxaga <pablo@walon.org>.
* LINGUAS: Add wa.
2003-08-05 Bruno Haible <bruno@clisp.org>
* nl.po: Update from Elros Cyriatan <cyriatan@fastmail.fm>.
2003-07-31 Bruno Haible <bruno@clisp.org>
* nl.po: New file, from Taco Witte <T.C.Witte@phys.uu.nl>.
* LINGUAS: Add nl.
2003-06-11 Bruno Haible <bruno@clisp.org>
* et.po: New file, from Toomas Soome <Toomas.Soome@microlink.ee>.
* ro.po: Update from Eugen Hoanca <eugenh@urban-grafx.ro>.
* ru.po: Update from Dmitry S. Sivachenko <mitya@cavia.pp.ru>.
* zh_CN.po: New file, from Wang Jian <lark@linux.net.cn>.
* LINGUAS: Add et and zh_CN.
2003-05-07 Bruno Haible <bruno@clisp.org>
* ga.po: Update from Kevin Patrick Scannell <scannell@slu.edu>.
2003-05-06 Bruno Haible <bruno@clisp.org>
* ga.po: New file, from Kevin Patrick Scannell <scannell@slu.edu>.
* LINGUAS: Add it.
2003-04-22 Bruno Haible <bruno@clisp.org>
* ro.po: New file, from Eugen Hoanca <eugenh@urban-grafx.ro>.
* LINGUAS: Add it.
2003-04-05 Bruno Haible <bruno@clisp.org>
* Makefile.msvc.sh (PREFIX): New variable.
(prefix): Use it.
(clean): Drop Unix specific removal.
2003-04-09 Bruno Haible <bruno@clisp.org>
* Makevars (MSGID_BUGS_ADDRESS): New variable.
2003-04-09 gettextize <bug-gnu-gettext@gnu.org>
* Makefile.in.in: Upgrade to gettext-0.12-pre3.
2003-03-17 Bruno Haible <bruno@clisp.org>
Improved MSVC support.
* Makefile.msvc.sh: New file.
* Rules-msvc: New file.
2003-02-10 Bruno Haible <bruno@clisp.org>
* uk.po: New file, from Volodymyr M. Lisivka <lvm@mystery.lviv.net>.
* LINGUAS: Add it.
2002-12-05 Bruno Haible <bruno@clisp.org>
* it.po: New file, from Marco Parrone <marc0@autistici.org>.
* LINGUAS: Add it.
2002-11-12 Bruno Haible <bruno@clisp.org>
* da.po: New file, from Keld Simonsen <keld@dkuug.dk>.
* LINGUAS: Add da.
2002-10-29 Bruno Haible <bruno@clisp.org>
* id.po: New file, from Tedi Heriyanto <tedi_h@gmx.net>.
* LINGUAS: Add id.
2002-08-23 Bruno Haible <bruno@clisp.org>
* fi.po: New file, from Matti Koskimies <matti@apulanta.fi>.
* fr.po: New file, from Michel Robitaille <robitail@iro.umontreal.ca>.
* pt_BR.po: Update from
Alexandre Folle de Menezes <afmenez@terra.com.br>.
* ru.po: New file, from Dmitry S. Sivachenko <mitya@cavia.pp.ru>.
* sl.po: New file, from
Primož Peterlin <primoz.peterlin@biofiz.mf.uni-lj.si>.
* tr.po: New file, from Deniz Akkus Kanca <deniz@arayan.com>.
* LINGUAS: Add fi, fr, ru, sl, tr.
2002-06-20 Bruno Haible <bruno@clisp.org>
* es.po: New file, from Santiago Vila Doncel <sanvila@unex.es>.
* LINGUAS: Add es.
2002-06-14 Bruno Haible <bruno@clisp.org>
* hr.po: New file, from Denis Lackovic <delacko@fly.srk.fer.hr>.
* LINGUAS: Add hr.
2002-06-14 Bruno Haible <bruno@clisp.org>
* pt_BR.po: Update from
Alexandre Folle de Menezes <afmenez@terra.com.br>.
2002-06-11 Bruno Haible <bruno@clisp.org>
* sv.po: New file, from Christian Rose <menthos@menthos.com>.
* LINGUAS: Add sv.
2002-06-05 Bruno Haible <bruno@clisp.org>
* pt_BR.po: New file, from
Alexandre Folle de Menezes <afmenez@terra.com.br>.
* LINGUAS: Add pt_BR.
2002-06-03 Bruno Haible <bruno@clisp.org>
* gl.po: New file, from Jacobo Tarrio <jtarrio@trasno.net>.
* LINGUAS: Add gl.
2002-05-31 Bruno Haible <bruno@clisp.org>
* ca.po: New file, from Ivan Vilata i Balaguer <ivan@selidor.net>.
* eo.po: New file, from Edmund Grimley Evans <edmundo@rano.org>.
* hu.po: New file, from Emese Kovacs <emese@gnome.hu>.
* sk.po: New file, from Marcel Telka <marcel@telka.sk>.
* LINGUAS: Add ca, eo, hu, sk.
2002-04-27 gettextize <bug-gnu-gettext@gnu.org>
* Makefile.in.in: New file, from gettext-0.11.1.
* Rules-quot: New file, from gettext-0.11.1.
* boldquot.sed: New file, from gettext-0.11.1.
* en@boldquot.header: New file, from gettext-0.11.1.
* en@quot.header: New file, from gettext-0.11.1.
* insert-header.sin: New file, from gettext-0.11.1.
* quot.sed: New file, from gettext-0.11.1.
* remove-potcdate.sin: New file, from gettext-0.11.1.

4
gnuwin32/lib/charset.alias
View File

@@ -1,4 +0,0 @@
# This file contains a table of character encoding aliases,
# suitable for operating system 'mingw32'.
# It was automatically generated from config.charset.
# Packages using this file:

35
gnuwin32/lib/libcharset.la
View File

@@ -1,35 +0,0 @@
# libcharset.la - a libtool library file
# Generated by ltmain.sh - GNU libtool 1.5 (1.1220 2003/04/05 19:32:58)
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname='../bin/libcharset1.dll'
# Names of this library.
library_names='libcharset.dll.a'
# The name of the static archive.
old_library=''
# Libraries that this one depends upon.
dependency_libs=''
# Version information for libcharset.
current=1
age=0
revision=0
# Is this an already installed library?
installed=yes
# Should we warn about portability when linking against -modules?
shouldnotlink=no
# Files to dlopen/dlpreopen
dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='C:/Users/marius/DOWNLO~1/WEBKIT~1/install/lib'

35
gnuwin32/lib/libcharset.la.orig
View File

@@ -1,35 +0,0 @@
# libcharset.la - a libtool library file
# Generated by ltmain.sh - GNU libtool 1.5 (1.1220 2003/04/05 19:32:58)
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname='../bin/libcharset1.dll'
# Names of this library.
library_names='libcharset.dll.a'
# The name of the static archive.
old_library=''
# Libraries that this one depends upon.
dependency_libs=''
# Version information for libcharset.
current=1
age=0
revision=0
# Is this an already installed library?
installed=yes
# Should we warn about portability when linking against -modules?
shouldnotlink=no
# Files to dlopen/dlpreopen
dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='c:/progra~1/LibIconv/lib'

35
gnuwin32/lib/libiconv.la
View File

@@ -1,35 +0,0 @@
# libiconv.la - a libtool library file
# Generated by ltmain.sh - GNU libtool 1.5 (1.1220 2003/04/05 19:32:58)
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname='../bin/libiconv2.dll'
# Names of this library.
library_names='libiconv.dll.a'
# The name of the static archive.
old_library=''
# Libraries that this one depends upon.
dependency_libs=''
# Version information for libiconv.
current=4
age=2
revision=0
# Is this an already installed library?
installed=yes
# Should we warn about portability when linking against -modules?
shouldnotlink=no
# Files to dlopen/dlpreopen
dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='C:/Users/marius/DOWNLO~1/WEBKIT~1/install/lib'

35
gnuwin32/lib/libiconv.la.orig
View File

@@ -1,35 +0,0 @@
# libiconv.la - a libtool library file
# Generated by ltmain.sh - GNU libtool 1.5 (1.1220 2003/04/05 19:32:58)
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname='../bin/libiconv2.dll'
# Names of this library.
library_names='libiconv.dll.a'
# The name of the static archive.
old_library=''
# Libraries that this one depends upon.
dependency_libs=''
# Version information for libiconv.
current=4
age=2
revision=0
# Is this an already installed library?
installed=yes
# Should we warn about portability when linking against -modules?
shouldnotlink=no
# Files to dlopen/dlpreopen
dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='c:/progra~1/LibIconv/lib'

226
gnuwin32/man/cat1/gperf.1.txt
View File

@@ -1,226 +0,0 @@
GPERF(1) FSF GPERF(1)
NAME
gperf - generate a perfect hash function from a key set
SYNOPSIS
gperf [OPTION]... [INPUT-FILE]
DESCRIPTION
GNU 'gperf' generates perfect hash functions.
If a long option shows an argument as mandatory, then it
is mandatory for the equivalent short option also.
Output file location:
--output-file=FILE Write output to specified file.
The results are written to standard output if no output
file is specified or if it is -.
Input file interpretation:
-e, --delimiters=DELIMITER-LIST
Allow user to provide a string containing delim-
iters used to separate keywords from their
attributes. Default is ",".
-t, --struct-type
Allows the user to include a structured type dec-
laration for generated code. Any text before %%
is considered part of the type declaration. Key
words and additional fields may follow this, one
group of fields per line.
--ignore-case
Consider upper and lower case ASCII characters as
equivalent. Note that locale dependent case map-
pings are ignored.
Language for the output code:
-L, --language=LANGUAGE-NAME
Generates code in the specified language. Lan-
guages handled are currently C++, ANSI-C, C, and
KR-C. The default is C.
Details in the output code:
-K, --slot-name=NAME
Select name of the keyword component in the key-
word structure.
-F, --initializer-suffix=INITIALIZERS
Initializers for additional components in the
keyword structure.
-H, --hash-function-name=NAME
Specify name of generated hash function. Default
is 'hash'.
-N, --lookup-function-name=NAME
Specify name of generated lookup function.
Default name is 'in_word_set'.
-Z, --class-name=NAME
Specify name of generated C++ class. Default name
is 'Perfect_Hash'.
-7, --seven-bit
Assume 7-bit characters.
-l, --compare-lengths
Compare key lengths before trying a string com-
parison. This is necessary if the keywords con-
tain NUL bytes. It also helps cut down on the
number of string comparisons made during the
lookup.
-c, --compare-strncmp
Generate comparison code using strncmp rather
than strcmp.
-C, --readonly-tables
Make the contents of generated lookup tables con-
stant, i.e., readonly.
-E, --enum
Define constant values using an enum local to the
lookup function rather than with defines.
-I, --includes
Include the necessary system include file
<string.h> at the beginning of the code.
-G, --global-table
Generate the static table of keywords as a static
global variable, rather than hiding it inside of
the lookup function (which is the default behav-
ior).
-P, --pic
Optimize the generated table for inclusion in
shared libraries. This reduces the startup time
of programs using a shared library containing the
generated code.
-Q, --string-pool-name=NAME
Specify name of string pool generated by option
--pic. Default name is 'stringpool'.
--null-strings
Use NULL strings instead of empty strings for
empty keyword table entries.
-W, --word-array-name=NAME
Specify name of word list array. Default name is
'wordlist'.
-S, --switch=COUNT
Causes the generated C code to use a switch
statement scheme, rather than an array lookup ta-
ble. This can lead to a reduction in both time
and space requirements for some keyfiles. The
COUNT argument determines how many switch state-
ments are generated. A value of 1 generates 1
switch containing all the elements, a value of 2
generates 2 tables with 1/2 the elements in each
table, etc. If COUNT is very large, say 1000000,
the generated C code does a binary search.
-T, --omit-struct-type
Prevents the transfer of the type declaration to
the output file. Use this option if the type is
already defined elsewhere.
Algorithm employed by gperf:
-k, --key-positions=KEYS
Select the key positions used in the hash func-
tion. The allowable choices range between 1-255,
inclusive. The positions are separated by com-
mas, ranges may be used, and key positions may
occur in any order. Also, the meta-character '*'
causes the generated hash function to consider
ALL key positions, and $ indicates the "final
character" of a key, e.g., $,1,2,4,6-10.
-D, --duplicates
Handle keywords that hash to duplicate values.
This is useful for certain highly redundant key-
word sets.
-m, --multiple-iterations=ITERATIONS
Perform multiple choices of the -i and -j values,
and choose the best results. This increases the
running time by a factor of ITERATIONS but does a
good job minimizing the generated table size.
-i, --initial-asso=N
Provide an initial value for the associate values
array. Default is 0. Setting this value larger
helps inflate the size of the final table.
-j, --jump=JUMP-VALUE
Affects the "jump value", i.e., how far to
advance the associated character value upon col-
lisions. Must be an odd number, default is 5.
-n, --no-strlen
Do not include the length of the keyword when
computing the hash function.
-r, --random
Utilizes randomness to initialize the associated
values table.
-s, --size-multiple=N
Affects the size of the generated hash table. The
numeric argument N indicates "how many times
larger or smaller" the associated value range
should be, in relationship to the number of keys,
e.g. a value of 3 means "allow the maximum asso-
ciated value to be about 3 times larger than the
number of input keys". Conversely, a value of 1/3
means "make the maximum associated value about 3
times smaller than the number of input keys". A
larger table should decrease the time required
for an unsuccessful search, at the expense of
extra table space. Default value is 1.
Informative output:
-h, --help
Print this message.
-v, --version
Print the gperf version number.
-d, --debug
Enables the debugging option (produces verbose
output to the standard error).
AUTHOR
Written by Douglas C. Schmidt and Bruno Haible.
REPORTING BUGS
Report bugs to <bug-gnu-gperf@gnu.org>.
COPYRIGHT
Copyright (C) 1989-1998, 2000-2003 Free Software Founda-
tion, Inc.
This is free software; see the source for copying condi-
tions. There is NO warranty; not even for MERCHANTABIL-
ITY or FITNESS FOR A PARTICULAR PURPOSE.
SEE ALSO
The full documentation for gperf is maintained as a Tex-
info manual. If the info and gperf programs are prop-
erly installed at your site, the command
info gperf
should give you access to the complete manual.
GNU gperf 3.0.1 June 2003 GPERF(1)

48
gnuwin32/man/cat1/iconv.1.txt
View File

@@ -1,48 +0,0 @@
ICONV(1) Linux Programmer's Manual ICONV(1)
NAME
iconv - character set conversion
SYNOPSIS
iconv [-c] [-s] [-f encoding] [-t encoding] [inputfile ...]
iconv -l
DESCRIPTION
The iconv program converts text from one encoding to
another encoding. More precisely, it converts from the
encoding given for the -f option to the encoding given
for the -t option. Either of these encodings defaults to
the encoding of the current locale. All the inputfiles
are read and converted in turn; if no inputfile is
given, the standard input is used. The converted text is
printed to standard output.
When option -c is given, characters that cannot be con-
verted are silently discarded, instead of leading to a
conversion error.
When option -s is given, error messages about invalid or
unconvertible characters are omitted, but the actual
converted text is unaffected.
The encodings permitted are system dependent. For the
libiconv implementation, they are listed in the
iconv_open(3) manual page.
The iconv -l command lists the names of the supported
encodings, in a system dependent format. For the libi-
conv implementation, the names are printed in upper
case, separated by whitespace, and alias names of an
encoding are listed on the same line as the encoding
itself.
SEE ALSO
iconv_open(3), locale(7)
GNU January 13, 2002 ICONV(1)

42
gnuwin32/man/cat1/yacc.1.txt
View File

@@ -1,42 +0,0 @@
YACC(1) User Commands YACC(1)
NAME
yacc - GNU Project parser generator
SYNOPSIS
yacc [OPTION]... FILE
DESCRIPTION
Yacc (Yet Another Compiler Compiler) is a parser genera-
tor. This version is a simple wrapper around bison(1).
It passes option -y, --yacc to activate the upward com-
patibility mode. See bison(1) for more information.
AUTHOR
Written by Paul Eggert.
REPORTING BUGS
Report bugs to <bug-bison@gnu.org>.
COPYRIGHT
Copyright © 2008 Free Software Foundation, Inc.
This is free software; see the source for copying condi-
tions. There is NO warranty; not even for MERCHANTABIL-
ITY or FITNESS FOR A PARTICULAR PURPOSE.
SEE ALSO
lex(1), flex(1), bison(1).
The full documentation for bison is maintained as a Tex-
info manual. If the info and bison programs are prop-
erly installed at your site, the command
info bison
should give you access to the complete manual.
GNU Bison 2.4.1 November 2007 YACC(1)

1269
gnuwin32/man/cat1p/yacc.1p.txt
View File

File diff suppressed because it is too large Load Diff

97
gnuwin32/man/cat3/iconv.3.txt
View File

@@ -1,97 +0,0 @@
ICONV(3) Linux Programmer's Manual ICONV(3)
NAME
iconv - perform character set conversion
SYNOPSIS
#include <iconv.h>
size_t iconv (iconv_t cd,
const char* * inbuf, size_t * inbytesleft,
char* * outbuf, size_t * outbytesleft);
DESCRIPTION
The argument cd must be a conversion descriptor created
using the function iconv_open.
The main case is when inbuf is not NULL and *inbuf is
not NULL. In this case, the iconv function converts the
multibyte sequence starting at *inbuf to a multibyte
sequence starting at *outbuf. At most *inbytesleft
bytes, starting at *inbuf, will be read. At most *out-
bytesleft bytes, starting at *outbuf, will be written.
The iconv function converts one multibyte character at a
time, and for each character conversion it increments
*inbuf and decrements *inbytesleft by the number of con-
verted input bytes, it increments *outbuf and decrements
*outbytesleft by the number of converted output bytes,
and it updates the conversion state contained in cd.
The conversion can stop for four reasons:
1. An invalid multibyte sequence is encountered in the
input. In this case it sets errno to EILSEQ and returns
(size_t)(-1). *inbuf is left pointing to the beginning
of the invalid multibyte sequence.
2. The input byte sequence has been entirely converted,
i.e. *inbytesleft has gone down to 0. In this case iconv
returns the number of non-reversible conversions per-
formed during this call.
3. An incomplete multibyte sequence is encountered in
the input, and the input byte sequence terminates after
it. In this case it sets errno to EINVAL and returns
(size_t)(-1). *inbuf is left pointing to the beginning
of the incomplete multibyte sequence.
4. The output buffer has no more room for the next con-
verted character. In this case it sets errno to E2BIG
and returns (size_t)(-1).
A different case is when inbuf is NULL or *inbuf is
NULL, but outbuf is not NULL and *outbuf is not NULL. In
this case, the iconv function attempts to set cd's con-
version state to the initial state and store a corre-
sponding shift sequence at *outbuf. At most *out-
bytesleft bytes, starting at *outbuf, will be written.
If the output buffer has no more room for this reset
sequence, it sets errno to E2BIG and returns
(size_t)(-1). Otherwise it increments *outbuf and decre-
ments *outbytesleft by the number of bytes written.
A third case is when inbuf is NULL or *inbuf is NULL,
and outbuf is NULL or *outbuf is NULL. In this case, the
iconv function sets cd's conversion state to the initial
state.
RETURN VALUE
The iconv function returns the number of characters con-
verted in a non-reversible way during this call;
reversible conversions are not counted. In case of
error, it sets errno and returns (size_t)(-1).
ERRORS
The following errors can occur, among others:
E2BIG There is not sufficient room at *outbuf.
EILSEQ An invalid multibyte sequence has been encoun-
tered in the input.
EINVAL An incomplete multibyte sequence has been encoun-
tered in the input.
CONFORMING TO
UNIX98
SEE ALSO
iconv_open(3), iconv_close(3)
GNU January 21, 2004 ICONV(3)

32
gnuwin32/man/cat3/iconv_close.3.txt
View File

@@ -1,32 +0,0 @@
ICONV_CLOSE(3) Linux Programmer's Manual ICONV_CLOSE(3)
NAME
iconv_close - deallocate descriptor for character set
conversion
SYNOPSIS
#include <iconv.h>
int iconv_close (iconv_t cd);
DESCRIPTION
The iconv_close function deallocates a conversion
descriptor cd previously allocated using iconv_open.
RETURN VALUE
When successful, the iconv_close function returns 0. In
case of error, it sets errno and returns -1.
CONFORMING TO
UNIX98
SEE ALSO
iconv_open(3), iconv(3)
GNU November 27, 1999 ICONV_CLOSE(3)

152
gnuwin32/man/cat3/iconv_open.3.txt
View File

@@ -1,152 +0,0 @@
ICONV_OPEN(3) Linux Programmer's Manual ICONV_OPEN(3)
NAME
iconv_open - allocate descriptor for character set con-
version
SYNOPSIS
#include <iconv.h>
iconv_t iconv_open (const char* tocode, const char* fromcode);
DESCRIPTION
The iconv_open function allocates a conversion descrip-
tor suitable for converting byte sequences from charac-
ter encoding fromcode to character encoding tocode.
The values permitted for fromcode and tocode and the
supported combinations are system dependent. For the
libiconv library, the following encodings are supported,
in all combinations.
European languages
ASCII, ISO-8859-{1,2,3,4,5,7,9,10,13,14,15,16},
KOI8-R, KOI8-U, KOI8-RU,
CP{1250,1251,1252,1253,1254,1257}, CP{850,866},
Mac{Roman,CentralEurope,Iceland,Croatian,Roma-
nia}, Mac{Cyrillic,Ukraine,Greek,Turkish}, Macin-
tosh
Semitic languages
ISO-8859-{6,8}, CP{1255,1256}, CP862,
Mac{Hebrew,Arabic}
Japanese
EUC-JP, SHIFT_JIS, CP932, ISO-2022-JP,
ISO-2022-JP-2, ISO-2022-JP-1
Chinese
EUC-CN, HZ, GBK, GB18030, EUC-TW, BIG5, CP950,
BIG5-HKSCS, ISO-2022-CN, ISO-2022-CN-EXT
Korean
EUC-KR, CP949, ISO-2022-KR, JOHAB
Armenian
ARMSCII-8
Georgian
Georgian-Academy, Georgian-PS
Tajik
KOI8-T
Thai
TIS-620, CP874, MacThai
Laotian
MuleLao-1, CP1133
Vietnamese
VISCII, TCVN, CP1258
Platform specifics
HP-ROMAN8, NEXTSTEP
Full Unicode
UTF-8
UCS-2, UCS-2BE, UCS-2LE
UCS-4, UCS-4BE, UCS-4LE
UTF-16, UTF-16BE, UTF-16LE
UTF-32, UTF-32BE, UTF-32LE
UTF-7
C99, JAVA
Full Unicode, in terms of uint16_t or uint32_t
(with machine dependent endianness and alignment)
UCS-2-INTERNAL, UCS-4-INTERNAL
Locale dependent, in terms of char or wchar_t
(with machine dependent endianness and alignment,
and with semantics depending on the OS and the
current LC_CTYPE locale facet)
char, wchar_t
When configured with the option --enable-extra-encod-
ings, it also provides support for a few extra encod-
ings:
European languages
CP{437,737,775,852,853,855,857,858,860,861,863,865,869,1125}
Semitic languages
CP864
Japanese
EUC-JISX0213, Shift_JISX0213, ISO-2022-JP-3
Turkmen
TDS565
Platform specifics
RISCOS-LATIN1
The empty encoding name "" is equivalent to "char": it
denotes the locale dependent character encoding.
When the string "//TRANSLIT" is appended to tocode,
transliteration is activated. This means that when a
character cannot be represented in the target character
set, it can be approximated through one or several simi-
larly looking characters.
When the string "//IGNORE" is appended to tocode, char-
acters that cannot be represented in the target charac-
ter set will be silently discarded.
The resulting conversion descriptor can be used with
iconv any number of times. It remains valid until deal-
located using iconv_close.
A conversion descriptor contains a conversion state.
After creation using iconv_open, the state is in the
initial state. Using iconv modifies the descriptor's
conversion state. (This implies that a conversion
descriptor can not be used in multiple threads simulta-
neously.) To bring the state back to the initial state,
use iconv with NULL as inbuf argument.
RETURN VALUE
The iconv_open function returns a freshly allocated con-
version descriptor. In case of error, it sets errno and
returns (iconv_t)(-1).
ERRORS
The following error can occur, among others:
EINVAL The conversion from fromcode to tocode is not
supported by the implementation.
CONFORMING TO
UNIX98
SEE ALSO
iconv(3), iconv_close(3)
GNU May 26, 2002 ICONV_OPEN(3)

14
gnuwin32/manifest/gperf-3.0.1-bin.mft
View File

@@ -1,14 +0,0 @@
bin/gperf.exe
contrib/gperf/3.0.1/depends-GnuWin32.lst
contrib/gperf/3.0.1/gperf-3.0.1-GnuWin32.README
contrib/gperf/3.0.1/gperf-3.0.1-src/AUTHORS
contrib/gperf/3.0.1/gperf-3.0.1-src/ChangeLog
contrib/gperf/3.0.1/gperf-3.0.1-src/COPYING
contrib/gperf/3.0.1/gperf-3.0.1-src/INSTALL
contrib/gperf/3.0.1/gperf-3.0.1-src/NEWS
contrib/gperf/3.0.1/gperf-3.0.1-src/README
contrib/gperf/3.0.1/gperf-3.0.1/check.log
contrib/gperf/3.0.1/gperf-3.0.1/check_err.log
man/cat1/gperf.1.txt
manifest/gperf-3.0.1-bin.mft
manifest/gperf-3.0.1-bin.ver

2
gnuwin32/manifest/gperf-3.0.1-bin.ver
View File

@@ -1,2 +0,0 @@
Gperf 3.0.1: Binaries
Gperf: generate a perfect hash function from a key set

0
gnuwin32/manifest/libiconv-1.9.2-1-bin.mft
View File

2
gnuwin32/manifest/libiconv-1.9.2-1-bin.ver
View File

@@ -1,2 +0,0 @@
LibIconv 1.9.2: Binaries
LibIconv: convert between character encodings

0
gnuwin32/manifest/libiconv-1.9.2-1-dep.mft
View File

2
gnuwin32/manifest/libiconv-1.9.2-1-dep.ver
View File

@@ -1,2 +0,0 @@
LibIconv 1.9.2: Dependencies
LibIconv: convert between character encodings

47
gnuwin32/patches/win_flex.patch
View File

@@ -1,47 +0,0 @@
Index: flex/src/main.c
===================================================================
--- flex/src/main.c (revision 24)
+++ flex/src/main.c (working copy)
@@ -112,7 +112,7 @@
struct yytbl_writer tableswr;
int prev_stdout = 0;
-char *flex_temp_out_main="~flex_temp_out_main";
+char *flex_temp_out_main = 0;
/* Make sure program_name is initialized so we don't crash if writing
* out an error message before getting the program name from argv[0].
@@ -767,6 +767,8 @@
tblsiz);
}
+ free (flex_temp_out_main);
+ flex_temp_out_main = 0;
exit (exit_status);
}
@@ -779,8 +781,10 @@
{
int i, sawcmpflag, rv, optind;
char *arg;
+ char flex_temp_out_main_template[] = "~flex_temp_out_main_XXXXXX";
scanopt_t sopt;
+ flex_temp_out_main = _strdup(_mktemp(flex_temp_out_main_template));
printstats = syntaxerror = trace = spprdflt = false;
lex_compat = posix_compat = C_plus_plus = backing_up_report =
ddebug = fulltbl = false;
Index: flex/src/filter.c
===================================================================
--- flex/src/filter.c (revision 24)
+++ flex/src/filter.c (working copy)
@@ -86,7 +86,8 @@
/* Get some more or less random data. */
{
- static unsigned long long g_value = 827363;
+ static unsigned long long g_value;
+ g_value = _getpid();
g_value += 100;
random_time_bits = (((unsigned long long)234546 << 32)
| (unsigned long long)g_value);

48
gnuwin32/share/aclocal/bison-i18n.m4
View File

@@ -1,48 +0,0 @@
# bison-i18n.m4 serial 2
dnl Copyright (C) 2005-2006 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
dnl with or without modifications, as long as this notice is preserved.
dnl From Bruno Haible.
dnl Support for internationalization of bison-generated parsers.
dnl BISON_I18N
dnl should be used in configure.ac, after AM_GNU_GETTEXT. If USE_NLS is yes, it
dnl sets BISON_LOCALEDIR to indicate where to find the bison-runtime.mo files
dnl and defines YYENABLE_NLS if there are bison-runtime.mo files at all.
AC_DEFUN([BISON_I18N],
[
if test -z "$USE_NLS"; then
echo "The BISON-I18N macro is used without being preceded by AM-GNU-GETTEXT." 1>&2
exit 1
fi
BISON_LOCALEDIR=
BISON_USE_NLS=no
if test "$USE_NLS" = yes; then
dnl Determine bison's localedir.
dnl AC_PROG_YACC sets the YACC variable; other macros set the BISON variable.
dnl But even is YACC is called "yacc", it may be a script that invokes bison
dnl and accepts the --print-localedir option.
dnl YACC's default value is empty; BISON's default value is :.
if (${YACC-${BISON-:}} --print-localedir) >/dev/null 2>&1; then
BISON_LOCALEDIR=`${YACC-${BISON-:}} --print-localedir`
fi
AC_SUBST([BISON_LOCALEDIR])
if test -n "$BISON_LOCALEDIR"; then
dnl There is no need to enable internationalization if the user doesn't
dnl want message catalogs. So look at the language/locale names for
dnl which the user wants message catalogs. This is $LINGUAS. If unset
dnl or empty, he wants all of them.
USER_LINGUAS="${LINGUAS-%UNSET%}"
if test -n "$USER_LINGUAS"; then
BISON_USE_NLS=yes
fi
fi
fi
if test $BISON_USE_NLS = yes; then
AC_DEFINE([YYENABLE_NLS], 1,
[Define to 1 to internationalize bison runtime messages.])
fi
])

BIN
gnuwin32/share/locale/ca/LC_MESSAGES/libiconv.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/da/LC_MESSAGES/bison-runtime.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/da/LC_MESSAGES/bison.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/da/LC_MESSAGES/libiconv.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/de/LC_MESSAGES/bison-runtime.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/de/LC_MESSAGES/bison.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/de/LC_MESSAGES/libiconv.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/el/LC_MESSAGES/bison-runtime.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/el/LC_MESSAGES/bison.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/eo/LC_MESSAGES/libiconv.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/es/LC_MESSAGES/bison-runtime.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/es/LC_MESSAGES/bison.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/es/LC_MESSAGES/libiconv.mo
View File

Binary file not shown.

BIN
gnuwin32/share/locale/et/LC_MESSAGES/bison-runtime.mo
View File

Binary file not shown.

Some files were not shown because too many files have changed in this diff Show More