From: david_m_curry@my-deja.com
Sent: Monday, December 20, 1999 7:40 PM
To: Info-VAX@Mvb.Saic.Com
Subject: Problem porting RMS code from VAX to Alpha!

I was given the task to port a MACRO function which emulates F$PARSE on
a VAX to C.  I have never looked at MACRO code before, nor have I any
idea what I'm doing with RMS.  Anyhow, I ported the code and it works
dandy on a VAX.  However, it completely fails to work on an Alpha.  I
get no warnings when compiling and linking.  I am not using any flags.
Anybody have a clue as to the problem?  Hopefully, you don't need to
look at the code, but if you do (it's not very long), I included it.

Cheers,
David Curry

----------------------------------------------------------------------

#include <ssdef.h>
#include <descrip.h>
#include <rms.h>

int scm$parse_fields( struct dsc$descriptor_s *input_name,
                      struct dsc$descriptor_s *node,
                      struct dsc$descriptor_s *device,
                      struct dsc$descriptor_s *directory,
                      struct dsc$descriptor_s *file_name,
                      struct dsc$descriptor_s *file_type,
                      struct dsc$descriptor_s *file_version,
                      int                     *parse_flags,
                      int                     *file_flags,
                      struct dsc$descriptor_s *dflt )
{
   struct NAM name_block;
   struct FAB file_access_block;
   unsigned char expanded_string_length = 0;
   char expanded_string[NAM$C_MAXRSS];
   unsigned char resultant_name_length = 0;
   char resultant_name[NAM$C_MAXRSS];
   char input_specification[NAM$C_MAXRSS];
   char default_specification[NAM$C_MAXRSS];
   struct dsc$descriptor_s descr1 = { 0, 0, 0, 0 };

   name_block = cc$rms_nam;
   name_block.nam$l_rsa = resultant_name;
   name_block.nam$b_rss = NAM$C_MAXRSS;
   name_block.nam$l_esa = expanded_string;
   name_block.nam$b_ess = NAM$C_MAXRSS;

   file_access_block = cc$rms_fab;
   file_access_block.fab$l_fop = FAB$M_NAM;
   file_access_block.fab$l_nam = &name_block;
   file_access_block.fab$l_fna = input_specification;
   file_access_block.fab$l_dna = default_specification;

   file_access_block.fab$b_fns = input_name->dsc$w_length;
   strncpy(input_specification, input_name->dsc$a_pointer,
           input_name->dsc$w_length );
   name_block.nam$b_nop = 0;
   if( parse_flags != 0 ) {
      name_block.nam$b_nop = *parse_flags;
   }

   if( dflt != 0 ) {
      file_access_block.fab$b_dns = dflt->dsc$w_length;
      strncpy( default_specification, dflt->dsc$a_pointer,
               dflt->dsc$w_length );
   }
   else {
      file_access_block.fab$b_dns = 0;
   }

   if( sys$parse( &file_access_block ) != RMS$_NORMAL ) {
      return RMS$_IAL;
   }

   if( node != 0 ) {
      node->dsc$w_length = name_block.nam$b_node;
      strncpy( node->dsc$a_pointer, name_block.nam$l_node,
               name_block.nam$b_node );
   }
   if( device != 0 ) {
      device->dsc$w_length = name_block.nam$b_dev;
      strncpy( device->dsc$a_pointer, name_block.nam$l_dev,
               name_block.nam$b_dev );
   }

   if( directory != 0 ) {
      directory->dsc$w_length = name_block.nam$b_dir;
      strncpy( directory->dsc$a_pointer, name_block.nam$l_dir,
               name_block.nam$b_dir );
   }

   if( file_name != 0 ) {
      file_name->dsc$w_length = name_block.nam$b_name;
      strncpy( file_name->dsc$a_pointer, name_block.nam$l_name,
               name_block.nam$b_name );
   }

   if( file_type != 0 ) {
      file_type->dsc$w_length = name_block.nam$b_type;
      strncpy( file_type->dsc$a_pointer, name_block.nam$l_type,
               name_block.nam$b_type );
   }

   if( file_version != 0 ) {
      file_version->dsc$w_length = name_block.nam$b_ver;
      strncpy( file_version->dsc$a_pointer, name_block.nam$l_ver,
               name_block.nam$b_ver );
   }

   if( file_flags != 0 ) {
      *file_flags = name_block.nam$l_fnb;
   }

   file_access_block.fab$b_dns = 0;
   name_block.nam$l_rlf = 0;
   name_block.nam$b_nop = NAM$V_NOCONCEAL | NAM$V_SYNCHK;
   sys$parse( &file_access_block );

   return SS$_NORMAL;
}

----------------------------------------------------------------------

I called it using the following as a test:

----------------------------------------------------------------------

#include <ssdef.h>
#include <stdio.h>
#include <string.h>
#include <starlet.h>
#include <descrip.h>
#include <rms.h>

#define DEFAULT ((struct dsc$descriptor_s *)0)

int main( void )
{
   void get_descriptor( struct dsc$descriptor_s *descriptor, char
*string );
   extern int scm$parse_fields(
      struct dsc$descriptor_s *input_name,
      struct dsc$descriptor_s *node,
      struct dsc$descriptor_s *device,
      struct dsc$descriptor_s *directory,
      struct dsc$descriptor_s *file_name,
      struct dsc$descriptor_s *file_type,
      struct dsc$descriptor_s *file_version,
      int                     *parse_flags,
      int                     *file_flags,
      struct dsc$descriptor_s *dflt );

   char input_name[NAM$C_MAXRSS] =
           "MY_NODE::SYS$SYSDEVICE:[ME.SOURCE.MYPARSE]MYPARSE.C;1";
   char node[NAM$C_MAXRSS];
   char device[NAM$C_MAXRSS];
   char directory[NAM$C_MAXRSS];
   char file_name[NAM$C_MAXRSS];
   char file_type[NAM$C_MAXRSS];
   char file_version[NAM$C_MAXRSS];
   int  parse_flags = 0;
   int  file_flags = 0;
   char dflt[NAM$C_MAXRSS];
   int  status;
   struct dsc$descriptor_s dsc$input_name;
   struct dsc$descriptor_s dsc$node;
   struct dsc$descriptor_s dsc$device;
   struct dsc$descriptor_s dsc$directory;
   struct dsc$descriptor_s dsc$file_name;
   struct dsc$descriptor_s dsc$file_type;
   struct dsc$descriptor_s dsc$file_version;
   struct dsc$descriptor_s dsc$dflt;

   get_descriptor( &dsc$input_name, input_name );
   get_descriptor( &dsc$node, node );
   get_descriptor( &dsc$device, device );
   get_descriptor( &dsc$directory, directory );
   get_descriptor( &dsc$file_name, file_name );
   get_descriptor( &dsc$file_type, file_type );
   get_descriptor( &dsc$file_version, file_version );
   get_descriptor( &dsc$dflt, dflt );

   status = scm$parse_fields( &dsc$input_name,
                              &dsc$node,
                              &dsc$device,
                              &dsc$directory,
                              &dsc$file_name,
                              &dsc$file_type,
                              &dsc$file_version,
                              &parse_flags,
                              &file_flags,
                              DEFAULT );

   printf( "INPUT NAME: %s\n", dsc$input_name.dsc$a_pointer );
   printf( "NODE: %s\n", dsc$node.dsc$a_pointer );
   printf( "DEVICE: %s\n", dsc$device.dsc$a_pointer );
   printf( "DIRECTORY: %s\n", dsc$directory.dsc$a_pointer );
   printf( "FILE NAME: %s\n", dsc$file_name.dsc$a_pointer );
   printf( "FILE TYPE: %s\n", dsc$file_type.dsc$a_pointer );
   printf( "FILE VERSION: %s\n", dsc$file_version.dsc$a_pointer );
   printf( "DEFAULT: %s\n", dsc$dflt.dsc$a_pointer );

   return status;
}


void get_descriptor( struct dsc$descriptor_s *descriptor, char *string )
{
   descriptor->dsc$w_length = strlen( string );
   descriptor->dsc$a_pointer = string;
   descriptor->dsc$b_class = DSC$K_CLASS_S;
   descriptor->dsc$b_dtype = DSC$K_DTYPE_T;

   return;
}

----------------------------------------------------------------------


Sent via Deja.com http://www.deja.com/
Before you buy.