Debian Codegraph @

style/FOTBuilder.cxx

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