| <?php | |
| /**** | |
| * ASCIIMathPHP and associated classes: | |
| * -- XMLNode | |
| * -- MathMLNode extends XMLNode | |
| * | |
| * These classes are a PHP port of ASCIIMath | |
| * Version 1.3 Feb 19 2004, (c) Peter Jipsen http://www.chapman.edu/~jipsen | |
| * | |
| * ASCIIMathPHP Version 1.11, 26 April 2006, (c) Kee-Lin Steven Chan (kc56@cornell.edu) | |
| * | |
| * This program is free software; you can redistribute it and/or modify | |
| * it under the terms of the GNU General Public License as published by | |
| * the Free Software Foundation; either version 2 of the License, or (at | |
| * your option) any later version. | |
| * | |
| * This program is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * General Public License (at http://www.gnu.org/copyleft/gpl.html) | |
| * for more details. | |
| * | |
| * ChangeLog | |
| * | |
| * Ver 2.0 | |
| * -- PHP5 only version of ASCIIMathPHP | |
| * | |
| * Ver 1.12.1 | |
| * -- Included the missing setCurrExpr() method | |
| * | |
| * Ver 1.12 | |
| * -- Added changes that David Lippman <DLippman@pierce.ctc.edu> made to bring ASCIIMathPHP up to | |
| * ASCIIMath 1.4.7 functionality. | |
| * -- Added parseIntExpr, for intermediate expression parsing rule, allowing x^2/x^3 to render as (x^2)/(x^3) | |
| * -- Added quotes as another way of designating text; "hello" is equivalent to text(hello) | |
| * -- Added FUNC designator to allow sin, cos, etc to act as functions, so sin(x)/x renders as {sin(x)}/x | |
| * | |
| * Ver 1.11 | |
| * -- Fixed bug that stopped script execution for incomplete expressions | |
| * -- Changed the algorithm for parsing expressions so that it matches the longest string possible (greedy) | |
| * | |
| * Ver 1.10 | |
| * -- Added definition support | |
| * -- Added stackrel support | |
| * -- Added a bunch of different symbols etc. >>, << and definitions like dx, dy, dz etc. | |
| * | |
| * Ver 1.02 | |
| * -- Fixed bug with mbox and text | |
| * -- Fixed spacing bug with mbox and text | |
| * | |
| * Ver 1.01 | |
| * -- Fixed Bug that did not parse symbols greater than a single character | |
| * correctly when appearing at end of expression. | |
| * | |
| ***/ | |
| class XMLNode | |
| { | |
| // Private variables | |
| var $_id; | |
| var $_name; | |
| var $_content; | |
| var $_mt_elem_flg; | |
| var $_attr_arr; | |
| var $_child_arr; | |
| var $_nmspc; | |
| var $_nmspc_alias; | |
| var $_parent_id; | |
| var $_parent_node; | |
| function XMLNode($id = NULL) | |
| { | |
| $this->_id = isset($id) ? $id : md5(uniqid(rand(),1)); | |
| $this->_name = ''; | |
| $this->_content = ''; | |
| $this->_mt_elem_flg = FALSE; | |
| $this->_attr_arr = array(); | |
| $this->_child_arr = array(); | |
| $this->_nmspc = ''; | |
| $this->_nmspc_alias = ''; | |
| $this->_parent_id = FALSE; | |
| $this->_parent_node = NULL; | |
| } | |
| function addChild(&$node) | |
| { | |
| $this->_child_arr[$node->getId()] = $node; | |
| $node->setParentId($this->_id); | |
| $node->setParentNode($this); | |
| } | |
| function addChildArr(&$node_arr) | |
| { | |
| $key_arr = array_keys($node_arr); | |
| $num_key = count($key_arr); | |
| for ($i = 0; $i < $num_key; $i++) { | |
| $node = $node_arr[$key_arr[$i]]; | |
| $this->addChild($node); | |
| } | |
| } | |
| function insertChildBefore($idx,&$node) | |
| { | |
| $key_arr = array_keys($this->_child_arr); | |
| $num_key = count($key_arr); | |
| $tmp_arr = arry(); | |
| for ($i = 0;$i < $num_key;$i++) { | |
| if ($i == $idx) { | |
| $tmp_arr[$node->getId()] = $node; | |
| } | |
| $tmp_arr[$key_arr[$i]] = $this->_child_arr[$key_arr[$i]]; | |
| } | |
| $this->_child_arr = $tmp_arr; | |
| } | |
| function insertChildAfter($idx,&$node) | |
| { | |
| $key_arr = array_keys($this->_child_arr); | |
| $num_key = count($key_arr); | |
| $tmp_arr = arry(); | |
| for ($i = 0;$i < $num_key;$i++) { | |
| $tmp_arr[$key_arr[$i]] = $this->_child_arr[$key_arr[$i]]; | |
| if ($i == $idx) { | |
| $tmp_arr[$node->getId()] = $node; | |
| } | |
| } | |
| $this->_child_arr = $tmp_arr; | |
| } | |
| function setId($id) | |
| { | |
| $this->_id = $id; | |
| } | |
| function setName($name) | |
| { | |
| $this->_name = $name; | |
| } | |
| function setNamepace($nmspc) | |
| { | |
| $this->_nmspc = $nmspc; | |
| } | |
| function setNamespaceAlias($nmspc_alias) | |
| { | |
| $this->_nmspc_alias = $nmspc_alias; | |
| } | |
| function setContent($content) | |
| { | |
| $this->_content = $content; | |
| } | |
| function setEmptyElem($mt_elem_flg) | |
| { | |
| $this->_mt_elem_flg = $mt_elem_flg; | |
| } | |
| function setAttr($attr_nm,$attr_val) | |
| { | |
| $this->_attr_arr[$attr_nm] = $attr_val; | |
| } | |
| function setAttrArr($attr_arr) | |
| { | |
| $this->_attr_arr = $attr_arr; | |
| } | |
| function setParentId($id) | |
| { | |
| $this->_parent_id = $id; | |
| } | |
| function setParentNode(&$node) | |
| { | |
| $this->_parent_node = $node; | |
| } | |
| function getId() | |
| { | |
| return($this->_id); | |
| } | |
| function getName() | |
| { | |
| return($this->_name); | |
| } | |
| function getNamespace() | |
| { | |
| return($this->_nmspc); | |
| } | |
| function getNamespaceAlias() | |
| { | |
| return($this->_nmspc_alias); | |
| } | |
| function getContent() | |
| { | |
| return($this->_content); | |
| } | |
| function getAttr($attr_nm) | |
| { | |
| if (isset($this->_attr_arr[$attr_nm])) { | |
| return($this->_attr_arr[$attr_nm]); | |
| } else { | |
| return(NULL); | |
| } | |
| } | |
| function getAttrArr() | |
| { | |
| return($this->_attr_arr); | |
| } | |
| function getParentId() | |
| { | |
| return($this->parent_id); | |
| } | |
| function getParentNode() | |
| { | |
| return($this->_parent_node); | |
| } | |
| function getChild($id) | |
| { | |
| if (isset($this->_child_arr[$id])) { | |
| return($this->_child_arr[$id]); | |
| } else { | |
| return(FALSE); | |
| } | |
| } | |
| function getFirstChild() | |
| { | |
| $id_arr = array_keys($this->_child_arr); | |
| $num_child = count($id_arr); | |
| if ($num_child > 0) { | |
| return($this->_child_arr[$id_arr[0]]); | |
| } else { | |
| return(FALSE); | |
| } | |
| } | |
| function getLastChild() | |
| { | |
| $id_arr = array_keys($this->_child_arr); | |
| $num_child = count($id_arr); | |
| if ($num_child > 0) { | |
| return($this->_child_arr[$id_arr[$num_child - 1]]); | |
| } else { | |
| return(FALSE); | |
| } | |
| } | |
| function getChildByIdx($idx) | |
| { | |
| $id_arr = array_keys($this->_child_arr); | |
| if (isset($this->_child_arr[$id_arr[$idx]])) { | |
| return($this->_child_arr[$id_arr[$idx]]); | |
| } else { | |
| return(FALSE); | |
| } | |
| } | |
| function getNumChild() | |
| { | |
| return(count($this->_child_arr)); | |
| } | |
| function removeChild($id) | |
| { | |
| unset($this->_child_arr[$id]); | |
| } | |
| function removeChildByIdx($idx) | |
| { | |
| $key_arr = array_keys($this->_child_arr); | |
| unset($this->_child_arr[$key_arr[$idx]]); | |
| } | |
| function removeFirstChild() | |
| { | |
| $key_arr = array_keys($this->_child_arr); | |
| unset($this->_child_arr[$key_arr[0]]); | |
| } | |
| function removeLastChild() | |
| { | |
| $key_arr = array_keys($this->_child_arr); | |
| unset($this->_child_arr[$key_arr[count($key_arr)-1]]); | |
| } | |
| function dumpXML($indent_str = "\t") | |
| { | |
| $attr_txt = $this->_dumpAttr(); | |
| $name = $this->_dumpName(); | |
| $xmlns = $this->_dumpXmlns(); | |
| $lvl = $this->_getCurrentLevel(); | |
| $indent = str_pad('',$lvl,$indent_str); | |
| if ($this->_mt_elem_flg) { | |
| $tag = "$indent<$name$xmlns$attr_txt />"; | |
| return($tag); | |
| } else { | |
| $key_arr = array_keys($this->_child_arr); | |
| $num_child = count($key_arr); | |
| $tag = "$indent<$name$xmlns$attr_txt>$this->_content"; | |
| for ($i = 0;$i < $num_child;$i++) { | |
| $node = $this->_child_arr[$key_arr[$i]]; | |
| $child_txt = $node->dumpXML($indent_str); | |
| $tag .= "\n$child_txt"; | |
| } | |
| $tag .= ($num_child > 0 ? "\n$indent</$name>" : "</$name>"); | |
| return($tag); | |
| } | |
| } | |
| function _dumpAttr() | |
| { | |
| $id_arr = array_keys($this->_attr_arr); | |
| $id_arr_cnt = count($id_arr); | |
| $attr_txt = ''; | |
| for($i = 0;$i < $id_arr_cnt;$i++) { | |
| $key = $id_arr[$i]; | |
| $attr_txt .= " $key=\"{$this->_attr_arr[$key]}\""; | |
| } | |
| return($attr_txt); | |
| } | |
| function _dumpName() | |
| { | |
| $alias = $this->getNamespaceAlias(); | |
| if ($alias == '') { | |
| return($this->getName()); | |
| } else { | |
| return("$alias:" . $this->getName()); | |
| } | |
| } | |
| function _dumpXmlns() | |
| { | |
| $nmspc = $this->getNamespace(); | |
| $alias = $this->getNamespaceAlias(); | |
| if ($nmspc != '') { | |
| if ($alias == '') { | |
| return(" xmlns=\"" . $nmspc . "\""); | |
| } else { | |
| return(" xmlns:$alias=\"" . $nmspc . "\""); | |
| } | |
| } else { | |
| return(''); | |
| } | |
| } | |
| function _getCurrentLevel() | |
| { | |
| if ($this->_parent_id === FALSE) { | |
| return(0); | |
| } else { | |
| $node = $this->getParentNode(); | |
| $lvl = $node->_getCurrentLevel(); | |
| $lvl++; | |
| return($lvl); | |
| } | |
| } | |
| } | |
| class MathMLNode extends XMLNode | |
| { | |
| function MathMLNode($id = NULL) | |
| { | |
| parent::XMLNode($id); | |
| } | |
| function removeBrackets() | |
| { | |
| if ($this->_name == 'mrow') { | |
| if ($c_node_0 = $this->getFirstChild()) { | |
| $c_node_0->isLeftBracket() ? $this->removeFirstChild() : 0; | |
| } | |
| if ($c_node_0 = $this->getLastChild()) { | |
| $c_node_0->isRightBracket() ? $this->removeLastChild() : 0; | |
| } | |
| } | |
| } | |
| function isLeftBracket() | |
| { | |
| switch ($this->_content) { | |
| case '{': | |
| case '[': | |
| case '(': | |
| return(TRUE); | |
| break; | |
| } | |
| return(FALSE); | |
| } | |
| function isRightBracket() | |
| { | |
| switch ($this->_content) { | |
| case '}': | |
| case ']': | |
| case ')': | |
| return(TRUE); | |
| break; | |
| } | |
| return(FALSE); | |
| } | |
| } | |
| class ASCIIMathPHP | |
| { | |
| var $_expr; | |
| var $_curr_expr; | |
| var $_prev_expr; | |
| var $_symbol_arr; | |
| var $_node_arr; | |
| var $_node_cntr; | |
| function ASCIIMathPHP($symbol_arr,$expr = NULL) | |
| { | |
| $this->_symbol_arr = $symbol_arr; | |
| if (isset($expr)) { | |
| $this->setExpr($expr); | |
| } | |
| } | |
| /** | |
| * Returns an empty node (containing a non-breaking space) 26-Apr-2006 | |
| * | |
| * Used when an expression is incomplete | |
| * | |
| * @return object | |
| * | |
| * @access private | |
| */ | |
| function emptyNode() | |
| { | |
| $tmp_node = $this->createNode(); | |
| $tmp_node->setName('mn'); | |
| $tmp_node->setContent('&#' . hexdec('200B') . ';'); | |
| return $tmp_node; | |
| } | |
| function pushExpr($prefix) // 2005-06-11 wes | |
| { | |
| $this->_curr_expr = $prefix . $this->_curr_expr; | |
| } | |
| function setExpr($expr) | |
| { | |
| $this->_expr = $expr; | |
| $this->_curr_expr = $expr; | |
| $this->_prev_expr = $expr; | |
| $this->_node_arr = array(); | |
| $this->_node_cntr = 0; | |
| } | |
| function genMathML($attr_arr = NULL) | |
| { | |
| // <math> node | |
| $node_0 = $this->createNode(); | |
| $node_0->setName('math'); | |
| $node_0->setNamepace('http://www.w3.org/1998/Math/MathML'); | |
| // <mstyle> node | |
| if (isset($attr_arr)) { | |
| $node_1 = $this->createNode(); | |
| $node_1->setName('mstyle'); | |
| $node_1->setAttrArr($attr_arr); | |
| $node_arr = $this->parseExpr(); | |
| $node_1->addChildArr($node_arr); | |
| $node_0->addChild($node_1); | |
| } else { | |
| $node_arr = $this->parseExpr(); | |
| $node_0->addChildArr($node_arr); | |
| } | |
| return TRUE; | |
| } | |
| /* | |
| function mergeNodeArr(&$node_arr_0,&$node_arr_1) | |
| { | |
| $key_arr_0 = array_keys($node_arr_0); | |
| $key_arr_1 = array_keys($node_arr_1); | |
| $num_key_0 = count($key_arr_0); | |
| $num_key_1 = count($key_arr_1); | |
| $merge_arr = array(); | |
| for ($i = 0;$i < $num_key_0;$i++) { | |
| $merge_arr[$key_arr_0[$i]] = $node_arr_0[$key_arr_0[$i]]; | |
| } | |
| for ($j = 0;$j < $num_key_1;$i++) { | |
| $merge_arr[$key_arr_1[$i]] = $node_arr_1[$key_arr_1[$i]]; | |
| } | |
| return($merge_arr); | |
| } | |
| */ | |
| //Broken out of parseExpr Sept 7, 2006 David Lippman for | |
| //ASCIIMathML 1.4.7 compatibility | |
| function parseIntExpr() | |
| { | |
| $sym_0 = $this->getSymbol(); | |
| $node_0 = $this->parseSmplExpr(); | |
| $sym = $this->getSymbol(); | |
| if (isset($sym['infix']) && $sym['input'] != '/') { | |
| $this->chopExpr($sym['symlen']); | |
| $node_1 = $this->parseSmplExpr(); | |
| if ($node_1 === FALSE) { //show box in place of missing argument | |
| $node_1 = $this->emptyNode();//?? | |
| } else { | |
| $node_1->removeBrackets(); | |
| } | |
| // If 'sub' -- subscript | |
| if ($sym['input'] == '_') { | |
| $sym_1 = $this->getSymbol(); | |
| // If 'sup' -- superscript | |
| if ($sym_1['input'] == '^') { | |
| $this->chopExpr($sym_1['symlen']); | |
| $node_2 = $this->parseSmplExpr(); | |
| $node_2->removeBrackets(); | |
| $node_3 = $this->createNode(); | |
| $node_3->setName(isset($sym_0['underover']) ? 'munderover' : 'msubsup'); | |
| $node_3->addChild($node_0); | |
| $node_3->addChild($node_1); | |
| $node_3->addChild($node_2); | |
| $node_4 = $this->createNode(); | |
| $node_4->setName('mrow'); | |
| $node_4->addChild($node_3); | |
| return $node_4; | |
| } else { | |
| $node_2 = $this->createNode(); | |
| $node_2->setName(isset($sym_0['underover']) ? 'munder' : 'msub'); | |
| $node_2->addChild($node_0); | |
| $node_2->addChild($node_1); | |
| return $node_2; | |
| } | |
| } else { | |
| $node_2 = $this->createNode(); | |
| $node_2->setName($sym['tag']); | |
| $node_2->addChild($node_0); | |
| $node_2->addChild($node_1); | |
| return($node_2); | |
| } | |
| } elseif ($node_0 !== FALSE) { | |
| return($node_0); | |
| } else { | |
| return $this->emptyNode(); | |
| } | |
| } | |
| function parseExpr() | |
| { | |
| // Child/Fragment array | |
| $node_arr = array(); | |
| // Deal whole expressions like 'ax + by + c = 0' etc. | |
| do { | |
| $sym_0 = $this->getSymbol(); | |
| $node_0 = $this->parseIntExpr(); | |
| $sym = $this->getSymbol(); | |
| // var_dump($sym); | |
| if (isset($sym['infix']) && $sym['input'] == '/') { | |
| $this->chopExpr($sym['symlen']); | |
| $node_1 = $this->parseIntExpr(); | |
| if ($node_1 === FALSE) { //should show box in place of missing argument | |
| $node_1 = $this->emptyNode(); | |
| continue; | |
| } | |
| $node_1->removeBrackets(); | |
| // If 'div' -- divide | |
| $node_0->removeBrackets(); | |
| $node_2 = $this->createNode(); | |
| $node_2->setName($sym['tag']); | |
| $node_2->addChild($node_0); | |
| $node_2->addChild($node_1); | |
| $node_arr[$node_2->getId()] = $node_2; | |
| } elseif ($node_0 !== FALSE) { | |
| $node_arr[$node_0->getId()] = $node_0; | |
| } | |
| } while (!isset($sym['right_bracket']) && $sym !== FALSE && $sym['output'] != ''); | |
| //var_dump($sym); | |
| // Possibly to deal with matrices | |
| if (isset($sym['right_bracket'])) { | |
| $node_cnt = count($node_arr); | |
| $key_node_arr = array_keys($node_arr); | |
| if ($node_cnt > 1) { | |
| $node_5 = $node_arr[$key_node_arr[$node_cnt-1]]; | |
| $node_6 = $node_arr[$key_node_arr[$node_cnt-2]]; | |
| } else { | |
| $node_5 = FALSE; | |
| $node_6 = FALSE; | |
| } | |
| // Dealing with matrices | |
| if ($node_5 !== FALSE && $node_6 !== FALSE && | |
| $node_cnt > 1 && | |
| $node_5->getName() == 'mrow' && | |
| $node_6->getName() == 'mo' && | |
| $node_6->getContent() == ',') { | |
| // Checking if Node 5 has a LastChild | |
| if ($node_7 = $node_5->getLastChild()) { | |
| $node_7_cntnt = $node_7->getContent(); | |
| } else { | |
| $node_7_cntnt = FALSE; | |
| } | |
| // If there is a right bracket | |
| if ($node_7 !== FALSE && ($node_7_cntnt == ']' || $node_7_cntnt == ')')) { | |
| // Checking if Node 5 has a firstChild | |
| if ($node_8 = $node_5->getFirstChild()) { | |
| $node_8_cntnt = $node_8->getContent(); | |
| } else { | |
| $node_8_cntnt = FALSE; | |
| } | |
| // If there is a matching left bracket | |
| if ($node_8 !== FALSE && | |
| (($node_8_cntnt == '(' && $node_7_cntnt == ')' && $sym['output'] != '}') || | |
| ($node_8_cntnt == '[' && $node_7_cntnt == ']'))) { | |
| $is_mtrx_flg = TRUE; | |
| $comma_pos_arr = array(); | |
| $i = 0; | |
| while ($i < $node_cnt && $is_mtrx_flg) { | |
| $tmp_node = $node_arr[$key_node_arr[$i]]; | |
| if($tmp_node_first = $tmp_node->getFirstChild()) { | |
| $tnfc = $tmp_node_first->getContent(); | |
| } else { | |
| $tnfc = FALSE; | |
| } | |
| if($tmp_node_last = $tmp_node->getLastChild()) { | |
| $tnlc = $tmp_node_last->getContent(); | |
| } else { | |
| $tnlc = FALSE; | |
| } | |
| if (isset($key_node_arr[$i+1])) { | |
| $next_tmp_node = $node_arr[$key_node_arr[$i+1]]; | |
| $ntnn = $next_tmp_node->getName(); | |
| $ntnc = $next_tmp_node->getContent(); | |
| } else { | |
| $ntnn = FALSE; | |
| $ntnc = FALSE; | |
| } | |
| // Checking each node in node array for matrix criteria | |
| if ($is_mtrx_flg) { | |
| $is_mtrx_flg = $tmp_node->getName() == 'mrow' && | |
| ($i == $node_cnt-1 || $ntnn == 'mo' && $ntnc == ',') && | |
| $tnfc == $node_8_cntnt && $tnlc == $node_7_cntnt; | |
| } | |
| if ($is_mtrx_flg) { | |
| for ($j = 0;$j < $tmp_node->getNumChild();$j++) { | |
| $tmp_c_node = $tmp_node->getChildByIdx($j); | |
| if ($tmp_c_node->getContent() == ',') { | |
| $comma_pos_arr[$i][] = $j; | |
| } | |
| } | |
| } | |
| if ($is_mtrx_flg && $i > 1) { | |
| $cnt_cpan = isset($comma_pos_arr[$i]) ? count($comma_pos_arr[$i]) : NULL; | |
| $cnt_cpap = isset($comma_pos_arr[$i-2]) ? count($comma_pos_arr[$i-2]) : NULL; | |
| $is_mtrx_flg = $cnt_cpan == $cnt_cpap; | |
| } | |
| $i += 2; | |
| } | |
| // If the node passes the matrix tests | |
| if ($is_mtrx_flg) { | |
| $tab_node_arr = array(); | |
| for ($i = 0;$i < $node_cnt;$i += 2) { | |
| $tmp_key_node_arr = array_keys($node_arr); | |
| if (!($tmp_node = $node_arr[$tmp_key_node_arr[0]])) { | |
| break; | |
| } | |
| $num_child = $tmp_node->getNumChild(); | |
| $k = 0; | |
| $tmp_node->removeFirstChild(); | |
| $row_node_arr = array(); | |
| $row_frag_node_arr = array(); | |
| for ($j = 1;$j < ($num_child-1);$j++) { | |
| if (isset($comma_pos_arr[$i][$k]) && | |
| $j == $comma_pos_arr[$i][$k]) { | |
| $tmp_node->removeFirstChild(); | |
| $tmp_c_node = $this->createNode(); | |
| $tmp_c_node->setName('mtd'); | |
| $tmp_c_node->addChildArr($row_frag_node_arr); | |
| $row_frag_node_arr = array(); | |
| $row_node_arr[$tmp_c_node->getId()] = $tmp_c_node; | |
| $k++; | |
| } else { | |
| if ($tmp_c_node = $tmp_node->getFirstChild()) { | |
| $row_frag_node_arr[$tmp_c_node->getId()] = $tmp_c_node; | |
| $tmp_node->removeFirstChild(); | |
| } | |
| } | |
| } | |
| $tmp_c_node = $this->createNode(); | |
| $tmp_c_node->setName('mtd'); | |
| $tmp_c_node->addChildArr($row_frag_node_arr); | |
| $row_node_arr[$tmp_c_node->getId()] = $tmp_c_node; | |
| if (count($node_arr) > 2) { | |
| $tmp_key_node_arr = array_keys($node_arr); | |
| unset($node_arr[$tmp_key_node_arr[0]]); | |
| unset($node_arr[$tmp_key_node_arr[1]]); | |
| } | |
| $tmp_c_node = $this->createNode(); | |
| $tmp_c_node->setName('mtr'); | |
| $tmp_c_node->addChildArr($row_node_arr); | |
| $tab_node_arr[$tmp_c_node->getId()] = $tmp_c_node; | |
| } | |
| $tmp_c_node = $this->createNode(); | |
| $tmp_c_node->setName('mtable'); | |
| $tmp_c_node->addChildArr($tab_node_arr); | |
| if (isset($sym['invisible'])) { | |
| $tmp_c_node->setAttr('columnalign','left'); | |
| } | |
| $key_node_arr = array_keys($node_arr); | |
| $tmp_c_node->setId($key_node_arr[0]); | |
| $node_arr[$tmp_c_node->getId()] = $tmp_c_node; | |
| } | |
| } | |
| } | |
| } | |
| $this->chopExpr($sym['symlen']); | |
| if (!isset($sym['invisible'])) { | |
| $node_7 = $this->createNode(); | |
| $node_7->setName('mo'); | |
| $node_7->setContent($sym['output']); | |
| $node_arr[$node_7->getId()] = $node_7; | |
| } | |
| } | |
| return($node_arr); | |
| } | |
| function parseSmplExpr() | |
| { | |
| $sym = $this->getSymbol(); | |
| if (!$sym || isset($sym['right_bracket'])) //return FALSE; | |
| return $this->emptyNode(); | |
| $this->chopExpr($sym['symlen']); | |
| // 2005-06-11 wes: add definition type support | |
| if(isset($sym['definition'])) { | |
| $this->pushExpr($sym['output']); | |
| $sym = $this->getSymbol(); | |
| $this->chopExpr($sym['symlen']); | |
| } | |
| if (isset($sym['left_bracket'])) { | |
| $node_arr = $this->parseExpr(); | |
| if (isset($sym['invisible'])) { | |
| $node_0 = $this->createNode(); | |
| $node_0->setName('mrow'); | |
| $node_0->addChildArr($node_arr); | |
| return($node_0); | |
| } else { | |
| $node_0 = $this->createNode(); | |
| $node_0->setName('mo'); | |
| $node_0->setContent($sym['output']); | |
| $node_1 = $this->createNode(); | |
| $node_1->setName('mrow'); | |
| $node_1->addChild($node_0); | |
| $node_1->addChildArr($node_arr); | |
| return($node_1); | |
| } | |
| } elseif (isset($sym['unary'])) { | |
| if ($sym['input'] == 'sqrt') { | |
| $node_0 = $this->parseSmplExpr(); | |
| $node_0->removeBrackets(); | |
| $node_1 = $this->createNode(); | |
| $node_1->setName($sym['tag']); | |
| $node_1->addChild($node_0); | |
| return($node_1); | |
| } elseif (isset($sym['func'])) { //added 2006-9-7 David Lippman | |
| $expr = ltrim($this->getCurrExpr()); | |
| $st = $expr{0}; | |
| $node_0 = $this->parseSmplExpr(); | |
| //$node_0->removeBrackets(); | |
| if ($st=='^' || $st == '_' || $st=='/' || $st=='|' || $st==',') { | |
| $node_1 = $this->createNode(); | |
| $node_1->setName($sym['tag']); | |
| $node_1->setContent($sym['output']); | |
| $this->setCurrExpr($expr); | |
| return($node_1); | |
| } else { | |
| $node_1 = $this->createNode(); | |
| $node_1->setName('mrow'); | |
| $node_2 = $this->createNode(); | |
| $node_2->setName($sym['tag']); | |
| $node_2->setContent($sym['output']); | |
| $node_1->addChild($node_2); | |
| $node_1->addChild($node_0); | |
| return($node_1); | |
| } | |
| } elseif ($sym['input'] == 'text' || $sym['input'] == 'mbox' || $sym['input'] == '"') { | |
| $expr = ltrim($this->getCurrExpr()); | |
| if ($sym['input']=='"') { | |
| $end_brckt = '"'; | |
| $txt = substr($expr,0,strpos($expr,$end_brckt)); | |
| } else { | |
| switch($expr{0}) { | |
| case '(': | |
| $end_brckt = ')'; | |
| break; | |
| case '[': | |
| $end_brckt = ']'; | |
| break; | |
| case '{': | |
| $end_brckt = '}'; | |
| break; | |
| default: | |
| $end_brckt = chr(11); // A character that will never be matched. | |
| break; | |
| } | |
| $txt = substr($expr,1,strpos($expr,$end_brckt)-1); | |
| } | |
| //$txt = substr($expr,1,strpos($expr,$end_brckt)-1); | |
| $len = strlen($txt); | |
| $node_0 = $this->createNode(); | |
| $node_0->setName('mrow'); | |
| if ($len > 0) { | |
| if ($txt{0} == " ") { | |
| $node_1 = $this->createNode(); | |
| $node_1->setName('mspace'); | |
| $node_1->setAttr('width','1ex'); | |
| $node_0->addChild($node_1); | |
| } | |
| $node_3 = $this->createNode(); | |
| $node_3->setName($sym['tag']); | |
| $node_3->setContent(trim($txt)); | |
| $node_0->addChild($node_3); | |
| if ($len > 1 && $txt{$len-1} == " ") { | |
| $node_2 = $this->createNode(); | |
| $node_2->setName('mspace'); | |
| $node_2->setAttr('width','1ex'); | |
| $node_0->addChild($node_2); | |
| } | |
| $this->chopExpr($len+2); | |
| } | |
| return($node_0); | |
| } elseif (isset($sym['acc'])) { | |
| $node_0 = $this->parseSmplExpr(); | |
| $node_0->removeBrackets(); | |
| $node_1 = $this->createNode(); | |
| $node_1->setName($sym['tag']); | |
| $node_1->addChild($node_0); | |
| $node_2 = $this->createNode(); | |
| $node_2->setName('mo'); | |
| $node_2->setContent($sym['output']); | |
| $node_1->addChild($node_2); | |
| return($node_1); | |
| } else { | |
| // Font change commands -- to complete | |
| } | |
| } elseif (isset($sym['binary'])) { | |
| $node_arr = array(); | |
| $node_0 = $this->parseSmplExpr(); | |
| $node_0->removeBrackets(); | |
| $node_1 = $this->parseSmplExpr(); | |
| $node_1->removeBrackets(); | |
| /* 2005-06-05 wes: added stackrel */ | |
| if ($sym['input'] == 'root' || $sym['input'] == 'stackrel') { | |
| $node_arr[$node_1->getId()] = $node_1; | |
| $node_arr[$node_0->getId()] = $node_0; | |
| } elseif ($sym['input'] == 'frac') { | |
| $node_arr[$node_0->getId()] = $node_0; | |
| $node_arr[$node_1->getId()] = $node_1; | |
| } | |
| $node_2 = $this->createNode(); | |
| $node_2->setName($sym['tag']); | |
| $node_2->addChildArr($node_arr); | |
| return($node_2); | |
| } elseif (isset($sym['infix'])) { | |
| $node_0 = $this->createNode(); | |
| $node_0->setName('mo'); | |
| $node_0->setContent($sym['output']); | |
| return($node_0); | |
| } elseif (isset($sym['space'])) { | |
| $node_0 = $this->createNode(); | |
| $node_0->setName('mrow'); | |
| $node_1 = $this->createNode(); | |
| $node_1->setName('mspace'); | |
| $node_1->setAttr('width',$sym['space']); | |
| $node_2 = $this->createNode(); | |
| $node_2->setName($sym['tag']); | |
| $node_2->setContent($sym['output']); | |
| $node_3 = $this->createNode(); | |
| $node_3->setName('mspace'); | |
| $node_3->setAttr('width',$sym['space']); | |
| $node_0->addChild($node_1); | |
| $node_0->addChild($node_2); | |
| $node_0->addChild($node_3); | |
| return($node_0); | |
| } else { | |
| // A constant | |
| $node_0 = $this->createNode(); | |
| $node_0->setName($sym['tag']); | |
| $node_0->setContent($sym['output']); | |
| return($node_0); | |
| } | |
| // Return an empty node | |
| return $this->emptyNode(); | |
| } | |
| function getMathML() | |
| { | |
| $root = $this->_node_arr[0]; | |
| return($root->dumpXML()); | |
| } | |
| function getCurrExpr() | |
| { | |
| return($this->_curr_expr); | |
| } | |
| function setCurrExpr($str) | |
| { | |
| $this->_curr_expr = $str; | |
| } | |
| function getExpr() | |
| { | |
| return($this->_expr); | |
| } | |
| function getPrevExpr() | |
| { | |
| return($this->_prev_expr); | |
| } | |
| function createNode() | |
| { | |
| $node = new MathMLNode($this->_node_cntr); | |
| // $node->setNamespaceAlias('m'); | |
| $this->_node_arr[$this->_node_cntr] = $node; | |
| $this->_node_cntr++; | |
| return($node); | |
| } | |
| /** | |
| * Gets the largest symbol in the expression (greedy). Changed from non-greedy 26-Apr-2006 | |
| * | |
| * @parameter boolean[optional] Chop original string? | |
| * | |
| * @return mixed | |
| * | |
| * @access private | |
| */ | |
| function getSymbol($chop_flg = FALSE) | |
| { | |
| // Implemented a reverse symbol matcher. | |
| // Instead of going front to back, it goes back to front. Steven 26-Apr-2006 | |
| $chr_cnt = strlen($this->_curr_expr); | |
| if ($chr_cnt == 0) return FALSE; | |
| for ($i = $chr_cnt; $i > 0; $i--) { | |
| $sym_0 = substr($this->_curr_expr,0,$i); | |
| // Reading string for numeric values | |
| if (is_numeric($sym_0)) { | |
| if ($chop_flg) $this->chopExpr($i); | |
| return array('input'=>$sym_0, 'tag'=>'mn', 'output'=>$sym_0, 'symlen'=>$i); | |
| } elseif (isset($this->_symbol_arr[$sym_0])) { | |
| if ($chop_flg) $this->chopExpr($i); | |
| $sym_arr = $this->_symbol_arr[$sym_0]; | |
| $sym_arr['symlen'] = $i; | |
| return $sym_arr; | |
| } | |
| } | |
| // Reading string for alphabetic constants and the minus sign | |
| $char = $this->_curr_expr{0}; | |
| $len_left = $chop_flg ? $this->chopExpr(1) : strlen($this->_curr_expr)-1; | |
| // Deals with expressions of length 1 | |
| if ($len_left == 0 && isset($this->_symbol_arr[$char])) { | |
| $sym_arr = $this->_symbol_arr[$char]; | |
| $sym_arr['symlen'] = 1; | |
| return $sym_arr; | |
| } else { | |
| $tag = preg_match('/[a-z]/i',$char) ? 'mi' : 'mo'; | |
| return array('input'=>$char, 'tag'=>$tag, 'output'=>$char, 'symlen'=>1); | |
| } | |
| } | |
| function chopExpr($strlen) | |
| { | |
| $this->_prev_expr = $this->_curr_expr; | |
| if ($strlen == strlen($this->_curr_expr)) { | |
| $this->_curr_expr = ''; | |
| return(0); | |
| } else { | |
| $this->_curr_expr = ltrim(substr($this->_curr_expr,$strlen)); | |
| return(strlen($this->_curr_expr)); | |
| } | |
| } | |
| } | |
| ?> |