prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/07/88)
Here is the Runoff to LaTeX converter -- 5 parts #rno_tex.1_of_5
prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/07/88)
#rno_tex.2_of_5
prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/07/88)
#rno_tex.3_of_5
prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/07/88)
#rno_tex.4_of_5
prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/07/88)
#rno_tex.5_of_5
prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/12/88)
Sorry about the previous send, I am still learning this mailer.
I'll try again with a different method.
...................... Cut between dotted lines and save. .....................
$!.............................................................................
$! VAX/VMS archive file created by VMS_SHARE V06.00 26-May-1988.
$!
$! VMS_SHARE was written by James Gray (Gray:OSBUSouth@Xerox.COM) from
$! VMS_SHAR by Michael Bednarek (U3369429@ucsvc.dn.mu.oz.au).
$!
$! To unpack, simply save, concatinate all parts into one file and
$! execute (@) that file.
$!
$! This archive was created by user EDGECOMBE
$! on 6-APR-1866 20:07:23.76.
$!
$! ATTENTION: To keep each article below 62 blocks (31744 bytes), this
$! program has been transmitted in 5 parts. You should
$! concatenate ALL parts to ONE file and execute (@) that file.
$!
$! It contains the following 18 files:
$! ARGOPS.PAS
$! BASICFILEOPS.PAS
$! COMPILE_RNOTOTEX.COM
$! CONVERSION.PAS
$! DSROPS.PAS
$! FLAGOPS.PAS
$! GETCLI.FOR
$! INIOPS.PAS
$! LATEXOPS.PAS
$! LINK_RNOTOTEX.COM
$! RNOTOTEX.CLD
$! RNOTOTEX.PAS
$! RNOTOTEX.RNH
$! RNOTOTEX_GUIDE.TEX
$! SCREENHANDLERS.PAS
$! SETUP.COM
$! TREEANDLISTOPS.PAS
$! UTILITYOPS.PAS
$!
$!==============================================================================
$ SET SYMBOL/SCOPE=( NOLOCAL, NOGLOBAL )
$ VERSION = F$GETSYI( "VERSION" )
$ IF VERSION .GES "V4.4" THEN GOTO VERSION_OK
$ WRITE SYS$OUTPUT "You are running VMS ''VERSION'; ", -
"VMS_SHARE V06.00 26-May-1988 requires VMS V4.4 or higher."
$ EXIT 44
$VERSION_OK:
$ GOTO START
$
$UNPACK_FILE:
$ WRITE SYS$OUTPUT "Creating ''FILE_IS'"
$ DEFINE/USER_MODE SYS$OUTPUT NL:
$ EDIT/TPU/COMMAND=SYS$INPUT/NODISPLAY/OUTPUT='FILE_IS'/NOSECTION -
VMS_SHARE_DUMMY.DUMMY
b_part := CREATE_BUFFER( "{Part}", GET_INFO( COMMAND_LINE, "file_name" ) )
; s_file_spec := GET_INFO( COMMAND_LINE, "output_file" ); SET( OUTPUT_FILE
, b_part, s_file_spec ); b_errors := CREATE_BUFFER( "{Errors}" ); i_errors
:= 0; pat_beg_1 := ANCHOR & "-+-+-+ Beginning"; pat_beg_2 := LINE_BEGIN
& "+-+-+-+ Beginning"; pat_end := ANCHOR & "+-+-+-+-+ End"; POSITION
( BEGINNING_OF( b_part ) ); i_append_line := 0; LOOP EXITIF MARK( NONE
) = END_OF( b_part ); s_x := ERASE_CHARACTER( 1 ); IF s_x = "+" THEN r_skip
:= SEARCH( pat_beg_1, FORWARD, EXACT ); IF r_skip <> 0 THEN s_x := ""
; MOVE_HORIZONTAL( -CURRENT_OFFSET ); ERASE_LINE; ENDIF; ENDIF
; IF s_x = "-" THEN r_skip := SEARCH( pat_end, FORWARD, EXACT ); IF r_skip <
> 0 THEN s_x := ""; MOVE_HORIZONTAL( -CURRENT_OFFSET ); m_skip := MARK( NONE )
; r_skip := SEARCH( pat_beg_2, FORWARD, EXACT ); IF r_skip <> 0 THEN POSITION
( END_OF( r_skip ) ); MOVE_HORIZONTAL( -CURRENT_OFFSET ); MOVE_VERTICAL( 1 )
; MOVE_HORIZONTAL( -1 ); ELSE POSITION( END_OF( b_part ) ); ENDIF; ERASE
( CREATE_RANGE( m_skip, MARK( NONE ), NONE ) ); ENDIF; ENDIF
; IF s_x = "V" THEN s_x := ""; IF i_append_line <> 0 THEN APPEND_LINE
; MOVE_HORIZONTAL( -CURRENT_OFFSET ); ENDIF; i_append_line := 1; MOVE_VERTICAL
( 1 ); ENDIF; IF s_x = "X" THEN s_x := ""; IF i_append_line <
> 0 THEN APPEND_LINE; MOVE_HORIZONTAL( -CURRENT_OFFSET ); ENDIF
; i_append_line := 0; MOVE_VERTICAL( 1 ); ENDIF; IF s_x <> "" THEN i_errors
:= i_errors + 1; s_text := CURRENT_LINE; POSITION( b_errors ); COPY_TEXT
( "The following line could not be unpacked properly:" ); SPLIT_LINE
; COPY_TEXT( s_x ); COPY_TEXT( s_text ); POSITION( b_part ); MOVE_VERTICAL( 1
); ENDIF; ENDLOOP; POSITION( BEGINNING_OF( b_part ) ); LOOP r_x := SEARCH( "`"
, FORWARD, EXACT ); EXITIF r_x = 0; POSITION( r_x ); ERASE_CHARACTER( 1 )
; IF CURRENT_CHARACTER = "`" THEN MOVE_HORIZONTAL( 1 ); ELSE COPY_TEXT( ASCII
( INT( ERASE_CHARACTER( 3 ) ) ) ); ENDIF; ENDLOOP; IF i_errors = 0 THEN SET
( NO_WRITE, b_errors, ON ); ELSE POSITION( BEGINNING_OF( b_errors ) )
; COPY_TEXT( FAO( "The following !UL errors were detected while unpacking !AS"
, i_errors, s_file_spec ) ); SPLIT_LINE; SET( OUTPUT_FILE, b_errors
, "SYS$COMMAND" ); ENDIF; EXIT;
$ DELETE VMS_SHARE_DUMMY.DUMMY;*
$ CHECKSUM 'FILE_IS
$ WRITE SYS$OUTPUT " CHECKSUM ", -
F$ELEMENT( CHECKSUM_IS .EQ. CHECKSUM$CHECKSUM, ",", "failed!,passed." )
$ RETURN
$
$START:
$ FILE_IS = "ARGOPS.PAS"
$ CHECKSUM_IS = 1669226973
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X{`009MODULE FOR LIST AND TREE OPERATIONS ARGUMENTS }
X{`009RANDALL VENHOLA JULY 8, 1987 }
X
X
X[INHERIT('SCREENHANDLERS','UTILITYOPS')]
X
XMODULE ARGOPS;
X
XCONST
X
X maxchars = 31; {# of chars in arg literal }
X maxargsinarray = 15; {for conversion to an array of args}
X indexofunknowntexcommand = 0;
X
XTYPE
X
X pckstr = VARYING [ maxchars ] of char;
X
X comparisons = (notvalid, lessthan, equal, greaterthan);
X
X setofcomparisons = set of comparisons;
X
X argtype = ( dsrverb, int, signedint, stylespecifier,
X`009 textpckstr, character, quotedpckstr, nulltype);
X
X setofargtype = set of argtype;
X
X argument = record
X`009 source : pckstr;
X`009 isgeneralization : boolean;
X `009 texindex : integer;
X class : setofargtype
X`009 end;
X
X argarray = array[1..maxargsinarray] of argument;
X
X
X
X
X[GLOBAL] FUNCTION argliteral( arg : argument; smooth : boolean ) : pckstr;
X
Xvar
X s : pckstr;
X i,j, firstchar, lastchar : integer;
X ch : char;
X
X procedure findfirstchar( s : pckstr; var firstchar : integer);
X begin
X firstchar := 1;
X while (firstchar < s.length) and (s.body[firstchar] <= blank) do
X firstchar := firstchar + 1
X end;
X
X procedure findlastchar( s : pckstr; var lastchar : integer );
X begin
X lastchar := s.length;
X while (lastchar > 1) and (s.body[lastchar] <= blank) do
X lastchar := lastchar - 1
X end;
X
Xbegin
X if smooth then
X begin
X findfirstchar( arg.source, firstchar);
X findlastchar( arg.source, lastchar);
X j := 0;
X for i := firstchar to lastchar do
X begin
X ch := arg.source.body[i];
X if ch < blank then ch := blank;
X if ch in ['a'..'z'] then ch := chr(ord(ch) - ord(blank));
X j := j + 1;
X s.body[j] := ch
X end;
X if (j = 1) and (s.body[1] = blank) then
X s.length := 0
X else
X s.length := j
X end
X else
X s := arg.source;
X argliteral := s
Xend;
X
X
X
X
X
X[GLOBAL] FUNCTION pckstrisgeneralization( s : pckstr ) : boolean;
X label
X routineexit;
X var
X flag : boolean;
X begin
X flag := false;
X if s = '[N]' then
X begin
X flag := true;
X goto routineexit
X end;
X if s = '[C]' then
X begin
X flag := true;
X goto routineexit
X end;
X if s = '[Y]' then
X begin
X flag := true;
X goto routineexit
X end;
X if s = '[T]' then
X begin
X flag := true;
X goto routineexit
X end;
X if s = '[Q]' then
X begin
X flag := true;
X goto routineexit
X end;
X routineexit : pckstrisgeneralization := flag
Xend;
X
X
X
X
X[GLOBAL] FUNCTION argisgeneralization( arg : argument ) : boolean;
Xbegin
X argisgeneralization := arg.isgeneralization
Xend;
X
X
X
X
V[GLOBAL] FUNCTION textualmatch( arg1, arg2 : argument) : boolean;
X
Xbegin
X textualmatch := false;
X if (arg1.source = '[T]') and (textpckstr in arg2.class) then
X`009textualmatch := true
X else
X if (arg2.source = '[T]') and (textpckstr in arg1.class) then
X`009textualmatch := true
Xend;
X
X
X
X
X[GLOBAL] FUNCTION compareargs( leftarg, rightarg : argument ) : comparisons;
Xlabel
X routineexit;
Xvar
X lefts, rights : pckstr;
X equalpckstrs : boolean;
X comp : comparisons;
X
X procedure greaterorlessthancompare;
X begin
X if lefts < rights then
X comp := lessthan
X else
X comp := greaterthan
X end;
X
X procedure checktexindex;
X begin
X if (leftarg.texindex = indexofunknowntexcommand) or
X (rightarg.texindex = indexofunknowntexcommand) then
X comp := equal
X else
X`009if leftarg.texindex = rightarg.texindex then
X`009 comp := equal
X`009else
X greaterorlessthancompare
X end;
X
Xbegin
X if textualmatch( leftarg, rightarg) then
X begin
X comp := equal;
X goto routineexit
X end;
X if (leftarg.class = [nulltype]) or (rightarg.class = [nulltype]) then
X begin
X comp := equal;
X goto routineexit
X end;
X lefts := argliteral(leftarg, TRUE);
X rights := argliteral(rightarg, TRUE);
X equalpckstrs := (lefts = rights);
X comp := notvalid;
X if leftarg.class * rightarg.class <> [] then
X begin
X if equalpckstrs then
X comp := equal
X else
X if (leftarg.isgeneralization) or (rightarg.isgeneralization) then
X checktexindex
X else
X greaterorlessthancompare
X end
X else
X greaterorlessthancompare;
X routineexit : compareargs := comp
Xend;
X
X
X
X
X[GLOBAL] FUNCTION argtexindex( arg : argument ) : integer;
Xbegin
X argtexindex := arg.texindex
Xend;
X
X
X
X
X[GLOBAL] FUNCTION argclass( arg : argument ) : setofargtype;
Xbegin
X argclass := arg.class
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE initarg( var arg : argument; classification : setofargtype;
X lit : pckstr; index : integer; general : boolean );
Xbegin
X arg.source := lit;
X arg.class := classification;
X arg.texindex := index;
X arg.isgeneralization := general
Xend;
X
X
X
X
V[GLOBAL] PROCEDURE reassignargclass( var arg : argument; newclass : setofargtyp
Xe);
Xbegin
X arg.class := newclass
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE reassignargtexindex( var arg : argument; newindex:integer);
Xbegin
X arg.texindex := newindex
Xend;
X
X
X
V[GLOBAL] PROCEDURE reassignarggeneralization( var arg : argument;general:boolea
Xn);
Xbegin
X arg.isgeneralization := general
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE appendchartoarg( ch : char; var arg : argument );
Xbegin
X if arg.source.length = maxchars then
X warningmessage('appendchartoarg','argument too long')
X else
X begin
X arg.source.length := arg.source.length + 1;
X arg.source.body[arg.source.length] := ch
X end
Xend;
X
X
X
X
V[GLOBAL] PROCEDURE extractintegerfromargument( arg : argument; var successful :
X boolean;
X`009 var int : integer;
X`009 var signed : boolean );
Xvar
X s : pckstr;
Xbegin
X s := argliteral( arg, TRUE);
X readv( s, int, error := continue );
X if statusv <> 0 then
X successful := false
X else
X begin
X successful := true;
X signed := (s.body[1] = '+') or (s.body[1] = '-')
X end
Xend;
X
X
X
XEND.
X
$ GOSUB UNPACK_FILE
$ FILE_IS = "BASICFILEOPS.PAS"
$ CHECKSUM_IS = 172942151
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X[INHERIT('UTILITYOPS','SCREENHANDLERS','ARGOPS')]
X
XMODULE BASICFILEOPS;
X
XCONST
X
X maxfidchars = 255;
X ndatetimechars = 11;
X programversion = 'CVF02B';
X inifilename = 'INIT$RNOTOTEX';
X logfilename = 'RNOTOTEX.LOG';
X
X
XTYPE
X
Xfidtype = VARYING[maxfidchars] of char;
X
Xdatetimetype = packed array[1..ndatetimechars] of char;
X
X
XVAR
X inputcontainstexcommands : [EXTERNAL] boolean;
X totallines, totalchars : [EXTERNAL] integer;
X LOG`009 : [EXTERNAL] text;
X
X
X
X
X[GLOBAL] PROCEDURE noconversion;
Xbegin
X writeln(log,'[no conversion performed]')
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE greetuser ( var d, t : datetimetype );
Xbegin
X date( d );
X time( t );
X clearscreen;
X ttywritestring('RNOTOTEX ');
X ttywritestring(programversion);
X ttywritestring(' RUNOFF TO TEX CONVERSION ');
X ttywritestring( d );
X ttywritestring( t );
X ttywriteln;
X ttywriteln;
X ttywriteln
Xend;
X
X
X
X
X
V[GLOBAL] PROCEDURE openinputfile( fid : fidtype; var f : text; var openerror :
Xboolean );
Xbegin
X open( file_variable := f,
X file_name := fid,
X history := readonly,
X default := 'INPUT.RNO',
X error := continue );
X if status(f) <> 0 then
X openerror := true
X else
X begin
X reset( f );
X openerror := false
X end
Xend;
X
X
X
X
X
V[GLOBAL] PROCEDURE openoutputfile(fid : fidtype; var f : text; var openerror:bo
Xolean);
Xbegin
X open( file_variable := f,
X file_name := fid,
X history := new,
X default := 'OUTPUT.TEX',
X error := continue );
X if status(f) <> 0 then
X openerror := true
X else
X begin
X openerror := false;
X rewrite(f)
X end;
Xend;
X
X
X
X[GLOBAL] PROCEDURE openinifile ( var f : text );
Xbegin
X open( file_variable := f,
X file_name := inifilename,
X history := readonly,
X error := message );
X reset( f );
X ttywriteln;
X ttywritestring('Loading INI file ...')
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE openlogfile; { global var LOG : text used }
Xbegin
X open( file_variable := log,
X`009 file_name := logfilename,
X`009 history := new,
X`009 error := continue );
X rewrite( log )
Xend;
X
X
X
X[GLOBAL] PROCEDURE closelogfile;
Xbegin
X close( file_variable := log, error := continue )
Xend;
X
X[GLOBAL] PROCEDURE closeinifile( var f : text );
Xbegin
X close( file_variable := f, error := continue );
X ttywritestring('complete.');
X ttywriteln;
Xend;
X
X
X
X
X
X[GLOBAL] PROCEDURE closefiles( var infile, outfile : text );
X
Xbegin
X close(file_variable := infile, error := continue);
X close(file_variable := outfile, error := continue);
X ttywritestring('complete.');
X ttywriteln;
X ttywriteln;
X ttywriteln;
X if totallines = 1 then
X ttywritestring(' RNOTOTEX read only one line from the input file.')
X else
X if totallines = 0 then
X ttywritestring(' No end of line was found in the input file.')
X else
X begin
X ttywritestring(' RNOTOTEX processed a total of ');
X ttywriteint( totallines );
X ttywritestring(' lines.')
X end;
X ttywriteln;
X if totalchars = 1 then
X ttywritestring(' There was only one character in the file.')
X else
X if totalchars = 0 then
X ttywritestring(' No printable characters were found in the file.')
X else
X begin
X ttywritestring(' A total of ');
X ttywriteint( totalchars );
X ttywritestring(' characters were read.')
X end;
X ttywriteln
Xend;
X
X
X
X
X
X
X[GLOBAL] PROCEDURE putcommentstooutput( var outfile : text; infid : fidtype;
X`009 d, t : datetimetype );
Xbegin
X writeln(outfile,'% document translated from DEC RUNOFF to LaTeX format');
V writeln(outfile,'% by program RNOTOTEX version ',programversion,' at ',d,bla
Xnk,t);
X writeln(outfile,'% Source file :',infid);
X writeln(log,'[RNOTOTEX.LOG for ',infid,' ]');
X writeln(log,'[Processing at ',d, blank, t,' ]')
Xend;
X
X
X
X
X
X[GLOBAL] PROCEDURE userinterface( var inputfid, outputfid : fidtype;
X`009 var rno, tex : text );
X
Xtype
X packedarray = packed array[1..255] of char;
X
Xvar
X openerror : boolean;
X slashtex : integer;
X
X procedure getcli( var ifile, ofile : [class_s] packedarray;
X var slashtex : integer ); fortran;
Xbegin
X getcli( inputfid.body, outputfid.body, slashtex );
X inputfid.length := 75;
X outputfid.length := 75;
X openinputfile( inputfid, rno, openerror);
X if openerror then
X warningmessage('openinputfile','Could not open that input file.');
X openoutputfile( outputfid, TEX, openerror);
X if openerror then
X warningmessage('openoutputfile','Could not open that output file.');
X inputcontainstexcommands := slashtex <> 0
Xend;
X
X
XEND.
$ GOSUB UNPACK_FILE
$ FILE_IS = "COMPILE_RNOTOTEX.COM"
$ CHECKSUM_IS = 861748146
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X$ IF ("''P1'" .EQS. "") THEN $ P1="PASCAL/OPTIMIZE/NOCHECK"
X$ 'P1' SCREENHANDLERS
X$ 'P1' UTILITYOPS
X$ 'P1' ARGOPS
X$ 'P1' BASICFILEOPS
X$ 'P1' TREEANDLISTOPS
X$ 'P1' FLAGOPS
X$ 'P1' LATEXOPS
X$ 'P1' INIOPS
X$ 'P1' CONVERSION
X$ 'P1' DSROPS
X$ 'P1' RNOTOTEX
X$ FORTRAN GETCLI
$ GOSUB UNPACK_FILE
$ FILE_IS = "CONVERSION.PAS"
$ CHECKSUM_IS = 777150295
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X[INHERIT('UTILITYOPS','ARGOPS','FLAGOPS',
X'TREEANDLISTOPS','LATEXOPS')]
X
XMODULE CONVERSION;
X
XCONST
X maxlists = 8;
X maxheaderlevels = 6;
X maxlongpckstrchars = 75;
XTYPE
X
Xlongpckstr = VARYING[maxlongpckstrchars] of char;
X
Xpagesizetype = record
X`009 length : integer;
X`009 width : integer
X`009 end;
X
Xparagraphdeftype = record
X `009 indent : integer;
X`009 vertskip : integer;
X`009 testpage : integer
X`009 end;
X
Xnumberlisttype = record
X`009 listlevel : integer;
X`009 valuetoset : integer
X`009 end;
X
Xdisplayelementstype = record
X`009 leftchar : char;
X`009 style : styletype;
X`009 rightchar : char
X`009 end;
X
Xleveltype = record
X`009 value : integer;
X`009 display : styletype
X`009end;
X
Xheaderleveltype = array[1..maxheaderlevels] of leveltype;
X
X
XVAR
X
X
Xinputcontainstexcommands : [GLOBAL] boolean;
X
Xtotallines, totalchars : [EXTERNAL] integer;
X
Xpagesize : [GLOBAL] pagesizetype;
X
Xnumberpage : [GLOBAL] integer;
X
Xnumberrunning : [GLOBAL] integer;
X
Xdisplaynumber : [GLOBAL] styletype;
X
Xcapitalizetext, lowercasetext : [GLOBAL] boolean;
X
Xleftmargin : [GLOBAL] integer;
X
Xrightmargin : [GLOBAL] integer;
X
Xfill : [GLOBAL] boolean;
X
Xstartnofillagain : [GLOBAL] boolean;
X
Xjustify : [GLOBAL] boolean;
X
Xspacing : [GLOBAL] integer;
X
Xindent : [GLOBAL] integer;
X
Xcentering : [GLOBAL] boolean;
X
Xflushright : [GLOBAL] boolean;
X
Xminipageactive : [GLOBAL] boolean;
X
Xinmarginpar : [GLOBAL] boolean;
X
Xinfootnote : [GLOBAL] boolean;
X
Xparagraphdef : [GLOBAL] paragraphdeftype;
X
Xnumberlist : [GLOBAL] numberlisttype;
X
Xdisplayelements : [GLOBAL] displayelementstype;
X
Xnumberchapter : [GLOBAL] integer;
X
Xdisplaychapter : [GLOBAL] styletype;
X
Xheaderlevel : [GLOBAL] headerleveltype;
X
Xnestlevel : [GLOBAL] integer;
X
Xnumberappendix : [GLOBAL] integer;
X
Xdisplayappendix : [GLOBAL] styletype;
X
Xwritetexcommands : [GLOBAL] boolean;
X
Xflagtable : [GLOBAL] flagtabletype;
X
Xinliteral : [GLOBAL] boolean;
X
Xtitle, subtitle : [GLOBAL] argarray;
X
Xdatestring : [GLOBAL] pckstr;
X
Xpagestyle : [GLOBAL] pagestyletype;
X
Xliststate : [GLOBAL] array[1..maxlists] of liststatetype;
X
Xnumberofelements : [GLOBAL] array[1..maxlists] of integer;
X
Xoutputfirstitem : [GLOBAL] array[1..maxlists] of boolean;
X
Xlistnestlevel : [GLOBAL] integer;
X
Xnofillbeforelist : [GLOBAL] boolean;
X
XLOG : [EXTERNAL] text;
X
Xunderlineactive : [GLOBAL] enhancmentstates;
X
Xboldactive : [GLOBAL] enhancmentstates;
X
X
X
X[GLOBAL] FUNCTION quotedcharacter( arg : argument ) : char;
Xvar
X s : pckstr;
Xbegin
X s := argliteral( arg, true );
X if length(s) = 1 then
X quotedcharacter := s[1]
X else
X if length(s) = 3 then
X`009quotedcharacter := s[2]
X else
X`009quotedcharacter := blank
Xend;
X
X
X
X[HIDDEN] PROCEDURE noconversion; EXTERN;
X
X
X
X
X
X
X
X[GLOBAL] PROCEDURE blankifypckstr( var s : pckstr );
Xbegin
X s.body := blank;
X s.length := 0
Xend;
X
X
X
X[GLOBAL] PROCEDURE initglobalvars;
Xvar
X i : integer;
Xbegin
X pagesize.length := 58;
X pagesize.width := 60;
X numberpage := 1;
X numberrunning := 1;
X displaynumber := decimal;
X capitalizetext := false;
X lowercasetext := false;
X leftmargin := 0;
X rightmargin := 60;
X fill := true;
X startnofillagain := false;
X justify := true;
X centering := false;
X flushright := false;
X minipageactive := false;
X indent := 5;
X spacing := 1;
X paragraphdef.indent := 5;
X paragraphdef.vertskip := 2;
X paragraphdef.testpage := 5;
X numberlist.listlevel := 1;
X numberlist.valuetoset := 0;
X nofillbeforelist := false;
X displayelements.leftchar := blank;
X displayelements.style := decimal;
X displayelements.rightchar := blank;
X numberchapter := 0;
X numberappendix := 0;
X displaychapter := decimal;
X for i := 1 to maxheaderlevels do
X begin
X headerlevel[i].value := 0;
X headerlevel[i].display := decimal
X end;
X nestlevel := 1;
X inliteral := false;
X makenullarray( title );
X makenullarray( subtitle );
X pagestyle := myheadings;
X blankifypckstr( datestring );
X for i := 1 to maxlists do
X begin
X liststate[i] := nostate;
X numberofelements[i] := 0;
X outputfirstitem[i] := false
X end;
X listnestlevel := 0;
X underlineactive := notenhanced;
X boldactive := notenhanced
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE loglist( list : arglist; index : integer);
Xvar
X l : arglist;
Xbegin
X writeln(log);
X writeln(log,'INDEX >',index:1,' LENGTH >',arglistlength(list):1);
X l := list;
X write(log,'RUNOFF >');
X while l <> nulllist do
X begin
X write(log, argliteral(firstarg(l), false), blank);
X l := nextinlist(l)
X end;
X writeln(log);
X write(log,'TEX >')
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE dumpthelist( var outfile : text; list : arglist );
Xbegin
X if list <> nulllist then
X begin
X texwritearg(outfile, firstarg(list));
X dumpthelist(outfile, nextinlist(list))
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE newintvalue( arg : argument; var current : integer;
X `009 var modified : parameterchangestates;
X`009 var intextracted : integer );
Xvar
X signed : boolean;
X successful : boolean;
Xbegin
X modified := nochange;
X extractintegerfromargument(arg, successful, intextracted, signed );
X if successful then
X begin
X if signed then
X begin
X modified := altered;
X current := intextracted + current
X end
X else
X begin
X modified := assigned;
X current := intextracted
X end
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE newcountparameter( arg : argument; var current : integer;
X`009 var modified : parameterchangestates;
X var countervalueextracted : integer;
X`009 var class : countparametertype);
Xbegin
X modified := nochange
Xend;
X
X
V[GLOBAL] PROCEDURE newstyleparameter( arg : argument; var current : styletype )
X;
Xvar
X s : styletype;
Xbegin
X s := isastylespecifier( arg );
X if s <> undetermined then
X current := s
Xend;
X
X
X
X
X[LOCAL] FUNCTION m( i : integer ) : integer;
Xbegin
X if i < 2 then
X m := 1
X else
X m := i - 1
Xend;
X
X
X[LOCAL] PROCEDURE C( var f : text );
Xbegin
X writeln(f,'}');
X writeln(log,'}')
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE flagchange( f : dsrflagclasses; arg : argument );
Xvar
X ch : char;
Xbegin
X turnflagon( f );
X ch := quotedcharacter( arg );
X if ch <> blank then
X changeflagchar(f, ch)
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE puttexcommand( var outfile : text; index : integer;
X`009 dsrlist : arglist;
X`009 var writeanothertexcommand : integer );
X
Xlabel
X routineexit;
Xconst
X charwidth = true;
X charheight = false;
Xvar
X arg : argarray;
X i, j, n : integer;
X modified : parameterchangestates;
X extractedvalue, skip, startindex : integer;
X class : countparametertype;
X f : dsrflagclasses;
X q : char;
X startedwithfill : boolean;
X
Xbegin
X
Xif (index < 1) or (index > 130) then goto routineexit;
X
Xwriteanothertexcommand := indexofunknowntexcommand;
Xloglist( dsrlist, index );
Xn := arglistlength( dsrlist );
Xlisttoarray( dsrlist, index, arg, maxargsinarray);
Xstartedwithfill := fill;
Xstopunderline( outfile );
Xstopbold( outfile );
X
X{
X n - number of arguments supplied with the DSR command
X m(n-1) - one less than that number, unless n < 2
X m(n-2) - two less than the number of arguments, unless < 3
X etc
X
X arg[i] - the ith input dsr argument; e.g. four args could be :
X
X 1 2 3 4
X PAGE SIZE 10, 20 }
X
X
X
Xcase index of
X
X {***** PAGE SIZE *****}
X 1 : begin
X`009newintvalue(arg[n], pagesize.width, modified, extractedvalue);
X`009newintvalue(arg[m(n)], pagesize.length, modified, extractedvalue);
V adjustlength(outfile, modified, pagesize.width, extractedvalue,charwidt
Xh,'textwidth');
V`009adjustlength(outfile, modified, pagesize.length, extractedvalue,charheight,
X'textheight')
X end;
X
X {***** HEADERS OFF *****}
X 2 : adjustpagestyle(outfile, plain);
X
X {***** HEADERS ON ***** }
X 3 : adjustpagestyle(outfile, headings);
X
X {***** HEADERS UPPER ***** }
X 4 : noconversion;
X
X {***** HEADERS LOWER ***** }
X 5 : noconversion;
X
X {***** HEADERS MIXED ***** }
X 6 : noconversion;
X
X {***** ENABLE WRITING OF DATE *****}
X 7 : begin
X datestring := '\today';
X if pagestyle = myheadings then
X adjustpagestyle(outfile, myheadings)
X else
X`009 noconversion
X end;
X
X { ***** DISABLE WRITING OF DATE ***** }
X 8 : begin
X blankifypckstr( datestring );
X if pagestyle = myheadings then
X adjustpagestyle(outfile, myheadings )
X else
X noconversion
X end;
X`009
X { ***** LAYOUT ***** }
X 9 : noconversion;
X
X { ***** NO NUMBER ***** }
X 10 : adjustpagestyle(outfile, empty);
X
X { ***** NUMBER PAGE ***** }
X 11 : begin
X`009newcountparameter(arg[n], numberpage, modified, extractedvalue,class);
X adjustcounter(outfile, modified, numberpage, extractedvalue, 'page')
X end;
X
X { ***** NUMBER RUNNING ***** }
X 12 : begin
X newintvalue(arg[n], numberrunning, modified, extractedvalue);
X adjustcounter(outfile, modified, numberrunning, extractedvalue,'page')
X end;
X
X { ***** DISPLAY NUMBER ***** }
X 13 : begin
X newstyleparameter(arg[n], displaynumber);
X`009adjuststyle(outfile, displaynumber, 'page')
X end;
X
X { ***** NO PAGING ***** }
X 14 : noconversion;
X
X { ***** PAGING ***** }
X 15 : noconversion;
X
X { ***** BEGIN SUBPAGE ***** }
X 16 : begin
X if not minipageactive then
X`009begin
X`009 minipageactive := true;
X if not startedwithfill then
X`009 begin
X`009 endnofill( outfile );
X`009 startnofillagain := true
X`009 end;
X`009 writeln(outfile,'\begin{minipage}');
X writeln( log,'\begin{minipage}');
X`009 if not startedwithfill then
X`009 beginnofill( outfile )
X end
X`009else
X`009begin
X`009 writeln(outfile,'% RNOTOTEX - minipage already active');
X`009 writeln( log,'% RNOTOTEX - minipage already active')
X`009end
X end;
X
X { ***** END SUBPAGE ***** }
X 17 : begin
X if minipageactive then
X`009begin
X if not fill then
X`009 endnofill( outfile );
X writeln(outfile,'\end{minipage}');
X writeln( log,'\end{minipage}');
X if startnofillagain then
X`009 begin
X`009 startnofillagain := false;
X`009 beginnofill( outfile )
X end
X end
X else
-+-+-+-+-+ End of part 1 +-+-+-+-+-prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/12/88)
Sorry about the previous send, I am still learning this mailer.
I'll try again with a different method.
+-+-+-+ Beginning of part 2 +-+-+-+
X begin
X`009 writeln(outfile,'% RNOTOTEX - minipage not active');
X`009 writeln( log,'% RNOTOTEX - minipage not active')
X `009end;
X minipageactive := false
X end;
X
X { ***** NUMBER SUBPAGE ***** }
X 18 : noconversion;
X
X
X { ***** DISPLAY SUBPAGE ***** }
X 19 : noconversion;
X
X { ***** FIRST TITLE ***** }
X 20 : noconversion;
X
X { ***** TITLE ***** }
X 21 : begin
X for i := 2 to maxargsinarray do
X`009 title[i-1] := arg[i];
X if pagestyle = myheadings then
X adjustpagestyle(outfile, myheadings)
X else
X`009 noconversion
X end;
X
X { ***** SUBTITLE ***** }
X 22 : begin
X for i := 2 to maxargsinarray do
X`009 subtitle[i-1] := arg[i];
X if pagestyle = myheadings then
X`009 adjustpagestyle(outfile, myheadings)
X else
X`009 noconversion
X end;
X
X { ***** NO SUBTITLE ***** }
X 23 : begin
X makenullarray( subtitle );
X if pagestyle = myheadings then
X adjustpagestyle(outfile, myheadings)
X else
X`009 noconversion
X end;
X
X { ***** NO AUTOSUBTITLE ***** }
X 24 : begin
X makenullarray( subtitle );
X if pagestyle = myheadings then
X adjustpagestyle(outfile, plain)
X else
X noconversion
X end;
X
X { ***** AUTOSUBTITLE ***** }
X 25 : adjustpagestyle(outfile, headings);
X
X
X { ***** UPPERCASE ***** }
X 26 : begin
X capitalizetext := true;
X lowercasetext := false
X end;
X
X { ***** LOWERCASE ***** }
X 27 : begin
X`009capitalizetext := false;
X lowercasetext := true
X end;
X
X { ***** LEFT MARGIN ***** }
X 28 : begin
X newintvalue( arg[n], leftmargin, modified, extractedvalue);
X`009 noconversion
X end;
X
X { ***** RIGHT MARGIN ***** }
X 29 : begin
X newintvalue( arg[n], rightmargin, modified, extractedvalue);
X noconversion
X end;
X
X { ***** NO FILL ***** }
X 30 : beginnofill( outfile );
X
X { ***** FILL ***** }
X 31 : endnofill( outfile );
X
X { ***** NO JUSTIFY ***** }
X 32 : begin
X writeln(outfile,'\sloppy % - begin no justify');
X writeln( log,'\sloppy % - begin no justify');
X justify := false
X end;
X
X { ***** JUSTIFY ***** }
X 33 : begin
X writeln(outfile,'\fussy % - turn justification on');
X writeln( log,'\fussy % - turn justification on');
X justify := true
X end;
X
X { ***** BREAK ***** }
X 34 : begin
X if fill then
X`009 begin
X`009 writeln(outfile,'\hfil\linebreak');
X`009 writeln( log,'\hfil\linebreak')
X`009 end
X else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - forced break');
X`009 writeln( log,'% RNOTOTEX - forced break')
X`009 end
X end;
X
X { ***** SPACING ***** }
X 35 : begin
X newintvalue(arg[n], spacing, modified, extractedvalue );
V adjustlength(outfile, modified, spacing, extractedvalue, charheight,'
Xbaselineskip')
X end;
X
X { ***** SKIP ***** }
X 36 : begin
X if n = 1 then
X`009 begin
X`009 if (spacing > 0) and (spacing < 4) then
X`009 case spacing of
X`009 1 : begin
X`009 writeln(outfile,'\smallskip');
X`009 writeln( log,'\smallskip')
X`009 end;
X`009 2 : begin
X`009 writeln(outfile,'\medskip');
X`009 writeln( log,'\medskip')
X`009 end;
X`009 3 : begin
X`009 writeln(outfile,'\bigskip');
X`009 writeln( log,'\bigskip')
X`009 end
X`009 end
X`009 else
X`009 begin
X`009 writeln(outfile,'\smallskip % - default skip amount');
X`009 writeln( log,'\smallskip % - default skip amount')
X`009 end
X end
X else
X`009 begin
X skip := 1;
X newintvalue(arg[n], skip, modified, extractedvalue );
X extractedvalue := extractedvalue * spacing;
X`009 write(outfile,'\vspace{');
X write( log,'\vspace{');
X writecharheight(outfile, extractedvalue);
X c(outfile)
X end
X end;
X
X { ***** BLANK ***** }
X 37 : begin
X if n = 1 then
X`009 begin
X`009 writeln(outfile,'\smallskip');
X writeln( log,'\smallskip')
X end
X else
X begin
X`009 skip := 1;
X newintvalue(arg[n], skip, modified, extractedvalue );
X write(outfile,'\vspace{');
X write( log,'\vspace{');
X`009 writecharheight(outfile, extractedvalue);
X c(outfile)
X end
X end;
X
X { ***** PAGE ***** }
X 38 : begin
V`009 writeln(outfile,'\pagebreak[0] \typeout{runoff page break encountered, may
X be ignored}');
X`009 writeln( log,'\pagebreak[0]')
X end;
X
X { ***** TEST PAGE ***** }
X 39 : noconversion;
X
X { ***** CENTRE ***** }
X 40 : begin
X if not centering then
X`009 begin
X centering := true;
X`009 if not fill then
X`009 begin
X`009 startnofillagain := true;
X`009 endnofill( outfile )
X end;
X`009 writeln(outfile,'\begin{centering}');
X`009 writeln( log,'\begin{centering}');
X writeanothertexcommand := 40
X`009 end
X`009 else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - centering already active');
X`009 writeln( log,'% RNOTOTEX - centering already active')
X`009 end
X end;
X
X { ***** TAB STOPS ***** }
X 41 : noconversion;
X
X { ***** INDENT ***** }
X 42 : begin
X indent := 5;
X`009 newintvalue(arg[n], indent, modified, extractedvalue);
X if modified = nochange then
X begin
X`009 write(outfile,'\indent ');
X`009 write( log,'\indent ')
X end
X else
X begin
X write(outfile,'\hspace*{');
X write( log,'\hspace*{');
X writecharwidth(outfile, indent);
X write(outfile,'} ');
X writeln(log,'}')
X end
X end;
X
X { ***** LEFT ***** }
X 43 : begin
X indent := 5;
X`009 newintvalue(arg[n], indent, modified, extractedvalue);
X if (modified = nochange) or (n = 1) then
X begin
X`009 write(outfile,'\indent ');
X`009 write( log,'\indent ')
X`009 end
X else
X begin
X write(outfile,'\hspace*{');
X write( log,'\hspace*{');
X writecharwidth(outfile, indent);
X write(outfile,'} ');
X`009 writeln(log,'}')
X end
X end;
X
X { ***** RIGHT ***** }
X 44 : begin
X if not flushright then
X`009 begin
X if not fill then
X begin
X`009 startnofillagain := true;
X`009 endnofill( outfile )
X`009 end;
X`009 flushright:= true;
X`009 writeln(outfile,'\begin{flushright}');
X`009 writeln( log,'\begin{flushright}');
X writeanothertexcommand := 44
X`009 end
X`009 else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - flush right already active');
X`009 writeln( log,'% RNOTOTEX - flush right already active')
X`009 end
X end;
X
X { ***** NO PERIOD ***** }
X 45 : begin
X writeln(outfile,'\frenchspacing');
X writeln( log,'\frenchspacing')
X end;
X
X { ***** PERIOD ***** }
X 46 : begin
X`009 writeln(outfile,'\nofrenchspacing');
X`009 writeln( log,'\nofrenchspacing')
X end;
X
X { ***** NO SPACE ***** }
X 47 : noconversion;
X
X { ***** PARAGRAPH ***** }
X 48 : begin
X`009if n > 1 then
X `009begin
X`009 newintvalue(arg[2], paragraphdef.indent, modified, extractedvalue);
X `009 newintvalue(arg[3], paragraphdef.vertskip, modified, extractedvalue);
X`009 newintvalue(arg[4], paragraphdef.testpage, modified, extractedvalue)
X end;
X`009writeln(outfile,'\par');
X`009writeln( log,'\par')
X end;
X
X { ***** SET PARAGRAPH ***** }
X 49 : begin
X`009 newintvalue(arg[m(n-2)], paragraphdef.indent, modified, extractedvalue);
V `009 adjustlength(outfile, modified, paragraphdef.indent, extractedvalue,charw
Xidth,'parindent');
V `009 newintvalue(arg[m(n-1)], paragraphdef.vertskip, modified, extractedvalue)
X;
V`009 adjustlength(outfile, modified, paragraphdef.vertskip, extractedvalue,char
Xheight,'parskip');
X`009 newintvalue(arg[m(n)], paragraphdef.testpage, modified, extractedvalue)
X end;
X
X { ***** AUTOPARAGRAPH ***** }
X 50 : noconversion;
X
X { ***** NO AUTOPARAGRAPH ***** }
X 51 : noconversion;
X
X { ***** AUTOTABLE ***** }
X 52 : noconversion;
X
X { ***** NO AUTOTABLE ***** }
X 53 : noconversion;
X
X { ***** DISABLE UNDERLINING ***** }
X 54 : turnflagoff( underline );
X
V { ***** ENABLE UNDERLINING ***** }
X
X 55 : turnflagon( underline );
X
X { ***** NO HYNPHENATION ***** }
X 56 : turnflagoff( hyphenate );
X
X { ***** HYPENATION ***** }
X 57 : turnflagon( hyphenate );
X
X { ***** DISABLE BOLDING ***** }
X 58 : turnflagoff( bold );
X
X { ***** ENABLE BOLDING ***** }
X 59 : turnflagon( bold );
X
X { ***** DISABLE OVERSTRIKE ***** }
X 60 : turnflagoff( overstrike );
X
X { ***** ENABLE OVERSTRIKE ***** }
X 61 : turnflagon( overstrike );
X
X { ***** ENABLE BAR ***** }
X 62 : noconversion;
X
X { ***** BEGIN BAR ***** }
X 63 : noconversion;
X
X { ***** END BAR ***** }
X 64 : noconversion;
X
X { ***** DISABLE BAR ***** }
X 65 : noconversion;
X
X { ***** FIGURE ***** }
X 66 : begin
X`009 skip := 1;
X`009 newintvalue(arg[n], skip, modified, extractedvalue);
X`009 writeln(outfile,'\begin{figure}');
X write(outfile,'\vspace{');
X`009 writeln( log,'\begin{figure}');
X write( log,'\vspace{');
X writecharheight(outfile, skip);
X c(outfile);
X`009 writeln(outfile,'\caption{Another Figure}');
X writeln(outfile,'\end{figure}');
X`009 writeln( log,'\caption{Another Figure}');
X writeln( log,'\end{figure}')
X`009end;
X
X { ***** FIGURE DEFFERED ***** }
X 67 : begin
X`009 skip := 1;
X`009 newintvalue(arg[n], skip, modified, extractedvalue);
X`009 writeln(outfile,'\begin{figure}');
X`009 writeln( log,'\begin{figure}');
X write(outfile,'\vspace{');
X write( log,'\vspace{');
X writecharheight(outfile, skip);
X c(outfile);
X`009 writeln(outfile,'\caption{Another Figure}');
X writeln(outfile,'\end{figure}');
X`009 writeln( log,'\caption{Another Figure}');
X writeln( log,'\end{figure}')
X`009end;
X
X { ***** LITERAL ***** }
X 68 : begin
X`009 if not inliteral then
X`009 begin
X`009 if not fill then
X`009 begin
X`009 startnofillagain := true;
X`009 endnofill( outfile )
X`009 end;
X`009 inliteral := true;
X`009 writeln(outfile,'\begin{verbatim}');
X writeln( log,'\begin{verbatim}')
X`009 end
X`009 else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - literal already active');
X`009 writeln( log,'% RNOTOTEX - literal already active')
X`009 end
X`009end;`009
X
X { ***** END LITERAL ***** }
X 69 : begin
X`009 if inliteral then
X`009 begin
X`009 writeln(outfile,'\end{verbatim}');
X`009 writeln( log,'\end{verbatim}');
X`009 inliteral := false;
X`009 if startnofillagain then
X`009 begin
X`009 startnofillagain := false;
X`009 beginnofill( outfile )
X`009 end
X end
X`009 else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - end literal not after literal');
X`009 writeln( log,'% RNOTOTEX - end literal not after literal')
X`009 end
X`009end;
X
X { ***** REPEAT ***** }
X 70 : begin
X skip := 1;
X`009 newintvalue(arg[2], skip, modified, extractedvalue);
X`009 q := quotedcharacter( arg[3] );
X for i := 1 to skip do
X`009 begin
X`009 texwrite(outfile, q);
X`009 texwrite( log, q)
X`009 end
X end;
X
X { ***** LIST ***** }
X 71 : begin
X`009 if (not fill) and (listnestlevel = 0) then
X`009 begin
X`009 nofillbeforelist := true;
X`009 endnofill( outfile )
X`009 end;
X listnestlevel := listnestlevel + 1;
X numberofelements[listnestlevel] := 0;
X`009 if n = 3 then
X`009 begin
X`009 q := quotedcharacter( arg[3] );
X`009 writeln(outfile,'\begin{itemize} % list nest ',listnestlevel:1);
X`009 writeln( log,'\begin{itemize}');
X`009 liststate[listnestlevel] := itemize;
X`009 write(outfile,'\item ');
X`009 outputfirstitem[listnestlevel] := true
X`009 end
X`009 else
X`009 begin
X`009 writeln(outfile,'\begin{enumerate} % list nest ',listnestlevel:1);
X`009 writeln( log,'\begin{enumerate}');
X`009 liststate[listnestlevel] := enumerate;
X`009 write(outfile,'\item ');
X`009 outputfirstitem[listnestlevel] := true
X`009 end
X`009end;
X
X { ***** END LIST ***** }
X 72 : begin
X if listnestlevel > 0 then
X begin
X`009 case liststate[listnestlevel] of
V`009 nostate : writeln(outfile,'% - RNOTOTEX - close on list not open'
X);
V`009 itemize : writeln(outfile,'\end{itemize} % - list nest ',listnes
Xtlevel:1);
V`009 enumerate : writeln(outfile,'\end{enumerate} % - list nest ',listn
Xestlevel:1)
X`009 end;
X`009 case liststate[listnestlevel] of
V`009 nostate : writeln( log,'% - RNOTOTEX - close on list not open'
X);
X`009 itemize : writeln( log,'\end{itemize}');
X`009 enumerate : writeln( log,'\end{enumerate}')
X`009 end;
X numberofelements[listnestlevel] := 0;
X liststate[listnestlevel] := nostate;
X`009 outputfirstitem[listnestlevel] := false;
X `009 listnestlevel := listnestlevel - 1;
X`009 if (listnestlevel = 1) and (nofillbeforelist) then
X`009 begin
X`009 nofillbeforelist := false;
X`009 beginnofill( outfile )
X`009 end
X end
X`009 else
X`009 begin
X`009 writeln(outfile,'% - RNOTOTEX end list for none started');
X`009 writeln( log,'% - RNOTOTEX end list for none started')
X`009 end
X`009 end;
X
X { ***** LIST ELEMENT ***** }
X 73 : begin
X if listnestlevel > 0 then
X`009 begin
X if liststate[listnestlevel] = nostate then
X begin
V`009 writeln(outfile,'% - RNOTOTEX - list element for non-existant-list'
X);
V`009 writeln( log,'% - RNOTOTEX - list element for non-existant-list'
X)
X end
X`009 else
X begin
X`009 if not outputfirstitem[listnestlevel] then
X`009 begin
X`009 write(outfile,'\item ');
X `009 writeln( log,'\item ')
X`009 end
X`009 else
X`009 outputfirstitem[listnestlevel] := false;
V numberofelements[listnestlevel] := numberofelements[listnestleve
Xl] + 1
X end
X end
X else
X begin
X`009 writeln(outfile,'% - RNOTOTEX - list element for unopened-list');
X`009 writeln( log,'% - RNOTOTEX - list element for unopened-list')
X end
X `009 end;
X
X { ***** NUMBER LIST ***** }
X 74 : begin
X`009 newintvalue(arg[2], numberlist.listlevel, modified, extractedvalue);
X`009 newintvalue(arg[3], numberlist.valuetoset, modified, extractedvalue);
X`009 if (numberlist.listlevel > 0) and ( numberlist.listlevel < 5) then
X`009 case numberlist.valuetoset of
V`009 1 : adjustcounter(outfile, modified, numberlist.valuetoset,extracte
Xdvalue,'enumi');
V`009 2 : adjustcounter(outfile, modified, numberlist.valuetoset,extracte
Xdvalue,'enumii');
V`009 3 : adjustcounter(outfile, modified, numberlist.valuetoset,extracte
Xdvalue,'enumiii');
V`009 4 : adjustcounter(outfile, modified, numberlist.valuetoset,extracte
Xdvalue,'enumiv')
X`009 end
X`009 end;
X
X { ***** DISPLAY ELEMENTS ***** }
X 75 : noconversion;
X
X { ***** NOTE ***** }
X 76 : begin
X if not inmarginpar then
X`009 begin
X`009 writeln(outfile,'\marginpar{\em ');
X`009 writeln( log,'\marginpar{\em ');
X`009 inmarginpar := true;
X`009 if n > 1 then
X`009 begin
X`009 dumpthelist(outfile, dsrlist);
X`009 dumpthelist( log, dsrlist);
X`009 inmarginpar := false;
X`009 c(outfile)
X end
X end
X`009 else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - marginpar already active');
X`009 writeln( log,'% RNOTOTEX - marginpar already active')
X`009 end
X`009 end;
X
X { ***** END NOTE ***** }
X 77 : begin
X if inmarginpar then
X begin
X`009 writeln(outfile,'} % - end of margin par ');
X`009 writeln( log,'} % - end of margin par ')
X end
X`009 else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - marginpar not active');
X`009 writeln( log,'% RNOTOTEX - marginpar not active')
X`009 end;
X`009 inmarginpar := false
X`009 end;
X
X { ***** FOOTNOTE ***** }
X 78 : begin
X if not infootnote then
X`009 begin
X`009 write(outfile,'\footnote{');
X`009 writeln( log,'\footnote{');
X `009 infootnote := true
X end
X`009 else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - already in footnote');
X`009 writeln( log,'% RNOTOTEX - already in footnote')
X end
X`009 end;
X
X { ***** END FOOTNOTE ***** }
X 79 : begin
X `009 if infootnote then
X begin
X`009 writeln(outfile,'} % - end of footnote');
X`009 writeln( log,'} % - end of footnote')
X`009 end
X else
X`009 begin
X`009 writeln(outfile,'% RNOTOTEX - footnote not active');
X`009 writeln( log,'% RNOTOTEX - footnote not active')
X end;
X`009 infootnote := false
X`009 end;
X
X { ***** CHAPTER ***** }
X 80 : begin
X if not startedwithfill then
X`009 endnofill(outfile);
X`009 write(outfile,'\chapter{');
X`009 write( log,'\chapter{');
X`009 dumpthelist(outfile, nextinlist(dsrlist));
X`009 dumpthelist( log, nextinlist(dsrlist));
X`009 c(outfile);
X`009 if not startedwithfill then
X`009 beginnofill(outfile);
X`009 end;
X
X { ***** NUMBER CHAPTER ***** }
X 81 : begin
V`009 newcountparameter(arg[n], numberchapter, modified, extractedvalue, cla
Xss);
V`009 adjustcounter(outfile, modified, numberchapter, extractedvalue,'chapte
Xr')
X`009 end;
X
X { ***** DISPLAY CHAPTER ***** }
X 82 : begin
X`009 newstyleparameter(arg[n], displaychapter);
X`009 adjuststyle(outfile, displaychapter, 'chapter')
X`009 end;
X
X { ***** HEADER LEVEL ***** }
X 83 : begin
X`009 newintvalue(arg[2], nestlevel, modified, extractedvalue);
X`009 if modified <> nochange then
X`009 startindex := 3
X`009 else
X`009 begin
X`009 newintvalue(arg[3], nestlevel, modified, extractedvalue);
X`009 startindex := 4
X`009 end;
X`009 if modified <> nochange then
X`009 begin
X`009 if (nestlevel > 0) and (nestlevel < 7) then
X`009 begin
X`009 case nestlevel of
X`009 1 : write(outfile,'\section{');
X`009 2 : write(outfile,'\subsection{');
X`009 3 : write(outfile,'\subsubsection{');
X`009 4 : write(outfile,'\paragraph{');
X`009 5 : write(outfile,'\subparagraph{');
X`009 6 : write(outfile,'\P ')
X`009 end;
X`009 case nestlevel of
X`009 1 : write( log,'\section{');
X`009 2 : write( log,'\subsection{');
X`009 3 : write( log,'\subsubsection{');
X`009 4 : write( log,'\paragraph{');
X`009 5 : write( log,'\subparagraph{');
X`009 6 : write( log,'\P ')
X`009 end;
X`009 for i := startindex to n do
X begin
X`009 texwritearg(outfile, arg[i] );
X`009 texwritearg( log, arg[i] )
X end;
X`009 if nestlevel < 6 then
X`009 c(outfile);
V `009 headerlevel[nestlevel].value := headerlevel[nestlevel].value +
X 1
X`009 end
X end
X end;
X
X { ***** NUMBER LEVEL ***** }
X 84 : begin
X`009 startindex := -1;
X`009 if n = 7 then startindex := 2;
X`009 if n = 8 then startindex := 3;
X`009 if startindex <> -1 then
X`009 begin
X `009 for i := startindex to (startindex + 5) do
X`009 begin
X`009 j := i - startindex + 1;
V`009 newintvalue(arg[i], headerlevel[j].value, modified,extractedvalue)
X;
X`009 case j of
V`009 1 : adjustcounter(outfile, modified, headerlevel[1].value,extra
Xctedvalue,'section');
V`009 2 : adjustcounter(outfile, modified, headerlevel[2].value,extra
Xctedvalue,'subsection');
V`009 3 : adjustcounter(outfile, modified, headerlevel[3].value,extra
Xctedvalue,'subsubsection');
V`009 4 : adjustcounter(outfile, modified, headerlevel[4].value,extra
Xctedvalue,'paragraph');
V`009 5 : adjustcounter(outfile, modified, headerlevel[5].value,extra
Xctedvalue,'subparagraph');
X`009 6 : noconversion
X`009 end
X`009 end
X end
X`009 end;
X
X { ***** STYLE HEADERS ***** }
X 85 : noconversion;
X
X { ***** DISPLAY LEVELS ***** }
X 86 : begin
X`009 startindex := -1;
X`009 if n = 7 then startindex := 2;
X`009 if n = 8 then startindex := 3;
X`009 if startindex <> -1 then
X`009 begin
X `009 for i := startindex to (startindex + 5) do
X`009 begin
X`009 j := i - startindex + 1;
X`009 newstyleparameter(arg[i], headerlevel[j].display);
X`009 case j of
X`009 1 : adjuststyle(outfile, headerlevel[1].display, 'section');
X`009 2 : adjuststyle(outfile, headerlevel[2].display, 'subsection');
V`009 3 : adjuststyle(outfile, headerlevel[3].display, 'subsubsection
X');
X`009 4 : adjuststyle(outfile, headerlevel[4].display, 'paragraph');
V`009 5 : adjuststyle(outfile, headerlevel[5].display ,'subparagraph'
X);
X`009 6 : noconversion
X`009 end
X`009 end
X end
X`009 end;
X
X { ***** APPENDIX ***** }
X 87 : begin
X`009 write(outfile,'\chapter{APPENDIX ');
X`009 write( log,'\chapter{APPENDIX ');
X`009 if n >= 2 then
X`009 begin
X`009 write(outfile,': ');
X`009 write( log,': ');
X`009 dumpthelist(outfile, nextinlist(dsrlist));
X`009 dumpthelist( log, nextinlist(dsrlist))
X`009 end;
X`009 c(outfile)
X`009 end;
X
X { ***** NUMBER APPENDIX ***** }
X 88 : begin
V`009 newcountparameter(arg[n], numberappendix, modified, extractedvalue,cla
Xss);
V`009 adjustcounter(outfile, modified, numberappendix, extractedvalue, 'chap
Xter')
X`009 end;
X
X { ***** DISPLAY APPENDIX ***** }
X 89 : begin
X`009 newstyleparameter(arg[n], displayappendix);
X`009 adjuststyle(outfile, displayappendix, 'chapter')
X`009 end;
X
X { ***** STANDARD ***** }
X 90 : noconversion;
X
X { ***** COMMENT ***** }
X 91 : begin
X`009 write(outfile,'% ');
X`009 dumpthelist(outfile, nextinlist(dsrlist));
X`009 write( log,'% ');
X`009 dumpthelist( log, nextinlist(dsrlist))
X`009 end;
X
X { ***** REQUIRE ***** }
X 92 : begin
X`009 write(outfile,'%%%%%% REQUIRE WAS HERE %%%%% \input {');
X`009 dumpthelist(outfile, nextinlist(dsrlist));
X`009 write( log,'\input {');
X`009 dumpthelist( log, nextinlist(dsrlist));
X`009 c(outfile)
X`009 end;
X
X { ***** CONTROL CHARACTERS ***** }
X 93 : noconversion;
X
X { ***** NO CONTROL CHARACTERS ***** }
X 94 : noconversion;
X
X { ***** IF ***** }
X 95 : noconversion;
X
X { ***** ELSE ***** }
X 96 : noconversion;
X
X { ***** END IF ***** }
X 97 : noconversion;
X
X { ***** IFNOT ***** }
X 98 : noconversion;
X
X { ***** VARIABLE ***** }
X 99 : noconversion;
X
X { ***** SET DATE ***** }
X 100 : noconversion;
X
X { ***** SET TIME ***** }
X 101 : noconversion;
X
X { ***** FLAGS ALL ***** }
X 102 : begin
X`009 for f := control to substitute do
X`009 turnflagon( f )
X`009 end;
X
X { ***** NO FLAGS ALL ***** }
X 103 : begin
X`009 for f := control to substitute do
X`009 turnflagoff( f );
X`009 turnflagon( control )
X`009 end;
X
X { ***** NO FLAGS CONTROL ***** }
X 104 : turnflagoff( control );
X
X { ***** FLAGS CONTROL ***** }
X 105 : flagchange(control, arg[n]);
X
X { ***** NO FLAGS UPPERCASE ***** }
X 106 : turnflagoff( uppercase );
X
X { ***** FLAGS UPPERCASE ***** }
X 107 : flagchange( uppercase, arg[n]);
X
X { ***** NO FLAGS LOWERCASE ***** }
X 108 : turnflagoff( lowercase );
X
X { ***** FLAGS LOWERCASE ***** }
X 109 : flagchange( lowercase, arg[n]);
X
X { ***** NO FLAGS QUOTE ***** }
X 110 : turnflagoff( quote );
X`009
X { ***** FLAGS QUOTE ***** }
X 111 : flagchange( quote, arg[n] );
X
X { ***** NO FLAGS SPACE ***** }
X 112 : turnflagoff( space );
X
X { ***** FLAGS SPACE ***** }
X 113 : flagchange( space, arg[n] );
X
X { ***** NO FLAGS UNDERLINE ***** }
X 114 : turnflagoff( underline );
X
X { ***** FLAGS UNDERLINE ***** }
X 115 : flagchange( underline, arg[n] );
X
X { ***** NO FLAGS BOLD ***** }
X 116 : turnflagoff( bold );
X
X { ***** FLAGS BOLD ***** }
X 117 : flagchange( bold, arg[n] );
X
X { ***** NO FLAGS OVERSTRIKE ***** }
X 118 : turnflagoff( overstrike );
X
X { ***** FLAGS OVERSTRIKE ***** }
X 119 : flagchange( overstrike, arg[n] );
X
X { ***** NO FLAGS HYPHENATE ***** }
X 120 : turnflagoff( hyphenate );
X
X { ***** FLAGS HYPHENATE ***** }
X 121 : flagchange( hyphenate, arg[n] );
X
X { ***** NO FLAGS CAPITALIZE ***** }
X 122 : turnflagoff( capitalize );
X
X { ***** FLAGS CAPITALIZE ***** }
X 123 : flagchange( capitalize, arg[n] );
X
X { ***** NO FLAGS END FOOTNOTE ***** }
X 124 : turnflagoff( endfootnote );
X
X { ***** FLAGS END FOOTNOTE ***** }
X 125 : flagchange( endfootnote, arg[n] );
X
X { ***** NO FLAGS COMMENT ***** }
X 126 : turnflagoff( comment );
X
X { ***** FLAGS COMMENT ***** }
X 127 : flagchange( comment, arg[n] );
X
X { ***** NO FLAGS SUBSTITUTE ***** }
X 128 : turnflagoff( substitute );
X
X { ***** FLAGS SUBSTITUTE ***** }
X 129 : flagchange( substitute, arg[n] );
X
X { ***** INDEX ***** }
X 130 : begin
X`009 write(outfile,'\index{');
X`009 dumpthelist(outfile, nextinlist(dsrlist));
X`009 write( log,'\index{');
X`009 dumpthelist( log, nextinlist(dsrlist));
X`009 c(outfile)
X end
X
Xend; {case of tex index extracted}`009
X
X
Xroutineexit : nullstatement
Xend;
X
X
X
X[GLOBAL] PROCEDURE putsecondarytexcommand(var outfile : text;
X`009 var nextcommand : integer );
Xbegin
X
X if nextcommand = 40 {centering} then
X begin
X if centering then
X begin
X centering := false;
X writeln(outfile,'\end{centering}');
X if startnofillagain then
X begin
X`009 startnofillagain := false;
X`009 beginnofill( outfile )
X end
X end
X else
X begin
V`009writeln(outfile,'% RNOTOTEX - end centering when centering not-active');`00
X9
X`009writeln( log,'% RNOTOTEX - end centering when centering not-active')
X end
X end;
X if nextcommand = 44 {rightjustify} then
X begin
X if flushright then
X begin
X flushright := false;
X writeln(outfile,'\end{flushright}');
X if startnofillagain then
X begin
X`009 startnofillagain := false;
X`009 beginnofill( outfile )
X end
X end
X else
X begin
X writeln(outfile,'% RNOTOTEX - end flushright when not active');
X writeln( log,'% RNOTOTEX - end flushright when not active')
X end
X end;
X
X nextcommand := indexofunknowntexcommand
X
Xend;
X
X
X
X
X
XEND.
X
X
$ GOSUB UNPACK_FILE
$ FILE_IS = "DSROPS.PAS"
$ CHECKSUM_IS = 658424605
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X[INHERIT('SCREENHANDLERS','UTILITYOPS','ARGOPS',
X'TREEANDLISTOPS','FLAGOPS','CONVERSION')]
X
XMODULE DSROPS;
X
X
XCONST
X
X indexofpagecommand = 38;
X
XVAR
X
X totallines : [EXTERNAL] integer;
X totalgooddsrcommands : [EXTERNAL] integer;
X totalbaddsrcommands : [EXTERNAL] integer;
X
X
X
X
X
X[GLOBAL] FUNCTION listispagecommand( list : arglist ) : boolean;
Xvar
X s : pckstr;
Xbegin
X listispagecommand := false;
X if arglistlength(list) = 1 then
X begin
X s := argliteral(firstarg(list), TRUE );
-+-+-+-+-+ End of part 2 +-+-+-+-+-prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/12/88)
Sorry about the previous send, I am still learning this mailer.
I'll try again with a different method.
+-+-+-+ Beginning of part 3 +-+-+-+
X if s = 'PAGE' then
X listispagecommand := true
X end
Xend;
X
X
X
X[GLOBAL] PROCEDURE checkfordsrcommand( var infile, outfile : text;
X`009 var dsrcommand : boolean );
Xvar
X gotten : boolean;
Xbegin
X if flagclass(currentchar) = control then
X begin
X getnextchar(infile, gotten);
X if gotten then
X begin
X if (flagclass(currentchar) <> comment) and (currentchar <> blank) then
X dsrcommand := true
X end
X else
X begin
X dsrcommand := false;
X texwrite(outfile, currentchar)
X end
X end
X else
X dsrcommand := false
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE parsedsrcommand( var infile, outfile : text; var list :
X`009 arglist; var anothercommand : boolean;
V`009 var carrychar : boolean; var charcarried : ch
Xar);
Xconst
X dontwritethem = false;
Xtype
V charidentity = (letter, separator, number, semicolon, quote, commentchar,new
Xdsrcommand);
Xvar
X quotedchar : char;
X argread : argument;
X currentargclass : charidentity;
X done, gotten, atseparator, endofdsrcommand : boolean;
X i : integer;
X
X function charclass( ch : char ) : charidentity;
X label
X localexit;
X begin
X charclass := separator;
X if flagclass( ch ) = control then
X begin
X charclass := newdsrcommand;
X goto localexit
X end;
X if ch in ['a'..'z','A'..'Z'] then
X begin
X charclass := letter;
X goto localexit
X end;
X if ch in ['+','-','0'..'9'] then
X begin
X charclass := number;
X`009 goto localexit
X end;
X if ch in [chr(34), chr(39)] then
X begin
X charclass := quote;
X goto localexit
X end;
X if flagclass(currentchar) = comment then
X begin
X charclass := commentchar;
X goto localexit
X end;
X if ch = ';' then
X charclass := semicolon;
X localexit : nullstatement
X end;
X
X procedure startarg( ch : char; var arg : argument; startset : setofargtype);
X begin
X initarg(arg, startset, ch, indexofunknowntexcommand, false);
X end;
X
Xbegin
X list := nulllist;
X atseparator := false;
X endofdsrcommand := false;
X anothercommand := false;
X carrychar := false;
X repeat
X currentargclass := charclass(currentchar);
X case currentargclass of
X `009 letter : begin
X`009 atseparator := false;
V`009 startarg(currentchar, argread, [dsrverb,stylespecifier, tex
Xtpckstr,character]);
X done := false;
X repeat
X`009 getnextchar(infile, gotten);
X if gotten then
X`009 begin
X`009 if charclass(currentchar) = letter then
X appendchartoarg(currentchar, argread)
X else
X done := true
X end
X`009 else
X begin
X done := true;
X`009 endofdsrcommand := true
X`009 end
X`009 until done;
X`009 appendargonlist(list, argread )
X end;
X `009 number : begin
X`009 atseparator := false;
V`009 startarg(currentchar, argread, [int,signedint,textpckstr,nu
Xlltype]);
X done := false;
X repeat
X`009 getnextchar(infile, gotten);
X if gotten then
X`009 begin
X`009 if charclass(currentchar) = number then
X appendchartoarg(currentchar, argread)
X else
X done := true
X end
X`009 else
X begin
X done := true;
X`009 endofdsrcommand := true
X`009 end
X`009 until done;
X`009 appendargonlist(list, argread )
X end;
X`009 separator : begin
X`009 passblanks(infile, outfile, dontwritethem);
X`009 if (atseparator) and (currentchar <> lastinputchar) then
X`009 begin
X`009 startarg(blank, argread, [nulltype]);
X`009 appendargonlist(list, argread);
X atseparator := false
X`009 end
X`009 else
X`009 begin
X if flagclass(currentchar) = control then
X`009 endofdsrcommand := true
X else
X if charclass(currentchar) = separator then
X begin
X getnextchar(infile, gotten);
X`009 if gotten then
X atseparator := true
X`009 else
X begin
X atseparator := false;
X`009 startarg(blank, argread, [nulltype]);
X`009 appendargonlist(list, argread);
X`009 endofdsrcommand := true
X end
X end
X`009 end
V`009 end;
X
X`009semicolon : begin
X endofdsrcommand := true;
X`009 getnextchar(infile, gotten);
X`009 if charclass(currentchar) = newdsrcommand then
X`009 currentargclass := newdsrcommand
X`009 else
X`009 begin
X`009 carrychar := true;
X`009 charcarried := currentchar
X`009 end
X`009 end;
X`009 quote : begin
X`009 quotedchar := currentchar;
X`009 getnextchar(infile, gotten);
X if gotten then
X`009 begin
X`009 startarg(currentchar, argread, [quotedpckstr]);
X`009 done := false;
X`009 repeat
X`009 getnextchar(infile, gotten);
X`009 if gotten then
X`009 begin
X`009 if charclass(currentchar) = quote then
X`009 begin
X`009 getnextchar(infile, gotten);
X`009 done := true;
X`009 if not gotten then
X`009 endofdsrcommand := true
X`009 end
X`009 else
X`009 appendchartoarg(currentchar, argread)
X`009 end
X else
X`009 begin
X`009 endofdsrcommand := true;
X`009 done := true
X`009 end
X`009 until done
X`009 end
X`009 else
X`009 startarg(quotedchar, argread,[textpckstr,character]);
X appendargonlist(list, argread)
X end;
X commentchar : begin
X`009 endofdsrcommand := true
X end;
X newdsrcommand : begin
X endofdsrcommand := true;
X end
X end; {case}
X until endofdsrcommand;
X if currentargclass <> newdsrcommand then
X newline( infile, outfile, false)
X else
X anothercommand := true
Xend;
X`009
X
X
XPROCEDURE parsefile( var infile, outfile : text; textree : argtree );
Xconst
X nocrlf = false;
X putcrlf = true;
Xvar
X dsrcommandfound : boolean;
X chargotten : boolean;
X dsrarguments : arglist;
X texcommandindex : integer;
X nextcommandtowrite : integer;
X successfulparse : boolean;
X depthofsearch : integer;
X anothercommand : boolean;
X carrychar : boolean;
X charcarried, copychar : char;
Xbegin
X ttywritestring('Translating input ...');
X totalgooddsrcommands := 0;
X totalbaddsrcommands := 0;
X nextcommandtowrite := indexofunknowntexcommand;
X anothercommand := false;
X repeat
X putsecondarytexcommand( outfile, nextcommandtowrite);
X repeat
X checkfordsrcommand( infile, outfile, dsrcommandfound );
X if dsrcommandfound then
X begin
V parsedsrcommand( infile, outfile, dsrarguments, anothercommand,carrycha
Xr,charcarried);
X if listispagecommand( dsrarguments) then
X begin
X successfulparse := true;
X texcommandindex := indexofpagecommand
X end
X else
V searchtreeforlist( textree, dsrarguments,successfulparse, texcommandi
Xndex,
X depthofsearch);
X if successfulparse then
X begin
X totalgooddsrcommands := totalgooddsrcommands + 1;
V puttexcommand(outfile, texcommandindex, dsrarguments, nextcommandtowr
Xite);
X if carrychar then
X begin
X`009 copychar := currentchar;
X`009 currentchar := charcarried;
X`009 writecurrentchar( infile, outfile );
X`009 currentchar := copychar
X end
X end
X else
X begin
X totalbaddsrcommands := totalbaddsrcommands + 1;
X write(outfile,'%Unidentified RUNOFF command "');
X dumpthelist(outfile, dsrarguments);
X writeln(outfile,'"')
X end
X end
X else
X anothercommand := false
X until (not dsrcommandfound) and (not anothercommand);
X repeat
X writecurrentchar( infile, outfile );
X getnextchar(infile, chargotten)
X until not chargotten;
X newline(infile, outfile, putcrlf)
X until eof(infile)
Xend;
X
X
X
XEND.
X
X
$ GOSUB UNPACK_FILE
$ FILE_IS = "FLAGOPS.PAS"
$ CHECKSUM_IS = 125287985
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X[INHERIT('UTILITYOPS','ARGOPS')]
X
XMODULE FLAGOPS;
X
XCONST
X
X tab = 9;
X ncharsintab = 8;
X
XTYPE
X
Xdsrflagtype = record
X`009 representation : char;
X`009 turnedon : boolean
X `009 end;
X
X
Xdsrflagclasses = (notaflag, control, uppercase, lowercase, quote,
Xspace, underline, bold, overstrike, hyphenate, break, period, capitalize,
Xendfootnote, comment, substitute);
X
Xflagtabletype = array[dsrflagclasses] of dsrflagtype;
X
Xtabrecordtype = record
X`009 tabread : boolean;
X`009 charcountintab : integer
X`009 end;
X
Xstyletype = (undetermined, decimal, octal, hexidecimal, romanupper, romanlower,
X`009 romanmixed, letterupper, letterlower, lettermixed, nostyle);
X
Xenhancmentstates = (notenhanced, singlecharenhanced, enhancmentlocked);
X
X
X
XVAR
X
X`009lastinputchar, currentchar : [EXTERNAL] char;
X capitalizetext, lowercasetext : [EXTERNAL] boolean;
X`009inputcontainstexcommands : [EXTERNAL] boolean;
X inliteral : [EXTERNAL] boolean;
X totallines, totalchars : [EXTERNAL] integer;
X flagtable : [EXTERNAL] flagtabletype;
X tabrecord : [EXTERNAL] tabrecordtype;
X`009LOG : [EXTERNAL] text;
X columncounter : [EXTERNAL] integer;
X`009infootnote : [EXTERNAL] boolean;
X`009boldactive : [EXTERNAL] enhancmentstates;
X underlineactive : [EXTERNAL] enhancmentstates;
X startnofillagain : [EXTERNAL] boolean;
X fill : [EXTERNAL] boolean;
X listnestlevel : [EXTERNAL] integer;
X
X
X
X[GLOBAL] PROCEDURE beginnofill( var outfile : text );
Xbegin
X if (fill) and (listnestlevel = 0) then
X begin
X writeln(outfile,'{\obeylines \obeyspaces % - begin no fill');
X fill := false
X end
X else
X begin
X writeln(outfile,'% - RNOTOTEX obeylines, obeyspaces already active');
X writeln( log,'% - RNOTOTEX obeylines, obeyspaces already active')
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE endnofill( var outfile : text );
Xbegin
X if (not fill) and (listnestlevel = 0) then
X begin
X writeln(outfile,'} % - end of no fill');
X fill := true
X end
X else
X begin
X writeln(outfile,'% - RNOTOTEX obeylines, obeyspaces not active');
X writeln( log,'% - RNOTOTEX obeylines, obeyspaces not active')
X end
Xend;
X
X
X
X
X
X
X[GLOBAL] PROCEDURE writeflagname( var outfile : text; f : dsrflagclasses );
Xbegin
X case f of
X notaflag : write(outfile,'?????');
X control : write(outfile,'CONTROL');
X uppercase : write(outfile,'UPPERCASE');
X lowercase : write(outfile,'LOWERCASE');
X quote : write(outfile,'QUOTE');
X space : write(outfile,'SPACE');
X underline : write(outfile,'UNDERLINE');
X bold : write(outfile,'BOLD');
X overstrike : write(outfile,'OVERSTRIKE');
X hyphenate : write(outfile,'HYPYENATE');
X capitalize : write(outfile,'CAPITALIZE');
X endfootnote : write(outfile,'END FOOTNOTE');
X comment : write(outfile,'COMMENT');
X substitute : write(outfile,'SUBSTITUTE')
X end
Xend;
X
X
X
X
X
X
X[GLOBAL] FUNCTION isastylespecifier( arg : argument ) : styletype;
Xlabel
X routineexit;
Xvar
X s : pckstr;
X classification : styletype;
Xbegin
X s := argliteral( arg, TRUE );
X classification := undetermined;
X if (s.body[1] = 'D') and (s.length = 1) then
X begin
X classification := decimal;
X goto routineexit
X end;
X if (s.body[1] = 'O') and (s.length = 1) then
X begin
X classification := octal;
X goto routineexit
X end;
X if (s.body[1] = 'H') and (s.length = 1) then
X begin
X classification := hexidecimal;
X goto routineexit
X end;
X if (s.body = 'RU') and (s.length = 2) then
X begin
X classification := romanupper;
X goto routineexit
X end;
X if (s.body = 'RL') and (s.length = 2) then
X begin
X classification := romanlower;
X goto routineexit
X end;
X if (s.body = 'RM') and (s.length = 2) then
X begin
X classification := romanmixed;
X goto routineexit
X end;
X if (s.body = 'LU') and (s.length = 2) then
X begin
X classification := letterupper;
X goto routineexit
X end;
X if (s.body = 'LL') and (s.length = 2) then
X begin
X classification := letterlower;
X goto routineexit
X end;
X if (s.body = 'LM') and (s.length = 2) then
X begin
X classification := lettermixed;
X goto routineexit
X end;
X routineexit : isastylespecifier := classification
Xend;
X
X
X
X[GLOBAL] PROCEDURE initflagtable;
Xvar
X f : dsrflagclasses;
Xbegin
X for f := notaflag to substitute do
X case f of
X `009notaflag : begin
X`009 flagtable[f].representation := blank;
X`009 flagtable[f].turnedon := false
X`009 end;
X `009control : begin
X`009 flagtable[f].representation := '.';
X`009 flagtable[f].turnedon := true
X`009 end;
X `009uppercase : begin
X`009 flagtable[f].representation := '^';
X`009 flagtable[f].turnedon := true
X`009 end;
X `009lowercase : begin
X`009 flagtable[f].representation := '\';
X`009 flagtable[f].turnedon := true
X`009 end;
X `009quote : begin
X`009 flagtable[f].representation := '_';
X`009 flagtable[f].turnedon := true
X`009 end;
X `009space : begin
X`009 flagtable[f].representation := '#';
X`009 flagtable[f].turnedon := true
X`009 end;
X `009underline : begin
X`009 flagtable[f].representation := '&';
X`009 flagtable[f].turnedon := true
X`009 end;
X `009bold : begin
X`009 flagtable[f].representation := '*';
X`009 flagtable[f].turnedon := false
X`009 end;
X `009overstrike : begin
X`009 flagtable[f].representation := '%';
X`009 flagtable[f].turnedon := false
X`009 end;
X `009hyphenate : begin
X`009 flagtable[f].representation := '=';
X`009 flagtable[f].turnedon := false
X`009 end;
X `009break : begin
X`009 flagtable[f].representation := '|';
X`009 flagtable[f].turnedon := false
X`009 end;
X `009period : begin
X`009 flagtable[f].representation := '+';
X`009 flagtable[f].turnedon := false
X`009 end;
X `009capitalize : begin
X`009 flagtable[f].representation := '<';
X`009 flagtable[f].turnedon := false
X`009 end;
X endfootnote : begin
X flagtable[f].representation := '!';
X`009 flagtable[f].turnedon := false
X`009 end;
X `009comment : begin
X`009 flagtable[f].representation := '!';
X`009 flagtable[f].turnedon := true
X`009 end;
X `009substitute : begin
X`009 flagtable[f].representation := '$';
X`009 flagtable[f].turnedon := false
X`009 end
X end { case }
Xend; {initflagtable}
X
X
X
X
X[GLOBAL] FUNCTION flagclass( ch : char ) : dsrflagclasses;
Xvar
X class : dsrflagclasses;
X foundclass : boolean;
Xbegin
X class := control;
X foundclass := false;
X while (class <> substitute) and ( not foundclass) do
V if (ch = flagtable[class].representation) and (flagtable[class].turnedon)t
Xhen
X foundclass := true
X else
X class := succ(class);
X if foundclass then
X if inliteral then
X`009if class = control then
X`009 flagclass := control
X`009else
X`009 flagclass := notaflag
X else
X flagclass := class
X else
X flagclass := notaflag
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE initcharreader(var f : text );
Xbegin
X reset(f);
X lastinputchar := blank;
X read(f, currentchar);
X totallines := 0;
X totalchars := 0;
X columncounter := 1;
X if ord(currentchar) = tab then
X begin
X tabrecord.tabread := true;
X tabrecord.charcountintab := ncharsintab
X end
X else
X begin
X tabrecord.tabread := false;
X tabrecord.charcountintab := 0
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE getnextchar( var f : text; var gotten : boolean );
X
X function nexttabcolumn( startingcolumn : integer ) : integer;
X var
X i : integer;
X begin
X i := startingcolumn;
X repeat
X i := i + 1
X until (i-1) mod ncharsintab = 0;
X nexttabcolumn := i;
X writeln(log,'nexttabcolumn input = ',startingcolumn:1,', output = ',i:1)
X end;
X
Xbegin
X gotten := false;
X if NOT eof(f) then
X if NOT eoln(f) then
X with tabrecord do
X begin
X lastinputchar := currentchar;
X gotten := true;
X columncounter := columncounter + 1;
X if (tabread) and (charcountintab > 0) then
X begin
X`009 currentchar := blank;
X`009 charcountintab := charcountintab - 1;
X`009 if charcountintab = 0 then tabread := false
X`009end
X`009else
X`009begin
X totalchars := totalchars + 1;
X read( f, currentchar );
X if currentchar < blank then
X begin
X if ord(currentchar) = tab then
X begin
X tabread := true;
V charcountintab := nexttabcolumn( columncounter ) - columncounter
X-1;
X writeln(log,'charcountintab = ',charcountintab)
X end;
X`009 currentchar := blank
X end
X end
X end
Xend;
X
X
X
V[GLOBAL] PROCEDURE startunderline( var outfile : text; class : enhancmentstates
X);
Xbegin
X if class <> notenhanced then
X case underlineactive of
X notenhanced : begin
X`009 write(outfile,'\underline{');
X`009 underlineactive := class
X`009 end;
X singlecharenhanced : nullstatement;
X enhancmentlocked : nullstatement
X end;
X underlineactive := class
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE stopunderline( var outfile : text );
Xbegin
X case underlineactive of
X notenhanced : nullstatement;
X singlecharenhanced : begin
X`009 write(outfile,'} ');
X`009 underlineactive := notenhanced
X`009 end;
X enhancmentlocked : nullstatement
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE startbold( var outfile : text; class : enhancmentstates);
Xbegin
X if class <> notenhanced then
X case boldactive of
X notenhanced : begin
X`009 write(outfile,'{\bf ');
X`009 boldactive := class
X`009 end;
X singlecharenhanced : nullstatement;
X enhancmentlocked : nullstatement
X end;
X boldactive := class
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE stopbold( var outfile : text );
Xbegin
X case boldactive of
X notenhanced : nullstatement;
X singlecharenhanced : begin
X`009 write(outfile,'} ');
X`009 boldactive := notenhanced
X`009 end;
X enhancmentlocked : nullstatement
X end
Xend;
X
X
X
X
X
V[GLOBAL] PROCEDURE passblanks( var infile, outfile : text; writethem : boolean
X);
Xvar
X gotten, keeppassing : boolean;
Xbegin
X keeppassing := true;
X gotten := true;
X repeat
X if (currentchar = blank) and (gotten) then
X begin
X if writethem then write(outfile, blank );
X getnextchar(infile, gotten)
X end
X else
X keeppassing := false
X until NOT keeppassing
Xend;
X
X
X
X[GLOBAL] PROCEDURE texwrite( var f : text; ch : char );
Xconst
X maxtrys = 2;
Xvar
X ntrys : integer;
X written : boolean;
Xbegin
X ntrys := 0;
X written := false;
X repeat
X if (inputcontainstexcommands) or (inliteral) then
X write(f, ch, error := continue)
X else
X if ch >= blank then
X if ch in ['#','$','%','&','_','^','{','}','~'] then
X write(f, '\',ch, error := continue)
X else
X if ch = '\' then
X write(f,'\backslash ', error := continue)
X else
X write(f, ch, error := continue);
X if status(f) > 0 then
X begin
X writeln(f, error := continue);
X ntrys := ntrys + 1
X end
X else
X written := true
X until (written) or (ntrys > maxtrys);
X if ntrys > maxtrys then
X errorexit('TEXWRITE','error writing to output')
Xend;
X
X
X
X[GLOBAL] PROCEDURE writecurrentchar( var infile, outfile : text );
Xvar
X gotten : boolean;
Xbegin
X if capitalizetext then
X currentchar := capchar( currentchar );
X if lowercasetext then
X currentchar := lcchar( currentchar );
X case flagclass(currentchar) of
X notaflag : begin
X`009 stopunderline( outfile );
X`009 stopbold( outfile );
X`009 texwrite(outfile, currentchar)
X end;
X`009control : begin
X`009 stopunderline( outfile );
X`009 stopbold( outfile );
X`009 texwrite(outfile, currentchar)
X end;
X `009uppercase : begin
X getnextchar(infile, gotten);
X if gotten then
X case flagclass(currentchar) of
X`009`009 underline : startunderline( outfile, enhancmentlocked);
X`009 bold : startbold( outfile, enhancmentlocked );
X otherwise texwrite(outfile, capchar(currentchar))
X end
X`009 end;
X `009lowercase : begin
X getnextchar(infile, gotten);
X if gotten then
X`009 case flagclass(currentchar) of
X`009`009 underline : begin
X`009 if underlineactive <> notenhanced then
X`009 write(outfile,'} ');
X`009 underlineactive := notenhanced
X`009 end;
X`009 bold : begin
X if boldactive <> notenhanced then
X `009 write(outfile,'} ');
X`009 boldactive := notenhanced
X`009 end;
X otherwise texwrite(outfile, lcchar(currentchar))
X end
X`009 end;
X `009quote : begin
X`009 getnextchar(infile, gotten);
X if gotten then
X`009 texwrite(outfile, currentchar )
X`009 end;
X `009space : write(outfile,'\ ');
X `009underline : begin
X getnextchar(infile, gotten );
X if gotten then
X begin
X startunderline( outfile, singlecharenhanced);
X`009 texwrite(outfile, currentchar)
X end
X`009 else
X`009 texwrite(outfile, currentchar)
X end;
X `009bold : begin
X`009 getnextchar(infile, gotten);
X if gotten then
X begin
X startbold( outfile, singlecharenhanced);
X`009 texwrite(outfile, currentchar)
X`009 end
X`009 else
X`009 texwrite(outfile, currentchar)
X`009 end;
X `009overstrike : begin
X`009 getnextchar(infile, gotten);
X if gotten then
X begin
X`009 startbold( outfile, singlecharenhanced);
X`009 texwrite(outfile, currentchar)
X`009 end
X`009 else
X`009 texwrite(outfile, currentchar)
X`009 end;
X `009hyphenate : write(outfile,'--');
X `009break : writeln(outfile,'\linebreak');
X `009period : write(outfile,'\nonfrenchspacing ');
X `009capitalize : begin
X`009 getnextchar( infile, gotten);
X`009 if gotten then
X`009 texwrite(outfile, capchar(currentchar))
X`009 end;
X endfootnote : begin
X`009 if (columncounter = 1) and (infootnote) then
X`009 begin
X if not fill then
X`009 endnofill( outfile );
X`009 `009 writeln(outfile,'} % - end of footnote');
X`009 writeln( log,'} % - end of footnote');
X infootnote := false;
X`009 if startnofillagain then
X`009 begin
X`009 startnofillagain := false;
X`009 beginnofill( outfile )
X`009 end
X`009 end
X`009 else
X`009 texwrite(outfile, currentchar)
X`009 end;
X `009comment : begin
X if flagclass(lastinputchar) = control then
X`009 write(outfile,'% ')
X else
X`009 texwrite(outfile,currentchar)
X`009 end;
X `009substitute : texwrite(outfile, currentchar)
X end { case }
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE newline( var infile, outfile : text; putcrlf : boolean );
Xvar
-+-+-+-+-+ End of part 3 +-+-+-+-+-prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/12/88)
Sorry about the previous send, I am still learning this mailer.
I'll try again with a different method.
+-+-+-+ Beginning of part 4 +-+-+-+
X gotten : boolean;
Xbegin
X if eoln(infile) then
X begin
X readln(infile);
X totallines := totallines + 1;
X columncounter := 1
X end;
X if putcrlf then
X writeln(outfile);
X while (eoln(infile)) and (not eof(infile)) do
X begin
X readln(infile);
X writeln(outfile);
X columncounter := 1;
X totallines := totallines + 1
X end;
X if not eof(infile) then
X begin
X read(infile, currentchar);
X totalchars := totalchars + 1;
X lastinputchar := blank
X end;
X if ord(currentchar) = tab then
X begin
X tabrecord.charcountintab := ncharsintab;
X tabrecord.tabread := true
X end
X else
X begin
X tabrecord.charcountintab := 0;
X tabrecord.tabread := false
X end;
X if currentchar < blank then currentchar := blank
Xend;
X
X
X
X
X
X
X[GLOBAL] PROCEDURE changeflagchar( flag : dsrflagclasses; newchar:char);
Xbegin
X flagtable[flag].representation := newchar;
X write(log,'[internal flag representation change for ');
X writeflagname(log, flag);
X writeln(log,' to "',newchar,'"]')
Xend;
X
X
X
X[GLOBAL] PROCEDURE turnflagon( flag : dsrflagclasses );
Xbegin
X flagtable[flag].turnedon := true;
X write(log,'[internal flag ');
X writeflagname(log, flag);
X writeln(log,' enabled]')
Xend;
X
X
X
X[GLOBAL] PROCEDURE turnflagoff( flag : dsrflagclasses );
Xbegin
X flagtable[flag].turnedon := false;
X write(log,'[internal flag ');
X writeflagname(log, flag);
X writeln(log,' disabled]')
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE texwritearg( var outfile : text; arg : argument );
Xvar
X s : pckstr;
X i, l : integer;
Xbegin
X s := argliteral( arg, false );
X l := length( s );
X for i := 1 to l do texwrite(outfile, s.body[i]);
X write(outfile, blank)
Xend;
X
X
XEND.
$ GOSUB UNPACK_FILE
$ FILE_IS = "GETCLI.FOR"
$ CHECKSUM_IS = 53499580
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X`009SUBROUTINE GETCLI (IFILE,OFILE,TEX)
X
X`009IMPLICIT NONE
X`009
XC
XC FUNCTIONAL DESCRIPTION:`009
XC
XC This routine gets the input and output file names for program
XC RNOTOTEX.
XC
XC DUMMY ARGUMENTS:
XC
XC none.
XC
XC IMPLICIT INPUTS:
XC
XC none
XC
XC IMPLICIT OUTPUTS:
XC
X`009CHARACTER*(*) IFILE
XC`009INPUT FILE NAME
XC
X`009CHARACTER*(*) OFILE
XC`009OUTPUT FILE NAME
XC
X`009INTEGER TEX
XC `009TEX COMMANDS FLAG : 0 FOR NO, NOT 0 FOR YES
XC
XC SIDE EFFECTS:
XC
XC none
XC
XC
XC`009LOCALS
XC
X`009INTEGER CLI$GET_VALUE
X`009EXTERNAL CLI$GET_VALUE
XC`009system routine to get a value from a command line
XC
X`009INTEGER STATUS
XC`009status of command line extraction
XC`009
XC`009BEGIN
X
X`009STATUS = CLI$GET_VALUE('RNO_FILE',IFILE,)
X`009STATUS = CLI$GET_VALUE('TEX_FILE',OFILE,)
X
X TEX = 0
X
X`009RETURN
X`009END
$ GOSUB UNPACK_FILE
$ FILE_IS = "INIOPS.PAS"
$ CHECKSUM_IS = 608058111
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X{ `009INI FILE MODULE FOR RNO TO TEX CONVERSION }
X{ `009RANDALL VENHOLA JULY 7, 1987 }
X
X[INHERIT('UTILITYOPS','BASICFILEOPS','ARGOPS',
X 'TREEANDLISTOPS','SCREENHANDLERS')]
X
XMODULE INIOPS;
X
X
X
X[GLOBAL] PROCEDURE readarglistfromini( var ini : text; var index : integer;
X`009 var list : arglist );
Xconst
X iniseparator = '$';
Xvar
X s : pckstr;
X done : boolean;
X gotten : boolean;
X arg : argument;
X inserted : boolean;
X
X function endofline : boolean;
X begin
X if eof(ini) then
X endofline := true
X else
X begin
X if eoln(ini) then
X endofline := true
X else
X begin
X if ini^ = blank then
X endofline := true
X else
X endofline := false
X end
X end
X end;
X
X function atseparator : boolean;
X begin
X atseparator := (ini^ = iniseparator)
X end;
X
X procedure readpckstr( var s : pckstr; var gotten : boolean );
X var
X ch : char;
X done : boolean;
X charindex : integer;
X begin
X s.body := blank;
X done := false;
X charindex := 0;
X repeat
X if endofline then
X done := true
X else
X if atseparator then
X done := true
X else
X if charindex = maxchars then
X begin
X`009 warningmessage('readini','ini file argument size overflow');
X done := true
X end
X`009 else
X begin
X read(ini, ch);
X charindex := charindex + 1;
X s.body[charindex] := ch
X end;
X s.length := charindex
X until done;
X gotten := charindex > 0;
X if atseparator then read(ini, ch)
X end;
X
X procedure readindex(var index : integer; var gotten : boolean );
X const
X ndigits = 3;
X var
X count : integer;
X ch : char;
X begin
X gotten := true;
X count := 0;
X index := 0;
X repeat
X if endofline then
X gotten := false
X else
X if count < ndigits then
X begin
X read(ini, ch);
X count := count + 1;
X if ch in ['0'..'9'] then
X index := index*10 + ord(ch) - ord('0')
X else
X begin
X`009 warningmessage('readini','bad index digits in INI');
X`009 gotten := false
X end
X end
X until (not gotten) or (count = ndigits);
X if (gotten) and (not eof(ini)) then read(ini, ch)
X end;
X
X procedure pckstrtoarg( s : pckstr; index : integer; var arg : argument);
X label
X routineexit;
X begin
X initarg(arg, [dsrverb], s, index, false );
X if s = '[N]' then
X begin
X reassignargclass(arg, [int,signedint,nulltype]);
X reassignarggeneralization(arg, true);
X goto routineexit
X end;
X if s = '[Y]' then
X begin
X reassignargclass(arg, [stylespecifier]);
X reassignarggeneralization(arg, true);
X goto routineexit
X end;
X if s = '[T]' then
X begin
X reassignargclass(arg, [textpckstr,character,nulltype]);
X reassignarggeneralization(arg, true);
X goto routineexit
X end;
X if s = '[C]' then
X begin
X reassignargclass(arg, [character,nulltype]);
X reassignarggeneralization(arg, true);
X goto routineexit
X end;
X if s = '[Q]' then
X begin
X reassignargclass(arg, [quotedpckstr,nulltype]);
X reassignarggeneralization(arg, true);
X goto routineexit
X end;
X routineexit : nullstatement
X end;
X
Xbegin {readarglistfromini}
X list := nulllist;
X readindex(index, gotten );
X if gotten then
X begin
X if index < 1 then
X warningmessage('readini','bad INI index value');
X repeat
X readpckstr(s, gotten );
X if gotten then
X begin
X pckstrtoarg(s, index, arg );
X appendargonlist(list, arg);
X end
X until not gotten;
X if arglistlength(list) = 0 then
X warningmessage('readini','empty argument list in INI file')
X end
X else
X begin
X index := indexofunknowntexcommand;
X warningmessage('readini','could not read index from INI file')
X end;
X if not eof(ini) then
X readln(ini)
Xend;
X
X
X
X
X
X
X[GLOBAL] PROCEDURE setuptree( var ini : text; var tree : argtree );
Xvar
X list : arglist;
X index : integer;
Xbegin
X openinifile( ini );
X tree := nulltree;
X while not eof(ini) do
X begin
X readarglistfromini( ini, index, list);
X
X { ***** ttywritestring(' index read = ');
X ttywriteint(index);
X ttywriteln; ***** }
X
X insertlistintotree( list, tree )
X end;
X closeinifile( ini )
Xend;
X
X
X
XEND.
$ GOSUB UNPACK_FILE
$ FILE_IS = "LATEXOPS.PAS"
$ CHECKSUM_IS = 964346211
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X[INHERIT('UTILITYOPS','ARGOPS','BASICFILEOPS',
X'TREEANDLISTOPS','FLAGOPS')]
X
XMODULE LATEXOPS;
X
X
XTYPE
X
X
Xcountparametertype = (numericcounter, lowercasechars, uppercasechars );
X
Xparameterchangestates = (nochange, altered, assigned);
X
Xpagestyletype = (empty, plain, headings, myheadings);
X
Xliststatetype = (nostate, itemize, enumerate);
X
X
XVAR
X
X LOG : [EXTERNAL] TEXT;
X pagestyle : [EXTERNAL] pagestyletype;
X datestring : [EXTERNAL] pckstr;
X title, subtitle : [EXTERNAL] argarray;
X fill`009 : [EXTERNAL] boolean;
X centering : [EXTERNAL] boolean;
X flushright : [EXTERNAL] boolean;
X minipageactive : [EXTERNAL] boolean;
X inmarginpar : [EXTERNAL] boolean;
X infootnote : [EXTERNAL] boolean;
X underlineactive : [EXTERNAL] enhancmentstates;
X boldactive : [EXTERNAL] enhancmentstates;
X listnestlevel : [EXTERNAL] integer;
X
VPROCEDURE startlatex( var outfile : text; outputfont : integer ; outputstyle: p
Xckstr );
Xconst
X minfont = 10;
X maxfont = 12;
Xvar
X pt : integer;
Xbegin
X pt := outputfont;
X if (pt < minfont) or (pt > maxfont) then
X pt := minfont;
X writeln(outfile,'%');
X if pt = 10 then
X writeln(outfile,'\documentstyle{',outputstyle,'}')
X else
X writeln(outfile,'\documentstyle[',pt:2,'pt]{',outputstyle,'}');
X writeln(outfile,'%');
X writeln(outfile,'% (put preamble statements here) ');
X writeln(outfile,'%');
X writeln(outfile,'\begin{document}');
X writeln(outfile,'%')
Xend;
X
X
X[GLOBAL] PROCEDURE closeanyopenbrackets( var outfile : text );
Xvar
X i : integer;
Xbegin
X if not fill then
X writeln(outfile,'} % - end of obeylines and obeyspaces group');
X if centering then
X writeln(outfile,'\end{centering}');
X if flushright then
X writeln(outfile,'\end{flushright}');
X if minipageactive then
X writeln(outfile,'\end{minipage}');
X if inmarginpar then
X writeln(outfile,'} % - end of margin par ');
X if infootnote then
X writeln(outfile,'} % - end of footnote');
X if inliteral then
X writeln(outfile,'\end{verbatim}');
X for i := 1 to listnestlevel do
X writeln(outfile,'\end{itemize} % - RNOTOTEX forced list close');
X stopunderline( outfile );
X stopbold( outfile )
Xend;
X
X
X
X[GLOBAL] PROCEDURE endlatex( var outfile : text );
Xbegin
X closeanyopenbrackets( outfile );
X writeln(outfile,'%');
X writeln(outfile,'% (put postamble statements here) ');
X writeln(outfile,'%');
X writeln(outfile,'\end{document}')
Xend;
X
X
X
X[GLOBAL] PROCEDURE adjustpagestyle( var f : text; newstyle : pagestyletype);
Xbegin
X pagestyle := newstyle;
X case pagestyle of
X empty : writeln(f,'\pagestyle{empty}');
X plain : writeln(f,'\pagestyle{plain}');
X headings : writeln(f,'\pagestyle{headings}');
X myheadings : begin
X writeln(f,'\pagestyle{myheadings}');
X`009 write(f,'\markright{');
X writeargarray(f, title);
X writeargarray(f, subtitle);
X write(f, datestring );
X writeln(f,'}')
X end
X end;
X case pagestyle of
X empty : writeln(log,'\pagestyle{empty}');
X plain : writeln(log,'\pagestyle{plain}');
X headings : writeln(log,'\pagestyle{headings}');
X myheadings : begin
X writeln(log,'\pagestyle{myheadings}');
X`009 write(log,'\markright{');
X writeargarray(log, title);
X writeargarray(log, subtitle);
X write(log, datestring );
X writeln(log,'}')
X end
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE writecharwidth( var f : text; nchars : integer);
Xconst
X widthofcharincm = 0.254; { 10 chars per inch, 2.54 cm per inch }
X maxwidth = 20.0;
X minwidth = -20.0;
Xvar
X cm : real;
Xbegin
X cm := nchars * widthofcharincm;
X if cm > maxwidth then
X begin
X writeln(log,'[too many chars to skip, ',nchars,' = ',cm:10:2,'cm]');
X cm := 1.0
X end;
X if cm < minwidth then
X begin
X writeln(log,'[too many chars to skip ',nchars,' = ',cm:10:2,'cm]');
X cm := -1.0
X end;
X write(f, cm:6:2, 'cm ');
X write(log, cm:6:2,'cm ')
Xend;
X
X
X
X[GLOBAL] PROCEDURE writecharheight( var f : text; nlines : integer );
Xconst
X heightoftextincm = 0.425; { 6 lines per inch, 2.54 cm per inch }
X maxheight = 25.0;
X minheight = -25.0;
Xvar
X cm : real;
Xbegin
X cm := nlines * heightoftextincm;
X if cm > maxheight then
X begin
X writeln(log,'[too many lines to skip, ',nlines,' = ',cm:10:2,'cm]');
X cm := 1.0
X end;
X if cm < minheight then
X begin
X writeln(log,'[too many lines to skip ',nlines,' = ',cm:10:2,'cm]');
X cm := -1.0
X end;
X write(f, cm:6:2,'cm ');
X write(log, cm:6:2,'cm ')
Xend;
X
X
X
X
X
V[GLOBAL] PROCEDURE adjustlength( var outfile : text; modified : parameterchange
Xstates;
Xlengthvalue : integer; adjustmentvalue : integer; charwidth : boolean;
Xlatexname : pckstr );
Xbegin
X case modified of
X nochange : nullstatement;
X altered : begin
X`009 write(outfile,'\addtolength{',latexname,'}{');
X if charwidth then
X writecharwidth(outfile, adjustmentvalue)
X else
X writecharheight(outfile, adjustmentvalue);
X writeln(outfile,'}')
X end;
X assigned : begin
X`009 write(outfile,'\setlength{',latexname,'}{');
X if charwidth then
X writecharwidth(outfile, lengthvalue)
X`009 else
X`009 writecharheight(outfile, lengthvalue);
X writeln(outfile,'}')
X end
X end;
X case modified of
X nochange : noconversion;
X altered : begin
X`009 write(log,'\addtolength{',latexname,'}{');
X if charwidth then
X writecharwidth(log, adjustmentvalue)
X else
X writecharheight(log, adjustmentvalue);
X writeln(log,'}')
X end;
X assigned : begin
X`009 write(log,'\setlength{',latexname,'}{');
X if charwidth then
X writecharwidth(log, lengthvalue)
X`009 else
X`009 writecharheight(log, lengthvalue);
X writeln(log,'}')
X end
X end
Xend;
X
X
X
V[GLOBAL] PROCEDURE adjustcounter( var outfile : text; modified : parameterchan
Xgestates;
Xcountervalue : integer; adjustmentvalue : integer; latexname : pckstr );
Xbegin
X case modified of
X nochange : nullstatement;
V altered : writeln(outfile,'\addtocounter{',latexname,'}{',adjustmentvalu
Xe,'}');
V assigned : writeln(outfile,'\setcounter{',latexname,'}{',countervalue,'}'
X)
X end;
X case modified of
X nochange : noconversion;
V altered : writeln(log,'\addtocounter{',latexname,'}{',adjustmentvalue,'}
X');
V assigned : writeln(log,'\setcounter{',latexname,'}{',countervalue,'}')
X
X end
Xend;
X
X
X
X[GLOBAL] PROCEDURE adjuststyle(var outfile : text; s : styletype;
X`009 latexname : pckstr );
Xbegin
X case s of
X undetermined : nullstatement;
V decimal : writeln(outfile,'\renewcommand{\the',latexname,'}{\arabic{'
X,latexname,'}}');
V octal : writeln(outfile,'\renewcommand{\the',latexname,'}{\arabic{'
X,latexname,'}}');
V hexidecimal : writeln(outfile,'\renewcommand{\the',latexname,'}{\arabic{'
X,latexname,'}}');
V romanupper : writeln(outfile,'\renewcommand{\the',latexname,'}{\Roman{',l
Xatexname,'}}');
V romanlower : writeln(outfile,'\renewcommand{\the',latexname,'}{\roman{',l
Xatexname,'}}');
V romanmixed : writeln(outfile,'\renewcommand{\the',latexname,'}{\roman{',l
Xatexname,'}}');
V letterupper : writeln(outfile,'\renewcommand{\the',latexname,'}{\Alpha{',l
Xatexname,'}}');
V letterlower : writeln(outfile,'\renewcommand{\the',latexname,'}{\alpha{',l
Xatexname,'}}');
V lettermixed : writeln(outfile,'\renewcommand{\the',latexname,'}{\alpha{',l
Xatexname,'}}');
X nostyle : nullstatement
X end;
X case s of
X undetermined : noconversion;
V decimal : writeln(log,'\renewcommand{\the',latexname,'}{\arabic{',lat
Xexname,'}}');
V octal : writeln(log,'\renewcommand{\the',latexname,'}{\arabic{',lat
Xexname,'}}');
V hexidecimal : writeln(log,'\renewcommand{\the',latexname,'}{\arabic{',lat
Xexname,'}}');
V romanupper : writeln(log,'\renewcommand{\the',latexname,'}{\Roman{',latex
Xname,'}}');
V romanlower : writeln(log,'\renewcommand{\the',latexname,'}{\roman{',latex
Xname,'}}');
V romanmixed : writeln(log,'\renewcommand{\the',latexname,'}{\roman{',latex
Xname,'}}');
V letterupper : writeln(log,'\renewcommand{\the',latexname,'}{\Alpha{',latex
Xname,'}}');
V letterlower : writeln(log,'\renewcommand{\the',latexname,'}{\alpha{',latex
Xname,'}}');
V lettermixed : writeln(log,'\renewcommand{\the',latexname,'}{\alpha{',latex
Xname,'}}');
X nostyle : noconversion
X end
Xend;
X
X
XEND.
X
$ GOSUB UNPACK_FILE
$ FILE_IS = "LINK_RNOTOTEX.COM"
$ CHECKSUM_IS = 960643418
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X$ IF ("''P1'" .EQS. "") THEN $ PI="NODEBUG"
X$ LINK/'P1' RNOTOTEX,-
X`009 UTILITYOPS,-
X`009 SCREENHANDLERS,-
X`009 ARGOPS,-
X`009 BASICFILEOPS,-
X`009 FLAGOPS,-
X`009 TREEANDLISTOPS,-
X`009 LATEXOPS,-
X`009 INIOPS,-
X`009 CONVERSION,-
X`009 DSROPS,-
X`009 GETCLI
$ GOSUB UNPACK_FILE
$ FILE_IS = "RNOTOTEX.CLD"
$ CHECKSUM_IS = 958872892
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X!`009
X!`009FILE TO SET UP THE RNOTOTEX COMMAND
XDEFINE VERB RNOTOTEX
X IMAGE TEX_CONVERTAREA:RNOTOTEX.EXE
X QUALIFIER TEX
X PARAMETER P1 LABEL=RNO_FILE,PROMPT="RNO file",VALUE(TYPE=$FILE,REQUIRED)
X PARAMETER P2 LABEL=TEX_FILE,PROMPT="TeX file",VALUE(TYPE=$FILE,REQUIRED)
$ GOSUB UNPACK_FILE
$ FILE_IS = "RNOTOTEX.PAS"
$ CHECKSUM_IS = 1062041168
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X[INHERIT('BASICFILEOPS','CONVERSION',
X'LATEXOPS','TREEANDLISTOPS','FLAGOPS','DSROPS','INIOPS')]
X
XPROGRAM RNOTOTEX( INPUT, OUTPUT);
X
X{ PROGRAM TO CONVERT A RUNOFF FORMAT FILE TO TEX FORMAT }
X{ DEVELOPED BY RANDALL VENHOLA, SUMMER 1987 ON CCRS SMOKE:: }
X{ USING VAX PASCAL }
X
XLABEL
X
X ENDOFPROGRAM;
X
XCONST
X DEFAULTFONT = 10;
X DEFAULTSTYLE = 'report';
X
XVAR
X
X RNO, TEX, INI : TEXT;
X RUNOFFTREE : ARGTREE;
X CURRENTDATE, CURRENTTIME : DATETIMETYPE;
X INPUTFID, OUTPUTFID : FIDTYPE;
X LASTINPUTCHAR, CURRENTCHAR : [GLOBAL] CHAR;
X TOTALLINES, TOTALCHARS : [GLOBAL] INTEGER;
X TOTALGOODDSRCOMMANDS : [GLOBAL] INTEGER;
X TOTALBADDSRCOMMANDS : [GLOBAL] INTEGER;
X TABRECORD : [GLOBAL] TABRECORDTYPE;
X LOG`009 : [GLOBAL] TEXT;
X COLUMNCOUNTER : [GLOBAL] INTEGER;
X
X{emergency exit procedure}
X[GLOBAL] PROCEDURE GOTOENDOFPROGRAM;
XBEGIN
X GOTO ENDOFPROGRAM
XEND;
X
X
XBEGIN
X
X OPENLOGFILE;
X GREETUSER( CURRENTDATE, CURRENTTIME );
X USERINTERFACE( INPUTFID, OUTPUTFID, RNO, TEX );
X SETUPTREE( INI, RUNOFFTREE );
X PUTCOMMENTSTOOUTPUT( TEX, INPUTFID, CURRENTDATE, CURRENTTIME);
X STARTLATEX( TEX, DEFAULTFONT, DEFAULTSTYLE );
X INITFLAGTABLE;
X INITGLOBALVARS;
X INITCHARREADER( RNO );
X PARSEFILE(RNO, TEX, RUNOFFTREE );
X ENDLATEX( TEX );
X
XENDOFPROGRAM:
X
X WRITELN(LOG,'[TOTAL GOOD DSR COMMANDS = ',TOTALGOODDSRCOMMANDS,']');
X WRITELN(LOG,'[TOTAL BAD DSR COMMANDS = ',TOTALBADDSRCOMMANDS,']');
X CLOSEFILES( RNO, TEX );
X CLOSELOGFILE
X
XEND.
X
$ GOSUB UNPACK_FILE
$ FILE_IS = "RNOTOTEX.RNH"
$ CHECKSUM_IS = 808919667
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X.AP
X.NOFLAGS ACCEPT
X.NONUMBER
X.LITERAL
X
X1 RNOTOTEX
X
X $ RNOTOTEX[ /qualifier] RNO-FILE-SPEC TEX-FILE-SPEC
X
X.END LITERAL
X.LM+2
XReads a Digital Standard Runoff format file and creates the LaTeX
Xequivalent.
X.LM-2
X.LITERAL
X
X2 Parameters
X
X RNO-FILE-SPEC
X
X.END LITERAL
X.LM+2
X ... is the name of the input DSR format file. The default type
Xis .RNO.
X.LITERAL
X
X TEX-FILE-SPEC
X
X.END LITERAL
X
X ... is the name of the output TEX file spec. The default
Xtype is .TEX.
X.LM-2
X.LITERAL
X
X2 Command-Qualifiers
X
X/TEX
X
X /TEX
X
X.END LITERAL
X.LM+2
XPreserve embedded TeX and LaTeX commands in the input DSR file.
XAny commands found are copied directly to the output .TEX file. The
Xdefault is /NOTEX.
X
X.LM-2
X.LITERAL
X
X2 Example
X
X.END LITERAL
X.LM+2
XThe following DCL
Xcommands convert the DSR file FOO.RNO to FOO.TEX and prints the
XLN3 file on the LN03. The log of the conversion is also printed
Xand deleted.
X.LITERAL
X
X $ RNOTOTEX FOO.RNO FOO.TEX
X $ LATEX/BATCH FOO.TEX
X $ DVI2LN3 FOO.DVI
X $ PRINT/FORM=TEX FOO.LN3
X $ PRINT/DELETE RNOTOTEX.LOG
X
X.END LITERAL
X
XNote that there isn't a one-to-one mapping of DSR commands to LaTeX
Xcommands and that more LaTeX text fits on a page than a RUNOFF file.
XThe first output may be messy! The output .TEX file must be
Xedited after examining the first printing. It may take a few tries to
Xget the output that you want.
X
XThe program was designed for those familiar with both LaTeX and DSR
Xand would like to upgrade older documents to LaTeX format.
$ GOSUB UNPACK_FILE
$ FILE_IS = "RNOTOTEX_GUIDE.TEX"
$ CHECKSUM_IS = 1613414640
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X\documentstyle{report}
X%
X% DOCUMENTATION FOR PROGRAM RNOTOTEX
X% WRITTEN IN LATEX USING LSE
X% R. VENHOLA, 9-MAR-88
X%
X% Revised by John Edgecombe, 6-JUL-1988, restricting to RNOTOTEX only
X%
X% put section headings on top of page
X\pagestyle{headings}
X
X% release the LaTeX boundaries for margins
X\setlength{\oddsidemargin}{0.5in}
X\setlength{\evensidemargin}{0.0in}
X\setlength{\topmargin}{0.0in}
X
X% make the page size wider and longer
X\setlength{\textwidth}{6.0in} % 8.5 by 11 page with 1 inch margins
X\setlength{\textheight}{8.0in} % on each side
X
X% generate a title page
X\author{R.~Venhola}
X\title{ { \Huge \TeX\ \& \LaTeX\ \\
X\vspace*{1.0ex}
XCONVERSION PROGRAM } \\
XRNOTOTEX
X}
X\maketitle
X
X% An IDX file is to be generated
X\makeindex
X
X% A short form command
X\newcommand{\lb}{\large\bf}
X
X\begin{document}
X
X\chapter{Quick Reference}
XExecute SETUP.COM ({\tt @SETUP.COM}) to set the DCL command syntax
Xbefore using the RNOTOTEX command.
X
X\section{RNOTOTEX}
XDCL command format is :
X
X\begin{center}
X
X{\large\bf \$ RNOTOTEX[\ /qualifier] RNO-FILE-SPEC TEX-FILE-SPEC}
X
X\end{center}
X
XReads a {\em Digital Standard Runoff} format file and creates the \LaTeX\
Xequivalent.
X
X
X\subsection{Parameters}
X
X\begin{center}
X
X
X {\large\sl RNO--FILE--SPEC }
X
X\end{center}
X
X$\ldots$ is the name of the input DSR format file. The default type
Xis~{\tt{.RNO}}.
X\begin{center}
X
X
X {\large\sl TEX--FILE--SPEC }
X
X\end{center}
X$\ldots$ is the name of the output~{\tt{TEX}} file spec. The default
Xtype is~{\tt{.TEX}}.
X
X\subsection{/TEX}
X
X\begin{center}
X
X{\large\sl /TEX }
X
X\end{center}
X
XPreserve embedded \TeX\ and \LaTeX\ commands in the input DSR file.
XAny commands found are copied directly to the output~{\tt{.TEX}} file. The
Xdefault is /NOTEX.
X
X\subsection{Example}
XThe following DCL
Xcommands convert the DSR file FOO.RNO to FOO.TEX and prints the
XLN3 file on the LN03. The log of the conversion is also printed
Xand deleted.
X
X\begin{verbatim}
X
X $ RNOTOTEX FOO.RNO
X $ LATEX FOO.TEX
X $ DVI2LN3 FOO.DVI
X $ PRINT/FORM=TEX FOO.LN3
X $ PRINT/DELETE RNOTOTEX.LOG
X
X\end{verbatim}
X
XNote that there isn't a one-to-one mapping of DSR commands to \LaTeX\
Xcommands and that more \LaTeX\ text fits on a page than a RUNOFF file.
VThe first output may be messy! The output~{\tt{.TEX}} file must \index{messy
X RNOTOTEX output}
Xedited after examining the first printing. It may take a few tries to
Xget the output that you want.
X
XThe program was designed for those familiar with both \LaTeX\ and DSR
Xand would like to upgrade older documents to \LaTeX\ format.
X\vspace{10.0cm}
X\pagebreak
X
X\chapter{Introduction}
X\TeX\ and \LaTeX\ are programs that allow programmers to typeset manuscripts
Vfor high precision output devices, such as the \index{LN03} LN03 linked to the
XSMOKE
Xsystem at CCRS. \LaTeX\ can be thought of as a usable extension of
X\TeX\ . Raw \TeX\ can be difficult to use.
X
XThe input files to the program are created in the same
Xmanner as one would create a RUNOFF source file. The usual file type
Xis ````{\tt{.TEX}}''.
XThe files are in simple ASCII format, so that they may be created using an
Xeditor such as EDT, SED or \index{LSE} LSE ({\bf L}anguage
X{\bf S}ensitive {\bf E}ditor). As a note, the current version of
XLSE on SMOKE recognizes {\tt{TEX}} files and initializes the programming
Xlanguage to be ````LATEX'', with the appropriate expandable placeholders.
X
XCommands such as ````\verb+\chapter{Introduction}+'' are
Xembedded in the~{\tt{.TEX}}
Xfile. The file is run through either the \TeX\ or \LaTeX\ program,
Vwhich will produces a~{\tt{.DVI}} file (for {\bf D}e{\bf{V}}ice {\bf I}ndepende
Xnt).
XThis {\tt{.DVI}} file must be converted to the local print format, which in our
Xcase is done by the program {\bf DVI2LN3}.
X
XDocumentation on \TeX\ and \LaTeX\ commands are given in Knuth\cite{tex-manual}
Xand Lamport\cite{latex-manual}\footnote{References are listed in the
XBibliography}.
XThe user requires some familiarity with either \TeX\ or \LaTeX\
Xto use the conversion programs described in this document.
X
XProgram {\bf RNOTOTEX} reads a DSR format file
X(i.e.~FOO.RNO) and writes the equivalent\footnote{Well, not {\em really}
Xequivalent, as you will find out in later} TEX format
Xfile (FOO.TEX).
X
X\chapter{RNOTOTEX}
XProgram {\bf RNOTOTEX} will read a DEC Standard RUNOFF (DSR) format text file,
Xtranslate the RUNOFF commands to \LaTeX\ commands and write the corresponding
XTEX file. The output file may then be processed by \LaTeX\ and printed
Xon the local high quality printer. To use {\bf RNOTOTEX} one must have
Xexecuted the DCL command procedure
X````SETUP'' as described
Xin the first chapter.
X
X\section{Execution}
XProgram {\bf RNOTOTEX} requires two files names on the command line : the
Xinput~.RNO file and the output~{\tt{.TEX}} file. For example~:
X\begin{verbatim}
X
X $ RNOTOTEX FOO.RNO FOO.TEX
X
X\end{verbatim}
Xtranslates the file FOO.RNO to the file FOO.TEX. The program does not
Xrequire any user input.
X
X\section{Translation Actions}
XThe program does four tasks. It will translate RUNOFF sectioning commands
Xto \LaTeX\ sectioning commands, translate RUNOFF flags to \LaTeX\ commands,
Xtranslate RUNOFF page directives to \LaTeX\ page directives and adjust
X\LaTeX\ counters by the same amount as RUNOFF counters are to be adjusted.
X
X\subsection{Conversion of Sectioning Commands}
X{\bf RNOTOTEX} converts RUNOFF sectioning commands to \LaTeX\ sectioning
Xcommands.
XThe output \LaTeX\ style is always {\tt report } in 10 point font.
XThe sectioning command are converted in table~\ref{section-commands}.
X\begin{table}
X\begin{tabular}{ll}
X{\lb RUNOFF }`009 & {\LaTeX\ \lb Command Generated} \\
X .HL1 text & \verb+\chapter{text}+ \\
X .HL2 text & \verb+\section{text}+ \\
X .HL3 text & \verb+\subsection{text}+ \\
X .HL4 text & \verb+\subsubsection{text}+ \\
X .HL5 text & \verb+\paragraph{text}+ \\
X .HL6 text & \verb+\subparagraph{text}+ \\
X\end{tabular}
X\caption{Conversion of RUNOFF Sectioning Commands\label{section-commands}}
X\end{table}
X
X\subsection{Conversion of RUNOFF Flags}
XRUNOFF flags are converted to \LaTeX\ commands by {\bf RNOTOTEX}.
XThis is a direct
Xconversion process, i.e.~a RUNOFF underline command is converted to a
X\LaTeX\ underline command. This does not always produce the prettiest
Xresults (as one can use {\bf bold} and {\it italic} fonts in \LaTeX\ ),
Xbut it is consistent. The author regrets that {\bf RNOTOTEX} does not
Vhave the esthetic sense to decide when a font is more appropriate than \index{e
Xsthetic sense}
Xa converted RUNOFF command. The conversion process for RUNOFF flags
Xis table~\ref{flag-commands}.
X\begin{table}
X\begin{tabular}{lcl}
X{\lb RUNOFF Flag } & {\lb Flag } & {\LaTeX\ \lb Command Generated} \\
X{\lb Name } & {\lb Char } &`009`009\\
XAccept`009`009`009& \_`009`009 & \verb!\verb+?+! \\
XBold`009`009`009& *`009`009 & \verb+{\bf+$\cdots$\verb+}+ \\
XBreak`009`009`009& \verb+|+`009 & \verb+\\+ \\
XCapitalize`009`009& \verb+<+`009 & (see below) \\
XComment`009`009 & !`009`009 & \% \\
-+-+-+-+-+ End of part 4 +-+-+-+-+-prindiville%ccrs.CDN@ean.ubc.ca (John Edgecombe) (07/12/88)
Sorry about the previous send, I am still learning this mailer.
I'll try again with a different method.
+-+-+-+ Beginning of part 5 +-+-+-+
XHyphenate`009`009& =`009`009 & \verb+\hyphenate{+$\cdots$\verb+}+ \\
XIndex`009`009`009& \verb+>+`009 & \verb+\index{+$\cdots$\verb+}+ \\
XLowercase`009`009& $\backslash`009$ & (see below) \\
XOverstrike`009`009& \%`009`009 & \verb+{\bf+$\cdots$\verb+}+ \\
XPeriod`009`009 & +`009`009 & \verb+\frenchspacing+ \\
XSpace`009`009`009& \#`009`009 & \verb*+\ + \\
XSubindex`009`009& \verb+>+ & \verb+\index{+$\cdots$\verb+}+ \\
XSubstitute`009`009& \$`009`009 & {\em not translated } \\
XUnderline`009`009& \&`009`009 & \verb+\underline{+$\cdots$\verb+}+ \\
XUppercase & \verb+^+ & (see below) \\
X\end{tabular}
X\caption{Conversion of RUNOFF Flags\label{flag-commands}}
X\end{table}
X
XCharacters following CAPITALIZE, LOWERCASE or UPPERCASE flags are converted
Xto the appropriate case during the translation process by {\bf RNOTOTEX},
Xunless they are paired with other flags. In these other cases, the flags in
XRUNOFF lock another flag on, such as the {\bf bold}ing flag described
Xin the DSR manual\cite{dsr-manual} on page 3-6. {\bf RNOTOTEX} will lock the
Xappropriate flag to the state it is in and produce the appropriate
X\LaTeX\ commands.
X\pagebreak
XFor example, {\bf RNOTOTEX} will convert~:
X\begin{verbatim}
X
X ^*These words are in bold face.\*
X
X to
X
X {\bf These words are in bold face.}
X
X\end{verbatim}
X
X\subsection{Conversion of RUNOFF Directives}
XRNOTOTEX converts RUNOFF directives to \LaTeX\ directives.
XRUNOFF allows one to enable or disable flags and change the
Xdefault flag character for a flag. {\bf RNOTOTEX} will recognize these
Xcommands and change the internal parsing setup so that the flag is
X(or is not) recognized by the character specified. See the RUNOFF commands
X````ENABLE'', ````DISABLE'', ````FLAGS'' and ````NO FLAGS'' described in the
XRUNOFF manual.
X
VIn addition, {\bf RNOTOTEX} will translate RUNOFF commands such as ````NOFILL''
X,
V````INDENT'' and ````LIST'' in the manner described in table~\ref{directive-com
Xmands}.
X\begin{table}
X\begin{tabular}{ll}
X{\lb RUNOFF }`009`009 & {\LaTeX\ \lb Command Generated} \\
X.APPENDIX`009`009 & \verb+\appendix+ \\
X.BLANK $n$`009`009 & \verb+\vspace{+$n$+\verb+}+ \\
X.BREAK`009`009`009 & \verb+\linebreak+ \\
X.CENTRE {\it text } & \verb+\begin{centering}+ \\
X`009`009`009 & {\it text } \\
X`009`009`009 & \verb+\end{centering}+ \\
X.FOOTNOTE {\it text}`009 & \verb+\footnote{+{\it text }\} \\
X.INDENT`009`009`009 & \verb+\indent+ \\
X.JUSTIFY`009`009 & \verb+\obeylines \obeyspaces+ \\
X.LIST $n$,````q''`009`009 & \verb+\begin{enumerate}+ \\
X.LITERAL`009`009 & \verb+\begin{verbatim}+ etc. \\
X.NOFILL`009`009`009 & \verb+\sloppy+ \\
X.PAGE`009`009`009 & \verb+\pagebreak[4]+ \\
X.SPACING`009`009 & \verb+\setlength{\baselineskip}{n}+ \\
X.SUBTITLE {\it text}`009 & \verb+\pagestyle{myheadings}+ etc. \\
X.TITLE {\it text}`009 & \verb+\pagestyle{myheadings}+ etc. \\
X\end{tabular}
X\caption{Conversion of RUNOFF Directives\label{directive-commands}}
X\end{table}
X
X\subsection{Conversion of RUNOFF Counters}
X{\bf RNOTOTEX} converts the RUNOFF counter changes to \LaTeX\ counter
Xadjustment changes. The conversion process in described in
Xtable~\ref{counter-commands}.
X\begin{table}
X\begin{tabular}{ll}
X{\lb RUNOFF}`009 & {\LaTeX\ \lb Command Generated} \\
X.NUMBER APPENDIX $n$ & \verb+\setcounter{\chapter}{+$n$\verb+}+ \\
X.NUMBER LEVEL $s,n$ & \verb+\setcounter{s}{n}+ \\
X.NUMBER LIST $n$ & \verb+\setcounter{\enumi}{n}+ \\
X.NUMBER PAGE $n$ & \verb+\setcounter{\page}{n}+ \\
X\end{tabular}
X\caption{Conversion of RUNOFF Numbering\label{counter-commands}}
X\end{table}
X
X\section{The Conversion LOG File}
XEach time {\bf RNOTOTEX} is executed, it generates the file {\tt RNOTOTEX.LOG}.
XIt is a record of each conversion used to generate the output \LaTeX\ commands.
XIt is useful to users less familiar with \LaTeX\ and wish to learn by
Xtrial and error rather than by reading the manual. It may also be
Xuseful to experienced \LaTeX\ users to quickly identify what \LaTeX\ will
Xproduce as output from the generated TEX file without going through
Xa complete printing.
X
XIt is recommended that the log file be printed and deleted for each
Xexecution. For example, the batch job~:
X\begin{verbatim}
X
X $ @DCL:TEX_CONVERSION_SETUP
X $ RNOTOTEX REPORT NEW_REPORT
X $ PRINT/DELETE RNOTOTEX.LOG
X
X\end{verbatim}
Xgenerates the file NEW\_REPORT.TEX from the file REPORT.RNO and prints
Xthe log of the conversion process. The user can the examine the printed
Xlog file and decide upon the editing required to produce a ````nice''
X\LaTeX\ output.
X
X
X\begin{thebibliography}{99}
X\addcontentsline{toc}{chapter}{Bibliography}
X
X\bibitem{latex-manual} Leslie Lamport {\em \LaTeX\ User Guide \& Reference} \\
XAddison-Wesley Publishing Company, 1986
X
X\bibitem{tex-manual} Donald E.~Knuth {\em The \TeX book} \\
XAddison-Wesley Publishing Company, 1984
X
X\bibitem{metafont-manual} Donald E.~Knuth {\em The METAFONT Book} \\
XAddison-Wesley Publishing Company, 1986
X
X\bibitem{dsr-manual} Digital Equipment Corporation {Digital Standard RUNOFF
X(DSR) Reference Manual } \\
XOrder \# AA-Z301B-TE, July 1985
X
X\end{thebibliography}
X\clearpage
X
X\setcounter{page}{0}
X\pagenumbering{roman}
X\tableofcontents
X\listoftables
X
X\end{document}
$ GOSUB UNPACK_FILE
$ FILE_IS = "SCREENHANDLERS.PAS"
$ CHECKSUM_IS = 860971282
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X{`009operations for input/output of data from the terminal.
X`009Randall Venhola`009`0095-May-1987 }
X
XMODULE screenhandlers;
X
X
XTYPE
X wordinteger = [WORD] 0..65535;
X byterange = [BYTE] 0..255;
X
X
X
XVAR
Xterminalerror : [HIDDEN,STATIC] integer := 0;
Xcursorrow : [HIDDEN,STATIC] wordinteger := 1;
Xcursorcolumn : [HIDDEN,STATIC] wordinteger := 1;
X
X
X
X[GLOBAL] PROCEDURE clearsubscreen( line, column : integer );
X
X FUNCTION LIB$ERASE_PAGE(lineno, colno : wordinteger) : integer; extern;
X
X VAR
X l, c : wordinteger;
X
XBEGIN
X l := line;
X c := column;
X terminalerror := lib$erase_page(l,c);
XEND;
X
X
X
X
X[GLOBAL] PROCEDURE clearscreen;
X
XBEGIN
X clearsubscreen(1,1);
XEND;
X
X
X
X
X[GLOBAL] PROCEDURE positioncursor( line, column : integer );
X
X FUNCTION LIB$SET_CURSOR( lineno, colno : wordinteger ) : integer; extern;
X
X VAR
X l, c : wordinteger;
X
XBEGIN
X l := line;
X c := column;
X terminalerror := lib$set_cursor(l,c);
X cursorrow := line;
X cursorcolumn := column
XEND;
X
X
X[GLOBAL] PROCEDURE rollttyforward;
XBEGIN
X positioncursor(cursorrow+1, cursorcolumn)
XEND;
X
X
X[GLOBAL] PROCEDURE rollttyback;
XBEGIN
X if cursorrow > 1 then
X positioncursor(cursorrow-1, cursorcolumn)
XEND;
X
X
X[GLOBAL] PROCEDURE putstringtoterminal( string : VARYING [limit] of CHAR;
X`009`009`009`009`009 line, column : integer;
X`009`009`009`009`009 reversevideo : boolean;
X`009`009 `009`009`009 blinking : boolean);
XCONST
X maxscreenwidth = 132;
X
XVAR
X l, c, flags, newcolumn : wordinteger;
X
X FUNCTION LIB$PUT_SCREEN(outtext : VARYING [C] OF CHAR;
X `009 `009 lineno : wordinteger; colno : wordinteger;
X`009`009 `009 flags : wordinteger) : integer; extern;
X
X
XBEGIN
X l := line;
X c := column;
X if reversevideo then
X if blinking then
X flags := 3
X else
X flags := 2
X else
X flags := 0;
X terminalerror := lib$put_screen(string, l, c, flags);
X newcolumn := 1 + length(string) + cursorcolumn;
X if newcolumn > maxscreenwidth then
X positioncursor(cursorrow + 1, 1)
X else
X positioncursor( cursorrow, newcolumn)
XEND;
X
X
X[GLOBAL] PROCEDURE ttywriteln;
Xconst
X carriagereturn = 13;
X linefeed = 10;
X
Xvar
X endofline : [STATIC] VARYING[2] of char;
XBEGIN
X endofline.body[1] := chr(carriagereturn);
X endofline.body[2] := chr(linefeed);
X endofline.length := 2;
X putstringtoterminal(endofline, cursorrow, cursorcolumn, false, false);
X positioncursor(cursorrow + 1, 1)
XEND;
X
X
X
X
X[GLOBAL] PROCEDURE ttyreadln( VAR string : VARYING [limit] of char );
X
X FUNCTION LIB$GET_SCREEN(VAR inputtext : VARYING [lim1] OF CHAR;
V promptstring : VARYING [lim2] OF CHAR; VAR outlen : wordinteger := %IMMED 0)
X : integer; extern;
X
X VAR
X len : wordinteger;
X prompt : [STATIC] VARYING [2] OF CHAR := '>';
X
XBEGIN
X terminalerror := lib$get_screen(string, prompt, len);
X ttywriteln
XEND;
X
X
X
X[GLOBAL] PROCEDURE findcursor( var line, column : integer );
X
XBEGIN
X line := cursorrow;
X column := cursorcolumn;
XEND;
X
X
X
X[GLOBAL] FUNCTION terminalerrorcode : integer;
X
XBEGIN
X terminalerrorcode := terminalerror;
XEND;
X
X
X
X
X[GLOBAL] PROCEDURE ttywritestring( string : VARYING [limit] OF CHAR);
X
XBEGIN
X putstringtoterminal(string, cursorrow, cursorcolumn, false, false);
XEND;
X
X
X[GLOBAL] PROCEDURE ttywriteint( int : integer );
Xconst
X maxintchars = 20;
Xvar
X s : varying[maxintchars] of char;
XBEGIN
X writev(s, int:1);
X ttywritestring( s )
XEND;
X
X
X[GLOBAL] PROCEDURE ttywritereal( floating : real; fieldwidth,
X`009 ndigits : integer);
Xconst
X maxfieldwidth = 30;
Xvar
X s : varying[maxfieldwidth] of char;
XBEGIN
X writev(s, floating:fieldwidth:ndigits);
X ttywritestring( s )
XEND;
X
XEND.
X
X
$ GOSUB UNPACK_FILE
$ FILE_IS = "SETUP.COM"
$ CHECKSUM_IS = 1043937621
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X$ set command rnototex
X$ define init$rnototex rnototex.ini
$ GOSUB UNPACK_FILE
$ FILE_IS = "TREEANDLISTOPS.PAS"
$ CHECKSUM_IS = 894243433
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X{ TREE AND LIST OPERATIONS - VERSION CVF01A
X `009 RANDALL VENHOLA JUNE 30, 1987
X`009 DOCUMENTED IN MODULEAREA:TREEOPS.TEX }
X
X
X
X[INHERIT('SCREENHANDLERS','ARGOPS','UTILITYOPS')]
XMODULE TREEANDLISTOPS;
X
X{ list and tree operations - requires the external declarations for
X data structures
X
X`009 ARGUMENT - the item of the list
X`009 COMPARISONS - possible results of comparisons
X`009 SETOFCOMPARISONS - set of above ordinal type
X
X the package is to be copied to the area of the source code and
X recompiled. It expects to find the environment file for the above
X data structures and at least the following routines :
X
X function compareargs( leftarg, rightarg : argument ) : comparisons;
X function argtexindex( arg : argument ) : integer;
X`009 }
X
XCONST
X
X nulllist = NIL;
X nulltree = NIL;
X
XTYPE
X
Xarglist = ^listnode;
X
Xargtree = ^treenode;
X
X treenode = record
X`009 parentnode : argtree;
X`009 contents : arglist
X`009 end;
X
X listnode = record
X`009 field : argument;
X`009 next : arglist;
X`009 subtree : argtree
X`009 end;
X
X
X
X
X[GLOBAL] FUNCTION nextinlist( list : arglist ) : arglist;
Xbegin
X if list = nulllist then
X errorexit('nextinlist','empty list')
X else
X nextinlist := list^.next
Xend;
X
X
X
X
X[GLOBAL] FUNCTION firstarg( list : arglist ) : argument;
Xbegin
X if list = nulllist then
X errorexit('firstlistpointer','empty list')
X else
X firstarg := list^.field
Xend;
X
X
X[GLOBAL] FUNCTION arglistlength( list : arglist ) : integer;
Xbegin
X if list = nulllist then
X arglistlength := 0
X else
X arglistlength := arglistlength(nextinlist(list)) + 1
Xend;
X
X
X
X
X
X[GLOBAL] FUNCTION leadingnodesubtree( list : arglist ) : argtree;
Xbegin
X if list = nulllist then
X errorexit('listsubtree','empty list')
X else
X leadingnodesubtree := list^.subtree
Xend;
X
X
X
X
X
X[GLOBAL] FUNCTION listofargsattree( tree : argtree ) : arglist;
Xbegin
X if tree = nulltree then
X errorexit('listofargsattree','empty tree')
X else
X listofargsattree := tree^.contents
Xend;
X
X
X
X[GLOBAL] FUNCTION treeisroot( tree : argtree ) : boolean;
Xbegin
X if tree = nulltree then
X treeisroot := TRUE
X else
X treeisroot := tree^.parentnode = nulltree
Xend;
X
X
X
X
X[GLOBAL] FUNCTION parenttree( tree : argtree ) : argtree;
Xbegin
X if treeisroot( tree ) then
X errorexit('parenttree','tree is root')
X else
X parenttree := tree^.parentnode
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE insertarginsortedlist( var list : arglist;
X`009 arg : argument; var pointertoarg : arglist );
X`009
Xtype
X scanstates = (searching, atfrontoflist, positionfound, endoflist);
Xvar
X state : scanstates;
X p, prevp, newp : arglist;
X comp : comparisons;
X
X procedure allocatenewp;
X begin
X new( newp );
X newp^.next := nulllist;
X newp^.subtree := nulltree;
X newp^.field := arg;
X pointertoarg := newp
X end;
X
Xbegin
X if list = nulllist then
X begin
X allocatenewp;
X list := newp
X end
X else
X begin
X p := list;
X comp := compareargs(arg, firstarg(list));
X if (comp = lessthan) or (comp = equal) then
X `009 state := atfrontoflist
X else
X begin
X state := searching;
X repeat
X prevp := p;
X p := nextinlist(p);
X`009 if p = nulllist then
X`009 state := endoflist
X`009 else
X`009 begin
X`009 comp := compareargs(arg, firstarg(p));
X`009 if (comp = lessthan) or (comp = equal) then
X`009 state := positionfound
X`009 end
X until state <> searching
X end;
X if comp = equal then
X warningmessage('insertarginsortedlist','already in list')
X else
X case state of
X atfrontoflist : begin
X`009 allocatenewp;
X`009 newp^.next := list;
X`009 list := newp
X`009 end;
X positionfound : begin
X`009 allocatenewp;
X `009 newp^.next := p;
X`009 prevp^.next := newp
X `009 end;
X`009 endoflist : begin
X`009 allocatenewp;
X`009 prevp^.next := newp
X`009 end
X end {case}
X end {else}
Xend;
X `009
X
X
X
X[GLOBAL] PROCEDURE appendargonlist( var list : arglist; arg : argument );
Xvar
X p, prevp, newp : arglist;
Xbegin
X if list = nulllist then
X begin
X new( newp );
X`009newp^.subtree := nulltree;`009
X newp^.field := arg;
X newp^.next := nulllist;
X list := newp
X end
X else
X begin
X `009p := list;
X repeat
X`009 prevp := p;
X p := nextinlist(p)
X until p = nulllist;
X new( newp );
X newp^.subtree := nulltree;
X newp^.field := arg;
X`009newp^.next := nulllist;
X prevp^.next := newp
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE preceedargonlist( var list : arglist; arg : argument );
Xvar
X newl : arglist;
Xbegin
X new(newl);
X newl^.subtree := nulltree;
X newl^.field := arg;
X newl^.next := list;
X list := newl
Xend;
X
X
X
X[GLOBAL] FUNCTION listcopy( list: arglist ) : arglist;
Xvar
X l : arglist;
X
X procedure prec( list : arglist );
X begin
X if list = nulllist then
X l := nulllist
X else
X begin
X prec( nextinlist(l) );
X preceedargonlist( l, firstarg(l))
X end
X end;
X
Xbegin
X if list = nulllist then
X listcopy := nulllist
X else
X begin
X prec( list );
X listcopy := l
X end
Xend;
X
X
X
X[GLOBAL] FUNCTION reverseoflist( list: arglist ) : arglist;
Xvar
X l : arglist;
X
X procedure app( list : arglist );
X begin
X if list = nulllist then
X l := nulllist
X else
X begin
X app( nextinlist(l) );
X appendargonlist( l, firstarg(l))
X end
X end;
X
Xbegin
X if list = nulllist then
X reverseoflist := nulllist
X else
X begin
X app( list );
X reverseoflist := l
X end
Xend;
X
X
X
X
X[GLOBAL] FUNCTION leadingnodehassubtree( list : arglist ) : boolean;
Xbegin
X if list = nulllist then
X leadingnodehassubtree := false
X else
X leadingnodehassubtree := list^.subtree <> nulltree
Xend;
X
X
X
X
X
X
X[GLOBAL] PROCEDURE findarginsortedlist( list : arglist; arg : argument;
X`009 var found : boolean;
X`009 var pointertoarg : arglist );
X
Xtype
X searchstates = (searching, positionfound, foundlessthanlocation, endoflist);
Xvar
X p : arglist;
X state : searchstates;
X currentarg : argument;
X comp : comparisons;
Xbegin
X found := false;
X if list <> nulllist then
X begin
X p := list;
X state:= searching;
X repeat
X currentarg := firstarg(p);
X`009 comp := compareargs(arg, currentarg);
X`009 case comp of
X notvalid : errorexit('findarginsortedlist','invalid-comparison');
X`009 lessthan : state := foundlessthanlocation;
X equal : begin
X`009 state := positionfound;
X`009 pointertoarg := p;
X`009`009 found := true
X end;
X greaterthan : nullstatement
X end; {case}
X if not found then
X begin
X`009 p := nextinlist(p);
X if p = nulllist then
X`009 state := endoflist
X`009 end
X until state <> searching
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE findarginlist( list : arglist; arg : argument;
X`009 var found : boolean;
X`009 var pointertoarg : arglist );
Xvar
X p : arglist;
X compare : comparisons;
Xbegin
X found := false;
X if list <> nulllist then
X begin
X p := list;
X repeat
X compare := compareargs( arg, firstarg(p) );
X if compare = equal then
X begin
X found := true;
X`009 pointertoarg := p
X end
X else
X p := nextinlist(p)
X until (p = nulllist) or (found)
X end
Xend;
X
X
X
X
X
X[GLOBAL] FUNCTION nargsattreenode( tree : argtree ) : integer;
Xbegin
X if tree = nulltree then
X nargsattreenode := 0
X else
X nargsattreenode := arglistlength( tree^.contents )
Xend;
X
X
X
X
X
X
X
X
X
X[GLOBAL] PROCEDURE insertlistintotree( list : arglist; var tree : argtree);
X`009
Xprocedure subinsert( list : arglist; var tree : argtree;
X`009 parentpointer : arglist );
Xlabel
X routineexit;
Xvar
X newtree : argtree;
X found : boolean;
X arg : argument;
X pointertoarg : arglist;
Xbegin
X if list = nulllist then
X goto routineexit;
X arg := firstarg(list);
X if tree = nulltree then
X begin
X new( newtree );
X newtree^.contents := nulllist;
X appendargonlist(newtree^.contents, arg);
X if parentpointer = nulllist then
X newtree^.parentnode := nulltree
X else
X newtree^.parentnode := parentpointer^.subtree;
V subinsert(nextinlist(list), newtree^.contents^.subtree, newtree^.contents
X);
X if parentpointer = nulllist then
X tree := newtree
X else
X`009parentpointer^.subtree := newtree;
X goto routineexit
X end;
X findarginsortedlist( tree^.contents, arg, found, pointertoarg);
X if not found then
X insertarginsortedlist(tree^.contents, arg, pointertoarg);
X subinsert( nextinlist(list), pointertoarg^.subtree, pointertoarg);
X routineexit : nullstatement
Xend;
X
Xbegin
X subinsert( list, tree, nulllist)
Xend;
X
X
X
X[GLOBAL] PROCEDURE searchtreeforlist( tree : argtree; list : arglist;
X var found : boolean; var indexfound, depthfoundat : integer);
X
X procedure subsearch( tree : argtree; list : arglist );
X label
X routineexit;
X var
X findsuccessful : boolean;
X arg: argument;
X pointertoarg : arglist;
X begin
X if tree = nulltree then
X goto routineexit;
X if list = nulllist then
X goto routineexit;
X arg := firstarg(list);
X depthfoundat := depthfoundat + 1;
V findarginsortedlist(listofargsattree(tree), arg, findsuccessful, pointert
Xoarg);
X if findsuccessful then
X begin
X found := true;
X indexfound := argtexindex(firstarg(pointertoarg));
X if leadingnodehassubtree(pointertoarg) then
X subsearch(leadingnodesubtree(pointertoarg), nextinlist(list))
X end;
X routineexit : nullstatement
X end;
X
Xbegin {searchtree}
X found := false;
X indexfound := indexofunknowntexcommand;
X if list = nulllist then
X warningmessage('searchtree','given empty list')
X else
X subsearch(tree, list)
Xend;
X
X
X
X
X
X
X[GLOBAL] PROCEDURE padwithnullarguments( var list : arglist; index : integer;
X`009 requiredlength : integer );
Xvar
X arg : argument;
X i, ntoappend : integer;
Xbegin
X initarg(arg, [nulltype], blank, index, TRUE);
X ntoappend := requiredlength - arglistlength(list);
X for i := 1 to ntoappend do
X appendargonlist(list, arg)
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE listtoarray(var list : arglist; index : integer;
V var arr : argarray; requiredlength :integer )
X;
Xvar
X l : arglist;
X i : integer;
Xbegin
X if requiredlength > maxargsinarray then
X errorexit('listtoarray','array size exceeded');
X padwithnullarguments( list, index, requiredlength);
X l := list;
X for i := 1 to requiredlength do
X begin
X arr[i] := firstarg(l);
X l := nextinlist(l)
X end
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE dlist( var f : text; l : arglist );
Xconst
X linelength = 75;
Xvar
X nchars : integer;
X
X procedure dl( l : arglist );
X var
X s : pckstr;
X begin
X if l = nulllist then
X writeln(f)
X else
X begin
X s := argliteral(firstarg(l), true);
X if (length(s) + nchars + 1) > linelength then
X begin
X writeln(f);
X nchars := 0
X end;
X nchars := nchars + length(s) + 1;
X write(f, s, blank);
X dl( nextinlist(l))
X end
Xend;
X
Xbegin
X nchars := 0;
X dl( l )
Xend;
X
X
X[GLOBAL] PROCEDURE dtree( var f : text; tree : argtree);
X
X procedure dt( name : pckstr; tree : argtree );
X var
X l : arglist;
X s : pckstr;
X begin
X if tree <> nulltree then
X begin
X writeln(f);
X writeln(f,'**** "',name,'" NODE HAS ****');
X l := listofargsattree(tree);
X dlist(f,l);
X writeln(f,'**** ',name,' *************');
X while l <> nulllist do
X begin
X if leadingnodehassubtree(l) then
X begin
X s := argliteral(firstarg(l), true);
X dt(s, leadingnodesubtree(l))
X end;
X l := nextinlist(l)
X end
X end
X end;
X
X begin
X dt('<ROOT>', tree)
Xend;
X
X
X
X[HIDDEN] PROCEDURE texwritearg( var f : text; arg : argument);
XEXTERN;
X
X
X
X[GLOBAL] PROCEDURE writeargarray( var f : text; arr : argarray );
Xvar
X i : integer;
Xbegin
X for i := 1 to maxargsinarray do
X if argclass(arr[i]) <> [nulltype] then
X texwritearg(f, arr[i])
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE makenullarray( var arr : argarray );
Xvar
X templist : arglist;
Xbegin
X templist := nulllist;
X padwithnullarguments(templist, indexofunknowntexcommand, maxargsinarray);
X listtoarray( templist, indexofunknowntexcommand, arr, maxargsinarray)
Xend;
X
X
X
XEND.
X
$ GOSUB UNPACK_FILE
$ FILE_IS = "UTILITYOPS.PAS"
$ CHECKSUM_IS = 236858740
$ COPY SYS$INPUT VMS_SHARE_DUMMY.DUMMY
X[INHERIT('SCREENHANDLERS')]
X
XMODULE UTILITYOPS;
X
XCONST
X blank = ' ';
X
X
X
XPROCEDURE gotoendofprogram;
XEXTERN;
X
X
X
X[GLOBAL] PROCEDURE errorexit( caller : varying[limit1] of char;
X`009 message : varying[limit2] of char );
Xbegin
X ttywriteln;
X ttywritestring('?ERROR from ');
X ttywritestring(caller);
X ttywritestring(message);
X ttywriteln;
X gotoendofprogram
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE warningmessage( caller : varying[limit1] of char;
X`009 message : varying[limit2] of char );
X
Xbegin
X ttywriteln;
X ttywritestring('%WARNING from procedure ');
X ttywritestring(caller);
X ttywritestring('"');
X ttywritestring(message);
X ttywritestring('"');
X ttywriteln
Xend;
X
X
X
X
X[GLOBAL] PROCEDURE nullstatement;
Xbegin
Xend;
X
X
X
X
X[GLOBAL] FUNCTION capchar ( ch : char ) : char;
Xbegin
X if ch in ['a'..'z'] then
X capchar := chr(ord(ch) - 32)
X else
X capchar := ch
Xend;
X
X
X
X
X[GLOBAL] FUNCTION lcchar( ch : char ) : char;
Xbegin
X if ch in ['A'..'Z'] then
X lcchar := chr(ord(ch) + 32)
X else
X lcchar := ch
Xend;
X
X
XEND.
$ GOSUB UNPACK_FILE
$ EXIT
-+-+-+-+-+ End of part 5 +-+-+-+-+-