Embedding multiple (non embedded) high level languages into an assembler code6061519Abstract A novel method is taught to quickly and easily produce assember code from a single embedded file which can include high level language code written in any of a number of high level languages interspersed, if desired, among assembler code itself. Claims What is claimed is: Description TECHNICAL FIELD
TABLE 1
______________________________________
Keywords to identify high-level language
codes within the embedded file
Language: Begin statement
End statement
______________________________________
`C` program !c.sub.-- begin
!c.sub.-- end
Bourne Shell !sh.sub.-- begin
!sh.sub.-- end
c-Shell !csh.sub.-- begin
!csh.sub.-- end
Awk !nawk.sub.-- begin
!nawk.sub.-- end
perl !perl.sub.-- begin
!perl.sub.-- end
______________________________________
The following steps are used by a programmer to create the embedded file, including high-level language embedded within assembler code: 1) Use the appropriate begin and end statement as defined in Table 1 for the language chosen. 2) Write the assembler code generation program in the high-level language within the begin-end block. 3) Use additional assembler language directly without any begin-end statement, if required. 4) Use CAPS program to expand the high-level languages into the assembler code. Of interest, the user needs only to use the CAPS program for testing purposes. Otherwise, we can incorporate CAPS into the assembler parser program and the user need not expand the test code written in high-level languages, as the CAPS program is part of the Validation tool set and during the CPU validation process, the CAPS program used expand the code automatically. The following is an example of initialization of registers using manually written assembler codes: mov %g0, %i0 mov %g0, %i1 mov %g0, %i2 mov %g0, %i3 mov %g0, %i4 mov %g0, %i5 mov %g0, %i6 mov %g0, %i7 mov %g0, %l0 mov %g0, %l1 mov %g0, %l2 mov %g0, %l3 mov %g0, %l4 mov %g0, %l5 mov %g0, %l6 mov %g0, %l7 mov %g0, %o0 mov %g0, %o1 mov %g0, %o2 mov %g0, %o3 mov %g0, %o4 mov %g0, %o5 mov %g0, %o6 mov %g0, %o7 In accordance with the teachings of this invention, the above register initialization is achieved in a much simpler fashion, utilizing a single embedded code file, for example as follows:
______________________________________
!perl.sub.-- begin
@regc = ( "i", "l", "o" );
foreach $r ( 0 .. $#regc ) {
for ($i = 0; $i <= 7; $i++ ) {
print ".backslash.tmov %g0, %$regc[$r]$i.backslash.n";
}
!perl.sub.-- end
______________________________________
As another, and more complex example, the following is an example of an embedded code file including manually written assembler code and embedded high level language code, written in high-level languages, `perl`, `c`, and awk.
__________________________________________________________________________
user.sub.-- text.sub.-- start :
main:
!perl.sub.-- begin
@regc = ( "g", "o");
foreach $r ( 0 . . $#regc ) {
print ".backslash.n.backslash.nreg.sub.-- $regc[$r].sub.-- init:.backslash
.n";
for ( $i = 0; $i <= 7; $i++ ) {
print ".backslash.tmov %g0, %$regc[$r]$i.backslash.n";
}
@regc = ( "1");
foreach $r ( 0 . . $#regc ) {
print ".backslash.n.backslash.nreg.sub.-- $regc[$r].sub.-- i.sub.--
init:.backslash.n";
for ( $i = 0; $i <= 7; $i++) {
if ( $i <= 5 ) {
print ".backslash.tset page.sub.-- $i, %$regc[$r]$i.backslash.n";
}
else {
print ".backslash.tset nc.sub.-- page.sub.-- $i,
%$regc[$r]$i.backslash.n";
}
print ".backslash.tmov %$reqc[$r]$i, %i$i.backslash.n";
}
}
!perl.sub.-- end
!# define f0 and f1
ldd [%10], %f0
!#--------------------------------------------------------------
!#
body.sub.-- cprog.i file contains `c` code and this code will
!#
generate assembler code using CAPS program during
!#
the validation process.
!#
!#
!#
To run with random seed:
!# 1) comment out SEED.sub.-- INIT definition
!# 2) set `1` to SBTHRASH.sub.-- RANDOM.sub.-- SEED
!#
!#--------------------------------------------------------------
!c.sub.-- begin
#define
SEED.sub.-- INIT 0x1234
#define
SBTHRASH.sub.-- RANDOM.sub.-- SEED 1 /* random seed; SEED.sub.--
INIT
will not be used */
/* SBTHRASH Test:
Most of the `c` code is borrowed from dtharsh test.
Redistributed the ld,lda,st,sta usage to generate maximum
amount of store. Also, I and D TLB lock is done randomly.
Required parameters are defined as cpp macros. No need to
change the code to generate variable no. of instrs., or
number of tlb entry locking.
*/
#include <stdio.h>
#define
NO.sub.-- OF.sub.-- INSTRS 3000
#define
LOCK.sub.-- DTLB.sub.-- ENTRIES
59
#define
LOCK.sub.-- ITLB.sub.-- ENTRIES
13
#define
DTLB.sub.-- ENTRIES
64
#define
ITLB.sub.-- ENTRIES
16
#define TABLEWALKS 20
/* this causes table walks every TABLEWALKS operations, min =16
*/
/* NOTE: operations are about 2.4 instructions each (1-3), NOT
one cycle */
/* warning, this explodes the size of mem.dat */
int icount. = 0;
int tlb.sub.-- lock.sub.-- flag[100];
int tlb.sub.-- lock.sub.-- count;
print.sub.-- ins (ins.sub.-- buf)
char *ins.sub.-- buf;
{
icount++;
if ( ( icount % 10 ) == 0 ) {
printf ("sbthrash.sub.-- ins.sub.-- count.sub.-- %d:.backslash.n",
icount);
}
printf("%s", ins.sub.-- buf);
}
init.sub.-- tlb.sub.-- lock.sub.-- flag(num)
{
while ( num-- )
tlb.sub.-- lock.sub.-- flag[num] = 0;
}
main(argc, argv)
int argc;
char**argv;
{
long randnum;
int page, offset, accsize, align;
char *sizestr, *signstr;
int fi;
char ins.sub.-- buf[128];
int tlb.sub.-- index;
int seed.sub.-- init;
long random();
char *transparent="0"; /* change here to move PA space */
int PAGES= 0x8; /* A % is silly if pages=8, wasn't always
*/
int RANGE= 0x3f; /* 63: offset range, 31 for one line, 63
for two. */
#if ( SBTHRASH.sub.-- RANDOM.sub.-- SEED == 1 )
seed.sub.-- init = getpid();
printf(".backslash.n!#.backslash.t.backslash.t.backslash.tNOTE: USING
RANDOM SEED ( 0x%x).backslash.n",
seed.sub.-- init);
fprintf(stderr, ".backslash.n.backslash.t.backslash.t.backslash.tNOTE:
USING RANDOM SEED (
0x%x).backslash.n", seed.sub.-- init);
#else
seed.sub.-- init = SEED.sub.-- INIT;
fprintf(stderr, ".backslash.n.backslash.t.backslash.t.backslash.tNOTE:
USING SEED VALUE ( 0x%x).backslash.n",
seed.sub.-- init);
#endif
/* if(argc!=3)printf("usage: body randseed numops.backslash.n");*/
srandom(seed.sub.-- init);
/*
=============================================================
generate instr. to display the SEED.sub.-- INIT value
and no. of instrs in.sim.*log
=============================================================
*/
printf("seed.sub.-- init:.backslash.n.backslash.tset 0x%x,
%%g3.backslash.n.backslash.n", seed.sub.-- init);
printf("no.sub.-- of.sub.-- instrs:.backslash.n.backslash.tset 0x%x,
%%g4.backslash.n.backslash.n", NO.sub.-- OF.sub.-- INSTRS);
/*
=============================================================
generate instr. to lock DTLB entries
=============================================================
*/
printf(".backslash.tmov.backslash.t0x1, %%g1.backslash.n");
printf(".backslash.n.backslash.ndtlb.sub.-- lock.sub.-- %d.sub.--
entries.sub.-- in.sub.-- random:.backslash.n",
LOCK.sub.-- DTLB.sub.-- ENTRIES);
init.sub.-- tlb.sub.-- lock.sub.-- flag(DTLB.sub.-- ENTRIES );
for (fi = 0; fi <LOCK.sub.-- DTLB.sub.-- ENTRIES ; fi ++ ) {
for ( ; ; ) {
tlb.sub.-- index = (random() & 0x3f);
if ( ! tlb.sub.-- lock.sub.-- flag[tlb.sub.-- index] ) break;
}
tlb.sub.-- lock.sub.-- flag[tlb.sub.-- index] = 1;
printf("dtlb.sub.-- lock.sub.-- %d.sub.-- %d:.backslash.n.backslash.tset
0x%x, %%g2.backslash.n", fi,
tlb.sub.-- index, ((tlb.sub.-- index*4096) + 768) );
printf(".backslash.tsta.backslash.t%%g1, [%%g2] MTEST.sub.-- TLB.sub.--
LOCK.sub.-- ASI.backslash.n");
}
printf(".backslash.n");
/*
=============================================================
generate instr. to lock ITLB entries
=============================================================
*/
printf(".backslash.n.backslash.nitlb.sub.-- lock.sub.-- %d.sub.--
entries.sub.-- in.sub.-- random:.backslash.n",
LOCK.sub.-- ITLB.sub.-- ENTRIES);
init.sub.-- tlb.sub.-- lock.sub.-- flag(ITLB.sub.-- ENTRIES );
for (fi = 0; fi <LOCK.sub.-- ITLB.sub.-- ENTRIES ; fi ++ ) {
for ( ; ; ) {
tlb.sub.-- index = (random() & 0xf);
if ( ! tlb.sub.-- lock.sub.-- flag[tlb.sub.-- index] ) break;
}
tlb.sub.-- lock.sub.-- flag[tlb.sub.-- index] = 1;
printf("itlb.sub.-- lock.sub.-- %d.sub.-- %d:.backslash.n.backslash.tset
0x%x, %%g2.backslash.n", fi,
tlb.sub.-- index, ((tlb.sub.-- index.*4096) + 768) );
printf(".backslash.tsta.backslash.t%%g1, [%%g2] MTESTI.sub.-- TLB.sub.--
LOCK.sub.-- ASI.backslash.n");
}
printf(".backslash.n");
printf(".backslash.tmov.backslash.t%%g0, %%g1.backslash.n");
printf(".backslash.tmov.backslash.t%%g0, %%g2.backslash.n");
printf(".backslash.tmov.backslash.t%%g0, %%g3.backslash.n");
printf(".backslash.tmov.backslash.t%%g0, %%g4.backslash.n");
printf(".backslash.n.backslash.n.backslash.n");
printf("sbthrash.sub.-- start:.backslash.n");
icount = 0;
for(; ;){ /* Infinite loop */
if ( icount >= NO.sub.-- OF.sub.-- INSTRS ) break;
randnum=random();
page = (randnum & 0xff) % PAGES;
offset = ((randnum>> 8) & RANGE);
/* accsize determines the byte/half/word/double */
accsize = (randnum>> 14 ) & 3;
/* signstr may cause unsigned byte or half */
signstr = (randnum>> 16 )&1?"u":"s";
/* align rounds offset for that size */
align=offset; sizestr = "b";
if(accsize==1) {align &= .about.1; sizestr = "h";}
if(accsize==2) {align &= .about.3; sizestr = " "; signstr=" ";}
if(accsize==3) {align &= .about.7; sizestr = "d"; signstr=" ";
page &= .about.1;}
/*printf("rnum=%x, page=%d, offset=%d, accsize=%d,
align=%d.backslash.n",randnum, page, offset, accsize, align);*/
switch((randnum>>17) & 0x7 ) {
/* 4 - regular store, 2 sta, 1 ld */
case 0: /* free fall */
case 1: /* free fall */
case 2: /* free fall */
case 3: /* ST */
sprintf(ins.sub.-- buf, ".backslash.tst%s.backslash.t%%i%i,
[%%l%i+%i].backslash.n", sizestr,
page, page, align); print.sub.-- ins(ins.sub.-- buf);
sprintf(ins.sub.-- buf, ".backslash.tinc.backslash.t%%i%i.backslash.n",
page) ;
print.sub.-- ins(ins.sub.-- buf);
break;
case 4: /* free fall */
case 5: /* STA user/super instruction/data access */
sprintf(ins.sub.-- buf, ".backslash.tadd.backslash.t%d, %%l%i,
%%g%i.backslash.n", align,
page, page?page:1); print.sub.-- ins(ins.sub.-- buf);
sprintf(ins.sub.-- buf, ".backslash.tst%sa.backslash.t%%i%i, [%%g%i]
0x%X.backslash.n",
sizestr, page, page?page:1, 8+((randnum>>20) & 3));
print.sub.-- ins(ins.sub.-- buf);
sprintf(ins.sub.-- buf, ".backslash.tinc.backslash.t%%i%i.backslash.n",
page) ;
print.sub.-- ins(ins.sub.-- buf);
break;
case 6: /* LD) */
sprintf(ins.sub.-- buf, ".backslash.tld%s%s.backslash.t(%%l%i+%i],
%%o%i.backslash.n",
signstr, sizestr, page, align, page); print.sub.-- ins(ins.sub.-- buf);
break;
case 7:
switch ((randnum>>20) & 0x7) {
case 0: /* free fall */
case 1: /* free fall */
case 2: /* free fall */
case 3: /* LDA transparent, if page=0, can't use reg
%g0, overuse %g1 */
sprintf(ins.sub.-- buf, ".backslash.tadd.backslash.t%d, %%l%i,
%%g%i.backslash.n", align,
page, page?page:1); print.sub.-- ins(ins.sub.-- buf);
sprintf(ins.sub.-- buf, ".backslash.tld%s%sa.backslash.t[%%g%i] 0x2%s,
%%o%i.backslash.n",
signstr, sizestr, page?page:1, transparent, page);
print.sub.-- ins(ins.sub.-- buf);
break;
case 4: /* LDSTUB */
sprintf(ins.sub.-- buf, ".backslash.tmov.backslash.t%%i%i,
%%o%i.backslash.n", page, page);
print.sub.-- ins(ins.sub.-- buf);
sprintf(ins.sub.-- buf, ".backslash.tldstub.backslash.t[%%l%i+%i],
%%o%i.backslash.n",
page, offset, page); print.sub.-- ins(ins.sub.-- buf);
sprintf(ins.sub.-- buf, ".backslash.tinc.backslash.t%%i%i.backslash.n",
page);
print.sub.-- ins(ins.sub.-- buf);
break;
case 5:
case 6: /* ST with FBUSY */
sprintf(ins.sub.-- buf, ".backslash.tfmovs.backslash.t%%f0,
%%f1.backslash.n")
print.sub.-- ins(ins.sub.-- buf);
sprintf(ins.sub.-- buf, ".backslash.tst.backslash.t%%f1,
[%%l%i+%i].backslash.n", page,
offset & .about.3); print.sub.-- ins(ins.sub.-- buf);
break;
case 7: /* LD with FBUSY */
sprintf(ins.sub.-- buf, ".backslash.tld.backslash.t[%%l%i+%i],
The resultant assembler code after expanding the above embedded file utilizing the CAPS program is shown in appendix I: FIG. 1 is a flow chart depicting the operation of one embodiment of an expansion program such as the CAPS program to read an input assembler file and expand embedded high level language code statements to generate a final output code file which is written completely in assembler code. As shown in FIG. 1, first the input assembler code file is read and a determination is made as to whether a high level begin string is found. If a high level begin string is not found, that line of assembler code is written to the output file, and the next input file line is read. If a high level begin string is located, the high level language type is determined based on, for example, information contained in the high level language begin string. Then, code expansion is performed on the high level code to generate assembler code, until such time as the high level language end statement is reached, indicating the conclusion of that high level language string in the embedded input file. This generated assembler code is then output to the output file, and a return is made to continue reading the input file.
______________________________________
#
#=====================================================
# %W% %G%
#=====================================================
# Program to expand shell, awk, perl and `c` code in asm file.
# The perl block starts with `!perl.sub.-- begin` string
# and ends with `!perl.sub.-- end` string
# Other blocks:
# sh block: !sh.sub.-- begin to !sh.sub.-- end
# csh block: !csh.sub.-- begin to !csh.sub.-- end
# awk block: !nawk.sub.-- begin to !nawk.sub.-- end
# c block: !c.sub.-- begin to !c.sub.-- end
#
#=====================================================
( $#ARGV == 1 ) .vertline..vertline. die("Usage: $0 <input file> <output
file>
.backslash.n");
#-----------------------------------------------
# get input file
#-----------------------------------------------
$infile = shift;
#-----------------------------------------------
# get outfile
#-----------------------------------------------
$outfile = shift;
$tmpFile1 = "/tmp/$infile.1.$$.c";
$tmpFile2 = "/tmp/$infile.2.$$";
$tmpFile3 = "/tmp/$infile.3.$$";
$perl.sub.-- begin.sub.-- str
= `perl.sub.-- begin`;
$perl.sub.-- end.sub.-- str
= `perl.sub.-- end`;
$nawk.sub.-- begin.sub.-- str
= `nawk.sub.-- begin`;
$nawk.sub.-- end.sub.-- str
= `nawk.sub.-- end`;
$csh.sub.-- begin.sub.-- str
= `csh.sub.-- begin`;
$csh.sub.-- end.sub.-- str
= `csh.sub.-- end`;
$sh.sub.-- begin.sub.-- str
= `sh.sub.-- begin`;
$sh.sub.-- end.sub.-- str
= `sh.sub.-- end`;
$c.sub.-- begin.sub.-- str
= `c.sub.-- begin`;
$c.sub.-- end.sub.-- str
= `c.sub.-- end`;
$tasks.sub.-- str
= `tasks`;
$val = &main.sub.-- prog();
unlink($tmpFile1);
unlink($tmpFile2);
unlink($tmpFile3);
exit($val);
# MAIN Func.
sub main.sub.-- prog {
open(FH, "<$infile") .vertline..vertline.
die "Can't open file $infile in `r` mode:
$!.backslash.n";
open(FHOUT, ">$outfile") .vertline..vertline.
die "Can't open file $outfile in `w` mode:
$!.backslash.n";
$tasks.sub.-- flag = 0;
$n = 0;
while (<FH>) {
chop;
#print ".vertline.$.sub.-- .vertline..backslash.n";
$n++;
if ( / .backslash.!$tasks.sub.-- str/ ) {
$tasks.sub.-- flag = 1;
}
if ( / .backslash.!$perl.sub.-- begin.sub.-- str/
.vertline..vertline.
/ .backslash.!$nawk.sub.-- begin.sub.-- str/ .vertline..vertline.
/ .backslash.!$sh.sub.-- begin.sub.-- str/ .vertline..vertline. /
.backslash.!$c.sub.-- begin.sub.-- str/
.vertline..vertline.
/ .backslash.!$csh.sub.-- begin.sub.-- str/
) {
if ( / .backslash.!$perl.sub.-- begin.sub.-- str/ ) {
$type = "perl";
$end.sub.-- str = "$perl.sub.-- end.sub.-- str";
}
elsif ( / .backslash.!$nawk.sub.-- begin.sub.-- str/ ) {
$type = "nawk";
$end.sub.-- str = "$nawk.sub.-- end.sub.-- str";
}
elsif ( / .backslash.!$csh.sub.-- begin.sub.-- str/ ) {
$type = "csh";
$end.sub.-- str = "$csh.sub.-- end.sub.-- str";
}
elsif ( / .backslash.!$sh.sub.-- begin.sub.-- str/ ) {
$type = "sh";
$end.sub.-- str = "$sh.sub.-- end.sub.-- str";
}
elsif ( / .backslash.!$c.sub.-- begin.sub.-- str/ ) {
$type = "c";
$end.sub.-- str = "$c.end.sub.-- str";
}
print FHOUT "/* $.sub.-- */.backslash.n";
$block.sub.-- begin.sub.-- ln = $n;
$val = &expand.sub.-- prog($type, $end.sub.-- str,
$tasks.sub.-- flag);
if ( $val != 0 ) {
print STDERR ".backslash.tError: $type expansion
failed.backslash.n";
exit(-1);
}
}
print FHOUT "$.sub.-- .backslash.n";
}
close(FH);
close(FHOUT);
0;
}
sub expand.sub.-- prog {
local($type, $end.sub.-- str, $tasks.sub.-- flag) = @.sub.-- ;
open(FHOUT.sub.-- PROG, ">$tmpFile1") .vertline..vertline.
die "Can't open file $tmpFile1 in `w` mode:
$!.backslash.n";
if ( $type eq "perl" ) {
$val = &output.sub.-- perl.sub.-- header;
}
while (<FH>) {
chop;
#print ".vertline.$.sub.-- .vertline..backslash.n";
$n++;
if ( / .backslash.!$end.sub.-- str/ ) {
$line "$.sub.-- " ;
$block.sub.-- end.sub.-- ln = $n;
if ( $type eq "perl" ) {
print FHOUT.sub.-- PROG "exit(0); .backslash.n";
close FHOUT.sub.-- PROG;
print STDERR ".backslash.n.backslash.t Expanding Perl Code from
line $block.sub.-- begin.sub.-- ln
to $block.sub.-- end.sub.-- ln
.backslash.n";
print STDERR ".backslash.t.backslash.tchmod +x $tmpFile1;
$tmpFile1.backslash.n";
$val = system("chmod +x $tmpFile1; $tmpFile1 >
$tmpFile2");
}
elsif ( $type eq "csh" ) {
print FHOUT.sub.-- PROG "exit .backslash.$status; .backslash.n";
close FHOUT.sub.-- PROG;
print STDERR ".backslash.n.backslash.t Expanding Shell Code
from line $block.sub.-- begin.sub.-- ln to $block.sub.-- end.sub.-- ln
.backslash.n";
print STDERR ".backslash.t.backslash.tchmod +x $tmpFile1;
$tmpFile1.backslash.n";
$val = system("chmod +x $tmpFile1; $tmpFile1 >
$tmpFile2");
}
elsif ( $type eq "sh" ) {
print FHOUT.sub.-- PROG "exit 0; .backslash.n";
close FHOUT.sub.-- PROG;
print STDERR ".backslash.n.backslash.t Expanding Shell Code from line
$block.sub.-- begin.sub.-- ln to $block.sub.-- end.sub.-- ln
.backslash.n";
print STDERR ".backslash.t.backslash.tchmod +x $tmpFile1;
$tmpFile1.backslash.n";
$val = system("chmod +x $tmpFile1; $tmpFile1 >
$tmpFile2");
}
elsif ( $type eq "nawk" ) {
close FHOUT.sub.-- PROG;
print STDERR ".backslash.n.backslash.t Expanding Nawk Code from line
$block.sub.-- begin.sub.-- ln to $block.sub.-- end.sub.-- ln
.backslash.n";
print STDERR ".backslash.t.backslash.tnawk
-f $tmpFile1 .backslash.n";
$val = system("nawk
-f $tmpFile1 >
$tmpFile2");
}
elsif ( $type eq "c" ) {
close FHOUT.sub.-- PROG;
print STDERR ".backslash.n.backslash.t Expanding C Code from line
$block.sub.-- begin.sub.-- ln
to $block.sub.-- end.sub.-- ln
.backslash.n";
print STDERR "/t/tacc -g -I. $tmpFile1 -o $tmpFile3 &&
$tmpFile3 .backslash.n";
$val =
system("acc -g -I. $tmpFile1 -o $tmpFile3 && chmod
+x $tmpFile3 && $tmpFile3 > $tmpFile2");
}
else {
print STDERR ".backslash.tError:
Internal error in expand.sub.-- prog `if end.sub.-- str`.backslash.n";
exit(-1);
}
if ( $val != 0 ) {
print STDERR ".backslash.tError: $type expansion
failed.backslash.n";
exit(-1);
}
$val = &transfer.sub.-- to.sub.-- outfile($tmpFile2);
print FHOUT "/* $line */.backslash.n";
last;
}
if ( / .backslash.!$perl.sub.-- begin.sub.-- str/ .vertline..vertlin
e.
/ .backslash.!$nawk.sub.-- begin.sub.-- str/
.vertline..vertline. / .backslash.!$sh.sub.-- begin.sub.-- str/
.vertline..vertline.
/ .backslash.!$perl.sub.-- end.sub.-- str/ .vertline..vertli
ne.
/ .backslash.!$nawk.sub.-- end.sub.-- str/ .vertline..vertline.
/ .backslash.!$sh.sub.-- end.sub.-- str/ .vertline..vertline. /
.backslash.!$csh.sub.-- end str/
) {
print STDERR ".backslash.tError: Illegal
block end str at line $n; $type block started
at $ln .backslash.n";
exit(-1);
}
print FHOUT.sub.-- PROG "$.sub.-- .backslash.n";
}
0 ;
}
sub output.sub.-- perl.sub.-- header {
print FHOUT.sub.-- PROG ":.backslash.n" ;
print FHOUT.sub.-- PROG `eval .backslash.`(exit $?0).backslash.` && eval
.backslash.`exec
perl -S $0 ${1+"$@"}.backslash.``;
print FHOUT.sub.-- PROG ".backslash.n";
print FHOUT.sub.-- PROG ` & eval .backslash.`exec perl -S $0
$argv:q.backslash.``;
print FHOUT.sub.-- PROG ".backslash.n";
print FHOUT.sub.-- PROG "if 0;.backslash.n";
print FHOUT.sub.-- PROG `# !!!!!!!!!! above is required, funny
way to start perl !!!!!!!!!!!!`;
print FHOUT.sub.-- PROG ".backslash.n.backslash.n.backslash.n";
}
sub transfer.sub.-- to.sub.-- outfile {
local($file) = @.sub.-- ;
open(FH.sub.-- LOC, "<$file") .vertline..vertline.
die "Can't open file $file in `r` mode:
$!.backslash.n";
while (<FH.sub.-- LOC>) {
print FHOUT "$.sub.-- ";
}
close(FH.sub.-- LOC);
}
______________________________________
All publications and patent applications mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication or patent application was specifically and individually indicated to be incorporated by reference. The invention now being fully described, it will be apparent to one of ordinary skill in the art that many changes and modifications can be made thereto without departing from the spirit or scope of the appended claims. ##SPC1##
|
Same subclass Same class Consider this |
||||||||||