Attachment #58807 for bug #92485

View | Details | Raw Unified | Return to bug 92485
Collapse All | Expand All




    Xfd = XConnectionNumber(Xdisplay);
    D_CMD(("Xfd = %d\n", Xfd));
    cmdbuf_ptr = cmdbuf_endp = cmdbuf_base;
    AT_LEAST(num_fds, Xfd + 1);
    if (pipe_fd >= 0) {
        AT_LEAST(num_fds, pipe_fd + 1);
    }
    if ((cmd_fd = command_func(argv)) < 0) {
        print_error("Unable to run sub-command.\n");

            register unsigned char *str;

            D_CMD(("Command buffer contains %d characters.\n", cmdbuf_endp - cmdbuf_ptr));
            D_VT(("\n%s\n\n", safe_print_string((char *)cmdbuf_ptr - 1, cmdbuf_endp - cmdbuf_ptr + 1)));

            /*
             * point to the start of the string,




                      } else if (action_check_modifiers(MOD_SHIFT, ev->xbutton.state)) {
                          scr_page(UP, 1);
                      } else if (action_check_modifiers(MOD_ALT, ev->xbutton.state)) {
                          tt_write((unsigned char *)"\033[5~", 4);
                      } else if (action_check_modifiers((MOD_ALT | MOD_SHIFT), ev->xbutton.state)) {
                          tt_write((unsigned char *)"\033[A", 3);
                      } else if (action_check_modifiers((MOD_ALT | MOD_CTRL), ev->xbutton.state)) {
                          tt_write((unsigned char *)"\033[5~\033[5~\033[5~\033[5~\033[5~", 20);
                      } else {
                          scr_page(UP, TermWin.nrow - CONTEXT_LINES);
                      }

                      } else if (action_check_modifiers(MOD_SHIFT, ev->xbutton.state)) {
                          scr_page(DN, 1);
                      } else if (action_check_modifiers(MOD_ALT, ev->xbutton.state)) {
                          tt_write((unsigned char *)"\033[6~", 4);
                      } else if (action_check_modifiers((MOD_ALT | MOD_SHIFT), ev->xbutton.state)) {
                          tt_write((unsigned char *)"\033[B", 3);
                      } else if (action_check_modifiers((MOD_ALT | MOD_CTRL), ev->xbutton.state)) {
                          tt_write((unsigned char *)"\033[6~\033[6~\033[6~\033[6~\033[6~", 20);
                      } else {
                          scr_page(DN, TermWin.nrow - CONTEXT_LINES);
                      }





    ASSERT_RVAL(line != NULL, 0);

    n = num_words((spif_charptr_t)line);

    if (!BEG_STRCASECMP(line, "none")) {
        MEMSET(&fshadow, 0, sizeof(fontshadow_t));

        if (n != 2) {
            return 0;
        }
        color = (char *)get_word(2, (spif_charptr_t)line);
        p = get_color_by_name(color, "black");
        FREE(color);
        for (which = 0; which < 4; which++) {

    } else if (!BEG_STRCASECMP(line, "shadow")) {
        if (n == 2) {
            which = SHADOW_BOTTOM_RIGHT;
            color = (char *)get_word(2, (spif_charptr_t)line);
        } else if (n == 3) {
            color = (char *)get_word(3, (spif_charptr_t)line);
            corner = (char *)get_pword(2, (spif_charptr_t)line);
            which = get_corner(corner);
            if (which >= 4) {
                return 0;

        if (n != 3) {
            return 0;
        }
        color = (char *)get_word(2, (spif_charptr_t)line);
        p = get_color_by_name(color, "black");
        set_shadow_color_by_pixel(SHADOW_BOTTOM_RIGHT, p);
        FREE(color);

        color = (char *)get_word(3, (spif_charptr_t)line);
        p = get_color_by_name(color, "white");
        set_shadow_color_by_pixel(SHADOW_TOP_LEFT, p);
        FREE(color);

        if (n != 3) {
            return 0;
        }
        color = (char *)get_word(2, (spif_charptr_t)line);
        p = get_color_by_name(color, "black");
        set_shadow_color_by_pixel(SHADOW_TOP_LEFT, p);
        FREE(color);

        color = (char *)get_word(3, (spif_charptr_t)line);
        p = get_color_by_name(color, "white");
        set_shadow_color_by_pixel(SHADOW_BOTTOM_RIGHT, p);
        FREE(color);

            which = get_corner(line);
            if (which >= 4) {
                which = i;
                color = (char *)get_word(1, (spif_charptr_t)line);
                line = (char *)get_pword(2, (spif_charptr_t)line);
            } else {
                color = (char *)get_word(2, (spif_charptr_t)line);
                line = (char *)get_pword(3, (spif_charptr_t)line);
            }
            set_shadow_color_by_name(which, color);
            FREE(color);





    if (str && *str) {

        chomp((spif_charptr_t)str);
        n = strlen(str);

        if (!n) {

    register unsigned char *out, *outp, *in;
    register unsigned long i;

    D_CMD(("buff == %8p \"%s\", cnt == %lu\n", buff, safe_print_string((char *)buff, cnt), cnt));
    outp = out = (unsigned char *) MALLOC(cnt * 2);
    for (i = 0, in = buff; i < cnt; i++) {
        if (*in == '\n') {

    i = (unsigned long) (out - outp);
    memcpy(buff, outp, i);
    FREE(outp);
    D_CMD(("buff == %8p \"%s\", i == %lu\n", buff, safe_print_string((char *)buff, i), i));
    return i;
}





static void
handle_attribute(char *val_ptr)
{
    conf_parse_line(NULL, (spif_charptr_t)val_ptr);
}

/* The config file parsers.  Each function handles a given context. */

        return NULL;
    }
    if (!BEG_STRCASECMP(buff, "foreground ")) {
        RESET_AND_ASSIGN(rs_color[fgColor], (char *)get_word(2, (spif_charptr_t)buff));
    } else if (!BEG_STRCASECMP(buff, "background ")) {
        RESET_AND_ASSIGN(rs_color[bgColor], (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "cursor ")) {

#ifndef NO_CURSORCOLOR
        RESET_AND_ASSIGN(rs_color[cursorColor], (char *)get_word(2, (spif_charptr_t)buff));
#else
        print_warning("Support for the cursor attribute was not compiled in, ignoring\n");
#endif

    } else if (!BEG_STRCASECMP(buff, "cursor_text ")) {
#ifndef NO_CURSORCOLOR
        RESET_AND_ASSIGN(rs_color[cursorColor2], (char *)get_word(2, (spif_charptr_t)buff));
#else
        print_warning("Support for the cursor_text attribute was not compiled in, ignoring\n");
#endif

    } else if (!BEG_STRCASECMP(buff, "pointer ")) {
        RESET_AND_ASSIGN(rs_color[pointerColor], (char *)get_word(2, (spif_charptr_t)buff));

#ifdef ESCREEN
    } else if (!BEG_STRCASECMP(buff, "es_current ")) {
        RESET_AND_ASSIGN(rs_color[ES_COLOR_CURRENT], (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "es_active ")) {
        RESET_AND_ASSIGN(rs_color[ES_COLOR_ACTIVE], (char *)get_word(2, (spif_charptr_t)buff));
#endif

    } else if (!BEG_STRCASECMP(buff, "video ")) {

        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!BEG_STRCASECMP(tmp, "reverse")) {
            BITFIELD_SET(vt_options, VT_OPTIONS_REVERSE_VIDEO);

        char *tmp = 0, *r1, *g1, *b1;
        unsigned int n, r, g, b, index = 0;

        n = num_words((spif_charptr_t)buff);
        if (n < 3) {
            print_error("Parse error in file %s, line %lu:  Invalid parameter list \"%s\" for \n"
                        "attribute color", file_peek_path(), file_peek_line(), NONULL(tmp));
            return NULL;
        }
        tmp = (char *)get_pword(2, (spif_charptr_t)buff);
        r1 = (char *)get_pword(3, (spif_charptr_t)buff);
        if (!isdigit(*r1)) {
            if (isdigit(*tmp)) {
                n = strtoul(tmp, (char **) NULL, 0);

                } else if (n >= 8 && n <= 15) {
                    index = minBright + n - 8;
                }
                RESET_AND_ASSIGN(rs_color[index], (char *)get_word(1, (spif_charptr_t)r1));
                return NULL;
            } else {
                if (!BEG_STRCASECMP(tmp, "bd ")) {
#ifndef NO_BOLDUNDERLINE
                    RESET_AND_ASSIGN(rs_color[colorBD], (char *)get_word(1, (spif_charptr_t)r1));
#else
                    print_warning("Support for the color bd attribute was not compiled in, ignoring\n");
#endif
                    return NULL;
                } else if (!BEG_STRCASECMP(tmp, "ul ")) {
#ifndef NO_BOLDUNDERLINE
                    RESET_AND_ASSIGN(rs_color[colorUL], (char *)get_word(1, (spif_charptr_t)r1));
#else
                    print_warning("Support for the color ul attribute was not compiled in, ignoring\n");
#endif
                    return NULL;
                } else {
                    tmp = (char *)get_word(1, (spif_charptr_t)tmp);
                    print_error("Parse error in file %s, line %lu:  Invalid color index \"%s\"\n",
                                file_peek_path(), file_peek_line(), NONULL(tmp));
                    FREE(tmp);

                        "attribute color", file_peek_path(), file_peek_line(), NONULL(tmp));
            return NULL;
        }
        g1 = (char *)get_pword(4, (spif_charptr_t)buff);
        b1 = (char *)get_pword(5, (spif_charptr_t)buff);
        if (isdigit(*tmp)) {
            n = strtoul(tmp, (char **) NULL, 0);
            r = strtoul(r1, (char **) NULL, 0);

#endif

        } else {
            tmp = (char *)get_word(1, (spif_charptr_t)tmp);
            print_error("Parse error in file %s, line %lu:  Invalid color index \"%s\"\n", file_peek_path(), file_peek_line(), NONULL(tmp));
            FREE(tmp);
        }

        return NULL;
    }
    if (!BEG_STRCASECMP(buff, "geometry ")) {
        RESET_AND_ASSIGN(rs_geometry, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "title ")) {
        RESET_AND_ASSIGN(rs_title, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "name ")) {
        RESET_AND_ASSIGN(rs_name, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "iconname ")) {
        RESET_AND_ASSIGN(rs_iconName, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "desktop ")) {
        rs_desktop = (int) strtol(buff, (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "scrollbar_type ")) {
        RESET_AND_ASSIGN(rs_scrollbar_type, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "scrollbar_width ")) {
        rs_scrollbar_width = strtoul((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "font ")) {

        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);
        unsigned long n;

        if (!BEG_STRCASECMP(tmp, "fx ") || !BEG_STRCASECMP(tmp, "effect")) {
            if (parse_font_fx((char *)get_pword(2, (spif_charptr_t)tmp)) != 1) {
                print_error("Parse error in file %s, line %lu:  Syntax error in font effects specification\n",
                            file_peek_path(), file_peek_line());
            }
        } else if (!BEG_STRCASECMP(tmp, "prop")) {
            tmp = (char *)get_pword(2, (spif_charptr_t)tmp);
            if (BOOL_OPT_ISTRUE(tmp)) {
                BITFIELD_SET(vt_options, VT_OPTIONS_PROPORTIONAL);
            } else if (BOOL_OPT_ISFALSE(tmp)) {

        } else if (isdigit(*tmp)) {
            n = strtoul(tmp, (char **) NULL, 0);
            if (n <= 255) {
                eterm_font_add(&etfonts, (char *)get_pword(2, (spif_charptr_t)tmp), n);
            } else {
                print_error("Parse error in file %s, line %lu:  Invalid font index %d\n", file_peek_path(), file_peek_line(), n);
            }
        } else if (!BEG_STRCASECMP(tmp, "bold ")) {
#ifndef NO_BOLDFONT
            RESET_AND_ASSIGN(rs_boldFont, (char *)get_word(2, (spif_charptr_t)tmp));
#else
            print_warning("Support for the bold font attribute was not compiled in, ignoring\n");
#endif

        } else if (!BEG_STRCASECMP(tmp, "default ")) {
            def_font_idx = strtoul((char *)get_pword(2, (spif_charptr_t)tmp), (char **) NULL, 0);

        } else {
            tmp = (char *)get_word(1, (spif_charptr_t)tmp);
            print_error("Parse error in file %s, line %lu:  Invalid font index \"%s\"\n", file_peek_path(), file_peek_line(), NONULL(tmp));
            FREE(tmp);
        }

    if ((*buff == CONF_BEGIN_CHAR) || (*buff == CONF_END_CHAR)) {
        return NULL;
    }
    if (!(tmp = (char *)get_pword(2, (spif_charptr_t)buff))) {
        print_error("Parse error in file %s, line %lu:  Missing boolean value in context toggles\n", file_peek_path(), file_peek_line());
        return NULL;
    }

    }
    if (!BEG_STRCASECMP(buff, "smallfont_key ")) {
#if defined (HOTKEY_CTRL) || defined (HOTKEY_META)
        RESET_AND_ASSIGN(rs_smallfont_key, (char *)get_word(2, (spif_charptr_t)buff));
        TO_KEYSYM(&ks_smallfont, rs_smallfont_key);
#else
        print_warning("Support for the smallfont_key attribute was not compiled in, ignoring\n");


    } else if (!BEG_STRCASECMP(buff, "bigfont_key ")) {
#if defined (HOTKEY_CTRL) || defined (HOTKEY_META)
        RESET_AND_ASSIGN(rs_bigfont_key, (char *)get_word(2, (spif_charptr_t)buff));
        TO_KEYSYM(&ks_bigfont, rs_bigfont_key);
#else
        print_warning("Support for the bigfont_key attribute was not compiled in, ignoring\n");

                            file_peek_path(), file_peek_line(), sym + 0xff00);
                return NULL;
            }
            s = (char *)get_word(3, (spif_charptr_t)buff);
            str = (char *) MALLOC(strlen(s) + 2);
            strcpy(str, s);
            FREE(s);
            chomp((spif_charptr_t)str);
            len = parse_escaped_string(str);
            if (len > 255)
                len = 255;      /* We can only handle lengths that will fit in a char */

#endif

    } else if (!BEG_STRCASECMP(buff, "meta_mod ")) {
        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!tmp) {
            print_error("Parse error in file %s, line %lu:  Missing modifier value for attribute meta_mod\n",

        rs_meta_mod = (unsigned int) strtoul(tmp, (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "alt_mod ")) {
        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!tmp) {
            print_error("Parse error in file %s, line %lu:  Missing modifier value for attribute alt_mod\n",

        rs_alt_mod = (unsigned int) strtoul(tmp, (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "numlock_mod ")) {
        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!tmp) {
            print_error("Parse error in file %s, line %lu:  Missing modifier value for attribute numlock_mod\n",


    } else if (!BEG_STRCASECMP(buff, "app_keypad ")) {

        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!tmp) {
            print_error("Parse error in file %s, line %lu:  Missing boolean value for attribute app_keypad\n",


    } else if (!BEG_STRCASECMP(buff, "app_cursor ")) {

        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!tmp) {
            print_error("Parse error in file %s, line %lu:  Missing boolean value for attribute app_cursor\n",

    }
    if (!BEG_STRCASECMP(buff, "print_pipe ")) {
#ifdef PRINTPIPE
        RESET_AND_ASSIGN(rs_print_pipe, (char *)get_word(2, (spif_charptr_t)buff));
#else
        print_warning("Support for the print_pipe attribute was not compiled in, ignoring\n");
#endif

    } else if (!BEG_STRCASECMP(buff, "save_lines ")) {
        rs_saveLines = strtol((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "min_anchor_size ")) {
        rs_min_anchor_size = strtol((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "border_width ")) {
#ifdef BORDER_WIDTH_OPTION
        TermWin.internalBorder = (short) strtol((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);
#else
        print_warning("Support for the border_width attribute was not compiled in, ignoring\n");
#endif

    } else if (!BEG_STRCASECMP(buff, "line_space ")) {
        rs_line_space = strtol((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "finished_title ")) {
        RESET_AND_ASSIGN(rs_finished_title, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "finished_text ")) {
        RESET_AND_ASSIGN(rs_finished_text, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "term_name ")) {
        RESET_AND_ASSIGN(rs_term_name, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "debug ")) {
        DEBUG_LEVEL = (unsigned int) strtoul((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);

    } else if (!BEG_STRCASECMP(buff, "exec ")) {

        register unsigned short k, n;

        RESET_AND_ASSIGN(rs_exec_args, (char **) MALLOC(sizeof(char *) * ((n = num_words(get_pword(2, (spif_charptr_t)buff))) + 1)));

        for (k = 0; k < n; k++) {
            rs_exec_args[k] = (char *)get_word(k + 2, (spif_charptr_t)buff);
            D_OPTIONS(("rs_exec_args[%d] == %s\n", k, rs_exec_args[k]));
        }
        rs_exec_args[n] = (char *) NULL;

    } else if (!BEG_STRCASECMP(buff, "cut_chars ")) {
#ifdef CUTCHAR_OPTION
        RESET_AND_ASSIGN(rs_cutchars, (char *)get_word(2, (spif_charptr_t)buff));
        chomp((spif_charptr_t)rs_cutchars);
#else
        print_warning("Support for the cut_chars attribute was not compiled in, ignoring\n");
#endif


    if (!BEG_STRCASECMP(buff, "icon ")) {
#ifdef PIXMAP_SUPPORT
        RESET_AND_ASSIGN(rs_icon, (char *)get_word(2, (spif_charptr_t)buff));
#else
        print_warning("Pixmap support was not compiled in, ignoring \"icon\" attribute\n");
#endif

    } else if (!BEG_STRCASECMP(buff, "cache")) {
#ifdef PIXMAP_SUPPORT
        rs_cache_size = strtoul((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);
#else
        print_warning("Pixmap support was not compiled in, ignoring \"cache\" attribute\n");
#endif

    } else if (!BEG_STRCASECMP(buff, "path ")) {
        RESET_AND_ASSIGN(rs_path, (char *)get_word(2, (spif_charptr_t)buff));

    } else if (!BEG_STRCASECMP(buff, "anim ")) {
#ifdef BACKGROUND_CYCLING_SUPPORT
        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (tmp) {
            rs_anim_pixmap_list = STRDUP(tmp);

    }
    idx = *((int *) state);
    if (!BEG_STRCASECMP(buff, "type ")) {
        char *type = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!type) {
            print_error("Parse error in file %s, line %lu:  Missing image type\n", file_peek_path(), file_peek_line());

        *((int *) state) = idx;

    } else if (!BEG_STRCASECMP(buff, "mode ")) {
        char *mode = (char *)get_pword(2, (spif_charptr_t)buff);
        char *allow_list = (char *)get_pword(4, (spif_charptr_t)buff);

        if (!CHECK_VALID_INDEX(idx)) {
            print_error("Parse error in file %s, line %lu:  Encountered \"mode\" with no image type defined\n", file_peek_path(),

            }
        }
    } else if (!BEG_STRCASECMP(buff, "state ")) {
        char *state = (char *)get_pword(2, (spif_charptr_t)buff), new = 0;

        if (!state) {
            print_error("Parse error in file %s, line %lu:  Missing state\n", file_peek_path(), file_peek_line());

            MEMSET(images[idx].current->iml, 0, sizeof(imlib_t));
        }
    } else if (!BEG_STRCASECMP(buff, "color ")) {
        char *fg = (char *)get_word(2, (spif_charptr_t)buff),
	     *bg = (char *)get_word(3, (spif_charptr_t)buff);

        if (!CHECK_VALID_INDEX(idx)) {
            print_error("Parse error in file %s, line %lu:  Encountered \"color\" with no image type defined\n", file_peek_path(),


    } else if (!BEG_STRCASECMP(buff, "file ")) {
#ifdef PIXMAP_SUPPORT
        char *filename = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!CHECK_VALID_INDEX(idx)) {
            print_error("Parse error in file %s, line %lu:  Encountered \"file\" with no image type defined\n", file_peek_path(),


    } else if (!BEG_STRCASECMP(buff, "geom ")) {
#ifdef PIXMAP_SUPPORT
        char *geom = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!CHECK_VALID_INDEX(idx)) {
            print_error("Parse error in file %s, line %lu:  Encountered \"geom\" with no image type defined\n", file_peek_path(),


    } else if (!BEG_STRCASECMP(buff, "cmod ") || !BEG_STRCASECMP(buff, "colormod ")) {
#ifdef PIXMAP_SUPPORT
        char *color = (char *)get_pword(2, (spif_charptr_t)buff);
        char *mods = (char *)get_pword(3, (spif_charptr_t)buff);
        unsigned char n;
        imlib_t *iml = images[idx].current->iml;


            print_error("Parse error in file %s, line %lu:  Missing modifier(s)\n", file_peek_path(), file_peek_line());
            return NULL;
        }
        n = num_words((spif_charptr_t)mods);

        if (!BEG_STRCASECMP(color, "image ")) {
            if (iml->mod) {

            iml->mod = create_colormod();
            iml->mod->brightness = (int) strtol(mods, (char **) NULL, 0);
            if (n > 1) {
                iml->mod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            if (n > 2) {
                iml->mod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            update_cmod(iml->mod);
        } else if (!BEG_STRCASECMP(color, "red ")) {

            iml->rmod = create_colormod();
            iml->rmod->brightness = (int) strtol(mods, (char **) NULL, 0);
            if (n > 1) {
                iml->rmod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            if (n > 2) {
                iml->rmod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            update_cmod(iml->rmod);
        } else if (!BEG_STRCASECMP(color, "green ")) {

            iml->gmod = create_colormod();
            iml->gmod->brightness = (int) strtol(mods, (char **) NULL, 0);
            if (n > 1) {
                iml->gmod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            if (n > 2) {
                iml->gmod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            update_cmod(iml->gmod);
        } else if (!BEG_STRCASECMP(color, "blue ")) {

            iml->bmod = create_colormod();
            iml->bmod->brightness = (int) strtol(mods, (char **) NULL, 0);
            if (n > 1) {
                iml->bmod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            if (n > 2) {
                iml->bmod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)mods), (char **) NULL, 0);
            }
            update_cmod(iml->bmod);
        } else {

                        file_peek_line());
            return NULL;
        }
        if (num_words((spif_charptr_t)buff + 7) < 4) {
            print_error("Parse error in file %s, line %lu:  Invalid parameter list for attribute \"border\"\n", file_peek_path(),
                        file_peek_line());
            return NULL;
        }
        RESET_AND_ASSIGN(images[idx].current->iml->border, (Imlib_Border *) MALLOC(sizeof(Imlib_Border)));

        images[idx].current->iml->border->left = (unsigned short) strtoul((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->border->right = (unsigned short) strtoul((char *)get_pword(3, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->border->top = (unsigned short) strtoul((char *)get_pword(4, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->border->bottom = (unsigned short) strtoul((char *)get_pword(5, (spif_charptr_t)buff), (char **) NULL, 0);

        if ((images[idx].current->iml->border->left == 0) && (images[idx].current->iml->border->right == 0)
            && (images[idx].current->iml->border->top == 0) && (images[idx].current->iml->border->bottom == 0)) {

                        file_peek_line());
            return NULL;
        }
        if (num_words((spif_charptr_t)buff + 6) < 5) {
            print_error("Parse error in file %s, line %lu:  Invalid parameter list for attribute \"bevel\"\n", file_peek_path(),
                        file_peek_line());
            return NULL;

        images[idx].current->iml->bevel = (bevel_t *) MALLOC(sizeof(bevel_t));
        images[idx].current->iml->bevel->edges = (Imlib_Border *) MALLOC(sizeof(Imlib_Border));

        if (!BEG_STRCASECMP((char *)get_pword(2, (spif_charptr_t)buff), "down")) {
            images[idx].current->iml->bevel->up = 0;
        } else {
            images[idx].current->iml->bevel->up = 1;
        }
        images[idx].current->iml->bevel->edges->left = (unsigned short) strtoul((char *)get_pword(3, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->bevel->edges->right = (unsigned short) strtoul((char *)get_pword(4, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->bevel->edges->top = (unsigned short) strtoul((char *)get_pword(5, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->bevel->edges->bottom = (unsigned short) strtoul((char *)get_pword(6, (spif_charptr_t)buff), (char **) NULL, 0);

        if ((images[idx].current->iml->bevel->edges->left == 0) && (images[idx].current->iml->bevel->edges->right == 0)
            && (images[idx].current->iml->bevel->edges->top == 0) && (images[idx].current->iml->bevel->edges->bottom == 0)) {

                        file_peek_line());
            return NULL;
        }
        if (num_words((spif_charptr_t)buff + 8) < 4) {
            print_error("Parse error in file %s, line %lu:  Invalid parameter list for attribute \"padding\"\n", file_peek_path(),
                        file_peek_line());
            return NULL;
        }
        RESET_AND_ASSIGN(images[idx].current->iml->pad, (Imlib_Border *) MALLOC(sizeof(Imlib_Border)));

        images[idx].current->iml->pad->left = (unsigned short) strtoul((char *)get_pword(2, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->pad->right = (unsigned short) strtoul((char *)get_pword(3, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->pad->top = (unsigned short) strtoul((char *)get_pword(4, (spif_charptr_t)buff), (char **) NULL, 0);
        images[idx].current->iml->pad->bottom = (unsigned short) strtoul((char *)get_pword(5, (spif_charptr_t)buff), (char **) NULL, 0);

        if ((images[idx].current->iml->pad->left == 0) && (images[idx].current->iml->pad->right == 0)
            && (images[idx].current->iml->pad->top == 0) && (images[idx].current->iml->pad->bottom == 0)) {

    }

    if (!BEG_STRCASECMP(buff, "bind ")) {
        for (i = 2; (str = (char *)get_word(i, (spif_charptr_t)buff)) && strcasecmp(str, "to"); i++) {
            if (!BEG_STRCASECMP(str, "anymod")) {
                mod = MOD_ANY;
            } else if (!BEG_STRCASECMP(str, "ctrl")) {

            return NULL;
        }
        i++;
        str = (char *)get_pword(i, (spif_charptr_t)buff);
        if (!BEG_STRCASECMP(str, "string")) {
            str = (char *)get_word(i + 1, (spif_charptr_t)buff);
            action_add(mod, button, keysym, ACTION_STRING, (void *) str);
            FREE(str);
        } else if (!BEG_STRCASECMP(str, "echo")) {
            str = (char *)get_word(i + 1, (spif_charptr_t)buff);
            action_add(mod, button, keysym, ACTION_ECHO, (void *) str);
            FREE(str);
        } else if (!BEG_STRCASECMP(str, "menu")) {
            menu_t *menu;

            str = (char *)get_word(i + 1, (spif_charptr_t)buff);
            menu = find_menu_by_title(menu_list, str);
            action_add(mod, button, keysym, ACTION_MENU, (void *) menu);
            FREE(str);
        } else if (!BEG_STRCASECMP(str, "script")) {
            str = (char *)get_word(i + 1, (spif_charptr_t)buff);
            action_add(mod, button, keysym, ACTION_SCRIPT, (void *) str);
            FREE(str);
        } else {

    menu_t *menu;

    if (*buff == CONF_BEGIN_CHAR) {
        char *title = (char *)get_pword(2, (spif_charptr_t)buff + 6);

        menu = menu_create(title);
        return ((void *) menu);

        return NULL;
    }
    if (!BEG_STRCASECMP(buff, "title ")) {
        char *title = (char *)get_word(2, (spif_charptr_t)buff);

        menu_set_title(menu, title);
        FREE(title);

    } else if (!BEG_STRCASECMP(buff, "font ")) {
        char *name = (char *)get_word(2, (spif_charptr_t)buff);

        if (!name) {
            print_error("Parse error in file %s, line %lu:  Missing font name.\n", file_peek_path(), file_peek_line());

        return ((void *) menu);
    }
    if (!BEG_STRCASECMP(buff, "text ")) {
        char *text = (char *)get_word(2, (spif_charptr_t)buff);

        if (!text) {
            print_error("Parse error in file %s, line %lu:  Missing menuitem text.\n", file_peek_path(), file_peek_line());

        FREE(text);

    } else if (!BEG_STRCASECMP(buff, "rtext ")) {
        char *rtext = (char *)get_word(2, (spif_charptr_t)buff);

        if (!rtext) {
            print_error("Parse error in file %s, line %lu:  Missing menuitem right-justified text.\n", file_peek_path(), file_peek_line());

    } else if (!BEG_STRCASECMP(buff, "icon ")) {

    } else if (!BEG_STRCASECMP(buff, "action ")) {
        char *type = (char *)get_pword(2, (spif_charptr_t)buff);
        char *action = (char *)get_word(3, (spif_charptr_t)buff);

        if (!BEG_STRCASECMP(type, "submenu ")) {
            menuitem_set_action(curitem, MENUITEM_SUBMENU, action);

        return NULL;
    }
    if (!BEG_STRCASECMP(buff, "font ")) {
        char *font = (char *)get_word(2, (spif_charptr_t)buff);

        bbar_set_font(bbar, font);
        FREE(font);

    } else if (!BEG_STRCASECMP(buff, "dock ")) {
        char *where = (char *)get_pword(2, (spif_charptr_t)buff);

        if (!where) {
            print_error("Parse error in file %s, line %lu:  Attribute dock requires a parameter\n", file_peek_path(), file_peek_line());

        }

    } else if (!BEG_STRCASECMP(buff, "visible ")) {
        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);

        if (BOOL_OPT_ISTRUE(tmp)) {
            bbar_set_visible(bbar, 1);

        }

    } else if (!BEG_STRCASECMP(buff, "button ") || !BEG_STRCASECMP(buff, "rbutton ")) {
        char *text = (char *)get_pword(2, (spif_charptr_t)buff);
        char *icon = strcasestr(buff, "icon ");
        char *action = strcasestr(buff, "action ");
        button_t *button;

        if (text == icon) {
            text = NULL;
        } else {
            text = (char *)get_word(2, (spif_charptr_t)buff);
        }
        if (!text && !icon) {
            print_error("Parse error in file %s, line %lu:  Missing button specifications\n", file_peek_path(), file_peek_line());

        if (icon) {
            simage_t *simg;

            icon = (char *)get_word(2, (spif_charptr_t)icon);
            simg = create_simage();
            if (load_image(icon, simg)) {
                button_set_icon(button, simg);

            FREE(icon);
        }
        if (action) {
            char *type = (char *)get_pword(2, (spif_charptr_t)action);

            action = (char *)get_word(2, (spif_charptr_t)type);
            if (!BEG_STRCASECMP(type, "menu ")) {
                button_set_action(button, ACTION_MENU, action);
            } else if (!BEG_STRCASECMP(type, "string ")) {

        return NULL;
    }
    if (!BEG_STRCASECMP(buff, "input_method ")) {
        RESET_AND_ASSIGN(rs_input_method, (char *)get_word(2, (spif_charptr_t)buff));
    } else if (!BEG_STRCASECMP(buff, "preedit_type ")) {
        RESET_AND_ASSIGN(rs_preedit_type, (char *)get_word(2, (spif_charptr_t)buff));
    } else {
        print_error("Parse error in file %s, line %lu:  Attribute \"%s\" is not valid within context xim\n",
                    file_peek_path(), file_peek_line(), buff);

        return NULL;
    }
    if (!BEG_STRCASECMP(buff, "encoding ")) {
        RESET_AND_ASSIGN(rs_multichar_encoding, (char *)get_word(2, (spif_charptr_t)buff));
        if (rs_multichar_encoding != NULL) {
            if (BEG_STRCASECMP(rs_multichar_encoding, "eucj")
                && BEG_STRCASECMP(rs_multichar_encoding, "sjis")

        }
    } else if (!BEG_STRCASECMP(buff, "font ")) {

        char *tmp = (char *)get_pword(2, (spif_charptr_t)buff);
        unsigned long n;

        if (num_words((spif_charptr_t)buff) != 3) {
            print_error("Parse error in file %s, line %lu:  Invalid parameter list \"%s\" for attribute font\n",
                        file_peek_path(), file_peek_line(), NONULL(tmp));
            return NULL;

        if (isdigit(*tmp)) {
            n = strtoul(tmp, (char **) NULL, 0);
            if (n <= 255) {
                eterm_font_add(&etmfonts, (char *)get_pword(2, (spif_charptr_t)tmp), n);
            } else {
                print_error("Parse error in file %s, line %lu:  Invalid font index %d\n", file_peek_path(), file_peek_line(), n);
            }
        } else {
            tmp = (char *)get_word(1, (spif_charptr_t)tmp);
            print_error("Parse error in file %s, line %lu:  Invalid font index \"%s\"\n", file_peek_path(), file_peek_line(), NONULL(tmp));
            FREE(tmp);
        }

        } else {
            snprintf(path, sizeof(path), CONFIG_SEARCH_PATH);
        }
        shell_expand((spif_charptr_t)path);
    }
    if (fallback & PARSE_TRY_USER_THEME) {
        if (theme && *theme && (ret = (char *)conf_parse((spif_charptr_t)conf_name, (spif_charptr_t)*theme, (spif_charptr_t)path)) != NULL) {
            return ret;
        }
    }
    if (fallback & PARSE_TRY_DEFAULT_THEME) {
        RESET_AND_ASSIGN(*theme, STRDUP(PACKAGE));
        if ((ret = (char *)conf_parse((spif_charptr_t)conf_name, (spif_charptr_t)*theme, (spif_charptr_t)path)) != NULL) {
            return ret;
        }
    }
    if (fallback & PARSE_TRY_NO_THEME) {
        RESET_AND_ASSIGN(*theme, NULL);
        return ((char *)conf_parse((spif_charptr_t)conf_name, (spif_charptr_t)*theme, (spif_charptr_t)path));
    }
    return NULL;
}

    conf_init_subsystem();

    /* Register Eterm's context parsers. */
    conf_register_context((spif_charptr_t)"color", (ctx_handler_t)parse_color);
    conf_register_context((spif_charptr_t)"attributes", (ctx_handler_t)parse_attributes);
    conf_register_context((spif_charptr_t)"toggles", (ctx_handler_t)parse_toggles);
    conf_register_context((spif_charptr_t)"keyboard", (ctx_handler_t)parse_keyboard);
    conf_register_context((spif_charptr_t)"misc", (ctx_handler_t)parse_misc);
    conf_register_context((spif_charptr_t)"imageclasses", (ctx_handler_t)parse_imageclasses);
    conf_register_context((spif_charptr_t)"image", (ctx_handler_t)parse_image);
    conf_register_context((spif_charptr_t)"actions", (ctx_handler_t)parse_actions);
    conf_register_context((spif_charptr_t)"menu", (ctx_handler_t)parse_menu);
    conf_register_context((spif_charptr_t)"menuitem", (ctx_handler_t)parse_menuitem);
    conf_register_context((spif_charptr_t)"button_bar", (ctx_handler_t)parse_bbar);
    conf_register_context((spif_charptr_t)"xim", (ctx_handler_t)parse_xim);
    conf_register_context((spif_charptr_t)"multichar", (ctx_handler_t)parse_multichar);
    conf_register_context((spif_charptr_t)"escreen", (ctx_handler_t)parse_escreen);
}

/* Sync up options with our internal data after parsing options and configs */

        FREE(rs_tint);
    }
    if (rs_cmod_image) {
        unsigned char n = num_words((spif_charptr_t)rs_cmod_image);
        imlib_t *iml = images[image_bg].norm->iml;

        if (iml->mod) {

        iml->mod = create_colormod();
        iml->mod->brightness = (int) strtol(rs_cmod_image, (char **) NULL, 0);
        if (n > 1) {
            iml->mod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)rs_cmod_image), (char **) NULL, 0);
        }
        if (n > 2) {
            iml->mod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)rs_cmod_image), (char **) NULL, 0);
        }
        D_PIXMAP(("From image cmod string %s to brightness %d, contrast %d, and gamma %d\n", rs_cmod_image,
                  iml->mod->brightness, iml->mod->contrast, iml->mod->gamma));
        FREE(rs_cmod_image);
    }
    if (rs_cmod_red) {
        unsigned char n = num_words((spif_charptr_t)rs_cmod_red);
        imlib_t *iml = images[image_bg].norm->iml;

        if (iml->rmod) {

        iml->rmod = create_colormod();
        iml->rmod->brightness = (int) strtol(rs_cmod_red, (char **) NULL, 0);
        if (n > 1) {
            iml->rmod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)rs_cmod_red), (char **) NULL, 0);
        }
        if (n > 2) {
            iml->rmod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)rs_cmod_red), (char **) NULL, 0);
        }
        D_PIXMAP(("From red cmod string %s to brightness %d, contrast %d, and gamma %d\n", rs_cmod_red,
                  iml->rmod->brightness, iml->rmod->contrast, iml->rmod->gamma));

        update_cmod(iml->rmod);
    }
    if (rs_cmod_green) {
        unsigned char n = num_words((spif_charptr_t)rs_cmod_green);
        imlib_t *iml = images[image_bg].norm->iml;

        if (iml->gmod) {

        iml->gmod = create_colormod();
        iml->gmod->brightness = (int) strtol(rs_cmod_green, (char **) NULL, 0);
        if (n > 1) {
            iml->gmod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)rs_cmod_green), (char **) NULL, 0);
        }
        if (n > 2) {
            iml->gmod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)rs_cmod_green), (char **) NULL, 0);
        }
        D_PIXMAP(("From green cmod string %s to brightness %d, contrast %d, and gamma %d\n", rs_cmod_green,
                  iml->gmod->brightness, iml->gmod->contrast, iml->gmod->gamma));

        update_cmod(iml->gmod);
    }
    if (rs_cmod_blue) {
        unsigned char n = num_words((spif_charptr_t)rs_cmod_blue);
        imlib_t *iml = images[image_bg].norm->iml;

        if (iml->bmod) {

        iml->bmod = create_colormod();
        iml->bmod->brightness = (int) strtol(rs_cmod_blue, (char **) NULL, 0);
        if (n > 1) {
            iml->bmod->contrast = (int) strtol((char *)get_pword(2, (spif_charptr_t)rs_cmod_blue), (char **) NULL, 0);
        }
        if (n > 2) {
            iml->bmod->gamma = (int) strtol((char *)get_pword(3, (spif_charptr_t)rs_cmod_blue), (char **) NULL, 0);
        }
        D_PIXMAP(("From blue cmod string %s to brightness %d, contrast %d, and gamma %d\n", rs_cmod_blue,
                  iml->bmod->brightness, iml->bmod->contrast, iml->bmod->gamma));

            unsigned long w, h;
            int count;

            count = num_words((spif_charptr_t)rs_anim_pixmap_list) - 1;	/* -1 for the delay */
            rs_anim_pixmaps = (char **) MALLOC(sizeof(char *) * (count + 1));

            for (i = 0; i < count; i++) {
                temp = (char *)get_word(i + 2, (spif_charptr_t)rs_anim_pixmap_list);	/* +2 rather than +1 to account for the delay */
                if (temp == NULL)
                    break;
                if (num_words((spif_charptr_t)temp) != 3) {
                    if (num_words((spif_charptr_t)temp) == 1) {
                        rs_anim_pixmaps[i] = temp;
                    }
                } else {
                    w1 = (char *)get_pword(1, (spif_charptr_t)temp);
                    h1 = (char *)get_pword(2, (spif_charptr_t)temp);
                    w = strtol(w1, (char **) NULL, 0);
                    h = strtol(h1, (char **) NULL, 0);
                    if (w || h) {
                        rs_anim_pixmaps[i] = (char *)get_word(3, (spif_charptr_t)temp);
                        rs_anim_pixmaps[i] = (char *) REALLOC(rs_anim_pixmaps[i], strlen(rs_anim_pixmaps[i]) + 9);
                        strcat(rs_anim_pixmaps[i], "@100x100");
                    } else {
                        rs_anim_pixmaps[i] = (char *)get_word(3, (spif_charptr_t)temp);
                        rs_anim_pixmaps[i] = (char *) REALLOC(rs_anim_pixmaps[i], strlen(rs_anim_pixmaps[i]) + 5);
                        strcat(rs_anim_pixmaps[i], "@0x0");
                    }

Lines 824-830 Link Here

(-)Eterm-0.9.3.orig/src/pixmap.c (-2 / +2 lines)
824	FREE(reply);	824	FREE(reply);
825	} else {	825	} else {
826	pmap = (Pixmap) strtoul(reply, (char **) NULL, 0);	826	pmap = (Pixmap) strtoul(reply, (char **) NULL, 0);
827	mask = (Pixmap) strtoul(get_pword(2, reply), (char **) NULL, 0);	827	mask = (Pixmap) strtoul((char )get_pword(2, (spif_charptr_t)reply), (char *) NULL, 0);
828	FREE(reply);	828	FREE(reply);
829	enl_ipc_sync();	829	enl_ipc_sync();
830	if (pmap) {	830	if (pmap) {
Lines 1053-1059 Link Here
1053	Pixmap pmap, mask;	1053	Pixmap pmap, mask;
1054		1054
1055	pmap = (Pixmap) strtoul(reply, (char **) NULL, 0);	1055	pmap = (Pixmap) strtoul(reply, (char **) NULL, 0);
1056	mask = (Pixmap) strtoul(get_pword(2, reply), (char **) NULL, 0);	1056	mask = (Pixmap) strtoul((char )get_pword(2, (spif_charptr_t)reply), (char *) NULL, 0);
1057	FREE(reply);	1057	FREE(reply);
1058	enl_ipc_sync();	1058	enl_ipc_sync();
1059	if (pmap) {	1059	if (pmap) {




                    }
                    col--;
                    if (buffer[0] & 0x80)
                        multichar_decode((unsigned char *)buffer, len);
                    wlen = len / 2;
                } else {
                    if ((rend & RS_multiMask) == RS_multi1) {

    for (row = 0; row < rows; row++) {
        if (screen.text[row]) {
            c = screen.text[row];
            for (s = strstr((char *)c, str); s; s = strstr(s + 1, str)) {
                unsigned long j;

                col = (long) s - (long) c;

                    lrow = row;
                }
            }
            for (s = (char *)screen.text[row] + cols - len + 1, k = len - 1; k; s++, k--) {
                unsigned long j;

                if ((row < rows - 1) && !strncasecmp(s, str, k) && screen.text[row + 1]
                    && !strncasecmp((char *)screen.text[row + 1], str + k, len - k)) {
                    col = (long) s - (long) c;
                    for (i = &(screen.rend[row][cols - k]), j = 0; j < k; i++, j++) {
                        (*i & RS_RVid) ? (*i &= ~RS_RVid) : (*i |= RS_RVid);

    buff = MALLOC(cols + 1);
    for (row = 0; row < rows; row++) {
        if (screen.text[row]) {
            for (src = (char *)screen.text[row], dest = buff, col = 0; col < cols; col++)
                *dest++ = *src++;
            *dest++ = '\n';
            *dest = 0;

selection_write(unsigned char *data, size_t len)
{
    size_t num;
    unsigned char *p, *cr = (unsigned char *)"\r";

    D_SELECT(("Writing %lu characters of selection data to tty.\n", len));
    D_SELECT(("\n%s\n\n", safe_print_string((char *) data, len)));

                D_SELECT(("Got string list 0x%08x with %d strings.\n", cl, size));
                for (i = 0; i < size; i++) {
                    if (cl[i]) {
                        selection_write((unsigned char *)cl[i], strlen(cl[i]));
                    }
                }
                XFreeStringList(cl);

        }
    } else {
        D_SELECT(("Copying selection to cut buffer %d\n", (int) sel));
        XChangeProperty(Xdisplay, Xroot, sel, XA_STRING, 8, PropModeReplace, (unsigned char *)str, len);
    }
}


void
selection_copy(Atom sel)
{
    selection_copy_string(sel, (char *)selection.text, selection.len);
}

/* Paste the specified selection from the specified buffer. */

        XTextProperty xtextp;
        char *l[1];

        *l = (char *)selection.text;
        xtextp.value = NULL;
        xtextp.nitems = 0;
        if (XmbTextListToTextProperty(Xdisplay, l, 1, XCompoundTextStyle, &xtextp) == Success) {




    char **tmp;

    for (tmp = params; tmp && *tmp; tmp++) {
        tt_write((unsigned char *)*tmp, strlen(*tmp));
    }
}


        if (isdigit(params[0][0]) || (params[0][0] == '-' && isdigit(params[0][1]))) {
            code = (unsigned char) atoi(params[0]);
        } else {
            tmp = (char *)join((spif_charptr_t)" ", (spif_charptr_t *)params);
            printf("Exiting:  %s\n", tmp);
            FREE(tmp);
        }

    char *tmp;

    if (params && *params) {
        tmp = (char *)join((spif_charptr_t)" ", (spif_charptr_t *)params);
        system_no_wait(tmp);
        FREE(tmp);
    } else {

    char **tmp;

    for (tmp = params; tmp && *tmp; tmp++) {
        cmd_write((unsigned char *)*tmp, strlen(*tmp));
    }
}


    int ret;

    if (params && *params) {
        tmp = (char *)join((spif_charptr_t)" ", (spif_charptr_t *)params);
    } else {
        tmp = NULL;
    }

    char *tmp;

    if (params && *params) {
        tmp = (char *)join((spif_charptr_t)" ", (spif_charptr_t *)params);
        scr_refresh(DEFAULT_REFRESH);
        menu_dialog(NULL, tmp, 1, NULL, NULL);
        FREE(tmp);


    D_SCRIPT(("Parsing:  \"%s\"\n", s));

    token_list = (char **)split((spif_charptr_t)";", (spif_charptr_t)s);
    if (token_list == NULL) {
        D_SCRIPT(("No tokens found; ignoring script.\n"));
        return;


    for (i = 0; token_list[i]; i++) {
        pstr = token_list[i];
        chomp((spif_charptr_t)pstr);
        if (!(*pstr)) {
            continue;
        }

                free_array((void **) token_list, 0);
                return;
            }
            param_list = (char **)split((spif_charptr_t)", \t", (spif_charptr_t)params);
        } else {
            param_list = NULL;
        }




        /* Lookup the string equivalent in terms of the XIM input context. */
        len = XmbLookupString(xim_input_context, &ev->xkey, (char *) kbuf, sizeof(short_buf), &keysym, &status_return);
        D_TTY(("XmbLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\" based on the XIM input context %010p\n",
               len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len), xim_input_context));
        /* Whoops, it's too long.  Allocate a new buffer and repeat the call. */
        if (status_return == XBufferOverflow) {
            kbuf = (unsigned char *) MALLOC(len + 1);
            kbuf_alloced = 1;
            len = XmbLookupString(xim_input_context, &ev->xkey, (char *) kbuf, len, &keysym, &status_return);
            D_TTY(("XmbLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\" based on the XIM input context %010p\n",
                   len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len), xim_input_context));
        }
        valid_keysym = (status_return == XLookupKeySym) || (status_return == XLookupBoth);
    } else {
        /* No XIM input context.  Do it the normal way. */
        len = XLookupString(&ev->xkey, (char *) kbuf, sizeof(short_buf), &keysym, NULL);
        D_TTY(("XLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\"\n", len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len)));
        valid_keysym = 1;
    }
#else /* USE_XIM */

                  case XK_ISO_Left_Tab:
                      if (shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033[Z");
                      }
                      break;


                      /* allow shift to override */
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033Ow");
                          break;
                      }
                      /* -> else FALL THROUGH */
#endif

                  case XK_Home:
                      len = strlen(strcpy((char *)kbuf, KS_HOME));
                      break;

#ifdef XK_KP_Left

                  case XK_KP_Down:     /* \033Or or standard cursor key */
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033OZ");       /* The Z is replaced by t, x, v, or r */
                          kbuf[2] = ("txvr"[keysym - XK_KP_Left]);
                          break;
                      } else {

                  case XK_Right:       /* "\033[C" */
                  case XK_Down:        /* "\033[B" */
                      len = 3;
                      strcpy((char *)kbuf, "\033[@");
                      kbuf[2] = ("DACB"[keysym - XK_Left]);
                      if (PrivateModes & PrivMode_aplCUR) {
                          kbuf[1] = 'O';

                      /* allow shift to override */
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033Oy");
                          break;
                      }
                      /* -> else FALL THROUGH */
# endif /* XK_KP_Prior */
                  case XK_Prior:
                      len = 4;
                      strcpy((char *)kbuf, "\033[5~");
                      break;
# ifdef XK_KP_Next
                  case XK_KP_Next:
                      /* allow shift to override */
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033Os");
                          break;
                      }
                      /* -> else FALL THROUGH */
# endif /* XK_KP_Next */
                  case XK_Next:
                      len = 4;
                      strcpy((char *)kbuf, "\033[6~");
                      break;
#endif /* UNSHIFTED_SCROLLKEYS */


                      /* allow shift to override */
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033Oq");
                          break;
                      }
                      /* -> else FALL THROUGH */
#endif /* XK_KP_End */
                  case XK_End:
                      len = strlen(strcpy((char *)kbuf, KS_END));
                      break;

                  case XK_Select:
                      len = 4;
                      strcpy((char *)kbuf, "\033[4~");
                      break;

#ifdef DXK_Remove

#endif
                  case XK_Execute:
                      len = 4;
                      strcpy((char *)kbuf, "\033[3~");
                      break;

#ifdef XK_KP_Insert
                  case XK_KP_Insert:
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033Op");
                          break;
                      }
#endif
                  case XK_Insert:
                      len = 4;
                      strcpy((char *)kbuf, "\033[2~");
                      break;

#ifdef XK_KP_Delete
                  case XK_KP_Delete:
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033On");
                          break;
                      }
#endif
                  case XK_Delete:
#ifdef KS_DELETE
                      len = strlen(strcpy((char *)kbuf, KS_DELETE));
#ifdef MULTI_CHARSET
                      if ((BITFIELD_IS_SET(eterm_options, ETERM_OPTIONS_MBYTE_CURSOR)) && scr_multi1()) {
                          memmove(kbuf + len, kbuf, len);


                  case XK_Menu:
                      len = 5;
                      strcpy((char *)kbuf, "\033[29~");
                      break;
                  case XK_Find:
                      len = 4;
                      strcpy((char *)kbuf, "\033[1~");
                      break;
                  case XK_Help:
                      len = 5;
                      strcpy((char *)kbuf, "\033[28~");
                      break;

                  case XK_KP_Enter:
                      /* allow shift to override */
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033OM");
                      } else {
                          len = 1;
                          kbuf[0] = '\r';

#ifdef XK_KP_Begin
                  case XK_KP_Begin:
                      len = 3;
                      strcpy((char *)kbuf, "\033Ou");
                      break;
#endif /* XK_KP_Begin */


                  case XK_KP_F3:       /* "\033OR" */
                  case XK_KP_F4:       /* "\033OS" */
                      len = 3;
                      strcpy((char *)kbuf, "\033OP");
                      kbuf[2] += (keysym - XK_KP_F1);
                      break;


                      /* allow shift to override */
                      if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
                          len = 3;
                          strcpy((char *)kbuf, "\033Oj");
                          kbuf[2] += (keysym - XK_KP_Multiply);
                      } else {
                          len = 1;


        tt_write(&ch, 1);
    }
    D_TTY(("After handling:  len %d, keysym \"%s\" (0x%04x), and buffer \"%s\"\n", len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len)));
    tt_write(kbuf, len);        /* Send the resulting string to the child process */

    LK_RET();

        for (i = 1; i < 7; i++) {
            string[i] = cmd_getc();
        }
        set_window_color(idx, (char *)string);
        return;
    } else if (ch == ';') {
        unsigned long n = 0;

Return to bug 92485

Lines 3002-3010 Link Here

(-)Eterm-0.9.3.orig/src/command.c (-3 / +3 lines)
3002	Xfd = XConnectionNumber(Xdisplay);	3002	Xfd = XConnectionNumber(Xdisplay);
3003	D_CMD(("Xfd = %d\n", Xfd));	3003	D_CMD(("Xfd = %d\n", Xfd));
3004	cmdbuf_ptr = cmdbuf_endp = cmdbuf_base;	3004	cmdbuf_ptr = cmdbuf_endp = cmdbuf_base;
3005	AT_LEAST((int) num_fds, Xfd + 1);	3005	AT_LEAST(num_fds, Xfd + 1);
3006	if (pipe_fd >= 0) {	3006	if (pipe_fd >= 0) {
3007	AT_LEAST((int) num_fds, pipe_fd + 1);	3007	AT_LEAST(num_fds, pipe_fd + 1);
3008	}	3008	}
3009	if ((cmd_fd = command_func(argv)) < 0) {	3009	if ((cmd_fd = command_func(argv)) < 0) {
3010	print_error("Unable to run sub-command.\n");	3010	print_error("Unable to run sub-command.\n");
Lines 3469-3475 Link Here
3469	register unsigned char *str;	3469	register unsigned char *str;
3470		3470
3471	D_CMD(("Command buffer contains %d characters.\n", cmdbuf_endp - cmdbuf_ptr));	3471	D_CMD(("Command buffer contains %d characters.\n", cmdbuf_endp - cmdbuf_ptr));
3472	D_VT(("\n%s\n\n", safe_print_string(cmdbuf_ptr - 1, cmdbuf_endp - cmdbuf_ptr + 1)));	3472	D_VT(("\n%s\n\n", safe_print_string((char *)cmdbuf_ptr - 1, cmdbuf_endp - cmdbuf_ptr + 1)));
3473		3473
3474	/*	3474	/*
3475	* point to the start of the string,	3475	* point to the start of the string,

Lines 701-711 Link Here

(-)Eterm-0.9.3.orig/src/events.c (-6 / +6 lines)
701	} else if (action_check_modifiers(MOD_SHIFT, ev->xbutton.state)) {	701	} else if (action_check_modifiers(MOD_SHIFT, ev->xbutton.state)) {
702	scr_page(UP, 1);	702	scr_page(UP, 1);
703	} else if (action_check_modifiers(MOD_ALT, ev->xbutton.state)) {	703	} else if (action_check_modifiers(MOD_ALT, ev->xbutton.state)) {
704	tt_write("\033[5~", 4);	704	tt_write((unsigned char *)"\033[5~", 4);
705	} else if (action_check_modifiers((MOD_ALT \| MOD_SHIFT), ev->xbutton.state)) {	705	} else if (action_check_modifiers((MOD_ALT \| MOD_SHIFT), ev->xbutton.state)) {
706	tt_write("\033[A", 3);	706	tt_write((unsigned char *)"\033[A", 3);
707	} else if (action_check_modifiers((MOD_ALT \| MOD_CTRL), ev->xbutton.state)) {	707	} else if (action_check_modifiers((MOD_ALT \| MOD_CTRL), ev->xbutton.state)) {
708	tt_write("\033[5~\033[5~\033[5~\033[5~\033[5~", 20);	708	tt_write((unsigned char *)"\033[5~\033[5~\033[5~\033[5~\033[5~", 20);
709	} else {	709	} else {
710	scr_page(UP, TermWin.nrow - CONTEXT_LINES);	710	scr_page(UP, TermWin.nrow - CONTEXT_LINES);
711	}	711	}
Lines 717-727 Link Here
717	} else if (action_check_modifiers(MOD_SHIFT, ev->xbutton.state)) {	717	} else if (action_check_modifiers(MOD_SHIFT, ev->xbutton.state)) {
718	scr_page(DN, 1);	718	scr_page(DN, 1);
719	} else if (action_check_modifiers(MOD_ALT, ev->xbutton.state)) {	719	} else if (action_check_modifiers(MOD_ALT, ev->xbutton.state)) {
720	tt_write("\033[6~", 4);	720	tt_write((unsigned char *)"\033[6~", 4);
721	} else if (action_check_modifiers((MOD_ALT \| MOD_SHIFT), ev->xbutton.state)) {	721	} else if (action_check_modifiers((MOD_ALT \| MOD_SHIFT), ev->xbutton.state)) {
722	tt_write("\033[B", 3);	722	tt_write((unsigned char *)"\033[B", 3);
723	} else if (action_check_modifiers((MOD_ALT \| MOD_CTRL), ev->xbutton.state)) {	723	} else if (action_check_modifiers((MOD_ALT \| MOD_CTRL), ev->xbutton.state)) {
724	tt_write("\033[6~\033[6~\033[6~\033[6~\033[6~", 20);	724	tt_write((unsigned char *)"\033[6~\033[6~\033[6~\033[6~\033[6~", 20);
725	} else {	725	} else {
726	scr_page(DN, TermWin.nrow - CONTEXT_LINES);	726	scr_page(DN, TermWin.nrow - CONTEXT_LINES);
727	}	727	}

Lines 736-742 Link Here

(-)Eterm-0.9.3.orig/src/font.c (-13 / +13 lines)
736		736
737	ASSERT_RVAL(line != NULL, 0);	737	ASSERT_RVAL(line != NULL, 0);
738		738
739	n = num_words(line);	739	n = num_words((spif_charptr_t)line);
740		740
741	if (!BEG_STRCASECMP(line, "none")) {	741	if (!BEG_STRCASECMP(line, "none")) {
742	MEMSET(&fshadow, 0, sizeof(fontshadow_t));	742	MEMSET(&fshadow, 0, sizeof(fontshadow_t));
Lines 744-750 Link Here
744	if (n != 2) {	744	if (n != 2) {
745	return 0;	745	return 0;
746	}	746	}
747	color = get_word(2, line);	747	color = (char *)get_word(2, (spif_charptr_t)line);
748	p = get_color_by_name(color, "black");	748	p = get_color_by_name(color, "black");
749	FREE(color);	749	FREE(color);
750	for (which = 0; which < 4; which++) {	750	for (which = 0; which < 4; which++) {
Lines 753-762 Link Here
753	} else if (!BEG_STRCASECMP(line, "shadow")) {	753	} else if (!BEG_STRCASECMP(line, "shadow")) {
754	if (n == 2) {	754	if (n == 2) {
755	which = SHADOW_BOTTOM_RIGHT;	755	which = SHADOW_BOTTOM_RIGHT;
756	color = get_word(2, line);	756	color = (char *)get_word(2, (spif_charptr_t)line);
757	} else if (n == 3) {	757	} else if (n == 3) {
758	color = get_word(3, line);	758	color = (char *)get_word(3, (spif_charptr_t)line);
759	corner = get_pword(2, line);	759	corner = (char *)get_pword(2, (spif_charptr_t)line);
760	which = get_corner(corner);	760	which = get_corner(corner);
761	if (which >= 4) {	761	if (which >= 4) {
762	return 0;	762	return 0;
Lines 770-781 Link Here
770	if (n != 3) {	770	if (n != 3) {
771	return 0;	771	return 0;
772	}	772	}
773	color = get_word(2, line);	773	color = (char *)get_word(2, (spif_charptr_t)line);
774	p = get_color_by_name(color, "black");	774	p = get_color_by_name(color, "black");
775	set_shadow_color_by_pixel(SHADOW_BOTTOM_RIGHT, p);	775	set_shadow_color_by_pixel(SHADOW_BOTTOM_RIGHT, p);
776	FREE(color);	776	FREE(color);
777		777
778	color = get_word(3, line);	778	color = (char *)get_word(3, (spif_charptr_t)line);
779	p = get_color_by_name(color, "white");	779	p = get_color_by_name(color, "white");
780	set_shadow_color_by_pixel(SHADOW_TOP_LEFT, p);	780	set_shadow_color_by_pixel(SHADOW_TOP_LEFT, p);
781	FREE(color);	781	FREE(color);
Lines 783-794 Link Here
783	if (n != 3) {	783	if (n != 3) {
784	return 0;	784	return 0;
785	}	785	}
786	color = get_word(2, line);	786	color = (char *)get_word(2, (spif_charptr_t)line);
787	p = get_color_by_name(color, "black");	787	p = get_color_by_name(color, "black");
788	set_shadow_color_by_pixel(SHADOW_TOP_LEFT, p);	788	set_shadow_color_by_pixel(SHADOW_TOP_LEFT, p);
789	FREE(color);	789	FREE(color);
790		790
791	color = get_word(3, line);	791	color = (char *)get_word(3, (spif_charptr_t)line);
792	p = get_color_by_name(color, "white");	792	p = get_color_by_name(color, "white");
793	set_shadow_color_by_pixel(SHADOW_BOTTOM_RIGHT, p);	793	set_shadow_color_by_pixel(SHADOW_BOTTOM_RIGHT, p);
794	FREE(color);	794	FREE(color);
Lines 799-809 Link Here
799	which = get_corner(line);	799	which = get_corner(line);
800	if (which >= 4) {	800	if (which >= 4) {
801	which = i;	801	which = i;
802	color = get_word(1, line);	802	color = (char *)get_word(1, (spif_charptr_t)line);
803	line = get_pword(2, line);	803	line = (char *)get_pword(2, (spif_charptr_t)line);
804	} else {	804	} else {
805	color = get_word(2, line);	805	color = (char *)get_word(2, (spif_charptr_t)line);
806	line = get_pword(3, line);	806	line = (char *)get_pword(3, (spif_charptr_t)line);
807	}	807	}
808	set_shadow_color_by_name(which, color);	808	set_shadow_color_by_name(which, color);
809	FREE(color);	809	FREE(color);

Lines 80-86 Link Here

(-)Eterm-0.9.3.orig/src/misc.c (-3 / +3 lines)
80		80
81	if (str && *str) {	81	if (str && *str) {
82		82
83	chomp(str);	83	chomp((spif_charptr_t)str);
84	n = strlen(str);	84	n = strlen(str);
85		85
86	if (!n) {	86	if (!n) {
Lines 316-322 Link Here
316	register unsigned char out, outp, *in;	316	register unsigned char out, outp, *in;
317	register unsigned long i;	317	register unsigned long i;
318		318
319	D_CMD(("buff == %8p \"%s\", cnt == %lu\n", buff, safe_print_string(buff, cnt), cnt));	319	D_CMD(("buff == %8p \"%s\", cnt == %lu\n", buff, safe_print_string((char *)buff, cnt), cnt));
320	outp = out = (unsigned char ) MALLOC(cnt 2);	320	outp = out = (unsigned char ) MALLOC(cnt 2);
321	for (i = 0, in = buff; i < cnt; i++) {	321	for (i = 0, in = buff; i < cnt; i++) {
322	if (*in == '\n') {	322	if (*in == '\n') {
Lines 327-333 Link Here
327	i = (unsigned long) (out - outp);	327	i = (unsigned long) (out - outp);
328	memcpy(buff, outp, i);	328	memcpy(buff, outp, i);
329	FREE(outp);	329	FREE(outp);
330	D_CMD(("buff == %8p \"%s\", i == %lu\n", buff, safe_print_string(buff, i), i));	330	D_CMD(("buff == %8p \"%s\", i == %lu\n", buff, safe_print_string((char *)buff, i), i));
331	return i;	331	return i;
332	}	332	}
333		333

Lines 1783-1789 Link Here

(-)Eterm-0.9.3.orig/src/screen.c (-10 / +10 lines)
1783	}	1783	}
1784	col--;	1784	col--;
1785	if (buffer[0] & 0x80)	1785	if (buffer[0] & 0x80)
1786	multichar_decode(buffer, len);	1786	multichar_decode((unsigned char *)buffer, len);
1787	wlen = len / 2;	1787	wlen = len / 2;
1788	} else {	1788	} else {
1789	if ((rend & RS_multiMask) == RS_multi1) {	1789	if ((rend & RS_multiMask) == RS_multi1) {
Lines 2188-2194 Link Here
2188	for (row = 0; row < rows; row++) {	2188	for (row = 0; row < rows; row++) {
2189	if (screen.text[row]) {	2189	if (screen.text[row]) {
2190	c = screen.text[row];	2190	c = screen.text[row];
2191	for (s = strstr(c, str); s; s = strstr(s + 1, str)) {	2191	for (s = strstr((char *)c, str); s; s = strstr(s + 1, str)) {
2192	unsigned long j;	2192	unsigned long j;
2193		2193
2194	col = (long) s - (long) c;	2194	col = (long) s - (long) c;
Lines 2203-2213 Link Here
2203	lrow = row;	2203	lrow = row;
2204	}	2204	}
2205	}	2205	}
2206	for (s = screen.text[row] + cols - len + 1, k = len - 1; k; s++, k--) {	2206	for (s = (char *)screen.text[row] + cols - len + 1, k = len - 1; k; s++, k--) {
2207	unsigned long j;	2207	unsigned long j;
2208		2208
2209	if ((row < rows - 1) && !strncasecmp(s, str, k) && screen.text[row + 1]	2209	if ((row < rows - 1) && !strncasecmp(s, str, k) && screen.text[row + 1]
2210	&& !strncasecmp(screen.text[row + 1], str + k, len - k)) {	2210	&& !strncasecmp((char *)screen.text[row + 1], str + k, len - k)) {
2211	col = (long) s - (long) c;	2211	col = (long) s - (long) c;
2212	for (i = &(screen.rend[row][cols - k]), j = 0; j < k; i++, j++) {	2212	for (i = &(screen.rend[row][cols - k]), j = 0; j < k; i++, j++) {
2213	(i & RS_RVid) ? (i &= ~RS_RVid) : (*i \|= RS_RVid);	2213	(i & RS_RVid) ? (i &= ~RS_RVid) : (*i \|= RS_RVid);
Lines 2305-2311 Link Here
2305	buff = MALLOC(cols + 1);	2305	buff = MALLOC(cols + 1);
2306	for (row = 0; row < rows; row++) {	2306	for (row = 0; row < rows; row++) {
2307	if (screen.text[row]) {	2307	if (screen.text[row]) {
2308	for (src = screen.text[row], dest = buff, col = 0; col < cols; col++)	2308	for (src = (char *)screen.text[row], dest = buff, col = 0; col < cols; col++)
2309	dest++ = src++;	2309	dest++ = src++;
2310	*dest++ = '\n';	2310	*dest++ = '\n';
2311	*dest = 0;	2311	*dest = 0;
Lines 2376-2382 Link Here
2376	selection_write(unsigned char *data, size_t len)	2376	selection_write(unsigned char *data, size_t len)
2377	{	2377	{
2378	size_t num;	2378	size_t num;
2379	unsigned char p, cr = "\r";	2379	unsigned char p, cr = (unsigned char *)"\r";
2380		2380
2381	D_SELECT(("Writing %lu characters of selection data to tty.\n", len));	2381	D_SELECT(("Writing %lu characters of selection data to tty.\n", len));
2382	D_SELECT(("\n%s\n\n", safe_print_string((char *) data, len)));	2382	D_SELECT(("\n%s\n\n", safe_print_string((char *) data, len)));
Lines 2453-2459 Link Here
2453	D_SELECT(("Got string list 0x%08x with %d strings.\n", cl, size));	2453	D_SELECT(("Got string list 0x%08x with %d strings.\n", cl, size));
2454	for (i = 0; i < size; i++) {	2454	for (i = 0; i < size; i++) {
2455	if (cl[i]) {	2455	if (cl[i]) {
2456	selection_write(cl[i], strlen(cl[i]));	2456	selection_write((unsigned char *)cl[i], strlen(cl[i]));
2457	}	2457	}
2458	}	2458	}
2459	XFreeStringList(cl);	2459	XFreeStringList(cl);
Lines 2480-2486 Link Here
2480	}	2480	}
2481	} else {	2481	} else {
2482	D_SELECT(("Copying selection to cut buffer %d\n", (int) sel));	2482	D_SELECT(("Copying selection to cut buffer %d\n", (int) sel));
2483	XChangeProperty(Xdisplay, Xroot, sel, XA_STRING, 8, PropModeReplace, str, len);	2483	XChangeProperty(Xdisplay, Xroot, sel, XA_STRING, 8, PropModeReplace, (unsigned char *)str, len);
2484	}	2484	}
2485	}	2485	}
2486		2486
Lines 2488-2494 Link Here
2488	void	2488	void
2489	selection_copy(Atom sel)	2489	selection_copy(Atom sel)
2490	{	2490	{
2491	selection_copy_string(sel, selection.text, selection.len);	2491	selection_copy_string(sel, (char *)selection.text, selection.len);
2492	}	2492	}
2493		2493
2494	/* Paste the specified selection from the specified buffer. */	2494	/* Paste the specified selection from the specified buffer. */
Lines 3265-3271 Link Here
3265	XTextProperty xtextp;	3265	XTextProperty xtextp;
3266	char *l[1];	3266	char *l[1];
3267		3267
3268	*l = selection.text;	3268	l = (char )selection.text;
3269	xtextp.value = NULL;	3269	xtextp.value = NULL;
3270	xtextp.nitems = 0;	3270	xtextp.nitems = 0;
3271	if (XmbTextListToTextProperty(Xdisplay, l, 1, XCompoundTextStyle, &xtextp) == Success) {	3271	if (XmbTextListToTextProperty(Xdisplay, l, 1, XCompoundTextStyle, &xtextp) == Success) {

Lines 191-197 Link Here

(-)Eterm-0.9.3.orig/src/script.c (-9 / +9 lines)
191	char **tmp;	191	char **tmp;
192		192
193	for (tmp = params; tmp && *tmp; tmp++) {	193	for (tmp = params; tmp && *tmp; tmp++) {
194	tt_write(tmp, strlen(tmp));	194	tt_write((unsigned char )tmp, strlen(*tmp));
195	}	195	}
196	}	196	}
197		197
Lines 214-220 Link Here
214	if (isdigit(params[0][0]) \|\| (params[0][0] == '-' && isdigit(params[0][1]))) {	214	if (isdigit(params[0][0]) \|\| (params[0][0] == '-' && isdigit(params[0][1]))) {
215	code = (unsigned char) atoi(params[0]);	215	code = (unsigned char) atoi(params[0]);
216	} else {	216	} else {
217	tmp = join(" ", params);	217	tmp = (char )join((spif_charptr_t)" ", (spif_charptr_t )params);
218	printf("Exiting: %s\n", tmp);	218	printf("Exiting: %s\n", tmp);
219	FREE(tmp);	219	FREE(tmp);
220	}	220	}
Lines 411-417 Link Here
411	char *tmp;	411	char *tmp;
412		412
413	if (params && *params) {	413	if (params && *params) {
414	tmp = join(" ", params);	414	tmp = (char )join((spif_charptr_t)" ", (spif_charptr_t )params);
415	system_no_wait(tmp);	415	system_no_wait(tmp);
416	FREE(tmp);	416	FREE(tmp);
417	} else {	417	} else {
Lines 431-437 Link Here
431	char **tmp;	431	char **tmp;
432		432
433	for (tmp = params; tmp && *tmp; tmp++) {	433	for (tmp = params; tmp && *tmp; tmp++) {
434	cmd_write(tmp, strlen(tmp));	434	cmd_write((unsigned char )tmp, strlen(*tmp));
435	}	435	}
436	}	436	}
437		437
Lines 448-454 Link Here
448	int ret;	448	int ret;
449		449
450	if (params && *params) {	450	if (params && *params) {
451	tmp = join(" ", params);	451	tmp = (char )join((spif_charptr_t)" ", (spif_charptr_t )params);
452	} else {	452	} else {
453	tmp = NULL;	453	tmp = NULL;
454	}	454	}
Lines 474-480 Link Here
474	char *tmp;	474	char *tmp;
475		475
476	if (params && *params) {	476	if (params && *params) {
477	tmp = join(" ", params);	477	tmp = (char )join((spif_charptr_t)" ", (spif_charptr_t )params);
478	scr_refresh(DEFAULT_REFRESH);	478	scr_refresh(DEFAULT_REFRESH);
479	menu_dialog(NULL, tmp, 1, NULL, NULL);	479	menu_dialog(NULL, tmp, 1, NULL, NULL);
480	FREE(tmp);	480	FREE(tmp);
Lines 739-745 Link Here
739		739
740	D_SCRIPT(("Parsing: \"%s\"\n", s));	740	D_SCRIPT(("Parsing: \"%s\"\n", s));
741		741
742	token_list = split(";", s);	742	token_list = (char **)split((spif_charptr_t)";", (spif_charptr_t)s);
743	if (token_list == NULL) {	743	if (token_list == NULL) {
744	D_SCRIPT(("No tokens found; ignoring script.\n"));	744	D_SCRIPT(("No tokens found; ignoring script.\n"));
745	return;	745	return;
Lines 747-753 Link Here
747		747
748	for (i = 0; token_list[i]; i++) {	748	for (i = 0; token_list[i]; i++) {
749	pstr = token_list[i];	749	pstr = token_list[i];
750	chomp(pstr);	750	chomp((spif_charptr_t)pstr);
751	if (!(*pstr)) {	751	if (!(*pstr)) {
752	continue;	752	continue;
753	}	753	}
Lines 778-784 Link Here
778	free_array((void **) token_list, 0);	778	free_array((void **) token_list, 0);
779	return;	779	return;
780	}	780	}
781	param_list = split(", \t", params);	781	param_list = (char **)split((spif_charptr_t)", \t", (spif_charptr_t)params);
782	} else {	782	} else {
783	param_list = NULL;	783	param_list = NULL;
784	}	784	}

Lines 233-252 Link Here

(-)Eterm-0.9.3.orig/src/term.c (-29 / +29 lines)
233	/* Lookup the string equivalent in terms of the XIM input context. */	233	/* Lookup the string equivalent in terms of the XIM input context. */
234	len = XmbLookupString(xim_input_context, &ev->xkey, (char *) kbuf, sizeof(short_buf), &keysym, &status_return);	234	len = XmbLookupString(xim_input_context, &ev->xkey, (char *) kbuf, sizeof(short_buf), &keysym, &status_return);
235	D_TTY(("XmbLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\" based on the XIM input context %010p\n",	235	D_TTY(("XmbLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\" based on the XIM input context %010p\n",
236	len, XKeysymToString(keysym), keysym, safe_print_string(kbuf, len), xim_input_context));	236	len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len), xim_input_context));
237	/* Whoops, it's too long. Allocate a new buffer and repeat the call. */	237	/* Whoops, it's too long. Allocate a new buffer and repeat the call. */
238	if (status_return == XBufferOverflow) {	238	if (status_return == XBufferOverflow) {
239	kbuf = (unsigned char *) MALLOC(len + 1);	239	kbuf = (unsigned char *) MALLOC(len + 1);
240	kbuf_alloced = 1;	240	kbuf_alloced = 1;
241	len = XmbLookupString(xim_input_context, &ev->xkey, (char *) kbuf, len, &keysym, &status_return);	241	len = XmbLookupString(xim_input_context, &ev->xkey, (char *) kbuf, len, &keysym, &status_return);
242	D_TTY(("XmbLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\" based on the XIM input context %010p\n",	242	D_TTY(("XmbLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\" based on the XIM input context %010p\n",
243	len, XKeysymToString(keysym), keysym, safe_print_string(kbuf, len), xim_input_context));	243	len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len), xim_input_context));
244	}	244	}
245	valid_keysym = (status_return == XLookupKeySym) \|\| (status_return == XLookupBoth);	245	valid_keysym = (status_return == XLookupKeySym) \|\| (status_return == XLookupBoth);
246	} else {	246	} else {
247	/* No XIM input context. Do it the normal way. */	247	/* No XIM input context. Do it the normal way. */
248	len = XLookupString(&ev->xkey, (char *) kbuf, sizeof(short_buf), &keysym, NULL);	248	len = XLookupString(&ev->xkey, (char *) kbuf, sizeof(short_buf), &keysym, NULL);
249	D_TTY(("XLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\"\n", len, XKeysymToString(keysym), keysym, safe_print_string(kbuf, len)));	249	D_TTY(("XLookupString() gave us len %d, keysym \"%s\" (0x%04x), and buffer \"%s\"\n", len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len)));
250	valid_keysym = 1;	250	valid_keysym = 1;
251	}	251	}
252	#else /* USE_XIM */	252	#else /* USE_XIM */
Lines 478-484 Link Here
478	case XK_ISO_Left_Tab:	478	case XK_ISO_Left_Tab:
479	if (shft) {	479	if (shft) {
480	len = 3;	480	len = 3;
481	strcpy(kbuf, "\033[Z");	481	strcpy((char *)kbuf, "\033[Z");
482	}	482	}
483	break;	483	break;
484		484
Lines 487-500 Link Here
487	/* allow shift to override */	487	/* allow shift to override */
488	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	488	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
489	len = 3;	489	len = 3;
490	strcpy(kbuf, "\033Ow");	490	strcpy((char *)kbuf, "\033Ow");
491	break;	491	break;
492	}	492	}
493	/* -> else FALL THROUGH */	493	/* -> else FALL THROUGH */
494	#endif	494	#endif
495		495
496	case XK_Home:	496	case XK_Home:
497	len = strlen(strcpy(kbuf, KS_HOME));	497	len = strlen(strcpy((char *)kbuf, KS_HOME));
498	break;	498	break;
499		499
500	#ifdef XK_KP_Left	500	#ifdef XK_KP_Left
Lines 504-510 Link Here
504	case XK_KP_Down: /* \033Or or standard cursor key */	504	case XK_KP_Down: /* \033Or or standard cursor key */
505	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	505	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
506	len = 3;	506	len = 3;
507	strcpy(kbuf, "\033OZ"); /* The Z is replaced by t, x, v, or r */	507	strcpy((char )kbuf, "\033OZ"); / The Z is replaced by t, x, v, or r */
508	kbuf[2] = ("txvr"[keysym - XK_KP_Left]);	508	kbuf[2] = ("txvr"[keysym - XK_KP_Left]);
509	break;	509	break;
510	} else {	510	} else {
Lines 517-523 Link Here
517	case XK_Right: /* "\033[C" */	517	case XK_Right: /* "\033[C" */
518	case XK_Down: /* "\033[B" */	518	case XK_Down: /* "\033[B" */
519	len = 3;	519	len = 3;
520	strcpy(kbuf, "\033[@");	520	strcpy((char *)kbuf, "\033[@");
521	kbuf[2] = ("DACB"[keysym - XK_Left]);	521	kbuf[2] = ("DACB"[keysym - XK_Left]);
522	if (PrivateModes & PrivMode_aplCUR) {	522	if (PrivateModes & PrivMode_aplCUR) {
523	kbuf[1] = 'O';	523	kbuf[1] = 'O';
Lines 544-571 Link Here
544	/* allow shift to override */	544	/* allow shift to override */
545	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	545	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
546	len = 3;	546	len = 3;
547	strcpy(kbuf, "\033Oy");	547	strcpy((char *)kbuf, "\033Oy");
548	break;	548	break;
549	}	549	}
550	/* -> else FALL THROUGH */	550	/* -> else FALL THROUGH */
551	# endif /* XK_KP_Prior */	551	# endif /* XK_KP_Prior */
552	case XK_Prior:	552	case XK_Prior:
553	len = 4;	553	len = 4;
554	strcpy(kbuf, "\033[5~");	554	strcpy((char *)kbuf, "\033[5~");
555	break;	555	break;
556	# ifdef XK_KP_Next	556	# ifdef XK_KP_Next
557	case XK_KP_Next:	557	case XK_KP_Next:
558	/* allow shift to override */	558	/* allow shift to override */
559	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	559	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
560	len = 3;	560	len = 3;
561	strcpy(kbuf, "\033Os");	561	strcpy((char *)kbuf, "\033Os");
562	break;	562	break;
563	}	563	}
564	/* -> else FALL THROUGH */	564	/* -> else FALL THROUGH */
565	# endif /* XK_KP_Next */	565	# endif /* XK_KP_Next */
566	case XK_Next:	566	case XK_Next:
567	len = 4;	567	len = 4;
568	strcpy(kbuf, "\033[6~");	568	strcpy((char *)kbuf, "\033[6~");
569	break;	569	break;
570	#endif /* UNSHIFTED_SCROLLKEYS */	570	#endif /* UNSHIFTED_SCROLLKEYS */
571		571
Lines 575-592 Link Here
575	/* allow shift to override */	575	/* allow shift to override */
576	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	576	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
577	len = 3;	577	len = 3;
578	strcpy(kbuf, "\033Oq");	578	strcpy((char *)kbuf, "\033Oq");
579	break;	579	break;
580	}	580	}
581	/* -> else FALL THROUGH */	581	/* -> else FALL THROUGH */
582	#endif /* XK_KP_End */	582	#endif /* XK_KP_End */
583	case XK_End:	583	case XK_End:
584	len = strlen(strcpy(kbuf, KS_END));	584	len = strlen(strcpy((char *)kbuf, KS_END));
585	break;	585	break;
586		586
587	case XK_Select:	587	case XK_Select:
588	len = 4;	588	len = 4;
589	strcpy(kbuf, "\033[4~");	589	strcpy((char *)kbuf, "\033[4~");
590	break;	590	break;
591		591
592	#ifdef DXK_Remove	592	#ifdef DXK_Remove
Lines 594-626 Link Here
594	#endif	594	#endif
595	case XK_Execute:	595	case XK_Execute:
596	len = 4;	596	len = 4;
597	strcpy(kbuf, "\033[3~");	597	strcpy((char *)kbuf, "\033[3~");
598	break;	598	break;
599		599
600	#ifdef XK_KP_Insert	600	#ifdef XK_KP_Insert
601	case XK_KP_Insert:	601	case XK_KP_Insert:
602	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	602	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
603	len = 3;	603	len = 3;
604	strcpy(kbuf, "\033Op");	604	strcpy((char *)kbuf, "\033Op");
605	break;	605	break;
606	}	606	}
607	#endif	607	#endif
608	case XK_Insert:	608	case XK_Insert:
609	len = 4;	609	len = 4;
610	strcpy(kbuf, "\033[2~");	610	strcpy((char *)kbuf, "\033[2~");
611	break;	611	break;
612		612
613	#ifdef XK_KP_Delete	613	#ifdef XK_KP_Delete
614	case XK_KP_Delete:	614	case XK_KP_Delete:
615	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	615	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
616	len = 3;	616	len = 3;
617	strcpy(kbuf, "\033On");	617	strcpy((char *)kbuf, "\033On");
618	break;	618	break;
619	}	619	}
620	#endif	620	#endif
621	case XK_Delete:	621	case XK_Delete:
622	#ifdef KS_DELETE	622	#ifdef KS_DELETE
623	len = strlen(strcpy(kbuf, KS_DELETE));	623	len = strlen(strcpy((char *)kbuf, KS_DELETE));
624	#ifdef MULTI_CHARSET	624	#ifdef MULTI_CHARSET
625	if ((BITFIELD_IS_SET(eterm_options, ETERM_OPTIONS_MBYTE_CURSOR)) && scr_multi1()) {	625	if ((BITFIELD_IS_SET(eterm_options, ETERM_OPTIONS_MBYTE_CURSOR)) && scr_multi1()) {
626	memmove(kbuf + len, kbuf, len);	626	memmove(kbuf + len, kbuf, len);
Lines 632-653 Link Here
632		632
633	case XK_Menu:	633	case XK_Menu:
634	len = 5;	634	len = 5;
635	strcpy(kbuf, "\033[29~");	635	strcpy((char *)kbuf, "\033[29~");
636	break;	636	break;
637	case XK_Find:	637	case XK_Find:
638	len = 4;	638	len = 4;
639	strcpy(kbuf, "\033[1~");	639	strcpy((char *)kbuf, "\033[1~");
640	break;	640	break;
641	case XK_Help:	641	case XK_Help:
642	len = 5;	642	len = 5;
643	strcpy(kbuf, "\033[28~");	643	strcpy((char *)kbuf, "\033[28~");
644	break;	644	break;
645		645
646	case XK_KP_Enter:	646	case XK_KP_Enter:
647	/* allow shift to override */	647	/* allow shift to override */
648	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	648	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
649	len = 3;	649	len = 3;
650	strcpy(kbuf, "\033OM");	650	strcpy((char *)kbuf, "\033OM");
651	} else {	651	} else {
652	len = 1;	652	len = 1;
653	kbuf[0] = '\r';	653	kbuf[0] = '\r';
Lines 657-663 Link Here
657	#ifdef XK_KP_Begin	657	#ifdef XK_KP_Begin
658	case XK_KP_Begin:	658	case XK_KP_Begin:
659	len = 3;	659	len = 3;
660	strcpy(kbuf, "\033Ou");	660	strcpy((char *)kbuf, "\033Ou");
661	break;	661	break;
662	#endif /* XK_KP_Begin */	662	#endif /* XK_KP_Begin */
663		663
Lines 666-672 Link Here
666	case XK_KP_F3: /* "\033OR" */	666	case XK_KP_F3: /* "\033OR" */
667	case XK_KP_F4: /* "\033OS" */	667	case XK_KP_F4: /* "\033OS" */
668	len = 3;	668	len = 3;
669	strcpy(kbuf, "\033OP");	669	strcpy((char *)kbuf, "\033OP");
670	kbuf[2] += (keysym - XK_KP_F1);	670	kbuf[2] += (keysym - XK_KP_F1);
671	break;	671	break;
672		672
Lines 689-695 Link Here
689	/* allow shift to override */	689	/* allow shift to override */
690	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	690	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {
691	len = 3;	691	len = 3;
692	strcpy(kbuf, "\033Oj");	692	strcpy((char *)kbuf, "\033Oj");
693	kbuf[2] += (keysym - XK_KP_Multiply);	693	kbuf[2] += (keysym - XK_KP_Multiply);
694	} else {	694	} else {
695	len = 1;	695	len = 1;
Lines 814-820 Link Here
814		814
815	tt_write(&ch, 1);	815	tt_write(&ch, 1);
816	}	816	}
817	D_TTY(("After handling: len %d, keysym \"%s\" (0x%04x), and buffer \"%s\"\n", len, XKeysymToString(keysym), keysym, safe_print_string(kbuf, len)));	817	D_TTY(("After handling: len %d, keysym \"%s\" (0x%04x), and buffer \"%s\"\n", len, XKeysymToString(keysym), keysym, safe_print_string((char *)kbuf, len)));
818	tt_write(kbuf, len); /* Send the resulting string to the child process */	818	tt_write(kbuf, len); /* Send the resulting string to the child process */
819		819
820	LK_RET();	820	LK_RET();
Lines 1259-1265 Link Here
1259	for (i = 1; i < 7; i++) {	1259	for (i = 1; i < 7; i++) {
1260	string[i] = cmd_getc();	1260	string[i] = cmd_getc();
1261	}	1261	}
1262	set_window_color(idx, string);	1262	set_window_color(idx, (char *)string);
1263	return;	1263	return;
1264	} else if (ch == ';') {	1264	} else if (ch == ';') {
1265	unsigned long n = 0;	1265	unsigned long n = 0;