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

 /*
  *  R : A Computer Language for Statistical Data Analysis
  *  Copyright (C) 1995, 1996, 1997 Robert Gentleman and Ross Ihaka
+ *  Copyright (C) 1998-1999	The R Core Team
+ *
  *  This source code module:
  *  Copyright (C) 1997, 1998 Paul Murrell and Ross Ihaka
+ *
  *  This program is free software; you can redistribute it and/or modify
 static int MetricUnit = INCHES;
 /* Font Definitions */
 typedef enum {
-    PlainFont      = 1,
+    PlainFont	   = 1,
-    BoldFont       = 2,
+    BoldFont	   = 2,
-    ItalicFont     = 3,
+    ItalicFont	   = 3,
     BoldItalicFont = 4,
-    SymbolFont     = 5,
+    SymbolFont	   = 5,
 } FontType;
 /*
  *  Italic Correction Factor
+ *
     double height, depth, width;
     GMetricInfo('g', &height, &depth, &width, MetricUnit, MathDevice);
     return depth;
+}
-#ifdef NOT_used_currently/*-- out 'def'  (-Wall) --*/
+#ifdef NOT_used_currently/*-- out 'def'	 (-Wall) --*/
 static double AscHeight()
+{
     double height, depth, width, save;
     GMetricInfo('d', &height, &depth, &width, MetricUnit, MathDevice);
     save = height;
  *  Note : The values are ``optimised'' for PostScript.
+ *
  */
 typedef enum {
-    sigma2,  sigma5,  sigma6,  sigma8,  sigma9,  sigma10, sigma11,
+    sigma2,  sigma5,  sigma6,  sigma8,	sigma9,	 sigma10, sigma11,
     sigma12, sigma13, sigma14, sigma15, sigma16, sigma17, sigma18,
     sigma19, sigma20, sigma21, sigma22, xi8, xi9, xi10, xi11, xi12, xi13
+}
 TEXPAR;
-#define SUBS           0.7
+#define SUBS	       0.7
 static double TeX(TEXPAR which)
+{
     switch(which) {
     case sigma2:  /* space */
 	return Quad();
     case sigma8:  /* num1 */
 	return AxisHeight()
 	    + 3.51 * RuleThickness()
-	    + 0.15 * XHeight()          /* 54/36 * 0.1 */
+	    + 0.15 * XHeight()		/* 54/36 * 0.1 */
 	    + SUBS * DescDepth();
     case sigma9:  /* num2 */
 	return AxisHeight()
 	    + 1.51 * RuleThickness()
-	    + 0.08333333 * XHeight();   /* 30/36 * 0.1 */
+	    + 0.08333333 * XHeight();	/* 30/36 * 0.1 */
     case sigma10: /* num3 */
 	return AxisHeight()
 	    + 1.51 * RuleThickness()
-	    + 0.1333333 * XHeight();    /* 48/36 * 0.1 */
+	    + 0.1333333 * XHeight();	/* 48/36 * 0.1 */
     case sigma11: /* denom1 */
-	return  - AxisHeight()
+	return	- AxisHeight()
 	    + 3.51 * RuleThickness()
 	    + SUBS * FigHeight()
-	    + 0.344444 * XHeight();     /* 124/36 * 0.1 */
+	    + 0.344444 * XHeight();	/* 124/36 * 0.1 */
     case sigma12: /* denom2 */
-	return  - AxisHeight()
+	return	- AxisHeight()
 	    + 1.51 * RuleThickness()
 	    + SUBS * FigHeight()
-	    + 0.08333333 * XHeight();   /* 30/36 * 0.1 */
+	    + 0.08333333 * XHeight();	/* 30/36 * 0.1 */
     case sigma13: /* sup1 */
 	return 0.95 * xHeight();
     case sigma14: /* sup2 */
 	return 0.825 * xHeight();
 	return 1.01 *XHeight();
     case sigma22: /* axis_height */
 	return AxisHeight();
-    case xi8:     /* default_rule_thickness */
+    case xi8:	  /* default_rule_thickness */
 	return RuleThickness();
-    case xi9:     /* big_op_spacing1 */
+    case xi9:	  /* big_op_spacing1 */
-    case xi10:    /* big_op_spacing2 */
+    case xi10:	  /* big_op_spacing2 */
-    case xi11:    /* big_op_spacing3 */
+    case xi11:	  /* big_op_spacing3 */
-    case xi12:    /* big_op_spacing4 */
+    case xi12:	  /* big_op_spacing4 */
-    case xi13:    /* big_op_spacing5 */
+    case xi13:	  /* big_op_spacing5 */
 	return 0.15 * XHeight();
     default:/* never happens (enum type) */
 	error("invalid `which' in TeX()!\n"); return 0;/*-Wall*/
+    }
+}
 static double CenterShift(BBOX bbox)
+{
     return 0.5 * (bboxHeight(bbox) - bboxDepth(bbox));
+}
-#ifdef NOT_used_currently/*-- out 'def'  (-Wall) --*/
+#ifdef NOT_used_currently/*-- out 'def'	 (-Wall) --*/
 static BBOX DrawBBox(BBOX bbox, double xoffset, double yoffset)
+{
     double xsaved = CurrentX;
     double ysaved = CurrentY;
     double x[5], y[5];
     return !strcmp(CHAR(STRING(expr)[0]), aString);
+}
 /* Code to determine the ascii code corresponding */
 /* to an element of a mathematical expression. */
-#define A_HAT             94
+#define A_HAT		  94
-#define A_TILDE          126
+#define A_TILDE		 126
-#define S_SPACE           32
+#define S_SPACE		  32
-#define S_PARENLEFT       40
+#define S_PARENLEFT	  40
-#define S_PARENRIGHT      41
+#define S_PARENRIGHT	  41
-#define S_ASTERISKMATH    42
+#define S_ASTERISKMATH	  42
-#define S_COMMA           44
+#define S_COMMA		  44
-#define S_SLASH           47
+#define S_SLASH		  47
-#define S_RADICALEX       96
+#define S_RADICALEX	  96
-#define S_FRACTION       164
+#define S_FRACTION	 164
-#define S_ELLIPSIS       188
+#define S_ELLIPSIS	 188
-#define S_INTERSECTION   199
+#define S_INTERSECTION	 199
-#define S_UNION          200
+#define S_UNION		 200
-#define S_PRODUCT        213
+#define S_PRODUCT	 213
-#define S_RADICAL        214
+#define S_RADICAL	 214
-#define S_SUM            229
+#define S_SUM		 229
-#define S_INTEGRAL       242
+#define S_INTEGRAL	 242
-#define S_BRACKETLEFTTP  233
+#define S_BRACKETLEFTTP	 233
-#define S_BRACKETLEFTBT  235
+#define S_BRACKETLEFTBT	 235
 #define S_BRACKETRIGHTTP 249
 #define S_BRACKETRIGHTBT 251
-#define N_LIM           1001
+#define N_LIM		1001
-#define N_LIMINF        1002
+#define N_LIMINF	1002
-#define N_LIMSUP        1003
+#define N_LIMSUP	1003
-#define N_INF           1004
+#define N_INF		1004
-#define N_SUP           1005
+#define N_SUP		1005
-#define N_MIN           1006
+#define N_MIN		1006
-#define N_MAX           1007
+#define N_MAX		1007
 /* The Full Adobe Symbol Font */
 static struct {
     char *name;
     int code;
+}
 SymbolTable[] = {
-    "space",          32,
+    "space",	      32,
-    "exclam",         33,
+    "exclam",	      33,
     "universal",      34,
     "numbersign",     35,
     "existential",    36,
-    "percent",        37,
+    "percent",	      37,
     "ampersand",      38,
-    "suchthat",       39,
+    "suchthat",	      39,
     "parenleft",      40,
     "parenright",     41,
     "asteriskmath",   42,
-    "plus",           43,
+    "plus",	      43,
-    "comma",          44,
+    "comma",	      44,
-    "minus",          45,
+    "minus",	      45,
-    "period",         46,
+    "period",	      46,
-    "slash",          47,
+    "slash",	      47,
-    "0",              48,
+    "0",	      48,
-    "1",              49,
+    "1",	      49,
-    "2",              50,
+    "2",	      50,
-    "3",              51,
+    "3",	      51,
-    "4",              52,
+    "4",	      52,
-    "5",              53,
+    "5",	      53,
-    "6",              54,
+    "6",	      54,
-    "7",              55,
+    "7",	      55,
-    "8",              56,
+    "8",	      56,
-    "9",              57,
+    "9",	      57,
-    "colon",          58,
+    "colon",	      58,
     "semicolon",      59,
-    "less",           60,
+    "less",	      60,
-    "equal",          61,
+    "equal",	      61,
-    "greater",        62,
+    "greater",	      62,
-    "question",       63,
+    "question",	      63,
     "congruent",      64,
-    "Alpha",          65,    /* Upper Case Greek Characters */
+    "Alpha",	      65,    /* Upper Case Greek Characters */
-    "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,
-    "theta1",         74,
+    "theta1",	      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,
     "bracketleft",    91,    /* Miscellaneous Special Characters */
     "therefore",      92,
     "bracketright",   93,
     "perpendicular",  94,
     "underscore",     95,
     "radicalex",      96,
-    "alpha",          97,    /* Lower Case Greek Characters */
+    "alpha",	      97,    /* Lower Case Greek Characters */
-    "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,
     "braceleft",     123,    /* Miscellaneous Special Characters */
-    "bar",           124,
+    "bar",	     124,
     "braceright",    125,
-    "similar",       126,
+    "similar",	     126,
-    "Upsilon1",      161,    /* Lone Greek */
+    "Upsilon1",	     161,    /* Lone Greek */
-    "minute",        162,
+    "minute",	     162,
     "lessequal",     163,
-    "fraction",      164,
+    "fraction",	     164,
-    "infinity",      165,
+    "infinity",	     165,
-    "florin",        166,
+    "florin",	     166,
-    "club",          167,
+    "club",	     167,
-    "diamond",       168,
+    "diamond",	     168,
-    "heart",         169,
+    "heart",	     169,
-    "spade",         170,
+    "spade",	     170,
     "arrowboth",     171,
     "arrowleft",     172,
-    "arrowup",       173,
+    "arrowup",	     173,
     "arrowright",    174,
     "arrowdown",     175,
-    "degree",        176,
+    "degree",	     176,
     "plusminus",     177,
-    "second",        178,
+    "second",	     178,
     "greaterequal",  179,
-    "multiply",      180,
+    "multiply",	     180,
     "proportional",  181,
     "partialdiff",   182,
-    "bullet",        183,
+    "bullet",	     183,
-    "divide",        184,
+    "divide",	     184,
-    "notequal",      185,
+    "notequal",	     185,
     "equivalence",   186,
     "approxequal",   187,
-    "ellipsis",      188,
+    "ellipsis",	     188,
     "arrowvertex",   189,
     "arrowhorizex",  190,
     "carriagereturn",191,
-    "aleph",         192,
+    "aleph",	     192,
-    "Ifraktur",      193,
+    "Ifraktur",	     193,
-    "Rfraktur",      194,
+    "Rfraktur",	     194,
     "weierstrass",   195,
     "circlemultiply",196,
     "circleplus",    197,
-    "emptyset",      198,
+    "emptyset",	     198,
     "intersection",  199,
-    "union",         200,
+    "union",	     200,
     "propersuperset",201,
     "reflexsuperset",202,
     "notsubset",     203,
     "propersubset",  204,
     "reflexsubset",  205,
-    "element",       206,
+    "element",	     206,
     "notelement",    207,
-    "angle",         208,
+    "angle",	     208,
-    "gradient",      209,
+    "gradient",	     209,
     "registerserif", 210,
     "copyrightserif",211,
     "trademarkserif",212,
-    "product",       213,
+    "product",	     213,
-    "radical",       214,
+    "radical",	     214,
-    "dotmath",       215,
+    "dotmath",	     215,
     "logicaland",    217,
     "logicalor",     218,
     "arrowdblboth",  219,
     "arrowdblleft",  220,
     "arrowdblup",    221,
     "arrowdblright", 222,
     "arrowdbldown",  223,
-    "lozenge",       224,
+    "lozenge",	     224,
     "angleleft",     225,
     "registersans",  226,
     "copyrightsans", 227,
     "trademarksans", 228,
     "summation",     229,
     "bracketleftex", 234,
     "bracketleftbt", 235,
     "bracelefttp",   236,
     "braceleftmid",  237,
     "braceleftbt",   238,
-    "braceex",       239,
+    "braceex",	     239,
     "angleright",    241,
-    "integral",      242,
+    "integral",	     242,
     "integraltp",    243,
     "integralex",    244,
     "integralbt",    245,
     "parenrighttp",  246,
     "parenrightex",  247,
     "bracketrightbt",251,
     "bracerighttp",  252,
     "bracerightmid", 253,
     "bracerightbt",  254,
-    NULL,              0,
+    NULL,	       0,
 };
 static int SymbolCode(SEXP expr)
+{
     int i;
+}
 static int TranslatedSymbol(SEXP expr)
+{
     int code = SymbolCode(expr);
-    if ((0101 <= code && code <= 0132)  ||   /* Greek */
+    if ((0101 <= code && code <= 0132)	||   /* Greek */
-	(0141 <= code && code <= 0172)  ||   /* Greek */
+	(0141 <= code && code <= 0172)	||   /* Greek */
-	code == 0241                    ||   /* Greek */
+	code == 0241			||   /* Greek */
-	code == 0242                    ||   /* minute */
+	code == 0242			||   /* minute */
-	code == 0245                    ||   /* infinity */
+	code == 0245			||   /* infinity */
-	code == 0260                    ||   /* degree */
+	code == 0260			||   /* degree */
-	code == 0262                    ||   /* second */
+	code == 0262			||   /* second */
 )
 	return code;
     else
 	return 0;
+}
 static int StringAtom(SEXP expr)
+{
     return (TYPEOF(expr) == STRSXP);
+}
-#ifdef NOT_used_currently/*-- out 'def'  (-Wall) --*/
+#ifdef NOT_used_currently/*-- out 'def'	 (-Wall) --*/
 static int symbolAtom(SEXP expr)
+{
     int i;
     if (NameAtom(expr)) {
 	for (i = 0; SymbolTable[i].code; i++)
+}
 #endif
 /* Code to determine a font from the */
 /* nature of the expression */
-#ifdef NOT_used_currently/*-- out 'def'  (-Wall) --*/
+#ifdef NOT_used_currently/*-- out 'def'	 (-Wall) --*/
 static FontType CurrentFont = 3;
 #endif
 static FontType GetFont()
+{
     return MathDevice->gp.font;
 static BBOX RenderOffsetElement(SEXP, double, double, int);
 static BBOX RenderExpression(SEXP, int);
 static BBOX RenderSymbolChar(int, int);
-/*  Code to Generate Bounding Boxes and Draw Formulae.  */
+/*  Code to Generate Bounding Boxes and Draw Formulae.	*/
 static BBOX RenderItalicCorr(BBOX bbox, int draw)
+{
     if (bboxItalic(bbox) > 0) {
 	if (draw)
 /* Code for Ellipsis (ldots, cdots, ...) */
 static int DotsAtom(SEXP expr)
+{
     if (NameMatch(expr, "cdots") ||
-	NameMatch(expr, "...")   ||
+	NameMatch(expr, "...")	 ||
 	NameMatch(expr, "ldots"))
-            return 1;
+	    return 1;
     return 0;
+}
 static BBOX RenderDots(SEXP expr, int draw)
+{
 	opBBox = CombineBBoxes(opBBox, arg2BBox);
 	return opBBox;
+    }
     else
 	error("invalid mathematical annotation\n");
+}
 static SymTab BinTable[] = {
-    "*",                052,    /* Binary Operators */
+    "*",		052,	/* Binary Operators */
-    "+",                053,
+    "+",		053,
-    "-",                055,
+    "-",		055,
-    "/",                057,
+    "/",		057,
-    ":",                072,
+    ":",		072,
-    "%+-%",            0261,
+    "%+-%",	       0261,
-    "%*%",             0264,
+    "%*%",	       0264,
-    "%/%",             0270,
+    "%/%",	       0270,
     "%intersection%",  0307,
-    "%union%",         0310,
+    "%union%",	       0310,
-    NULL,                 0
+    NULL,		  0
 };
 static int BinAtom(SEXP expr)
+{
     int i;
  */
 #define ACCENT_GAP  0.2
 #define HAT_HEIGHT  0.3
-#define NTILDE      8
+#define NTILDE	    8
-#define DELTA       0.05
+#define DELTA	    0.05
 static int WideTildeAtom(SEXP expr)
+{
     return NameAtom(expr) && NameMatch(expr, "widetilde");
+}
 static struct {
     char *name;
     int code;
+}
 AccentTable[] = {
-    "hat",            94,
+    "hat",	      94,
-    "ring",          176,
+    "ring",	     176,
-    "tilde",         126,
+    "tilde",	     126,
-    NULL,              0,
+    NULL,	       0,
 };
 static int AccentCode(SEXP expr)
+{
     int i;
+}
 static int OverAtom(SEXP expr)
+{
     return NameAtom(expr) &&
-        (NameMatch(expr, "over") || NameMatch(expr, "frac"));
+	(NameMatch(expr, "over") || NameMatch(expr, "frac"));
+}
 static BBOX RenderOver(SEXP expr, int draw)
+{
     return RenderFraction(expr, 1, draw);
     case '}':
 	top = 252; ext = 239; bot = 254; mid = 253;
 	break;
     default:
 	error("group is incomplete\n");
-	break;
+	return ansBBox;/*never reached*/
+    }
     topBBox = GlyphBBox(top);
     extBBox = GlyphBBox(ext);
     botBBox = GlyphBBox(bot);
     if (which == '{' || which == '}') {
     delim1 = DelimCode(expr, CADR(expr));
     delim2 = DelimCode(expr, CADDDR(expr));
     bbox = RenderElement(CADDR(expr), 0);
     dist = max(bboxHeight(bbox) - axisHeight, bboxDepth(bbox) + axisHeight);
     bbox = RenderDelim(delim1, dist + extra, draw);
-    bbox = CombineBBoxes(bbox,  RenderElement(CADDR(expr), draw));
+    bbox = CombineBBoxes(bbox,	RenderElement(CADDR(expr), draw));
     bbox = RenderItalicCorr(bbox, draw);
-    bbox = CombineBBoxes(bbox,  RenderDelim(delim2, dist + extra, draw));
+    bbox = CombineBBoxes(bbox,	RenderDelim(delim2, dist + extra, draw));
     return bbox;
+}
 /*----------------------------------------------------------------------
+ *
  */
 #define OperatorSymbolMag  1.25
 static SymTab OpTable[] = {
-    "prod",          S_PRODUCT,
+    "prod",	     S_PRODUCT,
-    "sum",           S_SUM,
+    "sum",	     S_SUM,
-    "union",         S_UNION,
+    "union",	     S_UNION,
     "intersect",     S_INTERSECTION,
-    "lim",           N_LIM,
+    "lim",	     N_LIM,
-    "liminf",        N_LIMINF,
+    "liminf",	     N_LIMINF,
-    "limsup",        N_LIMINF,
+    "limsup",	     N_LIMINF,
-    "inf",           N_INF,
+    "inf",	     N_INF,
-    "sup",           N_SUP,
+    "sup",	     N_SUP,
-    "min",           N_MIN,
+    "min",	     N_MIN,
-    "max",           N_MAX,
+    "max",	     N_MAX,
-    NULL,            0
+    NULL,	     0
 };
 static int OpAtom(SEXP expr)
+{
     int i;
+ *
  *  Code for radical expressions (root, sqrt)
+ *
  *  Tunable parameteters :
+ *
- *  RADICAL_GAP    The gap between the nucleus and the radical extension.
+ *  RADICAL_GAP	   The gap between the nucleus and the radical extension.
  *  RADICAL_SPACE  Extra space to the left and right of the nucleus.
+ *
  */
 #define RADICAL_GAP    0.4
+ *
  *  Code for Relation Expressions (i.e. ... ==, !=, ...)
+ *
  */
-                                /* Binary Relationships */
+				/* Binary Relationships */
 SymTab RelTable[] = {
-    "<",                 60,    /* less */
+    "<",		 60,	/* less */
-    "==",                61,    /* equal */
+    "==",		 61,	/* equal */
-    ">",                 62,    /* greater */
+    ">",		 62,	/* greater */
-    "%=~%",              64,    /* congruent */
+    "%=~%",		 64,	/* congruent */
-    "!=",               185,    /* not equal */
+    "!=",		185,	/* not equal */
-    "<=",               163,    /* less or equal */
+    "<=",		163,	/* less or equal */
-    ">=",               179,    /* greater or equal */
+    ">=",		179,	/* greater or equal */
-    "%==%",             186,    /* equivalence */
+    "%==%",		186,	/* equivalence */
-    "%~~%",             187,    /* approxequal */
+    "%~~%",		187,	/* approxequal */
-    "%<->%",            171,    /* Arrows */
+    "%<->%",		171,	/* Arrows */
-    "%<-%",             172,
+    "%<-%",		172,
-    "%up%",             173,
+    "%up%",		173,
-    "%->%",             174,
+    "%->%",		174,
-    "%down%",           175,
+    "%down%",		175,
-    "%<=>%",            219,
+    "%<=>%",		219,
-    "%<=%",             220,
+    "%<=%",		220,
-    "%dblup%",          221,
+    "%dblup%",		221,
-    "%=>%",             222,
+    "%=>%",		222,
-    "%dbldown%",        223,
+    "%dbldown%",	223,
-    "%supset%",         201,    /* Sets (TeX Names) */
+    "%supset%",		201,	/* Sets (TeX Names) */
-    "%supseteq%",       202,
+    "%supseteq%",	202,
-    "%notsubset%",      203,
+    "%notsubset%",	203,
-    "%subset%",         204,
+    "%subset%",		204,
-    "%subseteq%",       205,
+    "%subseteq%",	205,
-    "%in%",             206,
+    "%in%",		206,
-    "%notin%",          207,
+    "%notin%",		207,
-    NULL,                0,
+    NULL,		 0,
 };
 static int RelAtom(SEXP expr)
+{
     int i;
     else if (BGroupAtom(head))
 	return RenderBGroup(expr, draw);
     else if (GroupAtom(head))
 	return RenderGroup(expr, draw);
     else if (IntAtom(head))
-       	return RenderInt(expr, draw);
+	return RenderInt(expr, draw);
     else if (OpAtom(head))
 	return RenderOp(expr, draw);
     else if (RadicalAtom(head))
 	return RenderRadical(expr, draw);
     else if (AbsAtom(head))
 void GMMathText(SEXP str, int side, double line, int outer,
 		double at, int las, DevDesc *dd)
+{
-    int coords;
+    int coords = 0;
     double a, xadj, yadj;
     MathDevice = dd;
     if (outer) {
 	    coords = MAR4;
 	    a = 90.0;
 	    xadj = MathDevice->gp.adj;
 	    yadj = NA_REAL;
 	    break;
+	default: return;/* never happens */
+	}
 	GMathText(at, line, coords, str, xadj, yadj, a, dd);
+    }
     else {
 	switch (side) {
 	case 1:
-	    if (las == 2) {
+	    if (las == 2 || las == 3) {/* perpendicular */
 		at = at - GConvertXUnits(dd->gp.yLineBias,
 					 LINES, USER, dd);
 		line = line + dd->gp.yLineBias;
 		a = 90.0;
 		xadj = 1.0;
 		yadj = NA_REAL;
+	    }
 	    coords = MAR2;
 	    break;
 	case 3:
-	    if (las == 2) {
+	    if (las == 2 || las == 3) {/* perpendicular */
 		at = at - GConvertXUnits(dd->gp.yLineBias,
 					 LINES, USER, dd);
 		line = line + dd->gp.yLineBias;
 		a = 90.0;
 		xadj = 0.0;
 		xadj = MathDevice->gp.adj;
 		yadj = NA_REAL;
+	    }
 	    coords = MAR4;
 	    break;
+	default: return;/* never happens */
+	}
 	GMathText(at, line, coords, str, xadj, yadj, a, dd);
+    }
+}

The R Project SVN R

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