From 293f5bf8800478a08e08231a50430590b61b40d9 Mon Sep 17 00:00:00 2001 From: Alexey Prokhin Date: Sun, 20 Feb 2011 19:00:52 +0300 Subject: [PATCH] Updated to dmdfe 2.052 --- .hgignore | 2 + dmd2/aggregate.h | 1 + dmd2/argtypes.c | 14 +- dmd2/arrayop.c | 4 +- dmd2/attrib.c | 1 + dmd2/cast.c | 27 +- dmd2/class.c | 7 + dmd2/constfold.c | 16 +- dmd2/declaration.c | 1 + dmd2/declaration.h | 4 +- dmd2/doc.c | 36 +- dmd2/doc.h | 1 + dmd2/dsymbol.c | 3 +- dmd2/entity.c | 3519 ++++++++++++++++++++++++++++--------------- dmd2/expression.c | 66 +- dmd2/func.c | 133 +- dmd2/imphint.c | 2 +- dmd2/interpret.c | 10 +- dmd2/mars.c | 6 +- dmd2/mtype.c | 43 +- dmd2/mtype.h | 1 + dmd2/parse.c | 12 +- dmd2/parse.h | 2 +- dmd2/rmem.h | 16 + dmd2/root/speller.c | 4 + dmd2/statement.c | 44 +- dmd2/template.c | 59 +- dmd2/template.h | 1 + dmd2/traits.c | 10 +- dmd2/utf.c | 91 ++ dmd2/utf.h | 11 +- 31 files changed, 2753 insertions(+), 1394 deletions(-) create mode 100644 dmd2/rmem.h diff --git a/.hgignore b/.hgignore index 2c48dc63..083d8a63 100644 --- a/.hgignore +++ b/.hgignore @@ -18,6 +18,8 @@ cmake_install.cmake .DS_Store CMakeLists.txt.user* .directory +druntime +phobos druntime-orig phobos-orig diff --git a/dmd2/aggregate.h b/dmd2/aggregate.h index 979f3f3c..cd9d44cd 100644 --- a/dmd2/aggregate.h +++ b/dmd2/aggregate.h @@ -231,6 +231,7 @@ struct ClassDeclaration : AggregateDeclaration { static ClassDeclaration *object; static ClassDeclaration *classinfo; + static ClassDeclaration *throwable; ClassDeclaration *baseClass; // NULL only if this is Object #if DMDV1 diff --git a/dmd2/argtypes.c b/dmd2/argtypes.c index 422539db..8e6b533d 100644 --- a/dmd2/argtypes.c +++ b/dmd2/argtypes.c @@ -155,7 +155,19 @@ TypeTuple *TypeDelegate::toArgTypes() TypeTuple *TypeStruct::toArgTypes() { - return new TypeTuple(); // pass on the stack for efficiency + int sz = size(0); + switch (sz) + { + case 1: + return new TypeTuple(Type::tint8); + case 2: + return new TypeTuple(Type::tint16); + case 4: + return new TypeTuple(Type::tint32); + case 8: + return new TypeTuple(Type::tint64); + } + return new TypeTuple(); // pass on the stack } TypeTuple *TypeEnum::toArgTypes() diff --git a/dmd2/arrayop.c b/dmd2/arrayop.c index b399fa97..03336182 100644 --- a/dmd2/arrayop.c +++ b/dmd2/arrayop.c @@ -356,9 +356,7 @@ Expression *BinExp::arrayOp(Scope *sc) fd->fbody = fbody; fd->protection = PROTpublic; fd->linkage = LINKd; - - // special attention for array ops - fd->isArrayOp = true; + fd->isArrayOp = 1; sc->module->importedFrom->members->push(fd); diff --git a/dmd2/attrib.c b/dmd2/attrib.c index 2556a859..78eddef7 100644 --- a/dmd2/attrib.c +++ b/dmd2/attrib.c @@ -206,6 +206,7 @@ void AttribDeclaration::inlineScan() void AttribDeclaration::addComment(unsigned char *comment) { + //printf("AttribDeclaration::addComment %s\n", comment); if (comment) { Dsymbols *d = include(NULL, NULL); diff --git a/dmd2/cast.c b/dmd2/cast.c index bf0fffe2..ff5b1aae 100644 --- a/dmd2/cast.c +++ b/dmd2/cast.c @@ -426,12 +426,7 @@ MATCH StructLiteralExp::implicitConvTo(Type *t) for (int i = 0; i < elements->dim; i++) { Expression *e = (Expression *)elements->data[i]; Type *te = e->type; - if (t->mod == 0) - te = te->mutableOf(); - else - { assert(t->mod == MODimmutable); - te = te->invariantOf(); - } + te = te->castMod(t->mod); MATCH m2 = e->implicitConvTo(te); //printf("\t%s => %s, match = %d\n", e->toChars(), te->toChars(), m2); if (m2 < m) @@ -827,9 +822,17 @@ Expression *Expression::castTo(Scope *sc, Type *t) } else if (typeb->ty == Tclass) { TypeClass *ts = (TypeClass *)typeb; - if (tb->ty != Tclass && - ts->sym->aliasthis) - { /* Forward the cast to our alias this member, rewrite to: + if (ts->sym->aliasthis) + { + if (tb->ty == Tclass) + { + ClassDeclaration *cdfrom = typeb->isClassHandle(); + ClassDeclaration *cdto = tb->isClassHandle(); + int offset; + if (cdto->isBaseOf(cdfrom, &offset)) + goto L1; + } + /* Forward the cast to our alias this member, rewrite to: * cast(to)e1.aliasthis */ Expression *e1 = new DotIdExp(loc, this, ts->sym->aliasthis->ident); @@ -837,6 +840,7 @@ Expression *Expression::castTo(Scope *sc, Type *t) e = e->semantic(sc); return e; } + L1: ; } e = new CastExp(loc, e, tb); } @@ -2152,6 +2156,11 @@ IntRange AndExp::getIntRange() return ir; } +/* + * Adam D. Ruppe's algo for bitwise OR: + * http://www.digitalmars.com/d/archives/digitalmars/D/value_range_propagation_for_logical_OR_108765.html#N108793 + */ + IntRange OrExp::getIntRange() { IntRange ir; diff --git a/dmd2/class.c b/dmd2/class.c index e1a4e4bd..892cb69f 100644 --- a/dmd2/class.c +++ b/dmd2/class.c @@ -31,6 +31,7 @@ ClassDeclaration *ClassDeclaration::classinfo; ClassDeclaration *ClassDeclaration::object; +ClassDeclaration *ClassDeclaration::throwable; ClassDeclaration::ClassDeclaration(Loc loc, Identifier *id, BaseClasses *baseclasses) : AggregateDeclaration(loc, id) @@ -183,6 +184,12 @@ ClassDeclaration::ClassDeclaration(Loc loc, Identifier *id, BaseClasses *basecla object = this; } + if (id == Id::Throwable) + { if (throwable) + throwable->error("%s", msg); + throwable = this; + } + //if (id == Id::ClassInfo) if (id == Id::TypeInfo_Class) { if (classinfo) diff --git a/dmd2/constfold.c b/dmd2/constfold.c index cc4a1f9f..fd0ea546 100644 --- a/dmd2/constfold.c +++ b/dmd2/constfold.c @@ -25,6 +25,7 @@ #include "expression.h" #include "aggregate.h" #include "declaration.h" +#include "utf.h" #if __FreeBSD__ #define fmodl fmod // hack for now, fix later @@ -1361,10 +1362,12 @@ Expression *Cat(Type *type, Expression *e1, Expression *e2) if (e1->op == TOKnull && (e2->op == TOKint64 || e2->op == TOKstructliteral)) { e = e2; + t = t1; goto L2; } else if ((e1->op == TOKint64 || e1->op == TOKstructliteral) && e2->op == TOKnull) { e = e1; + t = t2; L2: Type *tn = e->type->toBasetype(); if (tn->ty == Tchar || tn->ty == Twchar || tn->ty == Tdchar) @@ -1372,12 +1375,15 @@ Expression *Cat(Type *type, Expression *e1, Expression *e2) // Create a StringExp void *s; StringExp *es; - size_t len = 1; - int sz = tn->size(); + if (t->nextOf()) + t = t->nextOf()->toBasetype(); + int sz = t->size(); + dinteger_t v = e->toInteger(); + size_t len = utf_codeLength(sz, v); s = mem.malloc((len + 1) * sz); - memcpy((unsigned char *)s, &v, sz); + utf_encode(sz, s, v); // Add terminating 0 memset((unsigned char *)s + len * sz, 0, sz); @@ -1467,13 +1473,13 @@ Expression *Cat(Type *type, Expression *e1, Expression *e2) StringExp *es1 = (StringExp *)e1; StringExp *es; Type *t; - size_t len = es1->len + 1; int sz = es1->sz; dinteger_t v = e2->toInteger(); + size_t len = es1->len + utf_codeLength(sz, v); s = mem.malloc((len + 1) * sz); memcpy(s, es1->string, es1->len * sz); - memcpy((unsigned char *)s + es1->len * sz, &v, sz); + utf_encode(sz, (unsigned char *)s + (sz * es1->len), v); // Add terminating 0 memset((unsigned char *)s + len * sz, 0, sz); diff --git a/dmd2/declaration.c b/dmd2/declaration.c index 622975cb..698207cf 100644 --- a/dmd2/declaration.c +++ b/dmd2/declaration.c @@ -620,6 +620,7 @@ Dsymbol *AliasDeclaration::toAlias() if (inSemantic) { error("recursive alias declaration"); aliassym = new TypedefDeclaration(loc, ident, Type::terror, NULL); + type = Type::terror; } else if (!aliassym && scope) semantic(scope); diff --git a/dmd2/declaration.h b/dmd2/declaration.h index fef50a80..91b66496 100644 --- a/dmd2/declaration.h +++ b/dmd2/declaration.h @@ -715,6 +715,7 @@ struct FuncDeclaration : Declaration ILS inlineStatus; int inlineNest; // !=0 if nested inline int cantInterpret; // !=0 if cannot interpret function + int isArrayOp; // !=0 if array operation enum PASS semanticRun; // this function's frame ptr ForeachStatement *fes; // if foreach body, this is the foreach @@ -840,9 +841,6 @@ struct FuncDeclaration : Declaration typedef std::map LabelMap; LabelMap labmap; - // if this is an array operation it gets a little special attention - bool isArrayOp; - // Functions that wouldn't have gotten semantic3'ed if we weren't inlining set this flag. bool availableExternally; diff --git a/dmd2/doc.c b/dmd2/doc.c index 3e4e0c11..5dd94dbf 100644 --- a/dmd2/doc.c +++ b/dmd2/doc.c @@ -363,6 +363,36 @@ void Module::gendocfile() /**************************************************** * Having unmatched parentheses can hose the output of Ddoc, * as the macros depend on properly nested parentheses. + * This function replaces all ( with $(LPAREN) and ) with $(RPAREN) + * to preserve text literally. This also means macros in the + * text won't be expanded. + */ +void escapeDdocString(OutBuffer *buf, unsigned start) +{ + for (unsigned u = start; u < buf->offset; u++) + { + unsigned char c = buf->data[u]; + switch(c) + { + case '(': + buf->remove(u, 1); //remove the ( + buf->insert(u, "$(LPAREN)", 9); //insert this instead + u += 8; //skip over newly inserted macro + break; + + case ')': + buf->remove(u, 1); //remove the ) + buf->insert(u, "$(RPAREN)", 9); //insert this instead + u += 8; //skip over newly inserted macro + break; + } + } +} + +/**************************************************** + * Having unmatched parentheses can hose the output of Ddoc, + * as the macros depend on properly nested parentheses. + * Fix by replacing unmatched ( with $(LPAREN) and unmatched ) with $(RPAREN). */ void escapeStrayParenthesis(OutBuffer *buf, unsigned start, Loc loc) @@ -836,7 +866,11 @@ void FuncDeclaration::toDocBuffer(OutBuffer *buf) hgs.ddoc = 1; prefix(buf, td); if (tf) - tf->next->toCBuffer(buf, NULL, &hgs); + { if (tf->nextOf()) + tf->nextOf()->toCBuffer(buf, NULL, &hgs); + else + buf->writestring("auto"); + } buf->writeByte(' '); buf->writestring(ident->toChars()); buf->writeByte('('); diff --git a/dmd2/doc.h b/dmd2/doc.h index c74ab4f7..ffa97fb9 100644 --- a/dmd2/doc.h +++ b/dmd2/doc.h @@ -15,5 +15,6 @@ #pragma once #endif /* __DMC__ */ +void escapeDdocString(OutBuffer *buf, unsigned start); #endif diff --git a/dmd2/dsymbol.c b/dmd2/dsymbol.c index 43c20571..258a6622 100644 --- a/dmd2/dsymbol.c +++ b/dmd2/dsymbol.c @@ -84,7 +84,8 @@ int Dsymbol::equals(Object *o) if (this == o) return TRUE; s = (Dsymbol *)(o); - if (s && ident->equals(s->ident)) + // Overload sets don't have an ident + if (s && ident && s->ident && ident->equals(s->ident)) return TRUE; return FALSE; } diff --git a/dmd2/entity.c b/dmd2/entity.c index 110128e4..98b81141 100644 --- a/dmd2/entity.c +++ b/dmd2/entity.c @@ -9,1055 +9,2360 @@ #include +#include /********************************************* * Convert from named entity to its encoding. * For reference: * http://www.htmlhelp.com/reference/html40/entities/ - * http://www.w3.org/TR/1999/REC-html401-19991224/sgml/entities.html + * http://www.w3.org/2003/entities/2007/w3centities-f.ent */ struct NameId { const char *name; - unsigned short value; + unsigned value; }; -#if IN_GCC static NameId namesA[]={ - "Aacgr", 0x0386, - "aacgr", 0x03AC, - "Aacute", 0x00C1, - "aacute", 0x00E1, - "Abreve", 0x0102, - "abreve", 0x0103, - "Acirc", 0x00C2, - "acirc", 0x00E2, - "acute", 0x00B4, - "Acy", 0x0410, - "acy", 0x0430, - "AElig", 0x00C6, - "aelig", 0x00E6, - "Agr", 0x0391, - "agr", 0x03B1, - "Agrave", 0x00C0, - "agrave", 0x00E0, - "aleph", 0x2135, - "alpha", 0x03B1, - "Amacr", 0x0100, - "amacr", 0x0101, - "amalg", 0x2210, - "amp", 0x0026, - "and", 0x2227, - "ang", 0x2220, - "ang90", 0x221F, - "angmsd", 0x2221, - "angsph", 0x2222, - "angst", 0x212B, - "Aogon", 0x0104, - "aogon", 0x0105, - "ap", 0x2248, - "ape", 0x224A, - "apos", 0x0027, - "Aring", 0x00C5, - "aring", 0x00E5, - "ast", 0x002A, - "asymp", 0x224D, - "Atilde", 0x00C3, - "atilde", 0x00E3, - "Auml", 0x00C4, - "auml", 0x00E4, - NULL, 0 + "Aacgr", 0x00386, // GREEK CAPITAL LETTER ALPHA WITH TONOS + "aacgr", 0x003AC, // GREEK SMALL LETTER ALPHA WITH TONOS + "Aacute", 0x000C1, // LATIN CAPITAL LETTER A WITH ACUTE + "aacute", 0x000E1, // LATIN SMALL LETTER A WITH ACUTE + "Abreve", 0x00102, // LATIN CAPITAL LETTER A WITH BREVE + "abreve", 0x00103, // LATIN SMALL LETTER A WITH BREVE + "ac", 0x0223E, // INVERTED LAZY S + "acd", 0x0223F, // SINE WAVE +// "acE", 0x0223E;0x00333, // INVERTED LAZY S with double underline + "Acirc", 0x000C2, // LATIN CAPITAL LETTER A WITH CIRCUMFLEX + "acirc", 0x000E2, // LATIN SMALL LETTER A WITH CIRCUMFLEX + "acute", 0x000B4, // ACUTE ACCENT + "Acy", 0x00410, // CYRILLIC CAPITAL LETTER A + "acy", 0x00430, // CYRILLIC SMALL LETTER A + "AElig", 0x000C6, // LATIN CAPITAL LETTER AE + "aelig", 0x000E6, // LATIN SMALL LETTER AE + "af", 0x02061, // FUNCTION APPLICATION + "Afr", 0x1D504, // MATHEMATICAL FRAKTUR CAPITAL A + "afr", 0x1D51E, // MATHEMATICAL FRAKTUR SMALL A + "Agr", 0x00391, // GREEK CAPITAL LETTER ALPHA + "agr", 0x003B1, // GREEK SMALL LETTER ALPHA + "Agrave", 0x000C0, // LATIN CAPITAL LETTER A WITH GRAVE + "agrave", 0x000E0, // LATIN SMALL LETTER A WITH GRAVE + "alefsym", 0x02135, // ALEF SYMBOL + "aleph", 0x02135, // ALEF SYMBOL + "Alpha", 0x00391, // GREEK CAPITAL LETTER ALPHA + "alpha", 0x003B1, // GREEK SMALL LETTER ALPHA + "Amacr", 0x00100, // LATIN CAPITAL LETTER A WITH MACRON + "amacr", 0x00101, // LATIN SMALL LETTER A WITH MACRON + "amalg", 0x02A3F, // AMALGAMATION OR COPRODUCT + "amp", 0x00026, // AMPERSAND + "AMP", 0x00026, // AMPERSAND + "and", 0x02227, // LOGICAL AND + "And", 0x02A53, // DOUBLE LOGICAL AND + "andand", 0x02A55, // TWO INTERSECTING LOGICAL AND + "andd", 0x02A5C, // LOGICAL AND WITH HORIZONTAL DASH + "andslope", 0x02A58, // SLOPING LARGE AND + "andv", 0x02A5A, // LOGICAL AND WITH MIDDLE STEM + "ang", 0x02220, // ANGLE + "ange", 0x029A4, // ANGLE WITH UNDERBAR + "angle", 0x02220, // ANGLE + "angmsd", 0x02221, // MEASURED ANGLE + "angmsdaa", 0x029A8, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT + "angmsdab", 0x029A9, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT + "angmsdac", 0x029AA, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT + "angmsdad", 0x029AB, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT + "angmsdae", 0x029AC, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP + "angmsdaf", 0x029AD, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP + "angmsdag", 0x029AE, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN + "angmsdah", 0x029AF, // MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN + "angrt", 0x0221F, // RIGHT ANGLE + "angrtvb", 0x022BE, // RIGHT ANGLE WITH ARC + "angrtvbd", 0x0299D, // MEASURED RIGHT ANGLE WITH DOT + "angsph", 0x02222, // SPHERICAL ANGLE + "angst", 0x000C5, // LATIN CAPITAL LETTER A WITH RING ABOVE + "angzarr", 0x0237C, // RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW + "Aogon", 0x00104, // LATIN CAPITAL LETTER A WITH OGONEK + "aogon", 0x00105, // LATIN SMALL LETTER A WITH OGONEK + "Aopf", 0x1D538, // MATHEMATICAL DOUBLE-STRUCK CAPITAL A + "aopf", 0x1D552, // MATHEMATICAL DOUBLE-STRUCK SMALL A + "ap", 0x02248, // ALMOST EQUAL TO + "apacir", 0x02A6F, // ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT + "ape", 0x0224A, // ALMOST EQUAL OR EQUAL TO + "apE", 0x02A70, // APPROXIMATELY EQUAL OR EQUAL TO + "apid", 0x0224B, // TRIPLE TILDE + "apos", 0x00027, // APOSTROPHE + "ApplyFunction", 0x02061, // FUNCTION APPLICATION + "approx", 0x02248, // ALMOST EQUAL TO + "approxeq", 0x0224A, // ALMOST EQUAL OR EQUAL TO + "Aring", 0x000C5, // LATIN CAPITAL LETTER A WITH RING ABOVE + "aring", 0x000E5, // LATIN SMALL LETTER A WITH RING ABOVE + "Ascr", 0x1D49C, // MATHEMATICAL SCRIPT CAPITAL A + "ascr", 0x1D4B6, // MATHEMATICAL SCRIPT SMALL A + "Assign", 0x02254, // COLON EQUALS + "ast", 0x0002A, // ASTERISK + "asymp", 0x02248, // ALMOST EQUAL TO + "asympeq", 0x0224D, // EQUIVALENT TO + "Atilde", 0x000C3, // LATIN CAPITAL LETTER A WITH TILDE + "atilde", 0x000E3, // LATIN SMALL LETTER A WITH TILDE + "Auml", 0x000C4, // LATIN CAPITAL LETTER A WITH DIAERESIS + "auml", 0x000E4, // LATIN SMALL LETTER A WITH DIAERESIS + "awconint", 0x02233, // ANTICLOCKWISE CONTOUR INTEGRAL + "awint", 0x02A11, // ANTICLOCKWISE INTEGRATION + NULL, 0 }; static NameId namesB[]={ - "barwed", 0x22BC, - "Barwed", 0x2306, - "bcong", 0x224C, - "Bcy", 0x0411, - "bcy", 0x0431, - "becaus", 0x2235, - "bepsi", 0x220D, - "bernou", 0x212C, - "beta", 0x03B2, - "beth", 0x2136, - "Bgr", 0x0392, - "bgr", 0x03B2, - "blank", 0x2423, - "blk12", 0x2592, - "blk14", 0x2591, - "blk34", 0x2593, - "block", 0x2588, - "bottom", 0x22A5, - "bowtie", 0x22C8, - "boxdl", 0x2510, - "boxDL", 0x2555, - "boxdL", 0x2556, - "boxDl", 0x2557, - "boxdr", 0x250C, - "boxDR", 0x2552, - "boxDr", 0x2553, - "boxdR", 0x2554, - "boxh", 0x2500, - "boxH", 0x2550, - "boxhd", 0x252C, - "boxhD", 0x2564, - "boxHD", 0x2565, - "boxHd", 0x2566, - "boxhu", 0x2534, - "boxhU", 0x2567, - "boxHU", 0x2568, - "boxHu", 0x2569, - "boxul", 0x2518, - "boxUL", 0x255B, - "boxUl", 0x255C, - "boxuL", 0x255D, - "boxur", 0x2514, - "boxUR", 0x2558, - "boxuR", 0x2559, - "boxUr", 0x255A, - "boxv", 0x2502, - "boxV", 0x2551, - "boxvh", 0x253C, - "boxvH", 0x256A, - "boxVH", 0x256B, - "boxVh", 0x256C, - "boxvl", 0x2524, - "boxvL", 0x2561, - "boxVL", 0x2562, - "boxVl", 0x2563, - "boxvr", 0x251C, - "boxvR", 0x255E, - "boxVR", 0x255F, - "boxVr", 0x2560, - "bprime", 0x2035, - "breve", 0x02D8, - "brvbar", 0x00A6, - "bsim", 0x223D, - "bsime", 0x22CD, - "bsol", 0x005C, - "bull", 0x2022, - "bump", 0x224E, - "bumpe", 0x224F, - NULL, 0 + "backcong", 0x0224C, // ALL EQUAL TO + "backepsilon", 0x003F6, // GREEK REVERSED LUNATE EPSILON SYMBOL + "backprime", 0x02035, // REVERSED PRIME + "backsim", 0x0223D, // REVERSED TILDE + "backsimeq", 0x022CD, // REVERSED TILDE EQUALS + "Backslash", 0x02216, // SET MINUS +// "b.alpha", 0x1D6C2, // MATHEMATICAL BOLD SMALL ALPHA + "Barv", 0x02AE7, // SHORT DOWN TACK WITH OVERBAR + "barvee", 0x022BD, // NOR + "barwed", 0x02305, // PROJECTIVE + "Barwed", 0x02306, // PERSPECTIVE + "barwedge", 0x02305, // PROJECTIVE +// "b.beta", 0x1D6C3, // MATHEMATICAL BOLD SMALL BETA + "bbrk", 0x023B5, // BOTTOM SQUARE BRACKET + "bbrktbrk", 0x023B6, // BOTTOM SQUARE BRACKET OVER TOP SQUARE BRACKET +// "b.chi", 0x1D6D8, // MATHEMATICAL BOLD SMALL CHI + "bcong", 0x0224C, // ALL EQUAL TO + "Bcy", 0x00411, // CYRILLIC CAPITAL LETTER BE + "bcy", 0x00431, // CYRILLIC SMALL LETTER BE +// "b.Delta", 0x1D6AB, // MATHEMATICAL BOLD CAPITAL DELTA +// "b.delta", 0x1D6C5, // MATHEMATICAL BOLD SMALL DELTA + "bdquo", 0x0201E, // DOUBLE LOW-9 QUOTATION MARK + "becaus", 0x02235, // BECAUSE + "because", 0x02235, // BECAUSE + "Because", 0x02235, // BECAUSE + "bemptyv", 0x029B0, // REVERSED EMPTY SET + "bepsi", 0x003F6, // GREEK REVERSED LUNATE EPSILON SYMBOL +// "b.epsi", 0x1D6C6, // MATHEMATICAL BOLD SMALL EPSILON +// "b.epsiv", 0x1D6DC, // MATHEMATICAL BOLD EPSILON SYMBOL + "bernou", 0x0212C, // SCRIPT CAPITAL B + "Bernoullis", 0x0212C, // SCRIPT CAPITAL B + "Beta", 0x00392, // GREEK CAPITAL LETTER BETA + "beta", 0x003B2, // GREEK SMALL LETTER BETA +// "b.eta", 0x1D6C8, // MATHEMATICAL BOLD SMALL ETA + "beth", 0x02136, // BET SYMBOL + "between", 0x0226C, // BETWEEN + "Bfr", 0x1D505, // MATHEMATICAL FRAKTUR CAPITAL B + "bfr", 0x1D51F, // MATHEMATICAL FRAKTUR SMALL B +// "b.Gamma", 0x1D6AA, // MATHEMATICAL BOLD CAPITAL GAMMA +// "b.gamma", 0x1D6C4, // MATHEMATICAL BOLD SMALL GAMMA +// "b.Gammad", 0x1D7CA, // MATHEMATICAL BOLD CAPITAL DIGAMMA +// "b.gammad", 0x1D7CB, // MATHEMATICAL BOLD SMALL DIGAMMA + "Bgr", 0x00392, // GREEK CAPITAL LETTER BETA + "bgr", 0x003B2, // GREEK SMALL LETTER BETA + "bigcap", 0x022C2, // N-ARY INTERSECTION + "bigcirc", 0x025EF, // LARGE CIRCLE + "bigcup", 0x022C3, // N-ARY UNION + "bigodot", 0x02A00, // N-ARY CIRCLED DOT OPERATOR + "bigoplus", 0x02A01, // N-ARY CIRCLED PLUS OPERATOR + "bigotimes", 0x02A02, // N-ARY CIRCLED TIMES OPERATOR + "bigsqcup", 0x02A06, // N-ARY SQUARE UNION OPERATOR + "bigstar", 0x02605, // BLACK STAR + "bigtriangledown", 0x025BD, // WHITE DOWN-POINTING TRIANGLE + "bigtriangleup", 0x025B3, // WHITE UP-POINTING TRIANGLE + "biguplus", 0x02A04, // N-ARY UNION OPERATOR WITH PLUS + "bigvee", 0x022C1, // N-ARY LOGICAL OR + "bigwedge", 0x022C0, // N-ARY LOGICAL AND +// "b.iota", 0x1D6CA, // MATHEMATICAL BOLD SMALL IOTA +// "b.kappa", 0x1D6CB, // MATHEMATICAL BOLD SMALL KAPPA +// "b.kappav", 0x1D6DE, // MATHEMATICAL BOLD KAPPA SYMBOL + "bkarow", 0x0290D, // RIGHTWARDS DOUBLE DASH ARROW + "blacklozenge", 0x029EB, // BLACK LOZENGE + "blacksquare", 0x025AA, // BLACK SMALL SQUARE + "blacktriangle", 0x025B4, // BLACK UP-POINTING SMALL TRIANGLE + "blacktriangledown", 0x025BE, // BLACK DOWN-POINTING SMALL TRIANGLE + "blacktriangleleft", 0x025C2, // BLACK LEFT-POINTING SMALL TRIANGLE + "blacktriangleright", 0x025B8, // BLACK RIGHT-POINTING SMALL TRIANGLE +// "b.Lambda", 0x1D6B2, // MATHEMATICAL BOLD CAPITAL LAMDA +// "b.lambda", 0x1D6CC, // MATHEMATICAL BOLD SMALL LAMDA + "blank", 0x02423, // OPEN BOX + "blk12", 0x02592, // MEDIUM SHADE + "blk14", 0x02591, // LIGHT SHADE + "blk34", 0x02593, // DARK SHADE + "block", 0x02588, // FULL BLOCK +// "b.mu", 0x1D6CD, // MATHEMATICAL BOLD SMALL MU +// "bne", 0x0003D;0x020E5, // EQUALS SIGN with reverse slash +// "bnequiv", 0x02261;0x020E5, // IDENTICAL TO with reverse slash + "bnot", 0x02310, // REVERSED NOT SIGN + "bNot", 0x02AED, // REVERSED DOUBLE STROKE NOT SIGN +// "b.nu", 0x1D6CE, // MATHEMATICAL BOLD SMALL NU +// "b.Omega", 0x1D6C0, // MATHEMATICAL BOLD CAPITAL OMEGA +// "b.omega", 0x1D6DA, // MATHEMATICAL BOLD SMALL OMEGA + "Bopf", 0x1D539, // MATHEMATICAL DOUBLE-STRUCK CAPITAL B + "bopf", 0x1D553, // MATHEMATICAL DOUBLE-STRUCK SMALL B + "bot", 0x022A5, // UP TACK + "bottom", 0x022A5, // UP TACK + "bowtie", 0x022C8, // BOWTIE + "boxbox", 0x029C9, // TWO JOINED SQUARES + "boxdl", 0x02510, // BOX DRAWINGS LIGHT DOWN AND LEFT + "boxdL", 0x02555, // BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE + "boxDl", 0x02556, // BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE + "boxDL", 0x02557, // BOX DRAWINGS DOUBLE DOWN AND LEFT + "boxdr", 0x0250C, // BOX DRAWINGS LIGHT DOWN AND RIGHT + "boxdR", 0x02552, // BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE + "boxDr", 0x02553, // BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE + "boxDR", 0x02554, // BOX DRAWINGS DOUBLE DOWN AND RIGHT + "boxh", 0x02500, // BOX DRAWINGS LIGHT HORIZONTAL + "boxH", 0x02550, // BOX DRAWINGS DOUBLE HORIZONTAL + "boxhd", 0x0252C, // BOX DRAWINGS LIGHT DOWN AND HORIZONTAL + "boxHd", 0x02564, // BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE + "boxhD", 0x02565, // BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE + "boxHD", 0x02566, // BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL + "boxhu", 0x02534, // BOX DRAWINGS LIGHT UP AND HORIZONTAL + "boxHu", 0x02567, // BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE + "boxhU", 0x02568, // BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE + "boxHU", 0x02569, // BOX DRAWINGS DOUBLE UP AND HORIZONTAL + "boxminus", 0x0229F, // SQUARED MINUS + "boxplus", 0x0229E, // SQUARED PLUS + "boxtimes", 0x022A0, // SQUARED TIMES + "boxul", 0x02518, // BOX DRAWINGS LIGHT UP AND LEFT + "boxuL", 0x0255B, // BOX DRAWINGS UP SINGLE AND LEFT DOUBLE + "boxUl", 0x0255C, // BOX DRAWINGS UP DOUBLE AND LEFT SINGLE + "boxUL", 0x0255D, // BOX DRAWINGS DOUBLE UP AND LEFT + "boxur", 0x02514, // BOX DRAWINGS LIGHT UP AND RIGHT + "boxuR", 0x02558, // BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE + "boxUr", 0x02559, // BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE + "boxUR", 0x0255A, // BOX DRAWINGS DOUBLE UP AND RIGHT + "boxv", 0x02502, // BOX DRAWINGS LIGHT VERTICAL + "boxV", 0x02551, // BOX DRAWINGS DOUBLE VERTICAL + "boxvh", 0x0253C, // BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL + "boxvH", 0x0256A, // BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE + "boxVh", 0x0256B, // BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE + "boxVH", 0x0256C, // BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL + "boxvl", 0x02524, // BOX DRAWINGS LIGHT VERTICAL AND LEFT + "boxvL", 0x02561, // BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE + "boxVl", 0x02562, // BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE + "boxVL", 0x02563, // BOX DRAWINGS DOUBLE VERTICAL AND LEFT + "boxvr", 0x0251C, // BOX DRAWINGS LIGHT VERTICAL AND RIGHT + "boxvR", 0x0255E, // BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE + "boxVr", 0x0255F, // BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE + "boxVR", 0x02560, // BOX DRAWINGS DOUBLE VERTICAL AND RIGHT +// "b.Phi", 0x1D6BD, // MATHEMATICAL BOLD CAPITAL PHI +// "b.phi", 0x1D6D7, // MATHEMATICAL BOLD SMALL PHI +// "b.phiv", 0x1D6DF, // MATHEMATICAL BOLD PHI SYMBOL +// "b.Pi", 0x1D6B7, // MATHEMATICAL BOLD CAPITAL PI +// "b.pi", 0x1D6D1, // MATHEMATICAL BOLD SMALL PI +// "b.piv", 0x1D6E1, // MATHEMATICAL BOLD PI SYMBOL + "bprime", 0x02035, // REVERSED PRIME +// "b.Psi", 0x1D6BF, // MATHEMATICAL BOLD CAPITAL PSI +// "b.psi", 0x1D6D9, // MATHEMATICAL BOLD SMALL PSI + "breve", 0x002D8, // BREVE + "Breve", 0x002D8, // BREVE +// "b.rho", 0x1D6D2, // MATHEMATICAL BOLD SMALL RHO +// "b.rhov", 0x1D6E0, // MATHEMATICAL BOLD RHO SYMBOL + "brvbar", 0x000A6, // BROKEN BAR + "Bscr", 0x0212C, // SCRIPT CAPITAL B + "bscr", 0x1D4B7, // MATHEMATICAL SCRIPT SMALL B + "bsemi", 0x0204F, // REVERSED SEMICOLON +// "b.Sigma", 0x1D6BA, // MATHEMATICAL BOLD CAPITAL SIGMA +// "b.sigma", 0x1D6D4, // MATHEMATICAL BOLD SMALL SIGMA +// "b.sigmav", 0x1D6D3, // MATHEMATICAL BOLD SMALL FINAL SIGMA + "bsim", 0x0223D, // REVERSED TILDE + "bsime", 0x022CD, // REVERSED TILDE EQUALS + "bsol", 0x0005C, // REVERSE SOLIDUS + "bsolb", 0x029C5, // SQUARED FALLING DIAGONAL SLASH + "bsolhsub", 0x027C8, // REVERSE SOLIDUS PRECEDING SUBSET +// "b.tau", 0x1D6D5, // MATHEMATICAL BOLD SMALL TAU +// "b.Theta", 0x1D6AF, // MATHEMATICAL BOLD CAPITAL THETA +// "b.thetas", 0x1D6C9, // MATHEMATICAL BOLD SMALL THETA +// "b.thetav", 0x1D6DD, // MATHEMATICAL BOLD THETA SYMBOL + "bull", 0x02022, // BULLET + "bullet", 0x02022, // BULLET + "bump", 0x0224E, // GEOMETRICALLY EQUIVALENT TO + "bumpe", 0x0224F, // DIFFERENCE BETWEEN + "bumpE", 0x02AAE, // EQUALS SIGN WITH BUMPY ABOVE + "Bumpeq", 0x0224E, // GEOMETRICALLY EQUIVALENT TO + "bumpeq", 0x0224F, // DIFFERENCE BETWEEN +// "b.Upsi", 0x1D6BC, // MATHEMATICAL BOLD CAPITAL UPSILON +// "b.upsi", 0x1D6D6, // MATHEMATICAL BOLD SMALL UPSILON +// "b.Xi", 0x1D6B5, // MATHEMATICAL BOLD CAPITAL XI +// "b.xi", 0x1D6CF, // MATHEMATICAL BOLD SMALL XI +// "b.zeta", 0x1D6C7, // MATHEMATICAL BOLD SMALL ZETA + NULL, 0 }; static NameId namesC[]={ - "Cacute", 0x0106, - "cacute", 0x0107, - "cap", 0x2229, - "Cap", 0x22D2, - "caret", 0x2041, - "caron", 0x02C7, - "Ccaron", 0x010C, - "ccaron", 0x010D, - "Ccedil", 0x00C7, - "ccedil", 0x00E7, - "Ccirc", 0x0108, - "ccirc", 0x0109, - "Cdot", 0x010A, - "cdot", 0x010B, - "cedil", 0x00B8, - "cent", 0x00A2, - "CHcy", 0x0427, - "chcy", 0x0447, - "check", 0x2713, - "chi", 0x03C7, - "cir", 0x25CB, - "circ", 0x005E, - "cire", 0x2257, - "clubs", 0x2663, - "colon", 0x003A, - "colone", 0x2254, - "comma", 0x002C, - "commat", 0x0040, - "comp", 0x2201, - "compfn", 0x2218, - "cong", 0x2245, - "conint", 0x222E, - "coprod", 0x2210, - "copy", 0x00A9, - "copysr", 0x2117, - "cross", 0x2717, - "cuepr", 0x22DE, - "cuesc", 0x22DF, - "cularr", 0x21B6, - "cup", 0x222A, - "Cup", 0x22D3, - "cupre", 0x227C, - "curarr", 0x21B7, - "curren", 0x00A4, - "cuvee", 0x22CE, - "cuwed", 0x22CF, - NULL, 0 + "Cacute", 0x00106, // LATIN CAPITAL LETTER C WITH ACUTE + "cacute", 0x00107, // LATIN SMALL LETTER C WITH ACUTE + "cap", 0x02229, // INTERSECTION + "Cap", 0x022D2, // DOUBLE INTERSECTION + "capand", 0x02A44, // INTERSECTION WITH LOGICAL AND + "capbrcup", 0x02A49, // INTERSECTION ABOVE BAR ABOVE UNION + "capcap", 0x02A4B, // INTERSECTION BESIDE AND JOINED WITH INTERSECTION + "capcup", 0x02A47, // INTERSECTION ABOVE UNION + "capdot", 0x02A40, // INTERSECTION WITH DOT + "CapitalDifferentialD", 0x02145, // DOUBLE-STRUCK ITALIC CAPITAL D +// "caps", 0x02229;0x0FE00, // INTERSECTION with serifs + "caret", 0x02041, // CARET INSERTION POINT + "caron", 0x002C7, // CARON + "Cayleys", 0x0212D, // BLACK-LETTER CAPITAL C + "ccaps", 0x02A4D, // CLOSED INTERSECTION WITH SERIFS + "Ccaron", 0x0010C, // LATIN CAPITAL LETTER C WITH CARON + "ccaron", 0x0010D, // LATIN SMALL LETTER C WITH CARON + "Ccedil", 0x000C7, // LATIN CAPITAL LETTER C WITH CEDILLA + "ccedil", 0x000E7, // LATIN SMALL LETTER C WITH CEDILLA + "Ccirc", 0x00108, // LATIN CAPITAL LETTER C WITH CIRCUMFLEX + "ccirc", 0x00109, // LATIN SMALL LETTER C WITH CIRCUMFLEX + "Cconint", 0x02230, // VOLUME INTEGRAL + "ccups", 0x02A4C, // CLOSED UNION WITH SERIFS + "ccupssm", 0x02A50, // CLOSED UNION WITH SERIFS AND SMASH PRODUCT + "Cdot", 0x0010A, // LATIN CAPITAL LETTER C WITH DOT ABOVE + "cdot", 0x0010B, // LATIN SMALL LETTER C WITH DOT ABOVE + "cedil", 0x000B8, // CEDILLA + "Cedilla", 0x000B8, // CEDILLA + "cemptyv", 0x029B2, // EMPTY SET WITH SMALL CIRCLE ABOVE + "cent", 0x000A2, // CENT SIGN + "centerdot", 0x000B7, // MIDDLE DOT + "CenterDot", 0x000B7, // MIDDLE DOT + "Cfr", 0x0212D, // BLACK-LETTER CAPITAL C + "cfr", 0x1D520, // MATHEMATICAL FRAKTUR SMALL C + "CHcy", 0x00427, // CYRILLIC CAPITAL LETTER CHE + "chcy", 0x00447, // CYRILLIC SMALL LETTER CHE + "check", 0x02713, // CHECK MARK + "checkmark", 0x02713, // CHECK MARK + "Chi", 0x003A7, // GREEK CAPITAL LETTER CHI + "chi", 0x003C7, // GREEK SMALL LETTER CHI + "cir", 0x025CB, // WHITE CIRCLE + "circ", 0x002C6, // MODIFIER LETTER CIRCUMFLEX ACCENT + "circeq", 0x02257, // RING EQUAL TO + "circlearrowleft", 0x021BA, // ANTICLOCKWISE OPEN CIRCLE ARROW + "circlearrowright", 0x021BB, // CLOCKWISE OPEN CIRCLE ARROW + "circledast", 0x0229B, // CIRCLED ASTERISK OPERATOR + "circledcirc", 0x0229A, // CIRCLED RING OPERATOR + "circleddash", 0x0229D, // CIRCLED DASH + "CircleDot", 0x02299, // CIRCLED DOT OPERATOR + "circledR", 0x000AE, // REGISTERED SIGN + "circledS", 0x024C8, // CIRCLED LATIN CAPITAL LETTER S + "CircleMinus", 0x02296, // CIRCLED MINUS + "CirclePlus", 0x02295, // CIRCLED PLUS + "CircleTimes", 0x02297, // CIRCLED TIMES + "cire", 0x02257, // RING EQUAL TO + "cirE", 0x029C3, // CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT + "cirfnint", 0x02A10, // CIRCULATION FUNCTION + "cirmid", 0x02AEF, // VERTICAL LINE WITH CIRCLE ABOVE + "cirscir", 0x029C2, // CIRCLE WITH SMALL CIRCLE TO THE RIGHT + "ClockwiseContourIntegral", 0x02232, // CLOCKWISE CONTOUR INTEGRAL + "CloseCurlyDoubleQuote", 0x0201D, // RIGHT DOUBLE QUOTATION MARK + "CloseCurlyQuote", 0x02019, // RIGHT SINGLE QUOTATION MARK + "clubs", 0x02663, // BLACK CLUB SUIT + "clubsuit", 0x02663, // BLACK CLUB SUIT + "colon", 0x0003A, // COLON + "Colon", 0x02237, // PROPORTION + "colone", 0x02254, // COLON EQUALS + "Colone", 0x02A74, // DOUBLE COLON EQUAL + "coloneq", 0x02254, // COLON EQUALS + "comma", 0x0002C, // COMMA + "commat", 0x00040, // COMMERCIAL AT + "comp", 0x02201, // COMPLEMENT + "compfn", 0x02218, // RING OPERATOR + "complement", 0x02201, // COMPLEMENT + "complexes", 0x02102, // DOUBLE-STRUCK CAPITAL C + "cong", 0x02245, // APPROXIMATELY EQUAL TO + "congdot", 0x02A6D, // CONGRUENT WITH DOT ABOVE + "Congruent", 0x02261, // IDENTICAL TO + "conint", 0x0222E, // CONTOUR INTEGRAL + "Conint", 0x0222F, // SURFACE INTEGRAL + "ContourIntegral", 0x0222E, // CONTOUR INTEGRAL + "Copf", 0x02102, // DOUBLE-STRUCK CAPITAL C + "copf", 0x1D554, // MATHEMATICAL DOUBLE-STRUCK SMALL C + "coprod", 0x02210, // N-ARY COPRODUCT + "Coproduct", 0x02210, // N-ARY COPRODUCT + "copy", 0x000A9, // COPYRIGHT SIGN + "COPY", 0x000A9, // COPYRIGHT SIGN + "copysr", 0x02117, // SOUND RECORDING COPYRIGHT + "CounterClockwiseContourIntegral", 0x02233, // ANTICLOCKWISE CONTOUR INTEGRAL + "crarr", 0x021B5, // DOWNWARDS ARROW WITH CORNER LEFTWARDS + "cross", 0x02717, // BALLOT X + "Cross", 0x02A2F, // VECTOR OR CROSS PRODUCT + "Cscr", 0x1D49E, // MATHEMATICAL SCRIPT CAPITAL C + "cscr", 0x1D4B8, // MATHEMATICAL SCRIPT SMALL C + "csub", 0x02ACF, // CLOSED SUBSET + "csube", 0x02AD1, // CLOSED SUBSET OR EQUAL TO + "csup", 0x02AD0, // CLOSED SUPERSET + "csupe", 0x02AD2, // CLOSED SUPERSET OR EQUAL TO + "ctdot", 0x022EF, // MIDLINE HORIZONTAL ELLIPSIS + "cudarrl", 0x02938, // RIGHT-SIDE ARC CLOCKWISE ARROW + "cudarrr", 0x02935, // ARROW POINTING RIGHTWARDS THEN CURVING DOWNWARDS + "cuepr", 0x022DE, // EQUAL TO OR PRECEDES + "cuesc", 0x022DF, // EQUAL TO OR SUCCEEDS + "cularr", 0x021B6, // ANTICLOCKWISE TOP SEMICIRCLE ARROW + "cularrp", 0x0293D, // TOP ARC ANTICLOCKWISE ARROW WITH PLUS + "cup", 0x0222A, // UNION + "Cup", 0x022D3, // DOUBLE UNION + "cupbrcap", 0x02A48, // UNION ABOVE BAR ABOVE INTERSECTION + "CupCap", 0x0224D, // EQUIVALENT TO + "cupcap", 0x02A46, // UNION ABOVE INTERSECTION + "cupcup", 0x02A4A, // UNION BESIDE AND JOINED WITH UNION + "cupdot", 0x0228D, // MULTISET MULTIPLICATION + "cupor", 0x02A45, // UNION WITH LOGICAL OR +// "cups", 0x0222A;0x0FE00, // UNION with serifs + "curarr", 0x021B7, // CLOCKWISE TOP SEMICIRCLE ARROW + "curarrm", 0x0293C, // TOP ARC CLOCKWISE ARROW WITH MINUS + "curlyeqprec", 0x022DE, // EQUAL TO OR PRECEDES + "curlyeqsucc", 0x022DF, // EQUAL TO OR SUCCEEDS + "curlyvee", 0x022CE, // CURLY LOGICAL OR + "curlywedge", 0x022CF, // CURLY LOGICAL AND + "curren", 0x000A4, // CURRENCY SIGN + "curvearrowleft", 0x021B6, // ANTICLOCKWISE TOP SEMICIRCLE ARROW + "curvearrowright", 0x021B7, // CLOCKWISE TOP SEMICIRCLE ARROW + "cuvee", 0x022CE, // CURLY LOGICAL OR + "cuwed", 0x022CF, // CURLY LOGICAL AND + "cwconint", 0x02232, // CLOCKWISE CONTOUR INTEGRAL + "cwint", 0x02231, // CLOCKWISE INTEGRAL + "cylcty", 0x0232D, // CYLINDRICITY + NULL, 0 }; static NameId namesD[]={ - "dagger", 0x2020, - "Dagger", 0x2021, - "daleth", 0x2138, - "darr", 0x2193, - "dArr", 0x21D3, - "darr2", 0x21CA, - "dash", 0x2010, - "dashv", 0x22A3, - "dblac", 0x02DD, - "Dcaron", 0x010E, - "dcaron", 0x010F, - "Dcy", 0x0414, - "dcy", 0x0434, - "deg", 0x00B0, - "Delta", 0x0394, - "delta", 0x03B4, - "Dgr", 0x0394, - "dgr", 0x03B4, - "dharl", 0x21C3, - "dharr", 0x21C2, - "diam", 0x22C4, - "diams", 0x2666, - "die", 0x00A8, - "divide", 0x00F7, - "divonx", 0x22C7, - "DJcy", 0x0402, - "djcy", 0x0452, - "dlarr", 0x2199, - "dlcorn", 0x231E, - "dlcrop", 0x230D, - "dollar", 0x0024, - "Dot", 0x00A8, - "dot", 0x02D9, - "DotDot", 0x20DC, - "drarr", 0x2198, - "drcorn", 0x231F, - "drcrop", 0x230C, - "DScy", 0x0405, - "dscy", 0x0455, - "Dstrok", 0x0110, - "dstrok", 0x0111, - "dtri", 0x25BF, - "dtrif", 0x25BE, - "DZcy", 0x040F, - "dzcy", 0x045F, - NULL, 0 + "dagger", 0x02020, // DAGGER + "Dagger", 0x02021, // DOUBLE DAGGER + "daleth", 0x02138, // DALET SYMBOL + "darr", 0x02193, // DOWNWARDS ARROW + "Darr", 0x021A1, // DOWNWARDS TWO HEADED ARROW + "dArr", 0x021D3, // DOWNWARDS DOUBLE ARROW + "dash", 0x02010, // HYPHEN + "dashv", 0x022A3, // LEFT TACK + "Dashv", 0x02AE4, // VERTICAL BAR DOUBLE LEFT TURNSTILE + "dbkarow", 0x0290F, // RIGHTWARDS TRIPLE DASH ARROW + "dblac", 0x002DD, // DOUBLE ACUTE ACCENT + "Dcaron", 0x0010E, // LATIN CAPITAL LETTER D WITH CARON + "dcaron", 0x0010F, // LATIN SMALL LETTER D WITH CARON + "Dcy", 0x00414, // CYRILLIC CAPITAL LETTER DE + "dcy", 0x00434, // CYRILLIC SMALL LETTER DE + "DD", 0x02145, // DOUBLE-STRUCK ITALIC CAPITAL D + "dd", 0x02146, // DOUBLE-STRUCK ITALIC SMALL D + "ddagger", 0x02021, // DOUBLE DAGGER + "ddarr", 0x021CA, // DOWNWARDS PAIRED ARROWS + "DDotrahd", 0x02911, // RIGHTWARDS ARROW WITH DOTTED STEM + "ddotseq", 0x02A77, // EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW + "deg", 0x000B0, // DEGREE SIGN + "Del", 0x02207, // NABLA + "Delta", 0x00394, // GREEK CAPITAL LETTER DELTA + "delta", 0x003B4, // GREEK SMALL LETTER DELTA + "demptyv", 0x029B1, // EMPTY SET WITH OVERBAR + "dfisht", 0x0297F, // DOWN FISH TAIL + "Dfr", 0x1D507, // MATHEMATICAL FRAKTUR CAPITAL D + "dfr", 0x1D521, // MATHEMATICAL FRAKTUR SMALL D + "Dgr", 0x00394, // GREEK CAPITAL LETTER DELTA + "dgr", 0x003B4, // GREEK SMALL LETTER DELTA + "dHar", 0x02965, // DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT + "dharl", 0x021C3, // DOWNWARDS HARPOON WITH BARB LEFTWARDS + "dharr", 0x021C2, // DOWNWARDS HARPOON WITH BARB RIGHTWARDS + "DiacriticalAcute", 0x000B4, // ACUTE ACCENT + "DiacriticalDot", 0x002D9, // DOT ABOVE + "DiacriticalDoubleAcute", 0x002DD, // DOUBLE ACUTE ACCENT + "DiacriticalGrave", 0x00060, // GRAVE ACCENT + "DiacriticalTilde", 0x002DC, // SMALL TILDE + "diam", 0x022C4, // DIAMOND OPERATOR + "diamond", 0x022C4, // DIAMOND OPERATOR + "Diamond", 0x022C4, // DIAMOND OPERATOR + "diamondsuit", 0x02666, // BLACK DIAMOND SUIT + "diams", 0x02666, // BLACK DIAMOND SUIT + "die", 0x000A8, // DIAERESIS + "DifferentialD", 0x02146, // DOUBLE-STRUCK ITALIC SMALL D + "digamma", 0x003DD, // GREEK SMALL LETTER DIGAMMA + "disin", 0x022F2, // ELEMENT OF WITH LONG HORIZONTAL STROKE + "div", 0x000F7, // DIVISION SIGN + "divide", 0x000F7, // DIVISION SIGN + "divideontimes", 0x022C7, // DIVISION TIMES + "divonx", 0x022C7, // DIVISION TIMES + "DJcy", 0x00402, // CYRILLIC CAPITAL LETTER DJE + "djcy", 0x00452, // CYRILLIC SMALL LETTER DJE + "dlcorn", 0x0231E, // BOTTOM LEFT CORNER + "dlcrop", 0x0230D, // BOTTOM LEFT CROP + "dollar", 0x00024, // DOLLAR SIGN + "Dopf", 0x1D53B, // MATHEMATICAL DOUBLE-STRUCK CAPITAL D + "dopf", 0x1D555, // MATHEMATICAL DOUBLE-STRUCK SMALL D + "Dot", 0x000A8, // DIAERESIS + "dot", 0x002D9, // DOT ABOVE + "DotDot", 0x020DC, // COMBINING FOUR DOTS ABOVE + "doteq", 0x02250, // APPROACHES THE LIMIT + "doteqdot", 0x02251, // GEOMETRICALLY EQUAL TO + "DotEqual", 0x02250, // APPROACHES THE LIMIT + "dotminus", 0x02238, // DOT MINUS + "dotplus", 0x02214, // DOT PLUS + "dotsquare", 0x022A1, // SQUARED DOT OPERATOR + "doublebarwedge", 0x02306, // PERSPECTIVE + "DoubleContourIntegral", 0x0222F, // SURFACE INTEGRAL + "DoubleDot", 0x000A8, // DIAERESIS + "DoubleDownArrow", 0x021D3, // DOWNWARDS DOUBLE ARROW + "DoubleLeftArrow", 0x021D0, // LEFTWARDS DOUBLE ARROW + "DoubleLeftRightArrow", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "DoubleLeftTee", 0x02AE4, // VERTICAL BAR DOUBLE LEFT TURNSTILE + "DoubleLongLeftArrow", 0x027F8, // LONG LEFTWARDS DOUBLE ARROW + "DoubleLongLeftRightArrow", 0x027FA, // LONG LEFT RIGHT DOUBLE ARROW + "DoubleLongRightArrow", 0x027F9, // LONG RIGHTWARDS DOUBLE ARROW + "DoubleRightArrow", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "DoubleRightTee", 0x022A8, // TRUE + "DoubleUpArrow", 0x021D1, // UPWARDS DOUBLE ARROW + "DoubleUpDownArrow", 0x021D5, // UP DOWN DOUBLE ARROW + "DoubleVerticalBar", 0x02225, // PARALLEL TO + "downarrow", 0x02193, // DOWNWARDS ARROW + "DownArrow", 0x02193, // DOWNWARDS ARROW + "Downarrow", 0x021D3, // DOWNWARDS DOUBLE ARROW + "DownArrowBar", 0x02913, // DOWNWARDS ARROW TO BAR + "DownArrowUpArrow", 0x021F5, // DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW + "DownBreve", 0x00311, // COMBINING INVERTED BREVE + "downdownarrows", 0x021CA, // DOWNWARDS PAIRED ARROWS + "downharpoonleft", 0x021C3, // DOWNWARDS HARPOON WITH BARB LEFTWARDS + "downharpoonright", 0x021C2, // DOWNWARDS HARPOON WITH BARB RIGHTWARDS + "DownLeftRightVector", 0x02950, // LEFT BARB DOWN RIGHT BARB DOWN HARPOON + "DownLeftTeeVector", 0x0295E, // LEFTWARDS HARPOON WITH BARB DOWN FROM BAR + "DownLeftVector", 0x021BD, // LEFTWARDS HARPOON WITH BARB DOWNWARDS + "DownLeftVectorBar", 0x02956, // LEFTWARDS HARPOON WITH BARB DOWN TO BAR + "DownRightTeeVector", 0x0295F, // RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR + "DownRightVector", 0x021C1, // RIGHTWARDS HARPOON WITH BARB DOWNWARDS + "DownRightVectorBar", 0x02957, // RIGHTWARDS HARPOON WITH BARB DOWN TO BAR + "DownTee", 0x022A4, // DOWN TACK + "DownTeeArrow", 0x021A7, // DOWNWARDS ARROW FROM BAR + "drbkarow", 0x02910, // RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW + "drcorn", 0x0231F, // BOTTOM RIGHT CORNER + "drcrop", 0x0230C, // BOTTOM RIGHT CROP + "Dscr", 0x1D49F, // MATHEMATICAL SCRIPT CAPITAL D + "dscr", 0x1D4B9, // MATHEMATICAL SCRIPT SMALL D + "DScy", 0x00405, // CYRILLIC CAPITAL LETTER DZE + "dscy", 0x00455, // CYRILLIC SMALL LETTER DZE + "dsol", 0x029F6, // SOLIDUS WITH OVERBAR + "Dstrok", 0x00110, // LATIN CAPITAL LETTER D WITH STROKE + "dstrok", 0x00111, // LATIN SMALL LETTER D WITH STROKE + "dtdot", 0x022F1, // DOWN RIGHT DIAGONAL ELLIPSIS + "dtri", 0x025BF, // WHITE DOWN-POINTING SMALL TRIANGLE + "dtrif", 0x025BE, // BLACK DOWN-POINTING SMALL TRIANGLE + "duarr", 0x021F5, // DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW + "duhar", 0x0296F, // DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT + "dwangle", 0x029A6, // OBLIQUE ANGLE OPENING UP + "DZcy", 0x0040F, // CYRILLIC CAPITAL LETTER DZHE + "dzcy", 0x0045F, // CYRILLIC SMALL LETTER DZHE + "dzigrarr", 0x027FF, // LONG RIGHTWARDS SQUIGGLE ARROW + NULL, 0 }; static NameId namesE[]={ - "Eacgr", 0x0388, - "eacgr", 0x03AD, - "Eacute", 0x00C9, - "eacute", 0x00E9, - "Ecaron", 0x011A, - "ecaron", 0x011B, - "ecir", 0x2256, - "Ecirc", 0x00CA, - "ecirc", 0x00EA, - "ecolon", 0x2255, - "Ecy", 0x042D, - "ecy", 0x044D, - "Edot", 0x0116, - "edot", 0x0117, - "eDot", 0x2251, - "EEacgr", 0x0389, - "eeacgr", 0x03AE, - "EEgr", 0x0397, - "eegr", 0x03B7, - "efDot", 0x2252, - "Egr", 0x0395, - "egr", 0x03B5, - "Egrave", 0x00C8, - "egrave", 0x00E8, - "egs", 0x22DD, - "ell", 0x2113, - "els", 0x22DC, - "Emacr", 0x0112, - "emacr", 0x0113, - "empty", 0x2205, - "emsp", 0x2003, - "emsp13", 0x2004, - "emsp14", 0x2005, - "ENG", 0x014A, - "eng", 0x014B, - "ensp", 0x2002, - "Eogon", 0x0118, - "eogon", 0x0119, - "epsi", 0x220A, - "epsis", 0x220A, - "epsiv", 0x03B5, - "equals", 0x003D, - "equiv", 0x2261, - "erDot", 0x2253, - "esdot", 0x2250, - "eta", 0x03B7, - "ETH", 0x00D0, - "eth", 0x00F0, - "Euml", 0x00CB, - "euml", 0x00EB, - "excl", 0x0021, - "exist", 0x2203, - NULL, 0 + "Eacgr", 0x00388, // GREEK CAPITAL LETTER EPSILON WITH TONOS + "eacgr", 0x003AD, // GREEK SMALL LETTER EPSILON WITH TONOS + "Eacute", 0x000C9, // LATIN CAPITAL LETTER E WITH ACUTE + "eacute", 0x000E9, // LATIN SMALL LETTER E WITH ACUTE + "easter", 0x02A6E, // EQUALS WITH ASTERISK + "Ecaron", 0x0011A, // LATIN CAPITAL LETTER E WITH CARON + "ecaron", 0x0011B, // LATIN SMALL LETTER E WITH CARON + "ecir", 0x02256, // RING IN EQUAL TO + "Ecirc", 0x000CA, // LATIN CAPITAL LETTER E WITH CIRCUMFLEX + "ecirc", 0x000EA, // LATIN SMALL LETTER E WITH CIRCUMFLEX + "ecolon", 0x02255, // EQUALS COLON + "Ecy", 0x0042D, // CYRILLIC CAPITAL LETTER E + "ecy", 0x0044D, // CYRILLIC SMALL LETTER E + "eDDot", 0x02A77, // EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW + "Edot", 0x00116, // LATIN CAPITAL LETTER E WITH DOT ABOVE + "edot", 0x00117, // LATIN SMALL LETTER E WITH DOT ABOVE + "eDot", 0x02251, // GEOMETRICALLY EQUAL TO + "ee", 0x02147, // DOUBLE-STRUCK ITALIC SMALL E + "EEacgr", 0x00389, // GREEK CAPITAL LETTER ETA WITH TONOS + "eeacgr", 0x003AE, // GREEK SMALL LETTER ETA WITH TONOS + "EEgr", 0x00397, // GREEK CAPITAL LETTER ETA + "eegr", 0x003B7, // GREEK SMALL LETTER ETA + "efDot", 0x02252, // APPROXIMATELY EQUAL TO OR THE IMAGE OF + "Efr", 0x1D508, // MATHEMATICAL FRAKTUR CAPITAL E + "efr", 0x1D522, // MATHEMATICAL FRAKTUR SMALL E + "eg", 0x02A9A, // DOUBLE-LINE EQUAL TO OR GREATER-THAN + "Egr", 0x00395, // GREEK CAPITAL LETTER EPSILON + "egr", 0x003B5, // GREEK SMALL LETTER EPSILON + "Egrave", 0x000C8, // LATIN CAPITAL LETTER E WITH GRAVE + "egrave", 0x000E8, // LATIN SMALL LETTER E WITH GRAVE + "egs", 0x02A96, // SLANTED EQUAL TO OR GREATER-THAN + "egsdot", 0x02A98, // SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE + "el", 0x02A99, // DOUBLE-LINE EQUAL TO OR LESS-THAN + "Element", 0x02208, // ELEMENT OF + "elinters", 0x023E7, // ELECTRICAL INTERSECTION + "ell", 0x02113, // SCRIPT SMALL L + "els", 0x02A95, // SLANTED EQUAL TO OR LESS-THAN + "elsdot", 0x02A97, // SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE + "Emacr", 0x00112, // LATIN CAPITAL LETTER E WITH MACRON + "emacr", 0x00113, // LATIN SMALL LETTER E WITH MACRON + "empty", 0x02205, // EMPTY SET + "emptyset", 0x02205, // EMPTY SET + "EmptySmallSquare", 0x025FB, // WHITE MEDIUM SQUARE + "emptyv", 0x02205, // EMPTY SET + "EmptyVerySmallSquare", 0x025AB, // WHITE SMALL SQUARE + "emsp", 0x02003, // EM SPACE + "emsp13", 0x02004, // THREE-PER-EM SPACE + "emsp14", 0x02005, // FOUR-PER-EM SPACE + "ENG", 0x0014A, // LATIN CAPITAL LETTER ENG + "eng", 0x0014B, // LATIN SMALL LETTER ENG + "ensp", 0x02002, // EN SPACE + "Eogon", 0x00118, // LATIN CAPITAL LETTER E WITH OGONEK + "eogon", 0x00119, // LATIN SMALL LETTER E WITH OGONEK + "Eopf", 0x1D53C, // MATHEMATICAL DOUBLE-STRUCK CAPITAL E + "eopf", 0x1D556, // MATHEMATICAL DOUBLE-STRUCK SMALL E + "epar", 0x022D5, // EQUAL AND PARALLEL TO + "eparsl", 0x029E3, // EQUALS SIGN AND SLANTED PARALLEL + "eplus", 0x02A71, // EQUALS SIGN ABOVE PLUS SIGN + "epsi", 0x003B5, // GREEK SMALL LETTER EPSILON + "Epsilon", 0x00395, // GREEK CAPITAL LETTER EPSILON + "epsilon", 0x003B5, // GREEK SMALL LETTER EPSILON + "epsiv", 0x003F5, // GREEK LUNATE EPSILON SYMBOL + "eqcirc", 0x02256, // RING IN EQUAL TO + "eqcolon", 0x02255, // EQUALS COLON + "eqsim", 0x02242, // MINUS TILDE + "eqslantgtr", 0x02A96, // SLANTED EQUAL TO OR GREATER-THAN + "eqslantless", 0x02A95, // SLANTED EQUAL TO OR LESS-THAN + "Equal", 0x02A75, // TWO CONSECUTIVE EQUALS SIGNS + "equals", 0x0003D, // EQUALS SIGN + "EqualTilde", 0x02242, // MINUS TILDE + "equest", 0x0225F, // QUESTIONED EQUAL TO + "Equilibrium", 0x021CC, // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON + "equiv", 0x02261, // IDENTICAL TO + "equivDD", 0x02A78, // EQUIVALENT WITH FOUR DOTS ABOVE + "eqvparsl", 0x029E5, // IDENTICAL TO AND SLANTED PARALLEL + "erarr", 0x02971, // EQUALS SIGN ABOVE RIGHTWARDS ARROW + "erDot", 0x02253, // IMAGE OF OR APPROXIMATELY EQUAL TO + "escr", 0x0212F, // SCRIPT SMALL E + "Escr", 0x02130, // SCRIPT CAPITAL E + "esdot", 0x02250, // APPROACHES THE LIMIT + "esim", 0x02242, // MINUS TILDE + "Esim", 0x02A73, // EQUALS SIGN ABOVE TILDE OPERATOR + "Eta", 0x00397, // GREEK CAPITAL LETTER ETA + "eta", 0x003B7, // GREEK SMALL LETTER ETA + "ETH", 0x000D0, // LATIN CAPITAL LETTER ETH + "eth", 0x000F0, // LATIN SMALL LETTER ETH + "Euml", 0x000CB, // LATIN CAPITAL LETTER E WITH DIAERESIS + "euml", 0x000EB, // LATIN SMALL LETTER E WITH DIAERESIS + "euro", 0x020AC, // EURO SIGN + "excl", 0x00021, // EXCLAMATION MARK + "exist", 0x02203, // THERE EXISTS + "Exists", 0x02203, // THERE EXISTS + "expectation", 0x02130, // SCRIPT CAPITAL E + "exponentiale", 0x02147, // DOUBLE-STRUCK ITALIC SMALL E + "ExponentialE", 0x02147, // DOUBLE-STRUCK ITALIC SMALL E + NULL, 0 }; static NameId namesF[]={ - "Fcy", 0x0424, - "fcy", 0x0444, - "female", 0x2640, - "ffilig", 0xFB03, - "fflig", 0xFB00, - "ffllig", 0xFB04, - "filig", 0xFB01, - "flat", 0x266D, - "fllig", 0xFB02, - "fnof", 0x0192, - "forall", 0x2200, - "fork", 0x22D4, - "frac12", 0x00BD, - "frac13", 0x2153, - "frac14", 0x00BC, - "frac15", 0x2155, - "frac16", 0x2159, - "frac18", 0x215B, - "frac23", 0x2154, - "frac25", 0x2156, - "frac34", 0x00BE, - "frac35", 0x2157, - "frac38", 0x215C, - "frac45", 0x2158, - "frac56", 0x215A, - "frac58", 0x215D, - "frac78", 0x215E, - "frown", 0x2322, - NULL, 0 + "fallingdotseq", 0x02252, // APPROXIMATELY EQUAL TO OR THE IMAGE OF + "Fcy", 0x00424, // CYRILLIC CAPITAL LETTER EF + "fcy", 0x00444, // CYRILLIC SMALL LETTER EF + "female", 0x02640, // FEMALE SIGN + "ffilig", 0x0FB03, // LATIN SMALL LIGATURE FFI + "fflig", 0x0FB00, // LATIN SMALL LIGATURE FF + "ffllig", 0x0FB04, // LATIN SMALL LIGATURE FFL + "Ffr", 0x1D509, // MATHEMATICAL FRAKTUR CAPITAL F + "ffr", 0x1D523, // MATHEMATICAL FRAKTUR SMALL F + "filig", 0x0FB01, // LATIN SMALL LIGATURE FI + "FilledSmallSquare", 0x025FC, // BLACK MEDIUM SQUARE + "FilledVerySmallSquare", 0x025AA, // BLACK SMALL SQUARE +// "fjlig", 0x00066;0x0006A, // fj ligature + "flat", 0x0266D, // MUSIC FLAT SIGN + "fllig", 0x0FB02, // LATIN SMALL LIGATURE FL + "fltns", 0x025B1, // WHITE PARALLELOGRAM + "fnof", 0x00192, // LATIN SMALL LETTER F WITH HOOK + "Fopf", 0x1D53D, // MATHEMATICAL DOUBLE-STRUCK CAPITAL F + "fopf", 0x1D557, // MATHEMATICAL DOUBLE-STRUCK SMALL F + "forall", 0x02200, // FOR ALL + "ForAll", 0x02200, // FOR ALL + "fork", 0x022D4, // PITCHFORK + "forkv", 0x02AD9, // ELEMENT OF OPENING DOWNWARDS + "Fouriertrf", 0x02131, // SCRIPT CAPITAL F + "fpartint", 0x02A0D, // FINITE PART INTEGRAL + "frac12", 0x000BD, // VULGAR FRACTION ONE HALF + "frac13", 0x02153, // VULGAR FRACTION ONE THIRD + "frac14", 0x000BC, // VULGAR FRACTION ONE QUARTER + "frac15", 0x02155, // VULGAR FRACTION ONE FIFTH + "frac16", 0x02159, // VULGAR FRACTION ONE SIXTH + "frac18", 0x0215B, // VULGAR FRACTION ONE EIGHTH + "frac23", 0x02154, // VULGAR FRACTION TWO THIRDS + "frac25", 0x02156, // VULGAR FRACTION TWO FIFTHS + "frac34", 0x000BE, // VULGAR FRACTION THREE QUARTERS + "frac35", 0x02157, // VULGAR FRACTION THREE FIFTHS + "frac38", 0x0215C, // VULGAR FRACTION THREE EIGHTHS + "frac45", 0x02158, // VULGAR FRACTION FOUR FIFTHS + "frac56", 0x0215A, // VULGAR FRACTION FIVE SIXTHS + "frac58", 0x0215D, // VULGAR FRACTION FIVE EIGHTHS + "frac78", 0x0215E, // VULGAR FRACTION SEVEN EIGHTHS + "frasl", 0x02044, // FRACTION SLASH + "frown", 0x02322, // FROWN + "Fscr", 0x02131, // SCRIPT CAPITAL F + "fscr", 0x1D4BB, // MATHEMATICAL SCRIPT SMALL F + NULL, 0 }; static NameId namesG[]={ - "gacute", 0x01F5, - "Gamma", 0x0393, - "gamma", 0x03B3, - "gammad", 0x03DC, - "gap", 0x2273, - "Gbreve", 0x011E, - "gbreve", 0x011F, - "Gcedil", 0x0122, - "Gcirc", 0x011C, - "gcirc", 0x011D, - "Gcy", 0x0413, - "gcy", 0x0433, - "Gdot", 0x0120, - "gdot", 0x0121, - "ge", 0x2265, - "gE", 0x2267, - "gel", 0x22DB, - "gEl", 0x22DB, - "ges", 0x2265, - "Gg", 0x22D9, - "Ggr", 0x0393, - "ggr", 0x03B3, - "gimel", 0x2137, - "GJcy", 0x0403, - "gjcy", 0x0453, - "gl", 0x2277, - "gnap", 0xE411, - "gne", 0x2269, - "gnE", 0x2269, - "gnsim", 0x22E7, - "grave", 0x0060, - "gsdot", 0x22D7, - "gsim", 0x2273, - "gt", 0x003E, - "Gt", 0x226B, - "gvnE", 0x2269, - NULL, 0 + "gacute", 0x001F5, // LATIN SMALL LETTER G WITH ACUTE + "Gamma", 0x00393, // GREEK CAPITAL LETTER GAMMA + "gamma", 0x003B3, // GREEK SMALL LETTER GAMMA + "Gammad", 0x003DC, // GREEK LETTER DIGAMMA + "gammad", 0x003DD, // GREEK SMALL LETTER DIGAMMA + "gap", 0x02A86, // GREATER-THAN OR APPROXIMATE + "Gbreve", 0x0011E, // LATIN CAPITAL LETTER G WITH BREVE + "gbreve", 0x0011F, // LATIN SMALL LETTER G WITH BREVE + "Gcedil", 0x00122, // LATIN CAPITAL LETTER G WITH CEDILLA + "Gcirc", 0x0011C, // LATIN CAPITAL LETTER G WITH CIRCUMFLEX + "gcirc", 0x0011D, // LATIN SMALL LETTER G WITH CIRCUMFLEX + "Gcy", 0x00413, // CYRILLIC CAPITAL LETTER GHE + "gcy", 0x00433, // CYRILLIC SMALL LETTER GHE + "Gdot", 0x00120, // LATIN CAPITAL LETTER G WITH DOT ABOVE + "gdot", 0x00121, // LATIN SMALL LETTER G WITH DOT ABOVE + "ge", 0x02265, // GREATER-THAN OR EQUAL TO + "gE", 0x02267, // GREATER-THAN OVER EQUAL TO + "gel", 0x022DB, // GREATER-THAN EQUAL TO OR LESS-THAN + "gEl", 0x02A8C, // GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN + "geq", 0x02265, // GREATER-THAN OR EQUAL TO + "geqq", 0x02267, // GREATER-THAN OVER EQUAL TO + "geqslant", 0x02A7E, // GREATER-THAN OR SLANTED EQUAL TO + "ges", 0x02A7E, // GREATER-THAN OR SLANTED EQUAL TO + "gescc", 0x02AA9, // GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL + "gesdot", 0x02A80, // GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE + "gesdoto", 0x02A82, // GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE + "gesdotol", 0x02A84, // GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT +// "gesl", 0x022DB;0x0FE00, // GREATER-THAN slanted EQUAL TO OR LESS-THAN + "gesles", 0x02A94, // GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL + "Gfr", 0x1D50A, // MATHEMATICAL FRAKTUR CAPITAL G + "gfr", 0x1D524, // MATHEMATICAL FRAKTUR SMALL G + "gg", 0x0226B, // MUCH GREATER-THAN + "Gg", 0x022D9, // VERY MUCH GREATER-THAN + "ggg", 0x022D9, // VERY MUCH GREATER-THAN + "Ggr", 0x00393, // GREEK CAPITAL LETTER GAMMA + "ggr", 0x003B3, // GREEK SMALL LETTER GAMMA + "gimel", 0x02137, // GIMEL SYMBOL + "GJcy", 0x00403, // CYRILLIC CAPITAL LETTER GJE + "gjcy", 0x00453, // CYRILLIC SMALL LETTER GJE + "gl", 0x02277, // GREATER-THAN OR LESS-THAN + "gla", 0x02AA5, // GREATER-THAN BESIDE LESS-THAN + "glE", 0x02A92, // GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL + "glj", 0x02AA4, // GREATER-THAN OVERLAPPING LESS-THAN + "gnap", 0x02A8A, // GREATER-THAN AND NOT APPROXIMATE + "gnapprox", 0x02A8A, // GREATER-THAN AND NOT APPROXIMATE + "gnE", 0x02269, // GREATER-THAN BUT NOT EQUAL TO + "gne", 0x02A88, // GREATER-THAN AND SINGLE-LINE NOT EQUAL TO + "gneq", 0x02A88, // GREATER-THAN AND SINGLE-LINE NOT EQUAL TO + "gneqq", 0x02269, // GREATER-THAN BUT NOT EQUAL TO + "gnsim", 0x022E7, // GREATER-THAN BUT NOT EQUIVALENT TO + "Gopf", 0x1D53E, // MATHEMATICAL DOUBLE-STRUCK CAPITAL G + "gopf", 0x1D558, // MATHEMATICAL DOUBLE-STRUCK SMALL G + "grave", 0x00060, // GRAVE ACCENT + "GreaterEqual", 0x02265, // GREATER-THAN OR EQUAL TO + "GreaterEqualLess", 0x022DB, // GREATER-THAN EQUAL TO OR LESS-THAN + "GreaterFullEqual", 0x02267, // GREATER-THAN OVER EQUAL TO + "GreaterGreater", 0x02AA2, // DOUBLE NESTED GREATER-THAN + "GreaterLess", 0x02277, // GREATER-THAN OR LESS-THAN + "GreaterSlantEqual", 0x02A7E, // GREATER-THAN OR SLANTED EQUAL TO + "GreaterTilde", 0x02273, // GREATER-THAN OR EQUIVALENT TO + "gscr", 0x0210A, // SCRIPT SMALL G + "Gscr", 0x1D4A2, // MATHEMATICAL SCRIPT CAPITAL G + "gsim", 0x02273, // GREATER-THAN OR EQUIVALENT TO + "gsime", 0x02A8E, // GREATER-THAN ABOVE SIMILAR OR EQUAL + "gsiml", 0x02A90, // GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN + "gt", 0x0003E, // GREATER-THAN SIGN + "GT", 0x0003E, // GREATER-THAN SIGN + "Gt", 0x0226B, // MUCH GREATER-THAN + "gtcc", 0x02AA7, // GREATER-THAN CLOSED BY CURVE + "gtcir", 0x02A7A, // GREATER-THAN WITH CIRCLE INSIDE + "gtdot", 0x022D7, // GREATER-THAN WITH DOT + "gtlPar", 0x02995, // DOUBLE LEFT ARC GREATER-THAN BRACKET + "gtquest", 0x02A7C, // GREATER-THAN WITH QUESTION MARK ABOVE + "gtrapprox", 0x02A86, // GREATER-THAN OR APPROXIMATE + "gtrarr", 0x02978, // GREATER-THAN ABOVE RIGHTWARDS ARROW + "gtrdot", 0x022D7, // GREATER-THAN WITH DOT + "gtreqless", 0x022DB, // GREATER-THAN EQUAL TO OR LESS-THAN + "gtreqqless", 0x02A8C, // GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN + "gtrless", 0x02277, // GREATER-THAN OR LESS-THAN + "gtrsim", 0x02273, // GREATER-THAN OR EQUIVALENT TO +// "gvertneqq", 0x02269;0x0FE00, // GREATER-THAN BUT NOT EQUAL TO - with vertical stroke +// "gvnE", 0x02269;0x0FE00, // GREATER-THAN BUT NOT EQUAL TO - with vertical stroke + NULL, 0 }; static NameId namesH[]={ - "hairsp", 0x200A, - "half", 0x00BD, - "hamilt", 0x210B, - "HARDcy", 0x042A, - "hardcy", 0x044A, - "harr", 0x2194, - "hArr", 0x21D4, - "harrw", 0x21AD, - "Hcirc", 0x0124, - "hcirc", 0x0125, - "hearts", 0x2665, - "hellip", 0x2026, - "horbar", 0x2015, - "Hstrok", 0x0126, - "hstrok", 0x0127, - "hybull", 0x2043, - "hyphen", 0x002D, - NULL, 0 + "Hacek", 0x002C7, // CARON + "hairsp", 0x0200A, // HAIR SPACE + "half", 0x000BD, // VULGAR FRACTION ONE HALF + "hamilt", 0x0210B, // SCRIPT CAPITAL H + "HARDcy", 0x0042A, // CYRILLIC CAPITAL LETTER HARD SIGN + "hardcy", 0x0044A, // CYRILLIC SMALL LETTER HARD SIGN + "harr", 0x02194, // LEFT RIGHT ARROW + "hArr", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "harrcir", 0x02948, // LEFT RIGHT ARROW THROUGH SMALL CIRCLE + "harrw", 0x021AD, // LEFT RIGHT WAVE ARROW + "Hat", 0x0005E, // CIRCUMFLEX ACCENT + "hbar", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "Hcirc", 0x00124, // LATIN CAPITAL LETTER H WITH CIRCUMFLEX + "hcirc", 0x00125, // LATIN SMALL LETTER H WITH CIRCUMFLEX + "hearts", 0x02665, // BLACK HEART SUIT + "heartsuit", 0x02665, // BLACK HEART SUIT + "hellip", 0x02026, // HORIZONTAL ELLIPSIS + "hercon", 0x022B9, // HERMITIAN CONJUGATE MATRIX + "Hfr", 0x0210C, // BLACK-LETTER CAPITAL H + "hfr", 0x1D525, // MATHEMATICAL FRAKTUR SMALL H + "HilbertSpace", 0x0210B, // SCRIPT CAPITAL H + "hksearow", 0x02925, // SOUTH EAST ARROW WITH HOOK + "hkswarow", 0x02926, // SOUTH WEST ARROW WITH HOOK + "hoarr", 0x021FF, // LEFT RIGHT OPEN-HEADED ARROW + "homtht", 0x0223B, // HOMOTHETIC + "hookleftarrow", 0x021A9, // LEFTWARDS ARROW WITH HOOK + "hookrightarrow", 0x021AA, // RIGHTWARDS ARROW WITH HOOK + "Hopf", 0x0210D, // DOUBLE-STRUCK CAPITAL H + "hopf", 0x1D559, // MATHEMATICAL DOUBLE-STRUCK SMALL H + "horbar", 0x02015, // HORIZONTAL BAR + "HorizontalLine", 0x02500, // BOX DRAWINGS LIGHT HORIZONTAL + "Hscr", 0x0210B, // SCRIPT CAPITAL H + "hscr", 0x1D4BD, // MATHEMATICAL SCRIPT SMALL H + "hslash", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "Hstrok", 0x00126, // LATIN CAPITAL LETTER H WITH STROKE + "hstrok", 0x00127, // LATIN SMALL LETTER H WITH STROKE + "HumpDownHump", 0x0224E, // GEOMETRICALLY EQUIVALENT TO + "HumpEqual", 0x0224F, // DIFFERENCE BETWEEN + "hybull", 0x02043, // HYPHEN BULLET + "hyphen", 0x02010, // HYPHEN + NULL, 0 }; static NameId namesI[]={ - "Iacgr", 0x038A, - "iacgr", 0x03AF, - "Iacute", 0x00CD, - "iacute", 0x00ED, - "Icirc", 0x00CE, - "icirc", 0x00EE, - "Icy", 0x0418, - "icy", 0x0438, - "idiagr", 0x0390, - "Idigr", 0x03AA, - "idigr", 0x03CA, - "Idot", 0x0130, - "IEcy", 0x0415, - "iecy", 0x0435, - "iexcl", 0x00A1, - "iff", 0x21D4, - "Igr", 0x0399, - "igr", 0x03B9, - "Igrave", 0x00CC, - "igrave", 0x00EC, - "IJlig", 0x0132, - "ijlig", 0x0133, - "Imacr", 0x012A, - "imacr", 0x012B, - "image", 0x2111, - "incare", 0x2105, - "infin", 0x221E, - "inodot", 0x0131, - "int", 0x222B, - "intcal", 0x22BA, - "IOcy", 0x0401, - "iocy", 0x0451, - "Iogon", 0x012E, - "iogon", 0x012F, - "iota", 0x03B9, - "iquest", 0x00BF, - "isin", 0x220A, - "Itilde", 0x0128, - "itilde", 0x0129, - "Iukcy", 0x0406, - "iukcy", 0x0456, - "Iuml", 0x00CF, - "iuml", 0x00EF, - NULL, 0 + "Iacgr", 0x0038A, // GREEK CAPITAL LETTER IOTA WITH TONOS + "iacgr", 0x003AF, // GREEK SMALL LETTER IOTA WITH TONOS + "Iacute", 0x000CD, // LATIN CAPITAL LETTER I WITH ACUTE + "iacute", 0x000ED, // LATIN SMALL LETTER I WITH ACUTE + "ic", 0x02063, // INVISIBLE SEPARATOR + "Icirc", 0x000CE, // LATIN CAPITAL LETTER I WITH CIRCUMFLEX + "icirc", 0x000EE, // LATIN SMALL LETTER I WITH CIRCUMFLEX + "Icy", 0x00418, // CYRILLIC CAPITAL LETTER I + "icy", 0x00438, // CYRILLIC SMALL LETTER I + "idiagr", 0x00390, // GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + "Idigr", 0x003AA, // GREEK CAPITAL LETTER IOTA WITH DIALYTIKA + "idigr", 0x003CA, // GREEK SMALL LETTER IOTA WITH DIALYTIKA + "Idot", 0x00130, // LATIN CAPITAL LETTER I WITH DOT ABOVE + "IEcy", 0x00415, // CYRILLIC CAPITAL LETTER IE + "iecy", 0x00435, // CYRILLIC SMALL LETTER IE + "iexcl", 0x000A1, // INVERTED EXCLAMATION MARK + "iff", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "Ifr", 0x02111, // BLACK-LETTER CAPITAL I + "ifr", 0x1D526, // MATHEMATICAL FRAKTUR SMALL I + "Igr", 0x00399, // GREEK CAPITAL LETTER IOTA + "igr", 0x003B9, // GREEK SMALL LETTER IOTA + "Igrave", 0x000CC, // LATIN CAPITAL LETTER I WITH GRAVE + "igrave", 0x000EC, // LATIN SMALL LETTER I WITH GRAVE + "ii", 0x02148, // DOUBLE-STRUCK ITALIC SMALL I + "iiiint", 0x02A0C, // QUADRUPLE INTEGRAL OPERATOR + "iiint", 0x0222D, // TRIPLE INTEGRAL + "iinfin", 0x029DC, // INCOMPLETE INFINITY + "iiota", 0x02129, // TURNED GREEK SMALL LETTER IOTA + "IJlig", 0x00132, // LATIN CAPITAL LIGATURE IJ + "ijlig", 0x00133, // LATIN SMALL LIGATURE IJ + "Im", 0x02111, // BLACK-LETTER CAPITAL I + "Imacr", 0x0012A, // LATIN CAPITAL LETTER I WITH MACRON + "imacr", 0x0012B, // LATIN SMALL LETTER I WITH MACRON + "image", 0x02111, // BLACK-LETTER CAPITAL I + "ImaginaryI", 0x02148, // DOUBLE-STRUCK ITALIC SMALL I + "imagline", 0x02110, // SCRIPT CAPITAL I + "imagpart", 0x02111, // BLACK-LETTER CAPITAL I + "imath", 0x00131, // LATIN SMALL LETTER DOTLESS I + "imof", 0x022B7, // IMAGE OF + "imped", 0x001B5, // LATIN CAPITAL LETTER Z WITH STROKE + "Implies", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "in", 0x02208, // ELEMENT OF + "incare", 0x02105, // CARE OF + "infin", 0x0221E, // INFINITY + "infintie", 0x029DD, // TIE OVER INFINITY + "inodot", 0x00131, // LATIN SMALL LETTER DOTLESS I + "int", 0x0222B, // INTEGRAL + "Int", 0x0222C, // DOUBLE INTEGRAL + "intcal", 0x022BA, // INTERCALATE + "integers", 0x02124, // DOUBLE-STRUCK CAPITAL Z + "Integral", 0x0222B, // INTEGRAL + "intercal", 0x022BA, // INTERCALATE + "Intersection", 0x022C2, // N-ARY INTERSECTION + "intlarhk", 0x02A17, // INTEGRAL WITH LEFTWARDS ARROW WITH HOOK + "intprod", 0x02A3C, // INTERIOR PRODUCT + "InvisibleComma", 0x02063, // INVISIBLE SEPARATOR + "InvisibleTimes", 0x02062, // INVISIBLE TIMES + "IOcy", 0x00401, // CYRILLIC CAPITAL LETTER IO + "iocy", 0x00451, // CYRILLIC SMALL LETTER IO + "Iogon", 0x0012E, // LATIN CAPITAL LETTER I WITH OGONEK + "iogon", 0x0012F, // LATIN SMALL LETTER I WITH OGONEK + "Iopf", 0x1D540, // MATHEMATICAL DOUBLE-STRUCK CAPITAL I + "iopf", 0x1D55A, // MATHEMATICAL DOUBLE-STRUCK SMALL I + "Iota", 0x00399, // GREEK CAPITAL LETTER IOTA + "iota", 0x003B9, // GREEK SMALL LETTER IOTA + "iprod", 0x02A3C, // INTERIOR PRODUCT + "iquest", 0x000BF, // INVERTED QUESTION MARK + "Iscr", 0x02110, // SCRIPT CAPITAL I + "iscr", 0x1D4BE, // MATHEMATICAL SCRIPT SMALL I + "isin", 0x02208, // ELEMENT OF + "isindot", 0x022F5, // ELEMENT OF WITH DOT ABOVE + "isinE", 0x022F9, // ELEMENT OF WITH TWO HORIZONTAL STROKES + "isins", 0x022F4, // SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "isinsv", 0x022F3, // ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "isinv", 0x02208, // ELEMENT OF + "it", 0x02062, // INVISIBLE TIMES + "Itilde", 0x00128, // LATIN CAPITAL LETTER I WITH TILDE + "itilde", 0x00129, // LATIN SMALL LETTER I WITH TILDE + "Iukcy", 0x00406, // CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I + "iukcy", 0x00456, // CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I + "Iuml", 0x000CF, // LATIN CAPITAL LETTER I WITH DIAERESIS + "iuml", 0x000EF, // LATIN SMALL LETTER I WITH DIAERESIS + NULL, 0 }; static NameId namesJ[]={ - "Jcirc", 0x0134, - "jcirc", 0x0135, - "Jcy", 0x0419, - "jcy", 0x0439, - "Jsercy", 0x0408, - "jsercy", 0x0458, - "Jukcy", 0x0404, - "jukcy", 0x0454, - NULL, 0 + "Jcirc", 0x00134, // LATIN CAPITAL LETTER J WITH CIRCUMFLEX + "jcirc", 0x00135, // LATIN SMALL LETTER J WITH CIRCUMFLEX + "Jcy", 0x00419, // CYRILLIC CAPITAL LETTER SHORT I + "jcy", 0x00439, // CYRILLIC SMALL LETTER SHORT I + "Jfr", 0x1D50D, // MATHEMATICAL FRAKTUR CAPITAL J + "jfr", 0x1D527, // MATHEMATICAL FRAKTUR SMALL J + "jmath", 0x00237, // LATIN SMALL LETTER DOTLESS J + "Jopf", 0x1D541, // MATHEMATICAL DOUBLE-STRUCK CAPITAL J + "jopf", 0x1D55B, // MATHEMATICAL DOUBLE-STRUCK SMALL J + "Jscr", 0x1D4A5, // MATHEMATICAL SCRIPT CAPITAL J + "jscr", 0x1D4BF, // MATHEMATICAL SCRIPT SMALL J + "Jsercy", 0x00408, // CYRILLIC CAPITAL LETTER JE + "jsercy", 0x00458, // CYRILLIC SMALL LETTER JE + "Jukcy", 0x00404, // CYRILLIC CAPITAL LETTER UKRAINIAN IE + "jukcy", 0x00454, // CYRILLIC SMALL LETTER UKRAINIAN IE + NULL, 0 }; static NameId namesK[]={ - "kappa", 0x03BA, - "kappav", 0x03F0, - "Kcedil", 0x0136, - "kcedil", 0x0137, - "Kcy", 0x041A, - "kcy", 0x043A, - "Kgr", 0x039A, - "kgr", 0x03BA, - "kgreen", 0x0138, - "KHcy", 0x0425, - "khcy", 0x0445, - "KHgr", 0x03A7, - "khgr", 0x03C7, - "KJcy", 0x040C, - "kjcy", 0x045C, - NULL, 0 + "Kappa", 0x0039A, // GREEK CAPITAL LETTER KAPPA + "kappa", 0x003BA, // GREEK SMALL LETTER KAPPA + "kappav", 0x003F0, // GREEK KAPPA SYMBOL + "Kcedil", 0x00136, // LATIN CAPITAL LETTER K WITH CEDILLA + "kcedil", 0x00137, // LATIN SMALL LETTER K WITH CEDILLA + "Kcy", 0x0041A, // CYRILLIC CAPITAL LETTER KA + "kcy", 0x0043A, // CYRILLIC SMALL LETTER KA + "Kfr", 0x1D50E, // MATHEMATICAL FRAKTUR CAPITAL K + "kfr", 0x1D528, // MATHEMATICAL FRAKTUR SMALL K + "Kgr", 0x0039A, // GREEK CAPITAL LETTER KAPPA + "kgr", 0x003BA, // GREEK SMALL LETTER KAPPA + "kgreen", 0x00138, // LATIN SMALL LETTER KRA + "KHcy", 0x00425, // CYRILLIC CAPITAL LETTER HA + "khcy", 0x00445, // CYRILLIC SMALL LETTER HA + "KHgr", 0x003A7, // GREEK CAPITAL LETTER CHI + "khgr", 0x003C7, // GREEK SMALL LETTER CHI + "KJcy", 0x0040C, // CYRILLIC CAPITAL LETTER KJE + "kjcy", 0x0045C, // CYRILLIC SMALL LETTER KJE + "Kopf", 0x1D542, // MATHEMATICAL DOUBLE-STRUCK CAPITAL K + "kopf", 0x1D55C, // MATHEMATICAL DOUBLE-STRUCK SMALL K + "Kscr", 0x1D4A6, // MATHEMATICAL SCRIPT CAPITAL K + "kscr", 0x1D4C0, // MATHEMATICAL SCRIPT SMALL K + NULL, 0 }; static NameId namesL[]={ - "lAarr", 0x21DA, - "Lacute", 0x0139, - "lacute", 0x013A, - "lagran", 0x2112, - "Lambda", 0x039B, - "lambda", 0x03BB, - "lang", 0x3008, - "lap", 0x2272, - "laquo", 0x00AB, - "larr", 0x2190, - "Larr", 0x219E, - "lArr", 0x21D0, - "larr2", 0x21C7, - "larrhk", 0x21A9, - "larrlp", 0x21AB, - "larrtl", 0x21A2, - "Lcaron", 0x013D, - "lcaron", 0x013E, - "Lcedil", 0x013B, - "lcedil", 0x013C, - "lceil", 0x2308, - "lcub", 0x007B, - "Lcy", 0x041B, - "lcy", 0x043B, - "ldot", 0x22D6, - "ldquo", 0x201C, - "ldquor", 0x201E, - "le", 0x2264, - "lE", 0x2266, - "leg", 0x22DA, - "lEg", 0x22DA, - "les", 0x2264, - "lfloor", 0x230A, - "lg", 0x2276, - "Lgr", 0x039B, - "lgr", 0x03BB, - "lhard", 0x21BD, - "lharu", 0x21BC, - "lhblk", 0x2584, - "LJcy", 0x0409, - "ljcy", 0x0459, - "Ll", 0x22D8, - "Lmidot", 0x013F, - "lmidot", 0x0140, - "lnap", 0xE2A2, - "lne", 0x2268, - "lnE", 0x2268, - "lnsim", 0x22E6, - "lowast", 0x2217, - "lowbar", 0x005F, - "loz", 0x25CA, - "lozf", 0x2726, - "lpar", 0x0028, - "lrarr2", 0x21C6, - "lrhar2", 0x21CB, - "lsh", 0x21B0, - "lsim", 0x2272, - "lsqb", 0x005B, - "lsquo", 0x2018, - "lsquor", 0x201A, - "Lstrok", 0x0141, - "lstrok", 0x0142, - "lt", 0x003C, - "Lt", 0x226A, - "lthree", 0x22CB, - "ltimes", 0x22C9, - "ltri", 0x25C3, - "ltrie", 0x22B4, - "ltrif", 0x25C2, - "lvnE", 0x2268, - NULL, 0 + "lAarr", 0x021DA, // LEFTWARDS TRIPLE ARROW + "Lacute", 0x00139, // LATIN CAPITAL LETTER L WITH ACUTE + "lacute", 0x0013A, // LATIN SMALL LETTER L WITH ACUTE + "laemptyv", 0x029B4, // EMPTY SET WITH LEFT ARROW ABOVE + "lagran", 0x02112, // SCRIPT CAPITAL L + "Lambda", 0x0039B, // GREEK CAPITAL LETTER LAMDA + "lambda", 0x003BB, // GREEK SMALL LETTER LAMDA + "lang", 0x027E8, // MATHEMATICAL LEFT ANGLE BRACKET + "Lang", 0x027EA, // MATHEMATICAL LEFT DOUBLE ANGLE BRACKET + "langd", 0x02991, // LEFT ANGLE BRACKET WITH DOT + "langle", 0x027E8, // MATHEMATICAL LEFT ANGLE BRACKET + "lap", 0x02A85, // LESS-THAN OR APPROXIMATE + "Laplacetrf", 0x02112, // SCRIPT CAPITAL L + "laquo", 0x000AB, // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK + "larr", 0x02190, // LEFTWARDS ARROW + "Larr", 0x0219E, // LEFTWARDS TWO HEADED ARROW + "lArr", 0x021D0, // LEFTWARDS DOUBLE ARROW + "larrb", 0x021E4, // LEFTWARDS ARROW TO BAR + "larrbfs", 0x0291F, // LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND + "larrfs", 0x0291D, // LEFTWARDS ARROW TO BLACK DIAMOND + "larrhk", 0x021A9, // LEFTWARDS ARROW WITH HOOK + "larrlp", 0x021AB, // LEFTWARDS ARROW WITH LOOP + "larrpl", 0x02939, // LEFT-SIDE ARC ANTICLOCKWISE ARROW + "larrsim", 0x02973, // LEFTWARDS ARROW ABOVE TILDE OPERATOR + "larrtl", 0x021A2, // LEFTWARDS ARROW WITH TAIL + "lat", 0x02AAB, // LARGER THAN + "latail", 0x02919, // LEFTWARDS ARROW-TAIL + "lAtail", 0x0291B, // LEFTWARDS DOUBLE ARROW-TAIL + "late", 0x02AAD, // LARGER THAN OR EQUAL TO +// "lates", 0x02AAD;0x0FE00, // LARGER THAN OR slanted EQUAL + "lbarr", 0x0290C, // LEFTWARDS DOUBLE DASH ARROW + "lBarr", 0x0290E, // LEFTWARDS TRIPLE DASH ARROW + "lbbrk", 0x02772, // LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT + "lbrace", 0x0007B, // LEFT CURLY BRACKET + "lbrack", 0x0005B, // LEFT SQUARE BRACKET + "lbrke", 0x0298B, // LEFT SQUARE BRACKET WITH UNDERBAR + "lbrksld", 0x0298F, // LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER + "lbrkslu", 0x0298D, // LEFT SQUARE BRACKET WITH TICK IN TOP CORNER + "Lcaron", 0x0013D, // LATIN CAPITAL LETTER L WITH CARON + "lcaron", 0x0013E, // LATIN SMALL LETTER L WITH CARON + "Lcedil", 0x0013B, // LATIN CAPITAL LETTER L WITH CEDILLA + "lcedil", 0x0013C, // LATIN SMALL LETTER L WITH CEDILLA + "lceil", 0x02308, // LEFT CEILING + "lcub", 0x0007B, // LEFT CURLY BRACKET + "Lcy", 0x0041B, // CYRILLIC CAPITAL LETTER EL + "lcy", 0x0043B, // CYRILLIC SMALL LETTER EL + "ldca", 0x02936, // ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS + "ldquo", 0x0201C, // LEFT DOUBLE QUOTATION MARK + "ldquor", 0x0201E, // DOUBLE LOW-9 QUOTATION MARK + "ldrdhar", 0x02967, // LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN + "ldrushar", 0x0294B, // LEFT BARB DOWN RIGHT BARB UP HARPOON + "ldsh", 0x021B2, // DOWNWARDS ARROW WITH TIP LEFTWARDS + "le", 0x02264, // LESS-THAN OR EQUAL TO + "lE", 0x02266, // LESS-THAN OVER EQUAL TO + "LeftAngleBracket", 0x027E8, // MATHEMATICAL LEFT ANGLE BRACKET + "leftarrow", 0x02190, // LEFTWARDS ARROW + "LeftArrow", 0x02190, // LEFTWARDS ARROW + "Leftarrow", 0x021D0, // LEFTWARDS DOUBLE ARROW + "LeftArrowBar", 0x021E4, // LEFTWARDS ARROW TO BAR + "LeftArrowRightArrow", 0x021C6, // LEFTWARDS ARROW OVER RIGHTWARDS ARROW + "leftarrowtail", 0x021A2, // LEFTWARDS ARROW WITH TAIL + "LeftCeiling", 0x02308, // LEFT CEILING + "LeftDoubleBracket", 0x027E6, // MATHEMATICAL LEFT WHITE SQUARE BRACKET + "LeftDownTeeVector", 0x02961, // DOWNWARDS HARPOON WITH BARB LEFT FROM BAR + "LeftDownVector", 0x021C3, // DOWNWARDS HARPOON WITH BARB LEFTWARDS + "LeftDownVectorBar", 0x02959, // DOWNWARDS HARPOON WITH BARB LEFT TO BAR + "LeftFloor", 0x0230A, // LEFT FLOOR + "leftharpoondown", 0x021BD, // LEFTWARDS HARPOON WITH BARB DOWNWARDS + "leftharpoonup", 0x021BC, // LEFTWARDS HARPOON WITH BARB UPWARDS + "leftleftarrows", 0x021C7, // LEFTWARDS PAIRED ARROWS + "leftrightarrow", 0x02194, // LEFT RIGHT ARROW + "LeftRightArrow", 0x02194, // LEFT RIGHT ARROW + "Leftrightarrow", 0x021D4, // LEFT RIGHT DOUBLE ARROW + "leftrightarrows", 0x021C6, // LEFTWARDS ARROW OVER RIGHTWARDS ARROW + "leftrightharpoons", 0x021CB, // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON + "leftrightsquigarrow", 0x021AD, // LEFT RIGHT WAVE ARROW + "LeftRightVector", 0x0294E, // LEFT BARB UP RIGHT BARB UP HARPOON + "LeftTee", 0x022A3, // LEFT TACK + "LeftTeeArrow", 0x021A4, // LEFTWARDS ARROW FROM BAR + "LeftTeeVector", 0x0295A, // LEFTWARDS HARPOON WITH BARB UP FROM BAR + "leftthreetimes", 0x022CB, // LEFT SEMIDIRECT PRODUCT + "LeftTriangle", 0x022B2, // NORMAL SUBGROUP OF + "LeftTriangleBar", 0x029CF, // LEFT TRIANGLE BESIDE VERTICAL BAR + "LeftTriangleEqual", 0x022B4, // NORMAL SUBGROUP OF OR EQUAL TO + "LeftUpDownVector", 0x02951, // UP BARB LEFT DOWN BARB LEFT HARPOON + "LeftUpTeeVector", 0x02960, // UPWARDS HARPOON WITH BARB LEFT FROM BAR + "LeftUpVector", 0x021BF, // UPWARDS HARPOON WITH BARB LEFTWARDS + "LeftUpVectorBar", 0x02958, // UPWARDS HARPOON WITH BARB LEFT TO BAR + "LeftVector", 0x021BC, // LEFTWARDS HARPOON WITH BARB UPWARDS + "LeftVectorBar", 0x02952, // LEFTWARDS HARPOON WITH BARB UP TO BAR + "leg", 0x022DA, // LESS-THAN EQUAL TO OR GREATER-THAN + "lEg", 0x02A8B, // LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN + "leq", 0x02264, // LESS-THAN OR EQUAL TO + "leqq", 0x02266, // LESS-THAN OVER EQUAL TO + "leqslant", 0x02A7D, // LESS-THAN OR SLANTED EQUAL TO + "les", 0x02A7D, // LESS-THAN OR SLANTED EQUAL TO + "lescc", 0x02AA8, // LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL + "lesdot", 0x02A7F, // LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE + "lesdoto", 0x02A81, // LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE + "lesdotor", 0x02A83, // LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT +// "lesg", 0x022DA;0x0FE00, // LESS-THAN slanted EQUAL TO OR GREATER-THAN + "lesges", 0x02A93, // LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL + "lessapprox", 0x02A85, // LESS-THAN OR APPROXIMATE + "lessdot", 0x022D6, // LESS-THAN WITH DOT + "lesseqgtr", 0x022DA, // LESS-THAN EQUAL TO OR GREATER-THAN + "lesseqqgtr", 0x02A8B, // LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN + "LessEqualGreater", 0x022DA, // LESS-THAN EQUAL TO OR GREATER-THAN + "LessFullEqual", 0x02266, // LESS-THAN OVER EQUAL TO + "LessGreater", 0x02276, // LESS-THAN OR GREATER-THAN + "lessgtr", 0x02276, // LESS-THAN OR GREATER-THAN + "LessLess", 0x02AA1, // DOUBLE NESTED LESS-THAN + "lesssim", 0x02272, // LESS-THAN OR EQUIVALENT TO + "LessSlantEqual", 0x02A7D, // LESS-THAN OR SLANTED EQUAL TO + "LessTilde", 0x02272, // LESS-THAN OR EQUIVALENT TO + "lfisht", 0x0297C, // LEFT FISH TAIL + "lfloor", 0x0230A, // LEFT FLOOR + "Lfr", 0x1D50F, // MATHEMATICAL FRAKTUR CAPITAL L + "lfr", 0x1D529, // MATHEMATICAL FRAKTUR SMALL L + "lg", 0x02276, // LESS-THAN OR GREATER-THAN + "lgE", 0x02A91, // LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL + "Lgr", 0x0039B, // GREEK CAPITAL LETTER LAMDA + "lgr", 0x003BB, // GREEK SMALL LETTER LAMDA + "lHar", 0x02962, // LEFTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB DOWN + "lhard", 0x021BD, // LEFTWARDS HARPOON WITH BARB DOWNWARDS + "lharu", 0x021BC, // LEFTWARDS HARPOON WITH BARB UPWARDS + "lharul", 0x0296A, // LEFTWARDS HARPOON WITH BARB UP ABOVE LONG DASH + "lhblk", 0x02584, // LOWER HALF BLOCK + "LJcy", 0x00409, // CYRILLIC CAPITAL LETTER LJE + "ljcy", 0x00459, // CYRILLIC SMALL LETTER LJE + "ll", 0x0226A, // MUCH LESS-THAN + "Ll", 0x022D8, // VERY MUCH LESS-THAN + "llarr", 0x021C7, // LEFTWARDS PAIRED ARROWS + "llcorner", 0x0231E, // BOTTOM LEFT CORNER + "Lleftarrow", 0x021DA, // LEFTWARDS TRIPLE ARROW + "llhard", 0x0296B, // LEFTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH + "lltri", 0x025FA, // LOWER LEFT TRIANGLE + "Lmidot", 0x0013F, // LATIN CAPITAL LETTER L WITH MIDDLE DOT + "lmidot", 0x00140, // LATIN SMALL LETTER L WITH MIDDLE DOT + "lmoust", 0x023B0, // UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION + "lmoustache", 0x023B0, // UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION + "lnap", 0x02A89, // LESS-THAN AND NOT APPROXIMATE + "lnapprox", 0x02A89, // LESS-THAN AND NOT APPROXIMATE + "lnE", 0x02268, // LESS-THAN BUT NOT EQUAL TO + "lne", 0x02A87, // LESS-THAN AND SINGLE-LINE NOT EQUAL TO + "lneq", 0x02A87, // LESS-THAN AND SINGLE-LINE NOT EQUAL TO + "lneqq", 0x02268, // LESS-THAN BUT NOT EQUAL TO + "lnsim", 0x022E6, // LESS-THAN BUT NOT EQUIVALENT TO + "loang", 0x027EC, // MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET + "loarr", 0x021FD, // LEFTWARDS OPEN-HEADED ARROW + "lobrk", 0x027E6, // MATHEMATICAL LEFT WHITE SQUARE BRACKET + "longleftarrow", 0x027F5, // LONG LEFTWARDS ARROW + "LongLeftArrow", 0x027F5, // LONG LEFTWARDS ARROW + "Longleftarrow", 0x027F8, // LONG LEFTWARDS DOUBLE ARROW + "longleftrightarrow", 0x027F7, // LONG LEFT RIGHT ARROW + "LongLeftRightArrow", 0x027F7, // LONG LEFT RIGHT ARROW + "Longleftrightarrow", 0x027FA, // LONG LEFT RIGHT DOUBLE ARROW + "longmapsto", 0x027FC, // LONG RIGHTWARDS ARROW FROM BAR + "longrightarrow", 0x027F6, // LONG RIGHTWARDS ARROW + "LongRightArrow", 0x027F6, // LONG RIGHTWARDS ARROW + "Longrightarrow", 0x027F9, // LONG RIGHTWARDS DOUBLE ARROW + "looparrowleft", 0x021AB, // LEFTWARDS ARROW WITH LOOP + "looparrowright", 0x021AC, // RIGHTWARDS ARROW WITH LOOP + "lopar", 0x02985, // LEFT WHITE PARENTHESIS + "Lopf", 0x1D543, // MATHEMATICAL DOUBLE-STRUCK CAPITAL L + "lopf", 0x1D55D, // MATHEMATICAL DOUBLE-STRUCK SMALL L + "loplus", 0x02A2D, // PLUS SIGN IN LEFT HALF CIRCLE + "lotimes", 0x02A34, // MULTIPLICATION SIGN IN LEFT HALF CIRCLE + "lowast", 0x02217, // ASTERISK OPERATOR + "lowbar", 0x0005F, // LOW LINE + "LowerLeftArrow", 0x02199, // SOUTH WEST ARROW + "LowerRightArrow", 0x02198, // SOUTH EAST ARROW + "loz", 0x025CA, // LOZENGE + "lozenge", 0x025CA, // LOZENGE + "lozf", 0x029EB, // BLACK LOZENGE + "lpar", 0x00028, // LEFT PARENTHESIS + "lparlt", 0x02993, // LEFT ARC LESS-THAN BRACKET + "lrarr", 0x021C6, // LEFTWARDS ARROW OVER RIGHTWARDS ARROW + "lrcorner", 0x0231F, // BOTTOM RIGHT CORNER + "lrhar", 0x021CB, // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON + "lrhard", 0x0296D, // RIGHTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH + "lrm", 0x0200E, // LEFT-TO-RIGHT MARK + "lrtri", 0x022BF, // RIGHT TRIANGLE + "lsaquo", 0x02039, // SINGLE LEFT-POINTING ANGLE QUOTATION MARK + "Lscr", 0x02112, // SCRIPT CAPITAL L + "lscr", 0x1D4C1, // MATHEMATICAL SCRIPT SMALL L + "lsh", 0x021B0, // UPWARDS ARROW WITH TIP LEFTWARDS + "Lsh", 0x021B0, // UPWARDS ARROW WITH TIP LEFTWARDS + "lsim", 0x02272, // LESS-THAN OR EQUIVALENT TO + "lsime", 0x02A8D, // LESS-THAN ABOVE SIMILAR OR EQUAL + "lsimg", 0x02A8F, // LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN + "lsqb", 0x0005B, // LEFT SQUARE BRACKET + "lsquo", 0x02018, // LEFT SINGLE QUOTATION MARK + "lsquor", 0x0201A, // SINGLE LOW-9 QUOTATION MARK + "Lstrok", 0x00141, // LATIN CAPITAL LETTER L WITH STROKE + "lstrok", 0x00142, // LATIN SMALL LETTER L WITH STROKE + "lt", 0x0003C, // LESS-THAN SIGN + "LT", 0x0003C, // LESS-THAN SIGN + "Lt", 0x0226A, // MUCH LESS-THAN + "ltcc", 0x02AA6, // LESS-THAN CLOSED BY CURVE + "ltcir", 0x02A79, // LESS-THAN WITH CIRCLE INSIDE + "ltdot", 0x022D6, // LESS-THAN WITH DOT + "lthree", 0x022CB, // LEFT SEMIDIRECT PRODUCT + "ltimes", 0x022C9, // LEFT NORMAL FACTOR SEMIDIRECT PRODUCT + "ltlarr", 0x02976, // LESS-THAN ABOVE LEFTWARDS ARROW + "ltquest", 0x02A7B, // LESS-THAN WITH QUESTION MARK ABOVE + "ltri", 0x025C3, // WHITE LEFT-POINTING SMALL TRIANGLE + "ltrie", 0x022B4, // NORMAL SUBGROUP OF OR EQUAL TO + "ltrif", 0x025C2, // BLACK LEFT-POINTING SMALL TRIANGLE + "ltrPar", 0x02996, // DOUBLE RIGHT ARC LESS-THAN BRACKET + "lurdshar", 0x0294A, // LEFT BARB UP RIGHT BARB DOWN HARPOON + "luruhar", 0x02966, // LEFTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB UP +// "lvertneqq", 0x02268;0x0FE00, // LESS-THAN BUT NOT EQUAL TO - with vertical stroke +// "lvnE", 0x02268;0x0FE00, // LESS-THAN BUT NOT EQUAL TO - with vertical stroke + NULL, 0 }; static NameId namesM[]={ - "macr", 0x00AF, - "male", 0x2642, - "malt", 0x2720, - "map", 0x21A6, - "marker", 0x25AE, - "Mcy", 0x041C, - "mcy", 0x043C, - "mdash", 0x2014, - "Mgr", 0x039C, - "mgr", 0x03BC, - "micro", 0x00B5, - "mid", 0x2223, - "middot", 0x00B7, - "minus", 0x2212, - "minusb", 0x229F, - "mldr", 0x2026, - "mnplus", 0x2213, - "models", 0x22A7, - "mu", 0x03BC, - "mumap", 0x22B8, - NULL, 0 + "macr", 0x000AF, // MACRON + "male", 0x02642, // MALE SIGN + "malt", 0x02720, // MALTESE CROSS + "maltese", 0x02720, // MALTESE CROSS + "map", 0x021A6, // RIGHTWARDS ARROW FROM BAR + "Map", 0x02905, // RIGHTWARDS TWO-HEADED ARROW FROM BAR + "mapsto", 0x021A6, // RIGHTWARDS ARROW FROM BAR + "mapstodown", 0x021A7, // DOWNWARDS ARROW FROM BAR + "mapstoleft", 0x021A4, // LEFTWARDS ARROW FROM BAR + "mapstoup", 0x021A5, // UPWARDS ARROW FROM BAR + "marker", 0x025AE, // BLACK VERTICAL RECTANGLE + "mcomma", 0x02A29, // MINUS SIGN WITH COMMA ABOVE + "Mcy", 0x0041C, // CYRILLIC CAPITAL LETTER EM + "mcy", 0x0043C, // CYRILLIC SMALL LETTER EM + "mdash", 0x02014, // EM DASH + "mDDot", 0x0223A, // GEOMETRIC PROPORTION + "measuredangle", 0x02221, // MEASURED ANGLE + "MediumSpace", 0x0205F, // MEDIUM MATHEMATICAL SPACE + "Mellintrf", 0x02133, // SCRIPT CAPITAL M + "Mfr", 0x1D510, // MATHEMATICAL FRAKTUR CAPITAL M + "mfr", 0x1D52A, // MATHEMATICAL FRAKTUR SMALL M + "Mgr", 0x0039C, // GREEK CAPITAL LETTER MU + "mgr", 0x003BC, // GREEK SMALL LETTER MU + "mho", 0x02127, // INVERTED OHM SIGN + "micro", 0x000B5, // MICRO SIGN + "mid", 0x02223, // DIVIDES + "midast", 0x0002A, // ASTERISK + "midcir", 0x02AF0, // VERTICAL LINE WITH CIRCLE BELOW + "middot", 0x000B7, // MIDDLE DOT + "minus", 0x02212, // MINUS SIGN + "minusb", 0x0229F, // SQUARED MINUS + "minusd", 0x02238, // DOT MINUS + "minusdu", 0x02A2A, // MINUS SIGN WITH DOT BELOW + "MinusPlus", 0x02213, // MINUS-OR-PLUS SIGN + "mlcp", 0x02ADB, // TRANSVERSAL INTERSECTION + "mldr", 0x02026, // HORIZONTAL ELLIPSIS + "mnplus", 0x02213, // MINUS-OR-PLUS SIGN + "models", 0x022A7, // MODELS + "Mopf", 0x1D544, // MATHEMATICAL DOUBLE-STRUCK CAPITAL M + "mopf", 0x1D55E, // MATHEMATICAL DOUBLE-STRUCK SMALL M + "mp", 0x02213, // MINUS-OR-PLUS SIGN + "Mscr", 0x02133, // SCRIPT CAPITAL M + "mscr", 0x1D4C2, // MATHEMATICAL SCRIPT SMALL M + "mstpos", 0x0223E, // INVERTED LAZY S + "Mu", 0x0039C, // GREEK CAPITAL LETTER MU + "mu", 0x003BC, // GREEK SMALL LETTER MU + "multimap", 0x022B8, // MULTIMAP + "mumap", 0x022B8, // MULTIMAP + NULL, 0 }; static NameId namesN[]={ - "nabla", 0x2207, - "Nacute", 0x0143, - "nacute", 0x0144, - "nap", 0x2249, - "napos", 0x0149, - "natur", 0x266E, -// "nbsp", 0x00A0, - "nbsp", 32, // make non-breaking space appear as space - "Ncaron", 0x0147, - "ncaron", 0x0148, - "Ncedil", 0x0145, - "ncedil", 0x0146, - "ncong", 0x2247, - "Ncy", 0x041D, - "ncy", 0x043D, - "ndash", 0x2013, - "ne", 0x2260, - "nearr", 0x2197, - "nequiv", 0x2262, - "nexist", 0x2204, - "nge", 0x2271, - "ngE", 0x2271, - "nges", 0x2271, - "Ngr", 0x039D, - "ngr", 0x03BD, - "ngt", 0x226F, - "nharr", 0x21AE, - "nhArr", 0x21CE, - "ni", 0x220D, - "NJcy", 0x040A, - "njcy", 0x045A, - "nlarr", 0x219A, - "nlArr", 0x21CD, - "nldr", 0x2025, - "nle", 0x2270, - "nlE", 0x2270, - "nles", 0x2270, - "nlt", 0x226E, - "nltri", 0x22EA, - "nltrie", 0x22EC, - "nmid", 0x2224, - "not", 0x00AC, - "notin", 0x2209, - "npar", 0x2226, - "npr", 0x2280, - "npre", 0x22E0, - "nrarr", 0x219B, - "nrArr", 0x21CF, - "nrtri", 0x22EB, - "nrtrie", 0x22ED, - "nsc", 0x2281, - "nsce", 0x22E1, - "nsim", 0x2241, - "nsime", 0x2244, - "nsmid", 0xE2AA, - "nspar", 0x2226, - "nsub", 0x2284, - "nsube", 0x2288, - "nsubE", 0x2288, - "nsup", 0x2285, - "nsupe", 0x2289, - "nsupE", 0x2289, - "Ntilde", 0x00D1, - "ntilde", 0x00F1, - "nu", 0x03BD, - "num", 0x0023, - "numero", 0x2116, - "numsp", 0x2007, - "nvdash", 0x22AC, - "nvDash", 0x22AD, - "nVdash", 0x22AE, - "nVDash", 0x22AF, - "nwarr", 0x2196, - NULL, 0 + "nabla", 0x02207, // NABLA + "Nacute", 0x00143, // LATIN CAPITAL LETTER N WITH ACUTE + "nacute", 0x00144, // LATIN SMALL LETTER N WITH ACUTE +// "nang", 0x02220;0x020D2, // ANGLE with vertical line + "nap", 0x02249, // NOT ALMOST EQUAL TO +// "napE", 0x02A70;0x00338, // APPROXIMATELY EQUAL OR EQUAL TO with slash +// "napid", 0x0224B;0x00338, // TRIPLE TILDE with slash + "napos", 0x00149, // LATIN SMALL LETTER N PRECEDED BY APOSTROPHE + "napprox", 0x02249, // NOT ALMOST EQUAL TO + "natur", 0x0266E, // MUSIC NATURAL SIGN + "natural", 0x0266E, // MUSIC NATURAL SIGN + "naturals", 0x02115, // DOUBLE-STRUCK CAPITAL N + "nbsp", 0x000A0, // NO-BREAK SPACE +// "nbump", 0x0224E;0x00338, // GEOMETRICALLY EQUIVALENT TO with slash +// "nbumpe", 0x0224F;0x00338, // DIFFERENCE BETWEEN with slash + "ncap", 0x02A43, // INTERSECTION WITH OVERBAR + "Ncaron", 0x00147, // LATIN CAPITAL LETTER N WITH CARON + "ncaron", 0x00148, // LATIN SMALL LETTER N WITH CARON + "Ncedil", 0x00145, // LATIN CAPITAL LETTER N WITH CEDILLA + "ncedil", 0x00146, // LATIN SMALL LETTER N WITH CEDILLA + "ncong", 0x02247, // NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO +// "ncongdot", 0x02A6D;0x00338, // CONGRUENT WITH DOT ABOVE with slash + "ncup", 0x02A42, // UNION WITH OVERBAR + "Ncy", 0x0041D, // CYRILLIC CAPITAL LETTER EN + "ncy", 0x0043D, // CYRILLIC SMALL LETTER EN + "ndash", 0x02013, // EN DASH + "ne", 0x02260, // NOT EQUAL TO + "nearhk", 0x02924, // NORTH EAST ARROW WITH HOOK + "nearr", 0x02197, // NORTH EAST ARROW + "neArr", 0x021D7, // NORTH EAST DOUBLE ARROW + "nearrow", 0x02197, // NORTH EAST ARROW +// "nedot", 0x02250;0x00338, // APPROACHES THE LIMIT with slash + "NegativeMediumSpace", 0x0200B, // ZERO WIDTH SPACE + "NegativeThickSpace", 0x0200B, // ZERO WIDTH SPACE + "NegativeThinSpace", 0x0200B, // ZERO WIDTH SPACE + "NegativeVeryThinSpace", 0x0200B, // ZERO WIDTH SPACE + "nequiv", 0x02262, // NOT IDENTICAL TO + "nesear", 0x02928, // NORTH EAST ARROW AND SOUTH EAST ARROW +// "nesim", 0x02242;0x00338, // MINUS TILDE with slash + "NestedGreaterGreater", 0x0226B, // MUCH GREATER-THAN + "NestedLessLess", 0x0226A, // MUCH LESS-THAN + "NewLine", 0x0000A, // LINE FEED (LF) + "nexist", 0x02204, // THERE DOES NOT EXIST + "nexists", 0x02204, // THERE DOES NOT EXIST + "Nfr", 0x1D511, // MATHEMATICAL FRAKTUR CAPITAL N + "nfr", 0x1D52B, // MATHEMATICAL FRAKTUR SMALL N +// "ngE", 0x02267;0x00338, // GREATER-THAN OVER EQUAL TO with slash + "nge", 0x02271, // NEITHER GREATER-THAN NOR EQUAL TO + "ngeq", 0x02271, // NEITHER GREATER-THAN NOR EQUAL TO +// "ngeqq", 0x02267;0x00338, // GREATER-THAN OVER EQUAL TO with slash +// "ngeqslant", 0x02A7E;0x00338, // GREATER-THAN OR SLANTED EQUAL TO with slash +// "nges", 0x02A7E;0x00338, // GREATER-THAN OR SLANTED EQUAL TO with slash +// "nGg", 0x022D9;0x00338, // VERY MUCH GREATER-THAN with slash + "Ngr", 0x0039D, // GREEK CAPITAL LETTER NU + "ngr", 0x003BD, // GREEK SMALL LETTER NU + "ngsim", 0x02275, // NEITHER GREATER-THAN NOR EQUIVALENT TO +// "nGt", 0x0226B;0x020D2, // MUCH GREATER THAN with vertical line + "ngt", 0x0226F, // NOT GREATER-THAN + "ngtr", 0x0226F, // NOT GREATER-THAN +// "nGtv", 0x0226B;0x00338, // MUCH GREATER THAN with slash + "nharr", 0x021AE, // LEFT RIGHT ARROW WITH STROKE + "nhArr", 0x021CE, // LEFT RIGHT DOUBLE ARROW WITH STROKE + "nhpar", 0x02AF2, // PARALLEL WITH HORIZONTAL STROKE + "ni", 0x0220B, // CONTAINS AS MEMBER + "nis", 0x022FC, // SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "nisd", 0x022FA, // CONTAINS WITH LONG HORIZONTAL STROKE + "niv", 0x0220B, // CONTAINS AS MEMBER + "NJcy", 0x0040A, // CYRILLIC CAPITAL LETTER NJE + "njcy", 0x0045A, // CYRILLIC SMALL LETTER NJE + "nlarr", 0x0219A, // LEFTWARDS ARROW WITH STROKE + "nlArr", 0x021CD, // LEFTWARDS DOUBLE ARROW WITH STROKE + "nldr", 0x02025, // TWO DOT LEADER +// "nlE", 0x02266;0x00338, // LESS-THAN OVER EQUAL TO with slash + "nle", 0x02270, // NEITHER LESS-THAN NOR EQUAL TO + "nleftarrow", 0x0219A, // LEFTWARDS ARROW WITH STROKE + "nLeftarrow", 0x021CD, // LEFTWARDS DOUBLE ARROW WITH STROKE + "nleftrightarrow", 0x021AE, // LEFT RIGHT ARROW WITH STROKE + "nLeftrightarrow", 0x021CE, // LEFT RIGHT DOUBLE ARROW WITH STROKE + "nleq", 0x02270, // NEITHER LESS-THAN NOR EQUAL TO +// "nleqq", 0x02266;0x00338, // LESS-THAN OVER EQUAL TO with slash +// "nleqslant", 0x02A7D;0x00338, // LESS-THAN OR SLANTED EQUAL TO with slash +// "nles", 0x02A7D;0x00338, // LESS-THAN OR SLANTED EQUAL TO with slash + "nless", 0x0226E, // NOT LESS-THAN +// "nLl", 0x022D8;0x00338, // VERY MUCH LESS-THAN with slash + "nlsim", 0x02274, // NEITHER LESS-THAN NOR EQUIVALENT TO +// "nLt", 0x0226A;0x020D2, // MUCH LESS THAN with vertical line + "nlt", 0x0226E, // NOT LESS-THAN + "nltri", 0x022EA, // NOT NORMAL SUBGROUP OF + "nltrie", 0x022EC, // NOT NORMAL SUBGROUP OF OR EQUAL TO +// "nLtv", 0x0226A;0x00338, // MUCH LESS THAN with slash + "nmid", 0x02224, // DOES NOT DIVIDE + "NoBreak", 0x02060, // WORD JOINER + "NonBreakingSpace", 0x000A0, // NO-BREAK SPACE + "Nopf", 0x02115, // DOUBLE-STRUCK CAPITAL N + "nopf", 0x1D55F, // MATHEMATICAL DOUBLE-STRUCK SMALL N + "not", 0x000AC, // NOT SIGN + "Not", 0x02AEC, // DOUBLE STROKE NOT SIGN + "NotCongruent", 0x02262, // NOT IDENTICAL TO + "NotCupCap", 0x0226D, // NOT EQUIVALENT TO + "NotDoubleVerticalBar", 0x02226, // NOT PARALLEL TO + "NotElement", 0x02209, // NOT AN ELEMENT OF + "NotEqual", 0x02260, // NOT EQUAL TO +// "NotEqualTilde", 0x02242;0x00338, // MINUS TILDE with slash + "NotExists", 0x02204, // THERE DOES NOT EXIST + "NotGreater", 0x0226F, // NOT GREATER-THAN + "NotGreaterEqual", 0x02271, // NEITHER GREATER-THAN NOR EQUAL TO +// "NotGreaterFullEqual", 0x02267;0x00338, // GREATER-THAN OVER EQUAL TO with slash +// "NotGreaterGreater", 0x0226B;0x00338, // MUCH GREATER THAN with slash + "NotGreaterLess", 0x02279, // NEITHER GREATER-THAN NOR LESS-THAN +// "NotGreaterSlantEqual", 0x02A7E;0x00338, // GREATER-THAN OR SLANTED EQUAL TO with slash + "NotGreaterTilde", 0x02275, // NEITHER GREATER-THAN NOR EQUIVALENT TO +// "NotHumpDownHump", 0x0224E;0x00338, // GEOMETRICALLY EQUIVALENT TO with slash +// "NotHumpEqual", 0x0224F;0x00338, // DIFFERENCE BETWEEN with slash + "notin", 0x02209, // NOT AN ELEMENT OF +// "notindot", 0x022F5;0x00338, // ELEMENT OF WITH DOT ABOVE with slash +// "notinE", 0x022F9;0x00338, // ELEMENT OF WITH TWO HORIZONTAL STROKES with slash + "notinva", 0x02209, // NOT AN ELEMENT OF + "notinvb", 0x022F7, // SMALL ELEMENT OF WITH OVERBAR + "notinvc", 0x022F6, // ELEMENT OF WITH OVERBAR + "NotLeftTriangle", 0x022EA, // NOT NORMAL SUBGROUP OF +// "NotLeftTriangleBar", 0x029CF;0x00338, // LEFT TRIANGLE BESIDE VERTICAL BAR with slash + "NotLeftTriangleEqual", 0x022EC, // NOT NORMAL SUBGROUP OF OR EQUAL TO + "NotLess", 0x0226E, // NOT LESS-THAN + "NotLessEqual", 0x02270, // NEITHER LESS-THAN NOR EQUAL TO + "NotLessGreater", 0x02278, // NEITHER LESS-THAN NOR GREATER-THAN +// "NotLessLess", 0x0226A;0x00338, // MUCH LESS THAN with slash +// "NotLessSlantEqual", 0x02A7D;0x00338, // LESS-THAN OR SLANTED EQUAL TO with slash + "NotLessTilde", 0x02274, // NEITHER LESS-THAN NOR EQUIVALENT TO +// "NotNestedGreaterGreater", 0x02AA2;0x00338, // DOUBLE NESTED GREATER-THAN with slash +// "NotNestedLessLess", 0x02AA1;0x00338, // DOUBLE NESTED LESS-THAN with slash + "notni", 0x0220C, // DOES NOT CONTAIN AS MEMBER + "notniva", 0x0220C, // DOES NOT CONTAIN AS MEMBER + "notnivb", 0x022FE, // SMALL CONTAINS WITH OVERBAR + "notnivc", 0x022FD, // CONTAINS WITH OVERBAR + "NotPrecedes", 0x02280, // DOES NOT PRECEDE +// "NotPrecedesEqual", 0x02AAF;0x00338, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash + "NotPrecedesSlantEqual", 0x022E0, // DOES NOT PRECEDE OR EQUAL + "NotReverseElement", 0x0220C, // DOES NOT CONTAIN AS MEMBER + "NotRightTriangle", 0x022EB, // DOES NOT CONTAIN AS NORMAL SUBGROUP +// "NotRightTriangleBar", 0x029D0;0x00338, // VERTICAL BAR BESIDE RIGHT TRIANGLE with slash + "NotRightTriangleEqual", 0x022ED, // DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL +// "NotSquareSubset", 0x0228F;0x00338, // SQUARE IMAGE OF with slash + "NotSquareSubsetEqual", 0x022E2, // NOT SQUARE IMAGE OF OR EQUAL TO +// "NotSquareSuperset", 0x02290;0x00338, // SQUARE ORIGINAL OF with slash + "NotSquareSupersetEqual", 0x022E3, // NOT SQUARE ORIGINAL OF OR EQUAL TO +// "NotSubset", 0x02282;0x020D2, // SUBSET OF with vertical line + "NotSubsetEqual", 0x02288, // NEITHER A SUBSET OF NOR EQUAL TO + "NotSucceeds", 0x02281, // DOES NOT SUCCEED +// "NotSucceedsEqual", 0x02AB0;0x00338, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash + "NotSucceedsSlantEqual", 0x022E1, // DOES NOT SUCCEED OR EQUAL +// "NotSucceedsTilde", 0x0227F;0x00338, // SUCCEEDS OR EQUIVALENT TO with slash +// "NotSuperset", 0x02283;0x020D2, // SUPERSET OF with vertical line + "NotSupersetEqual", 0x02289, // NEITHER A SUPERSET OF NOR EQUAL TO + "NotTilde", 0x02241, // NOT TILDE + "NotTildeEqual", 0x02244, // NOT ASYMPTOTICALLY EQUAL TO + "NotTildeFullEqual", 0x02247, // NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO + "NotTildeTilde", 0x02249, // NOT ALMOST EQUAL TO + "NotVerticalBar", 0x02224, // DOES NOT DIVIDE + "npar", 0x02226, // NOT PARALLEL TO + "nparallel", 0x02226, // NOT PARALLEL TO +// "nparsl", 0x02AFD;0x020E5, // DOUBLE SOLIDUS OPERATOR with reverse slash +// "npart", 0x02202;0x00338, // PARTIAL DIFFERENTIAL with slash + "npolint", 0x02A14, // LINE INTEGRATION NOT INCLUDING THE POLE + "npr", 0x02280, // DOES NOT PRECEDE + "nprcue", 0x022E0, // DOES NOT PRECEDE OR EQUAL +// "npre", 0x02AAF;0x00338, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash + "nprec", 0x02280, // DOES NOT PRECEDE +// "npreceq", 0x02AAF;0x00338, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash + "nrarr", 0x0219B, // RIGHTWARDS ARROW WITH STROKE + "nrArr", 0x021CF, // RIGHTWARDS DOUBLE ARROW WITH STROKE +// "nrarrc", 0x02933;0x00338, // WAVE ARROW POINTING DIRECTLY RIGHT with slash +// "nrarrw", 0x0219D;0x00338, // RIGHTWARDS WAVE ARROW with slash + "nrightarrow", 0x0219B, // RIGHTWARDS ARROW WITH STROKE + "nRightarrow", 0x021CF, // RIGHTWARDS DOUBLE ARROW WITH STROKE + "nrtri", 0x022EB, // DOES NOT CONTAIN AS NORMAL SUBGROUP + "nrtrie", 0x022ED, // DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL + "nsc", 0x02281, // DOES NOT SUCCEED + "nsccue", 0x022E1, // DOES NOT SUCCEED OR EQUAL +// "nsce", 0x02AB0;0x00338, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash + "Nscr", 0x1D4A9, // MATHEMATICAL SCRIPT CAPITAL N + "nscr", 0x1D4C3, // MATHEMATICAL SCRIPT SMALL N + "nshortmid", 0x02224, // DOES NOT DIVIDE + "nshortparallel", 0x02226, // NOT PARALLEL TO + "nsim", 0x02241, // NOT TILDE + "nsime", 0x02244, // NOT ASYMPTOTICALLY EQUAL TO + "nsimeq", 0x02244, // NOT ASYMPTOTICALLY EQUAL TO + "nsmid", 0x02224, // DOES NOT DIVIDE + "nspar", 0x02226, // NOT PARALLEL TO + "nsqsube", 0x022E2, // NOT SQUARE IMAGE OF OR EQUAL TO + "nsqsupe", 0x022E3, // NOT SQUARE ORIGINAL OF OR EQUAL TO + "nsub", 0x02284, // NOT A SUBSET OF + "nsube", 0x02288, // NEITHER A SUBSET OF NOR EQUAL TO +// "nsubE", 0x02AC5;0x00338, // SUBSET OF ABOVE EQUALS SIGN with slash +// "nsubset", 0x02282;0x020D2, // SUBSET OF with vertical line + "nsubseteq", 0x02288, // NEITHER A SUBSET OF NOR EQUAL TO +// "nsubseteqq", 0x02AC5;0x00338, // SUBSET OF ABOVE EQUALS SIGN with slash + "nsucc", 0x02281, // DOES NOT SUCCEED +// "nsucceq", 0x02AB0;0x00338, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash + "nsup", 0x02285, // NOT A SUPERSET OF + "nsupe", 0x02289, // NEITHER A SUPERSET OF NOR EQUAL TO +// "nsupE", 0x02AC6;0x00338, // SUPERSET OF ABOVE EQUALS SIGN with slash +// "nsupset", 0x02283;0x020D2, // SUPERSET OF with vertical line + "nsupseteq", 0x02289, // NEITHER A SUPERSET OF NOR EQUAL TO +// "nsupseteqq", 0x02AC6;0x00338, // SUPERSET OF ABOVE EQUALS SIGN with slash + "ntgl", 0x02279, // NEITHER GREATER-THAN NOR LESS-THAN + "Ntilde", 0x000D1, // LATIN CAPITAL LETTER N WITH TILDE + "ntilde", 0x000F1, // LATIN SMALL LETTER N WITH TILDE + "ntlg", 0x02278, // NEITHER LESS-THAN NOR GREATER-THAN + "ntriangleleft", 0x022EA, // NOT NORMAL SUBGROUP OF + "ntrianglelefteq", 0x022EC, // NOT NORMAL SUBGROUP OF OR EQUAL TO + "ntriangleright", 0x022EB, // DOES NOT CONTAIN AS NORMAL SUBGROUP + "ntrianglerighteq", 0x022ED, // DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL + "Nu", 0x0039D, // GREEK CAPITAL LETTER NU + "nu", 0x003BD, // GREEK SMALL LETTER NU + "num", 0x00023, // NUMBER SIGN + "numero", 0x02116, // NUMERO SIGN + "numsp", 0x02007, // FIGURE SPACE +// "nvap", 0x0224D;0x020D2, // EQUIVALENT TO with vertical line + "nvdash", 0x022AC, // DOES NOT PROVE + "nvDash", 0x022AD, // NOT TRUE + "nVdash", 0x022AE, // DOES NOT FORCE + "nVDash", 0x022AF, // NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE +// "nvge", 0x02265;0x020D2, // GREATER-THAN OR EQUAL TO with vertical line +// "nvgt", 0x0003E;0x020D2, // GREATER-THAN SIGN with vertical line + "nvHarr", 0x02904, // LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE + "nvinfin", 0x029DE, // INFINITY NEGATED WITH VERTICAL BAR + "nvlArr", 0x02902, // LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE +// "nvle", 0x02264;0x020D2, // LESS-THAN OR EQUAL TO with vertical line +// "nvlt", 0x0003C;0x020D2, // LESS-THAN SIGN with vertical line +// "nvltrie", 0x022B4;0x020D2, // NORMAL SUBGROUP OF OR EQUAL TO with vertical line + "nvrArr", 0x02903, // RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE +// "nvrtrie", 0x022B5;0x020D2, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO with vertical line +// "nvsim", 0x0223C;0x020D2, // TILDE OPERATOR with vertical line + "nwarhk", 0x02923, // NORTH WEST ARROW WITH HOOK + "nwarr", 0x02196, // NORTH WEST ARROW + "nwArr", 0x021D6, // NORTH WEST DOUBLE ARROW + "nwarrow", 0x02196, // NORTH WEST ARROW + "nwnear", 0x02927, // NORTH WEST ARROW AND NORTH EAST ARROW + NULL, 0 }; static NameId namesO[]={ - "Oacgr", 0x038C, - "oacgr", 0x03CC, - "Oacute", 0x00D3, - "oacute", 0x00F3, - "oast", 0x229B, - "ocir", 0x229A, - "Ocirc", 0x00D4, - "ocirc", 0x00F4, - "Ocy", 0x041E, - "ocy", 0x043E, - "odash", 0x229D, - "Odblac", 0x0150, - "odblac", 0x0151, - "odot", 0x2299, - "OElig", 0x0152, - "oelig", 0x0153, - "ogon", 0x02DB, - "Ogr", 0x039F, - "ogr", 0x03BF, - "Ograve", 0x00D2, - "ograve", 0x00F2, - "OHacgr", 0x038F, - "ohacgr", 0x03CE, - "OHgr", 0x03A9, - "ohgr", 0x03C9, - "ohm", 0x2126, - "olarr", 0x21BA, - "Omacr", 0x014C, - "omacr", 0x014D, - "Omega", 0x03A9, - "omega", 0x03C9, - "ominus", 0x2296, - "oplus", 0x2295, - "or", 0x2228, - "orarr", 0x21BB, - "order", 0x2134, - "ordf", 0x00AA, - "ordm", 0x00BA, - "oS", 0x24C8, - "Oslash", 0x00D8, - "oslash", 0x00F8, - "osol", 0x2298, - "Otilde", 0x00D5, - "otilde", 0x00F5, - "otimes", 0x2297, - "Ouml", 0x00D6, - "ouml", 0x00F6, - NULL, 0 + "Oacgr", 0x0038C, // GREEK CAPITAL LETTER OMICRON WITH TONOS + "oacgr", 0x003CC, // GREEK SMALL LETTER OMICRON WITH TONOS + "Oacute", 0x000D3, // LATIN CAPITAL LETTER O WITH ACUTE + "oacute", 0x000F3, // LATIN SMALL LETTER O WITH ACUTE + "oast", 0x0229B, // CIRCLED ASTERISK OPERATOR + "ocir", 0x0229A, // CIRCLED RING OPERATOR + "Ocirc", 0x000D4, // LATIN CAPITAL LETTER O WITH CIRCUMFLEX + "ocirc", 0x000F4, // LATIN SMALL LETTER O WITH CIRCUMFLEX + "Ocy", 0x0041E, // CYRILLIC CAPITAL LETTER O + "ocy", 0x0043E, // CYRILLIC SMALL LETTER O + "odash", 0x0229D, // CIRCLED DASH + "Odblac", 0x00150, // LATIN CAPITAL LETTER O WITH DOUBLE ACUTE + "odblac", 0x00151, // LATIN SMALL LETTER O WITH DOUBLE ACUTE + "odiv", 0x02A38, // CIRCLED DIVISION SIGN + "odot", 0x02299, // CIRCLED DOT OPERATOR + "odsold", 0x029BC, // CIRCLED ANTICLOCKWISE-ROTATED DIVISION SIGN + "OElig", 0x00152, // LATIN CAPITAL LIGATURE OE + "oelig", 0x00153, // LATIN SMALL LIGATURE OE + "ofcir", 0x029BF, // CIRCLED BULLET + "Ofr", 0x1D512, // MATHEMATICAL FRAKTUR CAPITAL O + "ofr", 0x1D52C, // MATHEMATICAL FRAKTUR SMALL O + "ogon", 0x002DB, // OGONEK + "Ogr", 0x0039F, // GREEK CAPITAL LETTER OMICRON + "ogr", 0x003BF, // GREEK SMALL LETTER OMICRON + "Ograve", 0x000D2, // LATIN CAPITAL LETTER O WITH GRAVE + "ograve", 0x000F2, // LATIN SMALL LETTER O WITH GRAVE + "ogt", 0x029C1, // CIRCLED GREATER-THAN + "OHacgr", 0x0038F, // GREEK CAPITAL LETTER OMEGA WITH TONOS + "ohacgr", 0x003CE, // GREEK SMALL LETTER OMEGA WITH TONOS + "ohbar", 0x029B5, // CIRCLE WITH HORIZONTAL BAR + "OHgr", 0x003A9, // GREEK CAPITAL LETTER OMEGA + "ohgr", 0x003C9, // GREEK SMALL LETTER OMEGA + "ohm", 0x003A9, // GREEK CAPITAL LETTER OMEGA + "oint", 0x0222E, // CONTOUR INTEGRAL + "olarr", 0x021BA, // ANTICLOCKWISE OPEN CIRCLE ARROW + "olcir", 0x029BE, // CIRCLED WHITE BULLET + "olcross", 0x029BB, // CIRCLE WITH SUPERIMPOSED X + "oline", 0x0203E, // OVERLINE + "olt", 0x029C0, // CIRCLED LESS-THAN + "Omacr", 0x0014C, // LATIN CAPITAL LETTER O WITH MACRON + "omacr", 0x0014D, // LATIN SMALL LETTER O WITH MACRON + "Omega", 0x003A9, // GREEK CAPITAL LETTER OMEGA + "omega", 0x003C9, // GREEK SMALL LETTER OMEGA + "Omicron", 0x0039F, // GREEK CAPITAL LETTER OMICRON + "omicron", 0x003BF, // GREEK SMALL LETTER OMICRON + "omid", 0x029B6, // CIRCLED VERTICAL BAR + "ominus", 0x02296, // CIRCLED MINUS + "Oopf", 0x1D546, // MATHEMATICAL DOUBLE-STRUCK CAPITAL O + "oopf", 0x1D560, // MATHEMATICAL DOUBLE-STRUCK SMALL O + "opar", 0x029B7, // CIRCLED PARALLEL + "OpenCurlyDoubleQuote", 0x0201C, // LEFT DOUBLE QUOTATION MARK + "OpenCurlyQuote", 0x02018, // LEFT SINGLE QUOTATION MARK + "operp", 0x029B9, // CIRCLED PERPENDICULAR + "oplus", 0x02295, // CIRCLED PLUS + "or", 0x02228, // LOGICAL OR + "Or", 0x02A54, // DOUBLE LOGICAL OR + "orarr", 0x021BB, // CLOCKWISE OPEN CIRCLE ARROW + "ord", 0x02A5D, // LOGICAL OR WITH HORIZONTAL DASH + "order", 0x02134, // SCRIPT SMALL O + "orderof", 0x02134, // SCRIPT SMALL O + "ordf", 0x000AA, // FEMININE ORDINAL INDICATOR + "ordm", 0x000BA, // MASCULINE ORDINAL INDICATOR + "origof", 0x022B6, // ORIGINAL OF + "oror", 0x02A56, // TWO INTERSECTING LOGICAL OR + "orslope", 0x02A57, // SLOPING LARGE OR + "orv", 0x02A5B, // LOGICAL OR WITH MIDDLE STEM + "oS", 0x024C8, // CIRCLED LATIN CAPITAL LETTER S + "oscr", 0x02134, // SCRIPT SMALL O + "Oscr", 0x1D4AA, // MATHEMATICAL SCRIPT CAPITAL O + "Oslash", 0x000D8, // LATIN CAPITAL LETTER O WITH STROKE + "oslash", 0x000F8, // LATIN SMALL LETTER O WITH STROKE + "osol", 0x02298, // CIRCLED DIVISION SLASH + "Otilde", 0x000D5, // LATIN CAPITAL LETTER O WITH TILDE + "otilde", 0x000F5, // LATIN SMALL LETTER O WITH TILDE + "otimes", 0x02297, // CIRCLED TIMES + "Otimes", 0x02A37, // MULTIPLICATION SIGN IN DOUBLE CIRCLE + "otimesas", 0x02A36, // CIRCLED MULTIPLICATION SIGN WITH CIRCUMFLEX ACCENT + "Ouml", 0x000D6, // LATIN CAPITAL LETTER O WITH DIAERESIS + "ouml", 0x000F6, // LATIN SMALL LETTER O WITH DIAERESIS + "ovbar", 0x0233D, // APL FUNCTIONAL SYMBOL CIRCLE STILE + "OverBar", 0x0203E, // OVERLINE + "OverBrace", 0x023DE, // TOP CURLY BRACKET + "OverBracket", 0x023B4, // TOP SQUARE BRACKET + "OverParenthesis", 0x023DC, // TOP PARENTHESIS + NULL, 0 }; static NameId namesP[]={ - "par", 0x2225, - "para", 0x00B6, - "part", 0x2202, - "Pcy", 0x041F, - "pcy", 0x043F, - "percnt", 0x0025, - "period", 0x002E, - "permil", 0x2030, - "perp", 0x22A5, - "Pgr", 0x03A0, - "pgr", 0x03C0, - "PHgr", 0x03A6, - "phgr", 0x03C6, - "Phi", 0x03A6, - "phis", 0x03C6, - "phiv", 0x03D5, - "phmmat", 0x2133, - "phone", 0x260E, - "Pi", 0x03A0, - "pi", 0x03C0, - "piv", 0x03D6, - "planck", 0x210F, - "plus", 0x002B, - "plusb", 0x229E, - "plusdo", 0x2214, - "plusmn", 0x00B1, - "pound", 0x00A3, - "pr", 0x227A, - "prap", 0x227E, - "pre", 0x227C, - "prime", 0x2032, - "Prime", 0x2033, - "prnap", 0x22E8, - "prnE", 0xE2B3, - "prnsim", 0x22E8, - "prod", 0x220F, - "prop", 0x221D, - "prsim", 0x227E, - "PSgr", 0x03A8, - "psgr", 0x03C8, - "Psi", 0x03A8, - "psi", 0x03C8, - "puncsp", 0x2008, - NULL, 0 + "par", 0x02225, // PARALLEL TO + "para", 0x000B6, // PILCROW SIGN + "parallel", 0x02225, // PARALLEL TO + "parsim", 0x02AF3, // PARALLEL WITH TILDE OPERATOR + "parsl", 0x02AFD, // DOUBLE SOLIDUS OPERATOR + "part", 0x02202, // PARTIAL DIFFERENTIAL + "PartialD", 0x02202, // PARTIAL DIFFERENTIAL + "Pcy", 0x0041F, // CYRILLIC CAPITAL LETTER PE + "pcy", 0x0043F, // CYRILLIC SMALL LETTER PE + "percnt", 0x00025, // PERCENT SIGN + "period", 0x0002E, // FULL STOP + "permil", 0x02030, // PER MILLE SIGN + "perp", 0x022A5, // UP TACK + "pertenk", 0x02031, // PER TEN THOUSAND SIGN + "Pfr", 0x1D513, // MATHEMATICAL FRAKTUR CAPITAL P + "pfr", 0x1D52D, // MATHEMATICAL FRAKTUR SMALL P + "Pgr", 0x003A0, // GREEK CAPITAL LETTER PI + "pgr", 0x003C0, // GREEK SMALL LETTER PI + "PHgr", 0x003A6, // GREEK CAPITAL LETTER PHI + "phgr", 0x003C6, // GREEK SMALL LETTER PHI + "Phi", 0x003A6, // GREEK CAPITAL LETTER PHI + "phi", 0x003C6, // GREEK SMALL LETTER PHI + "phiv", 0x003D5, // GREEK PHI SYMBOL + "phmmat", 0x02133, // SCRIPT CAPITAL M + "phone", 0x0260E, // BLACK TELEPHONE + "Pi", 0x003A0, // GREEK CAPITAL LETTER PI + "pi", 0x003C0, // GREEK SMALL LETTER PI + "pitchfork", 0x022D4, // PITCHFORK + "piv", 0x003D6, // GREEK PI SYMBOL + "planck", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "planckh", 0x0210E, // PLANCK CONSTANT + "plankv", 0x0210F, // PLANCK CONSTANT OVER TWO PI + "plus", 0x0002B, // PLUS SIGN + "plusacir", 0x02A23, // PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE + "plusb", 0x0229E, // SQUARED PLUS + "pluscir", 0x02A22, // PLUS SIGN WITH SMALL CIRCLE ABOVE + "plusdo", 0x02214, // DOT PLUS + "plusdu", 0x02A25, // PLUS SIGN WITH DOT BELOW + "pluse", 0x02A72, // PLUS SIGN ABOVE EQUALS SIGN + "PlusMinus", 0x000B1, // PLUS-MINUS SIGN + "plusmn", 0x000B1, // PLUS-MINUS SIGN + "plussim", 0x02A26, // PLUS SIGN WITH TILDE BELOW + "plustwo", 0x02A27, // PLUS SIGN WITH SUBSCRIPT TWO + "pm", 0x000B1, // PLUS-MINUS SIGN + "Poincareplane", 0x0210C, // BLACK-LETTER CAPITAL H + "pointint", 0x02A15, // INTEGRAL AROUND A POINT OPERATOR + "Popf", 0x02119, // DOUBLE-STRUCK CAPITAL P + "popf", 0x1D561, // MATHEMATICAL DOUBLE-STRUCK SMALL P + "pound", 0x000A3, // POUND SIGN + "pr", 0x0227A, // PRECEDES + "Pr", 0x02ABB, // DOUBLE PRECEDES + "prap", 0x02AB7, // PRECEDES ABOVE ALMOST EQUAL TO + "prcue", 0x0227C, // PRECEDES OR EQUAL TO + "pre", 0x02AAF, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN + "prE", 0x02AB3, // PRECEDES ABOVE EQUALS SIGN + "prec", 0x0227A, // PRECEDES + "precapprox", 0x02AB7, // PRECEDES ABOVE ALMOST EQUAL TO + "preccurlyeq", 0x0227C, // PRECEDES OR EQUAL TO + "Precedes", 0x0227A, // PRECEDES + "PrecedesEqual", 0x02AAF, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN + "PrecedesSlantEqual", 0x0227C, // PRECEDES OR EQUAL TO + "PrecedesTilde", 0x0227E, // PRECEDES OR EQUIVALENT TO + "preceq", 0x02AAF, // PRECEDES ABOVE SINGLE-LINE EQUALS SIGN + "precnapprox", 0x02AB9, // PRECEDES ABOVE NOT ALMOST EQUAL TO + "precneqq", 0x02AB5, // PRECEDES ABOVE NOT EQUAL TO + "precnsim", 0x022E8, // PRECEDES BUT NOT EQUIVALENT TO + "precsim", 0x0227E, // PRECEDES OR EQUIVALENT TO + "prime", 0x02032, // PRIME + "Prime", 0x02033, // DOUBLE PRIME + "primes", 0x02119, // DOUBLE-STRUCK CAPITAL P + "prnap", 0x02AB9, // PRECEDES ABOVE NOT ALMOST EQUAL TO + "prnE", 0x02AB5, // PRECEDES ABOVE NOT EQUAL TO + "prnsim", 0x022E8, // PRECEDES BUT NOT EQUIVALENT TO + "prod", 0x0220F, // N-ARY PRODUCT + "Product", 0x0220F, // N-ARY PRODUCT + "profalar", 0x0232E, // ALL AROUND-PROFILE + "profline", 0x02312, // ARC + "profsurf", 0x02313, // SEGMENT + "prop", 0x0221D, // PROPORTIONAL TO + "Proportion", 0x02237, // PROPORTION + "Proportional", 0x0221D, // PROPORTIONAL TO + "propto", 0x0221D, // PROPORTIONAL TO + "prsim", 0x0227E, // PRECEDES OR EQUIVALENT TO + "prurel", 0x022B0, // PRECEDES UNDER RELATION + "Pscr", 0x1D4AB, // MATHEMATICAL SCRIPT CAPITAL P + "pscr", 0x1D4C5, // MATHEMATICAL SCRIPT SMALL P + "PSgr", 0x003A8, // GREEK CAPITAL LETTER PSI + "psgr", 0x003C8, // GREEK SMALL LETTER PSI + "Psi", 0x003A8, // GREEK CAPITAL LETTER PSI + "psi", 0x003C8, // GREEK SMALL LETTER PSI + "puncsp", 0x02008, // PUNCTUATION SPACE + NULL, 0 }; static NameId namesQ[]={ - "quest", 0x003F, - "quot", 0x0022, - NULL, 0 + "Qfr", 0x1D514, // MATHEMATICAL FRAKTUR CAPITAL Q + "qfr", 0x1D52E, // MATHEMATICAL FRAKTUR SMALL Q + "qint", 0x02A0C, // QUADRUPLE INTEGRAL OPERATOR + "Qopf", 0x0211A, // DOUBLE-STRUCK CAPITAL Q + "qopf", 0x1D562, // MATHEMATICAL DOUBLE-STRUCK SMALL Q + "qprime", 0x02057, // QUADRUPLE PRIME + "Qscr", 0x1D4AC, // MATHEMATICAL SCRIPT CAPITAL Q + "qscr", 0x1D4C6, // MATHEMATICAL SCRIPT SMALL Q + "quaternions", 0x0210D, // DOUBLE-STRUCK CAPITAL H + "quatint", 0x02A16, // QUATERNION INTEGRAL OPERATOR + "quest", 0x0003F, // QUESTION MARK + "questeq", 0x0225F, // QUESTIONED EQUAL TO + "quot", 0x00022, // QUOTATION MARK + "QUOT", 0x00022, // QUOTATION MARK + NULL, 0 }; static NameId namesR[]={ - "rAarr", 0x21DB, - "Racute", 0x0154, - "racute", 0x0155, - "radic", 0x221A, - "rang", 0x3009, - "raquo", 0x00BB, - "rarr", 0x2192, - "Rarr", 0x21A0, - "rArr", 0x21D2, - "rarr2", 0x21C9, - "rarrhk", 0x21AA, - "rarrlp", 0x21AC, - "rarrtl", 0x21A3, - "rarrw", 0x219D, - "Rcaron", 0x0158, - "rcaron", 0x0159, - "Rcedil", 0x0156, - "rcedil", 0x0157, - "rceil", 0x2309, - "rcub", 0x007D, - "Rcy", 0x0420, - "rcy", 0x0440, - "rdquo", 0x201D, - "rdquor", 0x201C, - "real", 0x211C, - "rect", 0x25AD, - "reg", 0x00AE, - "rfloor", 0x230B, - "Rgr", 0x03A1, - "rgr", 0x03C1, - "rhard", 0x21C1, - "rharu", 0x21C0, - "rho", 0x03C1, - "rhov", 0x03F1, - "ring", 0x02DA, - "rlarr2", 0x21C4, - "rlhar2", 0x21CC, - "rpar", 0x0029, - "rpargt", 0xE291, - "rsh", 0x21B1, - "rsqb", 0x005D, - "rsquo", 0x2019, - "rsquor", 0x2018, - "rthree", 0x22CC, - "rtimes", 0x22CA, - "rtri", 0x25B9, - "rtrie", 0x22B5, - "rtrif", 0x25B8, - "rx", 0x211E, - NULL, 0 + "rAarr", 0x021DB, // RIGHTWARDS TRIPLE ARROW +// "race", 0x0223D;0x00331, // REVERSED TILDE with underline + "Racute", 0x00154, // LATIN CAPITAL LETTER R WITH ACUTE + "racute", 0x00155, // LATIN SMALL LETTER R WITH ACUTE + "radic", 0x0221A, // SQUARE ROOT + "raemptyv", 0x029B3, // EMPTY SET WITH RIGHT ARROW ABOVE + "rang", 0x027E9, // MATHEMATICAL RIGHT ANGLE BRACKET + "Rang", 0x027EB, // MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET + "rangd", 0x02992, // RIGHT ANGLE BRACKET WITH DOT + "range", 0x029A5, // REVERSED ANGLE WITH UNDERBAR + "rangle", 0x027E9, // MATHEMATICAL RIGHT ANGLE BRACKET + "raquo", 0x000BB, // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK + "rarr", 0x02192, // RIGHTWARDS ARROW + "Rarr", 0x021A0, // RIGHTWARDS TWO HEADED ARROW + "rArr", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "rarrap", 0x02975, // RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO + "rarrb", 0x021E5, // RIGHTWARDS ARROW TO BAR + "rarrbfs", 0x02920, // RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND + "rarrc", 0x02933, // WAVE ARROW POINTING DIRECTLY RIGHT + "rarrfs", 0x0291E, // RIGHTWARDS ARROW TO BLACK DIAMOND + "rarrhk", 0x021AA, // RIGHTWARDS ARROW WITH HOOK + "rarrlp", 0x021AC, // RIGHTWARDS ARROW WITH LOOP + "rarrpl", 0x02945, // RIGHTWARDS ARROW WITH PLUS BELOW + "rarrsim", 0x02974, // RIGHTWARDS ARROW ABOVE TILDE OPERATOR + "rarrtl", 0x021A3, // RIGHTWARDS ARROW WITH TAIL + "Rarrtl", 0x02916, // RIGHTWARDS TWO-HEADED ARROW WITH TAIL + "rarrw", 0x0219D, // RIGHTWARDS WAVE ARROW + "ratail", 0x0291A, // RIGHTWARDS ARROW-TAIL + "rAtail", 0x0291C, // RIGHTWARDS DOUBLE ARROW-TAIL + "ratio", 0x02236, // RATIO + "rationals", 0x0211A, // DOUBLE-STRUCK CAPITAL Q + "rbarr", 0x0290D, // RIGHTWARDS DOUBLE DASH ARROW + "rBarr", 0x0290F, // RIGHTWARDS TRIPLE DASH ARROW + "RBarr", 0x02910, // RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW + "rbbrk", 0x02773, // LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT + "rbrace", 0x0007D, // RIGHT CURLY BRACKET + "rbrack", 0x0005D, // RIGHT SQUARE BRACKET + "rbrke", 0x0298C, // RIGHT SQUARE BRACKET WITH UNDERBAR + "rbrksld", 0x0298E, // RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER + "rbrkslu", 0x02990, // RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER + "Rcaron", 0x00158, // LATIN CAPITAL LETTER R WITH CARON + "rcaron", 0x00159, // LATIN SMALL LETTER R WITH CARON + "Rcedil", 0x00156, // LATIN CAPITAL LETTER R WITH CEDILLA + "rcedil", 0x00157, // LATIN SMALL LETTER R WITH CEDILLA + "rceil", 0x02309, // RIGHT CEILING + "rcub", 0x0007D, // RIGHT CURLY BRACKET + "Rcy", 0x00420, // CYRILLIC CAPITAL LETTER ER + "rcy", 0x00440, // CYRILLIC SMALL LETTER ER + "rdca", 0x02937, // ARROW POINTING DOWNWARDS THEN CURVING RIGHTWARDS + "rdldhar", 0x02969, // RIGHTWARDS HARPOON WITH BARB DOWN ABOVE LEFTWARDS HARPOON WITH BARB DOWN + "rdquo", 0x0201D, // RIGHT DOUBLE QUOTATION MARK + "rdquor", 0x0201D, // RIGHT DOUBLE QUOTATION MARK + "rdsh", 0x021B3, // DOWNWARDS ARROW WITH TIP RIGHTWARDS + "Re", 0x0211C, // BLACK-LETTER CAPITAL R + "real", 0x0211C, // BLACK-LETTER CAPITAL R + "realine", 0x0211B, // SCRIPT CAPITAL R + "realpart", 0x0211C, // BLACK-LETTER CAPITAL R + "reals", 0x0211D, // DOUBLE-STRUCK CAPITAL R + "rect", 0x025AD, // WHITE RECTANGLE + "reg", 0x000AE, // REGISTERED SIGN + "REG", 0x000AE, // REGISTERED SIGN + "ReverseElement", 0x0220B, // CONTAINS AS MEMBER + "ReverseEquilibrium", 0x021CB, // LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON + "ReverseUpEquilibrium", 0x0296F, // DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT + "rfisht", 0x0297D, // RIGHT FISH TAIL + "rfloor", 0x0230B, // RIGHT FLOOR + "Rfr", 0x0211C, // BLACK-LETTER CAPITAL R + "rfr", 0x1D52F, // MATHEMATICAL FRAKTUR SMALL R + "Rgr", 0x003A1, // GREEK CAPITAL LETTER RHO + "rgr", 0x003C1, // GREEK SMALL LETTER RHO + "rHar", 0x02964, // RIGHTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB DOWN + "rhard", 0x021C1, // RIGHTWARDS HARPOON WITH BARB DOWNWARDS + "rharu", 0x021C0, // RIGHTWARDS HARPOON WITH BARB UPWARDS + "rharul", 0x0296C, // RIGHTWARDS HARPOON WITH BARB UP ABOVE LONG DASH + "Rho", 0x003A1, // GREEK CAPITAL LETTER RHO + "rho", 0x003C1, // GREEK SMALL LETTER RHO + "rhov", 0x003F1, // GREEK RHO SYMBOL + "RightAngleBracket", 0x027E9, // MATHEMATICAL RIGHT ANGLE BRACKET + "rightarrow", 0x02192, // RIGHTWARDS ARROW + "RightArrow", 0x02192, // RIGHTWARDS ARROW + "Rightarrow", 0x021D2, // RIGHTWARDS DOUBLE ARROW + "RightArrowBar", 0x021E5, // RIGHTWARDS ARROW TO BAR + "RightArrowLeftArrow", 0x021C4, // RIGHTWARDS ARROW OVER LEFTWARDS ARROW + "rightarrowtail", 0x021A3, // RIGHTWARDS ARROW WITH TAIL + "RightCeiling", 0x02309, // RIGHT CEILING + "RightDoubleBracket", 0x027E7, // MATHEMATICAL RIGHT WHITE SQUARE BRACKET + "RightDownTeeVector", 0x0295D, // DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR + "RightDownVector", 0x021C2, // DOWNWARDS HARPOON WITH BARB RIGHTWARDS + "RightDownVectorBar", 0x02955, // DOWNWARDS HARPOON WITH BARB RIGHT TO BAR + "RightFloor", 0x0230B, // RIGHT FLOOR + "rightharpoondown", 0x021C1, // RIGHTWARDS HARPOON WITH BARB DOWNWARDS + "rightharpoonup", 0x021C0, // RIGHTWARDS HARPOON WITH BARB UPWARDS + "rightleftarrows", 0x021C4, // RIGHTWARDS ARROW OVER LEFTWARDS ARROW + "rightleftharpoons", 0x021CC, // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON + "rightrightarrows", 0x021C9, // RIGHTWARDS PAIRED ARROWS + "rightsquigarrow", 0x0219D, // RIGHTWARDS WAVE ARROW + "RightTee", 0x022A2, // RIGHT TACK + "RightTeeArrow", 0x021A6, // RIGHTWARDS ARROW FROM BAR + "RightTeeVector", 0x0295B, // RIGHTWARDS HARPOON WITH BARB UP FROM BAR + "rightthreetimes", 0x022CC, // RIGHT SEMIDIRECT PRODUCT + "RightTriangle", 0x022B3, // CONTAINS AS NORMAL SUBGROUP + "RightTriangleBar", 0x029D0, // VERTICAL BAR BESIDE RIGHT TRIANGLE + "RightTriangleEqual", 0x022B5, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO + "RightUpDownVector", 0x0294F, // UP BARB RIGHT DOWN BARB RIGHT HARPOON + "RightUpTeeVector", 0x0295C, // UPWARDS HARPOON WITH BARB RIGHT FROM BAR + "RightUpVector", 0x021BE, // UPWARDS HARPOON WITH BARB RIGHTWARDS + "RightUpVectorBar", 0x02954, // UPWARDS HARPOON WITH BARB RIGHT TO BAR + "RightVector", 0x021C0, // RIGHTWARDS HARPOON WITH BARB UPWARDS + "RightVectorBar", 0x02953, // RIGHTWARDS HARPOON WITH BARB UP TO BAR + "ring", 0x002DA, // RING ABOVE + "risingdotseq", 0x02253, // IMAGE OF OR APPROXIMATELY EQUAL TO + "rlarr", 0x021C4, // RIGHTWARDS ARROW OVER LEFTWARDS ARROW + "rlhar", 0x021CC, // RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON + "rlm", 0x0200F, // RIGHT-TO-LEFT MARK + "rmoust", 0x023B1, // UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION + "rmoustache", 0x023B1, // UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION + "rnmid", 0x02AEE, // DOES NOT DIVIDE WITH REVERSED NEGATION SLASH + "roang", 0x027ED, // MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET + "roarr", 0x021FE, // RIGHTWARDS OPEN-HEADED ARROW + "robrk", 0x027E7, // MATHEMATICAL RIGHT WHITE SQUARE BRACKET + "ropar", 0x02986, // RIGHT WHITE PARENTHESIS + "Ropf", 0x0211D, // DOUBLE-STRUCK CAPITAL R + "ropf", 0x1D563, // MATHEMATICAL DOUBLE-STRUCK SMALL R + "roplus", 0x02A2E, // PLUS SIGN IN RIGHT HALF CIRCLE + "rotimes", 0x02A35, // MULTIPLICATION SIGN IN RIGHT HALF CIRCLE + "RoundImplies", 0x02970, // RIGHT DOUBLE ARROW WITH ROUNDED HEAD + "rpar", 0x00029, // RIGHT PARENTHESIS + "rpargt", 0x02994, // RIGHT ARC GREATER-THAN BRACKET + "rppolint", 0x02A12, // LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE + "rrarr", 0x021C9, // RIGHTWARDS PAIRED ARROWS + "Rrightarrow", 0x021DB, // RIGHTWARDS TRIPLE ARROW + "rsaquo", 0x0203A, // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK + "Rscr", 0x0211B, // SCRIPT CAPITAL R + "rscr", 0x1D4C7, // MATHEMATICAL SCRIPT SMALL R + "rsh", 0x021B1, // UPWARDS ARROW WITH TIP RIGHTWARDS + "Rsh", 0x021B1, // UPWARDS ARROW WITH TIP RIGHTWARDS + "rsqb", 0x0005D, // RIGHT SQUARE BRACKET + "rsquo", 0x02019, // RIGHT SINGLE QUOTATION MARK + "rsquor", 0x02019, // RIGHT SINGLE QUOTATION MARK + "rthree", 0x022CC, // RIGHT SEMIDIRECT PRODUCT + "rtimes", 0x022CA, // RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT + "rtri", 0x025B9, // WHITE RIGHT-POINTING SMALL TRIANGLE + "rtrie", 0x022B5, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO + "rtrif", 0x025B8, // BLACK RIGHT-POINTING SMALL TRIANGLE + "rtriltri", 0x029CE, // RIGHT TRIANGLE ABOVE LEFT TRIANGLE + "RuleDelayed", 0x029F4, // RULE-DELAYED + "ruluhar", 0x02968, // RIGHTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB UP + "rx", 0x0211E, // PRESCRIPTION TAKE + NULL, 0 }; static NameId namesS[]={ - "Sacute", 0x015A, - "sacute", 0x015B, - "samalg", 0x2210, - "sbsol", 0xFE68, - "sc", 0x227B, - "scap", 0x227F, - "Scaron", 0x0160, - "scaron", 0x0161, - "sccue", 0x227D, - "sce", 0x227D, - "Scedil", 0x015E, - "scedil", 0x015F, - "Scirc", 0x015C, - "scirc", 0x015D, - "scnap", 0x22E9, - "scnE", 0xE2B5, - "scnsim", 0x22E9, - "scsim", 0x227F, - "Scy", 0x0421, - "scy", 0x0441, - "sdot", 0x22C5, - "sdotb", 0x22A1, - "sect", 0x00A7, - "semi", 0x003B, - "setmn", 0x2216, - "sext", 0x2736, - "sfgr", 0x03C2, - "sfrown", 0x2322, - "Sgr", 0x03A3, - "sgr", 0x03C3, - "sharp", 0x266F, - "SHCHcy", 0x0429, - "shchcy", 0x0449, - "SHcy", 0x0428, - "shcy", 0x0448, - "shy", 0x00AD, - "Sigma", 0x03A3, - "sigma", 0x03C3, - "sigmav", 0x03C2, - "sim", 0x223C, - "sime", 0x2243, - "smid", 0xE301, - "smile", 0x2323, - "SOFTcy", 0x042C, - "softcy", 0x044C, - "sol", 0x002F, - "spades", 0x2660, - "spar", 0x2225, - "sqcap", 0x2293, - "sqcup", 0x2294, - "sqsub", 0x228F, - "sqsube", 0x2291, - "sqsup", 0x2290, - "sqsupe", 0x2292, - "squ", 0x25A1, - "square", 0x25A1, - "squf", 0x25AA, - "ssetmn", 0x2216, - "ssmile", 0x2323, - "sstarf", 0x22C6, - "star", 0x22C6, - "starf", 0x2605, - "sub", 0x2282, - "Sub", 0x22D0, - "sube", 0x2286, - "subE", 0x2286, - "subne", 0x228A, - "subnE", 0x228A, - "sum", 0x2211, - "sung", 0x2669, - "sup", 0x2283, - "Sup", 0x22D1, - "sup1", 0x00B9, - "sup2", 0x00B2, - "sup3", 0x00B3, - "supe", 0x2287, - "supE", 0x2287, - "supne", 0x228B, - "supnE", 0x228B, - "szlig", 0x00DF, - NULL, 0 + "Sacute", 0x0015A, // LATIN CAPITAL LETTER S WITH ACUTE + "sacute", 0x0015B, // LATIN SMALL LETTER S WITH ACUTE + "sbquo", 0x0201A, // SINGLE LOW-9 QUOTATION MARK + "sc", 0x0227B, // SUCCEEDS + "Sc", 0x02ABC, // DOUBLE SUCCEEDS + "scap", 0x02AB8, // SUCCEEDS ABOVE ALMOST EQUAL TO + "Scaron", 0x00160, // LATIN CAPITAL LETTER S WITH CARON + "scaron", 0x00161, // LATIN SMALL LETTER S WITH CARON + "sccue", 0x0227D, // SUCCEEDS OR EQUAL TO + "sce", 0x02AB0, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN + "scE", 0x02AB4, // SUCCEEDS ABOVE EQUALS SIGN + "Scedil", 0x0015E, // LATIN CAPITAL LETTER S WITH CEDILLA + "scedil", 0x0015F, // LATIN SMALL LETTER S WITH CEDILLA + "Scirc", 0x0015C, // LATIN CAPITAL LETTER S WITH CIRCUMFLEX + "scirc", 0x0015D, // LATIN SMALL LETTER S WITH CIRCUMFLEX + "scnap", 0x02ABA, // SUCCEEDS ABOVE NOT ALMOST EQUAL TO + "scnE", 0x02AB6, // SUCCEEDS ABOVE NOT EQUAL TO + "scnsim", 0x022E9, // SUCCEEDS BUT NOT EQUIVALENT TO + "scpolint", 0x02A13, // LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE + "scsim", 0x0227F, // SUCCEEDS OR EQUIVALENT TO + "Scy", 0x00421, // CYRILLIC CAPITAL LETTER ES + "scy", 0x00441, // CYRILLIC SMALL LETTER ES + "sdot", 0x022C5, // DOT OPERATOR + "sdotb", 0x022A1, // SQUARED DOT OPERATOR + "sdote", 0x02A66, // EQUALS SIGN WITH DOT BELOW + "searhk", 0x02925, // SOUTH EAST ARROW WITH HOOK + "searr", 0x02198, // SOUTH EAST ARROW + "seArr", 0x021D8, // SOUTH EAST DOUBLE ARROW + "searrow", 0x02198, // SOUTH EAST ARROW + "sect", 0x000A7, // SECTION SIGN + "semi", 0x0003B, // SEMICOLON + "seswar", 0x02929, // SOUTH EAST ARROW AND SOUTH WEST ARROW + "setminus", 0x02216, // SET MINUS + "setmn", 0x02216, // SET MINUS + "sext", 0x02736, // SIX POINTED BLACK STAR + "sfgr", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA + "Sfr", 0x1D516, // MATHEMATICAL FRAKTUR CAPITAL S + "sfr", 0x1D530, // MATHEMATICAL FRAKTUR SMALL S + "sfrown", 0x02322, // FROWN + "Sgr", 0x003A3, // GREEK CAPITAL LETTER SIGMA + "sgr", 0x003C3, // GREEK SMALL LETTER SIGMA + "sharp", 0x0266F, // MUSIC SHARP SIGN + "SHCHcy", 0x00429, // CYRILLIC CAPITAL LETTER SHCHA + "shchcy", 0x00449, // CYRILLIC SMALL LETTER SHCHA + "SHcy", 0x00428, // CYRILLIC CAPITAL LETTER SHA + "shcy", 0x00448, // CYRILLIC SMALL LETTER SHA + "ShortDownArrow", 0x02193, // DOWNWARDS ARROW + "ShortLeftArrow", 0x02190, // LEFTWARDS ARROW + "shortmid", 0x02223, // DIVIDES + "shortparallel", 0x02225, // PARALLEL TO + "ShortRightArrow", 0x02192, // RIGHTWARDS ARROW + "ShortUpArrow", 0x02191, // UPWARDS ARROW + "shy", 0x000AD, // SOFT HYPHEN + "Sigma", 0x003A3, // GREEK CAPITAL LETTER SIGMA + "sigma", 0x003C3, // GREEK SMALL LETTER SIGMA + "sigmaf", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA + "sigmav", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA + "sim", 0x0223C, // TILDE OPERATOR + "simdot", 0x02A6A, // TILDE OPERATOR WITH DOT ABOVE + "sime", 0x02243, // ASYMPTOTICALLY EQUAL TO + "simeq", 0x02243, // ASYMPTOTICALLY EQUAL TO + "simg", 0x02A9E, // SIMILAR OR GREATER-THAN + "simgE", 0x02AA0, // SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN + "siml", 0x02A9D, // SIMILAR OR LESS-THAN + "simlE", 0x02A9F, // SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN + "simne", 0x02246, // APPROXIMATELY BUT NOT ACTUALLY EQUAL TO + "simplus", 0x02A24, // PLUS SIGN WITH TILDE ABOVE + "simrarr", 0x02972, // TILDE OPERATOR ABOVE RIGHTWARDS ARROW + "slarr", 0x02190, // LEFTWARDS ARROW + "SmallCircle", 0x02218, // RING OPERATOR + "smallsetminus", 0x02216, // SET MINUS + "smashp", 0x02A33, // SMASH PRODUCT + "smeparsl", 0x029E4, // EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE + "smid", 0x02223, // DIVIDES + "smile", 0x02323, // SMILE + "smt", 0x02AAA, // SMALLER THAN + "smte", 0x02AAC, // SMALLER THAN OR EQUAL TO +// "smtes", 0x02AAC;0x0FE00, // SMALLER THAN OR slanted EQUAL + "SOFTcy", 0x0042C, // CYRILLIC CAPITAL LETTER SOFT SIGN + "softcy", 0x0044C, // CYRILLIC SMALL LETTER SOFT SIGN + "sol", 0x0002F, // SOLIDUS + "solb", 0x029C4, // SQUARED RISING DIAGONAL SLASH + "solbar", 0x0233F, // APL FUNCTIONAL SYMBOL SLASH BAR + "Sopf", 0x1D54A, // MATHEMATICAL DOUBLE-STRUCK CAPITAL S + "sopf", 0x1D564, // MATHEMATICAL DOUBLE-STRUCK SMALL S + "spades", 0x02660, // BLACK SPADE SUIT + "spadesuit", 0x02660, // BLACK SPADE SUIT + "spar", 0x02225, // PARALLEL TO + "sqcap", 0x02293, // SQUARE CAP +// "sqcaps", 0x02293;0x0FE00, // SQUARE CAP with serifs + "sqcup", 0x02294, // SQUARE CUP +// "sqcups", 0x02294;0x0FE00, // SQUARE CUP with serifs + "Sqrt", 0x0221A, // SQUARE ROOT + "sqsub", 0x0228F, // SQUARE IMAGE OF + "sqsube", 0x02291, // SQUARE IMAGE OF OR EQUAL TO + "sqsubset", 0x0228F, // SQUARE IMAGE OF + "sqsubseteq", 0x02291, // SQUARE IMAGE OF OR EQUAL TO + "sqsup", 0x02290, // SQUARE ORIGINAL OF + "sqsupe", 0x02292, // SQUARE ORIGINAL OF OR EQUAL TO + "sqsupset", 0x02290, // SQUARE ORIGINAL OF + "sqsupseteq", 0x02292, // SQUARE ORIGINAL OF OR EQUAL TO + "squ", 0x025A1, // WHITE SQUARE + "square", 0x025A1, // WHITE SQUARE + "Square", 0x025A1, // WHITE SQUARE + "SquareIntersection", 0x02293, // SQUARE CAP + "SquareSubset", 0x0228F, // SQUARE IMAGE OF + "SquareSubsetEqual", 0x02291, // SQUARE IMAGE OF OR EQUAL TO + "SquareSuperset", 0x02290, // SQUARE ORIGINAL OF + "SquareSupersetEqual", 0x02292, // SQUARE ORIGINAL OF OR EQUAL TO + "SquareUnion", 0x02294, // SQUARE CUP + "squarf", 0x025AA, // BLACK SMALL SQUARE + "squf", 0x025AA, // BLACK SMALL SQUARE + "srarr", 0x02192, // RIGHTWARDS ARROW + "Sscr", 0x1D4AE, // MATHEMATICAL SCRIPT CAPITAL S + "sscr", 0x1D4C8, // MATHEMATICAL SCRIPT SMALL S + "ssetmn", 0x02216, // SET MINUS + "ssmile", 0x02323, // SMILE + "sstarf", 0x022C6, // STAR OPERATOR + "Star", 0x022C6, // STAR OPERATOR + "star", 0x02606, // WHITE STAR + "starf", 0x02605, // BLACK STAR + "straightepsilon", 0x003F5, // GREEK LUNATE EPSILON SYMBOL + "straightphi", 0x003D5, // GREEK PHI SYMBOL + "strns", 0x000AF, // MACRON + "sub", 0x02282, // SUBSET OF + "Sub", 0x022D0, // DOUBLE SUBSET + "subdot", 0x02ABD, // SUBSET WITH DOT + "sube", 0x02286, // SUBSET OF OR EQUAL TO + "subE", 0x02AC5, // SUBSET OF ABOVE EQUALS SIGN + "subedot", 0x02AC3, // SUBSET OF OR EQUAL TO WITH DOT ABOVE + "submult", 0x02AC1, // SUBSET WITH MULTIPLICATION SIGN BELOW + "subne", 0x0228A, // SUBSET OF WITH NOT EQUAL TO + "subnE", 0x02ACB, // SUBSET OF ABOVE NOT EQUAL TO + "subplus", 0x02ABF, // SUBSET WITH PLUS SIGN BELOW + "subrarr", 0x02979, // SUBSET ABOVE RIGHTWARDS ARROW + "subset", 0x02282, // SUBSET OF + "Subset", 0x022D0, // DOUBLE SUBSET + "subseteq", 0x02286, // SUBSET OF OR EQUAL TO + "subseteqq", 0x02AC5, // SUBSET OF ABOVE EQUALS SIGN + "SubsetEqual", 0x02286, // SUBSET OF OR EQUAL TO + "subsetneq", 0x0228A, // SUBSET OF WITH NOT EQUAL TO + "subsetneqq", 0x02ACB, // SUBSET OF ABOVE NOT EQUAL TO + "subsim", 0x02AC7, // SUBSET OF ABOVE TILDE OPERATOR + "subsub", 0x02AD5, // SUBSET ABOVE SUBSET + "subsup", 0x02AD3, // SUBSET ABOVE SUPERSET + "succ", 0x0227B, // SUCCEEDS + "succapprox", 0x02AB8, // SUCCEEDS ABOVE ALMOST EQUAL TO + "succcurlyeq", 0x0227D, // SUCCEEDS OR EQUAL TO + "Succeeds", 0x0227B, // SUCCEEDS + "SucceedsEqual", 0x02AB0, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN + "SucceedsSlantEqual", 0x0227D, // SUCCEEDS OR EQUAL TO + "SucceedsTilde", 0x0227F, // SUCCEEDS OR EQUIVALENT TO + "succeq", 0x02AB0, // SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN + "succnapprox", 0x02ABA, // SUCCEEDS ABOVE NOT ALMOST EQUAL TO + "succneqq", 0x02AB6, // SUCCEEDS ABOVE NOT EQUAL TO + "succnsim", 0x022E9, // SUCCEEDS BUT NOT EQUIVALENT TO + "succsim", 0x0227F, // SUCCEEDS OR EQUIVALENT TO + "SuchThat", 0x0220B, // CONTAINS AS MEMBER + "sum", 0x02211, // N-ARY SUMMATION + "Sum", 0x02211, // N-ARY SUMMATION + "sung", 0x0266A, // EIGHTH NOTE + "sup", 0x02283, // SUPERSET OF + "Sup", 0x022D1, // DOUBLE SUPERSET + "sup1", 0x000B9, // SUPERSCRIPT ONE + "sup2", 0x000B2, // SUPERSCRIPT TWO + "sup3", 0x000B3, // SUPERSCRIPT THREE + "supdot", 0x02ABE, // SUPERSET WITH DOT + "supdsub", 0x02AD8, // SUPERSET BESIDE AND JOINED BY DASH WITH SUBSET + "supe", 0x02287, // SUPERSET OF OR EQUAL TO + "supE", 0x02AC6, // SUPERSET OF ABOVE EQUALS SIGN + "supedot", 0x02AC4, // SUPERSET OF OR EQUAL TO WITH DOT ABOVE + "Superset", 0x02283, // SUPERSET OF + "SupersetEqual", 0x02287, // SUPERSET OF OR EQUAL TO + "suphsol", 0x027C9, // SUPERSET PRECEDING SOLIDUS + "suphsub", 0x02AD7, // SUPERSET BESIDE SUBSET + "suplarr", 0x0297B, // SUPERSET ABOVE LEFTWARDS ARROW + "supmult", 0x02AC2, // SUPERSET WITH MULTIPLICATION SIGN BELOW + "supne", 0x0228B, // SUPERSET OF WITH NOT EQUAL TO + "supnE", 0x02ACC, // SUPERSET OF ABOVE NOT EQUAL TO + "supplus", 0x02AC0, // SUPERSET WITH PLUS SIGN BELOW + "supset", 0x02283, // SUPERSET OF + "Supset", 0x022D1, // DOUBLE SUPERSET + "supseteq", 0x02287, // SUPERSET OF OR EQUAL TO + "supseteqq", 0x02AC6, // SUPERSET OF ABOVE EQUALS SIGN + "supsetneq", 0x0228B, // SUPERSET OF WITH NOT EQUAL TO + "supsetneqq", 0x02ACC, // SUPERSET OF ABOVE NOT EQUAL TO + "supsim", 0x02AC8, // SUPERSET OF ABOVE TILDE OPERATOR + "supsub", 0x02AD4, // SUPERSET ABOVE SUBSET + "supsup", 0x02AD6, // SUPERSET ABOVE SUPERSET + "swarhk", 0x02926, // SOUTH WEST ARROW WITH HOOK + "swarr", 0x02199, // SOUTH WEST ARROW + "swArr", 0x021D9, // SOUTH WEST DOUBLE ARROW + "swarrow", 0x02199, // SOUTH WEST ARROW + "swnwar", 0x0292A, // SOUTH WEST ARROW AND NORTH WEST ARROW + "szlig", 0x000DF, // LATIN SMALL LETTER SHARP S + NULL, 0 }; static NameId namesT[]={ - "target", 0x2316, - "tau", 0x03C4, - "Tcaron", 0x0164, - "tcaron", 0x0165, - "Tcedil", 0x0162, - "tcedil", 0x0163, - "Tcy", 0x0422, - "tcy", 0x0442, - "tdot", 0x20DB, - "telrec", 0x2315, - "Tgr", 0x03A4, - "tgr", 0x03C4, - "there4", 0x2234, - "Theta", 0x0398, - "thetas", 0x03B8, - "thetav", 0x03D1, - "THgr", 0x0398, - "thgr", 0x03B8, - "thinsp", 0x2009, - "thkap", 0x2248, - "thksim", 0x223C, - "THORN", 0x00DE, - "thorn", 0x00FE, - "tilde", 0x02DC, - "times", 0x00D7, - "timesb", 0x22A0, - "top", 0x22A4, - "tprime", 0x2034, - "trade", 0x2122, - "trie", 0x225C, - "TScy", 0x0426, - "tscy", 0x0446, - "TSHcy", 0x040B, - "tshcy", 0x045B, - "Tstrok", 0x0166, - "tstrok", 0x0167, - "twixt", 0x226C, - NULL, 0 + "Tab", 0x00009, // CHARACTER TABULATION + "target", 0x02316, // POSITION INDICATOR + "Tau", 0x003A4, // GREEK CAPITAL LETTER TAU + "tau", 0x003C4, // GREEK SMALL LETTER TAU + "tbrk", 0x023B4, // TOP SQUARE BRACKET + "Tcaron", 0x00164, // LATIN CAPITAL LETTER T WITH CARON + "tcaron", 0x00165, // LATIN SMALL LETTER T WITH CARON + "Tcedil", 0x00162, // LATIN CAPITAL LETTER T WITH CEDILLA + "tcedil", 0x00163, // LATIN SMALL LETTER T WITH CEDILLA + "Tcy", 0x00422, // CYRILLIC CAPITAL LETTER TE + "tcy", 0x00442, // CYRILLIC SMALL LETTER TE + "tdot", 0x020DB, // COMBINING THREE DOTS ABOVE + "telrec", 0x02315, // TELEPHONE RECORDER + "Tfr", 0x1D517, // MATHEMATICAL FRAKTUR CAPITAL T + "tfr", 0x1D531, // MATHEMATICAL FRAKTUR SMALL T + "Tgr", 0x003A4, // GREEK CAPITAL LETTER TAU + "tgr", 0x003C4, // GREEK SMALL LETTER TAU + "there4", 0x02234, // THEREFORE + "therefore", 0x02234, // THEREFORE + "Therefore", 0x02234, // THEREFORE + "Theta", 0x00398, // GREEK CAPITAL LETTER THETA + "theta", 0x003B8, // GREEK SMALL LETTER THETA + "thetasym", 0x003D1, // GREEK THETA SYMBOL + "thetav", 0x003D1, // GREEK THETA SYMBOL + "THgr", 0x00398, // GREEK CAPITAL LETTER THETA + "thgr", 0x003B8, // GREEK SMALL LETTER THETA + "thickapprox", 0x02248, // ALMOST EQUAL TO + "thicksim", 0x0223C, // TILDE OPERATOR +// "ThickSpace", 0x0205F;0x0200A, // space of width 5/18 em + "thinsp", 0x02009, // THIN SPACE + "ThinSpace", 0x02009, // THIN SPACE + "thkap", 0x02248, // ALMOST EQUAL TO + "thksim", 0x0223C, // TILDE OPERATOR + "THORN", 0x000DE, // LATIN CAPITAL LETTER THORN + "thorn", 0x000FE, // LATIN SMALL LETTER THORN + "tilde", 0x002DC, // SMALL TILDE + "Tilde", 0x0223C, // TILDE OPERATOR + "TildeEqual", 0x02243, // ASYMPTOTICALLY EQUAL TO + "TildeFullEqual", 0x02245, // APPROXIMATELY EQUAL TO + "TildeTilde", 0x02248, // ALMOST EQUAL TO + "times", 0x000D7, // MULTIPLICATION SIGN + "timesb", 0x022A0, // SQUARED TIMES + "timesbar", 0x02A31, // MULTIPLICATION SIGN WITH UNDERBAR + "timesd", 0x02A30, // MULTIPLICATION SIGN WITH DOT ABOVE + "tint", 0x0222D, // TRIPLE INTEGRAL + "toea", 0x02928, // NORTH EAST ARROW AND SOUTH EAST ARROW + "top", 0x022A4, // DOWN TACK + "topbot", 0x02336, // APL FUNCTIONAL SYMBOL I-BEAM + "topcir", 0x02AF1, // DOWN TACK WITH CIRCLE BELOW + "Topf", 0x1D54B, // MATHEMATICAL DOUBLE-STRUCK CAPITAL T + "topf", 0x1D565, // MATHEMATICAL DOUBLE-STRUCK SMALL T + "topfork", 0x02ADA, // PITCHFORK WITH TEE TOP + "tosa", 0x02929, // SOUTH EAST ARROW AND SOUTH WEST ARROW + "tprime", 0x02034, // TRIPLE PRIME + "trade", 0x02122, // TRADE MARK SIGN + "TRADE", 0x02122, // TRADE MARK SIGN + "triangle", 0x025B5, // WHITE UP-POINTING SMALL TRIANGLE + "triangledown", 0x025BF, // WHITE DOWN-POINTING SMALL TRIANGLE + "triangleleft", 0x025C3, // WHITE LEFT-POINTING SMALL TRIANGLE + "trianglelefteq", 0x022B4, // NORMAL SUBGROUP OF OR EQUAL TO + "triangleq", 0x0225C, // DELTA EQUAL TO + "triangleright", 0x025B9, // WHITE RIGHT-POINTING SMALL TRIANGLE + "trianglerighteq", 0x022B5, // CONTAINS AS NORMAL SUBGROUP OR EQUAL TO + "tridot", 0x025EC, // WHITE UP-POINTING TRIANGLE WITH DOT + "trie", 0x0225C, // DELTA EQUAL TO + "triminus", 0x02A3A, // MINUS SIGN IN TRIANGLE + "TripleDot", 0x020DB, // COMBINING THREE DOTS ABOVE + "triplus", 0x02A39, // PLUS SIGN IN TRIANGLE + "trisb", 0x029CD, // TRIANGLE WITH SERIFS AT BOTTOM + "tritime", 0x02A3B, // MULTIPLICATION SIGN IN TRIANGLE + "trpezium", 0x023E2, // WHITE TRAPEZIUM + "Tscr", 0x1D4AF, // MATHEMATICAL SCRIPT CAPITAL T + "tscr", 0x1D4C9, // MATHEMATICAL SCRIPT SMALL T + "TScy", 0x00426, // CYRILLIC CAPITAL LETTER TSE + "tscy", 0x00446, // CYRILLIC SMALL LETTER TSE + "TSHcy", 0x0040B, // CYRILLIC CAPITAL LETTER TSHE + "tshcy", 0x0045B, // CYRILLIC SMALL LETTER TSHE + "Tstrok", 0x00166, // LATIN CAPITAL LETTER T WITH STROKE + "tstrok", 0x00167, // LATIN SMALL LETTER T WITH STROKE + "twixt", 0x0226C, // BETWEEN + "twoheadleftarrow", 0x0219E, // LEFTWARDS TWO HEADED ARROW + "twoheadrightarrow", 0x021A0, // RIGHTWARDS TWO HEADED ARROW + NULL, 0 }; static NameId namesU[]={ - "Uacgr", 0x038E, - "uacgr", 0x03CD, - "Uacute", 0x00DA, - "uacute", 0x00FA, - "uarr", 0x2191, - "uArr", 0x21D1, - "uarr2", 0x21C8, - "Ubrcy", 0x040E, - "ubrcy", 0x045E, - "Ubreve", 0x016C, - "ubreve", 0x016D, - "Ucirc", 0x00DB, - "ucirc", 0x00FB, - "Ucy", 0x0423, - "ucy", 0x0443, - "Udblac", 0x0170, - "udblac", 0x0171, - "udiagr", 0x03B0, - "Udigr", 0x03AB, - "udigr", 0x03CB, - "Ugr", 0x03A5, - "ugr", 0x03C5, - "Ugrave", 0x00D9, - "ugrave", 0x00F9, - "uharl", 0x21BF, - "uharr", 0x21BE, - "uhblk", 0x2580, - "ulcorn", 0x231C, - "ulcrop", 0x230F, - "Umacr", 0x016A, - "umacr", 0x016B, - "uml", 0x00A8, - "Uogon", 0x0172, - "uogon", 0x0173, - "uplus", 0x228E, - "upsi", 0x03C5, - "Upsi", 0x03D2, - "urcorn", 0x231D, - "urcrop", 0x230E, - "Uring", 0x016E, - "uring", 0x016F, - "Utilde", 0x0168, - "utilde", 0x0169, - "utri", 0x25B5, - "utrif", 0x25B4, - "Uuml", 0x00DC, - "uuml", 0x00FC, - NULL, 0 + "Uacgr", 0x0038E, // GREEK CAPITAL LETTER UPSILON WITH TONOS + "uacgr", 0x003CD, // GREEK SMALL LETTER UPSILON WITH TONOS + "Uacute", 0x000DA, // LATIN CAPITAL LETTER U WITH ACUTE + "uacute", 0x000FA, // LATIN SMALL LETTER U WITH ACUTE + "uarr", 0x02191, // UPWARDS ARROW + "Uarr", 0x0219F, // UPWARDS TWO HEADED ARROW + "uArr", 0x021D1, // UPWARDS DOUBLE ARROW + "Uarrocir", 0x02949, // UPWARDS TWO-HEADED ARROW FROM SMALL CIRCLE + "Ubrcy", 0x0040E, // CYRILLIC CAPITAL LETTER SHORT U + "ubrcy", 0x0045E, // CYRILLIC SMALL LETTER SHORT U + "Ubreve", 0x0016C, // LATIN CAPITAL LETTER U WITH BREVE + "ubreve", 0x0016D, // LATIN SMALL LETTER U WITH BREVE + "Ucirc", 0x000DB, // LATIN CAPITAL LETTER U WITH CIRCUMFLEX + "ucirc", 0x000FB, // LATIN SMALL LETTER U WITH CIRCUMFLEX + "Ucy", 0x00423, // CYRILLIC CAPITAL LETTER U + "ucy", 0x00443, // CYRILLIC SMALL LETTER U + "udarr", 0x021C5, // UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW + "Udblac", 0x00170, // LATIN CAPITAL LETTER U WITH DOUBLE ACUTE + "udblac", 0x00171, // LATIN SMALL LETTER U WITH DOUBLE ACUTE + "udhar", 0x0296E, // UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT + "udiagr", 0x003B0, // GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + "Udigr", 0x003AB, // GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA + "udigr", 0x003CB, // GREEK SMALL LETTER UPSILON WITH DIALYTIKA + "ufisht", 0x0297E, // UP FISH TAIL + "Ufr", 0x1D518, // MATHEMATICAL FRAKTUR CAPITAL U + "ufr", 0x1D532, // MATHEMATICAL FRAKTUR SMALL U + "Ugr", 0x003A5, // GREEK CAPITAL LETTER UPSILON + "ugr", 0x003C5, // GREEK SMALL LETTER UPSILON + "Ugrave", 0x000D9, // LATIN CAPITAL LETTER U WITH GRAVE + "ugrave", 0x000F9, // LATIN SMALL LETTER U WITH GRAVE + "uHar", 0x02963, // UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT + "uharl", 0x021BF, // UPWARDS HARPOON WITH BARB LEFTWARDS + "uharr", 0x021BE, // UPWARDS HARPOON WITH BARB RIGHTWARDS + "uhblk", 0x02580, // UPPER HALF BLOCK + "ulcorn", 0x0231C, // TOP LEFT CORNER + "ulcorner", 0x0231C, // TOP LEFT CORNER + "ulcrop", 0x0230F, // TOP LEFT CROP + "ultri", 0x025F8, // UPPER LEFT TRIANGLE + "Umacr", 0x0016A, // LATIN CAPITAL LETTER U WITH MACRON + "umacr", 0x0016B, // LATIN SMALL LETTER U WITH MACRON + "uml", 0x000A8, // DIAERESIS + "UnderBar", 0x0005F, // LOW LINE + "UnderBrace", 0x023DF, // BOTTOM CURLY BRACKET + "UnderBracket", 0x023B5, // BOTTOM SQUARE BRACKET + "UnderParenthesis", 0x023DD, // BOTTOM PARENTHESIS + "Union", 0x022C3, // N-ARY UNION + "UnionPlus", 0x0228E, // MULTISET UNION + "Uogon", 0x00172, // LATIN CAPITAL LETTER U WITH OGONEK + "uogon", 0x00173, // LATIN SMALL LETTER U WITH OGONEK + "Uopf", 0x1D54C, // MATHEMATICAL DOUBLE-STRUCK CAPITAL U + "uopf", 0x1D566, // MATHEMATICAL DOUBLE-STRUCK SMALL U + "uparrow", 0x02191, // UPWARDS ARROW + "UpArrow", 0x02191, // UPWARDS ARROW + "Uparrow", 0x021D1, // UPWARDS DOUBLE ARROW + "UpArrowBar", 0x02912, // UPWARDS ARROW TO BAR + "UpArrowDownArrow", 0x021C5, // UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW + "updownarrow", 0x02195, // UP DOWN ARROW + "UpDownArrow", 0x02195, // UP DOWN ARROW + "Updownarrow", 0x021D5, // UP DOWN DOUBLE ARROW + "UpEquilibrium", 0x0296E, // UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT + "upharpoonleft", 0x021BF, // UPWARDS HARPOON WITH BARB LEFTWARDS + "upharpoonright", 0x021BE, // UPWARDS HARPOON WITH BARB RIGHTWARDS + "uplus", 0x0228E, // MULTISET UNION + "UpperLeftArrow", 0x02196, // NORTH WEST ARROW + "UpperRightArrow", 0x02197, // NORTH EAST ARROW + "upsi", 0x003C5, // GREEK SMALL LETTER UPSILON + "Upsi", 0x003D2, // GREEK UPSILON WITH HOOK SYMBOL + "upsih", 0x003D2, // GREEK UPSILON WITH HOOK SYMBOL + "Upsilon", 0x003A5, // GREEK CAPITAL LETTER UPSILON + "upsilon", 0x003C5, // GREEK SMALL LETTER UPSILON + "UpTee", 0x022A5, // UP TACK + "UpTeeArrow", 0x021A5, // UPWARDS ARROW FROM BAR + "upuparrows", 0x021C8, // UPWARDS PAIRED ARROWS + "urcorn", 0x0231D, // TOP RIGHT CORNER + "urcorner", 0x0231D, // TOP RIGHT CORNER + "urcrop", 0x0230E, // TOP RIGHT CROP + "Uring", 0x0016E, // LATIN CAPITAL LETTER U WITH RING ABOVE + "uring", 0x0016F, // LATIN SMALL LETTER U WITH RING ABOVE + "urtri", 0x025F9, // UPPER RIGHT TRIANGLE + "Uscr", 0x1D4B0, // MATHEMATICAL SCRIPT CAPITAL U + "uscr", 0x1D4CA, // MATHEMATICAL SCRIPT SMALL U + "utdot", 0x022F0, // UP RIGHT DIAGONAL ELLIPSIS + "Utilde", 0x00168, // LATIN CAPITAL LETTER U WITH TILDE + "utilde", 0x00169, // LATIN SMALL LETTER U WITH TILDE + "utri", 0x025B5, // WHITE UP-POINTING SMALL TRIANGLE + "utrif", 0x025B4, // BLACK UP-POINTING SMALL TRIANGLE + "uuarr", 0x021C8, // UPWARDS PAIRED ARROWS + "Uuml", 0x000DC, // LATIN CAPITAL LETTER U WITH DIAERESIS + "uuml", 0x000FC, // LATIN SMALL LETTER U WITH DIAERESIS + "uwangle", 0x029A7, // OBLIQUE ANGLE OPENING DOWN + NULL, 0 }; static NameId namesV[]={ - "varr", 0x2195, - "vArr", 0x21D5, - "Vcy", 0x0412, - "vcy", 0x0432, - "vdash", 0x22A2, - "vDash", 0x22A8, - "Vdash", 0x22A9, - "veebar", 0x22BB, - "vellip", 0x22EE, - "verbar", 0x007C, - "Verbar", 0x2016, - "vltri", 0x22B2, - "vprime", 0x2032, - "vprop", 0x221D, - "vrtri", 0x22B3, - "vsubne", 0x228A, - "vsubnE", 0xE2B8, - "vsupne", 0x228B, - "vsupnE", 0x228B, - "Vvdash", 0x22AA, - NULL, 0 + "vangrt", 0x0299C, // RIGHT ANGLE VARIANT WITH SQUARE + "varepsilon", 0x003F5, // GREEK LUNATE EPSILON SYMBOL + "varkappa", 0x003F0, // GREEK KAPPA SYMBOL + "varnothing", 0x02205, // EMPTY SET + "varphi", 0x003D5, // GREEK PHI SYMBOL + "varpi", 0x003D6, // GREEK PI SYMBOL + "varpropto", 0x0221D, // PROPORTIONAL TO + "varr", 0x02195, // UP DOWN ARROW + "vArr", 0x021D5, // UP DOWN DOUBLE ARROW + "varrho", 0x003F1, // GREEK RHO SYMBOL + "varsigma", 0x003C2, // GREEK SMALL LETTER FINAL SIGMA +// "varsubsetneq", 0x0228A;0x0FE00, // SUBSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "varsubsetneqq", 0x02ACB;0x0FE00, // SUBSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members +// "varsupsetneq", 0x0228B;0x0FE00, // SUPERSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "varsupsetneqq", 0x02ACC;0x0FE00, // SUPERSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members + "vartheta", 0x003D1, // GREEK THETA SYMBOL + "vartriangleleft", 0x022B2, // NORMAL SUBGROUP OF + "vartriangleright", 0x022B3, // CONTAINS AS NORMAL SUBGROUP + "vBar", 0x02AE8, // SHORT UP TACK WITH UNDERBAR + "Vbar", 0x02AEB, // DOUBLE UP TACK + "vBarv", 0x02AE9, // SHORT UP TACK ABOVE SHORT DOWN TACK + "Vcy", 0x00412, // CYRILLIC CAPITAL LETTER VE + "vcy", 0x00432, // CYRILLIC SMALL LETTER VE + "vdash", 0x022A2, // RIGHT TACK + "vDash", 0x022A8, // TRUE + "Vdash", 0x022A9, // FORCES + "VDash", 0x022AB, // DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE + "Vdashl", 0x02AE6, // LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL + "vee", 0x02228, // LOGICAL OR + "Vee", 0x022C1, // N-ARY LOGICAL OR + "veebar", 0x022BB, // XOR + "veeeq", 0x0225A, // EQUIANGULAR TO + "vellip", 0x022EE, // VERTICAL ELLIPSIS + "verbar", 0x0007C, // VERTICAL LINE + "Verbar", 0x02016, // DOUBLE VERTICAL LINE + "vert", 0x0007C, // VERTICAL LINE + "Vert", 0x02016, // DOUBLE VERTICAL LINE + "VerticalBar", 0x02223, // DIVIDES + "VerticalLine", 0x0007C, // VERTICAL LINE + "VerticalSeparator", 0x02758, // LIGHT VERTICAL BAR + "VerticalTilde", 0x02240, // WREATH PRODUCT + "VeryThinSpace", 0x0200A, // HAIR SPACE + "Vfr", 0x1D519, // MATHEMATICAL FRAKTUR CAPITAL V + "vfr", 0x1D533, // MATHEMATICAL FRAKTUR SMALL V + "vltri", 0x022B2, // NORMAL SUBGROUP OF +// "vnsub", 0x02282;0x020D2, // SUBSET OF with vertical line +// "vnsup", 0x02283;0x020D2, // SUPERSET OF with vertical line + "Vopf", 0x1D54D, // MATHEMATICAL DOUBLE-STRUCK CAPITAL V + "vopf", 0x1D567, // MATHEMATICAL DOUBLE-STRUCK SMALL V + "vprop", 0x0221D, // PROPORTIONAL TO + "vrtri", 0x022B3, // CONTAINS AS NORMAL SUBGROUP + "Vscr", 0x1D4B1, // MATHEMATICAL SCRIPT CAPITAL V + "vscr", 0x1D4CB, // MATHEMATICAL SCRIPT SMALL V +// "vsubne", 0x0228A;0x0FE00, // SUBSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "vsubnE", 0x02ACB;0x0FE00, // SUBSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members +// "vsupne", 0x0228B;0x0FE00, // SUPERSET OF WITH NOT EQUAL TO - variant with stroke through bottom members +// "vsupnE", 0x02ACC;0x0FE00, // SUPERSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members + "Vvdash", 0x022AA, // TRIPLE VERTICAL BAR RIGHT TURNSTILE + "vzigzag", 0x0299A, // VERTICAL ZIGZAG LINE + NULL, 0 }; static NameId namesW[]={ - "Wcirc", 0x0174, - "wcirc", 0x0175, - "wedgeq", 0x2259, - "weierp", 0x2118, - "wreath", 0x2240, - NULL, 0 + "Wcirc", 0x00174, // LATIN CAPITAL LETTER W WITH CIRCUMFLEX + "wcirc", 0x00175, // LATIN SMALL LETTER W WITH CIRCUMFLEX + "wedbar", 0x02A5F, // LOGICAL AND WITH UNDERBAR + "wedge", 0x02227, // LOGICAL AND + "Wedge", 0x022C0, // N-ARY LOGICAL AND + "wedgeq", 0x02259, // ESTIMATES + "weierp", 0x02118, // SCRIPT CAPITAL P + "Wfr", 0x1D51A, // MATHEMATICAL FRAKTUR CAPITAL W + "wfr", 0x1D534, // MATHEMATICAL FRAKTUR SMALL W + "Wopf", 0x1D54E, // MATHEMATICAL DOUBLE-STRUCK CAPITAL W + "wopf", 0x1D568, // MATHEMATICAL DOUBLE-STRUCK SMALL W + "wp", 0x02118, // SCRIPT CAPITAL P + "wr", 0x02240, // WREATH PRODUCT + "wreath", 0x02240, // WREATH PRODUCT + "Wscr", 0x1D4B2, // MATHEMATICAL SCRIPT CAPITAL W + "wscr", 0x1D4CC, // MATHEMATICAL SCRIPT SMALL W + NULL, 0 }; static NameId namesX[]={ - "xcirc", 0x25CB, - "xdtri", 0x25BD, - "Xgr", 0x039E, - "xgr", 0x03BE, - "xharr", 0x2194, - "xhArr", 0x2194, - "Xi", 0x039E, - "xi", 0x03BE, - "xlArr", 0x21D0, - "xrArr", 0x21D2, - "xutri", 0x25B3, - NULL, 0 + "xcap", 0x022C2, // N-ARY INTERSECTION + "xcirc", 0x025EF, // LARGE CIRCLE + "xcup", 0x022C3, // N-ARY UNION + "xdtri", 0x025BD, // WHITE DOWN-POINTING TRIANGLE + "Xfr", 0x1D51B, // MATHEMATICAL FRAKTUR CAPITAL X + "xfr", 0x1D535, // MATHEMATICAL FRAKTUR SMALL X + "Xgr", 0x0039E, // GREEK CAPITAL LETTER XI + "xgr", 0x003BE, // GREEK SMALL LETTER XI + "xharr", 0x027F7, // LONG LEFT RIGHT ARROW + "xhArr", 0x027FA, // LONG LEFT RIGHT DOUBLE ARROW + "Xi", 0x0039E, // GREEK CAPITAL LETTER XI + "xi", 0x003BE, // GREEK SMALL LETTER XI + "xlarr", 0x027F5, // LONG LEFTWARDS ARROW + "xlArr", 0x027F8, // LONG LEFTWARDS DOUBLE ARROW + "xmap", 0x027FC, // LONG RIGHTWARDS ARROW FROM BAR + "xnis", 0x022FB, // CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE + "xodot", 0x02A00, // N-ARY CIRCLED DOT OPERATOR + "Xopf", 0x1D54F, // MATHEMATICAL DOUBLE-STRUCK CAPITAL X + "xopf", 0x1D569, // MATHEMATICAL DOUBLE-STRUCK SMALL X + "xoplus", 0x02A01, // N-ARY CIRCLED PLUS OPERATOR + "xotime", 0x02A02, // N-ARY CIRCLED TIMES OPERATOR + "xrarr", 0x027F6, // LONG RIGHTWARDS ARROW + "xrArr", 0x027F9, // LONG RIGHTWARDS DOUBLE ARROW + "Xscr", 0x1D4B3, // MATHEMATICAL SCRIPT CAPITAL X + "xscr", 0x1D4CD, // MATHEMATICAL SCRIPT SMALL X + "xsqcup", 0x02A06, // N-ARY SQUARE UNION OPERATOR + "xuplus", 0x02A04, // N-ARY UNION OPERATOR WITH PLUS + "xutri", 0x025B3, // WHITE UP-POINTING TRIANGLE + "xvee", 0x022C1, // N-ARY LOGICAL OR + "xwedge", 0x022C0, // N-ARY LOGICAL AND + NULL, 0 }; static NameId namesY[]={ - "Yacute", 0x00DD, - "yacute", 0x00FD, - "YAcy", 0x042F, - "yacy", 0x044F, - "Ycirc", 0x0176, - "ycirc", 0x0177, - "Ycy", 0x042B, - "ycy", 0x044B, - "yen", 0x00A5, - "YIcy", 0x0407, - "yicy", 0x0457, - "YUcy", 0x042E, - "yucy", 0x044E, - "yuml", 0x00FF, - "Yuml", 0x0178, - NULL, 0 + "Yacute", 0x000DD, // LATIN CAPITAL LETTER Y WITH ACUTE + "yacute", 0x000FD, // LATIN SMALL LETTER Y WITH ACUTE + "YAcy", 0x0042F, // CYRILLIC CAPITAL LETTER YA + "yacy", 0x0044F, // CYRILLIC SMALL LETTER YA + "Ycirc", 0x00176, // LATIN CAPITAL LETTER Y WITH CIRCUMFLEX + "ycirc", 0x00177, // LATIN SMALL LETTER Y WITH CIRCUMFLEX + "Ycy", 0x0042B, // CYRILLIC CAPITAL LETTER YERU + "ycy", 0x0044B, // CYRILLIC SMALL LETTER YERU + "yen", 0x000A5, // YEN SIGN + "Yfr", 0x1D51C, // MATHEMATICAL FRAKTUR CAPITAL Y + "yfr", 0x1D536, // MATHEMATICAL FRAKTUR SMALL Y + "YIcy", 0x00407, // CYRILLIC CAPITAL LETTER YI + "yicy", 0x00457, // CYRILLIC SMALL LETTER YI + "Yopf", 0x1D550, // MATHEMATICAL DOUBLE-STRUCK CAPITAL Y + "yopf", 0x1D56A, // MATHEMATICAL DOUBLE-STRUCK SMALL Y + "Yscr", 0x1D4B4, // MATHEMATICAL SCRIPT CAPITAL Y + "yscr", 0x1D4CE, // MATHEMATICAL SCRIPT SMALL Y + "YUcy", 0x0042E, // CYRILLIC CAPITAL LETTER YU + "yucy", 0x0044E, // CYRILLIC SMALL LETTER YU + "yuml", 0x000FF, // LATIN SMALL LETTER Y WITH DIAERESIS + "Yuml", 0x00178, // LATIN CAPITAL LETTER Y WITH DIAERESIS + NULL, 0 }; static NameId namesZ[]={ - "Zacute", 0x0179, - "zacute", 0x017A, - "Zcaron", 0x017D, - "zcaron", 0x017E, - "Zcy", 0x0417, - "zcy", 0x0437, - "Zdot", 0x017B, - "zdot", 0x017C, - "zeta", 0x03B6, - "Zgr", 0x0396, - "zgr", 0x03B6, - "ZHcy", 0x0416, - "zhcy", 0x0436, - NULL, 0 + "Zacute", 0x00179, // LATIN CAPITAL LETTER Z WITH ACUTE + "zacute", 0x0017A, // LATIN SMALL LETTER Z WITH ACUTE + "Zcaron", 0x0017D, // LATIN CAPITAL LETTER Z WITH CARON + "zcaron", 0x0017E, // LATIN SMALL LETTER Z WITH CARON + "Zcy", 0x00417, // CYRILLIC CAPITAL LETTER ZE + "zcy", 0x00437, // CYRILLIC SMALL LETTER ZE + "Zdot", 0x0017B, // LATIN CAPITAL LETTER Z WITH DOT ABOVE + "zdot", 0x0017C, // LATIN SMALL LETTER Z WITH DOT ABOVE + "zeetrf", 0x02128, // BLACK-LETTER CAPITAL Z + "ZeroWidthSpace", 0x0200B, // ZERO WIDTH SPACE + "Zeta", 0x00396, // GREEK CAPITAL LETTER ZETA + "zeta", 0x003B6, // GREEK SMALL LETTER ZETA + "Zfr", 0x02128, // BLACK-LETTER CAPITAL Z + "zfr", 0x1D537, // MATHEMATICAL FRAKTUR SMALL Z + "Zgr", 0x00396, // GREEK CAPITAL LETTER ZETA + "zgr", 0x003B6, // GREEK SMALL LETTER ZETA + "ZHcy", 0x00416, // CYRILLIC CAPITAL LETTER ZHE + "zhcy", 0x00436, // CYRILLIC SMALL LETTER ZHE + "zigrarr", 0x021DD, // RIGHTWARDS SQUIGGLE ARROW + "Zopf", 0x02124, // DOUBLE-STRUCK CAPITAL Z + "zopf", 0x1D56B, // MATHEMATICAL DOUBLE-STRUCK SMALL Z + "Zscr", 0x1D4B5, // MATHEMATICAL SCRIPT CAPITAL Z + "zscr", 0x1D4CF, // MATHEMATICAL SCRIPT SMALL Z + "zwj", 0x0200D, // ZERO WIDTH JOINER + "zwnj", 0x0200C, // ZERO WIDTH NON-JOINER + NULL, 0 }; // @todo@ order namesTable and names? by frequency @@ -1070,297 +2375,17 @@ static NameId* namesTable[] = { int HtmlNamedEntity(unsigned char *p, int length) { int tableIndex = tolower(*p) - 'a'; - if (tableIndex >= 0 && tableIndex < 26) { + if (tableIndex >= 0 && tableIndex < 26) + { NameId* names = namesTable[tableIndex]; int i; - for (i = 0; names[i].name; i++){ - if (strncmp(names[i].name, (char *)p, length) == 0){ - return names[i].value; - } + for (i = 0; names[i].name; i++) + { + if (strncmp(names[i].name, (char *)p, length) == 0) + return names[i].value; } } - error("unrecognized character entity \"%.*s\"", length, p); return -1; } -#else //TODO: Merge Walter's list with Thomas' - -static NameId names[] = -{ - // Entities - "quot", 34, - "amp", 38, - "lt", 60, - "gt", 62, - - "OElig", 338, - "oelig", 339, - "Scaron", 352, - "scaron", 353, - "Yuml", 376, - "circ", 710, - "tilde", 732, - "ensp", 8194, - "emsp", 8195, - "thinsp", 8201, - "zwnj", 8204, - "zwj", 8205, - "lrm", 8206, - "rlm", 8207, - "ndash", 8211, - "mdash", 8212, - "lsquo", 8216, - "rsquo", 8217, - "sbquo", 8218, - "ldquo", 8220, - "rdquo", 8221, - "bdquo", 8222, - "dagger", 8224, - "Dagger", 8225, - "permil", 8240, - "lsaquo", 8249, - "rsaquo", 8250, - "euro", 8364, - - // Latin-1 (ISO-8859-1) Entities - "nbsp", 160, - "iexcl", 161, - "cent", 162, - "pound", 163, - "curren", 164, - "yen", 165, - "brvbar", 166, - "sect", 167, - "uml", 168, - "copy", 169, - "ordf", 170, - "laquo", 171, - "not", 172, - "shy", 173, - "reg", 174, - "macr", 175, - "deg", 176, - "plusmn", 177, - "sup2", 178, - "sup3", 179, - "acute", 180, - "micro", 181, - "para", 182, - "middot", 183, - "cedil", 184, - "sup1", 185, - "ordm", 186, - "raquo", 187, - "frac14", 188, - "frac12", 189, - "frac34", 190, - "iquest", 191, - "Agrave", 192, - "Aacute", 193, - "Acirc", 194, - "Atilde", 195, - "Auml", 196, - "Aring", 197, - "AElig", 198, - "Ccedil", 199, - "Egrave", 200, - "Eacute", 201, - "Ecirc", 202, - "Euml", 203, - "Igrave", 204, - "Iacute", 205, - "Icirc", 206, - "Iuml", 207, - "ETH", 208, - "Ntilde", 209, - "Ograve", 210, - "Oacute", 211, - "Ocirc", 212, - "Otilde", 213, - "Ouml", 214, - "times", 215, - "Oslash", 216, - "Ugrave", 217, - "Uacute", 218, - "Ucirc", 219, - "Uuml", 220, - "Yacute", 221, - "THORN", 222, - "szlig", 223, - "agrave", 224, - "aacute", 225, - "acirc", 226, - "atilde", 227, - "auml", 228, - "aring", 229, - "aelig", 230, - "ccedil", 231, - "egrave", 232, - "eacute", 233, - "ecirc", 234, - "euml", 235, - "igrave", 236, - "iacute", 237, - "icirc", 238, - "iuml", 239, - "eth", 240, - "ntilde", 241, - "ograve", 242, - "oacute", 243, - "ocirc", 244, - "otilde", 245, - "ouml", 246, - "divide", 247, - "oslash", 248, - "ugrave", 249, - "uacute", 250, - "ucirc", 251, - "uuml", 252, - "yacute", 253, - "thorn", 254, - "yuml", 255, - - // Symbols and Greek letter entities - "fnof", 402, - "Alpha", 913, - "Beta", 914, - "Gamma", 915, - "Delta", 916, - "Epsilon", 917, - "Zeta", 918, - "Eta", 919, - "Theta", 920, - "Iota", 921, - "Kappa", 922, - "Lambda", 923, - "Mu", 924, - "Nu", 925, - "Xi", 926, - "Omicron", 927, - "Pi", 928, - "Rho", 929, - "Sigma", 931, - "Tau", 932, - "Upsilon", 933, - "Phi", 934, - "Chi", 935, - "Psi", 936, - "Omega", 937, - "alpha", 945, - "beta", 946, - "gamma", 947, - "delta", 948, - "epsilon", 949, - "zeta", 950, - "eta", 951, - "theta", 952, - "iota", 953, - "kappa", 954, - "lambda", 955, - "mu", 956, - "nu", 957, - "xi", 958, - "omicron", 959, - "pi", 960, - "rho", 961, - "sigmaf", 962, - "sigma", 963, - "tau", 964, - "upsilon", 965, - "phi", 966, - "chi", 967, - "psi", 968, - "omega", 969, - "thetasym", 977, - "upsih", 978, - "piv", 982, - "bull", 8226, - "hellip", 8230, - "prime", 8242, - "Prime", 8243, - "oline", 8254, - "frasl", 8260, - "weierp", 8472, - "image", 8465, - "real", 8476, - "trade", 8482, - "alefsym", 8501, - "larr", 8592, - "uarr", 8593, - "rarr", 8594, - "darr", 8595, - "harr", 8596, - "crarr", 8629, - "lArr", 8656, - "uArr", 8657, - "rArr", 8658, - "dArr", 8659, - "hArr", 8660, - "forall", 8704, - "part", 8706, - "exist", 8707, - "empty", 8709, - "nabla", 8711, - "isin", 8712, - "notin", 8713, - "ni", 8715, - "prod", 8719, - "sum", 8721, - "minus", 8722, - "lowast", 8727, - "radic", 8730, - "prop", 8733, - "infin", 8734, - "ang", 8736, - "and", 8743, - "or", 8744, - "cap", 8745, - "cup", 8746, - "int", 8747, - "there4", 8756, - "sim", 8764, - "cong", 8773, - "asymp", 8776, - "ne", 8800, - "equiv", 8801, - "le", 8804, - "ge", 8805, - "sub", 8834, - "sup", 8835, - "nsub", 8836, - "sube", 8838, - "supe", 8839, - "oplus", 8853, - "otimes", 8855, - "perp", 8869, - "sdot", 8901, - "lceil", 8968, - "rceil", 8969, - "lfloor", 8970, - "rfloor", 8971, - "lang", 9001, - "rang", 9002, - "loz", 9674, - "spades", 9824, - "clubs", 9827, - "hearts", 9829, - "diams", 9830, -}; - -int HtmlNamedEntity(unsigned char *p, int length) -{ - int i; - - // BUG: this is a dumb, slow linear search - for (i = 0; i < sizeof(names) / sizeof(names[0]); i++) - { - // Entries are case sensitive - if (memcmp(names[i].name, (char *)p, length) == 0 && - !names[i].name[length]) - return names[i].value; - } - return -1; -} - -#endif diff --git a/dmd2/expression.c b/dmd2/expression.c index b3302ce9..37a1ff3f 100644 --- a/dmd2/expression.c +++ b/dmd2/expression.c @@ -137,6 +137,14 @@ Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad, e1 = new VarExp(loc, f->vthis); } + else + { + e1->error("need 'this' of type %s to access member %s" + " from static function %s", + ad->toChars(), var->toChars(), f->toChars()); + e1 = new ErrorExp(); + return e1; + } } if (s && s->isClassDeclaration()) { e1->type = s->isClassDeclaration()->type; @@ -2401,6 +2409,11 @@ Lagain: if (!f->originalType && f->scope) // semantic not yet run f->semantic(f->scope); + + // if inferring return type, sematic3 needs to be run + if (f->inferRetType && f->scope && f->type && !f->type->nextOf()) + f->semantic3(f->scope); + if (f->isUnitTestDeclaration()) { error("cannot call unittest function %s", toChars()); @@ -4304,6 +4317,9 @@ Expression *VarExp::semantic(Scope *sc) #endif } + if (type && !type->deco) + type = type->semantic(loc, sc); + /* Fix for 1161 doesn't work because it causes protection * problems when instantiating imported templates passing private * variables as alias template parameters. @@ -4772,9 +4788,14 @@ Expression *DeclarationExp::semantic(Scope *sc) error("declaration %s is already defined", s->toPrettyChars()); else if (sc->func) { VarDeclaration *v = s->isVarDeclaration(); - if (s->isFuncDeclaration() && + if ( (s->isFuncDeclaration() || s->isTypedefDeclaration() || + s->isAggregateDeclaration() || s->isEnumDeclaration() || + s->isInterfaceDeclaration()) && !sc->func->localsymtab->insert(s)) - error("declaration %s is already defined in another scope in %s", s->toPrettyChars(), sc->func->toChars()); + { + error("declaration %s is already defined in another scope in %s", + s->toPrettyChars(), sc->func->toChars()); + } else if (!global.params.useDeprecated) { // Disallow shadowing @@ -5410,6 +5431,8 @@ Expression *BinExp::semantic(Scope *sc) error("%s has no value", e2->toChars()); return new ErrorExp(); } + if (e1->op == TOKerror || e2->op == TOKerror) + return new ErrorExp(); return this; } @@ -6026,7 +6049,8 @@ Expression *DotIdExp::semantic(Scope *sc, int flag) e->type = v->type; } } - return e->deref(); + e = e->deref(); + return e->semantic(sc); } FuncDeclaration *f = s->isFuncDeclaration(); @@ -8659,6 +8683,8 @@ Expression *IndexExp::semantic(Scope *sc) if (!e1->type) e1 = e1->semantic(sc); assert(e1->type); // semantic() should already be run on it + if (e1->op == TOKerror) + goto Lerr; e = this; // Note that unlike C we do not implement the int[ptr] @@ -8768,6 +8794,8 @@ Expression *IndexExp::semantic(Scope *sc) } default: + if (e1->op == TOKerror) + goto Lerr; error("%s must be an array or pointer type, not %s", e1->toChars(), e1->type->toChars()); case Terror: @@ -9055,7 +9083,9 @@ Expression *AssignExp::semantic(Scope *sc) } } - BinExp::semantic(sc); + Expression *e = BinExp::semantic(sc); + if (e->op == TOKerror) + return e; if (e1->op == TOKdottd) { // Rewrite a.b=e2, when b is a template, as a.b(e2) @@ -9188,10 +9218,23 @@ Expression *AssignExp::semantic(Scope *sc) } if (t1->ty == Tsarray && !refinit) - { // Convert e1 to e1[] - Expression *e = new SliceExp(e1->loc, e1, NULL, NULL); - e1 = e->semantic(sc); - t1 = e1->type->toBasetype(); + { + if (e1->op == TOKindex && + ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray) + { + // Assignment to an AA of fixed-length arrays. + // Convert T[n][U] = T[] into T[n][U] = T[n] + e2 = e2->implicitCastTo(sc, e1->type); + if (e2->type == Type::terror) + return e2; + } + else + { + // Convert e1 to e1[] + Expression *e = new SliceExp(e1->loc, e1, NULL, NULL); + e1 = e->semantic(sc); + t1 = e1->type->toBasetype(); + } } e2->rvalue(); @@ -9233,8 +9276,13 @@ Expression *AssignExp::semantic(Scope *sc) else if (t1->ty == Tsarray) { /* Should have already converted e1 => e1[] + * unless it is an AA */ - assert(op == TOKconstruct); + if (!(e1->op == TOKindex && t2->ty == Tsarray && + ((IndexExp *)e1)->e1->type->toBasetype()->ty == Taarray)) + { + assert(op == TOKconstruct); + } //error("cannot assign to static array %s", e1->toChars()); } else if (e1->op == TOKslice) diff --git a/dmd2/func.c b/dmd2/func.c index 52555760..b62ba3ea 100644 --- a/dmd2/func.c +++ b/dmd2/func.c @@ -1,5 +1,5 @@ // Compiler implementation of the D programming language -// Copyright (c) 1999-2010 by Digital Mars +// Copyright (c) 1999-2011 by Digital Mars // All Rights Reserved // written by Walter Bright // http://www.digitalmars.com @@ -66,6 +66,7 @@ FuncDeclaration::FuncDeclaration(Loc loc, Loc endloc, Identifier *id, StorageCla inlineNest = 0; inlineAsm = 0; cantInterpret = 0; + isArrayOp = 0; semanticRun = PASSinit; #if DMDV1 nestedFrameRef = 0; @@ -972,9 +973,24 @@ void FuncDeclaration::semantic3(Scope *sc) if (f->varargs == 1) { #if TARGET_NET - varArgs(sc2, f, argptr, _arguments); + varArgs(sc2, f, argptr, _arguments); #else - Type *t; + Type *t; + + if (global.params.is64bit) + { // Declare save area for varargs registers + Type *t = new TypeIdentifier(loc, Id::va_argsave_t); + t = t->semantic(loc, sc); + if (t == Type::terror) + error("must import core.vararg to use variadic functions"); + else + { + v_argsave = new VarDeclaration(loc, t, Id::va_argsave, NULL); + v_argsave->semantic(sc2); + sc2->insert(v_argsave); + v_argsave->parent = this; + } + } if (f->linkage == LINKd) { // Declare _arguments[] @@ -1014,20 +1030,6 @@ void FuncDeclaration::semantic3(Scope *sc) } #endif } - if (global.params.is64bit && f->varargs && f->linkage == LINKc) - { // Declare save area for varargs registers - Type *t = new TypeIdentifier(loc, Id::va_argsave_t); - t = t->semantic(loc, sc); - if (t == Type::terror) - error("must import std.c.stdarg to use variadic functions"); - else - { - v_argsave = new VarDeclaration(loc, t, Id::va_argsave, NULL); - v_argsave->semantic(sc2); - sc2->insert(v_argsave); - v_argsave->parent = this; - } - } #if IN_LLVM // LDC make sure argument type is semanticed. @@ -1458,53 +1460,65 @@ void FuncDeclaration::semantic3(Scope *sc) // we'll handle variadics ourselves #if !IN_LLVM if (argptr) - { // Initialize _argptr to point past non-variadic arg + { // Initialize _argptr #if IN_GCC // Handled in FuncDeclaration::toObjFile v_argptr = argptr; v_argptr->init = new VoidInitializer(loc); #else Type *t = argptr->type; - VarDeclaration *p; - unsigned offset = 0; - - Expression *e1 = new VarExp(0, argptr); - // Find the last non-ref parameter - if (parameters && parameters->dim) - { - int lastNonref = parameters->dim -1; - p = (VarDeclaration *)parameters->data[lastNonref]; - /* The trouble with out and ref parameters is that taking - * the address of it doesn't work, because later processing - * adds in an extra level of indirection. So we skip over them. - */ - while (p->storage_class & (STCout | STCref)) - { - --lastNonref; - offset += PTRSIZE; - if (lastNonref < 0) - { - p = v_arguments; - break; - } - p = (VarDeclaration *)parameters->data[lastNonref]; - } + if (global.params.isX86_64) + { // Initialize _argptr to point to v_argsave + Expression *e1 = new VarExp(0, argptr); + Expression *e = new SymOffExp(0, v_argsave, 6*8 + 8*16); + e->type = argptr->type; + e = new AssignExp(0, e1, e); + e = e->semantic(sc); + a->push(new ExpStatement(0, e)); } else - p = v_arguments; // last parameter is _arguments[] - if (p->storage_class & STClazy) - // If the last parameter is lazy, it's the size of a delegate - offset += PTRSIZE * 2; - else - offset += p->type->size(); - offset = (offset + PTRSIZE - 1) & ~(PTRSIZE - 1); // assume stack aligns on pointer size - Expression *e = new SymOffExp(0, p, offset); - e->type = Type::tvoidptr; - //e = e->semantic(sc); - e = new AssignExp(0, e1, e); - e->type = t; - a->push(new ExpStatement(0, e)); - p->isargptr = TRUE; + { // Initialize _argptr to point past non-variadic arg + VarDeclaration *p; + unsigned offset = 0; + + Expression *e1 = new VarExp(0, argptr); + // Find the last non-ref parameter + if (parameters && parameters->dim) + { + int lastNonref = parameters->dim -1; + p = (VarDeclaration *)parameters->data[lastNonref]; + /* The trouble with out and ref parameters is that taking + * the address of it doesn't work, because later processing + * adds in an extra level of indirection. So we skip over them. + */ + while (p->storage_class & (STCout | STCref)) + { + --lastNonref; + offset += PTRSIZE; + if (lastNonref < 0) + { + p = v_arguments; + break; + } + p = (VarDeclaration *)parameters->data[lastNonref]; + } + } + else + p = v_arguments; // last parameter is _arguments[] + if (p->storage_class & STClazy) + // If the last parameter is lazy, it's the size of a delegate + offset += PTRSIZE * 2; + else + offset += p->type->size(); + offset = (offset + PTRSIZE - 1) & ~(PTRSIZE - 1); // assume stack aligns on pointer size + Expression *e = new SymOffExp(0, p, offset); + e->type = Type::tvoidptr; + //e = e->semantic(sc); + e = new AssignExp(0, e1, e); + e->type = t; + a->push(new ExpStatement(0, e)); + p->isargptr = TRUE; + } #endif } @@ -1710,7 +1724,9 @@ void FuncDeclaration::semantic3(Scope *sc) if (isSynchronized()) { /* Wrap the entire function body in a synchronized statement */ - ClassDeclaration *cd = parent->isClassDeclaration(); + AggregateDeclaration *ad = isThis(); + ClassDeclaration *cd = ad ? ad->isClassDeclaration() : NULL; + if (cd) { #if TARGET_WINDOS @@ -3427,7 +3443,8 @@ int StaticCtorDeclaration::addPostInvariant() void StaticCtorDeclaration::toCBuffer(OutBuffer *buf, HdrGenState *hgs) { if (hgs->hdrgen) - { buf->writestring("static this();\n"); + { buf->writestring("static this();"); + buf->writenl(); return; } buf->writestring("static this()"); diff --git a/dmd2/imphint.c b/dmd2/imphint.c index 50db4b75..09b057d8 100644 --- a/dmd2/imphint.c +++ b/dmd2/imphint.c @@ -46,7 +46,7 @@ const char *importHint(const char *s) { "core.stdc.stdio", "std.stdio", "std.math", - "std.c.stdarg", + "core.vararg", }; static const char *names[] = { diff --git a/dmd2/interpret.c b/dmd2/interpret.c index e6f0be2a..34375018 100644 --- a/dmd2/interpret.c +++ b/dmd2/interpret.c @@ -3132,7 +3132,7 @@ Expression *AssertExp::interpret(InterState *istate) { // Special case: deal with compiler-inserted assert(&this, "null this") AddrExp *ade = (AddrExp *)this->e1; if (ade->e1->op == TOKthis && istate->localThis) - if (ade->e1->op == TOKdotvar + if (istate->localThis->op == TOKdotvar && ((DotVarExp *)(istate->localThis))->e1->op == TOKthis) return getVarExp(loc, istate, ((DotVarExp*)(istate->localThis))->var); else @@ -3141,7 +3141,13 @@ Expression *AssertExp::interpret(InterState *istate) if (this->e1->op == TOKthis) { if (istate->localThis) - return istate->localThis->interpret(istate); + { + if (istate->localThis->op == TOKdotvar + && ((DotVarExp *)(istate->localThis))->e1->op == TOKthis) + return getVarExp(loc, istate, ((DotVarExp*)(istate->localThis))->var); + else + return istate->localThis->interpret(istate); + } } e1 = this->e1->interpret(istate); if (e1 == EXP_CANT_INTERPRET) diff --git a/dmd2/mars.c b/dmd2/mars.c index cccbafd2..290c0374 100644 --- a/dmd2/mars.c +++ b/dmd2/mars.c @@ -1,6 +1,6 @@ // Compiler implementation of the D programming language -// Copyright (c) 1999-2010 by Digital Mars +// Copyright (c) 1999-2011 by Digital Mars // All Rights Reserved // written by Walter Bright // http://www.digitalmars.com @@ -94,13 +94,13 @@ Global::Global() #endif #endif - copyright = "Copyright (c) 1999-2010 by Digital Mars"; + copyright = "Copyright (c) 1999-2011 by Digital Mars"; written = "written by Walter Bright" #if TARGET_NET "\nMSIL back-end (alpha release) by Cristian L. Vlasceanu and associates."; #endif ; - version = "v2.051"; + version = "v2.052"; #if IN_LLVM ldc_version = "LDC trunk"; llvm_version = "LLVM 2.8"; diff --git a/dmd2/mtype.c b/dmd2/mtype.c index 04a60f10..7414abcb 100644 --- a/dmd2/mtype.c +++ b/dmd2/mtype.c @@ -52,6 +52,7 @@ #include "import.h" #include "aggregate.h" #include "hdrgen.h" +#include "doc.h" #if IN_LLVM //#include "gen/tollvm.h" @@ -1781,10 +1782,13 @@ Expression *Type::getProperty(Loc loc, Identifier *ident) s = toDsymbol(NULL); if (s) s = s->search_correct(ident); - if (s) - error(loc, "no property '%s' for type '%s', did you mean '%s'?", ident->toChars(), toChars(), s->toChars()); - else - error(loc, "no property '%s' for type '%s'", ident->toChars(), toChars()); + if (this != Type::terror) + { + if (s) + error(loc, "no property '%s' for type '%s', did you mean '%s'?", ident->toChars(), toChars(), s->toChars()); + else + error(loc, "no property '%s' for type '%s'", ident->toChars(), toChars()); + } e = new ErrorExp(); } return e; @@ -2551,12 +2555,21 @@ unsigned TypeBasic::alignsize() #if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS case Tint64: case Tuns64: + sz = global.params.isX86_64 ? 8 : 4; + break; + case Tfloat64: case Timaginary64: + sz = global.params.isX86_64 ? 8 : 4; + break; + case Tcomplex32: - case Tcomplex64: sz = 4; break; + + case Tcomplex64: + sz = global.params.isX86_64 ? 8 : 4; + break; #endif #if IN_DMD default: @@ -6183,6 +6196,7 @@ TypeTypeof::TypeTypeof(Loc loc, Expression *exp) : TypeQualified(Ttypeof, loc) { this->exp = exp; + inuse = 0; } Type *TypeTypeof::syntaxCopy() @@ -6225,6 +6239,13 @@ Type *TypeTypeof::semantic(Loc loc, Scope *sc) //printf("TypeTypeof::semantic() %s\n", toChars()); //static int nest; if (++nest == 50) *(char*)0=0; + if (inuse) + { + inuse = 2; + error(loc, "circular typeof definition"); + return Type::terror; + } + inuse++; #if 0 /* Special case for typeof(this) and typeof(super) since both @@ -6327,9 +6348,11 @@ Type *TypeTypeof::semantic(Loc loc, Scope *sc) goto Lerr; } } + inuse--; return t; Lerr: + inuse--; return terror; } @@ -7333,9 +7356,12 @@ static MATCH aliasthisConvTo(AggregateDeclaration *ad, Type *from, Type *to) Expression *ethis = from->defaultInit(0); fd = fd->overloadResolve(0, ethis, NULL); if (fd) + { t = ((TypeFunction *)fd->type)->next; + } } - return t->implicitConvTo(to); + MATCH m = t->implicitConvTo(to); + return m; } return MATCHnomatch; } @@ -8348,7 +8374,12 @@ void Parameter::argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Parameters *argu if (arg->defaultArg) { argbuf.writestring(" = "); + unsigned o = argbuf.offset; arg->defaultArg->toCBuffer(&argbuf, hgs); + if (hgs->ddoc) + { + escapeDdocString(&argbuf, o); + } } buf->write(&argbuf); } diff --git a/dmd2/mtype.h b/dmd2/mtype.h index 4de1769b..488d59af 100644 --- a/dmd2/mtype.h +++ b/dmd2/mtype.h @@ -730,6 +730,7 @@ struct TypeInstance : TypeQualified struct TypeTypeof : TypeQualified { Expression *exp; + int inuse; TypeTypeof(Loc loc, Expression *exp); Type *syntaxCopy(); diff --git a/dmd2/parse.c b/dmd2/parse.c index da1375c7..62a9a305 100644 --- a/dmd2/parse.c +++ b/dmd2/parse.c @@ -230,7 +230,7 @@ Dsymbols *Parser::parseDeclDefs(int once) case TOKtypeof: case TOKdot: Ldeclaration: - a = parseDeclarations(STCundefined); + a = parseDeclarations(STCundefined, NULL); decldefs->append(a); continue; @@ -431,7 +431,7 @@ Dsymbols *Parser::parseDeclDefs(int once) peek(tk)->value == TOKlcurly) ) { - a = parseDeclarations(storageClass); + a = parseDeclarations(storageClass, comment); decldefs->append(a); continue; } @@ -2651,7 +2651,7 @@ Type *Parser::parseDeclarator(Type *t, Identifier **pident, TemplateParameters * * Return array of Declaration *'s. */ -Dsymbols *Parser::parseDeclarations(StorageClass storage_class) +Dsymbols *Parser::parseDeclarations(StorageClass storage_class, unsigned char *comment) { StorageClass stc; Type *ts; @@ -2660,10 +2660,12 @@ Dsymbols *Parser::parseDeclarations(StorageClass storage_class) Identifier *ident; Dsymbols *a; enum TOK tok = TOKreserved; - unsigned char *comment = token.blockComment; enum LINK link = linkage; //printf("parseDeclarations() %s\n", token.toChars()); + if (!comment) + comment = token.blockComment; + if (storage_class) { ts = NULL; // infer type goto L2; @@ -3483,7 +3485,7 @@ Statement *Parser::parseStatement(int flags) Ldeclaration: { Array *a; - a = parseDeclarations(STCundefined); + a = parseDeclarations(STCundefined, NULL); if (a->dim > 1) { Statements *as = new Statements(); diff --git a/dmd2/parse.h b/dmd2/parse.h index 2dbf9773..bfcddd57 100644 --- a/dmd2/parse.h +++ b/dmd2/parse.h @@ -108,7 +108,7 @@ struct Parser : Lexer Type *parseBasicType(); Type *parseBasicType2(Type *t); Type *parseDeclarator(Type *t, Identifier **pident, TemplateParameters **tpl = NULL); - Dsymbols *parseDeclarations(StorageClass storage_class); + Dsymbols *parseDeclarations(StorageClass storage_class, unsigned char *comment); void parseContracts(FuncDeclaration *f); Statement *parseStatement(int flags); Initializer *parseInitializer(); diff --git a/dmd2/rmem.h b/dmd2/rmem.h new file mode 100644 index 00000000..5d84828d --- /dev/null +++ b/dmd2/rmem.h @@ -0,0 +1,16 @@ +#ifndef __RMEM_H__ +#define __RMEM_H__ + +// jam memory stuff here + +#include "mem.h" + +#if (defined (__SVR4) && defined (__sun)) +#include +#endif + +#ifdef __MINGW32__ +#include +#endif + +#endif // __RMEM_H__ diff --git a/dmd2/root/speller.c b/dmd2/root/speller.c index 5ea67db8..845f5756 100644 --- a/dmd2/root/speller.c +++ b/dmd2/root/speller.c @@ -4,6 +4,10 @@ #include #include +#if __sun&&__SVR4 +#include +#endif + #include "speller.h" const char idchars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"; diff --git a/dmd2/statement.c b/dmd2/statement.c index 7503446c..ed1dc110 100644 --- a/dmd2/statement.c +++ b/dmd2/statement.c @@ -42,7 +42,10 @@ int os_critsecsize() return sizeof(pthread_mutex_t); } #elif IN_DMD -extern int os_critsecsize(); + +extern int os_critsecsize32(); +extern int os_critsecsize64(); + #endif /******************************** Statement ***************************/ @@ -2402,12 +2405,6 @@ Statement *IfStatement::semantic(Scope *sc) { condition = condition->semantic(sc); condition = resolveProperties(sc, condition); - condition = condition->checkToBoolean(sc); - - // If we can short-circuit evaluate the if statement, don't do the - // semantic analysis of the skipped code. - // This feature allows a limited form of conditional compilation. - condition = condition->optimize(WANTflags); // Evaluate at runtime unsigned cs0 = sc->callSuper; @@ -2431,15 +2428,25 @@ Statement *IfStatement::semantic(Scope *sc) match->parent = sc->func; /* Generate: - * (arg = condition) + * ((arg = condition), arg) */ VarExp *v = new VarExp(0, match); condition = new AssignExp(loc, v, condition); + condition = new CommaExp(loc, condition, v); condition = condition->semantic(scd); } else scd = sc->push(); + // Convert to boolean after declaring arg so this works: + // if (S arg = S()) {} + // where S is a struct that defines opCast!bool. + condition = condition->checkToBoolean(sc); + + // If we can short-circuit evaluate the if statement, don't do the + // semantic analysis of the skipped code. + // This feature allows a limited form of conditional compilation. + condition = condition->optimize(WANTflags); ifbody = ifbody->semanticNoScope(scd); scd->pop(); @@ -4041,11 +4048,11 @@ Statement *SynchronizedStatement::semantic(Scope *sc) cs->push(new DeclarationStatement(loc, new DeclarationExp(loc, tmp))); #if IN_LLVM - // LDC: Build args - Parameters* args = new Parameters; - args->push(new Parameter(STCin, t->pointerTo(), NULL, NULL)); + // LDC: Build args + Parameters* args = new Parameters; + args->push(new Parameter(STCin, t->pointerTo(), NULL, NULL)); - FuncDeclaration *fdenter = FuncDeclaration::genCfunc(args, Type::tvoid, Id::criticalenter); + FuncDeclaration *fdenter = FuncDeclaration::genCfunc(args, Type::tvoid, Id::criticalenter); #else FuncDeclaration *fdenter = FuncDeclaration::genCfunc(Type::tvoid, Id::criticalenter); #endif @@ -4373,12 +4380,13 @@ void Catch::semantic(Scope *sc) sc = sc->push(sym); if (!type) - type = new TypeIdentifier(0, Id::Object); + type = new TypeIdentifier(0, Id::Throwable); type = type->semantic(loc, sc); - if (!type->toBasetype()->isClassHandle()) + ClassDeclaration *cd = type->toBasetype()->isClassHandle(); + if (!cd || ((cd != ClassDeclaration::throwable) && !ClassDeclaration::throwable->isBaseOf(cd, NULL))) { if (type != Type::terror) - { error(loc, "can only catch class objects, not '%s'", type->toChars()); + { error(loc, "can only catch class objects derived from Throwable, not '%s'", type->toChars()); type = Type::terror; } } @@ -4603,8 +4611,10 @@ Statement *ThrowStatement::semantic(Scope *sc) #endif exp = exp->semantic(sc); exp = resolveProperties(sc, exp); - if (!exp->type->toBasetype()->isClassHandle()) - error("can only throw class objects, not type %s", exp->type->toChars()); + ClassDeclaration *cd = exp->type->toBasetype()->isClassHandle(); + if (!cd || ((cd != ClassDeclaration::throwable) && !ClassDeclaration::throwable->isBaseOf(cd, NULL))) + error("can only throw class objects derived from Throwable, not type %s", exp->type->toChars()); + return this; } diff --git a/dmd2/template.c b/dmd2/template.c index f3faa909..d18ae75e 100644 --- a/dmd2/template.c +++ b/dmd2/template.c @@ -1,6 +1,6 @@ // Compiler implementation of the D programming language -// Copyright (c) 1999-2010 by Digital Mars +// Copyright (c) 1999-2011 by Digital Mars // All Rights Reserved // written by Walter Bright // http://www.digitalmars.com @@ -433,20 +433,28 @@ void TemplateDeclaration::semantic(Scope *sc) { // Generate this function as it may be used // when template is instantiated in other modules - - // FIXME: LDC - //sc->module->toModuleArray(); + // FIXME: LDC + //sc->module->toModuleArray(); } if (/*global.params.useAssert &&*/ sc->module) { // Generate this function as it may be used // when template is instantiated in other modules - - // FIXME: LDC - //sc->module->toModuleAssert(); + // FIXME: LDC + //sc->module->toModuleAssert(); } +#if DMDV2 + if (/*global.params.useUnitTests &&*/ sc->module) + { + // Generate this function as it may be used + // when template is instantiated in other modules + // FIXME: LDC + // sc->module->toModuleUnittest(); + } +#endif + /* Remember Scope for later instantiations, but make * a copy since attributes can change. */ @@ -1085,6 +1093,14 @@ L2: Type *tthis = ethis->type; unsigned mod = fd->type->mod; StorageClass stc = scope->stc; + // Propagate parent storage class (see bug 5504) + Dsymbol *p = parent; + while (p->isTemplateDeclaration() || p->isTemplateInstance()) + p = p->parent; + AggregateDeclaration *ad = p->isAggregateDeclaration(); + if (ad) + stc |= ad->storage_class; + if (stc & (STCshared | STCsynchronized)) mod |= MODshared; if (stc & STCimmutable) @@ -1327,23 +1343,23 @@ Lmatch: { if (arrayObjectMatch(p->dedargs, dedargs, this, sc)) { - //printf("recursive, no match %p %s\n", this, this->toChars()); - nmatches++; + //printf("recursive, no match p->sc=%p %p %s\n", p->sc, this, this->toChars()); + /* It must be a subscope of p->sc, other scope chains are not recursive + * instantiations. + */ + for (Scope *scx = sc; scx; scx = scx->enclosing) + { + if (scx == p->sc) + goto Lnomatch; + } } /* BUG: should also check for ref param differences */ } - /* Look for 2 matches at least, because sometimes semantic3() gets run causing what appears to - * be recursion but isn't. - * Template A's constraint instantiates B, B's semantic3() run includes something that has A in its constraint. - * Perhaps a better solution is to always defer semantic3() rather than doing it eagerly. The risk - * with that is what if semantic3() fails, but our constraint "succeeded"? - */ - if (nmatches >= 2) - goto Lnomatch; Previous pr; pr.prev = previous; + pr.sc = paramscope; pr.dedargs = dedargs; previous = ≺ // add this to threaded list @@ -2540,7 +2556,7 @@ void deduceBaseClassParameters(BaseClass *b, Scope *sc, Type *tparam, TemplateParameters *parameters, Objects *dedtypes, Objects *best, int &numBaseClassMatches) { - TemplateInstance *parti = b->base->parent->isTemplateInstance(); + TemplateInstance *parti = b->base ? b->base->parent->isTemplateInstance() : NULL; if (parti) { // Make a temporary copy of dedtypes so we don't destroy it @@ -3286,7 +3302,10 @@ void TemplateValueParameter::semantic(Scope *sc) valType = valType->semantic(loc, sc); if (!(valType->isintegral() || valType->isfloating() || valType->isString()) && valType->ty != Tident) - error(loc, "arithmetic/string type expected for value-parameter, not %s", valType->toChars()); + { + if (valType != Type::terror) + error(loc, "arithmetic/string type expected for value-parameter, not %s", valType->toChars()); + } if (specValue) { Expression *e = specValue; @@ -3736,7 +3755,7 @@ void TemplateInstance::semantic(Scope *sc) void TemplateInstance::semantic(Scope *sc, Expressions *fargs) { - //printf("TemplateInstance::semantic('%s', this=%p, gag = %d)\n", toChars(), this, global.gag); + //printf("TemplateInstance::semantic('%s', this=%p, gag = %d, sc = %p)\n", toChars(), this, global.gag, sc); if (global.errors && name != Id::AssociativeArray) { //printf("not instantiating %s due to %d errors\n", toChars(), global.errors); diff --git a/dmd2/template.h b/dmd2/template.h index 85068820..154592f7 100644 --- a/dmd2/template.h +++ b/dmd2/template.h @@ -70,6 +70,7 @@ struct TemplateDeclaration : ScopeDsymbol struct Previous { Previous *prev; + Scope *sc; Objects *dedargs; }; Previous *previous; // threaded list of previous instantiation attempts on stack diff --git a/dmd2/traits.c b/dmd2/traits.c index f1777368..004e770c 100644 --- a/dmd2/traits.c +++ b/dmd2/traits.c @@ -76,8 +76,11 @@ Expression *TraitsExp::semantic(Scope *sc) #if LOGSEMANTIC printf("TraitsExp::semantic() %s\n", toChars()); #endif - if (ident != Id::compiles && ident != Id::isSame) + if (ident != Id::compiles && ident != Id::isSame && + ident != Id::identifier) + { TemplateInstance::semanticTiargs(loc, sc, args, 1); + } size_t dim = args ? args->dim : 0; Object *o; Declaration *d; @@ -176,6 +179,11 @@ Expression *TraitsExp::semantic(Scope *sc) } else if (ident == Id::identifier) { // Get identifier for symbol as a string literal + + // Specify 0 for the flags argument to semanticTiargs() so that + // a symbol should not be folded to a constant. + TemplateInstance::semanticTiargs(loc, sc, args, 0); + if (dim != 1) goto Ldimerror; Object *o = (Object *)args->data[0]; diff --git a/dmd2/utf.c b/dmd2/utf.c index 53e234dc..78f8cd4a 100644 --- a/dmd2/utf.c +++ b/dmd2/utf.c @@ -11,6 +11,7 @@ // http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 #include +#include #include #include "utf.h" @@ -227,3 +228,93 @@ const char *utf_decodeWchar(unsigned short *s, size_t len, size_t *pidx, dchar_t return msg; } +void utf_encodeChar(unsigned char *s, dchar_t c) +{ + if (c <= 0x7F) + { + s[0] = (char) c; + } + else if (c <= 0x7FF) + { + s[0] = (char)(0xC0 | (c >> 6)); + s[1] = (char)(0x80 | (c & 0x3F)); + } + else if (c <= 0xFFFF) + { + s[0] = (char)(0xE0 | (c >> 12)); + s[1] = (char)(0x80 | ((c >> 6) & 0x3F)); + s[2] = (char)(0x80 | (c & 0x3F)); + } + else if (c <= 0x10FFFF) + { + s[0] = (char)(0xF0 | (c >> 18)); + s[1] = (char)(0x80 | ((c >> 12) & 0x3F)); + s[2] = (char)(0x80 | ((c >> 6) & 0x3F)); + s[3] = (char)(0x80 | (c & 0x3F)); + } + else + assert(0); +} + +void utf_encodeWchar(unsigned short *s, dchar_t c) +{ + if (c <= 0xFFFF) + { + s[0] = (wchar_t) c; + } + else + { + s[0] = (wchar_t) ((((c - 0x10000) >> 10) & 0x3FF) + 0xD800); + s[1] = (wchar_t) (((c - 0x10000) & 0x3FF) + 0xDC00); + } +} + + +/** + * Returns the code length of c in the encoding. + * The code is returned in character count, not in bytes. + */ + +int utf_codeLengthChar(dchar_t c) +{ + return + c <= 0x7F ? 1 + : c <= 0x7FF ? 2 + : c <= 0xFFFF ? 3 + : c <= 0x10FFFF ? 4 + : (assert(false), 6); +} + +int utf_codeLengthWchar(dchar_t c) +{ + return c <= 0xFFFF ? 1 : 2; +} + +/** + * Returns the code length of c in the encoding. + * sz is the encoding: 1 = utf8, 2 = utf16, 4 = utf32. + * The code is returned in character count, not in bytes. + */ +int utf_codeLength(int sz, dchar_t c) +{ + if (sz == 1) + return utf_codeLengthChar(c); + if (sz == 2) + return utf_codeLengthWchar(c); + assert(sz == 4); + return 1; +} + +void utf_encode(int sz, void *s, dchar_t c) +{ + if (sz == 1) + utf_encodeChar((unsigned char *)s, c); + else if (sz == 2) + utf_encodeWchar((unsigned short *)s, c); + else + { + assert(sz == 4); + memcpy((unsigned char *)s, &c, sz); + } +} + diff --git a/dmd2/utf.h b/dmd2/utf.h index 6be40447..22d8d3eb 100644 --- a/dmd2/utf.h +++ b/dmd2/utf.h @@ -1,6 +1,6 @@ // Compiler implementation of the D programming language // utf.h -// Copyright (c) 2003-2008 by Digital Mars +// Copyright (c) 2003-2010 by Digital Mars // All Rights Reserved // written by Walter Bright // http://www.digitalmars.com @@ -23,4 +23,13 @@ const char *utf_validateString(unsigned char *s, size_t len); extern int isUniAlpha(dchar_t); +void utf_encodeChar(unsigned char *s, dchar_t c); +void utf_encodeWchar(unsigned short *s, dchar_t c); + +int utf_codeLengthChar(dchar_t c); +int utf_codeLengthWchar(dchar_t c); + +int utf_codeLength(int sz, dchar_t c); +void utf_encode(int sz, void *s, dchar_t c); + #endif