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.7 by sashby, Fri Dec 10 13:41:36 2004 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 parsefilelist()
87	>	{
88	>	my $self=shift;
89	>	my ($files)=@_;
90	>	# basic setup of switcher
91	>	$self->{switch}=ActiveDoc::Switcher->new($files);
92	>	$self->{switch}->usegroupchecker($self->{gc});
93	>	$self->{switch}->usetags($self->{tags});
94	>
95	>	# -- parse
96	>	$self->{switch}->parsefilelist();
97	>	undef $self->{switch};
98	>	}
99	>
100	>	sub line
101	>	{
102	>	my $self=shift;
103	>
104	>	if ( defined $self->{switch} )
105	>	{
106	>	return $self->{switch}->line();
107	>	}
108	>	return undef;
109	>	}
110	>
111	>	sub tagstartline
112	>	{
113	>	my $self=shift;
114	>
115	>	if ( defined $self->{switch} )
116	>	{
117	>	return $self->{switch}->tagstartline();
118	>	}
119	>	return undef;
120	>	}
121	>
122	>	sub includeparse
123	>	{
124	>	my $self=shift;
125	>	my $obj=shift;
126	>	my $tag;
127	>
128	>	# copy the tags from  the remote parse object
129	>	foreach $tag ( $obj->tags() )
130	>	{
131	>	$self->addtag($tag,$obj->{tags}->tagsettings($tag));
132	>	}
133	>	# now the group settings
134	>	}
135	>
136	>	sub addtag
137	>	{
138	>	my $self=shift;
139	>
140	>	$self->{tags}->addtag(@_);
141	>	$self->verbose(">> Adding tag ".@_." ");
142	>	}
143	>
144	>	sub addgrouptags
145	>	{
146	>	my $self=shift;
147	>
148	>	$self->verbose(">> Adding a group tag");
149	>	$self->{tags}->addtag("Group", \&Group_Start,$self,
150	>	"", $self, \&Group_End, $self);
151	>	$self->{tags}->setgrouptag("Group");
152	>	}
153	>
154	>	sub addignoretags
155	>	{
156	>	my $self=shift;
157	>
158	>	$self->verbose(">> Adding an IGNORE tag");
159	>	$self->{gc}->exclude("ignore");
160	>	$self->{tags}->addtag("Ignore", \&Ignore_Start, $self,
161	>	"",$self, \&Ignore_End,$self);
162	>	$self->{tags}->setgrouptag("Ignore");
163	>	}
164	>
165	>	sub contexttag
166	>	{
167	>	my $self=shift;
168	>	my $name=shift;
169	>
170	>	$self->verbose("-- contexttag: ".$name." ");
171	>	$self->{tags}->setgrouptag($name);
172	>	}
173	>
174	>	sub opencontext
175	>	{
176	>	my $self=shift;
177	>	my $name=shift;
178	>
179	>	$self->verbose("-- opencontext: ".$name." ");
180	>	$self->{gc}->opencontext($name);
181	>	}
182	>
183	>	sub closecontext
184	>	{
185	>	my $self=shift;
186	>	my $name=shift;
187	>
188	>	$self->verbose("-- closecontext: ".$name." ");
189	>	$self->{gc}->closecontext($name);
190	>	}
191	>
192	>	sub includecontext
193	>	{
194	>	my $self=shift;
195	>	my $name=shift;
196	>
197	>	$self->verbose("-- includecontext : ".$name." ");
198	>	$self->{gc}->unexclude($name);
199	>	$self->{gc}->include($name);
200	>	}
201	>
202	>	sub excludecontext
203	>	{
204	>	my $self=shift;
205	>	my $name=shift;
206	>	$self->verbose("-- excludecontext: ".$name." ");
207	>	$self->{gc}->exclude($name);
208	>	$self->{gc}->uninclude($name);
209	>	}
210	>
211	>	sub cleartags
212	>	{
213	>	my $self=shift;
214	>	$self->verbose(">> Clearing TAGS");
215	>	$self->{tags}->cleartags();
216	>	}
217
218		sub tags {
219		my $self=shift;
220	+	$self->verbose("-- tags");
221		return $self->{tags}->tags();
222		}
223
224		# ---------  Basic Group Related Tags ---------------------------------
225
226	<	sub Group_Start {
227	<	my $self=shift;
228	<	my $name=shift;
229	<	my $vars=shift;
230	<	my $lastgp;
231	<
232	<	$lastgp="group::".$$vars{name};
233	<	$self->{switch}->checkparam($name, 'name');
234	<	$self->{gc}->opencontext("group::".$$vars{name});
235	<
236	<	}
237	<
238	<	sub Group_End {
239	<	my $self=shift;
240	<	my $name=shift;
241	<	my $lastgp;
242	<
243	<	$self->{gc}->closelastcontext("group");
244	<	}
245	<
246	<	sub Ignore_Start {
247	<	my $self=shift;
248	<	my $name=shift;
249	<
250	<	$self->{gc}->opencontext("ignore");
251	<	}
252	<
253	<	sub Ignore_End {
254	<	my $self=shift;
255	<	$self->{gc}->closecontext("ignore");
256	<	}
226	>	sub Group_Start
227	>	{
228	>	my $self=shift;
229	>	my $name=shift;
230	>	my $vars=shift;
231	>	my $lastgp;
232	>
233	>	$self->verbose(">> Group_Start: ".$name." ");
234	>	$lastgp="group::".$$vars{name};
235	>	$self->{switch}->checkparam($name, 'name');
236	>	$self->{gc}->opencontext("group::".$$vars{name});
237	>
238	>	}
239	>
240	>	sub Group_End
241	>	{
242	>	my $self=shift;
243	>	my $name=shift;
244	>	my $lastgp;
245	>
246	>	$self->verbose(">> Group_End: ".$name." ");
247	>	$self->{gc}->closelastcontext("group");
248	>	}
249	>
250	>	sub Ignore_Start
251	>	{
252	>	my $self=shift;
253	>	my $name=shift;
254	>
255	>	$self->verbose(">> Ignore_Start: ".$name." ");
256	>	$self->{gc}->opencontext("ignore");
257	>	}
258	>
259	>	sub Ignore_End
260	>	{
261	>	my $self=shift;
262	>
263	>	$self->verbose(">> Ignore_End: ".$name." ");
264	>	$self->{gc}->closecontext("ignore");
265	>	}
266

Diff Legend

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