ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/hybrid-ircservices-1/compat.c
(Generate patch)

Comparing hybrid-ircservices-1/compat.c (file contents):
Revision 1208 by michael, Mon Aug 22 18:55:33 2011 UTC vs.
Revision 1209 by michael, Thu Aug 25 19:05:49 2011 UTC

# Line 19 | Line 19
19  
20   /* hstrerror: return an error message for the given h_errno code. */
21  
22 < const char *hstrerror(int h_errnum)
22 > const char *
23 > hstrerror(int h_errnum)
24   {
25 <    switch (h_errnum) {
26 <        case HOST_NOT_FOUND: return "Host not found";
27 <        case TRY_AGAIN:      return "Host not found, try again";
28 <        case NO_RECOVERY:    return "Nameserver error";
29 <        case NO_DATA:        return "No data of requested type";
30 <        default:             return "Unknown error";
31 <    }
25 >  switch (h_errnum)
26 >  {
27 >  case HOST_NOT_FOUND:
28 >    return "Host not found";
29 >  case TRY_AGAIN:
30 >    return "Host not found, try again";
31 >  case NO_RECOVERY:
32 >    return "Nameserver error";
33 >  case NO_DATA:
34 >    return "No data of requested type";
35 >  default:
36 >    return "Unknown error";
37 >  }
38   }
39  
40   #endif /* !HAVE_HSTRERROR */
# Line 42 | Line 49 | const char *hstrerror(int h_errnum)
49   */
50  
51   #if BAD_SNPRINTF
52 < int vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
52 > int
53 > vsnprintf(char *buf, size_t len, const char *fmt, va_list args)
54   {
55 <    if (len <= 0)
56 <        return 0;
57 <    *buf = 0;
55 >  if (len <= 0)
56 >    return 0;
57 >  *buf = 0;
58   #undef vsnprintf
59 <    vsnprintf(buf, len, fmt, args);
59 >  vsnprintf(buf, len, fmt, args);
60   #define vsnprintf my_vsnprintf
61 <    buf[len-1] = 0;
62 <    return strlen(buf);
61 >  buf[len - 1] = 0;
62 >  return strlen(buf);
63   }
64 < #endif  /* BAD_SNPRINTF */
64 > #endif /* BAD_SNPRINTF */
65  
66 < int snprintf(char *buf, size_t len, const char *fmt, ...)
66 > int
67 > snprintf(char *buf, size_t len, const char *fmt, ...)
68   {
69 <    va_list args;
70 <    int ret;
69 >  va_list args;
70 >  int ret;
71  
72 <    va_start(args, fmt);
73 <    ret = vsnprintf(buf, len, fmt, args);
74 <    va_end(args);
75 <    return ret;
72 >  va_start(args, fmt);
73 >  ret = vsnprintf(buf, len, fmt, args);
74 >  va_end(args);
75 >  return ret;
76   }
77  
78   #endif /* !HAVE_SNPRINTF */
# Line 78 | Line 87 | int snprintf(char *buf, size_t len, cons
87   * returning NULL for strtok(NULL, " ").
88   */
89  
90 < char *strtok(char *str, const char *delim)
90 > char *
91 > strtok(char *str, const char *delim)
92   {
93 <    static char *current = NULL;
94 <    char *ret;
93 >  static char *current = NULL;
94 >  char *ret;
95  
96 <    if (str)
97 <        current = str;
98 <    if (!current)
99 <        return NULL;
100 <    current += strspn(current, delim);
101 <    ret = *current ? current : NULL;
102 <    current += strcspn(current, delim);
103 <    if (!*current)
104 <        current = NULL;
105 <    else
106 <        *current++ = 0;
107 <    return ret;
96 >  if (str)
97 >    current = str;
98 >  if (!current)
99 >    return NULL;
100 >  current += strspn(current, delim);
101 >  ret = *current ? current : NULL;
102 >  current += strcspn(current, delim);
103 >  if (!*current)
104 >    current = NULL;
105 >  else
106 >    *current++ = 0;
107 >  return ret;
108   }
109  
110   #endif /* !HAVE_STRTOK */
# Line 107 | Line 117 | char *strtok(char *str, const char *deli
117   *                     strncmp().
118   */
119  
120 < int stricmp(const char *s1, const char *s2)
120 > int
121 > stricmp(const char *s1, const char *s2)
122   {
123 <    register int c;
123 >  register int c;
124  
125 <    while ((c = tolower(*s1)) == tolower(*s2)) {
126 <        if (c == 0)
127 <            return 0;
128 <        s1++;
129 <        s2++;
130 <    }
131 <    if (c < tolower(*s2))
132 <        return -1;
133 <    return 1;
134 < }
135 <
136 < int strnicmp(const char *s1, const char *s2, size_t len)
137 < {
138 <    register int c;
139 <
140 <    if (!len)
141 <        return 0;
142 <    while ((c = tolower(*s1)) == tolower(*s2) && len > 0) {
143 <        if (c == 0 || --len == 0)
144 <            return 0;
145 <        s1++;
146 <        s2++;
147 <    }
148 <    if (c < tolower(*s2))
149 <        return -1;
150 <    return 1;
125 >  while ((c = tolower(*s1)) == tolower(*s2))
126 >  {
127 >    if (c == 0)
128 >      return 0;
129 >    s1++;
130 >    s2++;
131 >  }
132 >  if (c < tolower(*s2))
133 >    return -1;
134 >  return 1;
135 > }
136 >
137 > int
138 > strnicmp(const char *s1, const char *s2, size_t len)
139 > {
140 >  register int c;
141 >
142 >  if (!len)
143 >    return 0;
144 >  while ((c = tolower(*s1)) == tolower(*s2) && len > 0)
145 >  {
146 >    if (c == 0 || --len == 0)
147 >      return 0;
148 >    s1++;
149 >    s2++;
150 >  }
151 >  if (c < tolower(*s2))
152 >    return -1;
153 >  return 1;
154   }
155   #endif
156  
157   /*************************************************************************/
158  
159   #if !HAVE_STRDUP && !MEMCHECKS
160 < char *strdup(const char *s)
160 > char *
161 > strdup(const char *s)
162   {
163 <    char *new = malloc(strlen(s)+1);
164 <    if (new)
165 <        strcpy(new, s);
166 <    return new;
163 >  char *new = malloc(strlen(s) + 1);
164 >  if (new)
165 >    strcpy(new, s);
166 >  return new;
167   }
168   #endif
169  
# Line 156 | Line 171 | char *strdup(const char *s)
171  
172   #if !HAVE_STRSPN
173  
174 < size_t strspn(const char *s, const char *accept)
174 > size_t
175 > strspn(const char *s, const char *accept)
176   {
177 <    size_t i = 0;
177 >  size_t i = 0;
178  
179 <    while (*s && strchr(accept, *s))
180 <        ++i, ++s;
181 <    return i;
179 >  while (*s && strchr(accept, *s))
180 >    ++i, ++s;
181 >  return i;
182   }
183  
184 < size_t strcspn(const char *s, const char *reject)
184 > size_t
185 > strcspn(const char *s, const char *reject)
186   {
187 <    size_t i = 0;
187 >  size_t i = 0;
188  
189 <    while (*s && !strchr(reject, *s))
190 <        ++i, ++s;
191 <    return i;
189 >  while (*s && !strchr(reject, *s))
190 >    ++i, ++s;
191 >  return i;
192   }
193  
194   #endif
# Line 183 | Line 200 | size_t strcspn(const char *s, const char
200   extern char *sys_errlist[];
201   # endif
202  
203 < char *strerror(int errnum)
203 > char *
204 > strerror(int errnum)
205   {
206   # if HAVE_SYS_ERRLIST
207 <    return sys_errlist[errnum];
207 >  return sys_errlist[errnum];
208   # else
209 <    static char buf[20];
210 <    snprintf(buf, sizeof(buf), "Error %d", errnum);
211 <    return buf;
209 >  static char buf[20];
210 >  snprintf(buf, sizeof(buf), "Error %d", errnum);
211 >  return buf;
212   # endif
213   }
214   #endif
# Line 198 | Line 216 | char *strerror(int errnum)
216   /*************************************************************************/
217  
218   #if !HAVE_STRSIGNAL
219 < char *strsignal(int signum)
219 > char *
220 > strsignal(int signum)
221   {
222 <    static char buf[32];
223 <    switch (signum) {
224 <        case SIGHUP:    strbcpy(buf, "Hangup");                         break;
225 <        case SIGINT:    strbcpy(buf, "Interrupt");                      break;
226 <        case SIGQUIT:   strbcpy(buf, "Quit");                           break;
222 >  static char buf[32];
223 >  switch (signum)
224 >  {
225 >  case SIGHUP:
226 >    strbcpy(buf, "Hangup");
227 >    break;
228 >  case SIGINT:
229 >    strbcpy(buf, "Interrupt");
230 >    break;
231 >  case SIGQUIT:
232 >    strbcpy(buf, "Quit");
233 >    break;
234   #ifdef SIGILL
235 <        case SIGILL:    strbcpy(buf, "Illegal instruction");            break;
235 >  case SIGILL:
236 >    strbcpy(buf, "Illegal instruction");
237 >    break;
238   #endif
239   #ifdef SIGABRT
240 <        case SIGABRT:   strbcpy(buf, "Abort");                          break;
240 >  case SIGABRT:
241 >    strbcpy(buf, "Abort");
242 >    break;
243   #endif
244   #if defined(SIGIOT) && (!defined(SIGABRT) || SIGIOT != SIGABRT)
245 <        case SIGIOT:    strbcpy(buf, "IOT trap");                       break;
245 >  case SIGIOT:
246 >    strbcpy(buf, "IOT trap");
247 >    break;
248   #endif
249   #ifdef SIGBUS
250 <        case SIGBUS:    strbcpy(buf, "Bus error");                      break;
250 >  case SIGBUS:
251 >    strbcpy(buf, "Bus error");
252 >    break;
253   #endif
254 <        case SIGFPE:    strbcpy(buf, "Floating point exception");       break;
255 <        case SIGKILL:   strbcpy(buf, "Killed");                         break;
256 <        case SIGUSR1:   strbcpy(buf, "User signal 1");                  break;
257 <        case SIGSEGV:   strbcpy(buf, "Segmentation fault");             break;
258 <        case SIGUSR2:   strbcpy(buf, "User signal 2");                  break;
259 <        case SIGPIPE:   strbcpy(buf, "Broken pipe");                    break;
260 <        case SIGALRM:   strbcpy(buf, "Alarm clock");                    break;
261 <        case SIGTERM:   strbcpy(buf, "Terminated");                     break;
262 <        case SIGSTOP:   strbcpy(buf, "Stopped (signal)");               break;
263 <        case SIGTSTP:   strbcpy(buf, "Stopped");                        break;
264 <        case SIGIO:     strbcpy(buf, "I/O error");                      break;
265 <        default:        snprintf(buf, sizeof(buf), "Signal %d\n", signum);
266 <                        break;
267 <    }
268 <    return buf;
254 >  case SIGFPE:
255 >    strbcpy(buf, "Floating point exception");
256 >    break;
257 >  case SIGKILL:
258 >    strbcpy(buf, "Killed");
259 >    break;
260 >  case SIGUSR1:
261 >    strbcpy(buf, "User signal 1");
262 >    break;
263 >  case SIGSEGV:
264 >    strbcpy(buf, "Segmentation fault");
265 >    break;
266 >  case SIGUSR2:
267 >    strbcpy(buf, "User signal 2");
268 >    break;
269 >  case SIGPIPE:
270 >    strbcpy(buf, "Broken pipe");
271 >    break;
272 >  case SIGALRM:
273 >    strbcpy(buf, "Alarm clock");
274 >    break;
275 >  case SIGTERM:
276 >    strbcpy(buf, "Terminated");
277 >    break;
278 >  case SIGSTOP:
279 >    strbcpy(buf, "Stopped (signal)");
280 >    break;
281 >  case SIGTSTP:
282 >    strbcpy(buf, "Stopped");
283 >    break;
284 >  case SIGIO:
285 >    strbcpy(buf, "I/O error");
286 >    break;
287 >  default:
288 >    snprintf(buf, sizeof(buf), "Signal %d\n", signum);
289 >    break;
290 >  }
291 >  return buf;
292   }
293   #endif
294  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines