HP OpenVMS Systems Documentation

** Show_roots.c
**
*/

#include <rms>
#include <stdio>
#define MAXKEY 10
main (int argc, char *argv[])
{
struct FAB      fab;
struct XABSUM   sum;
struct XABKEY   xab[MAXKEY];
int             i, stat, lvl, keys;

fab = cc$rms_fab;
sum = cc$rms_xabsum;
fab.fab$b_shr = FAB$M_SHRPUT;
fab.fab$b_fac = FAB$M_GET;
fab.fab$l_fna = argv[1];
fab.fab$b_fns = STRLEN( argv[1] );
fab.fab$l_xab = &sum;
stat = SYS$OPEN ( &fab );
if (!(stat&1)) return stat;
if (fab.fab$b_org!=FAB$C_IDX) return RMS$_ORG;
keys = sum.xab$b_nok;
fab.fab$l_xab = &xab[0];
for (i=0; i<keys; i++)
    {
    /*
    ** Init Xab Key for each defined key
    ** Point previous to current except first.
    */
    xab[i] = cc$rms_xabkey;
    xab[i].xab$b_ref = i;
    if (i) xab[i-1].xab$l_nxt = &xab[i];
    }
/*
** Ask RMS to fill in the XABs hooked off the FAB.
*/
stat = SYS$DISPLAY ( &fab );
if (!(stat&1)) return stat;
printf ("File %s, Root levels: %d", argv[1], xab[0].xab$b_lvl);
for (i=1; i<keys; i++) printf (", %d", xab[i].xab$b_lvl);
printf (".\n");
return stat;
}

   %CC-E-UNDECLARED, In the declaration of "primarySpec", "NAML$C_MAXRSS"
   is not declared.

   %RMS-F-NAM, invalid NAM block or NAM block not accessible

/*--------------------------------------------------------------
 *
 *   NAML_EXAMPLE.C
 *
 *   This sample program uses NAML blocks (short and long
 *   buffers) with RMS $PARSE and $SEARCH functions to
 *   demonstrate extended file specification capabilities.
 *
 *   NAML blocks are supported only on Alpha platforms.
 *
 *   Notes:
 *      The no-short-upcase NAML bit is set, so the short expanded
 *      specification will not be upcased.
 *
 *-------------------------------------------------------------*/

#include <string>                       // for strlen, etc.
#include <ssdef>                        // for SS$_NORMAL
#include <stdio>                        // for printf, etc.
#include <starlet>                      // sys$parse, sys$search
                                        // function prototypes
#include <rms>                          // NAML and FAB structure definitions

int main()
{
    int vms_status;
    int primarySpecLength = 0;
    char primarySpec[NAML$C_MAXRSS+2];  // (Include room for LF and \0.)
    char defaultSpec[] = "*.*;*";

    /*
     *  Create the string buffers for the resultant and expanded strings
     */

    char Naml_Shrt_Esa[NAM$C_MAXRSS],
         Naml_Long_Esa[NAML$C_MAXRSS],
         Naml_Shrt_Rsa[NAM$C_MAXRSS],
         Naml_Long_Rsa[NAML$C_MAXRSS];

    /*
     *  Declare the FAB and NAML structures
     */

    struct FAB fab;
    struct namldef naml;

    /*
     *  Initialize the FAB and NAML using the default structures,
     *  then set them up for our use.
     */

    fab = cc$rms_fab;
    naml = cc$rms_naml;

    /*
     *  To indicate that the NAML fields should be used rather
     *  than the FAB fields for the filename, we put a -1 in
     *  the FNA field, and a zero in the FNS field.
     */

    fab.fab$l_fna = (char *)-1;
    fab.fab$b_fns = 0;

    fab.fab$l_dna = defaultSpec;
    fab.fab$b_dns = strlen(defaultSpec);

    fab.fab$l_naml = &naml;     //  tie the NAML to the FAB

    naml.naml$l_long_filename = primarySpec;
    naml.naml$l_esa = Naml_Shrt_Esa;
    naml.naml$b_ess = sizeof (Naml_Shrt_Esa);
    naml.naml$l_rsa = Naml_Shrt_Rsa;
    naml.naml$b_rss = sizeof (Naml_Shrt_Rsa);

    naml.naml$l_long_expand       = Naml_Long_Esa;
    naml.naml$l_long_expand_alloc = sizeof (Naml_Long_Esa);
    naml.naml$l_long_result       = Naml_Long_Rsa;
    naml.naml$l_long_result_alloc = sizeof (Naml_Long_Rsa);

    /*
     *  Set NAML options flags
     */

    naml.naml$v_synchk = 0;             // Have $PARSE do directory
                                        //   existence check
    naml.naml$v_no_short_upcase = 1;    // Don't upcase short expanded spec.

    /*
     *  Prompt for the input file specification.  A blank
     *  response will use the default filespec of *.*;*
     */

    printf("File specification to be scanned: ");
    gets(primarySpec);

    naml.naml$l_long_filename_size = strlen(primarySpec);

    /*
     *  Parse the given file specification.  This sets up for
     *  the $SEARCH loop.  On success, print out the expanded
     *  file specifications.
     */

    printf ("\n\nParsing: %s\n", primarySpec);
    vms_status = sys$parse (&fab);
    if (!(vms_status & 1))                      //  return any error
    {
        return vms_status;
    }

    naml.naml$l_esa[naml.naml$b_esl] = '\0';    //  terminate the string
    printf ("   (Short) Expanded Specification: '%s'\n",
                naml.naml$l_esa);

    naml.naml$l_long_expand[naml.naml$l_long_expand_size] = '\0';
    printf ("   (Long)  Expanded Specification: '%s'\n",
                naml.naml$l_long_expand);

    /*
     *  Go into the $SEARCH loop.  We loop until the
     *  $SEARCH fails or returns No More Files (NMF)
     *  For each successful $SEARCH, print out the
     *  resultant file names from the NAML block.
     */

    printf ("\n\nSearching for files matching: %s\n", primarySpec);
    while (1)
    {
        vms_status = sys$search (&fab);
        if (!(vms_status & 1))          //  handle any error
        {
            if (vms_status == RMS$_NMF)
                return SS$_NORMAL;
            else
                return vms_status;
        }

        printf ("   (Short) Resultant Specification: '%-*.*s'\n",
                    naml.naml$b_rsl,
                    naml.naml$b_rsl,
                    naml.naml$l_rsa);

        printf ("   (Long)  Resultant Specification: '%-*.*s'\n",
                    naml.naml$l_long_result_size,
                    naml.naml$l_long_result_size,
                    naml.naml$l_long_result);

    }  //  end of while loop

}  // end of function main()

        x_rab = cc$rms_rab64;

/*
 *  RAB64_EXAMPLE.C
 *
 *  Description:
 *      This sample program uses the 64-bit pointers in the new RAB64
 *      structure to allow addressing of the full 64-bit Alpha
 *      address space.
 *
 *  NOTE:
 *      Prior to V7.2, the cc$rms_rab64 initializer was not available
 *      and the RAB64 structure had to be initialized manually.  See
 *      the comment in the code for details.
 *
 */

#define __NEW_STARLET

#include <far_pointers.h>    // basic set of 64-bit pointer types
#include <rms.h>             // both RAB and RAB64 structures
#include <lib$routines.h>    // for lib$signal
#include <starlet.h>         // for RMS function prototypes
#include <stdio.h>           // for printf, gets, etc.
#include <string.h>          // for strlen
#include <ssdef.h>           // for status codes

#include <stdlib.h>          // for memset

/*
 *  Start of code
 */

int main()
{
    int status;

    /*
     *  Define the structures for RMS
     */

    struct FAB   fab;
    struct RAB64 x_rab;

    char file_name[NAM$C_MAXRSS];

    /*
     *  Set up variables for allocating a record buffer
     *  from 64-bit P2 address space.
     */

    VOID_PQ p2_va;
    CHAR_PQ record_buffer;

    __int64 num_bytes = 1024;
    __int64 num_pagelets = (num_bytes / 512);

    /*
     *  Get the filename
     */

    printf("Enter filename to read: ");
    gets(file_name);

    /*
     *  Set up the FAB using the default structures, then
     *  set it up for our use.
     */

    fab = cc$rms_fab;

    fab.fab$l_fna = file_name;
    fab.fab$b_fns = strlen(file_name);
    fab.fab$b_org = FAB$C_SEQ;
    fab.fab$b_fac = FAB$M_GET;
    fab.fab$b_shr = FAB$M_NIL;

    /*
     *  Open the file
     */

    status = sys$open(&fab);
    if (!(status & 1))
    {
        return status;
    }
    printf("File %s was opened.\n", file_name);

    /*
     *  Dynamically allocate record buffer in 64-bit P2 space
     */

    status = LIB$GET_VM_PAGE_64 ( &num_pagelets, &p2_va );
    if (!(status & 1))
    {
        return status;
    }
    printf("Allocated %Ld pagelets of P2 space starting at %LX\n",num_pagelets,p2_va);

    record_buffer = p2_va;

    /*
     *  Initialize rab64
     *
     *  NOTE:  Prior to OpenVMS V7.2, the cc$rms_rab64 initializer
     *  was not available.  As of V7.2, the following memset, block-id
     *  and length assignments may be replaced with the assignment:
     *
     *    x_rab = cc$rms_rab64;
     *
     */

    memset(&x_rab,0,RAB$C_BLN64);       //  requires stdlib.h
    x_rab.rab64$b_bid    = RAB$C_BID;   //  block id
    x_rab.rab64$b_bln    = RAB$C_BLN64; //  block length

    x_rab.rab64$l_fab    = &fab;        //  tie the FAB to the RAB
    x_rab.rab64$b_rac    = RAB$C_SEQ;
    x_rab.rab64$l_ubf    = (char *) -1; //  -1 says use the PQ field
    x_rab.rab64$pq_ubf   = record_buffer;
    x_rab.rab64$w_usz    = 0;           //  0 says use the Q field
    x_rab.rab64$q_usz    = num_bytes;

    /*
     *  Connect our record stream
     */

    status = sys$connect( (struct _rabdef *) &x_rab);
    if (!(status & 1))
    {
        return status;
    }
    printf("Record stream was connected.\n");

    /*
     *  Retrieve first record in file for illustration purposes
     */

    status = sys$get ( (struct _rabdef *) &x_rab);
    if (!(status & 1))
    {
        /*
         *  Signal the error rather than just returning
         *  it so we can include the STV field from
         *  the RAB
         */

        lib$signal ( status, x_rab.rab64$l_stv);
    }

    /*
     *  Add null byte to terminate record in record buffer
     */

    record_buffer[x_rab.rab64$q_rsz] = 0;
    printf ("Record = %s\n",record_buffer);

    /*
     *  Close the file, doing an implicit disconnect of
     *  the record stream.
     */

    status = sys$close (&fab);
    if (!(status & 1))
    {
        return status;
    }
    printf("File was closed.\n");

    /*
     *  Deallocate record buffer in 64-bit P2 space
     */

    status = LIB$FREE_VM_PAGE_64 ( &num_pagelets, &p2_va );
    if (!(status & 1))
    {
        return status;
    }
    printf("Deallocated %Ld pagelets of P2 space starting at %LX\n",num_pagelets,p2_va);

    return SS$_NORMAL;
}