/*----------------------------------------------------------------*/            
/* tstcaps.c      02/18/2011  Keven Miller   kevenm@3kranger.com  */            
#ifdef   __mpexl                                                                
#pragma list off                                                                
#endif                                                                          
/*------------------------------------------------------------------            
   This demo program shows how to determine if the running program              
   has PH, PM, DS, and/or MR capability.                                        
   The WHO intrinsic returns the caps of the user running a program.            
                                                                                
   Set a system trap when calling intrinsics that require PH, PM and DS         
   capability (like MAIL, FREEDSEG, GETPRIVMODE) and set indicator flags.       
   For MR, use FLOCK twice on a file to.                                        
                                                                                
   setvar ccopts "-Aa -C +e +w1"                                                
   ccxllk tstcaps.c, tstcaps.pub                                                
------------------------------------------------------------------*/            
#include <stdio.h>   /* printf,fprintf */                                       
#include <stdlib.h>  /* exit */                                                 
#include <string.h>  /* strchr */                                               
                                                                                
#pragma intrinsic CCODE             /* for MR check */                          
#pragma intrinsic FCHECK            /* for MR check */                          
#pragma intrinsic FCLOSE            /* for MR check */                          
#pragma intrinsic FOPEN             /* for MR check */                          
#pragma intrinsic FLOCK             /* for MR check */                          
#pragma intrinsic FREEDSEG          /* for DS check */                          
#pragma intrinsic GETPRIVMODE       /* for PM check */                          
#pragma intrinsic MAIL              /* for PH check */                          
#pragma intrinsic FUNLOCK           /* for MR check */                          
#pragma intrinsic XSYSTRAP          /* trap set */                              
                                                                                
#define  proc                                                                   
#define  VERSION           "E.00.00"                                            
#define  MPE_CCE           2                                                    
                                                                                
#ifndef  S16                                                                    
#define  S16                                                                    
typedef  unsigned short u16;                                                    
typedef           short s16;                                                    
typedef  unsigned int   u32;                                                    
typedef           int   s32;                                                    
typedef           float f32;                                                    
typedef          double f64;                                                    
#endif                                                                          
                                                                                
/*----------------------------------------------------------------*/            
int   trap_noph;                                                                
int   trap_nopm;                                                                
int   trap_nods;                                                                
int   trap_nomr;                                                                
                                                                                
proc void trapsys (s32 code, s32 intr, s32 err, s32 parm)                       
{                                                                               
   int   rtv;                                                                   
                                                                                
   rtv = 0;                                                                     
   if (code == 1003)                                                            
   {                                                                            
/* switch on called intrinsic */                                                
      switch (intr)                                                             
      {                                                                         
      case 106:   /* set 5 msg 106 MAIL */                                      
/* err=254  parm=255 (err should be 2) */                                       
         trap_noph = 1;                                                         
         rtv = 1;                                                               
         break;                                                                 
                                                                                
      case 131:   /* set 5 msg 131 FREEDSEG */                                  
/* err=2 parm=0   set 6 msg 2 ILLEGAL CAPABILITY */                             
         trap_nods = 1;                                                         
         rtv = 1;                                                               
         break;                                                                 
                                                                                
      case 200:   /* set 5 msg 200 GETPRIVMODE */                               
/* err=2 parm=0   set 6 msg 2 ILLEGAL CAPABILITY */                             
         trap_nopm = 1;                                                         
         rtv = 1;                                                               
      }                                                                         
   }                                                                            
                                                                                
   if ( ! rtv )                                                                 
   {                                                                            
      fprintf (stderr, "TrapSys code %d intr %d err %d parm %d\n",              
         code, intr, err, parm);                                                
      exit (9);                                                                 
   }                                                                            
}                                                                               
/*----------------------------------------------------------------*/            
                                                                                
proc int test_progcaps (void)                                                   
{                                                                               
   int   old, fn1, fn2;                                                         
   s16   slen;                                                                  
                                                                                
/* check for required CAPS */                                                   
   XSYSTRAP ((int) &trapsys, &old);                                             
                                                                                
   trap_noph = trap_nopm = trap_nods = 0;                                       
                                                                                
/*------------------*/                                                          
/* check for PH caps - MAIL intrinsic requires PH */                            
   old = MAIL (0, &slen);                                                       
                                                                                
/*------------------*/                                                          
/* check for DS caps - FREEDSEG requires DS */                                  
   FREEDSEG (0, 0);                                                             
                                                                                
/*------------------*/                                                          
/* check for MR caps - FLOCK twice requires MR */                               
   trap_nomr = -1;   /* assume error */                                         
   fn1 = fn2 = 0;                                                               
   do                                                                           
   {                                                                            
      fn1 = FOPEN ("STDNEW", 024, 041);  /* $NEW,ASC,NEW LCK,WR */              
      if (CCODE () != MPE_CCE)                                                  
      {                                                                         
         FCHECK (fn1, &slen);                                                   
         printf ("** MR check FOPEN-1 fserr %d\n", slen);                       
         break;                                                                 
      }                                                                         
      fn2 = FOPEN ("STDNEW", 024, 041);                                         
      if (CCODE () != MPE_CCE)                                                  
      {                                                                         
         FCHECK (fn2, &slen);                                                   
         printf ("** MR check FOPEN-2 fserr %d\n", slen);                       
         break;                                                                 
      }                                                                         
                                                                                
/* get first lock */                                                            
      FLOCK (fn1, 0);                                                           
      if (CCODE () != MPE_CCE)                                                  
      {                                                                         
         FCHECK (fn1, &slen);                                                   
         printf ("** MR check FLOCK-1 fserr %d\n", slen);                       
         break;                                                                 
      }                                                                         
                                                                                
/* try second lock or MR */                                                     
      FLOCK (fn2, 0);                                                           
      if (CCODE () != MPE_CCE)                                                  
      {                                                                         
         FCHECK (fn2, &slen);                                                   
         if (slen == 64)                                                        
            trap_nomr = 1;                                                      
         else                                                                   
            printf ("** MR check FLOCK-2 fserr %d\n", slen);                    
         break;                                                                 
      }                                                                         
      trap_nomr = 0;                                                            
   } while (0);                                                                 
/* cleanup */                                                                   
   if (fn2)                                                                     
   {                                                                            
      FUNLOCK (fn2);                                                            
      FCLOSE (fn2,0,0);                                                         
   }                                                                            
   if (fn1)                                                                     
   {                                                                            
      FUNLOCK (fn1);                                                            
      FCLOSE (fn1,0,0);                                                         
   }                                                                            
                                                                                
/*------------------*/                                                          
/* check for PM caps - GETPRIVMODE requires PM */                               
   GETPRIVMODE ();         /* PM Test */                                        
/* No need to call GETUSERMODE since return from procedure does that */         
                                                                                
   return   0;                                                                  
}                                                                               
/*----------------------------------------------------------------*/            
                                                                                
proc int main (int ac, char *av[])                                              
{                                                                               
   int   rtv;                                                                   
   char  *cp, *pg;                                                              
                                                                                
   pg = av [0];                                                                 
   cp = strchr (pg, '.');                                                       
   if (cp) *cp = 0;                                                             
                                                                                
   printf ("%s  %s\n", pg, VERSION);                                            
   rtv = 0;                                                                     
                                                                                
   test_progcaps ();                                                            
                                                                                
   if (trap_noph)                                                               
   {                                                                            
      printf ("%s: Needs PH capability!\n", pg);                                
      rtv = 1;                                                                  
   }                                                                            
   else                                                                         
      printf ("%s: Has PH\n", pg);                                              
                                                                                
                                                                                
   if (trap_nopm)                                                               
   {                                                                            
      printf ("%s: Needs PM capability!\n", pg);                                
      rtv = 1;                                                                  
   }                                                                            
   else                                                                         
      printf ("%s: Has PM\n", pg);                                              
                                                                                
                                                                                
   if (trap_nods)                                                               
   {                                                                            
      printf ("%s: Needs DS capability!\n", pg);                                
      rtv = 1;                                                                  
   }                                                                            
   else                                                                         
      printf ("%s: Has DS\n", pg);                                              
                                                                                
                                                                                
   if (trap_nomr > 0)                                                           
   {                                                                            
      printf ("%s: Needs MR capability!\n", pg);                                
      rtv = 1;                                                                  
   }                                                                            
   else if (trap_nomr < 0)                                                      
   {                                                                            
      printf ("%s: MR test failed with file error!\n", pg);                     
      rtv = 2;                                                                  
   }                                                                            
   else                                                                         
      printf ("%s: Has MR\n", pg);                                              
                                                                                
   return   rtv;                                                                
}                                                                               
/*----------------------------------------------------------------*/