src/ActiveDoc/PreProcessedFile.pm

#
# PreProcessedFile.pm
#
# Originally Written by Christopher Williams
#
# Description
# -----------
# Handle Preprocessed file information
#
# Interface
# ---------
# new()         : A new PreProcessedFile object
# url([url])    : return the full url. With an argument will take the given
#                 url and expand it in the context of the current url base. 
# file()        : return the filename corresponding to url of the document
# ProcessedFile() : return the filename corresponding to processed url 
#                       of the document
# realline(number): Return the line and fileobj corresponding to number in 
#                 processed file
# update()          : update the preprocessed file as required.
# store(filename)   :
# restore(filename) :

package ActiveDoc::PreProcessedFile;
use ActiveDoc::ActiveDoc;
require 5.004;
@ISA=qw(ActiveDoc::ActiveDoc);

sub init {
        my $self=shift;
        $self->{lastsequence}=-1;
        # Specific Tags
        $self->newparse("include");
        $self->addurltags("include");
        $self->addtag("include","Include", \&Include_Start, $self,      
                                          "", $self, "", $self);
}

sub realline {
        my $self=shift;
        my $origline=shift;

        my $fileob=$self;
        my $line=$origline;
        for(my $i=0; $i<=$#{$self->{includesdesc}}; $i++ ) {
          $inc=$self->{includesdesc}[$i];
          $startline=$inc->startline();
          last if ( $line <= $startline );
          if ( $line >= ($inc->lines()+$startline+2) ) { 
                                        # take out the 2 carriage returns added
            $line=$line-($inc->lines()+$startline-$inc->endline())-2;
#+($inc->endline()-$startline);
                         # n lines in original map to m lines in expanded
        print "Included file lines = ".$inc->lines()." +2 \n";
        print "Start tag= $startline , endtag=".$inc->endline()."\n";
          }
          else { # must be in the include file
        print "Passing $line-$startline \n";
            ($line, $fileob)=$self->{includes}[$i]->
                                        realline($line-$startline);
          }
        }
        
        return ($line, $fileob);
}

sub line {
        my $self=shift;
        my $line=$self->{currentparser}->line();
        return $line, $self;
}

sub url {
        my $self=shift;

        if ( @_ ) {
        my $url=shift;
          ($self->{url}, $file)=$self->{urlhandler}->get($url);
        }
        else {
          $self->{url};
        }
}

sub ProcessedFile {
        my $self=shift;
        $self->config()->cache()->file("_preprocess_".$self->url());
}

sub file {
        my $self=shift;
        
        my ($url, $file)=$self->{urlhandler}->get($self->url());
        return $file;
}
 
sub ProcessFile {
        my $self=shift;
        return $self->file();
}

sub update {
        my $self=shift;

        my $rv=0;
        my $outfile="_preprocess_".$self->url();
        my $fileobj;
        my $sn;
        @{$self->{updatedfiles}}=();
        
        # -- check the input file snd output sequence numbers are in sync
        my $basefilenumber=$self->config()->cache()->updatenumber($self->url());
        if ( $basefilenumber != $self->{lastsequence} ) {
            $rv=1;
        }
        else {
          # -- update dependencies
          for (my $i=0; $i<=$#{$self->{includes}}; $i++ ) {
             $fileobj=$self->{includes}[$i];
             $rv=$rv+$fileobj->update(); # make sure it up to date

             # -- has it changed since last time we built this object
             $sn=$self->config()->sequence($fileobj->url());
             if ( $self->{includesdesc}[$i]->lastsequence() != $sn ) {
               $rv++;
               push @{$self->{updatedfiles}},$fileobj->url(); # record for test
             }
          }
        }

        if ( $rv != 0 ) {
         $self->verbose(" Need to Update ".$self->url());
          # ---- sort out the preprocessed file in the cache
          my $newfile=$self->config()->cache()->
                                filename($outfile);
          $self->config()->cache()->store($outfile,$newfile);
          
          $self->process($self->config()->cache()->file($self->url()),$newfile);
          $self->{lastsequence}=$basefilenumber;
          # store self in the objectstore by url
          $self->config->store($self,$self->url());
        }
        else {
            $self->verbose("No Need to Update ".$self->url());
        }
        return $rv;
}

sub updatedfiles {
        my $self=shift;
        return @{$self->{updatedfiles}};
}

sub process {
        my $self=shift;
        my $filein=shift;
        my $fileout=shift;

        #-- create a new file in the url cache 
        $self->_cleanup();
        $self->{fileout}=FileHandle->new();
        $self->{fileout}->open(">".$fileout) or die "Unable to open $newfile\n"
                                ."$!\n";

        # turn on the switch streamer
        $self->parse("include", $self->{fileout}, "include_starttag");

        $self->{fileout}->close();
        $self->verbose("$fileout Created");
}

sub store {
        my $self=shift;
        my $location=shift;

        my $fh=$self->openfile(">".$location);

        # get all include objects to store themselves
        print $fh $self->{lastsequence}."\n";
        print $fh ($self->url()?$self->url():"");
        print $fh "\n"; 
        foreach $inc ( @{$self->{includesdesc}} ) {
          print $fh ">\n";
          $inc->store($fh);
        }
        close $fh;
}

sub restore {
        my $self=shift;
        my $location=shift;

        my $fh=$self->openfile("<".$location);

        $self->{lastsequence}=<$fh>;
        chomp $self->{lastsequence};
        $self->{url}=<$fh>;
        chomp $self->{url};
        while ( <$fh> ) {
           if ( $_ eq ">\n") {
                $inc=IncFile->new();
                $inc->restore($fh);
                push @{$self->{includesdesc}}, $inc;
                # resurrect the appropriate object ID
                push @{$self->{includes}}, $self->getfile($inc->file());
           }
        }
        $fh->close();
}

sub _cleanup {
        my $self=shift;
        foreach $inc ( @{$self->{includesdesc}} ) {
          undef $inc;
        }
        undef @{$self->{includesdesc}};
        undef @{$self->{includes}};
}

sub _includefile {
        use ActiveDoc::IncFile;
        my $self=shift;
        my $fileobj=shift;
        my $startline=shift;
        my $endline=shift;
        my $lines=shift;
        
        my $obj=IncFile->new();
        my $url=$fileobj->url();
        my $sn=$self->config()->sequence($url);
        $obj->init($url,$startline,$endline,$lines, $sn);
        push @{$self->{includes}}, $fileobj;
        push @{$self->{includesdesc}}, $obj;
}

# ------------------------ Tag Routines -------------------------------

#
# Include tag

sub Include_Start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        $self->checktag( $name,$hashref, "url");
        print "Including ".$$hashref{'url'}."\n";
        my $fileObj=$self->getfile($$hashref{'url'});
        if ( defined $fileObj ) {
          # dump out to our file in construction
          my $fh=FileHandle->new();
          my $outfilename=$fileObj->ProcessedFile();
          $fh->open("<".$outfilename) or die "Unable to open $outfilename\n";
          print {$self->{fileout}} "\n";# always start an include on a new line
          my $linecount=0;
          while ( <$fh> ) {
            $linecount++;
            print {$self->{fileout}} $_;
          }
          print {$self->{fileout}} "\n";# always end include with new line
          undef $fh;
          $self->_includefile($fileObj, $self->{currentparser}->tagstartline(),
                $self->{currentparser}->line(), $linecount);
        }
}

Revision:	1.6
Committed:	Mon Feb 21 14:30:08 2000 UTC (25 years, 2 months ago) by williamc
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+12 -7 lines
Log Message:	ProcessFile method - override
#	User	Rev	Content
1	williamc	1.1	#
2			# PreProcessedFile.pm
3			#
4			# Originally Written by Christopher Williams
5			#
6			# Description
7			# -----------
8			# Handle Preprocessed file information
9			#
10			# Interface
11			# ---------
12			# new() : A new PreProcessedFile object
13			# url([url]) : return the full url. With an argument will take the given
14			# url and expand it in the context of the current url base.
15			# file() : return the filename corresponding to url of the document
16			# ProcessedFile() : return the filename corresponding to processed url
17			# of the document
18	williamc	1.4	# realline(number): Return the line and fileobj corresponding to number in
19	williamc	1.1	# processed file
20			# update() : update the preprocessed file as required.
21			# store(filename) :
22			# restore(filename) :
23
24			package ActiveDoc::PreProcessedFile;
25			use ActiveDoc::ActiveDoc;
26			require 5.004;
27			@ISA=qw(ActiveDoc::ActiveDoc);
28
29			sub init {
30			my $self=shift;
31			$self->{lastsequence}=-1;
32			# Specific Tags
33			$self->newparse("include");
34			$self->addurltags("include");
35			$self->addtag("include","Include", \&Include_Start, $self,
36			"", $self, "", $self);
37			}
38
39	williamc	1.4	sub realline {
40	williamc	1.1	my $self=shift;
41			my $origline=shift;
42
43			my $fileob=$self;
44			my $line=$origline;
45	williamc	1.3	for(my $i=0; $i<=$#{$self->{includesdesc}}; $i++ ) {
46			$inc=$self->{includesdesc}[$i];
47	williamc	1.1	$startline=$inc->startline();
48	williamc	1.5	last if ( $line <= $startline );
49	williamc	1.6	if ( $line >= ($inc->lines()+$startline+2) ) {
50			# take out the 2 carriage returns added
51	williamc	1.5	$line=$line-($inc->lines()+$startline-$inc->endline())-2;
52			#+($inc->endline()-$startline);
53	williamc	1.1	# n lines in original map to m lines in expanded
54	williamc	1.5	print "Included file lines = ".$inc->lines()." +2 \n";
55			print "Start tag= $startline , endtag=".$inc->endline()."\n";
56	williamc	1.1	}
57			else { # must be in the include file
58	williamc	1.5	print "Passing $line-$startline \n";
59	williamc	1.3	($line, $fileob)=$self->{includes}[$i]->
60	williamc	1.5	realline($line-$startline);
61	williamc	1.1	}
62			}
63
64			return ($line, $fileob);
65	williamc	1.4	}
66
67			sub line {
68			my $self=shift;
69			my $line=$self->{currentparser}->line();
70			return $line, $self;
71	williamc	1.1	}
72
73			sub url {
74			my $self=shift;
75
76			if ( @_ ) {
77	williamc	1.6	my $url=shift;
78			($self->{url}, $file)=$self->{urlhandler}->get($url);
79			}
80			else {
81			$self->{url};
82			}
83	williamc	1.1	}
84
85			sub ProcessedFile {
86			my $self=shift;
87			$self->config()->cache()->file("_preprocess_".$self->url());
88			}
89
90			sub file {
91			my $self=shift;
92
93			my ($url, $file)=$self->{urlhandler}->get($self->url());
94			return $file;
95			}
96
97	williamc	1.6	sub ProcessFile {
98			my $self=shift;
99			return $self->file();
100			}
101	williamc	1.1
102			sub update {
103			my $self=shift;
104
105			my $rv=0;
106	williamc	1.3	my $outfile="_preprocess_".$self->url();
107			my $fileobj;
108			my $sn;
109			@{$self->{updatedfiles}}=();
110	williamc	1.1
111	williamc	1.3	# -- check the input file snd output sequence numbers are in sync
112			my $basefilenumber=$self->config()->cache()->updatenumber($self->url());
113			if ( $basefilenumber != $self->{lastsequence} ) {
114			$rv=1;
115			}
116			else {
117			# -- update dependencies
118			for (my $i=0; $i<=$#{$self->{includes}}; $i++ ) {
119			$fileobj=$self->{includes}[$i];
120			$rv=$rv+$fileobj->update(); # make sure it up to date
121
122			# -- has it changed since last time we built this object
123			$sn=$self->config()->sequence($fileobj->url());
124			if ( $self->{includesdesc}[$i]->lastsequence() != $sn ) {
125			$rv++;
126			push @{$self->{updatedfiles}},$fileobj->url(); # record for test
127			}
128			}
129	williamc	1.1	}
130	williamc	1.3
131			if ( $rv != 0 ) {
132	williamc	1.5	$self->verbose(" Need to Update ".$self->url());
133	williamc	1.1	# ---- sort out the preprocessed file in the cache
134			my $newfile=$self->config()->cache()->
135	williamc	1.3	filename($outfile);
136			$self->config()->cache()->store($outfile,$newfile);
137	williamc	1.1
138			$self->process($self->config()->cache()->file($self->url()),$newfile);
139	williamc	1.3	$self->{lastsequence}=$basefilenumber;
140			# store self in the objectstore by url
141			$self->config->store($self,$self->url());
142			}
143			else {
144	williamc	1.5	$self->verbose("No Need to Update ".$self->url());
145	williamc	1.1	}
146			return $rv;
147			}
148
149	williamc	1.3	sub updatedfiles {
150			my $self=shift;
151			return @{$self->{updatedfiles}};
152			}
153
154	williamc	1.1	sub process {
155			my $self=shift;
156			my $filein=shift;
157			my $fileout=shift;
158
159			#-- create a new file in the url cache
160			$self->_cleanup();
161			$self->{fileout}=FileHandle->new();
162			$self->{fileout}->open(">".$fileout) or die "Unable to open $newfile\n"
163			."$!\n";
164
165			# turn on the switch streamer
166			$self->parse("include", $self->{fileout}, "include_starttag");
167
168			$self->{fileout}->close();
169	williamc	1.5	$self->verbose("$fileout Created");
170	williamc	1.1	}
171
172			sub store {
173			my $self=shift;
174			my $location=shift;
175
176			my $fh=$self->openfile(">".$location);
177
178			# get all include objects to store themselves
179			print $fh $self->{lastsequence}."\n";
180			print $fh ($self->url()?$self->url():"");
181			print $fh "\n";
182	williamc	1.3	foreach $inc ( @{$self->{includesdesc}} ) {
183	williamc	1.1	print $fh ">\n";
184			$inc->store($fh);
185			}
186			close $fh;
187			}
188
189			sub restore {
190			my $self=shift;
191			my $location=shift;
192
193	williamc	1.3	my $fh=$self->openfile("<".$location);
194	williamc	1.1
195			$self->{lastsequence}=<$fh>;
196			chomp $self->{lastsequence};
197			$self->{url}=<$fh>;
198			chomp $self->{url};
199			while ( <$fh> ) {
200	williamc	1.3	if ( $_ eq ">\n") {
201	williamc	1.1	$inc=IncFile->new();
202			$inc->restore($fh);
203	williamc	1.3	push @{$self->{includesdesc}}, $inc;
204			# resurrect the appropriate object ID
205			push @{$self->{includes}}, $self->getfile($inc->file());
206	williamc	1.1	}
207			}
208			$fh->close();
209			}
210
211			sub _cleanup {
212			my $self=shift;
213	williamc	1.3	foreach $inc ( @{$self->{includesdesc}} ) {
214	williamc	1.1	undef $inc;
215			}
216	williamc	1.3	undef @{$self->{includesdesc}};
217	williamc	1.1	undef @{$self->{includes}};
218			}
219
220	williamc	1.3	sub _includefile {
221			use ActiveDoc::IncFile;
222			my $self=shift;
223			my $fileobj=shift;
224			my $startline=shift;
225			my $endline=shift;
226			my $lines=shift;
227
228			my $obj=IncFile->new();
229			my $url=$fileobj->url();
230			my $sn=$self->config()->sequence($url);
231			$obj->init($url,$startline,$endline,$lines, $sn);
232			push @{$self->{includes}}, $fileobj;
233			push @{$self->{includesdesc}}, $obj;
234			}
235
236	williamc	1.1	# ------------------------ Tag Routines -------------------------------
237
238			#
239			# Include tag
240
241			sub Include_Start {
242			my $self=shift;
243			my $name=shift;
244			my $hashref=shift;
245
246			$self->checktag( $name,$hashref, "url");
247			print "Including ".$$hashref{'url'}."\n";
248			my $fileObj=$self->getfile($$hashref{'url'});
249			if ( defined $fileObj ) {
250			# dump out to our file in construction
251			my $fh=FileHandle->new();
252			my $outfilename=$fileObj->ProcessedFile();
253			$fh->open("<".$outfilename) or die "Unable to open $outfilename\n";
254			print {$self->{fileout}} "\n";# always start an include on a new line
255	williamc	1.3	my $linecount=0;
256	williamc	1.1	while ( <$fh> ) {
257	williamc	1.3	$linecount++;
258	williamc	1.1	print {$self->{fileout}} $_;
259			}
260			print {$self->{fileout}} "\n";# always end include with new line
261			undef $fh;
262	williamc	1.3	$self->_includefile($fileObj, $self->{currentparser}->tagstartline(),
263			$self->{currentparser}->line(), $linecount);
264	williamc	1.1	}
265			}
266