home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / utils / amd-udi / mondfe / dump.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-23  |  40.7 KB  |  1,483 lines
  1. static char _[] = " @(#)dump.c    5.20 93/07/30 16:38:27, Srini, AMD ";
  2. /******************************************************************************
  3.  * Copyright 1991 Advanced Micro Devices, Inc.
  4.  *
  5.  * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
  6.  * specifically  grants the user the right to modify, use and distribute this
  7.  * software provided this notice is not removed or altered.  All other rights
  8.  * are reserved by AMD.
  9.  *
  10.  * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
  11.  * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
  12.  * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
  13.  * USE OF THIS SOFTWARE.
  14.  *
  15.  * So that all may benefit from your experience, please report  any  problems
  16.  * or  suggestions about this software to the 29K Technical Support Center at
  17.  * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
  18.  * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
  19.  *
  20.  * Advanced Micro Devices, Inc.
  21.  * 29K Support Products
  22.  * Mail Stop 573
  23.  * 5900 E. Ben White Blvd.
  24.  * Austin, TX 78741
  25.  * 800-292-9263
  26.  *****************************************************************************
  27.  *      Engineer: Srini Subramanian.
  28.  *****************************************************************************
  29.  ** 
  30.  **       This code provides dump routines to output data in
  31.  **       hex / ASCII formats. 
  32.  **
  33.  *****************************************************************************
  34.  */
  35.  
  36. #include <stdio.h>
  37. #include <ctype.h>
  38. #include <memory.h>
  39. #include "main.h"
  40. #include "macros.h"
  41. #include "monitor.h"
  42. #include "miniint.h"
  43. #include "memspcs.h"
  44. #include "error.h"
  45.  
  46.  
  47. #ifdef MSDOS
  48. #include <stdlib.h>
  49. #include <string.h>
  50. #else
  51. #include <string.h>
  52. #endif
  53.  
  54. int   get_addr_29k PARAMS((char *, struct addr_29k_t *));
  55. int   addr_29k_ok PARAMS((struct addr_29k_t *));
  56. int   print_addr_29k PARAMS((INT32, ADDR32));
  57.  
  58. int   dump_mem_word PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  59. int   dump_reg_word PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  60. int   dump_mem_half PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  61. int   dump_reg_half PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  62. int   dump_mem_byte PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  63. int   dump_reg_byte PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  64. int   dump_mem_float PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  65. int   dump_reg_float PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  66. int   dump_mem_double PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  67. int   dump_reg_double PARAMS((INT32 mspace, ADDR32 addr, INT32 bytes, BYTE *buf));
  68.  
  69. int   get_data PARAMS((BYTE *, BYTE *, int));
  70. int   dump_ASCII PARAMS((char *, int, BYTE *, int));
  71.  
  72.  
  73. /*
  74. ** The function below is used in dumping data.  This function is
  75. ** called in the main command loop parser of the monitor.  The
  76. ** parameters passed to this function are:
  77. **
  78. ** token - This is an array of pointers to strings.  Each string
  79. **         referenced by this array is a "token" of the user's
  80. **         input, translated to lower case.
  81. **
  82. ** token_count - This is the number of tokens in "token".
  83. **
  84. ** This function reduces the tokens to three parameters:
  85. ** memory_space, address and byte_count.  The address parameter is
  86. ** aligned as follows:
  87. **
  88. **    - All register accesses are byte aligned.  The address,
  89. **      however, accesses 32 bit words.  The valued in these
  90. **      registers are displayed in formats determined by the
  91. **      first token.
  92. **
  93. **    - Memory addresses are aligned and displayed according
  94. **      to the dump format as specified in the first token.
  95. ** 
  96. **
  97. */
  98.  
  99.  
  100. INT32
  101. dump_cmd(token, token_count)
  102.    char   *token[];
  103.    int     token_count;
  104.    {
  105.    static INT32  memory_space=D_MEM;
  106.    static ADDR32 address=0;
  107.    INT32  byte_count=64;
  108.    int    result;
  109.    struct addr_29k_t addr_29k_start;
  110.    struct addr_29k_t addr_29k_end;
  111.    int    dump_format;
  112.    int    object_size;
  113.    ADDR32 align_mask;
  114.  
  115.    INT32    retval;
  116.    INT32    hostendian;
  117.    INT32    bytes_returned;
  118.    BYTE        *read_buffer;
  119.  
  120.    /*
  121.    ** What is the dump format?
  122.    */
  123.  
  124.    if ((strcmp(token[0], "d") == 0) ||
  125.        (strcmp(token[0], "dw") == 0)) {
  126.       dump_format = WORD_FORMAT;
  127.       object_size = sizeof(INT32);
  128.       align_mask = 0xfffffffc;
  129.       }
  130.    else
  131.    if (strcmp(token[0], "dh") == 0) {
  132.       dump_format = HALF_FORMAT;
  133.       object_size = sizeof(INT16);
  134.       align_mask = 0xfffffffe;
  135.       }
  136.    else
  137.    if (strcmp(token[0], "db") == 0) {
  138.       dump_format = BYTE_FORMAT;
  139.       object_size = sizeof(BYTE);
  140.       align_mask = 0xffffffff;
  141.       }
  142.    else
  143.    if (strcmp(token[0], "df") == 0) {
  144.       dump_format = FLOAT_FORMAT;
  145.       object_size = sizeof(float);
  146.       align_mask = 0xfffffffc;
  147.       }
  148.    else
  149.    if (strcmp(token[0], "dd") == 0) {
  150.       dump_format = DOUBLE_FORMAT;
  151.       object_size = sizeof(double);
  152.       align_mask = 0xfffffff8;
  153.       }
  154.    else
  155.       return(EMSYNTAX);
  156.  
  157.    /*
  158.    ** Get start address and byte count
  159.    */
  160.  
  161.    if (token_count == 1) {
  162.       if (ISREG(memory_space))
  163.          address = address + (byte_count/4);
  164.       else
  165.       if (ISMEM(memory_space))
  166.          address = address + byte_count;
  167.       else
  168.          return(EMBADADDR);
  169.       /* Check the start address */
  170.       addr_29k_start.address = address;
  171.       addr_29k_start.memory_space = memory_space;
  172.       result = addr_29k_ok(&addr_29k_start);
  173.       if (result != 0)
  174.          return (result);
  175.       }
  176.    else
  177.    if (token_count == 2) {
  178.       result = get_addr_29k(token[1], &addr_29k_start);
  179.       if (result != 0)
  180.          return (EMSYNTAX);
  181.       /* Check the start address */
  182.       result = addr_29k_ok(&addr_29k_start);
  183.       if (result != 0)
  184.          return (result);
  185.  
  186.       memory_space = addr_29k_start.memory_space;
  187.       /* Make sure we have an even multiple of object_size */
  188.       if (ISREG(memory_space)) {
  189.          address = addr_29k_start.address;
  190.          byte_count = (byte_count + (object_size - 1)) & 0xfffffffc;
  191.          }
  192.       else
  193.       if (ISMEM(memory_space)) {
  194.          address = addr_29k_start.address & align_mask;
  195.          byte_count = (byte_count + (object_size - 1)) & align_mask;
  196.          }
  197.       else
  198.          return(EMBADADDR);
  199.       }
  200.    else
  201.    if (token_count == 3) {
  202.       result = get_addr_29k(token[1], &addr_29k_start);
  203.       if (result != 0)
  204.          return (EMSYNTAX);
  205.       /* Only check the start address */
  206.       result = addr_29k_ok(&addr_29k_start);
  207.       if (result != 0)
  208.          return (result);
  209.       result = get_addr_29k(token[2], &addr_29k_end);
  210.       if (result != 0)
  211.          return (EMSYNTAX);
  212.  
  213.       if (addr_29k_start.memory_space != addr_29k_end.memory_space)
  214.          return (EMBADADDR);
  215.       if (addr_29k_start.address > addr_29k_end.address)
  216.          return (EMBADADDR);
  217.  
  218.       memory_space = addr_29k_start.memory_space;
  219.       if (ISREG(memory_space)) {
  220.          address = addr_29k_start.address;
  221.          byte_count = (addr_29k_end.address -
  222.                        addr_29k_start.address + 1) * 4;
  223.          }
  224.       else
  225.       if (ISMEM(memory_space)) {
  226.          address = addr_29k_start.address & align_mask;
  227.          byte_count = ((addr_29k_end.address & align_mask) -
  228.                        (addr_29k_start.address & align_mask) +
  229.                       object_size);
  230.          }
  231.       else
  232.          return(EMBADADDR);
  233.  
  234.       }
  235.    else
  236.    /* Too many args */
  237.       return (EMSYNTAX);
  238.  
  239.  
  240.    /*
  241.    ** Get data
  242.    */
  243.  
  244.    /* Will the data overflow the message buffer? Done by TIP ??*/
  245.    if ((read_buffer = (BYTE *) malloc((unsigned int) byte_count)) == NULL) {
  246.        warning(EMALLOC);
  247.        return(FAILURE);
  248.    };
  249.  
  250.    hostendian = FALSE;
  251.    if ((retval = Mini_read_req(memory_space,
  252.                 address,
  253.                 byte_count / object_size,
  254.                 (INT16) object_size, 
  255.                 &bytes_returned,
  256.                 read_buffer,
  257.                 hostendian)) != SUCCESS) {
  258.     return(FAILURE);
  259.    };
  260.   
  261.    bytes_returned = bytes_returned * object_size;
  262.     
  263.     /* Continue if SUCCESSful */
  264.     
  265.    /*
  266.    ** Call data format routines
  267.    */
  268.  
  269.    if ISMEM(memory_space) {
  270.       if (dump_format == WORD_FORMAT)
  271.          result = dump_mem_word(memory_space,
  272.                 address,
  273.                 bytes_returned,
  274.                 read_buffer);
  275.       else
  276.       if (dump_format == HALF_FORMAT)
  277.          result = dump_mem_half(memory_space,
  278.                 address,
  279.                 bytes_returned,
  280.                 read_buffer);
  281.       else
  282.       if (dump_format == BYTE_FORMAT)
  283.          result = dump_mem_byte(memory_space,
  284.                 address,
  285.                 bytes_returned,
  286.                 read_buffer);
  287.       else
  288.       if (dump_format == FLOAT_FORMAT)
  289.          result = dump_mem_float(memory_space,
  290.                 address,
  291.                 bytes_returned,
  292.                 read_buffer);
  293.       else
  294.       if (dump_format == DOUBLE_FORMAT)
  295.          result = dump_mem_double(memory_space,
  296.                 address,
  297.                 bytes_returned,
  298.                 read_buffer);
  299.       }
  300.    else
  301.    if ISREG(memory_space) {
  302.       if (dump_format == WORD_FORMAT)
  303.          result = dump_reg_word(memory_space,
  304.                 address,
  305.                 bytes_returned,
  306.                 read_buffer);
  307.       else
  308.       if (dump_format == HALF_FORMAT)
  309.          result = dump_reg_half(memory_space,
  310.                 address,
  311.                 bytes_returned,
  312.                 read_buffer);
  313.       else
  314.       if (dump_format == BYTE_FORMAT)
  315.          result = dump_reg_byte(memory_space,
  316.                 address,
  317.                 bytes_returned,
  318.                 read_buffer);
  319.       else
  320.       if (dump_format == FLOAT_FORMAT)
  321.          result = dump_reg_float(memory_space,
  322.                 address,
  323.                 bytes_returned,
  324.                 read_buffer);
  325.       else
  326.       if (dump_format == DOUBLE_FORMAT)
  327.          result = dump_reg_double(memory_space,
  328.                 address,
  329.                 bytes_returned,
  330.                 read_buffer);
  331.       }
  332.    else
  333.       return(EMBADADDR);
  334.  
  335.    (void) free ((char *) read_buffer);
  336.    return (result);
  337.  
  338.    }  /* end dump_cmd() */
  339.  
  340.  
  341.  
  342. /*
  343. ** Functions used by dump_cmd()
  344. */
  345.  
  346.  
  347. /*
  348. ** This function is used to dump 32 bit words of data.
  349. ** the address is printed, followed by the data, grouped
  350. ** into 8 character long strings, each representing one
  351. ** 32 bit word.  Space for four 32-bit words is reserved
  352. ** on each line.  Following the hex data, an ASCII
  353. ** representation of the data is printed.
  354. */
  355.  
  356. int
  357. dump_mem_word(memory_space, read_address, bytes_returned, read_buffer)
  358.    INT32  memory_space;
  359.    ADDR32 read_address;
  360.    INT32  bytes_returned;
  361.    BYTE   *read_buffer;
  362.    {
  363.    int      result;
  364.    ADDR32   address;
  365.    ADDR32   start_address;
  366.    ADDR32   end_address;
  367.    ADDR32   last_print_address;
  368.    ADDR32   address_mask;
  369.    INT32    byte_count;
  370.    INT32    data_word;
  371.    struct   addr_29k_t addr_29k;
  372.    int      ASCII_index;
  373.    char     ASCII_buffer[20];
  374.  
  375.    byte_count = 0;
  376.    ASCII_index = 0;
  377.    ASCII_buffer[0] = '\0';
  378.  
  379.    address_mask = 0xfffffff0;
  380.    start_address = read_address;
  381.    end_address = read_address + bytes_returned;
  382.    last_print_address = (end_address + 0xf) & address_mask;
  383.    address = start_address & address_mask;
  384.  
  385.    /*
  386.    ** Loop while data available
  387.    */
  388.  
  389.    while (address <= last_print_address) {
  390.  
  391.       /* Exit if address not valid */
  392.       addr_29k.memory_space = memory_space;
  393.       addr_29k.address = address;
  394.       result = addr_29k_ok(&addr_29k);
  395.       if (result != 0) {
  396.      if (io_config.echo_mode == (INT32) TRUE)
  397.          fprintf(io_config.echo_file, "\n\n");
  398.          fprintf(stderr, "\n\n");
  399.          return (0);
  400.          }
  401.  
  402.       /* Print out ASCII data */
  403.       if ((address & address_mask) == address) {
  404.          fprintf(stderr, "  %s\n", ASCII_buffer);
  405.      if (io_config.echo_mode == (INT32) TRUE)
  406.          fprintf(io_config.echo_file, "  %s\n", ASCII_buffer);
  407.          ASCII_index = 0;
  408.          }
  409.  
  410.       /* Print address in margin */
  411.       if (((address & address_mask) == address) &&
  412.           (address  != last_print_address)) {
  413.          result = print_addr_29k(memory_space, address);
  414.          if (result != 0)
  415.             return (EMBADADDR);
  416.          }
  417.  
  418.       /* Do leading and trailing spaces (if necessary) */
  419.       if ((address < start_address) ||
  420.           (address >= end_address)) {
  421.          fprintf(stderr, "         ");
  422.      if (io_config.echo_mode == (INT32) TRUE)
  423.          fprintf(io_config.echo_file, "         ");
  424.          result = dump_ASCII(ASCII_buffer, ASCII_index,
  425.                              (BYTE *) NULL, sizeof(INT32)); 
  426.          ASCII_index = ASCII_index + sizeof(INT32);
  427.          address = address + sizeof(INT32);
  428.          }
  429.  
  430.       /* Print out hex data */
  431.       if ((address >= start_address) &&
  432.           (address < end_address)) {
  433.  
  434.          result = get_data((BYTE *)&data_word,
  435.                            &read_buffer[byte_count],
  436.                            sizeof(INT32));
  437.          if (result != 0)
  438.             return (EMBADADDR);
  439.  
  440.          fprintf(stderr, "%08lx ", data_word);
  441.      if (io_config.echo_mode == (INT32) TRUE)
  442.          fprintf(io_config.echo_file, "%08lx ", data_word);
  443.  
  444.          /* Build ASCII srting */
  445.          result = dump_ASCII(ASCII_buffer,
  446.                              ASCII_index,
  447.                              &read_buffer[byte_count],
  448.                              sizeof(INT32)); 
  449.          ASCII_index = ASCII_index + sizeof(INT32);
  450.  
  451.          address = address + sizeof(INT32);
  452.  
  453.          byte_count = byte_count + sizeof(INT32);
  454.  
  455.          }  /* end if */
  456.  
  457.       }  /* end while */
  458.  
  459.    fprintf(stderr, "\n");
  460.    if (io_config.echo_mode == (INT32) TRUE)
  461.    fprintf(io_config.echo_file, "\n");
  462.  
  463.    return (0);
  464.  
  465.    }  /* end dump_mem_word() */
  466.  
  467.  
  468. int
  469. dump_reg_word(memory_space, read_address, bytes_returned, read_buffer)
  470.    INT32  memory_space;
  471.    ADDR32 read_address;
  472.    INT32  bytes_returned;
  473.    BYTE   *read_buffer;
  474.    {
  475.    int      result;
  476.    ADDR32   address;
  477.    ADDR32   start_address;
  478.    ADDR32   end_address;
  479.    ADDR32   last_print_address;
  480.    ADDR32   address_mask;
  481.    INT32    byte_count;
  482.    INT32    data_word;
  483.    struct   addr_29k_t addr_29k;
  484.    int      ASCII_index;
  485.    char     ASCII_buffer[20];
  486.  
  487.    byte_count = 0;
  488.    ASCII_index = 0;
  489.    ASCII_buffer[0] = '\0';
  490.  
  491.    address_mask = 0xfffffffc;
  492.    start_address = read_address;
  493.    end_address = read_address + (bytes_returned / 4);
  494.    last_print_address = (end_address + 0x3) & address_mask;
  495.    address = start_address & address_mask;
  496.  
  497.    /*
  498.    ** Loop while data available
  499.    */
  500.  
  501.    while (address <= last_print_address) {
  502.  
  503.       /* Exit if address not valid */
  504.       addr_29k.memory_space = memory_space;
  505.       addr_29k.address = address;
  506.       result = addr_29k_ok(&addr_29k);
  507.       if (result != 0) {
  508.          fprintf(stderr, "\n\n");
  509.      if (io_config.echo_mode == (INT32) TRUE)
  510.          fprintf(io_config.echo_file, "\n\n");
  511.          return (0);
  512.          }
  513.  
  514.       /* Print out ASCII data */
  515.       if ((address & address_mask) == address) {
  516.          fprintf(stderr, "  %s\n", ASCII_buffer);
  517.      if (io_config.echo_mode == (INT32) TRUE)
  518.          fprintf(io_config.echo_file, "  %s\n", ASCII_buffer);
  519.          ASCII_index = 0;
  520.          }
  521.  
  522.       /* Print address in margin */
  523.       if (((address & address_mask) == address) &&
  524.           (address  != last_print_address)) {
  525.          result = print_addr_29k(memory_space, address);
  526.          if (result != 0)
  527.             return (EMBADADDR);
  528.          }
  529.  
  530.       /* Do leading and trailing spaces (if necessary) */
  531.       if ((address < start_address) ||
  532.           (address >= end_address)) {
  533.          fprintf(stderr, "         ");
  534.      if (io_config.echo_mode == (INT32) TRUE)
  535.          fprintf(io_config.echo_file, "         ");
  536.          result = dump_ASCII(ASCII_buffer, ASCII_index,
  537.                              (BYTE *) NULL, sizeof(INT32)); 
  538.          ASCII_index = ASCII_index + sizeof(INT32);
  539.          address = address + 1;
  540.          }
  541.  
  542.       /* Print out hex data */
  543.       if ((address >= start_address) &&
  544.           (address < end_address)) {
  545.  
  546.          result = get_data((BYTE *)&data_word,
  547.                            &read_buffer[byte_count],
  548.                            sizeof(INT32));
  549.          if (result != 0)
  550.             return (EMBADADDR);
  551.  
  552.          fprintf(stderr, "%08lx ", data_word);
  553.      if (io_config.echo_mode == (INT32) TRUE)
  554.          fprintf(io_config.echo_file, "%08lx ", data_word);
  555.  
  556.          /* Build ASCII srting */
  557.          result = dump_ASCII(ASCII_buffer,
  558.                              ASCII_index,
  559.                              &read_buffer[byte_count],
  560.                              sizeof(INT32)); 
  561.          ASCII_index = ASCII_index + sizeof(INT32);
  562.  
  563.          address = address + 1;
  564.  
  565.          byte_count = byte_count + sizeof(INT32);
  566.  
  567.          }  /* end if */
  568.  
  569.       }  /* end while */
  570.  
  571.    fprintf(stderr, "\n");
  572.    if (io_config.echo_mode == (INT32) TRUE)
  573.    fprintf(io_config.echo_file, "\n");
  574.  
  575.    return (0);
  576.  
  577.    }  /* end dump_reg_word() */
  578.  
  579.  
  580.  
  581. /*
  582. ** This function is used to dump memory as half words.
  583. */
  584.  
  585. int
  586. dump_mem_half(memory_space, read_address, bytes_returned, read_buffer)
  587.    INT32  memory_space;
  588.    ADDR32 read_address;
  589.    INT32  bytes_returned;
  590.    BYTE   *read_buffer;
  591.    {
  592.    int      result;
  593.    ADDR32   address;
  594.    ADDR32   start_address;
  595.    ADDR32   end_address;
  596.    ADDR32   last_print_address;
  597.    ADDR32   address_mask;
  598.    INT32    byte_count;
  599.    INT16    data_half;
  600.    INT32    data_word;
  601.    struct   addr_29k_t addr_29k;
  602.    int      ASCII_index;
  603.    char     ASCII_buffer[20];
  604.  
  605.    byte_count = 0;
  606.    ASCII_index = 0;
  607.    ASCII_buffer[0] = '\0';
  608.  
  609.    address_mask = 0xfffffff0;
  610.    start_address = read_address;
  611.    end_address = read_address + bytes_returned;
  612.    last_print_address = (end_address + 0xf) & address_mask;
  613.    address = start_address & address_mask;
  614.  
  615.    /*
  616.    ** Loop while data available
  617.    */
  618.  
  619.    while (address <= last_print_address) {
  620.  
  621.       /* Exit if address not valid */
  622.       addr_29k.memory_space = memory_space;
  623.       addr_29k.address = address;
  624.       result = addr_29k_ok(&addr_29k);
  625.       if (result != 0) {
  626.          fprintf(stderr, "\n\n");
  627.      if (io_config.echo_mode == (INT32) TRUE)
  628.          fprintf(io_config.echo_file, "\n\n");
  629.          return (0);
  630.          }
  631.  
  632.       /* Print out ASCII data */
  633.       if ((address & address_mask) == address) {
  634.          fprintf(stderr, "  %s\n", ASCII_buffer);
  635.      if (io_config.echo_mode == (INT32) TRUE)
  636.          fprintf(io_config.echo_file, "  %s\n", ASCII_buffer);
  637.          ASCII_index = 0;
  638.          }
  639.  
  640.       /* Print address in margin */
  641.       if (((address & address_mask) == address) &&
  642.           (address != last_print_address)) {
  643.          result = print_addr_29k(memory_space, address);
  644.          if (result != 0)
  645.             return (EMBADADDR);
  646.          }
  647.  
  648.       /* Do leading and trailing spaces (if necessary) */
  649.       if ((address < start_address) ||
  650.           (address >= end_address)) {
  651.          fprintf(stderr, "     ");
  652.      if (io_config.echo_mode == (INT32) TRUE)
  653.          fprintf(io_config.echo_file, "     ");
  654.          result = dump_ASCII(ASCII_buffer, ASCII_index,
  655.                              (BYTE *) NULL, sizeof(INT16));
  656.          ASCII_index = ASCII_index + sizeof(INT16);
  657.          address = address + sizeof(INT16);
  658.          }
  659.  
  660.       /* Print out hex data */
  661.       if ((address >= start_address) &&
  662.           (address < end_address)) {
  663.  
  664.          result = get_data((BYTE *)&data_half,
  665.                            &read_buffer[byte_count],
  666.                            sizeof(INT16));
  667.          if (result != 0)
  668.             return (EMBADADDR);
  669.  
  670.          /* We have to cast to INT32 to print out a hex halfword */
  671.          /* (the Sun libraries sign extend to 32 bits) */
  672.          data_word = (INT32) data_half;
  673.          data_word = (data_word & 0x0000ffff);
  674.          fprintf(stderr, "%04x ", data_word);
  675.      if (io_config.echo_mode == (INT32) TRUE)
  676.          fprintf(io_config.echo_file, "%04x ", data_word);
  677.  
  678.          /* Build ASCII srting */
  679.          result = dump_ASCII(ASCII_buffer,
  680.                              ASCII_index,
  681.                              &read_buffer[byte_count],
  682.                              sizeof(INT16)); 
  683.          ASCII_index = ASCII_index + sizeof(INT16);
  684.  
  685.          address = address + sizeof(INT16);
  686.  
  687.          byte_count = byte_count + sizeof(INT16);
  688.  
  689.          }  /* end if */
  690.  
  691.       }  /* end while */
  692.  
  693.    fprintf(stderr, "\n");
  694.    if (io_config.echo_mode == (INT32) TRUE)
  695.    fprintf(io_config.echo_file, "\n");
  696.  
  697.    return (0);
  698.    }  /* end dump_mem_half() */
  699.  
  700.  
  701.  
  702. /*
  703. ** This function is used to dump registers as half words.
  704. */
  705.  
  706. int
  707. dump_reg_half(memory_space, read_address, bytes_returned, read_buffer)
  708.    INT32  memory_space;
  709.    ADDR32 read_address;
  710.    INT32  bytes_returned;
  711.    BYTE   *read_buffer;
  712.    {
  713.    int      result;
  714.    ADDR32   address;
  715.    ADDR32   start_address;
  716.    ADDR32   end_address;
  717.    ADDR32   last_print_address;
  718.    ADDR32   address_mask;
  719.    INT32    byte_count;
  720.    INT32    data_word;
  721.    struct   addr_29k_t addr_29k;
  722.    int      ASCII_index;
  723.    char     ASCII_buffer[20];
  724.  
  725.    byte_count = 0;
  726.    ASCII_index = 0;
  727.    ASCII_buffer[0] = '\0';
  728.  
  729.    address_mask = 0xfffffffc;
  730.    start_address = read_address;
  731.    end_address = read_address + (bytes_returned / 4);
  732.    last_print_address = (end_address + 0x3) & address_mask;
  733.    address = start_address & address_mask;
  734.  
  735.    /*
  736.    ** Loop while data available
  737.    */
  738.  
  739.    while (address <= last_print_address) {
  740.  
  741.       /* Exit if address not valid */
  742.       addr_29k.memory_space = memory_space;
  743.       addr_29k.address = address;
  744.       result = addr_29k_ok(&addr_29k);
  745.       if (result != 0) {
  746.          fprintf(stderr, "\n\n");
  747.      if (io_config.echo_mode == (INT32) TRUE)
  748.          fprintf(io_config.echo_file, "\n\n");
  749.          return (0);
  750.          }
  751.  
  752.       /* Print out ASCII data */
  753.       if ((address & address_mask) == address) {
  754.          fprintf(stderr, "  %s\n", ASCII_buffer);
  755.      if (io_config.echo_mode == (INT32) TRUE)
  756.          fprintf(io_config.echo_file, "  %s\n", ASCII_buffer);
  757.          ASCII_index = 0;
  758.          }
  759.  
  760.       /* Print address in margin */
  761.       if (((address & address_mask) == address) &&
  762.           (address != last_print_address)) {
  763.          result = print_addr_29k(memory_space, address);
  764.          if (result != 0)
  765.             return (EMBADADDR);
  766.          }
  767.  
  768.       /* Do leading and trailing spaces (if necessary) */
  769.       if ((address < start_address) ||
  770.           (address >= end_address)) {
  771.          fprintf(stderr, "         ");
  772.      if (io_config.echo_mode == (INT32) TRUE)
  773.          fprintf(io_config.echo_file, "         ");
  774.          result = dump_ASCII(ASCII_buffer, ASCII_index,
  775.                              (BYTE *) NULL, sizeof(INT16));
  776.          ASCII_index = ASCII_index + sizeof(INT16);
  777.  
  778.          address = address + 1;
  779.          }
  780.  
  781.       /* Print out hex data */
  782.       if ((address >= start_address) &&
  783.           (address < end_address)) {
  784.  
  785.          result = get_data((BYTE *)&data_word,
  786.                            &read_buffer[byte_count],
  787.                            sizeof(INT32));
  788.          if (result != 0)
  789.             return (EMBADADDR);
  790.  
  791.          fprintf(stderr, "%04lx %04lx ",
  792.                 ((data_word >> 16) & 0xffff),
  793.                 (data_word & 0xffff));
  794.      if (io_config.echo_mode == (INT32) TRUE)
  795.          fprintf(io_config.echo_file, "%04lx %04lx ",
  796.                 ((data_word >> 16) & 0xffff),
  797.                 (data_word & 0xffff));
  798.  
  799.          /* Build ASCII srting */
  800.          result = dump_ASCII(ASCII_buffer,
  801.                              ASCII_index,
  802.                              &read_buffer[byte_count],
  803.                              sizeof(INT32));
  804.          ASCII_index = ASCII_index + sizeof(INT32);
  805.  
  806.          address = address + 1;
  807.  
  808.          byte_count = byte_count + sizeof(INT32);
  809.  
  810.          }  /* end if */
  811.  
  812.       }  /* end while */
  813.  
  814.    fprintf(stderr, "\n");
  815.    if (io_config.echo_mode == (INT32) TRUE)
  816.    fprintf(io_config.echo_file, "\n");
  817.  
  818.    return (0);
  819.    }  /* end dump_reg_half() */
  820.  
  821.  
  822.  
  823. /*
  824. ** This function is used to dump memory as bytes.
  825. */
  826.  
  827. int
  828. dump_mem_byte(memory_space, read_address, bytes_returned, read_buffer)
  829.    INT32  memory_space;
  830.    ADDR32 read_address;
  831.    INT32  bytes_returned;
  832.    BYTE   *read_buffer;
  833.    {
  834.    int      result;
  835.    ADDR32   address;
  836.    ADDR32   start_address;
  837.    ADDR32   end_address;
  838.    ADDR32   last_print_address;
  839.    ADDR32   address_mask;
  840.    INT32    byte_count;
  841.    BYTE     data_byte;
  842.    struct   addr_29k_t addr_29k;
  843.    int      ASCII_index;
  844.    char     ASCII_buffer[20];
  845.  
  846.    byte_count = 0;
  847.    ASCII_index = 0;
  848.    ASCII_buffer[0] = '\0';
  849.  
  850.    address_mask = 0xfffffff0;
  851.    start_address = read_address;
  852.    end_address = read_address + bytes_returned;
  853.    last_print_address = (end_address + 0xf) & address_mask;
  854.    address = start_address & address_mask;
  855.  
  856.    /*
  857.    ** Loop while data available
  858.    */
  859.  
  860.    while (address <= last_print_address) {
  861.  
  862.       /* Exit if address not valid */
  863.       addr_29k.memory_space = memory_space;
  864.       addr_29k.address = address;
  865.       result = addr_29k_ok(&addr_29k);
  866.       if (result != 0) {
  867.          fprintf(stderr, "\n\n");
  868.      if (io_config.echo_mode == (INT32) TRUE)
  869.          fprintf(io_config.echo_file, "\n\n");
  870.          return (0);
  871.          }
  872.  
  873.       /* Print out ASCII data */
  874.       if ((address & address_mask) == address) {
  875.          fprintf(stderr, "  %s\n", ASCII_buffer);
  876.      if (io_config.echo_mode == (INT32) TRUE)
  877.          fprintf(io_config.echo_file, "  %s\n", ASCII_buffer);
  878.          ASCII_index = 0;
  879.          }
  880.  
  881.       /* Print address in margin */
  882.       if (((address & address_mask) == address) &&
  883.           (address != last_print_address)) {
  884.          result = print_addr_29k(memory_space, address);
  885.          if (result != 0)
  886.             return (EMBADADDR);
  887.          }
  888.  
  889.       /* Do leading and trailing spaces (if necessary) */
  890.       if ((address < start_address) ||
  891.           (address >= end_address)) {
  892.          fprintf(stderr, "   ");
  893.      if (io_config.echo_mode == (INT32) TRUE)
  894.          fprintf(io_config.echo_file, "   ");
  895.          result = dump_ASCII(ASCII_buffer, ASCII_index,
  896.                              (BYTE *) NULL, sizeof(BYTE));
  897.          ASCII_index = ASCII_index + sizeof(BYTE);
  898.          address = address + sizeof(BYTE);
  899.          }
  900.  
  901.       /* Print out hex data */
  902.       if ((address >= start_address) &&
  903.           (address < end_address)) {
  904.  
  905.          result = get_data((BYTE *)&data_byte,
  906.                            &read_buffer[byte_count],
  907.                            sizeof(BYTE));
  908.          if (result != 0)
  909.             return (EMBADADDR);
  910.  
  911.          fprintf(stderr, "%02x ", data_byte);
  912.      if (io_config.echo_mode == (INT32) TRUE)
  913.          fprintf(io_config.echo_file, "%02x ", data_byte);
  914.  
  915.          /* Build ASCII srting */
  916.          result = dump_ASCII(ASCII_buffer,
  917.                              ASCII_index,
  918.                              &read_buffer[byte_count],
  919.                              sizeof(BYTE)); 
  920.          ASCII_index = ASCII_index + sizeof(BYTE);
  921.  
  922.          address = address + sizeof(BYTE);
  923.  
  924.          byte_count = byte_count + sizeof(BYTE);
  925.  
  926.          }  /* end if */
  927.  
  928.       }  /* end while */
  929.  
  930.    fprintf(stderr, "\n");
  931.    if (io_config.echo_mode == (INT32) TRUE)
  932.    fprintf(io_config.echo_file, "\n");
  933.  
  934.    return (0);
  935.    }  /* end dump_mem_byte() */
  936.  
  937.  
  938.  
  939. /*
  940. ** This function is used to dump registers as bytes.
  941. */
  942.  
  943. int
  944. dump_reg_byte(memory_space, read_address, bytes_returned, read_buffer)
  945.    INT32  memory_space;
  946.    ADDR32 read_address;
  947.    INT32  bytes_returned;
  948.    BYTE   *read_buffer;
  949.    {
  950.    int      result;
  951.    ADDR32   address;
  952.    ADDR32   start_address;
  953.    ADDR32   end_address;
  954.    ADDR32   last_print_address;
  955.    ADDR32   address_mask;
  956.    INT32    byte_count;
  957.    INT32    data_word;
  958.    struct   addr_29k_t addr_29k;
  959.    int      ASCII_index;
  960.    char     ASCII_buffer[20];
  961.  
  962.    byte_count = 0;
  963.    ASCII_index = 0;
  964.    ASCII_buffer[0] = '\0';
  965.  
  966.    address_mask = 0xfffffffc;
  967.    start_address = read_address;
  968.    end_address = read_address + (bytes_returned / 4);
  969.    last_print_address = (end_address + 0x3) & address_mask;
  970.    address = start_address & address_mask;
  971.  
  972.    /*
  973.    ** Loop while data available
  974.    */
  975.  
  976.    while (address <= last_print_address) {
  977.  
  978.       /* Exit if address not valid */
  979.       addr_29k.memory_space = memory_space;
  980.       addr_29k.address = address;
  981.       result = addr_29k_ok(&addr_29k);
  982.       if (result != 0) {
  983.          fprintf(stderr, "\n\n");
  984.      if (io_config.echo_mode == (INT32) TRUE)
  985.          fprintf(io_config.echo_file, "\n\n");
  986.          return (0);
  987.          }
  988.  
  989.       /* Print out ASCII data */
  990.       if ((address & address_mask) == address) {
  991.          fprintf(stderr, "  %s\n", ASCII_buffer);
  992.      if (io_config.echo_mode == (INT32) TRUE)
  993.          fprintf(io_config.echo_file, "  %s\n", ASCII_buffer);
  994.          ASCII_index = 0;
  995.          }
  996.  
  997.       /* Print address in margin */
  998.       if (((address & address_mask) == address) &&
  999.           (address != last_print_address)) {
  1000.          result = print_addr_29k(memory_space, address);
  1001.          if (result != 0)
  1002.             return (EMBADADDR);
  1003.          }
  1004.  
  1005.       /* Do leading and trailing spaces (if necessary) */
  1006.       if ((address < start_address) ||
  1007.           (address >= end_address)) {
  1008.          fprintf(stderr, "            ");
  1009.      if (io_config.echo_mode == (INT32) TRUE)
  1010.          fprintf(io_config.echo_file, "            ");
  1011.          result = dump_ASCII(ASCII_buffer, ASCII_index,
  1012.                              (BYTE *) NULL, sizeof(INT32));
  1013.          ASCII_index = ASCII_index + sizeof(INT32);
  1014.  
  1015.          address = address + 1;
  1016.          }
  1017.  
  1018.       /* Print out hex data */
  1019.       if ((address >= start_address) &&
  1020.           (address < end_address)) {
  1021.  
  1022.          result = get_data((BYTE *)&data_word,
  1023.                            &read_buffer[byte_count],
  1024.                            sizeof(INT32));
  1025.          if (result != 0)
  1026.             return (EMBADADDR);
  1027.  
  1028.      if (io_config.echo_mode == (INT32) TRUE)
  1029.          fprintf(io_config.echo_file, "%02lx %02lx %02lx %02lx ",
  1030.                 ((data_word >> 24) & 0xff),
  1031.                 ((data_word >> 16) & 0xff),
  1032.                 ((data_word >> 8) & 0xff),
  1033.                 (data_word & 0xff));
  1034.          fprintf(stderr, "%02lx %02lx %02lx %02lx ",
  1035.                 ((data_word >> 24) & 0xff),
  1036.                 ((data_word >> 16) & 0xff),
  1037.                 ((data_word >> 8) & 0xff),
  1038.                 (data_word & 0xff));
  1039.  
  1040.          /* Build ASCII srting */
  1041.          result = dump_ASCII(ASCII_buffer,
  1042.                              ASCII_index,
  1043.                              &read_buffer[byte_count],
  1044.                              sizeof(INT32)); 
  1045.          ASCII_index = ASCII_index + sizeof(INT32);
  1046.  
  1047.          address = address + 1;
  1048.  
  1049.          byte_count = byte_count + sizeof(INT32);
  1050.  
  1051.          }  /* end if */
  1052.  
  1053.       }  /* end while */
  1054.  
  1055.    fprintf(stderr, "\n");
  1056.    if (io_config.echo_mode == (INT32) TRUE)
  1057.    fprintf(io_config.echo_file, "\n");
  1058.  
  1059.    return (0);
  1060.    }  /* end dump_reg_byte() */
  1061.  
  1062.  
  1063.  
  1064. /*
  1065. ** This function is used to dump memory as floats.
  1066. */
  1067.  
  1068. int
  1069. dump_mem_float(memory_space, read_address, bytes_returned, read_buffer)
  1070.    INT32  memory_space;
  1071.    ADDR32 read_address;
  1072.    INT32  bytes_returned;
  1073.    BYTE   *read_buffer;
  1074.    {
  1075.    int      result;
  1076.    ADDR32   address;
  1077.    ADDR32   start_address;
  1078.    ADDR32   end_address;
  1079.    ADDR32   last_print_address;
  1080.    ADDR32   address_mask;
  1081.    INT32    byte_count;
  1082.    float    data_float;
  1083.    struct   addr_29k_t addr_29k;
  1084.  
  1085.    byte_count = 0;
  1086.  
  1087.    address_mask = 0xfffffff0;
  1088.    start_address = read_address;
  1089.    end_address = read_address + bytes_returned;
  1090.    last_print_address = (end_address + 0xf) & address_mask;
  1091.    address = start_address & address_mask;
  1092.  
  1093.    /*
  1094.    ** Loop while data available
  1095.    */
  1096.  
  1097.    while (address <= last_print_address) {
  1098.  
  1099.       /* Exit if address not valid */
  1100.       addr_29k.memory_space = memory_space;
  1101.       addr_29k.address = address;
  1102.       result = addr_29k_ok(&addr_29k);
  1103.       if (result != 0) {
  1104.          fprintf(stderr, "\n\n");
  1105.      if (io_config.echo_mode == (INT32) TRUE)
  1106.          fprintf(io_config.echo_file, "\n\n");
  1107.          return (0);
  1108.          }
  1109.  
  1110.       /* Print address in margin */
  1111.       if (((address & address_mask) == address) &&
  1112.           (address != last_print_address)) {
  1113.          fprintf(stderr, "\n");
  1114.      if (io_config.echo_mode == (INT32) TRUE)
  1115.          fprintf(io_config.echo_file, "\n");
  1116.          result = print_addr_29k(memory_space, address);
  1117.          if (result != 0)
  1118.             return (EMBADADDR);
  1119.          }
  1120.  
  1121.       /* Do leading and trailing spaces (if necessary) */
  1122.       if ((address < start_address) ||
  1123.           (address >= end_address)) {
  1124.          fprintf(stderr, "               ");
  1125.      if (io_config.echo_mode == (INT32) TRUE)
  1126.          fprintf(io_config.echo_file, "               ");
  1127.          address = address + sizeof(float);
  1128.          }
  1129.  
  1130.       /* Print out hex data */
  1131.       if ((address >= start_address) &&
  1132.           (address < end_address)) {
  1133.  
  1134.          result = get_data((BYTE *)&data_float,
  1135.                            &read_buffer[byte_count],
  1136.                            sizeof(float));
  1137.          if (result != 0)
  1138.             return (EMBADADDR);
  1139.  
  1140.          fprintf(stderr, "%+1.6e ", (double) data_float);
  1141.      if (io_config.echo_mode == (INT32) TRUE)
  1142.          fprintf(io_config.echo_file, "%+1.6e ", (double) data_float);
  1143.  
  1144.          address = address + sizeof(float);
  1145.  
  1146.          byte_count = byte_count + sizeof(float);
  1147.  
  1148.          }  /* end if */
  1149.  
  1150.       }  /* end while */
  1151.  
  1152.    fprintf(stderr, "\n");
  1153.    if (io_config.echo_mode == (INT32) TRUE)
  1154.    fprintf(io_config.echo_file, "\n");
  1155.  
  1156.    return (0);
  1157.    }  /* end dump_mem_float() */
  1158.  
  1159.  
  1160.  
  1161.  
  1162. /*
  1163. ** This function is used to dump registers as floats.
  1164. */
  1165.  
  1166. int
  1167. dump_reg_float(memory_space, read_address, bytes_returned, read_buffer)
  1168.    INT32  memory_space;
  1169.    ADDR32 read_address;
  1170.    INT32  bytes_returned;
  1171.    BYTE   *read_buffer;
  1172.    {
  1173.    int      result;
  1174.    ADDR32   address;
  1175.    ADDR32   start_address;
  1176.    ADDR32   end_address;
  1177.    ADDR32   last_print_address;
  1178.    ADDR32   address_mask;
  1179.    INT32    byte_count;
  1180.    float    data_float;
  1181.    struct   addr_29k_t addr_29k;
  1182.  
  1183.    byte_count = 0;
  1184.  
  1185.    address_mask = 0xfffffffc;
  1186.    start_address = read_address;
  1187.    end_address = read_address + (bytes_returned / 4);
  1188.    last_print_address = (end_address + 0x3) & address_mask;
  1189.    address = start_address & address_mask;
  1190.  
  1191.    /*
  1192.    ** Loop while data available
  1193.    */
  1194.  
  1195.    while (address <= last_print_address) {
  1196.  
  1197.       /* Exit if address not valid */
  1198.       addr_29k.memory_space = memory_space;
  1199.       addr_29k.address = address;
  1200.       result = addr_29k_ok(&addr_29k);
  1201.       if (result != 0) {
  1202.          fprintf(stderr, "\n\n");
  1203.      if (io_config.echo_mode == (INT32) TRUE)
  1204.          fprintf(io_config.echo_file, "\n\n");
  1205.          return (0);
  1206.          }
  1207.  
  1208.       /* Print address in margin */
  1209.       if (((address & address_mask) == address) &&
  1210.           (address != last_print_address)) {
  1211.          fprintf(stderr, "\n");
  1212.      if (io_config.echo_mode == (INT32) TRUE)
  1213.          fprintf(io_config.echo_file, "\n");
  1214.          result = print_addr_29k(memory_space, address);
  1215.          if (result != 0)
  1216.             return (EMBADADDR);
  1217.          }
  1218.  
  1219.       /* Do leading and trailing spaces (if necessary) */
  1220.       if ((address < start_address) ||
  1221.           (address >= end_address)) {
  1222.          fprintf(stderr, "               ");
  1223.      if (io_config.echo_mode == (INT32) TRUE)
  1224.          fprintf(io_config.echo_file, "               ");
  1225.          address = address + 1;
  1226.          }
  1227.  
  1228.       /* Print out hex data */
  1229.       if ((address >= start_address) &&
  1230.           (address < end_address)) {
  1231.  
  1232.          result = get_data((BYTE *)&data_float,
  1233.                            &read_buffer[byte_count],
  1234.                            sizeof(float));
  1235.          if (result != 0)
  1236.             return (EMBADADDR);
  1237.  
  1238.          fprintf(stderr, "%+1.6e ", (double) data_float);
  1239.      if (io_config.echo_mode == (INT32) TRUE)
  1240.          fprintf(io_config.echo_file, "%+1.6e ", (double) data_float);
  1241.  
  1242.          address = address + 1;
  1243.  
  1244.          byte_count = byte_count + sizeof(float);
  1245.  
  1246.          }  /* end if */
  1247.  
  1248.       }  /* end while */
  1249.  
  1250.    fprintf(stderr, "\n");
  1251.    if (io_config.echo_mode == (INT32) TRUE)
  1252.    fprintf(io_config.echo_file, "\n");
  1253.  
  1254.    return (0);
  1255.    }  /* end dump_reg_float() */
  1256.  
  1257.  
  1258.  
  1259.  
  1260. /*
  1261. ** This function is used to dump memory as doubles.
  1262. */
  1263.  
  1264. int
  1265. dump_mem_double(memory_space, read_address, bytes_returned, read_buffer)
  1266.    INT32  memory_space;
  1267.    ADDR32 read_address;
  1268.    INT32  bytes_returned;
  1269.    BYTE   *read_buffer;
  1270.    {
  1271.    int      result;
  1272.    ADDR32   address;
  1273.    ADDR32   start_address;
  1274.    ADDR32   end_address;
  1275.    ADDR32   last_print_address;
  1276.    ADDR32   address_mask;
  1277.    INT32    byte_count;
  1278.    double   data_double;
  1279.    struct   addr_29k_t addr_29k;
  1280.  
  1281.    byte_count = 0;
  1282.  
  1283.    address_mask = 0xfffffff0;
  1284.    start_address = read_address;
  1285.    end_address = read_address + bytes_returned;
  1286.    last_print_address = (end_address + 0xf) & address_mask;
  1287.    address = start_address & address_mask;
  1288.  
  1289.    /*
  1290.    ** Loop while data available
  1291.    */
  1292.  
  1293.    while (address <= last_print_address) {
  1294.  
  1295.       /* Exit if address not valid */
  1296.       addr_29k.memory_space = memory_space;
  1297.       addr_29k.address = address;
  1298.       result = addr_29k_ok(&addr_29k);
  1299.       if (result != 0) {
  1300.          fprintf(stderr, "\n\n");
  1301.      if (io_config.echo_mode == (INT32) TRUE)
  1302.          fprintf(io_config.echo_file, "\n\n");
  1303.          return (0);
  1304.          }
  1305.  
  1306.       /* Print address in margin */
  1307.       if (((address & address_mask) == address) &&
  1308.           (address != last_print_address)) {
  1309.          fprintf(stderr, "\n");
  1310.      if (io_config.echo_mode == (INT32) TRUE)
  1311.          fprintf(io_config.echo_file, "\n");
  1312.          result = print_addr_29k(memory_space, address);
  1313.          if (result != 0)
  1314.             return (EMBADADDR);
  1315.          }
  1316.  
  1317.       /* Do leading and trailing spaces (if necessary) */
  1318.       if ((address < start_address) ||
  1319.           (address >= end_address)) {
  1320.          fprintf(stderr, "                        ");
  1321.      if (io_config.echo_mode == (INT32) TRUE)
  1322.          fprintf(io_config.echo_file, "                        ");
  1323.          address = address + sizeof(double);
  1324.          }
  1325.  
  1326.       /* Print out hex data */
  1327.       if ((address >= start_address) &&
  1328.           (address < end_address)) {
  1329.  
  1330.          result = get_data((BYTE *)&data_double,
  1331.                            &read_buffer[byte_count],
  1332.                            sizeof(double));
  1333.          if (result != 0)
  1334.             return (EMBADADDR);
  1335.  
  1336.          fprintf(stderr, "%+1.15e ", data_double);
  1337.      if (io_config.echo_mode == (INT32) TRUE)
  1338.          fprintf(io_config.echo_file, "%+1.15e ", data_double);
  1339.  
  1340.          address = address + sizeof(double);
  1341.  
  1342.          byte_count = byte_count + sizeof(double);
  1343.  
  1344.          }  /* end if */
  1345.  
  1346.       }  /* end while */
  1347.  
  1348.    fprintf(stderr, "\n");
  1349.    if (io_config.echo_mode == (INT32) TRUE)
  1350.    fprintf(io_config.echo_file, "\n");
  1351.  
  1352.    return (0);
  1353.    }  /* end dump_mem_double() */
  1354.  
  1355.  
  1356.  
  1357.  
  1358. /*
  1359. ** This function is used to dump registers as doubles.
  1360. */
  1361.  
  1362. int
  1363. dump_reg_double(memory_space, read_address, bytes_returned, read_buffer)
  1364.    INT32  memory_space;
  1365.    ADDR32 read_address;
  1366.    INT32  bytes_returned;
  1367.    BYTE   *read_buffer;
  1368.    {
  1369.    int      result;
  1370.    ADDR32   address;
  1371.    ADDR32   start_address;
  1372.    ADDR32   end_address;
  1373.    ADDR32   last_print_address;
  1374.    ADDR32   address_mask;
  1375.    INT32    byte_count;
  1376.    double   data_double;
  1377.    struct   addr_29k_t addr_29k;
  1378.  
  1379.    byte_count = 0;
  1380.  
  1381.    address_mask = 0xfffffffc;
  1382.    start_address = read_address;
  1383.    end_address = read_address + (bytes_returned / 4);
  1384.    last_print_address = (end_address + 0x3) & address_mask;
  1385.    address = start_address & address_mask;
  1386.  
  1387.    /*
  1388.    ** Loop while data available
  1389.    */
  1390.  
  1391.    while (address <= last_print_address) {
  1392.  
  1393.       /* Exit if address not valid */
  1394.       addr_29k.memory_space = memory_space;
  1395.       addr_29k.address = address;
  1396.       result = addr_29k_ok(&addr_29k);
  1397.       if (result != 0) {
  1398.          fprintf(stderr, "\n\n");
  1399.      if (io_config.echo_mode == (INT32) TRUE)
  1400.          fprintf(io_config.echo_file, "\n\n");
  1401.          return (0);
  1402.          }
  1403.  
  1404.       /* Print address in margin */
  1405.       if (((address & address_mask) == address) &&
  1406.           (address != last_print_address)) {
  1407.          fprintf(stderr, "\n");
  1408.      if (io_config.echo_mode == (INT32) TRUE)
  1409.          fprintf(io_config.echo_file, "\n");
  1410.          result = print_addr_29k(memory_space, address);
  1411.          if (result != 0)
  1412.             return (EMBADADDR);
  1413.          }
  1414.  
  1415.       /* Do leading and trailing spaces (if necessary) */
  1416.       if ((address < start_address) ||
  1417.           (address >= end_address)) {
  1418.          fprintf(stderr, "                        ");
  1419.      if (io_config.echo_mode == (INT32) TRUE)
  1420.          fprintf(io_config.echo_file, "                        ");
  1421.          address = address + 2;
  1422.          }
  1423.  
  1424.       /* Print out hex data */
  1425.       if ((address >= start_address) &&
  1426.           (address < end_address)) {
  1427.  
  1428.          result = get_data((BYTE *)&data_double,
  1429.                            &read_buffer[byte_count],
  1430.                            sizeof(double));
  1431.          if (result != 0)
  1432.             return (EMBADADDR);
  1433.  
  1434.          fprintf(stderr, "%+1.15e ", data_double);
  1435.      if (io_config.echo_mode == (INT32) TRUE)
  1436.          fprintf(io_config.echo_file, "%+1.15e ", data_double);
  1437.  
  1438.          address = address + (sizeof(double) / sizeof(INT32));
  1439.  
  1440.          byte_count = byte_count + sizeof(double);
  1441.  
  1442.          }  /* end if */
  1443.  
  1444.       }  /* end while */
  1445.  
  1446.    fprintf(stderr, "\n");
  1447.    if (io_config.echo_mode == (INT32) TRUE)
  1448.    fprintf(io_config.echo_file, "\n");
  1449.  
  1450.    return (0);
  1451.    }  /* end dump_reg_double() */
  1452.  
  1453. /*
  1454. ** This function fills in a buffer with a character
  1455. ** representation of the dumped data.
  1456. */
  1457.  
  1458. int
  1459. dump_ASCII(buffer, index, data, size)
  1460.    char    *buffer;
  1461.    int      index;
  1462.    BYTE    *data;
  1463.    int      size;
  1464.    {
  1465.    INT32    i;
  1466.  
  1467.    /* Do ASCII dump */
  1468.    for (i=0; i<size; i=i+1)
  1469.       if (data == NULL)
  1470.          buffer[index+i] = ' ';
  1471.       else
  1472.          if (isprint(data[i]))
  1473.             buffer[index+i] = data[i];
  1474.             else
  1475.                buffer[index+i] = '.';
  1476.  
  1477.    buffer[index+i] = '\0';  /* Null terminate */
  1478.  
  1479.    return (0);
  1480.  
  1481.    }  /* end dump_ASCII() */
  1482.  
  1483.