[xiph-cvs] cvs commit: vorbis-tools/vorbiscomment Makefile.am vcomment.c getopt.c getopt.h getopt1.c

Stan Seibert volsung at xiph.org
Sat Sep 22 15:49:53 PDT 2001



volsung     01/09/22 15:49:53

  Modified:    .        Makefile.am configure.in
               ogg123   Makefile.am
               oggenc   Makefile.am
               ogginfo  Makefile.am
               vorbiscomment Makefile.am vcomment.c
  Added:       include  Makefile.am getopt.h utf8.h
               share    8859-1.map 8859-2.map Makefile.am charsetmap.h
                        getopt.c getopt1.c make_code_map.pl utf8.c
  Removed:     ogg123   getopt.c getopt.h getopt1.c
               oggenc   8859-1.map 8859-2.map charsetmap.h getopt.c
                        getopt.h getopt1.c make_code_map.pl utf8.c utf8.h
               vorbiscomment getopt.c getopt.h getopt1.c
  Log:
  - Created a "share" directory for code shared between all of the tools.  Right
  now it only contains the getopt code and the utf8 code.
  - Modified vorbiscomment to perform UTF-8 encoding of the comments as per the
  vorbis comment spec.
  - Added stubs in the utf8.c file for the future UTF-8 decoding routines that
  someone will hopefully write.  :)  We need them for ogg123 and ogginfo.

Revision  Changes    Path
1.8       +1 -1      vorbis-tools/Makefile.am

Index: Makefile.am
===================================================================
RCS file: /usr/local/cvsroot/vorbis-tools/Makefile.am,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- Makefile.am	2001/07/04 14:58:40	1.7
+++ Makefile.am	2001/09/22 22:49:48	1.8
@@ -2,7 +2,7 @@
 
 AUTOMAKE_OPTIONS = foreign dist-zip
 
-SUBDIRS = oggenc ogg123 vorbiscomment vcut ogginfo debian
+SUBDIRS = include share oggenc ogg123 vorbiscomment vcut ogginfo debian
 
 EXTRA_DIST = README AUTHORS COPYING vorbis-tools.spec acinclude.m4
 

1.29      +3 -1      vorbis-tools/configure.in

Index: configure.in
===================================================================
RCS file: /usr/local/cvsroot/vorbis-tools/configure.in,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -r1.28 -r1.29
--- configure.in	2001/08/13 03:40:21	1.28
+++ configure.in	2001/09/22 22:49:48	1.29
@@ -62,6 +62,7 @@
 SOCKET_LIBS=
 AC_CHECK_LIB(socket, socket, SOCKET_LIBS="-lsocket")
 AC_CHECK_LIB(nsl, gethostbyname, SOCKET_LIBS="-lnsl $SOCKET_LIBS")
+SHARE_LIBS='$(top_srcdir)/share/libutf8.a $(top_srcdir)/share/libgetopt.a'
 
 dnl --------------------------------------------------
 dnl Check for library functions
@@ -88,5 +89,6 @@
 AC_SUBST(DEBUG)
 AC_SUBST(PROFILE)
 AC_SUBST(SOCKET_LIBS)
+AC_SUBST(SHARE_LIBS)
 
-AC_OUTPUT(Makefile oggenc/Makefile oggenc/man/Makefile ogg123/Makefile vorbiscomment/Makefile vcut/Makefile ogginfo/Makefile debian/Makefile)
+AC_OUTPUT(Makefile include/Makefile share/Makefile oggenc/Makefile oggenc/man/Makefile ogg123/Makefile vorbiscomment/Makefile vcut/Makefile ogginfo/Makefile debian/Makefile)

1.1                  vorbis-tools/include/Makefile.am

Index: Makefile.am
===================================================================
## Process this file with automake to produce Makefile.in

AUTOMAKE_OPTIONS = foreign

EXTRA_DIST = utf8.h getopt.h

1.1                  vorbis-tools/include/getopt.h

Index: getopt.h
===================================================================
/* Declarations for getopt.
   Copyright (C) 1989,90,91,92,93,94,96,97,98 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#ifndef _GETOPT_H

#ifndef __need_getopt
# define _GETOPT_H 1
#endif

#ifdef	__cplusplus
extern "C" {
#endif

/* For communication from `getopt' to the caller.
   When `getopt' finds an option that takes an argument,
   the argument value is returned here.
   Also, when `ordering' is RETURN_IN_ORDER,
   each non-option ARGV-element is returned here.  */

extern char *optarg;

/* Index in ARGV of the next element to be scanned.
   This is used for communication to and from the caller
   and for communication between successive calls to `getopt'.

   On entry to `getopt', zero means this is the first call; initialize.

   When `getopt' returns -1, this is the index of the first of the
   non-option elements that the caller should itself scan.

   Otherwise, `optind' communicates from one call to the next
   how much of ARGV has been scanned so far.  */

extern int optind;

/* Callers store zero here to inhibit the error message `getopt' prints
   for unrecognized options.  */

extern int opterr;

/* Set to an option character which was unrecognized.  */

extern int optopt;

#ifndef __need_getopt
/* Describe the long-named options requested by the application.
   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
   of `struct option' terminated by an element containing a name which is
   zero.

   The field `has_arg' is:
   no_argument		(or 0) if the option does not take an argument,
   required_argument	(or 1) if the option requires an argument,
   optional_argument 	(or 2) if the option takes an optional argument.

   If the field `flag' is not NULL, it points to a variable that is set
   to the value given in the field `val' when the option is found, but
   left unchanged if the option is not found.

   To have a long-named option do something other than set an `int' to
   a compiled-in constant, such as set a value from `optarg', set the
   option's `flag' field to zero and its `val' field to a nonzero
   value (the equivalent single-letter option character, if there is
   one).  For long options that have a zero `flag' field, `getopt'
   returns the contents of the `val' field.  */

truct option
{
# if defined __STDC__ && __STDC__
  const char *name;
# else
  char *name;
# endif
  /* has_arg can't be an enum because some compilers complain about
     type mismatches in all the code that assumes it is an int.  */
  int has_arg;
  int *flag;
  int val;
};

/* Names for the values of the `has_arg' field of `struct option'.  */

# define no_argument		0
# define required_argument	1
# define optional_argument	2
#endif	/* need getopt */

/* Get definitions and prototypes for functions to process the
   arguments in ARGV (ARGC of them, minus the program name) for
   options given in OPTS.

   Return the option character from OPTS just read.  Return -1 when
   there are no more options.  For unrecognized options, or options
   missing arguments, `optopt' is set to the option letter, and '?' is
   returned.

   The OPTS string is a list of characters which are recognized option
   letters, optionally followed by colons, specifying that that letter
   takes an argument, to be placed in `optarg'.

   If a letter in OPTS is followed by two colons, its argument is
   optional.  This behavior is specific to the GNU `getopt'.

   The argument `--' causes premature termination of argument
   scanning, explicitly telling `getopt' that there are no more
   options.

   If OPTS begins with `--', then non-option arguments are treated as
   arguments to the option '\0'.  This behavior is specific to the GNU
   `getopt'.  */

#if defined __STDC__ && __STDC__
# ifdef __GNU_LIBRARY__
/* Many other libraries have conflicting prototypes for getopt, with
   differences in the consts, in stdlib.h.  To avoid compilation
   errors, only prototype getopt for the GNU C library.  */
extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
# else /* not __GNU_LIBRARY__ */
extern int getopt ();
# endif /* __GNU_LIBRARY__ */

# ifndef __need_getopt
extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts,
                        const struct option *__longopts, int *__longind);
extern int getopt_long_only (int __argc, char *const *__argv,
                             const char *__shortopts,
                             const struct option *__longopts, int *__longind);

/* Internal only.  Users should not call this directly.  */
extern int _getopt_internal (int __argc, char *const *__argv,
                             const char *__shortopts,
                             const struct option *__longopts, int *__longind,
                             int __long_only);
# endif
#else /* not __STDC__ */
extern int getopt ();
# ifndef __need_getopt
extern int getopt_long ();
extern int getopt_long_only ();

extern int _getopt_internal ();
# endif
#endif /* __STDC__ */

#ifdef	__cplusplus
}
#endif

/* Make sure we later can get all the definitions and declarations.  */
#undef __need_getopt

#endif /* getopt.h */

1.1                  vorbis-tools/include/utf8.h

Index: utf8.h
===================================================================
/* OggEnc
 *
 * This program is distributed under the GNU General Public License, version 2.
 * A copy of this license is included with this source.
 *
 * Copyright © 2001, Daniel Resare <noa at metamatrix.se>
 */

typedef struct
{
        char* name;
        int mapping[256];
} charset_map;

charset_map *get_map(const char *encoding);
char *make_utf8_string(const unsigned short *unicode);
int simple_utf8_encode(const char *from, char **to, const char *encoding);
int utf8_encode(char *from, char **to, const char *encoding);

1.16      +4 -3      vorbis-tools/ogg123/Makefile.am

Index: Makefile.am
===================================================================
RCS file: /usr/local/cvsroot/vorbis-tools/ogg123/Makefile.am,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -r1.15 -r1.16
--- Makefile.am	2001/08/04 22:23:21	1.15
+++ Makefile.am	2001/09/22 22:49:49	1.16
@@ -11,11 +11,12 @@
 INCLUDES = @OGG_CFLAGS@ @VORBIS_CFLAGS@ @AO_CFLAGS@
 
 ogg123_LDADD = @VORBISFILE_LIBS@ @VORBIS_LIBS@ @OGG_LIBS@ @AO_LIBS@ \
-		@SOCKET_LIBS@
+		@SOCKET_LIBS@ @SHARE_LIBS@
+ogg123_DEPENDENCIES = @SHARE_LIBS@
 
-ogg123_SOURCES = ogg123.c ao_interface.c buffer.c ogg123.h buffer.h getopt.c getopt1.c getopt.h
+ogg123_SOURCES = ogg123.c ao_interface.c buffer.c ogg123.h buffer.h
 ## Comment the above and uncomment the next line to disable the buffer support
-##ogg123_SOURCES = ogg123.c ao_interface.c nullbuffer.c ogg123.h buffer.h getopt.c getopt1.c getopt.h
+##ogg123_SOURCES = ogg123.c ao_interface.c nullbuffer.c ogg123.h buffer.h
 
 EXTRA_DIST = $(man_MANS) $(doc_DATA)
 

1.11      +8 -7      vorbis-tools/oggenc/Makefile.am

Index: Makefile.am
===================================================================
RCS file: /usr/local/cvsroot/vorbis-tools/oggenc/Makefile.am,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -r1.10 -r1.11
--- Makefile.am	2001/08/13 00:28:55	1.10
+++ Makefile.am	2001/09/22 22:49:50	1.11
@@ -6,15 +6,16 @@
 
 bin_PROGRAMS = oggenc
 
-INCLUDES = @OGG_CFLAGS@ @VORBIS_CFLAGS@
+INCLUDES = @OGG_CFLAGS@ @VORBIS_CFLAGS@ -I$(top_srcdir)/include
 
-oggenc_LDADD = @VORBISENC_LIBS@ @VORBIS_LIBS@ @OGG_LIBS@ @LIBICONV@
-oggenc_SOURCES = oggenc.c audio.c encode.c getopt.c getopt1.c\
-		platform.c utf8.c utf8.h\
-		audio.h encode.h platform.h getopt.h
+oggenc_LDADD = @VORBISENC_LIBS@ @VORBIS_LIBS@ @OGG_LIBS@ @LIBICONV@ \
+               @SHARE_LIBS@
+oggenc_DEPENDENCIES = @SHARE_LIBS@
 
-MAP_FILES = 8859-1.map 8859-2.map
-EXTRA_DIST = oggenc.dsp build_oggenc.bat $(MAP_FILES) make_code_map.pl charsetmap.h
+oggenc_SOURCES = oggenc.c audio.c encode.c platform.c \
+                 audio.h encode.h platform.h
+
+EXTRA_DIST = oggenc.dsp build_oggenc.bat
 
 debug:
         $(MAKE) all CFLAGS="@DEBUG@"

1.5       +2 -1      vorbis-tools/ogginfo/Makefile.am

Index: Makefile.am
===================================================================
RCS file: /usr/local/cvsroot/vorbis-tools/ogginfo/Makefile.am,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- Makefile.am	2001/09/09 03:12:12	1.4
+++ Makefile.am	2001/09/22 22:49:50	1.5
@@ -8,7 +8,8 @@
 
 INCLUDES = @OGG_CFLAGS@ @VORBIS_CFLAGS@
 
-ogginfo_LDADD = @VORBIS_LIBS@ @OGG_LIBS@
+ogginfo_LDADD = @VORBIS_LIBS@ @OGG_LIBS@ @LIBICONV@ @SHARE_LIBS@
+ogginfo_DEPENDENCIES = @SHARE_LIBS@
 
 ogginfo_SOURCES = ogginfo.c
 

1.1                  vorbis-tools/share/8859-1.map

Index: 8859-1.map
===================================================================
#
#	Name:             ISO/IEC 8859-1:1998 to Unicode
#	Unicode version:  3.0
#	Table version:    1.0
#	Table format:     Format A
#	Date:             1999 July 27
#	Authors:          Ken Whistler <kenw at sybase.com>
#
#	Copyright (c) 1991-1999 Unicode, Inc.  All Rights reserved.
#
#	This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
#	No claims are made as to fitness for any particular purpose.  No
#	warranties of any kind are expressed or implied.  The recipient
#	agrees to determine applicability of information provided.  If this
#	file has been provided on optical media by Unicode, Inc., the sole
#	remedy for any claim will be exchange of defective media within 90
#	days of receipt.
#
#	Unicode, Inc. hereby grants the right to freely use the information
#	supplied in this file in the creation of products supporting the
#	Unicode Standard, and to make copies of this file in any form for
#	internal or external distribution as long as this notice remains
#	attached.
#
#	General notes:
#
#	This table contains the data the Unicode Consortium has on how
#       ISO/IEC 8859-1:1998 characters map into Unicode.
#
#	Format:  Three tab-separated columns
#		 Column #1 is the ISO/IEC 8859-1 code (in hex as 0xXX)
#		 Column #2 is the Unicode (in hex as 0xXXXX)
#		 Column #3 the Unicode name (follows a comment sign, '#')
#
#	The entries are in ISO/IEC 8859-1 order.
#
#	Version history
#	1.0 version updates 0.1 version by adding mappings for all
#	control characters.
#
#	Updated versions of this file may be found in:
#		<ftp://ftp.unicode.org/Public/MAPPINGS/>
#
#	Any comments or problems, contact <errata at unicode.org>
#	Please note that <errata at unicode.org> is an archival address;
#	notices will be checked, but do not expect an immediate response.
#
0x00	0x0000	#	NULL
0x01	0x0001	#	START OF HEADING
0x02	0x0002	#	START OF TEXT
0x03	0x0003	#	END OF TEXT
0x04	0x0004	#	END OF TRANSMISSION
0x05	0x0005	#	ENQUIRY
0x06	0x0006	#	ACKNOWLEDGE
0x07	0x0007	#	BELL
0x08	0x0008	#	BACKSPACE
0x09	0x0009	#	HORIZONTAL TABULATION
0x0A	0x000A	#	LINE FEED
0x0B	0x000B	#	VERTICAL TABULATION
0x0C	0x000C	#	FORM FEED
0x0D	0x000D	#	CARRIAGE RETURN
0x0E	0x000E	#	SHIFT OUT
0x0F	0x000F	#	SHIFT IN
0x10	0x0010	#	DATA LINK ESCAPE
0x11	0x0011	#	DEVICE CONTROL ONE
0x12	0x0012	#	DEVICE CONTROL TWO
0x13	0x0013	#	DEVICE CONTROL THREE
0x14	0x0014	#	DEVICE CONTROL FOUR
0x15	0x0015	#	NEGATIVE ACKNOWLEDGE
0x16	0x0016	#	SYNCHRONOUS IDLE
0x17	0x0017	#	END OF TRANSMISSION BLOCK
0x18	0x0018	#	CANCEL
0x19	0x0019	#	END OF MEDIUM
0x1A	0x001A	#	SUBSTITUTE
0x1B	0x001B	#	ESCAPE
0x1C	0x001C	#	FILE SEPARATOR
0x1D	0x001D	#	GROUP SEPARATOR
0x1E	0x001E	#	RECORD SEPARATOR
0x1F	0x001F	#	UNIT SEPARATOR
0x20	0x0020	#	SPACE
0x21	0x0021	#	EXCLAMATION MARK
0x22	0x0022	#	QUOTATION MARK
0x23	0x0023	#	NUMBER SIGN
0x24	0x0024	#	DOLLAR SIGN
0x25	0x0025	#	PERCENT SIGN
0x26	0x0026	#	AMPERSAND
0x27	0x0027	#	APOSTROPHE
0x28	0x0028	#	LEFT PARENTHESIS
0x29	0x0029	#	RIGHT PARENTHESIS
0x2A	0x002A	#	ASTERISK
0x2B	0x002B	#	PLUS SIGN
0x2C	0x002C	#	COMMA
0x2D	0x002D	#	HYPHEN-MINUS
0x2E	0x002E	#	FULL STOP
0x2F	0x002F	#	SOLIDUS
0x30	0x0030	#	DIGIT ZERO
0x31	0x0031	#	DIGIT ONE
0x32	0x0032	#	DIGIT TWO
0x33	0x0033	#	DIGIT THREE
0x34	0x0034	#	DIGIT FOUR
0x35	0x0035	#	DIGIT FIVE
0x36	0x0036	#	DIGIT SIX
0x37	0x0037	#	DIGIT SEVEN
0x38	0x0038	#	DIGIT EIGHT
0x39	0x0039	#	DIGIT NINE
0x3A	0x003A	#	COLON
0x3B	0x003B	#	SEMICOLON
0x3C	0x003C	#	LESS-THAN SIGN
0x3D	0x003D	#	EQUALS SIGN
0x3E	0x003E	#	GREATER-THAN SIGN
0x3F	0x003F	#	QUESTION MARK
0x40	0x0040	#	COMMERCIAL AT
0x41	0x0041	#	LATIN CAPITAL LETTER A
0x42	0x0042	#	LATIN CAPITAL LETTER B
0x43	0x0043	#	LATIN CAPITAL LETTER C
0x44	0x0044	#	LATIN CAPITAL LETTER D
0x45	0x0045	#	LATIN CAPITAL LETTER E
0x46	0x0046	#	LATIN CAPITAL LETTER F
0x47	0x0047	#	LATIN CAPITAL LETTER G
0x48	0x0048	#	LATIN CAPITAL LETTER H
0x49	0x0049	#	LATIN CAPITAL LETTER I
0x4A	0x004A	#	LATIN CAPITAL LETTER J
0x4B	0x004B	#	LATIN CAPITAL LETTER K
0x4C	0x004C	#	LATIN CAPITAL LETTER L
0x4D	0x004D	#	LATIN CAPITAL LETTER M
0x4E	0x004E	#	LATIN CAPITAL LETTER N
0x4F	0x004F	#	LATIN CAPITAL LETTER O
0x50	0x0050	#	LATIN CAPITAL LETTER P
0x51	0x0051	#	LATIN CAPITAL LETTER Q
0x52	0x0052	#	LATIN CAPITAL LETTER R
0x53	0x0053	#	LATIN CAPITAL LETTER S
0x54	0x0054	#	LATIN CAPITAL LETTER T
0x55	0x0055	#	LATIN CAPITAL LETTER U
0x56	0x0056	#	LATIN CAPITAL LETTER V
0x57	0x0057	#	LATIN CAPITAL LETTER W
0x58	0x0058	#	LATIN CAPITAL LETTER X
0x59	0x0059	#	LATIN CAPITAL LETTER Y
0x5A	0x005A	#	LATIN CAPITAL LETTER Z
0x5B	0x005B	#	LEFT SQUARE BRACKET
0x5C	0x005C	#	REVERSE SOLIDUS
0x5D	0x005D	#	RIGHT SQUARE BRACKET
0x5E	0x005E	#	CIRCUMFLEX ACCENT
0x5F	0x005F	#	LOW LINE
0x60	0x0060	#	GRAVE ACCENT
0x61	0x0061	#	LATIN SMALL LETTER A
0x62	0x0062	#	LATIN SMALL LETTER B
0x63	0x0063	#	LATIN SMALL LETTER C
0x64	0x0064	#	LATIN SMALL LETTER D
0x65	0x0065	#	LATIN SMALL LETTER E
0x66	0x0066	#	LATIN SMALL LETTER F
0x67	0x0067	#	LATIN SMALL LETTER G
0x68	0x0068	#	LATIN SMALL LETTER H
0x69	0x0069	#	LATIN SMALL LETTER I
0x6A	0x006A	#	LATIN SMALL LETTER J
0x6B	0x006B	#	LATIN SMALL LETTER K
0x6C	0x006C	#	LATIN SMALL LETTER L
0x6D	0x006D	#	LATIN SMALL LETTER M
0x6E	0x006E	#	LATIN SMALL LETTER N
0x6F	0x006F	#	LATIN SMALL LETTER O
0x70	0x0070	#	LATIN SMALL LETTER P
0x71	0x0071	#	LATIN SMALL LETTER Q
0x72	0x0072	#	LATIN SMALL LETTER R
0x73	0x0073	#	LATIN SMALL LETTER S
0x74	0x0074	#	LATIN SMALL LETTER T
0x75	0x0075	#	LATIN SMALL LETTER U
0x76	0x0076	#	LATIN SMALL LETTER V
0x77	0x0077	#	LATIN SMALL LETTER W
0x78	0x0078	#	LATIN SMALL LETTER X
0x79	0x0079	#	LATIN SMALL LETTER Y
0x7A	0x007A	#	LATIN SMALL LETTER Z
0x7B	0x007B	#	LEFT CURLY BRACKET
0x7C	0x007C	#	VERTICAL LINE
0x7D	0x007D	#	RIGHT CURLY BRACKET
0x7E	0x007E	#	TILDE
0x7F	0x007F	#	DELETE
0x80	0x0080	#	<control>
0x81	0x0081	#	<control>
0x82	0x0082	#	<control>
0x83	0x0083	#	<control>
0x84	0x0084	#	<control>
0x85	0x0085	#	<control>
0x86	0x0086	#	<control>
0x87	0x0087	#	<control>
0x88	0x0088	#	<control>
0x89	0x0089	#	<control>
0x8A	0x008A	#	<control>
0x8B	0x008B	#	<control>
0x8C	0x008C	#	<control>
0x8D	0x008D	#	<control>
0x8E	0x008E	#	<control>
0x8F	0x008F	#	<control>
0x90	0x0090	#	<control>
0x91	0x0091	#	<control>
0x92	0x0092	#	<control>
0x93	0x0093	#	<control>
0x94	0x0094	#	<control>
0x95	0x0095	#	<control>
0x96	0x0096	#	<control>
0x97	0x0097	#	<control>
0x98	0x0098	#	<control>
0x99	0x0099	#	<control>
0x9A	0x009A	#	<control>
0x9B	0x009B	#	<control>
0x9C	0x009C	#	<control>
0x9D	0x009D	#	<control>
0x9E	0x009E	#	<control>
0x9F	0x009F	#	<control>
0xA0	0x00A0	#	NO-BREAK SPACE
0xA1	0x00A1	#	INVERTED EXCLAMATION MARK
0xA2	0x00A2	#	CENT SIGN
0xA3	0x00A3	#	POUND SIGN
0xA4	0x00A4	#	CURRENCY SIGN
0xA5	0x00A5	#	YEN SIGN
0xA6	0x00A6	#	BROKEN BAR
0xA7	0x00A7	#	SECTION SIGN
0xA8	0x00A8	#	DIAERESIS
0xA9	0x00A9	#	COPYRIGHT SIGN
0xAA	0x00AA	#	FEMININE ORDINAL INDICATOR
0xAB	0x00AB	#	LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
0xAC	0x00AC	#	NOT SIGN
0xAD	0x00AD	#	SOFT HYPHEN
0xAE	0x00AE	#	REGISTERED SIGN
0xAF	0x00AF	#	MACRON
0xB0	0x00B0	#	DEGREE SIGN
0xB1	0x00B1	#	PLUS-MINUS SIGN
0xB2	0x00B2	#	SUPERSCRIPT TWO
0xB3	0x00B3	#	SUPERSCRIPT THREE
0xB4	0x00B4	#	ACUTE ACCENT
0xB5	0x00B5	#	MICRO SIGN
0xB6	0x00B6	#	PILCROW SIGN
0xB7	0x00B7	#	MIDDLE DOT
0xB8	0x00B8	#	CEDILLA
0xB9	0x00B9	#	SUPERSCRIPT ONE
0xBA	0x00BA	#	MASCULINE ORDINAL INDICATOR
0xBB	0x00BB	#	RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
0xBC	0x00BC	#	VULGAR FRACTION ONE QUARTER
0xBD	0x00BD	#	VULGAR FRACTION ONE HALF
0xBE	0x00BE	#	VULGAR FRACTION THREE QUARTERS
0xBF	0x00BF	#	INVERTED QUESTION MARK
0xC0	0x00C0	#	LATIN CAPITAL LETTER A WITH GRAVE
0xC1	0x00C1	#	LATIN CAPITAL LETTER A WITH ACUTE
0xC2	0x00C2	#	LATIN CAPITAL LETTER A WITH CIRCUMFLEX
0xC3	0x00C3	#	LATIN CAPITAL LETTER A WITH TILDE
0xC4	0x00C4	#	LATIN CAPITAL LETTER A WITH DIAERESIS
0xC5	0x00C5	#	LATIN CAPITAL LETTER A WITH RING ABOVE
0xC6	0x00C6	#	LATIN CAPITAL LETTER AE
0xC7	0x00C7	#	LATIN CAPITAL LETTER C WITH CEDILLA
0xC8	0x00C8	#	LATIN CAPITAL LETTER E WITH GRAVE
0xC9	0x00C9	#	LATIN CAPITAL LETTER E WITH ACUTE
0xCA	0x00CA	#	LATIN CAPITAL LETTER E WITH CIRCUMFLEX
0xCB	0x00CB	#	LATIN CAPITAL LETTER E WITH DIAERESIS
0xCC	0x00CC	#	LATIN CAPITAL LETTER I WITH GRAVE
0xCD	0x00CD	#	LATIN CAPITAL LETTER I WITH ACUTE
0xCE	0x00CE	#	LATIN CAPITAL LETTER I WITH CIRCUMFLEX
0xCF	0x00CF	#	LATIN CAPITAL LETTER I WITH DIAERESIS
0xD0	0x00D0	#	LATIN CAPITAL LETTER ETH (Icelandic)
0xD1	0x00D1	#	LATIN CAPITAL LETTER N WITH TILDE
0xD2	0x00D2	#	LATIN CAPITAL LETTER O WITH GRAVE
0xD3	0x00D3	#	LATIN CAPITAL LETTER O WITH ACUTE
0xD4	0x00D4	#	LATIN CAPITAL LETTER O WITH CIRCUMFLEX
0xD5	0x00D5	#	LATIN CAPITAL LETTER O WITH TILDE
0xD6	0x00D6	#	LATIN CAPITAL LETTER O WITH DIAERESIS
0xD7	0x00D7	#	MULTIPLICATION SIGN
0xD8	0x00D8	#	LATIN CAPITAL LETTER O WITH STROKE
0xD9	0x00D9	#	LATIN CAPITAL LETTER U WITH GRAVE
0xDA	0x00DA	#	LATIN CAPITAL LETTER U WITH ACUTE
0xDB	0x00DB	#	LATIN CAPITAL LETTER U WITH CIRCUMFLEX
0xDC	0x00DC	#	LATIN CAPITAL LETTER U WITH DIAERESIS
0xDD	0x00DD	#	LATIN CAPITAL LETTER Y WITH ACUTE
0xDE	0x00DE	#	LATIN CAPITAL LETTER THORN (Icelandic)
0xDF	0x00DF	#	LATIN SMALL LETTER SHARP S (German)
0xE0	0x00E0	#	LATIN SMALL LETTER A WITH GRAVE
0xE1	0x00E1	#	LATIN SMALL LETTER A WITH ACUTE
0xE2	0x00E2	#	LATIN SMALL LETTER A WITH CIRCUMFLEX
0xE3	0x00E3	#	LATIN SMALL LETTER A WITH TILDE
0xE4	0x00E4	#	LATIN SMALL LETTER A WITH DIAERESIS
0xE5	0x00E5	#	LATIN SMALL LETTER A WITH RING ABOVE
0xE6	0x00E6	#	LATIN SMALL LETTER AE
0xE7	0x00E7	#	LATIN SMALL LETTER C WITH CEDILLA
0xE8	0x00E8	#	LATIN SMALL LETTER E WITH GRAVE
0xE9	0x00E9	#	LATIN SMALL LETTER E WITH ACUTE
0xEA	0x00EA	#	LATIN SMALL LETTER E WITH CIRCUMFLEX
0xEB	0x00EB	#	LATIN SMALL LETTER E WITH DIAERESIS
0xEC	0x00EC	#	LATIN SMALL LETTER I WITH GRAVE
0xED	0x00ED	#	LATIN SMALL LETTER I WITH ACUTE
0xEE	0x00EE	#	LATIN SMALL LETTER I WITH CIRCUMFLEX
0xEF	0x00EF	#	LATIN SMALL LETTER I WITH DIAERESIS
0xF0	0x00F0	#	LATIN SMALL LETTER ETH (Icelandic)
0xF1	0x00F1	#	LATIN SMALL LETTER N WITH TILDE
0xF2	0x00F2	#	LATIN SMALL LETTER O WITH GRAVE
0xF3	0x00F3	#	LATIN SMALL LETTER O WITH ACUTE
0xF4	0x00F4	#	LATIN SMALL LETTER O WITH CIRCUMFLEX
0xF5	0x00F5	#	LATIN SMALL LETTER O WITH TILDE
0xF6	0x00F6	#	LATIN SMALL LETTER O WITH DIAERESIS
0xF7	0x00F7	#	DIVISION SIGN
0xF8	0x00F8	#	LATIN SMALL LETTER O WITH STROKE
0xF9	0x00F9	#	LATIN SMALL LETTER U WITH GRAVE
0xFA	0x00FA	#	LATIN SMALL LETTER U WITH ACUTE
0xFB	0x00FB	#	LATIN SMALL LETTER U WITH CIRCUMFLEX
0xFC	0x00FC	#	LATIN SMALL LETTER U WITH DIAERESIS
0xFD	0x00FD	#	LATIN SMALL LETTER Y WITH ACUTE
0xFE	0x00FE	#	LATIN SMALL LETTER THORN (Icelandic)
0xFF	0x00FF	#	LATIN SMALL LETTER Y WITH DIAERESIS

1.1                  vorbis-tools/share/8859-2.map

Index: 8859-2.map
===================================================================
#
#	Name:             ISO 8859-2:1999 to Unicode
#	Unicode version:  3.0
#	Table version:    1.0
#	Table format:     Format A
#	Date:             1999 July 27
#	Authors:          Ken Whistler <kenw at sybase.com>
#
#	Copyright (c) 1991-1999 Unicode, Inc.  All Rights reserved.
#
#	This file is provided as-is by Unicode, Inc. (The Unicode Consortium).
#	No claims are made as to fitness for any particular purpose.  No
#	warranties of any kind are expressed or implied.  The recipient
#	agrees to determine applicability of information provided.  If this
#	file has been provided on optical media by Unicode, Inc., the sole
#	remedy for any claim will be exchange of defective media within 90
#	days of receipt.
#
#	Unicode, Inc. hereby grants the right to freely use the information
#	supplied in this file in the creation of products supporting the
#	Unicode Standard, and to make copies of this file in any form for
#	internal or external distribution as long as this notice remains
#	attached.
#
#	General notes:
#
#	This table contains the data the Unicode Consortium has on how
#       ISO/IEC 8859-2:1999 characters map into Unicode.
#
#	Format:  Three tab-separated columns
#		 Column #1 is the ISO/IEC 8859-2 code (in hex as 0xXX)
#		 Column #2 is the Unicode (in hex as 0xXXXX)
#		 Column #3 the Unicode name (follows a comment sign, '#')
#
#	The entries are in ISO/IEC 8859-2 order.
#
#	Version history
#	1.0 version updates 0.1 version by adding mappings for all
#	control characters.
#
#	Updated versions of this file may be found in:
#		<ftp://ftp.unicode.org/Public/MAPPINGS/>
#
#	Any comments or problems, contact <errata at unicode.org>
#	Please note that <errata at unicode.org> is an archival address;
#	notices will be checked, but do not expect an immediate response.
#
0x00	0x0000	#	NULL
0x01	0x0001	#	START OF HEADING
0x02	0x0002	#	START OF TEXT
0x03	0x0003	#	END OF TEXT
0x04	0x0004	#	END OF TRANSMISSION
0x05	0x0005	#	ENQUIRY
0x06	0x0006	#	ACKNOWLEDGE
0x07	0x0007	#	BELL
0x08	0x0008	#	BACKSPACE
0x09	0x0009	#	HORIZONTAL TABULATION
0x0A	0x000A	#	LINE FEED
0x0B	0x000B	#	VERTICAL TABULATION
0x0C	0x000C	#	FORM FEED
0x0D	0x000D	#	CARRIAGE RETURN
0x0E	0x000E	#	SHIFT OUT
0x0F	0x000F	#	SHIFT IN
0x10	0x0010	#	DATA LINK ESCAPE
0x11	0x0011	#	DEVICE CONTROL ONE
0x12	0x0012	#	DEVICE CONTROL TWO
0x13	0x0013	#	DEVICE CONTROL THREE
0x14	0x0014	#	DEVICE CONTROL FOUR
0x15	0x0015	#	NEGATIVE ACKNOWLEDGE
0x16	0x0016	#	SYNCHRONOUS IDLE
0x17	0x0017	#	END OF TRANSMISSION BLOCK
0x18	0x0018	#	CANCEL
0x19	0x0019	#	END OF MEDIUM
0x1A	0x001A	#	SUBSTITUTE
0x1B	0x001B	#	ESCAPE
0x1C	0x001C	#	FILE SEPARATOR
0x1D	0x001D	#	GROUP SEPARATOR
0x1E	0x001E	#	RECORD SEPARATOR
0x1F	0x001F	#	UNIT SEPARATOR
0x20	0x0020	#	SPACE
0x21	0x0021	#	EXCLAMATION MARK
0x22	0x0022	#	QUOTATION MARK
0x23	0x0023	#	NUMBER SIGN
0x24	0x0024	#	DOLLAR SIGN
0x25	0x0025	#	PERCENT SIGN
0x26	0x0026	#	AMPERSAND
0x27	0x0027	#	APOSTROPHE
0x28	0x0028	#	LEFT PARENTHESIS
0x29	0x0029	#	RIGHT PARENTHESIS
0x2A	0x002A	#	ASTERISK
0x2B	0x002B	#	PLUS SIGN
0x2C	0x002C	#	COMMA
0x2D	0x002D	#	HYPHEN-MINUS
0x2E	0x002E	#	FULL STOP
0x2F	0x002F	#	SOLIDUS
0x30	0x0030	#	DIGIT ZERO
0x31	0x0031	#	DIGIT ONE
0x32	0x0032	#	DIGIT TWO
0x33	0x0033	#	DIGIT THREE
0x34	0x0034	#	DIGIT FOUR
0x35	0x0035	#	DIGIT FIVE
0x36	0x0036	#	DIGIT SIX
0x37	0x0037	#	DIGIT SEVEN
0x38	0x0038	#	DIGIT EIGHT
0x39	0x0039	#	DIGIT NINE
0x3A	0x003A	#	COLON
0x3B	0x003B	#	SEMICOLON
0x3C	0x003C	#	LESS-THAN SIGN
0x3D	0x003D	#	EQUALS SIGN
0x3E	0x003E	#	GREATER-THAN SIGN
0x3F	0x003F	#	QUESTION MARK
0x40	0x0040	#	COMMERCIAL AT
0x41	0x0041	#	LATIN CAPITAL LETTER A
0x42	0x0042	#	LATIN CAPITAL LETTER B
0x43	0x0043	#	LATIN CAPITAL LETTER C
0x44	0x0044	#	LATIN CAPITAL LETTER D
0x45	0x0045	#	LATIN CAPITAL LETTER E
0x46	0x0046	#	LATIN CAPITAL LETTER F
0x47	0x0047	#	LATIN CAPITAL LETTER G
0x48	0x0048	#	LATIN CAPITAL LETTER H
0x49	0x0049	#	LATIN CAPITAL LETTER I
0x4A	0x004A	#	LATIN CAPITAL LETTER J
0x4B	0x004B	#	LATIN CAPITAL LETTER K
0x4C	0x004C	#	LATIN CAPITAL LETTER L
0x4D	0x004D	#	LATIN CAPITAL LETTER M
0x4E	0x004E	#	LATIN CAPITAL LETTER N
0x4F	0x004F	#	LATIN CAPITAL LETTER O
0x50	0x0050	#	LATIN CAPITAL LETTER P
0x51	0x0051	#	LATIN CAPITAL LETTER Q
0x52	0x0052	#	LATIN CAPITAL LETTER R
0x53	0x0053	#	LATIN CAPITAL LETTER S
0x54	0x0054	#	LATIN CAPITAL LETTER T
0x55	0x0055	#	LATIN CAPITAL LETTER U
0x56	0x0056	#	LATIN CAPITAL LETTER V
0x57	0x0057	#	LATIN CAPITAL LETTER W
0x58	0x0058	#	LATIN CAPITAL LETTER X
0x59	0x0059	#	LATIN CAPITAL LETTER Y
0x5A	0x005A	#	LATIN CAPITAL LETTER Z
0x5B	0x005B	#	LEFT SQUARE BRACKET
0x5C	0x005C	#	REVERSE SOLIDUS
0x5D	0x005D	#	RIGHT SQUARE BRACKET
0x5E	0x005E	#	CIRCUMFLEX ACCENT
0x5F	0x005F	#	LOW LINE
0x60	0x0060	#	GRAVE ACCENT
0x61	0x0061	#	LATIN SMALL LETTER A
0x62	0x0062	#	LATIN SMALL LETTER B
0x63	0x0063	#	LATIN SMALL LETTER C
0x64	0x0064	#	LATIN SMALL LETTER D
0x65	0x0065	#	LATIN SMALL LETTER E
0x66	0x0066	#	LATIN SMALL LETTER F
0x67	0x0067	#	LATIN SMALL LETTER G
0x68	0x0068	#	LATIN SMALL LETTER H
0x69	0x0069	#	LATIN SMALL LETTER I
0x6A	0x006A	#	LATIN SMALL LETTER J
0x6B	0x006B	#	LATIN SMALL LETTER K
0x6C	0x006C	#	LATIN SMALL LETTER L
0x6D	0x006D	#	LATIN SMALL LETTER M
0x6E	0x006E	#	LATIN SMALL LETTER N
0x6F	0x006F	#	LATIN SMALL LETTER O
0x70	0x0070	#	LATIN SMALL LETTER P
0x71	0x0071	#	LATIN SMALL LETTER Q
0x72	0x0072	#	LATIN SMALL LETTER R
0x73	0x0073	#	LATIN SMALL LETTER S
0x74	0x0074	#	LATIN SMALL LETTER T
0x75	0x0075	#	LATIN SMALL LETTER U
0x76	0x0076	#	LATIN SMALL LETTER V
0x77	0x0077	#	LATIN SMALL LETTER W
0x78	0x0078	#	LATIN SMALL LETTER X
0x79	0x0079	#	LATIN SMALL LETTER Y
0x7A	0x007A	#	LATIN SMALL LETTER Z
0x7B	0x007B	#	LEFT CURLY BRACKET
0x7C	0x007C	#	VERTICAL LINE
0x7D	0x007D	#	RIGHT CURLY BRACKET
0x7E	0x007E	#	TILDE
0x7F	0x007F	#	DELETE
0x80	0x0080	#	<control>
0x81	0x0081	#	<control>
0x82	0x0082	#	<control>
0x83	0x0083	#	<control>
0x84	0x0084	#	<control>
0x85	0x0085	#	<control>
0x86	0x0086	#	<control>
0x87	0x0087	#	<control>
0x88	0x0088	#	<control>
0x89	0x0089	#	<control>
0x8A	0x008A	#	<control>
0x8B	0x008B	#	<control>
0x8C	0x008C	#	<control>
0x8D	0x008D	#	<control>
0x8E	0x008E	#	<control>
0x8F	0x008F	#	<control>
0x90	0x0090	#	<control>
0x91	0x0091	#	<control>
0x92	0x0092	#	<control>
0x93	0x0093	#	<control>
0x94	0x0094	#	<control>
0x95	0x0095	#	<control>
0x96	0x0096	#	<control>
0x97	0x0097	#	<control>
0x98	0x0098	#	<control>
0x99	0x0099	#	<control>
0x9A	0x009A	#	<control>
0x9B	0x009B	#	<control>
0x9C	0x009C	#	<control>
0x9D	0x009D	#	<control>
0x9E	0x009E	#	<control>
0x9F	0x009F	#	<control>
0xA0	0x00A0	#	NO-BREAK SPACE
0xA1	0x0104	#	LATIN CAPITAL LETTER A WITH OGONEK
0xA2	0x02D8	#	BREVE
0xA3	0x0141	#	LATIN CAPITAL LETTER L WITH STROKE
0xA4	0x00A4	#	CURRENCY SIGN
0xA5	0x013D	#	LATIN CAPITAL LETTER L WITH CARON
0xA6	0x015A	#	LATIN CAPITAL LETTER S WITH ACUTE
0xA7	0x00A7	#	SECTION SIGN
0xA8	0x00A8	#	DIAERESIS
0xA9	0x0160	#	LATIN CAPITAL LETTER S WITH CARON
0xAA	0x015E	#	LATIN CAPITAL LETTER S WITH CEDILLA
0xAB	0x0164	#	LATIN CAPITAL LETTER T WITH CARON
0xAC	0x0179	#	LATIN CAPITAL LETTER Z WITH ACUTE
0xAD	0x00AD	#	SOFT HYPHEN
0xAE	0x017D	#	LATIN CAPITAL LETTER Z WITH CARON
0xAF	0x017B	#	LATIN CAPITAL LETTER Z WITH DOT ABOVE
0xB0	0x00B0	#	DEGREE SIGN
0xB1	0x0105	#	LATIN SMALL LETTER A WITH OGONEK
0xB2	0x02DB	#	OGONEK
0xB3	0x0142	#	LATIN SMALL LETTER L WITH STROKE
0xB4	0x00B4	#	ACUTE ACCENT
0xB5	0x013E	#	LATIN SMALL LETTER L WITH CARON
0xB6	0x015B	#	LATIN SMALL LETTER S WITH ACUTE
0xB7	0x02C7	#	CARON
0xB8	0x00B8	#	CEDILLA
0xB9	0x0161	#	LATIN SMALL LETTER S WITH CARON
0xBA	0x015F	#	LATIN SMALL LETTER S WITH CEDILLA
0xBB	0x0165	#	LATIN SMALL LETTER T WITH CARON
0xBC	0x017A	#	LATIN SMALL LETTER Z WITH ACUTE
0xBD	0x02DD	#	DOUBLE ACUTE ACCENT
0xBE	0x017E	#	LATIN SMALL LETTER Z WITH CARON
0xBF	0x017C	#	LATIN SMALL LETTER Z WITH DOT ABOVE
0xC0	0x0154	#	LATIN CAPITAL LETTER R WITH ACUTE
0xC1	0x00C1	#	LATIN CAPITAL LETTER A WITH ACUTE
0xC2	0x00C2	#	LATIN CAPITAL LETTER A WITH CIRCUMFLEX
0xC3	0x0102	#	LATIN CAPITAL LETTER A WITH BREVE
0xC4	0x00C4	#	LATIN CAPITAL LETTER A WITH DIAERESIS
0xC5	0x0139	#	LATIN CAPITAL LETTER L WITH ACUTE
0xC6	0x0106	#	LATIN CAPITAL LETTER C WITH ACUTE
0xC7	0x00C7	#	LATIN CAPITAL LETTER C WITH CEDILLA
0xC8	0x010C	#	LATIN CAPITAL LETTER C WITH CARON
0xC9	0x00C9	#	LATIN CAPITAL LETTER E WITH ACUTE
0xCA	0x0118	#	LATIN CAPITAL LETTER E WITH OGONEK
0xCB	0x00CB	#	LATIN CAPITAL LETTER E WITH DIAERESIS
0xCC	0x011A	#	LATIN CAPITAL LETTER E WITH CARON
0xCD	0x00CD	#	LATIN CAPITAL LETTER I WITH ACUTE
0xCE	0x00CE	#	LATIN CAPITAL LETTER I WITH CIRCUMFLEX
0xCF	0x010E	#	LATIN CAPITAL LETTER D WITH CARON
0xD0	0x0110	#	LATIN CAPITAL LETTER D WITH STROKE
0xD1	0x0143	#	LATIN CAPITAL LETTER N WITH ACUTE
0xD2	0x0147	#	LATIN CAPITAL LETTER N WITH CARON
0xD3	0x00D3	#	LATIN CAPITAL LETTER O WITH ACUTE
0xD4	0x00D4	#	LATIN CAPITAL LETTER O WITH CIRCUMFLEX
0xD5	0x0150	#	LATIN CAPITAL LETTER O WITH DOUBLE ACUTE
0xD6	0x00D6	#	LATIN CAPITAL LETTER O WITH DIAERESIS
0xD7	0x00D7	#	MULTIPLICATION SIGN
0xD8	0x0158	#	LATIN CAPITAL LETTER R WITH CARON
0xD9	0x016E	#	LATIN CAPITAL LETTER U WITH RING ABOVE
0xDA	0x00DA	#	LATIN CAPITAL LETTER U WITH ACUTE
0xDB	0x0170	#	LATIN CAPITAL LETTER U WITH DOUBLE ACUTE
0xDC	0x00DC	#	LATIN CAPITAL LETTER U WITH DIAERESIS
0xDD	0x00DD	#	LATIN CAPITAL LETTER Y WITH ACUTE
0xDE	0x0162	#	LATIN CAPITAL LETTER T WITH CEDILLA
0xDF	0x00DF	#	LATIN SMALL LETTER SHARP S
0xE0	0x0155	#	LATIN SMALL LETTER R WITH ACUTE
0xE1	0x00E1	#	LATIN SMALL LETTER A WITH ACUTE
0xE2	0x00E2	#	LATIN SMALL LETTER A WITH CIRCUMFLEX
0xE3	0x0103	#	LATIN SMALL LETTER A WITH BREVE
0xE4	0x00E4	#	LATIN SMALL LETTER A WITH DIAERESIS
0xE5	0x013A	#	LATIN SMALL LETTER L WITH ACUTE
0xE6	0x0107	#	LATIN SMALL LETTER C WITH ACUTE
0xE7	0x00E7	#	LATIN SMALL LETTER C WITH CEDILLA
0xE8	0x010D	#	LATIN SMALL LETTER C WITH CARON
0xE9	0x00E9	#	LATIN SMALL LETTER E WITH ACUTE
0xEA	0x0119	#	LATIN SMALL LETTER E WITH OGONEK
0xEB	0x00EB	#	LATIN SMALL LETTER E WITH DIAERESIS
0xEC	0x011B	#	LATIN SMALL LETTER E WITH CARON
0xED	0x00ED	#	LATIN SMALL LETTER I WITH ACUTE
0xEE	0x00EE	#	LATIN SMALL LETTER I WITH CIRCUMFLEX
0xEF	0x010F	#	LATIN SMALL LETTER D WITH CARON
0xF0	0x0111	#	LATIN SMALL LETTER D WITH STROKE
0xF1	0x0144	#	LATIN SMALL LETTER N WITH ACUTE
0xF2	0x0148	#	LATIN SMALL LETTER N WITH CARON
0xF3	0x00F3	#	LATIN SMALL LETTER O WITH ACUTE
0xF4	0x00F4	#	LATIN SMALL LETTER O WITH CIRCUMFLEX
0xF5	0x0151	#	LATIN SMALL LETTER O WITH DOUBLE ACUTE
0xF6	0x00F6	#	LATIN SMALL LETTER O WITH DIAERESIS
0xF7	0x00F7	#	DIVISION SIGN
0xF8	0x0159	#	LATIN SMALL LETTER R WITH CARON
0xF9	0x016F	#	LATIN SMALL LETTER U WITH RING ABOVE
0xFA	0x00FA	#	LATIN SMALL LETTER U WITH ACUTE
0xFB	0x0171	#	LATIN SMALL LETTER U WITH DOUBLE ACUTE
0xFC	0x00FC	#	LATIN SMALL LETTER U WITH DIAERESIS
0xFD	0x00FD	#	LATIN SMALL LETTER Y WITH ACUTE
0xFE	0x0163	#	LATIN SMALL LETTER T WITH CEDILLA
0xFF	0x02D9	#	DOT ABOVE

1.1                  vorbis-tools/share/Makefile.am

Index: Makefile.am
===================================================================
## Process this file with automake to produce Makefile.in

AUTOMAKE_OPTIONS = foreign

INCLUDES = -I$(top_srcdir)/include

lib_LIBRARIES = libutf8.a libgetopt.a

libutf8_a_SOURCES = utf8.c
MAP_FILES = 8859-1.map 8859-2.map

libgetopt_a_SOURCES = getopt.c getopt1.c

EXTRA_DIST = $(MAP_FILES) charsetmap.h make_code_map.pl

debug:
        $(MAKE) all CFLAGS="@DEBUG@"

profile:
        $(MAKE) all CFLAGS="@PROFILE@"

1.1                  vorbis-tools/share/charsetmap.h

Index: charsetmap.h
===================================================================
/* This file was automatically generated by make_code_map.pl
   please don't edit directly
   Daniel Resare <noa at metamatrix.se>
*/
charset_map maps[] = {
        {"ISO-8859-1",
         {
          0x0000,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,
          0x0008,0x0009,0x000A,0x000B,0x000C,0x000D,0x000E,0x000F,
          0x0010,0x0011,0x0012,0x0013,0x0014,0x0015,0x0016,0x0017,
          0x0018,0x0019,0x001A,0x001B,0x001C,0x001D,0x001E,0x001F,
          0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,
          0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,
          0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,
          0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,
          0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,
          0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,
          0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,
          0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,
          0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,
          0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,
          0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,
          0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,0x007F,
          0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,
          0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,
          0x0090,0x0091,0x0092,0x0093,0x0094,0x0095,0x0096,0x0097,
          0x0098,0x0099,0x009A,0x009B,0x009C,0x009D,0x009E,0x009F,
          0x00A0,0x00A1,0x00A2,0x00A3,0x00A4,0x00A5,0x00A6,0x00A7,
          0x00A8,0x00A9,0x00AA,0x00AB,0x00AC,0x00AD,0x00AE,0x00AF,
          0x00B0,0x00B1,0x00B2,0x00B3,0x00B4,0x00B5,0x00B6,0x00B7,
          0x00B8,0x00B9,0x00BA,0x00BB,0x00BC,0x00BD,0x00BE,0x00BF,
          0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,
          0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,
          0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,
          0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,
          0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,
          0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
          0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,
          0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF
         }
        },
        {"ISO-8859-2",
         {
          0x0000,0x0001,0x0002,0x0003,0x0004,0x0005,0x0006,0x0007,
          0x0008,0x0009,0x000A,0x000B,0x000C,0x000D,0x000E,0x000F,
          0x0010,0x0011,0x0012,0x0013,0x0014,0x0015,0x0016,0x0017,
          0x0018,0x0019,0x001A,0x001B,0x001C,0x001D,0x001E,0x001F,
          0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,
          0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,
          0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,
          0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,
          0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,
          0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,
          0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,
          0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,
          0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,
          0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,
          0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,
          0x0078,0x0079,0x007A,0x007B,0x007C,0x007D,0x007E,0x007F,
          0x0080,0x0081,0x0082,0x0083,0x0084,0x0085,0x0086,0x0087,
          0x0088,0x0089,0x008A,0x008B,0x008C,0x008D,0x008E,0x008F,
          0x0090,0x0091,0x0092,0x0093,0x0094,0x0095,0x0096,0x0097,
          0x0098,0x0099,0x009A,0x009B,0x009C,0x009D,0x009E,0x009F,
          0x00A0,0x0104,0x02D8,0x0141,0x00A4,0x013D,0x015A,0x00A7,
          0x00A8,0x0160,0x015E,0x0164,0x0179,0x00AD,0x017D,0x017B,
          0x00B0,0x0105,0x02DB,0x0142,0x00B4,0x013E,0x015B,0x02C7,
          0x00B8,0x0161,0x015F,0x0165,0x017A,0x02DD,0x017E,0x017C,
          0x0154,0x00C1,0x00C2,0x0102,0x00C4,0x0139,0x0106,0x00C7,
          0x010C,0x00C9,0x0118,0x00CB,0x011A,0x00CD,0x00CE,0x010E,
          0x0110,0x0143,0x0147,0x00D3,0x00D4,0x0150,0x00D6,0x00D7,
          0x0158,0x016E,0x00DA,0x0170,0x00DC,0x00DD,0x0162,0x00DF,
          0x0155,0x00E1,0x00E2,0x0103,0x00E4,0x013A,0x0107,0x00E7,
          0x010D,0x00E9,0x0119,0x00EB,0x011B,0x00ED,0x00EE,0x010F,
          0x0111,0x0144,0x0148,0x00F3,0x00F4,0x0151,0x00F6,0x00F7,
          0x0159,0x016F,0x00FA,0x0171,0x00FC,0x00FD,0x0163,0x02D9
         }
        },
        {NULL}
};

1.1                  vorbis-tools/share/getopt.c

Index: getopt.c
===================================================================
/* Getopt for GNU.
   NOTE: getopt is now part of the C library, so if you don't know what
   "Keep this file name-space clean" means, talk to drepper at gnu.org
   before changing it!

   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
           Free Software Foundation, Inc.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
   Ditto for AIX 3.2 and <stdlib.h>.  */
#ifndef _NO_PROTO
# define _NO_PROTO
#endif

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#if !defined __STDC__ || !__STDC__
/* This is a separate conditional since some stdc systems
   reject `defined (const)'.  */
# ifndef const
#  define const
# endif
#endif

#include <stdio.h>

/* Comment out all this code if we are using the GNU C Library, and are not
   actually compiling the library itself.  This code is part of the GNU C
   Library, but also included in many other GNU distributions.  Compiling
   and linking in this code is a waste when using the GNU C library
   (especially if it is a shared library).  Rather than having every GNU
   program understand `configure --with-gnu-libc' and omit the object files,
   it is simpler to just do this in the source for each such file.  */

#define GETOPT_INTERFACE_VERSION 2
#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
# include <gnu-versions.h>
# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
#  define ELIDE_CODE
# endif
#endif

#ifndef ELIDE_CODE

/* This needs to come after some library #include
   to get __GNU_LIBRARY__ defined.  */
#ifdef	__GNU_LIBRARY__
/* Don't include stdlib.h for non-GNU C libraries because some of them
   contain conflicting prototypes for getopt.  */
# include <stdlib.h>
# include <unistd.h>
#endif	/* GNU C library.  */

#ifdef VMS
# include <unixlib.h>
# if HAVE_STRING_H - 0
#  include <string.h>
# endif
#endif

#ifndef _
/* This is for other GNU distributions with internationalized messages.
   When compiling libc, the _ macro is predefined.  */
# ifdef HAVE_LIBINTL_H
#  include <libintl.h>
#  define _(msgid)	gettext (msgid)
# else
#  define _(msgid)	(msgid)
# endif
#endif

/* This version of `getopt' appears to the caller like standard Unix `getopt'
   but it behaves differently for the user, since it allows the user
   to intersperse the options with the other arguments.

   As `getopt' works, it permutes the elements of ARGV so that,
   when it is done, all the options precede everything else.  Thus
   all application programs are extended to handle flexible argument order.

   Setting the environment variable POSIXLY_CORRECT disables permutation.
   Then the behavior is completely standard.

   GNU application programs can use a third alternative mode in which
   they can distinguish the relative order of options and other arguments.  */

#include "getopt.h"

/* For communication from `getopt' to the caller.
   When `getopt' finds an option that takes an argument,
   the argument value is returned here.
   Also, when `ordering' is RETURN_IN_ORDER,
   each non-option ARGV-element is returned here.  */

char *optarg;

/* Index in ARGV of the next element to be scanned.
   This is used for communication to and from the caller
   and for communication between successive calls to `getopt'.

   On entry to `getopt', zero means this is the first call; initialize.

   When `getopt' returns -1, this is the index of the first of the
   non-option elements that the caller should itself scan.

   Otherwise, `optind' communicates from one call to the next
   how much of ARGV has been scanned so far.  */

/* 1003.2 says this must be 1 before any call.  */
int optind = 1;

/* Formerly, initialization of getopt depended on optind==0, which
   causes problems with re-calling getopt as programs generally don't
   know that. */

int __getopt_initialized;

/* The next char to be scanned in the option-element
   in which the last option character we returned was found.
   This allows us to pick up the scan where we left off.

   If this is zero, or a null string, it means resume the scan
   by advancing to the next ARGV-element.  */

tatic char *nextchar;

/* Callers store zero here to inhibit the error message
   for unrecognized options.  */

int opterr = 1;

/* Set to an option character which was unrecognized.
   This must be initialized on some systems to avoid linking in the
   system's own getopt implementation.  */

int optopt = '?';

/* Describe how to deal with options that follow non-option ARGV-elements.

   If the caller did not specify anything,
   the default is REQUIRE_ORDER if the environment variable
   POSIXLY_CORRECT is defined, PERMUTE otherwise.

   REQUIRE_ORDER means don't recognize them as options;
   stop option processing when the first non-option is seen.
   This is what Unix does.
   This mode of operation is selected by either setting the environment
   variable POSIXLY_CORRECT, or using `+' as the first character
   of the list of option characters.

   PERMUTE is the default.  We permute the contents of ARGV as we scan,
   so that eventually all the non-options are at the end.  This allows options
   to be given in any order, even with programs that were not written to
   expect this.

   RETURN_IN_ORDER is an option available to programs that were written
   to expect options and other ARGV-elements in any order and that care about
   the ordering of the two.  We describe each non-option ARGV-element
   as if it were the argument of an option with character code 1.
   Using `-' as the first character of the list of option characters
   selects this mode of operation.

   The special argument `--' forces an end of option-scanning regardless
   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */

tatic enum
{
  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
} ordering;

/* Value of POSIXLY_CORRECT environment variable.  */
static char *posixly_correct;

#ifdef	__GNU_LIBRARY__
/* We want to avoid inclusion of string.h with non-GNU libraries
   because there are many ways it can cause trouble.
   On some systems, it contains special magic macros that don't work
   in GCC.  */
# include <string.h>
# define my_index	strchr
#else

#include <string.h>

/* Avoid depending on library functions or files
   whose names are inconsistent.  */

#ifndef getenv
extern char *getenv ();
#endif

tatic char *
my_index (str, chr)
     const char *str;
     int chr;
{
  while (*str)
    {
      if (*str == chr)
        return (char *) str;
      str++;
    }
  return 0;
}

/* If using GCC, we can safely declare strlen this way.
   If not using GCC, it is ok not to declare it.  */
#ifdef __GNUC__
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
   That was relevant to code that was here before.  */
# if (!defined __STDC__ || !__STDC__) && !defined strlen
/* gcc with -traditional declares the built-in strlen to return int,
   and has done so at least since version 2.4.5. -- rms.  */
extern int strlen (const char *);
# endif /* not __STDC__ */
#endif /* __GNUC__ */

#endif /* not __GNU_LIBRARY__ */

/* Handle permutation of arguments.  */

/* Describe the part of ARGV that contains non-options that have
   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
   `last_nonopt' is the index after the last of them.  */

tatic int first_nonopt;
static int last_nonopt;

#ifdef _LIBC
/* Bash 2.0 gives us an environment variable containing flags
   indicating ARGV elements that should not be considered arguments.  */

/* Defined in getopt_init.c  */
extern char *__getopt_nonoption_flags;

tatic int nonoption_flags_max_len;
static int nonoption_flags_len;

tatic int original_argc;
static char *const *original_argv;

/* Make sure the environment variable bash 2.0 puts in the environment
   is valid for the getopt call we must make sure that the ARGV passed
   to getopt is that one passed to the process.  */
static void
__attribute__ ((unused))
store_args_and_env (int argc, char *const *argv)
{
  /* XXX This is no good solution.  We should rather copy the args so
     that we can compare them later.  But we must not use malloc(3).  */
  original_argc = argc;
  original_argv = argv;
}
# ifdef text_set_element
text_set_element (__libc_subinit, store_args_and_env);
# endif /* text_set_element */

# define SWAP_FLAGS(ch1, ch2) \
  if (nonoption_flags_len > 0)						      \
    {									      \
      char __tmp = __getopt_nonoption_flags[ch1];			      \
      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
      __getopt_nonoption_flags[ch2] = __tmp;				      \
    }
#else	/* !_LIBC */
# define SWAP_FLAGS(ch1, ch2)
#endif	/* _LIBC */

/* Exchange two adjacent subsequences of ARGV.
   One subsequence is elements [first_nonopt,last_nonopt)
   which contains all the non-options that have been skipped so far.
   The other is elements [last_nonopt,optind), which contains all
   the options processed since those non-options were skipped.

   `first_nonopt' and `last_nonopt' are relocated so that they describe
   the new indices of the non-options in ARGV after they are moved.  */

#if defined __STDC__ && __STDC__
static void exchange (char **);
#endif

tatic void
exchange (argv)
     char **argv;
{
  int bottom = first_nonopt;
  int middle = last_nonopt;
  int top = optind;
  char *tem;

  /* Exchange the shorter segment with the far end of the longer segment.
     That puts the shorter segment into the right place.
     It leaves the longer segment in the right place overall,
     but it consists of two parts that need to be swapped next.  */

#ifdef _LIBC
  /* First make sure the handling of the `__getopt_nonoption_flags'
     string can work normally.  Our top argument must be in the range
     of the string.  */
  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
    {
      /* We must extend the array.  The user plays games with us and
         presents new arguments.  */
      char *new_str = malloc (top + 1);
      if (new_str == NULL)
        nonoption_flags_len = nonoption_flags_max_len = 0;
      else
        {
          memset (__mempcpy (new_str, __getopt_nonoption_flags,
                             nonoption_flags_max_len),
                  '\0', top + 1 - nonoption_flags_max_len);
          nonoption_flags_max_len = top + 1;
          __getopt_nonoption_flags = new_str;
        }
    }
#endif

  while (top > middle && middle > bottom)
    {
      if (top - middle > middle - bottom)
        {
          /* Bottom segment is the short one.  */
          int len = middle - bottom;
          register int i;

          /* Swap it with the top part of the top segment.  */
          for (i = 0; i < len; i++)
            {
              tem = argv[bottom + i];
              argv[bottom + i] = argv[top - (middle - bottom) + i];
              argv[top - (middle - bottom) + i] = tem;
              SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
            }
          /* Exclude the moved bottom segment from further swapping.  */
          top -= len;
        }
      else
        {
          /* Top segment is the short one.  */
          int len = top - middle;
          register int i;

          /* Swap it with the bottom part of the bottom segment.  */
          for (i = 0; i < len; i++)
            {
              tem = argv[bottom + i];
              argv[bottom + i] = argv[middle + i];
              argv[middle + i] = tem;
              SWAP_FLAGS (bottom + i, middle + i);
            }
          /* Exclude the moved top segment from further swapping.  */
          bottom += len;
        }
    }

  /* Update records for the slots the non-options now occupy.  */

  first_nonopt += (optind - last_nonopt);
  last_nonopt = optind;
}

/* Initialize the internal data when the first call is made.  */

#if defined __STDC__ && __STDC__
static const char *_getopt_initialize (int, char *const *, const char *);
#endif
static const char *
_getopt_initialize (argc, argv, optstring)
     int argc;
     char *const *argv;
     const char *optstring;
{
  /* Start processing options with ARGV-element 1 (since ARGV-element 0
     is the program name); the sequence of previously skipped
     non-option ARGV-elements is empty.  */

  first_nonopt = last_nonopt = optind;

  nextchar = NULL;

  posixly_correct = getenv ("POSIXLY_CORRECT");

  /* Determine how to handle the ordering of options and nonoptions.  */

  if (optstring[0] == '-')
    {
      ordering = RETURN_IN_ORDER;
      ++optstring;
    }
  else if (optstring[0] == '+')
    {
      ordering = REQUIRE_ORDER;
      ++optstring;
    }
  else if (posixly_correct != NULL)
    ordering = REQUIRE_ORDER;
  else
    ordering = PERMUTE;

#ifdef _LIBC
  if (posixly_correct == NULL
      && argc == original_argc && argv == original_argv)
    {
      if (nonoption_flags_max_len == 0)
        {
          if (__getopt_nonoption_flags == NULL
              || __getopt_nonoption_flags[0] == '\0')
            nonoption_flags_max_len = -1;
          else
            {
              const char *orig_str = __getopt_nonoption_flags;
              int len = nonoption_flags_max_len = strlen (orig_str);
              if (nonoption_flags_max_len < argc)
                nonoption_flags_max_len = argc;
              __getopt_nonoption_flags =
                (char *) malloc (nonoption_flags_max_len);
              if (__getopt_nonoption_flags == NULL)
                nonoption_flags_max_len = -1;
              else
                memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
                        '\0', nonoption_flags_max_len - len);
            }
        }
      nonoption_flags_len = nonoption_flags_max_len;
    }
  else
    nonoption_flags_len = 0;
#endif

  return optstring;
}

/* Scan elements of ARGV (whose length is ARGC) for option characters
   given in OPTSTRING.

   If an element of ARGV starts with '-', and is not exactly "-" or "--",
   then it is an option element.  The characters of this element
   (aside from the initial '-') are option characters.  If `getopt'
   is called repeatedly, it returns successively each of the option characters
   from each of the option elements.

   If `getopt' finds another option character, it returns that character,
   updating `optind' and `nextchar' so that the next call to `getopt' can
   resume the scan with the following option character or ARGV-element.

   If there are no more option characters, `getopt' returns -1.
   Then `optind' is the index in ARGV of the first ARGV-element
   that is not an option.  (The ARGV-elements have been permuted
   so that those that are not options now come last.)

   OPTSTRING is a string containing the legitimate option characters.
   If an option character is seen that is not listed in OPTSTRING,
   return '?' after printing an error message.  If you set `opterr' to
   zero, the error message is suppressed but we still return '?'.

   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
   so the following text in the same ARGV-element, or the text of the following
   ARGV-element, is returned in `optarg'.  Two colons mean an option that
   wants an optional arg; if there is text in the current ARGV-element,
   it is returned in `optarg', otherwise `optarg' is set to zero.

   If OPTSTRING starts with `-' or `+', it requests different methods of
   handling the non-option ARGV-elements.
   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.

   Long-named options begin with `--' instead of `-'.
   Their names may be abbreviated as long as the abbreviation is unique
   or is an exact match for some defined option.  If they have an
   argument, it follows the option name in the same ARGV-element, separated
   from the option name by a `=', or else the in next ARGV-element.
   When `getopt' finds a long-named option, it returns 0 if that option's
   `flag' field is nonzero, the value of the option's `val' field
   if the `flag' field is zero.

   The elements of ARGV aren't really const, because we permute them.
   But we pretend they're const in the prototype to be compatible
   with other systems.

   LONGOPTS is a vector of `struct option' terminated by an
   element containing a name which is zero.

   LONGIND returns the index in LONGOPT of the long-named option found.
   It is only valid when a long-named option has been found by the most
   recent call.

   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
   long-named options.  */

int
_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
     int argc;
     char *const *argv;
     const char *optstring;
     const struct option *longopts;
     int *longind;
     int long_only;
{
  optarg = NULL;

  if (optind == 0 || !__getopt_initialized)
    {
      if (optind == 0)
        optind = 1;	/* Don't scan ARGV[0], the program name.  */
      optstring = _getopt_initialize (argc, argv, optstring);
      __getopt_initialized = 1;
    }

  /* Test whether ARGV[optind] points to a non-option argument.
     Either it does not have option syntax, or there is an environment flag
     from the shell indicating it is not an option.  The later information
     is only used when the used in the GNU libc.  */
#ifdef _LIBC
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'	      \
                      || (optind < nonoption_flags_len			      \
                          && __getopt_nonoption_flags[optind] == '1'))
#else
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
#endif

  if (nextchar == NULL || *nextchar == '\0')
    {
      /* Advance to the next ARGV-element.  */

      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
         moved back by the user (who may also have changed the arguments).  */
      if (last_nonopt > optind)
        last_nonopt = optind;
      if (first_nonopt > optind)
        first_nonopt = optind;

      if (ordering == PERMUTE)
        {
          /* If we have just processed some options following some non-options,
             exchange them so that the options come first.  */

          if (first_nonopt != last_nonopt && last_nonopt != optind)
            exchange ((char **) argv);
          else if (last_nonopt != optind)
            first_nonopt = optind;

          /* Skip any additional non-options
             and extend the range of non-options previously skipped.  */

          while (optind < argc && NONOPTION_P)
            optind++;
          last_nonopt = optind;
        }

      /* The special ARGV-element `--' means premature end of options.
         Skip it like a null option,
         then exchange with previous non-options as if it were an option,
         then skip everything else like a non-option.  */

      if (optind != argc && !strcmp (argv[optind], "--"))
        {
          optind++;

          if (first_nonopt != last_nonopt && last_nonopt != optind)
            exchange ((char **) argv);
          else if (first_nonopt == last_nonopt)
            first_nonopt = optind;
          last_nonopt = argc;

          optind = argc;
        }

      /* If we have done all the ARGV-elements, stop the scan
         and back over any non-options that we skipped and permuted.  */

      if (optind == argc)
        {
          /* Set the next-arg-index to point at the non-options
             that we previously skipped, so the caller will digest them.  */
          if (first_nonopt != last_nonopt)
            optind = first_nonopt;
          return -1;
        }

      /* If we have come to a non-option and did not permute it,
         either stop the scan or describe it to the caller and pass it by.  */

      if (NONOPTION_P)
        {
          if (ordering == REQUIRE_ORDER)
            return -1;
          optarg = argv[optind++];
          return 1;
        }

      /* We have found another option-ARGV-element.
         Skip the initial punctuation.  */

      nextchar = (argv[optind] + 1
                  + (longopts != NULL && argv[optind][1] == '-'));
    }

  /* Decode the current option-ARGV-element.  */

  /* Check whether the ARGV-element is a long option.

     If long_only and the ARGV-element has the form "-f", where f is
     a valid short option, don't consider it an abbreviated form of
     a long option that starts with f.  Otherwise there would be no
     way to give the -f short option.

     On the other hand, if there's a long option "fubar" and
     the ARGV-element is "-fu", do consider that an abbreviation of
     the long option, just like "--fu", and not "-f" with arg "u".

     This distinction seems to be the most useful approach.  */

  if (longopts != NULL
      && (argv[optind][1] == '-'
          || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
    {
      char *nameend;
      const struct option *p;
      const struct option *pfound = NULL;
      int exact = 0;
      int ambig = 0;
      int indfound = -1;
      int option_index;

      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
        /* Do nothing.  */ ;

      /* Test all long options for either exact match
         or abbreviated matches.  */
      for (p = longopts, option_index = 0; p->name; p++, option_index++)
        if (!strncmp (p->name, nextchar, nameend - nextchar))
          {
            if ((unsigned int) (nameend - nextchar)
                == (unsigned int) strlen (p->name))
              {
                /* Exact match found.  */
                pfound = p;
                indfound = option_index;
                exact = 1;
                break;
              }
            else if (pfound == NULL)
              {
                /* First nonexact match found.  */
                pfound = p;
                indfound = option_index;
              }
            else
              /* Second or later nonexact match found.  */
              ambig = 1;
          }

      if (ambig && !exact)
        {
          if (opterr)
            fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
                     argv[0], argv[optind]);
          nextchar += strlen (nextchar);
          optind++;
          optopt = 0;
          return '?';
        }

      if (pfound != NULL)
        {
          option_index = indfound;
          optind++;
          if (*nameend)
            {
              /* Don't test has_arg with >, because some C compilers don't
                 allow it to be used on enums.  */
              if (pfound->has_arg)
                optarg = nameend + 1;
              else
                {
                  if (opterr)
                    {
                      if (argv[optind - 1][1] == '-')
                        /* --option */
                        fprintf (stderr,
                                 _("%s: option `--%s' doesn't allow an argument\n"),
                                 argv[0], pfound->name);
                      else
                        /* +option or -option */
                        fprintf (stderr,
                                 _("%s: option `%c%s' doesn't allow an argument\n"),
                                 argv[0], argv[optind - 1][0], pfound->name);
                    }

                  nextchar += strlen (nextchar);

                  optopt = pfound->val;
                  return '?';
                }
            }
          else if (pfound->has_arg == 1)
            {
              if (optind < argc)
                optarg = argv[optind++];
              else
                {
                  if (opterr)
                    fprintf (stderr,
                           _("%s: option `%s' requires an argument\n"),
                           argv[0], argv[optind - 1]);
                  nextchar += strlen (nextchar);
                  optopt = pfound->val;
                  return optstring[0] == ':' ? ':' : '?';
                }
            }
          nextchar += strlen (nextchar);
          if (longind != NULL)
            *longind = option_index;
          if (pfound->flag)
            {
              *(pfound->flag) = pfound->val;
              return 0;
            }
          return pfound->val;
        }

      /* Can't find it as a long option.  If this is not getopt_long_only,
         or the option starts with '--' or is not a valid short
         option, then it's an error.
         Otherwise interpret it as a short option.  */
      if (!long_only || argv[optind][1] == '-'
          || my_index (optstring, *nextchar) == NULL)
        {
          if (opterr)
            {
              if (argv[optind][1] == '-')
                /* --option */
                fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
                         argv[0], nextchar);
              else
                /* +option or -option */
                fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
                         argv[0], argv[optind][0], nextchar);
            }
          nextchar = (char *) "";
          optind++;
          optopt = 0;
          return '?';
        }
    }

  /* Look at and handle the next short option-character.  */

  {
    char c = *nextchar++;
    char *temp = my_index (optstring, c);

    /* Increment `optind' when we start to process its last character.  */
    if (*nextchar == '\0')
      ++optind;

    if (temp == NULL || c == ':')
      {
        if (opterr)
          {
            if (posixly_correct)
              /* 1003.2 specifies the format of this message.  */
              fprintf (stderr, _("%s: illegal option -- %c\n"),
                       argv[0], c);
            else
              fprintf (stderr, _("%s: invalid option -- %c\n"),
                       argv[0], c);
          }
        optopt = c;
        return '?';
      }
    /* Convenience. Treat POSIX -W foo same as long option --foo */
    if (temp[0] == 'W' && temp[1] == ';')
      {
        char *nameend;
        const struct option *p;
        const struct option *pfound = NULL;
        int exact = 0;
        int ambig = 0;
        int indfound = 0;
        int option_index;

        /* This is an option that requires an argument.  */
        if (*nextchar != '\0')
          {
            optarg = nextchar;
            /* If we end this ARGV-element by taking the rest as an arg,
               we must advance to the next element now.  */
            optind++;
          }
        else if (optind == argc)
          {
            if (opterr)
              {
                /* 1003.2 specifies the format of this message.  */
                fprintf (stderr, _("%s: option requires an argument -- %c\n"),
                         argv[0], c);
              }
            optopt = c;
            if (optstring[0] == ':')
              c = ':';
            else
              c = '?';
            return c;
          }
        else
          /* We already incremented `optind' once;
             increment it again when taking next ARGV-elt as argument.  */
          optarg = argv[optind++];

        /* optarg is now the argument, see if it's in the
           table of longopts.  */

        for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
          /* Do nothing.  */ ;

        /* Test all long options for either exact match
           or abbreviated matches.  */
        for (p = longopts, option_index = 0; p->name; p++, option_index++)
          if (!strncmp (p->name, nextchar, nameend - nextchar))
            {
              if ((unsigned int) (nameend - nextchar) == strlen (p->name))
                {
                  /* Exact match found.  */
                  pfound = p;
                  indfound = option_index;
                  exact = 1;
                  break;
                }
              else if (pfound == NULL)
                {
                  /* First nonexact match found.  */
                  pfound = p;
                  indfound = option_index;
                }
              else
                /* Second or later nonexact match found.  */
                ambig = 1;
            }
        if (ambig && !exact)
          {
            if (opterr)
              fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
                       argv[0], argv[optind]);
            nextchar += strlen (nextchar);
            optind++;
            return '?';
          }
        if (pfound != NULL)
          {
            option_index = indfound;
            if (*nameend)
              {
                /* Don't test has_arg with >, because some C compilers don't
                   allow it to be used on enums.  */
                if (pfound->has_arg)
                  optarg = nameend + 1;
                else
                  {
                    if (opterr)
                      fprintf (stderr, _("\
%s: option `-W %s' doesn't allow an argument\n"),
                               argv[0], pfound->name);

                    nextchar += strlen (nextchar);
                    return '?';
                  }
              }
            else if (pfound->has_arg == 1)
              {
                if (optind < argc)
                  optarg = argv[optind++];
                else
                  {
                    if (opterr)
                      fprintf (stderr,
                               _("%s: option `%s' requires an argument\n"),
                               argv[0], argv[optind - 1]);
                    nextchar += strlen (nextchar);
                    return optstring[0] == ':' ? ':' : '?';
                  }
              }
            nextchar += strlen (nextchar);
            if (longind != NULL)
              *longind = option_index;
            if (pfound->flag)
              {
                *(pfound->flag) = pfound->val;
                return 0;
              }
            return pfound->val;
          }
          nextchar = NULL;
          return 'W';	/* Let the application handle it.   */
      }
    if (temp[1] == ':')
      {
        if (temp[2] == ':')
          {
            /* This is an option that accepts an argument optionally.  */
            if (*nextchar != '\0')
              {
                optarg = nextchar;
                optind++;
              }
            else
              optarg = NULL;
            nextchar = NULL;
          }
        else
          {
            /* This is an option that requires an argument.  */
            if (*nextchar != '\0')
              {
                optarg = nextchar;
                /* If we end this ARGV-element by taking the rest as an arg,
                   we must advance to the next element now.  */
                optind++;
              }
            else if (optind == argc)
              {
                if (opterr)
                  {
                    /* 1003.2 specifies the format of this message.  */
                    fprintf (stderr,
                           _("%s: option requires an argument -- %c\n"),
                           argv[0], c);
                  }
                optopt = c;
                if (optstring[0] == ':')
                  c = ':';
                else
                  c = '?';
              }
            else
              /* We already incremented `optind' once;
                 increment it again when taking next ARGV-elt as argument.  */
              optarg = argv[optind++];
            nextchar = NULL;
          }
      }
    return c;
  }
}

int
getopt (argc, argv, optstring)
     int argc;
     char *const *argv;
     const char *optstring;
{
  return _getopt_internal (argc, argv, optstring,
                           (const struct option *) 0,
                           (int *) 0,
                           0);
}

#endif	/* Not ELIDE_CODE.  */

#ifdef TEST

/* Compile with -DTEST to make an executable for use in testing
   the above definition of `getopt'.  */

int
main (argc, argv)
     int argc;
     char **argv;
{
  int c;
  int digit_optind = 0;

  while (1)
    {
      int this_option_optind = optind ? optind : 1;

      c = getopt (argc, argv, "abc:d:0123456789");
      if (c == -1)
        break;

      switch (c)
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
          if (digit_optind != 0 && digit_optind != this_option_optind)
            printf ("digits occur in two different argv-elements.\n");
          digit_optind = this_option_optind;
          printf ("option %c\n", c);
          break;

        case 'a':
          printf ("option a\n");
          break;

        case 'b':
          printf ("option b\n");
          break;

        case 'c':
          printf ("option c with value `%s'\n", optarg);
          break;

        case '?':
          break;

        default:
          printf ("?? getopt returned character code 0%o ??\n", c);
        }
    }

  if (optind < argc)
    {
      printf ("non-option ARGV-elements: ");
      while (optind < argc)
        printf ("%s ", argv[optind++]);
      printf ("\n");
    }

  exit (0);
}

#endif /* TEST */

1.1                  vorbis-tools/share/getopt1.c

Index: getopt1.c
===================================================================
/* getopt_long and getopt_long_only entry points for GNU getopt.
   Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98
     Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "getopt.h"

#if !defined __STDC__ || !__STDC__
/* This is a separate conditional since some stdc systems
   reject `defined (const)'.  */
#ifndef const
#define const
#endif
#endif

#include <stdio.h>

/* Comment out all this code if we are using the GNU C Library, and are not
   actually compiling the library itself.  This code is part of the GNU C
   Library, but also included in many other GNU distributions.  Compiling
   and linking in this code is a waste when using the GNU C library
   (especially if it is a shared library).  Rather than having every GNU
   program understand `configure --with-gnu-libc' and omit the object files,
   it is simpler to just do this in the source for each such file.  */

#define GETOPT_INTERFACE_VERSION 2
#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
#include <gnu-versions.h>
#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
#define ELIDE_CODE
#endif
#endif

#ifndef ELIDE_CODE

/* This needs to come after some library #include
   to get __GNU_LIBRARY__ defined.  */
#ifdef __GNU_LIBRARY__
#include <stdlib.h>
#endif

#ifndef	NULL
#define NULL 0
#endif

int
getopt_long (argc, argv, options, long_options, opt_index)
     int argc;
     char *const *argv;
     const char *options;
     const struct option *long_options;
     int *opt_index;
{
  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
}

/* Like getopt_long, but '-' as well as '--' can indicate a long option.
   If an option that starts with '-' (not '--') doesn't match a long option,
   but does match a short option, it is parsed as a short option
   instead.  */

int
getopt_long_only (argc, argv, options, long_options, opt_index)
     int argc;
     char *const *argv;
     const char *options;
     const struct option *long_options;
     int *opt_index;
{
  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
}

#endif	/* Not ELIDE_CODE.  */

#ifdef TEST

#include <stdio.h>

int
main (argc, argv)
     int argc;
     char **argv;
{
  int c;
  int digit_optind = 0;

  while (1)
    {
      int this_option_optind = optind ? optind : 1;
      int option_index = 0;
      static struct option long_options[] =
      {
        {"add", 1, 0, 0},
        {"append", 0, 0, 0},
        {"delete", 1, 0, 0},
        {"verbose", 0, 0, 0},
        {"create", 0, 0, 0},
        {"file", 1, 0, 0},
        {0, 0, 0, 0}
      };

      c = getopt_long (argc, argv, "abc:d:0123456789",
                       long_options, &option_index);
      if (c == -1)
        break;

      switch (c)
        {
        case 0:
          printf ("option %s", long_options[option_index].name);
          if (optarg)
            printf (" with arg %s", optarg);
          printf ("\n");
          break;

        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
          if (digit_optind != 0 && digit_optind != this_option_optind)
            printf ("digits occur in two different argv-elements.\n");
          digit_optind = this_option_optind;
          printf ("option %c\n", c);
          break;

        case 'a':
          printf ("option a\n");
          break;

        case 'b':
          printf ("option b\n");
          break;

        case 'c':
          printf ("option c with value `%s'\n", optarg);
          break;

        case 'd':
          printf ("option d with value `%s'\n", optarg);
          break;

        case '?':
          break;

        default:
          printf ("?? getopt returned character code 0%o ??\n", c);
        }
    }

  if (optind < argc)
    {
      printf ("non-option ARGV-elements: ");
      while (optind < argc)
        printf ("%s ", argv[optind++]);
      printf ("\n");
    }

  exit (0);
}

#endif /* TEST */

1.1                  vorbis-tools/share/make_code_map.pl

Index: make_code_map.pl
===================================================================
#!/usr/bin/perl
# OggEnc

# This program is distributed under the GNU General Public License, version 2.
# A copy of this license is included with this source.
#
# Copyright © 2001, Daniel Resare <noa at metamatrix.se>

# this script creates a headerfile with charset maps from charset mapping
# files in the format published on unicode.org.
# To add more encodings, simply pull the desired files from
# http://www.unicode.org/Public/ and add encoding name and file name to 
# %maps

%maps = ('ISO-8859-1' => '8859-1.map',
        'ISO-8859-2' => '8859-2.map');

print <<EOF;
/* This file was automatically generated by make_code_map.pl
   please don't edit directly
   Daniel Resare <noa\@metamatrix.se>
*/
EOF

print("charset_map maps[] = {");
for(keys(%maps)) {
  print("\n\t{\"" . $_ . "\",\n\t {");

  open FILE, $maps{$_} or die;
  $i = 0;
  while(<FILE>) {
    if(/^#/) {
      next;
    }
    if($i != 0) {
      print ",";
    }
    @fields = split;
    unless ($i % 8) {
      print "\n\t  ";
    }
    print "$fields[1]";
    $i++;
  }
  print("\n\t }\n\t},");
}
print "\n\t{NULL}\n};\n";

1.1                  vorbis-tools/share/utf8.c

Index: utf8.c
===================================================================
/* OggEnc
 *
 * This program is distributed under the GNU General Public License, version 2.
 * A copy of this license is included with this source.
 *
 * (C) 2001 Michael Smith <msmith at labyrinth.net.au>
 *
 * UTF-8 Conversion routines
 *   Copyright (C) 2001, Daniel Resare <noa at metamatrix.se>
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "utf8.h"

#ifdef _WIN32
#include <windows.h>

int utf8_encode(char *from, char **to, const char *encoding)
{
        /* Thanks to Peter Harris <peter.harris at hummingbird.com> for this win32
         * code.
         *
         * We ignore 'encoding' and assume that the input is in the 'code page'
         * of the console. Reasonable, since oggenc is a console app.
         */

        unsigned short *unicode;
        int wchars, err;

        wchars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, from,
                        strlen(from), NULL, 0);

        if(wchars == 0)
        {
                fprintf(stderr, "Unicode translation error %d\n", GetLastError());
                return 1;
        }

        unicode = calloc(wchars + 1, sizeof(unsigned short));
        if(unicode == NULL) 
        {
                fprintf(stderr, "Out of memory processing string to UTF8\n");
                return 1;
        }

        err = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, from, 
                        strlen(from), unicode, wchars);
        if(err != wchars)
        {
                free(unicode);
                fprintf(stderr, "Unicode translation error %d\n", GetLastError());
                return 1;
        }

        /* On NT-based windows systems, we could use WideCharToMultiByte(), but 
         * MS doesn't actually have a consistent API across win32.
         */
        *to = make_utf8_string(unicode);

        free(unicode);
        return 0;
}

int utf8_decode(char *from, char **to, const char *encoding)
{
        return 1;  /* Dummy stub */
}

#else /* End win32. Rest is for real operating systems */

#ifdef HAVE_ICONV
#include <iconv.h>
#include <errno.h>
#endif

#include "charsetmap.h"

#define BUFSIZE 256

/*
 Converts the string FROM from the encoding specified in ENCODING
 to UTF-8. The resulting string i pointed to by *TO.

 Return values:
 0 indicates a successfully converted string.
 1 indicates that the given encoding is not available.
 2 indicates that the given string is bigger than BUFSIZE and can therefore
   not be encoded.
 3 indicates that given string could not be parsed.
*/
int utf8_encode(char *from, char **to, const char *encoding)
{
#ifdef HAVE_ICONV
        static unsigned char buffer[BUFSIZE];
    char *from_p, *to_p;
        size_t from_left, to_left;
        iconv_t cd;
#endif

        if (!strcasecmp(encoding, "UTF-8")) {
            /* ideally some checking of the given string should be done */
                *to = malloc(strlen(from) + 1);
                strcpy(*to, from);
                return 0;
        }

#ifdef HAVE_ICONV
        cd = iconv_open("UTF-8", encoding);
        if(cd == (iconv_t)(-1))
        {
                if(errno == EINVAL) {
                        /* if iconv can't encode from this encoding, try
                         * simple_utf8_encode()
                         */
                        return simple_utf8_encode(from, to, encoding);
                } else {
                        perror("iconv_open");
                }
        }
        
        from_left = strlen(from);
        to_left = BUFSIZE;
        from_p = from;
        to_p = buffer;
        
        if(iconv(cd, (ICONV_CONST char **)(&from_p), &from_left, &to_p, 
                                &to_left) == (size_t)-1)
        {
                iconv_close(cd);
                switch(errno)
                {
                case E2BIG:
                        /* if the buffer is too small, try simple_utf8_encode()
                         */
                        return simple_utf8_encode(from, to, encoding);
                case EILSEQ:
                case EINVAL:
                        return 3;
                default:
                        perror("iconv");
                }
        }
        else
        {
                iconv_close(cd);
        }
        *to = malloc(BUFSIZE - to_left + 1);
        buffer[BUFSIZE - to_left] = 0;
        strcpy(*to, buffer);
        return 0;
#else
        return simple_utf8_encode(from, to, encoding);
#endif
}

/*
 This implementation has the following limitations: The given charset must
 represent each glyph with exactly one (1) byte. No multi byte or variable
 width charsets are allowed. (An exception to this i UTF-8 that is passed
 right through.) The glyhps in the charsets must have a unicode value equal
 to or less than 0xFFFF (this inclues pretty much everything). For a complete,
 free conversion implementation please have a look at libiconv.
*/
int simple_utf8_encode(const char *from, char **to, const char *encoding)
{
        /* can you always know this will be 16 bit? */
        unsigned short *unicode;
        charset_map *map;
        int index = 0;
        unsigned char c;
        
        unicode = calloc((strlen(from) + 1), sizeof(short));

        map = get_map(encoding);
        
        if (map == NULL) 
                return 1;

        c = from[index];
        while(c)
        {
                unicode[index] = map->mapping[c];
                index++;
                c = from[index];
        }

        *to =  make_utf8_string(unicode);
        free(unicode);
        return 0;
}

int utf8_decode(char *from, char **to, const char *encoding)
{
        return 1;  /* Dummy stub */
}

charset_map *get_map(const char *encoding)
{
        charset_map *map_p = maps;
        while(map_p->name != NULL)
        {
                if(!strcasecmp(map_p->name, encoding))
                {
                        return map_p;
                }
                map_p++;
        }
        return NULL;
}

#endif /* The rest is used by everthing */

char *make_utf8_string(const unsigned short *unicode)
{
        int size = 0, index = 0, out_index = 0;
        unsigned char *out;
        unsigned short c;

    /* first calculate the size of the target string */
        c = unicode[index++];
        while(c) {
                if(c < 0x0080) {
                        size += 1;
                } else if(c < 0x0800) {
                        size += 2;
                } else {
                        size += 3;
                }
                c = unicode[index++];
        }	

        out = malloc(size + 1);
        index = 0;

        c = unicode[index++];
        while(c)
        {
                if(c < 0x080) {
                        out[out_index++] = c;
                } else if(c < 0x800) {
                        out[out_index++] = 0xc0 | (c >> 6);
                        out[out_index++] = 0x80 | (c & 0x3f);
                } else {
                        out[out_index++] = 0xe0 | (c >> 12);
                        out[out_index++] = 0x80 | ((c >> 6) & 0x3f);
                        out[out_index++] = 0x80 | (c & 0x3f);
                }
                c = unicode[index++];
        }
        out[out_index] = 0x00;

        return out;
}

1.9       +4 -3      vorbis-tools/vorbiscomment/Makefile.am

Index: Makefile.am
===================================================================
RCS file: /usr/local/cvsroot/vorbis-tools/vorbiscomment/Makefile.am,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -r1.8 -r1.9
--- Makefile.am	2001/02/19 23:10:42	1.8
+++ Makefile.am	2001/09/22 22:49:52	1.9
@@ -4,11 +4,12 @@
 
 bin_PROGRAMS = vorbiscomment
 
-INCLUDES = @OGG_CFLAGS@ @VORBIS_CFLAGS@
+INCLUDES = @OGG_CFLAGS@ @VORBIS_CFLAGS@ -I$(top_srcdir)/include
 
-vorbiscomment_LDADD = @VORBIS_LIBS@ @OGG_LIBS@
+vorbiscomment_LDADD = @VORBIS_LIBS@ @OGG_LIBS@ @LIBICONV@ @SHARE_LIBS@
+vorbiscomment_DEPENDENCIES = @SHARE_LIBS@
 
-vorbiscomment_SOURCES = vcedit.c vcedit.h vcomment.c getopt.c getopt.h getopt1.c
+vorbiscomment_SOURCES = vcedit.c vcedit.h vcomment.c
 
 debug:
         $(MAKE) all CFLAGS="@DEBUG@"

1.10      +28 -13    vorbis-tools/vorbiscomment/vcomment.c

Index: vcomment.c
===================================================================
RCS file: /usr/local/cvsroot/vorbis-tools/vorbiscomment/vcomment.c,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -r1.9 -r1.10
--- vcomment.c	2001/07/17 12:28:31	1.9
+++ vcomment.c	2001/09/22 22:49:52	1.10
@@ -13,6 +13,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include "getopt.h"
+#include "utf8.h"
 
 #include "vcedit.h"
 
@@ -35,6 +36,7 @@
         int commentcount;
         char **comments;
         int tempoutfile;
+	char *encoding;
 } param_t;
 
 #define MODE_NONE  0
@@ -45,7 +47,7 @@
 /* prototypes */
 void usage(void);
 void print_comments(FILE *out, vorbis_comment *vc);
-int  add_comment(char *line, vorbis_comment *vc);
+int  add_comment(char *line, vorbis_comment *vc, char *encoding);
 
 param_t	*new_param(void);
 void parse_options(int argc, char *argv[], param_t *param);
@@ -125,7 +127,7 @@
 
                 for(i=0; i < param->commentcount; i++)
                 {
-			if(add_comment(param->comments[i], vc) < 0)
+			if(add_comment(param->comments[i], vc, param->encoding) < 0)
                                 fprintf(stderr, "Bad comment: \"%s\"\n", param->comments[i]);
                 }
 
@@ -136,7 +138,7 @@
                         char *buf = (char *)malloc(sizeof(char)*1024);
 
                         while (fgets(buf, 1024, param->com))
-				if (add_comment(buf, vc) < 0) {
+				if (add_comment(buf, vc, param->encoding) < 0) {
                                         fprintf(stderr,
                                                 "bad comment: \"%s\"\n",
                                                 buf);
@@ -184,18 +186,18 @@
 
 /**********
 
-   Take a line of the form "TAG=value string", parse it,
-   and add it to the vorbis_comment structure. Error checking
-   is performed.
+   Take a line of the form "TAG=value string", parse it, convert the
+   value to UTF-8 from the specified encoding, and add it to the
+   vorbis_comment structure. Error checking is performed.
 
    Note that this assumes a null-terminated string, which may cause
    problems with > 8-bit character sets!
 
 ***********/
 
-int  add_comment(char *line, vorbis_comment *vc)
+int  add_comment(char *line, vorbis_comment *vc, char *encoding)
 {
-	char	*mark, *value;
+	char	*mark, *value, *utf8_value;
 
         /* strip any terminal newline */
         {
@@ -221,10 +223,17 @@
         *mark = '\0';	
         value++;
 
-	/* append the comment and return */
-	vorbis_comment_add_tag(vc, line, value);
-
-	return 0;
+	/* convert the value from the native charset to UTF-8 */
+	if (utf8_encode(value, &utf8_value, encoding) == 0) {
+		
+		/* append the comment and return */
+		vorbis_comment_add_tag(vc, line, value);
+		return 0;
+	} else {
+		fprintf(stderr, "Couldn't convert comment to UTF8, "
+			"cannot add\n");
+		return -1;
+	}
 }
 
 
@@ -287,6 +296,9 @@
         param->comments=NULL;
         param->tempoutfile=0;
 
+	/* character encoding */
+	param->encoding = "ISO-8859-1";
+
         return param;
 }
 
@@ -304,7 +316,7 @@
         int ret;
         int option_index = 1;
 
-	while ((ret = getopt_long(argc, argv, "alwhqc:t:",
+	while ((ret = getopt_long(argc, argv, "aelwhqc:t:",
                         long_options, &option_index)) != -1) {
                 switch (ret) {
                         case 0:
@@ -319,6 +331,9 @@
                                 break;
                         case 'a':
                                 param->mode = MODE_APPEND;
+				break;
+			case 'e':
+				param->mode = strdup(optarg);
                                 break;
                         case 'h':
                                 usage();

--- >8 ----
List archives:  http://www.xiph.org/archives/
Ogg project homepage: http://www.xiph.org/ogg/
To unsubscribe from this list, send a message to 'cvs-request at xiph.org'
containing only the word 'unsubscribe' in the body.  No subject is needed.
Unsubscribe messages sent to the list will be ignored/filtered.



More information about the commits mailing list