Debian Codegraph @

style/DocumentGenerator.cxx

raw
1 // Copyright (c) 1999 Matthias Clasen
2 // See the file copying.txt for copying permission.
3
4 #include "stylelib.h"
5 #include <OpenSP/macros.h>
6 #include "DocumentGenerator.h"
7 #include <stdio.h>
8
9 #ifdef DSSSL_NAMESPACE
10 namespace DSSSL_NAMESPACE {
11 #endif
12
13 #ifdef GROVE_NAMESPACE
14 using namespace GROVE_NAMESPACE;
15 #endif
16
17 //FIXME: this is just because OutputCharStream::operator<<(Newline) is broken
18 const char RE = '\r';
19
20 inline
21 OutputCharStream &operator<<(OutputCharStream &os, const GroveString &str)
22 {
23 os << StringC((const Char *)str.data(), str.size());
24 return os;
25 }
26
27 inline
28 OutputCharStream &operator<<(OutputCharStream &os, const GroveChar ch)
29 {
30 os << StringC((const Char *)&ch, 1);
31 return os;
32 };
33
34 DocumentGenerator::DocumentGenerator(SdataMapper *smap, OutputCharStream *os)
35 : smap_(smap), os_(os)
36 {
37 }
38
39 void DocumentGenerator::emit(const GroveStringListPtr &strs,
40 const char *a,
41 const char *sep,
42 const char *o)
43 {
44 ConstGroveStringListIter iter(ConstGroveStringListIter(strs->iter()));
45 if (!iter.done()) {
46 os() << a << iter.cur();
47 iter.next();
48 for (;!iter.done();iter.next())
49 os() << sep << iter.cur();
50 os() << o;
51 }
52 }
53
54 void DocumentGenerator::emit(const NodePtr &ptr)
55 {
56 switch (ptr->classDef().className) {
57 case ComponentName::idSgmlDocument: {
58 NodePtr gdtd;
59 ptr->getGoverningDoctype(gdtd);
60 emit(gdtd);
61 NodeListPtr prolog;
62 GroveString sep;
63 if (ptr->getProlog(prolog) == accessOK)
64 emit(prolog, sep);
65 NodePtr docelem;
66 if (ptr->getDocumentElement(docelem) == accessOK)
67 emit(docelem);
68 NodeListPtr epilog;
69 if (ptr->getProlog(epilog) == accessOK)
70 emit(epilog, sep);
71 break;
72 }
73 case ComponentName::idElement: {
74 GroveString gi;
75 ptr->getGi(gi);
76 os() << "<" << gi;
77 NamedNodeListPtr atts;
78 GroveChar ch = ' ';
79 GroveString sep(&ch, 1);
80 NodePtr nd;
81 if (ptr->getAttributes(atts) == accessOK
82 && atts->nodeList()->first(nd) == accessOK) {
83 os() << " ";
84 emit(atts->nodeList(), sep);
85 }
86 os() << ">";
87 NodeListPtr content;
88 sep.assign(0, 0);
89 if (ptr->getContent(content) == accessOK)
90 emit(content, sep);
91 bool mustOmitEndTag;
92 ptr->getMustOmitEndTag(mustOmitEndTag);
93 if (!mustOmitEndTag)
94 os() << "</" << gi << ">";
95 break;
96 }
97 case ComponentName::idDataChar: {
98 GroveChar ch;
99 ptr->getChar(*smap_, ch);
100 os() << ch;
101 break;
102 }
103 case ComponentName::idAttributeAssignment: {
104 bool implied;
105 ptr->getImplied(implied);
106 if (!implied) {
107 GroveString name;
108 ptr->getName(name);
109 os() << name << "='";
110 GroveChar ch;
111 GroveString sep;
112 if (ptr->getTokenSep(ch) != accessNull)
113 sep.assign(&ch, 1);
114 NodeListPtr value;
115 if (ptr->getValue(value) == accessOK)
116 emit(value, sep);
117 os() << "'";
118 }
119 break;
120 }
121 case ComponentName::idAttributeValueToken: {
122 GroveString tok;
123 ptr->getToken(tok);
124 os() << tok;
125 break;
126 }
127 case ComponentName::idPi: {
128 GroveString str;
129 if (ptr->getEntityName(str) == accessOK)
130 os() << "&" << str << ";";
131 else {
132 ptr->getSystemData(str);
133 os() << "<?" << str << ">";
134 }
135 break;
136 }
137 case ComponentName::idSdata:
138 case ComponentName::idSubdocument:
139 case ComponentName::idExternalData: {
140 GroveString str;
141 ptr->getEntityName(str);
142 os() << "&" << str << ";";
143 break;
144 }
145 case ComponentName::idDocumentType: {
146 GroveString name;
147 GroveString sep;
148 ptr->getName(name);
149 os() << "<!DOCTYPE " << name << " [" << RE;
150 NamedNodeListPtr nnl;
151 if (ptr->getNotations(nnl) == accessOK)
152 emit(nnl->nodeList(), sep);
153 if (ptr->getParameterEntities(nnl) == accessOK)
154 emit(nnl->nodeList(), sep);
155 if (ptr->getGeneralEntities(nnl) == accessOK)
156 emit(nnl->nodeList(), sep);
157 NodePtr dent;
158 if (ptr->getDefaultEntity(dent) == accessOK)
159 emit(dent);
160 if (ptr->getElementTypes(nnl) == accessOK)
161 emit(nnl->nodeList(), sep);
162 os() << "]>" << RE;
163 break;
164 }
165 case ComponentName::idNotation: {
166 GroveString name;
167 ptr->getName(name);
168 os() << "<!NOTATION " << name << " ";
169 NodePtr extid;
170 if (ptr->getExternalId(extid) == accessOK)
171 emit(extid);
172 os() << ">" << RE;
173 NamedNodeListPtr atts;
174 NodePtr first;
175 if (ptr->getAttributeDefs(atts) == accessOK
176 && atts->nodeList()->first(first) == accessOK) {
177 os() << "<!ATTLIST #NOTATION " << name << RE;
178 GroveChar ch = RE;
179 GroveString sep(&ch, 1);
180 emit(atts->nodeList(), sep);
181 os() << " >" << RE;
182 }
183 break;
184 }
185 case ComponentName::idDefaultEntity:
186 case ComponentName::idEntity: {
187 bool defaulted;
188 ptr->getDefaulted(defaulted);
189 if (defaulted)
190 break;
191 os() << "<!ENTITY ";
192 Node::EntityType::Enum type;
193 ptr->getEntityType(type);
194 GroveString name;
195 ptr->getName(name);
196 if (name.size() > 0)
197 os() << name << " ";
198 else
199 os() << "#DEFAULT ";
200 NodePtr extid;
201 if (ptr->getExternalId(extid) == accessOK) {
202 emit(extid);
203 switch (type) {
204 case Node::EntityType::subdocument:
205 os() << " SUBDOC";
206 break;
207 case Node::EntityType::cdata:
208 os() << " CDATA";
209 break;
210 case Node::EntityType::sdata:
211 os() << " SDATA";
212 break;
213 case Node::EntityType::ndata:
214 os() << " NDATA";
215 break;
216 default:
217 CANNOT_HAPPEN();
218 }
219 switch (type) {
220 case Node::EntityType::cdata:
221 case Node::EntityType::sdata:
222 case Node::EntityType::ndata: {
223 GroveString notname;
224 ptr->getNotationName(notname);
225 os() << " " << notname << " ";
226 NamedNodeListPtr atts;
227 NodePtr first;
228 if (ptr->getAttributes(atts) == accessOK
229 && atts->nodeList()->first(first) == accessOK) {
230 os() << "[";
231 GroveChar ch = ' ';
232 GroveString sep(&ch, 1);
233 emit(atts->nodeList(), sep);
234 os() << "] ";
235 }
236 break;
237 }
238 default:
239 break;
240 }
241 }
242 else { // internal entity
243 switch (type) {
244 case Node::EntityType::text:
245 break;
246 case Node::EntityType::pi:
247 os() << "PI ";
248 break;
249 case Node::EntityType::cdata:
250 os() << "CDATA ";
251 break;
252 case Node::EntityType::sdata:
253 os() << "SDATA ";
254 break;
255 default:
256 CANNOT_HAPPEN();
257 }
258 GroveString text;
259 ptr->getText(text);
260 os() << "'" << text << "' ";
261 }
262 os() << ">" << RE;
263 break;
264 }
265 case ComponentName::idElementType: {
266 GroveString gi;
267 ptr->getGi(gi);
268 os() << "<!ELEMENT " << gi << " ";
269 bool ostart, oend;
270 ptr->getOmitStartTag(ostart);
271 ptr->getOmitEndTag(oend);
272 os() << (ostart ? "O " : "- ") << (oend ? "O " : "- ");
273 Node::ContentType::Enum type;
274 ptr->getContentType(type);
275 switch(type) {
276 case Node::ContentType::cdata:
277 os() << "CDATA";
278 break;
279 case Node::ContentType::rcdata:
280 os() << "RCDATA";
281 break;
282 case Node::ContentType::empty:
283 os() << "EMPTY";
284 break;
285 case Node::ContentType::any:
286 os() << "ANY";
287 break;
288 case Node::ContentType::modelgrp: {
289 NodePtr model;
290 if (ptr->getModelGroup(model) == accessOK)
291 emit(model);
292 break;
293 }
294 default:
295 CANNOT_HAPPEN();
296 }
297 GroveStringListPtr cl;
298 if (ptr->getExclusions(cl) == accessOK)
299 emit(cl, " -(", "|", ")");
300 if (ptr->getInclusions(cl) == accessOK)
301 emit(cl, " +(", "|", ")");
302 os() << " >" << RE;
303 NamedNodeListPtr atts;
304 NodePtr first;
305 if (ptr->getAttributeDefs(atts) == accessOK
306 && atts->nodeList()->first(first) == accessOK) {
307 os() << "<!ATTLIST " << gi << RE;
308 GroveChar ch = RE;
309 GroveString sep(&ch, 1);
310 emit(atts->nodeList(), sep);
311 os() << " >" << RE;
312 }
313 break;
314 }
315 case ComponentName::idAttributeDef: {
316 GroveString name;
317 ptr->getName(name);
318 os() << " " << name << " ";
319 Node::DeclValueType::Enum decl;
320 ptr->getDeclValueType(decl);
321 switch (decl) {
322 case Node::DeclValueType::cdata:
323 os() << "CDATA ";
324 break;
325 case Node::DeclValueType::entity:
326 os() << "ENTITY ";
327 break;
328 case Node::DeclValueType::entities:
329 os() << "ENTITIES ";
330 break;
331 case Node::DeclValueType::id:
332 os() << "ID ";
333 break;
334 case Node::DeclValueType::idref:
335 os() << "IDREF ";
336 break;
337 case Node::DeclValueType::idrefs:
338 os() << "IDREFS ";
339 break;
340 case Node::DeclValueType::name:
341 os() << "NAME ";
342 break;
343 case Node::DeclValueType::names:
344 os() << "NAMES ";
345 break;
346 case Node::DeclValueType::nmtoken:
347 os() << "NMTOKEN ";
348 break;
349 case Node::DeclValueType::nmtokens:
350 os() << "NMTOKENS ";
351 break;
352 case Node::DeclValueType::number:
353 os() << "NUMBER ";
354 break;
355 case Node::DeclValueType::numbers:
356 os() << "NUMBERS ";
357 break;
358 case Node::DeclValueType::nutoken:
359 os() << "NUTOKEN ";
360 break;
361 case Node::DeclValueType::nutokens:
362 os() << "NUTOKENS ";
363 break;
364 case Node::DeclValueType::notation:
365 os() << "NOTATION ";
366 // fall through
367 case Node::DeclValueType::nmtkgrp: {
368 GroveStringListPtr toks;
369 ptr->getTokens(toks);
370 emit(toks, "(", "|", ") ");
371 break;
372 }
373 default:
374 CANNOT_HAPPEN();
375 }
376 Node::DefaultValueType::Enum deflt;
377 ptr->getDefaultValueType(deflt);
378 switch (deflt) {
379 case Node::DefaultValueType::fixed:
380 os() << "#FIXED ";
381 // fall through
382 case Node::DefaultValueType::value: {
383 NodeListPtr val;
384 GroveString sep;
385 if (ptr->getDefaultValue(val) == accessOK)
386 emit(val, sep);
387 break;
388 }
389 case Node::DefaultValueType::required:
390 os() << "#REQUIRED";
391 break;
392 case Node::DefaultValueType::current:
393 os() << "#CURRENT";
394 break;
395 case Node::DefaultValueType::conref:
396 os() << "#CONREF";
397 break;
398 case Node::DefaultValueType::implied:
399 os() << "#IMPLIED";
400 break;
401 default:
402 CANNOT_HAPPEN();
403 }
404 break;
405 }
406 case ComponentName::idExternalId: {
407 GroveString pubid, sysid;
408 if (ptr->getPublicId(pubid) == accessOK)
409 os() << "PUBLIC '" << pubid << "'";
410 if (ptr->getSystemId(sysid) == accessOK)
411 os() << (pubid.size() > 0 ? " " : "") << "SYSTEM '" << sysid << "'";
412 break;
413 }
414 case ComponentName::idModelGroup: {
415 //FIXME: fails for (#pcdata)
416 os() << "(";
417 Node::Connector::Enum conn;
418 ptr->getConnector(conn);
419 GroveChar ch;
420 switch (conn) {
421 case Node::Connector::and_:
422 ch = '&';
423 break;
424 case Node::Connector::or_:
425 ch = '|';
426 break;
427 case Node::Connector::seq:
428 ch = ',';
429 break;
430 default:
431 CANNOT_HAPPEN();
432 }
433 GroveString sep(&ch, 1);
434 NodeListPtr toks;
435 if (ptr->getContentTokens(toks) == accessOK)
436 emit(toks, sep);
437 os() << ")";
438 Node::OccurIndicator::Enum occur;
439 if (ptr->getOccurIndicator(occur) == accessOK) {
440 switch (occur) {
441 case Node::OccurIndicator::opt:
442 os() << '?';
443 break;
444 case Node::OccurIndicator::plus:
445 os() << '+';
446 break;
447 case Node::OccurIndicator::rep:
448 os() << '*';
449 break;
450 default:
451 CANNOT_HAPPEN();
452 }
453 }
454 break;
455 }
456 case ComponentName::idElementToken: {
457 GroveString gi;
458 ptr->getGi(gi);
459 os() << gi;
460 Node::OccurIndicator::Enum occur;
461 if (ptr->getOccurIndicator(occur) == accessOK) {
462 switch (occur) {
463 case Node::OccurIndicator::opt:
464 os() << '?';
465 break;
466 case Node::OccurIndicator::plus:
467 os() << '+';
468 break;
469 case Node::OccurIndicator::rep:
470 os() << '*';
471 break;
472 default:
473 CANNOT_HAPPEN();
474 }
475 }
476 break;
477 }
478 case ComponentName::idPcdataToken: {
479 os() << "#PCDATA";
480 break;
481 }
482 case ComponentName::idSgmlConstants:
483 case ComponentName::noId: // message and nonSgml
484 break;
485 default:
486 CANNOT_HAPPEN();
487 }
488 }
489
490 void DocumentGenerator::emit(const NodeListPtr &ptr, const GroveString &sep)
491 {
492 NodeListPtr nl(ptr);
493 NodePtr nd;
494 for (;;) {
495 if (nl->first(nd) != accessOK)
496 return;
497 emit(nd);
498 if (nl->rest(nl) != accessOK)
499 return;
500 os() << sep;
501 }
502 }
503
504 #ifdef DSSSL_NAMESPACE
505 }
506 #endif