src/ActiveDoc/Parse.pm

#
# Parse.pm
#
# Originally Written by Christopher Williams
#
# Description
# -----------
# maintain parse configurations
#
# Interface
# ---------
# new()                 : A new Parse object
# addtag(name,start,text,end,$object)   : Add a new tag
# addgrouptags()        : add <Group> tag functionality
# addignoretags()       : add <ignore> tag functionality
# parse(filename,[streamhandle], [streamexcludetag]) : 
#                               parse the given file - turn on the stream
#                                  function of the switcher if a filehandle
#                                  supplied as a second argument
# line()                : return the current linenumber in the file
# tagstartline()        : return the linenumber of the last tag opening 
# includeparse(Parse)   : include the settings from another parse object
# tags()                : return list of defined tags
# cleartags()           : clear of all tags
# opencontext(name)     : open a parse context
# closecontext(name)    : close a parse context
# includecontext(name)  : Process when in a given context
# excludecontext(name)  : No Processing when given context
# contexttag(tagname)   : Register the tagname as one able to change context
#                         if not registerd - the close tag will be ignored
#                         too if outside of the specified context!


package ActiveDoc::Parse;
require 5.004;
use ActiveDoc::Switcher;
use ActiveDoc::TagContainer;
use ActiveDoc::GroupChecker;
use Utilities::Verbose;

@ISA=qw(Utilities::Verbose);

sub new
   {
   my $class=shift;
   $self={};
   bless $self, $class;
   $self->init();
   return $self;
   }

sub init
   {
   my $self=shift;
   $self->{gc}=GroupChecker->new();
   $self->{gc}->include("all");
   $self->{tags}=ActiveDoc::TagContainer->new();
   }

sub parse
   {
   my $self=shift;
   my $file=shift;
   
   # basic setup of switcher
   $self->{switch}=ActiveDoc::Switcher->new($file);
   $self->{switch}->usegroupchecker($self->{gc});
   $self->{switch}->usetags($self->{tags});

   # do we need to switch on the streamer?
   if ( @_ )
      {
      $fh=shift;
      $self->{switch}->stream($fh);
      foreach $tag ( @_ )
         {
         $self->{switch}->streamexclude($tag);
         }
      }

   # -- parse
   $self->{switch}->parse();
   undef $self->{switch};
   }

sub parsefilelist()
   {
   my $self=shift;
   my ($files)=@_;
   # basic setup of switcher
   $self->{switch}=ActiveDoc::Switcher->new($files);   
   $self->{switch}->usegroupchecker($self->{gc});
   $self->{switch}->usetags($self->{tags});

   # -- parse
   $self->{switch}->parsefilelist();
   undef $self->{switch};
   }

sub line
   {
   my $self=shift;
   
   if ( defined $self->{switch} )
      {
      return $self->{switch}->line();
      }
   return undef;
   }

sub tagstartline
   {
   my $self=shift;

   if ( defined $self->{switch} )
      {
      return $self->{switch}->tagstartline();
      }
   return undef;
   }

sub includeparse
   {
   my $self=shift;
   my $obj=shift;
   my $tag;
   
   # copy the tags from  the remote parse object
   foreach $tag ( $obj->tags() )
      {
      $self->addtag($tag,$obj->{tags}->tagsettings($tag));
      }
   # now the group settings
   }

sub addtag
   {
   my $self=shift;

   $self->{tags}->addtag(@_);
   $self->verbose(">> Adding tag ".@_." ");
   }

sub addgrouptags
   {
   my $self=shift;
   
   $self->verbose(">> Adding a group tag");
   $self->{tags}->addtag("Group", \&Group_Start,$self, 
                         "", $self, \&Group_End, $self);
   $self->{tags}->setgrouptag("Group");
   }

sub addignoretags
   {
   my $self=shift;

   $self->verbose(">> Adding an IGNORE tag");
   $self->{gc}->exclude("ignore");
   $self->{tags}->addtag("Ignore", \&Ignore_Start, $self,
                         "",$self, \&Ignore_End,$self);
   $self->{tags}->setgrouptag("Ignore");
   }

sub contexttag
   {
   my $self=shift;
   my $name=shift;
   
   $self->verbose("-- contexttag: ".$name." ");
   $self->{tags}->setgrouptag($name);
   }

sub opencontext
   {
   my $self=shift;
   my $name=shift;

   $self->verbose("-- opencontext: ".$name." ");
   $self->{gc}->opencontext($name);
   }

sub closecontext
   {
   my $self=shift;
   my $name=shift;

   $self->verbose("-- closecontext: ".$name." ");
   $self->{gc}->closecontext($name);
   }

sub includecontext
   {
   my $self=shift;
   my $name=shift;

   $self->verbose("-- includecontext : ".$name." ");
   $self->{gc}->unexclude($name);
   $self->{gc}->include($name);
   }

sub excludecontext
   {
   my $self=shift;
   my $name=shift;
   $self->verbose("-- excludecontext: ".$name." ");
   $self->{gc}->exclude($name);
   $self->{gc}->uninclude($name);
   }

sub cleartags
   {
   my $self=shift;
   $self->verbose(">> Clearing TAGS");
   $self->{tags}->cleartags();
   }

sub tags {
         my $self=shift;
         $self->verbose("-- tags");
         return $self->{tags}->tags();
}

# ---------  Basic Group Related Tags ---------------------------------

sub Group_Start
   {
   my $self=shift;
   my $name=shift;
   my $vars=shift;
   my $lastgp;

   $self->verbose(">> Group_Start: ".$name." ");
   $lastgp="group::".$$vars{name};
   $self->{switch}->checkparam($name, 'name');
   $self->{gc}->opencontext("group::".$$vars{name});
   
   }

sub Group_End
   {
   my $self=shift;
   my $name=shift;
   my $lastgp;
   
   $self->verbose(">> Group_End: ".$name." ");
   $self->{gc}->closelastcontext("group");
   }

sub Ignore_Start
   {
   my $self=shift;
   my $name=shift;
   
   $self->verbose(">> Ignore_Start: ".$name." ");
   $self->{gc}->opencontext("ignore");
   }

sub Ignore_End
   {
   my $self=shift;

   $self->verbose(">> Ignore_End: ".$name." ");
   $self->{gc}->closecontext("ignore");
   }

Revision:	1.7
Committed:	Fri Dec 10 13:41:36 2004 UTC (20 years, 5 months ago) by sashby
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V1_0_2, V1_0_2_p1, v102p1, V1_0_1, V1_0_0
Branch point for:	v103_branch
Changes since 1.6:	+14 -0 lines
Log Message:	Merged V1_0 branch to HEAD
#	User	Rev	Content
1	williamc	1.1	#
2			# Parse.pm
3			#
4			# Originally Written by Christopher Williams
5			#
6			# Description
7			# -----------
8			# maintain parse configurations
9			#
10			# Interface
11			# ---------
12	sashby	1.6	# new() : A new Parse object
13	williamc	1.1	# addtag(name,start,text,end,$object) : Add a new tag
14	sashby	1.6	# addgrouptags() : add <Group> tag functionality
15			# addignoretags() : add <ignore> tag functionality
16	williamc	1.1	# 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	sashby	1.6	# line() : return the current linenumber in the file
21	williamc	1.1	# tagstartline() : return the linenumber of the last tag opening
22	sashby	1.6	# includeparse(Parse) : include the settings from another parse object
23	williamc	1.2	# tags() : return list of defined tags
24	williamc	1.3	# cleartags() : clear of all tags
25	sashby	1.6	# opencontext(name) : open a parse context
26	williamc	1.4	# 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	williamc	1.1
33
34			package ActiveDoc::Parse;
35			require 5.004;
36			use ActiveDoc::Switcher;
37			use ActiveDoc::TagContainer;
38			use ActiveDoc::GroupChecker;
39	sashby	1.6	use Utilities::Verbose;
40	williamc	1.1
41	sashby	1.6	@ISA=qw(Utilities::Verbose);
42	williamc	1.1
43	sashby	1.6	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	sashby	1.7	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	sashby	1.6	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	williamc	1.3
218			sub tags {
219			my $self=shift;
220	sashby	1.6	$self->verbose("-- tags");
221	williamc	1.3	return $self->{tags}->tags();
222			}
223
224	williamc	1.1	# --------- Basic Group Related Tags ---------------------------------
225
226	sashby	1.6	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	williamc	1.1