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 / getdata.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-23  |  19.7 KB  |  808 lines
  1. static char _[] = "@(#)getdata.c    5.21 93/07/30 16:38:33, 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 file contains functions used to parse strings into
  31.  **       various data structures. 
  32.  **
  33.  *****************************************************************************
  34.  */
  35.  
  36. #include <stdio.h>
  37. #include <ctype.h>
  38. #include "memspcs.h"
  39. #include "main.h"
  40. #include "opcodes.h"
  41. #include "macros.h"
  42. #include "error.h"
  43.  
  44. #ifdef MSDOS
  45. #include <string.h>
  46. #else
  47. #include <string.h>
  48. #endif
  49.  
  50. /* Function declarations */
  51. int get_data PARAMS(( BYTE  *out_data, BYTE  *in_data, int    size));
  52. int set_data PARAMS((BYTE *out_data, BYTE *in_data, int size));
  53. int get_word_decimal PARAMS((char *buffer, INT32 *data_word));
  54. int get_double PARAMS((char *buffer, double *data_double));
  55. int get_float PARAMS((char *buffer, float *data_float));
  56. int get_byte PARAMS((char *buffer, BYTE  *data_byte));
  57. int get_half PARAMS((char *buffer, INT16 *data_half));
  58. int get_word PARAMS((char *buffer, INT32 *data_word));
  59. int get_alias_29k PARAMS((char  *reg_str, struct addr_29k_t *addr_29k));
  60. int get_register_29k PARAMS((char *reg_str,struct addr_29k_t *addr_29k));
  61. int get_memory_29k PARAMS((char *memory_str, struct addr_29k_t *addr_29k, INT32 default_space));
  62. int print_addr_29k PARAMS((INT32 memory_space, ADDR32 address));
  63. int addr_29k_ok PARAMS((struct addr_29k_t *addr_29k));
  64. int get_addr_29k PARAMS((char *addr_str, struct addr_29k_t *addr_29k));
  65. int get_addr_29k_m PARAMS((char *addr_str, struct addr_29k_t *addr_29k, INT32 default_space));
  66. void convert16 PARAMS(( BYTE *byte));
  67. void convert32 PARAMS(( BYTE *byte));
  68.  
  69.  
  70. /*
  71. ** This function is used to parse a string into the
  72. ** memory space / address pair used by the Am29000.
  73. ** the memory spaces supported are in the "memspcs.h"
  74. ** file.
  75. **
  76. ** The strings parsed are:
  77. **
  78. **    lr0 to gr127  (Local registers)
  79. **    gr0 to gr127  (Global registers)
  80. **    sr0 to sr127  (Special registers)
  81. **    tr0 to tr127  (TLB registers)
  82. **    xr0 to xr32   (Coprocessor registers)
  83. **       and
  84. **    <hex_addr>{i|r|d}
  85. **
  86. ** If successful, the Am29000 memory space / address pair
  87. ** pointed to by addr_29k is filled in and zero is returned.
  88. ** If unsuccessful, a -1 is returned and the values in
  89. ** addr_29k are undefined.
  90. **
  91. ** Note:  This function expects an unpadded, lower case
  92. **        ASCII string.
  93. */
  94.  
  95.  
  96. int
  97. get_addr_29k(addr_str, addr_29k)
  98.    char   *addr_str;
  99.    struct  addr_29k_t  *addr_29k;
  100.    {
  101.    /* defaults memory addresses to D_MEM */
  102.    return(get_addr_29k_m(addr_str, addr_29k, D_MEM));
  103.    } 
  104.  
  105.  
  106. int
  107. get_addr_29k_m(addr_str, addr_29k, default_space)
  108.    char   *addr_str;
  109.    struct  addr_29k_t  *addr_29k;
  110.    INT32   default_space;    /* for default if no space given in string */
  111.    {
  112.    int  result;
  113.  
  114.    result = get_memory_29k(addr_str, addr_29k, default_space);
  115.  
  116.    if (result != 0)
  117.       result = get_register_29k(addr_str, addr_29k);
  118.  
  119.    if (result != 0)
  120.       result = get_alias_29k(addr_str, addr_29k);
  121.  
  122.    return (result);
  123.    }  /* end get_addr_29k() */
  124.  
  125.  
  126. /*
  127. ** This function is used to verify that an Am29000
  128. ** memory space / address pair contains a valid address.
  129. ** The memory spaces supported are those defined in the
  130. ** "memspcs.h" header file.
  131. **
  132. ** The global structure "target_config" is also used to
  133. ** do range checking.
  134. **
  135. ** If successful, a 0 is returned, otherwise -1 is
  136. ** returned.
  137. */
  138.  
  139.  
  140. int
  141. addr_29k_ok(addr_29k)
  142.    struct  addr_29k_t  *addr_29k;
  143.    {
  144.    int     return_code;
  145.    ADDR32  start_addr;
  146.    ADDR32  end_addr;
  147.  
  148.    return_code = 0;
  149.  
  150.    if (addr_29k->memory_space == LOCAL_REG) {
  151.       if (addr_29k->address > 127)
  152.          return_code = EMBADREG;
  153.       }
  154.    else
  155.    if (addr_29k->memory_space == ABSOLUTE_REG) {
  156.     if ((addr_29k->address >= 0) && (addr_29k->address <= 255))
  157.        return (0);
  158.     else
  159.        return (EMBADREG);
  160.       }
  161.    else
  162.    if (addr_29k->memory_space == GLOBAL_REG) {
  163.       if (PROCESSOR(target_config.processor_id) == PROC_AM29050) {
  164.          if ( ((addr_29k->address > 3) &&
  165.               (addr_29k->address < 64)) ||
  166.  
  167.               (addr_29k->address > 127))
  168.             return_code = EMBADREG;
  169.       } else {
  170.          if ( ((addr_29k->address > 1) &&
  171.               (addr_29k->address < 64)) ||
  172.  
  173.               (addr_29k->address > 127))
  174.             return_code = EMBADREG;
  175.        }
  176.    } else /* Note:  Am29xxx procesors have different SPECIAL_REGs */
  177.    if ((addr_29k->memory_space == SPECIAL_REG) ||
  178.       (addr_29k->memory_space == A_SPCL_REG)) {
  179.  
  180.       if ((PROCESSOR(target_config.processor_id) == PROC_AM29030) ||
  181.          (PROCESSOR(target_config.processor_id) == PROC_AM29240) ||
  182.          (PROCESSOR(target_config.processor_id) == PROC_AM29035)) {
  183.  
  184.          if (((addr_29k->address > 14) &&
  185.               (addr_29k->address < 29)) ||
  186.  
  187.              ((addr_29k->address > 30) &&
  188.               (addr_29k->address < 128)) ||
  189.  
  190.              ((addr_29k->address > 135) &&
  191.               (addr_29k->address < 160)) ||
  192.  
  193.              ((addr_29k->address > 162) &&
  194.               (addr_29k->address < 164)) ||
  195.  
  196.               (addr_29k->address > 164))
  197.             return_code = EMBADREG;
  198.          }
  199.       else
  200.       if (PROCESSOR(target_config.processor_id) == PROC_AM29050) {
  201.  
  202.          if (((addr_29k->address > 26) &&
  203.               (addr_29k->address < 128)) ||
  204.  
  205.              ((addr_29k->address > 135) &&
  206.               (addr_29k->address < 160)) ||
  207.  
  208.               (addr_29k->address > 164))
  209.             return_code = EMBADREG;
  210.          }
  211.       else    /* default */
  212.          if (((addr_29k->address > 14) &&
  213.               (addr_29k->address < 128)) ||
  214.  
  215.              ((addr_29k->address > 135) &&
  216.               (addr_29k->address < 160)) ||
  217.  
  218.              ((addr_29k->address > 162) &&
  219.               (addr_29k->address < 164)) ||
  220.  
  221.               (addr_29k->address > 164))
  222.             return_code = EMBADREG;
  223.       }  /* end if (SPECIAL_REG) */
  224.    else
  225.    if (addr_29k->memory_space == TLB_REG) {
  226.       if (addr_29k->address > 127)
  227.          return_code = EMBADREG;
  228.       }
  229.    else
  230.    if (addr_29k->memory_space == COPROC_REG) {
  231.       if (target_config.coprocessor != 0)
  232.          return_code = EMBADREG;
  233.       if (addr_29k->address > 32)
  234.          return_code = EMBADREG;
  235.       }
  236.    else
  237.    if (addr_29k->memory_space == PC_SPACE) {
  238.       return (0);
  239.      }
  240.    else
  241.    if (addr_29k->memory_space == GENERIC_SPACE) {
  242.       return (0);
  243.      }
  244.    else
  245.    if (addr_29k->memory_space == I_MEM) {
  246.       start_addr = target_config.I_mem_start;
  247.       end_addr = start_addr + (ADDR32) target_config.I_mem_size;
  248.       if ((addr_29k->address < start_addr) ||
  249.           (addr_29k->address > end_addr))
  250.          return_code = EMBADADDR;
  251.       }
  252.    else
  253.    if (addr_29k->memory_space == D_MEM) {
  254.       start_addr = target_config.D_mem_start;
  255.       end_addr = start_addr + (ADDR32) target_config.D_mem_size;
  256.       if ((addr_29k->address < start_addr) ||
  257.           (addr_29k->address > end_addr))
  258.          return_code = EMBADADDR;
  259.       }
  260.    else
  261.    if (addr_29k->memory_space == I_ROM) {
  262.       start_addr = target_config.ROM_start;
  263.       end_addr = start_addr + (ADDR32) target_config.ROM_size;
  264.       if ((addr_29k->address < start_addr) ||
  265.           (addr_29k->address > end_addr))
  266.          return_code = EMBADADDR;
  267.       }
  268.    else
  269.    if (addr_29k->memory_space == D_ROM) {
  270.          return_code = EMBADADDR;  /* We don't use this memory space */
  271.       }
  272.    else
  273.    if (addr_29k->memory_space == I_O) {
  274.       return (0);  /* No checking on I/O space */
  275.       }
  276.    else
  277.       return_code = EMBADADDR;  /* Unknown memory space */
  278.  
  279.    return (return_code);
  280.  
  281.    }  /* end addr_29k_ok() */
  282.  
  283.  
  284.  
  285.  
  286.  
  287. /*
  288. ** This function is used to print out an address.  The
  289. ** parameters are a memory_space and an address.  This
  290. ** function returns a 0 if the command was successful and
  291. ** a -1 on failure.
  292. **
  293. ** The strings printed are:
  294. **
  295. **    lr0 to gr127  (Local registers)
  296. **    gr0 to gr127  (Global registers)
  297. **    sr0 to sr127  (Special registers)
  298. **    tr0 to tr127  (TLB registers)
  299. **    xr0 to xr32   (Coprocessor registers)
  300. **    <hex_addr>    (Data memory)
  301. **    <hex_addr>i   (instruction memory)
  302. **       and
  303. **    <hex_addr>r   (ROM memory)
  304. **
  305. */
  306.  
  307.  
  308. int
  309. print_addr_29k(memory_space, address)
  310.    INT32   memory_space;
  311.    ADDR32  address;
  312.    {
  313.    char        buf[80];
  314.  
  315.    if (memory_space == LOCAL_REG)
  316.       sprintf(&buf[0], "lr%03ld      ", address);
  317.    else
  318.    if (memory_space == ABSOLUTE_REG)
  319.       sprintf(&buf[0], "ar%03ld      ", address);
  320.    else
  321.    if (memory_space == GLOBAL_REG)
  322.       sprintf(&buf[0], "gr%03ld      ", address);
  323.    else
  324.    if ((memory_space == SPECIAL_REG) || (memory_space == A_SPCL_REG))
  325.       sprintf(&buf[0], "sr%03ld      ", address);
  326.    else
  327.    if (memory_space == PC_SPACE)
  328.       sprintf(&buf[0], "pc%03ld      ", address);
  329.    else
  330.    if (memory_space == TLB_REG)
  331.       sprintf(&buf[0], "tr%03ld      ", address);
  332.    else
  333.    if (memory_space == COPROC_REG)
  334.       sprintf(&buf[0], "xr%03ld      ", address);
  335.    else
  336.    if (memory_space == I_MEM)
  337.       sprintf(&buf[0], "%08lxi  ", address);
  338.    else
  339.    if (memory_space == D_MEM)
  340.       sprintf(&buf[0], "%08lx   ", address);
  341.    else
  342.    if (memory_space == GENERIC_SPACE)
  343.       sprintf(&buf[0], "%08lx   ", address);
  344.    else
  345.    if (memory_space == I_ROM)
  346.       sprintf(&buf[0], "%08lxr  ", address);
  347.    else
  348.    if (memory_space == D_ROM)
  349.       sprintf(&buf[0], "%08ldr  ", address);
  350.    else
  351.    if (memory_space == I_O)
  352.       sprintf(&buf[0], "%08lx(i/o)", address);
  353.    else
  354.       return (-1);
  355.  
  356.    fprintf (stderr, "%s", &buf[0]);
  357.    if (io_config.echo_mode == (INT32) TRUE)
  358.        fprintf (io_config.echo_file, "%s", &buf[0]);
  359.    return (0);      
  360.    }  /* end print_addr_29k() */
  361.  
  362.  
  363.  
  364. /*
  365. ** This function is used to convert a string denoting a
  366. ** 29k address into an addr_29k_t memory space / address pair.
  367. ** This function recognizes the registers described in
  368. ** get_addr_29k() above.
  369. */
  370.  
  371. int
  372. get_memory_29k(memory_str, addr_29k, default_space)
  373.    char   *memory_str;
  374.    struct  addr_29k_t  *addr_29k;
  375.    INT32   default_space;
  376.    {
  377.    int     i;
  378.    int     fields;
  379.    int     string_length;
  380.    ADDR32  addr;
  381.    char    i_r;
  382.    char    error;
  383.  
  384.    addr_29k->memory_space = -1;
  385.    addr_29k->address = -1;
  386.  
  387.    addr = 0;
  388.    i_r = '\0';
  389.    error = '\0';
  390.  
  391.    /* Get rid of leading "0x" */
  392.    if ((strlen(memory_str) > 2) &&
  393.        (strncmp(memory_str, "0x", 2) == 0))
  394.       memory_str = &(memory_str[2]);
  395.  
  396.    string_length = strlen(memory_str);
  397.  
  398.    if ((string_length > 10) || (string_length < 1))
  399.       return (EMBADADDR);
  400.  
  401.    if (memory_str[0] == '.') {/* relative offset */
  402.      fields = sscanf(&memory_str[1], "%lx%c%c", &addr, &i_r, &error);
  403.       addr_29k->memory_space = PC_RELATIVE;
  404.       addr_29k->address = addr;
  405.       return (0);
  406.    } 
  407.  
  408.    for (i=1; i<(string_length-1); i=i+1)
  409.     if (isxdigit(memory_str[i]) == 0)
  410.        return (EMBADADDR);
  411.  
  412.    if ((isxdigit(memory_str[(string_length-1)]) == 0) &&
  413.        (memory_str[(string_length-1)] != 'i') &&
  414.        (memory_str[(string_length-1)] != 'm') &&
  415.        (memory_str[(string_length-1)] != 'u') &&
  416.        (memory_str[(string_length-1)] != 'p') &&
  417.        (memory_str[(string_length-1)] != 'r'))
  418.       return (EMBADADDR);
  419.  
  420.    fields = sscanf(memory_str, "%lx%c%c", &addr, &i_r, &error);
  421.  
  422.    addr_29k->address = addr;
  423.  
  424.    if (fields == 1) {
  425.       addr_29k->memory_space = default_space;
  426.       }
  427.    else
  428.    if (fields == 2) {
  429.       if ((i_r == '\0') || (i_r == 'm'))
  430.          addr_29k->memory_space = D_MEM;
  431.       else
  432.       if (i_r == 'r')
  433.          addr_29k->memory_space = I_ROM;
  434.       else
  435.       if (i_r == 'i')
  436.          addr_29k->memory_space = I_MEM;
  437.       else
  438.       if (i_r == 'p')
  439.      if ((target_config.processor_id & 0xf1) >= 0x50)
  440.             addr_29k->memory_space = GENERIC_SPACE;
  441.      else
  442.             addr_29k->memory_space = I_O;
  443.       else
  444.       if (i_r == 'u')
  445.          addr_29k->memory_space = GENERIC_SPACE;
  446.       else
  447.          return (EMBADADDR);
  448.       }
  449.    else
  450.       return (EMBADADDR);
  451.  
  452.    return (0);      
  453.    }  /* end get_memory_29k() */
  454.  
  455.  
  456.  
  457. /*
  458. ** This function is used to convert a string denoting an
  459. ** 29k register into an addr_29k_t memory space / address pair.
  460. */
  461.  
  462. int
  463. get_register_29k(reg_str, addr_29k)
  464.    char   *reg_str;
  465.    struct  addr_29k_t  *addr_29k;
  466.    {
  467.    int     fields;
  468.    ADDR32  reg_number;
  469.    char    error;
  470.  
  471.    addr_29k->memory_space = -1;
  472.    addr_29k->address = -1;
  473.  
  474.    reg_number = 0;
  475.    error = '\0';
  476.  
  477.    if (strlen(reg_str) > 8)
  478.       return (EMBADREG);
  479.  
  480.    if (strncmp(reg_str, "lr", 2) == 0)
  481.       addr_29k->memory_space = LOCAL_REG;
  482.    else
  483.    if (strncmp(reg_str, "ar", 2) == 0)
  484.       addr_29k->memory_space = ABSOLUTE_REG;
  485.    else
  486.    if (strncmp(reg_str, "gr", 2) == 0)
  487.       addr_29k->memory_space = GLOBAL_REG;
  488.    else
  489.    if (strncmp(reg_str, "sr", 2) == 0)
  490.       addr_29k->memory_space = A_SPCL_REG;
  491.    else
  492.    if (strncmp(reg_str, "tr", 2) == 0)
  493.       addr_29k->memory_space = TLB_REG;
  494.    else
  495.    if (strncmp(reg_str, "xr", 2) == 0)
  496.      addr_29k->memory_space = COPROC_REG;
  497.  
  498.    /* Get register number */
  499.    if (addr_29k->memory_space != -1) {
  500.       fields = sscanf(&(reg_str[2]), "%ld%c", ®_number, &error);
  501.       if ((fields == 1) &&
  502.           (error == '\0')) 
  503.          addr_29k->address = reg_number;
  504.          else
  505.             addr_29k->memory_space = -1;
  506.       }
  507.  
  508.    if (addr_29k->memory_space == -1)
  509.       return (EMBADREG);
  510.       else
  511.          return (0);      
  512.    }  /* end get_register_29k() */
  513.  
  514.  
  515.  
  516.  
  517. /*
  518. ** This function is used to get the special register aliases
  519. ** ("cps", "vab", "ops", etc ...) in addition to the registers
  520. ** described in get_addr_29k() above.
  521. */
  522.  
  523. int
  524. get_alias_29k(reg_str, addr_29k)
  525.    char   *reg_str;
  526.    struct  addr_29k_t  *addr_29k;
  527.    {
  528.    int     i;
  529.    int     result;
  530.    int     found;
  531.  
  532.    addr_29k->memory_space = -1;
  533.    addr_29k->address = -1;
  534.  
  535.    if (strlen(reg_str) > 8)
  536.       return (EMBADREG);
  537.  
  538.    /* Check for logical PC */
  539.    if ((strcmp("pc", reg_str) == 0) ||
  540.        (strcmp("PC", reg_str) == 0)) {
  541.          addr_29k->memory_space = PC_SPACE;
  542.          addr_29k->address = (ADDR32) 0;
  543.      return (0);
  544.    }
  545.    /* Search for a special register alias */
  546.    i=0;
  547.    found = FALSE;
  548.    while ((i<256) && (found != TRUE)) {
  549.       result = strcmp(spreg[i], reg_str);
  550.       if (result == 0) {
  551.          found = TRUE;
  552.          addr_29k->memory_space = A_SPCL_REG;
  553.          addr_29k->address = (ADDR32) i;
  554.          }
  555.       i = i + 1;
  556.       }  /* end while */
  557.  
  558.    if (found == TRUE)
  559.       return (0);      
  560.       else
  561.          return (EMBADREG);
  562.  
  563.    }  /* end get_alias_29k() */
  564.  
  565.  
  566.  
  567.  
  568.  
  569. /*
  570. ** This function is used to read in a 32 bit hex word.
  571. ** This word is input as an ASCII string and converted
  572. ** into an INT32 data_word.  If the conversion is successful,
  573. ** a zero is returned, otherwise a -1 is returned.
  574. */
  575.  
  576. int
  577. get_word(buffer, data_word)
  578.    char    *buffer;
  579.    INT32   *data_word;
  580.    {
  581.    int      fields;
  582.    char     error;
  583.  
  584.    /* No more than eight (hex) characters */
  585.    if (strlen(buffer) > 8)
  586.       return (EMSYNTAX);
  587.  
  588.    fields = sscanf(buffer, "%lx%c", data_word, &error);
  589.  
  590.    if (fields != 1)
  591.       return (EMSYNTAX);
  592.  
  593.    return (0);
  594.  
  595.    }  /* end get_word() */
  596.  
  597.  
  598.  
  599. int
  600. get_half(buffer, data_half)
  601.    char    *buffer;
  602.    INT16   *data_half;
  603.    {
  604.    int      fields;
  605.    char     error;
  606.    INT16      temp_int;
  607.  
  608.    /* No more than four (hex) characters */
  609.    if (strlen(buffer) > 4)
  610.       return (EMSYNTAX);
  611.  
  612.    fields = sscanf(buffer, "%hx%c", &temp_int, &error);
  613.  
  614.    if (fields != 1)
  615.       return (EMSYNTAX);
  616.  
  617.    *data_half = (INT16) temp_int;
  618.  
  619.    return (0);
  620.  
  621.    }  /* end get_half() */
  622.  
  623.  
  624. int
  625. get_byte(buffer, data_byte)
  626.    char    *buffer;
  627.    BYTE    *data_byte;
  628.    {
  629.    int      fields;
  630.    char     error;
  631.    int      temp_int;
  632.  
  633.    /* No more than two (hex) characters */
  634.    if (strlen(buffer) > 2)
  635.       return (EMSYNTAX);
  636.  
  637.    fields = sscanf(buffer, "%x%c", &temp_int, &error);
  638.  
  639.    if (fields != 1)
  640.       return (EMSYNTAX);
  641.  
  642.    *data_byte = (BYTE) temp_int;
  643.  
  644.    return (0);
  645.  
  646.    }  /* end get_byte() */
  647.  
  648.  
  649. int
  650. get_float(buffer, data_float)
  651.    char    *buffer;
  652.    float   *data_float;
  653.    {
  654.    int      fields;
  655.    char     error;
  656.  
  657.    fields = sscanf(buffer, "%f%c", data_float, &error);
  658.  
  659.    if (fields != 1)
  660.       return (EMSYNTAX);
  661.  
  662.    return (0);
  663.  
  664.    }  /* end get_float() */
  665.  
  666.  
  667. int
  668. get_double(buffer, data_double)
  669.    char    *buffer;
  670.    double  *data_double;
  671.    {
  672.    int      fields;
  673.    char     error;
  674.  
  675.    fields = sscanf(buffer, "%lf%c", data_double, &error);
  676.  
  677.    if (fields != 1)
  678.       return (EMSYNTAX);
  679.  
  680.    return (0);
  681.  
  682.  
  683.    }  /* end get_double() */
  684.  
  685.  
  686.  
  687.  
  688. /*
  689. ** This function is used to read in a 32 bit decimal word.
  690. ** This word is input as an ASCII string and converted
  691. ** into an INT32 data_word.  If the conversion is successful,
  692. ** a zero is returned, otherwise a -1 is returned.
  693. ** This function is very similar to get_word().
  694. */
  695.  
  696. int
  697. get_word_decimal(buffer, data_word)
  698.    char    *buffer;
  699.    INT32   *data_word;
  700.    {
  701.    int      fields;
  702.    char     error;
  703.  
  704.    /* No more than eight (hex) characters */
  705.    if (strlen(buffer) > 8)
  706.       return (EMSYNTAX);
  707.  
  708.    fields = sscanf(buffer, "%ld%c", data_word, &error);
  709.  
  710.    if (fields != 1)
  711.       return (EMSYNTAX);
  712.  
  713.    return (0);
  714.  
  715.    }  /* end get_word_decimal() */
  716.  
  717.  
  718. /*
  719. ** This function is used to copy data from into and out
  720. ** of the message buffers.  If necessary, endian
  721. ** conversion is performed.
  722. */
  723.  
  724. int
  725. set_data(out_data, in_data, size)
  726.    BYTE  *out_data;
  727.    BYTE  *in_data;
  728.    int    size;
  729.    {
  730.    int  i;
  731.  
  732.    if (host_config.host_endian == host_config.target_endian)
  733.       for (i=0; i<size; i=i+1)
  734.          out_data[i] = in_data[i];
  735.       else
  736.          for (i=0; i<size; i=i+1)
  737.             out_data[i] = in_data[((size-1)-i)];
  738.  
  739.    return (0);      
  740.    }  /* end set_data() */
  741.  
  742.  
  743.  
  744.  
  745. /*
  746. ** This function is used to get data.
  747. ** If necessary, endian conversion is performed.
  748. */
  749.  
  750. int
  751. get_data(out_data, in_data, size)
  752.    BYTE  *out_data;
  753.    BYTE  *in_data;
  754.    int    size;
  755.    {
  756.    int  i;
  757.  
  758.    if (host_config.host_endian == host_config.target_endian)
  759.       for (i=0; i<size; i=i+1)
  760.          out_data[i] = in_data[i];
  761.       else
  762.          for (i=0; i<size; i=i+1)
  763.             out_data[i] = in_data[((size-1)-i)];
  764.  
  765.    return (0);      
  766.    }  /* end get_data() */
  767.  
  768.  
  769.  
  770. /*
  771. ** This function is used to swap the bytes in a 32 bit
  772. ** word.  This will convert "little endian" (IBM-PC / Intel)
  773. ** words to "big endian" (Sun / Motorola) words.
  774. */
  775.  
  776. void
  777. convert32(byte)
  778.    BYTE *byte;
  779.    {
  780.    BYTE temp;
  781.  
  782.    temp = byte[0];  /* Swap bytes 0 and 3 */
  783.    byte[0] = byte[3];
  784.    byte[3] = temp;
  785.    temp = byte[1];  /* Swap bytes 1 and 2 */
  786.    byte[1] = byte[2];
  787.    byte[2] = temp;
  788.    }   /* end convert32() */
  789.  
  790.  
  791. /*
  792. ** This function is used to swap the bytes in a 16 bit
  793. ** word.  This will convert "little endian" (IBM-PC / Intel)
  794. ** half words to "big endian" (Sun / Motorola) half words.
  795. */
  796.  
  797. void
  798. convert16(byte)
  799.    BYTE *byte;
  800.    {
  801.    BYTE temp;
  802.  
  803.    temp = byte[0];  /* Swap bytes 0 and 1 */
  804.    byte[0] = byte[1];
  805.    byte[1] = temp;
  806.  
  807.    }   /* end convert16() */
  808.