home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 322_01 / ramtest1.c < prev    next >
C/C++ Source or Header  |  1990-08-06  |  21KB  |  733 lines
  1. /*------------------------------------------------------
  2.  
  3.                       Mohammad Khurrum
  4.                             and
  5.                       Dean Lance Smith
  6.                Dept. of Electrical Engineering
  7.                   Memphis State University
  8.                       Memphis, TN 38152
  9.                        (901) 678-3253
  10.                        (901) 678-2175
  11.  
  12.  This program is an implementation of the ATS
  13.  (Algorithmic Testing Sequence) algorithm.  It was
  14.  compiled with TURBOC 1.5 on MS DOS.  The program tests
  15.  RAM for any single or multiple stuck-at-0 or stuck-at-1
  16.  faults.
  17.  
  18.  The inputs to the program are the starting and ending
  19.  addresses of any part of the Random Access Memory.  The
  20.  output is the address of the location where the fault
  21.  occurs and also the type of fault that occurs (stuck-
  22.  at-0 or stuck-at-1).  A message is displayed if no
  23.  fault is detected.
  24.  
  25.  The ATS procedure works only if the decoder is
  26.  noncreative wired-OR logic.  These restrictions do not
  27.  apply to the ATS+ procedure.  See R. Nair, "Comments on
  28.  An Optimal Algorithm for Testing Stuck-at Faults in
  29.  Random Access Memories," IEEE Trans.  Comput., vol.  C-
  30.  28, pp. 258-261.  Mar.  1979.
  31.  
  32.  The algorithms are written as two separate functions
  33.  ats() and atst().  The ats() function has eight steps.
  34.  The atst() function has thirteen steps.  Some of these
  35.  steps write a pattern into memory and others read
  36.  memory to check for faults.  RAM is divided into three
  37.  sections, g0, g1 and g2.  For both algorithms g0, g1,
  38.  g2, start and end are declared as huge pointers.  Huge
  39.  pointers are 32-bit pointers that are unique to TurboC.
  40.  
  41.  The function hex() reads the starting and ending
  42.  addresses from the keyboard in the form segment :
  43.  offset where segment and offset are in hexadecimal.
  44.  The function converts the addresses to binary values
  45.  and far pointers.  A far (32-bit) pointer contains not
  46.  only the offset but also a 16-bit segment address.  Far
  47.  pointers permit multiple code segments and allow access
  48.  to memories larger than 64K bytes.
  49.  
  50.  The functions st() and en() are 8086 dependent.  These
  51.  functions make far pointers for the starting and ending
  52.  addresses.  The functions clear() and deb() are MS DOS
  53.  dependent.
  54.  ------------------------------------------------------
  55. */
  56.  
  57. #include <stdio.h>
  58. #include<dos.h>
  59. #define MAXVAL 255 /* Maximum size of an input line. */
  60.  
  61. /*-----------------------------------------------------
  62.                     THE MAIN PROGRAM
  63.  
  64.  The main routine prints a menu and permits the user to
  65.  select an operation.  It then calls the test routine
  66.  selected (ats() or atst()) or exits.
  67.  ------------------------------------------------------
  68. */
  69.  
  70. main() {
  71.  unsigned char huge *st();
  72.  unsigned char huge *en();
  73.  unsigned char huge *start; /* Starting and Ending    */
  74.  unsigned char huge *end;   /* address.               */
  75.  
  76.  int c, q;     /* Characters being read from keyboard.*/
  77.  int fault_count;
  78.  
  79.  do
  80.   {menu();
  81.    c = getchar();
  82.    if(c == '1'|| c == '2') {
  83.      start = st(); /* Get starting and ending address.*/
  84.      end = en();
  85.      if(start > end){
  86.       do
  87.        {message(start, end);
  88.         start = st();
  89.         end = en();}
  90.       while(start>end);}
  91.       message(start, end);
  92.      if(c == '1')
  93.        fault_count = ats(start, end); /* Run ATS test */
  94.      else
  95.        fault_count = atst(start, end);/* Run ATS+ test*/
  96.      if(fault_count > 0)
  97.        printf("\n%d Faults detected.\n",fault_count);
  98.      else
  99.        printf("\n\t\tNO FAULTS DETECTED-RAM TESTS OK!");
  100.      printf("\n\n\nDepress any key to go back to the");
  101.      printf(" menu..");
  102.      getch();
  103.          }
  104.    else if(c == '3'){
  105.      clear();
  106.      type();
  107.       }
  108. else
  109.       clear();                        /* clear screen.*/
  110.  }
  111.  while(c != '4');
  112. }
  113. /*--------------------MAIN ENDS-------------------------
  114.  
  115.  
  116.  
  117.                     THE ATS PROCEDURE
  118.  
  119. This routine tests RAM with the ATS algorithm.  The
  120. routine detects any single or multiple stuck-at-faults
  121. in RAM.  Control is transferred to an error routine if a
  122. fault is detected.  The declarations for start, end, g0,
  123. g1 and g2 are unique to TURBOC.  The algorithm is by J.
  124. Knaizuk, Jr. and C.R.P Hartman, "An Optimal Algorithm
  125. For Testing Stuck-at Faults in Random Access Memories,"
  126. IEEE Trans.  Comput., vol. C-26, pp. 1141-1144, Nov.
  127. 1977.
  128. -------------------------------------------------------
  129. */
  130. ats(start, end)
  131.  
  132.  unsigned char huge *start;/* Starting and ending     */
  133.  unsigned char huge *end;  /* addresses.              */
  134.  
  135.  {  /*       g0, g1 & g2 point to each partition.     */
  136.  unsigned char huge *g0;
  137.  unsigned char huge *g1;
  138.  unsigned char huge *g2;
  139.  
  140.  unsigned char dummy;
  141.  int fault;                            /* fault count */
  142.  
  143.    fault = 0;
  144.  
  145.    g0 = start;    /* Starting Address of partition 0. */
  146.    g1 = start + 1;/* Starting Address of partition 1. */
  147.    g2 = start + 2;/* Starting Address of partition 2. */
  148. /*------------------------------------------------------
  149.  Step 1.   Write 0 in all locations in partitions 1 & 2.
  150.  -------------------------------------------------------
  151. */
  152.  
  153.  while((g1 <= end) || (g2 <= end))
  154.    {
  155.       *g1 = 0x00;
  156.       g1 = g1 + 3;
  157.       if(g2 <= end){
  158.         *g2 = 0x00;
  159.         g2 = g2 + 3;  }
  160.    }
  161. /*------------------------------------------------------
  162.  Step 2.   Write 1's in all locations in partition 0.
  163.  -------------------------------------------------------
  164. */
  165.  
  166.   while(g0 <= end)
  167.       {
  168.          *g0 = 0xff;
  169.          g0 = g0 + 3;
  170.        }
  171.  
  172. /*------------------------------------------------------
  173.  Step 3.  Read all locations in partition 1.
  174.  -------------------------------------------------------
  175. */
  176.  
  177.    g1 = start + 1;
  178.    while(g1 <= end)
  179.       {
  180.          dummy = *g1;
  181.          if(dummy != 0x00){
  182.             error(dummy, g1, 1);
  183.             fault = fault + 1;}
  184.          g1 = g1 + 3;
  185.       }
  186.  
  187. /*------------------------------------------------------
  188.  Step 4.   Write 1's in all locations in partition 1.
  189.  -------------------------------------------------------
  190. */
  191.  
  192.    g1 = start + 1;
  193.    while(g1 <= end)
  194.       {
  195.       *g1 = 0xff;
  196.        g1 = g1 + 3;
  197.       }
  198.  
  199. /*------------------------------------------------------
  200.  Step 5.   Read all locations in partition 2.
  201.  -------------------------------------------------------
  202. */
  203.  
  204.    g2 = start + 2;
  205.    while(g2 <= end)
  206.       {  dummy = *g2;
  207.          if(dummy != 0x00){
  208.             error(dummy, g2, 1);
  209.             fault = fault + 1;}
  210.          g2 = g2 + 3;
  211.       }
  212.  
  213.  
  214. /*------------------------------------------------------
  215.  Step 6.   Read all locations in partitions 0 and 1.
  216.  -------------------------------------------------------
  217. */
  218.  
  219.    g0 = start;
  220.    g1 = start + 1;
  221.    while((g0 <= end) || (g1 <= end))
  222.       {
  223.          dummy = *g0;
  224.          if(dummy != 0xff){
  225.             error(dummy, g0, 0);
  226.             fault = fault + 1;}
  227.             g0 = g0 + 3;
  228.  
  229.          if(g1 <= end){
  230.            dummy = *g1;
  231.            if(dummy != 0xff){
  232.              error(dummy, g1, 0);
  233.              fault = fault + 1;}
  234.            g1 = g1 + 3;  }
  235.       }
  236.  
  237. /*------------------------------------------------------
  238.  Step 7.   Write 0 into each location in partition 0 and
  239.  read the location.
  240.  -------------------------------------------------------
  241. */
  242.  
  243.    g0 = start;
  244.    while(g0 <= end)
  245.       {
  246.          *g0 = 0x00;
  247.          dummy = *g0;
  248.          if(dummy != 0x00){
  249.             error(dummy, g0, 1);
  250.             fault = fault + 1;}
  251.          g0 = g0 + 3;
  252.       }
  253.  
  254. /*------------------------------------------------------
  255.  Step 8.   Read all locations in partition 2.
  256.  -------------------------------------------------------
  257. */
  258.  
  259.    g2 = start + 2;
  260.    while(g2 <= end)
  261.       {
  262.          *g2 = 0xff;
  263.          dummy = *g2;
  264.          if(dummy != 0xff){
  265.             error(dummy, g2, 0);
  266.             fault = fault + 1;}
  267.          g2 = g2 + 3;
  268.       }
  269.  
  270.  
  271.    return(fault);     /* Return the total # of faults.*/
  272. }
  273. /*------------------------------------------------------
  274.  
  275.  
  276.  
  277.  
  278.  
  279.                    THE ATS+ PROCEDURE
  280.  
  281. This routine tests RAM with the ATS+ algorithm.  The
  282. routine detects any single or multiple stuck-at-faults
  283. in RAM.  Control is transferred to an error routine if a
  284. fault is detected.  The declarations for start, end, g0,
  285. g1 and g2 are unique to Turbo C.  The algorithm is by R.
  286. Nair, "Comments on An Optimal Algorithm for Testing
  287. Stuck-at Faults in Random Access Memories," IEEE Trans.
  288. Comput., vol.  C-28, pp.  258- 261.  Mar.  1979.
  289. --------------------------------------------------------
  290. */
  291. atst(start, end)
  292.  
  293.  unsigned char huge *start;/* Starting and ending     */
  294.  unsigned char huge *end;  /* addresses.              */
  295.  
  296.  { /* g0, g1 and g2 partition memory into three parts.*/
  297.  unsigned char huge *g0;
  298.  unsigned char huge *g1;
  299.  unsigned char huge *g2;
  300.  
  301.  unsigned char dummy;
  302.  int fault;                            /* fault count */
  303.  
  304.    fault = 0;
  305.  
  306.    g0 = start;    /* Starting Address of partition 0. */
  307.    g1 = start + 1;/* Starting Address of partition 1. */
  308.    g2 = start + 2;/* Starting Address of partition 2. */
  309. /*------------------------------------------------------
  310.  Step 1.   Write 0 in all locations in partition 1.
  311.  -------------------------------------------------------
  312. */
  313.  
  314.    while((g1 <= end) )
  315.       {
  316.          *g1 = 0x00;
  317.          g1 = g1 + 3;
  318.       }
  319.  
  320. /*------------------------------------------------------
  321.  Step 2.   Write 0 in all locations in partition 2.
  322.  -------------------------------------------------------
  323. */
  324.  
  325.    while((g2 <= end) )
  326.       {
  327.          *g2 = 0x00;
  328.          g2 = g2 + 3;
  329.       }
  330.  
  331. /*------------------------------------------------------
  332.  Step 3.   Write 1's in all locations in partition 0.
  333.  -------------------------------------------------------
  334. */
  335.  
  336.    while(g0 <= end)
  337.       {
  338.          *g0 = 0xff;
  339.          g0 = g0 + 3;
  340.       }
  341.  
  342. /*------------------------------------------------------
  343.  Step 4.   Read all locations in partition 1.
  344.  -------------------------------------------------------
  345. */
  346.  
  347.    g1 = start + 1;
  348.    while(g1 <= end)
  349.       {  dummy = *g1;
  350.          if(dummy != 0x00){
  351.             error(dummy, g1, 1);
  352.             fault = fault + 1;}
  353.  
  354.          g1 = g1 + 3;
  355.       }
  356.  
  357. /*------------------------------------------------------
  358.  Step  5.   Write 1's in all locations in partition 1.
  359.  -------------------------------------------------------
  360. */
  361.  
  362.    g1 = start + 1;
  363.    while(g1 <= end)
  364.       {
  365.          *g1 = 0xff;
  366.          g1 = g1 + 3;
  367.       }
  368.  
  369.  
  370.  
  371.  
  372.  
  373. /*------------------------------------------------------
  374.  Step 6.   Read all locations in partition 2.
  375.  -------------------------------------------------------
  376. */
  377.  
  378.    g2 = start + 2;
  379.    while(g2 <= end)
  380.       {  dummy = *g2;
  381.          if(dummy != 0x00){
  382.             error(dummy, g2, 1);
  383.             fault = fault + 1;}
  384.  
  385.          g2 = g2 + 3;
  386.       }
  387.  
  388. /*------------------------------------------------------
  389.  Step 7.   Write 1's in all locations in partition 2.
  390.  -------------------------------------------------------
  391. */
  392.  
  393.    g2 = start + 2;
  394.    while((g2 <= end) )
  395.       {
  396.          *g2 = 0xff;
  397.          g2 = g2 + 3;
  398.       }
  399.  
  400. /*------------------------------------------------------
  401.  Step 8.   Read all locations in partition 0.
  402.  -------------------------------------------------------
  403. */
  404.  
  405.    g0 = start;
  406.    while( (g0 <= end))
  407.       {  dummy = *g0;
  408.          if(dummy != 0xff){
  409.             error(dummy, g0, 0);
  410.             fault = fault + 1;}
  411.          g0 = g0 + 3;
  412.       }
  413.  
  414. /*------------------------------------------------------
  415.  Step 9.   Write 0 in all locations in partition 0.
  416.  -------------------------------------------------------
  417. */
  418.  
  419.    g0 = start;
  420.    while(g0 <= end)
  421.       {
  422.          *g0 = 0x00;
  423.          g0 = g0 + 3;
  424.       }
  425.  
  426. /*------------------------------------------------------
  427.  Step 10.   Read all locations in partition 1.
  428.  -------------------------------------------------------
  429. */
  430.  
  431.    g1 = start + 1;
  432.    while(g1 <= end)
  433.       {
  434.          *g1 = 0xff;
  435.          dummy = *g1;
  436.          if(dummy != 0xff){
  437.             error(dummy, g1, 0);
  438.             fault = fault + 1;}
  439.          g1 = g1 + 3;
  440.       }
  441.  
  442. /*------------------------------------------------------
  443.  Step 11.   Write 0 in all locations in partition 1.
  444.  -------------------------------------------------------
  445. */
  446.  
  447.    g1 = start + 1;
  448.    while(g1 <= end)
  449.       {
  450.          *g1 = 0x00;
  451.          g1 = g1 + 3;
  452.       }
  453.  
  454. /*------------------------------------------------------
  455.  Step 12.   Read all locations in partition 2.
  456.  -------------------------------------------------------
  457. */
  458.  
  459.    g2 = start + 2;
  460.    while(g2 <= end)
  461.       {  dummy = *g2;
  462.          if(dummy != 0xff){
  463.             error(dummy, g2, 0);
  464.             fault = fault + 1;}
  465.  
  466.          g2 = g2 + 3;
  467.       }
  468.  
  469. /*------------------------------------------------------
  470.  Step 13.    Read all locations in partition 0.
  471.  -------------------------------------------------------
  472. */
  473.  
  474.    g0 = start  ;
  475.    while( (g0 <= end))
  476.       {  dummy = *g0;
  477.          if(dummy != 0x00){
  478.             error(dummy, g0, 1);
  479.             fault = fault + 1;}
  480.  
  481.          g0 = g0 + 3;
  482.       }
  483.  
  484.    return(fault);              /* Return fault count. */
  485.  
  486. }
  487.  
  488. /*----------------------------------------------------*/
  489.  
  490.  
  491.  
  492. /*------------------------------------------------------
  493.  Prints a menu on the screen and prompt the user to
  494.  select an option.
  495.  -------------------------------------------------------
  496. */
  497. menu()
  498.  {
  499.  
  500.   clear();                         /*  Clear screen.  */
  501.  
  502.   printf("\n\n\n\n\n\t\t\tTHE RAM TESTER\n");
  503.   printf("\n\n\n\t\t1. TEST RAM USING THE ATS ");
  504.   printf("PROCEDURE\n");
  505.  
  506.   printf("\t\t2. TEST RAM USING THE ATS+ PROCEDURE\n");
  507.   printf("\t\t3. A BRIEF DESCRIPTION OF THE PROGRAM\n");
  508.   printf("\t\t4. EXIT THE RAM TESTER\n\n\n\n");
  509.   printf("\tPlease enter the option number of your");
  510.   printf(" choice.\n");
  511.  
  512.  }
  513.  
  514. /*------------------------------------------------------
  515.  This function makes a far pointer and assigns it to
  516.  start.
  517.  -------------------------------------------------------
  518. */
  519. unsigned char huge *st()
  520. {
  521.  
  522.  unsigned char huge *start;
  523.  
  524.  int seg1; /* Segment value of the starting address.  */
  525.  int off1; /* Offset value of the starting address.   */
  526.  
  527.    printf("\n Starting address segment = ");
  528.    seg1 = hex();    /* Get segment of the starting
  529.                        address.*/
  530.    printf(" offset = ");
  531.    off1 = hex();    /* Get offset of the starting
  532.                        address.*/
  533.    start = MK_FP(seg1, off1);/* Make far pointers.
  534.                         MK_FP is a Turbo C macro that
  535.                         makes far pointers from its
  536.                         segment and offset components.*/
  537.    return(start);      /* Return the starting address.*/
  538.   }
  539.  
  540. /*------------------------------------------------------
  541.  This function makes a far pointer and assigns it to
  542.  end.
  543.  -------------------------------------------------------
  544. */
  545. unsigned char huge *en()
  546. {
  547.  
  548.  unsigned char huge *end;
  549.  
  550.  int seg1;     /* Segment value of the ending address.*/
  551.  int off1;     /* Offset value of the ending address. */
  552.  
  553.    printf("\n Ending address segment   = ");
  554.    seg1 = hex(); /* Get segment of the ending address.*/
  555.  
  556.    printf(" offset = ");
  557.    off1 = hex();  /* Get offset of the ending address.*/
  558.  
  559.    end = MK_FP(seg1, off1);    /* Make far pointers.  */
  560.    return(end);          /* Return the ending address.*/
  561.   }
  562.  
  563. /*------------------------------------------------------
  564.  This function gets a four character hexadecimal number
  565.  from the keyboard.  It expects lead zeros.  The string
  566.  is converted to binary and returned. This function also
  567.  checks to see if the segment/offset is 4 characters
  568.  long and is a valid hexadecimal number.  It gives an
  569.  error message and lets the user enter the
  570.  segment/offset value again if the segment/offset is not
  571.  4 characters or if any of the characters are not
  572.  hexadecimal.
  573.  -------------------------------------------------------
  574. */
  575.  int hex()
  576.  {
  577.  
  578.  int n;                           /* Converted value. */
  579.  int count;                            /* Error flag. */
  580.  char c;        /* Characters read from the keyboard. */
  581.  
  582.    n = 1;
  583.  do
  584.   {
  585.    count = 0;
  586.    while((((c=getch())>='0'&&c<='9') ||(c>='A'&&c<='F')
  587.                    ||(c>= 'a'&& c<='f') )&&count <4)
  588.       {
  589.          putch(c);    /* Outputs character to screen. */
  590.          count = count + 1;
  591.          if(c >= '0' && c<= '9')
  592.             n = 16*n + c - '0';
  593.          if(c >= 'A' && c <= 'F')
  594.             n = 16*n + 10 + c - 'A';
  595.          if(c>='a' && c <= 'f')
  596.             n = 16*n + 10 +c -'a';
  597.       }
  598.    if(count!=4) {
  599.       printf("\n ERROR.   \nPlease enter a");
  600.       printf(" 4-character hexadecimal number:");}
  601.       }
  602.    while(count<4);
  603.  
  604.    return(n);
  605. }
  606.  
  607. /*-----------------------------------------------------
  608.  Function message() displays a message to wait if the
  609.  memory under test is large.
  610.  ------------------------------------------------------
  611. */
  612. message(start, end)
  613.  
  614. unsigned char huge *start; /* Starting and Ending    */
  615. unsigned char huge *end;   /* address.               */
  616.  
  617. {  if(end > start + 512 )
  618.       printf("\n\n Please wait.  \n");
  619.    if(start > end){
  620.      clear();
  621.      printf("\n\nError in assigning addresses.\n");
  622.      printf("Starting address > Ending address\n\n");}
  623.  }
  624.  
  625. /*------------------------------------------------------
  626.  This function is system dependent.  It clears the
  627.  screen.
  628.  -------------------------------------------------------
  629. */
  630. clear()
  631. {
  632.  system("cls");                       /* clear screen.*/
  633. }
  634.  
  635. /*------------------------------------------------------
  636.  This function displays the data in file 'desc.dat' on
  637.  the screen.  Twenty lines of text are displayed at a
  638.  time.  The user can press any key to display more text.
  639.  -------------------------------------------------------
  640. */
  641. type()
  642. {
  643.  
  644.  FILE *fp, *fopen();    /* File pointer declarations. */
  645.  char line[MAXVAL];     /* Lines read from the file.  */
  646.  int count, letter, i;  /* Flags to indicate error.   */
  647.  
  648.   count = 0;  i = 0;
  649.  
  650. /*               Open data file desc.dat.             */
  651.  do
  652.   {i = i + 1;
  653.    if((fp = fopen("desc.dat", "r")) == NULL){
  654.      printf("\nError opening desc.dat\n");
  655.      printf("Insert new disk and press return\n");
  656.      printf("or enter Q to quit\n\n");
  657.      letter = getch();
  658.      putch(letter); }}
  659.   while((letter!='Q'&&letter!='q'&&fp==NULL)&&(i<3));
  660.   if(fp==NULL && letter != 'Q'&& letter != 'q'){
  661.      printf("\n\nSorry file not found...\n");
  662.      getch();}
  663.   if(fp != NULL){
  664.      while(fgets(line, MAXVAL, fp) != NULL){
  665.         count = count + 1;
  666.         printf("%s", line);
  667.         if(count == 20){
  668.            getch();
  669.            clear();
  670.            count = 0;} }
  671.      getch();
  672.      fclose(fp);}
  673.   return(1);
  674. }
  675.  
  676. /*------------------------------------------------------
  677.  This routine prints an error message during the
  678.  execution of the ats() and atst() functions.  The user
  679.  may decide whether to continue the calling routine,
  680.  abort the program or look at memory using a debug
  681.  program.
  682.  -------------------------------------------------------
  683. */
  684. error(a, b, error_type)
  685.  
  686. char a;                /* Contents of memory location.*/
  687. unsigned char huge *b; /* Pointer to the memory
  688.                           location.*/
  689. int error_type;      /* Type of error, S-a-0 or S-a-1.*/
  690.  {
  691.  
  692.   int j;          /* Character read from the keyboard.*/
  693.  
  694.    do
  695.    {  clear();
  696.       printf(" Please enter one of the options \n");
  697.       printf("\n%x   = content at location %Fp", a, b);
  698.       printf("\n Error in address (segment:offset) =");
  699.       printf(" %Fp - stuck at %d\n\n", b, error_type);
  700.       printf("\t 1. Ignore the error and continue.\n");
  701.       printf("\t 2. Examine memory with debug. \n");
  702.       printf("\t 3. Quit.  \n ");
  703.       j = getch();
  704.    }
  705.    while(j!='1' && j!='2' && j!='3');
  706.  
  707.    if(j == '2')
  708.       deb();
  709.    if(j == '3')
  710.       exit(1);
  711.  
  712.    return(1);    /* Return to calling routine to ignore
  713.                     the fault and continue with the
  714.                     test.  */
  715.  
  716. }
  717.  
  718. /*------------------------------------------------------
  719.  Function deb() helps the user to use the MS DOS debuger
  720.  (debug) to look at the memory.
  721.  -------------------------------------------------------
  722. */
  723. deb()
  724.  {
  725.    printf("\n\n\n");
  726.    printf("At the '-'prompt enter '-dsegment:offset'");
  727.    printf(" 'offset' of ");
  728.    printf(" the block \nof memory to be viewed\n");
  729.    printf("For example -d8000:0000 000f to view ");
  730.    printf("locations or -q to quit\n\n");
  731.    system("debug");
  732.   }
  733.