cde/programs/nsgmls/Event.C

   1 /* $XConsortium: Event.C /main/1 1996/07/29 16:51:15 cde-hp $ */
   2 // Copyright (c) 1994 James Clark
   3 // See the file COPYING for copying permission.
   4
   5 #ifdef __GNUG__
   6 #pragma implementation
   7 #endif
   8 #include "splib.h"
   9 #include "Event.h"
  10 #include "Entity.h"
  11 #include "Attribute.h"
  12 #include "EventQueue.h"
  13
  14 #ifdef SP_NAMESPACE
  15 namespace SP_NAMESPACE {
  16 #endif
  17
  18 void Event::copyData()
  19 {
  20 }
  21
  22 LocatedEvent::LocatedEvent(Type type, const Location &location)
  23 : location_(location), Event(type)
  24 {
  25 }
  26
  27 MarkupEvent::MarkupEvent(Type type)
  28 : LocatedEvent(type, Location())
  29 {
  30 }
  31
  32 MarkupEvent::MarkupEvent(Type type, const Location &loc, Markup *markup)
  33 : LocatedEvent(type, loc)
  34 {
  35   if (markup)
  36     markup->swap(markup_);
  37 }
  38
  39 StartElementEvent::StartElementEvent(const ElementType *elementType,
  40                                      const ConstPtr<Dtd> &dtd,
  41                                      AttributeList *attributes,
  42                                      const Location &startLocation,
  43                                      Markup *markup)
  44 : LocatedEvent(startElement, startLocation),
  45   elementType_(elementType),
  46   dtd_(dtd),
  47   included_(0),
  48   copied_(0),
  49   markup_(markup),
  50   attributes_(attributes)
  51 {
  52 }
  53
  54 StartElementEvent::~StartElementEvent()
  55 {
  56   if (copied_) {
  57     delete attributes_;
  58     delete markup_;
  59   }
  60 }
  61
  62 void StartElementEvent::copyData()
  63 {
  64   if (!copied_) {
  65     {
  66       AttributeList *p = new AttributeList;
  67       attributes_->swap(*p);
  68       attributes_ = p;
  69     }
  70     if (markup_) {
  71       Markup *p = new Markup;
  72       markup_->swap(*p);
  73       markup_ = p;
  74     }
  75     copied_ = 1;
  76   }
  77 }
  78
  79 EndElementEvent::EndElementEvent(const ElementType *elementType,
  80                                  const ConstPtr<Dtd> &dtd,
  81                                  const Location &startLocation,
  82                                  Markup *markup)
  83 : LocatedEvent(endElement, startLocation),
  84   elementType_(elementType),
  85   dtd_(dtd),
  86   included_(0),
  87   copied_(0),
  88   markup_(markup)
  89 {
  90 }
  91
  92 EndElementEvent::~EndElementEvent()
  93 {
  94   if (copied_)
  95     delete markup_;
  96 }
  97
  98 void EndElementEvent::copyData()
  99 {
 100   if (!copied_) {
 101     if (markup_) {
 102       Markup *p = new Markup;
 103       markup_->swap(*p);
 104       markup_ = p;
 105     }
 106     copied_ = 1;
 107   }
 108 }
 109
 110 DataEvent::DataEvent(Type type, const Char *p, size_t length,
 111                      const Location &location)
 112 : p_(p),length_(length), LocatedEvent(type, location)
 113 {
 114 }
 115
 116 const Entity *DataEvent::entity() const
 117 {
 118   return 0;
 119 }
 120
 121 Boolean DataEvent::isRe(unsigned long &) const
 122 {
 123   return 0;
 124 }
 125
 126 ImmediateDataEvent::ImmediateDataEvent(Type type, const Char *p, size_t length,
 127                                        const Location &location,
 128                                        Boolean copy)
 129 : DataEvent(type, p, length, location), alloc_(0)
 130 {
 131   if (copy)
 132     ImmediateDataEvent::copyData();
 133 }
 134
 135 ImmediateDataEvent::~ImmediateDataEvent()
 136 {
 137   if (alloc_)
 138     delete [] alloc_;
 139 }
 140
 141 void ImmediateDataEvent::copyData()
 142 {
 143   if (!alloc_) {
 144     alloc_ = new Char[length_];
 145     memcpy(alloc_, p_, length_*sizeof(Char));
 146     p_ = alloc_;
 147   }
 148 }
 149
 150 ReEvent::ReEvent(const Char *p, const Location &location, unsigned long serial)
 151 : ImmediateDataEvent(characterData, p, 1, location, 0),
 152   serial_(serial)
 153 {
 154 }
 155
 156 Boolean ReEvent::isRe(unsigned long &serial) const
 157 {
 158   serial = serial_;
 159   return 1;
 160 }
 161
 162 DataEntityEvent::DataEntityEvent(Type type, const InternalEntity *entity,
 163                                  const ConstPtr<Origin> &origin)
 164 : DataEvent(type,
 165             entity->string().data(),
 166             entity->string().size(),
 167             Location(origin, 0))
 168 {
 169 }
 170
 171 const Entity *DataEntityEvent::entity() const
 172 {
 173   return location().origin()->asEntityOrigin()->entity().pointer();
 174 }
 175
 176 CdataEntityEvent::CdataEntityEvent(const InternalEntity *entity,
 177                                    const ConstPtr<Origin> &origin)
 178 : DataEntityEvent(characterData, entity, origin)
 179 {
 180 }
 181
 182 SdataEntityEvent::SdataEntityEvent(const InternalEntity *entity,
 183                                    const ConstPtr<Origin> &origin)
 184 : DataEntityEvent(sdataEntity, entity, origin)
 185 {
 186 }
 187
 188 MessageEvent::MessageEvent(const Message &m)
 189 : Event(Event::message), message_(m)
 190 {
 191 }
 192
 193 MessageEvent::MessageEvent(Message &m)
 194 : Event(Event::message)
 195 {
 196   m.swap(message_);
 197 }
 198
 199 PiEvent::PiEvent(const Char *data, size_t dataLength, const Location &location)
 200 : data_(data), dataLength_(dataLength), LocatedEvent(pi, location)
 201 {
 202 }
 203
 204 const Entity *PiEvent::entity() const
 205 {
 206   return 0;
 207 }
 208
 209 PiEntityEvent::PiEntityEvent(const PiEntity *entity,
 210                              const ConstPtr<Origin> &origin)
 211 : PiEvent(entity->string().data(), entity->string().size(),
 212           Location(origin, 0))
 213 {
 214 }
 215
 216 const Entity *PiEntityEvent::entity() const
 217 {
 218   return location().origin()->asEntityOrigin()->entity().pointer();
 219 }
 220
 221 ImmediatePiEvent::ImmediatePiEvent(StringC &str, const Location &loc)
 222 : PiEvent(str.data(), str.size(), loc)
 223 {
 224   str.swap(string_);
 225 }
 226
 227 ExternalEntityEvent::ExternalEntityEvent(Type type,
 228                                          const ConstPtr<EntityOrigin> &origin)
 229 : origin_(origin), Event(type)
 230 {
 231 }
 232
 233 ExternalDataEntityEvent::ExternalDataEntityEvent(const ExternalDataEntity *entity,
 234                                                  const ConstPtr<EntityOrigin> &origin)
 235 : dataEntity_(entity), ExternalEntityEvent(externalDataEntity, origin)
 236 {
 237 }
 238
 239 SubdocEntityEvent::SubdocEntityEvent(const SubdocEntity *entity,
 240                                      const ConstPtr<EntityOrigin> &origin)
 241 : subdocEntity_(entity), ExternalEntityEvent(subdocEntity, origin)
 242 {
 243 }
 244
 245 AppinfoEvent::AppinfoEvent(const Location &location)
 246 : LocatedEvent(appinfo, location), appinfoNone_(1)
 247 {
 248 }
 249
 250 AppinfoEvent::AppinfoEvent(const Text &text, const Location &location)
 251 : LocatedEvent(appinfo, location), appinfoNone_(0), appinfo_(text)
 252 {
 253 }
 254
 255 UselinkEvent::UselinkEvent(const ConstPtr<Lpd> &lpd,
 256                            const LinkSet *linkSet,
 257                            Boolean restore,
 258                            const Location &loc,
 259                            Markup *markup)
 260 : MarkupEvent(uselink, loc, markup),
 261   lpd_(lpd),
 262   linkSet_(linkSet),
 263   restore_(restore)
 264 {
 265 }
 266
 267 UsemapEvent::UsemapEvent(const ShortReferenceMap *map,
 268                          Vector<const ElementType *> &elements,
 269                          const ConstPtr<Dtd> &dtd,
 270                          const Location &loc,
 271                          Markup *markup)
 272 : MarkupEvent(usemap, loc, markup),
 273   map_(map),
 274   dtd_(dtd)
 275 {
 276   elements.swap(elements_);
 277 }
 278
 279 StartSubsetEvent::StartSubsetEvent(Type type,
 280                                    const StringC &name,
 281                                    const ConstPtr<Entity> &entity,
 282                                    Boolean hasInternalSubset,
 283                                    const Location &loc,
 284                                    Markup *markup)
 285 : name_(name), entity_(entity), hasInternalSubset_(hasInternalSubset),
 286   MarkupEvent(type, loc, markup)
 287 {
 288 }
 289
 290 StartDtdEvent::StartDtdEvent(const StringC &name,
 291                              const ConstPtr<Entity> &entity,
 292                              Boolean hasInternalSubset,
 293                              const Location &loc,
 294                              Markup *markup)
 295 : StartSubsetEvent(startDtd, name, entity, hasInternalSubset, loc, markup)
 296 {
 297 }
 298
 299 StartLpdEvent::StartLpdEvent(Boolean active,
 300                              const StringC &name,
 301                              const ConstPtr<Entity> &entity,
 302                              Boolean hasInternalSubset,
 303                              const Location &loc,
 304                              Markup *markup)
 305 : StartSubsetEvent(startLpd, name, entity, hasInternalSubset, loc, markup),
 306   active_(active)
 307 {
 308 }
 309
 310 EndDtdEvent::EndDtdEvent(const ConstPtr<Dtd> &dtd,
 311                          const Location &loc,
 312                          Markup *markup)
 313 :  MarkupEvent(endDtd, loc, markup), dtd_(dtd)
 314 {
 315 }
 316
 317 EndLpdEvent::EndLpdEvent(const ConstPtr<Lpd> &lpd,
 318                          const Location &loc,
 319                          Markup *markup)
 320 :  MarkupEvent(endLpd, loc, markup), lpd_(lpd)
 321 {
 322 }
 323
 324 EndPrologEvent::EndPrologEvent(const ConstPtr<Dtd> &dtd,
 325                                const ConstPtr<ComplexLpd> &lpd,
 326                                Vector<StringC> &simpleLinkNames,
 327                                Vector<AttributeList> &simpleLinkAttributes,
 328                                const Location &location)
 329 : LocatedEvent(endProlog, location), dtd_(dtd), lpd_(lpd)
 330 {
 331   simpleLinkAttributes.swap(simpleLinkAttributes_);
 332   simpleLinkNames.swap(simpleLinkNames_);
 333 }
 334
 335 EndPrologEvent::EndPrologEvent(const ConstPtr<Dtd> &dtd,
 336                                const Location &location)
 337 : LocatedEvent(endProlog, location), dtd_(dtd)
 338 {
 339 }
 340
 341 SgmlDeclEvent::SgmlDeclEvent(const ConstPtr<Sd> &sd,
 342                              const ConstPtr<Syntax> &syntax)
 343
 344 : sd_(sd), prologSyntax_(syntax), instanceSyntax_(syntax),
 345   nextIndex_(0), MarkupEvent(sgmlDecl)
 346 {
 347 }
 348
 349 SgmlDeclEvent::SgmlDeclEvent(const ConstPtr<Sd> &sd,
 350                              const ConstPtr<Syntax> &prologSyntax,
 351                              const ConstPtr<Syntax> &instanceSyntax,
 352                              const ConstPtr<Sd> &refSd,
 353                              const ConstPtr<Syntax> &refSyntax,
 354                              Index nextIndex,
 355                              const StringC &implySystemId,
 356                              const Location &loc,
 357                              Markup *markup)
 358 : sd_(sd), prologSyntax_(prologSyntax), instanceSyntax_(instanceSyntax),
 359   refSd_(refSd), refSyntax_(refSyntax),
 360   nextIndex_(nextIndex), implySystemId_(implySystemId),
 361   MarkupEvent(sgmlDecl, loc, markup)
 362 {
 363 }
 364
 365 CommentDeclEvent::CommentDeclEvent(const Location &loc,
 366                                    Markup *markup)
 367 : MarkupEvent(commentDecl, loc, markup)
 368 {
 369 }
 370
 371 SSepEvent::SSepEvent(const Char *p, size_t length,
 372                      const Location &location, Boolean copy)
 373 : ImmediateDataEvent(sSep, p, length, location, copy)
 374 {
 375 }
 376
 377 IgnoredRsEvent::IgnoredRsEvent(Char c, const Location &location)
 378 : LocatedEvent(ignoredRs, location), c_(c)
 379 {
 380 }
 381
 382 IgnoredReEvent::IgnoredReEvent(Char c, const Location &location,
 383                                unsigned long serial)
 384 : LocatedEvent(ignoredRe, location),
 385   c_(c),
 386   serial_(serial)
 387 {
 388 }
 389
 390 ReOriginEvent::ReOriginEvent(Char c, const Location &location,
 391                              unsigned long serial)
 392 : LocatedEvent(reOrigin, location), c_(c), serial_(serial)
 393 {
 394 }
 395
 396
 397 IgnoredCharsEvent::IgnoredCharsEvent(const Char *p, size_t length,
 398                                      const Location &location, Boolean copy)
 399 : ImmediateDataEvent(ignoredChars, p, length, location, copy)
 400 {
 401 }
 402
 403 MarkedSectionEvent::MarkedSectionEvent(Type type, Status status,
 404                                        const Location &loc,
 405                                        Markup *markup)
 406 : MarkupEvent(type, loc, markup),
 407   status_(status)
 408 {
 409 }
 410
 411 MarkedSectionStartEvent::MarkedSectionStartEvent(Status status,
 412                                                  const Location &loc,
 413                                                  Markup *markup)
 414 : MarkedSectionEvent(markedSectionStart, status, loc, markup)
 415 {
 416 }
 417
 418 MarkedSectionEndEvent::MarkedSectionEndEvent(Status status,
 419                                              const Location &loc,
 420                                              Markup *markup)
 421 : MarkedSectionEvent(markedSectionEnd, status, loc, markup)
 422 {
 423 }
 424
 425 EntityStartEvent::EntityStartEvent(const ConstPtr<EntityOrigin> &origin)
 426 : Event(entityStart), origin_(origin)
 427 {
 428 }
 429
 430 EntityEndEvent::EntityEndEvent(const Location &location)
 431 : LocatedEvent(entityEnd, location)
 432 {
 433 }
 434
 435 EntityDeclEvent:: EntityDeclEvent(const ConstPtr<Entity> &entity,
 436                                   Boolean ignored, const Location &loc,
 437                                   Markup *markup)
 438 : MarkupEvent(entityDecl, loc, markup),
 439   entity_(entity),
 440   ignored_(ignored)
 441 {
 442 }
 443
 444 NotationDeclEvent:: NotationDeclEvent(const ConstPtr<Notation> &notation,
 445                                       const Location &loc,
 446                                       Markup *markup)
 447 : MarkupEvent(notationDecl, loc, markup), notation_(notation)
 448 {
 449 }
 450
 451 ElementDeclEvent::ElementDeclEvent(Vector<const ElementType *> &elements,
 452                                    const ConstPtr<Dtd> &dtd,
 453                                    const Location &loc,
 454                                    Markup *markup)
 455 : MarkupEvent(elementDecl, loc, markup), dtd_(dtd)
 456 {
 457   elements.swap(elements_);
 458 }
 459
 460 AttlistDeclEvent::AttlistDeclEvent(Vector<const ElementType *> &elements,
 461                                    const ConstPtr<Dtd> &dtd,
 462                                    const Location &loc,
 463                                    Markup *markup)
 464 : MarkupEvent(attlistDecl, loc, markup), dtd_(dtd)
 465 {
 466   elements.swap(elements_);
 467 }
 468
 469 AttlistNotationDeclEvent::AttlistNotationDeclEvent(
 470   Vector<ConstPtr<Notation> > &notations, const Location &loc,
 471                                                    Markup *markup)
 472 : MarkupEvent(attlistNotationDecl, loc, markup)
 473 {
 474   notations.swap(notations_);
 475 }
 476
 477 LinkAttlistDeclEvent
 478 ::LinkAttlistDeclEvent(Vector<const ElementType *> &elements,
 479                        const ConstPtr<Lpd> &lpd,
 480                        const Location &loc,
 481                        Markup *markup)
 482 : MarkupEvent(linkAttlistDecl, loc, markup), lpd_(lpd)
 483 {
 484   elements.swap(elements_);
 485 }
 486
 487 LinkDeclEvent::LinkDeclEvent(const LinkSet *linkSet,
 488                              const ConstPtr<ComplexLpd> &lpd,
 489                              const Location &loc,
 490                              Markup *markup)
 491 : MarkupEvent(linkDecl, loc, markup), lpd_(lpd), linkSet_(linkSet)
 492 {
 493 }
 494
 495 IdLinkDeclEvent::IdLinkDeclEvent(const ConstPtr<ComplexLpd> &lpd,
 496                                  const Location &loc,
 497                                  Markup *markup)
 498 : MarkupEvent(linkDecl, loc, markup), lpd_(lpd)
 499 {
 500 }
 501
 502 ShortrefDeclEvent::ShortrefDeclEvent(const ShortReferenceMap *map,
 503                                      const ConstPtr<Dtd> &dtd,
 504                                      const Location &loc,
 505                                      Markup *markup)
 506 : MarkupEvent(shortrefDecl, loc, markup), map_(map), dtd_(dtd)
 507 {
 508 }
 509
 510 IgnoredMarkupEvent::IgnoredMarkupEvent(const Location &loc,
 511                                        Markup *markup)
 512 : MarkupEvent(ignoredMarkup, loc, markup)
 513 {
 514 }
 515
 516 EntityDefaultedEvent::EntityDefaultedEvent(const ConstPtr<Entity> &entity,
 517                                            const Location &loc)
 518 : LocatedEvent(entityDefaulted, loc), entity_(entity)
 519 {
 520 }
 521
 522 SgmlDeclEntityEvent::  SgmlDeclEntityEvent(const PublicId &publicId,
 523                                            PublicId::TextClass entityType,
 524                                            const StringC &effectiveSystemId,
 525                                            const Location &loc)
 526 : LocatedEvent(sgmlDeclEntity, loc), publicId_(publicId),
 527   entityType_(entityType), effectiveSystemId_(effectiveSystemId)
 528 {
 529 }
 530
 531 EventHandler::~EventHandler()
 532 {
 533 }
 534
 535 EventQueue::EventQueue()
 536 {
 537 }
 538
 539 #define EVENT(c, f) \
 540   void EventHandler::f(c *event) { delete event; } \
 541   void EventQueue::f(c *event) { append(event); } \
 542   void c::handle(EventHandler &handler) { handler.f(this); }
 543 #include "events.h"
 544 #undef EVENT
 545
 546 Pass1EventHandler::Pass1EventHandler()
 547 : hadError_(0), origHandler_(0)
 548 {
 549 }
 550
 551 void Pass1EventHandler::init(EventHandler *origHandler)
 552 {
 553   hadError_ = 0;
 554   origHandler_ = origHandler;
 555 }
 556
 557 void Pass1EventHandler::message(MessageEvent *event)
 558 {
 559   if (event->message().isError()) {
 560     hadError_ = 1;
 561     origHandler_->message(event);
 562   }
 563   else
 564     IQueue<Event>::append(event);
 565 }
 566
 567 #ifdef SP_NAMESPACE
 568 }
 569 #endif