1 RJE$
     The RJE (Remote  Job  Entry) command allows files to be sent to the
 IBM 3081 for processing.   Use  the  CONSOLE  command to  determine the
 status of jobs on the IBM 3081  and/or to display information about the
 local RJE system on the VAX.
 
 Format:                   RJE file-spec[,...]
2 Description
     RJE will process  each  file  such that each time a JCL JOB card is
 encounted in the file(s) to be sent  it  is  scanned  for  the  strings
 NO1NOZIT,  PROJCODE, and ACCTPSWD. These act in a manner similar to the
 TSO submit command on the IBM system. NO1NOZIT  will  automatically  be
 replaced  with the project code being billed for you current session on
 the VAX. PROJCODE and ACCTPSWD will prompt you at the  terminal  for  a
 project  code  and  account  password respectively. These substitutions
 will be performed on  the  JOB  card  before  it  is  transmitted.  The
 original files are not modified. If a command qualifier is placed after
 the RJE it becomes the default for all files in  the  list.  If  it  is
 placed  after  a  file  name  in  the  list  it affects only that file.
 Command qualifiers may be abbreviated to any unique  leading  substring
 (i.e. /TRANSLATE could be abbreviated /TRAN or /TRA, or even /TR ). 
2 Parameters 
 File-spec[,...]
 
     Specifies the names of the file(s) tobe sent  to  the  IBM  system.
 The  list  of  input  files may be separted by either plus (+) or comma
 (,).  File names are  of  the  format  DISK:[DIRECTORY]FILENAME.TYP;VER
 where  DISK:  defaults  to  the  current disk (probably U1:), DIRECTORY
 defaults to to the current directory, FILENAME has no default and  must
 be  specified,  and  .TYP  defaults  to  .RJE.  If no version number is
 specified, the highest version will be used.  All valid  VMS  directory
 traversial  characters  such as [-.] may be used to specify a  path for
 the file, but wild cards such as % and * are not allowed in file names.
2 Pre_Process
      The RJE  preprocessor  can  perform  basic  data manipulation on a
 data  file(s)  before  it  is  transmitted  to  the  IBM  3081.    This
 manipulation  comes in three forms: text control, keyword substitution,
 and file inclusion.  These operations are performed through the use  of
 embedded  commands  in  the files to be processed by RJE.  Preprocessor
 commands begin with a "~" (tilde) and start  in  column  one.   If  the
 command  starts  after column one, it is ignored and will be treated as
 text.   The  preprocessor   commands   are   NOT   case   (upper/lower)
 sensitive. 
                      ~command [optional_arguments]
3 Control
      The following  describes  a  series  of  commands  which  take  no
 arguments.   Usage  of  these  commands  is  the  same  as  the   other
 preprocessor  commands.   The  command must start in column one and can
 be in either upper or lower case.  For example, to  use  the  TEXTUPPER
 control  word, one merely places the  command  "~textupper"  within the
 RJE file(s).  See individual commands for  more  information  on  their
 effects and scope. 
4 ~jcllower
      The ~jcllower  command  directs  the preprocessor to leave all JCL
 lines (lines which start with // or /*) alone.   There  is  a  ~jclower
 command  which  performs the same function for those who can't remember
 the number of "l"s in the command. 
4 ~jclupper
      The ~jclupper command directs the preprocessor to convert all  JCL
 lines (lines which start with // or /*) to ALL upper case. 
4 ~textlower
      The ~textlower  command  directs  the  preprocessor  to  leave ALL
 non-JCL lines (lines starting with  something  other  than  //  or  /*)
 alone.  Text that is upper/lower case is left "asis". 
4 ~textupper
      The ~textupper  command  directs ALL non-JCL lines (lines starting
 with something other than // or /*) to be  translated  to  upper  case.
 This  command  affects  text  lines following the command itself in the
 current file and subsequently included files.  As soon as  the  current
 file  is  closed, the translation to upper case is controled by the RJE
 command qualifier /TEXT. 
 
 Example:
 
      If we have three files A.RJE, B.RJE, and C.RJE, which contain  the
 following control words:
 
           A.RJE
               ~textupper
               This is file A.RJE
               ~include B.RJE
               
           B.RJE
               This is file B.RJE
               
           C.RJE
               This is file C.RJE
               
 If  we issued the command RJE A.RJE,C.RJE, the resulting RJE file would
 be:
               THIS IS FILE A.RJE
               THIS IS FILE B.RJE
               This is file C.RJE
               
 since the default setting for /TEXT=LOWER does  not  perform  lower  to
 upper case translation. 
4 ~verify
      The ~verify  command  instructs RJE to display the line counts and
 names of the input data file(s) processed by RJE. 
4 ~noverify
      The ~noverify command  instructs  RJE  not  to  display  the  line
 counts and names of the input data file(s) processed by RJE. 
3 Scope
      The "global  variable"  and "local variable" definition is crucial
 to the replacement policy, it is essential to know which is  which.   A
 global  variable  is a word which starts with "@", "#", or "$".  Global
 variables are eligable for substitution anywhere in  the  RJE  file(s).
 While  a local variable may only be replaced within a JCL statement and
 must start with either a  letter  or  a  number.   To  illustrate,  the
 variable  "projcode" is a local variable, where as the variable "@file"
 is a global variable.  To better  show  the  substitution  policies  at
 work, if given the following RJE file:
 
           ~replace  projcode=AAA00000
           ~replace  @file=u1:[mygroup]login.com
           //test job projcode,'my name',class=u,typrun=copy
           The filename supplied is @file.
           However, we can't tell what projcode is.
 
 would be translated by the preprocessor to
 
           //test job AAA00000,'my name',class=u,typrun=copy
           The filename supplied is u1:[mygroup]login.com.
           However, we can't tell what projcode is.
 
 Notice  that  "projcode"  was  replaced in the JCL statement and not in
 the last line of  text;   however,  the  global  variable  "@file"  was
 replaced in preceding line. 
3 Substitution
      Some of  the more interesting applications of keyword substitution
 arise out of the fact that substitution can take place on  preprocessor
 commands.   However to do this, we must use global variables to perform
 the substitutions.  For example, suppose we want to set up an RJE  file
 that  uploads  a  VAX  file  to the IBM with minimum effort.  First, we
 need a couple of things:
 
       a)  We need the name of an IBM  utility  to  perform  the  actual
           upload  of  data  to an IBM dataset.  We choose the procedure
           TSOLOAD and assume that  the  reader  is  familiar  with  it.
           TSOLOAD  requires  data  input and the name of an IBM dataset
           which is to be created. 
           
       b)  We need to know which VAX file to transmit. 
           
       c)  We will need an IBM project code and  a  name  for  JOB  card
           information. 
           
 Given  these  requirements, we can generate a simple RJE file which can
 perform this task on almost any file for any user.  Take the  following
 RJE file as an example:
 
           ~prompt  @vaxfile=VAX filename?
           ~prompt  @ibmfile=IBM dataset?
           ~prompt  projcode=Project Code?
           ~prompt  username=Your name?
           //XFER JOB projcode,'username',CLASS=U
           //     EXEC TSOLOAD,DSN='@ibmfile'
           //SYSIN  DD *
           ~include @vaxfile
           //
 
 Here,  we've  defined  two global variables (@vaxfile and @ibmfile) and
 two local variables  (projcode  and  username).   The  ~prompt  command
 prompts  the  user's terminal for values that the four variables are to
 take on.  If these lines  were  in  the  file  XFER.RJE,  a  submission
 session  might  proceed  as  follows.   Words  in  upper  case  reflect
 possible responses to the prompts:
 
           $ RJE XFER.RJE
           Project Code? AAA88888
           Your name? JOHN DOE
           IBM dataset? MYTSOID.VAXTEST.DATA
           VAX filename? TEST.DAT
               8 lines, test.dat
               9 lines, xfer.rje
           $
3 Summary
    ~jcllower   --  JCL lines converted to lower case.
    ~jclupper   --  JCL lines converted to upper case.
    ~textlower  --  All non-JCL lines converted to lower case.
    ~textupper  --  All non-JCL lines converted to upper case.
    ~noverify   --  Disable/Enable display of line counts and names
    ~verify         of each processed input file(s).

    ~include    --  Include external file into the RJE data file(s).
                      ~include file_specification
    ~prompt     --  Prompt for substitution value for a variable.
                      ~prompt variable_name=prompt_string
    ~replace    --  Define a variable value for future processing.
                      ~replace variable_name=replacement_string
3 Translation
      The RJE preprocessor does not distinguish between upper  or  lower
 case  letters.   In other words, the variable "PROJCODE" is the same as
 the variable "projcode".  The preprocessor also predefines three  local
 variables:   "PROJCODE",  "ACCTPSWD",  and  "NO1NOZIT".   PROJCODE  and
 ACCTPSWD  will  prompt  for  an  IBM   project   code   and   password,
 respectively.   NO1NOZIT  will substitute the IBM account for which VAX
 account is billed.  This account can be listed by the VMS command  SHOW
 PROCESS/QUOTA. 
3 Variables
      The preprocessor  maintains  a  special  list  of  words  known as
 variables.  Associated with each variable is a  string.   Whenever  the
 preprocessor  sees  a  variable  in  the  data file(s), the variable is
 extracted and its  associated  string  is  inserted  within  the  data.
 Every  statement  within the RJE file(s) is subject to this replacement
 under the following guidlines:
 
       1)  In JCL statements (any line starting with // or  /*),  either
           a local variable or a global variable can be replaced. 
           
       2)  In  non-JCL statements (preprocessor commands included), only
           global  variables  are   subject   to   replacement.    Local
           variables,  by  their  nature,  are ignored when not in a JCL
           statement. 
           
       3)  The preprocessor  is  a  single  pass  processor.   Take  the
           following example:
           
                ~replace  projcode=myprojcode
                ~replace  myprojcode=AAA00000
                //TEST JOB projcode,'MY NAME',CLASS=U
                
           The resulting JOB card will become:
                //TEST JOB myprojcode,'MY NAME',CLASS=U
                
           This next example shows replacement of a replace:
                
                ~replace  myprojode=AAA00000
                ~replace  projcode=myprojcode
                //TEST JOB projcode,'MY NAME',CLASS=U
                
           The resulting JOB card now becomes:
                //TEST JOB AAA00000,'MY NAME',CLASS=U
3 Words
      Words are  symbolically  represented  as  a collection of letters,
 numbers, or the  symbols  '@',  '#',  or  '$'.   For  example,  in  the
 following commands:
 
                      ~prompt   @vaxfile=Filename?
                      ~replace  Name=John L. Xyzzy
 
 The   strings:   "prompt",   "@vaxfile",   "replace",  and  "Name"  are
 considered words.  "Filename?" is the prompting  string  that  will  be
 displayed  and  "John  L.  Xyzzy"  is a replacement string for the word
 "Name".  This concept will help explain how the  preprocessor  performs
 its substitution within the data file(s). 
3 ~include
      The ~include  command  provides a mechanism for including external
 files into the RJE data file(s).  The syntax for the command is:
 
                     ~include  file-specification  (or)
                     ~include  global_variable
 
 In its first form, the argument is taken as the  name  of  an  existing
 file.   If the file can be opened, its contents are copied into the RJE
 file.  If the file can't be opened, an error message is issued and  RJE
 terminates  processing  immediately.   The  second  form  is  the  more
 flexible as it allows the user  to  specify  the  name  of  a  variable
 previously defined by either a ~replace command or a ~prompt command. 
 
      There are  some  restrictions  on the use of the ~include command.
 First, like the other preprocessor commands, it must  start  in  column
 one.   It  may  be  in  either upper or lower case.  Also, a maximum of
 eight files may be opened at the same time  (e.g.  you  can  include  a
 file  which  in  turn  includes  a file which in turn ... etc ... up to
 eight times).  If a ninth file is opened, RJE issues an  error  message
 about  exceeding  the  maximum  nesting level and terminates processing
 immediately.  This action prevents a file from including itself. 
3 ~prompt
      The ~prompt  preprocessor  directive  allows  RJE  to  prompt  for
 substitute  values  for certain variables.  A prime example is the case
 where RJE prompts the user for  an  IBM  project  code  when  the  word
 PROJCODE  is  found  on a JCL statement.  ~Prompt may be used to supply
 values for either local variables or global variables. 
 
      The syntax for the ~prompt command is:
 
                  ~prompt  variable_name=prompt_string
 
 When the RJE preprocessor encounters a variable which  was  defined  by
 the  ~prompt  command,  it  checks  to  see if a value has already been
 supplied by a previous command.  If a replacement is found, it is  used
 and  no  prompting  is  done.  In the case none is found (which implies
 this is the first occurrence of the variable), RJE  issues  the  prompt
 "prompt_string"  and  waits for the user to type in a reply.  The reply
 is then recorded as  the  replacement  string  for  that  variable  and
 subsequent  references  to the variable causes an action similar to the
 ~replace command.  If the  user  enters  end-of-file  (control-Z  under
 VMS),  then  RJE terminates processing of all files and issues an abort
 message.  Such behavior guards against premature submission of  a  file
 from, say, a .COM file. 
 
      For a   further   description   of  the  ~prompt  syntax  and  its
 requirements, the reader is directed to the help entry  describing  the
 ~replace command. 
3 ~replace
      The ~replace  command  defines a local variable or global variable
 for future processing.  See help on Globals for a  further  description
 of  the  terms "local variables" or "global variables".  The syntax for
 the ~replace command is:
 
                ~replace variable_name=replacement_string
 
 The ~replace command must begin in column  one.   Failure  to  do  this
 will  cause  the  instruction  to  be  ignored.  The command itself may
 appear in upper or lower case.  "Variable_name" is any  valid  variable
 name.   A  local  variable  will only be replaced if found within a JCL
 statement (any line starting with // or /*) where as a global  variable
 will  be  replaced whenever it is found.  An upper case variable is the
 same as a lower case variable by  the  same  name.   For  example,  the
 variable   "projcode"   is   the   same  as  the  variable  "PROJCODE".
 "Replacement_string" can be any string  of  characters  that  the  user
 wishes  to  use.   It  should  be  noted  that  upper and lower case is
 preserved within the replacement string. 
 
      When using the ~replace command,  the  variable  definition  takes
 effect  from  that  point  on  to  the end of RJE file processing.  The
 definition will span multiple files.  If the ~replace command makes  an
 attempt  to  define  a  variable  that  was previously defined, the new
 definition replaces the old one. 
 
      For coding purposes, the following rules must be adhered to:
 
       a)  ~replace must start in column one.  Failure to do  so  causes
           the line to be treated as normal text. 
           
       b)  The  amount of white space between ~replace and variable_name
           is insignificant. 
           
       c)  Do not put a blank BEFORE the equal  sign.   If  a  blank  is
           found,  the  statement is ignored and is treated as a line of
           normal text. 
           
       d)  Anything and everything immediately following the equal  sign
           is  taken  as  the replacement string.  This action preserves
           all white space as well as upper and lower case.  End of  the
           line  terminates  the  string.  There is no way of continuing
           the replacement string across lines. 
2 Remote_Exe 
      Remote execution  on  the  VAX  is  made possible by virtue of the
 optional parameter  "EXECUTE=file-specification"  on  an  incoming  Tag
 Card  -  see  help on Tag_Card.  This parameter will cause the creation
 of a  DETACHED  process  of  the  specified  image  (executable)  file,
 provided  that  the  file  type  is a .REX instead of a .EXE file type.
 This ensures that ONLY programs  specifically  designed  to  run  as  a
 remote executable can be invoked by an inbound RJE file. 
 
      The remote   executable   program   will   run   under  a  limited
 environment.  The username, UIC, and  account  (project  code)  is  the
 same  as that of the owner of the .REX file and will have access to all
 of the files with like ownership.  Since the  program  will  run  as  a
 DETACHED  process,  there is no CLI with which to make calls to the Run
 Time Library routines LIB$DO_COMMAND or LIB$SPAWN.  If such calls  must
 be  made, the .REX program must spawn the image SYS$SYSTEM:LOGINOUT and
 supply commands through a mailbox.  The DETACHED process  will  execute
 with  only the TMPMBX privilege unless the .REX file has been installed
 with privileges (.REX files set up on the System  and  made  accessable
 to the general user). 
 
      The input/output  logicals  SYS$INPUT,  SYS$OUTPUT,  and SYS$ERROR
 are defined to be the incoming RJE  file,  RJEXEC.LIS,  and  RJEOUT.ERR
 respectively.   If the incoming RJE file does not specify a destination
 value via the OUTPUTFILE parameter, then it is stored  as  a  temporary
 file  in  the RJE Spool directory.  The RJEXEC.LIS and RJEOUT.ERR files
 will be created in the default directory (SYS$LOGIN) of the  user  that
 owns the .REX file. 
2 Summary    
 Format:                   RJE file-spec[,...]
 Qualifiers:                                      (Abbreviation allowed)
 /JCL                      /PUNTRANSLATE               /TRANSLATE
    /JCL=UPPER (D)            /PUNTRANSLATE (D)           /TRANSLATE (D)
    /JCL=NOUPPER              /NOPUNTRANSLATE             /NOTRANSLATE
 /NOTIFY                   /TAG                        /WRAP
    /NOTIFY[=username] (D)    /TAG (D)                    /WRAP
    /NONOTIFY                 /NOTAG                      /NOWRAP (D)
 /OUTPUT                   /TEXT
    /OUTPUT[=file-spec] (D)   /TEXT=UPPER
    /NOOUTPUT                 /TEXT=NOUPPER (D)
3 Pre_Process
    ~jcllower   --  JCL lines converted to lower case.
    ~jclupper   --  JCL lines converted to upper case.
    ~textlower  --  All non-JCL lines converted to lower case.
    ~textupper  --  All non-JCL lines converted to upper case.
    ~noverify   --  Disable/Enable display of line counts and names
    ~verify         of each processed input file(s).

    ~include    --  Include external file into the RJE data file(s).
                      ~include file_specification
    ~prompt     --  Prompt for substitution value for a variable.
                      ~prompt variable_name=prompt_string
    ~replace    --  Define a variable value for future processing.
                      ~replace variable_name=replacement_string
2 Tag_Card   
      The tag  card  is an IBM control statement used for routing output
 returning  from  the  IBM  System.   The  keyword  parameters  may   be
 abbreviated  to  three letters.  Multiple parameters are separated by a
 blank or a comma.  The UCS VAX tag card format is as follows:
      /*TAG OUTPUTFILE=dev:[directory-path]filename,NOTIFY=username
 
 The OUTPUTFILE=file-spec is required.  The  parameter  PUNTRANSLATE  or
 NOPUNTRANSLATE  may be added on the end.  Note "<>" may be used instead
 of "[]" if you are using an IBM terminal or  card  punch.   For  Remote
 EXecution on the UCS VAX the tag card format is:
 /*TAG OUTPUTFILE=dev:[dir-path]filename,EXECUTE=rexfile,NOTIFY=username
3 ECN_Tag
      One version of an ECN tag card is as follows:
 
                      /*TAG USR=(username,/BIN/GUS)
3 EXECUTE
      The EXECUTE  parameter creates a DETACHED process of the specified
 image (executable), provided that the image's file  type  specification
 is  .REX  instead  of  a  .EXE  file  type.  The image is run under the
 control and ownership of the owner  of  the  .REX  file.   For  further
 information on Remote EXecution, see the help entry on Remote_Exe. 
3 NOTIFY
      The NOTIFY  parameter  signals RJE to send a completion message to
 the specified VAX user.  This message is either  broadcast  to  ALL  of
 the  VAX  terminals  the  user  is logged on, or it will be sent to the
 specified username via mail.  Note that if the user is  logged  on  but
 has  /NOBROADCAST turned on, the message will be mailed.  The mail sent
 is compatible with VMS MAIL. 
3 OUTPUTFILE
      The OUTPUTFILE  parameter  specifies  the  name  of  the  file  to
 contain  the  output  returned  from  the IBM System.  Ownership of the
 resultant RJE file is based on the owner of the directory  on  the  VAX
 into  which  the  file  is created.  The file protection will be set to
 (s:rw,o:rwed,g,w).  If a problem occurs, such as  an  invalid  filename
 or  exceeded  disk  quota,  then the output file is re-routed to either
 the VAX line printer (if a print file listing)  or  to  the  RJE  spool
 directory (if a punch file). 
 
      The default  file  types  are  .LIS  for  print files and .PUN for
 punch files.  The file type specification  is  fixed  and  can  not  be
 altered  by  the  output specification.  Output device specification is
 restricted to user disks (U1, U2, or U3). 
3 PUNTRANSLATE
      The PUNTRANSLATE and the NOPUNTRANSLATE  parameters  are  actually
 flags.   They  control  whether or not data received as a punch file is
 to be treated as transparent or non-transparent data. 
 
      If the data is transparent, the first two lines of  the  incomming
 file  are  removed;  typically,  the  Tag  Card  and  header card.  The
 remainder of  the  file  is  stored  as  fixed  length  records  of  80
 characters  with  no  translation  from EBCIDIC to ASCII performed.  If
 the data is non-transparent, a variable length carriage return file  is
 created  in ASCII.  It should be noted that transparent data can not be
 received as a print file. 
2 Qualifiers
/JCL

    /JCL=UPPER   (D)
    /JCL=NOUPPER
 
 The /JCL=UPPER option causes all  IBM  Job  Control  Statements  to  be
 folded  to  upper  case before transmission.  The original source files
 are not modified.  This feature is very useful  because  JCL  statments
 must  be  upper  case.   The  default is /JCL=UPPER which automatically
 fold JCL but not text. 
 
/NOTIFY

    /NOTIFY[=username]   (D)
    /NONOTIFY
 
 The  /NOTIFY  parameter  causes  the  RJE  system  to  place  a  notify
 statement  on  any  /*TAG  cards  it generates.  The default is /NOTIFY
 which sends a message to the sender of the file if they  are  still  on
 the  system  when the output come back from the IBM system or send MAIL
 if they have logged off.   You  may  optionally  specify  the  name  of
 another user or suppress notification. 
 
/OUTPUT

    /OUTPUT[=file-spec]   (D)
    /NOOUTPUT
 
 The  /OUTPUT  option  allows  you  to  specify  the name of the file to
 contain the output returned from the IBM system.  Both  full-path  file
 specification   (i.e.   u1:[group.username]file   )   or   partial-path
 specification (i.e. [-.work.rje]file ) may be  used  with  the  /OUTPUT
 qualifier.   When  a  partial-path  is  used  RJE  will  determine  the
 complete  path  during  the  generation  of   the   tag-card.    If   a
 directory-path  is  not specified then the current directory from which
 RJE was invoked will be used.   RJE  will  also  allow  valid  logicals
 (process,  group,  and  system) to be used; however, RJE will not allow
 system disks (S0, S1, or S2) to be used.  The  file  type  you  specify
 will  be  ignored.  All print files received will be of type ".LIS" and
 all punch files will  be  of  type  ".PUN".   This  restriction  is  to
 prevent  reception  of  ".EXE"  and  ".COM"  files  which  could  cause
 difficulties if executed.   If  you  omit  the  /OUTPUT  statement  the
 default  file  name is RJEPRINT.LIS in the directory where the file was
 submitted from.  If you specify  /NOOUTPUT  then  the  output  will  go
 directly to the line printer. 

 Examples:

    /output=u1:[group.username.ibm]goodstuff
    /output=u3:[scratch.mydir]rjetemp
    /out=[-.ibm]project
    /out=sys$login:rjeout
    /output=ibmwork

/PUNTRANSLATE

    /PUNTRANSLATE   (D)
    /NOPUNTRANSLATE
 
 The /PUNTRANSLATE statement causes punch  (SYSOUT=B)  output  from  the
 IBM  system to be translated from EBCDIC to ASCII.  This is the default
 action.  Specifying /NOPUNTRANSLATE would be used to send  BINARY  data
 between systems. 
 
/TAG

    /TAG   (D)
    /NOTAG
 
 The  /TAG option causes the RJE command to generate a /*TAG card at the
 front of each JOB submitted to the IBM system for processing.  /TAG  is
 the  default  unless  there  is  already  a  /*TAG  card  in  the file.
 Specifying /NOTAG suppresses the generation of  /*TAG  cards  but  will
 not cause them to be removed if they are present in the file. 
 
/TEXT

    /TEXT=UPPER
    /TEXT=NOUPPER   (D)
 
 The  /TEXT=UPPER  option  causes  all  text  to be folded to upper case
 before transmission.  The  original  source  files  are  not  modified.
 Text  is  defined  as  being  anything  in the files except the IBM JCL
 statements.   This  particular  feature  is  useful  when  transmitting
 program  source  because most of the IBM compilers are very picky about
 lower case.  The  default  is  /TEXT=NOUPPER  which  leaves  your  text
 exactly as found. 
 
/TRANSLATE

    /TRANSLATE    (D)
    /NOTRANSLATE
 
 The  /TRANSLATE  option  causes ASCII files on the VAX to be translated
 to EBCDIC before being set to the IBM 3081.  /TRANSLATE is the  default
 for  all  files  sent to the IBM system.  Specifying /NOTRANSLATE would
 be  used  to  send  BINARY  data  between  systems.   DO  NOT   SPECIFY
 /NOTRANSLATE AT THIS TIME.  IT IS NOT YET IMPLEMENTED. 
 
/WRAP

    /WRAP
    /NOWRAP   (D)
 
 The  /WRAP  option  causes  lines longer than 80 characters to be split
 into multiple lines before transmission.  The 80  character  length  is
 determined  by  the  IBM  system  which  treats  the  VAX RJE as a card
 reader.  The default  is  /NOWRAP  which  causes  longer  lines  to  be
 truncated. 
