Regina has support for VAX/VMS, but due to lack of time (and more
recently: lack of a machine for testing), I have not yet tested it on
as many different VMS machines as I wanted. I hope it will be of use,
and I will try to clear up the remaining problems later. Please feel
free to send me comments and suggestions on how Rexx should be
implemented under VMS.

There are a few details in the implementation.

1) You need the files vmsfuncs.c and vmscmd.c in addition to the rest
   of the files. These files are not used on non-VMS machines. 

2) The makefile may not work. There is a simplified makefile.vms,
   which I've been using myself, but as far as I know, there are
   several different versions of make for VMS, and not all are
   compatible, so my makefile may not work for you.

   If the makefile doesn't work, just compile all c code, and link it
   all together. 

3) The lex and yacc code may be a bit of a problem. There are mainly
   two ways to fix it: either install the gnu versions of lex and yacc
   (called flex and bison) on VMS, or run lex and yacc on a Unix
   machine, transferring the resulting C code to the VMS machine
   afterwards. You may run into several problems here. Among other
   things, not all versions of yacc seems to produce code that are
   correct. 

   The best result has been with flex version 2.3, and yacc on SunOS,
   I don't know why, but output from yacc from Ultrix seems to give
   occational syntax errors. It *may* be an error in yacc under
   Ultrix, but I havn't really tracked the problem well enough to say
   for sure.

Regina has been extended with a set of functions which are equivalent
to the DCL lexical functions. Only in a few areas do they differ:

1) The DCL lexial functions may be abbreviated (as long as they are 
   unique. However, in Rexx, the concept of abbreviateable function 
   names does not exist, and you are required to spell the function's
   name completely.

2) DCL devide messages into fatal, severe, error, warning and
   informational. And some function may flash warnings or
   informational messages on the screen without interrupting the
   program. However, in Regina, 

3) There may be some slightly different conditions on the format of
   parameters in Regina than in DCL, e.g. where padding of spaces are
   allowed or which characters are whitespace. This is mostly due to
   VMS not completely defining these in "DCL Dictionary". I'll
   consider fixing any such inconsistence that comes to my attention. 

4) The two functions f$environment() and f$verify() are not
   implemented. These are functions that operates on the internal
   variables of the DCL CLI itself, and I don't have enough
   documentation to implement them. (Implementing the KNOWN item of
   f$file_attributes() was bad enough!) Besides there are some
   problems and questions related to these, that I am not sure how to
   answer:

      a) Should they refer to data in Regina rather than the DCL CLI?
         E.g. should f$environment('depth') return? The depth of
         routines in Regina, or in DCL?. 

      b) If it should refer to data in DCL rather than in Regina
         (which I think it should), should it refer to data in the
         caller (the process that started Regina) or data in the DCL
         CLI that performs commands?

      c) In case they refer to the DCL CLI that performs commands, the
         result of these functions may even depend upon the
         environment chosen.
   


Some of these function provides information about the system, and some
of them are purly utility functions that perform similar tasks under
DCL that the builtin-in functions do under Rexx. For completeness, I
have included all functions, but I strongly recommend that you use the
Rexx built-in functions instead the the DCL lexical functions, where
possible. The DCL lexical functions that are more or less duplication
of functionality that already exists in Rexx are:

   F$LOCATE, F$LENGTH, F$INTEGER

The lexical functions that are implemented are listed below, with a
very short description. For a more complete discussion of these
functions, see the VAX/VMS documentation on lexical functions.

   F$CVSI()
   F$CVTIME()
   F$CVUI()

   F$DIRECTORY() -- returns the name of the current default directory,
         not that the name of the current device is not returned as a 
         part of this string.

   F$EDIT(string,operations) -- Returns 'string', after having done
         some operations on it. The parameter 'operations' is a comma
         separated list of operations, which may be:
  
          COLLAPSE -- remove all whitespace in 'string'
          COMPRESS -- compress all consequitive whitespace to exactly
             one space character
          LOWERCASE -- convert all uppercase character to lower case
          TRIM -- remove leading and trailing whitespace from 'string'
          UNCOMMENT -- remove comments from 'string', a comment is 
             started by the '!' character.
          UPCASE -- convert all lowercase character to upper case.

   F$ELEMENT(num,delim,string) -- Interprets 'string' as a set of 
        substrings, delimited by the 'delim' character, and returns
        the num'th such substring. The first substring (before the
        first delimiter) is numbered 0.

   F$ENVIRONMENT(item) -- Currently not implemented.

   F$EXTRACT(start,length,string) -- Extract a substring from 'string'
   
        which starts at the start'th character, and is 'length'
        characters long. The first character in 'string' is numbered
        0. 'string' is not padded if 'start' and 'length' refers to 
        more characters than 'string' contains.

   F$FAO(...)

   F$FILE_ATTRIBUTES(file,item) -- A piece of information (specified
        by 'item') about the file 'file' is returned. The legal
        'item's are:

          ALQ, BDT, BKS, BLS, CBT, CDT, CTG, DEQ, DID, DVI, EDT, EOF,
          FID, FSZ, GRP, KNOWN, MBM, MRN, MRS, NOA, NOK, ORG, PRO, PVN,
          RAT, RCK, RDT, RFM, RVN, UIC, WCK

   F$GETDVI(device,item) -- Return information about the named device
        'device', which information is specified by 'item'. The legal
        values of 'item' are:
 
          ACPPID ACPTYPE ALL ALLDEVNAM ALLOCLASS ALT_HOST_AVAIL
          ALT_HOST_NAME ALT_HOST_TYPE AVL CCL CLUSTER CONCEALED
          CYLINDERS DEVBUFSIZ DEVCHAR DEVCHAR2 DEVCLASS DEVDEPEND
          DEVDEPEND2 DEVLOCKNAM DEVNAM DEVSTS DEVTYPE DIR DMT DUA ELG
          ERRCNT EXISTS FOD FOR FREEBLOCKS FULLDEVNAM GEN HOST_AVAIL
          HOST_COUNT HOST_NAME HOST_TYPE IDV LOCKID LOGVOLNAM MAXBLOCK
          MAXFILES MBX MEDIA_ID MEDIA_NAME MEDIA_TYPE MNT MOUNTCNT NET
          NEXTDEVNAM ODV OPCNT OPR OWNUIC PID RCK RCT REC RECSIZ
          REFCNT REMOTE_DEVICE RND ROOTDEVNAM RTM SDI SECTORS
          SERIALNUM SERVED_DEVICE SHR SPL SPLDEVNAM SQD STS SWL TRACKS
          TRANSCNT TRM TT_ACCPORNAM TT_ALTYPEAHD TT_ANSICRT
          TT_APP_KEYPAD TT_AUTOBAUD TT_AVO TT_BLOCK TT_BRDCSTMBX
          TT_CRFILL TT_DECCRT TT_DECCRT2 TT_DIALUP TT_DISCONNECT
          TT_DMA TT_DRCS TT_EDIT TT_EDITING TT_EIGHTBIT TT_ESCAPE
          TT_FALLBACK TT_HALFDUP TT_HANGUP TT_HOSTSYNC TT_INSERT
          TT_LFFILL TT_LOCALECHO TT_LOWER TT_MBXDSABL TT_MECHFORM
          TT_MECHTAB TT_MODEM TT_MODHANGUP TT_NOBRDCST TT_NOECHO
          TT_NOTYPEAHD TT_OPER TT_PAGE TT_PASTHRU TT_PHYDEVNAM
          TT_PRINTER TT_READSYNC TT_REGIS TT_REMOTE TT_SCOPE TT_SECURE
          TT_SETSPEED TT_SIXEL TT_TTSYNC TT_SYSPWD TT_WRAP UNIT
          VOLCOUNT VOLNAM VOLNUMBER VOLSETMEM VPROT WCK

   F$GETJPI(process,item) -- Return information about the specified
          process 'process', which information to return is specified
          by 'item'. The legal values of 'item' are:

   F$GETQUI(func,item,object,flags) -- Return information about a
          queue, or something related to a queue. 'func' is the
          particular funtion to perform, while 'item' is the piece of
          information to return. You may regard 'func' and 'item' as a
          sort of two-level item code. The 'object' names an object
          (e.g. a queue or a spool file) that the function is to
          return information about. 'flags' is used to select the
          scope of the function, e.g. only to certain jobs or certain
          queues. 

          Note that only certain combinations of the four parameters
          are legal, and refer to the VMS manuals for more
          information. 

   F$GETSYI(item[,node]) -- Return information about the system. The
          'item' specifies which information to return, which the
          optional parameter 'node' can be used to select a particular
          node. If 'node' is omitted, the local node is used. The
          legal values for 'item' are:

             ARCHFLAG BOOTTIME CHARACTER_EMULATED CPU DECIMAL_EMULATED
             D_FLOAT_EMULATED ERRORLOGBUFFERS F_FLOAT_EMULATED
             G_FLOAT_EMULATED PAGEFILE_FREE PAGEFILE_PAGE SID
             SWAPFILE_FREE SWAPFILE_PAGE VERSION ACTIVECPU_CNT
             AVAILCPU_CNT CLUSTER_FSYSID CLUSTER_FTIME CLUSTER_MEMBER
             CLUSTER_NODES CLUSTER_QUORUM CLUSTER_VOTES
             CONTIG_GBLPAGES FREE_GBLPAGES FREE_GBLSECTS HW_MODEL
             HW_NAME NODENAME NODE_AREA NODE_CSID NODE_HWTYPE
             NODE_HWVERS NODE_NUMBER NODE_QUORUM NODE_SWINCARN
             NODE_SWTYPE NODE_SWVERS NODE_SYSTEMID NODE_VOTES
             SCS_EXISTS

   F$IDENTIFIER(id,conv) -- Takes the 'id' and converts to another
          format, depending on the value of 'conv'. 'conv' may only
          take the values:

            NAME_TO_NUMBER -- 'id' is a alphanumeric identifier, which
              is to be converted into numeric format.

            NUMBER_TO_NAME -- 'id' is a numberic identifier, whic is
              to be converted into alphanumeric format.

   F$INTEGER(number) -- In DCL, this function converts between the
          internal format of a number, and the ASCII representation of
          a the same numeric value. In Rexx however, numbers are
          stored as their character string format, so there aren't two
          format to convert between. Consequently, this is almost a
          no-op function, the only task it performs is to normalize
          'number'. 

   F$LENGTH(string) -- Returns the length of 'string', same as Rexx
          built-in function length()

   F$LOCATE(substring,string) -- Seeks for 'substring' in 'string',
          and if a match is found, it returns the number of the first
          character of the first match. The first character of
          'string' is numbered 0. If no match is found, -1 is
          returned.

   F$LOGICAL(name) -- Retrieves the logical name for 'name'. This
          function has be obsoleted by the F$TRNLNM() function, and
          you should use that instead.

   F$MESSAGE(code) -- Returns the message assiciated with the numeric
          (error-)code 'code'. Note that this message may include
          formatting information (F$FAO-codes).

   F$MODE() -- Returns one of "BATCH", "NETWORK", "OTHER" or
          "INTERACTIVE", depending on the current mode of operation
          for the process running the interpreter. 

   F$PARSE(file,default,related,field,type) -- Parses (in the DCL
          sence) 'file', which must be a file specification, and
          return parts of it, possibly after filling out missing
          parts. The parameters 'default' and 'related' contain
          filename specification which is interpreted as defaults for
          missing fields in 'file'. The 'field' refers to which
          particular field to extract, and can be one of NODE, DEVICE,
          DIRECTORY, NAME, TYPE or VERSION. The 'type' can be empty,
          or either NO_CONCEAL or SYNTAX_ONLY. 

   F$PID(context)
   F$PRIVILEGES()
   F$PROCESS()
   F$SEARCH()
   F$SETPRV()
   F$STRING()
   F$TIME()
   F$TRNLNM()
   F$TYPE()
   F$USER()


