ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/SCRAM/src/ActiveDoc/Parse.pm

Comparing COMP/SCRAM/src/ActiveDoc/Parse.pm (file contents):
Revision 1.1 by williamc, Tue Nov 23 17:20:55 1999 UTC vs.
Revision 1.10 by sashby, Tue Feb 27 13:33:04 2007 UTC

#	Line 9 | Line 9
9		#
10		# Interface
11		# ---------
12	<	# new()         : A new Parse object
12	>	# new()                 : A new Parse object
13		# addtag(name,start,text,end,$object)   : Add a new tag
14	<	# addgrouptags()  : add <Group> tag functionality
15	<	# addignoretags() : add <ignore> tag functionality
14	>	# addgrouptags()        : add <Group> tag functionality
15	>	# addignoretags()       : add <ignore> tag functionality
16		# parse(filename,[streamhandle], [streamexcludetag]) :
17		#                               parse the given file - turn on the stream
18		#                                  function of the switcher if a filehandle
19		#                                  supplied as a second argument
20	<	# line()        : return the current linenumber in the file
20	>	# line()                : return the current linenumber in the file
21		# tagstartline()        : return the linenumber of the last tag opening
22	<
22	>	# includeparse(Parse)   : include the settings from another parse object
23	>	# tags()                : return list of defined tags
24	>	# cleartags()           : clear of all tags
25	>	# opencontext(name)     : open a parse context
26	>	# closecontext(name)    : close a parse context
27	>	# includecontext(name)  : Process when in a given context
28	>	# excludecontext(name)  : No Processing when given context
29	>	# contexttag(tagname)   : Register the tagname as one able to change context
30	>	#                         if not registerd - the close tag will be ignored
31	>	#                         too if outside of the specified context!
32
33		package ActiveDoc::Parse;
34		require 5.004;
35	<	use ActiveDoc::Switcher;
36	<	use ActiveDoc::TagContainer;
37	<	use ActiveDoc::GroupChecker;
38	<
39	<	sub new {
40	<	my $class=shift;
41	<	$self={};
42	<	bless $self, $class;
43	<	$self->init();
44	<	return $self;
45	<	}
46	<
47	<	sub init {
48	<	my $self=shift;
49	<	$self->{gc}=GroupChecker->new();
50	<	$self->{gc}->include("all");
51	<	$self->{tags}=ActiveDoc::TagContainer->new();
52	<	}
53	<
54	<	sub parse {
55	<	my $self=shift;
56	<	my $file=shift;
57	<
58	<	# basic setup of switcher
59	<	$self->{switch}=ActiveDoc::Switcher->new($file);
60	<	$self->{switch}->usegroupchecker($self->{gc});
61	<	$self->{switch}->usetags($self->{tags});
62	<
63	<	# do we need to switch on the streamer?
64	<	if ( @_ ) {
65	<	$fh=shift;
66	<	$self->{switch}->stream($fh);
67	<	foreach $tag ( @_ ) {
68	<	$self->{switch}->streamexclude($tag);
69	<	}
70	<	}
71	<
72	<	# parse
73	<	$self->{switch}->parse();
74	<	undef $self->{switch};
75	<	}
76	<
77	<	sub line {
78	<	my $self=shift;
79	<	if ( defined $self->{switch} ) {
80	<	return $self->{switch}->line();
81	<	}
82	<	return undef;
83	<	}
84	<
85	<	sub tagstartline {
86	<	my $self=shift;
87	<	if ( defined $self->{switch} ) {
88	<	return $self->{switch}->tagstartline();
89	<	}
90	<	return undef;
91	<	}
92	<	sub addtag {
93	<	my $self=shift;
94	<	$self->{tags}->addtag(@_);
95	<	}
96	<
97	<	sub addgrouptags {
98	<	my $self=shift;
99	<	$self->{tags}->addtag("Group", \&Group_Start,$self,
100	<	"", $self, \&Group_End, $self);
101	<	$self->{tags}->setgrouptag("Group");
102	<	}
103	<
104	<	sub addignoretags {
105	<	my $self=shift;
106	<	$self->{gc}->exclude("ignore");
107	<	$self->{tags}->addtag("Ignore", \&Ignore_Start, $self,
99	<	"",$self, \&Ignore_End,$self);
100	<	}
101	<
102	<	# ---------  Basic Group Related Tags ---------------------------------
103	<
104	<	sub Group_Start {
105	<	my $self=shift;
106	<	my $name=shift;
107	<	my $vars=shift;
108	<	my $lastgp;
109	<
110	<	$lastgp="group::".$$vars{name};
111	<	$self->{switch}->checkparam($name, 'name');
112	<	$self->{gc}->opencontext("group::".$$vars{name});
113	<
114	<	}
115	<
116	<	sub Group_End {
117	<	my $self=shift;
118	<	my $name=shift;
119	<	my $lastgp;
120	<
121	<	$self->{gc}->closelastcontext("group");
122	<	}
123	<
124	<	sub Ignore_Start {
125	<	my $self=shift;
126	<	my $name=shift;
127	<
128	<	$self->{gc}->opencontext("ignore");
129	<	}
130	<
131	<	sub Ignore_End {
132	<	my $self=shift;
133	<	$self->{gc}->closecontext("ignore");
134	<	}
35	>	use XML::Parser;
36	>
37	>	sub new()
38	>	{
39	>	my $class=shift;
40	>	$self={};
41	>	bless $self, $class;
42	>	my ($dataclass, $parse_style)=@_;
43	>
44	>	$self->{xmlparser} = new XML::Parser (
45	>	Style => $parse_style,
46	>	ParseParamEnt => 1,
47	>	ErrorContext => 3,
48	>	Pkg   => $dataclass);
49	>	return $self;
50	>	}
51	>
52	>	sub parsefilelist()
53	>	{
54	>	my $self=shift;
55	>	my ($files)=@_;
56	>	}
57	>
58	>	sub parse()
59	>	{
60	>	my $self=shift;
61	>	my ($file)=@_;
62	>	$self->{data} = $self->{xmlparser}->parse($self->getfilestring_($file));
63	>	return $self;
64	>	}
65	>
66	>	sub getfilestring_()
67	>	{
68	>	my $self=shift;
69	>	my ($file)=@_;
70	>	open (IN, "< $file") or die __PACKAGE__.": Cannot read file $file: $!\n";
71	>	my $filestring = join("", <IN>);
72	>	close (IN) or die __PACKAGE__.": Cannot read file $file: $!\n";
73	>	# Strip spaces at the beginning and end of the line:
74	>	$filestring =~ s/^\s+//g;
75	>	$filestring =~ s/\s+$//g;
76	>	# Finally strip the newlines:
77	>	$filestring =~ s/\n//g;
78	>	# Strip out spaces in between tags:
79	>	$filestring =~ s/>\s+</></g;
80	>	$self->{filestring}=$filestring;
81	>	return $filestring;
82	>	}
83	>
84	>	sub data()
85	>	{
86	>	my $self=shift;
87	>	return $self->{data}->[0];
88	>	}
89	>
90	>	sub includeparse
91	>	{
92	>	my $self=shift;
93	>	my $obj=shift;
94	>	my $tag;
95	>
96	>	# copy the tags from  the remote parse object
97	>	foreach $tag ( $obj->tags() )
98	>	{
99	>	$self->addtag($tag,$obj->{tags}->tagsettings($tag));
100	>	}
101	>	}
102	>
103	>	sub addtag
104	>	{
105	>	my $self=shift;
106	>	$self->{tags}->addtag(@_);
107	>	}
108
109	+	1;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines