Message/DOM/ProcessingInstruction.pm

package Message::DOM::ProcessingInstruction;
use strict;
our $VERSION=do{my @r=(q$Revision: 1.4 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
push our @ISA, 'Message::DOM::Node', 'Message::IF::ProcessingInstruction';
require Message::DOM::Node;

sub ____new ($$$$) {
  my $self = shift->SUPER::____new (shift);
  ($$self->{target}, $$self->{data}) = @_;
  return $self;
} # ____new
             
sub AUTOLOAD {
  my $method_name = our $AUTOLOAD;
  $method_name =~ s/.*:://;
  return if $method_name eq 'DESTROY';

  if ({
    ## Read-only attributes (trivial accessors)
    target => 1,
    data => 1,
  }->{$method_name}) {
    no strict 'refs';
    eval qq{
      sub $method_name (\$) {
        if (\@_ > 1) {
          require Carp;
          Carp::croak (qq<Can't modify read-only attribute>);
        }
        return \${\$_[0]}->{$method_name}; 
      }
    };
    goto &{ $AUTOLOAD };
  } elsif ({
    ## Read-write attributes (DOMString, trivial accessors)
    manakai_base_uri => 1,
  }->{$method_name}) {
    no strict 'refs';
    eval qq{
      sub $method_name (\$;\$) {
        if (\@_ > 1) {
          if (\${\${\$_[0]}->{owner_document}}->{strict_error_checking} and
              \${\$_[0]}->{manakai_read_only}) {
            report Message::DOM::DOMException
                -object => \$_[0],
                -type => 'NO_MODIFICATION_ALLOWED_ERR',
                -subtype => 'READ_ONLY_NODE_ERR';
          }
          if (defined \$_[1]) {
            \${\$_[0]}->{$method_name} = ''.\$_[1];
          } else {
            delete \${\$_[0]}->{$method_name};
          }
        }
        return \${\$_[0]}->{$method_name};
      }
    };
    goto &{ $AUTOLOAD };
  } else {
    require Carp;
    Carp::croak (qq<Can't locate method "$AUTOLOAD">);
  }
} # AUTOLOAD
sub target ($);
sub data ($);

## |Node| attributes

sub base_uri ($) {
  my $self = $_[0];
  return $$self->{manakai_base_uri} if defined $$self->{manakai_base_uri};
  
  local $Error::Depth = $Error::Depth + 1;
  my $node = $$self->{parent_node};
  while (defined $node) {
    my $nt = $node->node_type;
    if ($nt == 1 or $nt == 6 or $nt == 9 or $nt == 10 or $nt == 11) {
      ## Element, Entity, Document, DocumentType, or DocumentFragment
      return $node->base_uri;
    } elsif ($nt == 5) {
      ## EntityReference
      return $node->manakai_entity_base_uri if $node->manakai_external;
    }
    $node = $$node->{parent_node};
  }
  return $node->base_uri if $node;
  return $self->owner_document->base_uri;
} # base_uri

sub child_nodes ($) {
  require Message::DOM::NodeList;
  return bless \\($_[0]), 'Message::DOM::NodeList::EmptyNodeList';
} # child_nodes

## The target of the processing instruction [DOM1, DOM2].
## Same as |ProcessingInstruction.target| [DOM3].

*node_name = \&target;

sub node_type () { 7 } # PROCESSING_INSTRUCTION_NODE

## The entire content exclude the target [DOM1, DOM2].
## Same as |ProcessingInstruction.data| [DOM3].

*node_value = \&data;

*text_content = \&node_value;

## |Node| methods

sub manakai_append_text ($$) {
  ## NOTE: Same as |CharacterData|'s.
  if (${${$_[0]}->{owner_document}}->{strict_error_checking} and
      ${$_[0]}->{manakai_read_only}) {
    report Message::DOM::DOMException
        -object => $_[0],
        -type => 'NO_MODIFICATION_ALLOWED_ERR',
        -subtype => 'READ_ONLY_NODE_ERR';
  }
  ${$_[0]}->{data} .= ref $_[1] eq 'SCALAR' ? ${$_[1]} : $_[1];
} # manakai_append_text

## |ProcessingInstruction| attributes

sub manakai_base_uri ($;$);

package Message::IF::ProcessingInstruction;

package Message::DOM::Document;

sub create_processing_instruction ($$$) {
  return Message::DOM::ProcessingInstruction->____new (@_[0, 1, 2]);
} # create_processing_instruction

=head1 LICENSE

Copyright 2007 Wakaba <w@suika.fam.cx>

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=cut

1;
## $Date: 2007/06/16 15:27:45 $
1	package Message::DOM::ProcessingInstruction;
2	use strict;
3	our $VERSION=do{my @r=(q$Revision: 1.4 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4	push our @ISA, 'Message::DOM::Node', 'Message::IF::ProcessingInstruction';
5	require Message::DOM::Node;
6
7	sub ____new ($$$$) {
8	my $self = shift->SUPER::____new (shift);
9	($$self->{target}, $$self->{data}) = @_;
10	return $self;
11	} # ____new
12
13	sub AUTOLOAD {
14	my $method_name = our $AUTOLOAD;
15	$method_name =~ s/.*:://;
16	return if $method_name eq 'DESTROY';
17
18	if ({
19	## Read-only attributes (trivial accessors)
20	target => 1,
21	data => 1,
22	}->{$method_name}) {
23	no strict 'refs';
24	eval qq{
25	sub $method_name (\$) {
26	if (\@_ > 1) {
27	require Carp;
28	Carp::croak (qq<Can't modify read-only attribute>);
29	}
30	return \${\$_[0]}->{$method_name};
31	}
32	};
33	goto &{ $AUTOLOAD };
34	} elsif ({
35	## Read-write attributes (DOMString, trivial accessors)
36	manakai_base_uri => 1,
37	}->{$method_name}) {
38	no strict 'refs';
39	eval qq{
40	sub $method_name (\$;\$) {
41	if (\@_ > 1) {
42	if (\${\${\$_[0]}->{owner_document}}->{strict_error_checking} and
43	\${\$_[0]}->{manakai_read_only}) {
44	report Message::DOM::DOMException
45	-object => \$_[0],
46	-type => 'NO_MODIFICATION_ALLOWED_ERR',
47	-subtype => 'READ_ONLY_NODE_ERR';
48	}
49	if (defined \$_[1]) {
50	\${\$_[0]}->{$method_name} = ''.\$_[1];
51	} else {
52	delete \${\$_[0]}->{$method_name};
53	}
54	}
55	return \${\$_[0]}->{$method_name};
56	}
57	};
58	goto &{ $AUTOLOAD };
59	} else {
60	require Carp;
61	Carp::croak (qq<Can't locate method "$AUTOLOAD">);
62	}
63	} # AUTOLOAD
64	sub target ($);
65	sub data ($);
66
67	## \|Node\| attributes
68
69	sub base_uri ($) {
70	my $self = $_[0];
71	return $$self->{manakai_base_uri} if defined $$self->{manakai_base_uri};
72
73	local $Error::Depth = $Error::Depth + 1;
74	my $node = $$self->{parent_node};
75	while (defined $node) {
76	my $nt = $node->node_type;
77	if ($nt == 1 or $nt == 6 or $nt == 9 or $nt == 10 or $nt == 11) {
78	## Element, Entity, Document, DocumentType, or DocumentFragment
79	return $node->base_uri;
80	} elsif ($nt == 5) {
81	## EntityReference
82	return $node->manakai_entity_base_uri if $node->manakai_external;
83	}
84	$node = $$node->{parent_node};
85	}
86	return $node->base_uri if $node;
87	return $self->owner_document->base_uri;
88	} # base_uri
89
90	sub child_nodes ($) {
91	require Message::DOM::NodeList;
92	return bless \\($_[0]), 'Message::DOM::NodeList::EmptyNodeList';
93	} # child_nodes
94
95	## The target of the processing instruction [DOM1, DOM2].
96	## Same as \|ProcessingInstruction.target\| [DOM3].
97
98	*node_name = \&target;
99
100	sub node_type () { 7 } # PROCESSING_INSTRUCTION_NODE
101
102	## The entire content exclude the target [DOM1, DOM2].
103	## Same as \|ProcessingInstruction.data\| [DOM3].
104
105	*node_value = \&data;
106
107	*text_content = \&node_value;
108
109	## \|Node\| methods
110
111	sub manakai_append_text ($$) {
112	## NOTE: Same as \|CharacterData\|'s.
113	if (${${$_[0]}->{owner_document}}->{strict_error_checking} and
114	${$_[0]}->{manakai_read_only}) {
115	report Message::DOM::DOMException
116	-object => $_[0],
117	-type => 'NO_MODIFICATION_ALLOWED_ERR',
118	-subtype => 'READ_ONLY_NODE_ERR';
119	}
120	${$_[0]}->{data} .= ref $_[1] eq 'SCALAR' ? ${$_[1]} : $_[1];
121	} # manakai_append_text
122
123	## \|ProcessingInstruction\| attributes
124
125	sub manakai_base_uri ($;$);
126
127	package Message::IF::ProcessingInstruction;
128
129	package Message::DOM::Document;
130
131	sub create_processing_instruction ($$$) {
132	return Message::DOM::ProcessingInstruction->____new (@_[0, 1, 2]);
133	} # create_processing_instruction
134
135	=head1 LICENSE
136
137	Copyright 2007 Wakaba <w@suika.fam.cx>
138
139	This program is free software; you can redistribute it and/or
140	modify it under the same terms as Perl itself.
141
142	=cut
143
144	1;
145	## $Date: 2007/06/16 15:27:45 $