[BACK]Return to chars.in CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/chars.in, Revision 1.28

1.28    ! kristaps    1: /*     $Id: chars.in,v 1.27 2010/07/17 09:21:39 kristaps Exp $ */
1.1       kristaps    2: /*
1.25      kristaps    3:  * Copyright (c) 2009 Kristaps Dzonsons <kristaps@bsd.lv>
1.1       kristaps    4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the above
                      7:  * copyright notice and this permission notice appear in all copies.
                      8:  *
                      9:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     12:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     13:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     14:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     15:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     16:  */
                     17:
                     18: /*
                     19:  * The ASCII translation tables.  STRING corresponds to predefined
                     20:  * strings (cf. mdoc_samples.7 and tmac/mdoc/doc-nroff).  CHAR
                     21:  * corresponds to special characters (cf. groff_char.7).  BOTH contains
                     22:  * sequences that are equivalent in both STRING and CHAR.
                     23:  *
                     24:  * Either way, the left-hand side corresponds to the input sequence (\x,
                     25:  * \(xx, \*(xx and so on) whose length is listed second element.  The
                     26:  * right-hand side is what's produced by the front-end, with the fourth
                     27:  * element being its length.
                     28:  *
                     29:  * XXX - C-escape strings!
                     30:  * XXX - update LINES_MAX if adding more!
                     31:  */
                     32:
1.19      kristaps   33: /* Non-breaking, non-collapsing space uses unit separator. */
1.23      schwarze   34: static const char ascii_nbrsp[2] = { ASCII_NBRSP, 0 };
1.19      kristaps   35:
                     36: CHAR_TBL_START
                     37:
1.17      kristaps   38: /* Spacing. */
1.27      kristaps   39: CHAR("c",                      "",             0,      -1)
                     40: CHAR("0",                      " ",            1,      8194)
1.28    ! kristaps   41: CHAR(" ",                      ascii_nbrsp,    1,      160)
1.27      kristaps   42: CHAR("~",                      ascii_nbrsp,    1,      160)
                     43: CHAR("%",                      "",             0,      -1)
                     44: CHAR("&",                      "",             0,      -1)
                     45: CHAR("^",                      "",             0,      -1)
                     46: CHAR("|",                      "",             0,      -1)
                     47: CHAR("}",                      "",             0,      -1)
1.1       kristaps   48:
1.12      kristaps   49: /* Accents. */
1.27      kristaps   50: CHAR("a\"",                    "\"",           1,      779)
                     51: CHAR("a-",                     "-",            1,      175)
                     52: CHAR("a.",                     ".",            1,      729)
                     53: CHAR("a^",                     "^",            1,      770)
                     54: BOTH("\'",                     "\'",           1,      769)
                     55: BOTH("aa",                     "\'",           1,      769)
                     56: BOTH("ga",                     "`",            1,      768)
                     57: BOTH("`",                      "`",            1,      768)
                     58: CHAR("ab",                     "`",            1,      774)
                     59: CHAR("ac",                     ",",            1,      807)
                     60: CHAR("ad",                     "\"",           1,      776)
                     61: CHAR("ah",                     "v",            1,      711)
                     62: CHAR("ao",                     "o",            1,      730)
                     63: CHAR("a~",                     "~",            1,      771)
                     64: CHAR("ho",                     ",",            1,      808)
                     65: CHAR("ha",                     "^",            1,      94)
                     66: CHAR("ti",                     "~",            1,      126)
1.11      kristaps   67:
1.13      kristaps   68: /* Quotes. */
1.27      kristaps   69: CHAR("Bq",                     ",,",           2,      8222)
                     70: CHAR("bq",                     ",",            1,      8218)
                     71: BOTH("lq",                     "``",           2,      8220)
                     72: BOTH("rq",                     "\'\'",         2,      8221)
                     73: CHAR("oq",                     "`",            1,      8216)
                     74: CHAR("cq",                     "\'",           1,      8217)
                     75: CHAR("aq",                     "\'",           1,      39)
                     76: CHAR("dq",                     "\"",           1,      34)
                     77: CHAR("Fo",                     "<<",           2,      171)
                     78: CHAR("Fc",                     ">>",           2,      187)
                     79: CHAR("fo",                     "<",            1,      8249)
                     80: CHAR("fc",                     ">",            1,      8250)
1.13      kristaps   81:
1.14      kristaps   82: /* Brackets. */
1.27      kristaps   83: CHAR("lB",                     "[",            1,      91)
                     84: CHAR("rB",                     "]",            1,      93)
                     85: CHAR("lC",                     "{",            1,      123)
                     86: CHAR("rC",                     "}",            1,      125)
                     87: CHAR("la",                     "<",            1,      10216) /* FIXME: 60 */
                     88: CHAR("ra",                     ">",            1,      10217) /* FIXME: 62 */
                     89: CHAR("bv",                     "|",            1,      9130)
                     90: CHAR("braceex",                        "|",            1,      9130)
                     91: CHAR("bracketlefttp",          "|",            1,      9121)
                     92: CHAR("bracketleftbp",          "|",            1,      9123)
                     93: CHAR("bracketleftex",          "|",            1,      9122)
                     94: CHAR("bracketrighttp",         "|",            1,      9124)
                     95: CHAR("bracketrightbp",         "|",            1,      9126)
                     96: CHAR("bracketrightex",         "|",            1,      9125)
                     97: CHAR("lt",                     ",-",           2,      9127)
                     98: CHAR("bracelefttp",            ",-",           2,      9127)
                     99: CHAR("lk",                     "{",            1,      9128)
                    100: CHAR("braceleftmid",           "{",            1,      9128)
                    101: CHAR("lb",                     ",-",           2,      9129)
                    102: CHAR("braceleftbp",            "`-",           2,      9129)
                    103: CHAR("braceleftex",            "|",            1,      9130)
                    104: CHAR("rt",                     "-.",           2,      9131)
                    105: CHAR("bracerighttp",           "-.",           2,      9131)
                    106: CHAR("rk",                     "}",            1,      9132)
                    107: CHAR("bracerightmid",          "}",            1,      9132)
                    108: CHAR("rb",                     "-\'",          2,      9133)
                    109: CHAR("bracerightbp",           "-\'",          2,      9133)
                    110: CHAR("bracerightex",           "|",            1,      9130)
                    111: CHAR("parenlefttp",            "/",            1,      9115)
                    112: CHAR("parenleftbp",            "\\",           1,      9117)
                    113: CHAR("parenleftex",            "|",            1,      9116)
                    114: CHAR("parenrighttp",           "\\",           1,      9118)
                    115: CHAR("parenrightbp",           "/",            1,      9120)
                    116: CHAR("parenrightex",           "|",            1,      9119)
1.1       kristaps  117:
1.11      kristaps  118: /* Greek characters. */
1.27      kristaps  119: CHAR("*A",                     "A",            1,      913)
                    120: CHAR("*B",                     "B",            1,      914)
                    121: CHAR("*G",                     "|",            1,      915)
                    122: CHAR("*D",                     "/\\",          2,      916)
                    123: CHAR("*E",                     "E",            1,      917)
                    124: CHAR("*Z",                     "Z",            1,      918)
                    125: CHAR("*Y",                     "H",            1,      919)
                    126: CHAR("*H",                     "O",            1,      920)
                    127: CHAR("*I",                     "I",            1,      921)
                    128: CHAR("*K",                     "K",            1,      922)
                    129: CHAR("*L",                     "/\\",          2,      923)
                    130: CHAR("*M",                     "M",            1,      924)
                    131: CHAR("*N",                     "N",            1,      925)
                    132: CHAR("*C",                     "H",            1,      926)
                    133: CHAR("*O",                     "O",            1,      927)
                    134: CHAR("*P",                     "TT",           2,      928)
                    135: CHAR("*R",                     "P",            1,      929)
                    136: CHAR("*S",                     ">",            1,      931)
                    137: CHAR("*T",                     "T",            1,      932)
                    138: CHAR("*U",                     "Y",            1,      933)
                    139: CHAR("*F",                     "O_",           1,      934)
                    140: CHAR("*X",                     "X",            1,      935)
                    141: CHAR("*Q",                     "Y",            1,      936)
                    142: CHAR("*W",                     "O",            1,      937)
                    143: CHAR("*a",                     "a",            1,      945)
                    144: CHAR("*b",                     "B",            1,      946)
                    145: CHAR("*g",                     "y",            1,      947)
                    146: CHAR("*d",                     "d",            1,      948)
                    147: CHAR("*e",                     "e",            1,      949)
                    148: CHAR("*z",                     "C",            1,      950)
                    149: CHAR("*y",                     "n",            1,      951)
                    150: CHAR("*h",                     "0",            1,      952)
                    151: CHAR("*i",                     "i",            1,      953)
                    152: CHAR("*k",                     "k",            1,      954)
                    153: CHAR("*l",                     "\\",           1,      955)
                    154: CHAR("*m",                     "u",            1,      956)
                    155: CHAR("*n",                     "v",            1,      957)
                    156: CHAR("*c",                     "E",            1,      958)
                    157: CHAR("*o",                     "o",            1,      959)
                    158: CHAR("*p",                     "n",            1,      960)
                    159: CHAR("*r",                     "p",            1,      961)
                    160: CHAR("*s",                     "o",            1,      963)
                    161: CHAR("*t",                     "t",            1,      964)
                    162: CHAR("*u",                     "u",            1,      965)
                    163: CHAR("*f",                     "o",            1,      981)
                    164: CHAR("*x",                     "x",            1,      967)
                    165: CHAR("*q",                     "u",            1,      968)
                    166: CHAR("*w",                     "w",            1,      969)
                    167: CHAR("+h",                     "0",            1,      977)
                    168: CHAR("+f",                     "o",            1,      966)
                    169: CHAR("+p",                     "w",            1,      982)
                    170: CHAR("+e",                     "e",            1,      1013)
                    171: CHAR("ts",                     "s",            1,      962)
1.11      kristaps  172:
1.17      kristaps  173: /* Accented letters. */
1.27      kristaps  174: CHAR(",C",                     "C",            1,      199)
                    175: CHAR(",c",                     "c",            1,      231)
                    176: CHAR("/L",                     "L",            1,      321)
                    177: CHAR("/O",                     "O",            1,      216)
                    178: CHAR("/l",                     "l",            1,      322)
                    179: CHAR("/o",                     "o",            1,      248)
                    180: CHAR("oA",                     "A",            1,      197)
                    181: CHAR("oa",                     "a",            1,      229)
                    182: CHAR(":A",                     "A",            1,      196)
                    183: CHAR(":E",                     "E",            1,      203)
                    184: CHAR(":I",                     "I",            1,      207)
                    185: CHAR(":O",                     "O",            1,      214)
                    186: CHAR(":U",                     "U",            1,      220)
                    187: CHAR(":a",                     "a",            1,      228)
                    188: CHAR(":e",                     "e",            1,      235)
                    189: CHAR(":i",                     "i",            1,      239)
                    190: CHAR(":o",                     "o",            1,      245)
                    191: CHAR(":u",                     "u",            1,      252)
                    192: CHAR(":y",                     "y",            1,      255)
                    193: CHAR("\'A",                    "A",            1,      193)
                    194: CHAR("\'E",                    "E",            1,      201)
                    195: CHAR("\'I",                    "I",            1,      205)
                    196: CHAR("\'O",                    "O",            1,      211)
                    197: CHAR("\'U",                    "U",            1,      218)
                    198: CHAR("\'a",                    "a",            1,      225)
                    199: CHAR("\'e",                    "e",            1,      233)
                    200: CHAR("\'i",                    "i",            1,      237)
                    201: CHAR("\'o",                    "o",            1,      243)
                    202: CHAR("\'u",                    "u",            1,      250)
                    203: CHAR("^A",                     "A",            1,      194)
                    204: CHAR("^E",                     "E",            1,      202)
                    205: CHAR("^I",                     "I",            1,      206)
                    206: CHAR("^O",                     "O",            1,      212)
                    207: CHAR("^U",                     "U",            1,      219)
                    208: CHAR("^a",                     "a",            1,      226)
                    209: CHAR("^e",                     "e",            1,      234)
                    210: CHAR("^i",                     "i",            1,      238)
                    211: CHAR("^o",                     "o",            1,      244)
                    212: CHAR("^u",                     "u",            1,      251)
                    213: CHAR("`A",                     "A",            1,      192)
                    214: CHAR("`E",                     "E",            1,      200)
                    215: CHAR("`I",                     "I",            1,      204)
                    216: CHAR("`O",                     "O",            1,      210)
                    217: CHAR("`U",                     "U",            1,      217)
                    218: CHAR("`a",                     "a",            1,      224)
                    219: CHAR("`e",                     "e",            1,      232)
                    220: CHAR("`i",                     "i",            1,      236)
                    221: CHAR("`o",                     "o",            1,      242)
                    222: CHAR("`u",                     "u",            1,      249)
                    223: CHAR("~A",                     "A",            1,      195)
                    224: CHAR("~N",                     "N",            1,      209)
                    225: CHAR("~O",                     "O",            1,      213)
                    226: CHAR("~a",                     "a",            1,      227)
                    227: CHAR("~n",                     "n",            1,      241)
                    228: CHAR("~o",                     "o",            1,      245)
1.11      kristaps  229:
1.17      kristaps  230: /* Arrows and lines. */
1.27      kristaps  231: CHAR("<-",                     "<-",           2,      8592)
                    232: CHAR("->",                     "->",           2,      8594)
                    233: CHAR("<>",                     "<>",           2,      8596)
                    234: CHAR("da",                     "v",            1,      8595)
                    235: BOTH("ua",                     "^",            1,      8593)
                    236: BOTH("va",                     "^v",           2,      8597)
                    237: CHAR("lA",                     "<=",           2,      8656)
                    238: CHAR("rA",                     "=>",           2,      8658)
                    239: CHAR("hA",                     "<=>",          3,      8660)
                    240: CHAR("dA",                     "v",            1,      8659)
                    241: CHAR("uA",                     "^",            1,      8657)
                    242: CHAR("vA",                     "^=v",          3,      8661)
1.11      kristaps  243:
                    244: /* Logic. */
1.27      kristaps  245: CHAR("AN",                     "^",            1,      8743)
                    246: CHAR("OR",                     "v",            1,      8744)
                    247: CHAR("no",                     "~",            1,      172)
                    248: CHAR("tno",                    "~",            1,      172)
                    249: CHAR("te",                     "3",            1,      8707)
                    250: CHAR("fa",                     "V",            1,      8704)
                    251: CHAR("st",                     "-)",           2,      8715)
                    252: CHAR("tf",                     ".:.",          3,      8756)
                    253: CHAR("3d",                     ".:.",          3,      8756)
                    254: CHAR("or",                     "|",            1,      124)
1.11      kristaps  255:
                    256: /* Mathematicals. */
1.27      kristaps  257: CHAR("pl",                     "+",            1,      43)
                    258: CHAR("mi",                     "-",            1,      8722)
                    259: CHAR("-",                      "-",            1,      45)
                    260: CHAR("-+",                     "-+",           2,      8723)
                    261: CHAR("+-",                     "+-",           2,      177)
                    262: CHAR("t+-",                    "+-",           2,      177)
                    263: CHAR("pc",                     ".",            1,      183)
                    264: CHAR("md",                     ".",            1,      8901)
                    265: CHAR("mu",                     "x",            1,      215)
                    266: CHAR("tmu",                    "x",            1,      215)
                    267: CHAR("c*",                     "x",            1,      8855)
                    268: CHAR("c+",                     "+",            1,      8853)
                    269: CHAR("di",                     "-:-",          3,      247)
                    270: CHAR("tdi",                    "-:-",          3,      247)
                    271: CHAR("f/",                     "/",            1,      8260)
                    272: CHAR("**",                     "*",            1,      8727)
                    273: BOTH("<=",                     "<=",           2,      8804)
                    274: BOTH(">=",                     ">=",           2,      8805)
                    275: CHAR("<<",                     "<<",           2,      8810)
                    276: CHAR(">>",                     ">>",           2,      8811)
                    277: CHAR("eq",                     "=",            1,      61)
                    278: CHAR("!=",                     "!=",           2,      8800)
                    279: CHAR("==",                     "==",           2,      8801)
                    280: CHAR("ne",                     "!==",          3,      8802)
                    281: CHAR("=~",                     "=~",           2,      8773)
                    282: CHAR("-~",                     "-~",           2,      8771)
                    283: CHAR("ap",                     "~",            1,      8764)
                    284: CHAR("~~",                     "~~",           2,      8776)
                    285: CHAR("~=",                     "~=",           2,      8780)
                    286: CHAR("pt",                     "oc",           2,      8733)
                    287: CHAR("es",                     "{}",           2,      8709)
                    288: CHAR("mo",                     "E",            1,      8712)
                    289: CHAR("nm",                     "!E",           2,      8713)
                    290: CHAR("sb",                     "(=",           2,      8834)
                    291: CHAR("nb",                     "(!=",          3,      8836)
                    292: CHAR("sp",                     "=)",           2,      8835)
                    293: CHAR("nc",                     "!=)",          3,      8837)
                    294: CHAR("ib",                     "(=",           2,      8838)
                    295: CHAR("ip",                     "=)",           2,      8839)
                    296: CHAR("ca",                     "(^)",          3,      8745)
                    297: CHAR("cu",                     "U",            1,      8746)
                    298: CHAR("/_",                     "/_",           2,      8736)
                    299: CHAR("pp",                     "_|_",          3,      8869)
                    300: CHAR("is",                     "I",            1,      8747)
                    301: CHAR("integral",               "I",            1,      8747)
                    302: CHAR("sum",                    "E",            1,      8721)
                    303: CHAR("product",                        "TT",           2,      8719)
                    304: CHAR("coproduct",              "U",            1,      8720)
                    305: CHAR("gr",                     "V",            1,      8711)
                    306: CHAR("sr",                     "\\/",          2,      8730)
                    307: CHAR("sqrt",                   "\\/",          2,      8730)
                    308: CHAR("lc",                     "|~",           2,      8968)
                    309: CHAR("rc",                     "~|",           2,      8969)
                    310: CHAR("lf",                     "|_",           2,      8970)
                    311: CHAR("rf",                     "_|",           2,      8971)
                    312: CHAR("if",                     "oo",           2,      8734)
                    313: CHAR("Ah",                     "N",            1,      8501)
                    314: CHAR("Im",                     "I",            1,      8465)
                    315: CHAR("Re",                     "R",            1,      8476)
                    316: CHAR("pd",                     "a",            1,      8706)
                    317: CHAR("-h",                     "/h",           2,      8463)
1.11      kristaps  318:
1.15      kristaps  319: /* Ligatures. */
1.27      kristaps  320: CHAR("ff",                     "ff",           2,      64256)
                    321: CHAR("fi",                     "fi",           2,      64257)
                    322: CHAR("fl",                     "fl",           2,      64258)
                    323: CHAR("Fi",                     "ffi",          3,      64259)
                    324: CHAR("Fl",                     "ffl",          3,      64260)
                    325: BOTH("AE",                     "AE",           2,      198)
                    326: BOTH("ae",                     "ae",           2,      230)
                    327: CHAR("OE",                     "OE",           2,      338)
                    328: CHAR("oe",                     "oe",           2,      339)
                    329: CHAR("ss",                     "ss",           2,      223)
                    330: CHAR("IJ",                     "IJ",           2,      306)
                    331: CHAR("ij",                     "ij",           2,      307)
1.15      kristaps  332:
                    333: /* Special letters. */
1.27      kristaps  334: CHAR("-D",                     "D",            1,      208)
                    335: CHAR("Sd",                     "o",            1,      240)
                    336: CHAR("TP",                     "b",            1,      222)
                    337: CHAR("Tp",                     "b",            1,      254)
                    338: CHAR(".i",                     "i",            1,      305)
                    339: CHAR(".j",                     "j",            1,      567)
1.16      kristaps  340:
                    341: /* Currency. */
1.27      kristaps  342: CHAR("Do",                     "$",            1,      36)
                    343: CHAR("ct",                     "c",            1,      162)
                    344: CHAR("Eu",                     "EUR",          3,      8364)
                    345: CHAR("eu",                     "EUR",          3,      8364)
                    346: CHAR("Ye",                     "Y",            1,      165)
                    347: CHAR("Po",                     "L",            1,      163)
                    348: CHAR("Cs",                     "x",            1,      164)
                    349: CHAR("Fn",                     "f",            1,      402)
1.21      kristaps  350:
                    351: /* pod2man holdovers. */
1.27      kristaps  352: STRING("--",                   "--",           2,      8212)
                    353: STRING("PI",                   "pi",           2,      960)
                    354: STRING("L\"",                  "``",           2,      8220)
                    355: STRING("R\"",                  "\'\'",         2,      8221)
                    356: STRING("C+",                   "C++",          3,      0)
                    357: STRING("C`",                   "`",            1,      8216)
                    358: STRING("C\'",                  "\'",           1,      8217)
                    359: STRING("Aq",                   "\'",           1,      39)
                    360: STRING("^",                    "^",            1,      94)
                    361: STRING(",",                    ",",            1,      44)
                    362: STRING("~",                    "~",            1,      126)
                    363: STRING("/",                    "/",            1,      47)
                    364: STRING(":",                    "\"",           1,      776)
                    365: STRING("8",                    "B",            1,      946)
                    366: STRING("o",                    "o",            1,      176)
                    367: STRING("D-",                   "D",            1,      208)
                    368: STRING("d-",                   "o",            1,      240)
                    369: STRING("Th",                   "b",            1,      222)
                    370: STRING("th",                   "b",            1,      254)
1.17      kristaps  371:
                    372: /* Old style. */
1.27      kristaps  373: STRING("Am",                   "&",            1,      38)
                    374: STRING("Ba",                   "|",            1,      124)
                    375: STRING("Ge",                   ">=",           2,      8805)
                    376: STRING("Gt",                   ">",            1,      62)
                    377: STRING("If",                   "infinity",     8,      0)
                    378: STRING("Le",                   "<=",           2,      8804)
                    379: STRING("Lq",                   "``",           2,      8220)
                    380: STRING("Lt",                   "<",            1,      60)
                    381: STRING("Na",                   "NaN",          3,      0)
                    382: STRING("Ne",                   "!=",           2,      8800)
                    383: STRING("Pi",                   "pi",           2,      960)
                    384: STRING("Pm",                   "+-",           2,      177)
                    385: STRING("R",                    "(R)",          3,      174)
                    386: STRING("Rq",                   "\'\'",         2,      8221)
                    387: STRING("Tm",                   "tm",           2,      8482)
                    388: STRING("left-bracket",         "[",            1,      91)
                    389: STRING("left-parenthesis",     "(",            1,      40)
                    390: STRING("left-singlequote",     "`",            1,      8216)
                    391: STRING("lp",                   "(",            1,      40)
                    392: STRING("q",                    "\"",           1,      34)
                    393: STRING("quote-left",           "`",            1,      8216)
                    394: STRING("quote-right",          "\'",           1,      8217)
                    395: STRING("right-bracket",                "]",            1,      93)
                    396: STRING("right-parenthesis",    ")",            1,      41)
                    397: STRING("right-singlequote",    "\'",           1,      8217)
                    398: STRING("rp",                   ")",            1,      41)
1.17      kristaps  399:
                    400: /* Lines. */
1.27      kristaps  401: CHAR("ba",                     "|",            1,      124)
                    402: CHAR("br",                     "|",            1,      9474)
                    403: CHAR("ul",                     "_",            1,      95)
                    404: CHAR("rl",                     "-",            1,      8254)
                    405: CHAR("bb",                     "|",            1,      166)
                    406: CHAR("sl",                     "/",            1,      47)
                    407: CHAR("rs",                     "\\",           1,      92)
1.17      kristaps  408:
                    409: /* Text markers. */
1.27      kristaps  410: CHAR("ci",                     "o",            1,      9675)
                    411: CHAR("bu",                     "o",            1,      8226)
                    412: CHAR("dd",                     "=",            1,      8225)
                    413: CHAR("dg",                     "-",            1,      8224)
                    414: CHAR("lz",                     "<>",           2,      9674)
                    415: CHAR("sq",                     "[]",           2,      9633)
                    416: CHAR("ps",                     "9|",           2,      182)
                    417: CHAR("sc",                     "S",            1,      167)
                    418: CHAR("lh",                     "<=",           2,      9756)
                    419: CHAR("rh",                     "=>",           2,      9758)
                    420: CHAR("at",                     "@",            1,      64)
                    421: CHAR("sh",                     "#",            1,      35)
                    422: CHAR("CR",                     "_|",           2,      8629)
                    423: CHAR("OK",                     "\\/",          2,      10003)
1.17      kristaps  424:
                    425: /* Legal symbols. */
1.27      kristaps  426: CHAR("co",                     "(C)",          3,      169)
                    427: CHAR("rg",                     "(R)",          3,      174)
                    428: CHAR("tm",                     "tm",           2,      8482)
1.17      kristaps  429:
                    430: /* Punctuation. */
1.27      kristaps  431: CHAR(".",                      ".",            1,      46)
                    432: CHAR("r!",                     "i",            1,      161)
                    433: CHAR("r?",                     "c",            1,      191)
                    434: CHAR("em",                     "--",           2,      8212)
                    435: CHAR("en",                     "-",            1,      8211)
                    436: CHAR("hy",                     "-",            1,      8208)
                    437: CHAR("e",                      "\\",           1,      92)
1.17      kristaps  438:
                    439: /* Units. */
1.27      kristaps  440: CHAR("de",                     "o",            1,      176)
                    441: CHAR("%0",                     "%o",           2,      8240)
                    442: CHAR("fm",                     "\'",           1,      8242)
                    443: CHAR("sd",                     "\"",           1,      8243)
                    444: CHAR("mc",                     "mu",           2,      181)
1.19      kristaps  445:
                    446: CHAR_TBL_END

CVSweb