Bug Summary

File:gromacs/utility/cstringutil.c
Location:line 216, column 20
Description:Value stored to 'user' during its initialization is never read

Annotated Source Code

1/*
2 * This file is part of the GROMACS molecular simulation package.
3 *
4 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
5 * Copyright (c) 2001-2004, The GROMACS development team.
6 * Copyright (c) 2013,2014, by the GROMACS development team, led by
7 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
8 * and including many others, as listed in the AUTHORS file in the
9 * top-level source directory and at http://www.gromacs.org.
10 *
11 * GROMACS is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public License
13 * as published by the Free Software Foundation; either version 2.1
14 * of the License, or (at your option) any later version.
15 *
16 * GROMACS is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with GROMACS; if not, see
23 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
24 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 *
26 * If you want to redistribute modifications to GROMACS, please
27 * consider that scientific software is very special. Version
28 * control is crucial - bugs must be traceable. We will be happy to
29 * consider code for inclusion in the official distribution, but
30 * derived work must not be called official GROMACS. Details are found
31 * in the README & COPYING files - if they are missing, get the
32 * official version at http://www.gromacs.org.
33 *
34 * To help us fund GROMACS development, we humbly ask that you cite
35 * the research papers on the package. Check out http://www.gromacs.org.
36 */
37/* This file is completely threadsafe - keep it that way! */
38#include "cstringutil.h"
39
40#ifdef HAVE_CONFIG_H1
41#include <config.h>
42#endif
43
44#include <assert.h>
45#include <ctype.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <string.h>
49#include <time.h>
50
51#include <sys/types.h>
52#ifdef HAVE_SYS_TIME_H
53#include <sys/time.h>
54#endif
55#ifdef HAVE_PWD_H
56#include <pwd.h>
57#endif
58#ifdef HAVE_UNISTD_H
59#include <unistd.h>
60#endif
61
62#include "gromacs/utility/basedefinitions.h"
63#include "gromacs/utility/basenetwork.h"
64#include "gromacs/utility/fatalerror.h"
65#include "gromacs/utility/futil.h"
66#include "gromacs/utility/smalloc.h"
67
68int continuing(char *s)
69{
70 int sl;
71 assert(s)((void) (0));
72
73 rtrim(s);
74 sl = strlen(s);
75 if ((sl > 0) && (s[sl-1] == CONTINUE'\\'))
76 {
77 s[sl-1] = 0;
78 return TRUE1;
79 }
80 else
81 {
82 return FALSE0;
83 }
84}
85
86
87
88char *fgets2(char *line, int n, FILE *stream)
89{
90 char *c;
91 if (fgets(line, n, stream) == NULL((void*)0))
92 {
93 return NULL((void*)0);
94 }
95 if ((c = strchr(line, '\n')(__extension__ (__builtin_constant_p ('\n') && !__builtin_constant_p
(line) && ('\n') == '\0' ? (char *) __rawmemchr (line
, '\n') : __builtin_strchr (line, '\n')))) != NULL((void*)0))
96 {
97 *c = '\0';
98 }
99 else
100 {
101 /* A line not ending in a newline can only occur at the end of a file,
102 * or because of n being too small.
103 * Since both cases occur very infrequently, we can check for EOF.
104 */
105 if (!gmx_eof(stream))
106 {
107 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 107, "An input file contains a line longer than %d characters, while the buffer passed to fgets2 has size %d. The line starts with: '%20.20s'", n, n, line);
108 }
109 }
110 if ((c = strchr(line, '\r')(__extension__ (__builtin_constant_p ('\r') && !__builtin_constant_p
(line) && ('\r') == '\0' ? (char *) __rawmemchr (line
, '\r') : __builtin_strchr (line, '\r')))) != NULL((void*)0))
111 {
112 *c = '\0';
113 }
114
115 return line;
116}
117
118void strip_comment (char *line)
119{
120 char *c;
121
122 if (!line)
123 {
124 return;
125 }
126
127 /* search for a comment mark and replace it by a zero */
128 if ((c = strchr(line, COMMENTSIGN)(__extension__ (__builtin_constant_p (';') && !__builtin_constant_p
(line) && (';') == '\0' ? (char *) __rawmemchr (line
, ';') : __builtin_strchr (line, ';')))) != NULL((void*)0))
129 {
130 (*c) = 0;
131 }
132}
133
134void upstring (char *str)
135{
136 int i;
137
138 for (i = 0; (i < (int)strlen(str)); i++)
139 {
140 str[i] = toupper(str[i])(__extension__ ({ int __res; if (sizeof (str[i]) > 1) { if
(__builtin_constant_p (str[i])) { int __c = (str[i]); __res =
__c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc (
))[__c]; } else __res = toupper (str[i]); } else __res = (*__ctype_toupper_loc
())[(int) (str[i])]; __res; }));
141 }
142}
143
144void ltrim (char *str)
145{
146 char *tr;
147 int i, c;
148
149 if (NULL((void*)0) == str)
150 {
151 return;
152 }
153
154 c = 0;
155 while (('\0' != str[c]) && isspace(str[c])((*__ctype_b_loc ())[(int) ((str[c]))] & (unsigned short int
) _ISspace))
156 {
157 c++;
158 }
159 if (c > 0)
160 {
161 for (i = c; ('\0' != str[i]); i++)
162 {
163 str[i-c] = str[i];
164 }
165 str[i-c] = '\0';
166 }
167}
168
169void rtrim (char *str)
170{
171 int nul;
172
173 if (NULL((void*)0) == str)
174 {
175 return;
176 }
177
178 nul = strlen(str)-1;
179 while ((nul > 0) && ((str[nul] == ' ') || (str[nul] == '\t')) )
180 {
181 str[nul] = '\0';
182 nul--;
183 }
184}
185
186void trim (char *str)
187{
188 ltrim (str);
189 rtrim (str);
190}
191
192char *
193gmx_ctime_r(const time_t *clock, char *buf, int n)
194{
195 char tmpbuf[STRLEN4096];
196
197#ifdef GMX_NATIVE_WINDOWS
198 /* Windows */
199 ctime_s( tmpbuf, STRLEN4096, clock );
200#elif (defined(__sun))
201 /*Solaris*/
202 ctime_r(clock, tmpbuf, n);
203#else
204 ctime_r(clock, tmpbuf);
205#endif
206 strncpy(buf, tmpbuf, n-1)__builtin_strncpy (buf, tmpbuf, n-1);
207 buf[n-1] = '\0';
208
209 return buf;
210}
211
212void nice_header (FILE *out, const char *fn)
213{
214 const char *unk = "onbekend";
215 time_t clock;
216 const char *user = unk;
Value stored to 'user' during its initialization is never read
217 int gh;
218#ifdef HAVE_PWD_H
219 uid_t uid;
220#else
221 int uid;
222#endif
223 char buf[256] = "";
224 char timebuf[STRLEN4096];
225#ifdef HAVE_PWD_H
226 struct passwd *pw;
227#endif
228
229 /* Print a nice header above the file */
230 time(&clock);
231 fprintf (out, "%c\n", COMMENTSIGN';');
232 fprintf (out, "%c\tFile '%s' was generated\n", COMMENTSIGN';', fn ? fn : unk);
233
234#ifdef HAVE_PWD_H
235 uid = getuid();
236 pw = getpwuid(uid);
237 gh = gmx_gethostname(buf, 255);
238 /* pw returns null on error (e.g. compute nodes lack /etc/passwd) */
239 user = pw ? pw->pw_name : unk;
240#else
241 uid = 0;
242 gh = -1;
243#endif
244
245 gmx_ctime_r(&clock, timebuf, STRLEN4096);
246 fprintf (out, "%c\tBy user: %s (%d)\n", COMMENTSIGN';',
247 user ? user : unk, (int) uid);
248 fprintf(out, "%c\tOn host: %s\n", COMMENTSIGN';', (gh == 0) ? buf : unk);
249
250 fprintf (out, "%c\tAt date: %s", COMMENTSIGN';', timebuf);
251 fprintf (out, "%c\n", COMMENTSIGN';');
252}
253
254
255int gmx_strcasecmp_min(const char *str1, const char *str2)
256{
257 char ch1, ch2;
258
259 do
260 {
261 do
262 {
263 ch1 = toupper(*(str1++))(__extension__ ({ int __res; if (sizeof (*(str1++)) > 1) {
if (__builtin_constant_p (*(str1++))) { int __c = (*(str1++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str1++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str1++))]; __res; }));
264 }
265 while ((ch1 == '-') || (ch1 == '_'));
266 do
267 {
268 ch2 = toupper(*(str2++))(__extension__ ({ int __res; if (sizeof (*(str2++)) > 1) {
if (__builtin_constant_p (*(str2++))) { int __c = (*(str2++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str2++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str2++))]; __res; }));
269 }
270 while ((ch2 == '-') || (ch2 == '_'));
271
272 if (ch1 != ch2)
273 {
274 return (ch1-ch2);
275 }
276 }
277 while (ch1);
278 return 0;
279}
280
281int gmx_strncasecmp_min(const char *str1, const char *str2, int n)
282{
283 char ch1, ch2;
284 char *stri1, *stri2;
285
286 stri1 = (char *)str1;
287 stri2 = (char *)str2;
288 do
289 {
290 do
291 {
292 ch1 = toupper(*(str1++))(__extension__ ({ int __res; if (sizeof (*(str1++)) > 1) {
if (__builtin_constant_p (*(str1++))) { int __c = (*(str1++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str1++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str1++))]; __res; }));
293 }
294 while ((ch1 == '-') || (ch1 == '_'));
295 do
296 {
297 ch2 = toupper(*(str2++))(__extension__ ({ int __res; if (sizeof (*(str2++)) > 1) {
if (__builtin_constant_p (*(str2++))) { int __c = (*(str2++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str2++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str2++))]; __res; }));
298 }
299 while ((ch2 == '-') || (ch2 == '_'));
300
301 if (ch1 != ch2)
302 {
303 return (ch1-ch2);
304 }
305 }
306 while (ch1 && (str1-stri1 < n) && (str2-stri2 < n));
307 return 0;
308}
309
310int gmx_strcasecmp(const char *str1, const char *str2)
311{
312 char ch1, ch2;
313
314 do
315 {
316 ch1 = toupper(*(str1++))(__extension__ ({ int __res; if (sizeof (*(str1++)) > 1) {
if (__builtin_constant_p (*(str1++))) { int __c = (*(str1++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str1++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str1++))]; __res; }));
317 ch2 = toupper(*(str2++))(__extension__ ({ int __res; if (sizeof (*(str2++)) > 1) {
if (__builtin_constant_p (*(str2++))) { int __c = (*(str2++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str2++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str2++))]; __res; }));
318 if (ch1 != ch2)
319 {
320 return (ch1-ch2);
321 }
322 }
323 while (ch1);
324 return 0;
325}
326
327int gmx_strncasecmp(const char *str1, const char *str2, int n)
328{
329 char ch1, ch2;
330
331 if (n == 0)
332 {
333 return 0;
334 }
335
336 do
337 {
338 ch1 = toupper(*(str1++))(__extension__ ({ int __res; if (sizeof (*(str1++)) > 1) {
if (__builtin_constant_p (*(str1++))) { int __c = (*(str1++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str1++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str1++))]; __res; }));
339 ch2 = toupper(*(str2++))(__extension__ ({ int __res; if (sizeof (*(str2++)) > 1) {
if (__builtin_constant_p (*(str2++))) { int __c = (*(str2++)
); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc
())[__c]; } else __res = toupper (*(str2++)); } else __res =
(*__ctype_toupper_loc ())[(int) (*(str2++))]; __res; }));
340 if (ch1 != ch2)
341 {
342 return (ch1-ch2);
343 }
344 n--;
345 }
346 while (ch1 && n);
347 return 0;
348}
349
350char *gmx_strdup(const char *src)
351{
352 char *dest;
353
354 snew(dest, strlen(src)+1)(dest) = save_calloc("dest", "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 354, (strlen(src)+1), sizeof(*(dest)));
355 strcpy(dest, src);
356
357 return dest;
358}
359
360char *
361gmx_strndup(const char *src, int n)
362{
363 int len;
364 char *dest;
365
366 len = strlen(src);
367 if (len > n)
368 {
369 len = n;
370 }
371 snew(dest, len+1)(dest) = save_calloc("dest", "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 371, (len+1), sizeof(*(dest)));
372 strncpy(dest, src, len)__builtin_strncpy (dest, src, len);
373 dest[len] = 0;
374 return dest;
375}
376
377/* Magic hash init number for Dan J. Bernsteins algorithm.
378 * Do NOT use any other value unless you really know what you are doing.
379 */
380const unsigned int
381 gmx_string_hash_init = 5381;
382
383
384unsigned int
385gmx_string_fullhash_func(const char *s, unsigned int hash_init)
386{
387 int c;
388
389 while ((c = (*s++)) != '\0')
390 {
391 hash_init = ((hash_init << 5) + hash_init) ^ c; /* (hash * 33) xor c */
392 }
393 return hash_init;
394}
395
396unsigned int
397gmx_string_hash_func(const char *s, unsigned int hash_init)
398{
399 int c;
400
401 while ((c = toupper(*s++)(__extension__ ({ int __res; if (sizeof (*s++) > 1) { if (
__builtin_constant_p (*s++)) { int __c = (*s++); __res = __c <
-128 || __c > 255 ? __c : (*__ctype_toupper_loc ())[__c];
} else __res = toupper (*s++); } else __res = (*__ctype_toupper_loc
())[(int) (*s++)]; __res; }))) != '\0')
402 {
403 if (isalnum(c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISalnum
))
404 {
405 hash_init = ((hash_init << 5) + hash_init) ^ c; /* (hash * 33) xor c */
406 }
407 }
408 return hash_init;
409}
410
411int
412gmx_wcmatch(const char *pattern, const char *str)
413{
414 while (*pattern)
415 {
416 if (*pattern == '*')
417 {
418 /* Skip multiple wildcards in a sequence */
419 while (*pattern == '*' || *pattern == '?')
420 {
421 ++pattern;
422 /* For ?, we need to check that there are characters left
423 * in str. */
424 if (*pattern == '?')
425 {
426 if (*str == 0)
427 {
428 return GMX_NO_WCMATCH1;
429 }
430 else
431 {
432 ++str;
433 }
434 }
435 }
436 /* If the pattern ends after the star, we have a match */
437 if (*pattern == 0)
438 {
439 return 0;
440 }
441 /* Match the rest against each possible suffix of str */
442 while (*str)
443 {
444 /* Only do the recursive call if the first character
445 * matches. We don't have to worry about wildcards here,
446 * since we have processed them above. */
447 if (*pattern == *str)
448 {
449 int rc;
450 /* Match the suffix, and return if a match or an error */
451 rc = gmx_wcmatch(pattern, str);
452 if (rc != GMX_NO_WCMATCH1)
453 {
454 return rc;
455 }
456 }
457 ++str;
458 }
459 /* If no suffix of str matches, we don't have a match */
460 return GMX_NO_WCMATCH1;
461 }
462 else if ((*pattern == '?' && *str != 0) || *pattern == *str)
463 {
464 ++str;
465 }
466 else
467 {
468 return GMX_NO_WCMATCH1;
469 }
470 ++pattern;
471 }
472 /* When the pattern runs out, we have a match if the string has ended. */
473 return (*str == 0) ? 0 : GMX_NO_WCMATCH1;
474}
475
476char *wrap_lines(const char *buf, int line_width, int indent, gmx_bool bIndentFirst)
477{
478 char *b2;
479 int i, i0, i2, j, b2len, lspace = 0, l2space = 0;
480 gmx_bool bFirst, bFitsOnLine;
481
482 /* characters are copied from buf to b2 with possible spaces changed
483 * into newlines and extra space added for indentation.
484 * i indexes buf (source buffer) and i2 indexes b2 (destination buffer)
485 * i0 points to the beginning of the current line (in buf, source)
486 * lspace and l2space point to the last space on the current line
487 * bFirst is set to prevent indentation of first line
488 * bFitsOnLine says if the first space occurred before line_width, if
489 * that is not the case, we have a word longer than line_width which
490 * will also not fit on the next line, so we might as well keep it on
491 * the current line (where it also won't fit, but looks better)
492 */
493
494 b2 = NULL((void*)0);
495 b2len = strlen(buf)+1+indent;
496 snew(b2, b2len)(b2) = save_calloc("b2", "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 496, (b2len), sizeof(*(b2)));
497 i0 = i2 = 0;
498 if (bIndentFirst)
499 {
500 for (i2 = 0; (i2 < indent); i2++)
501 {
502 b2[i2] = ' ';
503 }
504 }
505 bFirst = TRUE1;
506 do
507 {
508 l2space = -1;
509 /* find the last space before end of line */
510 for (i = i0; ((i-i0 < line_width) || (l2space == -1)) && (buf[i]); i++)
511 {
512 b2[i2++] = buf[i];
513 /* remember the position of a space */
514 if (buf[i] == ' ')
515 {
516 lspace = i;
517 l2space = i2-1;
518 }
519 /* if we have a newline before the line is full, reset counters */
520 if (buf[i] == '\n' && buf[i+1])
521 {
522 i0 = i+1;
523 b2len += indent;
524 srenew(b2, b2len)(b2) = save_realloc("b2", "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 524, (b2), (b2len), sizeof(*(b2)));
525 /* add indentation after the newline */
526 for (j = 0; (j < indent); j++)
527 {
528 b2[i2++] = ' ';
529 }
530 }
531 }
532 /* If we are at the last newline, copy it */
533 if (buf[i] == '\n' && !buf[i+1])
534 {
535 b2[i2++] = buf[i++];
536 }
537 /* if we're not at the end of the string */
538 if (buf[i])
539 {
540 /* check if one word does not fit on the line */
541 bFitsOnLine = (i-i0 <= line_width);
542 /* reset line counters to just after the space */
543 i0 = lspace+1;
544 i2 = l2space+1;
545 /* if the words fit on the line, and we're beyond the indentation part */
546 if ( (bFitsOnLine) && (l2space >= indent) )
547 {
548 /* start a new line */
549 b2[l2space] = '\n';
550 /* and add indentation */
551 if (indent)
552 {
553 if (bFirst)
554 {
555 line_width -= indent;
556 bFirst = FALSE0;
557 }
558 b2len += indent;
559 srenew(b2, b2len)(b2) = save_realloc("b2", "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 559, (b2), (b2len), sizeof(*(b2)));
560 for (j = 0; (j < indent); j++)
561 {
562 b2[i2++] = ' ';
563 }
564 /* no extra spaces after indent; */
565 while (buf[i0] == ' ')
566 {
567 i0++;
568 }
569 }
570 }
571 }
572 }
573 while (buf[i]);
574 b2[i2] = '\0';
575
576 return b2;
577}
578
579gmx_int64_t
580str_to_int64_t(const char *str, char **endptr)
581{
582#ifndef _MSC_VER
583 return strtoll(str, endptr, 10);
584#else
585 return _strtoi64(str, endptr, 10);
586#endif
587}
588
589void parse_digits_from_plain_string(const char *digitstring, int *ndigits, int **digitlist)
590{
591 int i;
592
593 if (NULL((void*)0) == digitstring)
594 {
595 *ndigits = 0;
596 *digitlist = NULL((void*)0);
597 return;
598 }
599
600 *ndigits = strlen(digitstring);
601
602 snew(*digitlist, *ndigits)(*digitlist) = save_calloc("*digitlist", "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 602, (*ndigits), sizeof(*(*digitlist)));
603
604 for (i = 0; i < *ndigits; i++)
605 {
606 if (digitstring[i] < '0' || digitstring[i] > '9')
607 {
608 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 608, "Invalid character in digit-only string: '%c'\n",
609 digitstring[i]);
610 }
611 (*digitlist)[i] = digitstring[i] - '0';
612 }
613}
614
615static void parse_digits_from_csv_string(const char gmx_unused__attribute__ ((unused)) *digitstring, int gmx_unused__attribute__ ((unused)) *ndigits, int gmx_unused__attribute__ ((unused)) *digitlist)
616{
617 /* TODO Implement csv format to support (e.g.) more than 10
618 different GPUs in a node. */
619 gmx_incons("Not implemented yet")_gmx_error("incons", "Not implemented yet", "/home/alexxy/Develop/gromacs/src/gromacs/utility/cstringutil.c"
, 619);
620}