src/ActiveDoc/Switcher.pm

# Switcher Module
#
# Look for elements given in input has in a string
# If found then call a routine name with the same name
# Implemented as an object to maintain state info between each line
# processed.
# Interface
# ---------
#
# new(file,objectref) : A new object -  filename of file to parse
#                                       objectref->of the methods
# usetags(tagobjref)               : Specify a tagcontainer set to direct to
#                                    to the desired routines
# usegroupchecker(groupchecker)    : Set a groupchecker
# parse()                          : Parse the file                             
# line()                           : return the current line number of the parse
# tagstartline()                   : return the line number on which the current
#                                    tag was opened
# stream(filehandle)               : stream output to the filehandle if not handled
#                                    in any other way
package ActiveDoc::Switcher;
use Utilities::Verbose;
require 5.001;
use Carp;

@ISA=qw(Utilities::Verbose);

sub new { 
        my $class=shift;
        my $file=shift;
        my $objectname=shift;
        my $groupchecker=shift;

        $self = {};
        $self->{allw}=$objectname;
        bless $self, $class;
        $self->_initialise($file);
        return $self;
}

sub stream {
        my $self=shift;

        $self->{stream}=shift;
}

sub streamexclude {
        my $self=shift;
        my $tag=shift;

        $tag=~tr/A-Z/a-z/;
        $self->{streamexclude}{$tag}=1;
}

sub _initialise (hash1)
   {
   my $self=shift;
   $self->{filename}=shift;
   $self->verbose(">> New ActiveDoc::Switcher created.");
   # add a default groupchecker
   use ActiveDoc::GroupChecker;
   $self->{groupchecker}=GroupChecker->new();
   $self->{groupchecker}->include("all");

   # Add a default TagContainer
   use ActiveDoc::TagContainer;
   $self->{tagcontainer}=ActiveDoc::TagContainer->new();
   
   }

sub usetags {
        my $self=shift;
        my $tagcontainer=shift;

        $self->{tagcontainer}=$tagcontainer;
}

sub usegroupchecker {
        my $self=shift;
        my $ref=shift;
        
        $self->{groupchecker}=$ref;
}

sub parse {
        my $self=shift;
        my $char;
        my $buf;
        $self->{linecount}=0;
        $self->_resetvars();
        $self->{streamstore}="";
        $self->{streamtmp}="";

        # Open the file
        use FileHandle;
        local $filehandle;
        $filehandle=FileHandle->new();
        
        $self->verbose(">> Reading file: ".$self->{filename}." ");

        $filehandle->open("<".$self->{filename})
           or return 1;

        # Start file processing
        while ( ($_=<$filehandle>) ) {
         $self->{linecount}++;
         # Skip lines that start with a hash. A better way
         # of adding comments than ignore tags:
         next if (/^#/);
         $self->{currentline}=$_;
         $self->{stringpos}=0;
         while ( ($char=$self->_nextchar()) ne "" ) {
           $self->_checkchar($char);
         } # end char while
        } # End String while loop
        undef $filehandle;
        # make sure we close the last buffer
        $self->_calltag($self->{textcontext}, $self->{textcontext},
                                                        $self->_getstore());
}

#
# return the current line number
#
sub line {
        my $self=shift;
        return $self->{linecount};
}

# return the line the current tag was opened
sub tagstartline {
        my $self=shift;
        $self->{tagstart};
}
# --------------- Utility routines ----------------------------
 
#
# Some initialisation of test suites
#
sub _resetvars {
        my $self=shift;
        $self->{quotes}=0;
        $self->{lastlabel}="";
        $self->{textcontext}='none';
        $self->{tagcontext}="text";
        $self->_resetstore();
}

#
# Check for control characters
#
sub _checkchar {
        my $self=shift;
        my $char=shift;
        my $string;


        # ---- In a tag
        if ( $self->{tagcontext}=~/tag/ ) {
           $self->{tagbuff}=$self->{tagbuff}.$char;
           if ( ! $self->_quotetest($char) ) {
            if ( ! $self->_labeltest($char) ) {
             if ( $char eq ">") { $self->_closetag(); }
             else { $self->_putstore($char); }
            }
           }  
        }
        # ------ Outside a tag
        else { 
           if ( $char eq "<") { $self->_opentag() }
           else { $self->_putstore($char) } 
        }
}


#
# Return the next character from the current string buffer
#
sub _nextchar() {
        my $self=shift;
        my $char;
        $char=substr($self->{currentline},$self->{stringpos}++,1);

        # Keep a record for any stream processes
        $self->{streamstore}=$self->{streamstore}.$char;

        return $char;
}

sub _opentag {
        my $self=shift;
        my $char;

        # Keep a record of where the tag started
        $self->{tagstart}=$self->line();

        # Close the last text segment
        $self->{streamtmp}=$self->_popstream();
        $self->_calltag($self->{textcontext}, $self->{textcontext}, 
                                                        $self->_getstore());
        $self->_resetstore();
        $self->_resetlabels();

        # Do we have an opening or closing tag?
        if ( ($char=$self->_nextchar()) eq "/" ) { #we have a closing tag
          $self->{tagbuff}="<".$char;
          $self->{tagcontext}="endtag";
        }
        else { # an opening tag
          $self->{tagbuff}="<";
          $self->{tagcontext}="starttag";
          $self->_checkchar($char);
        }
}

#
# Close a tag
#
sub _closetag {
        my $self=shift;
        my $tagroutine;

        # -- Finish off any labels/get tagname
        $self->_closelabel();
        
        # -- Call the associated tag function if appropriate
        if ( defined $self->{tagname} ) {
         $tagroutine=$self->{tagname}."_".$self->{tagcontext};
         $self->_calltag($tagroutine, $self->{tagname}, 
                                                        $self->{tagvar});

         # -- Now make sure the text context is set for calling routines to
         # -- deal with text portions outside of tags
         if ( ($self->{tagcontext} eq "starttag") ) {
           if ( $self->{tagcontainer}->definescontext($self->{tagname}) ) {
              push @{$self->{textstack}} , $self->{textcontext};
              $self->{textcontext}=$self->{tagname};
           }
         }
         else {
          if ( $#{$self->{textstack}} > -1 ) {
           if ( $self->{textcontext} eq $self->{tagname} ) {    
            if ( $self->{tagcontainer}->definescontext($self->{tagname}) ) {
              # -- watch out for valid tags we ignore in this parse
              $self->{textcontext}=pop @{$self->{textstack}};
            }
           } 
            else { #The tag we are closing is not the last one so
                   # we keep our current context.
               $self->_removefromstack($self->{tagname},$self->{textstack});
            }

          }
          else { # more close tags than open ones
            if ( $self->{tagcontainer}->definescontext($self->{tagname}) ) {
             print "Warning : Unmatched </...> tag on line ".
                                        $self->line()."\n";     
            }
          }
         }
        }
        # Reset context back to text
        $self->{tagcontext}="text";
}

sub _calltag {
        my $self=shift;
        my $tagroutine=shift;
        my @args=@_;
        my $rt;
        my $found=0;

#       print "TAGROUTINE: ",$tagroutine,"\n";
        
        if ( $self->{groupchecker}->status() ||
                ( $self->{tagcontainer}->inquiregroup($tagroutine)) ) {
          ($rt,$obj)=$self->{tagcontainer}->getroutine($tagroutine);
          if ( $rt ne "" ) {
             if ( ! defined $obj ) {
               &{$rt}( $self->{allw},@_);
             }
             else {
               &{$rt}( $obj,@_);
             }
             $found=1;
          }
        }
        
        # stream function
        if ( ! exists $self->{streamexclude}{$tagroutine} ) {
            $self->_printstream();
        }
        $self->_clearstream();
}

sub _clearstream {
        my $self=shift;
        $self->{streamstore}=(($self->{streamtmp} ne "")?$self->{streamtmp}:"");
        $self->{streamtmp}="";
}

sub _popstream {
        my $self=shift;
        $self->{streamstore}=~s/(.*)(.)$/$1/;
        return $2;
}

sub _printstream {

        my $self=shift;

        # Stream output functionality
        if ( defined $self->{stream} ) {
            print {$self->{stream}} "$self->{streamstore}";
        }
}

sub _removefromstack {
        my $self=shift;
        my $name=shift;
        my $stack=shift;
        my $this;

        undef @tempstack;
        # Keep popping until we find our string
        while ( ($this=(pop @{$stack})) ne "$name") {
          push @tempstack, $this; 
          if ( $#{$stack} < 0 ) { last; }
        }
        # Now put them back
        while ( $#tempstack>-1) {
          $this=pop @tempstack;
          push @{$stack}, $this;
        }
}

#
# Quote handling
#

sub _quotetest {
        my $self=shift;
        my $char=shift;

        # --- Are we already in a quote context?
        if ( $self->{quotes} ) {
         if ( $char eq $self->{openquote} ) {
           $self->{quotes}=0;
         }
         else {
           $self->_putstore($char);
         }
        }
        # --- Unquoted Context
        elsif ( (($char eq "\"") || ($char eq "\'") || ($char eq "\`")) ) {
           $self->{quotes}=1;
           $self->{openquote}=$char;
        }
        else { return 0; } # Return zero if not quoted
        return 1;          # 1 otherwise
}

#
# Label handling
#
sub _labeltest {
        my $self=shift;
        my $char=shift;

        # Spaces are markers between tags
        if ( ($char eq " ") || ($char eq "\n") || ($char eq "\t")) {
          $self->_closelabel();
        }
        # Check for a change in label status
        elsif ( $char eq "=" ) {
                $self->{lastlabel}=$self->_getstore();
                $self->_resetstore();
        }
        else {
             return 0;
        }
        return 1;
}

sub _resetlabels {
        my $self=shift;
        undef $self->{tagvar};
        undef $self->{tagname};
}

sub _closelabel {
        my $self=shift;

        # Do we have a label name?
        if ( $self->{lastlabel} ne "" ) {
         (my $label=$self->{lastlabel})=~tr[A-Z][a-z];
         $self->{tagvar}{$label}=$self->_getstore();
         $self->{lastlabel}="";
        }
        elsif ( $self->_getstore() ne "") { 
         # Then it must be the tag name
         if ( ! defined $self->{tagname} ) {
            ($self->{tagname}=$self->_getstore())=~tr/A-Z/a-z/;
         }
         else {
            # do not die anymore - breaks non tag documents
            #die ">Tag syntax error in $self->{tagname} on line ".
            #   $self->line()." of file \n$self->{filename}";
            # -- assume that this is plain text
            $self->{tagcontext}="text";
            $self->_resetstore();
            $self->_unshiftstore($self->{tagbuff});
            $self->{tagbuff}="";
            return;
         }
        }
        $self->_resetstore();
}

#
# Character Store management interface
#
sub _putstore() {
        my $self=shift;
        my $char=shift;

        $self->{stringbuff}=$self->{stringbuff}.$char;
}

sub _unshiftstore() {
        my $self=shift;
        my $char=shift;

        $self->{stringbuff}=$char.$self->{stringbuff};
}

sub _getstore() {
        my $self=shift;

        return $self->{stringbuff};
}

sub _resetstore {
        my $self=shift;
        $self->{stringbuff}="";
}
Revision:	1.19.2.1
Committed:	Fri Feb 27 15:34:54 2004 UTC (21 years, 2 months ago) by sashby
Content type:	text/plain
Branch:	SCRAM_V1_BRANCH
CVS Tags:	V1_pre0, SCRAM_V1, SCRAMV1_IMPORT
Branch point for:	V1_pre1
Changes since 1.19:	+2 -2 lines
Log Message:	First import of new SCRAM packages into CMS cvs repos.
#	User	Rev	Content
1	williamc	1.1	# Switcher Module
2			#
3			# Look for elements given in input has in a string
4			# If found then call a routine name with the same name
5			# Implemented as an object to maintain state info between each line
6			# processed.
7			# Interface
8			# ---------
9	sashby	1.17	#
10	williamc	1.1	# new(file,objectref) : A new object - filename of file to parse
11	sashby	1.17	# objectref->of the methods
12	williamc	1.1	# usetags(tagobjref) : Specify a tagcontainer set to direct to
13			# to the desired routines
14			# usegroupchecker(groupchecker) : Set a groupchecker
15			# parse() : Parse the file
16	sashby	1.17	# line() : return the current line number of the parse
17			# tagstartline() : return the line number on which the current
18			# tag was opened
19			# stream(filehandle) : stream output to the filehandle if not handled
20			# in any other way
21	williamc	1.3	package ActiveDoc::Switcher;
22	sashby	1.17	use Utilities::Verbose;
23	williamc	1.1	require 5.001;
24			use Carp;
25
26	sashby	1.17	@ISA=qw(Utilities::Verbose);
27
28	williamc	1.1	sub new {
29			my $class=shift;
30			my $file=shift;
31			my $objectname=shift;
32			my $groupchecker=shift;
33
34	williamc	1.4	$self = {};
35	williamc	1.1	$self->{allw}=$objectname;
36			bless $self, $class;
37			$self->_initialise($file);
38			return $self;
39			}
40
41	williamc	1.6	sub stream {
42			my $self=shift;
43
44			$self->{stream}=shift;
45			}
46
47	williamc	1.8	sub streamexclude {
48			my $self=shift;
49			my $tag=shift;
50
51			$tag=~tr/A-Z/a-z/;
52			$self->{streamexclude}{$tag}=1;
53			}
54
55	sashby	1.17	sub _initialise (hash1)
56			{
57			my $self=shift;
58			$self->{filename}=shift;
59			$self->verbose(">> New ActiveDoc::Switcher created.");
60			# add a default groupchecker
61			use ActiveDoc::GroupChecker;
62			$self->{groupchecker}=GroupChecker->new();
63			$self->{groupchecker}->include("all");
64
65			# Add a default TagContainer
66			use ActiveDoc::TagContainer;
67			$self->{tagcontainer}=ActiveDoc::TagContainer->new();
68
69			}
70	williamc	1.1
71			sub usetags {
72			my $self=shift;
73			my $tagcontainer=shift;
74
75			$self->{tagcontainer}=$tagcontainer;
76			}
77
78			sub usegroupchecker {
79			my $self=shift;
80			my $ref=shift;
81
82			$self->{groupchecker}=$ref;
83			}
84
85			sub parse {
86			my $self=shift;
87			my $char;
88	williamc	1.4	my $buf;
89	williamc	1.1	$self->{linecount}=0;
90			$self->_resetvars();
91	williamc	1.6	$self->{streamstore}="";
92	williamc	1.8	$self->{streamtmp}="";
93	williamc	1.1
94			# Open the file
95			use FileHandle;
96	williamc	1.6	local $filehandle;
97	williamc	1.4	$filehandle=FileHandle->new();
98	sashby	1.17
99			$self->verbose(">> Reading file: ".$self->{filename}." ");
100
101	williamc	1.6	$filehandle->open("<".$self->{filename})
102	williamc	1.2	or return 1;
103	williamc	1.1
104			# Start file processing
105	williamc	1.4	while ( ($_=<$filehandle>) ) {
106	sashby	1.19	$self->{linecount}++;
107			# Skip lines that start with a hash. A better way
108	sashby	1.18	# of adding comments than ignore tags:
109			next if (/^#/);
110	williamc	1.1	$self->{currentline}=$_;
111			$self->{stringpos}=0;
112			while ( ($char=$self->_nextchar()) ne "" ) {
113			$self->_checkchar($char);
114			} # end char while
115			} # End String while loop
116	williamc	1.5	undef $filehandle;
117	williamc	1.14	# make sure we close the last buffer
118			$self->_calltag($self->{textcontext}, $self->{textcontext},
119			$self->_getstore());
120	williamc	1.1	}
121
122			#
123			# return the current line number
124			#
125			sub line {
126			my $self=shift;
127			return $self->{linecount};
128			}
129	williamc	1.12
130			# return the line the current tag was opened
131			sub tagstartline {
132			my $self=shift;
133			$self->{tagstart};
134			}
135	williamc	1.1	# --------------- Utility routines ----------------------------
136
137			#
138			# Some initialisation of test suites
139			#
140			sub _resetvars {
141			my $self=shift;
142			$self->{quotes}=0;
143			$self->{lastlabel}="";
144			$self->{textcontext}='none';
145			$self->{tagcontext}="text";
146			$self->_resetstore();
147			}
148
149			#
150			# Check for control characters
151			#
152			sub _checkchar {
153			my $self=shift;
154			my $char=shift;
155			my $string;
156
157	williamc	1.6
158	williamc	1.1	# ---- In a tag
159			if ( $self->{tagcontext}=~/tag/ ) {
160	williamc	1.16	$self->{tagbuff}=$self->{tagbuff}.$char;
161	williamc	1.1	if ( ! $self->_quotetest($char) ) {
162			if ( ! $self->_labeltest($char) ) {
163			if ( $char eq ">") { $self->_closetag(); }
164			else { $self->_putstore($char); }
165			}
166			}
167			}
168			# ------ Outside a tag
169			else {
170			if ( $char eq "<") { $self->_opentag() }
171			else { $self->_putstore($char) }
172			}
173			}
174
175
176			#
177			# Return the next character from the current string buffer
178			#
179			sub _nextchar() {
180			my $self=shift;
181			my $char;
182			$char=substr($self->{currentline},$self->{stringpos}++,1);
183	williamc	1.6
184			# Keep a record for any stream processes
185			$self->{streamstore}=$self->{streamstore}.$char;
186
187	williamc	1.1	return $char;
188			}
189
190			sub _opentag {
191			my $self=shift;
192			my $char;
193	williamc	1.12
194			# Keep a record of where the tag started
195			$self->{tagstart}=$self->line();
196	williamc	1.1
197			# Close the last text segment
198	williamc	1.8	$self->{streamtmp}=$self->_popstream();
199	williamc	1.1	$self->_calltag($self->{textcontext}, $self->{textcontext},
200			$self->_getstore());
201			$self->_resetstore();
202			$self->_resetlabels();
203
204			# Do we have an opening or closing tag?
205			if ( ($char=$self->_nextchar()) eq "/" ) { #we have a closing tag
206	williamc	1.16	$self->{tagbuff}="<".$char;
207	williamc	1.1	$self->{tagcontext}="endtag";
208			}
209			else { # an opening tag
210	williamc	1.16	$self->{tagbuff}="<";
211	williamc	1.1	$self->{tagcontext}="starttag";
212			$self->_checkchar($char);
213			}
214			}
215
216			#
217			# Close a tag
218			#
219			sub _closetag {
220			my $self=shift;
221			my $tagroutine;
222
223			# -- Finish off any labels/get tagname
224			$self->_closelabel();
225
226			# -- Call the associated tag function if appropriate
227	williamc	1.13	if ( defined $self->{tagname} ) {
228			$tagroutine=$self->{tagname}."_".$self->{tagcontext};
229			$self->_calltag($tagroutine, $self->{tagname},
230	williamc	1.1	$self->{tagvar});
231
232	williamc	1.13	# -- Now make sure the text context is set for calling routines to
233			# -- deal with text portions outside of tags
234	williamc	1.15	if ( ($self->{tagcontext} eq "starttag") ) {
235			if ( $self->{tagcontainer}->definescontext($self->{tagname}) ) {
236			push @{$self->{textstack}} , $self->{textcontext};
237			$self->{textcontext}=$self->{tagname};
238			}
239	williamc	1.13	}
240			else {
241	williamc	1.1	if ( $#{$self->{textstack}} > -1 ) {
242	williamc	1.15	if ( $self->{textcontext} eq $self->{tagname} ) {
243			if ( $self->{tagcontainer}->definescontext($self->{tagname}) ) {
244			# -- watch out for valid tags we ignore in this parse
245			$self->{textcontext}=pop @{$self->{textstack}};
246			}
247			}
248	williamc	1.1	else { #The tag we are closing is not the last one so
249			# we keep our current context.
250			$self->_removefromstack($self->{tagname},$self->{textstack});
251			}
252
253			}
254			else { # more close tags than open ones
255	williamc	1.15	if ( $self->{tagcontainer}->definescontext($self->{tagname}) ) {
256	williamc	1.1	print "Warning : Unmatched </...> tag on line ".
257			$self->line()."\n";
258	williamc	1.15	}
259	williamc	1.1	}
260	williamc	1.13	}
261	williamc	1.1	}
262			# Reset context back to text
263			$self->{tagcontext}="text";
264			}
265
266			sub _calltag {
267			my $self=shift;
268			my $tagroutine=shift;
269			my @args=@_;
270			my $rt;
271	williamc	1.6	my $found=0;
272	williamc	1.1
273	sashby	1.19.2.1	# print "TAGROUTINE: ",$tagroutine,"\n";
274
275	williamc	1.1	if ( $self->{groupchecker}->status() \|\|
276			( $self->{tagcontainer}->inquiregroup($tagroutine)) ) {
277	williamc	1.7	($rt,$obj)=$self->{tagcontainer}->getroutine($tagroutine);
278	williamc	1.1	if ( $rt ne "" ) {
279	williamc	1.7	if ( ! defined $obj ) {
280	williamc	1.1	&{$rt}( $self->{allw},@_);
281	williamc	1.7	}
282			else {
283			&{$rt}( $obj,@_);
284			}
285			$found=1;
286	williamc	1.1	}
287			}
288	williamc	1.6
289	williamc	1.8	# stream function
290			if ( ! exists $self->{streamexclude}{$tagroutine} ) {
291	williamc	1.6	$self->_printstream();
292			}
293			$self->_clearstream();
294			}
295
296			sub _clearstream {
297			my $self=shift;
298			$self->{streamstore}=(($self->{streamtmp} ne "")?$self->{streamtmp}:"");
299			$self->{streamtmp}="";
300			}
301
302			sub _popstream {
303			my $self=shift;
304			$self->{streamstore}=~s/(.*)(.)$/$1/;
305			return $2;
306			}
307
308			sub _printstream {
309
310			my $self=shift;
311
312			# Stream output functionality
313			if ( defined $self->{stream} ) {
314			print {$self->{stream}} "$self->{streamstore}";
315			}
316	williamc	1.1	}
317
318			sub _removefromstack {
319			my $self=shift;
320			my $name=shift;
321			my $stack=shift;
322			my $this;
323
324			undef @tempstack;
325			# Keep popping until we find our string
326			while ( ($this=(pop @{$stack})) ne "$name") {
327			push @tempstack, $this;
328			if ( $#{$stack} < 0 ) { last; }
329			}
330			# Now put them back
331			while ( $#tempstack>-1) {
332			$this=pop @tempstack;
333			push @{$stack}, $this;
334			}
335			}
336
337			#
338			# Quote handling
339			#
340
341			sub _quotetest {
342			my $self=shift;
343			my $char=shift;
344
345			# --- Are we already in a quote context?
346			if ( $self->{quotes} ) {
347			if ( $char eq $self->{openquote} ) {
348			$self->{quotes}=0;
349			}
350			else {
351			$self->_putstore($char);
352			}
353			}
354			# --- Unquoted Context
355			elsif ( (($char eq "\"") \|\| ($char eq "\'") \|\| ($char eq "\`")) ) {
356			$self->{quotes}=1;
357			$self->{openquote}=$char;
358			}
359			else { return 0; } # Return zero if not quoted
360			return 1; # 1 otherwise
361			}
362
363			#
364			# Label handling
365			#
366			sub _labeltest {
367			my $self=shift;
368			my $char=shift;
369
370			# Spaces are markers between tags
371			if ( ($char eq " ") \|\| ($char eq "\n") \|\| ($char eq "\t")) {
372			$self->_closelabel();
373			}
374			# Check for a change in label status
375			elsif ( $char eq "=" ) {
376			$self->{lastlabel}=$self->_getstore();
377			$self->_resetstore();
378			}
379			else {
380			return 0;
381			}
382			return 1;
383			}
384
385			sub _resetlabels {
386			my $self=shift;
387			undef $self->{tagvar};
388	williamc	1.9	undef $self->{tagname};
389	williamc	1.1	}
390
391			sub _closelabel {
392			my $self=shift;
393
394			# Do we have a label name?
395			if ( $self->{lastlabel} ne "" ) {
396	williamc	1.15	(my $label=$self->{lastlabel})=~tr[A-Z][a-z];
397			$self->{tagvar}{$label}=$self->_getstore();
398	williamc	1.1	$self->{lastlabel}="";
399			}
400			elsif ( $self->_getstore() ne "") {
401	williamc	1.9	# Then it must be the tag name
402			if ( ! defined $self->{tagname} ) {
403			($self->{tagname}=$self->_getstore())=~tr/A-Z/a-z/;
404			}
405			else {
406	williamc	1.16	# do not die anymore - breaks non tag documents
407			#die ">Tag syntax error in $self->{tagname} on line ".
408			# $self->line()." of file \n$self->{filename}";
409			# -- assume that this is plain text
410			$self->{tagcontext}="text";
411			$self->_resetstore();
412			$self->_unshiftstore($self->{tagbuff});
413			$self->{tagbuff}="";
414			return;
415	williamc	1.9	}
416	williamc	1.1	}
417			$self->_resetstore();
418			}
419
420			#
421			# Character Store management interface
422			#
423			sub _putstore() {
424			my $self=shift;
425			my $char=shift;
426
427			$self->{stringbuff}=$self->{stringbuff}.$char;
428	williamc	1.16	}
429
430			sub _unshiftstore() {
431			my $self=shift;
432			my $char=shift;
433
434			$self->{stringbuff}=$char.$self->{stringbuff};
435	williamc	1.1	}
436
437			sub _getstore() {
438			my $self=shift;
439
440			return $self->{stringbuff};
441			}
442
443			sub _resetstore {
444			my $self=shift;
445			$self->{stringbuff}="";
446			}