home *** CD-ROM | disk | FTP | other *** search
/ vsiftp.vmssoftware.com / VSIPUBLIC@vsiftp.vmssoftware.com.tar / FREEWARE / FREEWARE40.ZIP / callmon / src / example_shr_main.c < prev    next >
C/C++ Source or Header  |  1996-08-06  |  4KB  |  157 lines
  1. /*  CALLMON Examples
  2.  *
  3.  *  File:     EXAMPLE_SHR_MAIN.C
  4.  *  Author:   Thierry Lelegard
  5.  *  Version:  1.0
  6.  *  Date:     24-JUL-1996
  7.  *
  8.  *  Abstract: Calls the shareable image EXAMPLE_SHR.EXE.
  9.  */
  10.  
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <ssdef.h>
  15. #include <stsdef.h>
  16. #include <pdscdef.h>
  17. #include <libicb.h>
  18. #include <starlet.h>
  19. #include <lib$routines.h>
  20. #include "callmon.h"
  21.  
  22. extern int shr_proc ();
  23. void end_of_main (void);
  24.  
  25. #define entry_of(routine) (((struct pdscdef*)(routine))->pdsc$l_entry)
  26.  
  27.  
  28. /*
  29.  *  Pre- and post-processing routine for CALLMON.
  30.  *  Simply trace arguments.
  31.  */
  32.  
  33. static void trace (
  34.     callmon$arguments_t* arguments,
  35.     uint32               caller_invo_handle,
  36.     char*                routine_name,
  37.     uint64               (*intercepted_routine)(),
  38.     uint64               (*jacket_routine)())
  39. {
  40.     int arg;
  41.     struct invo_context_blk invo;
  42.  
  43.     printf ("%s calling %s at %08X, jacket at %08X\n",
  44.         arguments->post_processing ? "AFTER" : "BEFORE",
  45.         routine_name,
  46.         intercepted_routine,
  47.         jacket_routine);
  48.  
  49.     /* In preprocessing phase, display caller information */
  50.  
  51.     if (!arguments->post_processing) {
  52.  
  53.         /* Display argument list */
  54.  
  55.         for (arg = 0; arg < arguments->arg_count; arg++) {
  56.             printf ("    arg%-2d = %016LX (%e)\n", arg + 1,
  57.                 arguments->arg_list [arg], arguments->arg_list [arg]);
  58.         }
  59.  
  60.         /* Display caller's PC */
  61.  
  62.         if (lib$get_invo_context (caller_invo_handle, &invo))
  63.             printf ("Caller PC = %08X\n", invo.libicb$q_program_counter [0]);
  64.         else
  65.             printf ("Invalid caller handle: %08X\n", caller_invo_handle);
  66.     }
  67.  
  68.     /* In post-processing phase, display the results */
  69.  
  70.     else {
  71.         printf ("    Result R0 = %016LX\n", arguments->result_r0);
  72.         printf ("    Result R1 = %016LX\n", arguments->result_r1);
  73.         printf ("    Result F0 = %016LX\n", arguments->result_f0);
  74.         printf ("    Result F1 = %016LX\n", arguments->result_f1);
  75.     }
  76. }
  77.  
  78.  
  79. /*
  80.  *  Pre--processing routine for CALLMON.
  81.  *  Modify some parameters in the argument list.
  82.  */
  83.  
  84. static void modify_arglist (
  85.     callmon$arguments_t* arguments,
  86.     uint32               caller_invo_handle,
  87.     char*                routine_name,
  88.     uint64               (*intercepted_routine)(),
  89.     uint64               (*jacket_routine)())
  90. {
  91.     printf ("Before calling %s, setting a1 to 75 and a9 to 96\n", routine_name);
  92.  
  93.     arguments->arg_list [0] = 75;
  94.     arguments->arg_list [8] = 96;
  95. }
  96.  
  97.  
  98. /*
  99.  *  Pre--processing routine for CALLMON.
  100.  *  Skip actual procedure call.
  101.  */
  102.  
  103. static void skip_call (
  104.     callmon$arguments_t* arguments,
  105.     uint32               caller_invo_handle,
  106.     char*                routine_name,
  107.     uint64               (*intercepted_routine)(),
  108.     uint64               (*jacket_routine)())
  109. {
  110.     arguments->call_it = 0;
  111.     arguments->result_r0 = 1234;
  112.  
  113.     printf ("Skip call to %s, setting result to %d (0x%08X)\n",
  114.         routine_name, arguments->result_r0, arguments->result_r0);
  115. }
  116.  
  117.  
  118. /*
  119.  *  Test program entry point.
  120.  */
  121.  
  122. main ()
  123. {
  124.     uint32 status;
  125.  
  126.     /* First test: simple trace */
  127.  
  128.     status = callmon$intercept ("SHR_PROC", trace, trace);
  129.     if (!$VMS_STATUS_SUCCESS (status))
  130.         sys$exit (status);
  131.  
  132.     printf ("First test: simple trace\n");
  133.     printf ("Caller code range: %08X-%08X\n",
  134.         entry_of (main), entry_of (end_of_main));
  135.     shr_proc (1, 2.0, 3, 4.0, 5, 6.0, 7, 8.0, 9, 10.0);    
  136.  
  137.     /* Second test: modify argument list */
  138.  
  139.     status = callmon$intercept ("SHR_PROC", modify_arglist, trace);
  140.     if (!$VMS_STATUS_SUCCESS (status))
  141.         sys$exit (status);
  142.  
  143.     printf ("Second test: modify some parameters\n");
  144.     shr_proc (1, 2.0, 3, 4.0, 5, 6.0, 7, 8.0, 9, 10.0);    
  145.  
  146.     /* Third test: skip routine call */
  147.  
  148.     status = callmon$intercept ("SHR_PROC", skip_call, trace);
  149.     if (!$VMS_STATUS_SUCCESS (status))
  150.         sys$exit (status);
  151.  
  152.     printf ("Third test: skip actual call\n");
  153.     shr_proc (1, 2.0, 3, 4.0, 5, 6.0, 7, 8.0, 9, 10.0);    
  154. }
  155.  
  156. void end_of_main (void) {}
  157.