开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
math.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：62k
源码类别：

浏览器

开发平台：

Unix_Linux

math.c：源码内容
  1. /* Experimental html-math parser for X11 browser */
  3. /* Written by Dave Ragget, 1995 */
  5. /*
  7. Janne Saarela
  8. janne.saarela@hut.fi
  9. 28.7.1995
  11. I took the liberty of extending the mathematical text to hold
  12. the emphasis attribute. The different EMPH-* macros
  13. correspond to different emphasis one can give to different
  14. symbols and text using <above> and <below> elements.
  16. Therefore each math_box or Box now also holds the emph
  17. as an unsigned int.
  19. The parsing of mathematical markup was also improved to
  20. take the attributes into account. Before they were simply
  21. dropped out. This is why in ParseExpr() all shortrefs have
  22. to be carefully handled. This means in TAG_SUP, TAG_SUB
  23. and TAG_BOX the *bufptr has to be checked for the >
  24. character.
  26. Generally, the ParseExpr() routine is the trickies one
  27. to understand in this file. It's highly recursive and
  28. generates, as it proceeds, a list of boxes. In addition
  29. one should update the x value which corresponds to the
  30. x-coordinate of each box. The w member of the box
  31. holds the width of each box and can be used to calculate
  32. the x.
  34. The next variable is created in each case: and its next
  35. member is made to link to box variable which is always the
  36. list of previously created boxes. This is why the box = next
  37. assignment is also performed.
  39. The root and sqrt elements are parsed but the corresponding
  40. symbols and their alignments are not of satisfactory, though.
  42. */
  44. /*
  45.   .
  46. Stale Schumacher
  47. staalesc@usit.uio.no / stale@hypnotech.com
  48. 15.8.95
  50. I have extended the math support and corrected a few minor
  51. bugs. These are the most important changes:
  53.   - Added support for the <ATOP> tag
  54.   - Added new entity &lim; (limit function)
  55.   - Functions (&sin;, &cos;, &tan;, etc.) are now rendered in
  56.     an upright font, _not_ italic as they used to be. Furtermore,
  57.     all unknown entities are treated as functions. This avoids
  58.     the problem of defining one FUNC code for each mathematical
  59.     function (and believe me, there are quite a few if you take
  60.     into account things like arctan, sinh, arccosh etc.) This
  61.     solution also enables the HTML author to "invent" new
  62.     functions as an alternative to using <t>...</t>:
  63.       myfunc   - rendered in italics
  64.       &myfunc; - rendered in an upright font
  65.     Misuse of this "feature" is discouraged... :-)
  66.   - The characters '!' and ':' are now treated as SYMBOLs
  67.   - Added new macro IsISOLetter to prevent Arena from hanging if
  68.     the math markup contains national characters
  69.   - Curly brackets (braces: '{' and '}') may now be stretched
  70.     using <left> and <right>, just as '[', ']', '(', ')', and '|'
  71.   - Commented out some obsolete code, including FuncCode
  72.   - Reimplemented &prod; in MathEntity
  74. Changes 13.12.95:
  76.   - Changed <sqrt> and <root> to draw the radical graphically
  77.     rather than using the symbol font
  78.   - Changed the behaviour of <above>, <below>, <vec>, <bar> etc.
  79.     to draw _one_ contiguous line or arrow
  80.   - Fixed/improved a large number of alignment/placement problems
  81.   - Added new entity &dots;
  83. */
  86. #include <stdio.h>
  87. #include <stdlib.h>
  88. #include <string.h>
  90. #include "www.h"
  92. #define LATIN1  0
  93. #define SYMSET  1
  96. #define HLINE           0x40     /* width instead of right coord */
  98. #define NORMAL  0
  99. #define SMALL   1
  101. #define EMPH_NORMAL      0
  102. /*#define EMPH_ANCHOR     (1 << 0)*/
  103. #define EMPH_UNDERLINE  (1 << 1)
  104. #define EMPH_STRIKE     (1 << 2)
  105. #define EMPH_HIGHLIGHT  (1 << 3)
  107. #define EMPH_OVERLINE   (1 << 4)
  108. #define EMPH_OVERLARR (1 << 5)
  109. #define EMPH_OVERRARR (1 << 6)
  110. #define EMPH_OVERTILDE (1 << 7)
  111. #define EMPH_OVERHAT (1 << 8)
  112. #define EMPH_OVERDOT    (1 << 9)
  113. #define EMPH_OVERDDOT   (1 << 10)
  115. #define EMPH_UNDERLARR (1 << 11)
  116. #define EMPH_UNDERRARR (1 << 12)
  117. #define EMPH_UNDERTILDE (1 << 13)
  118. #define EMPH_UNDERHAT (1 << 14)
  120. #define EMPH_ROOTLINE   (1 << 15)
  122. #define IDX_NORMALFONT          5
  123. #define IDX_INORMALFONT         6
  124. #define IDX_BNORMALFONT         7
  125. #define IDX_BINORMALFONT        8
  126. #define IDX_FIXEDFONT           9
  127. #define IDX_IFIXEDFONT         10
  128. #define IDX_BFIXEDFONT         11
  129. #define IDX_BIFIXEDFONT        12
  130. #define IDX_SMALLFONT          13
  131. #define IDX_SYMBOLFONT         14
  132. #define IDX_SUBSYMFONT         15
  134. #if 0
  135. /*  janet: commented, already defined in www.h  */
  136. /* reproduce Frame struct here for quick hack interface */
  138. struct frame_struct 
  139.      { 
  140.          struct frame_struct *next;  /* linked list of peer frames */ 
  141.          struct frame_struct *child; /* linked list of nested frames */ 
  142.          unsigned char *top;         /* where to start displaying from */ 
  143.          long offset;                /* from start of document */ 
  144.          unsigned int indent;        /* from left of document */ 
  145.          long height;                /* documents can be very long */ 
  146.          unsigned int width; 
  147.          int leftmargin;             /* indent from lhs of frame */ 
  148.          int rightmargin;            /* indent from rhs of frame */ 
  149.          unsigned int info;    /* to BEGIN_FRAME object in paint stream */ 
  150.          unsigned int length;        /* byte count of frame's data */ 
  151.          unsigned int lastrow;       /* used in parsing tables */ 
  152.          unsigned char style;        /* frame's background style */ 
  153.          unsigned char border;       /* frame's border style */ 
  154.          int flow;    /* ALIGN_LEFT, ALIGN_NOTE, ALIGN_CENTER or ALIGN_RIGHT */ 
  155.          int oldmargin;     /* previous value of parent's margin */ 
  156.          int pushcount;     /* save count value for restore */ 
  157.          int leftcount;     /* of frames with ALIGN_LEFT or ALIGN_NOTE */ 
  158.          int rightcount;    /* of frames with ALIGN_RIGHT */ 
  159.      }; 
  161. typedef struct frame_struct Frame; 
  162. #endif
  164. extern int Here;
  165. extern char *bufptr, *lastbufptr;
  166. extern XFontStruct *Fonts[FONTS]; /* staalesc 13/12/95 */
  169. /******** end of interface to X11 browser ********/
  171. /* staalesc 15/08/95: these are now obsolete
  172. #define SIN             1
  173. #define COS             2
  174. #define TAN             3
  175. #define LOG             4
  176. #define EXP             5
  177. */
  179. /* integral, summation and product signs */
  180. #define INT             100
  181. #define SUM             101
  182. #define PROD            102
  184. /* staalesc 15/08/95: limit function */
  185. #define LIM             103
  187. /* staalesc 13/12/95: horizontal dots */
  188. #define DOTS            104
  190. #define LBRACKET        200
  191. #define RBRACKET        201
  192. #define LSQBRACKET      202
  193. #define RSQBRACKET      203
  194. #define LBRACE          204
  195. #define RBRACE          205
  197. /* janet 1/8/95: #define UNKNOWN        -2     */
  198. #define BUFFEND        -1
  199. #define NONE            0
  200. #define SPACE           1
  201. #define NAME            2
  202. #define FUNC            3
  203. #define OPERATOR        4
  204. #define DELIM           5
  205. #define SYM             6
  206. #define BOX             7
  207. #define DIVIDER         8
  208. #define TAG_BOX         9
  209. /* janet 1/8/95: #define TAG_SUP        10 */
  210. /* janet 1/8/95: #define TAG_SUB        11 */
  211. #define TAG_OVER       12
  212. #define TAG_LEFT       13
  213. #define TAG_RIGHT      14
  214. /* janet 1/8/95: #define TAG_MATH       15 */
  215. #define TAG_ROOT       16
  216. #define TAG_ABOVE      17
  217. #define TAG_BELOW      18
  218. #define TAG_UPRIGHT    19
  219. #define TAG_BUPRIGHT   20
  220. #define TAG_BOLDTEXT   21
  221. #define TAG_OF         22
  222. #define TAG_VEC        23
  223. #define TAG_BAR        24
  224. #define TAG_DOT        25
  225. #define TAG_DDOT       26
  226. #define TAG_HAT        27
  227. #define TAG_TILDE      28
  228. #define TAG_SQRT       29
  229. #define TAG_ATOP       30   /* staalesc 15/08/95 */
  230. #define RADICAL        31   /* staalesc 13/12/95 */
  232. #define STARTTAG        0
  233. /* janet 1/8/95: #define ENDTAG          1 */
  234. #define SHORTREF        2
  236. #define EXPR            1
  237. #define RSUP            2
  238. #define RSUB            3
  239. #define LDELIM          4
  240. #define CSUP            5
  241. #define CSUB            6
  242. #define RDELIM          7
  243. #define LSUP            8
  244. #define LSUB            9
  246. /* janet 1/8/95: #define ALIGN_LEFT      0 */
  247. /* janet 1/8/95: #define ALIGN_CENTER    1 */
  248. /* janet 1/8/95: #define ALIGN_RIGHT     2 */
  250. #define ROWS 24
  251. /* janet 1/8/95: #define COLS 80 */
  253. #ifndef max
  254. #define     max(a, b)   ((a) > (b) ? (a) : (b))
  255. #endif
  257. struct math_box
  258. {
  259.     int role;   /* EXPR, RSUP, RSUB, LDELIM, CSUP, CSUB, RDELIM, LSUP, LSUB */
  260.     int type;   /* NAME, FUNC, OPERATOR, DELIM, BOX */
  261.     struct math_box *next;
  262.     struct math_box *base;
  263.     struct math_box *indices;
  264.     int font;
  265.     char *str;
  266.     int len;
  267.     int code;
  268.     int subcode;
  269.     int dx, dy, w, above, below;
  270.     unsigned int emph;
  271. };
  273. typedef struct math_box Box;
  275. static int token_code, token_len, token_width, token_above, token_font,
  276.            token_below, token_align, token_charset, token_subcode;
  277. static char *token_str;
  280. int math_normal_sym_font = 0, math_small_sym_font, math_normal_text_font, 
  281.     math_small_text_font, math_italic_text_font, math_bold_text_font, math_ibold_text_font;
  283. static int current_font_tag = 0;
  285. int TextFont(int size, int emp)
  286. {
  287.     if (size == SMALL) {
  288. switch (emp) {
  289. case TAG_UPRIGHT:
  290.     return math_small_text_font;
  291.     break;
  292. case TAG_BUPRIGHT:
  293.     return math_small_text_font;
  294.     break;
  295. case TAG_BOLDTEXT:
  296.     return math_small_text_font;
  297.     break;
  298. default:
  299.     return math_small_text_font;
  300.     break;
  301. }
  302.     } else {
  303. switch (emp) {
  304. case TAG_UPRIGHT:
  305.     return math_normal_text_font;
  306.     break;
  307. case TAG_BUPRIGHT:
  308.     return math_bold_text_font;
  309.     break;
  310. case TAG_BOLDTEXT:
  311.     return math_ibold_text_font;
  312.     break;
  313. default:
  314.     return math_italic_text_font;
  315.     break;
  316. }
  317.     }
  318. }
  320. #define SymFont(size) (size == NORMAL ? math_normal_sym_font : math_small_sym_font)
  321. #define UprightTextFont(size) (TextFont(size, TAG_UPRIGHT))
  323. int Space(int font)
  324. {
  325.     int up, down;
  326.     static int myfont = -1, width = 0;
  328.     if (font != myfont)
  329.     {
  330.         myfont = font;
  331.         width = TextWidth(myfont, " ", 1, &up, &down);
  332.     }
  334.     return width;
  335. }
  337. int divide_base(int font) /* staalesc 13/12/95 */
  338. {
  339.     int direction_hint, font_ascent, font_descent;
  340.     XCharStruct overall;
  342.     XTextExtents(Fonts[font], "o", 1,
  343.                     &direction_hint,
  344.                     &font_ascent,
  345.                     &font_descent,
  346.                     &overall);
  348.     return font_ascent / 2;
  349. }
  351. Box *NewBox(int font)
  352. {
  353.     Box *box;
  355.     box = (Box *)malloc(sizeof(Box));
  356.     box->role = EXPR;
  357.     box->next = NULL;
  358.     box->base = NULL;
  359.     box->indices = NULL;
  360.     box->type = NAME;
  361.     box->str = NULL;
  362.     box->len = 0;
  363.     box->dx = box->dy = box->below = 0;
  364.     box->w = box->above = 0;
  365.     box->font = font;
  366.     box->emph = EMPH_NORMAL;
  368.     return (box); /* howcome 12/10/94: the return was missing! */
  369. }
  371. /* janet 1/8/95: defined in www.h: #define IsWhite(c) (c == ' ' || c == 't' || c == 'n' || c== 'r') */
  373. #define IsLetter(c) (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))
  374. #define IsISOLetter(c) (IsLetter(c) || (192 <= c && c <= 255 && c!=215 && c!=247))
  375. #define IsDigit(c) ('0' <= c && c <= '9')
  376. #define IsAlphaNumeric(c) (IsLetter(c) || IsDigit(c))
  378. static void ParseAboveAttrs (int *emph)
  379. {
  380.     int n, m, isSet; /* janet 21/09/95: not used: c */
  381.     char *attr, *attrval;
  383.     isSet = 0;
  384.     bufptr--;
  385.     for (;;)
  386.     {
  387.         if (*bufptr == '')
  388.             break;
  390.         if (*bufptr == '>') {
  391.     bufptr++;
  392.             break;
  393. }
  395.         if (IsWhite(*bufptr)) {
  396.     bufptr++;
  397.             continue;
  398. }
  400.         attr = ParseAttribute(&n);
  401.         attrval = ParseValue(&m);
  402.         if (n == 3 && strncasecmp(attr, "sym", n) == 0)
  403.         {
  404.             if (m == 3 && strncasecmp(attrval, "hat", m) == 0) {
  405.                 *emph |= EMPH_OVERHAT;
  406. isSet = 1;
  407. continue;
  408.     }
  409.             else if (m == 5 && strncasecmp(attrval, "tilde", m) == 0) {
  410.                 *emph |= EMPH_OVERTILDE;
  411. isSet = 1;
  412. continue;
  413.     }
  414.             else if (m == 4 && strncasecmp(attrval, "larr", m) == 0) {
  415.                 *emph |= EMPH_OVERLARR;
  416. isSet = 1;
  417. continue;
  418.     }
  419.             else if (m == 4 && strncasecmp(attrval, "rarr", m) == 0) {
  420.                 *emph |= EMPH_OVERRARR;
  421. isSet = 1;
  422. continue;
  423.     }
  424.     continue;
  425.         }
  426.     }
  427.     if (!isSet)
  428. *emph |= EMPH_OVERLINE;
  429. }
  431. static void ParseBelowAttrs (int *emph)
  432. {
  433.     int n, m, isSet; /* janet 21/07/95: not used: c */
  434.     char *attr, *attrval;
  436.     isSet = 0;
  437.     bufptr--;
  438.     for (;;)
  439.     {
  440.         if (*bufptr == '')
  441.             break;
  443.         if (*bufptr == '>') {
  444.     bufptr++;
  445.             break;
  446. }
  448.         if (IsWhite(*bufptr)) {
  449.     bufptr++;
  450.             continue;
  451. }
  453.         attr = ParseAttribute(&n);
  454.         attrval = ParseValue(&m);
  455.         if (n == 3 && strncasecmp(attr, "sym", n) == 0)
  456.         {
  457.             if (m == 3 && strncasecmp(attrval, "hat", m) == 0) {
  458.                 *emph |= EMPH_UNDERHAT;
  459. isSet = 1;
  460. continue;
  461.     }
  462.             else if (m == 5 && strncasecmp(attrval, "tilde", m) == 0) {
  463.                 *emph |= EMPH_UNDERTILDE;
  464. isSet = 1;
  465. continue;
  466.     }
  467.             else if (m == 4 && strncasecmp(attrval, "larr", m) == 0) {
  468.                 *emph |= EMPH_UNDERLARR;
  469. isSet = 1;
  470. continue;
  471.     }
  472.             else if (m == 4 && strncasecmp(attrval, "rarr", m) == 0) {
  473.                 *emph |= EMPH_UNDERRARR;
  474. isSet = 1;
  475. continue;
  476.     }
  477.     continue;
  478.         }
  479.     }
  480.     if (!isSet)
  481. *emph |= EMPH_UNDERLINE;
  482. }
  484. static int GetTag(void)
  485. {
  486.     int len; /* janet 21/07/95: not used: c */
  487.     char *tag;
  489.  /* bufptr -> "sub> or "/sub> etc */
  491.     len = 0;
  492.     token_code = STARTTAG;
  493.     tag = bufptr;
  495.     if (*bufptr == '/')
  496.     {
  497.         token_code = ENDTAG;
  498.         ++tag;
  499.         ++bufptr;
  500.     }
  501.     while (IsAlphaNumeric(*bufptr)) {
  502.         len++;
  503.         bufptr++;
  504.     }
  506.     /* don't skip attributes, Janne Saarela 9.6.1995 */
  508.     /* skip blank space before attributes or end tag character > */
  509.     while (IsWhite(*bufptr))
  510.         bufptr++;
  512.     /* skip the last > character */
  513. /*    if (token_code == ENDTAG)
  514.         bufptr++; */
  516.     if (len == 3 && strncasecmp(tag, "sub", len) == 0)
  517.         return TAG_SUB;
  519.     if (len == 3 && strncasecmp(tag, "sup", len) == 0)
  520.         return TAG_SUP;
  522.     if (len == 3 && strncasecmp(tag, "box", len) == 0)
  523.         return TAG_BOX;
  525.     if (len == 4 && strncasecmp(tag, "over", len) == 0)
  526.         return TAG_OVER;
  528.     if (len == 4 && strncasecmp(tag, "atop", len) == 0)
  529.         return TAG_ATOP;
  531.     if (len == 4 && strncasecmp(tag, "left", len) == 0)
  532.         return TAG_LEFT;
  534.     if (len == 5 && strncasecmp(tag, "right", len) == 0)
  535.         return TAG_RIGHT;
  537.     if (len == 4 && strncasecmp(tag, "math", len) == 0)
  538.         return TAG_MATH;
  540.     if (len == 4 && strncasecmp(tag, "root", len) == 0)
  541.         return TAG_ROOT;
  543.     if (len == 4 && strncasecmp(tag, "sqrt", len) == 0)
  544.         return TAG_SQRT;
  546.     if (len == 2 && strncasecmp(tag, "of", len) == 0)
  547.         return TAG_OF;
  549.     if (len == 5 && strncasecmp(tag, "above", len) == 0)
  550.         return TAG_ABOVE;
  552.     if (len == 5 && strncasecmp(tag, "below", len) == 0)
  553.         return TAG_BELOW;
  555.     if (len == 1 && strncasecmp(tag, "t", len) == 0)
  556.         return TAG_UPRIGHT;
  558.     if (len == 2 && strncasecmp(tag, "bt", len) == 0)
  559.         return TAG_BUPRIGHT;
  561.     if (len == 1 && strncasecmp(tag, "b", len) == 0)
  562.         return TAG_BOLDTEXT;
  564.     if (len == 3 && strncasecmp(tag, "vec", len) == 0)
  565.         return TAG_VEC;
  567.     if (len == 3 && strncasecmp(tag, "bar", len) == 0)
  568.         return TAG_BAR;
  570.     if (len == 3 && strncasecmp(tag, "dot", len) == 0)
  571.         return TAG_DOT;
  573.     if (len == 4 && strncasecmp(tag, "ddot", len) == 0)
  574.         return TAG_DDOT;
  576.     if (len == 3 && strncasecmp(tag, "hat", len) == 0)
  577.         return TAG_HAT;
  579.     if (len == 5 && strncasecmp(tag, "tilde", len) == 0)
  580.         return TAG_TILDE;
  581.     
  582.     return UNKNOWN;
  583. }
  585. /* needs expanding to cover full range of symbols as per TeX
  586.    one unresolve question is the set of tokens like ","  */
  588. static int DelimSymCode(int c, int *ch)
  589. {
  590.     if (c == '[')
  591.     {
  592.         *ch = 91;
  593.         return 234;
  594.     }
  596.     if (c == ']')
  597.     {
  598.         *ch = 93;
  599.         return 250;
  600.     }
  602.     if (c == '(')
  603.     {
  604.         *ch = 40;
  605.         return 231;
  606.     }
  608.     if (c == ')')
  609.     {
  610.         *ch = 41;
  611.         return 247;
  612.     }
  614.     if (c == '{')
  615.     {
  616.         *ch = 123;
  617.         return 237;
  618.     }
  620.     if (c == '}')
  621.     {
  622.         *ch = 125;
  623.         return 253;
  624.     }
  626.     if (c == '|')
  627.     {
  628.         *ch = 124;
  629.         return 239;
  630.     }
  632.     return TRUE;  /* janet: not of much use here, only for compilation */
  633. }
  635. static int DelimCode(int c, int size)
  636. {
  637.     char ch;
  639.     if (c == '[' || c == ']' || c == '(' || c == ')' || c == '{' || c == '}' || c == '|')
  640.     {
  641.         token_font = SymFont(size);
  642.         ch = c;
  643.         token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  644.         if (c == ')' || c == '|' || c == ']') /* staalesc 13/12/95: added extra space */
  645.             token_width += Space(token_font)/2;
  646.         token_code = DelimSymCode(c, &token_subcode);
  647.         token_charset = SYMSET;
  648.         return c;
  649.     }
  651. /*    return NULL;*/
  652.     return 0;
  653. }
  655. static int OperatorCode(int c, int size)
  656. {
  657.     char ch;
  659.     if (c == '=' || c == '+' || c == '-' || c == '/' ||
  660.         c == '.' || c == ',' || c == '<' || c == '>' ||
  661.         c == '!' || c == ':')
  662.     {
  663.         token_font = SymFont(size);
  664.         token_charset = SYMSET;
  665.         ch = c;
  666.         token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  667.         if (c != '.') token_width += Space(token_font)/2; /* staalesc 13/12/95 */
  668.         token_code = c;
  669.         return c;
  670.     }
  672. /*    return NULL;*/
  673.     return 0;
  674. }
  676. /* staalesc 15/08/95: FuncCode is never called, its job is done by MathEntity instead
  677. static int FuncCode(char *str, int len, int size)
  678. {
  679.     int up, down;
  680.     char ch;
  682.     token_font = UprightTextFont(size);
  684.     if (len == 3 && strncasecmp(str, "sin", len) == 0)
  685.     {
  686.         token_width = TextWidth(token_font, "sin", 3, &token_above, &token_below);
  687.         token_code = SIN;
  688.         return token_code;
  689.     }
  691.     if (len == 3 && strncasecmp(str, "cos", len) == 0)
  692.     {
  693.         token_width = TextWidth(token_font, "cos", 3, &token_above, &token_below);
  694.         token_code = COS;
  695.         return token_code;
  696.     }
  698.     if (len == 3 && strncasecmp(str, "tan", len) == 0)
  699.     {
  700.         token_width = TextWidth(token_font, "tan", 3, &token_above, &token_below);
  701.         token_code = TAN;
  702.         return token_code;
  703.     }
  705.     if (len == 3 && strncasecmp(str, "log", len) == 0)
  706.     {
  707.         token_width = TextWidth(token_font, "log", 3, &token_above, &token_below);
  708.         token_code = LOG;
  709.         return token_code;
  710.     }
  712.     if (len == 3 && strncasecmp(str, "exp", len) == 0)
  713.     {
  714.         token_width = TextWidth(token_font, "e", 1, &token_above, &token_below);
  715.         token_code = EXP;
  716.         return token_code;
  717.     }
  719.     if (len == 3 && strncasecmp(str, "int", len) == 0)
  720.     {
  721.         token_font = SymFont(size);
  722.         ch = 243;
  723.         token_width = TextWidth(token_font, &ch, 1, &up, &down);
  724.         token_above = up + up + down;
  725.         token_below = down + up + down;
  726.         token_align = ALIGN_CENTER;
  727.         token_code = INT;
  728.         token_charset = SYMSET;
  729.         return token_code;
  730.     }
  732.     if (len == 3 && strncasecmp(str, "sum", len) == 0)
  733.     {
  734.         token_font = SymFont(size);
  735.         ch = 229;        
  736.         token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  737.         token_align = ALIGN_CENTER;
  738.         token_code = SUM;
  739.         token_charset = SYMSET;
  740.         return token_code;
  741.     }
  743.     if (len == 4 && strncasecmp(str, "prod", len) == 0)
  744.     {
  745.         token_font = SymFont(size);
  746.         ch = 213;        
  747.         token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  748.         token_align = ALIGN_CENTER;
  749.         token_code = PROD;
  750.         token_charset = SYMSET;
  751.         return token_code;
  752.     }
  754.     return 0;
  755. }
  756. */
  758. static int MathEntity(int size)
  759. {
  760.     int  c, length;
  761.     char ch;
  763.     token_font = TextFont(size, current_font_tag);
  765.     if (strncmp(bufptr, "sp;", 3) == 0)
  766.     {
  767.         token_width = Space(token_font);
  768.         token_code = ' ';
  769.         bufptr += 3;
  770.         return SPACE;
  771.     }
  773.     if (strncmp(bufptr, "thinsp;", 7) == 0)
  774.     {
  775.         token_width = Space(token_font)/2;
  776.         token_code = ' ';
  777.         bufptr += 7;
  778.         return SPACE;
  779.     }
  781.     if (strncmp(bufptr, "dots;", 5) == 0)
  782.     {
  783.         token_font = SymFont(size);
  784.         token_width = TextWidth(token_font, "... ", 4, &token_above, &token_below);
  785.         token_align = ALIGN_CENTER;
  786.         token_code = DOTS;
  787. bufptr += 5;
  788.         token_charset = SYMSET;
  789.         return FUNC;
  790.     }
  792.     if (strncmp(bufptr, "int;", 4) == 0)
  793.     {
  794.         token_font = SymFont(size);
  795.         ch = 243;
  796.         token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  797.         token_above = token_above + token_above + token_below;
  798.         /* token_below = token_below + token_above + token_below; */  /* staalesc 13/12/95 */
  799.         token_align = ALIGN_CENTER;
  800.         token_code = INT;
  801. bufptr += 4;
  802.         token_charset = SYMSET;
  803.         return FUNC;
  804.     }
  806.     if (strncmp(bufptr, "sum;", 4) == 0)
  807.     {
  808.         token_font = SymFont(size);
  809.         ch = 229;        
  810.         token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  811.         token_align = ALIGN_CENTER;
  812.         token_code = SUM;
  813. bufptr += 4;
  814.         token_charset = SYMSET;
  815.         return FUNC;
  816.     }
  818.     if (strncmp(bufptr, "prod;", 5) == 0)
  819.     {
  820.         token_font = SymFont(size);
  821.         ch = 213;        
  822.         token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  823.         token_align = ALIGN_CENTER;
  824.         token_code = PROD;
  825. bufptr += 5;
  826.         token_charset = SYMSET;
  827.         return FUNC;
  828.     }
  830.     if (strncmp(bufptr, "lim;", 4) == 0)
  831.     { 
  832.         token_font = UprightTextFont(size);
  833.         token_width = TextWidth(token_font, "lim", 3, &token_above, &token_below);
  834.         token_align = ALIGN_CENTER;
  835.         token_code = LIM;
  836.   bufptr += 4;
  837.         return FUNC;
  838.     }
  840.     /* Janne Saarela 1/3/95
  841.        All the symbols entities are in the same hash table with the other
  842.        entity names. See entities.c */
  844.     if ( (c = entity(bufptr, &length)) )
  845.     {
  846.       bufptr += length-1;
  847.       if (DelimCode(c, size))
  848.           return DELIM; /* staalesc 15/08/95: entity may be '{' or '}' */
  849.       ch = c;
  850.       token_font = SymFont (size);
  851.       token_width = TextWidth(token_font, &ch, 1, &token_above, &token_below);
  852.       token_width += Space(token_font);
  853. /*      token_code = ch;*/
  854.       token_code = c; /* howcome 8/3/95 */
  855.       token_charset = SYMSET;
  856.       return SYM;
  857.     }
  859.     token_len = 0;
  860.     token_str = bufptr;
  861.     c = *bufptr++;
  863.     while (IsAlphaNumeric(c))
  864.     {
  865.         ++token_len;
  866.         c = *bufptr++;
  867.     }
  869.     if (token_len == 0)
  870.         return UNKNOWN;
  872.     token_font = UprightTextFont(size); /* Functions should not be rendered in italics */
  873.     token_width = TextWidth(token_font, token_str, token_len, &token_above, &token_below);
  874.     token_width += Space(token_font);
  875.     return NAME;
  876. }
  878. static int GetMathToken(int size)
  879. {
  880.   /* janet 21/07/95: not used:    Box *box; */
  881.   /* janet 21/07/95: not used:    char *str; */
  882.     unsigned char c; /* staalesc 15/08/95: changed from int to unsigned char */
  883.     int n; /* janet 21/07/95: not used: font */
  885.     token_align = ALIGN_RIGHT;
  886.     lastbufptr = bufptr;
  887.     token_charset = LATIN1;
  888.     token_font = TextFont(size, current_font_tag);
  889.     token_code = token_subcode = 0;
  891.     while (c = *bufptr++, IsWhite(c));
  893.     if (c == '')
  894.     {
  895.         --bufptr;
  896.         return BUFFEND;
  897.     }
  899. /*    if (c == '&' && (n = MathEntity(font)))*/ /* howcome 28/2/95: font should be size? */
  901.     if (c == '&' && (n = MathEntity(size)))
  902.         return n;
  904.     if (c == '^')
  905.     {
  906.         token_code = SHORTREF;
  907.         return TAG_SUP;
  908.     }
  910.     if (c == '_')
  911.     {
  912.         token_code = SHORTREF;
  913.         return TAG_SUB;
  914.     }
  916.     if (c == '{')
  917.     {
  918.         token_code = STARTTAG;
  919.         return TAG_BOX;
  920.     }
  922.     if (c == '}')
  923.     {
  924.         token_code = ENDTAG;
  925.         return TAG_BOX;
  926.     }
  928.     if ( (c == '<') &&  (bufptr[0] == '/' && IsLetter(bufptr[1]) || IsLetter(bufptr[0])) )
  929.         return GetTag();
  931.     if (DelimCode(c, size))
  932.         return DELIM;
  934.     if (OperatorCode(c, size))
  935.         return OPERATOR;
  937.     /* probably a NAME or FUNC */
  939.     token_len = 0;
  940.     token_str = bufptr - 1;
  943. #if 0
  945.     /* howcome 28/2/94: added more characters to the while test There
  946.        are probably even more of these */
  948.     while (IsAlphaNumeric(c) || (c == ''') || (c == '*') ||
  949.    (c == '%') || (c == ':') || (c == ';'))
  950.     {
  951.         ++token_len;
  952.         c = *bufptr++;
  953.     }
  954.     
  955. #endif
  957.     /* howcome 28/2/94: added more characters to the while test There
  958.        are probably even more of these */
  960.     /* jsaarela 7/3/95: had to separate digits from other symbols since
  961.        otherwise letters following digits would be in the symbol font */
  963.     if (IsISOLetter (c) || (c == ''') || (c == '*') || (c == '%') ||
  964.        (c == ';') || (c == '.'))
  965.     {
  966. while (IsISOLetter(c) || (c == ''') || (c == '*') || (c == '%') ||
  967.        (c == ';') || (c == '.'))
  968. {
  969.     ++token_len;
  970.     c = *bufptr++;
  971. }
  972.     } else if (IsDigit(c))
  973.     {
  974. while (IsDigit(c))
  975. {
  976.     ++token_len;
  977.     c = *bufptr++;
  978. }
  979.     }
  981. /* howcome 8/3/95: jannes part ends here */
  983.     --bufptr;
  985.     if (token_len == 0)
  986.         return UNKNOWN;
  988. /* staalesc 15/08/95: FuncCode obsolete
  989.     if (FuncCode(token_str, token_len, size))
  990.         return FUNC;
  991. */
  993.     if (IsDigit(*token_str))
  994.     {
  995.         if (size == SMALL)
  996.             token_font = TextFont(size, current_font_tag);
  997.         else
  998.             token_font = SymFont(size);
  999.     }
  1000.     else
  1001.         token_font = TextFont(size, current_font_tag);
  1003.     token_width = TextWidth(token_font, token_str, token_len, &token_above, &token_below);
  1004.     token_width += Space(token_font);
  1005.     return NAME;
  1006. }
  1008. /* janet 21/07/95: function is never used:
  1009. static void UnGetMathToken(void)
  1010. {
  1011.     bufptr = lastbufptr;
  1012. }
  1013. */
  1015. /* vertically reposition indices following stretching of base */
  1016. static void AdjustIndices(Box *base, int *above, int *below)
  1017. {
  1018.     int up, down;
  1019.     Box *box;
  1021.     up = base->above;
  1022.     down = base->below;
  1024.     for (box = base->indices; box; box = box->next)
  1025.     {
  1026.         if (box->role == LSUP || box->role == CSUP || box->role == RSUP)
  1027.         {
  1028.             box->dy = base->above + box->below;
  1029.             up = max(up, box->dy + box->above);
  1030.             continue;
  1031.         }
  1033.         if (box->role == LSUB || box->role == CSUB || box->role == RSUB)
  1034.         {
  1035.             box->dy = - (base->below + box->above);
  1036.             down = max(down, box->below - box->dy);
  1037.             continue;
  1038.         }
  1039.     }
  1041.     *above = up;
  1042.     *below = down;
  1043. }
  1045. int StretchSymbol(int font, int *up, int *down)
  1046. {
  1047.     int n, H, H1, h, ascent, descent;
  1049.     FontSize(font, &ascent, &descent);
  1050.     h = ascent + descent;
  1051.     H = *up + *down;
  1053.     if (H <= h)
  1054.         return 0;
  1056.     n = ((H + h - 1)/h) - 2;
  1057.     n = max(n, 1);
  1058.     H1 = (n + 2) * h;
  1059.     *up += (H1 - H)/2;
  1060.     *down = (H1 - *up);
  1061.     return n;
  1062. }
  1064. static void SetDelimHeight(Box *delim, int above, int below, int *above1, int *below1)
  1065. {
  1066.     int up, down;
  1067.     Box *box;
  1069.     for (box = delim; box; box = box->next)
  1070.     {
  1071.         up = above;
  1072.         down = below;
  1074.         if (box->type == DELIM)
  1075.         {
  1076.             box->above = above;
  1077.             box->below = below;
  1078.             box->len = StretchSymbol(box->font, &(box->above), &(box->below));
  1079.             up = max(up, box->above);
  1080.             down = max(down, box->below);
  1081.         }
  1082.         else if (box->type == FUNC)
  1083.         {
  1084.             if (box->code == INT)
  1085.             {
  1086.                 box->above = max(above, box->above);
  1087.                 box->below = max(below, box->below);
  1088.                 box->len = StretchSymbol(box->font, &(box->above), &(box->below));
  1089.                 AdjustIndices(box, &up, &down);
  1090.                 up = max(up, box->above);
  1091.                 down = max(down, box->below);
  1092.             }
  1093.         }
  1094.         else if (box->type == BOX)
  1095.             SetDelimHeight(box->base, above, below, &up, &down);
  1097.         *above1 = max(up, above);
  1098.         *below1 = max(down, below);
  1099.     }
  1100. }
  1102. static Box *ParseExpr(int size, int tag, int emph, int *closetag)
  1103. {
  1104.     int token, x, hw, above, below, left, right, limits=0, endtag;
  1105.     int up, down, asc, desc, oldemph; /* janet 21/07/95: not used: tmp */
  1106.     char ch;
  1107.     int basex, baseleft, baseright, baseup, basedown; /* janet 21/07/95: not used: baseh */
  1108.     Box *box, *next, *numerator, *denominator, *ldelim; /* janet 21/07/95: not used: *tmpBox */
  1110.     oldemph = EMPH_NORMAL;
  1111.     box = NULL;
  1112.     x = above = below = 0;
  1113.     basex = baseleft = baseright = baseup = basedown = 0;
  1114.     *closetag = BUFFEND;
  1116.     while ((token = GetMathToken(size)) != BUFFEND)
  1117.     {
  1118.         if (token == tag)
  1119.         {
  1120.             if (token_code == ENDTAG || token_code == SHORTREF)
  1121.             {
  1122.                 *closetag = token;
  1123. /* don't use swallowattribute as it does not work with } */
  1124. if (*bufptr == '>')
  1125.     bufptr++;
  1126.                 break;
  1127.             }
  1128.         }
  1130.      /* need to do something smarter based on tag classes */
  1131.         if (token == TAG_OVER || token == TAG_ATOP || token == TAG_LEFT ||
  1132.     token == TAG_RIGHT || token == TAG_OF)
  1133.         {
  1134.             *closetag = token;
  1135.     SwallowAttributes ();
  1136.             break;
  1137.         }
  1138.         switch (token)
  1139.         {
  1140.             case SPACE:
  1141.                 basex = x;
  1142.                 baseleft = baseright = baseup = basedown = 0;
  1143.                 x += token_width;
  1144.                 above = max(above, token_above);
  1145.                 below = max(below, token_below);
  1146.                 break;
  1148.             case TAG_SUP:
  1149. /* SwallowAttributes ();*/
  1151. if (*bufptr == '>')
  1152.     bufptr++;
  1154.                 if (token_code != ENDTAG)
  1155.                 {
  1156.                     next = ParseExpr(SMALL, TAG_SUP, emph, &endtag);
  1157.                     next->role = RSUP;
  1159.                     if (!box)
  1160.                         box = NewBox(token_font);
  1162.                     next->next = box->indices;
  1163.                     box->indices = next;
  1165.                     if (limits == ALIGN_RIGHT)
  1166.                     {
  1167.                         baseright = max(baseright, next->w);
  1168.                         next->dx = box->w - Space(token_font)/2; /* staalesc 13/12/95 */
  1169.                         next->dy = box->above;
  1170.                         baseup = max(baseup, next->above);
  1171.                         x = basex + baseleft + box->w + baseright;
  1172.                     }
  1173.                     else if (limits == ALIGN_CENTER)
  1174.                     {
  1175.                         right = (next->w)/2;
  1176.                         hw = (box->w)/2;
  1178.                         if (right > baseright + hw)
  1179.                             baseright = right + hw;
  1181.                         left = next->w - right;
  1182.                         hw = box->w - hw;
  1183.                         next->dx = hw - left;
  1185.                         if (left > baseleft + hw)
  1186.                         {
  1187.                             baseleft = left - hw;
  1188.                             box->dx = basex + baseleft;
  1189.                         }
  1191.                         next->dy = box->above + next->below;
  1192.                         baseup = max(baseup, next->above + next->below);
  1193.                         x = basex + box->w + baseright;
  1194.                     }
  1196.                     above = max(above, box->above + baseup);
  1197.                 }
  1198.                 break;
  1200.             case TAG_SUB:
  1201. /* SwallowAttributes ();*/
  1203. if (*bufptr == '>')
  1204.     bufptr++;
  1206.                 if (token_code != ENDTAG)
  1207.                 {
  1208.                     next = ParseExpr(SMALL, TAG_SUB, emph, &endtag);
  1209.                     next->role = RSUB;
  1211.                     if (!box)
  1212.                         box = NewBox(token_font);
  1214.                     next->next = box->indices;
  1215.                     box->indices = next;
  1217.                     if (limits == ALIGN_RIGHT)
  1218.                     {
  1219.                         baseright = max(baseright, next->w);
  1220.                         next->dx = box->w - Space(token_font)/2;  /* staalesc 13/12/95 */
  1221.                         next->dy = - (box->below);
  1222.                         basedown = max(basedown, next->below);
  1223.                         x = baseleft + basex + box->w + baseright;
  1224.                     }
  1225.                     else if (limits == ALIGN_CENTER)
  1226.                     {
  1227.                         right = (next->w)/2;
  1228.                         hw = (box->w)/2;
  1230.                         if (right > baseright + hw)
  1231.                             baseright = right + hw;
  1233.                         left = next->w - right;
  1234.                         hw = box->w - hw;
  1235.                         next->dx = hw - left;
  1237.                         if (left > baseleft + hw)
  1238.                         {
  1239.                             baseleft = left - hw;
  1240.                             box->dx = basex + baseleft;
  1241.                         }
  1243.                         next->dy = box->dy - (box->below + next->above);  /* staalesc 13/12/95 */
  1244.                         basedown = max(basedown, next->above + next->below);
  1245.                         x = baseleft + basex + baseright + Space(token_font);
  1246.                     }
  1248.                     below = max(below, box->below + basedown - box->dy);
  1249.                 }
  1250.                 break;
  1252.             case TAG_BOX:
  1253. /* cannot swallow attributes here as they cannot be found
  1254.    in case of { and }. If some day someone introduces
  1255.    attributes to BOX elements, this has to be changed */
  1256. if (*bufptr == '>') {
  1257.     bufptr++;
  1258. }
  1259.                 if (token_code != ENDTAG)
  1260.                 {
  1261.                     int up1, down1;
  1263.                     limits = token_align;
  1264.                     basex = x;
  1265.                     baseleft = baseright = baseup = basedown = 0;
  1266.                     next = ParseExpr(size, TAG_BOX, emph, &endtag);
  1268.                     if (endtag == TAG_LEFT)
  1269.                     {
  1270.                         ldelim = next;
  1272.                         if (ldelim)
  1273.                             ldelim->role = LDELIM;
  1275.                         next = ParseExpr(size, TAG_BOX, emph, &endtag);
  1276.                     }
  1277.                     else
  1278.                         ldelim = NULL;
  1280.                     if (endtag == TAG_OVER || endtag == TAG_ATOP)
  1281.                     {
  1282.                         int previous_endtag = endtag; /* Need to remember this */
  1283.                         numerator = next;
  1284.                         numerator->role = CSUP;
  1285.                         denominator = ParseExpr(size, TAG_BOX, emph, &endtag);
  1286.                         denominator->role = CSUB;
  1287.                         next = NewBox(SymFont(size));
  1288.                         if (previous_endtag == TAG_OVER)
  1289.                             next->type = DIVIDER;
  1290.                         else /* previous_endtag == TAG_ATOP */
  1291.                             next->type = NONE;
  1292.                         next->code = 0;
  1293.                         next->above = 1;
  1294.                         next->below = 2;
  1295.                         next->w = 10;
  1296.                         next->dy = divide_base(next->font);  /* staalesc 13/12/95 */
  1297.                         next->indices = denominator;
  1298.                         denominator->next = numerator;
  1300.                         if (numerator->w > denominator->w)
  1301.                         {
  1302.                             right = (numerator->w)/2;
  1303.                             left = numerator->w - right;
  1304.                             numerator->dx = 2;  /* staalesc 13/12/95 */
  1305.                             denominator->dx = 2 + left - denominator->w + (denominator->w)/2;
  1306.                         }
  1307.                         else
  1308.                         {
  1309.                             right = (denominator->w)/2;
  1310.                             left = denominator->w - right;
  1311.                             denominator->dx = 2;  /* staalesc 13/12/95*/
  1312.                             numerator->dx = 2 + left - numerator->w + (numerator->w)/2;
  1313.                         }
  1315.                         numerator->dy = next->dy + next->above + numerator->below;
  1316.                         denominator->dy = next->dy - (next->below + denominator->above);
  1317.                         up = next->above + (numerator->above + numerator->below);
  1318.                         down = next->below + (denominator->above + denominator->below);
  1319.                         next->w = left + right + 3;             /* staalesc 13/12/95 */
  1320.                         above = max(above, up + next->dy);      /* staalesc 13/12/95 */
  1321.                         below = max(below, down - next->dy);    /* staalesc 13/12/95 */
  1322.                     }
  1323.                     else
  1324.                     {
  1325.                         up = next->above;
  1326.                         down = next->below;
  1327.                         above = max(above, up);
  1328.                         below = max(below, down);
  1329.                     }
  1331.                  /* at this point next is the boxed expression */
  1333.                     if (next)
  1334.                     {
  1335.                         next->next = box;
  1336.                         box = next;
  1337.                         box->dx = x;
  1338.                         /* box->dy = 0; */  /* staalesc 13/12/95 */
  1339.                     }
  1341.                 /* insert left delimited in list of indices
  1342.                    and adjust position of expression to make room */
  1344.                     if (ldelim)
  1345.                     {
  1346.                         if (!box)  /* avoid core dump */
  1347.                         {
  1348.                             box = NewBox(SymFont(size));
  1349.                             box = next;
  1350.                             box->dx = x;
  1351.                             box->dy = 0;
  1352.                         }
  1354.                         SetDelimHeight(ldelim, up, down, &up1, &down1);
  1355.                         above = max(above, up1 + box->dy);
  1356.                         below = max(below, down1 + box->dy);
  1357.                         ldelim->next = box->indices;
  1358.                         box->indices = ldelim;
  1359.                         ldelim->dx = - ldelim->w;
  1360.                         ldelim->dy = 0;
  1361.                         box->dx += ldelim->w;
  1362.                     }
  1364.                     if (box)
  1365.                         x = box->dx + box->w + Space(token_font)/2;  /* staalesc 13/12/95 */
  1367.                 /* and check for a <RIGHT> element */
  1369.                     if (endtag == TAG_RIGHT)
  1370.                     {
  1371.                         next = ParseExpr(size, TAG_BOX, emph, &endtag);
  1373.                         if (next)
  1374.                         {
  1375.                             if (!box)  /* avoid core dump */
  1376.                             {
  1377.                                 box = NewBox(SymFont(size));
  1378.                                 box = next;
  1379.                                 box->dx = x;
  1380.                                 box->dy = 0;
  1381.                             }
  1383.                             next->role = RDELIM;
  1384.                             SetDelimHeight(next, up, down, &up1, &down1);
  1385.                             above = max(above, up1 + box->dy);
  1386.                             below = max(below, down1 + box->dy);
  1387.                             next->next = box->indices;
  1388.                             box->indices = next;
  1389.                             next->dx = box->w;
  1390.                             next->dy = 0;
  1391.                             x += next->w;
  1392.                         }
  1393.                     }
  1394.                 }
  1395.                 break;
  1397.     case TAG_UPRIGHT:
  1398. SwallowAttributes ();
  1399.                 if (token_code != ENDTAG)
  1400.                 {
  1401.     limits = token_align;
  1402.     basex = x;
  1403.     baseleft = baseright = baseup = basedown = 0;
  1404.     current_font_tag = TAG_UPRIGHT;
  1405.     next = ParseExpr(size, TAG_UPRIGHT, emph, &endtag);
  1406.     if (next)
  1407.     {
  1408. if (box) {
  1409.     next->next = box;
  1410.     box = next;
  1411. } else {
  1412.     box = next;
  1413. }
  1414. next->font = TextFont(size, current_font_tag);
  1415. current_font_tag = 0;
  1416. next->dx = x;
  1417. next->dy = 0;
  1418.     }
  1419.                     above = max(above, next->above);  /* staalesc 13/12/95 */
  1420.     x += next->w + 2;
  1421. }
  1422. break;
  1424.     case TAG_BUPRIGHT:
  1425. SwallowAttributes ();
  1426.                 if (token_code != ENDTAG)
  1427.                 {
  1428.     limits = token_align;
  1429.     basex = x;
  1430.     baseleft = baseright = baseup = basedown = 0;
  1431.     current_font_tag = TAG_BUPRIGHT;
  1432.     next = ParseExpr(size, TAG_BUPRIGHT, emph, &endtag);
  1433.     if (next)
  1434.     {
  1435. if (box) {
  1436.     next->next = box;
  1437.     box = next;
  1438. } else {
  1439.     box = next;
  1440. }
  1441. next->font = TextFont(size, current_font_tag);
  1442. current_font_tag = 0;
  1443. next->dx = x;
  1444. next->dy = 0;
  1445.     }
  1446.                     above = max(above, next->above);  /* staalesc 13/12/95 */
  1447.     x += next->w + 2;
  1448. }
  1449. break;
  1451.     case TAG_BOLDTEXT:
  1452. SwallowAttributes ();
  1453.                 if (token_code != ENDTAG)
  1454.                 {
  1455.     limits = token_align;
  1456.     basex = x;
  1457.     baseleft = baseright = baseup = basedown = 0;
  1458.     current_font_tag = TAG_BOLDTEXT;
  1459.     next = ParseExpr(size, TAG_BOLDTEXT, emph, &endtag);
  1460.     if (next)
  1461.     {
  1462. if (box) {
  1463.     next->next = box;
  1464.     box = next;
  1465. } else {
  1466.     box = next;
  1467. }
  1468. next->font = TextFont(size, current_font_tag);
  1469. current_font_tag = 0;
  1470. next->dx = x;
  1471. next->dy = 0;
  1472.     }
  1473.                     above = max(above, next->above);  /* staalesc 13/12/95 */
  1474.     x += next->w + 2;
  1475. }
  1476. break;
  1478.     case TAG_SQRT:
  1479. SwallowAttributes ();
  1480.                 if (token_code != ENDTAG)
  1481.                 {
  1482.                     limits = token_align;
  1483.                     basex = x;
  1484.                     baseleft = baseright = baseup = basedown = 0;
  1486.     /* Create a box for the square root symbol */
  1487.     next = NewBox (SymFont(size));
  1488.     next->font = SymFont (size);
  1489.     next->type = RADICAL;
  1490.     ch = 214; /* the square root character */
  1491.     next->w = 2 + TextWidth(next->font, &ch, 1,
  1492. &token_above, &token_below);
  1493.     next->dx = x;
  1494.     next->dy = 0;
  1495.     next->above = token_above;
  1496.     next->below = token_below;
  1497.     next->next = box;
  1498.     box = next;
  1499.     x += next->w;
  1500.                     next = ParseExpr(size, TAG_SQRT, emph, &endtag);
  1501.     if (next)
  1502.     {
  1503. next->dx = x;
  1504. next->dy = 0;
  1505. x += next->w;
  1507.                         /* staalesc 13/12/95: Stretch the radical to fit expression */
  1508. box->above = next->above += 2;
  1509.                         box->below = next->below;
  1510. next->next = box;
  1511. box = next;
  1513.                         /* staalesc 13/12/95: Place the whole expression inside its own box */
  1514.                         next = NewBox(token_font);
  1515.                         next->type = BOX;
  1516.         next->emph |= EMPH_ROOTLINE;
  1517.                         next->dx = box->dx;
  1518.                         next->dy = 0;
  1519.                         next->above = box->above;
  1520.                         next->below = box->below;
  1521.                         next->w = x - box->dx;
  1522.                         next->next = box;
  1523.                         box = next;
  1525. limits = token_align;
  1526. above = max (above, next->above);
  1527. below = max (below, next->below);
  1528.     }
  1529. }
  1530. break;
  1532.     case TAG_ROOT:
  1533. SwallowAttributes ();
  1534.                 if (token_code != ENDTAG)
  1535.                 {
  1536.                     limits = token_align;
  1537.                     basex = x;
  1538.                     baseleft = baseright = baseup = basedown = 0;
  1540.     /* create a box in which we can draw the square root symbol */
  1541.     next = NewBox (SymFont(size));
  1542.     next->font = SymFont (size);
  1543.     next->type = RADICAL;
  1544.     ch = 214; /* the square root character */
  1545.     next->w = 2 + TextWidth(next->font, &ch, 1,
  1546. &token_above, &token_below);
  1547.     next->dx = x;
  1548.     next->dy = 0;
  1549.     next->above = token_above;
  1550.     next->below = token_below;
  1551.     next->next = box;
  1552.     box = next;
  1553.     x += next->w;
  1555.                     next = ParseExpr(SMALL, TAG_ROOT, emph, &endtag);
  1556.                     if (endtag == TAG_OF)
  1557.                     {
  1558. /* place the index of the root over the root sign */
  1559. if (next)
  1560.                         {
  1561.     FontSize(next->font, &asc, &desc);
  1562.     next->dx = box->dx-next->w+box->w;
  1563.     /* next->dy = (asc+desc)*0.95; */
  1564.     next->above = token_above;
  1565.     next->below = token_below;
  1566.     next->next = box;
  1567.     box = next;
  1569.     limits = token_align;
  1570.     above = max (above, next->above);
  1571.     below = max (below, next->below);
  1572. }
  1573. next = ParseExpr(size, TAG_ROOT, emph, &endtag);
  1574. if (next)
  1575.                         {
  1576.     next->dx = x;
  1577.     next->dy = 0;
  1578.     x += next->w;
  1580.                             /* staalesc 13/12/95: Stretch the radical to fit expression */
  1581.     box->next->above = next->above += 2;
  1582.                             box->next->below = next->below;
  1583.                             box->dy = next->above-asc+2; /* position the index correctly */
  1584.     next->next = box;
  1585.     box = next;
  1587.                             /* staalesc 13/12/95: Place the whole expression inside its own box */
  1588.                             next = NewBox(token_font);
  1589.                             next->type = BOX;
  1590.             next->emph |= EMPH_ROOTLINE;
  1591.                             next->dx = box->dx;
  1592.                             next->dy = 0;
  1593.                             next->above = box->above;
  1594.                             next->below = box->below;
  1595.                             next->w = x - box->dx;
  1596.                             next->next = box;
  1597.                             box = next;
  1598.     
  1599.     limits = token_align;
  1600.     above = max (above, next->above);
  1601.     below = max (below, next->below);
  1602. }
  1603.       } else { /* Missing <OF> tag: treat just like <SQRT> */
  1604. if (next)
  1605. {
  1606.     next->dx = x;
  1607.     next->dy = 0;
  1608.     x += next->w;
  1610.                             /* staalesc 13/12/95: Stretch the radical to fit expression */
  1611.     box->above = next->above += 2;
  1612.                             box->below = next->below;
  1613.     next->next = box;
  1614.     box = next;
  1616.                             /* staalesc 13/12/95: Place the whole expression inside its own box */
  1617.                             next = NewBox(token_font);
  1618.                             next->type = BOX;
  1619.             next->emph |= EMPH_ROOTLINE;
  1620.                             next->dx = box->dx;
  1621.                             next->dy = 0;
  1622.                             next->above = box->above;
  1623.                             next->below = box->below;
  1624.                             next->w = x - box->dx;
  1625.                             next->next = box;
  1626.                             box = next;
  1628.     limits = token_align;
  1629.     above = max (above, next->above);
  1630.     below = max (below, next->below);
  1631. }
  1632.     }
  1633. }
  1634. break;
  1636.             case TAG_VEC:
  1637.             case TAG_BAR:
  1638.             case TAG_DOT:
  1639.             case TAG_DDOT:
  1640.             case TAG_HAT:
  1641.             case TAG_TILDE:
  1642. SwallowAttributes ();
  1643.                 if (token_code != ENDTAG)
  1644.                 {
  1645.                     limits = token_align;
  1646.                     basex = x;
  1647.                     baseleft = baseright = baseup = basedown = 0;
  1648.                     next = ParseExpr (size, token, emph, &endtag);
  1649.                     if (next)
  1650.                     {
  1651.                         next->dx = x;
  1652.                         next->dy = 0;
  1654.                         next->above = token_above;
  1655.                         next->below = token_below;
  1656.                         next->next = box;
  1657.                         box = next;
  1658.                         x += next->w;
  1660.                         oldemph = emph;
  1662.                         switch (token) {
  1663.                         case TAG_VEC:
  1664.                             emph |= EMPH_OVERRARR;
  1665.                             break;
  1666.                         case TAG_BAR:
  1667.                             emph |= EMPH_OVERLINE;
  1668.                             break;
  1669.                         case TAG_DOT:
  1670.                             emph |= EMPH_OVERDOT;
  1671.                             break;
  1672.                         case TAG_DDOT:
  1673.                             emph |= EMPH_OVERDDOT;
  1674.                             break;
  1675.                         case TAG_HAT:
  1676.                             emph |= EMPH_OVERHAT;
  1677.                             break;
  1678.                         case TAG_TILDE:
  1679.                             emph |= EMPH_OVERTILDE;
  1680.                             break;
  1681.                         default:
  1682.                             break;
  1683.                         }   
  1685.                         /* staalesc 13/12/95: Place the whole expression inside its own box */
  1686.                         next = NewBox(token_font);
  1687.                         next->type = BOX;
  1688.         next->emph = emph;
  1689.                         next->dx = basex;
  1690.                         next->dy = 0;
  1691.                         next->above = box->above;
  1692.                         next->below = box->below;
  1693.                         next->w = x - basex;
  1694.                         next->next = box;
  1695.                         box = next;
  1697.                         emph = oldemph;
  1699.                         above = max(above, next->above);
  1700.                         below = max(below, next->below);
  1701.                     }
  1702.                 }
  1703.                 break;
  1705.     case TAG_ABOVE:
  1706. if (token_code != ENDTAG)
  1707. {
  1708.                     int newemph = 0;
  1709.     ParseAboveAttrs (&newemph);
  1710.     limits = token_align;
  1711.     basex = x;
  1712.     baseleft = baseright = baseup = basedown = 0;
  1713.     next = ParseExpr (size, TAG_ABOVE, emph, &endtag);
  1714.     if (next)
  1715.     {
  1716. next->dx = x;
  1717. next->dy = 0;
  1719. next->above = token_above;
  1720. next->below = token_below;
  1721. next->next = box;
  1722. box = next;
  1723. x += next->w;
  1725.                         /* staalesc 13/12/95: Place the whole expression inside its own box */
  1726.                         next = NewBox(token_font);
  1727.                         next->type = BOX;
  1728.         next->emph = newemph;
  1729.                         next->dx = basex;
  1730.                         next->dy = 0;
  1731.                         next->above = box->above;
  1732.                         next->below = box->below;
  1733.                         next->w = x - basex;
  1734.                         next->next = box;
  1735.                         box = next;
  1737. above = max(above, next->above);
  1738. below = max(below, next->below);
  1739.     }
  1740. }
  1741. break;
  1743.     case TAG_BELOW:
  1744. if (token_code != ENDTAG)
  1745. {
  1746.                     int newemph = 0;
  1747.     ParseBelowAttrs (&newemph);
  1748.     limits = token_align;
  1749.     basex = x;
  1750.     baseleft = baseright = baseup = basedown = 0;
  1751.     next = ParseExpr (size, TAG_BELOW, emph, &endtag);
  1752.     if (next)
  1753.     {
  1754. next->dx = x;
  1755. next->dy = 0;
  1757. next->above = token_above;
  1758. next->below = token_below;
  1759. next->next = box;
  1760. box = next;
  1761. x += next->w;
  1763.                         /* staalesc 13/12/95: Place the whole expression inside its own box */
  1764.                         next = NewBox(token_font);
  1765.                         next->type = BOX;
  1766.         next->emph = newemph;
  1767.                         next->dx = basex;
  1768.                         next->dy = 0;
  1769.                         next->above = box->above;
  1770.                         next->below = box->below;
  1771.                         next->w = x - basex;
  1772.                         next->next = box;
  1773.                         box = next;
  1775. above = max(above, next->above);
  1776. below = max(below, next->below);
  1777.     }
  1778. }
  1779. break;
  1781.             case NAME:
  1782.                 limits = token_align;
  1783.                 basex = x;
  1784.                 baseleft = baseright = baseup = basedown = 0;
  1785.                 next = NewBox(token_font);
  1786.                 next->font = token_font;
  1787.                 next->type = NAME;
  1788.                 next->str = token_str;
  1789.                 next->len = token_len;
  1790. next->emph = emph;
  1791.                 next->dx = x;
  1792.                 next->dy = 0;
  1793.                 next->above = token_above;
  1794.                 next->below = token_below;
  1795.                 next->w = token_width;
  1796.                 next->next = box;
  1797.                 box = next;
  1798.                 x += box->w;
  1799.                 above = max(above, token_above);
  1800.                 below = max(below, token_below);
  1801.                 break;
  1803.             case FUNC:
  1804.                 limits = token_align;
  1805.                 basex = x;
  1806.                 baseleft = baseright = baseup = basedown = 0;
  1807.                 next = NewBox(token_font);
  1808.                 next->font = token_font;
  1809.                 next->type = FUNC;
  1810.                 next->code = token_code;
  1811. next->emph = emph;
  1812.                 next->dx = x;
  1813.                 if (next->code == LIM)
  1814.                     next->dy = divide_base(next->font);  /* staalesc 13/12/95 */
  1815.                 else
  1816.                     next->dy = 0;
  1817.                 next->above = token_above;
  1818.                 next->below = token_below;
  1819.                 next->w = token_width;
  1820.                 next->next = box;
  1821.                 box = next;
  1822.                 x += box->w;
  1823.                 above = max(above, token_above + box->dy);
  1824.                 below = max(below, token_below - box->dy);
  1825.                 break;
  1827.             case OPERATOR:
  1828.                 if (token_code=='=')
  1829.                     token_align = ALIGN_CENTER;  /* staalesc 13/12/95 */
  1830.                 limits = token_align;
  1831.                 basex = x;
  1832.                 baseleft = baseright = baseup = basedown = 0;
  1833.                 next = NewBox(token_font);
  1834.                 next->type = OPERATOR;
  1835.                 next->code = token_code;
  1836. next->emph = emph;
  1837.                 if (next->code == '.')
  1838.                     x -= Space(token_font);  /* staalesc 13/12/95 */
  1839.                 next->dx = x;
  1840.                 next->dy = 0;
  1841.                 next->above = token_above;
  1842.                 next->below = token_below;
  1843.                 next->w = token_width;
  1844.                 next->next = box;
  1845.                 box = next;
  1846.                 x += box->w+2;
  1847.                 above = max(above, token_above);
  1848.                 below = max(below, token_below);
  1849.                 break;
  1851.             case RADICAL:
  1852.             case DELIM:
  1853.             case SYM:
  1854.                 if (token_code==174 || token_code==222 || token_code==219)
  1855.                     token_align = ALIGN_CENTER;  /* staalesc 13/12/95 */
  1856.                 limits = token_align;
  1857.                 basex = x;
  1858.                 baseleft = baseright = baseup = basedown = 0;
  1859.                 next = NewBox(token_font);
  1860.                 next->type = token;
  1861.                 next->code = token_code;
  1862.                 next->subcode = token_subcode;
  1863. next->emph = emph;
  1864.                 next->dx = x;
  1865.                 next->dy = 0;
  1866.                 next->above = token_above;
  1867.                 next->below = token_below;
  1868.                 next->w = token_width;
  1869.                 next->next = box;
  1870.                 box = next;
  1871.                 x += box->w;
  1872.                 above = max(above, token_above);
  1873.                 below = max(below, token_below);
  1874.                 break;
  1876.     case TAG_MATH:
  1877.     case TAG_LEFT:
  1878.     case TAG_RIGHT:
  1879. SwallowAttributes ();
  1880. break;
  1881.         }
  1882.     }
  1884.  /* place non-atomic expression in a box */
  1886.     if (box)
  1887.     {
  1888.         if (box->next != NULL || box->indices != NULL)
  1889.         {
  1890.             next = NewBox(TextFont(size, current_font_tag));
  1891.             next->type = BOX;
  1892.             next->base = box;
  1893.             box = next;
  1894.         }
  1896.         box->w = x;
  1897.         box->above = above;
  1898.         box->below = below;
  1899.     }
  1901.     return box;
  1902. }
  1904. static void PutChar(Frame *frame, int emph, int font, char c, int x, int y)
  1905. {
  1906.     PutText(frame, emph, font, &c, 1, x, y);
  1907. }
  1909. static void PrintStr(Frame *frame, Box *box, int x, int y)
  1910. {
  1911.     x += box->dx;
  1912.     y += box->dy;
  1913.     PutText(frame, box->emph, box->font, box->str, box->len, x, y);
  1914. }
  1916. /* added void before DrawBigSym wm 20.Jan.95 */
  1917. static void DrawBigSym(Frame *frame, Box *box, int x, int y, char topch, char middlech, char bottomch)
  1918. {
  1919.     int len, h, asc, desc, m;
  1921.     FontSize(box->font, &asc, &desc);
  1922.     h = asc + desc;
  1923.     y += box->above - asc;
  1924.     PutChar(frame, box->emph, box->font, topch, x, y);
  1925.     len = box->len;
  1926.     m = len/2;
  1928.     while (len-- > 0)
  1929.     {
  1930.         y -= h;
  1931.         /* staalesc 15/08/95: kludge for '{' and '}' */
  1932.         if ((len!=m) && ((box->subcode==123) || (box->subcode==125)))
  1933.             PutChar(frame, box->emph, box->font, 239, x, y);
  1934.         else
  1935.             PutChar(frame, box->emph, box->font, middlech, x, y);
  1936.     }
  1938.      y -= h;
  1939.     PutChar(frame, box->emph, box->font, bottomch, x, y);
  1940. }
  1942. static void PrintFunc(Frame *frame, Box *box, int x, int y)
  1943. {
  1944.   /* janet 21/07/95: not used:    int i; */
  1945.     char *s = NULL;
  1947.     x += box->dx;
  1948.     y += box->dy;
  1950.     switch(box->code)
  1951.     {
  1952.         case INT:
  1953.             DrawBigSym(frame, box, x, y, 243, 244, 245);
  1954.             return;
  1956.         case SUM:
  1957.             PutChar(frame, box->emph, box->font, 229, x, y);
  1958.             return;
  1960.         case PROD:
  1961.             PutChar(frame, box->emph, box->font, 213, x, y);
  1962.             return;
  1964.         case LIM:
  1965.             s = "lim";
  1966.             break;
  1968.         case DOTS:
  1969.             s = "...";
  1970.             break;
  1971.     }
  1973.     PutText(frame, box->emph, box->font, s, strlen(s), x, y);
  1974. }
  1976. static void PrintSym(Frame *frame, Box *box, int x, int y)
  1977. {
  1978.   /*  janet 21/07/95: not used:   int i;   */
  1979.   /*  janet 21/07/95: not used:   char *s; */
  1981.     x += box->dx;
  1982.     y += box->dy;
  1983.     PutChar(frame, box->emph, box->font, box->code, x, y);
  1984. }
  1986. static void PrintOperator(Frame *frame, Box *box, int x, int y)
  1987. {
  1988.     x += box->dx;
  1989.     y += box->dy;
  1990.     PutChar(frame, box->emph, box->font, box->code, x, y);
  1991. }
  1993. static void PrintDelim(Frame *frame, Box *box, int x, int y)
  1994. {
  1995.   /*  janet 21/07/95: not used:   int i; */
  1997.     x += box->dx;
  1998.     y += box->dy;
  2000.     if (box->len > 0)
  2001.     {
  2002.         if (box->subcode == 124)  /* kludge for '|' */
  2003.             DrawBigSym(frame, box, x, y, box->code, box->code, box->code);
  2004.         else
  2005.             DrawBigSym(frame, box, x, y, box->code-1, box->code, box->code+1);
  2006.     }
  2007.     else
  2008.         PutChar(frame, box->emph, box->font, box->subcode, x, y);
  2009. }
  2011. static void RenderMath(Frame *frame, Box *box, int x, int y)
  2012. {
  2013.   /* janet 21/07/95: not used:    Box *indices; */
  2015.     if (box == NULL)
  2016.         return;
  2018.     RenderMath(frame, box->next, x, y);
  2020. /* staalesc: Uncomment this for debugging:
  2022.     PrintLine (frame,
  2023.                x + box->dx,
  2024.                x + box->dx + box->w,
  2025.        y + box->dy - box->below,
  2026.                y + box->dy - box->below);
  2027.     PrintLine (frame,
  2028.                x + box->dx,
  2029.                x + box->dx + box->w,
  2030.        y + box->dy + box->above,
  2031.                y + box->dy + box->above);
  2032.     PrintLine (frame,
  2033.                x + box->dx,
  2034.                x + box->dx,
  2035.        y + box->dy - box->below,
  2036.                y + box->dy + box->above);
  2037.     PrintLine (frame,
  2038.                x + box->dx + box->w,
  2039.                x + box->dx + box->w,
  2040.        y + box->dy - box->below,
  2041.                y + box->dy + box->above);
  2042. */
  2044.     switch(box->type)
  2045.     {
  2046.         case NAME:
  2047.             PrintStr(frame, box, x, y);
  2048.             break;
  2050.         case FUNC:
  2051.             PrintFunc(frame, box, x, y);
  2052.             break;
  2054.         case OPERATOR:
  2055.             PrintOperator(frame, box, x, y);
  2056.             break;
  2058.         case DELIM:
  2059.             PrintDelim(frame, box, x, y);
  2060.             break;
  2062.         case RADICAL:
  2063.             {
  2064. PrintLine (frame,
  2065.                            x + box->dx,
  2066.                            x + box->dx+2,
  2067.    y + box->dy - box->below + (box->above+box->below)/2,
  2068.                            y + box->dy - box->below + (box->above+box->below)/2 + 1);
  2069. PrintLine (frame,
  2070.                            x + box->dx+2,
  2071.                            x + box->dx+2 + (box->w-2)/3,
  2072.    y + box->dy - box->below + (box->above+box->below)/2,
  2073.                            y + box->dy - box->below + 1);
  2074. PrintLine (frame,
  2075.                            x + box->dx+2 + (box->w-2)/3,
  2076.                            x + box->dx + box->w,
  2077.    y + box->dy - box->below + 1,
  2078.                            y + box->dy + box->above);
  2079.             }
  2080.             break;
  2082.         case SYM:
  2083.             PrintSym(frame, box, x, y);
  2084.             break;
  2086.         case DIVIDER:
  2087.             PrintRule(frame, HLINE, x + box->dx, box->w, y + box->dy);
  2088.             break;
  2090.         case BOX:
  2091.     /* staalesc 13/12/95: Handle all the EMPH tags here */
  2092.     if (box->emph & EMPH_ROOTLINE) {
  2093. PrintRule (frame, HLINE, x + box->dx, box->w,
  2094.    y + box->dy + box->above);
  2095. PrintLine (frame, x + box->dx + box->w, x + box->dx + box->w,
  2096.    y + box->dy + box->above, y + box->dy + box->above - 2);
  2097.     }
  2098.     if (box->emph & EMPH_OVERLINE) {
  2099. PrintRule (frame, HLINE, x + box->dx, box->w,
  2100.    y + box->dy + box->above - 1);
  2101.     }
  2102.     if (box->emph & EMPH_OVERRARR) {
  2103. PrintRule (frame, HLINE, x + box->dx, box->w,
  2104.    y + box->dy + box->above - 1);
  2105. PrintLine (frame, x + box->dx + box->w, x + box->dx + box->w - 2,
  2106.    y + box->dy + box->above - 1, y + box->dy + box->above - 3);
  2107.         PrintLine (frame, x + box->dx + box->w, x + box->dx + box->w - 2,
  2108.    y + box->dy + box->above - 1, y + box->dy + box->above + 1);
  2109.     }
  2110.     if (box->emph & EMPH_OVERLARR) {
  2111. PrintRule (frame, HLINE, x + box->dx, box->w,
  2112.    y + box->dy + box->above - 1);
  2113. PrintLine (frame, x + box->dx, x + box->dx + 2,
  2114.    y + box->dy + box->above - 1, y + box->dy + box->above - 3);
  2115.         PrintLine (frame, x + box->dx, x + box->dx + 2,
  2116.    y + box->dy + box->above - 1, y + box->dy + box->above + 1);
  2117.     }
  2118.     if (box->emph & EMPH_UNDERLINE) {
  2119. PrintRule (frame, HLINE, x + box->dx, box->w,
  2120.    y + box->dy - box->below - 1);
  2121.     }
  2122.     if (box->emph & EMPH_UNDERRARR) {
  2123. PrintRule (frame, HLINE, x + box->dx, box->w,
  2124.    y + box->dy - box->below - 1);
  2125. PrintLine (frame, x + box->dx + box->w, x + box->dx + box->w - 3,
  2126.    y + box->dy - box->below - 1, y + box->dy - box->below - 3);
  2127.         PrintLine (frame, x + box->dx + box->w, x + box->dx + box->w - 2,
  2128.    y + box->dy - box->below - 1, y + box->dy - box->below + 1);
  2129.     }
  2130.     if (box->emph & EMPH_UNDERLARR) {
  2131. PrintRule (frame, HLINE, x + box->dx, box->w,
  2132.    y + box->dy - box->below - 1);
  2133. PrintLine (frame, x + box->dx, x + box->dx + 2,
  2134.    y + box->dy - box->below - 1, y + box->dy - box->below - 3);
  2135.         PrintLine (frame, x + box->dx, x + box->dx + 2,
  2136.    y + box->dy - box->below - 1, y + box->dy - box->below + 1);
  2137.     }
  2138.     RenderMath(frame, box->base, x + box->dx, y + box->dy);
  2139.             break;
  2140.     }
  2142.     RenderMath(frame, box->indices, x + box->dx, y);
  2143. }
  2145. /* shouldn't BoxFree be freeing more than b->next? */
  2146. void BoxFree(Box *b)
  2147. {
  2148.   if (b->next) 
  2149.     BoxFree(b->next);
  2150. #if 0
  2151.   else {
  2153.     Free(b->indices); /* janet 2/8/95: added  */
  2154.     Free(b->base);
  2155.     Free(b->str); 
  2156.     Free(b);
  2157.     return;
  2158.   }
  2159. */
  2161.   /* janet 2/8/95: added freeing base and indices too  */
  2163.   if (b->base)
  2164.     BoxFree(b->base);
  2165.   else
  2166.     return;
  2167.   
  2168.   if (b->indices)
  2169.     BoxFree(b->indices);
  2170.   else
  2171.     return;
  2172.   
  2173.   Free(b->next);  /* janet: what about free(b->indices), free(b->base), free(b->str), free(b) ?*/
  2174.   b->next = NULL;
  2176. #endif 
  2178.   if (b->indices)
  2179.     BoxFree(b->indices); /* janet 2/8/95: added  */
  2180.   if (b->base)
  2181.     BoxFree(b->base);
  2183.   /*   Free(b->str); */
  2185.   Free(b);
  2186. }
  2190. #define IDX_IFIXEDFONT         10
  2192. void ParseMath(Frame *frame, int *up, int *down)
  2193. {
  2194.     int endtag;
  2195.     Box *box;
  2197.     box = ParseExpr(NORMAL, TAG_MATH, EMPH_NORMAL, &endtag); /* purify: box and it's children has allocated memory */
  2199.     /* howcome 16/3/95: added test for box existance, but why doesn't <MATH></MATH> render properly? */
  2201.     if (box) { 
  2202. RenderMath(frame, box, Here, 0);
  2203. *up = box->above;
  2204. *down = box->below;
  2205. Here += box->w;
  2206.     }
  2208.     BoxFree(box);  /* janet: something is not being freed here, what? (64 bytes)*/
  2209. }