style/FOTBuilder.cxx

   1 // Copyright (c) 1996 James Clark
   2 // See the file copying.txt for copying permission.
   3
   4 #include "stylelib.h"
   5 #include "FOTBuilder.h"
   6 #include "Owner.h"
   7 #include "macros.h"
   8
   9 #ifdef DSSSL_NAMESPACE
  10 namespace DSSSL_NAMESPACE {
  11 #endif
  12
  13 const char *FOTBuilder::symbolName(Symbol sym)
  14 {
  15   if (sym < 2 || sym >= int(nSymbols))
  16     return 0;
  17   // These must match the order in Symbol
  18   static const char *names[] = {
  19     "not-applicable",
  20     "ultra-condensed",
  21     "extra-condensed",
  22     "condensed",
  23     "semi-condensed",
  24     "ultra-light",
  25     "extra-light",
  26     "light",
  27     "semi-light",
  28     "medium",
  29     "semi-expanded",
  30     "expanded",
  31     "extra-expanded",
  32     "ultra-expanded",
  33     "semi-bold",
  34     "bold",
  35     "extra-bold",
  36     "ultra-bold",
  37     "upright",
  38     "oblique",
  39     "back-slanted-oblique",
  40     "italic",
  41     "back-slanted-italic",
  42     "start",
  43     "end",
  44     "center",
  45     "justify",
  46     "spread-inside",
  47     "spread-outside",
  48     "page-inside",
  49     "page-outside",
  50     "wrap",
  51     "asis",
  52     "asis-wrap",
  53     "asis-truncate",
  54     "none",
  55     "before",
  56     "through",
  57     "after",
  58     "top-to-bottom",
  59     "left-to-right",
  60     "bottom-to-top",
  61     "right-to-left",
  62     "inside",
  63     "outside",
  64     "horizontal",
  65     "vertical",
  66     "escapement",
  67     "line-progression",
  68     "math",
  69     "ordinary",
  70     "operator",
  71     "binary",
  72     "relation",
  73     "opening",
  74     "closing",
  75     "punctuation",
  76     "inner",
  77     "space",
  78     "page",
  79     "page-region",
  80     "column-set",
  81     "column",
  82     "max",
  83     "max-uniform",
  84     "miter",
  85     "round",
  86     "join",
  87     "butt",
  88     "square",
  89     "loose",
  90     "normal",
  91     "kern",
  92     "tight",
  93     "touch",
  94     "preserve",
  95     "collapse",
  96     "ignore",
  97     "relative",
  98     "display",
  99     "inline",
 100     "border",
 101     "background",
 102     "both",
 103     "base",
 104     "font",
 105     "top",
 106     "bottom",
 107     "spread",
 108     "solid",
 109     "outline",
 110     "with",
 111     "against",
 112     "force",
 113     "independent",
 114     "pile",
 115     "sup-out",
 116     "sub-out",
 117     "lead-edge",
 118     "trail-edge",
 119     "explicit",
 120     "row-major",
 121     "column-major",
 122   };
 123   ASSERT(SIZEOF(names) == nSymbols - 2);
 124   return names[sym - 2];
 125 }
 126
 127 SaveFOTBuilder *FOTBuilder::asSaveFOTBuilder()
 128 {
 129   return 0;
 130 }
 131
 132 FOTBuilder::~FOTBuilder()
 133 {
 134 }
 135
 136 void FOTBuilder::start()
 137 {
 138 }
 139
 140 void FOTBuilder::end()
 141 {
 142 }
 143
 144 void FOTBuilder::atomic()
 145 {
 146   start();
 147   end();
 148 }
 149
 150 void FOTBuilder::characters(const Char *, size_t)
 151 {
 152 }
 153
 154 void FOTBuilder::charactersFromNode(const NodePtr &, const Char *s, size_t n)
 155 {
 156   characters(s, n);
 157 }
 158
 159 void FOTBuilder::character(const CharacterNIC &nic)
 160 {
 161   if (nic.valid)
 162     characters(&nic.ch, 1);
 163   atomic();
 164 }
 165
 166 void FOTBuilder::startSequence()
 167 {
 168   start();
 169 }
 170
 171 void FOTBuilder::endSequence()
 172 {
 173   end();
 174 }
 175
 176 void FOTBuilder::startLineField(const LineFieldNIC &)
 177 {
 178   start();
 179 }
 180
 181 void FOTBuilder::endLineField()
 182 {
 183   end();
 184 }
 185
 186 void FOTBuilder::paragraphBreak(const ParagraphNIC &)
 187 {
 188   atomic();
 189 }
 190
 191 void FOTBuilder::externalGraphic(const ExternalGraphicNIC &)
 192 {
 193   atomic();
 194 }
 195
 196 void FOTBuilder::rule(const RuleNIC &)
 197 {
 198   atomic();
 199 }
 200
 201 void FOTBuilder::alignmentPoint()
 202 {
 203   atomic();
 204 }
 205
 206 void FOTBuilder::formattingInstruction(const StringC &)
 207 {
 208   atomic();
 209 }
 210
 211 void FOTBuilder::startParagraph(const ParagraphNIC &)
 212 {
 213   start();
 214 }
 215
 216 void FOTBuilder::endParagraph()
 217 {
 218   end();
 219 }
 220
 221 void FOTBuilder::startDisplayGroup(const DisplayGroupNIC &)
 222 {
 223   start();
 224 }
 225
 226 void FOTBuilder::endDisplayGroup()
 227 {
 228   end();
 229 }
 230
 231 void FOTBuilder::startScroll()
 232 {
 233   start();
 234 }
 235
 236 void FOTBuilder::endScroll()
 237 {
 238   end();
 239 }
 240
 241 void FOTBuilder::startLink(const Address &)
 242 {
 243   start();
 244 }
 245
 246 void FOTBuilder::endLink()
 247 {
 248   end();
 249 }
 250
 251 void FOTBuilder::startMarginalia()
 252 {
 253   start();
 254 }
 255
 256 void FOTBuilder::endMarginalia()
 257 {
 258   end();
 259 }
 260
 261 void FOTBuilder::startMultiMode(const FOTBuilder::MultiMode *,
 262                                 const Vector<FOTBuilder::MultiMode> &,
 263                                 Vector<FOTBuilder *> &ports)
 264 {
 265   start();
 266   for (size_t i = 0; i < ports.size(); i++)
 267     ports[i] = this;
 268 }
 269
 270 void FOTBuilder::endMultiMode()
 271 {
 272   end();
 273 }
 274
 275 void FOTBuilder::startScore(Symbol)
 276 {
 277   start();
 278 }
 279
 280 void FOTBuilder::startScore(Char)
 281 {
 282   start();
 283 }
 284
 285 void FOTBuilder::startScore(const LengthSpec &)
 286 {
 287   start();
 288 }
 289
 290 void FOTBuilder::endScore()
 291 {
 292   end();
 293 }
 294
 295 void FOTBuilder::startLeader(const LeaderNIC &)
 296 {
 297   start();
 298 }
 299
 300 void FOTBuilder::endLeader()
 301 {
 302   end();
 303 }
 304
 305 void FOTBuilder::startBox(const BoxNIC &)
 306 {
 307   start();
 308 }
 309
 310 void FOTBuilder::endBox()
 311 {
 312   end();
 313 }
 314
 315 void FOTBuilder::startSideline()
 316 {
 317 }
 318
 319 void FOTBuilder::endSideline()
 320 {
 321 }
 322
 323 void FOTBuilder::startSimplePageSequence(FOTBuilder* headerFooter[nHF])
 324 {
 325   for ( unsigned i = 0; i < nHF; ++i )
 326     headerFooter[i] = this;
 327   start();
 328 }
 329
 330 void FOTBuilder::endSimplePageSequenceHeaderFooter()
 331 {
 332 }
 333
 334 void FOTBuilder::endSimplePageSequence()
 335 {
 336   end();
 337 }
 338
 339 void FOTBuilder::pageNumber()
 340 {
 341 }
 342
 343 void FOTBuilder::startTable(const TableNIC &)
 344 {
 345   start();
 346 }
 347
 348 void FOTBuilder::endTable()
 349 {
 350   end();
 351 }
 352
 353 void FOTBuilder::tableBeforeRowBorder()
 354 {
 355   atomic();
 356 }
 357
 358 void FOTBuilder::tableAfterRowBorder()
 359 {
 360   atomic();
 361 }
 362
 363 void FOTBuilder::tableBeforeColumnBorder()
 364 {
 365   atomic();
 366 }
 367
 368 void FOTBuilder::tableAfterColumnBorder()
 369 {
 370   atomic();
 371 }
 372
 373 void FOTBuilder::startTablePart(const TablePartNIC &, FOTBuilder *&header, FOTBuilder *&footer)
 374 {
 375   start();
 376   header = footer = this;
 377 }
 378
 379 void FOTBuilder::endTablePart()
 380 {
 381   end();
 382 }
 383
 384 void FOTBuilder::tableColumn(const TableColumnNIC &)
 385 {
 386   atomic();
 387 }
 388
 389 void FOTBuilder::startTableRow()
 390 {
 391   start();
 392 }
 393
 394 void FOTBuilder::endTableRow()
 395 {
 396   end();
 397 }
 398
 399 void FOTBuilder::startTableCell(const TableCellNIC &)
 400 {
 401   start();
 402 }
 403
 404 void FOTBuilder::endTableCell()
 405 {
 406   end();
 407 }
 408
 409 void FOTBuilder::tableCellBeforeRowBorder()
 410 {
 411   atomic();
 412 }
 413
 414 void FOTBuilder::tableCellAfterRowBorder()
 415 {
 416   atomic();
 417 }
 418
 419 void FOTBuilder::tableCellBeforeColumnBorder()
 420 {
 421   atomic();
 422 }
 423
 424 void FOTBuilder::tableCellAfterColumnBorder()
 425 {
 426   atomic();
 427 }
 428
 429 void FOTBuilder::startMathSequence()
 430 {
 431   start();
 432 }
 433
 434 void FOTBuilder::endMathSequence()
 435 {
 436   end();
 437 }
 438
 439 void FOTBuilder::startFraction(FOTBuilder *&numerator, FOTBuilder *&denominator)
 440 {
 441   start();
 442   numerator = denominator = this;
 443 }
 444
 445 void FOTBuilder::endFraction()
 446 {
 447   end();
 448 }
 449
 450 void FOTBuilder::fractionBar()
 451 {
 452   atomic();
 453 }
 454
 455 void FOTBuilder::startUnmath()
 456 {
 457   start();
 458 }
 459
 460 void FOTBuilder::endUnmath()
 461 {
 462   end();
 463 }
 464
 465 void FOTBuilder::startSuperscript()
 466 {
 467   start();
 468 }
 469
 470 void FOTBuilder::endSuperscript()
 471 {
 472   end();
 473 }
 474
 475 void FOTBuilder::startSubscript()
 476 {
 477   start();
 478 }
 479
 480 void FOTBuilder::endSubscript()
 481 {
 482   end();
 483 }
 484
 485 void FOTBuilder::startScript(FOTBuilder *&preSup,
 486                              FOTBuilder *&preSub,
 487                              FOTBuilder *&postSup,
 488                              FOTBuilder *&postSub,
 489                              FOTBuilder *&midSup,
 490                              FOTBuilder *&midSub)
 491 {
 492   start();
 493   preSup = preSub = postSup = postSub = midSup = midSub = this;
 494 }
 495
 496 void FOTBuilder::endScript()
 497 {
 498   end();
 499 }
 500
 501 void FOTBuilder::startMark(FOTBuilder *&overMark, FOTBuilder *&underMark)
 502 {
 503   start();
 504   overMark = underMark = this;
 505 }
 506
 507 void FOTBuilder::endMark()
 508 {
 509   end();
 510 }
 511
 512 void FOTBuilder::startFence(FOTBuilder *&open, FOTBuilder *&close)
 513 {
 514   start();
 515   open = close = this;
 516 }
 517
 518 void FOTBuilder::endFence()
 519 {
 520   end();
 521 }
 522
 523 void FOTBuilder::startRadical(FOTBuilder *&degree)
 524 {
 525   start();
 526   degree = this;
 527 }
 528
 529 void FOTBuilder::endRadical()
 530 {
 531   end();
 532 }
 533
 534 void FOTBuilder::radicalRadical(const CharacterNIC &)
 535 {
 536   atomic();
 537 }
 538
 539 void FOTBuilder::radicalRadicalDefaulted()
 540 {
 541 }
 542
 543 void FOTBuilder::startMathOperator(FOTBuilder *&oper,
 544                                    FOTBuilder *&lowerLimit,
 545                                    FOTBuilder *&upperLimit)
 546 {
 547   start();
 548   oper = lowerLimit = upperLimit = this;
 549 }
 550
 551 void FOTBuilder::endMathOperator()
 552 {
 553   end();
 554 }
 555
 556 void FOTBuilder::startGrid(const GridNIC &)
 557 {
 558   start();
 559 }
 560
 561 void FOTBuilder::endGrid()
 562 {
 563   end();
 564 }
 565
 566 void FOTBuilder::startGridCell(const GridCellNIC &)
 567 {
 568   start();
 569 }
 570
 571 void FOTBuilder::endGridCell()
 572 {
 573   end();
 574 }
 575
 576 void FOTBuilder::extension(const ExtensionFlowObj &, const NodePtr &)
 577 {
 578   atomic();
 579 }
 580
 581 void FOTBuilder::startExtension(const CompoundExtensionFlowObj &,
 582                                 const NodePtr &,
 583                                 Vector<FOTBuilder *> &ports)
 584 {
 585   for (size_t i = 0; i < ports.size(); i++)
 586     ports[i] = this;
 587   start();
 588 }
 589
 590 void FOTBuilder::endExtension(const CompoundExtensionFlowObj &)
 591 {
 592   end();
 593 }
 594
 595
 596 void FOTBuilder::setFontSize(Length)
 597 {
 598 }
 599
 600 void FOTBuilder::setFontFamilyName(const StringC &)
 601 {
 602 }
 603
 604 void FOTBuilder::setFontWeight(Symbol)
 605 {
 606 }
 607
 608 void FOTBuilder::setFontPosture(Symbol)
 609 {
 610 }
 611
 612 void FOTBuilder::setStartIndent(const LengthSpec &)
 613 {
 614 }
 615
 616 void FOTBuilder::setEndIndent(const LengthSpec &)
 617 {
 618 }
 619
 620 void FOTBuilder::setFirstLineStartIndent(const LengthSpec &)
 621 {
 622 }
 623
 624 void FOTBuilder::setLastLineEndIndent(const LengthSpec &)
 625 {
 626 }
 627
 628 void FOTBuilder::setLineSpacing(const LengthSpec &)
 629 {
 630 }
 631
 632 void FOTBuilder::setFieldWidth(const LengthSpec &)
 633 {
 634 }
 635
 636 void FOTBuilder::setQuadding(Symbol)
 637 {
 638 }
 639
 640 void FOTBuilder::setDisplayAlignment(Symbol)
 641 {
 642 }
 643
 644 void FOTBuilder::setFieldAlign(Symbol)
 645 {
 646 }
 647
 648 void FOTBuilder::setLines(Symbol)
 649 {
 650 }
 651
 652 void FOTBuilder::setColor(const DeviceRGBColor &)
 653 {
 654 }
 655
 656 void FOTBuilder::setBackgroundColor(const DeviceRGBColor &)
 657 {
 658 }
 659
 660 void FOTBuilder::setBackgroundColor()
 661 {
 662 }
 663
 664 void FOTBuilder::setPageWidth(Length)
 665 {
 666 }
 667
 668 void FOTBuilder::setPageHeight(Length)
 669 {
 670 }
 671
 672 void FOTBuilder::setLeftMargin(Length)
 673 {
 674 }
 675
 676 void FOTBuilder::setRightMargin(Length)
 677 {
 678 }
 679
 680 void FOTBuilder::setTopMargin(Length)
 681 {
 682 }
 683
 684 void FOTBuilder::setBottomMargin(Length)
 685 {
 686 }
 687
 688 void FOTBuilder::setHeaderMargin(Length)
 689 {
 690 }
 691
 692 void FOTBuilder::setFooterMargin(Length)
 693 {
 694 }
 695
 696 void FOTBuilder::setBorderPresent(bool)
 697 {
 698 }
 699
 700 void FOTBuilder::setLineThickness(Length)
 701 {
 702 }
 703
 704 void FOTBuilder::setCellBeforeRowMargin(Length)
 705 {
 706 }
 707
 708 void FOTBuilder::setCellAfterRowMargin(Length)
 709 {
 710 }
 711
 712 void FOTBuilder::setCellBeforeColumnMargin(Length)
 713 {
 714 }
 715
 716 void FOTBuilder::setCellAfterColumnMargin(Length)
 717 {
 718 }
 719
 720 void FOTBuilder::setLineSep(Length)
 721 {
 722 }
 723
 724 void FOTBuilder::setBoxSizeBefore(Length)
 725 {
 726 }
 727
 728 void FOTBuilder::setBoxSizeAfter(Length)
 729 {
 730 }
 731
 732 void FOTBuilder::setPositionPointShift(const LengthSpec &)
 733 {
 734 }
 735
 736 void FOTBuilder::setStartMargin(const LengthSpec &)
 737 {
 738 }
 739
 740 void FOTBuilder::setEndMargin(const LengthSpec &)
 741 {
 742 }
 743
 744 void FOTBuilder::setSidelineSep(const LengthSpec &)
 745 {
 746 }
 747
 748 void FOTBuilder::setAsisWrapIndent(const LengthSpec &)
 749 {
 750 }
 751
 752 void FOTBuilder::setLineNumberSep(const LengthSpec &)
 753 {
 754 }
 755
 756 void FOTBuilder::setLastLineJustifyLimit(const LengthSpec &)
 757 {
 758 }
 759
 760 void FOTBuilder::setJustifyGlyphSpaceMaxAdd(const LengthSpec &)
 761 {
 762 }
 763
 764 void FOTBuilder::setJustifyGlyphSpaceMaxRemove(const LengthSpec &)
 765 {
 766 }
 767
 768 void FOTBuilder::setTableCornerRadius(const LengthSpec &)
 769 {
 770 }
 771
 772 void FOTBuilder::setBoxCornerRadius(const LengthSpec &)
 773 {
 774 }
 775
 776 void FOTBuilder::setMarginaliaSep(const LengthSpec &)
 777 {
 778 }
 779
 780 void FOTBuilder::setMinPreLineSpacing(const OptLengthSpec &)
 781 {
 782 }
 783
 784 void FOTBuilder::setMinPostLineSpacing(const OptLengthSpec &)
 785 {
 786 }
 787
 788 void FOTBuilder::setMinLeading(const OptLengthSpec &)
 789 {
 790 }
 791
 792 void FOTBuilder::setInhibitLineBreaks(bool)
 793 {
 794 }
 795
 796 void FOTBuilder::setHyphenate(bool)
 797 {
 798 }
 799
 800 void FOTBuilder::setKern(bool)
 801 {
 802 }
 803
 804 void FOTBuilder::setLigature(bool)
 805 {
 806 }
 807
 808 void FOTBuilder::setScoreSpaces(bool)
 809 {
 810 }
 811
 812 void FOTBuilder::setFloatOutMarginalia(bool)
 813 {
 814 }
 815
 816 void FOTBuilder::setFloatOutSidelines(bool)
 817 {
 818 }
 819
 820 void FOTBuilder::setFloatOutLineNumbers(bool)
 821 {
 822 }
 823
 824 void FOTBuilder::setCellBackground(bool)
 825 {
 826 }
 827
 828 void FOTBuilder::setSpanWeak(bool)
 829 {
 830 }
 831
 832 void FOTBuilder::setIgnoreRecordEnd(bool)
 833 {
 834 }
 835
 836 void FOTBuilder::setNumberedLines(bool)
 837 {
 838 }
 839
 840 void FOTBuilder::setHangingPunct(bool)
 841 {
 842 }
 843
 844 void FOTBuilder::setBoxOpenEnd(bool)
 845 {
 846 }
 847
 848 void FOTBuilder::setTruncateLeader(bool)
 849 {
 850 }
 851
 852 void FOTBuilder::setAlignLeader(bool)
 853 {
 854 }
 855
 856 void FOTBuilder::setTablePartOmitMiddleHeader(bool)
 857 {
 858 }
 859
 860 void FOTBuilder::setTablePartOmitMiddleFooter(bool)
 861 {
 862 }
 863
 864 void FOTBuilder::setBorderOmitAtBreak(bool)
 865 {
 866 }
 867
 868 void FOTBuilder::setPrincipalModeSimultaneous(bool)
 869 {
 870 }
 871
 872 void FOTBuilder::setMarginaliaKeepWithPrevious(bool)
 873 {
 874 }
 875
 876 void FOTBuilder::setGridEquidistantRows(bool)
 877 {
 878 }
 879
 880 void FOTBuilder::setGridEquidistantColumns(bool)
 881 {
 882 }
 883
 884 void FOTBuilder::setLineJoin(Symbol)
 885 {
 886 }
 887
 888 void FOTBuilder::setLineCap(Symbol)
 889 {
 890 }
 891
 892 void FOTBuilder::setLineNumberSide(Symbol)
 893 {
 894 }
 895
 896 void FOTBuilder::setKernMode(Symbol)
 897 {
 898 }
 899
 900 void FOTBuilder::setInputWhitespaceTreatment(Symbol)
 901 {
 902 }
 903
 904 void FOTBuilder::setFillingDirection(Symbol)
 905 {
 906 }
 907
 908 void FOTBuilder::setWritingMode(Symbol)
 909 {
 910 }
 911
 912 void FOTBuilder::setLastLineQuadding(Symbol)
 913 {
 914 }
 915
 916 void FOTBuilder::setMathDisplayMode(Symbol)
 917 {
 918 }
 919
 920 void FOTBuilder::setScriptPreAlign(Symbol)
 921 {
 922 }
 923
 924 void FOTBuilder::setScriptPostAlign(Symbol)
 925 {
 926 }
 927
 928 void FOTBuilder::setScriptMidSupAlign(Symbol)
 929 {
 930 }
 931
 932 void FOTBuilder::setScriptMidSubAlign(Symbol)
 933 {
 934 }
 935
 936 void FOTBuilder::setNumeratorAlign(Symbol)
 937 {
 938 }
 939
 940 void FOTBuilder::setDenominatorAlign(Symbol)
 941 {
 942 }
 943
 944 void FOTBuilder::setGridPositionCellType(Symbol)
 945 {
 946 }
 947
 948 void FOTBuilder::setGridColumnAlignment(Symbol)
 949 {
 950 }
 951
 952 void FOTBuilder::setGridRowAlignment(Symbol)
 953 {
 954 }
 955
 956 void FOTBuilder::setBoxType(Symbol)
 957 {
 958 }
 959
 960 void FOTBuilder::setGlyphAlignmentMode(Symbol)
 961 {
 962 }
 963
 964 void FOTBuilder::setBoxBorderAlignment(Symbol)
 965 {
 966 }
 967
 968 void FOTBuilder::setCellRowAlignment(Symbol)
 969 {
 970 }
 971
 972 void FOTBuilder::setBorderAlignment(Symbol)
 973 {
 974 }
 975
 976 void FOTBuilder::setSidelineSide(Symbol)
 977 {
 978 }
 979
 980 void FOTBuilder::setHyphenationKeep(Symbol)
 981 {
 982 }
 983
 984 void FOTBuilder::setFontStructure(Symbol)
 985 {
 986 }
 987
 988 void FOTBuilder::setFontProportionateWidth(Symbol)
 989 {
 990 }
 991
 992 void FOTBuilder::setCellCrossed(Symbol)
 993 {
 994 }
 995
 996 void FOTBuilder::setMarginaliaSide(Symbol)
 997 {
 998 }
 999
1000 void FOTBuilder::setLayer(long)
1001 {
1002 }
1003
1004 void FOTBuilder::setBackgroundLayer(long)
1005 {
1006 }
1007
1008 void FOTBuilder::setBorderPriority(long)
1009 {
1010 }
1011
1012 void FOTBuilder::setLineRepeat(long)
1013 {
1014 }
1015
1016 void FOTBuilder::setSpan(long)
1017 {
1018 }
1019
1020 void FOTBuilder::setMinLeaderRepeat(long)
1021 {
1022 }
1023
1024 void FOTBuilder::setHyphenationRemainCharCount(long)
1025 {
1026 }
1027
1028 void FOTBuilder::setHyphenationPushCharCount(long)
1029 {
1030 }
1031
1032 void FOTBuilder::setWidowCount(long)
1033 {
1034 }
1035
1036 void FOTBuilder::setOrphanCount(long)
1037 {
1038 }
1039
1040 void FOTBuilder::setExpandTabs(long)
1041 {
1042 }
1043
1044 void FOTBuilder::setHyphenationLadderCount(long)
1045 {
1046 }
1047
1048 void FOTBuilder::setBackgroundTile(PublicId)
1049 {
1050 }
1051
1052 void FOTBuilder::setLineBreakingMethod(PublicId)
1053 {
1054 }
1055
1056 void FOTBuilder::setLineCompositionMethod(PublicId)
1057 {
1058 }
1059
1060 void FOTBuilder::setImplicitBidiMethod(PublicId)
1061 {
1062 }
1063
1064 void FOTBuilder::setGlyphSubstMethod(PublicId)
1065 {
1066 }
1067
1068 void FOTBuilder::setGlyphReorderMethod(PublicId)
1069 {
1070 }
1071
1072 void FOTBuilder::setHyphenationMethod(PublicId)
1073 {
1074 }
1075
1076 void FOTBuilder::setTableAutoWidthMethod(PublicId)
1077 {
1078 }
1079
1080 void FOTBuilder::setFontName(PublicId)
1081 {
1082 }
1083
1084 void FOTBuilder::setLanguage(Letter2)
1085 {
1086 }
1087
1088 void FOTBuilder::setCountry(Letter2)
1089 {
1090 }
1091
1092 void FOTBuilder::setEscapementSpaceBefore(const InlineSpace &)
1093 {
1094 }
1095
1096 void FOTBuilder::setEscapementSpaceAfter(const InlineSpace &)
1097 {
1098 }
1099
1100 void FOTBuilder::setInlineSpaceSpace(const OptInlineSpace &)
1101 {
1102 }
1103
1104 void FOTBuilder::setGlyphSubstTable(const Vector<ConstPtr<GlyphSubstTable> > &)
1105 {
1106 }
1107
1108 void FOTBuilder::startNode(const NodePtr &, const StringC &)
1109 {
1110 }
1111
1112 void FOTBuilder::endNode()
1113 {
1114 }
1115
1116 void FOTBuilder::currentNodePageNumber(const NodePtr &)
1117 {
1118 }
1119
1120 void FOTBuilder::extensionSet(void (FOTBuilder::*func)(bool), bool arg)
1121 {
1122   (this->*func)(arg);
1123 }
1124
1125 void FOTBuilder::extensionSet(void (FOTBuilder::*func)(const StringC &), const StringC &arg)
1126 {
1127   (this->*func)(arg);
1128 }
1129
1130 void FOTBuilder::extensionSet(void (FOTBuilder::*func)(long), long arg)
1131 {
1132   (this->*func)(arg);
1133 }
1134
1135
1136 FOTBuilder::DisplayNIC::DisplayNIC()
1137 : positionPreference(symbolFalse),
1138   keep(symbolFalse),
1139   breakBefore(symbolFalse),
1140   breakAfter(symbolFalse),
1141   keepWithPrevious(0),
1142   keepWithNext(0),
1143   mayViolateKeepBefore(0),
1144   mayViolateKeepAfter(0)
1145 {
1146 }
1147
1148 FOTBuilder::DisplayGroupNIC::DisplayGroupNIC()
1149 : hasCoalesceId(0)
1150 {
1151 }
1152
1153 FOTBuilder::InlineNIC::InlineNIC()
1154 : breakBeforePriority(0),
1155   breakAfterPriority(0)
1156 {
1157 }
1158
1159 FOTBuilder::ExternalGraphicNIC::ExternalGraphicNIC()
1160 : scaleType(symbolMaxUniform),
1161   isDisplay(0),
1162   hasMaxWidth(0),
1163   hasMaxHeight(0),
1164   escapementDirection(symbolFalse)
1165 {
1166 }
1167
1168 FOTBuilder::BoxNIC::BoxNIC()
1169 : isDisplay(0)
1170 {
1171 }
1172
1173 FOTBuilder::RuleNIC::RuleNIC()
1174 : orientation(symbolHorizontal),
1175   hasLength(0)
1176 {
1177 }
1178
1179 FOTBuilder::LeaderNIC::LeaderNIC()
1180 : hasLength(0)
1181 {
1182 }
1183
1184 FOTBuilder::CharacterNIC::CharacterNIC()
1185 : valid(0), specifiedC(0), stretchFactor(1.0)
1186 {
1187 }
1188
1189 FOTBuilder::TableNIC::TableNIC()
1190 : widthType(widthFull)
1191 {
1192 }
1193
1194 FOTBuilder::TableColumnNIC::TableColumnNIC()
1195 : columnIndex(0), nColumnsSpanned(1), hasWidth(0)
1196 {
1197 }
1198
1199 FOTBuilder::TableCellNIC::TableCellNIC()
1200 : columnIndex(0), nColumnsSpanned(1), nRowsSpanned(1), missing(0)
1201 {
1202 }
1203
1204 FOTBuilder::GridNIC::GridNIC()
1205 : nColumns(0), nRows(0)
1206 {
1207 }
1208
1209 FOTBuilder::GridCellNIC::GridCellNIC()
1210 : columnNumber(0), rowNumber(0)
1211 {
1212 }
1213
1214 FOTBuilder::MultiMode::MultiMode()
1215 : hasDesc(0)
1216 {
1217 }
1218
1219 FOTBuilder::GlyphId FOTBuilder::GlyphSubstTable::subst(const FOTBuilder::GlyphId &gid) const
1220 {
1221   for (size_t i = 0; i < pairs.size(); i += 2)
1222     if (gid == pairs[i])
1223       return pairs[i + 1];
1224   return gid;
1225 }
1226
1227 SaveFOTBuilder::SaveFOTBuilder()
1228 : calls_(0), tail_(&calls_)
1229 {
1230 }
1231
1232 SaveFOTBuilder::SaveFOTBuilder(const NodePtr &currentNode,
1233                                const StringC &processingMode)
1234 : currentNode_(currentNode),
1235   processingMode_(processingMode),
1236   calls_(0), tail_(&calls_)
1237 {
1238 }
1239
1240 SaveFOTBuilder::~SaveFOTBuilder()
1241 {
1242   *tail_ = 0;
1243   while (calls_) {
1244     Call *tem = calls_;
1245     calls_ = calls_->next;
1246     delete tem;
1247   }
1248 }
1249
1250 SaveFOTBuilder *SaveFOTBuilder::asSaveFOTBuilder()
1251 {
1252   return this;
1253 }
1254
1255 void SaveFOTBuilder::emit(FOTBuilder &fotb)
1256 {
1257   if (currentNode_)
1258     fotb.startNode(currentNode_, processingMode_);
1259   SaveFOTBuilder *save = fotb.asSaveFOTBuilder();
1260   if (save) {
1261     if (calls_) {
1262       *save->tail_ = calls_;
1263       save->tail_ = tail_;
1264       calls_ = 0;
1265       tail_ = &calls_;
1266     }
1267   }
1268   else {
1269     *tail_ = 0;
1270     while (calls_) {
1271       Call *tem = calls_;
1272       calls_ = calls_->next;
1273       tem->emit(fotb);
1274       delete tem;
1275     }
1276     tail_ = &calls_;
1277   }
1278   if (currentNode_)
1279     fotb.endNode();
1280 }
1281
1282 #define NO_ARG_CALL(F) \
1283   void SaveFOTBuilder::F() { \
1284     *tail_ = new NoArgCall(&FOTBuilder::F); \
1285      tail_ = &(*tail_)->next; }
1286
1287 NO_ARG_CALL(startSequence)
1288 NO_ARG_CALL(endSequence)
1289 NO_ARG_CALL(endLineField)
1290 NO_ARG_CALL(endParagraph)
1291 NO_ARG_CALL(endDisplayGroup)
1292 NO_ARG_CALL(alignmentPoint)
1293 NO_ARG_CALL(startScroll)
1294 NO_ARG_CALL(endScroll)
1295 NO_ARG_CALL(endLeader)
1296 NO_ARG_CALL(endLink)
1297 NO_ARG_CALL(startMarginalia)
1298 NO_ARG_CALL(endMarginalia)
1299 NO_ARG_CALL(endMultiMode)
1300 NO_ARG_CALL(endScore)
1301 NO_ARG_CALL(endBox)
1302 NO_ARG_CALL(startSideline)
1303 NO_ARG_CALL(endSideline)
1304 NO_ARG_CALL(endNode)
1305 NO_ARG_CALL(endSimplePageSequenceHeaderFooter)
1306 NO_ARG_CALL(endSimplePageSequence)
1307 NO_ARG_CALL(pageNumber)
1308 NO_ARG_CALL(endTable)
1309 NO_ARG_CALL(tableBeforeRowBorder)
1310 NO_ARG_CALL(tableAfterRowBorder)
1311 NO_ARG_CALL(tableBeforeColumnBorder)
1312 NO_ARG_CALL(tableAfterColumnBorder)
1313 NO_ARG_CALL(endTablePart)
1314 NO_ARG_CALL(startTableRow)
1315 NO_ARG_CALL(endTableRow)
1316 NO_ARG_CALL(endTableCell)
1317 NO_ARG_CALL(tableCellBeforeRowBorder)
1318 NO_ARG_CALL(tableCellAfterRowBorder)
1319 NO_ARG_CALL(tableCellBeforeColumnBorder)
1320 NO_ARG_CALL(tableCellAfterColumnBorder)
1321 NO_ARG_CALL(startMathSequence)
1322 NO_ARG_CALL(endMathSequence)
1323 NO_ARG_CALL(endFraction)
1324 NO_ARG_CALL(fractionBar)
1325 NO_ARG_CALL(startUnmath)
1326 NO_ARG_CALL(endUnmath)
1327 NO_ARG_CALL(startSuperscript)
1328 NO_ARG_CALL(endSuperscript)
1329 NO_ARG_CALL(startSubscript)
1330 NO_ARG_CALL(endSubscript)
1331 NO_ARG_CALL(endScript)
1332 NO_ARG_CALL(endMark)
1333 NO_ARG_CALL(endFence)
1334 NO_ARG_CALL(endRadical)
1335 NO_ARG_CALL(radicalRadicalDefaulted)
1336 NO_ARG_CALL(endMathOperator)
1337 NO_ARG_CALL(endGrid)
1338 NO_ARG_CALL(endGridCell)
1339
1340 #define LENGTH_SPEC_ARG_CALL(F) \
1341   void SaveFOTBuilder::F(const LengthSpec &lengthSpec) { \
1342     *tail_ = new LengthSpecArgCall(&FOTBuilder::F, lengthSpec); \
1343      tail_ = &(*tail_)->next; }
1344
1345 LENGTH_SPEC_ARG_CALL(setStartIndent)
1346 LENGTH_SPEC_ARG_CALL(setEndIndent)
1347 LENGTH_SPEC_ARG_CALL(setFirstLineStartIndent)
1348 LENGTH_SPEC_ARG_CALL(setLastLineEndIndent)
1349 LENGTH_SPEC_ARG_CALL(setLineSpacing)
1350 LENGTH_SPEC_ARG_CALL(setFieldWidth)
1351 LENGTH_SPEC_ARG_CALL(setPositionPointShift)
1352 LENGTH_SPEC_ARG_CALL(setStartMargin)
1353 LENGTH_SPEC_ARG_CALL(setEndMargin)
1354 LENGTH_SPEC_ARG_CALL(setSidelineSep)
1355 LENGTH_SPEC_ARG_CALL(setAsisWrapIndent)
1356 LENGTH_SPEC_ARG_CALL(setLineNumberSep)
1357 LENGTH_SPEC_ARG_CALL(setLastLineJustifyLimit)
1358 LENGTH_SPEC_ARG_CALL(setJustifyGlyphSpaceMaxAdd)
1359 LENGTH_SPEC_ARG_CALL(setJustifyGlyphSpaceMaxRemove)
1360 LENGTH_SPEC_ARG_CALL(setTableCornerRadius)
1361 LENGTH_SPEC_ARG_CALL(setBoxCornerRadius)
1362 LENGTH_SPEC_ARG_CALL(setMarginaliaSep)
1363
1364 #define OPT_LENGTH_SPEC_ARG_CALL(F) \
1365   void SaveFOTBuilder::F(const OptLengthSpec &optLengthSpec) { \
1366     *tail_ = new OptLengthSpecArgCall(&FOTBuilder::F, optLengthSpec); \
1367      tail_ = &(*tail_)->next; }
1368
1369 OPT_LENGTH_SPEC_ARG_CALL(setMinPreLineSpacing)
1370 OPT_LENGTH_SPEC_ARG_CALL(setMinPostLineSpacing)
1371 OPT_LENGTH_SPEC_ARG_CALL(setMinLeading)
1372
1373 #define LONG_ARG_CALL(F) \
1374   void SaveFOTBuilder::F(long n) { \
1375     *tail_ = new LongArgCall(&FOTBuilder::F, n); \
1376      tail_ = &(*tail_)->next; }
1377
1378
1379 LONG_ARG_CALL(setFontSize)
1380 LONG_ARG_CALL(setPageWidth)
1381 LONG_ARG_CALL(setPageHeight)
1382 LONG_ARG_CALL(setLeftMargin)
1383 LONG_ARG_CALL(setRightMargin)
1384 LONG_ARG_CALL(setTopMargin)
1385 LONG_ARG_CALL(setBottomMargin)
1386 LONG_ARG_CALL(setHeaderMargin)
1387 LONG_ARG_CALL(setFooterMargin)
1388 LONG_ARG_CALL(setLineThickness)
1389 LONG_ARG_CALL(setCellBeforeRowMargin)
1390 LONG_ARG_CALL(setCellAfterRowMargin)
1391 LONG_ARG_CALL(setCellBeforeColumnMargin)
1392 LONG_ARG_CALL(setCellAfterColumnMargin)
1393 LONG_ARG_CALL(setLineSep)
1394 LONG_ARG_CALL(setBoxSizeBefore)
1395 LONG_ARG_CALL(setBoxSizeAfter)
1396 LONG_ARG_CALL(setLayer)
1397 LONG_ARG_CALL(setBackgroundLayer)
1398 LONG_ARG_CALL(setBorderPriority)
1399 LONG_ARG_CALL(setLineRepeat)
1400 LONG_ARG_CALL(setSpan)
1401 LONG_ARG_CALL(setMinLeaderRepeat)
1402 LONG_ARG_CALL(setHyphenationRemainCharCount)
1403 LONG_ARG_CALL(setHyphenationPushCharCount)
1404 LONG_ARG_CALL(setWidowCount)
1405 LONG_ARG_CALL(setOrphanCount)
1406 LONG_ARG_CALL(setExpandTabs)
1407 LONG_ARG_CALL(setHyphenationLadderCount)
1408
1409 #define BOOL_ARG_CALL(F) \
1410   void SaveFOTBuilder::F(bool b) { \
1411     *tail_ = new BoolArgCall(&FOTBuilder::F, b); \
1412      tail_ = &(*tail_)->next; }
1413
1414 BOOL_ARG_CALL(setBorderPresent)
1415 BOOL_ARG_CALL(setInhibitLineBreaks)
1416 BOOL_ARG_CALL(setHyphenate)
1417 BOOL_ARG_CALL(setKern)
1418 BOOL_ARG_CALL(setLigature)
1419 BOOL_ARG_CALL(setScoreSpaces)
1420 BOOL_ARG_CALL(setFloatOutMarginalia)
1421 BOOL_ARG_CALL(setFloatOutSidelines)
1422 BOOL_ARG_CALL(setFloatOutLineNumbers)
1423 BOOL_ARG_CALL(setCellBackground)
1424 BOOL_ARG_CALL(setSpanWeak)
1425 BOOL_ARG_CALL(setIgnoreRecordEnd)
1426 BOOL_ARG_CALL(setNumberedLines)
1427 BOOL_ARG_CALL(setHangingPunct)
1428 BOOL_ARG_CALL(setBoxOpenEnd)
1429 BOOL_ARG_CALL(setTruncateLeader)
1430 BOOL_ARG_CALL(setAlignLeader)
1431 BOOL_ARG_CALL(setTablePartOmitMiddleHeader)
1432 BOOL_ARG_CALL(setTablePartOmitMiddleFooter)
1433 BOOL_ARG_CALL(setBorderOmitAtBreak)
1434 BOOL_ARG_CALL(setPrincipalModeSimultaneous)
1435 BOOL_ARG_CALL(setMarginaliaKeepWithPrevious)
1436 BOOL_ARG_CALL(setGridEquidistantRows)
1437 BOOL_ARG_CALL(setGridEquidistantColumns)
1438
1439 #define SYMBOL_ARG_CALL(F) \
1440   void SaveFOTBuilder::F(Symbol sym) { \
1441     *tail_ = new SymbolArgCall(&FOTBuilder::F, sym); \
1442      tail_ = &(*tail_)->next; }
1443
1444 SYMBOL_ARG_CALL(setFontWeight)
1445 SYMBOL_ARG_CALL(setFontPosture)
1446 SYMBOL_ARG_CALL(setLines)
1447 SYMBOL_ARG_CALL(setQuadding)
1448 SYMBOL_ARG_CALL(setDisplayAlignment)
1449 SYMBOL_ARG_CALL(setFieldAlign)
1450 SYMBOL_ARG_CALL(setLineJoin)
1451 SYMBOL_ARG_CALL(setLineCap)
1452 SYMBOL_ARG_CALL(setLineNumberSide)
1453 SYMBOL_ARG_CALL(setKernMode)
1454 SYMBOL_ARG_CALL(setInputWhitespaceTreatment)
1455 SYMBOL_ARG_CALL(setFillingDirection)
1456 SYMBOL_ARG_CALL(setWritingMode)
1457 SYMBOL_ARG_CALL(setLastLineQuadding)
1458 SYMBOL_ARG_CALL(setMathDisplayMode)
1459 SYMBOL_ARG_CALL(setScriptPreAlign)
1460 SYMBOL_ARG_CALL(setScriptPostAlign)
1461 SYMBOL_ARG_CALL(setScriptMidSupAlign)
1462 SYMBOL_ARG_CALL(setScriptMidSubAlign)
1463 SYMBOL_ARG_CALL(setNumeratorAlign)
1464 SYMBOL_ARG_CALL(setDenominatorAlign)
1465 SYMBOL_ARG_CALL(setGridPositionCellType)
1466 SYMBOL_ARG_CALL(setGridColumnAlignment)
1467 SYMBOL_ARG_CALL(setGridRowAlignment)
1468 SYMBOL_ARG_CALL(setBoxType)
1469 SYMBOL_ARG_CALL(setGlyphAlignmentMode)
1470 SYMBOL_ARG_CALL(setBoxBorderAlignment)
1471 SYMBOL_ARG_CALL(setCellRowAlignment)
1472 SYMBOL_ARG_CALL(setBorderAlignment)
1473 SYMBOL_ARG_CALL(setSidelineSide)
1474 SYMBOL_ARG_CALL(setHyphenationKeep)
1475 SYMBOL_ARG_CALL(setFontStructure)
1476 SYMBOL_ARG_CALL(setFontProportionateWidth)
1477 SYMBOL_ARG_CALL(setCellCrossed)
1478 SYMBOL_ARG_CALL(setMarginaliaSide)
1479
1480 #define PUBLIC_ID_ARG_CALL(F) \
1481   void SaveFOTBuilder::F(PublicId pubid) { \
1482     *tail_ = new PublicIdArgCall(&FOTBuilder::F, pubid); \
1483      tail_ = &(*tail_)->next; }
1484
1485 PUBLIC_ID_ARG_CALL(setBackgroundTile)
1486 PUBLIC_ID_ARG_CALL(setLineBreakingMethod)
1487 PUBLIC_ID_ARG_CALL(setLineCompositionMethod)
1488 PUBLIC_ID_ARG_CALL(setImplicitBidiMethod)
1489 PUBLIC_ID_ARG_CALL(setGlyphSubstMethod)
1490 PUBLIC_ID_ARG_CALL(setGlyphReorderMethod)
1491 PUBLIC_ID_ARG_CALL(setHyphenationMethod)
1492 PUBLIC_ID_ARG_CALL(setTableAutoWidthMethod)
1493 PUBLIC_ID_ARG_CALL(setFontName)
1494
1495 #define UNSIGNED_ARG_CALL(F) \
1496   void SaveFOTBuilder::F(unsigned n) { \
1497     *tail_ = new UnsignedArgCall(&FOTBuilder::F, n); \
1498      tail_ = &(*tail_)->next; }
1499
1500 UNSIGNED_ARG_CALL(setLanguage)
1501 UNSIGNED_ARG_CALL(setCountry)
1502
1503 #define STRING_ARG_CALL(F) \
1504   void SaveFOTBuilder::F(const StringC &str) { \
1505     *tail_ = new StringArgCall(&FOTBuilder::F, str); \
1506      tail_ = &(*tail_)->next; }
1507
1508
1509 STRING_ARG_CALL(setFontFamilyName)
1510 STRING_ARG_CALL(formattingInstruction)
1511
1512 #define INLINE_SPACE_ARG_CALL(F) \
1513   void SaveFOTBuilder::F(const InlineSpace &is) { \
1514     *tail_ = new InlineSpaceArgCall(&FOTBuilder::F, is); \
1515      tail_ = &(*tail_)->next; }
1516
1517 INLINE_SPACE_ARG_CALL(setEscapementSpaceBefore)
1518 INLINE_SPACE_ARG_CALL(setEscapementSpaceAfter)
1519
1520 SaveFOTBuilder::Call::~Call()
1521 {
1522 }
1523
1524 void SaveFOTBuilder::NoArgCall::emit(FOTBuilder &fotb)
1525 {
1526   (fotb.*func)();
1527 }
1528
1529 void SaveFOTBuilder::LongArgCall::emit(FOTBuilder &fotb)
1530 {
1531   (fotb.*func)(arg);
1532 }
1533
1534 void SaveFOTBuilder::ExtensionLongArgCall::emit(FOTBuilder &fotb)
1535 {
1536   fotb.extensionSet(func, arg);
1537 }
1538
1539 void SaveFOTBuilder::BoolArgCall::emit(FOTBuilder &fotb)
1540 {
1541   (fotb.*func)(arg);
1542 }
1543
1544 void SaveFOTBuilder::ExtensionBoolArgCall::emit(FOTBuilder &fotb)
1545 {
1546   fotb.extensionSet(func, arg);
1547 }
1548
1549 void SaveFOTBuilder::SymbolArgCall::emit(FOTBuilder &fotb)
1550 {
1551   (fotb.*func)(arg);
1552 }
1553
1554 void SaveFOTBuilder::PublicIdArgCall::emit(FOTBuilder &fotb)
1555 {
1556   (fotb.*func)(arg);
1557 }
1558
1559 void SaveFOTBuilder::UnsignedArgCall::emit(FOTBuilder &fotb)
1560 {
1561   (fotb.*func)(arg);
1562 }
1563
1564 void SaveFOTBuilder::InlineSpaceArgCall::emit(FOTBuilder &fotb)
1565 {
1566   (fotb.*func)(arg);
1567 }
1568
1569 void SaveFOTBuilder::StringArgCall::emit(FOTBuilder &fotb)
1570 {
1571   (fotb.*func)(arg);
1572 }
1573
1574 void SaveFOTBuilder::ExtensionStringArgCall::emit(FOTBuilder &fotb)
1575 {
1576   fotb.extensionSet(func, arg);
1577 }
1578
1579 void SaveFOTBuilder::CharArgCall::emit(FOTBuilder &fotb)
1580 {
1581   (fotb.*func)(arg);
1582 }
1583
1584 void SaveFOTBuilder::LengthSpecArgCall::emit(FOTBuilder &fotb)
1585 {
1586   (fotb.*func)(arg);
1587 }
1588
1589 void SaveFOTBuilder::OptLengthSpecArgCall::emit(FOTBuilder &fotb)
1590 {
1591   (fotb.*func)(arg);
1592 }
1593
1594 void SaveFOTBuilder::NodePtrArgCall::emit(FOTBuilder &fotb)
1595 {
1596   (fotb.*func)(arg);
1597 }
1598
1599 void SaveFOTBuilder::DeviceRGBColorArgCall::emit(FOTBuilder &fotb)
1600 {
1601   (fotb.*func)(arg);
1602 }
1603
1604 void SaveFOTBuilder::charactersFromNode(const NodePtr &node, const Char *s, size_t n)
1605 {
1606   *tail_ = new CharactersFromNodeCall(node, s, n);
1607   tail_ = &(*tail_)->next;
1608 }
1609
1610 SaveFOTBuilder::CharactersFromNodeCall::CharactersFromNodeCall(const NodePtr &nd,
1611                                                                const Char *s, size_t n)
1612   : data(s), size(n), node(nd)
1613 {
1614 }
1615
1616 void SaveFOTBuilder::CharactersFromNodeCall::emit(FOTBuilder &fotb)
1617 {
1618   fotb.charactersFromNode(node, data, size);
1619 }
1620
1621 void SaveFOTBuilder::characters(const Char *s, size_t n)
1622 {
1623   *tail_ = new CharactersCall(s, n);
1624   tail_ = &(*tail_)->next;
1625 }
1626
1627 void SaveFOTBuilder::CharacterCall::emit(FOTBuilder &fotb)
1628 {
1629   fotb.character(arg);
1630 }
1631
1632 void SaveFOTBuilder::character(const CharacterNIC &nic)
1633 {
1634   *tail_ = new CharacterCall(nic);
1635   tail_ = &(*tail_)->next;
1636 }
1637
1638 SaveFOTBuilder::StartNodeCall::StartNodeCall(const NodePtr &nd,
1639                                              const StringC &m)
1640 : node(nd), mode(m)
1641 {
1642 }
1643
1644 void SaveFOTBuilder::StartNodeCall::emit(FOTBuilder &fotb)
1645 {
1646   fotb.startNode(node, mode);
1647 }
1648
1649 void SaveFOTBuilder::startNode(const NodePtr &node, const StringC &mode)
1650 {
1651   *tail_ = new StartNodeCall(node, mode);
1652   tail_ = &(*tail_)->next;
1653 }
1654
1655 void SaveFOTBuilder::currentNodePageNumber(const NodePtr &node)
1656 {
1657   *tail_ = new NodePtrArgCall(&FOTBuilder::currentNodePageNumber, node);
1658   tail_ = &(*tail_)->next;
1659 }
1660
1661 void SaveFOTBuilder::setColor(const DeviceRGBColor &color)
1662 {
1663   *tail_ = new DeviceRGBColorArgCall(&FOTBuilder::setColor, color);
1664   tail_ = &(*tail_)->next;
1665 }
1666
1667 void SaveFOTBuilder::setBackgroundColor(const DeviceRGBColor &color)
1668 {
1669   DeviceRGBColorArgCall::FuncPtr f = &FOTBuilder::setBackgroundColor;
1670   *tail_ = new DeviceRGBColorArgCall(f, color);
1671   tail_ = &(*tail_)->next;
1672 }
1673
1674 void SaveFOTBuilder::setBackgroundColor()
1675 {
1676   NoArgCall::FuncPtr f = &FOTBuilder::setBackgroundColor;
1677   *tail_ = new NoArgCall(f);
1678   tail_ = &(*tail_)->next;
1679 }
1680
1681 void SaveFOTBuilder::startParagraph(const ParagraphNIC &nic)
1682
1683 {
1684   *tail_ = new StartParagraphCall(nic);
1685   tail_ = &(*tail_)->next;
1686 }
1687
1688 void SaveFOTBuilder::paragraphBreak(const ParagraphNIC &nic)
1689
1690 {
1691   *tail_ = new ParagraphBreakCall(nic);
1692   tail_ = &(*tail_)->next;
1693 }
1694
1695 void SaveFOTBuilder::startDisplayGroup(const DisplayGroupNIC &nic)
1696 {
1697   *tail_ = new StartDisplayGroupCall(nic);
1698   tail_ = &(*tail_)->next;
1699 }
1700
1701 void SaveFOTBuilder::externalGraphic(const ExternalGraphicNIC &nic)
1702 {
1703   *tail_ = new ExternalGraphicCall(nic);
1704   tail_ = &(*tail_)->next;
1705 }
1706
1707 void SaveFOTBuilder::rule(const RuleNIC &nic)
1708 {
1709   *tail_ = new RuleCall(nic);
1710   tail_ = &(*tail_)->next;
1711 }
1712
1713 void SaveFOTBuilder::startLeader(const LeaderNIC &nic)
1714 {
1715   *tail_ = new StartLeaderCall(nic);
1716   tail_ = &(*tail_)->next;
1717 }
1718
1719 void SaveFOTBuilder::startLink(const Address &addr)
1720 {
1721   *tail_ = new StartLinkCall(addr);
1722   tail_ = &(*tail_)->next;
1723 }
1724
1725 void SaveFOTBuilder::startScore(Symbol type)
1726 {
1727   SymbolArgCall::FuncPtr func = &FOTBuilder::startScore;
1728   *tail_ = new SymbolArgCall(func, type);
1729   tail_ = &(*tail_)->next;
1730 }
1731
1732 void SaveFOTBuilder::startScore(Char c)
1733 {
1734   CharArgCall::FuncPtr func = &FOTBuilder::startScore;
1735   *tail_ = new CharArgCall(func, c);
1736   tail_ = &(*tail_)->next;
1737 }
1738
1739 void SaveFOTBuilder::startScore(const LengthSpec &len)
1740 {
1741   LengthSpecArgCall::FuncPtr func = &FOTBuilder::startScore;
1742   *tail_ = new LengthSpecArgCall(func, len);
1743   tail_ = &(*tail_)->next;
1744 }
1745
1746 void SaveFOTBuilder::startLineField(const LineFieldNIC &nic)
1747 {
1748   *tail_ = new StartLineFieldCall(nic);
1749   tail_ = &(*tail_)->next;
1750 }
1751
1752 void SaveFOTBuilder::startBox(const BoxNIC &nic)
1753 {
1754   *tail_ = new StartBoxCall(nic);
1755   tail_ = &(*tail_)->next;
1756 }
1757
1758 void SaveFOTBuilder::startSimplePageSequence(FOTBuilder* headerFooter[nHF])
1759 {
1760   *tail_ = new StartSimplePageSequenceCall(headerFooter);
1761   tail_ = &(*tail_)->next;
1762 }
1763
1764 void SaveFOTBuilder::startTable(const TableNIC &nic)
1765 {
1766   *tail_ = new StartTableCall(nic);
1767   tail_ = &(*tail_)->next;
1768 }
1769
1770 void SaveFOTBuilder::startTablePart(const TablePartNIC &nic, FOTBuilder *&header, FOTBuilder *&footer)
1771 {
1772   *tail_ = new StartTablePartCall(nic, header, footer);
1773   tail_ = &(*tail_)->next;
1774 }
1775
1776 void SaveFOTBuilder::tableColumn(const TableColumnNIC &nic)
1777 {
1778   *tail_ = new TableColumnCall(nic);
1779   tail_ = &(*tail_)->next;
1780 }
1781
1782 void SaveFOTBuilder::startTableCell(const TableCellNIC &nic)
1783 {
1784   *tail_ = new StartTableCellCall(nic);
1785   tail_ = &(*tail_)->next;
1786 }
1787
1788 void SaveFOTBuilder::startFraction(FOTBuilder *&numerator, FOTBuilder *&denominator)
1789 {
1790   *tail_ = new StartFractionCall(numerator, denominator);
1791   tail_ = &(*tail_)->next;
1792 }
1793
1794 void SaveFOTBuilder::startScript(FOTBuilder *&preSup,
1795                                  FOTBuilder *&preSub,
1796                                  FOTBuilder *&postSup,
1797                                  FOTBuilder *&postSub,
1798                                  FOTBuilder *&midSup,
1799                                  FOTBuilder *&midSub)
1800 {
1801   *tail_ = new StartScriptCall(preSup, preSub,
1802                                postSup, postSub,
1803                                midSup, midSub);
1804   tail_ = &(*tail_)->next;
1805 }
1806
1807 void SaveFOTBuilder::startMark(FOTBuilder *&overMark, FOTBuilder *&underMark)
1808 {
1809   *tail_ = new StartMarkCall(overMark, underMark);
1810   tail_ = &(*tail_)->next;
1811 }
1812
1813 void SaveFOTBuilder::startFence(FOTBuilder *&open, FOTBuilder *&close)
1814 {
1815   *tail_ = new StartFenceCall(open, close);
1816   tail_ = &(*tail_)->next;
1817 }
1818
1819 void SaveFOTBuilder::startRadical(FOTBuilder *&degree)
1820 {
1821   *tail_ = new StartRadicalCall(degree);
1822   tail_ = &(*tail_)->next;
1823 }
1824
1825 void SaveFOTBuilder::radicalRadical(const CharacterNIC &nic)
1826 {
1827   *tail_ = new RadicalRadicalCall(nic);
1828   tail_ = &(*tail_)->next;
1829 }
1830
1831 void SaveFOTBuilder::startMathOperator(FOTBuilder *&oper,
1832                                        FOTBuilder *&lowerLimit,
1833                                        FOTBuilder *&upperLimit)
1834 {
1835   *tail_ = new StartMathOperatorCall(oper, lowerLimit, upperLimit);
1836   tail_ = &(*tail_)->next;
1837 }
1838
1839 void SaveFOTBuilder::startGrid(const GridNIC &nic)
1840 {
1841   *tail_ = new StartGridCall(nic);
1842   tail_ = &(*tail_)->next;
1843 }
1844
1845 void SaveFOTBuilder::startGridCell(const GridCellNIC &nic)
1846 {
1847   *tail_ = new StartGridCellCall(nic);
1848   tail_ = &(*tail_)->next;
1849 }
1850
1851 void SaveFOTBuilder::startMultiMode(const MultiMode *principalMode,
1852                                     const Vector<MultiMode> &namedModes,
1853                                     Vector<FOTBuilder *> &namedPorts)
1854 {
1855   *tail_ = new StartMultiModeCall(principalMode, namedModes, namedPorts);
1856   tail_ = &(*tail_)->next;
1857 }
1858
1859 void SaveFOTBuilder::setGlyphSubstTable(const Vector<ConstPtr<GlyphSubstTable> > &tables)
1860 {
1861   *tail_ = new SetGlyphSubstTableCall(tables);
1862   tail_ = &(*tail_)->next;
1863 }
1864
1865 void SaveFOTBuilder::extensionSet(void (FOTBuilder::*func)(bool), bool arg)
1866 {
1867   *tail_ = new ExtensionBoolArgCall(func, arg);
1868   tail_ = &(*tail_)->next;
1869 }
1870
1871 void SaveFOTBuilder::extensionSet(void (FOTBuilder::*func)(const StringC &), const StringC &arg)
1872 {
1873   *tail_ = new ExtensionStringArgCall(func, arg);
1874   tail_ = &(*tail_)->next;
1875 }
1876
1877 void SaveFOTBuilder::extensionSet(void (FOTBuilder::*func)(long), long arg)
1878 {
1879   *tail_ = new ExtensionLongArgCall(func, arg);
1880   tail_ = &(*tail_)->next;
1881 }
1882
1883 void SaveFOTBuilder::startExtension(const CompoundExtensionFlowObj &fo,
1884                                     const NodePtr &node,
1885                                     Vector<FOTBuilder *> &ports)
1886 {
1887   *tail_ = new StartExtensionCall(fo, node, ports);
1888   tail_ = &(*tail_)->next;
1889 }
1890
1891 void SaveFOTBuilder::endExtension(const CompoundExtensionFlowObj &fo)
1892 {
1893   *tail_ = new EndExtensionCall(fo);
1894   tail_ = &(*tail_)->next;
1895 }
1896
1897 void SaveFOTBuilder::extension(const ExtensionFlowObj &fo, const NodePtr &node)
1898 {
1899   *tail_ = new ExtensionCall(fo, node);
1900   tail_ = &(*tail_)->next;
1901 }
1902
1903 SaveFOTBuilder::CharactersCall::CharactersCall(const Char *s, size_t n)
1904 : str(s, n)
1905 {
1906 }
1907
1908 void SaveFOTBuilder::CharactersCall::emit(FOTBuilder &fotb)
1909 {
1910   fotb.characters(str.data(), str.size());
1911 }
1912
1913 StartSimplePageSequenceCall::StartSimplePageSequenceCall(FOTBuilder* hf[FOTBuilder::nHF])
1914 {
1915   for ( unsigned i = 0; i < FOTBuilder::nHF; ++i )
1916     hf[i] = &headerFooter[i];
1917 }
1918
1919 void StartSimplePageSequenceCall::emit(FOTBuilder& fotb)
1920 {
1921   FOTBuilder* hf[FOTBuilder::nHF];
1922   fotb.startSimplePageSequence(hf);
1923   for ( unsigned i = 0; i < FOTBuilder::nHF; ++i )
1924     headerFooter[i].emit(*hf[i]);
1925 }
1926
1927 StartFractionCall::StartFractionCall(FOTBuilder *&n, FOTBuilder *&d)
1928 {
1929   n = &numerator;
1930   d = &denominator;
1931 }
1932
1933 void StartFractionCall::emit(FOTBuilder &fotb)
1934 {
1935   FOTBuilder *n, *d;
1936   fotb.startFraction(n, d);
1937   numerator.emit(*n);
1938   denominator.emit(*d);
1939 }
1940
1941 StartScriptCall::StartScriptCall(FOTBuilder *&p0,
1942                                  FOTBuilder *&p1,
1943                                  FOTBuilder *&p2,
1944                                  FOTBuilder *&p3,
1945                                  FOTBuilder *&p4,
1946                                  FOTBuilder *&p5)
1947 {
1948   p0 = &preSup;
1949   p1 = &preSub;
1950   p2 = &postSup;
1951   p3 = &postSub;
1952   p4 = &midSup;
1953   p5 = &midSub;
1954 }
1955
1956 void StartScriptCall::emit(FOTBuilder &fotb)
1957 {
1958   FOTBuilder *v[6];
1959   fotb.startScript(v[0], v[1], v[2], v[3], v[4], v[5]);
1960   preSup.emit(*v[0]);
1961   preSub.emit(*v[1]);
1962   postSup.emit(*v[2]);
1963   postSub.emit(*v[3]);
1964   midSup.emit(*v[4]);
1965   midSub.emit(*v[5]);
1966 }
1967
1968 StartMarkCall::StartMarkCall(FOTBuilder *&o, FOTBuilder *&u)
1969 {
1970   o = &overMark;
1971   u = &underMark;
1972 }
1973
1974 void StartMarkCall::emit(FOTBuilder &fotb)
1975 {
1976   FOTBuilder *o, *u;
1977   fotb.startMark(o, u);
1978   overMark.emit(*o);
1979   underMark.emit(*u);
1980 }
1981
1982 StartFenceCall::StartFenceCall(FOTBuilder *&o, FOTBuilder *&c)
1983 {
1984   o = &open;
1985   c = &close;
1986 }
1987
1988 void StartFenceCall::emit(FOTBuilder &fotb)
1989 {
1990   FOTBuilder *o, *c;
1991   fotb.startFence(o, c);
1992   open.emit(*o);
1993   close.emit(*c);
1994 }
1995
1996 StartRadicalCall::StartRadicalCall(FOTBuilder *&d)
1997 {
1998   d = &degree;
1999 }
2000
2001 void StartRadicalCall::emit(FOTBuilder &fotb)
2002 {
2003   FOTBuilder *d;
2004   fotb.startRadical(d);
2005   degree.emit(*d);
2006 }
2007
2008 StartMathOperatorCall::StartMathOperatorCall(FOTBuilder *&o,
2009                                              FOTBuilder *&l,
2010                                              FOTBuilder *&u)
2011 {
2012   o = &oper;
2013   l = &lowerLimit;
2014   u = &upperLimit;
2015 }
2016
2017 void StartMathOperatorCall::emit(FOTBuilder &fotb)
2018 {
2019   FOTBuilder *o, *l, *u;
2020   fotb.startMathOperator(o, l, u);
2021   oper.emit(*o);
2022   lowerLimit.emit(*l);
2023   upperLimit.emit(*u);
2024 }
2025
2026 StartMultiModeCall::StartMultiModeCall(const FOTBuilder::MultiMode *pm,
2027                                        const Vector<FOTBuilder::MultiMode> &nm,
2028                                        Vector<FOTBuilder *> &v)
2029 : namedModes(nm)
2030 {
2031   if (pm) {
2032     hasPrincipalMode = 1;
2033     principalMode = *pm;
2034   }
2035   else
2036     hasPrincipalMode = 0;
2037   for (size_t i = v.size(); i > 0; i--) {
2038     ports.insert(new SaveFOTBuilder);
2039     v[i - 1] = ports.head();
2040   }
2041 }
2042
2043 void StartMultiModeCall::emit(FOTBuilder &fotb)
2044 {
2045   Vector<FOTBuilder *> v(namedModes.size());
2046   fotb.startMultiMode(hasPrincipalMode ? &principalMode : 0, namedModes, v);
2047   for (size_t i = 0; i < v.size(); i++) {
2048     Owner<SaveFOTBuilder> tem(ports.get());
2049     tem->emit(*v[i]);
2050   }
2051 }
2052
2053 void SaveFOTBuilder::StartTableCall::emit(FOTBuilder &fotb)
2054 {
2055   fotb.startTable(arg);
2056 }
2057
2058 void SaveFOTBuilder::TableColumnCall::emit(FOTBuilder &fotb)
2059 {
2060   fotb.tableColumn(arg);
2061 }
2062
2063 void SaveFOTBuilder::StartTableCellCall::emit(FOTBuilder &fotb)
2064 {
2065   fotb.startTableCell(arg);
2066 }
2067
2068 StartTablePartCall::StartTablePartCall(const SaveFOTBuilder::TablePartNIC &nic,
2069                                        FOTBuilder *&h, FOTBuilder *&f)
2070 : arg(nic)
2071 {
2072   h = &header;
2073   f = &footer;
2074 }
2075
2076 void StartTablePartCall::emit(FOTBuilder &fotb)
2077 {
2078   FOTBuilder *h, *f;
2079   fotb.startTablePart(arg, h, f);
2080   header.emit(*h);
2081   footer.emit(*f);
2082 }
2083
2084 SaveFOTBuilder::StartParagraphCall::StartParagraphCall(const ParagraphNIC &nic)
2085 : arg(nic)
2086 {
2087 }
2088
2089 void SaveFOTBuilder::StartParagraphCall::emit(FOTBuilder &fotb)
2090 {
2091   fotb.startParagraph(arg);
2092 }
2093
2094 SaveFOTBuilder::ParagraphBreakCall::ParagraphBreakCall(const ParagraphNIC &nic)
2095 : arg(nic)
2096 {
2097 }
2098
2099 void SaveFOTBuilder::ParagraphBreakCall::emit(FOTBuilder &fotb)
2100 {
2101   fotb.paragraphBreak(arg);
2102 }
2103
2104 SaveFOTBuilder
2105 ::StartDisplayGroupCall::StartDisplayGroupCall(const DisplayGroupNIC &nic)
2106 : arg(nic)
2107 {
2108 }
2109
2110 void SaveFOTBuilder::StartDisplayGroupCall::emit(FOTBuilder &fotb)
2111 {
2112   fotb.startDisplayGroup(arg);
2113 }
2114
2115 void SaveFOTBuilder::ExternalGraphicCall::emit(FOTBuilder &fotb)
2116 {
2117   fotb.externalGraphic(arg);
2118 }
2119
2120 void SaveFOTBuilder::RuleCall::emit(FOTBuilder &fotb)
2121 {
2122   fotb.rule(arg);
2123 }
2124
2125 void SaveFOTBuilder::StartLeaderCall::emit(FOTBuilder &fotb)
2126 {
2127   fotb.startLeader(arg);
2128 }
2129
2130 void SaveFOTBuilder::StartBoxCall::emit(FOTBuilder &fotb)
2131 {
2132   fotb.startBox(arg);
2133 }
2134
2135 void SaveFOTBuilder::StartLineFieldCall::emit(FOTBuilder &fotb)
2136 {
2137   fotb.startLineField(arg);
2138 }
2139
2140 void SaveFOTBuilder::StartLinkCall::emit(FOTBuilder &fotb)
2141 {
2142   fotb.startLink(arg);
2143 }
2144
2145 void SaveFOTBuilder::SetGlyphSubstTableCall::emit(FOTBuilder &fotb)
2146 {
2147   fotb.setGlyphSubstTable(arg);
2148 }
2149
2150 void SaveFOTBuilder::StartGridCall::emit(FOTBuilder &fotb)
2151 {
2152   fotb.startGrid(arg);
2153 }
2154
2155 void SaveFOTBuilder::StartGridCellCall::emit(FOTBuilder &fotb)
2156 {
2157   fotb.startGridCell(arg);
2158 }
2159
2160 void SaveFOTBuilder::RadicalRadicalCall::emit(FOTBuilder &fotb)
2161 {
2162   fotb.radicalRadical(arg);
2163 }
2164
2165 void SaveFOTBuilder::ExtensionCall::emit(FOTBuilder &fotb)
2166 {
2167   fotb.extension(*arg, node);
2168 }
2169
2170 void SaveFOTBuilder::EndExtensionCall::emit(FOTBuilder &fotb)
2171 {
2172   fotb.endExtension(*arg);
2173 }
2174
2175 StartExtensionCall::StartExtensionCall(const FOTBuilder::CompoundExtensionFlowObj &fo,
2176                                        const NodePtr &nd,
2177                                        Vector<FOTBuilder *> &v)
2178 : flowObj(fo.copy()->asCompoundExtensionFlowObj()), node(nd)
2179 {
2180   for (size_t i = v.size(); i > 0; i--) {
2181     ports.insert(new SaveFOTBuilder);
2182     v[i - 1] = ports.head();
2183   }
2184 }
2185
2186 void StartExtensionCall::emit(FOTBuilder &fotb)
2187 {
2188   Vector<StringC> portNames;
2189   flowObj->portNames(portNames);
2190   Vector<FOTBuilder *> v(portNames.size());
2191   fotb.startExtension(*flowObj, node, v);
2192   for (size_t i = 0; i < v.size(); i++) {
2193     Owner<SaveFOTBuilder> tem(ports.get());
2194     tem->emit(*v[i]);
2195   }
2196 }
2197
2198 SerialFOTBuilder::SerialFOTBuilder()
2199 {
2200 }
2201
2202 void SerialFOTBuilder::startSimplePageSequence(FOTBuilder* headerFooter[FOTBuilder::nHF])
2203 {
2204   for ( unsigned i = 0; i < nHF; ++i ) {
2205     save_.insert(new SaveFOTBuilder);
2206     headerFooter[nHF-1-i] = save_.head();
2207   }
2208   startSimplePageSequenceSerial();
2209 }
2210
2211 void SerialFOTBuilder::endSimplePageSequenceHeaderFooter()
2212 {
2213   Owner<SaveFOTBuilder> hf[nHF];
2214   for ( unsigned k = 0; k < nHF; ++k )
2215     hf[k] = save_.get();
2216   // output all 24 parts, but in same order as 1.2.1, for regression testing
2217   // replace with single loop later.
2218   // sorry about all those constants :(
2219   for (int i = 0; i < (1 << 2); i++) {
2220     for (int j = 0; j < 6; j++) {
2221       unsigned k = i | (j << 2);
2222       startSimplePageSequenceHeaderFooter(k);
2223       hf[k]->emit(*this);
2224       endSimplePageSequenceHeaderFooter(k);
2225     }
2226   }
2227   endAllSimplePageSequenceHeaderFooter();
2228 }
2229
2230 void SerialFOTBuilder::endSimplePageSequence()
2231 {
2232   endSimplePageSequenceSerial();
2233 }
2234
2235
2236 void SerialFOTBuilder::startFraction(FOTBuilder *&numerator, FOTBuilder *&denominator)
2237 {
2238   save_.insert(new SaveFOTBuilder);
2239   denominator = save_.head();
2240   save_.insert(new SaveFOTBuilder);
2241   numerator = save_.head();
2242   startFractionSerial();
2243 }
2244
2245 void SerialFOTBuilder::endFraction()
2246 {
2247   {
2248     Owner<SaveFOTBuilder> numerator(save_.get());
2249     startFractionNumerator();
2250     numerator->emit(*this);
2251     endFractionNumerator();
2252   }
2253   {
2254     Owner<SaveFOTBuilder> denominator(save_.get());
2255     startFractionDenominator();
2256     denominator->emit(*this);
2257     endFractionDenominator();
2258   }
2259   endFractionSerial();
2260 }
2261
2262 void SerialFOTBuilder::startScript(FOTBuilder *&preSup,
2263                                    FOTBuilder *&preSub,
2264                                    FOTBuilder *&postSup,
2265                                    FOTBuilder *&postSub,
2266                                    FOTBuilder *&midSup,
2267                                    FOTBuilder *&midSub)
2268 {
2269   save_.insert(new SaveFOTBuilder);
2270   midSub = save_.head();
2271   save_.insert(new SaveFOTBuilder);
2272   midSup = save_.head();
2273   save_.insert(new SaveFOTBuilder);
2274   postSub = save_.head();
2275   save_.insert(new SaveFOTBuilder);
2276   postSup = save_.head();
2277   save_.insert(new SaveFOTBuilder);
2278   preSub = save_.head();
2279   save_.insert(new SaveFOTBuilder);
2280   preSup = save_.head();
2281   startScriptSerial();
2282 }
2283
2284 void SerialFOTBuilder::endScript()
2285 {
2286   {
2287     Owner<SaveFOTBuilder> tem(save_.get());
2288     startScriptPreSup();
2289     tem->emit(*this);
2290     endScriptPreSup();
2291   }
2292   {
2293     Owner<SaveFOTBuilder> tem(save_.get());
2294     startScriptPreSub();
2295     tem->emit(*this);
2296     endScriptPreSub();
2297   }
2298   {
2299     Owner<SaveFOTBuilder> tem(save_.get());
2300     startScriptPostSup();
2301     tem->emit(*this);
2302     endScriptPostSup();
2303   }
2304   {
2305     Owner<SaveFOTBuilder> tem(save_.get());
2306     startScriptPostSub();
2307     tem->emit(*this);
2308     endScriptPostSub();
2309   }
2310   {
2311     Owner<SaveFOTBuilder> tem(save_.get());
2312     startScriptMidSup();
2313     tem->emit(*this);
2314     endScriptMidSup();
2315   }
2316   {
2317     Owner<SaveFOTBuilder> tem(save_.get());
2318     startScriptMidSub();
2319     tem->emit(*this);
2320     endScriptMidSub();
2321   }
2322   endScriptSerial();
2323 }
2324
2325 void SerialFOTBuilder::startMark(FOTBuilder *&overMark, FOTBuilder *&underMark)
2326 {
2327   save_.insert(new SaveFOTBuilder);
2328   underMark = save_.head();
2329   save_.insert(new SaveFOTBuilder);
2330   overMark = save_.head();
2331   startMarkSerial();
2332 }
2333
2334 void SerialFOTBuilder::endMark()
2335 {
2336   {
2337     Owner<SaveFOTBuilder> tem(save_.get());
2338     startMarkOver();
2339     tem->emit(*this);
2340     endMarkOver();
2341   }
2342   {
2343     Owner<SaveFOTBuilder> tem(save_.get());
2344     startMarkUnder();
2345     tem->emit(*this);
2346     endMarkUnder();
2347   }
2348   endMarkSerial();
2349 }
2350
2351 void SerialFOTBuilder::startFence(FOTBuilder *&open, FOTBuilder *&close)
2352 {
2353   save_.insert(new SaveFOTBuilder);
2354   close = save_.head();
2355   save_.insert(new SaveFOTBuilder);
2356   open = save_.head();
2357   startFenceSerial();
2358 }
2359
2360 void SerialFOTBuilder::endFence()
2361 {
2362   {
2363     Owner<SaveFOTBuilder> tem(save_.get());
2364     startFenceOpen();
2365     tem->emit(*this);
2366     endFenceOpen();
2367   }
2368   {
2369     Owner<SaveFOTBuilder> tem(save_.get());
2370     startFenceClose();
2371     tem->emit(*this);
2372     endFenceClose();
2373   }
2374   endFenceSerial();
2375 }
2376
2377 void SerialFOTBuilder::startRadical(FOTBuilder *&degree)
2378 {
2379   save_.insert(new SaveFOTBuilder);
2380   degree = save_.head();
2381   startRadicalSerial();
2382 }
2383
2384 void SerialFOTBuilder::endRadical()
2385 {
2386   Owner<SaveFOTBuilder> tem(save_.get());
2387   startRadicalDegree();
2388   tem->emit(*this);
2389   endRadicalDegree();
2390   endRadicalSerial();
2391 }
2392
2393 void SerialFOTBuilder::startMathOperator(FOTBuilder *&oper,
2394                                          FOTBuilder *&lowerLimit,
2395                                          FOTBuilder *&upperLimit)
2396 {
2397   save_.insert(new SaveFOTBuilder);
2398   upperLimit = save_.head();
2399   save_.insert(new SaveFOTBuilder);
2400   lowerLimit = save_.head();
2401   save_.insert(new SaveFOTBuilder);
2402   oper = save_.head();
2403   startMathOperatorSerial();
2404 }
2405
2406 void SerialFOTBuilder::endMathOperator()
2407 {
2408   {
2409     Owner<SaveFOTBuilder> tem(save_.get());
2410     startMathOperatorOperator();
2411     tem->emit(*this);
2412     endMathOperatorOperator();
2413   }
2414   {
2415     Owner<SaveFOTBuilder> tem(save_.get());
2416     startMathOperatorLowerLimit();
2417     tem->emit(*this);
2418     endMathOperatorLowerLimit();
2419   }
2420   {
2421     Owner<SaveFOTBuilder> tem(save_.get());
2422     startMathOperatorUpperLimit();
2423     tem->emit(*this);
2424     endMathOperatorUpperLimit();
2425   }
2426   endMathOperatorSerial();
2427 }
2428
2429 void SerialFOTBuilder::startSimplePageSequenceSerial()
2430 {
2431   start();
2432 }
2433
2434 void SerialFOTBuilder::endSimplePageSequenceSerial()
2435 {
2436   end();
2437 }
2438
2439 void SerialFOTBuilder::startSimplePageSequenceHeaderFooter(unsigned)
2440 {
2441   start();
2442 }
2443
2444 void SerialFOTBuilder::endSimplePageSequenceHeaderFooter(unsigned)
2445 {
2446   end();
2447 }
2448
2449 void SerialFOTBuilder::endAllSimplePageSequenceHeaderFooter()
2450 {
2451 }
2452
2453 void SerialFOTBuilder::startFractionSerial()
2454 {
2455   start();
2456 }
2457
2458 void SerialFOTBuilder::endFractionSerial()
2459 {
2460   end();
2461 }
2462
2463 void SerialFOTBuilder::startFractionNumerator()
2464 {
2465 }
2466
2467 void SerialFOTBuilder::endFractionNumerator()
2468 {
2469 }
2470
2471 void SerialFOTBuilder::startFractionDenominator()
2472 {
2473 }
2474
2475 void SerialFOTBuilder::endFractionDenominator()
2476 {
2477 }
2478
2479 void SerialFOTBuilder::startScriptSerial()
2480 {
2481   start();
2482 }
2483
2484 void SerialFOTBuilder::endScriptSerial()
2485 {
2486   end();
2487 }
2488
2489 void SerialFOTBuilder::startScriptPreSup()
2490 {
2491 }
2492
2493 void SerialFOTBuilder::endScriptPreSup()
2494 {
2495 }
2496
2497 void SerialFOTBuilder::startScriptPreSub()
2498 {
2499 }
2500
2501 void SerialFOTBuilder::endScriptPreSub()
2502 {
2503 }
2504
2505 void SerialFOTBuilder::startScriptPostSup()
2506 {
2507 }
2508
2509 void SerialFOTBuilder::endScriptPostSup()
2510 {
2511 }
2512
2513 void SerialFOTBuilder::startScriptPostSub()
2514 {
2515 }
2516
2517 void SerialFOTBuilder::endScriptPostSub()
2518 {
2519 }
2520
2521 void SerialFOTBuilder::startScriptMidSup()
2522 {
2523 }
2524
2525 void SerialFOTBuilder::endScriptMidSup()
2526 {
2527 }
2528
2529 void SerialFOTBuilder::startScriptMidSub()
2530 {
2531 }
2532
2533 void SerialFOTBuilder::endScriptMidSub()
2534 {
2535 }
2536
2537 void SerialFOTBuilder::startMarkSerial()
2538 {
2539   start();
2540 }
2541
2542 void SerialFOTBuilder::endMarkSerial()
2543 {
2544   end();
2545 }
2546
2547 void SerialFOTBuilder::startMarkOver()
2548 {
2549 }
2550
2551 void SerialFOTBuilder::endMarkOver()
2552 {
2553 }
2554
2555 void SerialFOTBuilder::startMarkUnder()
2556 {
2557 }
2558
2559 void SerialFOTBuilder::endMarkUnder()
2560 {
2561 }
2562
2563 void SerialFOTBuilder::startFenceSerial()
2564 {
2565   start();
2566 }
2567
2568 void SerialFOTBuilder::endFenceSerial()
2569 {
2570   end();
2571 }
2572
2573 void SerialFOTBuilder::startFenceOpen()
2574 {
2575 }
2576
2577 void SerialFOTBuilder::endFenceOpen()
2578 {
2579 }
2580
2581 void SerialFOTBuilder::startFenceClose()
2582 {
2583 }
2584
2585 void SerialFOTBuilder::endFenceClose()
2586 {
2587 }
2588
2589 void SerialFOTBuilder::startRadicalSerial()
2590 {
2591   start();
2592 }
2593
2594 void SerialFOTBuilder::endRadicalSerial()
2595 {
2596   end();
2597 }
2598
2599 void SerialFOTBuilder::startRadicalDegree()
2600 {
2601 }
2602
2603 void SerialFOTBuilder::endRadicalDegree()
2604 {
2605 }
2606
2607 void SerialFOTBuilder::startMathOperatorSerial()
2608 {
2609   start();
2610 }
2611
2612 void SerialFOTBuilder::endMathOperatorSerial()
2613 {
2614   end();
2615 }
2616
2617 void SerialFOTBuilder::startMathOperatorOperator()
2618 {
2619 }
2620
2621 void SerialFOTBuilder::endMathOperatorOperator()
2622 {
2623 }
2624
2625 void SerialFOTBuilder::startMathOperatorLowerLimit()
2626 {
2627 }
2628
2629 void SerialFOTBuilder::endMathOperatorLowerLimit()
2630 {
2631 }
2632
2633 void SerialFOTBuilder::startMathOperatorUpperLimit()
2634 {
2635 }
2636
2637 void SerialFOTBuilder::endMathOperatorUpperLimit()
2638 {
2639 }
2640
2641 void SerialFOTBuilder::startTablePart(const FOTBuilder::TablePartNIC &nic,
2642                                       FOTBuilder *&header, FOTBuilder *&footer)
2643 {
2644   save_.insert(new SaveFOTBuilder);
2645   footer = save_.head();
2646   save_.insert(new SaveFOTBuilder);
2647   header = save_.head();
2648   startTablePartSerial(nic);
2649 }
2650
2651 void SerialFOTBuilder::endTablePart()
2652 {
2653   Owner<SaveFOTBuilder> header(save_.get());
2654   startTablePartHeader();
2655   header->emit(*this);
2656   endTablePartHeader();
2657   Owner<SaveFOTBuilder> footer(save_.get());
2658   startTablePartFooter();
2659   footer->emit(*this);
2660   endTablePartFooter();
2661   endTablePartSerial();
2662 }
2663
2664 void SerialFOTBuilder::startTablePartSerial(const TablePartNIC &)
2665 {
2666   start();
2667 }
2668
2669 void SerialFOTBuilder::endTablePartSerial()
2670 {
2671   end();
2672 }
2673
2674 void SerialFOTBuilder::startTablePartHeader()
2675 {
2676 }
2677
2678 void SerialFOTBuilder::endTablePartHeader()
2679 {
2680 }
2681
2682 void SerialFOTBuilder::startTablePartFooter()
2683 {
2684 }
2685
2686 void SerialFOTBuilder::endTablePartFooter()
2687 {
2688 }
2689
2690 void SerialFOTBuilder::startMultiMode(const MultiMode *principalMode,
2691                                       const Vector<MultiMode> &namedModes,
2692                                       Vector<FOTBuilder *> &namedPorts)
2693 {
2694   for (size_t i = namedModes.size(); i > 0; i--) {
2695     save_.insert(new SaveFOTBuilder);
2696     namedPorts[i - 1] = save_.head();
2697   }
2698   multiModeStack_.push_back(namedModes);
2699   startMultiModeSerial(principalMode);
2700 }
2701
2702 void SerialFOTBuilder::endMultiMode()
2703 {
2704   const Vector<MultiMode> &namedModes = multiModeStack_.back();
2705   for (size_t i = 0; i < namedModes.size(); i++) {
2706     Owner<SaveFOTBuilder> mode(save_.get());
2707     startMultiModeMode(namedModes[i]);
2708     mode->emit(*this);
2709     endMultiModeMode();
2710   }
2711   endMultiModeSerial();
2712   multiModeStack_.resize(multiModeStack_.size() - 1);
2713 }
2714
2715 void SerialFOTBuilder::startMultiModeSerial(const MultiMode *)
2716 {
2717   start();
2718 }
2719
2720 void SerialFOTBuilder::endMultiModeSerial()
2721 {
2722   end();
2723 }
2724
2725 void SerialFOTBuilder::startMultiModeMode(const MultiMode &)
2726 {
2727 }
2728
2729 void SerialFOTBuilder::endMultiModeMode()
2730 {
2731 }
2732
2733 void SerialFOTBuilder::startExtension(const CompoundExtensionFlowObj &flowObj,
2734                                       const NodePtr &nd,
2735                                       Vector<FOTBuilder *> &ports)
2736 {
2737   for (size_t i = ports.size(); i > 0; i--) {
2738     save_.insert(new SaveFOTBuilder);
2739     ports[i - 1] = save_.head();
2740   }
2741   startExtensionSerial(flowObj, nd);
2742 }
2743
2744 void SerialFOTBuilder::endExtension(const CompoundExtensionFlowObj &flowObj)
2745 {
2746   Vector<StringC> portNames;
2747   flowObj.portNames(portNames);
2748   for (size_t i = 0; i < portNames.size(); i++) {
2749     Owner<SaveFOTBuilder> stream(save_.get());
2750     startExtensionStream(portNames[i]);
2751     stream->emit(*this);
2752     endExtensionStream(portNames[i]);
2753   }
2754   endExtensionSerial(flowObj);
2755 }
2756
2757 void SerialFOTBuilder::startExtensionSerial(const CompoundExtensionFlowObj &, const NodePtr &)
2758 {
2759   start();
2760 }
2761
2762 void SerialFOTBuilder::endExtensionSerial(const CompoundExtensionFlowObj &)
2763 {
2764   end();
2765 }
2766
2767 void SerialFOTBuilder::startExtensionStream(const StringC &)
2768 {
2769 }
2770
2771 void SerialFOTBuilder::endExtensionStream(const StringC &)
2772 {
2773 }
2774
2775 FOTBuilder::ExtensionFlowObj::~ExtensionFlowObj()
2776 {
2777 }
2778
2779 FOTBuilder::CompoundExtensionFlowObj *
2780 FOTBuilder::ExtensionFlowObj::asCompoundExtensionFlowObj()
2781 {
2782   return 0;
2783 }
2784
2785 const FOTBuilder::CompoundExtensionFlowObj *
2786 FOTBuilder::ExtensionFlowObj::asCompoundExtensionFlowObj() const
2787 {
2788   return 0;
2789 }
2790
2791 bool FOTBuilder::ExtensionFlowObj::hasNIC(const StringC &) const
2792 {
2793   return 0;
2794 }
2795
2796 void FOTBuilder::ExtensionFlowObj::setNIC(const StringC &, const Value &)
2797 {
2798   CANNOT_HAPPEN();
2799 }
2800
2801 FOTBuilder::CompoundExtensionFlowObj *
2802 FOTBuilder::CompoundExtensionFlowObj::asCompoundExtensionFlowObj()
2803 {
2804   return this;
2805 }
2806
2807 const FOTBuilder::CompoundExtensionFlowObj *
2808 FOTBuilder::CompoundExtensionFlowObj::asCompoundExtensionFlowObj() const
2809 {
2810   return this;
2811 }
2812
2813 bool FOTBuilder::CompoundExtensionFlowObj::hasPrincipalPort() const
2814 {
2815   return 1;
2816 }
2817
2818 void FOTBuilder::CompoundExtensionFlowObj::portNames(Vector<StringC> &) const
2819 {
2820 }
2821
2822 #ifdef DSSSL_NAMESPACE
2823 }
2824 #endif