examples/includes/ASCIIMathPHP-2.0/ASCIIMathPHP-2.0.class.php

   1 <?php
   2
   3 /****
   4  * ASCIIMathPHP and associated classes:
   5  * -- XMLNode
   6  * -- MathMLNode extends XMLNode
   7  *
   8  * These classes are a PHP port of ASCIIMath
   9  * Version 1.3 Feb 19 2004, (c) Peter Jipsen http://www.chapman.edu/~jipsen
  10  *
  11  * ASCIIMathPHP Version 1.11, 26 April 2006, (c) Kee-Lin Steven Chan (kc56@cornell.edu)
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or (at
  16  * your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * General Public License (at http://www.gnu.org/copyleft/gpl.html)
  22  * for more details.
  23  *
  24  * ChangeLog
  25  *
  26  * Ver 2.0
  27  * -- PHP5 only version of ASCIIMathPHP
  28  *
  29  * Ver 1.12.1
  30  * -- Included the missing setCurrExpr() method
  31  *
  32  * Ver 1.12
  33  * -- Added changes that David Lippman <DLippman@pierce.ctc.edu> made to bring ASCIIMathPHP up to
  34  * ASCIIMath 1.4.7 functionality.
  35  * -- Added parseIntExpr, for intermediate expression parsing rule, allowing x^2/x^3 to render as (x^2)/(x^3)
  36  * -- Added quotes as another way of designating text; "hello" is equivalent to text(hello)
  37  * -- Added FUNC designator to allow sin, cos, etc to act as functions, so sin(x)/x renders as {sin(x)}/x
  38  *
  39  * Ver 1.11
  40  * -- Fixed bug that stopped script execution for incomplete expressions
  41  * -- Changed the algorithm for parsing expressions so that it matches the longest string possible (greedy)
  42  *
  43  * Ver 1.10
  44  * -- Added definition support
  45  * -- Added stackrel support
  46  * -- Added a bunch of different symbols etc. >>, << and definitions like dx, dy, dz etc.
  47  *
  48  * Ver 1.02
  49  * -- Fixed bug with mbox and text
  50  * -- Fixed spacing bug with mbox and text
  51  *
  52  * Ver 1.01
  53  * -- Fixed Bug that did not parse symbols greater than a single character
  54  * correctly when appearing at end of expression.
  55  *
  56  ***/
  57
  58 class XMLNode
  59 {
  60     // Private variables
  61     var $_id;
  62     var $_name;
  63     var $_content;
  64     var $_mt_elem_flg;
  65     var $_attr_arr;
  66     var $_child_arr;
  67     var $_nmspc;
  68     var $_nmspc_alias;
  69     var $_parent_id;
  70     var $_parent_node;
  71
  72     function XMLNode($id = NULL)
  73     {
  74         $this->_id = isset($id) ? $id : md5(uniqid(rand(),1));
  75         $this->_name = '';
  76         $this->_content = '';
  77         $this->_mt_elem_flg = FALSE;
  78         $this->_attr_arr = array();
  79         $this->_child_arr = array();
  80         $this->_nmspc = '';
  81         $this->_nmspc_alias = '';
  82         $this->_parent_id = FALSE;
  83         $this->_parent_node = NULL;
  84     }
  85
  86     function addChild(&$node)
  87     {
  88         $this->_child_arr[$node->getId()] = $node;
  89         $node->setParentId($this->_id);
  90         $node->setParentNode($this);
  91     }
  92
  93     function addChildArr(&$node_arr)
  94     {
  95         $key_arr = array_keys($node_arr);
  96         $num_key = count($key_arr);
  97
  98         for ($i = 0; $i < $num_key; $i++) {
  99             $node = $node_arr[$key_arr[$i]];
 100             $this->addChild($node);
 101         }
 102     }
 103
 104     function insertChildBefore($idx,&$node)
 105     {
 106         $key_arr = array_keys($this->_child_arr);
 107         $num_key = count($key_arr);
 108         $tmp_arr = arry();
 109
 110         for ($i = 0;$i < $num_key;$i++) {
 111             if ($i == $idx) {
 112                 $tmp_arr[$node->getId()] = $node;
 113             }
 114             $tmp_arr[$key_arr[$i]] = $this->_child_arr[$key_arr[$i]];
 115         }
 116         $this->_child_arr = $tmp_arr;
 117     }
 118
 119     function insertChildAfter($idx,&$node)
 120     {
 121         $key_arr = array_keys($this->_child_arr);
 122         $num_key = count($key_arr);
 123         $tmp_arr = arry();
 124
 125         for ($i = 0;$i < $num_key;$i++) {
 126             $tmp_arr[$key_arr[$i]] = $this->_child_arr[$key_arr[$i]];
 127             if ($i == $idx) {
 128                 $tmp_arr[$node->getId()] = $node;
 129             }
 130         }
 131         $this->_child_arr = $tmp_arr;
 132     }
 133
 134     function setId($id)
 135     {
 136         $this->_id = $id;
 137     }
 138
 139     function setName($name)
 140     {
 141         $this->_name = $name;
 142     }
 143
 144     function setNamepace($nmspc)
 145     {
 146         $this->_nmspc = $nmspc;
 147     }
 148
 149     function setNamespaceAlias($nmspc_alias)
 150     {
 151         $this->_nmspc_alias = $nmspc_alias;
 152     }
 153
 154     function setContent($content)
 155     {
 156         $this->_content = $content;
 157     }
 158
 159     function setEmptyElem($mt_elem_flg)
 160     {
 161         $this->_mt_elem_flg = $mt_elem_flg;
 162     }
 163
 164     function setAttr($attr_nm,$attr_val)
 165     {
 166         $this->_attr_arr[$attr_nm] = $attr_val;
 167     }
 168
 169     function setAttrArr($attr_arr)
 170     {
 171         $this->_attr_arr = $attr_arr;
 172     }
 173
 174     function setParentId($id)
 175     {
 176         $this->_parent_id = $id;
 177     }
 178
 179     function setParentNode(&$node)
 180     {
 181         $this->_parent_node = $node;
 182     }
 183
 184     function getId()
 185     {
 186         return($this->_id);
 187     }
 188
 189     function getName()
 190     {
 191         return($this->_name);
 192     }
 193
 194     function getNamespace()
 195     {
 196         return($this->_nmspc);
 197     }
 198
 199     function getNamespaceAlias()
 200     {
 201         return($this->_nmspc_alias);
 202     }
 203
 204     function getContent()
 205     {
 206         return($this->_content);
 207     }
 208
 209     function getAttr($attr_nm)
 210     {
 211         if (isset($this->_attr_arr[$attr_nm])) {
 212             return($this->_attr_arr[$attr_nm]);
 213         } else {
 214             return(NULL);
 215         }
 216     }
 217
 218     function getAttrArr()
 219     {
 220         return($this->_attr_arr);
 221     }
 222
 223     function getParentId()
 224     {
 225         return($this->parent_id);
 226     }
 227
 228     function getParentNode()
 229     {
 230         return($this->_parent_node);
 231     }
 232
 233     function getChild($id)
 234     {
 235         if (isset($this->_child_arr[$id])) {
 236             return($this->_child_arr[$id]);
 237         } else {
 238             return(FALSE);
 239         }
 240     }
 241
 242     function getFirstChild()
 243     {
 244         $id_arr = array_keys($this->_child_arr);
 245         $num_child = count($id_arr);
 246
 247         if ($num_child > 0) {
 248             return($this->_child_arr[$id_arr[0]]);
 249         } else {
 250             return(FALSE);
 251         }
 252     }
 253
 254     function getLastChild()
 255     {
 256         $id_arr = array_keys($this->_child_arr);
 257         $num_child = count($id_arr);
 258
 259         if ($num_child > 0) {
 260             return($this->_child_arr[$id_arr[$num_child - 1]]);
 261         } else {
 262             return(FALSE);
 263         }
 264     }
 265
 266     function getChildByIdx($idx)
 267     {
 268         $id_arr = array_keys($this->_child_arr);
 269
 270         if (isset($this->_child_arr[$id_arr[$idx]])) {
 271             return($this->_child_arr[$id_arr[$idx]]);
 272         } else {
 273             return(FALSE);
 274         }
 275     }
 276
 277     function getNumChild()
 278     {
 279         return(count($this->_child_arr));
 280     }
 281
 282     function removeChild($id)
 283     {
 284         unset($this->_child_arr[$id]);
 285     }
 286
 287     function removeChildByIdx($idx)
 288     {
 289         $key_arr = array_keys($this->_child_arr);
 290         unset($this->_child_arr[$key_arr[$idx]]);
 291     }
 292
 293     function removeFirstChild()
 294     {
 295         $key_arr = array_keys($this->_child_arr);
 296         unset($this->_child_arr[$key_arr[0]]);
 297     }
 298
 299     function removeLastChild()
 300     {
 301         $key_arr = array_keys($this->_child_arr);
 302         unset($this->_child_arr[$key_arr[count($key_arr)-1]]);
 303     }
 304
 305     function dumpXML($indent_str = "\t")
 306     {
 307         $attr_txt = $this->_dumpAttr();
 308         $name = $this->_dumpName();
 309         $xmlns = $this->_dumpXmlns();
 310         $lvl = $this->_getCurrentLevel();
 311         $indent = str_pad('',$lvl,$indent_str);
 312
 313         if ($this->_mt_elem_flg) {
 314             $tag = "$indent<$name$xmlns$attr_txt />";
 315             return($tag);
 316         } else {
 317             $key_arr = array_keys($this->_child_arr);
 318             $num_child = count($key_arr);
 319
 320             $tag = "$indent<$name$xmlns$attr_txt>$this->_content";
 321
 322             for ($i = 0;$i < $num_child;$i++) {
 323                 $node = $this->_child_arr[$key_arr[$i]];
 324
 325                 $child_txt = $node->dumpXML($indent_str);
 326                 $tag .= "\n$child_txt";
 327             }
 328
 329             $tag .= ($num_child > 0 ? "\n$indent</$name>" : "</$name>");
 330             return($tag);
 331         }
 332     }
 333
 334     function _dumpAttr()
 335     {
 336         $id_arr = array_keys($this->_attr_arr);
 337         $id_arr_cnt = count($id_arr);
 338         $attr_txt = '';
 339
 340         for($i = 0;$i < $id_arr_cnt;$i++) {
 341             $key = $id_arr[$i];
 342             $attr_txt .= " $key=\"{$this->_attr_arr[$key]}\"";
 343         }
 344
 345         return($attr_txt);
 346     }
 347
 348     function _dumpName()
 349     {
 350         $alias = $this->getNamespaceAlias();
 351         if ($alias == '') {
 352             return($this->getName());
 353         } else {
 354             return("$alias:" . $this->getName());
 355         }
 356     }
 357
 358     function _dumpXmlns()
 359     {
 360         $nmspc = $this->getNamespace();
 361         $alias = $this->getNamespaceAlias();
 362
 363         if ($nmspc != '') {
 364             if ($alias == '') {
 365                 return(" xmlns=\"" . $nmspc . "\"");
 366             } else {
 367                 return(" xmlns:$alias=\"" . $nmspc . "\"");
 368             }
 369         } else {
 370             return('');
 371         }
 372     }
 373
 374     function _getCurrentLevel()
 375     {
 376         if ($this->_parent_id === FALSE) {
 377             return(0);
 378         } else {
 379             $node = $this->getParentNode();
 380             $lvl = $node->_getCurrentLevel();
 381             $lvl++;
 382             return($lvl);
 383         }
 384     }
 385 }
 386
 387 class MathMLNode extends XMLNode
 388 {
 389     function MathMLNode($id = NULL)
 390     {
 391         parent::XMLNode($id);
 392     }
 393
 394     function removeBrackets()
 395     {
 396         if ($this->_name == 'mrow') {
 397             if ($c_node_0 = $this->getFirstChild()) {
 398                 $c_node_0->isLeftBracket() ? $this->removeFirstChild() : 0;
 399             }
 400
 401             if ($c_node_0 = $this->getLastChild()) {
 402                 $c_node_0->isRightBracket() ? $this->removeLastChild() : 0;
 403             }
 404         }
 405     }
 406
 407     function isLeftBracket()
 408     {
 409         switch ($this->_content) {
 410             case '{':
 411             case '[':
 412             case '(':
 413                 return(TRUE);
 414                 break;
 415         }
 416         return(FALSE);
 417     }
 418
 419     function isRightBracket()
 420     {
 421         switch ($this->_content) {
 422             case '}':
 423             case ']':
 424             case ')':
 425                 return(TRUE);
 426                 break;
 427         }
 428         return(FALSE);
 429     }
 430 }
 431
 432 class ASCIIMathPHP
 433 {
 434     var $_expr;
 435     var $_curr_expr;
 436     var $_prev_expr;
 437     var $_symbol_arr;
 438     var $_node_arr;
 439     var $_node_cntr;
 440
 441     function ASCIIMathPHP($symbol_arr,$expr = NULL)
 442     {
 443         $this->_symbol_arr = $symbol_arr;
 444         if (isset($expr)) {
 445             $this->setExpr($expr);
 446         }
 447     }
 448
 449     /**
 450      * Returns an empty node (containing a non-breaking space) 26-Apr-2006
 451      *
 452      * Used when an expression is incomplete
 453      *
 454      * @return object
 455      *
 456      * @access private
 457      */
 458     function emptyNode()
 459     {
 460         $tmp_node = $this->createNode();
 461         $tmp_node->setName('mn');
 462         $tmp_node->setContent('&#' . hexdec('200B') . ';');
 463         return $tmp_node;
 464     }
 465
 466     function pushExpr($prefix) // 2005-06-11 wes
 467     {
 468         $this->_curr_expr = $prefix . $this->_curr_expr;
 469     }
 470
 471     function setExpr($expr)
 472     {
 473         $this->_expr = $expr;
 474         $this->_curr_expr = $expr;
 475         $this->_prev_expr = $expr;
 476
 477         $this->_node_arr = array();
 478         $this->_node_cntr = 0;
 479     }
 480
 481     function genMathML($attr_arr = NULL)
 482     {
 483         // <math> node
 484         $node_0 = $this->createNode();
 485         $node_0->setName('math');
 486         $node_0->setNamepace('http://www.w3.org/1998/Math/MathML');
 487
 488         // <mstyle> node
 489         if (isset($attr_arr)) {
 490             $node_1 = $this->createNode();
 491             $node_1->setName('mstyle');
 492             $node_1->setAttrArr($attr_arr);
 493
 494             $node_arr = $this->parseExpr();
 495
 496             $node_1->addChildArr($node_arr);
 497             $node_0->addChild($node_1);
 498         } else {
 499             $node_arr = $this->parseExpr();
 500             $node_0->addChildArr($node_arr);
 501         }
 502
 503         return TRUE;
 504     }
 505
 506     /*
 507     function  mergeNodeArr(&$node_arr_0,&$node_arr_1)
 508     {
 509         $key_arr_0 = array_keys($node_arr_0);
 510         $key_arr_1 = array_keys($node_arr_1);
 511
 512         $num_key_0 = count($key_arr_0);
 513         $num_key_1 = count($key_arr_1);
 514
 515         $merge_arr = array();
 516
 517         for ($i = 0;$i < $num_key_0;$i++) {
 518             $merge_arr[$key_arr_0[$i]] = $node_arr_0[$key_arr_0[$i]];
 519         }
 520
 521         for ($j = 0;$j < $num_key_1;$i++) {
 522             $merge_arr[$key_arr_1[$i]] = $node_arr_1[$key_arr_1[$i]];
 523         }
 524
 525         return($merge_arr);
 526     }
 527     */
 528
 529     //Broken out of parseExpr Sept 7, 2006 David Lippman for
 530     //ASCIIMathML 1.4.7 compatibility
 531     function  parseIntExpr()
 532     {
 533         $sym_0 = $this->getSymbol();
 534         $node_0 = $this->parseSmplExpr();
 535         $sym = $this->getSymbol();
 536
 537         if (isset($sym['infix']) && $sym['input'] != '/') {
 538             $this->chopExpr($sym['symlen']);
 539             $node_1 = $this->parseSmplExpr();
 540
 541             if ($node_1 === FALSE) { //show box in place of missing argument
 542                 $node_1 = $this->emptyNode();//??
 543             } else {
 544                 $node_1->removeBrackets();
 545             }
 546
 547             // If 'sub' -- subscript
 548             if ($sym['input'] == '_') {
 549
 550                 $sym_1 = $this->getSymbol();
 551
 552                 // If 'sup' -- superscript
 553                 if ($sym_1['input'] == '^') {
 554                     $this->chopExpr($sym_1['symlen']);
 555                     $node_2 = $this->parseSmplExpr();
 556                     $node_2->removeBrackets();
 557
 558                     $node_3 = $this->createNode();
 559                     $node_3->setName(isset($sym_0['underover']) ? 'munderover' : 'msubsup');
 560                     $node_3->addChild($node_0);
 561                     $node_3->addChild($node_1);
 562                     $node_3->addChild($node_2);
 563
 564                     $node_4 = $this->createNode();
 565                     $node_4->setName('mrow');
 566                     $node_4->addChild($node_3);
 567
 568                     return $node_4;
 569                 } else {
 570                     $node_2 = $this->createNode();
 571                     $node_2->setName(isset($sym_0['underover']) ? 'munder' : 'msub');
 572                     $node_2->addChild($node_0);
 573                     $node_2->addChild($node_1);
 574
 575                     return $node_2;
 576                 }
 577             } else {
 578                 $node_2 = $this->createNode();
 579                 $node_2->setName($sym['tag']);
 580                 $node_2->addChild($node_0);
 581                 $node_2->addChild($node_1);
 582
 583                 return($node_2);
 584             }
 585         } elseif ($node_0 !== FALSE) {
 586             return($node_0);
 587         } else {
 588             return $this->emptyNode();
 589         }
 590
 591     }
 592
 593     function  parseExpr()
 594     {
 595         // Child/Fragment array
 596         $node_arr = array();
 597
 598         // Deal whole expressions like 'ax + by + c = 0' etc.
 599         do {
 600             $sym_0 = $this->getSymbol();
 601             $node_0 = $this->parseIntExpr();
 602             $sym = $this->getSymbol();
 603             // var_dump($sym);
 604
 605             if (isset($sym['infix']) && $sym['input'] == '/') {
 606                 $this->chopExpr($sym['symlen']);
 607                 $node_1 = $this->parseIntExpr();
 608
 609                 if ($node_1 === FALSE) { //should show box in place of missing argument
 610                     $node_1 = $this->emptyNode();
 611                     continue;
 612                 }
 613
 614                 $node_1->removeBrackets();
 615
 616                 // If 'div' -- divide
 617                 $node_0->removeBrackets();
 618                 $node_2 = $this->createNode();
 619                 $node_2->setName($sym['tag']);
 620                 $node_2->addChild($node_0);
 621                 $node_2->addChild($node_1);
 622                 $node_arr[$node_2->getId()] = $node_2;
 623
 624             } elseif ($node_0 !== FALSE) {
 625                 $node_arr[$node_0->getId()] = $node_0;
 626             }
 627         } while (!isset($sym['right_bracket']) && $sym !== FALSE && $sym['output'] != '');
 628
 629         //var_dump($sym);
 630         // Possibly to deal with matrices
 631         if (isset($sym['right_bracket'])) {
 632             $node_cnt = count($node_arr);
 633             $key_node_arr = array_keys($node_arr);
 634
 635             if ($node_cnt > 1) {
 636                 $node_5 = $node_arr[$key_node_arr[$node_cnt-1]];
 637                 $node_6 = $node_arr[$key_node_arr[$node_cnt-2]];
 638             } else {
 639                 $node_5 = FALSE;
 640                 $node_6 = FALSE;
 641             }
 642
 643             // Dealing with matrices
 644             if ($node_5 !== FALSE && $node_6 !== FALSE &&
 645                 $node_cnt > 1 &&
 646                 $node_5->getName() == 'mrow' &&
 647                 $node_6->getName() == 'mo' &&
 648                 $node_6->getContent() == ',') {
 649
 650                 // Checking if Node 5 has a LastChild
 651                 if ($node_7 = $node_5->getLastChild()) {
 652                     $node_7_cntnt = $node_7->getContent();
 653                 } else {
 654                     $node_7_cntnt = FALSE;
 655                 }
 656
 657                 // If there is a right bracket
 658                 if ($node_7 !== FALSE && ($node_7_cntnt == ']' || $node_7_cntnt == ')')) {
 659
 660                     // Checking if Node 5 has a firstChild
 661                     if ($node_8 = $node_5->getFirstChild()) {
 662                         $node_8_cntnt = $node_8->getContent();
 663                     } else {
 664                         $node_8_cntnt = FALSE;
 665                     }
 666
 667                     // If there is a matching left bracket
 668                     if ($node_8 !== FALSE &&
 669                         (($node_8_cntnt == '(' && $node_7_cntnt == ')' && $sym['output'] != '}') ||
 670                         ($node_8_cntnt == '[' && $node_7_cntnt == ']'))) {
 671
 672                         $is_mtrx_flg = TRUE;
 673                         $comma_pos_arr = array();
 674
 675                         $i = 0;
 676
 677                         while ($i < $node_cnt && $is_mtrx_flg) {
 678                             $tmp_node = $node_arr[$key_node_arr[$i]];
 679
 680                             if($tmp_node_first = $tmp_node->getFirstChild()) {
 681                                 $tnfc = $tmp_node_first->getContent();
 682                             } else {
 683                                 $tnfc = FALSE;
 684                             }
 685
 686                             if($tmp_node_last = $tmp_node->getLastChild()) {
 687                                 $tnlc = $tmp_node_last->getContent();
 688                             } else {
 689                                 $tnlc = FALSE;
 690                             }
 691
 692                             if (isset($key_node_arr[$i+1])) {
 693                                 $next_tmp_node = $node_arr[$key_node_arr[$i+1]];
 694                                 $ntnn = $next_tmp_node->getName();
 695                                 $ntnc = $next_tmp_node->getContent();
 696                             } else {
 697                                 $ntnn = FALSE;
 698                                 $ntnc = FALSE;
 699                             }
 700
 701                             // Checking each node in node array for matrix criteria
 702                             if ($is_mtrx_flg) {
 703                                 $is_mtrx_flg = $tmp_node->getName() == 'mrow' &&
 704                                     ($i == $node_cnt-1 || $ntnn == 'mo' && $ntnc == ',') &&
 705                                     $tnfc == $node_8_cntnt && $tnlc == $node_7_cntnt;
 706                             }
 707
 708                             if ($is_mtrx_flg) {
 709                                 for ($j = 0;$j < $tmp_node->getNumChild();$j++) {
 710                                     $tmp_c_node = $tmp_node->getChildByIdx($j);
 711
 712                                     if ($tmp_c_node->getContent() == ',') {
 713                                         $comma_pos_arr[$i][] = $j;
 714                                     }
 715                                 }
 716                             }
 717
 718                             if ($is_mtrx_flg && $i > 1) {
 719
 720                                 $cnt_cpan = isset($comma_pos_arr[$i]) ? count($comma_pos_arr[$i]) : NULL;
 721                                 $cnt_cpap = isset($comma_pos_arr[$i-2]) ? count($comma_pos_arr[$i-2]) : NULL;
 722                                 $is_mtrx_flg = $cnt_cpan == $cnt_cpap;
 723                             }
 724
 725                             $i += 2;
 726                         }
 727
 728                         // If the node passes the matrix tests
 729                         if ($is_mtrx_flg) {
 730                             $tab_node_arr = array();
 731
 732                             for ($i = 0;$i < $node_cnt;$i += 2) {
 733                                 $tmp_key_node_arr = array_keys($node_arr);
 734                                 if (!($tmp_node = $node_arr[$tmp_key_node_arr[0]])) {
 735                                     break;
 736                                 }
 737                                 $num_child = $tmp_node->getNumChild();
 738                                 $k = 0;
 739
 740                                 $tmp_node->removeFirstChild();
 741
 742                                 $row_node_arr = array();
 743                                 $row_frag_node_arr = array();
 744
 745                                 for ($j = 1;$j < ($num_child-1);$j++) {
 746                                     if (isset($comma_pos_arr[$i][$k]) &&
 747                                         $j == $comma_pos_arr[$i][$k]) {
 748
 749                                         $tmp_node->removeFirstChild();
 750
 751                                         $tmp_c_node = $this->createNode();
 752                                         $tmp_c_node->setName('mtd');
 753                                         $tmp_c_node->addChildArr($row_frag_node_arr);
 754                                         $row_frag_node_arr = array();
 755
 756                                         $row_node_arr[$tmp_c_node->getId()] = $tmp_c_node;
 757
 758                                         $k++;
 759                                     } else {
 760
 761                                         if ($tmp_c_node = $tmp_node->getFirstChild()) {
 762                                             $row_frag_node_arr[$tmp_c_node->getId()] = $tmp_c_node;
 763                                             $tmp_node->removeFirstChild();
 764                                         }
 765                                     }
 766                                 }
 767
 768                                 $tmp_c_node = $this->createNode();
 769                                 $tmp_c_node->setName('mtd');
 770                                 $tmp_c_node->addChildArr($row_frag_node_arr);
 771
 772                                 $row_node_arr[$tmp_c_node->getId()] = $tmp_c_node;
 773
 774                                 if (count($node_arr) > 2) {
 775                                     $tmp_key_node_arr = array_keys($node_arr);
 776                                     unset($node_arr[$tmp_key_node_arr[0]]);
 777                                     unset($node_arr[$tmp_key_node_arr[1]]);
 778                                 }
 779
 780                                 $tmp_c_node = $this->createNode();
 781                                 $tmp_c_node->setName('mtr');
 782                                 $tmp_c_node->addChildArr($row_node_arr);
 783
 784                                 $tab_node_arr[$tmp_c_node->getId()] = $tmp_c_node;
 785                             }
 786
 787                             $tmp_c_node = $this->createNode();
 788                             $tmp_c_node->setName('mtable');
 789                             $tmp_c_node->addChildArr($tab_node_arr);
 790
 791                             if (isset($sym['invisible'])) {
 792                                 $tmp_c_node->setAttr('columnalign','left');
 793                             }
 794
 795                             $key_node_arr = array_keys($node_arr);
 796                             $tmp_c_node->setId($key_node_arr[0]);
 797
 798                             $node_arr[$tmp_c_node->getId()] = $tmp_c_node;
 799                         }
 800                     }
 801                 }
 802             }
 803
 804             $this->chopExpr($sym['symlen']);
 805             if (!isset($sym['invisible'])) {
 806                 $node_7 = $this->createNode();
 807                 $node_7->setName('mo');
 808                 $node_7->setContent($sym['output']);
 809                 $node_arr[$node_7->getId()] = $node_7;
 810             }
 811         }
 812
 813         return($node_arr);
 814     }
 815
 816     function  parseSmplExpr()
 817     {
 818         $sym = $this->getSymbol();
 819
 820         if (!$sym || isset($sym['right_bracket'])) //return FALSE;
 821             return $this->emptyNode();
 822
 823         $this->chopExpr($sym['symlen']);
 824
 825         // 2005-06-11 wes: add definition type support
 826         if(isset($sym['definition'])) {
 827             $this->pushExpr($sym['output']);
 828             $sym = $this->getSymbol();
 829             $this->chopExpr($sym['symlen']);
 830         }
 831
 832         if (isset($sym['left_bracket'])) {
 833             $node_arr = $this->parseExpr();
 834
 835             if (isset($sym['invisible'])) {
 836                 $node_0 = $this->createNode();
 837                 $node_0->setName('mrow');
 838                 $node_0->addChildArr($node_arr);
 839
 840                 return($node_0);
 841             } else {
 842                 $node_0 = $this->createNode();
 843                 $node_0->setName('mo');
 844                 $node_0->setContent($sym['output']);
 845
 846                 $node_1 = $this->createNode();
 847                 $node_1->setName('mrow');
 848                 $node_1->addChild($node_0);
 849                 $node_1->addChildArr($node_arr);
 850
 851                 return($node_1);
 852             }
 853         } elseif (isset($sym['unary'])) {
 854
 855             if ($sym['input'] == 'sqrt') {
 856                 $node_0 = $this->parseSmplExpr();
 857                 $node_0->removeBrackets();
 858
 859                 $node_1 = $this->createNode();
 860                 $node_1->setName($sym['tag']);
 861                 $node_1->addChild($node_0);
 862
 863                 return($node_1);
 864             } elseif (isset($sym['func'])) { //added 2006-9-7 David Lippman
 865                 $expr = ltrim($this->getCurrExpr());
 866                 $st = $expr{0};
 867                 $node_0 = $this->parseSmplExpr();
 868                 //$node_0->removeBrackets();
 869                 if ($st=='^' || $st == '_' || $st=='/' || $st=='|' || $st==',') {
 870                     $node_1 = $this->createNode();
 871                     $node_1->setName($sym['tag']);
 872                     $node_1->setContent($sym['output']);
 873                     $this->setCurrExpr($expr);
 874                     return($node_1);
 875                 } else {
 876                     $node_1 = $this->createNode();
 877                     $node_1->setName('mrow');
 878                     $node_2 = $this->createNode();
 879                     $node_2->setName($sym['tag']);
 880                     $node_2->setContent($sym['output']);
 881                     $node_1->addChild($node_2);
 882                     $node_1->addChild($node_0);
 883                     return($node_1);
 884                 }
 885             } elseif ($sym['input'] == 'text' || $sym['input'] == 'mbox' || $sym['input'] == '"') {
 886                 $expr = ltrim($this->getCurrExpr());
 887                 if ($sym['input']=='"') {
 888                     $end_brckt = '"';
 889                     $txt = substr($expr,0,strpos($expr,$end_brckt));
 890                 } else {
 891                     switch($expr{0}) {
 892                         case '(':
 893                             $end_brckt = ')';
 894                             break;
 895                         case '[':
 896                             $end_brckt = ']';
 897                             break;
 898                         case '{':
 899                             $end_brckt = '}';
 900                             break;
 901                         default:
 902                             $end_brckt = chr(11); // A character that will never be matched.
 903                             break;
 904                     }
 905                     $txt = substr($expr,1,strpos($expr,$end_brckt)-1);
 906                 }
 907
 908                 //$txt = substr($expr,1,strpos($expr,$end_brckt)-1);
 909                 $len = strlen($txt);
 910
 911                 $node_0 = $this->createNode();
 912                 $node_0->setName('mrow');
 913
 914                 if ($len > 0) {
 915                     if ($txt{0} == " ") {
 916                         $node_1 = $this->createNode();
 917                         $node_1->setName('mspace');
 918                         $node_1->setAttr('width','1ex');
 919
 920                         $node_0->addChild($node_1);
 921                     }
 922
 923                     $node_3 = $this->createNode();
 924                     $node_3->setName($sym['tag']);
 925                     $node_3->setContent(trim($txt));
 926
 927                     $node_0->addChild($node_3);
 928
 929                     if ($len > 1 && $txt{$len-1} == " ") {
 930                         $node_2 = $this->createNode();
 931                         $node_2->setName('mspace');
 932                         $node_2->setAttr('width','1ex');
 933
 934                         $node_0->addChild($node_2);
 935                     }
 936
 937                     $this->chopExpr($len+2);
 938                 }
 939                 return($node_0);
 940
 941             } elseif (isset($sym['acc'])) {
 942                 $node_0 = $this->parseSmplExpr();
 943                 $node_0->removeBrackets();
 944
 945                 $node_1 = $this->createNode();
 946                 $node_1->setName($sym['tag']);
 947                 $node_1->addChild($node_0);
 948
 949                 $node_2 = $this->createNode();
 950                 $node_2->setName('mo');
 951                 $node_2->setContent($sym['output']);
 952
 953                 $node_1->addChild($node_2);
 954                 return($node_1);
 955             } else {
 956                 // Font change commands -- to complete
 957             }
 958         } elseif (isset($sym['binary'])) {
 959             $node_arr = array();
 960
 961             $node_0 = $this->parseSmplExpr();
 962             $node_0->removeBrackets();
 963
 964             $node_1 = $this->parseSmplExpr();
 965             $node_1->removeBrackets();
 966
 967             /* 2005-06-05 wes: added stackrel */
 968             if ($sym['input'] == 'root' || $sym['input'] == 'stackrel') {
 969                 $node_arr[$node_1->getId()] = $node_1;
 970                 $node_arr[$node_0->getId()] = $node_0;
 971             } elseif ($sym['input'] == 'frac') {
 972                 $node_arr[$node_0->getId()] = $node_0;
 973                 $node_arr[$node_1->getId()] = $node_1;
 974             }
 975
 976             $node_2 = $this->createNode();
 977             $node_2->setName($sym['tag']);
 978             $node_2->addChildArr($node_arr);
 979
 980             return($node_2);
 981         } elseif (isset($sym['infix'])) {
 982             $node_0 = $this->createNode();
 983             $node_0->setName('mo');
 984             $node_0->setContent($sym['output']);
 985
 986             return($node_0);
 987         } elseif (isset($sym['space'])) {
 988             $node_0 = $this->createNode();
 989             $node_0->setName('mrow');
 990
 991             $node_1 = $this->createNode();
 992             $node_1->setName('mspace');
 993             $node_1->setAttr('width',$sym['space']);
 994
 995             $node_2 = $this->createNode();
 996             $node_2->setName($sym['tag']);
 997             $node_2->setContent($sym['output']);
 998
 999             $node_3 = $this->createNode();
1000             $node_3->setName('mspace');
1001             $node_3->setAttr('width',$sym['space']);
1002
1003             $node_0->addChild($node_1);
1004             $node_0->addChild($node_2);
1005             $node_0->addChild($node_3);
1006
1007             return($node_0);
1008         } else {
1009
1010             // A constant
1011             $node_0 = $this->createNode();
1012             $node_0->setName($sym['tag']);
1013             $node_0->setContent($sym['output']);
1014             return($node_0);
1015         }
1016
1017         // Return an empty node
1018         return $this->emptyNode();
1019     }
1020
1021     function getMathML()
1022     {
1023         $root = $this->_node_arr[0];
1024         return($root->dumpXML());
1025     }
1026
1027     function getCurrExpr()
1028     {
1029         return($this->_curr_expr);
1030     }
1031
1032     function setCurrExpr($str)
1033     {
1034         $this->_curr_expr = $str;
1035     }
1036
1037     function getExpr()
1038     {
1039         return($this->_expr);
1040     }
1041
1042     function getPrevExpr()
1043     {
1044         return($this->_prev_expr);
1045     }
1046
1047     function  createNode()
1048     {
1049         $node = new MathMLNode($this->_node_cntr);
1050         // $node->setNamespaceAlias('m');
1051         $this->_node_arr[$this->_node_cntr] = $node;
1052         $this->_node_cntr++;
1053         return($node);
1054     }
1055
1056     /**
1057      * Gets the largest symbol in the expression (greedy). Changed from non-greedy 26-Apr-2006
1058      *
1059      * @parameter boolean[optional] Chop original string?
1060      *
1061      * @return mixed
1062      *
1063      * @access private
1064      */
1065     function getSymbol($chop_flg = FALSE)
1066     {
1067         // Implemented a reverse symbol matcher.
1068         // Instead of going front to back, it goes back to front. Steven 26-Apr-2006
1069         $chr_cnt = strlen($this->_curr_expr);
1070
1071         if ($chr_cnt == 0) return FALSE;
1072
1073         for ($i = $chr_cnt; $i > 0; $i--) {
1074             $sym_0 = substr($this->_curr_expr,0,$i);
1075
1076             // Reading string for numeric values
1077             if (is_numeric($sym_0)) {
1078
1079                 if ($chop_flg) $this->chopExpr($i);
1080                 return array('input'=>$sym_0, 'tag'=>'mn', 'output'=>$sym_0, 'symlen'=>$i);
1081
1082             } elseif (isset($this->_symbol_arr[$sym_0])) {
1083
1084                 if ($chop_flg) $this->chopExpr($i);
1085                 $sym_arr = $this->_symbol_arr[$sym_0];
1086                 $sym_arr['symlen'] = $i;
1087                 return $sym_arr;
1088             }
1089         }
1090
1091         // Reading string for alphabetic constants and the minus sign
1092         $char = $this->_curr_expr{0};
1093         $len_left = $chop_flg ? $this->chopExpr(1) : strlen($this->_curr_expr)-1;
1094
1095         // Deals with expressions of length 1
1096         if ($len_left == 0 && isset($this->_symbol_arr[$char])) {
1097             $sym_arr = $this->_symbol_arr[$char];
1098             $sym_arr['symlen'] = 1;
1099             return $sym_arr;
1100         } else {
1101             $tag = preg_match('/[a-z]/i',$char) ? 'mi' : 'mo';
1102             return array('input'=>$char, 'tag'=>$tag, 'output'=>$char, 'symlen'=>1);
1103         }
1104     }
1105
1106     function chopExpr($strlen)
1107     {
1108         $this->_prev_expr = $this->_curr_expr;
1109
1110         if ($strlen == strlen($this->_curr_expr)) {
1111             $this->_curr_expr = '';
1112             return(0);
1113         } else {
1114             $this->_curr_expr = ltrim(substr($this->_curr_expr,$strlen));
1115             return(strlen($this->_curr_expr));
1116         }
1117     }
1118 }
1119 ?>