gmane.emacs.devel

[bugfixed] message-idna-to-ascii-rhs

Katsumi Yamaoka — 2008-12-03T02:32:59

Cc: emacs-devel Hi, When I send a message in which there is the Cc: line in the beginning of the body like this, I got the following error: Debugger entered--Lisp error: (wrong-type-argument char-or-string-p nil) message-idna-to-ascii-rhs-1("Cc") message-idna-to-ascii-rhs() message-generate-headers((From Subject Date (optional . In-Reply-To)...) message-send-mail(nil) message-send(nil) message-send-and-exit(nil) call-interactively(message-send-and-exit nil nil) (In my case, `message-use-idna' is t.) It was because the `message-idna-to-ascii-rhs' function failed in narrowing the message buffer to the headers. In that case there is the "--text follows this line--" line, so the function should not use `message-narrow-to-head' that recognizes only the first empty line as the message header separator. The same error will happen if there is a recipient address that doesn't have a domain part (i.e. a local user) in the header. Moreover, it is bad that lines looking like headers containing non-ASCII domain names in the message body are encoded. I've replaced it with `message-narrow-to-headers-or-head' in both the Gnus trunk and the Emacs trunk. Regards,

Problem report #133: base/src/emacs/src/font.c (font_range);FORWARD_NULL

Dan Nicolaescu — 2008-12-03T01:31:09

CID: 133 Checker: FORWARD_NULL (help) File: base/src/emacs/src/font.c Function: font_range Description: Variable "face" tracked as NULL was passed to a function that dereferences it. Event var_compare_op: Added "face" due to comparison "face == 0" Also see events: [var_deref_model][var_deref_model] At conditional (1): "face == 0" taking true path 3684 if (! face) 3685 { 3686 int face_id; 3687 3688 face_id = face_at_buffer_position (w, pos, 0, 0, &ignore, *limit, 0); At conditional (2): "face_id < (((0), ((w)->frame & -8))->face_cache)->used" taking false path 3689 face = FACE_FROM_ID (XFRAME (w->frame), face_id); 3690 } 3691 } 3692 else 3693 { 3694 font_assert (face); 3695 pos_byte = string_char_to_byte (string, pos); 3696 } 3697 3698 start = pos, start_byte = pos_byte; At conditional (3): "pos < *limit" taking true path 3699 while (pos < *limit) 3700 { 3701 Lisp_Object category; 3702 At conditional (4): "string == Qnil" taking true path 3703 if (NILP (string)) At conditional (5): "pos_byte >= ((current_buffer)->text)->gpt_byte" taking true path At conditional (6): "*(ptr + 0) & 128 == 0" taking true path At conditional (7): "0" taking false path 3704 FETCH_CHAR_ADVANCE_NO_CHECK (c, pos, pos_byte); 3705 else 3706 FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, string, pos, pos_byte); At conditional (8): "font_object == Qnil" taking true path 3707 if (NILP (font_object)) 3708 { Event var_deref_model: Variable "face" tracked as NULL was passed to a function that dereferences it. [model] Also see events: [var_compare_op][var_deref_model] 3709 font_object = font_for_char (face, c, pos - 1, string); 3710 if (NILP (font_object)) 3711 return Qnil; 3712 continue; 3713 } 3714 3715 category = CHAR_TABLE_REF (Vunicode_category_table, c); 3716 if (! EQ (category, QCf) 3717 && font_encode_char (font_object, c) == FONT_INVALID_CODE) 3718 { Event var_deref_model: Variable "face" tracked as NULL was passed to a function that dereferences it. [model] Also see events: [var_compare_op][var_deref_model] 3719 Lisp_Object f = font_for_char (face, c, pos - 1, string); 3720 EMACS_INT i, i_byte; 3721

Problem report #132 [2/2]: base/src/emacs/src/process.c(procfs_system_process_attributes); UNINIT

Dan Nicolaescu — 2008-12-03T01:22:25

CID: 132 Checker: UNINIT (help) File: base/src/emacs/src/process.c Function: procfs_system_process_attributes Description: Using uninitialized value "q" Event var_decl: Declared variable "q" without initializer Also see events: [uninit_use] 7246 char procbuf[1025], *p, *q; 7247 int fd; 7248 ssize_t nread; 7249 const char *cmd; 7250 char *cmdline = NULL; 7251 size_t cmdsize, cmdline_size; 7252 unsigned char c; 7253 int proc_id, ppid, uid, gid, pgrp, sess, tty, tpgid, thcount; 7254 unsigned long long utime, stime, cutime, cstime, start; 7255 long priority, nice, rss; 7256 unsigned long minflt, majflt, cminflt, cmajflt, vsize; 7257 time_t sec; 7258 unsigned usec; 7259 EMACS_TIME tnow, tstart, tboot, telapsed,ttotal; 7260 double pcpu, pmem; 7261 Lisp_Object attrs = Qnil; 7262 Lisp_Object cmd_str, decoded_cmd, tem; 7263 struct gcpro gcpro1, gcpro2; 7264 EMACS_INT uid_eint, gid_eint; 7265 At conditional (1): "pid & 7 != 6" taking true path At conditional (2): "pid & 7 != 0" taking false path At conditional (3): "0" taking false path 7266 CHECK_NUMBER_OR_FLOAT (pid); At conditional (4): "pid & 7 == 6" taking false path 7267 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid); 7268 sprintf (procfn, "/proc/%lu", proc_id); At conditional (5): "stat < 0" taking false path 7269 if (stat (procfn, &st) < 0) 7270 return attrs; 7271 7272 GCPRO2 (attrs, decoded_cmd); 7273 7274 /* euid egid */ 7275 uid = st.st_uid; 7276 /* Use of EMACS_INT stops GCC whining about limited range of data type. */ 7277 uid_eint = uid; At conditional (6): "uid_eint > 1152921504606846975" taking true path 7278 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid_eint)), attrs); 7279 BLOCK_INPUT; 7280 pw = getpwuid (uid); At conditional (7): "interrupt_input_blocked == 0" taking true path At conditional (8): "interrupt_input_pending != 0" taking true path At conditional (9): "pending_atimers != 0" taking true path At conditional (10): "0" taking false path 7281 UNBLOCK_INPUT; At conditional (11): "pw != 0" taking true path 7282 if (pw) 7283 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs); 7284 7285 gid = st.st_gid; 7286 gid_eint = gid; At conditional (12): "gid_eint > 1152921504606846975" taking true path 7287 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid_eint)), attrs); 7288 BLOCK_INPUT; 7289 gr = getgrgid (gid); At conditional (13): "interrupt_input_blocked == 0" taking true path At conditional (14): "interrupt_input_pending != 0" taking true path At conditional (15): "pending_atimers != 0" taking true path At conditional (16): "0" taking false path 7290 UNBLOCK_INPUT; At conditional (17): "gr != 0" taking true path 7291 if (gr) 7292 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs); 7293 7294 strcpy (fn, procfn); 7295 procfn_end = fn + strlen (fn); 7296 strcpy (procfn_end, "/stat"); 7297 fd = emacs_open (fn, O_RDONLY, 0); At conditional (18): "fd >= 0" taking true path At conditional (19): "nread = emacs_read > 0" taking true path 7298 if (fd >= 0 && (nread = emacs_read (fd, procbuf, sizeof(procbuf) - 1)) > 0) 7299 { 7300 procbuf[nread] = '\0'; 7301 p = procbuf; 7302 7303 cmd = NULL; 7304 p = strchr (p, '('); At conditional (20): "p != 0" taking false path 7305 if (p != NULL) 7306 { 7307 q = strrchr (p + 1, ')'); 7308 /* comm */ 7309 if (q != NULL) 7310 { 7311 cmd = p + 1; 7312 cmdsize = q - cmd; 7313 } 7314 } At conditional (21): "cmd == 0" taking true path 7315 if (cmd == NULL) 7316 { 7317 cmd = "???"; 7318 cmdsize = 3; 7319 } 7320 /* Command name is encoded in locale-coding-system; decode it. */ 7321 cmd_str = make_unibyte_string (cmd, cmdsize); 7322 decoded_cmd = code_convert_string_norecord (cmd_str, 7323 Vlocale_coding_system, 0); 7324 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs); 7325 Event uninit_use: Using uninitialized value "q" Also see events: [var_decl] 7326 if (q) 7327 { 7328 EMACS_INT ppid_eint, pgrp_eint, sess_eint, tpgid_eint, thcount_eint;

Problem report #134: base/src/emacs/src/fontset.c (font_for_char);UNINIT

Dan Nicolaescu — 2008-12-03T01:23:36

CID: 134 Checker: UNINIT (help) File: base/src/emacs/src/fontset.c Function: font_for_char Description: Using uninitialized value "id" in call to function "fontset_font" Event var_decl: Declared variable "id" without initializer Also see events: [uninit_use_in_call] 945 int id; 946 At conditional (1): "c < 128" taking false path 947 if (ASCII_CHAR_P (c)) 948 { 949 Lisp_Object font_object; 950 951 XSETFONT (font_object, face->ascii_face->font); 952 return font_object; 953 } 954 955 xassert (fontset_id_valid_p (face->fontset)); 956 fontset = FONTSET_FROM_ID (face->fontset); 957 xassert (!BASE_FONTSET_P (fontset)); At conditional (2): "pos < 0" taking false path 958 if (pos < 0) 959 { 960 id = -1; 961 charset = Qnil; 962 } 963 else 964 { 965 charset = Fget_char_property (make_number (pos), Qcharset, object); At conditional (3): "charset == Qnil" taking false path 966 if (NILP (charset)) 967 id = -1; At conditional (4): "hash_lookup >= 0" taking false path 968 else if (CHARSETP (charset)) 969 { 970 Lisp_Object val; 971 972 val = assoc_no_quit (charset, Vfont_encoding_charset_alist); 973 if (CONSP (val) && CHARSETP (XCDR (val))) 974 charset = XCDR (val); 975 id = XINT (CHARSET_SYMBOL_ID (charset)); 976 } 977 } 978 979 font_deferred_log ("font for", Fcons (make_number (c), charset), Qnil); Event uninit_use_in_call: Using uninitialized value "id" in call to function "fontset_font" [model] Also see events: [var_decl] 980 rfont_def = fontset_font (fontset, c, face, id); 981 return (VECTORP (rfont_def) 982 ? RFONT_DEF_OBJECT (rfont_def) 983 : Qnil); 984 } 985 9

Problem report #132 [1/2]: base/src/emacs/src/process.c(procfs_system_process_attributes); UNINIT

Dan Nicolaescu — 2008-12-03T01:21:27

CID: 132 Checker: UNINIT (help) File: base/src/emacs/src/process.c Function: procfs_system_process_attributes Description: Using uninitialized value "cmdsize" Event var_decl: Declared variable "cmdsize" without initializer Also see events: [uninit_use] 7251 size_t cmdsize, cmdline_size; 7252 unsigned char c; 7253 int proc_id, ppid, uid, gid, pgrp, sess, tty, tpgid, thcount; 7254 unsigned long long utime, stime, cutime, cstime, start; 7255 long priority, nice, rss; 7256 unsigned long minflt, majflt, cminflt, cmajflt, vsize; 7257 time_t sec; 7258 unsigned usec; 7259 EMACS_TIME tnow, tstart, tboot, telapsed,ttotal; 7260 double pcpu, pmem; 7261 Lisp_Object attrs = Qnil; 7262 Lisp_Object cmd_str, decoded_cmd, tem; 7263 struct gcpro gcpro1, gcpro2; 7264 EMACS_INT uid_eint, gid_eint; 7265 7266 CHECK_NUMBER_OR_FLOAT (pid); 7267 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid); 7268 sprintf (procfn, "/proc/%lu", proc_id); At conditional (1): "stat < 0" taking false path 7269 if (stat (procfn, &st) < 0) 7270 return attrs; 7271 7272 GCPRO2 (attrs, decoded_cmd); 7273 7274 /* euid egid */ 7275 uid = st.st_uid; 7276 /* Use of EMACS_INT stops GCC whining about limited range of data type. */ 7277 uid_eint = uid; At conditional (2): "uid_eint > 1152921504606846975" taking true path 7278 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid_eint)), attrs); 7279 BLOCK_INPUT; 7280 pw = getpwuid (uid); At conditional (3): "interrupt_input_blocked == 0" taking true path At conditional (4): "interrupt_input_pending != 0" taking true path At conditional (5): "pending_atimers != 0" taking true path At conditional (6): "0" taking false path 7281 UNBLOCK_INPUT; At conditional (7): "pw != 0" taking true path 7282 if (pw) 7283 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs); 7284 7285 gid = st.st_gid; 7286 gid_eint = gid; At conditional (8): "gid_eint > 1152921504606846975" taking true path 7287 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid_eint)), attrs); 7288 BLOCK_INPUT; 7289 gr = getgrgid (gid); At conditional (9): "interrupt_input_blocked == 0" taking true path At conditional (10): "interrupt_input_pending != 0" taking true path At conditional (11): "pending_atimers != 0" taking true path At conditional (12): "0" taking false path 7290 UNBLOCK_INPUT; At conditional (13): "gr != 0" taking true path 7291 if (gr) 7292 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs); 7293 7294 strcpy (fn, procfn); 7295 procfn_end = fn + strlen (fn); 7296 strcpy (procfn_end, "/stat"); 7297 fd = emacs_open (fn, O_RDONLY, 0); At conditional (14): "fd >= 0" taking true path At conditional (15): "nread = emacs_read > 0" taking false path 7298 if (fd >= 0 && (nread = emacs_read (fd, procbuf, sizeof(procbuf) - 1)) > 0) 7299 { 7300 procbuf[nread] = '\0'; 7301 p = procbuf; 7302 7303 cmd = NULL; 7304 p = strchr (p, '('); 7305 if (p != NULL) 7306 { 7307 q = strrchr (p + 1, ')'); 7308 /* comm */ 7309 if (q != NULL) 7310 { 7311 cmd = p + 1; 7312 cmdsize = q - cmd; 7313 } 7314 } 7315 if (cmd == NULL) 7316 { 7317 cmd = "???"; 7318 cmdsize = 3; 7319 } 7320 /* Command name is encoded in locale-coding-system; decode it. */ 7321 cmd_str = make_unibyte_string (cmd, cmdsize); 7322 decoded_cmd = code_convert_string_norecord (cmd_str, 7323 Vlocale_coding_system, 0); 7324 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs); 7325 7326 if (q) 7327 { 7328 EMACS_INT ppid_eint, pgrp_eint, sess_eint, tpgid_eint, thcount_eint; 7329 p = q + 2; 7330 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt utime stime cutime cstime priority nice thcount . start vsize rss */ 7331 sscanf (p, "%c %d %d %d %d %d %*u %lu %lu %lu %lu %Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld", 7332 &c, &ppid, &pgrp, &sess, &tty, &tpgid, 7333 &minflt, &cminflt, &majflt, &cmajflt, 7334 &utime, &stime, &cutime, &cstime, 7335 &priority, &nice, &thcount, &start, &vsize, &rss); 7336 { 7337 char state_str[2]; 7338 7339 state_str[0] = c; 7340 state_str[1] = '\0'; 7341 tem = build_string (state_str); 7342 attrs = Fcons (Fcons (Qstate, tem), attrs); 7343 } 7344 /* Stops GCC whining about limited range of data type. */ 7345 ppid_eint = ppid; 7346 pgrp_eint = pgrp; 7347 sess_eint = sess; 7348 tpgid_eint = tpgid; 7349 thcount_eint = thcount; 7350 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (ppid_eint)), attrs); 7351 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pgrp_eint)), attrs); 7352 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (sess_eint)), attrs); 7353 attrs = Fcons (Fcons (Qttname, procfs_ttyname (tty)), attrs); 7354 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (tpgid_eint)), attrs); 7355 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (minflt)), attrs); 7356 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (majflt)), attrs); 7357 attrs = Fcons (Fcons (Qcminflt, make_fixnum_or_float (cminflt)), attrs); 7358 attrs = Fcons (Fcons (Qcmajflt, make_fixnum_or_float (cmajflt)), attrs); 7359 clocks_per_sec = sysconf (_SC_CLK_TCK); 7360 if (clocks_per_sec < 0) 7361 clocks_per_sec = 100; 7362 attrs = Fcons (Fcons (Qutime, 7363 ltime_from_jiffies (utime, clocks_per_sec)), 7364 attrs); 7365 attrs = Fcons (Fcons (Qstime, 7366 ltime_from_jiffies (stime, clocks_per_sec)), 7367 attrs); 7368 attrs = Fcons (Fcons (Qcutime, 7369 ltime_from_jiffies (cutime, clocks_per_sec)), 7370 attrs); 7371 attrs = Fcons (Fcons (Qcstime, 7372 ltime_from_jiffies (cstime, clocks_per_sec)), 7373 attrs); 7374 attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs); 7375 attrs = Fcons (Fcons (Qnice, make_number (nice)), attrs); 7376 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs); 7377 EMACS_GET_TIME (tnow); 7378 get_up_time (&sec, &usec); 7379 EMACS_SET_SECS (telapsed, sec); 7380 EMACS_SET_USECS (telapsed, usec); 7381 EMACS_SUB_TIME (tboot, tnow, telapsed); 7382 time_from_jiffies (start, clocks_per_sec, &sec, &usec); 7383 EMACS_SET_SECS (tstart, sec); 7384 EMACS_SET_USECS (tstart, usec); 7385 EMACS_ADD_TIME (tstart, tboot, tstart); 7386 attrs = Fcons (Fcons (Qstart, 7387 list3 (make_number 7388 ((EMACS_SECS (tstart) >> 16) & 0xffff), 7389 make_number 7390 (EMACS_SECS (tstart) & 0xffff), 7391 make_number 7392 (EMACS_USECS (tstart)))), 7393 attrs); 7394 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs); 7395 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs); 7396 EMACS_SUB_TIME (telapsed, tnow, tstart); 7397 attrs = Fcons (Fcons (Qetime, 7398 list3 (make_number 7399 ((EMACS_SECS (telapsed) >> 16) & 0xffff), 7400 make_number 7401 (EMACS_SECS (telapsed) & 0xffff), 7402 make_number 7403 (EMACS_USECS (telapsed)))), 7404 attrs); 7405 time_from_jiffies (utime + stime, clocks_per_sec, &sec, &usec); 7406 pcpu = (sec + usec / 1000000.0) / (EMACS_SECS (telapsed) + EMACS_USECS (telapsed) / 1000000.0); 7407 if (pcpu > 1.0) 7408 pcpu = 1.0; 7409 attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs); 7410 pmem = 4.0 * 100 * rss / procfs_get_total_memory (); 7411 if (pmem > 100) 7412 pmem = 100; 7413 attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs); 7414 } 7415 } At conditional (16): "fd >= 0" taking true path 7416 if (fd >= 0) 7417 emacs_close (fd); 7418 7419 /* args */ 7420 strcpy (procfn_end, "/cmdline"); 7421 fd = emacs_open (fn, O_RDONLY, 0); At conditional (17): "fd >= 0" taking true path 7422 if (fd >= 0) 7423 { At conditional (18): "emacs_read == 1" taking true path At conditional (20): "emacs_read == 1" taking false path 7424 for (cmdline_size = 0; emacs_read (fd, &c, 1) == 1; cmdline_size++) 7425 { At conditional (19): "*(*__ctype_b_loc + (c * 2)) & 8192 != 0" taking true path 7426 if (isspace (c) || c == '\\') 7427 cmdline_size++;/* for later quoting, see below */ 7428 } At conditional (21): "cmdline_size != 0" taking false path 7429 if (cmdline_size) 7430 { 7431 cmdline = xmalloc (cmdline_size + 1); 7432 lseek (fd, 0L, SEEK_SET); 7433 cmdline[0] = '\0'; 7434 if ((nread = read (fd, cmdline, cmdline_size)) >= 0) 7435 cmdline[nread++] = '\0'; 7436 /* We don't want trailing null characters. */ 7437 for (p = cmdline + nread - 1; p > cmdline && !*p; p--) 7438 nread--; 7439 for (p = cmdline; p < cmdline + nread; p++) 7440 { 7441 /* Escape-quote whitespace and backslashes. */ 7442 if (isspace (*p) || *p == '\\') 7443 { 7444 memmove (p + 1, p, nread - (p - cmdline)); 7445 nread++; 7446 *p++ = '\\'; 7447 } 7448 else if (*p == '\0') 7449 *p = ' '; 7450 } 7451 cmdline_size = nread; 7452 } 7453 else 7454 { Event uninit_use: Using uninitialized value "cmdsize" Also see events: [var_decl] 7455 cmdline_size = cmdsize + 2; 7456 cmdline = xmalloc (cmdline_size + 1); 7457 strcpy (cmdline, "["); 7458 strcat (strncat (cmdline, cmd, cmdsize), "]"); 7459 } 7460 emacs_close (fd); 7461 /* Command line is encoded in locale-coding-system; decode it. */ 7462 cmd_str = make_unibyte_string (cmdline, cmdline_size); 7463 decoded_cmd = code_convert_string_norecord (cmd_str, 7464 Vlocale_coding_system, 0); 7465 xfree (cmdline); 7466 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs); 7467 } 7468 7469 UNGCPRO; 7470 return attrs; 7471 } 7472

Problem report #129: base/src/emacs/src/ftfont.c (ftfont_match);UNINIT

Dan Nicolaescu — 2008-12-03T01:12:29

CID: 129 Checker: UNINIT (help) File: base/src/emacs/src/ftfont.c Function: ftfont_match Description: Using uninitialized value "entity" in call to function "font_add_log" Event var_decl: Declared variable "entity" without initializer Also see events: [uninit_use][uninit_use_in_call] 923 Lisp_Object entity; 924 FcPattern *pattern, *match = NULL; 925 FcResult result; 926 char otlayout[15];/* For "otlayout:XXXX" */ 927 struct OpenTypeSpec *otspec = NULL; 928 At conditional (1): "fc_initialized == 0" taking true path 929 if (! fc_initialized) 930 { 931 FcInit (); 932 fc_initialized = 1; 933 } 934 935 pattern = ftfont_spec_pattern (spec, otlayout, &otspec); At conditional (2): "pattern == 0" taking false path 936 if (! pattern) 937 return Qnil; 938 At conditional (3): "((0), (spec & -8))->contents[8] & 7 == 0" taking true path 939 if (INTEGERP (AREF (spec, FONT_SIZE_INDEX))) 940 { 941 FcValue value; 942 943 value.type = FcTypeDouble; 944 value.u.d = XINT (AREF (spec, FONT_SIZE_INDEX)); 945 FcPatternAdd (pattern, FC_PIXEL_SIZE, value, FcFalse); 946 } At conditional (4): "FcConfigSubstitute == 1" taking true path 947 if (FcConfigSubstitute (NULL, pattern, FcMatchPattern) == FcTrue) 948 { 949 FcDefaultSubstitute (pattern); 950 match = FcFontMatch (NULL, pattern, &result); At conditional (5): "match != 0" taking false path 951 if (match) 952 { 953 entity = ftfont_pattern_entity (match, AREF (spec, FONT_EXTRA_INDEX)); 954 FcPatternDestroy (match); 955 if (! NILP (AREF (spec, FONT_FAMILY_INDEX)) 956 && NILP (assq_no_quit (AREF (spec, FONT_FAMILY_INDEX), 957 ftfont_generic_family_list)) 958 && NILP (Fstring_equal (AREF (spec, FONT_FAMILY_INDEX), 959 AREF (entity, FONT_FAMILY_INDEX)))) 960 entity = Qnil; 961 } 962 } 963 FcPatternDestroy (pattern); 964 Event uninit_use_in_call: Using uninitialized value "entity" in call to function "font_add_log" [model] Also see events: [var_decl][uninit_use] 965 font_add_log ("ftfont-match", spec, entity); Event uninit_use: Using uninitialized value "entity" Also see events: [var_decl][uninit_use_in_call] 966 return entity; 967 } 968 969 static Lisp_Object 970 ftfont_list_family (frame) 971

Problem report #131: base/src/emacs/src/process.c(procfs_system_process_attributes); UNINIT

Dan Nicolaescu — 2008-12-03T01:17:35

CID: 131 Checker: UNINIT (help) File: base/src/emacs/src/process.c Function: procfs_system_process_attributes Description: Using uninitialized value "cmd" as argument to function "strncat" Event var_decl: Declared variable "cmd" without initializer Also see events: [uninit_arg] 7249 const char *cmd; 7250 char *cmdline = NULL; 7251 size_t cmdsize, cmdline_size; 7252 unsigned char c; 7253 int proc_id, ppid, uid, gid, pgrp, sess, tty, tpgid, thcount; 7254 unsigned long long utime, stime, cutime, cstime, start; 7255 long priority, nice, rss; 7256 unsigned long minflt, majflt, cminflt, cmajflt, vsize; 7257 time_t sec; 7258 unsigned usec; 7259 EMACS_TIME tnow, tstart, tboot, telapsed,ttotal; 7260 double pcpu, pmem; 7261 Lisp_Object attrs = Qnil; 7262 Lisp_Object cmd_str, decoded_cmd, tem; 7263 struct gcpro gcpro1, gcpro2; 7264 EMACS_INT uid_eint, gid_eint; 7265 7266 CHECK_NUMBER_OR_FLOAT (pid); 7267 proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid); 7268 sprintf (procfn, "/proc/%lu", proc_id); At conditional (1): "stat < 0" taking false path 7269 if (stat (procfn, &st) < 0) 7270 return attrs; 7271 7272 GCPRO2 (attrs, decoded_cmd); 7273 7274 /* euid egid */ 7275 uid = st.st_uid; 7276 /* Use of EMACS_INT stops GCC whining about limited range of data type. */ 7277 uid_eint = uid; At conditional (2): "uid_eint > 1152921504606846975" taking true path 7278 attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (uid_eint)), attrs); 7279 BLOCK_INPUT; 7280 pw = getpwuid (uid); At conditional (3): "interrupt_input_blocked == 0" taking true path At conditional (4): "interrupt_input_pending != 0" taking true path At conditional (5): "pending_atimers != 0" taking true path At conditional (6): "0" taking false path 7281 UNBLOCK_INPUT; At conditional (7): "pw != 0" taking true path 7282 if (pw) 7283 attrs = Fcons (Fcons (Quser, build_string (pw->pw_name)), attrs); 7284 7285 gid = st.st_gid; 7286 gid_eint = gid; At conditional (8): "gid_eint > 1152921504606846975" taking true path 7287 attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (gid_eint)), attrs); 7288 BLOCK_INPUT; 7289 gr = getgrgid (gid); At conditional (9): "interrupt_input_blocked == 0" taking true path At conditional (10): "interrupt_input_pending != 0" taking true path At conditional (11): "pending_atimers != 0" taking true path At conditional (12): "0" taking false path 7290 UNBLOCK_INPUT; At conditional (13): "gr != 0" taking true path 7291 if (gr) 7292 attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs); 7293 7294 strcpy (fn, procfn); 7295 procfn_end = fn + strlen (fn); 7296 strcpy (procfn_end, "/stat"); 7297 fd = emacs_open (fn, O_RDONLY, 0); At conditional (14): "fd >= 0" taking true path At conditional (15): "nread = emacs_read > 0" taking false path 7298 if (fd >= 0 && (nread = emacs_read (fd, procbuf, sizeof(procbuf) - 1)) > 0) 7299 { 7300 procbuf[nread] = '\0'; 7301 p = procbuf; 7302 7303 cmd = NULL; 7304 p = strchr (p, '('); 7305 if (p != NULL) 7306 { 7307 q = strrchr (p + 1, ')'); 7308 /* comm */ 7309 if (q != NULL) 7310 { 7311 cmd = p + 1; 7312 cmdsize = q - cmd; 7313 } 7314 } 7315 if (cmd == NULL) 7316 { 7317 cmd = "???"; 7318 cmdsize = 3; 7319 } 7320 /* Command name is encoded in locale-coding-system; decode it. */ 7321 cmd_str = make_unibyte_string (cmd, cmdsize); 7322 decoded_cmd = code_convert_string_norecord (cmd_str, 7323 Vlocale_coding_system, 0); 7324 attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs); 7325 7326 if (q) 7327 { 7328 EMACS_INT ppid_eint, pgrp_eint, sess_eint, tpgid_eint, thcount_eint; 7329 p = q + 2; 7330 /* state ppid pgrp sess tty tpgid . minflt cminflt majflt cmajflt utime stime cutime cstime priority nice thcount . start vsize rss */ 7331 sscanf (p, "%c %d %d %d %d %d %*u %lu %lu %lu %lu %Lu %Lu %Lu %Lu %ld %ld %d %*d %Lu %lu %ld", 7332 &c, &ppid, &pgrp, &sess, &tty, &tpgid, 7333 &minflt, &cminflt, &majflt, &cmajflt, 7334 &utime, &stime, &cutime, &cstime, 7335 &priority, &nice, &thcount, &start, &vsize, &rss); 7336 { 7337 char state_str[2]; 7338 7339 state_str[0] = c; 7340 state_str[1] = '\0'; 7341 tem = build_string (state_str); 7342 attrs = Fcons (Fcons (Qstate, tem), attrs); 7343 } 7344 /* Stops GCC whining about limited range of data type. */ 7345 ppid_eint = ppid; 7346 pgrp_eint = pgrp; 7347 sess_eint = sess; 7348 tpgid_eint = tpgid; 7349 thcount_eint = thcount; 7350 attrs = Fcons (Fcons (Qppid, make_fixnum_or_float (ppid_eint)), attrs); 7351 attrs = Fcons (Fcons (Qpgrp, make_fixnum_or_float (pgrp_eint)), attrs); 7352 attrs = Fcons (Fcons (Qsess, make_fixnum_or_float (sess_eint)), attrs); 7353 attrs = Fcons (Fcons (Qttname, procfs_ttyname (tty)), attrs); 7354 attrs = Fcons (Fcons (Qtpgid, make_fixnum_or_float (tpgid_eint)), attrs); 7355 attrs = Fcons (Fcons (Qminflt, make_fixnum_or_float (minflt)), attrs); 7356 attrs = Fcons (Fcons (Qmajflt, make_fixnum_or_float (majflt)), attrs); 7357 attrs = Fcons (Fcons (Qcminflt, make_fixnum_or_float (cminflt)), attrs); 7358 attrs = Fcons (Fcons (Qcmajflt, make_fixnum_or_float (cmajflt)), attrs); 7359 clocks_per_sec = sysconf (_SC_CLK_TCK); 7360 if (clocks_per_sec < 0) 7361 clocks_per_sec = 100; 7362 attrs = Fcons (Fcons (Qutime, 7363 ltime_from_jiffies (utime, clocks_per_sec)), 7364 attrs); 7365 attrs = Fcons (Fcons (Qstime, 7366 ltime_from_jiffies (stime, clocks_per_sec)), 7367 attrs); 7368 attrs = Fcons (Fcons (Qcutime, 7369 ltime_from_jiffies (cutime, clocks_per_sec)), 7370 attrs); 7371 attrs = Fcons (Fcons (Qcstime, 7372 ltime_from_jiffies (cstime, clocks_per_sec)), 7373 attrs); 7374 attrs = Fcons (Fcons (Qpri, make_number (priority)), attrs); 7375 attrs = Fcons (Fcons (Qnice, make_number (nice)), attrs); 7376 attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs); 7377 EMACS_GET_TIME (tnow); 7378 get_up_time (&sec, &usec); 7379 EMACS_SET_SECS (telapsed, sec); 7380 EMACS_SET_USECS (telapsed, usec); 7381 EMACS_SUB_TIME (tboot, tnow, telapsed); 7382 time_from_jiffies (start, clocks_per_sec, &sec, &usec); 7383 EMACS_SET_SECS (tstart, sec); 7384 EMACS_SET_USECS (tstart, usec); 7385 EMACS_ADD_TIME (tstart, tboot, tstart); 7386 attrs = Fcons (Fcons (Qstart, 7387 list3 (make_number 7388 ((EMACS_SECS (tstart) >> 16) & 0xffff), 7389 make_number 7390 (EMACS_SECS (tstart) & 0xffff), 7391 make_number 7392 (EMACS_USECS (tstart)))), 7393 attrs); 7394 attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs); 7395 attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs); 7396 EMACS_SUB_TIME (telapsed, tnow, tstart); 7397 attrs = Fcons (Fcons (Qetime, 7398 list3 (make_number 7399 ((EMACS_SECS (telapsed) >> 16) & 0xffff), 7400 make_number 7401 (EMACS_SECS (telapsed) & 0xffff), 7402 make_number 7403 (EMACS_USECS (telapsed)))), 7404 attrs); 7405 time_from_jiffies (utime + stime, clocks_per_sec, &sec, &usec); 7406 pcpu = (sec + usec / 1000000.0) / (EMACS_SECS (telapsed) + EMACS_USECS (telapsed) / 1000000.0); 7407 if (pcpu > 1.0) 7408 pcpu = 1.0; 7409 attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs); 7410 pmem = 4.0 * 100 * rss / procfs_get_total_memory (); 7411 if (pmem > 100) 7412 pmem = 100; 7413 attrs = Fcons (Fcons (Qpmem, make_float (pmem)), attrs); 7414 } 7415 } At conditional (16): "fd >= 0" taking true path 7416 if (fd >= 0) 7417 emacs_close (fd); 7418 7419 /* args */ 7420 strcpy (procfn_end, "/cmdline"); 7421 fd = emacs_open (fn, O_RDONLY, 0); At conditional (17): "fd >= 0" taking true path 7422 if (fd >= 0) 7423 { At conditional (18): "emacs_read == 1" taking true path At conditional (20): "emacs_read == 1" taking false path 7424 for (cmdline_size = 0; emacs_read (fd, &c, 1) == 1; cmdline_size++) 7425 { At conditional (19): "*(*__ctype_b_loc + (c * 2)) & 8192 != 0" taking true path 7426 if (isspace (c) || c == '\\') 7427 cmdline_size++;/* for later quoting, see below */ 7428 } At conditional (21): "cmdline_size != 0" taking false path 7429 if (cmdline_size) 7430 { 7431 cmdline = xmalloc (cmdline_size + 1); 7432 lseek (fd, 0L, SEEK_SET); 7433 cmdline[0] = '\0'; 7434 if ((nread = read (fd, cmdline, cmdline_size)) >= 0) 7435 cmdline[nread++] = '\0'; 7436 /* We don't want trailing null characters. */ 7437 for (p = cmdline + nread - 1; p > cmdline && !*p; p--) 7438 nread--; 7439 for (p = cmdline; p < cmdline + nread; p++) 7440 { 7441 /* Escape-quote whitespace and backslashes. */ 7442 if (isspace (*p) || *p == '\\') 7443 { 7444 memmove (p + 1, p, nread - (p - cmdline)); 7445 nread++; 7446 *p++ = '\\'; 7447 } 7448 else if (*p == '\0') 7449 *p = ' '; 7450 } 7451 cmdline_size = nread; 7452 } 7453 else 7454 { 7455 cmdline_size = cmdsize + 2; 7456 cmdline = xmalloc (cmdline_size + 1); 7457 strcpy (cmdline, "["); Event uninit_arg: Using uninitialized value "cmd" as argument to function "strncat" Also see events: [var_decl] 7458 strcat (strncat (cmdline, cmd, cmdsize), "]"); 7459 } 7460 emacs_close (fd); 7461 /* Command line is encoded in locale-coding-system; decode it. */ 7462 cmd_str = make_unibyte_string (cmdline, cmdline_size); 7463 decoded_cmd = code_convert_string_norecord (cmd_str, 7464 Vlocale_coding_system, 0); 7465 xfree (cmdline); 7466 attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs); 7467 } 7468 7469 UNGCPRO; 7470 return attrs; 7471 }

Problem report #130: base/src/emacs/src/xterm.c(x_draw_glyph_string); UNINIT

Dan Nicolaescu — 2008-12-03T01:16:29

CID: 130 Checker: UNINIT (help) File: base/src/emacs/src/xterm.c Function: x_draw_glyph_string Description: Using uninitialized value "position" Event var_decl: Declared variable "position" without initializer Also see events: [uninit_use] 2729 unsigned long thickness, position; 2730 int y; 2731 At conditional (1): "(s)->prev != 0" taking true path At conditional (2): "(((s)->prev)->face)->underline_p != 0" taking false path 2732 if (s->prev && s->prev->face->underline_p) 2733 { 2734 /* We use the same underline style as the previous one. */ 2735 thickness = s->prev->underline_thickness; 2736 position = s->prev->underline_position; 2737 } 2738 else 2739 { 2740 /* Get the underline thickness. Default is 1 pixel. */ At conditional (3): "(s)->font != 0" taking false path 2741 if (s->font && s->font->underline_thickness > 0) 2742 thickness = s->font->underline_thickness; 2743 else 2744 thickness = 1; At conditional (4): "x_underline_at_descent_line != 0" taking false path 2745 if (x_underline_at_descent_line) 2746 position = (s->height - thickness) - (s->ybase - s->y); 2747 else 2748 { 2749 /* Get the underline position. This is the recommended 2750 vertical offset in pixels from the baseline to the top of 2751 the underline. This is a signed value according to the 2752 specs, and its default is 2753 2754 ROUND ((maximum descent) / 2), with 2755 ROUND(x) = floor (x + 0.5) */ 2756 At conditional (5): "x_use_underline_position_properties != 0" taking true path At conditional (6): "(s)->font != 0" taking false path 2757 if (x_use_underline_position_properties 2758 && s->font && s->font->underline_position >= 0) 2759 position = s->font->underline_position; At conditional (7): "(s)->font != 0" taking false path 2760 else if (s->font) 2761 position = (s->font->descent + 1) / 2; 2762 } Event uninit_use: Using uninitialized value "position" Also see events: [var_decl] 2763 position = max (position, underline_minimum_offset); 2764 }

Problem report #122: base/src/emacs/src/coding.c(encode_coding_emacs_mule); UNINIT

Dan Nicolaescu — 2008-12-03T01:16:58

CID: 122 Checker: UNINIT (help) File: base/src/emacs/src/coding.c Function: encode_coding_emacs_mule Description: Using uninitialized value "code" Event var_decl: Declared variable "code" without initializer Also see events: [uninit_use][uninit_use] 2444 unsigned code; 2445 int dimension; 2446 int emacs_mule_id; 2447 unsigned char leading_codes[2]; 2448 2449 if (preferred_charset_id >= 0) 2450 { 2451 charset = CHARSET_FROM_ID (preferred_charset_id); At conditional (1): "(((charset)->unified_p != 0 || (charset)->method == 3 || (charset)->method == 4) ? ((encode_char != (charset)->invalid_code) ? 1 : (0)) : (((c < 65536) ? (charset)->fast_map[c >> 10] & 1 << c >> 7 & 7 : ((charset)->fast_map[(c >> 15 + 62)] & 1 << c >> 12 & 7)) != 0 && (((charset)->method == 0) ? c >= (charset)->min_char && c <= (charset)->max_char : ((((charset)->method == 1 && (charset)->compact_codes_p != 0) ? ((((c < 128 && ((0), (((0), (((0), ((Vcharset_hash_table & -8)->key_and_value & -8))->contents[((2 * (charset)->hash_index) + 1)] & -8))->contents[5] & -8))->ascii & 7 == 4 && ((0), (((0), (((0), (((0), ((Vcharset_hash_table & -8)->key_and_value & -8))->contents[((2 * (charset)->hash_index) + 1)] & -8))->contents[5] & -8))->ascii & -8))->size & 4611686018428436480 == 4611686018428436480 && ((0), (((0), (((0), (((0), ((Vcharset_hash_table & -8)->key_and_value & -8))->contents[((2 * (charset)->hash_index) + 1)] & -8))->contents[5] & -8))->ascii & -8))->contents[c] != Qnil) ? ((0), (((0), (((0), (((0), ((Vcharset_hash_table & -8)->key_and_value & -8))->contents[((2 * (charset)->hash_index) + 1)] & -8))->contents[5] & -8))->ascii & -8))->contents[c] : (char_table_ref)) != Qnil) ? 1 : (0)) : (((encode_char != (charset)->invalid_code) ? 1 : (0)))))) != 0)) == 0" taking false path 2452 if (! CHAR_CHARSET_P (c, charset)) 2453 charset = char_charset (c, charset_list, NULL); 2454 } 2455 else 2456 charset = char_charset (c, charset_list, &code); At conditional (2): "charset == 0" taking false path 2457 if (! charset) 2458 { 2459 c = coding->default_char; 2460 if (ASCII_CHAR_P (c)) 2461 { 2462 EMIT_ONE_ASCII_BYTE (c); 2463 continue; 2464 } 2465 charset = char_charset (c, charset_list, &code); 2466 } 2467 dimension = CHARSET_DIMENSION (charset); 2468 emacs_mule_id = CHARSET_EMACS_MULE_ID (charset); At conditional (3): "emacs_mule_id < 160" taking true path At conditional (4): "0" taking false path 2469 EMACS_MULE_LEADING_CODES (emacs_mule_id, leading_codes); At conditional (5): "multibytep != 0" taking true path At conditional (6): "ch >= 128" taking true path At conditional (7): "ch <= 127" taking false path At conditional (8): "ch <= 2047" taking false path At conditional (9): "ch <= 65535" taking false path At conditional (10): "0" taking false path At conditional (11): "0" taking false path 2470 EMIT_ONE_BYTE (leading_codes[0]); At conditional (12): "leading_codes[1] != 0" taking true path 2471 if (leading_codes[1]) At conditional (13): "multibytep != 0" taking true path At conditional (14): "ch >= 128" taking true path At conditional (15): "ch <= 127" taking false path At conditional (16): "ch <= 2047" taking false path At conditional (17): "ch <= 65535" taking false path At conditional (18): "0" taking false path At conditional (19): "0" taking false path 2472 EMIT_ONE_BYTE (leading_codes[1]); At conditional (20): "dimension == 1" taking true path 2473 if (dimension == 1) Event uninit_use: Using uninitialized value "code" Also see events: [var_decl][uninit_use] At conditional (21): "multibytep != 0" taking true path 2474 EMIT_ONE_BYTE (code | 0x80); 2475 else 2476 { Event uninit_use: Using uninitialized value "code" Also see events: [var_decl][uninit_use] 2477 code |= 0x8080; 2478 EMIT_ONE_BYTE (code >> 8); 2479 EMIT_ONE_BYTE (code & 0xFF); 2480 } 2481 } 2482 }

Problem report #128: base/src/emacs/src/ftfont.c(ftfont_resolve_generic_family); UNINIT

Dan Nicolaescu — 2008-12-03T01:05:53

CID: 128 Checker: UNINIT (help) File: base/src/emacs/src/ftfont.c Function: ftfont_resolve_generic_family Description: Using uninitialized value "match" Event var_decl: Declared variable "match" without initializer Also see events: [uninit_use] 209 FcPattern *match; 210 FcResult result; 211 FcLangSet *langset; 212 213 family = Fintern (Fdowncase (SYMBOL_NAME (family)), Qnil); At conditional (1): "family == Qmono" taking true path 214 if (EQ (family, Qmono)) 215 family = Qmonospace; 216 else if (EQ (family, Qsans) || EQ (family, Qsans__serif)) 217 family = Qsans_serif; 218 slot = assq_no_quit (family, ftfont_generic_family_list); At conditional (2): "slot & 7 != 5" taking false path 219 if (! CONSP (slot)) 220 return Qnil; At conditional (3): "(0 + (((0), (slot & -8))->u).cdr) != Qt" taking false path 221 if (! EQ (XCDR (slot), Qt)) 222 return XCDR (slot); 223 pattern = FcPatternDuplicate (pattern); At conditional (4): "pattern == 0" taking true path 224 if (! pattern) 225 goto err; 226 FcPatternDel (pattern, FC_FOUNDRY); 227 FcPatternDel (pattern, FC_FAMILY); 228 FcPatternAddString (pattern, FC_FAMILY, SYMBOL_FcChar8 (family)); 229 if (FcPatternGetLangSet (pattern, FC_LANG, 0, &langset) != FcResultMatch) 230 { 231 /* This is to avoid the effect of locale. */ 232 langset = FcLangSetCreate (); 233 FcLangSetAdd (langset, "en"); 234 FcPatternAddLangSet (pattern, FC_LANG, langset); 235 FcLangSetDestroy (langset); 236 } 237 FcConfigSubstitute (NULL, pattern, FcMatchPattern); 238 FcDefaultSubstitute (pattern); 239 match = FcFontMatch (NULL, pattern, &result); 240 if (match) 241 { 242 FcChar8 *fam; 243 244 if (FcPatternGetString (match, FC_FAMILY, 0, &fam) == FcResultMatch) 245 family = intern ((char *) fam); 246 } 247 else 248 family = Qnil; 249 XSETCDR (slot, family); 250 err: Event uninit_use: Using uninitialized value "match" Also see events: [var_decl] 251 if (match) FcPatternDestroy (match); 252 if (pattern) FcPatternDestroy (pattern); 253 return family; 254 } 2

Problem report #127: base/src/emacs/src/ftfont.c(ftfont_list_family); UNINIT

Dan Nicolaescu — 2008-12-03T01:04:40

CID: 127 Checker: UNINIT (help) File: base/src/emacs/src/ftfont.c Function: ftfont_list_family Description: Using uninitialized value "list" Event var_decl: Declared variable "list" without initializer Also see events: [uninit_use] 973 Lisp_Object list; 974 FcPattern *pattern = NULL; 975 FcFontSet *fontset = NULL; 976 FcObjectSet *objset = NULL; 977 int i; 978 At conditional (1): "fc_initialized == 0" taking true path 979 if (! fc_initialized) 980 { 981 FcInit (); 982 fc_initialized = 1; 983 } 984 985 pattern = FcPatternCreate (); At conditional (2): "pattern == 0" taking true path 986 if (! pattern) 987 goto finish; 988 objset = FcObjectSetBuild (FC_FAMILY, NULL); 989 if (! objset) 990 goto finish; 991 fontset = FcFontList (NULL, pattern, objset); 992 if (! fontset) 993 goto finish; 994 995 list = Qnil; 996 for (i = 0; i < fontset->nfont; i++) 997 { 998 FcPattern *pat = fontset->fonts[i]; 999 FcChar8 *str; 1000 1001 if (FcPatternGetString (pat, FC_FAMILY, 0, &str) == FcResultMatch) 1002 list = Fcons (intern ((char *) str), list); 1003 } 1004 1005 finish: At conditional (3): "objset != 0" taking false path 1006 if (objset) FcObjectSetDestroy (objset); At conditional (4): "fontset != 0" taking false path 1007 if (fontset) FcFontSetDestroy (fontset); At conditional (5): "pattern != 0" taking false path 1008 if (pattern) FcPatternDestroy (pattern); 1009 Event uninit_use: Using uninitialized value "list" Also see events: [var_decl] 1010 return list; 1011 } 1012 1013

Problem report #124: base/src/emacs/src/term.c(encode_terminal_code); UNINIT

Dan Nicolaescu — 2008-12-03T01:01:34

CID: 124 Checker: UNINIT (help) File: base/src/emacs/src/term.c Function: encode_terminal_code Description: Using uninitialized value "c" in call to function "char_charset" Event var_decl: Declared variable "c" without initializer Also see events: [uninit_use_in_call] 655 int c; 656 Lisp_Object string; 657 658 string = Qnil; At conditional (1): "(((src + 0))->u).ch < 256" taking true path At conditional (2): "0" taking false path 659 SET_GLYPH_FROM_CHAR_GLYPH (g, src[0]); 660 At conditional (3): "(g).ch < 0" taking false path At conditional (4): "(g).face_id != 0" taking false path At conditional (5): "(g).ch >= tlen" taking false path At conditional (6): "*(tbase + ((g).ch * 8)) & 7 != 3" taking false path 661 if (GLYPH_INVALID_P (g) || GLYPH_SIMPLE_P (tbase, tlen, g)) 662 { 663 /* This glyph doesn't have an entry in Vglyph_table. */ 664 c = src->u.ch; 665 } 666 else 667 { 668 /* This glyph has an entry in Vglyph_table, 669 so process any alias before testing for simpleness. */ At conditional (7): "(g).face_id == 0" taking true path At conditional (8): "(g).ch < tlen" taking true path At conditional (9): "*(tbase + ((g).ch * 8)) & 7 == 0" taking true path At conditional (10): "(g).face_id == 0" taking true path At conditional (11): "(g).ch < tlen" taking true path At conditional (12): "*(tbase + ((g).ch * 8)) & 7 == 0" taking false path At conditional (13): "(g).ch > 4194303" taking true path At conditional (14): "0" taking false path 670 GLYPH_FOLLOW_ALIASES (tbase, tlen, g); 671 At conditional (15): "(g).face_id != 0" taking false path At conditional (16): "(g).ch >= tlen" taking false path At conditional (17): "*(tbase + ((g).ch * 8)) & 7 != 3" taking false path 672 if (GLYPH_SIMPLE_P (tbase, tlen, g)) 673 /* We set the multi-byte form of a character in G 674 (that should be an ASCII character) at WORKBUF. */ 675 c = GLYPH_CHAR (g); 676 else 677 /* We have a string in Vglyph_table. */ 678 string = tbase[GLYPH_CHAR (g)]; 679 } 680 At conditional (18): "string == Qnil" taking true path 681 if (NILP (string)) 682 { 683 nbytes = buf - encode_terminal_src; At conditional (19): "encode_terminal_src_size < (nbytes + 5)" taking true path 684 if (encode_terminal_src_size < nbytes + MAX_MULTIBYTE_LENGTH) 685 { 686 encode_terminal_src_size = nbytes + MAX_MULTIBYTE_LENGTH; 687 encode_terminal_src = xrealloc (encode_terminal_src, 688 encode_terminal_src_size); 689 buf = encode_terminal_src + nbytes; 690 } Event uninit_use_in_call: Using uninitialized value "c" in call to function "char_charset" [model] Also see events: [var_decl] 691 if (char_charset (c, charset_list, NULL)) 692 { 693 /* Store the multibyte form of C at BUF. */ 694 buf += CHAR_STRING (c, buf); 695 nchars++; 696 } 697 else 698 { 699 /* C is not encodable. */ 700 *buf++ = '?'; 701 nchars++; 702 while (src + 1 < src_end && CHAR_GLYPH_PADDING_P (src[1])) 703 { 704 *buf++ = '?'; 705 nchars++; 706 src++; 707 } 708 } 7

Problem report #125: base/src/emacs/src/search.c (simple_search);UNINIT

Dan Nicolaescu — 2008-12-03T01:02:36

CID: 125 Checker: UNINIT (help) File: base/src/emacs/src/search.c Function: simple_search Description: Using uninitialized value "match_byte" in call to function "set_search_regs" 1428 static int 1429 simple_search (n, pat, len, len_byte, trt, pos, pos_byte, lim, lim_byte) 1430 int n; 1431 unsigned char *pat; 1432 int len, len_byte; 1433 Lisp_Object trt; 1434 int pos, pos_byte; 1435 int lim, lim_byte; 1436 { At conditional (1): "(current_buffer)->enable_multibyte_characters != Qnil" taking true path 1437 int multibyte = ! NILP (current_buffer->enable_multibyte_characters); At conditional (2): "n > 0" taking false path 1438 int forward = n > 0; 1439 /* Number of buffer bytes matched. Note that this may be different 1440 from len_byte in a multibyte buffer. */ Event var_decl: Declared variable "match_byte" without initializer Also see events: [uninit_use_in_call] 1441 int match_byte; 1442 At conditional (3): "lim > pos" taking false path 1443 if (lim > pos && multibyte) 1444 while (n > 0) 1445 { 1446 while (1) 1447 { 1448 /* Try matching at position POS. */ 1449 int this_pos = pos; 1450 int this_pos_byte = pos_byte; 1451 int this_len = len; 1452 int this_len_byte = len_byte; 1453 unsigned char *p = pat; 1454 if (pos + len > lim || pos_byte + len_byte > lim_byte) 1455 goto stop; 1456 1457 while (this_len > 0) 1458 { 1459 int charlen, buf_charlen; 1460 int pat_ch, buf_ch; 1461 1462 pat_ch = STRING_CHAR_AND_LENGTH (p, this_len_byte, charlen); 1463 buf_ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (this_pos_byte), 1464 ZV_BYTE - this_pos_byte, 1465 buf_charlen); 1466 TRANSLATE (buf_ch, trt, buf_ch); 1467 1468 if (buf_ch != pat_ch) 1469 break; 1470 1471 this_len_byte -= charlen; 1472 this_len--; 1473 p += charlen; 1474 1475 this_pos_byte += buf_charlen; 1476 this_pos++; 1477 } 1478 1479 if (this_len == 0) 1480 { 1481 match_byte = this_pos_byte - pos_byte; 1482 pos += len; 1483 pos_byte += match_byte; 1484 break; 1485 } 1486 1487 INC_BOTH (pos, pos_byte); 1488 } 1489 1490 n--; 1491 } At conditional (4): "lim > pos" taking false path 1492 else if (lim > pos) 1493 while (n > 0) 1494 { 1495 while (1) 1496 { 1497 /* Try matching at position POS. */ 1498 int this_pos = pos; 1499 int this_len = len; 1500 unsigned char *p = pat; 1501 1502 if (pos + len > lim) 1503 goto stop; 1504 1505 while (this_len > 0) 1506 { 1507 int pat_ch = *p++; 1508 int buf_ch = FETCH_BYTE (this_pos); 1509 TRANSLATE (buf_ch, trt, buf_ch); 1510 1511 if (buf_ch != pat_ch) 1512 break; 1513 1514 this_len--; 1515 this_pos++; 1516 } 1517 1518 if (this_len == 0) 1519 { 1520 match_byte = len; 1521 pos += len; 1522 break; 1523 } 1524 1525 pos++; 1526 } 1527 1528 n--; 1529 } 1530 /* Backwards search. */ At conditional (5): "lim < pos" taking false path 1531 else if (lim < pos && multibyte) 1532 while (n < 0) 1533 { 1534 while (1) 1535 { 1536 /* Try matching at position POS. */ 1537 int this_pos = pos - len; 1538 int this_pos_byte; 1539 int this_len = len; 1540 int this_len_byte = len_byte; 1541 unsigned char *p = pat; 1542 1543 if (this_pos < lim || (pos_byte - len_byte) < lim_byte) 1544 goto stop; 1545 this_pos_byte = CHAR_TO_BYTE (this_pos); 1546 match_byte = pos_byte - this_pos_byte; 1547 1548 while (this_len > 0) 1549 { 1550 int charlen, buf_charlen; 1551 int pat_ch, buf_ch; 1552 1553 pat_ch = STRING_CHAR_AND_LENGTH (p, this_len_byte, charlen); 1554 buf_ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (this_pos_byte), 1555 ZV_BYTE - this_pos_byte, 1556 buf_charlen); 1557 TRANSLATE (buf_ch, trt, buf_ch); 1558 1559 if (buf_ch != pat_ch) 1560 break; 1561 1562 this_len_byte -= charlen; 1563 this_len--; 1564 p += charlen; 1565 this_pos_byte += buf_charlen; 1566 this_pos++; 1567 } 1568 1569 if (this_len == 0) 1570 { 1571 pos -= len; 1572 pos_byte -= match_byte; 1573 break; 1574 } 1575 1576 DEC_BOTH (pos, pos_byte); 1577 } 1578 1579 n++; 1580 } At conditional (6): "lim < pos" taking false path 1581 else if (lim < pos) 1582 while (n < 0) 1583 { 1584 while (1) 1585 { 1586 /* Try matching at position POS. */ 1587 int this_pos = pos - len; 1588 int this_len = len; 1589 unsigned char *p = pat; 1590 1591 if (this_pos < lim) 1592 goto stop; 1593 1594 while (this_len > 0) 1595 { 1596 int pat_ch = *p++; 1597 int buf_ch = FETCH_BYTE (this_pos); 1598 TRANSLATE (buf_ch, trt, buf_ch); 1599 1600 if (buf_ch != pat_ch) 1601 break; 1602 this_len--; 1603 this_pos++; 1604 } 1605 1606 if (this_len == 0) 1607 { 1608 match_byte = len; 1609 pos -= len; 1610 break; 1611 } 1612 1613 pos--; 1614 } 1615 1616 n++; 1617 } 1618 1619 stop: At conditional (7): "n == 0" taking true path 1620 if (n == 0) 1621 { At conditional (8): "forward != 0" taking false path 1622 if (forward) 1623 set_search_regs ((multibyte ? pos_byte : pos) - match_byte, match_byte); 1624 else Event uninit_use_in_call: Using uninitialized value "match_byte" in call to function "set_search_regs" [model] Also see events: [var_decl] At conditional (9): "multibyte != 0" taking true path 1625 set_search_regs (multibyte ? pos_byte : pos, match_byte); 1626 1627 return pos; 1628 } 1629 else if (n > 0) 1630 return -n; 1631 else 1632 return n; 1633 } 16

Problem report #126: base/src/emacs/src/font.c (font_at); UNINIT

Dan Nicolaescu — 2008-12-03T01:03:52

CID: 126 Checker: UNINIT (help) File: base/src/emacs/src/font.c Function: font_at Description: Using uninitialized value "multibyte" Event var_decl: Declared variable "multibyte" without initializer Also see events: [uninit_use] 3594 int multibyte; 3595 Lisp_Object font_object; 3596 At conditional (1): "c < 0" taking false path 3597 if (c < 0) 3598 { 3599 if (NILP (string)) 3600 { 3601 multibyte = ! NILP (current_buffer->enable_multibyte_characters); 3602 if (multibyte) 3603 { 3604 EMACS_INT pos_byte = CHAR_TO_BYTE (pos); 3605 3606 c = FETCH_CHAR (pos_byte); 3607 } 3608 else 3609 c = FETCH_BYTE (pos); 3610 } 3611 else 3612 { 3613 unsigned char *str; 3614 3615 multibyte = STRING_MULTIBYTE (string); 3616 if (multibyte) 3617 { 3618 EMACS_INT pos_byte = string_char_to_byte (string, pos); 3619 3620 str = SDATA (string) + pos_byte; 3621 c = STRING_CHAR (str, 0); 3622 } 3623 else 3624 c = SDATA (string)[pos]; 3625 } 3626 } 3627 3628 f = XFRAME (w->frame); At conditional (2): "(f)->output_method != 2" taking false path 3629 if (! FRAME_WINDOW_P (f)) 3630 return Qnil; At conditional (3): "face == 0" taking true path 3631 if (! face) 3632 { 3633 int face_id; 3634 EMACS_INT endptr; 3635 At conditional (4): "string & 7 == 3" taking true path 3636 if (STRINGP (string)) 3637 face_id = face_at_string_position (w, string, pos, 0, -1, -1, &endptr, 3638 DEFAULT_FACE_ID, 0); 3639 else 3640 face_id = face_at_buffer_position (w, pos, -1, -1, &endptr, 3641 pos + 100, 0); At conditional (5): "face_id < ((f)->face_cache)->used" taking true path 3642 face = FACE_FROM_ID (f, face_id); 3643 } Event uninit_use: Using uninitialized value "multibyte" Also see events: [var_decl] 3644 if (multibyte) 3645 { 3646 int face_id = FACE_FOR_CHAR (f, face, c, pos, string); 3647 face = FACE_FROM_ID (f, face_id); 3648 } 3649 if (! face->font) 3650 return Qnil; 3651 3652 XSETFONT (font_object, face->font); 3653 return font_object; 3654 }

Problem report #123: base/src/emacs/src/casefiddle.c(casify_region); UNINIT

Dan Nicolaescu — 2008-12-03T01:00:51

CID: 123 Checker: UNINIT (help) File: base/src/emacs/src/casefiddle.c Function: casify_region Description: Using uninitialized value "last" Event var_decl: Declared variable "last" without initializer Also see events: [uninit_use] 211 EMACS_INT first = -1, last;/* Position of first and last changes. */ 212 EMACS_INT opoint = PT; 213 EMACS_INT opoint_byte = PT_BYTE; 214 At conditional (2): "b == e" taking false path 215 if (EQ (b, e)) 216 /* Not modifying because nothing marked */ 217 return; 218 219 /* If the case table is flagged as modified, rescan it. */ At conditional (3): "((0), ((current_buffer)->downcase_table & -8))->extras[1] == Qnil" taking true path 220 if (NILP (XCHAR_TABLE (current_buffer->downcase_table)->extras[1])) 221 Fset_case_table (current_buffer->downcase_table); 222 223 validate_region (&b, &e); 224 start = XFASTINT (b); 225 end = XFASTINT (e); 226 modify_region (current_buffer, start, end, 0); 227 record_change (start, end - start); 228 start_byte = CHAR_TO_BYTE (start); 229 end_byte = CHAR_TO_BYTE (end); 230 At conditional (4): "start < end" taking true path At conditional (19): "start < end" taking false path 231 while (start < end) 232 { 233 int c2, len; 234 At conditional (5): "multibyte != 0" taking true path 235 if (multibyte) 236 { At conditional (6): "start_byte >= ((current_buffer)->text)->gpt_byte" taking true path At conditional (7): "*(_fetch_multibyte_char_p + 0) & 128 == 0" taking true path 237 c = FETCH_MULTIBYTE_CHAR (start_byte); At conditional (8): "c <= 127" taking true path 238 len = CHAR_BYTES (c); 239 } 240 else 241 { 242 c = FETCH_BYTE (start_byte); 243 MAKE_CHAR_MULTIBYTE (c); 244 len = 1; 245 } 246 c2 = c; At conditional (9): "inword != 0" taking true path At conditional (10): "flag != 3" taking true path 247 if (inword && flag != CASE_CAPITALIZE_UP) At conditional (11): "case_temp1 < 128" taking true path At conditional (12): "((0), ((current_buffer)->downcase_table & -8))->ascii & 7 == 4" taking true path At conditional (13): "((0), (((0), ((current_buffer)->downcase_table & -8))->ascii & -8))->size & 4611686018428436480 == 4611686018428436480" taking true path At conditional (14): "((0), (((0), ((current_buffer)->downcase_table & -8))->ascii & -8))->contents[case_temp1] != Qnil" taking true path At conditional (15): "case_temp2 & 7 == 0" taking true path At conditional (16): "case_temp2 >> 3 >= 0" taking true path 248 c = DOWNCASE (c); 249 else if (!UPPERCASEP (c) 250 && (!inword || flag != CASE_CAPITALIZE_UP)) 251 c = UPCASE1 (c); At conditional (17): "flag >= 2" taking false path 252 if ((int) flag >= (int) CASE_CAPITALIZE) 253 inword = ((SYNTAX (c) == Sword) && (inword || !SYNTAX_PREFIX (c))); At conditional (18): "c != c2" taking false path 254 if (c != c2) 255 { 256 last = start; 257 if (first < 0) 258 first = start; 259 260 if (! multibyte) 261 { 262 MAKE_CHAR_UNIBYTE (c); 263 FETCH_BYTE (start_byte) = c; 264 } 265 else if (ASCII_CHAR_P (c2) && ASCII_CHAR_P (c)) 266 FETCH_BYTE (start_byte) = c; 267 else 268 { 269 int tolen = CHAR_BYTES (c); 270 int j; 271 unsigned char str[MAX_MULTIBYTE_LENGTH]; 272 273 CHAR_STRING (c, str); 274 if (len == tolen) 275 { 276 /* Length is unchanged. */ 277 for (j = 0; j < len; ++j) 278 FETCH_BYTE (start_byte + j) = str[j]; 279 } 280 else 281 { 282 /* Replace one character with the other, 283 keeping text properties the same. */ 284 replace_range_2 (start, start_byte, 285 start + 1, start_byte + len, 286 str, 1, tolen, 287 0); 288 len = tolen; 289 } 290 } 291 } 292 start++; 293 start_byte += len; 294 } 295 At conditional (20): "((current_buffer)->pt + 0) != opoint" taking true path 296 if (PT != opoint) 297 TEMP_SET_PT_BOTH (opoint, opoint_byte); 298 At conditional (21): "first >= 0" taking true path 299 if (first >= 0) 300 { Event uninit_use: Using uninitialized value "last" Also see events: [var_decl] 301 signal_after_change (first, last + 1 - first, last + 1 - first); 302 update_compositions (first, last + 1, CHECK_ALL); 303 }

Problem report #121: base/src/emacs/src/coding.c(decode_coding_charset); UNINIT

Dan Nicolaescu — 2008-12-03T00:59:50

CID: 121 Checker: UNINIT (help) File: base/src/emacs/src/coding.c Function: decode_coding_charset Description: Using uninitialized value "charset" Event var_decl: Declared variable "charset" without initializer Also see events: [uninit_use] 5085 struct charset *charset; 5086 int dim; 5087 int len = 1; 5088 unsigned code; 5089 5090 src_base = src; 5091 consumed_chars_base = consumed_chars; 5092 At conditional (1): "charbuf >= charbuf_end" taking false path 5093 if (charbuf >= charbuf_end) 5094 break; 5095 At conditional (2): "byte_after_cr >= 0" taking false path 5096 if (byte_after_cr >= 0) 5097 { 5098 c = byte_after_cr; 5099 byte_after_cr = -1; 5100 } 5101 else 5102 { At conditional (3): "src == src_end" taking false path At conditional (4): "multibytep != 0" taking true path At conditional (5): "c & 128 != 0" taking true path At conditional (6): "c & 254 == 192" taking true path At conditional (7): "0" taking false path 5103 ONE_MORE_BYTE (c); At conditional (8): "eol_crlf != 0" taking true path At conditional (9): "c == 13" taking false path 5104 if (eol_crlf && c == '\r') 5105 ONE_MORE_BYTE (byte_after_cr); 5106 } At conditional (10): "c < 0" taking false path 5107 if (c < 0) 5108 goto invalid_code; 5109 code = c; 5110 5111 val = AREF (valids, c); At conditional (11): "val == Qnil" taking false path 5112 if (NILP (val)) 5113 goto invalid_code; At conditional (12): "val & 7 == 0" taking false path 5114 if (INTEGERP (val)) 5115 { 5116 charset = CHARSET_FROM_ID (XFASTINT (val)); 5117 dim = CHARSET_DIMENSION (charset); 5118 while (len < dim) 5119 { 5120 ONE_MORE_BYTE (c); 5121 code = (code << 8) | c; 5122 len++; 5123 } 5124 CODING_DECODE_CHAR (coding, src, src_base, src_end, 5125 charset, code, c); 5126 } 5127 else 5128 { 5129 /* VAL is a list of charset IDs. It is assured that the 5130 list is sorted by charset dimensions (smaller one 5131 comes first). */ At conditional (13): "val & 7 == 5" taking false path 5132 while (CONSP (val)) 5133 { 5134 charset = CHARSET_FROM_ID (XFASTINT (XCAR (val))); 5135 dim = CHARSET_DIMENSION (charset); 5136 while (len < dim) 5137 { 5138 ONE_MORE_BYTE (c); 5139 code = (code << 8) | c; 5140 len++; 5141 } 5142 CODING_DECODE_CHAR (coding, src, src_base, 5143 src_end, charset, code, c); 5144 if (c >= 0) 5145 break; 5146 val = XCDR (val); 5147 } 5148 } At conditional (14): "c < 0" taking false path 5149 if (c < 0) 5150 goto invalid_code; Event uninit_use: Using uninitialized value "charset" Also see events: [var_decl] 5151 if (charset->id != charset_ascii 5152 && last_id != charset->id) 5153 { 5154 if (last_id != charset_ascii) 5155 ADD_CHARSET_DATA (charbuf, char_offset - last_offset, last_id); 5156 last_id = charset->id; 5157 last_offset = char_offset; 5158 } 51

Problem report #120: base/src/emacs/src/indent.c (Fvertical_motion);UNINIT

Dan Nicolaescu — 2008-12-03T00:59:14

CID: 120 Checker: UNINIT (help) File: base/src/emacs/src/indent.c Function: Fvertical_motion Description: Using uninitialized value "cols" Event var_decl: Declared variable "cols" without initializer Also see events: [uninit_use] 2032 double cols; 2033 2034 /* Allow LINES to be of the form (HPOS . VPOS) aka (COLUMNS . LINES). */ At conditional (1): "lines & 7 == 5" taking true path At conditional (2): "(0 + ((0), (lines & -8))->car) & 7 == 0" taking false path At conditional (3): "(0 + ((0), (lines & -8))->car) & 7 == 6" taking false path 2035 if (CONSP (lines) && (NUMBERP (XCAR (lines)))) 2036 { 2037 lcols = XCAR (lines); 2038 cols = INTEGERP (lcols) ? (double) XINT (lcols) : XFLOAT_DATA (lcols); 2039 lines = XCDR (lines); 2040 } 2041 At conditional (4): "lines & 7 != 0" taking false path At conditional (5): "0" taking false path 2042 CHECK_NUMBER (lines); At conditional (6): "window != Qnil" taking true path 2043 if (! NILP (window)) At conditional (7): "window & 7 != 4" taking false path At conditional (8): "((0), (window & -8))->size & 4611686018427392000 != 4611686018427392000" taking false path At conditional (9): "0" taking false path 2044 CHECK_WINDOW (window); 2045 else 2046 window = selected_window; 2047 w = XWINDOW (window); 2048 2049 old_buffer = Qnil; 2050 GCPRO1 (old_buffer); At conditional (10): "(0), ((w)->buffer & -8 != current_buffer)" taking true path 2051 if (XBUFFER (w->buffer) != current_buffer) 2052 { 2053 /* Set the window's buffer temporarily to the current buffer. */ 2054 old_buffer = w->buffer; 2055 XSETBUFFER (w->buffer, current_buffer); 2056 } 2057 At conditional (11): "noninteractive != 0" taking false path 2058 if (noninteractive) 2059 { 2060 struct position pos; 2061 pos = *vmotion (PT, XINT (lines), w); 2062 SET_PT_BOTH (pos.bufpos, pos.bytepos); 2063 } 2064 else 2065 { 2066 int it_start, oselective, first_x, it_overshoot_expected; 2067 2068 SET_TEXT_POS (pt, PT, PT_BYTE); 2069 start_display (&it, w, pt); 2070 first_x = it.first_visible_x; 2071 it_start = IT_CHARPOS (it); 2072 2073 /* See comments below for why we calculate this. */ At conditional (12): "lines >> 3 > 0" taking true path 2074 if (XINT (lines) > 0) 2075 { At conditional (13): "((it).cmp_it).id >= 0" taking true path 2076 if (it.cmp_it.id >= 0) 2077 it_overshoot_expected = 1; 2078 else if (it.method == GET_FROM_STRING) 2079 { 2080 const char *s = SDATA (it.string); 2081 const char *e = s + SBYTES (it.string); 2082 while (s < e && *s != '\n') 2083 ++s; 2084 it_overshoot_expected = (s == e) ? -1 : 0; 2085 } 2086 else 2087 it_overshoot_expected = (it.method == GET_FROM_IMAGE 2088 || it.method == GET_FROM_STRETCH); 2089 } 2090 2091 /* Scan from the start of the line containing PT. If we don't 2092 do this, we start moving with IT->current_x == 0, while PT is 2093 really at some x > 0. */ 2094 reseat_at_previous_visible_line_start (&it); 2095 it.current_x = it.hpos = 0; 2096 /* Temporarily disable selective display so we don't move too far */ 2097 oselective = it.selective; 2098 it.selective = 0; 2099 move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS); 2100 it.selective = oselective; 2101 At conditional (14): "lines >> 3 <= 0" taking false path 2102 if (XINT (lines) <= 0) 2103 { 2104 it.vpos = 0; 2105 /* Do this even if LINES is 0, so that we move back to the 2106 beginning of the current line as we ought. */ 2107 if (XINT (lines) == 0 || IT_CHARPOS (it) > 0) 2108 move_it_by_lines (&it, XINT (lines), 0); 2109 } 2110 else 2111 { At conditional (15): "(((it).current).pos).charpos > it_start" taking true path 2112 if (IT_CHARPOS (it) > it_start) 2113 { 2114 /* IT may move too far if truncate-lines is on and PT 2115 lies beyond the right margin. In that case, 2116 backtrack unless the starting point is on an image, 2117 stretch glyph, composition, or Lisp string. */ At conditional (16): "it_overshoot_expected == 0" taking false path At conditional (17): "it_overshoot_expected < 0" taking false path 2118 if (!it_overshoot_expected 2119 /* Also, backtrack if the Lisp string contains no 2120 newline, but there is a newline right after it. 2121 In this case, IT overshoots if there is an 2122 after-string just before the newline. */ 2123 || (it_overshoot_expected < 0 2124 && it.method == GET_FROM_BUFFER 2125 && it.c == '\n')) 2126 move_it_by_lines (&it, -1, 0); 2127 it.vpos = 0; 2128 move_it_by_lines (&it, XINT (lines), 0); 2129 } 2130 else 2131 { 2132 /* Otherwise, we are at the first row occupied by PT, 2133 which might span multiple screen lines (e.g., if it's 2134 on a multi-line display string). We want to start 2135 from the last line that it occupies. */ 2136 if (it_start < ZV) 2137 { 2138 while (IT_CHARPOS (it) <= it_start) 2139 { 2140 it.vpos = 0; 2141 move_it_by_lines (&it, 1, 0); 2142 } 2143 if (XINT (lines) > 1) 2144 move_it_by_lines (&it, XINT (lines) - 1, 0); 2145 } 2146 else 2147 { 2148 it.vpos = 0; 2149 move_it_by_lines (&it, XINT (lines), 0); 2150 } 2151 } 2152 } 2153 2154 /* Move to the goal column, if one was specified. */ At conditional (18): "lcols != Qnil" taking true path 2155 if (!NILP (lcols)) 2156 { 2157 /* If the window was originally hscrolled, move forward by 2158 the hscrolled amount first. */ At conditional (19): "first_x > 0" taking true path 2159 if (first_x > 0) 2160 { 2161 move_it_in_display_line (&it, ZV, first_x, MOVE_TO_X); 2162 it.current_x = 0; 2163 } Event uninit_use: Using uninitialized value "cols" Also see events: [var_decl] 2164 move_it_in_display_line 2165 (&it, ZV, 2166 (int)(cols * FRAME_COLUMN_WIDTH (XFRAME (w->frame)) + 0.5), 2167 MOVE_TO_X); 2168 }

Problem report #118: base/src/emacs/src/charset.c(load_charset_map); UNINIT

Dan Nicolaescu — 2008-12-03T01:18:42

CID: 118 Checker: UNINIT (help) File: base/src/emacs/src/charset.c Function: load_charset_map Description: Using uninitialized value "table" in call to function "char_table_ref" Event var_decl: Declared variable "table" without initializer Also see events: [uninit_use_in_call][uninit_use_in_call] 203 Lisp_Object vec, table; 204 unsigned max_code = CHARSET_MAX_CODE (charset); 205 int ascii_compatible_p = charset->ascii_compatible_p; 206 int min_char, max_char, nonascii_min_char; 207 int i; 208 unsigned char *fast_map = charset->fast_map; 209 At conditional (1): "n_entries <= 0" taking false path 210 if (n_entries <= 0) 211 return; 212 At conditional (2): "control_flag > 0" taking false path 213 if (control_flag > 0) 214 { 215 int n = CODE_POINT_TO_INDEX (charset, max_code) + 1; 216 217 table = Fmake_char_table (Qnil, Qnil); 218 if (control_flag == 1) 219 vec = Fmake_vector (make_number (n), make_number (-1)); 220 else if (! CHAR_TABLE_P (Vchar_unify_table)) 221 Vchar_unify_table = Fmake_char_table (Qnil, Qnil); 222 223 charset_map_loaded = 1; 224 } 225 226 min_char = max_char = entries->entry[0].c; 227 nonascii_min_char = MAX_CHAR; At conditional (3): "i < n_entries" taking true path 228 for (i = 0; i < n_entries; i++) 229 { 230 unsigned from, to; 231 int from_index, to_index; 232 int from_c, to_c; 233 int idx = i % 0x10000; 234 At conditional (4): "i > 0" taking false path 235 if (i > 0 && idx == 0) 236 entries = entries->next; 237 from = entries->entry[idx].from; 238 to = entries->entry[idx].to; 239 from_c = entries->entry[idx].c; At conditional (5): "(charset)->code_linear_p != 0" taking true path 240 from_index = CODE_POINT_TO_INDEX (charset, from); At conditional (6): "from == to" taking true path 241 if (from == to) 242 { 243 to_index = from_index; 244 to_c = from_c; 245 } 246 else 247 { 248 to_index = CODE_POINT_TO_INDEX (charset, to); 249 to_c = from_c + (to_index - from_index); 250 } At conditional (7): "from_index < 0" taking false path At conditional (8): "to_index < 0" taking false path 251 if (from_index < 0 || to_index < 0) 252 continue; 253 At conditional (9): "control_flag < 2" taking true path 254 if (control_flag < 2) 255 { 256 int c; 257 At conditional (10): "to_c > max_char" taking true path 258 if (to_c > max_char) 259 max_char = to_c; 260 else if (from_c < min_char) 261 min_char = from_c; At conditional (11): "ascii_compatible_p != 0" taking true path 262 if (ascii_compatible_p) 263 { At conditional (12): "from_c >= 128" taking true path 264 if (! ASCII_BYTE_P (from_c)) 265 { At conditional (13): "from_c < nonascii_min_char" taking true path 266 if (from_c < nonascii_min_char) 267 nonascii_min_char = from_c; 268 } 269 else if (! ASCII_BYTE_P (to_c)) 270 { 271 nonascii_min_char = 0x80; 272 } 273 } 274 At conditional (14): "c <= to_c" taking true path At conditional (17): "c <= to_c" taking false path 275 for (c = from_c; c <= to_c; c++) At conditional (15): "c < 65536" taking true path At conditional (16): "0" taking false path 276 CHARSET_FAST_MAP_SET (c, fast_map); 277 At conditional (18): "control_flag == 1" taking true path 278 if (control_flag == 1) 279 { 280 unsigned code = from; 281 At conditional (19): "(charset)->compact_codes_p != 0" taking true path 282 if (CHARSET_COMPACT_CODES_P (charset)) At conditional (20): "1" taking true path 283 while (1) 284 { 285 ASET (vec, from_index, make_number (from_c)); Event uninit_use_in_call: Using uninitialized value "table" in call to function "char_table_ref" [model] Also see events: [var_decl][uninit_use_in_call] At conditional (21): "from_c < 128" taking false path 286 if (NILP (CHAR_TABLE_REF (table, from_c))) 287 CHAR_TABLE_SET (table, from_c, make_number (code)); 288 if (from_index == to_index) 289 break; 290 from_index++, from_c++; 291 code = INDEX_TO_CODE_POINT (charset, from_index); 292 } 293 else 294 for (; from_index <= to_index; from_index++, from_c++) 295 { 296 ASET (vec, from_index, make_number (from_c)); Event uninit_use_in_call: Using uninitialized value "table" in call to function "char_table_ref" [model] Also see events: [var_decl][uninit_use_in_call] 297 if (NILP (CHAR_TABLE_REF (table, from_c))) 298 CHAR_TABLE_SET (table, from_c, make_number (from_index)); 299 } 300 } 301 } 302 else 303

Problem report #119: base/src/emacs/src/charset.c(load_charset_map); UNINIT

Dan Nicolaescu — 2008-12-03T00:58:42

CID: 119 Checker: UNINIT (help) File: base/src/emacs/src/charset.c Function: load_charset_map Description: Using uninitialized value "vec" Event var_decl: Declared variable "vec" without initializer Also see events: [uninit_use][uninit_use] 203 Lisp_Object vec, table; 204 unsigned max_code = CHARSET_MAX_CODE (charset); 205 int ascii_compatible_p = charset->ascii_compatible_p; 206 int min_char, max_char, nonascii_min_char; 207 int i; 208 unsigned char *fast_map = charset->fast_map; 209 At conditional (1): "n_entries <= 0" taking false path 210 if (n_entries <= 0) 211 return; 212 At conditional (2): "control_flag > 0" taking false path 213 if (control_flag > 0) 214 { 215 int n = CODE_POINT_TO_INDEX (charset, max_code) + 1; 216 217 table = Fmake_char_table (Qnil, Qnil); 218 if (control_flag == 1) 219 vec = Fmake_vector (make_number (n), make_number (-1)); 220 else if (! CHAR_TABLE_P (Vchar_unify_table)) 221 Vchar_unify_table = Fmake_char_table (Qnil, Qnil); 222 223 charset_map_loaded = 1; 224 } 225 226 min_char = max_char = entries->entry[0].c; 227 nonascii_min_char = MAX_CHAR; At conditional (3): "i < n_entries" taking true path 228 for (i = 0; i < n_entries; i++) 229 { 230 unsigned from, to; 231 int from_index, to_index; 232 int from_c, to_c; 233 int idx = i % 0x10000; 234 At conditional (4): "i > 0" taking false path 235 if (i > 0 && idx == 0) 236 entries = entries->next; 237 from = entries->entry[idx].from; 238 to = entries->entry[idx].to; 239 from_c = entries->entry[idx].c; At conditional (5): "(charset)->code_linear_p != 0" taking true path 240 from_index = CODE_POINT_TO_INDEX (charset, from); At conditional (6): "from == to" taking true path 241 if (from == to) 242 { 243 to_index = from_index; 244 to_c = from_c; 245 } 246 else 247 { 248 to_index = CODE_POINT_TO_INDEX (charset, to); 249 to_c = from_c + (to_index - from_index); 250 } At conditional (7): "from_index < 0" taking false path At conditional (8): "to_index < 0" taking false path 251 if (from_index < 0 || to_index < 0) 252 continue; 253 At conditional (9): "control_flag < 2" taking true path 254 if (control_flag < 2) 255 { 256 int c; 257 At conditional (10): "to_c > max_char" taking true path 258 if (to_c > max_char) 259 max_char = to_c; 260 else if (from_c < min_char) 261 min_char = from_c; At conditional (11): "ascii_compatible_p != 0" taking true path 262 if (ascii_compatible_p) 263 { At conditional (12): "from_c >= 128" taking true path 264 if (! ASCII_BYTE_P (from_c)) 265 { At conditional (13): "from_c < nonascii_min_char" taking true path 266 if (from_c < nonascii_min_char) 267 nonascii_min_char = from_c; 268 } 269 else if (! ASCII_BYTE_P (to_c)) 270 { 271 nonascii_min_char = 0x80; 272 } 273 } 274 At conditional (14): "c <= to_c" taking true path At conditional (17): "c <= to_c" taking false path 275 for (c = from_c; c <= to_c; c++) At conditional (15): "c < 65536" taking true path At conditional (16): "0" taking false path 276 CHARSET_FAST_MAP_SET (c, fast_map); 277 At conditional (18): "control_flag == 1" taking true path 278 if (control_flag == 1) 279 { 280 unsigned code = from; 281 At conditional (19): "(charset)->compact_codes_p != 0" taking true path 282 if (CHARSET_COMPACT_CODES_P (charset)) At conditional (20): "1" taking true path 283 while (1) 284 { Event uninit_use: Using uninitialized value "vec" Also see events: [var_decl][uninit_use] 285 ASET (vec, from_index, make_number (from_c)); 286 if (NILP (CHAR_TABLE_REF (table, from_c))) 287 CHAR_TABLE_SET (table, from_c, make_number (code)); 288 if (from_index == to_index) 289 break; 290 from_index++, from_c++; 291 code = INDEX_TO_CODE_POINT (charset, from_index); 292 } 293 else 294 for (; from_index <= to_index; from_index++, from_c++) 295 { Event uninit_use: Using uninitialized value "vec" Also see events: [var_decl][uninit_use] 296 ASET (vec, from_index, make_number (from_c)); 297 if (NILP (CHAR_TABLE_REF (table, from_c))) 298 CHAR_TABLE_SET (table, from_c, make_number (from_index)); 299 } 3

Problem report #117: base/src/emacs/src/coding.c(encode_coding_object); UNINIT

Dan Nicolaescu — 2008-12-03T00:59:20

CID: 117 Checker: UNINIT (help) File: base/src/emacs/src/coding.c Function: encode_coding_object Description: Using uninitialized value "saved_pt_byte" in call to function "temp_set_point_both" Event var_decl: Declared variable "saved_pt_byte" without initializer Also see events: [uninit_use][uninit_use][uninit_use_in_call] 7330 int saved_pt = -1, saved_pt_byte; 7331 int need_marker_adjustment = 0; 7332 int kill_src_buffer = 0; 7333 Lisp_Object old_deactivate_mark; 7334 7335 old_deactivate_mark = Vdeactivate_mark; 7336 7337 coding->src_object = src_object; 7338 coding->src_chars = chars; 7339 coding->src_bytes = bytes; 7340 coding->src_multibyte = chars < bytes; 7341 7342 attrs = CODING_ID_ATTRS (coding->id); 7343 At conditional (1): "src_object == dst_object" taking true path 7344 if (EQ (src_object, dst_object)) 7345 { 7346 struct Lisp_Marker *tail; 7347 At conditional (2): "tail != 0" taking true path At conditional (5): "tail != 0" taking true path At conditional (8): "tail != 0" taking false path 7348 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next) 7349 { At conditional (3): "(tail)->insertion_type != 0" taking true path At conditional (4): "(tail)->charpos == (((tail)->insertion_type != 0) ? from : (to))" taking true path At conditional (6): "(tail)->insertion_type != 0" taking true path At conditional (7): "(tail)->charpos == (((tail)->insertion_type != 0) ? from : (to))" taking false path 7350 tail->need_adjustment 7351 = tail->charpos == (tail->insertion_type ? from : to); 7352 need_marker_adjustment |= tail->need_adjustment; 7353 } 7354 } 7355 At conditional (9): "((0), (attrs & -8))->contents[10] != Qnil" taking false path 7356 if (! NILP (CODING_ATTR_PRE_WRITE (attrs))) 7357 { 7358 coding->src_object = code_conversion_save (1, coding->src_multibyte); 7359 set_buffer_internal (XBUFFER (coding->src_object)); 7360 if (STRINGP (src_object)) 7361 insert_from_string (src_object, from, from_byte, chars, bytes, 0); 7362 else if (BUFFERP (src_object)) 7363 insert_from_buffer (XBUFFER (src_object), from, chars, 0); 7364 else 7365 insert_1_both (coding->source + from, chars, bytes, 0, 0, 0); 7366 7367 if (EQ (src_object, dst_object)) 7368 { 7369 set_buffer_internal (XBUFFER (src_object)); 7370 saved_pt = PT, saved_pt_byte = PT_BYTE; 7371 del_range_both (from, from_byte, to, to_byte, 1); 7372 set_buffer_internal (XBUFFER (coding->src_object)); 7373 } 7374 7375 { 7376 Lisp_Object args[3]; 7377 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5; 7378 7379 GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object, 7380 old_deactivate_mark); 7381 args[0] = CODING_ATTR_PRE_WRITE (attrs); 7382 args[1] = make_number (BEG); 7383 args[2] = make_number (Z); 7384 safe_call (3, args); 7385 UNGCPRO; 7386 } 7387 if (XBUFFER (coding->src_object) != current_buffer) 7388 kill_src_buffer = 1; 7389 coding->src_object = Fcurrent_buffer (); 7390 if (BEG != GPT) 7391 move_gap_both (BEG, BEG_BYTE); 7392 coding->src_chars = Z - BEG; 7393 coding->src_bytes = Z_BYTE - BEG_BYTE; 7394 coding->src_pos = BEG; 7395 coding->src_pos_byte = BEG_BYTE; 7396 coding->src_multibyte = Z < Z_BYTE; 7397 } At conditional (10): "src_object & 7 == 3" taking true path 7398 else if (STRINGP (src_object)) 7399 { 7400 code_conversion_save (0, 0); 7401 coding->src_pos = from; 7402 coding->src_pos_byte = from_byte; 7403 } 7404 else if (BUFFERP (src_object)) 7405 { 7406 code_conversion_save (0, 0); 7407 set_buffer_internal (XBUFFER (src_object)); 7408 if (EQ (src_object, dst_object)) 7409 { 7410 saved_pt = PT, saved_pt_byte = PT_BYTE; 7411 coding->src_object = del_range_1 (from, to, 1, 1); 7412 coding->src_pos = 0; 7413 coding->src_pos_byte = 0; 7414 } 7415 else 7416 { 7417 if (from < GPT && to >= GPT) 7418 move_gap_both (from, from_byte); 7419 coding->src_pos = from; 7420 coding->src_pos_byte = from_byte; 7421 } 7422 } 7423 else 7424 code_conversion_save (0, 0); 7425 At conditional (11): "dst_object & 7 == 4" taking true path At conditional (12): "((0), (dst_object & -8))->size & 4611686018427518976 == 4611686018427518976" taking true path 7426 if (BUFFERP (dst_object)) 7427 { 7428 coding->dst_object = dst_object; At conditional (13): "src_object == dst_object" taking true path 7429 if (EQ (src_object, dst_object)) 7430 { 7431 coding->dst_pos = from; 7432 coding->dst_pos_byte = from_byte; 7433 } 7434 else 7435 { 7436 struct buffer *current = current_buffer; 7437 7438 set_buffer_temp (XBUFFER (dst_object)); 7439 coding->dst_pos = PT; 7440 coding->dst_pos_byte = PT_BYTE; 7441 move_gap_both (coding->dst_pos, coding->dst_pos_byte); 7442 set_buffer_temp (current); 7443 } At conditional (14): "((0), (dst_object & -8))->enable_multibyte_characters != Qnil" taking true path 7444 coding->dst_multibyte 7445 = ! NILP (XBUFFER (dst_object)->enable_multibyte_characters); 7446 } 7447 else if (EQ (dst_object, Qt)) 7448 { 7449 coding->dst_object = Qnil; 7450 coding->dst_bytes = coding->src_chars; 7451 if (coding->dst_bytes == 0) 7452 coding->dst_bytes = 1; 7453 coding->destination = (unsigned char *) xmalloc (coding->dst_bytes); 7454 coding->dst_multibyte = 0; 7455 } 7456 else 7457 { 7458 coding->dst_object = Qnil; 7459 coding->dst_multibyte = 0; 7460 } 7461 7462 encode_coding (coding); 7463 At conditional (15): "dst_object == Qt" taking true path 7464 if (EQ (dst_object, Qt)) 7465 { At conditional (16): "(coding)->dst_object & 7 == 4" taking true path At conditional (17): "((0), ((coding)->dst_object & -8))->size & 4611686018427518976 == 4611686018427518976" taking true path 7466 if (BUFFERP (coding->dst_object)) 7467 coding->dst_object = Fbuffer_string (); 7468 else 7469 { 7470 coding->dst_object 7471 = make_unibyte_string ((char *) coding->destination, 7472 coding->produced); 7473 xfree (coding->destination); 7474 } 7475 } 7476 At conditional (18): "saved_pt >= 0" taking true path 7477 if (saved_pt >= 0) 7478 { 7479 /* This is the case of: 7480 (BUFFERP (src_object) && EQ (src_object, dst_object)) 7481 As we have moved PT while replacing the original buffer 7482 contents, we must recover it now. */ 7483 set_buffer_internal (XBUFFER (src_object)); At conditional (19): "saved_pt < from" taking false path 7484 if (saved_pt < from) Event uninit_use_in_call: Using uninitialized value "saved_pt_byte" in call to function "temp_set_point_both" [model] Also see events: [var_decl][uninit_use][uninit_use] 7485 TEMP_SET_PT_BOTH (saved_pt, saved_pt_byte); At conditional (20): "saved_pt < (from + chars)" taking false path 7486 else if (saved_pt < from + chars) 7487 TEMP_SET_PT_BOTH (from, from_byte); At conditional (21): "(current_buffer)->enable_multibyte_characters != Qnil" taking true path 7488 else if (! NILP (current_buffer->enable_multibyte_characters)) Event uninit_use: Using uninitialized value "saved_pt_byte" Also see events: [var_decl][uninit_use][uninit_use_in_call] 7489 TEMP_SET_PT_BOTH (saved_pt + (coding->produced_char - chars), 7490 saved_pt_byte + (coding->produced - bytes)); 7491 else Event uninit_use: Using uninitialized value "saved_pt_byte" Also see events: [var_decl][uninit_use][uninit_use_in_call] 7492 TEMP_SET_PT_BOTH (saved_pt + (coding->produced - bytes), 7493 saved_pt_byte + (coding->produced - bytes)); 7494

Problem report #116: base/src/emacs/src/fontset.c (face_for_char);UNINIT

Dan Nicolaescu — 2008-12-03T00:54:16

CID: 116 Checker: UNINIT (help) File: base/src/emacs/src/fontset.c Function: face_for_char Description: Using uninitialized value "id" in call to function "fontset_font" 867 868 int 869 face_for_char (f, face, c, pos, object) 870 FRAME_PTR f; 871 struct face *face; 872 int c, pos; 873 Lisp_Object object; 874 { 875 Lisp_Object fontset, rfont_def, charset; 876 int face_id; Event var_decl: Declared variable "id" without initializer Also see events: [uninit_use_in_call] 877 int id; 878 At conditional (1): "c < 128" taking false path 879 if (ASCII_CHAR_P (c)) 880 return face->ascii_face->id; 881 882 xassert (fontset_id_valid_p (face->fontset)); 883 fontset = FONTSET_FROM_ID (face->fontset); 884 xassert (!BASE_FONTSET_P (fontset)); 885 At conditional (2): "pos < 0" taking false path 886 if (pos < 0) 887 { 888 id = -1; 889 charset = Qnil; 890 } 891 else 892 { 893 charset = Fget_char_property (make_number (pos), Qcharset, object); At conditional (3): "charset == Qnil" taking false path 894 if (NILP (charset)) 895 id = -1; At conditional (4): "hash_lookup >= 0" taking false path 896 else if (CHARSETP (charset)) 897 { 898 Lisp_Object val; 899 900 val = assoc_no_quit (charset, Vfont_encoding_charset_alist); 901 if (CONSP (val) && CHARSETP (XCDR (val))) 902 charset = XCDR (val); 903 id = XINT (CHARSET_SYMBOL_ID (charset)); 904 } 905 } 906 907 font_deferred_log ("font for", Fcons (make_number (c), charset), Qnil); Event uninit_use_in_call: Using uninitialized value "id" in call to function "fontset_font" [model] Also see events: [var_decl] 908 rfont_def = fontset_font (fontset, c, face, id); 909 if (VECTORP (rfont_def)) 910 {