diff options
Diffstat (limited to 'Build/source/utils/texinfo/makeinfo/lang.c')
-rw-r--r-- | Build/source/utils/texinfo/makeinfo/lang.c | 1020 |
1 files changed, 1020 insertions, 0 deletions
diff --git a/Build/source/utils/texinfo/makeinfo/lang.c b/Build/source/utils/texinfo/makeinfo/lang.c new file mode 100644 index 00000000000..c72e8dbc631 --- /dev/null +++ b/Build/source/utils/texinfo/makeinfo/lang.c @@ -0,0 +1,1020 @@ +/* lang.c -- language-dependent support. + $Id: lang.c,v 1.14 2004/11/22 23:57:33 karl Exp $ + + Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Free Software + Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Originally written by Karl Heinz Marbaise <kama@hippo.fido.de>. */ + +#include "system.h" +#include "cmds.h" +#include "files.h" +#include "lang.h" +#include "makeinfo.h" +#include "xml.h" + +/* Current document encoding. */ +encoding_code_type document_encoding_code = no_encoding; + +/* Current language code; default is English. */ +language_code_type language_code = en; + +/* By default, unsupported encoding is an empty string. */ +char *unknown_encoding = NULL; + +static iso_map_type us_ascii_map [] = {{NULL, 0, 0}}; /* ASCII map is trivial */ + +/* Translation table between HTML and ISO Codes. The last item is + hopefully the Unicode. It might be possible that those Unicodes are + not correct, cause I didn't check them. kama */ +static iso_map_type iso8859_1_map [] = { + { "nbsp", 0xA0, 0x00A0 }, + { "iexcl", 0xA1, 0x00A1 }, + { "cent", 0xA2, 0x00A2 }, + { "pound", 0xA3, 0x00A3 }, + { "curren", 0xA4, 0x00A4 }, + { "yen", 0xA5, 0x00A5 }, + { "brkbar", 0xA6, 0x00A6 }, + { "sect", 0xA7, 0x00A7 }, + { "uml", 0xA8, 0x00A8 }, + { "copy", 0xA9, 0x00A9 }, + { "ordf", 0xAA, 0x00AA }, + { "laquo", 0xAB, 0x00AB }, + { "not", 0xAC, 0x00AC }, + { "shy", 0xAD, 0x00AD }, + { "reg", 0xAE, 0x00AE }, + { "hibar", 0xAF, 0x00AF }, + { "deg", 0xB0, 0x00B0 }, + { "plusmn", 0xB1, 0x00B1 }, + { "sup2", 0xB2, 0x00B2 }, + { "sup3", 0xB3, 0x00B3 }, + { "acute", 0xB4, 0x00B4 }, + { "micro", 0xB5, 0x00B5 }, + { "para", 0xB6, 0x00B6 }, + { "middot", 0xB7, 0x00B7 }, + { "cedil", 0xB8, 0x00B8 }, + { "sup1", 0xB9, 0x00B9 }, + { "ordm", 0xBA, 0x00BA }, + { "raquo", 0xBB, 0x00BB }, + { "frac14", 0xBC, 0x00BC }, + { "frac12", 0xBD, 0x00BD }, + { "frac34", 0xBE, 0x00BE }, + { "iquest", 0xBF, 0x00BF }, + { "Agrave", 0xC0, 0x00C0 }, + { "Aacute", 0xC1, 0x00C1 }, + { "Acirc", 0xC2, 0x00C2 }, + { "Atilde", 0xC3, 0x00C3 }, + { "Auml", 0xC4, 0x00C4 }, + { "Aring", 0xC5, 0x00C5 }, + { "AElig", 0xC6, 0x00C6 }, + { "Ccedil", 0xC7, 0x00C7 }, + { "Ccedil", 0xC7, 0x00C7 }, + { "Egrave", 0xC8, 0x00C8 }, + { "Eacute", 0xC9, 0x00C9 }, + { "Ecirc", 0xCA, 0x00CA }, + { "Euml", 0xCB, 0x00CB }, + { "Igrave", 0xCC, 0x00CC }, + { "Iacute", 0xCD, 0x00CD }, + { "Icirc", 0xCE, 0x00CE }, + { "Iuml", 0xCF, 0x00CF }, + { "ETH", 0xD0, 0x00D0 }, + { "Ntilde", 0xD1, 0x00D1 }, + { "Ograve", 0xD2, 0x00D2 }, + { "Oacute", 0xD3, 0x00D3 }, + { "Ocirc", 0xD4, 0x00D4 }, + { "Otilde", 0xD5, 0x00D5 }, + { "Ouml", 0xD6, 0x00D6 }, + { "times", 0xD7, 0x00D7 }, + { "Oslash", 0xD8, 0x00D8 }, + { "Ugrave", 0xD9, 0x00D9 }, + { "Uacute", 0xDA, 0x00DA }, + { "Ucirc", 0xDB, 0x00DB }, + { "Uuml", 0xDC, 0x00DC }, + { "Yacute", 0xDD, 0x00DD }, + { "THORN", 0xDE, 0x00DE }, + { "szlig", 0xDF, 0x00DF }, + { "agrave", 0xE0, 0x00E0 }, + { "aacute", 0xE1, 0x00E1 }, + { "acirc", 0xE2, 0x00E2 }, + { "atilde", 0xE3, 0x00E3 }, + { "auml", 0xE4, 0x00E4 }, + { "aring", 0xE5, 0x00E5 }, + { "aelig", 0xE6, 0x00E6 }, + { "ccedil", 0xE7, 0x00E7 }, + { "egrave", 0xE8, 0x00E8 }, + { "eacute", 0xE9, 0x00E9 }, + { "ecirc", 0xEA, 0x00EA }, + { "euml", 0xEB, 0x00EB }, + { "igrave", 0xEC, 0x00EC }, + { "iacute", 0xED, 0x00ED }, + { "icirc", 0xEE, 0x00EE }, + { "iuml", 0xEF, 0x00EF }, + { "eth", 0xF0, 0x00F0 }, + { "ntilde", 0xF1, 0x00F1 }, + { "ograve", 0xF2, 0x00F2 }, + { "oacute", 0xF3, 0x00F3 }, + { "ocirc", 0xF4, 0x00F4 }, + { "otilde", 0xF5, 0x00F5 }, + { "ouml", 0xF6, 0x00F6 }, + { "divide", 0xF7, 0x00F7 }, + { "oslash", 0xF8, 0x00F8 }, + { "ugrave", 0xF9, 0x00F9 }, + { "uacute", 0xFA, 0x00FA }, + { "ucirc", 0xFB, 0x00FB }, + { "uuml", 0xFC, 0x00FC }, + { "yacute", 0xFD, 0x00FD }, + { "thorn", 0xFE, 0x00FE }, + { "yuml", 0xFF, 0x00FF }, + { NULL, 0, 0 } +}; + + +/* ISO 8859-15, also known as Latin 9, differs from Latin 1 in only a + few positions. http://www.cs.tut.fi/~jkorpela/latin9.html has a good + explanation and listing, summarized here. The names are abbreviated + from the official Unicode names, to fit in a decent line length. + + code position + dec oct hex latin1 latin1 name latin9 latin9 name + + 164 0244 0xA4 U+00A4 currency symbol U+20AC euro sign + 166 0246 0xA6 U+00A6 broken bar U+0160 S with caron + 168 0250 0xA8 U+00A8 diaeresis U+0161 s with caron + 180 0264 0xB4 U+00B4 acute accent U+017D Z with caron + 184 0270 0xB8 U+00B8 cedilla U+017E z with caron + 188 0274 0xBC U+00BC fraction 1/4 U+0152 ligature OE + 189 0275 0xBD U+00BD fraction 1/2 U+0153 ligature oe + 190 0276 0xBE U+00BE fraction 3/4 U+0178 Y with diaeresis +*/ + +static iso_map_type iso8859_15_map [] = { + { "nbsp", 0xA0, 0x00A0 }, + { "iexcl", 0xA1, 0x00A1 }, + { "cent", 0xA2, 0x00A2 }, + { "pound", 0xA3, 0x00A3 }, + { "euro", 0xA4, 0x20AC }, + { "yen", 0xA5, 0x00A5 }, + { "Scaron", 0xA6, 0x0160 }, + { "sect", 0xA7, 0x00A7 }, + { "scaron", 0xA8, 0x0161 }, + { "copy", 0xA9, 0x00A9 }, + { "ordf", 0xAA, 0x00AA }, + { "laquo", 0xAB, 0x00AB }, + { "not", 0xAC, 0x00AC }, + { "shy", 0xAD, 0x00AD }, + { "reg", 0xAE, 0x00AE }, + { "hibar", 0xAF, 0x00AF }, + { "deg", 0xB0, 0x00B0 }, + { "plusmn", 0xB1, 0x00B1 }, + { "sup2", 0xB2, 0x00B2 }, + { "sup3", 0xB3, 0x00B3 }, + { "Zcaron", 0xB4, 0x017D }, + { "micro", 0xB5, 0x00B5 }, + { "para", 0xB6, 0x00B6 }, + { "middot", 0xB7, 0x00B7 }, + { "zcaron", 0xB8, 0x017E }, + { "sup1", 0xB9, 0x00B9 }, + { "ordm", 0xBA, 0x00BA }, + { "raquo", 0xBB, 0x00BB }, + { "OElig", 0xBC, 0x0152 }, + { "oelig", 0xBD, 0x0153 }, + { "Yuml", 0xBE, 0x0178 }, + { "iquest", 0xBF, 0x00BF }, + { "Agrave", 0xC0, 0x00C0 }, + { "Aacute", 0xC1, 0x00C1 }, + { "Acirc", 0xC2, 0x00C2 }, + { "Atilde", 0xC3, 0x00C3 }, + { "Auml", 0xC4, 0x00C4 }, + { "Aring", 0xC5, 0x00C5 }, + { "AElig", 0xC6, 0x00C6 }, + { "Ccedil", 0xC7, 0x00C7 }, + { "Ccedil", 0xC7, 0x00C7 }, + { "Egrave", 0xC8, 0x00C8 }, + { "Eacute", 0xC9, 0x00C9 }, + { "Ecirc", 0xCA, 0x00CA }, + { "Euml", 0xCB, 0x00CB }, + { "Igrave", 0xCC, 0x00CC }, + { "Iacute", 0xCD, 0x00CD }, + { "Icirc", 0xCE, 0x00CE }, + { "Iuml", 0xCF, 0x00CF }, + { "ETH", 0xD0, 0x00D0 }, + { "Ntilde", 0xD1, 0x00D1 }, + { "Ograve", 0xD2, 0x00D2 }, + { "Oacute", 0xD3, 0x00D3 }, + { "Ocirc", 0xD4, 0x00D4 }, + { "Otilde", 0xD5, 0x00D5 }, + { "Ouml", 0xD6, 0x00D6 }, + { "times", 0xD7, 0x00D7 }, + { "Oslash", 0xD8, 0x00D8 }, + { "Ugrave", 0xD9, 0x00D9 }, + { "Uacute", 0xDA, 0x00DA }, + { "Ucirc", 0xDB, 0x00DB }, + { "Uuml", 0xDC, 0x00DC }, + { "Yacute", 0xDD, 0x00DD }, + { "THORN", 0xDE, 0x00DE }, + { "szlig", 0xDF, 0x00DF }, + { "agrave", 0xE0, 0x00E0 }, + { "aacute", 0xE1, 0x00E1 }, + { "acirc", 0xE2, 0x00E2 }, + { "atilde", 0xE3, 0x00E3 }, + { "auml", 0xE4, 0x00E4 }, + { "aring", 0xE5, 0x00E5 }, + { "aelig", 0xE6, 0x00E6 }, + { "ccedil", 0xE7, 0x00E7 }, + { "egrave", 0xE8, 0x00E8 }, + { "eacute", 0xE9, 0x00E9 }, + { "ecirc", 0xEA, 0x00EA }, + { "euml", 0xEB, 0x00EB }, + { "igrave", 0xEC, 0x00EC }, + { "iacute", 0xED, 0x00ED }, + { "icirc", 0xEE, 0x00EE }, + { "iuml", 0xEF, 0x00EF }, + { "eth", 0xF0, 0x00F0 }, + { "ntilde", 0xF1, 0x00F1 }, + { "ograve", 0xF2, 0x00F2 }, + { "oacute", 0xF3, 0x00F3 }, + { "ocirc", 0xF4, 0x00F4 }, + { "otilde", 0xF5, 0x00F5 }, + { "ouml", 0xF6, 0x00F6 }, + { "divide", 0xF7, 0x00F7 }, + { "oslash", 0xF8, 0x00F8 }, + { "ugrave", 0xF9, 0x00F9 }, + { "uacute", 0xFA, 0x00FA }, + { "ucirc", 0xFB, 0x00FB }, + { "uuml", 0xFC, 0x00FC }, + { "yacute", 0xFD, 0x00FD }, + { "thorn", 0xFE, 0x00FE }, + { "yuml", 0xFF, 0x00FF }, + { NULL, 0, 0 } +}; + + + +/* Date: Mon, 31 Mar 2003 00:19:28 +0200 + From: Wojciech Polak <polak@gnu.org> +... + * Primary Polish site for ogonki is http://www.agh.edu.pl/ogonki/, + but it's only in Polish language (it has some interesting links). + + * A general site about ISO 8859-2 at http://nl.ijs.si/gnusl/cee/iso8859-2.html + + * ISO 8859-2 Character Set at http://nl.ijs.si/gnusl/cee/charset.html + This site provides almost all information about iso-8859-2, + including the character table!!! (must see!) + + * ISO 8859-2 and even HTML entities !!! (must see!) + http://people.ssh.fi/mtr/genscript/88592.txt + + * (minor) http://www.agh.edu.pl/ogonki/plchars.html + One more table, this time it includes even information about Polish + characters in Unicode. +*/ + +static iso_map_type iso8859_2_map [] = { + { "nbsp", 0xA0, 0x00A0 }, /* NO-BREAK SPACE */ + { "", 0xA1, 0x0104 }, /* LATIN CAPITAL LETTER A WITH OGONEK */ + { "", 0xA2, 0x02D8 }, /* BREVE */ + { "", 0xA3, 0x0141 }, /* LATIN CAPITAL LETTER L WITH STROKE */ + { "curren", 0xA4, 0x00A4 }, /* CURRENCY SIGN */ + { "", 0xA5, 0x013D }, /* LATIN CAPITAL LETTER L WITH CARON */ + { "", 0xA6, 0x015A }, /* LATIN CAPITAL LETTER S WITH ACUTE */ + { "sect", 0xA7, 0x00A7 }, /* SECTION SIGN */ + { "uml", 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 */ + { "shy", 0xAD, 0x00AD }, /* SOFT HYPHEN */ + { "", 0xAE, 0x017D }, /* LATIN CAPITAL LETTER Z WITH CARON */ + { "", 0xAF, 0x017B }, /* LATIN CAPITAL LETTER Z WITH DOT ABOVE */ + { "deg", 0xB0, 0x00B0 }, /* DEGREE SIGN */ + { "", 0xB1, 0x0105 }, /* LATIN SMALL LETTER A WITH OGONEK */ + { "", 0xB2, 0x02DB }, /* OGONEK */ + { "", 0xB3, 0x0142 }, /* LATIN SMALL LETTER L WITH STROKE */ + { "acute", 0xB4, 0x00B4 }, /* ACUTE ACCENT */ + { "", 0xB5, 0x013E }, /* LATIN SMALL LETTER L WITH CARON */ + { "", 0xB6, 0x015B }, /* LATIN SMALL LETTER S WITH ACUTE */ + { "", 0xB7, 0x02C7 }, /* CARON (Mandarin Chinese third tone) */ + { "cedil", 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 */ + { "times", 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 (German) */ + { "", 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 */ + { "divide", 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 (Mandarin Chinese light tone) */ + { NULL, 0, 0 } +}; + +encoding_type encoding_table[] = { + { no_encoding, "(no encoding)", NULL }, + { US_ASCII, "US-ASCII", us_ascii_map }, + { ISO_8859_1, "iso-8859-1", (iso_map_type *) iso8859_1_map }, + { ISO_8859_2, "iso-8859-2", (iso_map_type *) iso8859_2_map }, + { ISO_8859_3, "iso-8859-3", NULL }, + { ISO_8859_4, "iso-8859-4", NULL }, + { ISO_8859_5, "iso-8859-5", NULL }, + { ISO_8859_6, "iso-8859-6", NULL }, + { ISO_8859_7, "iso-8859-7", NULL }, + { ISO_8859_8, "iso-8859-8", NULL }, + { ISO_8859_9, "iso-8859-9", NULL }, + { ISO_8859_10, "iso-8859-10", NULL }, + { ISO_8859_11, "iso-8859-11", NULL }, + { ISO_8859_12, "iso-8859-12", NULL }, + { ISO_8859_13, "iso-8859-13", NULL }, + { ISO_8859_14, "iso-8859-14", NULL }, + { ISO_8859_15, "iso-8859-15", (iso_map_type *) iso8859_15_map }, + { last_encoding_code, NULL, NULL } +}; + + +language_type language_table[] = { + { aa, "aa", "Afar" }, + { ab, "ab", "Abkhazian" }, + { af, "af", "Afrikaans" }, + { am, "am", "Amharic" }, + { ar, "ar", "Arabic" }, + { as, "as", "Assamese" }, + { ay, "ay", "Aymara" }, + { az, "az", "Azerbaijani" }, + { ba, "ba", "Bashkir" }, + { be, "be", "Byelorussian" }, + { bg, "bg", "Bulgarian" }, + { bh, "bh", "Bihari" }, + { bi, "bi", "Bislama" }, + { bn, "bn", "Bengali; Bangla" }, + { bo, "bo", "Tibetan" }, + { br, "br", "Breton" }, + { ca, "ca", "Catalan" }, + { co, "co", "Corsican" }, + { cs, "cs", "Czech" }, + { cy, "cy", "Welsh" }, + { da, "da", "Danish" }, + { de, "de", "German" }, + { dz, "dz", "Bhutani" }, + { el, "el", "Greek" }, + { en, "en", "English" }, + { eo, "eo", "Esperanto" }, + { es, "es", "Spanish" }, + { et, "et", "Estonian" }, + { eu, "eu", "Basque" }, + { fa, "fa", "Persian" }, + { fi, "fi", "Finnish" }, + { fj, "fj", "Fiji" }, + { fo, "fo", "Faroese" }, + { fr, "fr", "French" }, + { fy, "fy", "Frisian" }, + { ga, "ga", "Irish" }, + { gd, "gd", "Scots Gaelic" }, + { gl, "gl", "Galician" }, + { gn, "gn", "Guarani" }, + { gu, "gu", "Gujarati" }, + { ha, "ha", "Hausa" }, + { he, "he", "Hebrew" } /* (formerly iw) */, + { hi, "hi", "Hindi" }, + { hr, "hr", "Croatian" }, + { hu, "hu", "Hungarian" }, + { hy, "hy", "Armenian" }, + { ia, "ia", "Interlingua" }, + { id, "id", "Indonesian" } /* (formerly in) */, + { ie, "ie", "Interlingue" }, + { ik, "ik", "Inupiak" }, + { is, "is", "Icelandic" }, + { it, "it", "Italian" }, + { iu, "iu", "Inuktitut" }, + { ja, "ja", "Japanese" }, + { jw, "jw", "Javanese" }, + { ka, "ka", "Georgian" }, + { kk, "kk", "Kazakh" }, + { kl, "kl", "Greenlandic" }, + { km, "km", "Cambodian" }, + { kn, "kn", "Kannada" }, + { ko, "ko", "Korean" }, + { ks, "ks", "Kashmiri" }, + { ku, "ku", "Kurdish" }, + { ky, "ky", "Kirghiz" }, + { la, "la", "Latin" }, + { ln, "ln", "Lingala" }, + { lo, "lo", "Laothian" }, + { lt, "lt", "Lithuanian" }, + { lv, "lv", "Latvian, Lettish" }, + { mg, "mg", "Malagasy" }, + { mi, "mi", "Maori" }, + { mk, "mk", "Macedonian" }, + { ml, "ml", "Malayalam" }, + { mn, "mn", "Mongolian" }, + { mo, "mo", "Moldavian" }, + { mr, "mr", "Marathi" }, + { ms, "ms", "Malay" }, + { mt, "mt", "Maltese" }, + { my, "my", "Burmese" }, + { na, "na", "Nauru" }, + { ne, "ne", "Nepali" }, + { nl, "nl", "Dutch" }, + { no, "no", "Norwegian" }, + { oc, "oc", "Occitan" }, + { om, "om", "(Afan) Oromo" }, + { or, "or", "Oriya" }, + { pa, "pa", "Punjabi" }, + { pl, "pl", "Polish" }, + { ps, "ps", "Pashto, Pushto" }, + { pt, "pt", "Portuguese" }, + { qu, "qu", "Quechua" }, + { rm, "rm", "Rhaeto-Romance" }, + { rn, "rn", "Kirundi" }, + { ro, "ro", "Romanian" }, + { ru, "ru", "Russian" }, + { rw, "rw", "Kinyarwanda" }, + { sa, "sa", "Sanskrit" }, + { sd, "sd", "Sindhi" }, + { sg, "sg", "Sangro" }, + { sh, "sh", "Serbo-Croatian" }, + { si, "si", "Sinhalese" }, + { sk, "sk", "Slovak" }, + { sl, "sl", "Slovenian" }, + { sm, "sm", "Samoan" }, + { sn, "sn", "Shona" }, + { so, "so", "Somali" }, + { sq, "sq", "Albanian" }, + { sr, "sr", "Serbian" }, + { ss, "ss", "Siswati" }, + { st, "st", "Sesotho" }, + { su, "su", "Sundanese" }, + { sv, "sv", "Swedish" }, + { sw, "sw", "Swahili" }, + { ta, "ta", "Tamil" }, + { te, "te", "Telugu" }, + { tg, "tg", "Tajik" }, + { th, "th", "Thai" }, + { ti, "ti", "Tigrinya" }, + { tk, "tk", "Turkmen" }, + { tl, "tl", "Tagalog" }, + { tn, "tn", "Setswana" }, + { to, "to", "Tonga" }, + { tr, "tr", "Turkish" }, + { ts, "ts", "Tsonga" }, + { tt, "tt", "Tatar" }, + { tw, "tw", "Twi" }, + { ug, "ug", "Uighur" }, + { uk, "uk", "Ukrainian" }, + { ur, "ur", "Urdu" }, + { uz, "uz", "Uzbek" }, + { vi, "vi", "Vietnamese" }, + { vo, "vo", "Volapuk" }, + { wo, "wo", "Wolof" }, + { xh, "xh", "Xhosa" }, + { yi, "yi", "Yiddish" } /* (formerly ji) */, + { yo, "yo", "Yoruba" }, + { za, "za", "Zhuang" }, + { zh, "zh", "Chinese" }, + { zu, "zu", "Zulu" }, + { last_language_code, NULL, NULL } +}; + +/* @documentlanguage. Maybe we'll do something useful with this in the + future. For now, we just recognize it. */ + +/* XML documents can make use of this data. Unfortunately, it clashes with + the structure currently used. So instead of enclosing content into + a language block, we just output an empty element. Anyways, a stream based + parser can make good use of it. */ +void +cm_documentlanguage (void) +{ + language_code_type c; + char *lang_arg; + + /* Read the line with the language code on it. */ + get_rest_of_line (0, &lang_arg); + + /* Linear search is fine these days. */ + for (c = aa; c != last_language_code; c++) + { + if (strcmp (lang_arg, language_table[c].abbrev) == 0) + { /* Set current language code. */ + language_code = c; + break; + } + } + + /* If we didn't find this code, complain. */ + if (c == last_language_code) + warning (_("%s is not a valid ISO 639 language code"), lang_arg); + + if (xml && !docbook) + { + xml_insert_element_with_attribute (DOCUMENTLANGUAGE, START, "xml:lang=\"%s\"", lang_arg); + xml_insert_element (DOCUMENTLANGUAGE, END); + } + + free (lang_arg); +} + + + +/* Search through the encoding table for the given character, returning + its equivalent. */ + +static int +cm_search_iso_map (char *html) +{ + int i; + iso_map_type *iso = encoding_table[document_encoding_code].isotab; + + /* If no conversion table for this encoding, quit. */ + if (!iso) + return -1; + + for (i = 0; iso[i].html; i++) + { + if (strcmp (html, iso[i].html) == 0) + return i; + } + + return -1; +} + + +/* @documentencoding. Set the translation table. */ + +void +cm_documentencoding (void) +{ + if (!handling_delayed_writes) + { + encoding_code_type enc; + char *enc_arg; + + /* This is ugly and probably needs to apply to other commands' + argument parsing as well. When we're doing @documentencoding, + we're generally in the frontmatter of the document, and so the. + expansion in html/xml/docbook would generally be the empty string. + (Because those modes wait until the first normal text of the + document to start outputting.) The result would thus be a warning + "unrecognized encoding name `'". Sigh. */ + int save_html = html; + int save_xml = xml; + + html = 0; + xml = 0; + get_rest_of_line (1, &enc_arg); + html = save_html; + xml = save_xml; + + /* See if we have this encoding. */ + for (enc = no_encoding+1; enc != last_encoding_code; enc++) + { + if (strcasecmp (enc_arg, encoding_table[enc].encname) == 0) + { + document_encoding_code = enc; + break; + } + } + + /* If we didn't find this code, complain. */ + if (enc == last_encoding_code) + { + warning (_("unrecognized encoding name `%s'"), enc_arg); + /* Let the previous one go. */ + if (unknown_encoding && *unknown_encoding) + free (unknown_encoding); + unknown_encoding = xstrdup (enc_arg); + } + + else if (encoding_table[document_encoding_code].isotab == NULL) + warning (_("sorry, encoding `%s' not supported"), enc_arg); + + free (enc_arg); + } + else if (xml) + { + char *encoding = current_document_encoding (); + + if (encoding && *encoding) + { + insert_string (" encoding=\""); + insert_string (encoding); + insert_string ("\""); + } + + free (encoding); + } +} + +char * +current_document_encoding (void) +{ + if (document_encoding_code != no_encoding) + return xstrdup (encoding_table[document_encoding_code].encname); + else if (unknown_encoding && *unknown_encoding) + return xstrdup (unknown_encoding); + else + return xstrdup (""); +} + + +/* If html or xml output, add &HTML_STR; to the output. If not html and + the user requested encoded output, add the real 8-bit character + corresponding to HTML_STR from the translation tables. Otherwise, + add INFO_STR. */ + +static void +add_encoded_char (char *html_str, char *info_str) +{ + if (html) + add_word_args ("&%s;", html_str); + else if (xml) + xml_insert_entity (html_str); + else if (enable_encoding) + { + /* Look for HTML_STR in the current translation table. */ + int rc = cm_search_iso_map (html_str); + if (rc >= 0) + /* We found it, add the real character. */ + add_char (encoding_table[document_encoding_code].isotab[rc].bytecode); + else + { /* We didn't find it, that seems bad. */ + warning (_("invalid encoded character `%s'"), html_str); + add_word (info_str); + } + } + else + add_word (info_str); +} + + + +/* Output an accent for HTML or XML. */ + +static void +cm_accent_generic_html (int arg, int start, int end, char *html_supported, + int single, int html_solo_standalone, char *html_solo) +{ + static int valid_html_accent; /* yikes */ + + if (arg == START) + { /* If HTML has good support for this character, use it. */ + if (strchr (html_supported, curchar ())) + { /* Yes; start with an ampersand. The character itself + will be added later in read_command (makeinfo.c). */ + int saved_escape_html = escape_html; + escape_html = 0; + valid_html_accent = 1; + add_char ('&'); + escape_html = saved_escape_html; + } + else + { /* @dotless{i} is not listed in html_supported but HTML entities + starting with `i' can be used, such as î. */ + int save_input_text_offset = input_text_offset; + char *accent_contents; + + get_until_in_braces ("\n", &accent_contents); + canon_white (accent_contents); + + if (strstr (accent_contents, "@dotless{i")) + { + add_word_args ("&%c", accent_contents[9]); + valid_html_accent = 1; + } + else + { + /* Search for @dotless{} wasn't successful, so rewind. */ + input_text_offset = save_input_text_offset; + valid_html_accent = 0; + if (html_solo_standalone) + { /* No special HTML support, so produce standalone char. */ + if (xml) + xml_insert_entity (html_solo); + else + add_word_args ("&%s;", html_solo); + } + else + /* If the html_solo does not exist as standalone character + (namely ˆ ` ˜), then we use + the single character version instead. */ + add_char (single); + } + + free (accent_contents); + } + } + else if (arg == END) + { /* Only if we saw a valid_html_accent can we use the full + HTML accent (umlaut, grave ...). */ + if (valid_html_accent) + { + add_word (html_solo); + add_char (';'); + } + } +} + + +static void +cm_accent_generic_no_headers (int arg, int start, int end, int single, + char *html_solo) +{ + if (arg == END) + { + if (no_encoding) + add_char (single); + else + { + int rc; + char *buffer = xmalloc (1 + strlen (html_solo) + 1); + buffer[0] = output_paragraph[end - 1]; + buffer[1] = 0; + strcat (buffer, html_solo); + + rc = cm_search_iso_map (buffer); + if (rc >= 0) + /* A little bit tricky ;-) + Here we replace the character which has + been inserted in read_command with + the value we have found in converting table + Does there exist a better way to do this? kama. */ + output_paragraph[end - 1] + = encoding_table[document_encoding_code].isotab[rc].bytecode; + else + { /* If we didn't find a translation for this character, + put the single instead. E.g., &Xuml; does not exist so X¨ + should be produced. */ + /* When the below warning is issued, an author has nothing + wrong in their document, let alone anything ``fixable'' + on their side. So it is commented out for now. */ + /* warning (_("%s is an invalid ISO code, using %c"), + buffer, single); */ + add_char (single); + } + + free (buffer); + } + } +} + + + +/* Accent commands that take explicit arguments and don't have any + special HTML support. */ + +void +cm_accent (int arg) +{ + int old_escape_html = escape_html; + escape_html = 0; + if (arg == START) + { + /* Must come first to avoid ambiguity with overdot. */ + if (strcmp (command, "udotaccent") == 0) /* underdot */ + add_char ('.'); + } + else if (arg == END) + { + if (strcmp (command, "=") == 0) /* macron */ + add_word ((html || xml) ? "¯" : "="); + else if (strcmp (command, "H") == 0) /* Hungarian umlaut */ + add_word ("''"); + else if (strcmp (command, "dotaccent") == 0) /* overdot */ + add_meta_char ('.'); + else if (strcmp (command, "ringaccent") == 0) /* ring */ + add_char ('*'); + else if (strcmp (command, "tieaccent") == 0) /* long tie */ + add_char ('['); + else if (strcmp (command, "u") == 0) /* breve */ + add_char ('('); + else if (strcmp (command, "ubaraccent") == 0) /* underbar */ + add_char ('_'); + else if (strcmp (command, "v") == 0) /* hacek/check */ + add_word ((html || xml) ? "<" : "<"); + } + escape_html = old_escape_html; +} + +/* Common routine for the accent characters that have support in HTML. + If the character being accented is in the HTML_SUPPORTED set, then + produce &CHTML_SOLO;, for example, Ä for an A-umlaut. If not in + HTML_SUPPORTED, just produce &HTML_SOLO;X for the best we can do with + at an X-umlaut. If not producing HTML, just use SINGLE, a + character such as " which is the best plain text representation we + can manage. If HTML_SOLO_STANDALONE is nonzero the given HTML_SOLO + exists as valid standalone character in HTML, e.g., ¨. */ + +static void +cm_accent_generic (int arg, int start, int end, char *html_supported, + int single, int html_solo_standalone, char *html_solo) +{ + /* Accentuating space characters makes no sense, so issue a warning. */ + if (arg == START && isspace (input_text[input_text_offset])) + warning ("Accent command `@%s' must not be followed by whitespace", + command); + + if (html || xml) + cm_accent_generic_html (arg, start, end, html_supported, + single, html_solo_standalone, html_solo); + else if (no_headers) + cm_accent_generic_no_headers (arg, start, end, single, html_solo); + else if (arg == END) + { + if (enable_encoding) + /* use 8-bit if available */ + cm_accent_generic_no_headers (arg, start, end, single, html_solo); + else + /* use regular character */ + add_char (single); + } +} + +void +cm_accent_umlaut (int arg, int start, int end) +{ + cm_accent_generic (arg, start, end, "aouAOUEeIiy", '"', 1, "uml"); +} + +void +cm_accent_acute (int arg, int start, int end) +{ + cm_accent_generic (arg, start, end, "AEIOUYaeiouy", '\'', 1, "acute"); +} + +void +cm_accent_cedilla (int arg, int start, int end) +{ + cm_accent_generic (arg, start, end, "Cc", ',', 1, "cedil"); +} + +void +cm_accent_hat (int arg, int start, int end) +{ + cm_accent_generic (arg, start, end, "AEIOUaeiou", '^', 0, "circ"); +} + +void +cm_accent_grave (int arg, int start, int end) +{ + cm_accent_generic (arg, start, end, "AEIOUaeiou", '`', 0, "grave"); +} + +void +cm_accent_tilde (int arg, int start, int end) +{ + cm_accent_generic (arg, start, end, "ANOano", '~', 0, "tilde"); +} + + + +/* Non-English letters/characters that don't insert themselves. */ +void +cm_special_char (int arg) +{ + int old_escape_html = escape_html; + escape_html = 0; + + if (arg == START) + { + if ((*command == 'L' || *command == 'l' + || *command == 'O' || *command == 'o') + && command[1] == 0) + { /* Lslash lslash Oslash oslash. + Lslash and lslash aren't supported in HTML. */ + if (command[0] == 'O') + add_encoded_char ("Oslash", "/O"); + else if (command[0] == 'o') + add_encoded_char ("oslash", "/o"); + else + add_word_args ("/%c", command[0]); + } + else if (strcmp (command, "exclamdown") == 0) + add_encoded_char ("iexcl", "!"); + else if (strcmp (command, "questiondown") == 0) + add_encoded_char ("iquest", "?"); + else if (strcmp (command, "euro") == 0) + /* http://www.cs.tut.fi/~jkorpela/html/euro.html suggests that + € degrades best in old browsers. */ + add_encoded_char ("euro", "Euro "); + else if (strcmp (command, "pounds") == 0) + add_encoded_char ("pound" , "#"); + else if (strcmp (command, "ordf") == 0) + add_encoded_char ("ordf" , "a"); + else if (strcmp (command, "ordm") == 0) + add_encoded_char ("ordm" , "o"); + else if (strcmp (command, "AE") == 0) + add_encoded_char ("AElig", command); + else if (strcmp (command, "ae") == 0) + add_encoded_char ("aelig", command); + else if (strcmp (command, "OE") == 0) + add_encoded_char ("OElig", command); + else if (strcmp (command, "oe") == 0) + add_encoded_char ("oelig", command); + else if (strcmp (command, "AA") == 0) + add_encoded_char ("Aring", command); + else if (strcmp (command, "aa") == 0) + add_encoded_char ("aring", command); + else if (strcmp (command, "ss") == 0) + add_encoded_char ("szlig", command); + else + line_error ("cm_special_char internal error: command=@%s", command); + } + escape_html = old_escape_html; +} + +/* Dotless i or j. */ +void +cm_dotless (int arg, int start, int end) +{ + if (arg == END) + { + xml_no_para --; + if (output_paragraph[start] != 'i' && output_paragraph[start] != 'j') + /* This error message isn't perfect if the argument is multiple + characters, but it doesn't seem worth getting right. */ + line_error (_("%c%s expects `i' or `j' as argument, not `%c'"), + COMMAND_PREFIX, command, output_paragraph[start]); + + else if (end - start != 1) + line_error (_("%c%s expects a single character `i' or `j' as argument"), + COMMAND_PREFIX, command); + + /* We've already inserted the `i' or `j', so nothing to do. */ + } + else + xml_no_para ++; +} |