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

Annotation of mandoc/chars.in, Revision 1.32

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

CVSweb