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.4 by williamc, Wed Feb 23 14:53:13 2000 UTC vs.
Revision 1.6 by sashby, Wed Mar 27 17:35:48 2002 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	<	# includeparse(Parse) : include the settings from another parse object
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
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
#	Line 36 | Line 36 | require 5.004;
36		use ActiveDoc::Switcher;
37		use ActiveDoc::TagContainer;
38		use ActiveDoc::GroupChecker;
39	+	use Utilities::Verbose;
40
41	<	sub new {
41	<	my $class=shift;
42	<	$self={};
43	<	bless $self, $class;
44	<	$self->init();
45	<	return $self;
46	<	}
47	<
48	<	sub init {
49	<	my $self=shift;
50	<	$self->{gc}=GroupChecker->new();
51	<	$self->{gc}->include("all");
52	<	$self->{tags}=ActiveDoc::TagContainer->new();
53	<	}
54	<
55	<	sub parse {
56	<	my $self=shift;
57	<	my $file=shift;
58	<
59	<	# basic setup of switcher
60	<	$self->{switch}=ActiveDoc::Switcher->new($file);
61	<	$self->{switch}->usegroupchecker($self->{gc});
62	<	$self->{switch}->usetags($self->{tags});
63	<
64	<	# do we need to switch on the streamer?
65	<	if ( @_ ) {
66	<	$fh=shift;
67	<	$self->{switch}->stream($fh);
68	<	foreach $tag ( @_ ) {
69	<	$self->{switch}->streamexclude($tag);
70	<	}
71	<	}
72	<
73	<	# parse
74	<	$self->{switch}->parse();
75	<	undef $self->{switch};
76	<	}
77	<
78	<	sub line {
79	<	my $self=shift;
80	<	if ( defined $self->{switch} ) {
81	<	return $self->{switch}->line();
82	<	}
83	<	return undef;
84	<	}
85	<
86	<	sub tagstartline {
87	<	my $self=shift;
88	<	if ( defined $self->{switch} ) {
89	<	return $self->{switch}->tagstartline();
90	<	}
91	<	return undef;
92	<	}
93	<
94	<	sub includeparse {
95	<	my $self=shift;
96	<	my $obj=shift;
97	<
98	<	my $tag;
99	<	# copy the tags from  the remote parse object
100	<	foreach $tag ( $obj->tags() ) {
101	<	$self->addtag($tag,$obj->{tags}->tagsettings($tag));
102	<	}
103	<	# now the group settings
104	<	}
105	<
106	<	sub addtag {
107	<	my $self=shift;
108	<	$self->{tags}->addtag(@_);
109	<	}
110	<
111	<	sub addgrouptags {
112	<	my $self=shift;
113	<	$self->{tags}->addtag("Group", \&Group_Start,$self,
114	<	"", $self, \&Group_End, $self);
115	<	$self->{tags}->setgrouptag("Group");
116	<	}
41	>	@ISA=qw(Utilities::Verbose);
42
43	<	sub addignoretags {
44	<	my $self=shift;
45	<	$self->{gc}->exclude("ignore");
46	<	$self->{tags}->addtag("Ignore", \&Ignore_Start, $self,
47	<	"",$self, \&Ignore_End,$self);
48	<	$self->{tags}->setgrouptag("Ignore");
49	<	}
50	<
51	<	sub contexttag {
52	<	my $self=shift;
53	<	$self->{tags}->setgrouptag(shift);
54	<	}
55	<
56	<	sub opencontext {
57	<	my $self=shift;
58	<	$self->{gc}->opencontext(shift);
59	<	}
60	<
61	<	sub closecontext {
62	<	my $self=shift;
63	<	$self->{gc}->closecontext(shift);
64	<	}
65	<
66	<	sub includecontext {
67	<	my $self=shift;
68	<	my $name=shift;
69	<
70	<	$self->{gc}->unexclude($name);
71	<	$self->{gc}->include($name);
72	<	}
73	<
74	<	sub excludecontext {
75	<	my $self=shift;
76	<	my $name=shift;
77	<	$self->{gc}->exclude($name);
78	<	$self->{gc}->uninclude($name);
79	<	}
80	<
81	<	sub cleartags {
82	<	my $self=shift;
83	<	$self->{tags}->cleartags();
84	<	}
43	>	sub new
44	>	{
45	>	my $class=shift;
46	>	$self={};
47	>	bless $self, $class;
48	>	$self->init();
49	>	return $self;
50	>	}
51	>
52	>	sub init
53	>	{
54	>	my $self=shift;
55	>	$self->{gc}=GroupChecker->new();
56	>	$self->{gc}->include("all");
57	>	$self->{tags}=ActiveDoc::TagContainer->new();
58	>	}
59	>
60	>	sub parse
61	>	{
62	>	my $self=shift;
63	>	my $file=shift;
64	>
65	>	# basic setup of switcher
66	>	$self->{switch}=ActiveDoc::Switcher->new($file);
67	>	$self->{switch}->usegroupchecker($self->{gc});
68	>	$self->{switch}->usetags($self->{tags});
69	>
70	>	# do we need to switch on the streamer?
71	>	if ( @_ )
72	>	{
73	>	$fh=shift;
74	>	$self->{switch}->stream($fh);
75	>	foreach $tag ( @_ )
76	>	{
77	>	$self->{switch}->streamexclude($tag);
78	>	}
79	>	}
80	>
81	>	# -- parse
82	>	$self->{switch}->parse();
83	>	undef $self->{switch};
84	>	}
85	>
86	>	sub line
87	>	{
88	>	my $self=shift;
89	>
90	>	if ( defined $self->{switch} )
91	>	{
92	>	return $self->{switch}->line();
93	>	}
94	>	return undef;
95	>	}
96	>
97	>	sub tagstartline
98	>	{
99	>	my $self=shift;
100	>
101	>	if ( defined $self->{switch} )
102	>	{
103	>	return $self->{switch}->tagstartline();
104	>	}
105	>	return undef;
106	>	}
107	>
108	>	sub includeparse
109	>	{
110	>	my $self=shift;
111	>	my $obj=shift;
112	>	my $tag;
113	>
114	>	# copy the tags from  the remote parse object
115	>	foreach $tag ( $obj->tags() )
116	>	{
117	>	$self->addtag($tag,$obj->{tags}->tagsettings($tag));
118	>	}
119	>	# now the group settings
120	>	}
121	>
122	>	sub addtag
123	>	{
124	>	my $self=shift;
125	>
126	>	$self->{tags}->addtag(@_);
127	>	$self->verbose(">> Adding tag ".@_." ");
128	>	}
129	>
130	>	sub addgrouptags
131	>	{
132	>	my $self=shift;
133	>
134	>	$self->verbose(">> Adding a group tag");
135	>	$self->{tags}->addtag("Group", \&Group_Start,$self,
136	>	"", $self, \&Group_End, $self);
137	>	$self->{tags}->setgrouptag("Group");
138	>	}
139	>
140	>	sub addignoretags
141	>	{
142	>	my $self=shift;
143	>
144	>	$self->verbose(">> Adding an IGNORE tag");
145	>	$self->{gc}->exclude("ignore");
146	>	$self->{tags}->addtag("Ignore", \&Ignore_Start, $self,
147	>	"",$self, \&Ignore_End,$self);
148	>	$self->{tags}->setgrouptag("Ignore");
149	>	}
150	>
151	>	sub contexttag
152	>	{
153	>	my $self=shift;
154	>	my $name=shift;
155	>
156	>	$self->verbose("-- contexttag: ".$name." ");
157	>	$self->{tags}->setgrouptag($name);
158	>	}
159	>
160	>	sub opencontext
161	>	{
162	>	my $self=shift;
163	>	my $name=shift;
164	>
165	>	$self->verbose("-- opencontext: ".$name." ");
166	>	$self->{gc}->opencontext($name);
167	>	}
168	>
169	>	sub closecontext
170	>	{
171	>	my $self=shift;
172	>	my $name=shift;
173	>
174	>	$self->verbose("-- closecontext: ".$name." ");
175	>	$self->{gc}->closecontext($name);
176	>	}
177	>
178	>	sub includecontext
179	>	{
180	>	my $self=shift;
181	>	my $name=shift;
182	>
183	>	$self->verbose("-- includecontext : ".$name." ");
184	>	$self->{gc}->unexclude($name);
185	>	$self->{gc}->include($name);
186	>	}
187	>
188	>	sub excludecontext
189	>	{
190	>	my $self=shift;
191	>	my $name=shift;
192	>	$self->verbose("-- excludecontext: ".$name." ");
193	>	$self->{gc}->exclude($name);
194	>	$self->{gc}->uninclude($name);
195	>	}
196	>
197	>	sub cleartags
198	>	{
199	>	my $self=shift;
200	>	$self->verbose(">> Clearing TAGS");
201	>	$self->{tags}->cleartags();
202	>	}
203
204		sub tags {
205		my $self=shift;
206	+	$self->verbose("-- tags");
207		return $self->{tags}->tags();
208		}
209
210		# ---------  Basic Group Related Tags ---------------------------------
211
212	<	sub Group_Start {
213	<	my $self=shift;
214	<	my $name=shift;
215	<	my $vars=shift;
216	<	my $lastgp;
217	<
218	<	$lastgp="group::".$$vars{name};
219	<	$self->{switch}->checkparam($name, 'name');
220	<	$self->{gc}->opencontext("group::".$$vars{name});
221	<
222	<	}
223	<
224	<	sub Group_End {
225	<	my $self=shift;
226	<	my $name=shift;
227	<	my $lastgp;
228	<
229	<	$self->{gc}->closelastcontext("group");
230	<	}
231	<
232	<	sub Ignore_Start {
233	<	my $self=shift;
234	<	my $name=shift;
235	<
236	<	$self->{gc}->opencontext("ignore");
237	<	}
238	<
239	<	sub Ignore_End {
240	<	my $self=shift;
241	<	$self->{gc}->closecontext("ignore");
242	<	}
212	>	sub Group_Start
213	>	{
214	>	my $self=shift;
215	>	my $name=shift;
216	>	my $vars=shift;
217	>	my $lastgp;
218	>
219	>	$self->verbose(">> Group_Start: ".$name." ");
220	>	$lastgp="group::".$$vars{name};
221	>	$self->{switch}->checkparam($name, 'name');
222	>	$self->{gc}->opencontext("group::".$$vars{name});
223	>
224	>	}
225	>
226	>	sub Group_End
227	>	{
228	>	my $self=shift;
229	>	my $name=shift;
230	>	my $lastgp;
231	>
232	>	$self->verbose(">> Group_End: ".$name." ");
233	>	$self->{gc}->closelastcontext("group");
234	>	}
235	>
236	>	sub Ignore_Start
237	>	{
238	>	my $self=shift;
239	>	my $name=shift;
240	>
241	>	$self->verbose(">> Ignore_Start: ".$name." ");
242	>	$self->{gc}->opencontext("ignore");
243	>	}
244	>
245	>	sub Ignore_End
246	>	{
247	>	my $self=shift;
248	>
249	>	$self->verbose(">> Ignore_End: ".$name." ");
250	>	$self->{gc}->closecontext("ignore");
251	>	}
252

Diff Legend

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