source/libvpx/examples/includes/ASCIIMathPHP-2.0/ASCIIMathPHP-2.0.class.php - Issue 148913004: libvpx: Pull from upstream

Side by Side Diff: source/libvpx/examples/includes/ASCIIMathPHP-2.0/ASCIIMathPHP-2.0.class.php

Issue 148913004: libvpx: Pull from upstream (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/libvpx/

Patch Set: Created 6 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

« no previous file with comments | « source/libvpx/examples/includes/ASCIIMathPHP-2.0/ASCIIMathPHP-2.0.cfg.php ('k') | source/libvpx/examples/includes/ASCIIMathPHP-2.0/htmlMathML.js » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
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@corne ll.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 A SCIIMathPHP 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 longe st 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' : 'ms ub');

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 a rgument

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 crite ria

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_c ntnt;

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($c omma_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()] = $t mp_c_node;

757

758 $k++;

759 } else {

760

761 if ($tmp_c_node = $tmp_node->getFirstChi ld()) {

762 $row_frag_node_arr[$tmp_c_node->getI d()] = $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_nod e;

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_nod e;

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-gree dy 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, 'sy mlen'=>$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 ?>

OLD	NEW