gdb/nlm/alpha-patch.c

   1 #include <nwtypes.h>
   2 #include "alpha-patch.h"
   3 #include <errno.h>
   4 #include <stdio.h>
   5
   6 #define CONST const
   7
   8 /* This file provides stubs and equivalent interfaces for all functions that
   9    the debugger stub needs, but aren't yet implemented. */
  10
  11 int
  12 AIOReadData (int portHandle, char  *buffer, LONG length, LONG *numberBytesRead)
  13 {
  14   ULONG c;
  15
  16   while (1)
  17     {
  18       c = com_interrupt ();
  19       if ((c & ~0377) == COM1)
  20         break;
  21     }
  22
  23   *buffer = c;
  24   *numberBytesRead = 1;
  25
  26   return AIO_SUCCESS;
  27 }
  28
  29 int
  30 AIOWriteData (int portHandle, char *buffer, LONG length,
  31               LONG *numberBytesWritten)
  32
  33 {
  34   *numberBytesWritten = length;
  35
  36   while (length-- > 0)
  37     uart_putchar (COM1, *buffer++);
  38
  39   return AIO_SUCCESS;
  40 }
  41
  42 int
  43 AIOAcquirePort (int *hardwareType, int *boardNumber, int *portNumber,
  44                 int *portHandle)
  45 {
  46   return AIO_SUCCESS;
  47 }
  48
  49 int
  50 AIOConfigurePort (int portHandle, BYTE bitRate, BYTE dataBits, BYTE stopBits,
  51                   BYTE parityMode, BYTE flowCtrlMode)
  52 {
  53   uart_init_line (1, 9600);
  54
  55   return AIO_SUCCESS;
  56 }
  57
  58 int
  59 AIOGetPortConfiguration (int portHandle, AIOPORTCONFIG *pPortConfig,
  60                              AIODVRCONFIG *pDvrConfig)
  61 {
  62   fprintf (stderr, "AIOGetPortConfiguration stubbed out\n");
  63   exit (1);
  64 }
  65
  66 int
  67 AIOReleasePort (int portHandle)
  68 {
  69   return AIO_SUCCESS;
  70 }
  71
  72 int
  73 AIOSetExternalControl (int portHandle, int requestType, int requestValue)
  74 {
  75   return AIO_SUCCESS;
  76 }
  77
  78 int
  79 AIOGetExternalStatus (int portHandle, LONG *extStatus, LONG *chgdExtStatus)
  80 {
  81   fprintf (stderr, "AIOGetExternalStatus stubbed out\n");
  82   exit (1);
  83 }
  84
  85 void
  86 StopBell ()
  87 {
  88 }
  89
  90 int
  91 Breakpoint (int __arg)
  92 {
  93   fprintf (stderr, "Breakpoint() stubbed out\n");
  94   exit (1);
  95 }
  96
  97 /*
  98  * strtol : convert a string to long.
  99  *
 100  * Andy Wilson, 2-Oct-89.
 101  */
 102
 103 /* FIXME: It'd be nice to configure around these, but the include files are too
 104    painful.  These macros should at least be more portable than hardwired hex
 105    constants. */
 106
 107 #define ULONG_MAX       ((unsigned long)(~0L))          /* 0xFFFFFFFF */
 108 #define LONG_MAX        ((long)(ULONG_MAX >> 1))        /* 0x7FFFFFFF */
 109 #define LONG_MIN        ((long)(~LONG_MAX))             /* 0x80000000 */
 110
 111 extern int errno;
 112
 113 long
 114 strtol(s, ptr, base)
 115      CONST char *s; char **ptr; int base;
 116 {
 117   extern unsigned long  strtoul();
 118   int minus=0;
 119   unsigned long tmp;
 120   CONST char *start=s, *eptr;
 121
 122   if (s==NULL)
 123     {
 124       errno = ERANGE;
 125       if (!ptr)
 126         *ptr = (char *)start;
 127       return 0L;
 128     }
 129   while (isspace(*s))
 130         s++;
 131   if (*s == '-') {
 132         s++;
 133         minus = 1;
 134       }
 135   else if (*s == '+')
 136     s++;
 137
 138   /*
 139    * let strtoul do the hard work.
 140    */
 141   tmp = strtoul(s, &eptr, base);
 142   if (ptr != NULL)
 143     *ptr = (char *)((eptr==s) ? (char *)start : eptr);
 144   if (tmp > (minus ? - (unsigned long) LONG_MIN : (unsigned long) LONG_MAX))
 145     {
 146       errno = ERANGE;
 147       return (minus ? LONG_MIN : LONG_MAX);
 148     }
 149   return (minus ? (long) -tmp : (long) tmp);
 150 }
 151
 152 /*
 153  * strtol : convert a string to long.
 154  *
 155  * Andy Wilson, 2-Oct-89.
 156  */
 157
 158 #ifndef ULONG_MAX
 159 #define ULONG_MAX       ((unsigned long)(~0L))          /* 0xFFFFFFFF */
 160 #endif
 161
 162 extern int errno;
 163
 164 unsigned long
 165 strtoul(s, ptr, base)
 166      CONST char *s; char **ptr; int base;
 167 {
 168   unsigned long total = 0;
 169   unsigned digit;
 170   CONST char *start=s;
 171   int did_conversion=0;
 172   int overflow = 0;
 173   int negate = 0;
 174   unsigned long maxdiv, maxrem;
 175
 176   if (s==NULL)
 177     {
 178       errno = ERANGE;
 179       if (!ptr)
 180         *ptr = (char *)start;
 181       return 0L;
 182     }
 183
 184   while (isspace(*s))
 185     s++;
 186   if (*s == '+')
 187     s++;
 188   else if (*s == '-')
 189     s++, negate = 1;
 190   if (base==0 || base==16) /*  the 'base==16' is for handling 0x */
 191     {
 192       int tmp;
 193
 194       /*
 195        * try to infer base from the string
 196        */
 197       if (*s != '0')
 198         tmp = 10;       /* doesn't start with 0 - assume decimal */
 199       else if (s[1] == 'X' || s[1] == 'x')
 200         tmp = 16, s += 2; /* starts with 0x or 0X - hence hex */
 201       else
 202         tmp = 8;        /* starts with 0 - hence octal */
 203       if (base==0)
 204         base = (int)tmp;
 205     }
 206
 207   maxdiv = ULONG_MAX / base;
 208   maxrem = ULONG_MAX % base;
 209
 210   while ((digit = *s) != '\0')
 211     {
 212       if (digit >= '0' && digit < ('0'+base))
 213         digit -= '0';
 214       else
 215         if (base > 10)
 216           {
 217             if (digit >= 'a' && digit < ('a'+(base-10)))
 218               digit = digit - 'a' + 10;
 219             else if (digit >= 'A' && digit < ('A'+(base-10)))
 220               digit = digit - 'A' + 10;
 221             else
 222               break;
 223           }
 224         else
 225           break;
 226       did_conversion = 1;
 227       if (total > maxdiv
 228           || (total == maxdiv && digit > maxrem))
 229         overflow = 1;
 230       total = (total * base) + digit;
 231       s++;
 232     }
 233   if (overflow)
 234     {
 235       errno = ERANGE;
 236       if (ptr != NULL)
 237         *ptr = (char *)s;
 238       return (ULONG_MAX);
 239     }
 240   if (ptr != NULL)
 241     *ptr = (char *) ((did_conversion) ? (char *)s : (char *)start);
 242   return negate ? -total : total;
 243 }