The R Project SVN – R – Diff – /trunk/src/main/plotmath.c

 #endif
 #ifdef Unix
 static DevDesc *mathDevice;
-		/* return maximum of two doubles */
+/* Return maximum of two doubles. */
 static double max(double x, double y)
+{
-	if (x > y) return x;
+    if (x > y) return x;
-	else return y;
+    else return y;
+}
-		/* determine match between symbol name and string */
+/* Determine match between symbol name and string. */
 static int symbolMatch(SEXP expr, char *aString)
+{
-	return !strcmp(CHAR(PRINTNAME(expr)), aString);
+    return !strcmp(CHAR(PRINTNAME(expr)), aString);
+}
-		/* code to determine the ascii code corresponding */
+/* Code to determine the ascii code corresponding */
-		/* to an element of a mathematical expression */
+/* to an element of a mathematical expression. */
 static int hatAscii()
+{
-	return 94;
+    return 94;
+}
 static int tildeAscii()
+{
-	return 126;
+    return 126;
+}
 static int accentAscii(SEXP expr)
+{
-	int result = 0;
+    int result = 0;
-	if (symbolMatch(expr, "hat"))
+    if (symbolMatch(expr, "hat"))
-		result = hatAscii();
+	result = hatAscii();
-	else if (symbolMatch(expr, "tilde"))
+    else if (symbolMatch(expr, "tilde"))
-		result = tildeAscii();
+	result = tildeAscii();
-	return result;
+    return result;
+}
 static int operatorAscii(SEXP expr)
+{
-	int result = 0;
+    int result = 0;
-	if (symbolMatch(expr, "sum"))
+    if (symbolMatch(expr, "sum"))
-		result = 229;
+	result = 229;
-	else if (symbolMatch(expr, "integral"))
+    else if (symbolMatch(expr, "integral"))
-		result = 242;
+	result = 242;
-	else if (symbolMatch(expr, "product"))
+    else if (symbolMatch(expr, "product"))
-		result = 213;
+	result = 213;
-	return result;
+    return result;
+}
 static int integralAscii(int section)
+{
-  if (section == 1)
+    if (section == 1)
-    return 243;
+	return 243;
-  else if (section == 2)
+    else if (section == 2)
-    return 244;
+	return 244;
-  else
+    else
-    return 245;
+	return 245;
+}
 static int groupOpenAscii()
+{
-	return 40;
+    return 40;
+}
 static int groupCloseAscii()
+{
-	return 41;
+    return 41;
+}
 static int commaAscii()
+{
-	return 44;
+    return 44;
+}
 static int spaceAscii()
+{
-	return 32;
+    return 32;
+}
 static int radicalAscii()
+{
-	return 214;
+    return 214;
+}
 static int radicalExAscii()
+{
-	return 96;
+    return 96;
+}
 static struct {
-	char *name;
+    char *name;
-	int code;
+    int code;
+}
-} GreekTable[] = {
+GreekTable[] = {
-	"Alpha", 65,
+    "Alpha",    65,
-	"Beta", 66,
+    "Beta",     66,
-	"Chi", 67,
+    "Chi",      67,
-	"Delta", 68,
+    "Delta",    68,
-	"Epsilon", 69,
+    "Epsilon",  69,
-	"Phi", 70,
+    "Phi",      70,
-	"Gamma", 71,
+    "Gamma",    71,
-	"Eta", 72,
+    "Eta",      72,
-	"Iota", 73,
+    "Iota",     73,
-	"Phi1", 74,
+    "Phi1",     74,
-	"Kappa", 75,
+    "Kappa",    75,
-	"Lambda", 76,
+    "Lambda",   76,
-	"Mu", 77,
+    "Mu",       77,
-	"Nu", 78,
+    "Nu",       78,
-	"Omicron", 79,
+    "Omicron",  79,
-	"Pi", 80,
+    "Pi",       80,
-	"Theta", 81,
+    "Theta",    81,
-	"Rho", 82,
+    "Rho",      82,
-	"Sigma", 83,
+    "Sigma",    83,
-	"Tau", 84,
+    "Tau",      84,
-	"Upsilon", 85,
+    "Upsilon",  85,
-	"sigma1", 86,
+    "sigma1",   86,
-	"Omega", 87,
+    "Omega",    87,
-	"Xi", 88,
+    "Xi",       88,
-	"Psi", 89,
+    "Psi",      89,
-	"Zeta", 90,
+    "Zeta",     90,
-	"alpha", 97,
+    "alpha",    97,
-	"beta", 98,
+    "beta",     98,
-	"chi", 99,
+    "chi",      99,
-	"delta", 100,
+    "delta",   100,
-	"epsilon", 101,
+    "epsilon", 101,
-	"phi", 102,
+    "phi",     102,
-	"gamma", 103,
+    "gamma",   103,
-	"eta", 104,
+    "eta",     104,
-	"iota", 105,
+    "iota",    105,
-	"phi1", 106,
+    "phi1",    106,
-	"kappa", 107,
+    "kappa",   107,
-	"lambda", 108,
+    "lambda",  108,
-	"mu", 109,
+    "mu",      109,
-	"nu", 110,
+    "nu",      110,
-	"omicron", 111,
+    "omicron", 111,
-	"pi", 112,
+    "pi",      112,
-	"theta", 113,
+    "theta",   113,
-	"rho", 114,
+    "rho",     114,
-	"sigma", 115,
+    "sigma",   115,
-	"tau", 116,
+    "tau",     116,
-	"upsilon", 117,
+    "upsilon", 117,
-	"omega1", 118,
+    "omega1",  118,
-	"omega", 119,
+    "omega",   119,
-	"xi", 120,
+    "xi",      120,
-	"psi", 121,
+    "psi",     121,
-	"zeta", 122,
+    "zeta",    122,
-	NULL, 0,
+    NULL,      0,
 };
 static int greekAscii(SEXP expr)
+{
-	int i;
+    int i;
-	for (i = 0; GreekTable[i].code; i++)
+    for (i = 0; GreekTable[i].code; i++)
-		if (symbolMatch(expr, GreekTable[i].name))
+	if (symbolMatch(expr, GreekTable[i].name))
-			return GreekTable[i].code;
+	    return GreekTable[i].code;
-	return 0;
+    return 0;
+}
-static int relAscii() { return 61; }
+static int relAscii()
+{
+    return 61;
+}
-	/* initialisation code for mathematical notation */
+/* Initialisation code for mathematical notation. */
 static double ratioScale = 0.8;
 static double scriptScale = 0.65;
 static int ratioDepth = 0;
 static int metricUnit = INCHES;
 static SEXP subSymbol;
 static SEXP groupSymbol;
 static void initFormulaSymbols()
+{
-	plusSymbol = install("+");
+    plusSymbol = install("+");
-	minusSymbol = install("-");
+    minusSymbol = install("-");
-	timesSymbol = install("*");
+    timesSymbol = install("*");
-	divideSymbol = install("/");
+    divideSymbol = install("/");
-	equalSymbol = install("==");
+    equalSymbol = install("==");
-	superSymbol = install("^");
+    superSymbol = install("^");
-	subSymbol = install("[");
+    subSymbol = install("[");
-	groupSymbol = install("(");
+    groupSymbol = install("(");
+}
-	/* code to determine the nature of an expression */
+/* Code to determine the nature of an expression. */
 static int formulaExpression(SEXP expr)
+{
-	return (TYPEOF(expr) == LANGSXP);
+    return (TYPEOF(expr) == LANGSXP);
+}
 static int symbolAtom(SEXP expr)
+{
-	return (TYPEOF(expr) == SYMSXP);
+    return (TYPEOF(expr) == SYMSXP);
+}
 static int numberAtom(SEXP expr)
+{
-	return (TYPEOF(expr) == REALSXP) ||
+    return ((TYPEOF(expr) == REALSXP) ||
-	    (TYPEOF(expr) == INTSXP) ||
+	    (TYPEOF(expr) == INTSXP)  ||
-	    (TYPEOF(expr) == CPLXSXP);
+	    (TYPEOF(expr) == CPLXSXP));
+}
 static int stringAtom(SEXP expr)
+{
-	return (TYPEOF(expr) == STRSXP);
+    return (TYPEOF(expr) == STRSXP);
+}
 static int binAtom(SEXP expr)
+{
-	int result = symbolAtom(expr) &&
+    int result = symbolAtom(expr) &&
-	((expr == plusSymbol) ||
+	((expr == plusSymbol)  ||
 	 (expr == minusSymbol) ||
 	 (expr == timesSymbol) ||
 	 (expr == divideSymbol));
-	return result;
+    return result;
+}
 static int relAtom(SEXP expr)
+{
-	return symbolAtom(expr) &&
+    return symbolAtom(expr) &&
-	    (expr == equalSymbol);
+	(expr == equalSymbol);
+}
 static int multiplicationOperator(SEXP expr)
+{
-	return binAtom(expr) &&
+    return binAtom(expr) &&
-	    (expr == timesSymbol);
+	(expr == timesSymbol);
+}
 static int superAtom(SEXP expr)
+{
-	return symbolAtom(expr) &&
+    return symbolAtom(expr) &&
-	    (expr == superSymbol);
+	(expr == superSymbol);
+}
 static int subAtom(SEXP expr)
+{
-	return symbolAtom(expr) &&
+    return symbolAtom(expr) &&
-	    (expr == subSymbol);
+	(expr == subSymbol);
+}
 static int hatAtom(SEXP expr)
+{
-	return symbolMatch(expr, "hat");
+    return symbolMatch(expr, "hat");
+}
 static int barAtom(SEXP expr)
+{
-	return symbolMatch(expr, "bar");
+    return symbolMatch(expr, "bar");
+}
 static int accentAtom(SEXP expr)
+{
-	return symbolAtom(expr) &&
+    return symbolAtom(expr) &&
-	    (hatAtom(expr) || barAtom(expr) ||
-	     symbolMatch(expr, "tilde"));
+	(hatAtom(expr) || barAtom(expr) || symbolMatch(expr, "tilde"));
+}
 static int fractionAtom(SEXP expr)
+{
-	return symbolAtom(expr) &&
+    return symbolAtom(expr) &&
-	    (symbolMatch(expr, "over") || symbolMatch(expr, "frac"));
+	(symbolMatch(expr, "over") || symbolMatch(expr, "frac"));
+}
 static int groupAtom(SEXP expr)
+{
-	return symbolAtom(expr) && (expr == groupSymbol);
+    return symbolAtom(expr) && (expr == groupSymbol);
+}
 static int operatorAtom(SEXP expr)
+{
-	return symbolAtom(expr) &&
+    return symbolAtom(expr) &&
-	    (symbolMatch(expr, "sum") ||
+	(symbolMatch(expr, "sum") ||
-	     symbolMatch(expr, "integral") ||
+	 symbolMatch(expr, "integral") ||
-	     symbolMatch(expr, "product"));
+	 symbolMatch(expr, "product"));
+}
 static int integralOperator(SEXP expr)
+{
-  return symbolAtom(expr) && symbolMatch(expr, "integral");
+    return symbolAtom(expr) && symbolMatch(expr, "integral");
+}
 static int radicalAtom(SEXP expr)
+{
-	return symbolAtom(expr) &&
+    return symbolAtom(expr) &&
-	    (symbolMatch(expr, "root") ||
-	     symbolMatch(expr, "sqrt"));
+	(symbolMatch(expr, "root") || symbolMatch(expr, "sqrt"));
+}
 static int absAtom(SEXP expr)
+{
-	return symbolAtom(expr) && symbolMatch(expr, "abs");
+    return symbolAtom(expr) && symbolMatch(expr, "abs");
+}
 static int curlyAtom(SEXP expr)
+{
-	return symbolAtom(expr) && symbolMatch(expr, "{");
+    return symbolAtom(expr) && symbolMatch(expr, "{");
+}
 static int boldAtom(SEXP expr)
+{
-	return symbolAtom(expr) && symbolMatch(expr, "bold");
+    return symbolAtom(expr) && symbolMatch(expr, "bold");
+}
 static int italicAtom(SEXP expr)
+{
-	return symbolAtom(expr) && symbolMatch(expr, "italic");
+    return symbolAtom(expr) && symbolMatch(expr, "italic");
+}
 static int plainAtom(SEXP expr)
+{
-	return symbolAtom(expr) && symbolMatch(expr, "plain");
+    return symbolAtom(expr) && symbolMatch(expr, "plain");
+}
 static int boldItalicAtom(SEXP expr)
+{
-	return symbolAtom(expr) && symbolMatch(expr, "bolditalic");
+    return symbolAtom(expr) && symbolMatch(expr, "bolditalic");
+}
 static int italicExpression(SEXP expr)
+{
-	return formulaExpression(expr) &&
+    return formulaExpression(expr) &&
-	       (italicAtom(CAR(expr)) || boldItalicAtom(CAR(expr)));
+	(italicAtom(CAR(expr)) || boldItalicAtom(CAR(expr)));
+}
 static int nonItalicExpression(SEXP expr)
+{
-	return formulaExpression(expr) &&
+    return formulaExpression(expr) &&
-	       (boldAtom(CAR(expr)) || plainAtom(CAR(expr)));
+	(boldAtom(CAR(expr)) || plainAtom(CAR(expr)));
+}
 static int concatenateAtom(SEXP expr)
+{
-	return symbolAtom(expr) && symbolMatch(expr, "paste");
+    return symbolAtom(expr) && symbolMatch(expr, "paste");
+}
 static int greekSymbol(SEXP expr)
+{
-	int i;
+    int i;
-	if (symbolAtom(expr)) {
+    if (symbolAtom(expr)) {
-		for (i = 0; GreekTable[i].code; i++)
+	for (i = 0; GreekTable[i].code; i++)
-			if (symbolMatch(expr, GreekTable[i].name))
+	    if (symbolMatch(expr, GreekTable[i].name))
-				return 1;
+		return 1;
-	}
+    }
-	return 0;
+    return 0;
+}
-		/* code to determine a font from the */
+/* Code to determine a font from the */
-		/* nature of the expression */
+/* nature of the expression */
 static int currentFont = 3;
 static int getFont() { return currentFont; }
 static int isItalic() { return (getFont() == 3 || getFont() == 4); }
 static int atomFontFace(SEXP expr)
+{
-	int fontFace = 1;
+    int fontFace = 1;
-	if (symbolAtom(expr)) {
+    if (symbolAtom(expr)) {
-		if (greekSymbol(expr) ||
+	if (greekSymbol(expr) ||
-		    binAtom(expr) ||
+	    binAtom(expr) ||
-		    relAtom(expr) ||
+	    relAtom(expr) ||
-		    groupAtom(expr) ||
+	    groupAtom(expr) ||
-		    operatorAtom(expr) ||
+	    operatorAtom(expr) ||
-		    radicalAtom(expr))
+	    radicalAtom(expr))
-			fontFace = 5;
+	    fontFace = 5;
-		else
+	else
 #ifdef OLD
-			fontFace = 3;
+	    fontFace = 3;
 #else
-			fontFace = getFont();
+	fontFace = getFont();
 #endif
-	}
+    }
-	return fontFace;
+    return fontFace;
+}
-	/* a forward declaration */
+/* a forward declaration */
 static double fontHeight();
-	/* some forward declarations */
+/* some forward declarations */
 typedef struct {
-	double height;
+    double height;
-	double depth;
+    double depth;
-	double width;
+    double width;
 } BBOX;
 static double bboxHeight(BBOX bbox)
+{
-	return bbox.height;
+    return bbox.height;
+}
 static double bboxDepth(BBOX bbox)
+{
-	return bbox.depth;
+    return bbox.depth;
+}
 static double bboxWidth(BBOX bbox)
+{
-	return bbox.width;
+    return bbox.width;
+}
 static BBOX asciiBBox(int ascii);
 static BBOX elementBBox(SEXP expr);
 static void drawElement(SEXP expr);
-	/* code to determine superscript offsets, etc ... */
+/* code to determine superscript offsets, etc ... */
-	/* these "twiddle factors" are given as  */
+/* these "twiddle factors" are given as  */
-	/* proportions of the current font height */
+/* proportions of the current font height */
-	/* NOTE that metric information is obtained */
+/* NOTE that metric information is obtained */
-	/* in INCHES so that the information will */
+/* in INCHES so that the information will */
-	/* be useful for rotated math.text */
+/* be useful for rotated math.text */
 static float SuperDrop = 0.3;
 static float Superscript = 0.3;
 static float SubDrop = 0.1;
 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;
+    double height, depth, width;
-	GMetricInfo(0, &height, &depth, &width, metricUnit, mathDevice);
+    GMetricInfo(0, &height, &depth, &width, metricUnit, mathDevice);
-	return height + depth;
+    return height + depth;
+}
 static double xHeight()
+{
-	int x = 'x';
+    int x = 'x';
-	double xheight, depth, width;
+    double xheight, depth, width;
-	GMetricInfo(x, &xheight, &depth, &width, metricUnit, mathDevice);
+    GMetricInfo(x, &xheight, &depth, &width, metricUnit, mathDevice);
-	return xheight;
+    return xheight;
+}
 static double axisHeight()
+{
-	int plus = '+';
+    int plus = '+';
-	double plusHeight, depth, width;
+    double plusHeight, depth, width;
-	GMetricInfo(plus, &plusHeight, &depth, &width, metricUnit, mathDevice);
+    GMetricInfo(plus, &plusHeight, &depth, &width, metricUnit, mathDevice);
-	return 0.5 * plusHeight;
+    return 0.5 * plusHeight;
+}
 static double superscriptDrop()
+{
-	return SuperDrop * fontHeight();
+    return SuperDrop * fontHeight();
+}
 static double subscriptDrop()
+{
-	return SubDrop * fontHeight();
+    return SubDrop * fontHeight();
+}
 static double superscript()
+{
-	return Superscript * fontHeight();
+    return Superscript * fontHeight();
+}
 static double subscript()
+{
-	return Subscript * fontHeight();
+    return Subscript * fontHeight();
+}
 static double lineWidth()
+{
-	return LineWidth * fontHeight();
+    return LineWidth * fontHeight();
+}
 static double numeratorShift()
+{
-	return axisHeight() + 3 * lineWidth();
+    return axisHeight() + 3 * lineWidth();
+}
 static double denominatorShift()
+{
-	return axisHeight() - 3 * lineWidth() - xHeight();
+    return axisHeight() - 3 * lineWidth() - xHeight();
+}
 static double radicalDrop()
+{
-	return 1.25 * lineWidth();
+    return 1.25 * lineWidth();
+}
 static double customAccentGap()
+{
-	return CustomAccentGap * fontHeight();
+    return CustomAccentGap * fontHeight();
+}
 static double customHatHeight()
+{
-	return CustomHatHeight * fontHeight();
+    return CustomHatHeight * fontHeight();
+}
 static double customRadicalWidth()
+{
-	return CustomRadicalWidth * fontHeight();
+    return CustomRadicalWidth * fontHeight();
+}
 static double customRadicalSpace()
+{
-	return CustomRadicalSpace * fontHeight();
+    return CustomRadicalSpace * fontHeight();
+}
 static double customRadicalGap()
+{
-	return CustomRadicalGap * fontHeight();
+    return CustomRadicalGap * fontHeight();
+}
 static double absSpace()
+{
-	return AbsSpace * fontHeight();
+    return AbsSpace * fontHeight();
+}
 static double operatorSpace(int i)
+{
-  return OperatorSpace[i] * fontHeight();
+    return OperatorSpace[i] * fontHeight();
+}
-	/* should only be called when font=5 (symbol) */
+/* Should only be called when font=5 (symbol) */
 static double radicalExWidth()
+{
-	int radicalEx = 96;
+    int radicalEx = 96;
-	double height, depth, REWidth;
+    double height, depth, REWidth;
-	GMetricInfo(radicalEx, &height, &depth, &REWidth, metricUnit, mathDevice);
+    GMetricInfo(radicalEx, &height, &depth, &REWidth, metricUnit, mathDevice);
-	return REWidth;
+    return REWidth;
+}
 static double superscriptShift(SEXP body, SEXP sup)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	BBOX superscriptBBox;
+    BBOX superscriptBBox;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	double temp1 = bboxHeight(bodyBBox) - superscriptDrop();
+    double temp1 = bboxHeight(bodyBBox) - superscriptDrop();
-	double temp2 = superscript();
+    double temp2 = superscript();
-	double temp3;
+    double temp3;
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-	superscriptBBox = elementBBox(sup);
+    superscriptBBox = elementBBox(sup);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-	temp3 = bboxDepth(superscriptBBox) + 0.25 * xHeight();
+    temp3 = bboxDepth(superscriptBBox) + 0.25 * xHeight();
-	return max(temp1, max(temp2, temp3));
+    return max(temp1, max(temp2, temp3));
+}
 static double subscriptShift(SEXP body, SEXP sub, int subOnly)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	BBOX subscriptBBox;
+    BBOX subscriptBBox;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	double temp1 = bboxDepth(bodyBBox) + subscriptDrop();
+    double temp1 = bboxDepth(bodyBBox) + subscriptDrop();
-	double temp2 = subscript();
+    double temp2 = subscript();
-	double temp3;
+    double temp3;
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-	subscriptBBox = elementBBox(sub);
+    subscriptBBox = elementBBox(sub);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-	temp3 = bboxHeight(subscriptBBox) - (4 * xHeight() / 5);
+    temp3 = bboxHeight(subscriptBBox) - (4 * xHeight() / 5);
-	if (subOnly)
+    if (subOnly)
-		return max(temp1, max(temp2, temp3));
+	return max(temp1, max(temp2, temp3));
-	else
+    else
-		return max(temp1, temp2);
+	return max(temp1, temp2);
+}
 static void supsubShift(SEXP body, SEXP sup, SEXP sub,
 			double *supShift, double *subShift)
+{
-	BBOX superscriptBBox, subscriptBBox;
+    BBOX superscriptBBox, subscriptBBox;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	double temp1, temp2;
+    double temp1, temp2;
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-	superscriptBBox = elementBBox(sup);
+    superscriptBBox = elementBBox(sup);
-	subscriptBBox = elementBBox(sub);
+    subscriptBBox = elementBBox(sub);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-	*supShift = superscriptShift(body, sup);
+    *supShift = superscriptShift(body, sup);
-	*subShift = subscriptShift(body, sub, 0);
+    *subShift = subscriptShift(body, sub, 0);
-	temp1 = (*supShift - bboxDepth(superscriptBBox)) -
+    temp1 = (*supShift - bboxDepth(superscriptBBox)) -
-	    (bboxHeight(subscriptBBox) - *subShift);
+	(bboxHeight(subscriptBBox) - *subShift);
-	if (temp1 < (4 * lineWidth()))
+    if (temp1 < (4 * lineWidth()))
-		*subShift = bboxHeight(subscriptBBox) -
+	*subShift = bboxHeight(subscriptBBox) -
-		    *supShift +
+	    *supShift +
-		    bboxDepth(superscriptBBox) +
+	    bboxDepth(superscriptBBox) +
-		    (4 * lineWidth());
+	    (4 * lineWidth());
-	temp2 = (4 * xHeight() / 5) -
+    temp2 = (4 * xHeight() / 5) -
-	    (*supShift - bboxDepth(superscriptBBox));
+	(*supShift - bboxDepth(superscriptBBox));
-	if (temp2 > 0) {
+    if (temp2 > 0) {
-		*supShift = *supShift + temp2;
+	*supShift = *supShift + temp2;
-		*subShift = *subShift - temp2;
+	*subShift = *subShift - temp2;
-	}
+    }
+}
 static double accentVShift(SEXP body)
+{
-	double temp = xHeight();
+    double temp = xHeight();
-	double bodyHeight = bboxHeight(elementBBox(body));
+    double bodyHeight = bboxHeight(elementBBox(body));
-	if (bodyHeight > temp)
+    if (bodyHeight > temp)
-		return bodyHeight - temp;
+	return bodyHeight - temp;
-	else
+    else
-		return 0;
+	return 0;
+}
 static double accentHShift(SEXP body, SEXP accent)
+{
-	return (bboxWidth(elementBBox(body)) -
+    return (bboxWidth(elementBBox(body)) -
-		bboxWidth(elementBBox(accent))) / 2;
+	    bboxWidth(elementBBox(accent))) / 2;
+}
 static double numeratorVShift(SEXP num)
+{
-	BBOX numBBox;
+    BBOX numBBox;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	double theShift, theClearance, minClearance;
+    double theShift, theClearance, minClearance;
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-	numBBox = elementBBox(num);
+    numBBox = elementBBox(num);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-	theShift = numeratorShift();
+    theShift = numeratorShift();
-	theClearance = numeratorShift() - bboxDepth(numBBox) -
+    theClearance = numeratorShift() - bboxDepth(numBBox) -
-	    (axisHeight() + 0.5 * lineWidth());
+	(axisHeight() + 0.5 * lineWidth());
-	minClearance = 3 * lineWidth();
+    minClearance = 3 * lineWidth();
-	if (theClearance < minClearance)
+    if (theClearance < minClearance)
-		theShift += minClearance - theClearance;
+	theShift += minClearance - theClearance;
-	return theShift;
+    return theShift;
+}
 /* RATIO */
 static double denominatorVShift(SEXP denom)
+{
-	BBOX denomBBox;
+    BBOX denomBBox;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	double theShift, theClearance, minClearance;
+    double theShift, theClearance, minClearance;
 #ifdef OLD
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
 #else
-	mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
 #endif
-	denomBBox = elementBBox(denom);
+    denomBBox = elementBBox(denom);
 #ifdef OLD
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #else
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #endif
-	theShift = denominatorShift();
+    theShift = denominatorShift();
-	theClearance = axisHeight() - 0.5 * lineWidth() -
+    theClearance = axisHeight() - 0.5 * lineWidth() -
-	    (bboxHeight(denomBBox) - denominatorShift());
+	(bboxHeight(denomBBox) - denominatorShift());
-	minClearance = 3 * lineWidth();
+    minClearance = 3 * lineWidth();
-	if (theClearance < minClearance)
+    if (theClearance < minClearance)
-		theShift += minClearance - theClearance;
+	theShift += minClearance - theClearance;
-	return theShift;
+    return theShift;
+}
 /* RATIO */
 static double fractionWidth(SEXP num, SEXP denom)
+{
-	BBOX numBBox;
+    BBOX numBBox;
-	BBOX denomBBox;
+    BBOX denomBBox;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	double temp1, temp2;
+    double temp1, temp2;
 #ifdef OLD
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
 #else
-	mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
 #endif
-	numBBox = elementBBox(num);
+    numBBox = elementBBox(num);
-	denomBBox = elementBBox(denom);
+    denomBBox = elementBBox(denom);
 #ifdef OLD
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #else
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #endif
-	temp1 = bboxWidth(numBBox);
+    temp1 = bboxWidth(numBBox);
-	temp2 = bboxWidth(denomBBox);
+    temp2 = bboxWidth(denomBBox);
-	return max(temp1, temp2);
+    return max(temp1, temp2);
+}
 /* RATIO */
 static void numdenomHShift(SEXP num, SEXP denom,
 			   double *numShift, double *denomShift)
+{
-	BBOX numBBox;
+    BBOX numBBox;
-	BBOX denomBBox;
+    BBOX denomBBox;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	double temp1, temp2;
+    double temp1, temp2;
 #ifdef OLD
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
 #else
-	mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
 #endif
-	numBBox = elementBBox(num);
+    numBBox = elementBBox(num);
-	denomBBox = elementBBox(denom);
+    denomBBox = elementBBox(denom);
 #ifdef OLD
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #else
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #endif
-	temp1 = bboxWidth(numBBox);
+    temp1 = bboxWidth(numBBox);
-	temp2 = bboxWidth(denomBBox);
+    temp2 = bboxWidth(denomBBox);
-	if (temp1 > temp2) {
+    if (temp1 > temp2) {
-		*numShift = 0;
+	*numShift = 0;
-		*denomShift = (temp1 - temp2) / 2;
+	*denomShift = (temp1 - temp2) / 2;
-	}
+    }
-	else {
+    else {
-		*numShift = (temp2 - temp1) / 2;
+	*numShift = (temp2 - temp1) / 2;
-		*denomShift = 0;
+	*denomShift = 0;
-	}
+    }
+}
 static int normalRadical(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	BBOX radicalBBox = asciiBBox(radicalAscii());
+    BBOX radicalBBox = asciiBBox(radicalAscii());
-	return ((bboxHeight(bodyBBox) + radicalDrop())
+    return ((bboxHeight(bodyBBox) + radicalDrop())
-		<= bboxHeight(radicalBBox)) &&
+	    <= bboxHeight(radicalBBox)) &&
-	    (bboxDepth(bodyBBox) <= bboxDepth(radicalBBox));
+	(bboxDepth(bodyBBox) <= bboxDepth(radicalBBox));
+}
 static double radicalVShift(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	return bboxHeight(bodyBBox) + radicalDrop();
+    return bboxHeight(bodyBBox) + radicalDrop();
+}
 static BBOX theOperatorBBox(SEXP operator);
 static BBOX operatorLimitBBox(SEXP operator);
 static double operatorLowerShift(SEXP operator, SEXP lower)
+{
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX lowerBBox;
+    BBOX lowerBBox;
-  double lowerHeight;
+    double lowerHeight;
-  double spacing2 = operatorSpace(1);
+    double spacing2 = operatorSpace(1);
-  double spacing4 = operatorSpace(3);
+    double spacing4 = operatorSpace(3);
-  lowerBBox = operatorLimitBBox(lower);
+    lowerBBox = operatorLimitBBox(lower);
-  lowerHeight = bboxHeight(lowerBBox);
+    lowerHeight = bboxHeight(lowerBBox);
-  if (spacing2 > (spacing4 - lowerHeight))
+    if (spacing2 > (spacing4 - lowerHeight))
-    return bboxDepth(opBBox) + spacing2 + lowerHeight;
+	return bboxDepth(opBBox) + spacing2 + lowerHeight;
-  else
+    else
-    return bboxDepth(opBBox) + spacing4;
+	return bboxDepth(opBBox) + spacing4;
+}
 static double operatorUpperShift(SEXP operator, SEXP upper)
+{
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX upperBBox;
+    BBOX upperBBox;
-  double upperDepth;
+    double upperDepth;
-  double spacing1 = operatorSpace(0);
+    double spacing1 = operatorSpace(0);
-  double spacing3 = operatorSpace(2);
+    double spacing3 = operatorSpace(2);
-  upperBBox = operatorLimitBBox(upper);
+    upperBBox = operatorLimitBBox(upper);
-  upperDepth = bboxDepth(upperBBox);
+    upperDepth = bboxDepth(upperBBox);
-  if (spacing1 > (spacing3 - upperDepth))
+    if (spacing1 > (spacing3 - upperDepth))
-    return bboxHeight(opBBox) + spacing1 + upperDepth;
+	return bboxHeight(opBBox) + spacing1 + upperDepth;
-  else
+    else
-    return bboxHeight(opBBox) + spacing3;
+	return bboxHeight(opBBox) + spacing3;
+}
 static double operatorLowerHShift(SEXP operator, SEXP lower)
+{
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX lowerBBox;
+    BBOX lowerBBox;
-  double maxWidth = bboxWidth(opBBox);
+    double maxWidth = bboxWidth(opBBox);
-  lowerBBox = operatorLimitBBox(lower);
+    lowerBBox = operatorLimitBBox(lower);
-  if (bboxWidth(lowerBBox) < maxWidth)
+    if (bboxWidth(lowerBBox) < maxWidth)
-    return (maxWidth - bboxWidth(lowerBBox))/2;
+	return (maxWidth - bboxWidth(lowerBBox))/2;
-  else
+    else
-    return 0;
+	return 0;
+}
 static double operatorHShift(SEXP operator, SEXP lower)
+{
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX lowerBBox;
+    BBOX lowerBBox;
-  double maxWidth = bboxWidth(opBBox);
+    double maxWidth = bboxWidth(opBBox);
-  lowerBBox = operatorLimitBBox(lower);
+    lowerBBox = operatorLimitBBox(lower);
-  if (bboxWidth(lowerBBox) > maxWidth)
+    if (bboxWidth(lowerBBox) > maxWidth)
-    return (bboxWidth(lowerBBox) - maxWidth)/2;
+	return (bboxWidth(lowerBBox) - maxWidth)/2;
-  else
+    else
-    return 0;
+	return 0;
+}
 static double operatorLowerHShiftAll(SEXP operator, SEXP lower, SEXP upper)
+{
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX lowerBBox, upperBBox;
+    BBOX lowerBBox, upperBBox;
-  double maxWidth = bboxWidth(opBBox);
+    double maxWidth = bboxWidth(opBBox);
-  lowerBBox = operatorLimitBBox(lower);
+    lowerBBox = operatorLimitBBox(lower);
-  upperBBox = operatorLimitBBox(upper);
+    upperBBox = operatorLimitBBox(upper);
-  maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
+    maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
-  if (bboxWidth(lowerBBox) < maxWidth)
+    if (bboxWidth(lowerBBox) < maxWidth)
-    return (maxWidth - bboxWidth(lowerBBox))/2;
+	return (maxWidth - bboxWidth(lowerBBox))/2;
-  else
+    else
-    return 0;
+	return 0;
+}
 static double operatorUpperHShiftAll(SEXP operator, SEXP lower, SEXP upper)
+{
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX lowerBBox, upperBBox;
+    BBOX lowerBBox, upperBBox;
-  double maxWidth = bboxWidth(opBBox);
+    double maxWidth = bboxWidth(opBBox);
-  lowerBBox = operatorLimitBBox(lower);
+    lowerBBox = operatorLimitBBox(lower);
-  upperBBox = operatorLimitBBox(upper);
+    upperBBox = operatorLimitBBox(upper);
-  maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
+    maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
-  if (bboxWidth(upperBBox) < maxWidth)
+    if (bboxWidth(upperBBox) < maxWidth)
-    return (maxWidth - bboxWidth(upperBBox))/2;
+	return (maxWidth - bboxWidth(upperBBox))/2;
-  else
+    else
-    return 0;
+	return 0;
+}
 static double operatorHShiftAll(SEXP operator, SEXP lower, SEXP upper)
+{
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX lowerBBox, upperBBox;
+    BBOX lowerBBox, upperBBox;
-  double maxWidth = bboxWidth(opBBox);
+    double maxWidth = bboxWidth(opBBox);
-  lowerBBox = operatorLimitBBox(lower);
+    lowerBBox = operatorLimitBBox(lower);
-  upperBBox = operatorLimitBBox(upper);
+    upperBBox = operatorLimitBBox(upper);
-  maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
+    maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));
-  if (bboxWidth(opBBox) < maxWidth)
+    if (bboxWidth(opBBox) < maxWidth)
-    return (maxWidth - bboxWidth(opBBox))/2;
+	return (maxWidth - bboxWidth(opBBox))/2;
-  else
+    else
-    return 0;
+	return 0;
+}
-	/* code to generate bounding boxes and draw formulae */
+/* Code to generate bounding boxes and draw formulae. */
-/* Bounding box basics */
+/* Bounding box basics. */
 static BBOX makeBBox(double height, double depth, double width)
+{
-	BBOX bbox;
+    BBOX bbox;
-	bbox.height = height;
+    bbox.height = height;
-	bbox.depth = depth;
+    bbox.depth = depth;
-	bbox.width = width;
+    bbox.width = width;
-	return bbox;
+    return bbox;
+}
 static BBOX nullBBox()
+{
-	return makeBBox(0.0, 0.0, 0.0);
+    return makeBBox(0.0, 0.0, 0.0);
+}
 static BBOX makeBBoxFromChar(int chr)
+{
-	double height, depth, width;
+    double height, depth, width;
-	GMetricInfo(chr, &height, &depth, &width, metricUnit, mathDevice);
+    GMetricInfo(chr, &height, &depth, &width, metricUnit, mathDevice);
-	return makeBBox(height, depth, width);
+    return makeBBox(height, depth, width);
+}
 static BBOX shiftBBox(BBOX bbox, double shiftV)
+{
-	return makeBBox(bboxHeight(bbox) + shiftV,
+    return makeBBox(bboxHeight(bbox) + shiftV,
-			bboxDepth(bbox) - shiftV,
+		    bboxDepth(bbox) - shiftV,
-			bboxWidth(bbox));
+		    bboxWidth(bbox));
+}
 static BBOX combineBBoxes(BBOX bbox1, BBOX bbox2)
+{
-	return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
+    return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
-			max(bboxDepth(bbox1), bboxDepth(bbox2)),
+		    max(bboxDepth(bbox1), bboxDepth(bbox2)),
-			bboxWidth(bbox1) + bboxWidth(bbox2));
+		    bboxWidth(bbox1) + bboxWidth(bbox2));
+}
 static BBOX combineAlignedBBoxes(BBOX bbox1, BBOX bbox2)
+{
-	return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
+    return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
-			max(bboxDepth(bbox1), bboxDepth(bbox2)),
+		    max(bboxDepth(bbox1), bboxDepth(bbox2)),
-			max(bboxWidth(bbox1), bboxWidth(bbox2)));
+		    max(bboxWidth(bbox1), bboxWidth(bbox2)));
+}
 /* Drawing basics */
 static double referenceX;
 static double currentY;
 static double currentAngle;
 static double cosAngle;
 static double sinAngle;
-		/*
-		   // convert currentX and currentY from 0 angle
+/* Convert currentX and currentY from 0 angle */
-		   // to and currentAngle
+/* to and currentAngle */
-		 */
 static double convertedX()
+{
-	double rotatedX = referenceX +
+    double rotatedX = referenceX +
 	(currentX - referenceX) * cosAngle -
 	(currentY - referenceY) * sinAngle;
-	return rotatedX;
+    return rotatedX;
+}
 static double convertedY()
+{
-	double rotatedY = referenceY +
+    double rotatedY = referenceY +
 	(currentY - referenceY) * cosAngle +
 	(currentX - referenceX) * sinAngle;
-	return rotatedY;
+    return rotatedY;
+}
 static void moveAcross(double xamount)
+{
-	currentX += xamount;
+    currentX += xamount;
+}
 static void moveUp(double yamount)
+{
-	currentY += yamount;
+    currentY += yamount;
+}
 static void moveTo(double x, double y)
+{
-	currentX = x;
+    currentX = x;
-	currentY = y;
+    currentY = y;
+}
-/* code for ascii atoms */
+/* Code for ascii atoms. */
-	/* NOTE that i assume that all symbols which have */
+/* NOTE that I assume that all symbols which have */
-	/* been converted to ascii are in the symbol font */
+/* been converted to ascii are in the symbol font. */
 static BBOX asciiBBox(int ascii)
+{
-	if ((ascii == hatAscii()) || (ascii == tildeAscii()))
+    if ((ascii == hatAscii()) || (ascii == tildeAscii()))
-		mathDevice->gp.font = 1;
+	mathDevice->gp.font = 1;
-	else
+    else
-		mathDevice->gp.font = 5;
+	mathDevice->gp.font = 5;
-	return makeBBoxFromChar(ascii);
+    return makeBBoxFromChar(ascii);
+}
 static void drawAscii(int ascii)
+{
-	char asciiStr[2];
+    char asciiStr[2];
-	if ((ascii == hatAscii()) || (ascii == tildeAscii()))
+    if ((ascii == hatAscii()) || (ascii == tildeAscii()))
-		mathDevice->gp.font = 1;
+	mathDevice->gp.font = 1;
-	else
+    else
-		mathDevice->gp.font = 5;
+	mathDevice->gp.font = 5;
-	asciiStr[0] = ascii;
+    asciiStr[0] = ascii;
-	asciiStr[1] = '\0';
+    asciiStr[1] = '\0';
-	GText(convertedX(), convertedY(), INCHES, asciiStr,
+    GText(convertedX(), convertedY(), INCHES, asciiStr,
 .0, 0.0, currentAngle, mathDevice);
-	moveAcross(GStrWidth(asciiStr, metricUnit, mathDevice));
+    moveAcross(GStrWidth(asciiStr, metricUnit, mathDevice));
+}
-/* code for character atoms */
+/* Code for character atoms. */
 static BBOX charBBox(char *str, SEXP expr)
+{
-	BBOX resultBBox = nullBBox();
+    BBOX resultBBox = nullBBox();
-	int i;
+    int i;
-	mathDevice->gp.font = atomFontFace(expr);
+    mathDevice->gp.font = atomFontFace(expr);
-	for (i = 0; i < strlen(str); i++)
+    for (i = 0; i < strlen(str); i++)
-		resultBBox = combineBBoxes(resultBBox, makeBBoxFromChar(str[i]));
+	resultBBox = combineBBoxes(resultBBox, makeBBoxFromChar(str[i]));
-	return resultBBox;
+    return resultBBox;
+}
 static void drawChar(char *str, SEXP expr)
+{
-	mathDevice->gp.font = atomFontFace(expr);
+    mathDevice->gp.font = atomFontFace(expr);
-	GText(convertedX(), convertedY(), INCHES, str,
+    GText(convertedX(), convertedY(), INCHES, str,
 .0, 0.0, currentAngle, mathDevice);
-	moveAcross(GStrWidth(str, metricUnit, mathDevice));
+    moveAcross(GStrWidth(str, metricUnit, mathDevice));
+}
 /* code for symbol atoms */
 static BBOX symbolBBox(SEXP expr)
+{
-	if (greekSymbol(expr))
+    if (greekSymbol(expr))
-		return asciiBBox(greekAscii(expr));
+	return asciiBBox(greekAscii(expr));
-	else
+    else
-		return charBBox(CHAR(PRINTNAME(expr)), expr);
+	return charBBox(CHAR(PRINTNAME(expr)), expr);
+}
 static void drawSymbol(SEXP expr)
+{
-	if (greekSymbol(expr))
+    if (greekSymbol(expr))
-		drawAscii(greekAscii(expr));
+	drawAscii(greekAscii(expr));
-	else
+    else
-		drawChar(CHAR(PRINTNAME(expr)), expr);
+	drawChar(CHAR(PRINTNAME(expr)), expr);
+}
 /* code for numeric atoms */
 static BBOX numberBBox(SEXP expr)
+{
-	return charBBox(CHAR(asChar(expr)), expr);
+    return charBBox(CHAR(asChar(expr)), expr);
+}
 static void drawNumber(SEXP expr)
+{
-	drawChar(CHAR(asChar(expr)), expr);
+    drawChar(CHAR(asChar(expr)), expr);
+}
 /* code for string atoms */
 static BBOX stringBBox(SEXP expr)
+{
-	return charBBox(CHAR(STRING(expr)[0]), expr);
+    return charBBox(CHAR(STRING(expr)[0]), expr);
+}
 static void drawString(SEXP expr)
+{
-	drawChar(CHAR(STRING(expr)[0]), expr);
+    drawChar(CHAR(STRING(expr)[0]), expr);
+}
 /* code for atoms */
 static BBOX atomBBox(SEXP expr)
+{
-	if (symbolAtom(expr))
+    if (symbolAtom(expr))
-		return symbolBBox(expr);
+	return symbolBBox(expr);
-	else if (numberAtom(expr))
+    else if (numberAtom(expr))
-		return numberBBox(expr);
+	return numberBBox(expr);
-	else if (stringAtom(expr))
+    else if (stringAtom(expr))
-		return stringBBox(expr);
+	return stringBBox(expr);
+}
 static void drawAtom(SEXP expr)
+{
-	if (symbolAtom(expr))
+    if (symbolAtom(expr))
-		drawSymbol(expr);
+	drawSymbol(expr);
-	else if (numberAtom(expr))
+    else if (numberAtom(expr))
-		drawNumber(expr);
+	drawNumber(expr);
-	else if (stringAtom(expr))
+    else if (stringAtom(expr))
-		drawString(expr);
+	drawString(expr);
+}
 /* code for italic corrections */
 static double half_pi = 1.57079632679489661922;
 static double italicCorrection(SEXP expr)
+{
-  BBOX exprBBox = elementBBox(expr);
+    BBOX exprBBox = elementBBox(expr);
-  return bboxHeight(exprBBox) * tan(half_pi / 6);
+    return bboxHeight(exprBBox) * tan(half_pi / 6);
+}
 	/* correction within expression checks for current font italic */
 static BBOX correctionWithinBBox(SEXP expr)
+{
-  if (isItalic() && !nonItalicExpression(expr))
+    if (isItalic() && !nonItalicExpression(expr))
-    return makeBBox(0, 0, italicCorrection(expr));
+	return makeBBox(0, 0, italicCorrection(expr));
-  else
+    else
-    return nullBBox();
+	return nullBBox();
+}
 static void drawCorrectionWithin(SEXP expr)
+{
-  if (isItalic() && !nonItalicExpression(expr))
+    if (isItalic() && !nonItalicExpression(expr))
-    moveAcross(italicCorrection(expr));
+	moveAcross(italicCorrection(expr));
+}
 	/* correction between expressions checks current font and font */
 	/* of each expression */
 static BBOX correctionBetweenBBox(SEXP expr1, SEXP expr2)
+{
-  if (((isItalic() && !nonItalicExpression(expr1)) ||
+    if (((isItalic() && !nonItalicExpression(expr1)) ||
-       italicExpression(expr1)) &&
+	 italicExpression(expr1)) &&
-      ((!isItalic() && !italicExpression(expr2)) ||
+	((!isItalic() && !italicExpression(expr2)) ||
-       nonItalicExpression(expr2)))
+	 nonItalicExpression(expr2)))
-    return makeBBox(0, 0, italicCorrection(expr1));
+	return makeBBox(0, 0, italicCorrection(expr1));
-  else
+    else
-    return nullBBox();
+	return nullBBox();
+}
 static void drawCorrectionBetween(SEXP expr1, SEXP expr2)
+{
-  if (((isItalic() && !nonItalicExpression(expr1)) ||
+    if (((isItalic() && !nonItalicExpression(expr1)) ||
-       italicExpression(expr1)) &&
+	 italicExpression(expr1)) &&
-      ((!isItalic() && !italicExpression(expr2)) ||
+	((!isItalic() && !italicExpression(expr2)) ||
-       nonItalicExpression(expr2)))
+	 nonItalicExpression(expr2)))
-    moveAcross(italicCorrection(expr1));
+	moveAcross(italicCorrection(expr1));
+}
 /* code for gaps */
 static int cexGap = 1;
   cexGap = mathDevice->gp.cex;
+}
 static BBOX gapBBox(double gap)
+{
-  double cexSaved = mathDevice->gp.cex;
+    double cexSaved = mathDevice->gp.cex;
-  BBOX theBBox;
+    BBOX theBBox;
-  mathDevice->gp.cex = cexGap;
+    mathDevice->gp.cex = cexGap;
-  theBBox = makeBBox(0, 0, gap * fontHeight());
+    theBBox = makeBBox(0, 0, gap * fontHeight());
-  mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-  return theBBox;
+    return theBBox;
+}
 static BBOX smallgapBBox(double gap)
+{
-  double cexSaved = mathDevice->gp.cex;
+    double cexSaved = mathDevice->gp.cex;
-  BBOX theBBox;
+    BBOX theBBox;
-  mathDevice->gp.cex = cexGap;
+    mathDevice->gp.cex = cexGap;
-  theBBox = makeBBox(0, 0, 0.5 * gap * fontHeight());
+    theBBox = makeBBox(0, 0, 0.5 * gap * fontHeight());
-  mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-  return theBBox;
+    return theBBox;
+}
 static void drawGap(double gap)
+{
-  double cexSaved = mathDevice->gp.cex;
+    double cexSaved = mathDevice->gp.cex;
-  mathDevice->gp.cex = cexGap;
+    mathDevice->gp.cex = cexGap;
-  moveAcross(gap * fontHeight());
+    moveAcross(gap * fontHeight());
-  mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
+}
 static void drawSmallGap(double gap)
+{
-  double cexSaved = mathDevice->gp.cex;
+    double cexSaved = mathDevice->gp.cex;
-  mathDevice->gp.cex = cexGap;
+    mathDevice->gp.cex = cexGap;
-  moveAcross(0.5 * gap * fontHeight());
+    moveAcross(0.5 * gap * fontHeight());
-  mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
+}
-/* code for binary operator (+, -, *, /) expressions */
+/* Code for binary operator (+, -, *, /) expressions */
-/* NOTE that gaps are specified as proportions of the current font height */
+/* NOTE that gaps are specified as proportions */
+/* of the current font height */
 static double binGapBefore(SEXP beforeOperand)
+{
-  return 0.2;
+    return 0.2;
+}
 static double binGapBetween(SEXP operand1, SEXP operand2)
+{
     return 0;
     return 0.2;
+}
 static BBOX binBBox(SEXP expr)
+{
-	SEXP operator, operand1, operand2;
+    SEXP operator, operand1, operand2;
-	BBOX middleBBox;
+    BBOX middleBBox;
-	operator = CAR(expr);
+    operator = CAR(expr);
-	operand1 = CADR(expr);
+    operand1 = CADR(expr);
-        setGapCEX();
+    setGapCEX();
-	if(length(expr) == 3) {
+    if(length(expr) == 3) {
-		operand2 = CADDR(expr);
+	operand2 = CADDR(expr);
-		if (multiplicationOperator(operator))
+	if (multiplicationOperator(operator))
-			middleBBox =
+	    middleBBox =
-			  correctionBetweenBBox(operand1, operand2);
+		correctionBetweenBBox(operand1, operand2);
-		else
+	else
-			middleBBox =
+	    middleBBox =
-                          combineBBoxes(
+		combineBBoxes(
-                            gapBBox(binGapBefore(operand1)),
+			      gapBBox(binGapBefore(operand1)),
-			    combineBBoxes(atomBBox(operator),
+			      combineBBoxes(atomBBox(operator),
-					  gapBBox(binGapAfter(operand2))));
+					    gapBBox(binGapAfter(operand2))));
-		return combineBBoxes(elementBBox(operand1),
+	return combineBBoxes(elementBBox(operand1),
-				     combineBBoxes(middleBBox,
+			     combineBBoxes(middleBBox,
-						   elementBBox(operand2)));
+					   elementBBox(operand2)));
-	}
+    }
-	else if(length(expr) == 2) {
+    else if(length(expr) == 2) {
-		middleBBox = combineBBoxes(atomBBox(operator),
+	middleBBox = combineBBoxes(atomBBox(operator),
 				   smallgapBBox(binGapAfter(operand1)));
-		return combineBBoxes(middleBBox, elementBBox(operand1));
+	return combineBBoxes(middleBBox, elementBBox(operand1));
-	}
+    }
-	else error("invalid formula\n");
+    else error("invalid formula\n");
+}
 static void drawBin(SEXP expr)
+{
-	SEXP operator, operand1, operand2;
+    SEXP operator, operand1, operand2;
-	operator = CAR(expr);
+    operator = CAR(expr);
-	operand1 = CADR(expr);
+    operand1 = CADR(expr);
-	setGapCEX();
+    setGapCEX();
-	if(length(expr) == 3) {
+    if(length(expr) == 3) {
-		operand2 = CADDR(expr);
+	operand2 = CADDR(expr);
-		drawElement(operand1);
+	drawElement(operand1);
-		if (multiplicationOperator(operator))
+	if (multiplicationOperator(operator))
-		  drawGap(binGapBetween(operand1, operand2));
+	    drawGap(binGapBetween(operand1, operand2));
-		else {
-			drawGap(binGapBefore(operand1));
-			drawAtom(operator);
-			drawGap(binGapAfter(operand2));
-		}
-		drawElement(operand2);
-	}
 	else {
+	    drawGap(binGapBefore(operand1));
-		drawAtom(operator);
+	    drawAtom(operator);
-		drawSmallGap(binGapAfter(operand1));
+	    drawGap(binGapAfter(operand2));
-		drawElement(operand1);
+	}
+	drawElement(operand2);
+    }
+    else {
+	drawAtom(operator);
+	drawSmallGap(binGapAfter(operand1));
+	drawElement(operand1);
+    }
+}
-/* code for superscript and subscript expressions */
+/* Code for superscript and subscript expressions */
 static BBOX supsubBBox(SEXP body, SEXP superscript, SEXP subscript);
 static BBOX superscriptBBox(SEXP superscript)
+{
-	BBOX result;
+    BBOX result;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-	result = elementBBox(superscript);
+    result = elementBBox(superscript);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-	return result;
+    return result;
+}
 static BBOX supBBox(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	SEXP superscript = CADDR(expr);
+    SEXP superscript = CADDR(expr);
-	int supsub = 0;
+    int supsub = 0;
-	if (formulaExpression(body))
+    if (formulaExpression(body))
-		if (subAtom(CAR(body)))
+	if (subAtom(CAR(body)))
-			supsub = 1;
+	    supsub = 1;
-	if (supsub)
+    if (supsub)
-		return supsubBBox(CADR(body), superscript, (CADDR(body)));
+	return supsubBBox(CADR(body), superscript, (CADDR(body)));
-	else
+    else
-		return combineBBoxes(
+	return combineBBoxes(elementBBox(body),
-			 elementBBox(body),
-			 combineBBoxes(
-			   correctionWithinBBox(body),
+			     combineBBoxes(correctionWithinBBox(body),
-			   shiftBBox(superscriptBBox(superscript),
+					   shiftBBox(superscriptBBox(superscript),
-				     superscriptShift(body, superscript))));
+						     superscriptShift(body, superscript))));
+}
 static BBOX subscriptBBox(SEXP subscript)
+{
-	BBOX result;
+    BBOX result;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-	result = elementBBox(subscript);
+    result = elementBBox(subscript);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-	return result;
+    return result;
+}
 static BBOX subBBox(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	SEXP subscript = CADDR(expr);
+    SEXP subscript = CADDR(expr);
-	return combineBBoxes(elementBBox(body),
+    return combineBBoxes(elementBBox(body),
-		             shiftBBox(subscriptBBox(subscript),
+			 shiftBBox(subscriptBBox(subscript),
-			               subscriptShift(body, subscript, 1)));
+				   subscriptShift(body, subscript, 1)));
+}
 static BBOX supsubBBox(SEXP body, SEXP superscript, SEXP subscript)
+{
-	double supShift, subShift;
+    double supShift, subShift;
-	supsubShift(body, superscript, subscript, &supShift, &subShift);
+    supsubShift(body, superscript, subscript, &supShift, &subShift);
-	return combineBBoxes(
+    return combineBBoxes(elementBBox(body),
-		 elementBBox(body),
-		 combineAlignedBBoxes(
+	       combineAlignedBBoxes(
-		   combineBBoxes(
-		     correctionWithinBBox(body),
+	           combineBBoxes(correctionWithinBBox(body),
-		     shiftBBox(superscriptBBox(superscript), supShift)),
+			    shiftBBox(superscriptBBox(superscript), supShift)),
 		   shiftBBox(subscriptBBox(subscript), subShift)));
+}
 static void drawScriptElement(SEXP expr)
+{
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-	drawElement(expr);
+    drawElement(expr);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
+}
 static void drawSupSub(SEXP body, SEXP superscript, SEXP subscript);
 static void drawSuper(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	SEXP superscript = CADDR(expr);
+    SEXP superscript = CADDR(expr);
-	double supShift = superscriptShift(body, superscript);
+    double supShift = superscriptShift(body, superscript);
-	int supsub = 0;
+    int supsub = 0;
-	if (formulaExpression(body))
+    if (formulaExpression(body))
-		if (subAtom(CAR(body)))
+	if (subAtom(CAR(body)))
-			supsub = 1;
+	    supsub = 1;
-	if (supsub)
+    if (supsub)
-		drawSupSub(CADR(body), superscript, CADDR(body));
+	drawSupSub(CADR(body), superscript, CADDR(body));
-	else {
+    else {
-		drawElement(body);
+	drawElement(body);
-		drawCorrectionWithin(body);
+	drawCorrectionWithin(body);
-		moveUp(supShift);
+	moveUp(supShift);
-		drawScriptElement(superscript);
+	drawScriptElement(superscript);
-		moveUp(-supShift);
+	moveUp(-supShift);
-	}
+    }
+}
 static void drawSub(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	SEXP subscript = CADDR(expr);
+    SEXP subscript = CADDR(expr);
-	double subShift = subscriptShift(body, subscript, 1);
+    double subShift = subscriptShift(body, subscript, 1);
-	drawElement(body);
+    drawElement(body);
-	moveUp(-subShift);
+    moveUp(-subShift);
-	drawScriptElement(subscript);
+    drawScriptElement(subscript);
-	moveUp(subShift);
+    moveUp(subShift);
+}
 static void drawSupSub(SEXP body, SEXP superscript, SEXP subscript)
+{
-	double supShift, subShift;
+    double supShift, subShift;
-	double savedX, savedY;
+    double savedX, savedY;
-	BBOX supBBox = elementBBox(superscript);
+    BBOX supBBox = elementBBox(superscript);
-	BBOX subBBox = elementBBox(subscript);
+    BBOX subBBox = elementBBox(subscript);
-	supsubShift(body, superscript, subscript, &supShift, &subShift);
+    supsubShift(body, superscript, subscript, &supShift, &subShift);
-	drawElement(body);
+    drawElement(body);
-	savedX = currentX;
+    savedX = currentX;
-	savedY = currentY;
+    savedY = currentY;
-	drawCorrectionWithin(body);
+    drawCorrectionWithin(body);
-	moveUp(supShift);
+    moveUp(supShift);
-	drawScriptElement(superscript);
+    drawScriptElement(superscript);
-	moveTo(savedX, savedY);
+    moveTo(savedX, savedY);
-	moveUp(-subShift);
+    moveUp(-subShift);
-	drawScriptElement(subscript);
+    drawScriptElement(subscript);
-	moveTo(savedX, savedY);
+    moveTo(savedX, savedY);
-	moveAcross(max(bboxWidth(supBBox), bboxWidth(subBBox)));
+    moveAcross(max(bboxWidth(supBBox), bboxWidth(subBBox)));
+}
 /* code for accented expressions (hat, bar, ...) */
 static BBOX hatBBox(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	return combineAlignedBBoxes(bodyBBox,
+    return combineAlignedBBoxes(bodyBBox,
-				    makeBBox(bboxHeight(bodyBBox) +
+				makeBBox(bboxHeight(bodyBBox) +
-					     customAccentGap() +
+					 customAccentGap() +
-					     customHatHeight(), 0, 0));
+					 customHatHeight(), 0, 0));
+}
 static BBOX barBBox(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	return combineAlignedBBoxes(bodyBBox,
+    return combineAlignedBBoxes(bodyBBox,
-				    makeBBox(bboxHeight(bodyBBox) +
+				makeBBox(bboxHeight(bodyBBox) +
-					     customAccentGap(), 0, 0));
+					 customAccentGap(), 0, 0));
+}
 static BBOX accentBBox(SEXP expr)
+{
-	SEXP accent = CAR(expr);
+    SEXP accent = CAR(expr);
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	if (hatAtom(accent))
+    if (hatAtom(accent))
-		return hatBBox(body);
+	return hatBBox(body);
-	else if (barAtom(accent))
+    else if (barAtom(accent))
-		return barBBox(body);
+	return barBBox(body);
-	else
+    else
-		return combineAlignedBBoxes(
+	return combineAlignedBBoxes(elementBBox(body),
-						   elementBBox(body),
-		combineBBoxes(makeBBox(accentHShift(body, accent), 0, 0),
+		    combineBBoxes(makeBBox(accentHShift(body, accent), 0, 0),
-			      shiftBBox(asciiBBox(accentAscii(accent)),
+				  shiftBBox(asciiBBox(accentAscii(accent)),
-					accentVShift(body))));
+					    accentVShift(body))));
+}
 static void drawHat(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	double width = bboxWidth(bodyBBox);
+    double width = bboxWidth(bodyBBox);
-	double savedX = currentX;
+    double savedX = currentX;
-	double savedY = currentY;
+    double savedY = currentY;
-	double x[3], y[3];
+    double x[3], y[3];
-	moveUp(bboxHeight(bodyBBox) + customAccentGap());
+    moveUp(bboxHeight(bodyBBox) + customAccentGap());
-	x[0] = convertedX(); y[0] = convertedY();
+    x[0] = convertedX(); y[0] = convertedY();
-	moveUp(customHatHeight());
+    moveUp(customHatHeight());
-	moveAcross(width / 2);
+    moveAcross(width / 2);
-	x[1] = convertedX(); y[1] = convertedY();
+    x[1] = convertedX(); y[1] = convertedY();
-	moveUp(-customHatHeight());
+    moveUp(-customHatHeight());
-	moveAcross(width / 2);
+    moveAcross(width / 2);
-	x[2] = convertedX(); y[2] = convertedY();
+    x[2] = convertedX(); y[2] = convertedY();
-	GPolyline(3, x, y, INCHES, mathDevice);
+    GPolyline(3, x, y, INCHES, mathDevice);
-	moveTo(savedX, savedY);
+    moveTo(savedX, savedY);
-	drawElement(body);
+    drawElement(body);
+}
 static void drawBar(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	double savedX = currentX;
+    double savedX = currentX;
-	double savedY = currentY;
+    double savedY = currentY;
-	double x[2], y[2];
+    double x[2], y[2];
-	moveUp(bboxHeight(bodyBBox) + customAccentGap());
+    moveUp(bboxHeight(bodyBBox) + customAccentGap());
-	x[0] = convertedX(); y[0] = convertedY();
+    x[0] = convertedX(); y[0] = convertedY();
-	moveAcross(bboxWidth(bodyBBox));
+    moveAcross(bboxWidth(bodyBBox));
-	x[1] = convertedX(); y[1] = convertedY();
+    x[1] = convertedX(); y[1] = convertedY();
-	GPolyline(2, x, y, INCHES, mathDevice);
+    GPolyline(2, x, y, INCHES, mathDevice);
-	moveTo(savedX, savedY);
+    moveTo(savedX, savedY);
-	drawElement(body);
+    drawElement(body);
+}
 static void drawAccent(SEXP expr)
+{
-	SEXP accent = CAR(expr);
+    SEXP accent = CAR(expr);
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	double savedX = currentX;
+    double savedX = currentX;
-	double savedY = currentY;
+    double savedY = currentY;
-	if (hatAtom(accent))
+    if (hatAtom(accent))
-		drawHat(body);
+	drawHat(body);
-	else if (barAtom(accent))
+    else if (barAtom(accent))
-		drawBar(body);
+	drawBar(body);
-	else {
+    else {
-		moveAcross(accentHShift(body, accent));
+	moveAcross(accentHShift(body, accent));
-		moveUp(accentVShift(body));
+	moveUp(accentVShift(body));
-		drawAscii(accentAscii(accent));
+	drawAscii(accentAscii(accent));
-		moveTo(savedX, savedY);
+	moveTo(savedX, savedY);
-		drawElement(body);
+	drawElement(body);
-	}
+    }
+}
-/* code for fraction expressions (over) */
+/* Code for fraction expressions (over) */
 static BBOX fractionBBox(SEXP expr)
+{
-	SEXP numerator = CADR(expr);
+    SEXP numerator = CADR(expr);
-	SEXP denominator = CADDR(expr);
+    SEXP denominator = CADDR(expr);
-	BBOX numBBox, denomBBox;
+    BBOX numBBox, denomBBox;
-	double numHShift, denomHShift;
+    double numHShift, denomHShift;
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
 #ifdef OLD
-	mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
 #else
-	mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
 #endif
-	numBBox = elementBBox(numerator);
+    numBBox = elementBBox(numerator);
-	denomBBox = elementBBox(denominator);
+    denomBBox = elementBBox(denominator);
 #ifdef OLD
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #else
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
 #endif
-	numdenomHShift(numerator, denominator, &numHShift, &denomHShift);
+    numdenomHShift(numerator, denominator, &numHShift, &denomHShift);
-	return combineAlignedBBoxes(
+    return combineAlignedBBoxes(
-	     shiftBBox(combineBBoxes(makeBBox(numHShift, 0, 0), numBBox),
+	      shiftBBox(combineBBoxes(makeBBox(numHShift, 0, 0), numBBox),
-		       numeratorVShift(numerator)),
+			numeratorVShift(numerator)),
-	 shiftBBox(combineBBoxes(makeBBox(denomHShift, 0, 0), denomBBox),
+	      shiftBBox(combineBBoxes(makeBBox(denomHShift, 0, 0), denomBBox),
-		   -denominatorVShift(denominator)));
+			-denominatorVShift(denominator)));
+}
 static void drawRatioElement(SEXP expr)
+{
-	float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-	mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * ratioScale;
-	drawElement(expr);
+    drawElement(expr);
-	mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
+}
 static void drawFraction(SEXP expr)
+{
-	SEXP numerator = CADR(expr);
+    SEXP numerator = CADR(expr);
-	SEXP denominator = CADDR(expr);
+    SEXP denominator = CADDR(expr);
-	double savedX = currentX;
+    double savedX = currentX;
-	double savedY = currentY;
+    double savedY = currentY;
-	double fWidth = fractionWidth(numerator, denominator);
+    double fWidth = fractionWidth(numerator, denominator);
-	double numHShift, denomHShift;
+    double numHShift, denomHShift;
-	double x[2], y[2];
+    double x[2], y[2];
-	numdenomHShift(numerator, denominator, &numHShift, &denomHShift);
+    numdenomHShift(numerator, denominator, &numHShift, &denomHShift);
-	moveAcross(numHShift);
+    moveAcross(numHShift);
-	moveUp(numeratorVShift(numerator));
+    moveUp(numeratorVShift(numerator));
 #ifdef OLD
-	drawScriptElement(numerator);
+    drawScriptElement(numerator);
 #else
-	drawRatioElement(numerator);
+    drawRatioElement(numerator);
 #endif
-	moveTo(savedX, savedY);
+    moveTo(savedX, savedY);
-	moveUp(axisHeight());
+    moveUp(axisHeight());
-	x[0] = convertedX(); y[0] = convertedY();
+    x[0] = convertedX(); y[0] = convertedY();
-	moveAcross(fWidth);
+    moveAcross(fWidth);
-	x[1] = convertedX(); y[1] = convertedY();
+    x[1] = convertedX(); y[1] = convertedY();
-	GPolyline(2, x, y, INCHES, mathDevice);
+    GPolyline(2, x, y, INCHES, mathDevice);
-	moveTo(savedX, savedY);
+    moveTo(savedX, savedY);
-	moveAcross(denomHShift);
+    moveAcross(denomHShift);
-	moveUp(-denominatorVShift(denominator));
+    moveUp(-denominatorVShift(denominator));
 #ifdef OLD
-	drawScriptElement(denominator);
+    drawScriptElement(denominator);
 #else
-	drawRatioElement(denominator);
+    drawRatioElement(denominator);
 #endif
-	moveTo(savedX + fWidth, savedY);
+    moveTo(savedX + fWidth, savedY);
+}
 /* code for group expressions (expressions within parentheses) */
 static BBOX groupBBox(SEXP expr)
+{
-	return combineBBoxes(
+    return combineBBoxes(
-		 asciiBBox(groupOpenAscii()),
+	      asciiBBox(groupOpenAscii()),
-		 combineBBoxes(
-		   elementBBox(CADR(expr)),
+	      combineBBoxes(elementBBox(CADR(expr)),
-		   combineBBoxes(correctionWithinBBox(CADR(expr)),
+			    combineBBoxes(correctionWithinBBox(CADR(expr)),
-				 asciiBBox(groupCloseAscii()))));
+					  asciiBBox(groupCloseAscii()))));
+}
 static void drawGroup(SEXP expr)
+{
-	drawAscii(groupOpenAscii());
+    drawAscii(groupOpenAscii());
-	drawElement(CADR(expr));
+    drawElement(CADR(expr));
-	drawCorrectionWithin(CADR(expr));
+    drawCorrectionWithin(CADR(expr));
-	drawAscii(groupCloseAscii());
+    drawAscii(groupCloseAscii());
+}
 /* code for operator expressions (sum, product, integral) */
 /* NOTE that gaps are specified as proportions of the current font height */
 static double integralBottomShift() { return -0.5 * fontHeight(); }
 static BBOX theOperatorBBox(SEXP operator)
+{
-  if (integralOperator(operator))
+    if (integralOperator(operator))
-    return combineAlignedBBoxes(
+	return combineAlignedBBoxes(
-	     shiftBBox(asciiBBox(integralAscii(1)), integralTopShift()),
+		  shiftBBox(asciiBBox(integralAscii(1)), integralTopShift()),
-	     combineAlignedBBoxes(asciiBBox(integralAscii(2)),
+		  combineAlignedBBoxes(asciiBBox(integralAscii(2)),
-				  shiftBBox(asciiBBox(integralAscii(3)),
+				       shiftBBox(asciiBBox(integralAscii(3)),
-					    integralBottomShift())));
+						 integralBottomShift())));
-  else
+    else
-    return asciiBBox(operatorAscii(operator));
+	return asciiBBox(operatorAscii(operator));
+}
 static int useRelGap = 1;
 static BBOX operatorLimitBBox(SEXP limit)
+{
-  float cexSaved = mathDevice->gp.cex;
+    float cexSaved = mathDevice->gp.cex;
-  BBOX limitBBox;
+    BBOX limitBBox;
-  mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
+    mathDevice->gp.cex = mathDevice->gp.cex * scriptScale;
-  useRelGap = 0;
+    useRelGap = 0;
-  limitBBox = elementBBox(limit);
+    limitBBox = elementBBox(limit);
-  useRelGap = 1;
+    useRelGap = 1;
-  mathDevice->gp.cex = cexSaved;
+    mathDevice->gp.cex = cexSaved;
-  return limitBBox;
+    return limitBBox;
+}
 static BBOX operatorBBox(SEXP expr)
+{
-  SEXP operator = CAR(expr);
+    SEXP operator = CAR(expr);
-  SEXP body, lower, upper;
+    SEXP body, lower, upper;
-  BBOX opBBox = theOperatorBBox(operator);
+    BBOX opBBox = theOperatorBBox(operator);
-  BBOX bodyBBox, lowerBBox, upperBBox;
+    BBOX bodyBBox, lowerBBox, upperBBox;
-  setGapCEX();
+    setGapCEX();
-  if (length(expr) > 1) {
+    if (length(expr) > 1) {
-    body = CADR(expr);
+	body = CADR(expr);
-    bodyBBox = combineBBoxes(opBBox,
+	bodyBBox = combineBBoxes(
+		      opBBox,
-                             combineBBoxes(gapBBox(operatorGap(body)),
+		      combineBBoxes(gapBBox(operatorGap(body)),
-					   elementBBox(body)));
+				    elementBBox(body)));
-    if (length(expr) > 2) {
+	if (length(expr) > 2) {
-      lower = CADDR(expr);
+	    lower = CADDR(expr);
-      lowerBBox = operatorLimitBBox(lower);
+	    lowerBBox = operatorLimitBBox(lower);
+	    if (length(expr) > 3) {
+		upper = CADDDR(expr);
+		upperBBox = operatorLimitBBox(upper);
-      if (length(expr) > 3) {
-	upper = CADDDR(expr);
-	upperBBox = operatorLimitBBox(upper);
-	return combineAlignedBBoxes(
+		return combineAlignedBBoxes(
-		 combineBBoxes(
+			 combineBBoxes(
+			   makeBBox(
-                   makeBBox(operatorHShiftAll(operator, lower, upper), 0, 0),
+			     operatorHShiftAll(operator,lower, upper),
+, 0),
-		   bodyBBox),
+			   bodyBBox),
-		 combineAlignedBBoxes(
+			 combineAlignedBBoxes(
-                   shiftBBox(
+			   shiftBBox(
-                     combineBBoxes(
+                             combineBBoxes(
+			       makeBBox(
-                       makeBBox(operatorUpperHShiftAll(operator, lower, upper),
+                                 operatorUpperHShiftAll(
+				   operator,lower, upper),
 , 0),
-		       upperBBox),
+			       upperBBox),
-		     operatorUpperShift(operator, upper)),
+			     operatorUpperShift(operator, upper)),
-		   shiftBBox(
+			   shiftBBox(
+                             combineBBoxes(
-		     combineBBoxes(
+			       makeBBox(
+				 operatorLowerHShiftAll(
-		       makeBBox(operatorLowerHShiftAll(operator, lower, upper),
+				   operator, lower, upper),
 , 0),
-		       lowerBBox),
+			       lowerBBox),
-		     operatorLowerShift(operator, lower))));
+			     operatorLowerShift(operator, lower))));
-      }
+	    }
-      else
+	    else
-	return combineAlignedBBoxes(
+		return combineAlignedBBoxes(
-                 combineBBoxes(
+			 combineBBoxes(
+			   makeBBox(
-		   makeBBox(operatorHShift(operator, lower), 0, 0),
+			     operatorHShift(operator, lower), 0, 0),
-		   bodyBBox),
+			   bodyBBox),
-		 shiftBBox(
+			 shiftBBox(
-		   combineBBoxes(
+			   combineBBoxes(
-		     makeBBox(operatorLowerHShift(operator, lower), 0, 0),
+			     makeBBox(operatorLowerHShift(operator, lower),
+, 0),
-		     lowerBBox),
+			     lowerBBox),
-		   operatorLowerShift(operator, lower)));
+			   operatorLowerShift(operator, lower)));
+	}
+	else
+	    return bodyBBox;
+    }
     else
-      return bodyBBox;
-  }
-  else
-    error("Invalid Formula\n");
+	error("Invalid Formula\n");
+}
 static void drawTheOperator(SEXP operator)
+{
-  if (integralOperator(operator)) {
+    if (integralOperator(operator)) {
-    double savedX = currentX;
+	double savedX = currentX;
-    double savedY = currentY;
+	double savedY = currentY;
-    moveUp(integralTopShift());
+	moveUp(integralTopShift());
-    drawAscii(integralAscii(1));
+	drawAscii(integralAscii(1));
-    moveTo(savedX, savedY);
+	moveTo(savedX, savedY);
-    moveUp(integralBottomShift());
+	moveUp(integralBottomShift());
-    drawAscii(integralAscii(3));
+	drawAscii(integralAscii(3));
-    moveTo(savedX, savedY);
+	moveTo(savedX, savedY);
-    drawAscii(integralAscii(2));
+	drawAscii(integralAscii(2));
-  }
+    }
-  else
+    else
-    drawAscii(operatorAscii(operator));
+	drawAscii(operatorAscii(operator));
+}
 static void drawOperatorLimit(SEXP limit)
+{
-  useRelGap = 0;
+    useRelGap = 0;
-  drawScriptElement(limit);
+    drawScriptElement(limit);
-  useRelGap = 1;
+    useRelGap = 1;
+}
 static void drawOperator(SEXP expr)
+{
-  SEXP operator = CAR(expr);
+    SEXP operator = CAR(expr);
-  SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-  SEXP lower, upper;
+    SEXP lower, upper;
-  double savedX = currentX;
+    double savedX = currentX;
-  double savedY = currentY;
+    double savedY = currentY;
-  setGapCEX();
+    setGapCEX();
-  if (length(expr) > 2) {
+    if (length(expr) > 2) {
-    lower = CADDR(expr);
+	lower = CADDR(expr);
-    if (length(expr) > 3) {
+	if (length(expr) > 3) {
-      upper = CADDDR(expr);
+	    upper = CADDDR(expr);
-      moveUp(operatorUpperShift(operator, upper));
+	    moveUp(operatorUpperShift(operator, upper));
-      moveAcross(operatorUpperHShiftAll(operator, lower, upper));
+	    moveAcross(operatorUpperHShiftAll(operator, lower, upper));
-      drawOperatorLimit(upper);
+	    drawOperatorLimit(upper);
-      moveTo(savedX, savedY);
+	    moveTo(savedX, savedY);
-      moveUp(-operatorLowerShift(operator, lower));
+	    moveUp(-operatorLowerShift(operator, lower));
-      moveAcross(operatorLowerHShiftAll(operator, lower, upper));
+	    moveAcross(operatorLowerHShiftAll(operator, lower, upper));
-      drawOperatorLimit(lower);
+	    drawOperatorLimit(lower);
-      moveTo(savedX, savedY);
+	    moveTo(savedX, savedY);
-      moveAcross(operatorHShiftAll(operator, lower, upper));
+	    moveAcross(operatorHShiftAll(operator, lower, upper));
-    }
+	}
-    else{
+	else{
-      moveUp(-operatorLowerShift(operator, lower));
+	    moveUp(-operatorLowerShift(operator, lower));
-      moveAcross(operatorLowerHShift(operator, lower));
+	    moveAcross(operatorLowerHShift(operator, lower));
-      drawOperatorLimit(lower);
+	    drawOperatorLimit(lower);
-      moveTo(savedX, savedY);
+	    moveTo(savedX, savedY);
-      moveAcross(operatorHShift(operator, lower));
+	    moveAcross(operatorHShift(operator, lower));
+	}
+    }
-  }
-  drawTheOperator(operator);
+    drawTheOperator(operator);
-  drawGap(operatorGap(body));
+    drawGap(operatorGap(body));
-  drawElement(body);
+    drawElement(body);
+}
-/* code for radical expressions (root) */
+/* Code for radical expressions (root) */
 static BBOX customRadicalBBox(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	return combineBBoxes(makeBBox(bboxHeight(bodyBBox) + customRadicalGap(),
+    return combineBBoxes(makeBBox(bboxHeight(bodyBBox) + customRadicalGap(),
 , customRadicalWidth()),
-		      combineBBoxes(makeBBox(0, 0, customRadicalSpace()),
+			 combineBBoxes(makeBBox(0, 0, customRadicalSpace()),
-				    bodyBBox));
+				       bodyBBox));
+}
 static BBOX radicalBBox(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	return customRadicalBBox(body);
+    return customRadicalBBox(body);
+}
 static void drawCustomRadical(SEXP body)
+{
-	BBOX bodyBBox = elementBBox(body);
+    BBOX bodyBBox = elementBBox(body);
-	double height = bboxHeight(bodyBBox);
+    double height = bboxHeight(bodyBBox);
-	double depth = bboxDepth(bodyBBox);
+    double depth = bboxDepth(bodyBBox);
-	double width = bboxWidth(bodyBBox);
+    double width = bboxWidth(bodyBBox);
-	double twiddleHeight = (height - depth) / 2;
+    double twiddleHeight = (height - depth) / 2;
-	double savedX = currentX;
+    double savedX = currentX;
-	double savedY = currentY;
+    double savedY = currentY;
-	double x[5], y[5];
+    double x[5], y[5];
-	moveUp(0.8 * twiddleHeight);
+    moveUp(0.8 * twiddleHeight);
-	x[0] = convertedX(); y[0] = convertedY();
+    x[0] = convertedX(); y[0] = convertedY();
-	moveUp(0.2 * twiddleHeight);
+    moveUp(0.2 * twiddleHeight);
-	moveAcross(0.3 * customRadicalWidth());
+    moveAcross(0.3 * customRadicalWidth());
-	x[1] = convertedX(); y[1] = convertedY();
+    x[1] = convertedX(); y[1] = convertedY();
-	moveUp(-(twiddleHeight + depth));
+    moveUp(-(twiddleHeight + depth));
-	moveAcross(0.3 * customRadicalWidth());
+    moveAcross(0.3 * customRadicalWidth());
-	x[2] = convertedX(); y[2] = convertedY();
+    x[2] = convertedX(); y[2] = convertedY();
-	moveUp(depth + height + customRadicalGap());
+    moveUp(depth + height + customRadicalGap());
-	moveAcross(0.4 * customRadicalWidth());
+    moveAcross(0.4 * customRadicalWidth());
-	x[3] = convertedX(); y[3] = convertedY();
+    x[3] = convertedX(); y[3] = convertedY();
-	moveAcross(customRadicalSpace() + width);
+    moveAcross(customRadicalSpace() + width);
-	x[4] = convertedX(); y[4] = convertedY();
+    x[4] = convertedX(); y[4] = convertedY();
-	GPolyline(5, x, y, INCHES, mathDevice);
+    GPolyline(5, x, y, INCHES, mathDevice);
-	moveTo(savedX, savedY);
+    moveTo(savedX, savedY);
-	moveAcross(customRadicalWidth() + customRadicalSpace());
+    moveAcross(customRadicalWidth() + customRadicalSpace());
-	drawElement(body);
+    drawElement(body);
+}
 static void drawRadical(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	drawCustomRadical(body);
+    drawCustomRadical(body);
+}
-/* code for absolute expressions (abs) */
+/* Code for absolute expressions (abs). */
 static BBOX absBBox(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	return combineBBoxes(makeBBox(0, 0, absSpace()),
+    return combineBBoxes(makeBBox(0, 0, absSpace()),
-			     combineBBoxes(elementBBox(body),
+			 combineBBoxes(elementBBox(body),
-					   makeBBox(0, 0, absSpace())));
+				       makeBBox(0, 0, absSpace())));
+}
 static void drawAbs(SEXP expr)
+{
-	SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-	BBOX bodyBBox = elementBBox(expr);
+    BBOX bodyBBox = elementBBox(expr);
-	double height = bboxHeight(bodyBBox);
+    double height = bboxHeight(bodyBBox);
-	double depth = bboxDepth(bodyBBox);
+    double depth = bboxDepth(bodyBBox);
-	double x[2], y[2];
+    double x[2], y[2];
-	moveUp(-depth);
+    moveUp(-depth);
-	x[0] = convertedX(); y[0] = convertedY();
+    x[0] = convertedX(); y[0] = convertedY();
-	moveUp(depth + height);
+    moveUp(depth + height);
-	x[1] = convertedX(); y[1] = convertedY();
+    x[1] = convertedX(); y[1] = convertedY();
-	GPolyline(2, x, y, INCHES, mathDevice);
+    GPolyline(2, x, y, INCHES, mathDevice);
-	moveUp(-height);
+    moveUp(-height);
-	moveAcross(absSpace());
+    moveAcross(absSpace());
-	drawElement(body);
+    drawElement(body);
-	moveAcross(absSpace());
+    moveAcross(absSpace());
-	moveUp(-depth);
+    moveUp(-depth);
-	x[0] = convertedX(); y[0] = convertedY();
+    x[0] = convertedX(); y[0] = convertedY();
-	moveUp(depth + height);
+    moveUp(depth + height);
-	x[1] = convertedX(); y[1] = convertedY();
+    x[1] = convertedX(); y[1] = convertedY();
-	GPolyline(2, x, y, INCHES, mathDevice);
+    GPolyline(2, x, y, INCHES, mathDevice);
-	moveUp(-height);
+    moveUp(-height);
+}
-/* code for general expressions with no special meaning in */
+/* Code for general expressions with no special meaning */
-/* mathematical notation syntax (e.g., f(x)) */
+/* in mathematical notation syntax (e.g., f(x)) */
 static BBOX expressionBBox(SEXP expr)
+{
-	int i;
+    int i;
-	int numParams = length(expr) - 1;
+    int numParams = length(expr) - 1;
-	BBOX resultBBox = elementBBox(CAR(expr));
+    BBOX resultBBox = elementBBox(CAR(expr));
-        SEXP lastTerm;
+    SEXP lastTerm;
+    lastTerm = CAR(expr);
+    expr = CDR(expr);
+    resultBBox = combineBBoxes(resultBBox, asciiBBox(groupOpenAscii()));
+    for (i = 0; i < numParams; i++) {
+	resultBBox = combineBBoxes(resultBBox, elementBBox(CAR(expr)));
 	lastTerm = CAR(expr);
 	expr = CDR(expr);
-	resultBBox = combineBBoxes(resultBBox, asciiBBox(groupOpenAscii()));
-	for (i = 0; i < numParams; i++) {
-		resultBBox = combineBBoxes(resultBBox, elementBBox(CAR(expr)));
-	        lastTerm = CAR(expr);
-		expr = CDR(expr);
-		if (i < numParams - 1)
+	if (i < numParams - 1)
-			resultBBox = combineBBoxes(resultBBox,
+	    resultBBox = combineBBoxes(resultBBox,
-				   combineBBoxes(asciiBBox(commaAscii()),
+				       combineBBoxes(asciiBBox(commaAscii()),
-					       asciiBBox(spaceAscii())));
+						     asciiBBox(spaceAscii())));
-	}
+    }
-	return combineBBoxes(resultBBox,
+    return combineBBoxes(resultBBox,
-			     combineBBoxes(correctionWithinBBox(lastTerm),
+			 combineBBoxes(correctionWithinBBox(lastTerm),
-					   asciiBBox(groupCloseAscii())));
+				       asciiBBox(groupCloseAscii())));
+}
 static void drawExpression(SEXP expr)
+{
-	int i;
+    int i;
-	int numParams = length(expr) - 1;
+    int numParams = length(expr) - 1;
-	SEXP lastTerm;
+    SEXP lastTerm;
+    drawElement(CAR(expr));
+    lastTerm = CAR(expr);
+    expr = CDR(expr);
+    drawAscii(groupOpenAscii());
+    for (i = 0; i < numParams; i++) {
 	drawElement(CAR(expr));
 	lastTerm = CAR(expr);
 	expr = CDR(expr);
-	drawAscii(groupOpenAscii());
-	for (i = 0; i < numParams; i++) {
-		drawElement(CAR(expr));
-	        lastTerm = CAR(expr);
-		expr = CDR(expr);
-		if (i < numParams - 1) {
+	if (i < numParams - 1) {
-			drawAscii(commaAscii());
+	    drawAscii(commaAscii());
-			drawAscii(spaceAscii());
+	    drawAscii(spaceAscii());
-		}
+	}
+    }
-	drawCorrectionWithin(lastTerm);
+    drawCorrectionWithin(lastTerm);
-	drawAscii(groupCloseAscii());
+    drawAscii(groupCloseAscii());
+}
-/* code for curly expressions (i.e., { ... } ) */
+/* Code for curly expressions (i.e., { ... } ) */
 static BBOX curlyBBox(SEXP expr)
+{
-	return expressionBBox(CADR(expr));
+    return expressionBBox(CADR(expr));
+}
 static void drawFormula(SEXP);
 static void drawCurly(SEXP expr)
+{
-	drawFormula(CADR(expr));
+    drawFormula(CADR(expr));
+}
 /* code for relation expressions (i.e. ... == ...) */
 static double relGap()
+{
-  if (useRelGap)
+    if (useRelGap)
-    return 0.3;
+	return 0.3;
-  else
+    else
-    return 0.1;
+	return 0.1;
+}
 static BBOX relBBox(SEXP expr)
+{
-  SEXP arg1 = CADR(expr);
+    SEXP arg1 = CADR(expr);
-  SEXP arg2 = CADDR(expr);
+    SEXP arg2 = CADDR(expr);
-  return combineBBoxes(
+    return combineBBoxes(
-	   elementBBox(arg1),
+	      elementBBox(arg1),
-	   combineBBoxes(
+	      combineBBoxes(
-			 gapBBox(relGap()),
+	         gapBBox(relGap()),
-			 combineBBoxes(
+	         combineBBoxes(
-				       asciiBBox(relAscii()),
+		    asciiBBox(relAscii()),
-				       combineBBoxes(
+		    combineBBoxes(
-						     gapBBox(relGap()),
+		       gapBBox(relGap()),
-						     elementBBox(arg2)))));
+		       elementBBox(arg2)))));
+}
 static void drawRel(SEXP expr)
+{
-  SEXP arg1 = CADR(expr);
+    SEXP arg1 = CADR(expr);
-  SEXP arg2 = CADDR(expr);
+    SEXP arg2 = CADDR(expr);
-  drawElement(arg1);
+    drawElement(arg1);
-  drawGap(relGap());
+    drawGap(relGap());
-  drawAscii(relAscii());
+    drawAscii(relAscii());
-  drawGap(relGap());
+    drawGap(relGap());
-  drawElement(arg2);
+    drawElement(arg2);
+}
 /* code for bold expressions */
 static BBOX boldBBox(SEXP expr)
+{
-  BBOX result;
+    BBOX result;
-  int savedFont = getFont();
+    int savedFont = getFont();
-  boldFont();
+    boldFont();
-  result = elementBBox(CADR(expr));
+    result = elementBBox(CADR(expr));
-  setFont(savedFont);
+    setFont(savedFont);
-  return result;
+    return result;
+}
 static void drawBold(SEXP expr)
+{
-  int savedFont = getFont();
+    int savedFont = getFont();
-  boldFont();
+    boldFont();
-  drawElement(CADR(expr));
+    drawElement(CADR(expr));
-  setFont(savedFont);
+    setFont(savedFont);
+}
 /* code for italic expressions */
 static BBOX italicBBox(SEXP expr)
+{
-  BBOX result;
+    BBOX result;
-  SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-  int savedFont = getFont();
+    int savedFont = getFont();
-  italicFont();
+    italicFont();
-  result = elementBBox(body);
+    result = elementBBox(body);
-  setFont(savedFont);
+    setFont(savedFont);
-  return result;
+    return result;
+}
 static void drawItalic(SEXP expr)
+{
-  SEXP body = CADR(expr);
+    SEXP body = CADR(expr);
-  int savedFont = getFont();
+    int savedFont = getFont();
-  italicFont();
+    italicFont();
-  drawElement(body);
+    drawElement(body);
-  setFont(savedFont);
+    setFont(savedFont);
+}
 /* code for plain expressions */
 static BBOX plainBBox(SEXP expr)
+{
-  BBOX result = nullBBox();
+    BBOX result = nullBBox();
-  int savedFont = getFont();
+    int savedFont = getFont();
-  plainFont();
+    plainFont();
-  result = elementBBox(CADR(expr));
+    result = elementBBox(CADR(expr));
-  setFont(savedFont);
+    setFont(savedFont);
-  return result;
+    return result;
+}
 static void drawPlain(SEXP expr)
+{
-  int savedFont = getFont();
+    int savedFont = getFont();
-  plainFont();
+    plainFont();
-  drawElement(CADR(expr));
+    drawElement(CADR(expr));
-  setFont(savedFont);
+    setFont(savedFont);
+}
 /* code for bolditalic expressions */
 static BBOX boldItalicBBox(SEXP expr)
+{
-  BBOX result;
+    BBOX result;
-  int savedFont = getFont();
+    int savedFont = getFont();
-  boldItalicFont();
+    boldItalicFont();
-  result = elementBBox(CADR(expr));
+    result = elementBBox(CADR(expr));
-  setFont(savedFont);
+    setFont(savedFont);
-  return result;
+    return result;
+}
 static void drawBoldItalic(SEXP expr)
+{
-  int savedFont = getFont();
+    int savedFont = getFont();
-  boldItalicFont();
+    boldItalicFont();
-  drawElement(CADR(expr));
+    drawElement(CADR(expr));
-  setFont(savedFont);
+    setFont(savedFont);
+}
 /* code for concatenating expressions c(...) */
 static BBOX concatenateBBox(SEXP expr)
+{
-  SEXP args = CDR(expr);
+    SEXP args = CDR(expr);
-  SEXP lastArg;
+    SEXP lastArg;
-  int i;
+    int i;
-  int numArgs = length(args);
+    int numArgs = length(args);
-  BBOX result = nullBBox();
+    BBOX result = nullBBox();
-  if (numArgs > 0)
+    if (numArgs > 0)
-  result = elementBBox(CAR(args));
+	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);
-  }
+    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;
+    return result;
+}
 static void drawConcatenate(SEXP expr)
+{
-  SEXP args = CDR(expr);
+    SEXP args = CDR(expr);
-  SEXP lastArg;
+    SEXP lastArg;
-  int i;
+    int i;
-  int numArgs = length(args);
+    int numArgs = length(args);
-  for (i=0; i<numArgs; i++) {
+    for (i=0; i<numArgs; i++) {
-    if (i > 0)
+	if (i > 0)
-      drawCorrectionBetween(lastArg, CAR(args));
+	    drawCorrectionBetween(lastArg, CAR(args));
-    drawElement(CAR(args));
+	drawElement(CAR(args));
-    lastArg = CAR(args);
+	lastArg = CAR(args);
-    args = CDR(args);
+	args = CDR(args);
-  }
+    }
+}
-/* dispatching procedure which determines nature of expression */
+/* Dispatching procedure which determines nature of expression. */
 static BBOX formulaBBox(SEXP expr)
+{
-	SEXP head = CAR(expr);
+    SEXP head = CAR(expr);
-	if (binAtom(head))
+    if (binAtom(head))
-		return binBBox(expr);
+	return binBBox(expr);
-	else if (superAtom(head))
+    else if (superAtom(head))
-		return supBBox(expr);
+	return supBBox(expr);
-	else if (subAtom(head))
+    else if (subAtom(head))
-		return subBBox(expr);
+	return subBBox(expr);
-	else if (accentAtom(head))
+    else if (accentAtom(head))
-		return accentBBox(expr);
+	return accentBBox(expr);
-	else if (fractionAtom(head))
+    else if (fractionAtom(head))
-		return fractionBBox(expr);
+	return fractionBBox(expr);
-	else if (groupAtom(head))
+    else if (groupAtom(head))
-		return groupBBox(expr);
+	return groupBBox(expr);
-	else if (operatorAtom(head))
+    else if (operatorAtom(head))
-		return operatorBBox(expr);
+	return operatorBBox(expr);
-	else if (radicalAtom(head))
+    else if (radicalAtom(head))
-		return radicalBBox(expr);
+	return radicalBBox(expr);
-	else if (absAtom(head))
+    else if (absAtom(head))
-		return absBBox(expr);
+	return absBBox(expr);
-	else if (curlyAtom(head))
+    else if (curlyAtom(head))
-		return curlyBBox(expr);
+	return curlyBBox(expr);
-	else if (relAtom(head))
+    else if (relAtom(head))
-	  return relBBox(expr);
+	return relBBox(expr);
-	else if (boldAtom(head))
+    else if (boldAtom(head))
-	  return boldBBox(expr);
+	return boldBBox(expr);
-	else if (italicAtom(head))
+    else if (italicAtom(head))
-	  return italicBBox(expr);
+	return italicBBox(expr);
-	else if (plainAtom(head))
+    else if (plainAtom(head))
-	  return plainBBox(expr);
+	return plainBBox(expr);
-	else if (boldItalicAtom(head))
+    else if (boldItalicAtom(head))
-	  return boldItalicBBox(expr);
+	return boldItalicBBox(expr);
-	else if (concatenateAtom(head))
+    else if (concatenateAtom(head))
-		return concatenateBBox(expr);
+	return concatenateBBox(expr);
-	else
+    else
-		return expressionBBox(expr);
+	return expressionBBox(expr);
+}
 static void drawFormula(SEXP expr)
+{
-	SEXP head = CAR(expr);
+    SEXP head = CAR(expr);
-	if (binAtom(head))
+    if (binAtom(head))
-		drawBin(expr);
+	drawBin(expr);
-	else if (superAtom(head))
+    else if (superAtom(head))
-		drawSuper(expr);
+	drawSuper(expr);
-	else if (subAtom(head))
+    else if (subAtom(head))
-		drawSub(expr);
+	drawSub(expr);
-	else if (accentAtom(head))
+    else if (accentAtom(head))
-		drawAccent(expr);
+	drawAccent(expr);
-	else if (fractionAtom(head))
+    else if (fractionAtom(head))
-		drawFraction(expr);
+	drawFraction(expr);
-	else if (groupAtom(head))
+    else if (groupAtom(head))
-		drawGroup(expr);
+	drawGroup(expr);
-	else if (operatorAtom(head))
+    else if (operatorAtom(head))
-		drawOperator(expr);
+	drawOperator(expr);
-	else if (radicalAtom(head))
+    else if (radicalAtom(head))
-		drawRadical(expr);
+	drawRadical(expr);
-	else if (absAtom(head))
+    else if (absAtom(head))
-		drawAbs(expr);
+	drawAbs(expr);
-	else if (curlyAtom(head))
+    else if (curlyAtom(head))
-		drawCurly(expr);
+	drawCurly(expr);
-	else if (relAtom(head))
+    else if (relAtom(head))
-	  drawRel(expr);
+	drawRel(expr);
-	else if (boldAtom(head))
+    else if (boldAtom(head))
-	  drawBold(expr);
+	drawBold(expr);
-	else if (italicAtom(head))
+    else if (italicAtom(head))
-	  drawItalic(expr);
+	drawItalic(expr);
-	else if (plainAtom(head))
+    else if (plainAtom(head))
-	  drawPlain(expr);
+	drawPlain(expr);
-	else if (boldItalicAtom(head))
+    else if (boldItalicAtom(head))
-	  drawBoldItalic(expr);
+	drawBoldItalic(expr);
-	else if (concatenateAtom(head))
+    else if (concatenateAtom(head))
-		drawConcatenate(expr);
+	drawConcatenate(expr);
-	/* if expression is not a special mathematical notation */
+    /* if expression is not a special mathematical notation */
-	/* function then just reconstruct expression */
+    /* function then just reconstruct expression */
-	else
+    else
-		drawExpression(expr);
+	drawExpression(expr);
+}
 /* top-level:  dispatch on whether atom (symbol, string, number, ...) */
 /* or formula (some sort of expression) */
 static BBOX elementBBox(SEXP expr)
+{
-	if (formulaExpression(expr))
+    if (formulaExpression(expr))
-		return formulaBBox(expr);
+	return formulaBBox(expr);
-	else
+    else
-		return atomBBox(expr);
+	return atomBBox(expr);
+}
 static void drawElement(SEXP expr)
+{
-	if (formulaExpression(expr))
+    if (formulaExpression(expr))
-		drawFormula(expr);
+	drawFormula(expr);
-	else
+    else
-		drawAtom(expr);
+	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 exprBBox = elementBBox(expr);
-        double w  = exprBBox.width;
+    double w  = exprBBox.width;
-	if (units == INCHES)
+    if (units == INCHES)
-		return w;
+	return w;
-	else
+    else
-		return GConvertXUnits(w, INCHES, units, dd);
+	return GConvertXUnits(w, INCHES, units, dd);
+}
 #define ABS(a)  ((a)>=0 ? (a) : -(a))
 double GExpressionHeight(SEXP expr, int units, DevDesc *dd)
+{
-        BBOX exprBBox = elementBBox(expr);
+    BBOX exprBBox = elementBBox(expr);
-        double h = exprBBox.height + exprBBox.depth;
+    double h = exprBBox.height + exprBBox.depth;
-	if (units == INCHES)
+    if (units == INCHES)
-		return h;
+	return h;
-	else
+    else
-		return GConvertYUnits(h, INCHES, units, dd);
+	return GConvertYUnits(h, INCHES, units, dd);
+}
-		/* functions forming the API */
+/* Functions forming the API */
 void GMathText(double x, double y, int coords, SEXP expr,
 	       double xc, double yc, double rot, DevDesc *dd)
+{
-	BBOX expressionBBox;
+    BBOX expressionBBox;
-	mathDevice = dd;
+    mathDevice = dd;
-	initFormulaSymbols();
+    initFormulaSymbols();
-	expressionBBox = elementBBox(expr);
+    expressionBBox = elementBBox(expr);
-	referenceX = x;
+    referenceX = x;
-	referenceY = y;
+    referenceY = y;
-	GConvert(&referenceX, &referenceY, coords, INCHES, dd);
+    GConvert(&referenceX, &referenceY, coords, INCHES, dd);
-	currentX = referenceX - xc * bboxWidth(expressionBBox);
+    currentX = referenceX - xc * bboxWidth(expressionBBox);
-	currentY = referenceY - yc * bboxHeight(expressionBBox);
+    currentY = referenceY - yc * bboxHeight(expressionBBox);
-	currentAngle = rot;
+    currentAngle = rot;
-	cosAngle = cos(rot / 90 * half_pi);
+    cosAngle = cos(rot / 90 * half_pi);
-	sinAngle = sin(rot / 90 * half_pi);
+    sinAngle = sin(rot / 90 * half_pi);
-	drawElement(expr);
+    drawElement(expr);
+}
 void GMMathText(SEXP str, int side, double line, int outer, double at, int las,
 		DevDesc *dd)
+{
-	int coords;
+    int coords;
-	double a, xadj, yadj;
+    double a, xadj, yadj;
-	mathDevice = dd;
+    mathDevice = dd;
-	if (outer) {
+    if (outer) {
-		switch (side) {
+	switch (side) {
-		case 1:
+	case 1:
-			line = line + 1;
+	    line = line + 1;
-			coords = MAR1;
+	    coords = MAR1;
-			a = 0.0;
+	    a = 0.0;
-			xadj = mathDevice->gp.adj;
+	    xadj = mathDevice->gp.adj;
-			yadj = 0.0;
+	    yadj = 0.0;
-			break;
+	    break;
-		case 2:
+	case 2:
-			coords = MAR2;
+	    coords = MAR2;
-			a = 90.0;
+	    a = 90.0;
-			xadj = mathDevice->gp.adj;
+	    xadj = mathDevice->gp.adj;
-			yadj = 0.0;
+	    yadj = 0.0;
-			break;
+	    break;
-		case 3:
+	case 3:
-			coords = MAR3;
+	    coords = MAR3;
-			a = 0.0;
+	    a = 0.0;
-			xadj = mathDevice->gp.adj;
+	    xadj = mathDevice->gp.adj;
-			yadj = 0.0;
+	    yadj = 0.0;
-			break;
+	    break;
-		case 4:
+	case 4:
-			line = line + 1;
+	    line = line + 1;
-			coords = MAR4;
+	    coords = MAR4;
-			a = 90.0;
+	    a = 90.0;
-			xadj = mathDevice->gp.adj;
+	    xadj = mathDevice->gp.adj;
-			yadj = 0.0;
+	    yadj = 0.0;
-			break;
+	    break;
-		}
-		GMathText(at, line, coords, str, xadj, yadj, a, dd);
+	}
+	GMathText(at, line, coords, str, xadj, yadj, a, dd);
+    }
-	else {
+    else {
-		switch (side) {
+	switch (side) {
-		case 1:
+	case 1:
-			if (las == 2) {
+	    if (las == 2) {
-				at = at - GConvertXUnits(dd->gp.yLineBias,
+		at = at - GConvertXUnits(dd->gp.yLineBias,
-							 LINES, USER, dd);
+					 LINES, USER, dd);
-				line = line + dd->gp.yLineBias;
+		line = line + dd->gp.yLineBias;
-				a = 90.0;
+		a = 90.0;
-				xadj = 1.0;
+		xadj = 1.0;
-				yadj = 0.5;
+		yadj = 0.5;
-			}
+	    }
-			else {
+	    else {
-				line = line + 1 - dd->gp.yLineBias;
+		line = line + 1 - dd->gp.yLineBias;
-				a = 0.0;
+		a = 0.0;
-				xadj = mathDevice->gp.adj;
+		xadj = mathDevice->gp.adj;
-				yadj = 0.0;
+		yadj = 0.0;
-			}
+	    }
-			coords = MAR1;
+	    coords = MAR1;
-			break;
+	    break;
-		case 2:
+	case 2:
-			if (las == 1 || las == 2) {
+	    if (las == 1 || las == 2) {
-				at = at + GConvertYUnits(dd->gp.yLineBias,
+		at = at + GConvertYUnits(dd->gp.yLineBias,
-							 LINES, USER, dd);
+					 LINES, USER, dd);
-				line = line + dd->gp.yLineBias;
+		line = line + dd->gp.yLineBias;
-				a = 0.0;
+		a = 0.0;
-				xadj = 1.0;
+		xadj = 1.0;
-				yadj = 0.5;
+		yadj = 0.5;
-			}
+	    }
-			else {
+	    else {
-				line = line + dd->gp.yLineBias;
+		line = line + dd->gp.yLineBias;
-				a = 90.0;
+		a = 90.0;
-				xadj = mathDevice->gp.adj;
+		xadj = mathDevice->gp.adj;
-				yadj = 0.0;
+		yadj = 0.0;
-			}
+	    }
-			coords = MAR2;
+	    coords = MAR2;
-			break;
+	    break;
-		case 3:
+	case 3:
-			if (las == 2) {
+	    if (las == 2) {
-				at = at - GConvertXUnits(dd->gp.yLineBias,
+		at = at - GConvertXUnits(dd->gp.yLineBias,
-							 LINES, USER, dd);
+					 LINES, USER, dd);
-				line = line + dd->gp.yLineBias;
+		line = line + dd->gp.yLineBias;
-				a = 90.0;
+		a = 90.0;
-				xadj = 0.0;
+		xadj = 0.0;
-				yadj = 0.5;
+		yadj = 0.5;
-			}
+	    }
-			else {
+	    else {
-				line = line + dd->gp.yLineBias;
+		line = line + dd->gp.yLineBias;
-				a = 0.0;
+		a = 0.0;
-				xadj = mathDevice->gp.adj;
+		xadj = mathDevice->gp.adj;
-				yadj = 0.0;
+		yadj = 0.0;
-			}
+	    }
-			coords = MAR3;
+	    coords = MAR3;
-			break;
+	    break;
-		case 4:
+	case 4:
-			if (las == 1 || las == 2) {
+	    if (las == 1 || las == 2) {
-				at = at + GConvertYUnits(dd->gp.yLineBias,
+		at = at + GConvertYUnits(dd->gp.yLineBias,
-							 LINES, USER, dd);
+					 LINES, USER, dd);
-				line = line + dd->gp.yLineBias;
+		line = line + dd->gp.yLineBias;
-				a = 0.0;
+		a = 0.0;
-				xadj = 0.0;
+		xadj = 0.0;
-				yadj = 0.5;
+		yadj = 0.5;
-			}
+	    }
-			else {
+	    else {
-				line = line + 1 - dd->gp.yLineBias;
+		line = line + 1 - dd->gp.yLineBias;
-				a = 90.0;
+		a = 90.0;
-				xadj = mathDevice->gp.adj;
+		xadj = mathDevice->gp.adj;
-				yadj = 0.0;
+		yadj = 0.0;
-			}
+	    }
-			coords = MAR4;
+	    coords = MAR4;
-			break;
+	    break;
-		}
-		GMathText(at, line, coords, str, xadj, yadj, a, dd);
+	}
+	GMathText(at, line, coords, str, xadj, yadj, a, dd);
+    }
+}
 #else
 void GMMathText(SEXP str, int side, double line, int outer, double at, int las)
+{
-	error("Can't print math under Windows ... yet\n");
+    error("Can't print math under Windows ... yet\n");
+}
 void GMathText(double x, double y, SEXP expr, double xc, double yc, double rot)
+{
-	error("Can't print math under Windows ... yet\n");
+    error("Can't print math under Windows ... yet\n");
+}
 #endif

The R Project SVN R

(root)/trunk/src/main/plotmath.c – Rev 1160 → 1839