ChangeSet ID: 1118955886501573614849807
CVSROOT: /cvsroot/wine
Module name: docs
Changes by: dimi(a)sc8-pr-cvs1.sourceforge.net 2005/06/16 14:04:46
Added files:
po4a/lib : SGMLS.pm
Log message:
Import of SGMLSpm 1.03ii.
Old revision New revision Changes Path
Added 1.1 +0 -0 docs/po4a/lib/SGMLS.pm
Index: docs/po4a/lib/SGMLS.pm
diff -u -p /dev/null docs/po4a/lib/SGMLS.pm:1.1
--- docs/po4a/lib/SGMLS.pm 16 Jun 2005 21: 4:46 -0000
+++ /dev/null 16 Jun 2005 21: 4:46 -0000
@@ -0,0 +1,893 @@
+package SGMLS;
+use Carp;
+
+$version = '$Revision: 1.1 $';
+
+=head1 NAME
+
+SGMLS - class for postprocessing the output from the B<sgmls> and
+B<nsgmls> parsers.
+
+=head1 SYNOPSIS
+
+ use SGMLS;
+
+ my $parse = new SGMLS(STDIN);
+
+ my $event = $parse->next_event;
+ while ($event) {
+
+ SWITCH: {
+
+ ($event->type eq 'start_element') && do {
+ my $element = $event->data; # An object of class SGMLS_Element
+ [[your code for the beginning of an element]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'end_element') && do {
+ my $element = $event->data; # An object of class SGMLS_Element
+ [[your code for the end of an element]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'cdata') && do {
+ my $cdata = $event->data; # A string
+ [[your code for character data]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'sdata') && do {
+ my $sdata = $event->data; # A string
+ [[your code for system data]]
+ last SWITCH;
+ };
+
+ ($event->type eq 're') && do {
+ [[your code for a record end]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'pi') && do {
+ my $pi = $event->data; # A string
+ [[your code for a processing instruction]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'entity') && do {
+ my $entity = $event->data; # An object of class SGMLS_Entity
+ [[your code for an external entity]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'start_subdoc') && do {
+ my $entity = $event->data; # An object of class SGMLS_Entity
+ [[your code for the beginning of a subdoc entity]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'end_subdoc') && do {
+ my $entity = $event->data; # An object of class SGMLS_Entity
+ [[your code for the end of a subdoc entity]]
+ last SWITCH;
+ };
+
+ ($event->type eq 'conforming') && do {
+ [[your code for a conforming document]]
+ last SWITCH;
+ };
+
+ die "Internal error: unknown event type " . $event->type . "\n";
+ }
+
+ $event = $parse->next_event;
+ }
+
+=head1 DESCRIPTION
+
+The B<SGMLS> package consists of several related classes: see
+L<"SGMLS">, L<"SGMLS_Event">, L<"SGMLS_Element">,
+L<"SGMLS_Attribute">, L<"SGMLS_Notation">, and L<"SGMLS_Entity">. All
+of these classes are available when you specify
+
+ use SGMLS;
+
+Generally, the only object which you will create explicitly will
+belong to the C<SGMLS> class; all of the others will then be created
+automatically for you over the course of the parse. Much fuller
+documentation is available in the C<.sgml> files in the C<DOC/>
+directory of the C<SGMLS.pm> distribution.
+
+=head2 The C<SGMLS> class
+
+This class holds a single parse. When you create an instance of it,
+you specify a file handle as an argument (if you are reading the
+output of B<sgmls> or B<nsgmls> from a pipe, the file handle will
+ordinarily be C<STDIN>):
+
+ my $parse = new SGMLS(STDIN);
+
+The most important method for this class is C<next_event>, which reads
+and returns the next major event from the input stream. It is
+important to note that the C<SGMLS> class deals with most B<ESIS>
+events itself: attributes and entity definitions, for example, are
+collected and stored automatically and invisibly to the user. The
+following list contains all of the methods for the C<SGMLS> class:
+
+=item C<next_event()>: Return an C<SGMLS_Event> object containing the
+next major event from the SGML parse.
+
+=item C<element()>: Return an C<SGMLS_Element> object containing the
+current element in the document.
+
+=item C<file()>: Return a string containing the name of the current
+SGML source file (this will work only if the C<-l> option was given to
+B<sgmls> or B<nsgmls>).
+
+=item C<line()>: Return a string containing the current line number
+from the source file (this will work only if the C<-l> option was
+given to B<sgmls> or B<nsgmls>).
+
+=item C<appinfo()>: Return a string containing the C<APPINFO>
+parameter (if any) from the SGML declaration.
+
+=item C<notation(NNAME)>: Return an C<SGMLS_Notation> object
+representing the notation named C<NNAME>. With newer versions of
+B<nsgmls>, all notations are available; otherwise, only the notations
+which are actually used will be available.
+
+=item C<entity(ENAME)>: Return an C<SGMLS_Entity> object representing
+the entity named C<ENAME>. With newer versions of B<nsgmls>, all
+entities are available; otherwise, only external data entities and
+internal entities used as attribute values will be available.
+
+=item C<ext()>: Return a reference to an associative array for
+user-defined extensions.
+
+
+=head2 The C<SGMLS_Event> class
+
+This class holds a single major event, as generated by the
+C<next_event> method in the C<SGMLS> class. It uses the following
+methods:
+
+=item C<type()>: Return a string describing the type of event:
+"start_element", "end_element", "cdata", "sdata", "re", "pi",
+"entity", "start_subdoc", "end_subdoc", and "conforming". See
+L<"SYNOPSIS">, above, for the values associated with each of these.
+
+=item C<data()>: Return the data associated with the current event (if
+any). For "start_element" and "end_element", returns an
+C<SGMLS_ELement> object; for "entity", "start_subdoc", and
+"end_subdoc", returns an C<SGMLS_Entity> object; for "cdata", "sdata",
+and "pi", returns a string; and for "re" and "conforming", returns the
+empty string. See L<"SYNOPSIS">, above, for an example of this
+method's use.
+
+=item C<key()>: Return a string key to the event, such as an element
+or entity name (otherwise, the same as C<data()>).
+
+=item C<file()>: Return the current file name, as in the C<SGMLS>
+class.
+
+=item C<line()>: Return the current line number, as in the C<SGMLS>
+class.
+
+=item C<element()>: Return the current element, as in the C<SGMLS>
+class.
+
+=item C<parse()>: Return the C<SGMLS> object which generated the
+event.
+
+=item C<entity(ENAME)>: Look up an entity, as in the C<SGMLS> class.
+
+=item C<notation(ENAME)>: Look up a notation, as in the C<SGMLS>
+class.
+
+=item C<ext()>: Return a reference to an associative array for
+user-defined extensions.
+
+
+=head2 The C<SGMLS_Element> class
+
+This class is used for elements, and contains all associated
+information (such as the element's attributes). It recognises the
+following methods:
+
+=item C<name()>: Return a string containing the name, or Generic
+Identifier, of the element, in upper case.
+
+=item C<parent()>: Return the C<SGMLS_Element> object for the
+element's parent (if any).
+
+=item C<parse()>: Return the C<SGMLS> object for the current parse.
+
+=item C<attributes()>: Return a reference to an associative array of
+attribute names and C<SGMLS_Attribute> structures. Attribute names
+will be all in upper case.
+
+=item C<attribute_names()>: Return an array of strings containing the
+names of all attributes defined for the current element, in upper
+case.
+
+=item C<attribute(ANAME)>: Return the C<SGMLS_Attribute> structure for
+the attribute C<ANAME>.
+
+=item C<set_attribute(ATTRIB)>: Add the C<SGMLS_Attribute> object
+C<ATTRIB> to the current element, replacing any other attribute
+structure with the same name.
+
+=item C<in(GI)>: Return C<true> (ie. 1) if the string C<GI> is the
+name of the current element's parent, or C<false> (ie. 0) if it is
+not.
+
+=item C<within(GI)>: Return C<true> (ie. 1) if the string C<GI> is the
+name of any of the ancestors of the current element, or C<false>
+(ie. 0) if it is not.
+
+=item C<ext()>: Return a reference to an associative array for
+user-defined extensions.
+
+
+=head2 The C<SGMLS_Attribute> class
+
+Each instance of an attribute for each C<SGMLS_Element> is an object
+belonging to this class, which recognises the following methods:
+
+=item C<name()>: Return a string containing the name of the current
+attribute, all in upper case.
+
+=item C<type()>: Return a string containing the type of the current
+attribute, all in upper case. Available types are "IMPLIED", "CDATA",
+"NOTATION", "ENTITY", and "TOKEN".
+
+=item C<value()>: Return the value of the current attribute, if any.
+This will be an empty string if the type is "IMPLIED", a string of
+some sort if the type is "CDATA" or "TOKEN" (if it is "TOKEN", you may
+want to split the string into a series of separate tokens), an
+C<SGMLS_Notation> object if the type is "NOTATION", or an
+C<SGMLS_Entity> object if the type is "ENTITY". Note that if the
+value is "CDATA", it will I<not> have escape sequences for 8-bit
+characters, record ends, or SDATA processed -- that will be your
+responsibility.
+
+=item C<is_implied()>: Return C<true> (ie. 1) if the value of the
+attribute is implied, or C<false> (ie. 0) if it is specified in the
+document.
+
+=item C<set_type(TYPE)>: Change the type of the attribute to the
+string C<TYPE> (which should be all in upper case). Available types
+are "IMPLIED", "CDATA", "NOTATION", "ENTITY", and "TOKEN".
+
+=item C<set_value(VALUE)>: Change the value of the attribute to
+C<VALUE>, which may be a string, an C<SGMLS_Entity> object, or an
+C<SGMLS_Notation> subject, depending on the attribute's type.
+
+=item C<ext()>: Return a reference to an associative array available
+for user-defined extensions.
+
+
+=head2 The C<SGMLS_Notation> class
+
+All declared notations appear as objects belonging to this class,
+which recognises the following methods:
+
+=item C<name()>: Return a string containing the name of the notation.
+
+=item C<sysid()>: Return a string containing the system identifier of
+the notation, if any.
+
+=item C<pubid()>: Return a string containing the public identifier of
+the notation, if any.
+
+=item C<ext()>: Return a reference to an associative array available
+for user-defined extensions.
+
+
+=head2 The C<SGMLS_Entity> class
+
+All declared entities appear as objects belonging to this class, which
+recognises the following methods:
+
+=item C<name()>: Return a string containing the name of the entity, in
+mixed case.
+
+=item C<type()>: Return a string containing the type of the entity, in
+upper case. Available types are "CDATA", "SDATA", "NDATA" (external
+entities only), "SUBDOC", "PI" (newer versions of B<nsgmls> only), or
+"TEXT" (newer versions of B<nsgmls> only).
+
+=item C<value()>: Return a string containing the value of the entity,
+if it is internal.
+
+=item C<sysid()>: Return a string containing the system identifier of
+the entity (if any), if it is external.
+
+=item C<pubid()>: Return a string containing the public identifier of
+the entity (if any), if it is external.
+
+=item C<filenames()>: Return an array of strings containing any file
+names generated from the identifiers, if the entity is external.
+
+=item C<notation()>: Return the C<SGMLS_Notation> object associated
+with the entity, if it is external.
+
+=item C<data_attributes()>: Return a reference to an associative array
+of data attribute names (in upper case) and the associated
+C<SGMLS_Attribute> objects for the current entity.
+
+=item C<data_attribute_names()>: Return an array of data attribute
+names (in upper case) for the current entity.
+
+=item C<data_attribute(ANAME)>: Return the C<SGMLS_Attribute> object
+for the data attribute named C<ANAME> for the current entity.
+
+=item C<set_data_attribute(ATTRIB)>: Add the C<SGMLS_Attribute> object
+C<ATTRIB> to the current entity, replacing any other data attribute
+with the same name.
+
+=item C<ext()>: Return a reference to an associative array for
+user-defined extensions.
+
+
+=head1 AUTHOR AND COPYRIGHT
+
+Copyright 1994 and 1995 by David Megginson,
+C<dmeggins(a)aix1.uottawa.ca>. Distributed under the terms of the Gnu
+General Public License (version 2, 1991) -- see the file C<COPYING>
+which is included in the B<SGMLS.pm> distribution.
+
+
+=head1 SEE ALSO:
+
+L<SGMLS::Output> and L<SGMLS::Refs>.
+
+=cut
+
+#
+# Data class for a single SGMLS ESIS output event. The object will
+# keep information about its own current element and, if available,
+# the source file and line where the event appeared.
+#
+# Event types are as follow:
+# Event Data
+# -------------------------------------------------------
+# 'start_element' SGMLS_Element
+# 'end_element' SGMLS_Element
+# 'cdata' string
+# 'sdata' string
+# 're' [none]
+# 'pi' string
+# 'entity' SGMLS_Entity
+# 'start_subdoc' SGMLS_Entity
+# 'end_subdoc' SGMLS_Entity
+# 'conforming' [none]
+#
+package SGMLS_Event;
+use Carp;
+ # Constructor.
+sub new {
+ my ($class,$type,$data,$parse) = @_;
+ return bless [$type,
+ $data,
+ $parse->file,
+ $parse->line,
+ $parse->element,
+ $parse,
+ {}
+ ];
+}
+ # Accessors.
+sub type { return $_[0]->[0]; }
+sub data { return $_[0]->[1]; }
+sub file { return $_[0]->[2]; }
+sub line { return $_[0]->[3]; }
+sub element { return $_[0]->[4]; }
+sub parse { return $_[0]->[5]; }
+sub ext { return $_[0]->[6]; }
+ # Generate a key for the event.
+sub key {
+ my $self = shift;
+ if (ref($self->data) eq SGMLS_Element ||
+ ref($self->data) eq SGMLS_Entity) {
+ return $self->data->name;
+ } else {
+ return $self->data;
+ }
+}
+ # Look up an entity in the parse.
+sub entity {
+ my ($self,$ename) = (@_);
+ return $self->parse->entity($ename);
+}
+ # Look up a notation in the parse.
+sub notation {
+ my ($self,$nname) = (@_);
+ return $self->parse->notation($nname);
+}
+
+
+#
+# Data class for a single SGML attribute. The object will know its
+# type, and will keep a value unless the type is 'IMPLIED', in which
+# case no meaningful value is available.
+#
+# Attribute types are as follow:
+# Type Value
+# ---------------------------------------
+# IMPLIED [none]
+# CDATA string
+# NOTATION SGMLS_Notation
+# ENTITY SGMLS_Entity
+# TOKEN string
+#
+package SGMLS_Attribute;
+use Carp;
+ # Constructor.
+sub new {
+ my ($class,$name,$type,$value) = @_;
+ return bless [$name,$type,$value,{}];
+}
+ # Accessors.
+sub name { return $_[0]->[0]; }
+sub type { return $_[0]->[1]; }
+sub value { return $_[0]->[2]; }
+sub ext { return $_[0]->[3]; }
+ # Return 1 if the value is implied.
+sub is_implied {
+ my $self = shift;
+ return ($self->type eq 'IMPLIED');
+}
+ # Set the attribute's type.
+sub set_type {
+ my ($self,$type) = @_;
+ $self->[1] = $type;
+}
+
+ # Set the attribute's value.
+sub set_value {
+ my ($self,$value) = @_;
+ $self->[2] = $value;
+}
+
+
+#
+# Data class for a single element of an SGML document. The object will not
+# know about its children (data or other elements), but it keeps track of its
+# parent and its attributes.
+#
+package SGMLS_Element;
+use Carp;
+ # Constructor.
+sub new {
+ my ($class,$name,$parent,$attributes,$parse) = @_;
+ return bless [$name,$parent,$attributes,$parse,{}];
+}
+ # Accessors.
+sub name { return $_[0]->[0]; }
+sub parent { return $_[0]->[1]; }
+sub parse { return $_[0]->[3]; }
+sub ext { return $_[0]->[4]; }
+
+ # Return the associative array of
+ # attributes, parsing it the first
+ # time through.
+sub attributes {
+ my $self = shift;
+ if (ref($self->[2]) eq 'ARRAY') {
+ my $new = {};
+ foreach (@{$self->[2]}) {
+ /^(\S+) (IMPLIED|CDATA|NOTATION|ENTITY|TOKEN)( (.*))?$/
+ || croak "Bad attribute event data: $_";
+ my ($name,$type,$value) = ($1,$2,$4);
+ if ($type eq 'NOTATION') {
+ $value = $self->parse->notation($value);
+ } elsif ($type eq 'ENTITY') {
+ $value = $self->parse->entity($value);
+ }
+ $new->{$name} =
+ new SGMLS_Attribute($name,$type,$value);
+ }
+ $self->[2] = $new;
+ }
+ return $self->[2];
+}
+ # Return a list of attribute names.
+sub attribute_names {
+ my $self = shift;
+ return keys(%{$self->attributes});
+}
+ # Find an attribute by name.
+sub attribute {
+ my ($self,$aname) = @_;
+ return $self->attributes->{$aname};
+}
+ # Add a new attribute.
+sub set_attribute {
+ my ($self,$attribute) = @_;
+ $self->attributes->{$attribute->name} = $attribute;
+}
+ # Check parent by name.
+sub in {
+ my ($self,$name) = @_;
+ if ($self->parent && $self->parent->name eq $name) {
+ return $self->parent;
+ } else {
+ return '';
+ }
+}
+ # Check ancestors by name.
+sub within {
+ my ($self,$name) = @_;
+ for ($self = $self->parent; $self; $self = $self->parent) {
+ return $self if ($self->name eq $name);
+ }
+ return '';
+}
+
+
+#
+# Data class for an SGML notation. The only information available
+# will be the name, the sysid, and the pubid -- the rest is up to the
+# processing application.
+#
+package SGMLS_Notation;
+use Carp;
+ # Constructor.
+sub new {
+ my ($class,$name,$sysid,$pubid) = @_;
+ return bless [$name,$sysid,$pubid,{}];
+}
+ # Accessors.
+sub name { return $_[0]->[0]; }
+sub sysid { return $_[0]->[1]; }
+sub pubid { return $_[0]->[2]; }
+sub ext { return $_[0]->[3]; }
+
+#
+# Data class for a single SGML entity. All entities will have a name
+# and a type. Internal entities will be of type CDATA or SDATA only,
+# and will have a value rather than a notation and sysid/pubid. External
+# CDATA, NDATA, and SDATA entities will always have notations attached,
+# and SUBDOC entities are always external (and will be parsed by SGMLS).
+#
+# Entity types are as follow:
+# Type Internal External
+# -----------------------------------------------------------
+# CDATA x x
+# NDATA x
+# SDATA x x
+# SUBDOC x
+# (newer versions of NSGMLS only:)
+# PI x
+# TEXT x x
+#
+package SGMLS_Entity;
+use Carp;
+ # Constructor.
+sub new {
+ my ($class,$name,$type,$value,$sysid,$pubid,$filenames,$notation) = @_;
+ return bless [$name,$type,$value,{},$sysid,$pubid,$filenames,$notation,{}];
+}
+ # Accessors.
+sub name { return $_[0]->[0]; }
+sub type { return $_[0]->[1]; }
+sub value { return $_[0]->[2]; }
+sub data_attributes { return $_[0]->[3]; }
+sub sysid { return $_[0]->[4]; }
+sub pubid { return $_[0]->[5]; }
+sub filenames { return $_[0]->[6]; }
+sub notation { return $_[0]->[7]; }
+sub ext { return $_[0]->[8]; }
+ # Return a list of data-attribute names.
+sub data_attribute_names {
+ my $self = shift;
+ return keys(%{$self->data_attributes});
+}
+ # Find a data attribute by name.
+sub data_attribute {
+ my ($self,$aname) = @_;
+ return $self->data_attributes->{$aname};
+}
+ # Add a new data attribute.
+sub set_data_attribute {
+ my ($self,$data_attribute) = @_;
+ $self->data_attributes()->{$data_attribute->name} = $data_attribute;
+}
+
+
+
+#
+# Data class for a single SGMLS parse. The constructor takes a single
+# argument, a file handle from which the SGMLS ESIS events will be read
+# (it may be a pipe, a fifo, a file, a socket, etc.). It is essential
+# that no two SGMLS objects have the same handle.
+#
+package SGMLS;
+ # Constructor.
+sub new {
+ my ($class,$handle) = @_;
+
+ # Force unqualified filehandles into caller's package
+ my ($package) = caller;
+ $handle =~ s/^[^':]+$/$package\:\:$&/;
+
+ return bless {
+ 'handle' => $handle,
+ 'event_stack' => [],
+ 'current_element' => '',
+ 'current_attributes' => [],
+ 'current_entities' => {},
+ 'entity_stack' => [],
+ 'current_notations' => {},
+ 'notation_stack' => [],
+ 'current_sysid' => '',
+ 'current_pubid' => '',
+ 'current_filenames' => [],
+ 'current_file' => '',
+ 'current_line' => '',
+ 'appinfo' => '',
+ 'ext' => {}
+ };
+}
+ # Accessors.
+sub element { return $_[0]->{'current_element'}; }
+sub file { return $_[0]->{'current_file'}; }
+sub line { return $_[0]->{'current_line'}; }
+sub appinfo { return $_[0]->{'appinfo'}; }
+sub ext { return $_[0]->{'ext'}; }
+
+ # Given its name, look up a notation.
+sub notation {
+ my ($self,$nname) = @_;
+ return $self->{'current_notations'}->{$nname};
+}
+ # Given its name, look up an entity.
+sub entity {
+ my ($self,$ename) = @_;
+ return $self->{'current_entities'}->{$ename};
+}
+
+ # Return the next SGMLS_Event, or ''
+ # if the document has finished.
+sub next_event {
+ my $self = shift;
+ my $handle = $self->{'handle'};
+
+ # If there are any queued up events,
+ # grab them first.
+ if ($#{$self->{event_stack}} >= 0) {
+ return pop @{$self->{event_stack}};
+ }
+
+ dispatch: while (!eof($handle)) {
+
+ my $c = getc($handle);
+ my $data = <$handle>;
+ chop $data;
+
+ ($c eq '(') && do { # start an element
+ $self->{'current_element'} =
+ new SGMLS_Element($data,
+ $self->{'current_element'},
+ $self->{'current_attributes'},
+ $self);
+ $self->{'current_attributes'} = [];
+ return new SGMLS_Event('start_element',
+ $self->{'current_element'},
+ $self);
+ };
+
+ ($c eq ')') && do { # end an element
+ my $old = $self->{'current_element'};
+ $self->{'current_element'} = $self->{'current_element'}->parent;
+ return new SGMLS_Event('end_element',$old,$self);
+ };
+
+ ($c eq '-') && do { # some data
+ my $sdata_flag = 0;
+ my $out = '';
+ while ($data =~ /\\(\\|n|\||[0-7]{1,3})/) {
+ $out .= $`;
+ $data = $';
+ # beginning or end of SDATA
+ if ($1 eq '|') {
+ if ("$out" ne '') {
+ unshift(@{$self->{'event_stack'}},
+ new SGMLS_Event($sdata_flag?'sdata':'cdata',
+ $out,
+ $self));
+ $out = '';
+ }
+ $sdata_flag = !$sdata_flag;
+ # record end
+ } elsif ($1 eq 'n') {
+ if ("$out" ne '') {
+ unshift(@{$self->{'event_stack'}},
+ new SGMLS_Event($sdata_flag?'sdata':'cdata',
+ $out,
+ $self));
+ $out = '';
+ }
+ unshift(@{$self->{'event_stack'}},
+ new SGMLS_Event('re','',$self));
+ } elsif ($1 eq '\\') {
+ $out .= '\\';
+ } else {
+ $out .= chr(oct($1));
+ }
+ }
+ $out .= $data;
+ if ("$out" ne '') {
+ unshift(@{$self->{'event_stack'}},
+ new SGMLS_Event($sdata_flag?'sdata':'cdata',
+ $out,
+ $self));
+ }
+ return $self->next_event;
+ };
+
+ ($c eq '&') && do { # external entity reference
+ return new SGMLS_Event('entity',
+ ($self->{'current_entities'}->{$data}
+ || croak "Unknown external entity: $data\n"),
+ $self);
+ };
+
+ ($c eq '?') && do { # processing instruction
+ return new SGMLS_Event('pi',
+ $data,
+ $self);
+ };
+
+ ($c eq 'A') && do { # attribute declaration
+ # (will parse only on demand)
+ push @{$self->{'current_attributes'}}, $data;
+ next dispatch;
+ };
+
+ ($c eq 'a') && do { # link attribute declaration
+ # NOT YET IMPLEMENTED!
+ next dispatch;
+ };
+
+ ($c eq 'D') && do { # data attribute declaration
+ $data =~ /^(\S+) (\S+) (\S+)( (.*))?$/
+ || croak "Bad data-attribute event data: $data";
+ my ($ename,$aname,$type,$value) = ($1,$2,$3,$5);
+ my $entity = $self->{'current_entities'}->{$ename};
+ my $attribute = new SGMLS_Attribute($aname,$type,$value);
+ $entity->set_data_attribute($attribute);
+ next dispatch;
+ };
+
+ ($c eq 'N') && do { # notation declaration
+ $self->{'current_notations'}->{$data} =
+ new SGMLS_Notation($data,
+ $self->{'current_sysid'},
+ $self->{'current_pubid'});
+ $self->{'current_sysid'} = '';
+ $self->{'current_pubid'} = '';
+ next dispatch;
+ };
+
+ ($c eq 'E') && do { # external entity declaration
+ $data =~ /^(\S+) (\S+) (\S+)$/
+ || croak "Bad external entity event data: $data";
+ my ($name,$type,$nname) = ($1,$2,$3);
+ my $notation = $self->{'current_notations'}->{$nname} if $nname;
+ $self->{'current_entities'}->{$name} =
+ new SGMLS_Entity($name,
+ $type,
+ '',
+ $self->{'current_sysid'},
+ $self->{'current_pubid'},
+ $self->{'current_filenames'},
+ $notation);
+ $self->{'current_sysid'} = '';
+ $self->{'current_pubid'} = '';
+ $self->{'current_filenames'} = [];
+ next dispatch;
+ };
+
+ ($c eq 'I') && do { # internal entity declaration
+ $data =~ /^(\S+) (\S+) (.*)$/
+ || croak "Bad external entity event data: $data";
+ my ($name,$type,$value) = ($1,$2,$3);
+ $self->{'current_entities'}->{$name} =
+ new SGMLS_Entity($name, $type, $value);
+ next dispatch;
+ };
+
+ ($c eq 'T') && do { # external text entity declaration
+ $self->{'current_entities'}->{$data} =
+ new SGMLS_Entity($data,
+ 'TEXT',
+ '',
+ $self->{'current_sysid'},
+ $self->{'current_pubid'},
+ $self->{'current_filenames'},
+ '');
+ $self->{'current_sysid'} = '';
+ $self->{'current_pubid'} = '';
+ $self->{'current_filenames'} = [];
+ next dispatch;
+ };
+
+ ($c eq 'S') && do { # subdocument entity declaration
+ $self->{'current_entities'}->{$data} =
+ new SGMLS_Entity($data,
+ 'SUBDOC',
+ '',
+ $self->{'current_sysid'},
+ $self->{'current_pubid'},
+ $self->{'current_filenames'},
+ '');
+ $self->{'current_sysid'} = '';
+ $self->{'current_pubid'} = '';
+ $self->{'current_filenames'} = [];
+ next dispatch;
+ };
+
+ ($c eq 's') && do { # system id
+ $self->{'current_sysid'} = $data;
+ next dispatch;
+ };
+
+ ($c eq 'p') && do { # public id
+ $self->{'current_pubid'} = $data;
+ next dispatch;
+ };
+
+ ($c eq 'f') && do { # generated filename
+ push @{$self->{'current_filenames'}}, $data;
+ next dispatch;
+ };
+
+ ($c eq '{') && do { # begin subdocument entity
+ my $subdoc = ($self->{'current_entities'}->{$data}||
+ croak "Unknown SUBDOC entity $data\n");
+ push @{$self->{'notation_stack'}}, $self->{'current_notations'};
+ push @{$self->{'entity_stack'}}, $self->{'current_entities'};
+ $self->{'current_notations'} = {};
+ $self->{'current_entities'} = {};
+ return new SGMLS_Event('start_subdoc',
+ $subdoc,
+ $self);
+ };
+
+ ($c eq '}') && do { # end subdocument entity
+ $self->{'current_notations'} = pop @{$self->{'notation_stack'}};
+ $self->{'current_entities'} = pop @{$self->{'entity_stack'}};
+ return new SGMLS_Event('end_subdoc',
+ ($self->{'current_entities'}->{$data} ||
+ croak "Unknown SUBDOC entity $data\n"),
+ $self);
+ };
+
+ ($c eq 'L') && do { # line number (and file name)
+ $data =~ /^(\d+)( (.*))?$/;
+ $self->{'current_line'} = $1;
+ $self->{'current_file'} = $3 if $3;
+ next dispatch;
+ };
+
+ ($c eq '#') && do { # APPINFO parameter
+ $self->{'appinfo'} = $data;
+ next dispatch;
+ };
+
+ ($c eq 'C') && do { # document is conforming
+ return new SGMLS_Event('conforming','',$self);
+ };
+ }
+ return '';
+}
+
+1;
+
+########################################################################
+# Local Variables:
+# mode: perl
+# End:
+########################################################################
