The R Project SVN – R – Diff – /branches/R-exp-R5/src/main/plotmath.c

 /*
  *  R : A Computer Language for Statistical Data Analysis
  *  Copyright (C) 1995, 1996, 1997 Robert Gentleman and Ross Ihaka
+ *
  *  This source code module:
- *  Copyright (C) 1997 Paul Murrell and Ross Ihaka
+ *  Copyright (C) 1997, 1998 Paul Murrell and Ross Ihaka
+ *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  */
 #include "Mathlib.h"
 #include "Graphics.h"
 #include "Defn.h"
+#include "ctype.h"
-#ifdef max
-#undef max
+/* The R graphics device */
-#endif
-static DevDesc *mathDevice;
+static DevDesc *MathDevice;
+static unsigned int BoxColor;
+static unsigned int TextColor;
+static double BaseCex = 1;
+static int MetricUnit = INCHES;
+static double HalfPi  = 1.57079632679489661922;
+/* Font Definitions */
+typedef enum {
+    PlainFont      = 1,
+    BoldFont       = 2,
+    ItalicFont     = 3,
+    BoldItalicFont = 4,
+    SymbolFont     = 5,
+} FontType;
+/*
-/* Return maximum of two doubles. */
+ *  Italic Correction Factor
+ *
+ *  The correction for a character is computed as ItalicFactor
+ *  times the height (above the baseline) of the character's
+ *  bounding box.
+ *
+ */
+static double ItalicFactor = 0.15;
+/* Drawing basics */
+static double ReferenceX;
+static double ReferenceY;
+static double CurrentX;
+static double CurrentY;
-static double max(double x, double y)
+static double CurrentAngle;
+static double CosAngle;
+static double SinAngle;
+/* Convert CurrentX and CurrentY from */
+/* 0 angle to and CurrentAngle */
+static double ConvertedX()
+{
+    double rotatedX = ReferenceX +
+	(CurrentX - ReferenceX) * CosAngle -
+	(CurrentY - ReferenceY) * SinAngle;
+    return rotatedX;
+}
+static double ConvertedY()
+{
-    if (x > y) return x;
+    double rotatedY = ReferenceY +
+	(CurrentY - ReferenceY) * CosAngle +
+	(CurrentX - ReferenceX) * SinAngle;
-    else return y;
+    return rotatedY;
+}
-/* Determine a match between symbol name and string. */
+static void MoveAcross(double xamount)
+{
+    CurrentX += xamount;
+}
-static int symbolMatch(SEXP expr, char *aString)
+static void MoveUp(double yamount)
+{
-    return !strcmp(CHAR(PRINTNAME(expr)), aString);
+    CurrentY += yamount;
+}
-/* Code to determine the ascii code corresponding */
+static void MoveTo(double x, double y)
+{
+    CurrentX = x;
+    CurrentY = y;
+}
-/* to an element of a mathematical expression. */
+/* Basic Font Properties */
+static double FontHeight()
+{
+    double height, depth, width;
+    GMetricInfo(0, &height, &depth, &width, MetricUnit, MathDevice);
+    return height + depth;
+}
+static double xHeight()
+{
+    double height, depth, width;
+    GMetricInfo('x', &height, &depth, &width, MetricUnit, MathDevice);
+    return height;
+}
-static int hatAscii()
+static double XHeight()
+{
+    double height, depth, width;
+    GMetricInfo('X', &height, &depth, &width, MetricUnit, MathDevice);
-    return 94;
+    return height;
+}
-static int tildeAscii()
+static double AxisHeight()
+{
+    double height, depth, width;
+    GMetricInfo('+', &height, &depth, &width, MetricUnit, MathDevice);
+    return 0.5 * height;
+}
+static double Quad()
+{
+    double height, depth, width;
+    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
-    return 126;
+    return width;
+}
-static int accentAscii(SEXP expr)
+static double ThinSpace()
+{
+    double height, depth, width;
+    static double OneSixth = 0.16666666666666666666;
+    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
-    int result = 0;
+    return OneSixth * width;
+}
-    if (symbolMatch(expr, "hat"))
+static double MediumSpace()
+{
-	result = hatAscii();
+    double height, depth, width;
-    else if (symbolMatch(expr, "tilde"))
+    static double TwoNinths = 0.22222222222222222222;
-	result = tildeAscii();
+    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
-    return result;
+    return TwoNinths * width;
+}
-static int operatorAscii(SEXP expr)
+static double ThickSpace()
+{
-    int result = 0;
-    if (symbolMatch(expr, "sum"))
+    double height, depth, width;
-	result = 229;
-    else if (symbolMatch(expr, "integral"))
+    static double FiveEighteenths = 0.27777777777777777777;
-	result = 242;
-    else if (symbolMatch(expr, "product"))
+    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
-	result = 213;
-    return result;
+    return FiveEighteenths * width;
+}
-static int integralAscii(int section)
+static double MuSpace()
+{
+    double height, depth, width;
+    static double OneEighteenth = 0.05555555555555555555;
+    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
+    return OneEighteenth * width;
+}
+/*
+ *  Mathematics Layout Parameters
+ *
+ *  The TeXBook, Appendex G, Page 447.
+ *
+ *  Note : these values are ``optimised'' for PostScript.
+ *  They can look ugly under X11.
+ *
+ */
+typedef enum {
+    sigma2, sigma5, sigma6, sigma8, sigma9, sigma10, sigma11, sigma12,
+    sigma13, sigma14, sigma15, sigma16, sigma17, sigma18, sigma19,
+    sigma20, sigma21, sigma22, xi8, xi9, xi10, xi11, xi12, xi13
+}
+TEXPAR;
+#define LINEWIDTH 0.015
+static double TeX(TEXPAR which)
+{
+    double value;
-    if (section == 1)
+    switch(which) {
+    case sigma2:  /* space */
+    case sigma5:  /* x_height */
+	return xHeight();
+    case sigma6:  /* quad */
-	return 243;
+	return Quad();
+    case sigma8:  /* num1 */
+    case sigma9:  /* num2 */
-    else if (section == 2)
+    case sigma10: /* num3 */
+	return (0.45 * XHeight() + AxisHeight());
+    case sigma11: /* denom1 */
+    case sigma12: /* denom2 */
+	return (1.45 * XHeight() - AxisHeight());
+    case sigma13: /* sup1 */
+    case sigma14: /* sup2 */
+    case sigma15: /* sup3 */
+	return xHeight();
+    case sigma16: /* sub1 */
+    case sigma17: /* sub2 */
+	return 0.5 * xHeight();
+    case sigma18: /* sup_drop */
+	return 0.1 * xHeight();
+    case sigma19: /* sub_drop */
+	return 0.1 * xHeight();
+    case sigma20: /* delim1 */
+    case sigma21: /* delim2 */
+    case sigma22: /* axis_height */
+	return AxisHeight();
+    case xi8:     /* default_rule_thickness */
-	return 244;
+	return LINEWIDTH;
+	break;
+    case xi9:     /* big_op_spacing1 */
+    case xi10:    /* big_op_spacing2 */
+    case xi11:    /* big_op_spacing3 */
+    case xi12:    /* big_op_spacing4 */
+    case xi13:    /* big_op_spacing5 */
+	return 0.15 * XHeight();
+    }
+}
+/*
+ *  TeX Math Styles
+ *
+ *  The TeXBook, Appendix G, Page 441.
+ *
+ */
+typedef enum {
+    STYLE_SS1 = 1,
+    STYLE_SS  = 2,
+    STYLE_S1  = 3,
+    STYLE_S   = 4,
+    STYLE_T1  = 5,
+    STYLE_T   = 6,
+    STYLE_D1  = 7,
+    STYLE_D   = 8
+} STYLE;
+static STYLE CurrentStyle;
+static STYLE GetStyle()
+{
+    return CurrentStyle;
+}
+static void SetStyle(STYLE newstyle)
+{
+    switch (newstyle) {
+    case STYLE_D:
+    case STYLE_T:
+    case STYLE_D1:
+    case STYLE_T1:
+	MathDevice->gp.cex = 1.0 * BaseCex;
+	break;
+    case STYLE_S:
+    case STYLE_S1:
+	MathDevice->gp.cex = 0.7 * BaseCex;
+	break;
+    case STYLE_SS:
+    case STYLE_SS1:
+	MathDevice->gp.cex = 0.5 * BaseCex;
+	break;
+    default:
+	error("invalid math style encountered\n");
+    }
+    CurrentStyle = newstyle;
+}
+static void SetPrimeStyle(STYLE style)
+{
+    switch (style) {
+    case STYLE_D:
+    case STYLE_D1:
+	SetStyle(STYLE_D1);
+	break;
+    case STYLE_T:
+    case STYLE_T1:
+	SetStyle(STYLE_T1);
+	break;
+    case STYLE_S:
+    case STYLE_S1:
+	SetStyle(STYLE_S1);
+	break;
+    case STYLE_SS:
+    case STYLE_SS1:
+	SetStyle(STYLE_SS1);
+	break;
+    }
+}
+static void SetSupStyle(STYLE style)
+{
+    switch (style) {
+    case STYLE_D:
+    case STYLE_T:
+	SetStyle(STYLE_S);
+	break;
+    case STYLE_D1:
+    case STYLE_T1:
+	SetStyle(STYLE_S1);
+	break;
+    case STYLE_S:
+    case STYLE_SS:
+	SetStyle(STYLE_SS);
+	break;
+    case STYLE_S1:
+    case STYLE_SS1:
+	SetStyle(STYLE_SS1);
+	break;
+    }
+}
+static void SetSubStyle(STYLE style)
+{
+    switch (style) {
+    case STYLE_D:
+    case STYLE_T:
+    case STYLE_D1:
+    case STYLE_T1:
+	SetStyle(STYLE_S1);
+	break;
+    case STYLE_S:
+    case STYLE_SS:
+    case STYLE_S1:
+    case STYLE_SS1:
+	SetStyle(STYLE_SS1);
+	break;
+    }
+}
+static void SetNumStyle(STYLE style)
+{
+    switch (style) {
+    case STYLE_D:
+	SetStyle(STYLE_T);
+	break;
+    case STYLE_D1:
+	SetStyle(STYLE_T1);
+	break;
+    default:
+	SetSupStyle(style);
+    }
+}
+static void SetDenomStyle(STYLE style)
+{
+    if (style > STYLE_T)
+	SetStyle(STYLE_T1);
     else
+	SetSubStyle(style);
+}
+static int IsCompactStyle(STYLE style)
+{
+    switch (style) {
+    case STYLE_D1:
+    case STYLE_T1:
+    case STYLE_S1:
+    case STYLE_SS1:
+	return 1;
+    default:
-	return 245;
+	return 0;
+    }
+}
+#ifdef max
+#undef max
+#endif
+/* Return maximum of two doubles. */
+static double max(double x, double y)
+{
+    if (x > y) return x;
+    else return y;
+}
+/* Bounding Boxes */
+/* These including italic corrections and an */
+/* indication of whether the nucleus was simple. */
+typedef struct {
+    double height;
+    double depth;
+    double width;
+    double italic;
+    int simple;
+} BBOX;
+#define bboxHeight(bbox) bbox.height
+#define bboxDepth(bbox) bbox.depth
+#define bboxWidth(bbox) bbox.width
+#define bboxItalic(bbox) bbox.italic
+#define bboxSimple(bbox) bbox.simple
+static BBOX MakeBBox(double height, double depth, double width)
+{
+    BBOX bbox;
+    bboxHeight(bbox) = height;
+    bboxDepth(bbox)  = depth;
+    bboxWidth(bbox)  = width;
+    bboxItalic(bbox) = 0;
+    bboxSimple(bbox) = 0;
+    return bbox;
+}
+static BBOX NullBBox()
+{
+    BBOX bbox;
+    bboxHeight(bbox) = 0;
+    bboxDepth(bbox)  = 0;
+    bboxWidth(bbox)  = 0;
+    bboxItalic(bbox) = 0;
+    bboxSimple(bbox) = 0;
+    return bbox;
+}
+static BBOX ShiftBBox(BBOX bbox1, double shiftV)
+{
+    bboxHeight(bbox1) = bboxHeight(bbox1) + shiftV;
+    bboxDepth(bbox1)  = bboxDepth(bbox1) - shiftV;
+    bboxWidth(bbox1)  = bboxWidth(bbox1);
+    bboxItalic(bbox1) = bboxItalic(bbox1);
+    bboxSimple(bbox1) = bboxSimple(bbox1);
+    return bbox1;
+}
+static BBOX EnlargeBBox(BBOX bbox, double deltaHeight, double deltaDepth,
+		      double deltaWidth)
+{
+    bboxHeight(bbox) += deltaHeight;
+    bboxDepth(bbox)  += deltaDepth;
+    bboxWidth(bbox)  += deltaWidth;
+    return bbox;
+}
-static int groupOpenAscii()
+static BBOX CombineBBoxes(BBOX bbox1, BBOX bbox2)
+{
+    bboxHeight(bbox1) = max(bboxHeight(bbox1), bboxHeight(bbox2));
+    bboxDepth(bbox1)  = max(bboxDepth(bbox1), bboxDepth(bbox2));
+    bboxWidth(bbox1)  = bboxWidth(bbox1) + bboxWidth(bbox2);
+    bboxItalic(bbox1) = bboxItalic(bbox2);
+    bboxSimple(bbox1) = bboxSimple(bbox2);
-    return 40;
+    return bbox1;
+}
-static int groupCloseAscii()
+static BBOX CombineAlignedBBoxes(BBOX bbox1, BBOX bbox2)
+{
+    bboxHeight(bbox1) = max(bboxHeight(bbox1), bboxHeight(bbox2));
+    bboxDepth(bbox1)  = max(bboxDepth(bbox1), bboxDepth(bbox2));
+    bboxWidth(bbox1)  = max(bboxWidth(bbox1), bboxWidth(bbox2));
+    bboxItalic(bbox1) = 0;
+    bboxSimple(bbox1) = 0;
-    return 41;
+    return bbox1;
+}
+static BBOX CombineOffsetBBoxes(BBOX bbox1, int italic1,
+				BBOX bbox2, int italic2,
+				double xoffset,
-static int commaAscii()
+				double yoffset)
+{
+    double width1 = bboxWidth(bbox1) + (italic1 ? bboxItalic(bbox1) : 0);
+    double width2 = bboxWidth(bbox2) + (italic2 ? bboxItalic(bbox2) : 0);
+    bboxWidth(bbox1) = max(width1, width2 + xoffset);
+    bboxHeight(bbox1) = max(bboxHeight(bbox1), bboxHeight(bbox2) + yoffset);
+    bboxDepth(bbox1) = max(bboxDepth(bbox1), bboxDepth(bbox2) - yoffset);
+    bboxItalic(bbox1) = 0;
+    bboxSimple(bbox1) = 0;
-    return 44;
+    return bbox1;
+}
-static int spaceAscii()
+static double CenterShift(BBOX bbox)
+{
+    return 0.5 * (bboxHeight(bbox) - bboxDepth(bbox));
+}
+static BBOX DrawBBox(BBOX bbox, double xoffset, double yoffset)
+{
+    double xsaved = CurrentX;
+    double ysaved = CurrentY;
+    double x[5], y[5];
+    CurrentX += xoffset;
+    CurrentY += yoffset;
+    MathDevice->gp.col = BoxColor;
+    MoveUp(-bboxDepth(bbox));
+    x[4] = x[0] = ConvertedX();
+    y[4] = y[0] = ConvertedY();
+    MoveAcross(bboxWidth(bbox));
+    x[1] = ConvertedX();
+    y[1] = ConvertedY();
+    MoveUp(bboxHeight(bbox) + bboxDepth(bbox));
+    x[2] = ConvertedX();
+    y[2] = ConvertedY();
+    MoveAcross(-bboxWidth(bbox));
+    x[3] = ConvertedX();
+    y[3] = ConvertedY();
+    GPolyline(5, x, y, INCHES, MathDevice);
+    MoveTo(xsaved, ysaved);
+    MathDevice->gp.col = TextColor;
-    return 32;
+    return bbox;
+}
+typedef struct {
+    char *name;
+    int code;
+} SymTab;
+/* Determine a match between symbol name and string. */
-static int radicalAscii()
+static int NameMatch(SEXP expr, char *aString)
+{
-    return 214;
+    return !strcmp(CHAR(PRINTNAME(expr)), aString);
+}
-static int radicalExAscii()
+static int StringMatch(SEXP expr, char *aString)
+{
-    return 96;
+    return !strcmp(CHAR(STRING(expr)[0]), aString);
+}
+/* Code to determine the ascii code corresponding */
+/* to an element of a mathematical expression. */
+#define A_HAT             94
+#define A_TILDE          126
+#define S_SPACE           32
+#define S_PARENLEFT       40
+#define S_PARENRIGHT      41
+#define S_ASTERISKMATH    42
+#define S_COMMA           44
+#define S_SLASH           47
+#define S_RADICALEX       96
+#define S_FRACTION       164
+#define S_ELLIPSIS       188
+#define S_INTERSECTION   199
+#define S_UNION          200
+#define S_PRODUCT        213
+#define S_RADICAL        214
+#define S_SUM            229
+#define S_INTEGRAL       242
+#define S_BRACKETLEFTTP  233
+#define S_BRACKETLEFTBT  235
+#define S_BRACKETRIGHTTP 249
+#define S_BRACKETRIGHTBT 251
+#define N_LIM           1001
+#define N_LIMINF        1002
+#define N_LIMSUP        1003
+#define N_INF           1004
+#define N_SUP           1005
+#define N_MIN           1006
+#define N_MAX           1007
+/* The Full Adobe Symbol Font */
 static struct {
     char *name;
     int code;
+}
 SymbolTable[] = {
+    "space",          32,
+    "exclam",         33,
+    "universal",      34,
+    "numbersign",     35,
+    "existential",    36,
+    "percent",        37,
+    "ampersand",      38,
+    "suchthat",       39,
+    "parenleft",      40,
+    "parenright",     41,
+    "asteriskmath",   42,
+    "plus",           43,
+    "comma",          44,
+    "minus",          45,
+    "period",         46,
+    "slash",          47,
+    "0",              48,
+    "1",              49,
+    "2",              50,
+    "3",              51,
+    "4",              52,
+    "5",              53,
+    "6",              54,
+    "7",              55,
+    "8",              56,
+    "9",              57,
+    "colon",          58,
+    "semicolon",      59,
+    "less",           60,
+    "equal",          61,
+    "greater",        62,
+    "question",       63,
+    "congruent",      64,
     "Alpha",          65,    /* Upper Case Greek Characters */
     "Beta",           66,
     "Chi",            67,
     "Delta",          68,
     "Epsilon",        69,
     "Phi",            70,
     "Gamma",          71,
     "Eta",            72,
     "Iota",           73,
-    "Phi1",           74,
+    "theta1",         74,
     "Kappa",          75,
     "Lambda",         76,
     "Mu",             77,
     "Nu",             78,
     "Omicron",        79,
     "Omega",          87,
     "Xi",             88,
     "Psi",            89,
     "Zeta",           90,
+    "bracketleft",    91,    /* Miscellaneous Special Characters */
+    "therefore",      92,
+    "bracketright",   93,
+    "perpendicular",  94,
+    "underscore",     95,
+    "radicalex",      96,
     "alpha",          97,    /* Lower Case Greek Characters */
     "beta",           98,
     "chi",            99,
     "delta",         100,
     "epsilon",       101,
     "omega",         119,
     "xi",            120,
     "psi",           121,
     "zeta",          122,
-    "universal",      34,    /* Miscellaneous Special Characters */
+    "braceleft",     123,    /* Miscellaneous Special Characters */
-    "existential",    36,
+    "bar",           124,
-    "therefore",      92,
+    "braceright",    125,
-    "perpendicular",  94,
+    "similar",       126,
+    "Upsilon1",      161,    /* Lone Greek */
     "minute",        162,
+    "lessequal",     163,
+    "fraction",      164,
     "infinity",      165,
+    "florin",        166,
     "club",          167,
     "diamond",       168,
     "heart",         169,
     "spade",         170,
+    "arrowboth",     171,
+    "arrowleft",     172,
+    "arrowup",       173,
+    "arrowright",    174,
+    "arrowdown",     175,
     "degree",        176,
+    "plusminus",     177,
     "second",        178,
+    "greaterequal",  179,
+    "multiply",      180,
+    "proportional",  181,
     "partialdiff",   182,
     "bullet",        183,
+    "divide",        184,
+    "notequal",      185,
+    "equivalence",   186,
+    "approxequal",   187,
     "ellipsis",      188,
+    "arrowvertex",   189,
+    "arrowhorizex",  190,
+    "carriagereturn",191,
     "aleph",         192,
     "Ifraktur",      193,
     "Rfraktur",      194,
     "weierstrass",   195,
+    "circlemultiply",196,
+    "circleplus",    197,
     "emptyset",      198,
+    "intersection",  199,
+    "union",         200,
+    "propersuperset",201,
+    "reflexsuperset",202,
+    "notsubset",     203,
+    "propersubset",  204,
+    "reflexsubset",  205,
+    "element",       206,
+    "notelement",    207,
     "angle",         208,
     "gradient",      209,
+    "registerserif", 210,
+    "copyrightserif",211,
+    "trademarkserif",212,
+    "product",       213,
+    "radical",       214,
+    "dotmath",       215,
+    "logicaland",    217,
+    "logicalor",     218,
+    "arrowdblboth",  219,
+    "arrowdblleft",  220,
+    "arrowdblup",    221,
+    "arrowdblright", 222,
+    "arrowdbldown",  223,
+    "lozenge",       224,
+    "angleleft",     225,
+    "registersans",  226,
+    "copyrightsans", 227,
+    "trademarksans", 228,
+    "summation",     229,
+    "parenlefttp",   230,
+    "parenleftex",   231,
+    "parenleftbt",   232,
+    "bracketlefttp", 233,
+    "bracketleftex", 234,
+    "bracketleftbt", 235,
+    "bracelefttp",   236,
+    "braceleftmid",  237,
+    "braceleftbt",   238,
+    "braceex",       239,
+    "angleright",    241,
+    "integral",      242,
+    "integraltp",    243,
+    "integralex",    244,
+    "integralbt",    245,
+    "parenrighttp",  246,
+    "parenrightex",  247,
+    "parenrightbt",  248,
+    "bracketrighttp",249,
+    "bracketrightex",250,
+    "bracketrightbt",251,
+    "bracerighttp",  252,
+    "bracerightmid", 253,
+    "bracerightbt",  254,
     NULL,              0,
 };
-static int symbolAscii(SEXP expr)
+static int SymbolCode(SEXP expr)
+{
     int i;
     for (i = 0; SymbolTable[i].code; i++)
-	if (symbolMatch(expr, SymbolTable[i].name))
+	if (NameMatch(expr, SymbolTable[i].name))
 	    return SymbolTable[i].code;
     return 0;
+}
-static struct {
-    char *name;
-    int code;
-}
-RelationTable[] = {
-    "<",                 60,    /* Binary Relationships */
-    "==",                61,
-    ">",                 62,
-    "%=~%",              64,
-    "!=",               185,
-    "<=",               163,
-    "%+-%",             177,
-    ">=",               179,
-    "%*%",              180,
-    "%/%",              184,
-    "%==%",             186,
-    "%~~%",             187,
-    "&",                217,
-    "&&",               217,
-    "|",                218,
-    "||",               218,
-    "%<->%",            171,    /* Arrows */
-    "%<-%",             172,
-    "%arrowup%",        173,
-    "%->%",             174,
-    "%arrowdown%",      175,
-    "%<=>%",            219,
-    "%<=%",             220,
-    "%arrowdblup%",     221,
-    "%=>%",             222,
-    "%arrowdbldown%",   223,
-    "%congruent%",       64,    /* Long (PostScript) Names */
-    "%plusminus%",      177,
-    "%multiply%",       180,
-    "%proportional%",   181,
-    "%divide%",         184,
-    "%equivalence%",    186,
-    "%approxequal%",    187,
-    "%intersection%",   199,
-    "%union%",          200,
-    "%propersuperset%", 201,
-    "%reflexsuperset%", 202,
-    "%notsubset%",      203,
-    "%propersubset%",   204,
-    "%reflexsubset%",   205,
-    "%element%",        206,
-    "%notelement%",     207,
-    "logicaland%",      217,
-    "logicalor%",       218,
-    NULL,                0,
-};
-/* Added argument - ihaka */
-static int relAscii(SEXP expr)
+static int TranslatedSymbol(SEXP expr)
+{
-    int i;
+    int code = SymbolCode(expr);
-    for (i = 0; RelationTable[i].code; i++)
+    if ((65 <= code && code <= 90)  ||   /* Greek */
+	(97 <= code && code <= 122) ||
+	code == 161                 ||
-	if (symbolMatch(expr, RelationTable[i].name))
+	code == 162                 ||   /* minute */
+	code == 165                 ||   /* infinity */
+	code == 176                 ||   /* degree */
+	code == 178                 ||   /* second */
+)
-	    return RelationTable[i].code;
+	return code;
+    else
-    return 0;
+	return 0;
+}
-/* Initialisation code for mathematical notation. */
-static double ratioScale = 0.8;
-static double scriptScale = 0.65;
-static int ratioDepth = 0;
-static int metricUnit = INCHES;
 /* Code to determine the nature of an expression. */
-static int formulaExpression(SEXP expr)
+static int FormulaExpression(SEXP expr)
+{
     return (TYPEOF(expr) == LANGSXP);
+}
-static int symbolAtom(SEXP expr)
+static int NameAtom(SEXP expr)
+{
     return (TYPEOF(expr) == SYMSXP);
+}
-static int numberAtom(SEXP expr)
+static int NumberAtom(SEXP expr)
+{
     return ((TYPEOF(expr) == REALSXP) ||
 	    (TYPEOF(expr) == INTSXP)  ||
 	    (TYPEOF(expr) == CPLXSXP));
+}
-static int stringAtom(SEXP expr)
+static int StringAtom(SEXP expr)
+{
     return (TYPEOF(expr) == STRSXP);
+}
-static int spaceAtom(SEXP expr)
+static int symbolAtom(SEXP expr)
-{
-    return symbolAtom(expr) && symbolMatch(expr, "~");
-}
-static struct {
-    char *name;
-    int code;
-}
-BinopTable[] = {
-    "*",                42,    /* Binary Relationships */
-    "+",                43,
-    "-",                45,
-    "/",                47,
-    ":",                58,
-    NULL,                0
-};
-static int binAtom(SEXP expr)
-{
-    int i;
-    for (i = 0; BinopTable[i].code; i++)
-	if (symbolMatch(expr, BinopTable[i].name))
-	    return BinopTable[i].code;
-    return 0;
-}
-static int relAtom(SEXP expr)
+{
     int i;
+    if (NameAtom(expr)) {
-    for (i = 0; RelationTable[i].code; i++)
+	for (i = 0; SymbolTable[i].code; i++)
-	if (symbolMatch(expr, RelationTable[i].name))
+	    if (NameMatch(expr, SymbolTable[i].name))
-	    return 1;
+		return 1;
+    }
     return 0;
+}
-static int multiplicationOperator(SEXP expr)
+/* Code to determine a font from the */
-{
-    return binAtom(expr) == 42;
+/* nature of the expression */
-}
-static int superAtom(SEXP expr)
+static FontType CurrentFont = 3;
-{
-    return symbolAtom(expr) && symbolMatch(expr, "^");
-}
-static int subAtom(SEXP expr)
+static FontType GetFont()
+{
-    return symbolAtom(expr) && symbolMatch(expr, "[");
+    return MathDevice->gp.font;
+}
-static int hatAtom(SEXP expr)
+static FontType SetFont(FontType font)
+{
+    FontType prevfont = MathDevice->gp.font;
+    MathDevice->gp.font = font;
-    return symbolMatch(expr, "hat");
+    return prevfont;
+}
-static int barAtom(SEXP expr)
+static int UsingItalics()
+{
-    return symbolMatch(expr, "bar");
+    return (MathDevice->gp.font == ItalicFont ||
+	    MathDevice->gp.font == BoldItalicFont);
+}
-static int accentAtom(SEXP expr)
+static BBOX GlyphBBox(int chr)
+{
+    BBOX bbox;
-    return symbolAtom(expr) &&
+    double height, depth, width;
-	(hatAtom(expr) || barAtom(expr) || symbolMatch(expr, "tilde"));
+    GMetricInfo(chr, &height, &depth, &width, MetricUnit, MathDevice);
+    bboxHeight(bbox) = height;
+    bboxDepth(bbox)  = depth;
+    bboxWidth(bbox)  = width;
+    bboxItalic(bbox) = 0;
+    bboxSimple(bbox) = 1;
+    return bbox;
+}
-static int fractionAtom(SEXP expr)
+static BBOX RenderElement(SEXP, int);
-{
+static BBOX RenderOffsetElement(SEXP, double, double, int);
-    return symbolAtom(expr) &&
+static BBOX RenderExpression(SEXP, int);
-	(symbolMatch(expr, "over") || symbolMatch(expr, "frac"));
+static BBOX RenderSymbolChar(int, int);
-}
-static int groupAtom(SEXP expr)
-{
-    return symbolAtom(expr) && symbolMatch(expr, "(");
-}
-static int operatorAtom(SEXP expr)
-{
-    return symbolAtom(expr) &&
+/*  Code to Generate Bounding Boxes and Draw Formulae.  */
-	(symbolMatch(expr, "sum") ||
-	 symbolMatch(expr, "integral") ||
-	 symbolMatch(expr, "product"));
-}
-static int integralOperator(SEXP expr)
+static BBOX RenderItalicCorr(BBOX bbox, int draw)
+{
+    if (bboxItalic(bbox) > 0) {
+	if (draw)
-    return symbolAtom(expr) && symbolMatch(expr, "integral");
+	    MoveAcross(bboxItalic(bbox));
+	bboxWidth(bbox) += bboxItalic(bbox);
+	bboxItalic(bbox) = 0;
+    }
+    return bbox;
+}
-static int radicalAtom(SEXP expr)
+static BBOX RenderGap(double gap, int draw)
+{
+    if (draw)
-    return symbolAtom(expr) &&
+	MoveAcross(gap);
-	(symbolMatch(expr, "root") || symbolMatch(expr, "sqrt"));
+    return MakeBBox(0, 0, gap);
+}
-static int absAtom(SEXP expr)
-{
-    return symbolAtom(expr) && symbolMatch(expr, "abs");
+/* Draw a Symbol from the Special Font */
-}
-static int curlyAtom(SEXP expr)
+static BBOX RenderSymbolChar(int ascii, int draw)
+{
+    FontType prev;
+    BBOX bbox;
+    char asciiStr[2];
+    if (ascii == A_HAT || ascii == A_TILDE)
+	prev = SetFont(PlainFont);
+    else
+	prev = SetFont(SymbolFont);
+    bbox = GlyphBBox(ascii);
+    if (draw) {
+	asciiStr[0] = ascii;
+	asciiStr[1] = '\0';
+	GText(ConvertedX(), ConvertedY(), INCHES, asciiStr,
-    return symbolAtom(expr) && symbolMatch(expr, "{");
+.0, 0.0, CurrentAngle, MathDevice);
+	MoveAcross(bboxWidth(bbox));
+    }
+    SetFont(prev);
+    return bbox;
+}
+/* Draw a Symbol String in "Math Mode */
+/* This code inserts italic corrections after */
+/* every character. */
-static int boldAtom(SEXP expr)
+static BBOX RenderSymbolStr(char *str, int draw)
 {
+    char chr[2];
+    BBOX glyphBBox;
+    BBOX resultBBox = NullBBox();
+    double lastItalicCorr = 0;
+    FontType prevfont = GetFont();
+    FontType font = prevfont;
+    chr[1] = '\0';
+    if (str) {
+	char *s = str;
+	while (*s) {
+	    if (isdigit(*s) && font != PlainFont) {
+		font = PlainFont;
+		SetFont(PlainFont);
+	    }
+	    else if (font != prevfont) {
+		font = prevfont;
+		SetFont(prevfont);
+	    }
+	    glyphBBox = GlyphBBox(*s);
+	    if (UsingItalics())
+		bboxItalic(glyphBBox) = ItalicFactor * bboxHeight(glyphBBox);
+	    else
+		bboxItalic(glyphBBox) = 0;
+	    if (draw) {
+		chr[0] = *s;
+		MoveAcross(lastItalicCorr);
+		GText(ConvertedX(), ConvertedY(), INCHES, chr,
+.0, 0.0, CurrentAngle, MathDevice);
+		MoveAcross(bboxWidth(glyphBBox));
+	    }
+	    bboxWidth(resultBBox) += lastItalicCorr;
-    return symbolAtom(expr) && symbolMatch(expr, "bold");
+	    resultBBox = CombineBBoxes(resultBBox, glyphBBox);
+	    lastItalicCorr = bboxItalic(glyphBBox);
+	    s++;
+	}
+	if (font != prevfont)
+	    SetFont(prevfont);
+    }
+    bboxSimple(resultBBox) = 1;
+    return resultBBox;
+}
-static int italicAtom(SEXP expr)
+/* Code for Character String Atoms. */
-{
-    return symbolAtom(expr) && symbolMatch(expr, "italic");
-}
-static int plainAtom(SEXP expr)
+static BBOX RenderChar(int ascii, int draw)
+{
+    BBOX bbox;
+    char asciiStr[2];
+    bbox = GlyphBBox(ascii);
+    if (draw) {
+	asciiStr[0] = ascii;
+	asciiStr[1] = '\0';
+	GText(ConvertedX(), ConvertedY(), INCHES, asciiStr,
-    return symbolAtom(expr) && symbolMatch(expr, "plain");
+.0, 0.0, CurrentAngle, MathDevice);
+	MoveAcross(bboxWidth(bbox));
+    }
+    return bbox;
+}
-static int boldItalicAtom(SEXP expr)
+static BBOX RenderStr(char *str, int draw)
+{
+    BBOX glyphBBox;
+    BBOX resultBBox = NullBBox();
+    if (str) {
+	char *s = str;
+	while (*s) {
+	    glyphBBox = GlyphBBox(*s);
-    return symbolAtom(expr) && symbolMatch(expr, "bolditalic");
+	    resultBBox = CombineBBoxes(resultBBox, glyphBBox);
+	    s++;
+	}
+	if (draw) {
+	    GText(ConvertedX(), ConvertedY(), INCHES, str,
+.0, 0.0, CurrentAngle, MathDevice);
+	    MoveAcross(bboxWidth(resultBBox));
+	}
+	if (UsingItalics())
+	    bboxItalic(resultBBox) = ItalicFactor * bboxHeight(glyphBBox);
+	else
+	    bboxItalic(resultBBox) = 0;
+    }
+    bboxSimple(resultBBox) = 1;
+    return resultBBox;
+}
-static int italicExpression(SEXP expr)
-{
-    return formulaExpression(expr) &&
-	(italicAtom(CAR(expr)) || boldItalicAtom(CAR(expr)));
-}
-static int nonItalicExpression(SEXP expr)
-{
-    return formulaExpression(expr) &&
+/* Code for Symbol Font Atoms */
-	(boldAtom(CAR(expr)) || plainAtom(CAR(expr)));
-}
-static int concatenateAtom(SEXP expr)
+static BBOX RenderSymbol(SEXP expr, int draw)
+{
+    int code;
+    if (code = TranslatedSymbol(expr))
+	return RenderSymbolChar(code, draw);
+    else
-    return symbolAtom(expr) && symbolMatch(expr, "paste");
+	return RenderSymbolStr(CHAR(PRINTNAME(expr)), draw);
+}
-static int symbolSymbol(SEXP expr)
+static BBOX RenderSymbolString(SEXP expr, int draw)
+{
-    int i;
+    int code;
-    if (symbolAtom(expr)) {
+    if (code = TranslatedSymbol(expr))
-	for (i = 0; SymbolTable[i].code; i++)
+	return RenderSymbolChar(code, draw);
-	    if (symbolMatch(expr, SymbolTable[i].name))
-		return 1;
-    }
+    else
-    return 0;
+	return RenderStr(CHAR(PRINTNAME(expr)), draw);
+}
-/* Code to determine a font from the */
-/* nature of the expression */
-static int currentFont = 3;
-static int getFont() { return currentFont; }
-static void setFont(font) { currentFont = font; }
-static void boldFont() { setFont(2); }
-static void italicFont() { setFont(3); }
-static void plainFont() { setFont(1); }
-static void boldItalicFont() { setFont(4); }
-static int isItalic() { return (getFont() == 3 || getFont() == 4); }
-/* Determine the appropriate font for an atom. */
-/* Switch to symbol for greek and math and */
-/* switch to plain for numbers. */
-/* FIXME : Should this switch to font=3 if the */
-/* current font is 4 (bolditalic). */
+/* Code for Numeric Atoms */
-static int atomFontFace(SEXP expr)
+static BBOX RenderNumber(SEXP expr, int draw)
+{
-    int fontFace = getFont();
+    BBOX bbox;
-    if (symbolAtom(expr) && (symbolSymbol(expr) ||
+    FontType prevfont = SetFont(PlainFont);
-			     binAtom(expr) ||
-			     relAtom(expr) ||
-			     groupAtom(expr) ||
-			     operatorAtom(expr) ||
+    bbox = RenderStr(CHAR(asChar(expr)), draw);
-			     radicalAtom(expr)))
-	fontFace = 5;
-    else if (numberAtom(expr))
+    SetFont(prevfont);
-	fontFace = 1;
-    return fontFace;
+    return bbox;
+}
-/* a forward declaration */
-static double fontHeight();
-/* some forward declarations */
+/* Code for String Atoms */
-typedef struct {
-    double height;
-    double depth;
-    double width;
-} BBOX;
-static double bboxHeight(BBOX bbox)
+static BBOX RenderString(SEXP expr, int draw)
-{
-    return bbox.height;
-}
-static double bboxDepth(BBOX bbox)
+{
-    return bbox.depth;
+    return RenderStr(CHAR(STRING(expr)[0]), draw);
+}
-static double bboxWidth(BBOX bbox)
-{
-    return bbox.width;
-}
-static BBOX asciiBBox(int ascii);
-static BBOX elementBBox(SEXP expr);
-static void drawElement(SEXP expr);
-/* code to determine superscript offsets, etc ... */
-/* these "twiddle factors" are given as  */
-/* proportions of the current font height */
-/* NOTE that metric information is obtained */
-/* in INCHES so that the information will */
-/* be useful for rotated math.text */
+/* Code for Ellipsis (ldots, cdots, ...) */
-static float SuperDrop = 0.3;
-static float Superscript = 0.3;
-static float SubDrop = 0.1;
-static float Subscript = -0.3;
+static int DotsAtom(SEXP expr)
-static float LineWidth = 0.05;
-static float CustomAccentGap = 0.2;
-static float CustomHatHeight = 0.3;
-static float CustomRadicalWidth = 0.6;
-static float CustomRadicalSpace = 0.1;
-static float CustomRadicalGap = 0.2;
-static float AbsSpace = 0.2;
-static float OperatorSpace[] = { 0.1, 0.15, 0.2, 0.6, 0.1 };
-static double fontHeight()
+{
-    double height, depth, width;
+    if (NameMatch(expr, "cdots") ||
-    GMetricInfo(0, &height, &depth, &width, metricUnit, mathDevice);
+	NameMatch(expr, "...")   ||
+	NameMatch(expr, "ldots"))
+            return 1;
-    return height + depth;
+    return 0;
+}
-static double xHeight()
+static BBOX RenderDots(SEXP expr, int draw)
+{
+    BBOX bbox = RenderSymbolChar(S_ELLIPSIS, 0);
+    if (NameMatch(expr, "cdots") || NameMatch(expr, "...")) {
+	double shift = AxisHeight() - 0.5 * bboxHeight(bbox);
+	if (draw) {
-    int x = 'x';
+	    MoveUp(shift);
+	    RenderSymbolChar(S_ELLIPSIS, 1);
+	    MoveUp(-shift);
+	}
-    double xheight, depth, width;
+	return ShiftBBox(bbox, shift);
+    }
+    else {
+	if (draw)
-    GMetricInfo(x, &xheight, &depth, &width, metricUnit, mathDevice);
+	    RenderSymbolChar(S_ELLIPSIS, 1);
-    return xheight;
+	return bbox;
+    }
+}
-static double axisHeight()
+/*----------------------------------------------------------------------
-{
+ *
-    int plus = '+';
+ *  Code for Atoms
-    double plusHeight, depth, width;
-    GMetricInfo(plus, &plusHeight, &depth, &width, metricUnit, mathDevice);
-    return 0.5 * plusHeight;
-}
+ *
+ */
-static double superscriptDrop()
-{
-    return SuperDrop * fontHeight();
-}
-static double subscriptDrop()
-{
-    return SubDrop * fontHeight();
-}
-static double superscript()
-{
-    return Superscript * fontHeight();
-}
-static double subscript()
-{
-    return Subscript * fontHeight();
-}
-static double lineWidth()
-{
-    return LineWidth * fontHeight();
-}
-static double numeratorShift()
-{
-    return axisHeight() + 3 * lineWidth();
-}
-static double denominatorShift()
+static BBOX RenderAtom(SEXP expr, int draw)
-{
-    return axisHeight() - 3 * lineWidth() - xHeight();
-}
-static double radicalDrop()
-{
-    return 1.25 * lineWidth();
-}
-static double customAccentGap()
-{
-    return CustomAccentGap * fontHeight();
-}
-static double customHatHeight()
+{
-    return CustomHatHeight * fontHeight();
-}
-static double customRadicalWidth()
+    if (NameAtom(expr)) {
-{
-    return CustomRadicalWidth * fontHeight();
-}
-static double customRadicalSpace()
+	if (DotsAtom(expr))
-{
-    return CustomRadicalSpace * fontHeight();
+	    return RenderDots(expr, draw);
-}
-static double customRadicalGap()
-{
+	else
-    return CustomRadicalGap * fontHeight();
+	    return RenderSymbol(expr, draw);
-}
+    }
-static double absSpace()
+    else if (NumberAtom(expr))
-{
-    return AbsSpace * fontHeight();
+	return RenderNumber(expr, draw);
-}
-static double operatorSpace(int i)
+    else if (StringAtom(expr))
-{
-    return OperatorSpace[i] * fontHeight();
+	return RenderString(expr, draw);
+}
+/*----------------------------------------------------------------------
+ *
+ *  Code for Binary / Unary Operators  (~, +, -, ... )
+ *
-/* Should only be called when font=5 (symbol) */
+ *  Note that there are unary and binary ~ s.
+ *
+ */
-static double radicalExWidth()
+static int SpaceAtom(SEXP expr)
+{
-    int radicalEx = 96;
-    double height, depth, REWidth;
+    return NameAtom(expr) && NameMatch(expr, "~");
-    GMetricInfo(radicalEx, &height, &depth, &REWidth, metricUnit, mathDevice);
-    return REWidth;
+}
-static double superscriptShift(SEXP body, SEXP sup)
-{
-    BBOX bodyBBox = elementBBox(body);
-    BBOX superscriptBBox;
-    float cexSaved = mathDevice->gp.cex;
-    double temp1 = bboxHeight(bodyBBox) - superscriptDrop();
-    double temp2 = superscript();
-    double temp3;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    superscriptBBox = elementBBox(sup);
-    mathDevice->gp.cex = cexSaved;
-    temp3 = bboxDepth(superscriptBBox) + 0.25 * xHeight();
-    return max(temp1, max(temp2, temp3));
-}
-static double subscriptShift(SEXP body, SEXP sub, int subOnly)
+static BBOX RenderSpace(SEXP expr, int draw)
+{
-    BBOX bodyBBox = elementBBox(body);
-    BBOX subscriptBBox;
+    SEXP arg1, arg2;
-    float cexSaved = mathDevice->gp.cex;
+    BBOX opBBox, arg1BBox, arg2BBox;
-    double temp1 = bboxDepth(bodyBBox) + subscriptDrop();
-    double temp2 = subscript();
+    int nexpr = length(expr);
-    double temp3;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    subscriptBBox = elementBBox(sub);
-    mathDevice->gp.cex = cexSaved;
-    temp3 = bboxHeight(subscriptBBox) - (4 * xHeight() / 5);
-    if (subOnly)
+    if (nexpr == 2) {
+	opBBox = RenderSymbolChar(' ', draw);
+	arg1BBox = RenderElement(CADR(expr), draw);
-	return max(temp1, max(temp2, temp3));
+	return CombineBBoxes(opBBox, arg1BBox);
+    }
+    else if (nexpr == 3) {
+	arg1BBox = RenderElement(CADR(expr), draw);
+	opBBox = RenderSymbolChar(' ', draw);
+	arg2BBox = RenderElement(CADDR(expr), draw);
+	opBBox = CombineBBoxes(arg1BBox, opBBox);
+	opBBox = CombineBBoxes(opBBox, arg2BBox);
+	return opBBox;
+    }
     else
-	return max(temp1, temp2);
-}
-static void supsubShift(SEXP body, SEXP sup, SEXP sub,
-			double *supShift, double *subShift)
-{
-    BBOX superscriptBBox, subscriptBBox;
-    float cexSaved = mathDevice->gp.cex;
-    double temp1, temp2;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    superscriptBBox = elementBBox(sup);
+	error("invalid mathematical annotation\n");
-    subscriptBBox = elementBBox(sub);
-    mathDevice->gp.cex = cexSaved;
-    *supShift = superscriptShift(body, sup);
-    *subShift = subscriptShift(body, sub, 0);
-    temp1 = (*supShift - bboxDepth(superscriptBBox)) -
-	(bboxHeight(subscriptBBox) - *subShift);
-    if (temp1 < (4 * lineWidth()))
-	*subShift = bboxHeight(subscriptBBox) -
-	    *supShift +
-	    bboxDepth(superscriptBBox) +
-	    (4 * lineWidth());
-    temp2 = (4 * xHeight() / 5) -
-	(*supShift - bboxDepth(superscriptBBox));
-    if (temp2 > 0) {
-	*supShift = *supShift + temp2;
-	*subShift = *subShift - temp2;
-    }
+}
-static double accentVShift(SEXP body)
+static SymTab BinTable[] = {
-{
+    "*",                42,    /* Binary Operators */
-    double temp = xHeight();
+    "+",                43,
-    double bodyHeight = bboxHeight(elementBBox(body));
+    "-",                45,
-    if (bodyHeight > temp)
+    "/",                47,
-	return bodyHeight - temp;
+    ":",                58,
-    else
+    "%+-%",            177,
-	return 0;
+    "%*%",             180,
+    "%/%",             184,
+    NULL,                0
-}
+};
-static double accentHShift(SEXP body, SEXP accent)
+static int BinAtom(SEXP expr)
+{
+    int i;
-    return (bboxWidth(elementBBox(body)) -
+    for (i = 0; BinTable[i].code; i++)
-	    bboxWidth(elementBBox(accent))) / 2;
+	if (NameMatch(expr, BinTable[i].name))
+	    return BinTable[i].code;
+    return 0;
+}
-static double numeratorVShift(SEXP num)
-{
-    BBOX numBBox;
+#define SLASH2
-    float cexSaved = mathDevice->gp.cex;
-    double theShift, theClearance, minClearance;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    numBBox = elementBBox(num);
-    mathDevice->gp.cex = cexSaved;
-    theShift = numeratorShift();
-    theClearance = numeratorShift() - bboxDepth(numBBox) -
-	(axisHeight() + 0.5 * lineWidth());
-    minClearance = 3 * lineWidth();
-    if (theClearance < minClearance)
-	theShift += minClearance - theClearance;
-    return theShift;
-}
-/* RATIO */
-static double denominatorVShift(SEXP denom)
+static BBOX RenderSlash(int draw)
+{
-    BBOX denomBBox;
-    float cexSaved = mathDevice->gp.cex;
-    double theShift, theClearance, minClearance;
-#ifdef OLD
+#ifdef SLASH0
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    /* The Default Font Character */
-#else
-    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
+    return RenderSymbolChar(S_SLASH, draw);
 #endif
+#ifdef SLASH1
+    /* Symbol Magnify Version */
-    denomBBox = elementBBox(denom);
+    double savecex = MathDevice->gp.cex;
-#ifdef OLD
+    BBOX bbox;
+    double height1, height2;
+    height1 = bboxHeight(RenderSymbolChar(S_SLASH, 0));
-    mathDevice->gp.cex = cexSaved;
+    MathDevice->gp.cex = 1.2 * MathDevice->gp.cex;
+    height2 = bboxHeight(RenderSymbolChar(S_SLASH, 0));
+    if (draw)
+	MoveUp(- 0.5 * (height2 - height1));
+    bbox = RenderSymbolChar(S_SLASH, draw);
-#else
+    if (draw)
+	MoveUp(0.5 * (height2 - height1));
-    mathDevice->gp.cex = cexSaved;
+    MathDevice->gp.cex = savecex;
+    return bbox;
 #endif
+#ifdef SLASH2
-    theShift = denominatorShift();
+    /* Line Drawing Version */
+    double x[2], y[2];
-    theClearance = axisHeight() - 0.5 * lineWidth() -
+    double depth = 0.5 * TeX(sigma22);
-	(bboxHeight(denomBBox) - denominatorShift());
+    double height = XHeight() + 0.5 * TeX(sigma22);
-    minClearance = 3 * lineWidth();
+    double width = 0.5 * xHeight();
-    if (theClearance < minClearance)
+    if (draw) {
-	theShift += minClearance - theClearance;
+	MoveAcross(0.5 * width);
-    return theShift;
+	MoveUp(-depth);
-}
-/* RATIO */
+	x[0] = ConvertedX();
-static double fractionWidth(SEXP num, SEXP denom)
+	y[0] = ConvertedY();
-{
-    BBOX numBBox;
+	MoveAcross(width);
-    BBOX denomBBox;
+	MoveUp(depth + height);
-    float cexSaved = mathDevice->gp.cex;
+	x[1] = ConvertedX();
-    double temp1, temp2;
+	y[1] = ConvertedY();
-#ifdef OLD
+	MoveUp(-height);
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+	GPolyline(2, x, y, INCHES, MathDevice);
+	MoveAcross(0.5 * width);
-#else
+    }
-    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
+    return MakeBBox(height, depth, 2 * width);
 #endif
+#ifdef SLASH3
+    /* Offset Overprinting - A Failure! */
+    BBOX slashBBox = RenderSymbolChar(S_SLASH, 0);
-    numBBox = elementBBox(num);
+    BBOX ansBBox;
+    double height = bboxHeight(slashBBox);
-    denomBBox = elementBBox(denom);
+    double depth = bboxDepth(slashBBox);
+    double width = bboxWidth(slashBBox);
+    double slope = (height + depth) / slope;
+    double delta = TeX(sigma22);
-#ifdef OLD
+    if (draw)
+	MoveUp(-delta);
+    ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), -delta);
-    mathDevice->gp.cex = cexSaved;
+    MoveUp(2 * delta);
+    ansBBox = CombineBBoxes(ansBBox, RenderGap(2 * delta / slope, draw));
+    ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), 2 * delta);
-#else
+    MoveUp(-delta);
-    mathDevice->gp.cex = cexSaved;
+    return ansBBox;
 #endif
-    temp1 = bboxWidth(numBBox);
-    temp2 = bboxWidth(denomBBox);
-    return max(temp1, temp2);
+}
-/* RATIO */
-static void numdenomHShift(SEXP num, SEXP denom,
+static BBOX RenderBin(SEXP expr, int draw)
-			   double *numShift, double *denomShift)
+{
-    BBOX numBBox;
-    BBOX denomBBox;
-    float cexSaved = mathDevice->gp.cex;
-    double temp1, temp2;
-#ifdef OLD
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-#else
-    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
-#endif
-    numBBox = elementBBox(num);
+    int op = BinAtom(CAR(expr));
-    denomBBox = elementBBox(denom);
+    int nexpr = length(expr);
-#ifdef OLD
-    mathDevice->gp.cex = cexSaved;
-#else
-    mathDevice->gp.cex = cexSaved;
-#endif
-    temp1 = bboxWidth(numBBox);
+    BBOX bbox;
-    temp2 = bboxWidth(denomBBox);
+    double gap;
-    if (temp1 > temp2) {
+    if(nexpr == 3) {
+	if (op == S_ASTERISKMATH) {
+	    bbox = RenderElement(CADR(expr), draw);
+	    bbox = RenderItalicCorr(bbox, draw);
+	    return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw));
+	}
+	else if (op == S_SLASH) {
-	*numShift = 0;
+	    gap = 0;
+	    bbox = RenderElement(CADR(expr), draw);
+	    bbox = RenderItalicCorr(bbox, draw);
+	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw));
+	    bbox = CombineBBoxes(bbox, RenderSlash(draw));
+	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw));
+	    return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw));
+	}
+	else {
+	    gap = (CurrentStyle > STYLE_S) ? MediumSpace() : 0;
-	*denomShift = (temp1 - temp2) / 2;
+	    bbox = RenderElement(CADR(expr), draw);
+	    bbox = RenderItalicCorr(bbox, draw);
+	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw));
+	    bbox = CombineBBoxes(bbox, RenderSymbolChar(op, draw));
+	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw));
+	    return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw));
+	}
+    }
-    else {
+    else if(nexpr == 2) {
-	*numShift = (temp2 - temp1) / 2;
+	gap = (CurrentStyle > STYLE_S) ? ThinSpace() : 0;
-	*denomShift = 0;
+	bbox = RenderSymbolChar(op, draw);
+	bbox = CombineBBoxes(bbox, RenderGap(gap, draw));
+	return CombineBBoxes(bbox, RenderElement(CADR(expr), draw));
+    }
+    else error("invalid mathematical annotation\n");
+}
-static int normalRadical(SEXP body)
-{
-    BBOX bodyBBox = elementBBox(body);
-    BBOX radicalBBox = asciiBBox(radicalAscii());
-    return ((bboxHeight(bodyBBox) + radicalDrop())
+/*----------------------------------------------------------------------
+ *
-	    <= bboxHeight(radicalBBox)) &&
+ *  Code for Subscript and Superscipt Expressions
+ *
-	(bboxDepth(bodyBBox) <= bboxDepth(radicalBBox));
+ *  Rules 18, 18a, ..., 18f of the TeXBook.
-}
+ *
+ */
-static double radicalVShift(SEXP body)
+static int SuperAtom(SEXP expr)
+{
-    BBOX bodyBBox = elementBBox(body);
-    return bboxHeight(bodyBBox) + radicalDrop();
+    return NameAtom(expr) && NameMatch(expr, "^");
+}
-static BBOX theOperatorBBox(SEXP operator);
+static int SubAtom(SEXP expr)
-static BBOX operatorLimitBBox(SEXP operator);
-static double operatorLowerShift(SEXP operator, SEXP lower)
+{
-    BBOX opBBox = theOperatorBBox(operator);
-    BBOX lowerBBox;
-    double lowerHeight;
-    double spacing2 = operatorSpace(1);
-    double spacing4 = operatorSpace(3);
-    lowerBBox = operatorLimitBBox(lower);
-    lowerHeight = bboxHeight(lowerBBox);
-    if (spacing2 > (spacing4 - lowerHeight))
-	return bboxDepth(opBBox) + spacing2 + lowerHeight;
+    return NameAtom(expr) && NameMatch(expr, "[");
-    else
-	return bboxDepth(opBBox) + spacing4;
+}
+/* Note : If all computations are correct */
+/* We do not need to save and restore the */
+/* current location here.  This is paranoia. */
-static double operatorUpperShift(SEXP operator, SEXP upper)
+static BBOX RenderSub(SEXP expr, int draw)
+{
-    BBOX opBBox = theOperatorBBox(operator);
+    BBOX bodyBBox, subBBox;
-    BBOX upperBBox;
+    SEXP body = CADR(expr);
-    double upperDepth;
+    SEXP sub = CADDR(expr);
+    STYLE style = GetStyle();
-    double spacing1 = operatorSpace(0);
+    double savedX = CurrentX;
-    double spacing3 = operatorSpace(2);
+    double savedY = CurrentY;
-    upperBBox = operatorLimitBBox(upper);
+    double shift, v, s5, s16;
-    upperDepth = bboxDepth(upperBBox);
+    bodyBBox = RenderElement(body, draw);
-    if (spacing1 > (spacing3 - upperDepth))
+    bodyBBox = RenderItalicCorr(bodyBBox, draw);
-	return bboxHeight(opBBox) + spacing1 + upperDepth;
+    v = bboxSimple(bodyBBox) ? 0 : bboxDepth(bodyBBox) + TeX(sigma19);
-    else
+    s5 = TeX(sigma5);
-	return bboxHeight(opBBox) + spacing3;
+    s16 = TeX(sigma16);
-}
-static double operatorLowerHShift(SEXP operator, SEXP lower)
+    SetSubStyle(style);
-{
-    BBOX opBBox = theOperatorBBox(operator);
+    subBBox = RenderElement(sub, 0);
-    BBOX lowerBBox;
-    double maxWidth = bboxWidth(opBBox);
+    v = max(max(v, s16), bboxHeight(subBBox) - 0.8 * sigma5);
-    lowerBBox = operatorLimitBBox(lower);
+    subBBox = RenderOffsetElement(sub, 0, -v, draw);
-    if (bboxWidth(lowerBBox) < maxWidth)
+    bodyBBox = CombineBBoxes(bodyBBox, subBBox);
-	return (maxWidth - bboxWidth(lowerBBox))/2;
+    SetStyle(style);
-    else
+    if (draw)
+	MoveTo(savedX + bboxWidth(bodyBBox), savedY);
-	return 0;
+    return bodyBBox;
+}
-static double operatorHShift(SEXP operator, SEXP lower)
+static BBOX RenderSup(SEXP expr, int draw)
+{
-    BBOX opBBox = theOperatorBBox(operator);
+    BBOX bodyBBox, subBBox, supBBox;
+    SEXP body = CADR(expr);
+    SEXP sup = CADDR(expr);
+    SEXP sub;
+    STYLE style = GetStyle();
+    double savedX = CurrentX;
+    double savedY = CurrentY;
+    double theta, delta, width;
+    double u, p;
+    double v, s5, s17;
-    BBOX lowerBBox;
+    int haveSub;
+    if (FormulaExpression(body) && SubAtom(CAR(body))) {
+	sub = CADDR(body);
+	body = CADR(body);
+	haveSub = 1;
+    }
+    else haveSub = 0;
+    bodyBBox = RenderElement(body, draw);
+    delta = bboxItalic(bodyBBox);
+    bodyBBox = RenderItalicCorr(bodyBBox, draw);
-    double maxWidth = bboxWidth(opBBox);
+    width = bboxWidth(bodyBBox);
+    if (bboxSimple(bodyBBox)) {
+	u = 0;
+	v = 0;
+    }
+    else {
+	u = bboxHeight(bodyBBox) - TeX(sigma18);
+	v = bboxDepth(bodyBBox) + TeX(sigma19);
+    }
+    theta = TeX(xi8);
+    s5 = TeX(sigma5);
+    s17 = TeX(sigma17);
+    if (style == STYLE_D)
+	p = TeX(sigma13);
+    else if (IsCompactStyle(style))
+	p = TeX(sigma15);
+    else
+	p = TeX(sigma14);
+    SetSupStyle(style);
+    supBBox = RenderElement(sup, 0);
+    u = max(max(u, p), bboxDepth(supBBox) + 0.25 * s5);
+    if (haveSub) {
+	SetSubStyle(style);
-    lowerBBox = operatorLimitBBox(lower);
+	subBBox = RenderElement(sub, 0);
+	v = max(v, s17);
+	if ((u - bboxDepth(supBBox)) - (bboxHeight(subBBox) - v) < 4 * theta) {
+	    double psi = 0.8 * s5 - (u - bboxDepth(supBBox));
+	    if (psi > 0) {
+		u += psi;
+		v -= psi;
+	    }
+	}
+	if (draw)
+	    MoveTo(savedX, savedY);
+	subBBox = RenderOffsetElement(sub, width, -v, draw);
+	if (draw)
-    if (bboxWidth(lowerBBox) > maxWidth)
+	    MoveTo(savedX, savedY);
+	SetSupStyle(style);
+	supBBox = RenderOffsetElement(sup, width + delta, u, draw);
+	bodyBBox = CombineAlignedBBoxes(bodyBBox, subBBox);
-	return (bboxWidth(lowerBBox) - maxWidth)/2;
+	bodyBBox = CombineAlignedBBoxes(bodyBBox, supBBox);
+    }
-    else
+    else {
+	supBBox = RenderOffsetElement(sup, 0, u, draw);
+	bodyBBox = CombineBBoxes(bodyBBox, supBBox);
+    }
+    if (draw)
+	MoveTo(savedX + bboxWidth(bodyBBox), savedY);
+    SetStyle(style);
-	return 0;
+    return bodyBBox;
+}
-static double operatorLowerHShiftAll(SEXP operator, SEXP lower, SEXP upper)
-{
-    BBOX opBBox = theOperatorBBox(operator);
-    BBOX lowerBBox, upperBBox;
-    double maxWidth = bboxWidth(opBBox);
-    lowerBBox = operatorLimitBBox(lower);
-    upperBBox = operatorLimitBBox(upper);
-    maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
-    if (bboxWidth(lowerBBox) < maxWidth)
+/*----------------------------------------------------------------------
+ *
-	return (maxWidth - bboxWidth(lowerBBox))/2;
+ *  Code for Accented Expressions (widehat, bar, widetilde, ...)
-    else
+ *
-	return 0;
-}
+ */
-static double operatorUpperHShiftAll(SEXP operator, SEXP lower, SEXP upper)
-{
-    BBOX opBBox = theOperatorBBox(operator);
-    BBOX lowerBBox, upperBBox;
+#define ACCENT_GAP  0.2
-    double maxWidth = bboxWidth(opBBox);
+#define HAT_HEIGHT  0.3
-    lowerBBox = operatorLimitBBox(lower);
-    upperBBox = operatorLimitBBox(upper);
-    maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
-    if (bboxWidth(upperBBox) < maxWidth)
-	return (maxWidth - bboxWidth(upperBBox))/2;
-    else
+#define NTILDE      8
-	return 0;
+#define DELTA       0.05
-}
-static double operatorHShiftAll(SEXP operator, SEXP lower, SEXP upper)
+static int WideTildeAtom(SEXP expr)
+{
+    return NameAtom(expr) && NameMatch(expr, "widetilde");
+}
+static BBOX RenderWideTilde(SEXP expr, int draw)
+{
+    double savedX = CurrentX;
+    double savedY = CurrentY;
-    BBOX opBBox = theOperatorBBox(operator);
+    BBOX bbox = RenderElement(CADR(expr), draw);
-    BBOX lowerBBox, upperBBox;
+    double height = bboxHeight(bbox);
-    double maxWidth = bboxWidth(opBBox);
+    double width = bboxWidth(bbox);
+    double totalwidth = bboxWidth(bbox) + bboxItalic(bbox);
+    double delta = totalwidth * (1 - 2 * DELTA) / NTILDE;
-    lowerBBox = operatorLimitBBox(lower);
+    double start = DELTA * totalwidth;
-    upperBBox = operatorLimitBBox(upper);
+    double accentGap = ACCENT_GAP * FontHeight();
-    maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
+    double hatHeight = 0.5 * HAT_HEIGHT * FontHeight();
+    double c = 8 * atan(1.0) / NTILDE;
+    double x[NTILDE + 3], y[NTILDE + 3];
+    double baseX, baseY, xval, yval;
+    int i;
+    if (draw) {
+	baseX = savedX;
+	baseY = savedY + height + accentGap;
+	MoveTo(baseX, baseY);
+	x[0] = ConvertedX();
+	y[0] = ConvertedY();
+	for (i = 0; i <= NTILDE; i++) {
-    if (bboxWidth(opBBox) < maxWidth)
+	    xval = start + i * delta;
+	    yval = 0.5 * hatHeight * (sin(c * i) + 1);
+	    MoveTo(baseX + xval, baseY + yval);
+	    x[i + 1] = ConvertedX();
+	    y[i + 1] = ConvertedY();
+	}
+	MoveTo(baseX + totalwidth, baseY + hatHeight);
+	x[NTILDE + 2] = ConvertedX();
+	y[NTILDE + 2] = ConvertedY();
+	GPolyline(NTILDE + 3, x, y, INCHES, MathDevice);
-	return (maxWidth - bboxWidth(opBBox))/2;
+	MoveTo(savedX + totalwidth, savedY);
-    else
+    }
+    return MakeBBox(height + accentGap + hatHeight,
-	return 0;
+		    bboxDepth(bbox), totalwidth);
+}
-/* Code to generate bounding boxes and draw formulae. */
-/* Bounding box basics. */
+static int WideHatAtom(SEXP expr)
-static BBOX makeBBox(double height, double depth, double width)
+{
-    BBOX bbox;
-    bbox.height = height;
+    return NameAtom(expr) && NameMatch(expr, "widehat");
-    bbox.depth = depth;
-    bbox.width = width;
-    return bbox;
+}
-static BBOX nullBBox()
+static BBOX RenderWideHat(SEXP expr, int draw)
+{
+    double savedX = CurrentX;
+    double savedY = CurrentY;
+    BBOX bbox = RenderElement(CADR(expr), draw);
+    double accentGap = ACCENT_GAP * FontHeight();
+    double hatHeight = HAT_HEIGHT * FontHeight();
+    double totalwidth = bboxWidth(bbox) + bboxItalic(bbox);
+    double height = bboxHeight(bbox);
-    return makeBBox(0.0, 0.0, 0.0);
+    double width = bboxWidth(bbox);
-}
+    double x[3], y[3];
+    if (draw) {
-static BBOX makeBBoxFromChar(int chr)
+	MoveTo(savedX, savedY + height + accentGap);
+	x[0] = ConvertedX();
+	y[0] = ConvertedY();
+	MoveAcross(0.5 * totalwidth);
-{
+	MoveUp(hatHeight);
+	x[1] = ConvertedX();
+	y[1] = ConvertedY();
-    double height, depth, width;
+	MoveAcross(0.5 * totalwidth);
+	MoveUp(-hatHeight);
+	x[2] = ConvertedX();
+	y[2] = ConvertedY();
-    GMetricInfo(chr, &height, &depth, &width, metricUnit, mathDevice);
+	GPolyline(3, x, y, INCHES, MathDevice);
+	MoveTo(savedX + width, savedY);
+    }
-    return makeBBox(height, depth, width);
+    return EnlargeBBox(bbox, accentGap + hatHeight, 0, 0);
+}
-static BBOX shiftBBox(BBOX bbox, double shiftV)
+static int BarAtom(SEXP expr)
+{
-    return makeBBox(bboxHeight(bbox) + shiftV,
+    return NameAtom(expr) && NameMatch(expr, "bar");
-		    bboxDepth(bbox) - shiftV,
-		    bboxWidth(bbox));
+}
-static BBOX combineBBoxes(BBOX bbox1, BBOX bbox2)
+static BBOX RenderBar(SEXP expr, int draw)
+{
+    double savedX = CurrentX;
+    double savedY = CurrentY;
+    BBOX bbox = RenderElement(CADR(expr), draw);
+    double accentGap = ACCENT_GAP * FontHeight();
+    double hatHeight = HAT_HEIGHT * FontHeight();
-    return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
+    double totalwidth = bboxWidth(bbox) + bboxItalic(bbox);
-		    max(bboxDepth(bbox1), bboxDepth(bbox2)),
+    double height = bboxHeight(bbox);
-		    bboxWidth(bbox1) + bboxWidth(bbox2));
+    double width = bboxWidth(bbox);
-}
+    double x[2], y[2];
+    if (draw) {
-static BBOX combineAlignedBBoxes(BBOX bbox1, BBOX bbox2)
+	MoveTo(savedX, savedY + height + accentGap);
-{
+	x[0] = ConvertedX();
+	y[0] = ConvertedY();
+	MoveAcross(totalwidth);
+	x[1] = ConvertedX();
+	y[1] = ConvertedY();
-    return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
+	GPolyline(2, x, y, INCHES, MathDevice);
-		    max(bboxDepth(bbox1), bboxDepth(bbox2)),
+	MoveTo(savedX + width, savedY);
+    }
-		    max(bboxWidth(bbox1), bboxWidth(bbox2)));
+    return EnlargeBBox(bbox, accentGap, 0, 0);
+}
-/* Drawing basics */
-static double referenceX;
-static double referenceY;
-static double currentX;
+static struct {
-static double currentY;
-static double currentAngle;
-static double cosAngle;
-static double sinAngle;
-/* Convert currentX and currentY from 0 angle */
-/* to and currentAngle */
+    char *name;
-static double convertedX()
-{
-    double rotatedX = referenceX +
-	(currentX - referenceX) * cosAngle -
-	(currentY - referenceY) * sinAngle;
-    return rotatedX;
+    int code;
+}
+AccentTable[] = {
+    "hat",            94,
+    "tilde",         126,
+    NULL,              0,
+};
-static double convertedY()
+static int AccentCode(SEXP expr)
+{
+    int i;
-    double rotatedY = referenceY +
+    for (i = 0; AccentTable[i].code; i++)
-	(currentY - referenceY) * cosAngle +
+	if (NameMatch(expr, AccentTable[i].name))
-	(currentX - referenceX) * sinAngle;
+	    return AccentTable[i].code;
-    return rotatedY;
+    return 0;
+}
-static void moveAcross(double xamount)
+static int AccentAtom(SEXP expr)
+{
-    currentX += xamount;
+    return NameAtom(expr) &&
+	(NameMatch(expr, "hat") || NameMatch(expr, "tilde"));
+}
-static void moveUp(double yamount)
+static void InvalidAccent(SEXP expr)
+{
-    currentY += yamount;
+    errorcall(expr, "invalid accent\n");
+}
-static void moveTo(double x, double y)
+static BBOX RenderAccent(SEXP expr, int draw)
+{
+    SEXP body, accent;
+    double savedX = CurrentX;
+    double savedY = CurrentY;
+    BBOX bodyBBox, accentBBox;
+    double xoffset, yoffset;
-    currentX = x;
+    int code;
+    if (length(expr) != 2)
+	InvalidAccent(expr);
+    accent = CAR(expr);
+    body = CADR(expr);
+    if (NameMatch(accent, "hat"))
+	code = 94;
+    else if (NameMatch(accent, "tilde"))
+	code = 126;
+    else
+	InvalidAccent(expr);
+    bodyBBox = RenderElement(body, draw);
+    accentBBox = RenderChar(code, 0);
+    xoffset = 0.5 *(bboxWidth(bodyBBox) - bboxWidth(accentBBox));
+    yoffset = bboxHeight(bodyBBox);
+    if (draw) {
+	MoveTo(savedX + xoffset, savedY + yoffset);
+	RenderChar(code, draw);
+    }
+    bodyBBox = CombineOffsetBBoxes(bodyBBox, 0, accentBBox, 0,
+				   xoffset, yoffset);
+    MoveTo(savedX + bboxWidth(bodyBBox), savedY);
-    currentY = y;
+    return bodyBBox;
+}
-/* Code for ascii atoms. */
-/* NOTE that I assume that all symbols which have */
-/* been converted to ascii are in the symbol font. */
-static BBOX asciiBBox(int ascii)
-{
-    if ((ascii == hatAscii()) || (ascii == tildeAscii()))
+/*----------------------------------------------------------------------
-	mathDevice->gp.font = 1;
-    else
-	mathDevice->gp.font = 5;
-    return makeBBoxFromChar(ascii);
-}
+ *
-static void drawAscii(int ascii)
+ *  Code for Fraction Expressions  (over, atop)
-{
+ *
-    char asciiStr[2];
-    if ((ascii == hatAscii()) || (ascii == tildeAscii()))
-	mathDevice->gp.font = 1;
-    else
-	mathDevice->gp.font = 5;
-    asciiStr[0] = ascii;
-    asciiStr[1] = '\0';
-    GText(convertedX(), convertedY(), INCHES, asciiStr,
-.0, 0.0, currentAngle, mathDevice);
+ *  Rules 15, 15a, ..., 15e of the TeXBook
-    moveAcross(GStrWidth(asciiStr, metricUnit, mathDevice));
-}
+ *
+ */
-/* Code for character atoms. */
-static BBOX charBBox(char *str, SEXP expr)
+static void NumDenomVShift(BBOX numBBox, BBOX denomBBox,
+			     double *u, double *v)
+{
+    double a, delta, phi, theta;
+    a = TeX(sigma22);
+    theta = TeX(xi8);
-    BBOX resultBBox = nullBBox();
+    if(CurrentStyle > STYLE_T) {
+	*u = TeX(sigma8);
+	*v = TeX(sigma11);
+	phi = 3 * theta;
+    }
-    int i;
+    else {
+	*u = TeX(sigma9);
+	*v = TeX(sigma12);
+	phi = theta;
+    }
-    mathDevice->gp.font = atomFontFace(expr);
+    delta = (*u - bboxDepth(numBBox)) - (a + 0.5 * theta);
-    for (i = 0; i < strlen(str); i++)
+    if (delta < phi)
+	*u += (phi - delta);
-	resultBBox = combineBBoxes(resultBBox, makeBBoxFromChar(str[i]));
+    delta = (a + 0.5 * theta) - (bboxHeight(denomBBox) - *v);
+    if (delta < phi)
-    return resultBBox;
+	*v += (phi - delta);
+}
-static void drawChar(char *str, SEXP expr)
+static void NumDenomHShift(BBOX numBBox, BBOX denomBBox,
+			   double *numShift, double *denomShift)
+{
-    mathDevice->gp.font = atomFontFace(expr);
+    double numWidth = bboxWidth(numBBox);
-    GText(convertedX(), convertedY(), INCHES, str,
+    double denomWidth = bboxWidth(denomBBox);
+    if (numWidth > denomWidth) {
+	*numShift = 0;
-.0, 0.0, currentAngle, mathDevice);
+	*denomShift = (numWidth - denomWidth) / 2;
+    }
+    else {
-    moveAcross(GStrWidth(str, metricUnit, mathDevice));
+	*numShift = (denomWidth - numWidth) / 2;
+	*denomShift = 0;
+    }
+}
-/* code for symbol atoms */
-static BBOX symbolBBox(SEXP expr)
+static BBOX RenderFraction(SEXP expr, int rule, int draw)
+{
-    if (symbolSymbol(expr))
+    SEXP numerator = CADR(expr);
-	return asciiBBox(symbolAscii(expr));
+    SEXP denominator = CADDR(expr);
+    BBOX numBBox, denomBBox, ansBBox;
+    double nHShift, dHShift;
+    double nVShift, dVShift;
+    double width, x[2], y[2];
+    double savedX = CurrentX;
+    double savedY = CurrentY;
+    STYLE style;
+    style = GetStyle();
+    SetNumStyle(style);
+    numBBox = RenderItalicCorr(RenderElement(numerator, 0), 0);
+    SetDenomStyle(style);
+    denomBBox = RenderItalicCorr(RenderElement(denominator, 0), 0);
+    SetStyle(style);
+    width = max(bboxWidth(numBBox), bboxWidth(denomBBox));
+    NumDenomHShift(numBBox, denomBBox, &nHShift, &dHShift);
+    NumDenomVShift(numBBox, denomBBox, &nVShift, &dVShift);
+    CurrentX = savedX;
+    CurrentY = savedY;
+    SetNumStyle(style);
+    numBBox = RenderOffsetElement(numerator, nHShift, nVShift, draw);
+    CurrentX = savedX;
+    CurrentY = savedY;
+    SetDenomStyle(style);
+    denomBBox = RenderOffsetElement(denominator, dHShift, -dVShift, draw);
+    SetStyle(style);
+    if (draw) {
+	if (rule) {
+	    CurrentX = savedX;
+	    CurrentY = savedY;
+	    MoveUp(AxisHeight());
+	    x[0] = ConvertedX();
+	    y[0] = ConvertedY();
+	    MoveAcross(width);
+	    x[1] = ConvertedX();
+	    y[1] = ConvertedY();
+	    GPolyline(2, x, y, INCHES, MathDevice);
+	    MoveUp(-AxisHeight());
+	}
+	MoveTo(savedX + width, savedY);
-    else
+    }
-	return charBBox(CHAR(PRINTNAME(expr)), expr);
+    return CombineAlignedBBoxes(numBBox, denomBBox);
+}
-static void drawSymbol(SEXP expr)
+static int OverAtom(SEXP expr)
+{
-    if (symbolSymbol(expr))
-	drawAscii(symbolAscii(expr));
-    else
-	drawChar(CHAR(PRINTNAME(expr)), expr);
+    return NameAtom(expr) && NameMatch(expr, "over");
+}
-/* code for numeric atoms */
-static BBOX numberBBox(SEXP expr)
+static BBOX RenderOver(SEXP expr, int draw)
+{
-#ifdef OLD
-    int fontFace = getFont();
-    setFont(1);
-#endif
-    return charBBox(CHAR(asChar(expr)), expr);
+    return RenderFraction(expr, 1, draw);
-#ifdef OLD
-    setFont(fontFace);
-#endif
+}
-static void drawNumber(SEXP expr)
+static int AtopAtom(SEXP expr)
+{
-#ifdef OLD
-    int fontFace = getFont();
-    setFont(1);
-#endif
-    drawChar(CHAR(asChar(expr)), expr);
+    return NameAtom(expr) && NameMatch(expr, "atop");
-#ifdef OLD
-    setFont(fontFace);
-#endif
+}
-/* code for string atoms */
-static BBOX stringBBox(SEXP expr)
+static BBOX RenderAtop(SEXP expr, int draw)
+{
-    return charBBox(CHAR(STRING(expr)[0]), expr);
+    return RenderFraction(expr, 0, draw);
+}
+/*----------------------------------------------------------------------
+ *
+ *  Code for Grouped Expressions  (e.g. ( ... ))
+ *
+ *    group(ldelim, body, rdelim)
+ *
+ *    bgroup(ldelim, body, rdelim)
+ *
+ */
-static void drawString(SEXP expr)
+static int DelimCode(SEXP expr, SEXP head)
+{
+    int code = 0;
+    if (NameAtom(head)) {
+	if (NameMatch(head, "lfloor"))
+	    code = S_BRACKETLEFTBT;
+	else if (NameMatch(head, "rfloor"))
+	    code = S_BRACKETRIGHTBT;
+	if (NameMatch(head, "lceil"))
+	    code = S_BRACKETLEFTBT;
+	else if (NameMatch(head, "rceil"))
+	    code = S_BRACKETRIGHTBT;
+    }
+    else if (StringAtom(head) && length(head) > 0) {
+	if (StringMatch(head, "|"))
+	    code = '|';
+	else if (StringMatch(head, "||"))
+	    code = 2;
+	else if (StringMatch(head, "("))
+	    code = '(';
+	else if (StringMatch(head, ")"))
+	    code = ')';
+	else if (StringMatch(head, "["))
+	    code = '[';
+	else if (StringMatch(head, "]"))
+	    code = ']';
+	else if (StringMatch(head, "{"))
+	    code = '{';
+	else if (StringMatch(head, "}"))
+	    code = '}';
+	else if (StringMatch(head, "") || StringMatch(head, "."))
+	    code = '.';
+    }
+    if (code == 0)
-    drawChar(CHAR(STRING(expr)[0]), expr);
+	errorcall(expr, "invalid group delimiter\n");
+    return code;
+}
-/* code for atoms */
-static BBOX atomBBox(SEXP expr)
+static int GroupAtom(SEXP expr)
+{
-    if (symbolAtom(expr))
-	return symbolBBox(expr);
-    else if (numberAtom(expr))
+    return NameAtom(expr) && NameMatch(expr, "group");
-	return numberBBox(expr);
-    else if (stringAtom(expr))
-	return stringBBox(expr);
+}
-static void drawAtom(SEXP expr)
+static BBOX RenderGroup(SEXP expr, int draw)
+{
+    BBOX bbox;
+    int code;
-    if (symbolAtom(expr))
+    if (length(expr) != 4)
+	errorcall(expr, "invalid group specification\n");
+    bbox = NullBBox();
+    code = DelimCode(expr, CADR(expr));
-	drawSymbol(expr);
+    if (code == 2) {
+	bbox = RenderSymbolChar('|', draw);
+	bbox = RenderSymbolChar('|', draw);
+    }
-    else if (numberAtom(expr))
+    else if (code != '.')
+	bbox = RenderSymbolChar(code, draw);
+    bbox = CombineBBoxes(bbox, RenderElement(CADDR(expr), draw));
+    bbox = RenderItalicCorr(bbox, draw);
+    code = DelimCode(expr, CADDDR(expr));
-	drawNumber(expr);
+    if (code == 2) {
+	bbox = RenderSymbolChar('|', draw);
+	bbox = RenderSymbolChar('|', draw);
+    }
-    else if (stringAtom(expr))
+    else if (code != '.')
+	bbox = RenderSymbolChar(code, draw);
-	drawString(expr);
+    return bbox;
+}
-/* code for italic corrections */
-static double half_pi = 1.57079632679489661922;
-static double italicCorrection(SEXP expr)
+static int BGroupAtom(SEXP expr)
+{
-    BBOX exprBBox = elementBBox(expr);
-    return bboxHeight(exprBBox) * tan(half_pi / 6);
+    return NameAtom(expr) && NameMatch(expr, "bgroup");
+}
-	/* correction within expression checks for current font italic */
-static BBOX correctionWithinBBox(SEXP expr)
+static BBOX RenderDelim(int which, double dist, int draw)
+{
+    double savedX = CurrentX;
+    double savedY = CurrentY;
-    if (isItalic() && !nonItalicExpression(expr))
+    FontType prev = SetFont(SymbolFont);
-	return makeBBox(0, 0, italicCorrection(expr));
+    BBOX ansBBox, topBBox, botBBox, extBBox, midBBox;
+    int top, bot, ext, mid;
+    double topShift, botShift;
+    double axisHeight = TeX(sigma22);
+    switch(which) {
-    else
+    case '.':
-	return nullBBox();
+	return NullBBox();
+	break;
+    case '|':
+    case 2:
+	top = 239; ext = 239; bot = 239; mid = 0;
+	break;
+    case '(':
+	top = 230; ext = 231; bot = 232; mid = 0;
+	break;
+    case ')':
+	top = 246; ext = 247; bot = 248; mid = 0;
+	break;
+    case '[':
+	top = 233; ext = 234; bot = 235; mid = 0;
+	break;
+    case ']':
+	top = 249; ext = 250; bot = 251; mid = 0;
+	break;
+    case '{':
+	top = 236; ext = 239; bot = 238; mid = 237;
+	break;
+    case '}':
+	top = 252; ext = 239; bot = 254; mid = 253;
+	break;
+    default:
+	error("group is incomplete\n");
+	break;
+    }
+    topBBox = GlyphBBox(top);
+    extBBox = GlyphBBox(ext);
+    botBBox = GlyphBBox(bot);
+    topShift = dist - bboxHeight(topBBox) + axisHeight;
+    botShift = dist - bboxDepth(botBBox) - axisHeight;
+    topBBox = ShiftBBox(topBBox, topShift);
+    botBBox = ShiftBBox(botBBox, -botShift);
+    ansBBox = CombineAlignedBBoxes(topBBox, botBBox);
+    if (draw) {
+	MoveUp(topShift);
+	RenderSymbolChar(top, draw);
+	MoveTo(savedX, savedY);
+	MoveUp(-botShift);
+	RenderSymbolChar(bot, draw);
+	MoveTo(savedX + bboxWidth(ansBBox), savedY);
+    }
+    SetFont(prev);
+    return ansBBox;
+}
-static void drawCorrectionWithin(SEXP expr)
+static BBOX RenderBGroup(SEXP expr, int draw)
+{
+    double dist;
+    BBOX bbox, bodyBBox;
+    double axisHeight = TeX(sigma22);
+    double extra = 0.2 * xHeight();
+    int delim1, delim2;
+    if (length(expr) != 4)
+	errorcall(expr, "invalid group specification\n");
+    bbox = NullBBox();
-    if (isItalic() && !nonItalicExpression(expr))
+    delim1 = DelimCode(expr, CADR(expr));
+    delim2 = DelimCode(expr, CADDDR(expr));
+    bbox = RenderElement(CADDR(expr), 0);
+    dist = max(bboxHeight(bbox) - axisHeight, bboxDepth(bbox) + axisHeight);
+    bbox = RenderDelim(delim1, dist + extra, draw);
+    bbox = CombineBBoxes(bbox,  RenderGap(ThinSpace(), draw));
+    bbox = CombineBBoxes(bbox,  RenderElement(CADDR(expr), draw));
-	moveAcross(italicCorrection(expr));
+    bbox = RenderItalicCorr(bbox, draw);
+    bbox = CombineBBoxes(bbox,  RenderDelim(delim2, dist + extra, draw));
+    bbox = CombineBBoxes(bbox,  RenderGap(ThinSpace(), draw));
+    return bbox;
+}
-	/* correction between expressions checks current font and font */
+/*----------------------------------------------------------------------
+ *
-	/* of each expression */
+ *  Code for Parenthetic Expressions  (i.e. ( ... ))
+ *
+ */
-static BBOX correctionBetweenBBox(SEXP expr1, SEXP expr2)
+static int ParenAtom(SEXP expr)
+{
-    if (((isItalic() && !nonItalicExpression(expr1)) ||
-	 italicExpression(expr1)) &&
-	((!isItalic() && !italicExpression(expr2)) ||
-	 nonItalicExpression(expr2)))
-	return makeBBox(0, 0, italicCorrection(expr1));
+    return NameAtom(expr) && NameMatch(expr, "(");
-    else
-	return nullBBox();
+}
-static void drawCorrectionBetween(SEXP expr1, SEXP expr2)
+static BBOX RenderParen(SEXP expr, int draw)
+{
-    if (((isItalic() && !nonItalicExpression(expr1)) ||
+    BBOX bbox;
-	 italicExpression(expr1)) &&
+    bbox = RenderSymbolChar(S_PARENLEFT, draw);
-	((!isItalic() && !italicExpression(expr2)) ||
+    bbox = CombineBBoxes(bbox, RenderElement(CADR(expr), draw));
-	 nonItalicExpression(expr2)))
+    bbox = RenderItalicCorr(bbox, draw);
-	moveAcross(italicCorrection(expr1));
+    return CombineBBoxes(bbox, RenderSymbolChar(S_PARENRIGHT, draw));
+}
-/* code for gaps */
-static int cexGap = 1;
+/*----------------------------------------------------------------------
+ *
-static void setGapCEX()
+ *  Code for Integral Operators.
-{
+ *
-  cexGap = mathDevice->gp.cex;
-}
+ */
-static BBOX gapBBox(double gap)
+static int IntAtom(SEXP expr)
+{
-    double cexSaved = mathDevice->gp.cex;
-    BBOX theBBox;
-    mathDevice->gp.cex = cexGap;
-    theBBox = makeBBox(0, 0, gap * fontHeight());
+    return NameAtom(expr) && NameMatch(expr, "integral");
-    mathDevice->gp.cex = cexSaved;
-    return theBBox;
+}
-static BBOX smallgapBBox(double gap)
-{
-    double cexSaved = mathDevice->gp.cex;
-    BBOX theBBox;
-    mathDevice->gp.cex = cexGap;
-    theBBox = makeBBox(0, 0, 0.5 * gap * fontHeight());
-    mathDevice->gp.cex = cexSaved;
-    return theBBox;
-}
-static void drawGap(double gap)
+static BBOX RenderIntSymbol(int draw)
+{
+    double savedX = CurrentX;
-    double cexSaved = mathDevice->gp.cex;
+    double savedY = CurrentY;
+    BBOX bbox1 = RenderSymbolChar(243, 0);
+    BBOX bbox2 = RenderSymbolChar(245, 0);
+    double shift;
+    shift = TeX(sigma22) + 0.99 * bboxDepth(bbox1);
+    MoveUp(shift);
+    bbox1 = ShiftBBox(RenderSymbolChar(243, draw), shift);
+    CurrentX = savedX;
+    CurrentY = savedY;
+    shift = TeX(sigma22) - 0.99 * bboxHeight(bbox2);
+    MoveUp(shift);
+    bbox2 = ShiftBBox(RenderSymbolChar(245, draw), shift);
+    if (draw)
+	MoveTo(savedX + max(bboxWidth(bbox1), bboxWidth(bbox2)), savedY);
+    else
+	MoveTo(savedX, savedY);
+    return CombineAlignedBBoxes(bbox1, bbox2);
+}
+static BBOX RenderInt(SEXP expr, int draw)
+{
+    BBOX opBBox, lowerBBox, upperBBox, bodyBBox;
-    mathDevice->gp.cex = cexGap;
+    int nexpr = length(expr);
+    STYLE style = GetStyle();
+    double savedX = CurrentX;
+    double savedY = CurrentY;
+    double hshift, vshift, width;
+    opBBox = RenderIntSymbol(draw);
+    width = bboxWidth(opBBox);
+    CurrentX = savedX;
+    CurrentY = savedY;
+    if (nexpr > 2) {
+	hshift = 0.5 * width + ThinSpace();
+	SetSubStyle(style);
+	lowerBBox = RenderElement(CADDR(expr), 0);
+	vshift = bboxDepth(opBBox) + CenterShift(lowerBBox);
+	lowerBBox = RenderOffsetElement(CADDR(expr), hshift, -vshift, draw);
+	opBBox = CombineAlignedBBoxes(opBBox, lowerBBox);
+	SetStyle(style);
+	CurrentX = savedX;
+	CurrentY = savedY;
+    }
+    if (nexpr > 3) {
+	hshift = width + ThinSpace();
+	SetSupStyle(style);
+	upperBBox = RenderElement(CADDDR(expr), 0);
+	vshift = bboxHeight(opBBox) - CenterShift(upperBBox);
+	upperBBox = RenderOffsetElement(CADDDR(expr), hshift, vshift, draw);
+	opBBox = CombineAlignedBBoxes(opBBox, upperBBox);
+	SetStyle(style);
+	CurrentX = savedX;
+	CurrentY = savedY;
+    }
-    moveAcross(gap * fontHeight());
+    MoveAcross(bboxWidth(opBBox));
+    if (nexpr > 1) {
+	bodyBBox = RenderElement(CADR(expr), draw);
-    mathDevice->gp.cex = cexSaved;
+	opBBox = CombineBBoxes(opBBox, bodyBBox);
+    }
+    return opBBox;
+}
-static void drawSmallGap(double gap)
-{
-    double cexSaved = mathDevice->gp.cex;
-    mathDevice->gp.cex = cexGap;
-    moveAcross(0.5 * gap * fontHeight());
-    mathDevice->gp.cex = cexSaved;
-}
+/*----------------------------------------------------------------------
+ *
-/* Code for binary operator (+, -, *, /) expressions */
+ *  Code for Operator Expressions (sum, product, lim, inf, sup, ...)
+ *
+ */
-/* NOTE that gaps are specified as proportions */
-/* of the current font height */
+#define OperatorSymbolMag  1.25
-static double binGapBefore(SEXP beforeOperand)
+static SymTab OpTable[] = {
-{
+    "prod",          S_PRODUCT,
+    "sum",           S_SUM,
+    "union",         S_UNION,
+    "intersect",     S_INTERSECTION,
+    "lim",           N_LIM,
+    "liminf",        N_LIMINF,
+    "limsup",        N_LIMINF,
+    "inf",           N_INF,
+    "sup",           N_SUP,
+    "min",           N_MIN,
+    "max",           N_MAX,
-    return 0.2;
+    NULL,            0
-}
+};
-static double binGapBetween(SEXP operand1, SEXP operand2)
+static int OpAtom(SEXP expr)
+{
+    int i;
+    for (i = 0; OpTable[i].code; i++)
+	if (NameMatch(expr, OpTable[i].name))
+	    return OpTable[i].code;
     return 0;
+}
-static double binGapAfter(SEXP afterOperand)
-{
-    return 0.2;
-}
-static BBOX spaceBBox(SEXP expr)
+static BBOX RenderOpSymbol(SEXP op, int draw)
-{
-    SEXP operator, operand1, operand2;
-    BBOX middleBBox;
-    operator = CAR(expr);
-    operand1 = CADR(expr);
-    setGapCEX();
-    if(length(expr) == 3) {
-	operand2 = CADDR(expr);
-	middleBBox = asciiBBox(' ');
-	return combineBBoxes(elementBBox(operand1),
-			     combineBBoxes(middleBBox,
-					   elementBBox(operand2)));
-    }
-    else error("invalid formula\n");
-}
-static void drawSpace(SEXP expr)
+{
-    SEXP operator, operand1, operand2;
-    operator = CAR(expr);
-    operand1 = CADR(expr);
-    setGapCEX();
+    BBOX bbox;
-    operand2 = CADDR(expr);
+    double cexSaved = MathDevice->gp.cex;
-    drawElement(operand1);
-    drawAscii(' ');
-    drawElement(operand2);
-}
-static BBOX binBBox(SEXP expr)
-{
-    SEXP operator, operand1, operand2;
-    BBOX middleBBox;
-    operator = CAR(expr);
+    double savedX = CurrentX;
-    operand1 = CADR(expr);
+    double savedY = CurrentY;
-    setGapCEX();
+    double shift;
-    if(length(expr) == 3) {
+    int opId = OpAtom(op);
-	operand2 = CADDR(expr);
-	if (multiplicationOperator(operator))
-	    middleBBox =
-		correctionBetweenBBox(operand1, operand2);
-	else
-	    middleBBox =
-		combineBBoxes(
-			      gapBBox(binGapBefore(operand1)),
-			      combineBBoxes(atomBBox(operator),
-					    gapBBox(binGapAfter(operand2))));
-	return combineBBoxes(elementBBox(operand1),
-			     combineBBoxes(middleBBox,
-					   elementBBox(operand2)));
-    }
-    else if(length(expr) == 2) {
+    if (opId == S_SUM || opId == S_PRODUCT) {
-	middleBBox = combineBBoxes(atomBBox(operator),
+	MathDevice->gp.cex = OperatorSymbolMag * MathDevice->gp.cex;
-				   smallgapBBox(binGapAfter(operand1)));
+	bbox = RenderSymbolChar(OpAtom(op), 0);
-	return combineBBoxes(middleBBox, elementBBox(operand1));
+	shift = 0.5 * (bboxHeight(bbox) - bboxDepth(bbox)) - TeX(sigma22);
-    }
+	if (draw) {
-    else error("invalid formula\n");
-}
-static void drawBin(SEXP expr)
-{
-    SEXP operator, operand1, operand2;
-    operator = CAR(expr);
-    operand1 = CADR(expr);
-    setGapCEX();
+	    MoveUp(-shift);
-    if(length(expr) == 3) {
-	operand2 = CADDR(expr);
-	drawElement(operand1);
-	if (multiplicationOperator(operator))
-	    drawGap(binGapBetween(operand1, operand2));
+	    bbox = RenderSymbolChar(OpAtom(op), 1);
-	else {
-	    drawGap(binGapBefore(operand1));
-	    drawAtom(operator);
+	    MoveUp(shift);
-	    drawGap(binGapAfter(operand2));
+	}
+	MathDevice->gp.cex = cexSaved;
-	drawElement(operand2);
+	return ShiftBBox(bbox, -shift);
+    }
     else {
-	drawAtom(operator);
+	FontType prevfont = SetFont(PlainFont);
-	drawSmallGap(binGapAfter(operand1));
+	bbox = RenderStr(CHAR(PRINTNAME(op)), draw);
-	drawElement(operand1);
+	SetFont(prevfont);
+	return bbox;
+    }
+}
-/* Code for superscript and subscript expressions */
-static BBOX supsubBBox(SEXP body, SEXP superscript, SEXP subscript);
-static BBOX superscriptBBox(SEXP superscript)
+static BBOX RenderOp(SEXP expr, int draw)
+{
-    BBOX result;
-    float cexSaved = mathDevice->gp.cex;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    result = elementBBox(superscript);
+    BBOX lowerBBox, upperBBox, bodyBBox;
-    mathDevice->gp.cex = cexSaved;
+    double savedX = CurrentX;
-    return result;
-}
-static BBOX supBBox(SEXP expr)
-{
-    SEXP body = CADR(expr);
+    double savedY = CurrentY;
-    SEXP superscript = CADDR(expr);
+    int nexpr = length(expr);
-    int supsub = 0;
-    if (formulaExpression(body))
-	if (subAtom(CAR(body)))
-	    supsub = 1;
-    if (supsub)
-	return supsubBBox(CADR(body), superscript, (CADDR(body)));
-    else
-	return combineBBoxes(elementBBox(body),
-			     combineBBoxes(correctionWithinBBox(body),
-					   shiftBBox(superscriptBBox(superscript),
-						     superscriptShift(body, superscript))));
-}
-static BBOX subscriptBBox(SEXP subscript)
-{
-    BBOX result;
-    float cexSaved = mathDevice->gp.cex;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    result = elementBBox(subscript);
-    mathDevice->gp.cex = cexSaved;
-    return result;
-}
-static BBOX subBBox(SEXP expr)
-{
-    SEXP body = CADR(expr);
+    STYLE style = GetStyle();
-    SEXP subscript = CADDR(expr);
+    BBOX opBBox = RenderOpSymbol(CAR(expr), 0);
-    return combineBBoxes(elementBBox(body),
+    double width = bboxWidth(opBBox);
-			 shiftBBox(subscriptBBox(subscript),
-				   subscriptShift(body, subscript, 1)));
-}
-static BBOX supsubBBox(SEXP body, SEXP superscript, SEXP subscript)
-{
-    double supShift, subShift;
+    double hshift, lvshift, uvshift;
-    supsubShift(body, superscript, subscript, &supShift, &subShift);
-    return combineBBoxes(elementBBox(body),
-	       combineAlignedBBoxes(
-	           combineBBoxes(correctionWithinBBox(body),
-			    shiftBBox(superscriptBBox(superscript), supShift)),
-		   shiftBBox(subscriptBBox(subscript), subShift)));
-}
-static void drawScriptElement(SEXP expr)
-{
-    float cexSaved = mathDevice->gp.cex;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    drawElement(expr);
+    if (nexpr > 2) {
-    mathDevice->gp.cex = cexSaved;
-}
-static void drawSupSub(SEXP body, SEXP superscript, SEXP subscript);
-static void drawSuper(SEXP expr)
-{
-    SEXP body = CADR(expr);
+	SetSubStyle(style);
-    SEXP superscript = CADDR(expr);
+	lowerBBox = RenderElement(CADDR(expr), 0);
-    double supShift = superscriptShift(body, superscript);
-    int supsub = 0;
+	SetStyle(style);
-    if (formulaExpression(body))
+	width = max(width, bboxWidth(lowerBBox));
-	if (subAtom(CAR(body)))
-	    supsub = 1;
-    if (supsub)
-	drawSupSub(CADR(body), superscript, CADDR(body));
+	lvshift = max(TeX(xi10), TeX(xi12) - bboxHeight(lowerBBox));
-    else {
-	drawElement(body);
-	drawCorrectionWithin(body);
-	moveUp(supShift);
-	drawScriptElement(superscript);
+	lvshift = bboxDepth(opBBox) + bboxHeight(lowerBBox) + lvshift;
-	moveUp(-supShift);
+    }
+    if (nexpr > 3) {
+	SetSupStyle(style);
+	upperBBox = RenderElement(CADDDR(expr), 0);
+	SetStyle(style);
+	width = max(width, bboxWidth(upperBBox));
+	uvshift = max(TeX(xi9), TeX(xi11) - bboxDepth(upperBBox));
+	uvshift = bboxHeight(opBBox) + bboxDepth(upperBBox) + uvshift;
+    }
+    hshift = 0.5 * (width - bboxWidth(opBBox));
+    opBBox = RenderGap(hshift, draw);
+    opBBox = CombineBBoxes(opBBox, RenderOpSymbol(CAR(expr), draw));
+    CurrentX = savedX;
+    CurrentY = savedY;
+    if (nexpr > 2) {
+	SetSubStyle(style);
+	hshift = 0.5 * (width - bboxWidth(lowerBBox));
+	lowerBBox = RenderOffsetElement(CADDR(expr), hshift, -lvshift, draw);
+	SetStyle(style);
+	opBBox = CombineAlignedBBoxes(opBBox, lowerBBox);
+	CurrentX = savedX;
+	CurrentY = savedY;
+    }
+    if (nexpr > 3) {
+	SetSupStyle(style);
+	hshift = 0.5 * (width - bboxWidth(upperBBox));
+	upperBBox = RenderOffsetElement(CADDDR(expr), hshift, uvshift, draw);
+	SetStyle(style);
+	opBBox = CombineAlignedBBoxes(opBBox, upperBBox);
+	CurrentX = savedX;
+	CurrentY = savedY;
+    }
+    opBBox = EnlargeBBox(opBBox, TeX(xi13), TeX(xi13), 0);
+    if (draw)
+	MoveAcross(width);
+    opBBox = CombineBBoxes(opBBox, RenderGap(ThinSpace(), draw));
+    bodyBBox = RenderElement(CADR(expr), draw);
+    return CombineBBoxes(opBBox, bodyBBox);
+}
-static void drawSub(SEXP expr)
-{
-    SEXP body = CADR(expr);
-    SEXP subscript = CADDR(expr);
-    double subShift = subscriptShift(body, subscript, 1);
-    drawElement(body);
-    moveUp(-subShift);
-    drawScriptElement(subscript);
-    moveUp(subShift);
-}
-static void drawSupSub(SEXP body, SEXP superscript, SEXP subscript)
-{
-    double supShift, subShift;
-    double savedX, savedY;
-    BBOX supBBox = elementBBox(superscript);
-    BBOX subBBox = elementBBox(subscript);
-    supsubShift(body, superscript, subscript, &supShift, &subShift);
+/*----------------------------------------------------------------------
-    drawElement(body);
-    savedX = currentX;
-    savedY = currentY;
+ *
-    drawCorrectionWithin(body);
+ *  Code for radical expressions (root, sqrt)
-    moveUp(supShift);
+ *
-    drawScriptElement(superscript);
+ *  Tunable parameteters :
-    moveTo(savedX, savedY);
-    moveUp(-subShift);
+ *
-    drawScriptElement(subscript);
+ *  RADICAL_GAP    The gap between the nucleus and the radical extension.
-    moveTo(savedX, savedY);
-    moveAcross(max(bboxWidth(supBBox), bboxWidth(subBBox)));
+ *  RADICAL_SPACE  Extra space to the left and right of the nucleus.
-}
+ *
+ */
-/* code for accented expressions (hat, bar, ...) */
+#define RADICAL_GAP    0.4
+#define RADICAL_SPACE  0.2
-static BBOX hatBBox(SEXP body)
+static int RadicalAtom(SEXP expr)
+{
-    BBOX bodyBBox = elementBBox(body);
-    return combineAlignedBBoxes(bodyBBox,
+    return NameAtom(expr) &&
-				makeBBox(bboxHeight(bodyBBox) +
+	(NameMatch(expr, "root") ||
-					 customAccentGap() +
-					 customHatHeight(), 0, 0));
+	 NameMatch(expr, "sqrt"));
+}
-static BBOX barBBox(SEXP body)
+static BBOX RenderScript(SEXP expr, int draw)
+{
+    BBOX bbox;
-    BBOX bodyBBox = elementBBox(body);
+    STYLE style = GetStyle();
-    return combineAlignedBBoxes(bodyBBox,
+    SetSupStyle(style);
-				makeBBox(bboxHeight(bodyBBox) +
+    bbox = RenderElement(expr, draw);
-					 customAccentGap(), 0, 0));
+    SetStyle(style);
+    return bbox;
+}
-static BBOX accentBBox(SEXP expr)
+static BBOX RenderRadical(SEXP expr, int draw)
+{
-    SEXP accent = CAR(expr);
     SEXP body = CADR(expr);
+    SEXP order = CADDR(expr);
+    BBOX bodyBBox, orderBBox, ansBBox;
+    double radWidth, radHeight, radDepth;
+    double leadWidth, leadHeight, twiddleHeight;
+    double hshift, vshift;
+    double radGap, radSpace, radTrail;
+    STYLE style = GetStyle();
+    double savedX = CurrentX;
+    double savedY = CurrentY;
+    double x[5], y[5];
+    radGap = RADICAL_GAP * xHeight();
+    radSpace = RADICAL_SPACE * xHeight();
-    if (hatAtom(accent))
+    radTrail = MuSpace();
-	return hatBBox(body);
+    SetPrimeStyle(style);
+    bodyBBox = RenderElement(body, 0);
+    bodyBBox = RenderItalicCorr(bodyBBox, 0);
+    radWidth = 0.6 *XHeight();
+    radHeight = bboxHeight(bodyBBox) + radGap;
+    radDepth = bboxDepth(bodyBBox);
+    twiddleHeight = CenterShift(bodyBBox);
-    else if (barAtom(accent))
+    leadWidth = radWidth;
+    leadHeight = radHeight;
+    if (order != R_NilValue) {
-	return barBBox(body);
+	SetSupStyle(style);
+	orderBBox = RenderScript(order, 0);
+	leadWidth = max(leadWidth, bboxWidth(orderBBox) + 0.4 * radWidth);
+	hshift = leadWidth - bboxWidth(orderBBox) - 0.4 * radWidth;
+	vshift = leadHeight - bboxHeight(orderBBox);
+	if (vshift - bboxDepth(orderBBox) < twiddleHeight + radGap)
+	    vshift = twiddleHeight + bboxDepth(orderBBox) + radGap;
+	if (draw) {
+	    MoveTo(savedX + hshift, savedY + vshift);
+	    orderBBox = RenderScript(order, draw);
+	}
+	orderBBox = EnlargeBBox(orderBBox, vshift, 0, hshift);
+    }
     else
-	return combineAlignedBBoxes(elementBBox(body),
+	orderBBox = NullBBox();
-		    combineBBoxes(makeBBox(accentHShift(body, accent), 0, 0),
-				  shiftBBox(asciiBBox(accentAscii(accent)),
-					    accentVShift(body))));
+    if (draw) {
-}
-static void drawHat(SEXP body)
-{
-    BBOX bodyBBox = elementBBox(body);
-    double width = bboxWidth(bodyBBox);
+	MoveTo(savedX + leadWidth - radWidth, savedY);
-    double savedX = currentX;
-    double savedY = currentY;
+	MoveUp(0.8 * twiddleHeight);
-    double x[3], y[3];
+	x[0] = ConvertedX();
-    moveUp(bboxHeight(bodyBBox) + customAccentGap());
-    x[0] = convertedX(); y[0] = convertedY();
+	y[0] = ConvertedY();
-    moveUp(customHatHeight());
+	MoveUp(0.2 * twiddleHeight);
-    moveAcross(width / 2);
+	MoveAcross(0.3 * radWidth);
-    x[1] = convertedX(); y[1] = convertedY();
+	x[1] = ConvertedX();
-    moveUp(-customHatHeight());
-    moveAcross(width / 2);
-    x[2] = convertedX(); y[2] = convertedY();
+	y[1] = ConvertedY();
-    GPolyline(3, x, y, INCHES, mathDevice);
+	MoveUp(-(twiddleHeight + bboxDepth(bodyBBox)));
-    moveTo(savedX, savedY);
+	MoveAcross(0.3 * radWidth);
-    drawElement(body);
+	x[2] = ConvertedX();
-}
-static void drawBar(SEXP body)
+	y[2] = ConvertedY();
-{
-    BBOX bodyBBox = elementBBox(body);
+	MoveUp(bboxDepth(bodyBBox) + bboxHeight(bodyBBox) + radGap);
-    double savedX = currentX;
+	MoveAcross(0.4 * radWidth);
-    double savedY = currentY;
+	x[3] = ConvertedX();
-    double x[2], y[2];
+	y[3] = ConvertedY();
-    moveUp(bboxHeight(bodyBBox) + customAccentGap());
+	MoveAcross(radSpace + bboxWidth(bodyBBox) + radTrail);
-    x[0] = convertedX(); y[0] = convertedY();
+	x[4] = ConvertedX();
-    moveAcross(bboxWidth(bodyBBox));
-    x[1] = convertedX(); y[1] = convertedY();
+	y[4] = ConvertedY();
-    GPolyline(2, x, y, INCHES, mathDevice);
+	GPolyline(5, x, y, INCHES, MathDevice);
-    moveTo(savedX, savedY);
-    drawElement(body);
-}
-static void drawAccent(SEXP expr)
-{
-    SEXP accent = CAR(expr);
-    SEXP body = CADR(expr);
-    double savedX = currentX;
-    double savedY = currentY;
-    if (hatAtom(accent))
-	drawHat(body);
-    else if (barAtom(accent))
-	drawBar(body);
-    else {
-	moveAcross(accentHShift(body, accent));
-	moveUp(accentVShift(body));
-	drawAscii(accentAscii(accent));
-	moveTo(savedX, savedY);
+	MoveTo(savedX, savedY);
-	drawElement(body);
+    }
+    orderBBox = CombineAlignedBBoxes(orderBBox,
+				     RenderGap(leadWidth + radSpace, draw));
+    SetPrimeStyle(style);
+    orderBBox = CombineBBoxes(orderBBox, RenderElement(body, draw));
+    orderBBox = CombineBBoxes(orderBBox, RenderGap(2 * radTrail, draw));
+    SetStyle(style);
+    return orderBBox;
+}
-/* Code for fraction expressions (over) */
+/*----------------------------------------------------------------------
-static BBOX fractionBBox(SEXP expr)
-{
+ *
-    SEXP numerator = CADR(expr);
-    SEXP denominator = CADDR(expr);
-    BBOX numBBox, denomBBox;
-    double numHShift, denomHShift;
-    float cexSaved = mathDevice->gp.cex;
-#ifdef OLD
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-#else
-    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
-#endif
-    numBBox = elementBBox(numerator);
-    denomBBox = elementBBox(denominator);
+ *  Code for Absolute Value Expressions (abs)
-#ifdef OLD
-    mathDevice->gp.cex = cexSaved;
-#else
-    mathDevice->gp.cex = cexSaved;
-#endif
-    numdenomHShift(numerator, denominator, &numHShift, &denomHShift);
+ *
-    return combineAlignedBBoxes(
-	      shiftBBox(combineBBoxes(makeBBox(numHShift, 0, 0), numBBox),
-			numeratorVShift(numerator)),
-	      shiftBBox(combineBBoxes(makeBBox(denomHShift, 0, 0), denomBBox),
-			-denominatorVShift(denominator)));
-}
+ */
-static void drawRatioElement(SEXP expr)
+static int AbsAtom(SEXP expr)
+{
-    float cexSaved = mathDevice->gp.cex;
+    return NameAtom(expr) && NameMatch(expr, "abs");
-    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
-    drawElement(expr);
-    mathDevice->gp.cex = cexSaved;
+}
-static void drawFraction(SEXP expr)
+static BBOX RenderAbs(SEXP expr, int draw)
+{
-    SEXP numerator = CADR(expr);
+    BBOX bbox = RenderElement(CADR(expr), 0);
-    SEXP denominator = CADDR(expr);
-    double savedX = currentX;
+    double height = bboxHeight(bbox);
-    double savedY = currentY;
+    double depth = bboxDepth(bbox);
-    double fWidth = fractionWidth(numerator, denominator);
-    double numHShift, denomHShift;
     double x[2], y[2];
-    numdenomHShift(numerator, denominator, &numHShift, &denomHShift);
+    bbox= RenderGap(MuSpace(), draw);
-    moveAcross(numHShift);
+    if (draw) {
-    moveUp(numeratorVShift(numerator));
+	MoveUp(-depth);
-#ifdef OLD
+	x[0] = ConvertedX();
-    drawScriptElement(numerator);
+	y[0] = ConvertedY();
-#else
+	MoveUp(depth + height);
-    drawRatioElement(numerator);
+	x[1] = ConvertedX();
-#endif
+	y[1] = ConvertedY();
-    moveTo(savedX, savedY);
+	GPolyline(2, x, y, INCHES, MathDevice);
-    moveUp(axisHeight());
+	MoveUp(-height);
+    }
-    x[0] = convertedX(); y[0] = convertedY();
+    bbox = CombineBBoxes(bbox, RenderGap(MuSpace(), draw));
-    moveAcross(fWidth);
+    bbox = CombineBBoxes(bbox, RenderElement(CADR(expr), draw));
-    x[1] = convertedX(); y[1] = convertedY();
+    bbox = RenderItalicCorr(bbox, draw);
-    GPolyline(2, x, y, INCHES, mathDevice);
+    bbox = CombineBBoxes(bbox, RenderGap(MuSpace(), draw));
-    moveTo(savedX, savedY);
+    if (draw) {
-    moveAcross(denomHShift);
+	MoveUp(-depth);
-    moveUp(-denominatorVShift(denominator));
+	x[0] = ConvertedX();
-#ifdef OLD
+	y[0] = ConvertedY();
-    drawScriptElement(denominator);
+	MoveUp(depth + height);
+	x[1] = ConvertedX();
-#else
+	y[1] = ConvertedY();
-    drawRatioElement(denominator);
+	GPolyline(2, x, y, INCHES, MathDevice);
+	MoveUp(-height);
-#endif
+    }
-    moveTo(savedX + fWidth, savedY);
+    bbox = CombineBBoxes(bbox, RenderGap(MuSpace(), draw));
+    return bbox;
+}
+/*----------------------------------------------------------------------
+ *
-/* code for group expressions (expressions within parentheses) */
+ *  Code for Grouped Expressions (i.e. { ... } )
+ *
+ */
-static BBOX groupBBox(SEXP expr)
+static int CurlyAtom(SEXP expr)
+{
-    return combineBBoxes(
+    return NameAtom(expr) &&
-	      asciiBBox(groupOpenAscii()),
+	NameMatch(expr, "{");
-	      combineBBoxes(elementBBox(CADR(expr)),
-			    combineBBoxes(correctionWithinBBox(CADR(expr)),
-					  asciiBBox(groupCloseAscii()))));
+}
-static void drawGroup(SEXP expr)
+static BBOX RenderCurly(SEXP expr, int draw)
+{
-    drawAscii(groupOpenAscii());
-    drawElement(CADR(expr));
+    return RenderElement(CADR(expr), draw);
-    drawCorrectionWithin(CADR(expr));
-    drawAscii(groupCloseAscii());
+}
-/* code for operator expressions (sum, product, integral) */
-/* NOTE that gaps are specified as proportions of the current font height */
+/*----------------------------------------------------------------------
+ *
-static double operatorGap(SEXP body)
+ *  Code for Relation Expressions (i.e. ... ==, !=, ...)
-{
+ *
-    return 0.1;
-}
+ */
-static double integralTopShift() { return 0.5 * fontHeight(); }
+                                /* Binary Relationships */
+SymTab RelTable[] = {
+    "<",                 60,    /* less */
+    "==",                61,    /* equal */
+    ">",                 62,    /* greater */
+    "%=~%",              64,    /* congruent */
+    "!=",               185,    /* not equal */
+    "<=",               163,    /* less or equal */
-static double integralBottomShift() { return -0.5 * fontHeight(); }
+    ">=",               179,    /* greater or equal */
+    "%==%",             186,    /* equivalence */
+    "%~~%",             187,    /* approxequal */
-static BBOX theOperatorBBox(SEXP operator)
+    "%<->%",            171,    /* Arrows */
-{
-    if (integralOperator(operator))
+    "%<-%",             172,
-	return combineAlignedBBoxes(
+    "%up%",             173,
-		  shiftBBox(asciiBBox(integralAscii(1)), integralTopShift()),
+    "%->%",             174,
-		  combineAlignedBBoxes(asciiBBox(integralAscii(2)),
+    "%down%",           175,
-				       shiftBBox(asciiBBox(integralAscii(3)),
+    "%<=>%",            219,
-						 integralBottomShift())));
+    "%<=%",             220,
-    else
+    "%dblup%",          221,
+    "%=>%",             222,
-	return asciiBBox(operatorAscii(operator));
+    "%dbldown%",        223,
-}
+    "%supset%",         201,    /* Sets (TeX Names) */
+    "%supseteq%",       202,
-static int useRelGap = 1;
+    "%notsubset%",      203,
+    "%subset%",         204,
+    "%subseteq%",       205,
+    "%in%",             206,
+    "%notin%",          207,
-static BBOX operatorLimitBBox(SEXP limit)
-{
-    float cexSaved = mathDevice->gp.cex;
-    BBOX limitBBox;
-    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-    useRelGap = 0;
-    limitBBox = elementBBox(limit);
-    useRelGap = 1;
-    mathDevice->gp.cex = cexSaved;
-    return limitBBox;
-}
-static BBOX operatorBBox(SEXP expr)
-{
-    SEXP operator = CAR(expr);
-    SEXP body, lower, upper;
-    BBOX opBBox = theOperatorBBox(operator);
-    BBOX bodyBBox, lowerBBox, upperBBox;
-    setGapCEX();
-    if (length(expr) > 1) {
-	body = CADR(expr);
-	bodyBBox = combineBBoxes(
-		      opBBox,
-		      combineBBoxes(gapBBox(operatorGap(body)),
-				    elementBBox(body)));
-	if (length(expr) > 2) {
-	    lower = CADDR(expr);
-	    lowerBBox = operatorLimitBBox(lower);
-	    if (length(expr) > 3) {
-		upper = CADDDR(expr);
-		upperBBox = operatorLimitBBox(upper);
-		return combineAlignedBBoxes(
-			 combineBBoxes(
-			   makeBBox(
-			     operatorHShiftAll(operator,lower, upper),
-, 0),
-			   bodyBBox),
-			 combineAlignedBBoxes(
-			   shiftBBox(
-                             combineBBoxes(
-			       makeBBox(
-                                 operatorUpperHShiftAll(
-				   operator,lower, upper),
-, 0),
-			       upperBBox),
-			     operatorUpperShift(operator, upper)),
-			   shiftBBox(
-                             combineBBoxes(
+    NULL,                0,
-			       makeBBox(
-				 operatorLowerHShiftAll(
-				   operator, lower, upper),
-, 0),
-			       lowerBBox),
-			     operatorLowerShift(operator, lower))));
-	    }
-	    else
-		return combineAlignedBBoxes(
-			 combineBBoxes(
-			   makeBBox(
-			     operatorHShift(operator, lower), 0, 0),
-			   bodyBBox),
-			 shiftBBox(
-			   combineBBoxes(
-			     makeBBox(operatorLowerHShift(operator, lower),
-, 0),
-			     lowerBBox),
-			   operatorLowerShift(operator, lower)));
-	}
-	else
-	    return bodyBBox;
-    }
-    else
-	error("Invalid Formula\n");
-}
+};
-static void drawTheOperator(SEXP operator)
+static int RelAtom(SEXP expr)
+{
-    if (integralOperator(operator)) {
-	double savedX = currentX;
-	double savedY = currentY;
+    int i;
-	moveUp(integralTopShift());
-	drawAscii(integralAscii(1));
-	moveTo(savedX, savedY);
-	moveUp(integralBottomShift());
+    for (i = 0; RelTable[i].code; i++)
-	drawAscii(integralAscii(3));
+	if (NameMatch(expr, RelTable[i].name))
-	moveTo(savedX, savedY);
-	drawAscii(integralAscii(2));
+	    return RelTable[i].code;
-    }
-    else
+    return 0;
-	drawAscii(operatorAscii(operator));
+}
-static void drawOperatorLimit(SEXP limit)
+static BBOX RenderRel(SEXP expr, int draw)
+{
-    useRelGap = 0;
+    int op = RelAtom(CAR(expr));
-    drawScriptElement(limit);
+    int nexpr = length(expr);
+    BBOX bbox;
-    useRelGap = 1;
+    double gap;
-}
-static void drawOperator(SEXP expr)
-{
-    SEXP operator = CAR(expr);
-    SEXP body = CADR(expr);
-    SEXP lower, upper;
-    double savedX = currentX;
-    double savedY = currentY;
-    setGapCEX();
-    if (length(expr) > 2) {
+    if(nexpr == 3) {
-	lower = CADDR(expr);
-	if (length(expr) > 3) {
-	    upper = CADDDR(expr);
-	    moveUp(operatorUpperShift(operator, upper));
+	gap = (CurrentStyle > STYLE_S) ? ThickSpace() : 0;
-	    moveAcross(operatorUpperHShiftAll(operator, lower, upper));
-	    drawOperatorLimit(upper);
+	bbox = RenderElement(CADR(expr), draw);
-	    moveTo(savedX, savedY);
-	    moveUp(-operatorLowerShift(operator, lower));
-	    moveAcross(operatorLowerHShiftAll(operator, lower, upper));
-	    drawOperatorLimit(lower);
+	bbox = RenderItalicCorr(bbox, draw);
-	    moveTo(savedX, savedY);
-	    moveAcross(operatorHShiftAll(operator, lower, upper));
+	bbox = CombineBBoxes(bbox, RenderGap(gap, draw));
-	}
-	else{
-	    moveUp(-operatorLowerShift(operator, lower));
+	bbox = CombineBBoxes(bbox, RenderSymbolChar(op, draw));
-	    moveAcross(operatorLowerHShift(operator, lower));
+	bbox = CombineBBoxes(bbox, RenderGap(gap, draw));
-	    drawOperatorLimit(lower);
-	    moveTo(savedX, savedY);
-	    moveAcross(operatorHShift(operator, lower));
+	return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw));
-	}
+    }
-    drawTheOperator(operator);
+    else error("invalid mathematical annotation\n");
-    drawGap(operatorGap(body));
-    drawElement(body);
+}
-/* Code for radical expressions (root) */
-static BBOX customRadicalBBox(SEXP body)
-{
-    BBOX bodyBBox = elementBBox(body);
-    return combineBBoxes(makeBBox(bboxHeight(bodyBBox) + customRadicalGap(),
-, customRadicalWidth()),
-			 combineBBoxes(makeBBox(0, 0, customRadicalSpace()),
-				       bodyBBox));
-}
-static BBOX radicalBBox(SEXP expr)
+/*----------------------------------------------------------------------
-{
+ *
-    SEXP body = CADR(expr);
+ *  Code for Boldface Expressions
-    return customRadicalBBox(body);
-}
+ *
+ */
-static void drawCustomRadical(SEXP body)
+static int BoldAtom(SEXP expr)
+{
-    BBOX bodyBBox = elementBBox(body);
-    double height = bboxHeight(bodyBBox);
-    double depth = bboxDepth(bodyBBox);
-    double width = bboxWidth(bodyBBox);
-    double twiddleHeight = (height - depth) / 2;
-    double savedX = currentX;
-    double savedY = currentY;
+    return NameAtom(expr) &&
-    double x[5], y[5];
-    moveUp(0.8 * twiddleHeight);
-    x[0] = convertedX(); y[0] = convertedY();
-    moveUp(0.2 * twiddleHeight);
-    moveAcross(0.3 * customRadicalWidth());
-    x[1] = convertedX(); y[1] = convertedY();
-    moveUp(-(twiddleHeight + depth));
-    moveAcross(0.3 * customRadicalWidth());
-    x[2] = convertedX(); y[2] = convertedY();
-    moveUp(depth + height + customRadicalGap());
-    moveAcross(0.4 * customRadicalWidth());
-    x[3] = convertedX(); y[3] = convertedY();
-    moveAcross(customRadicalSpace() + width);
-    x[4] = convertedX(); y[4] = convertedY();
-    GPolyline(5, x, y, INCHES, mathDevice);
-    moveTo(savedX, savedY);
-    moveAcross(customRadicalWidth() + customRadicalSpace());
-    drawElement(body);
+	NameMatch(expr, "bold");
+}
-static void drawRadical(SEXP expr)
+static BBOX RenderBold(SEXP expr, int draw)
+{
+    BBOX bbox;
+    FontType prevfont = SetFont(BoldFont);
-    SEXP body = CADR(expr);
+    bbox = RenderElement(CADR(expr), draw);
-    drawCustomRadical(body);
+    SetFont(prevfont);
+    return bbox;
+}
+/*----------------------------------------------------------------------
+ *
-/* Code for absolute expressions (abs). */
+ *  Code for Italic Expressions
+ *
+ */
-static BBOX absBBox(SEXP expr)
+static int ItalicAtom(SEXP expr)
+{
-    SEXP body = CADR(expr);
+    return NameAtom(expr) &&
-    return combineBBoxes(makeBBox(0, 0, absSpace()),
+	(NameMatch(expr, "italic") || NameMatch(expr, "math"));
-			 combineBBoxes(elementBBox(body),
-				       makeBBox(0, 0, absSpace())));
+}
-static void drawAbs(SEXP expr)
+static BBOX RenderItalic(SEXP expr, int draw)
+{
-    SEXP body = CADR(expr);
+    BBOX bbox;
-    BBOX bodyBBox = elementBBox(expr);
-    double height = bboxHeight(bodyBBox);
+    FontType prevfont = SetFont(ItalicFont);
-    double depth = bboxDepth(bodyBBox);
-    double x[2], y[2];
-    moveUp(-depth);
-    x[0] = convertedX(); y[0] = convertedY();
-    moveUp(depth + height);
-    x[1] = convertedX(); y[1] = convertedY();
+    bbox = RenderElement(CADR(expr), draw);
-    GPolyline(2, x, y, INCHES, mathDevice);
-    moveUp(-height);
+    SetFont(prevfont);
-    moveAcross(absSpace());
-    drawElement(body);
+    return bbox;
-    moveAcross(absSpace());
-    moveUp(-depth);
-    x[0] = convertedX(); y[0] = convertedY();
-    moveUp(depth + height);
-    x[1] = convertedX(); y[1] = convertedY();
-    GPolyline(2, x, y, INCHES, mathDevice);
-    moveUp(-height);
+}
-/* Code for general expressions with no special meaning */
+/*----------------------------------------------------------------------
+ *
-/* in mathematical notation syntax (e.g., f(x)) */
+ *  Code for Plain (i.e. Roman) Expressions
+ *
+ */
-static BBOX expressionBBox(SEXP expr)
+static int PlainAtom(SEXP expr)
+{
-    int i;
-    int numParams = length(expr) - 1;
-    BBOX resultBBox = elementBBox(CAR(expr));
-    SEXP lastTerm;
-    lastTerm = CAR(expr);
+    return NameAtom(expr) &&
-    expr = CDR(expr);
-    resultBBox = combineBBoxes(resultBBox, asciiBBox(groupOpenAscii()));
-    for (i = 0; i < numParams; i++) {
-	resultBBox = combineBBoxes(resultBBox, elementBBox(CAR(expr)));
-	lastTerm = CAR(expr);
+	NameMatch(expr, "plain");
-	expr = CDR(expr);
-	if (i < numParams - 1)
-	    resultBBox = combineBBoxes(resultBBox,
-				       combineBBoxes(asciiBBox(commaAscii()),
-						     asciiBBox(spaceAscii())));
-    }
-    return combineBBoxes(resultBBox,
-			 combineBBoxes(correctionWithinBBox(lastTerm),
-				       asciiBBox(groupCloseAscii())));
+}
-static void drawExpression(SEXP expr)
+static BBOX RenderPlain(SEXP expr, int draw)
+{
-    int i;
+    BBOX bbox;
-    int numParams = length(expr) - 1;
+    int prevfont = SetFont(PlainFont);
-    SEXP lastTerm;
-    drawElement(CAR(expr));
+    bbox = RenderElement(CADR(expr), draw);
-    lastTerm = CAR(expr);
+    SetFont(prevfont);
-    expr = CDR(expr);
+    return bbox;
-    drawAscii(groupOpenAscii());
-    for (i = 0; i < numParams; i++) {
-	drawElement(CAR(expr));
-	lastTerm = CAR(expr);
-	expr = CDR(expr);
-	if (i < numParams - 1) {
-	    drawAscii(commaAscii());
-	    drawAscii(spaceAscii());
-	}
-    }
-    drawCorrectionWithin(lastTerm);
-    drawAscii(groupCloseAscii());
+}
+/*----------------------------------------------------------------------
+ *
-/* Code for curly expressions (i.e., { ... } ) */
+ *  Code for Bold Italic Expressions
+ *
+ */
-static BBOX curlyBBox(SEXP expr)
+static int BoldItalicAtom(SEXP expr)
+{
-    return expressionBBox(CADR(expr));
+    return NameAtom(expr) &&
+	(NameMatch(expr, "bolditalic") || NameMatch(expr, "boldmath"));
+}
-static void drawFormula(SEXP);
-static void drawCurly(SEXP expr)
+static BBOX RenderBoldItalic(SEXP expr, int draw)
+{
+    BBOX bbox;
+    int prevfont = SetFont(BoldItalicFont);
-    drawFormula(CADR(expr));
+    bbox = RenderElement(CADR(expr), draw);
+    SetFont(prevfont);
+    return bbox;
+}
-/* code for relation expressions (i.e. ... == ...) */
+/*----------------------------------------------------------------------
+ *
-static double relGap()
+ *  Code for Styles
-{
+ *
-    if (useRelGap)
-	return 0.3;
-    else
-	return 0.1;
-}
+ */
-static BBOX relBBox(SEXP expr)
+static int StyleAtom(SEXP expr)
+{
-    SEXP op = CAR(expr);
-    SEXP arg1 = CADR(expr);
-    SEXP arg2 = CADDR(expr);
-    return combineBBoxes(
+    return (NameAtom(expr) &&
-	      elementBBox(arg1),
+	    (NameMatch(expr, "displaystyle") ||
-	      combineBBoxes(
-	         gapBBox(relGap()),
+	     NameMatch(expr, "textstyle")    ||
-	         combineBBoxes(
-		    asciiBBox(relAscii(op)),
+	     NameMatch(expr, "scriptstyle")   ||
-		    combineBBoxes(
-		       gapBBox(relGap()),
-		       elementBBox(arg2)))));
+	     NameMatch(expr, "scriptscriptstyle")));
+}
-static void drawRel(SEXP expr)
+static BBOX RenderStyle(SEXP expr, int draw)
+{
-    SEXP op = CAR(expr);
+    STYLE prevstyle = GetStyle();
+    BBOX bbox;
-    SEXP arg1 = CADR(expr);
+    if (NameMatch(CAR(expr), "displaystyle"))
+	SetStyle(STYLE_D);
-    SEXP arg2 = CADDR(expr);
+    else if (NameMatch(CAR(expr), "textstyle"))
+	SetStyle(STYLE_T);
+    else if (NameMatch(CAR(expr), "scriptstyle"))
-    drawElement(arg1);
+	SetStyle(STYLE_S);
+    else if (NameMatch(CAR(expr), "scriptscriptstyle"))
-    drawGap(relGap());
+	SetStyle(STYLE_SS);
-    drawAscii(relAscii(op));
+    bbox = RenderElement(CADR(expr), draw);
-    drawGap(relGap());
+    SetStyle(prevstyle);
-    drawElement(arg2);
+    return bbox;
+}
+/*----------------------------------------------------------------------
+ *
-/* code for bold expressions */
+ *  Code for Phantom Expressions
+ *
+ */
-static BBOX boldBBox(SEXP expr)
+static int PhantomAtom(SEXP expr)
+{
-    BBOX result;
-    int savedFont = getFont();
-    boldFont();
-    result = elementBBox(CADR(expr));
+    return (NameAtom(expr) &&
-    setFont(savedFont);
+	    (NameMatch(expr, "phantom") ||
-    return result;
+	     NameMatch(expr, "vphantom")));
+}
-static void drawBold(SEXP expr)
+static BBOX RenderPhantom(SEXP expr, int draw)
+{
+    BBOX bbox = RenderElement(CADR(expr), 0);
-    int savedFont = getFont();
+    if (NameMatch(CAR(expr), "vphantom")) {
-    boldFont();
+	bboxWidth(bbox) = 0;
+	bboxItalic(bbox) = 0;
+    }
-    drawElement(CADR(expr));
+    else RenderGap(bboxWidth(bbox), 0);
-    setFont(savedFont);
+    return bbox;
+}
-/* code for italic expressions */
+/*----------------------------------------------------------------------
-static BBOX italicBBox(SEXP expr)
-{
+ *
-    BBOX result;
-    SEXP body = CADR(expr);
-    int savedFont = getFont();
-    italicFont();
-    result = elementBBox(body);
+ *  Code for Concatenate Expressions
-    setFont(savedFont);
+ *
-    return result;
-}
+ */
-static void drawItalic(SEXP expr)
+static int ConcatenateAtom(SEXP expr)
+{
-    SEXP body = CADR(expr);
-    int savedFont = getFont();
+    return NameAtom(expr) && NameMatch(expr, "paste");
-    italicFont();
-    drawElement(body);
-    setFont(savedFont);
+}
-/* code for plain expressions */
-static BBOX plainBBox(SEXP expr)
+static BBOX RenderConcatenate(SEXP expr, int draw)
+{
-    BBOX result = nullBBox();
+    BBOX bbox;
-    int savedFont = getFont();
-    plainFont();
+    int i, n;
-    result = elementBBox(CADR(expr));
-    setFont(savedFont);
-    return result;
-}
-static void drawPlain(SEXP expr)
+    expr = CDR(expr);
-{
-    int savedFont = getFont();
+    n = length(expr);
+    for (i = 0; i < n; i++) {
+	bbox = CombineBBoxes(bbox, RenderElement(CAR(expr), draw));
-    plainFont();
+	if (i != n - 1)
+	    bbox = RenderItalicCorr(bbox, draw);
-    drawElement(CADR(expr));
+	expr = CDR(expr);
+    }
-    setFont(savedFont);
+    return bbox;
+}
+/*----------------------------------------------------------------------
+ *
-/* code for bolditalic expressions */
+ *  Code for Comma-Separated Lists
+ *
+ */
-static BBOX boldItalicBBox(SEXP expr)
+static BBOX RenderCommaList(SEXP expr, int draw)
+{
+    BBOX bbox = NullBBox();
+    double small = 0.4 * ThinSpace();
-    BBOX result;
+    int i, n;
-    int savedFont = getFont();
+    n = length(expr);
+    for (i = 0; i < n; i++) {
+	if (NameAtom(CAR(expr)) && NameMatch(CAR(expr), "...")) {
+	    if (i > 0) {
+		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_COMMA, draw));
+#ifdef OLD
+		bbox = CombineBBoxes(bbox, RenderGap(small, draw));
+#else
+		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_SPACE, draw));
+#endif
+	    }
+	    bbox = CombineBBoxes(bbox, RenderSymbolChar(S_ELLIPSIS, draw));
+	    bbox = CombineBBoxes(bbox, RenderGap(small, draw));
+	}
+	else {
-    boldItalicFont();
+	    if (i > 0) {
-    result = elementBBox(CADR(expr));
+		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_COMMA, draw));
+		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_SPACE, draw));
+	    }
-    setFont(savedFont);
+	    bbox = CombineBBoxes(bbox, RenderElement(CAR(expr), draw));
+	}
+	expr = CDR(expr);
+    }
-    return result;
+    return bbox;
+}
-static void drawBoldItalic(SEXP expr)
+/*----------------------------------------------------------------------
-{
+ *
-    int savedFont = getFont();
+ *  Code for General Expressions
+ *
+ */
+static BBOX RenderExpression(SEXP expr, int draw)
+{
-    boldItalicFont();
+    BBOX bbox;
-    drawElement(CADR(expr));
+    if (NameAtom(CAR(expr)))
+	bbox = RenderSymbolString(CAR(expr), draw);
+    else
+	bbox = RenderElement(CAR(expr), draw);
+    bbox = RenderItalicCorr(bbox, draw);
+    bbox = CombineBBoxes(bbox, RenderSymbolChar(S_PARENLEFT, draw));
+    bbox = CombineBBoxes(bbox, RenderCommaList(CDR(expr), draw));
+    bbox = RenderItalicCorr(bbox, draw);
+    bbox = CombineBBoxes(bbox, RenderSymbolChar(S_PARENRIGHT, draw));
-    setFont(savedFont);
+    return bbox;
+}
+/*----------------------------------------------------------------------
+ *
-/* code for concatenating expressions paste(...) */
+ *  Code for Comma Separated List Expressions
+ *
+ */
-static BBOX concatenateBBox(SEXP expr)
+static int ListAtom(SEXP expr)
+{
-    SEXP args = CDR(expr);
-    SEXP lastArg;
-    int i;
-    int numArgs = length(args);
+    return NameAtom(expr) && NameMatch(expr, "list");
-    BBOX result = nullBBox();
-    if (numArgs > 0)
-	result = elementBBox(CAR(args));
-    lastArg = CAR(args);
-    args = CDR(args);
-    for (i = 1; i < numArgs; i++) {
-	result = combineBBoxes(result,
-		    combineBBoxes(
-		       correctionBetweenBBox(lastArg, CAR(args)),
-		       elementBBox(CAR(args))));
-	lastArg = CAR(args);
-	args = CDR(args);
-    }
-    return result;
+}
-static void drawConcatenate(SEXP expr)
+static BBOX RenderList(SEXP expr, int draw)
+{
-    SEXP args = CDR(expr);
-    SEXP lastArg;
-    int i;
+    BBOX bbox;
-    int numArgs = length(args);
-    for (i = 0; i < numArgs; i++) {
-	if (i > 0)
-	    drawCorrectionBetween(lastArg, CAR(args));
+    return RenderCommaList(CDR(expr), draw);
-	drawElement(CAR(args));
-	lastArg = CAR(args);
-	args = CDR(args);
-    }
+}
 /* Dispatching procedure which determines nature of expression. */
-static BBOX formulaBBox(SEXP expr)
+static BBOX RenderFormula(SEXP expr, int draw)
+{
     SEXP head = CAR(expr);
-    if (spaceAtom(head))
+    if (SpaceAtom(head))
-	return spaceBBox(expr);
+	return RenderSpace(expr, draw);
-    else if (binAtom(head))
+    else if (BinAtom(head))
-	return binBBox(expr);
+	return RenderBin(expr, draw);
-    else if (superAtom(head))
+    else if (SuperAtom(head))
-	return supBBox(expr);
+	return RenderSup(expr, draw);
-    else if (subAtom(head))
+    else if (SubAtom(head))
+	return RenderSub(expr, draw);
+    else if (WideTildeAtom(head))
+	return RenderWideTilde(expr, draw);
+    else if (WideHatAtom(head))
+	return RenderWideHat(expr, draw);
+    else if (BarAtom(head))
-	return subBBox(expr);
+	return RenderBar(expr, draw);
-    else if (accentAtom(head))
+    else if (AccentAtom(head))
+	return RenderAccent(expr, draw);
+    else if (OverAtom(head))
+	return RenderOver(expr, draw);
+    else if (AtopAtom(head))
-	return accentBBox(expr);
+	return RenderAtop(expr, draw);
-    else if (fractionAtom(head))
+    else if (ParenAtom(head))
-	return fractionBBox(expr);
+	return RenderParen(expr, draw);
-    else if (groupAtom(head))
+    else if (BGroupAtom(head))
-	return groupBBox(expr);
+	return RenderBGroup(expr, draw);
-    else if (operatorAtom(head))
+    else if (GroupAtom(head))
-	return operatorBBox(expr);
+	return RenderGroup(expr, draw);
+    else if (IntAtom(head))
+       	return RenderInt(expr, draw);
+    else if (OpAtom(head))
+	return RenderOp(expr, draw);
-    else if (radicalAtom(head))
+    else if (RadicalAtom(head))
-	return radicalBBox(expr);
+	return RenderRadical(expr, draw);
-    else if (absAtom(head))
+    else if (AbsAtom(head))
-	return absBBox(expr);
+	return RenderAbs(expr, draw);
-    else if (curlyAtom(head))
+    else if (CurlyAtom(head))
-	return curlyBBox(expr);
+	return RenderCurly(expr, draw);
-    else if (relAtom(head))
+    else if (RelAtom(head))
-	return relBBox(expr);
+	return RenderRel(expr, draw);
-    else if (boldAtom(head))
+    else if (BoldAtom(head))
-	return boldBBox(expr);
+	return RenderBold(expr, draw);
-    else if (italicAtom(head))
+    else if (ItalicAtom(head))
-	return italicBBox(expr);
+	return RenderItalic(expr, draw);
-    else if (plainAtom(head))
+    else if (PlainAtom(head))
-	return plainBBox(expr);
+	return RenderPlain(expr, draw);
-    else if (boldItalicAtom(head))
+    else if (BoldItalicAtom(head))
-	return boldItalicBBox(expr);
+	return RenderBoldItalic(expr, draw);
+    else if (StyleAtom(head))
+	return RenderStyle(expr, draw);
+    else if (PhantomAtom(head))
+	return RenderPhantom(expr, draw);
-    else if (concatenateAtom(head))
+    else if (ConcatenateAtom(head))
-	return concatenateBBox(expr);
+	return RenderConcatenate(expr, draw);
+    else if (ListAtom(head))
+	return RenderList(expr, draw);
     else
-	return expressionBBox(expr);
+	return RenderExpression(expr, draw);
+}
-static void drawFormula(SEXP expr)
-{
-    SEXP head = CAR(expr);
-    if (spaceAtom(head))
-	drawSpace(expr);
-    else if (binAtom(head))
-	drawBin(expr);
-    else if (superAtom(head))
-	drawSuper(expr);
-    else if (subAtom(head))
-	drawSub(expr);
-    else if (accentAtom(head))
-	drawAccent(expr);
-    else if (fractionAtom(head))
-	drawFraction(expr);
-    else if (groupAtom(head))
-	drawGroup(expr);
-    else if (operatorAtom(head))
-	drawOperator(expr);
-    else if (radicalAtom(head))
-	drawRadical(expr);
-    else if (absAtom(head))
-	drawAbs(expr);
-    else if (curlyAtom(head))
-	drawCurly(expr);
-    else if (relAtom(head))
-	drawRel(expr);
-    else if (boldAtom(head))
-	drawBold(expr);
-    else if (italicAtom(head))
-	drawItalic(expr);
-    else if (plainAtom(head))
-	drawPlain(expr);
-    else if (boldItalicAtom(head))
-	drawBoldItalic(expr);
-    else if (concatenateAtom(head))
-	drawConcatenate(expr);
-    /* if expression is not a special mathematical notation */
+/* Dispatch on whether atom (symbol, string, number, ...) */
-    /* function then just reconstruct expression */
+/* or formula (some sort of expression) */
+static BBOX RenderElement(SEXP expr, int draw)
+{
+    if (FormulaExpression(expr))
+	return RenderFormula(expr, draw);
     else
-	drawExpression(expr);
+	return RenderAtom(expr, draw);
+}
-/* top-level:  dispatch on whether atom (symbol, string, number, ...) */
-/* or formula (some sort of expression) */
-static BBOX elementBBox(SEXP expr)
+static BBOX RenderOffsetElement(SEXP expr, double x, double y, int draw)
+{
+    BBOX bbox;
-    if (formulaExpression(expr))
+    double savedX = CurrentX;
-	return formulaBBox(expr);
+    double savedY = CurrentY;
+    if (draw) {
+	CurrentX += x;
+	CurrentY += y;
-    else
+    }
+    bbox = RenderElement(expr, draw);
+    bboxWidth(bbox) += x;
+    bboxHeight(bbox) += y;
+    bboxDepth(bbox) -= y;
+    CurrentX = savedX;
+    CurrentY = savedY;
-	return atomBBox(expr);
+    return bbox;
+}
-static void drawElement(SEXP expr)
+/* Calculate width of expression */
+/* BBOXes are in INCHES (see MetricUnit) */
+void GExpressionBBox(SEXP expr, int units, double *width,
+		     double *height, double *depth, DevDesc *dd)
+{
-    if (formulaExpression(expr))
+    BBOX bbox = RenderElement(expr, 0);
-	drawFormula(expr);
+    *width  = bboxWidth(bbox);
+    *height  = bboxHeight(bbox);
+    *depth  = bboxDepth(bbox);
+    if (units != INCHES) {
+	*width = GConvertXUnits(*width, INCHES, units, dd);
+	*height = GConvertYUnits(*height, INCHES, units, dd);
+	*depth = GConvertYUnits(*depth, INCHES, units, dd);
-    else
+    }
-	drawAtom(expr);
+}
-        /* calculate width of expression */
-        /* BBOXes are in INCHES (see metricUnit) */
 double GExpressionWidth(SEXP expr, int units, DevDesc *dd)
+{
-    BBOX exprBBox = elementBBox(expr);
+    BBOX bbox = RenderElement(expr, 0);
-    double w  = exprBBox.width;
+    double width  = bboxWidth(bbox);
     if (units == INCHES)
-	return w;
+	return width;
     else
-	return GConvertXUnits(w, INCHES, units, dd);
+	return GConvertXUnits(width, INCHES, units, dd);
+}
-#define ABS(a)  ((a)>=0 ? (a) : -(a))
 double GExpressionHeight(SEXP expr, int units, DevDesc *dd)
+{
-    BBOX exprBBox = elementBBox(expr);
+    BBOX bbox = RenderElement(expr, 0);
-    double h = exprBBox.height + exprBBox.depth;
+    double height = bboxHeight(bbox) + bboxDepth(bbox);
     if (units == INCHES)
-	return h;
+	return height;
     else
-	return GConvertYUnits(h, INCHES, units, dd);
+	return GConvertYUnits(height, INCHES, units, dd);
+}
-/* Functions forming the API */
+/* Functions forming the R API */
 void GMathText(double x, double y, int coords, SEXP expr,
 	       double xc, double yc, double rot, DevDesc *dd)
+{
-    BBOX expressionBBox;
+    BBOX bbox;
-    mathDevice = dd;
+    MathDevice = dd;
+    BaseCex = MathDevice->gp.cex;
+    BoxColor = name2col("pink");
+    TextColor = MathDevice->gp.col;
+    CurrentStyle = STYLE_D;
+#ifdef OLD
+    /* SetFont(ItalicFont); */
+#endif
-    expressionBBox = elementBBox(expr);
+    bbox = RenderElement(expr, 0);
-    referenceX = x;
+    ReferenceX = x;
-    referenceY = y;
+    ReferenceY = y;
-    GConvert(&referenceX, &referenceY, coords, INCHES, dd);
+    GConvert(&ReferenceX, &ReferenceY, coords, INCHES, dd);
+    if (FINITE(xc))
-    currentX = referenceX - xc * bboxWidth(expressionBBox);
+	CurrentX = ReferenceX - xc * bboxWidth(bbox);
+    else
+	CurrentX = ReferenceX;
+    if (FINITE(yc))
-    currentY = referenceY - yc * bboxHeight(expressionBBox);
+	CurrentY = ReferenceY + bboxDepth(bbox)
+	    - yc * (bboxHeight(bbox) + bboxDepth(bbox));
+    else
+	CurrentY = ReferenceY;
-    currentAngle = rot;
+    CurrentAngle = rot;
-    cosAngle = cos(rot / 90 * half_pi);
+    CosAngle = cos(rot / 90 * HalfPi);
-    sinAngle = sin(rot / 90 * half_pi);
+    SinAngle = sin(rot / 90 * HalfPi);
-    drawElement(expr);
+    RenderElement(expr, 1);
+}
-void GMMathText(SEXP str, int side, double line, int outer, double at, int las,
+void GMMathText(SEXP str, int side, double line, int outer,
-		DevDesc *dd)
+		double at, int las, DevDesc *dd)
+{
     int coords;
     double a, xadj, yadj;
-    mathDevice = dd;
+    MathDevice = dd;
     if (outer) {
 	switch (side) {
 	case 1:
 	    line = line + 1;
 	    coords = MAR1;
-	    a = 0.0;
+	    a = 0;
-	    xadj = mathDevice->gp.adj;
+	    xadj = MathDevice->gp.adj;
-	    yadj = 0.0;
+	    yadj = NA_REAL;
 	    break;
 	case 2:
 	    coords = MAR2;
-	    a = 90.0;
+	    a = 90;
-	    xadj = mathDevice->gp.adj;
+	    xadj = MathDevice->gp.adj;
-	    yadj = 0.0;
+	    yadj = NA_REAL;
 	    break;
 	case 3:
 	    coords = MAR3;
 	    a = 0.0;
-	    xadj = mathDevice->gp.adj;
+	    xadj = MathDevice->gp.adj;
-	    yadj = 0.0;
+	    yadj = NA_REAL;
 	    break;
 	case 4:
 	    line = line + 1;
 	    coords = MAR4;
 	    a = 90.0;
-	    xadj = mathDevice->gp.adj;
+	    xadj = MathDevice->gp.adj;
-	    yadj = 0.0;
+	    yadj = NA_REAL;
 	    break;
+	}
 	GMathText(at, line, coords, str, xadj, yadj, a, dd);
+    }
     else {
 		yadj = 0.5;
+	    }
 	    else {
 		line = line + 1 - dd->gp.yLineBias;
 		a = 0.0;
-		xadj = mathDevice->gp.adj;
+		xadj = MathDevice->gp.adj;
-		yadj = 0.0;
+		yadj = NA_REAL;
+	    }
 	    coords = MAR1;
 	    break;
 	case 2:
 	    if (las == 1 || las == 2) {
 		yadj = 0.5;
+	    }
 	    else {
 		line = line + dd->gp.yLineBias;
 		a = 90.0;
-		xadj = mathDevice->gp.adj;
+		xadj = MathDevice->gp.adj;
-		yadj = 0.0;
+		yadj = NA_REAL;
+	    }
 	    coords = MAR2;
 	    break;
 	case 3:
 	    if (las == 2) {
 		yadj = 0.5;
+	    }
 	    else {
 		line = line + dd->gp.yLineBias;
 		a = 0.0;
-		xadj = mathDevice->gp.adj;
+		xadj = MathDevice->gp.adj;
-		yadj = 0.0;
+		yadj = NA_REAL;
+	    }
 	    coords = MAR3;
 	    break;
 	case 4:
 	    if (las == 1 || las == 2) {
 		yadj = 0.5;
+	    }
 	    else {
 		line = line + 1 - dd->gp.yLineBias;
 		a = 90.0;
-		xadj = mathDevice->gp.adj;
+		xadj = MathDevice->gp.adj;
-		yadj = 0.0;
+		yadj = NA_REAL;
+	    }
 	    coords = MAR4;
 	    break;
+	}
 	GMathText(at, line, coords, str, xadj, yadj, a, dd);

The R Project SVN R

(root)/branches/R-exp-R5/src/main/plotmath.c @ 63243 – Rev 1926 → 2028