void set_altcharset(bool alt_on);
bool get_altcharset();

// Character set variable
static int Character_Set = CHARACTER_SET;

static int waddstr_with_altcharset(WINDOW* w, const char* s);

}
void set_altcharset( bool alt_on )
{
    Character_Set = ((alt_on) ? A_ALTCHARSET : 0);

bool get_altcharset( void )
{
    return (Character_Set != 0);
}

    mvwaddstr(Message_Window, which_line, firstcol, s);

    wmove(Message_Window, which_line, firstcol);
    waddstr_with_altcharset(Message_Window, s);

    i = addstr(buffer);

    i = waddstr_with_altcharset(stdscr, buffer);

// Wrapper around curses waddstr(); handles switching to the alt charset
// when necessary, and performing the funny DEC translation.
// Returns a curses success value.
static int waddstr_with_altcharset(WINDOW* w, const char* str)
{
    int ret = OK;
    if (Options.char_set == CSET_ASCII || Options.char_set == CSET_UNICODE)
    {
        // In ascii, we don't expect any high-bit chars.
        // In Unicode, str is UTF-8 and we shouldn't touch anything.
        ret = waddstr(w, str);
    }    
    else
    {
        // Otherwise, high bit indicates alternate charset.
        // DEC line-drawing chars don't have the high bit, so
        // we map them into 0xE0 and above.
        const bool bDEC = (Options.char_set == CSET_DEC);
        const char* begin = str;

        while (true)
        {
            const char* end = begin;
            // Output a range of normal characters (the common case)
            while (*end && (unsigned char)*end <= 127) ++end;
            if (end-begin) ret = waddnstr(w, begin, end-begin);
            // Then a single high-bit character
            chtype c = (unsigned char)*end;
            if (c == 0)
                break;
            else if (bDEC && c >= 0xE0)
                ret = waddch(w, (c & 0x7F) | A_ALTCHARSET);
            else // if (*end > 127)
                ret = waddch(w, c | A_ALTCHARSET);
            begin = end+1;
        }
    }
    return ret;
}

// NOTE: This affects libunix.cc draw state; use this just before setting
// textcolour and drawing a character and call set_altcharset(false)
// after you're done drawing.
//
unsigned cset_adjust(unsigned raw)

void put_colour_ch(int colour, unsigned ch)

    if (Options.char_set != CSET_ASCII && Options.char_set != CSET_UNICODE)

    if (Options.char_set == CSET_ASCII || Options.char_set == CSET_UNICODE)

        // switch to alternate char set for 8-bit characters:
        set_altcharset( raw > 127 );
        // shift the DEC line drawing set:
        if (Options.char_set == CSET_DEC 
            && raw >= 0xE0)
        {
            raw &= 0x7F;
        }

        // Unicode can't or-in curses attributes; but it also doesn't have
        // to fool around with altcharset
        textattr(colour);
        putwch(ch);

    return (raw);
}

    else
    {
        const unsigned oldch = ch;
        if (oldch & 0x80) ch |= A_ALTCHARSET;
        // Shift the DEC line drawing set
        if (oldch >= 0xE0 && Options.char_set == CSET_DEC)
            ch ^= 0x80;
        textattr(colour);

void put_colour_ch(int colour, unsigned ch)
{
    ch = cset_adjust(ch);
    textattr(colour);
    putwch(ch);

        // putch truncates ch to a byte, so don't use it.
        if ((ch & 0x7f) == 0) ch |= ' ';
        addch(ch);
    }

            const screen_buffer_t ch = cset_adjust( *buf );
            textattr( buf[1] );
            putwch( ch );

            put_colour_ch( buf[1], buf[0] );

    set_altcharset(false);

    return ( COLOR_PAIR(pair) | flags | Character_Set );

    return ( COLOR_PAIR(pair) | flags );

    return ( COLOR_PAIR(pair) | flags | Character_Set );

    return ( COLOR_PAIR(pair) | flags );