← Back to branch summary

~ubuntu-branches/debian/sid/ncurses/sid-200908151531

« back to all changes in this revision

Viewing changes to test/ncurses.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2008-11-05 21:34:00 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20081105213400-7d9r3jj2ngz18k24
Tags: 5.7-1
* Merging upstream version 5.7.
* Updating soname and sodepver to 5.7 in rules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/ncurses.c
1
1
/****************************************************************************
2
 
 * Copyright (c) 1998-2008,2009 Free Software Foundation, Inc.              *
 
2
 * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
3
3
 *                                                                          *
4
4
 * Permission is hereby granted, free of charge, to any person obtaining a  *
5
5
 * copy of this software and associated documentation files (the            *
40
40
   Author: Eric S. Raymond <esr@snark.thyrsus.com> 1993
41
41
           Thomas E. Dickey (beginning revision 1.27 in 1996).
42
42
 
43
 
$Id: ncurses.c,v 1.339 2009/04/04 22:46:11 juergen Exp $
 
43
$Id: ncurses.c,v 1.329 2008/09/27 14:34:58 tom Exp $
44
44
 
45
45
***************************************************************************/
46
46
 
483
483
        addstr("Shelling out...");
484
484
    def_prog_mode();
485
485
    endwin();
486
 
#ifdef __MINGW32__
487
 
    system("cmd.exe");
488
 
#else
489
486
    system("sh");
490
 
#endif
491
487
    if (message)
492
488
        addstr("returned from shellout.\n");
493
489
    refresh();
573
569
 *
574
570
 ****************************************************************************/
575
571
 
576
 
#define NUM_GETCH_FLAGS 256
577
 
typedef bool GetchFlags[NUM_GETCH_FLAGS];
578
 
 
579
572
static void
580
 
setup_getch(WINDOW *win, GetchFlags flags)
 
573
setup_getch(WINDOW *win, bool flags[])
581
574
{
582
575
    keypad(win, flags['k']);    /* should be redundant, but for testing */
583
576
    meta(win, flags['m']);      /* force this to a known state */
588
581
}
589
582
 
590
583
static void
591
 
init_getch(WINDOW *win, GetchFlags flags)
592
 
{
593
 
    memset(flags, FALSE, NUM_GETCH_FLAGS);
594
 
    flags[UChar('k')] = (win == stdscr);
595
 
    flags[UChar('m')] = TRUE;
596
 
 
597
 
    setup_getch(win, flags);
598
 
}
599
 
 
600
 
static void
601
 
wgetch_help(WINDOW *win, GetchFlags flags)
 
584
wgetch_help(WINDOW *win, bool flags[])
602
585
{
603
586
    static const char *help[] =
604
587
    {
748
731
    int first_y, first_x;
749
732
    int c;
750
733
    int incount = 0;
751
 
    GetchFlags flags;
 
734
    bool flags[256];
752
735
    bool blocking = (delay < 0);
753
736
 
754
 
    init_getch(win, flags);
 
737
    memset(flags, FALSE, sizeof(flags));
 
738
    flags[UChar('k')] = (win == stdscr);
 
739
 
 
740
    setup_getch(win, flags);
755
741
    wtimeout(win, delay);
756
742
    getyx(win, first_y, first_x);
757
743
 
849
835
                }
850
836
#endif
851
837
                (void) waddstr(win, keyname(c));
852
 
            } else if (c >= 0x80) {
853
 
                unsigned c2 = (unsigned) c;
854
 
#if !(defined(NCURSES_VERSION) || defined(_XOPEN_CURSES))
855
 
                /* at least Solaris SVR4 curses breaks unctrl(128), etc. */
856
 
                c2 &= 0x7f;
857
 
#endif
858
 
                if (isprint(c))
859
 
                    (void) wprintw(win, "%c", UChar(c));
860
 
                else if (c2 != UChar(c))
 
838
            } else if (c > 0x80) {
 
839
                unsigned c2 = (unsigned) (c & 0x7f);
 
840
                if (isprint(c2))
 
841
                    (void) wprintw(win, "M-%c", UChar(c2));
 
842
                else
861
843
                    (void) wprintw(win, "M-%s", unctrl(c2));
862
 
                else
863
 
                    (void) wprintw(win, "%s", unctrl(c2));
864
844
                waddstr(win, " (high-half character)");
865
845
            } else {
866
846
                if (isprint(c))
874
854
    }
875
855
 
876
856
    wtimeout(win, -1);
877
 
 
878
 
    if (!level)
879
 
        init_getch(win, flags);
880
857
}
881
858
 
882
859
static int
928
905
    wgetch_test(0, stdscr, delay);
929
906
    forget_boxes();
930
907
    finish_getch_test();
931
 
    slk_clear();
932
908
}
933
909
 
934
910
#if USE_WIDEC_SUPPORT
1002
978
    int first_y, first_x;
1003
979
    wint_t c;
1004
980
    int incount = 0;
1005
 
    GetchFlags flags;
 
981
    bool flags[256];
1006
982
    bool blocking = (delay < 0);
1007
983
    int y, x, code;
1008
984
    char *temp;
1009
985
 
1010
 
    init_getch(win, flags);
 
986
    memset(flags, FALSE, sizeof(flags));
 
987
    flags[UChar('k')] = (win == stdscr);
 
988
 
 
989
    setup_getch(win, flags);
1011
990
    wtimeout(win, delay);
1012
991
    getyx(win, first_y, first_x);
1013
992
 
1117
1096
                    resize_wide_boxes(level, win);
1118
1097
                }
1119
1098
#endif
1120
 
                (void) waddstr(win, keyname((wchar_t) c));
1121
 
            } else {
1122
1099
                (void) waddstr(win, key_name((wchar_t) c));
 
1100
            } else {
1123
1101
                if (c < 256 && iscntrl(c)) {
1124
 
                    (void) wprintw(win, " (control character)");
 
1102
                    (void) wprintw(win, "%s (control character)", unctrl(c));
1125
1103
                } else {
1126
 
                    (void) wprintw(win, " = %#x (printable character)",
1127
 
                                   (unsigned) c);
 
1104
                    wchar_t c2 = (wchar_t) c;
 
1105
                    waddnwstr(win, &c2, 1);
 
1106
                    (void) wprintw(win, " = %#x (printable character)", (unsigned) c);
1128
1107
                }
1129
1108
            }
1130
1109
            wgetch_wrap(win, first_y);
1132
1111
    }
1133
1112
 
1134
1113
    wtimeout(win, -1);
1135
 
 
1136
 
    if (!level)
1137
 
        init_getch(win, flags);
1138
1114
}
1139
1115
 
1140
1116
static void
1146
1122
    wget_wch_test(0, stdscr, delay);
1147
1123
    forget_boxes();
1148
1124
    finish_getch_test();
1149
 
    slk_clear();
1150
1125
}
1151
1126
#endif
1152
1127
 
1865
1840
            width = 4;
1866
1841
        } else if (color >= 8) {
1867
1842
            sprintf(temp, "[%02d]", color);
1868
 
        } else if (color < 0) {
1869
 
            strcpy(temp, "default");
1870
1843
        } else {
1871
1844
            strcpy(temp, the_color_names[color]);
1872
1845
        }
1901
1874
    mvwprintw(helpwin, row++, col,
1902
1875
              "  n/N     toggle text/number on/off");
1903
1876
    mvwprintw(helpwin, row++, col,
1904
 
              "  r/R     toggle reverse on/off");
1905
 
    mvwprintw(helpwin, row++, col,
1906
1877
              "  w/W     toggle width between 8/16 colors");
1907
1878
#if USE_WIDEC_SUPPORT
1908
1879
    if (wide) {
1935
1906
    bool done = FALSE;
1936
1907
    bool opt_acsc = FALSE;
1937
1908
    bool opt_bold = FALSE;
1938
 
    bool opt_revs = FALSE;
 
1909
    bool opt_wide = FALSE;
1939
1910
    bool opt_nums = FALSE;
1940
 
    bool opt_wide = FALSE;
1941
1911
    WINDOW *helpwin;
1942
1912
 
1943
 
    if (COLORS * COLORS == COLOR_PAIRS) {
1944
 
        int limit = (COLORS - min_colors) * (COLORS - min_colors);
1945
 
        if (pairs_max > limit)
1946
 
            pairs_max = limit;
1947
 
    } else {
1948
 
        if (pairs_max > COLOR_PAIRS)
1949
 
            pairs_max = COLOR_PAIRS;
1950
 
    }
 
1913
    if (pairs_max > COLOR_PAIRS)
 
1914
        pairs_max = COLOR_PAIRS;
1951
1915
 
1952
1916
    while (!done) {
1953
1917
        int shown = 0;
1962
1926
            hello = "Hello";
1963
1927
            per_row = 8;
1964
1928
        }
1965
 
        per_row -= min_colors;
1966
1929
 
1967
1930
        row_limit = (pairs_max + per_row - 1) / per_row;
1968
1931
 
1969
1932
        move(0, 0);
1970
 
        (void) printw("There are %d color pairs and %d colors%s\n",
1971
 
                      pairs_max, COLORS,
1972
 
                      min_colors ? " besides 'default'" : "");
 
1933
        (void) printw("There are %d color pairs and %d colors\n",
 
1934
                      pairs_max, COLORS);
1973
1935
 
1974
1936
        clrtobot();
1975
1937
        (void) mvprintw(top + 1, 0,
1980
1942
 
1981
1943
        /* show color names/numbers across the top */
1982
1944
        for (i = 0; i < per_row; i++)
1983
 
            show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
 
1945
            show_color_name(top + 2, (i + 1) * width, i, opt_wide);
1984
1946
 
1985
1947
        /* show a grid of colors, with color names/ numbers on the left */
1986
1948
        for (i = (short) (base_row * per_row); i < pairs_max; i++) {
1988
1950
            int col = (i % per_row + 1) * width;
1989
1951
            short pair = i;
1990
1952
 
1991
 
#define InxToFG(i) (short) ((i % (COLORS - min_colors)) + min_colors)
1992
 
#define InxToBG(i) (short) ((i / (COLORS - min_colors)) + min_colors)
1993
1953
            if (row >= 0 && move(row, col) != ERR) {
1994
 
                short fg = InxToFG(i);
1995
 
                short bg = InxToBG(i);
 
1954
                short fg = (short) (i % COLORS);
 
1955
                short bg = (short) (i / COLORS);
1996
1956
 
1997
1957
                init_pair(pair, fg, bg);
1998
1958
                attron((attr_t) COLOR_PAIR(pair));
2000
1960
                    attron((attr_t) A_ALTCHARSET);
2001
1961
                if (opt_bold)
2002
1962
                    attron((attr_t) A_BOLD);
2003
 
                if (opt_revs)
2004
 
                    attron((attr_t) A_REVERSE);
2005
1963
 
2006
1964
                if (opt_nums) {
2007
1965
                    sprintf(numbered, "{%02X}", i);
2010
1968
                printw("%-*.*s", width, width, hello);
2011
1969
                attrset(A_NORMAL);
2012
1970
 
2013
 
                if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2014
 
                    show_color_name(row, 0, InxToBG(i), opt_wide);
 
1971
                if ((i % per_row) == 0 && (i % COLORS) == 0) {
 
1972
                    show_color_name(row, 0, i / COLORS, opt_wide);
2015
1973
                }
2016
1974
                ++shown;
2017
1975
            } else if (shown) {
2038
1996
        case 'N':
2039
1997
            opt_nums = TRUE;
2040
1998
            break;
2041
 
        case 'r':
2042
 
            opt_revs = FALSE;
2043
 
            break;
2044
 
        case 'R':
2045
 
            opt_revs = TRUE;
2046
 
            break;
2047
1999
        case case_QUIT:
2048
2000
            done = TRUE;
2049
2001
            continue;
2121
2073
    int base_row = 0;
2122
2074
    int grid_top = top + 3;
2123
2075
    int page_size = (LINES - grid_top);
2124
 
    int pairs_max = (unsigned short) (-1);
 
2076
    int pairs_max = COLOR_PAIRS;
2125
2077
    int row_limit;
2126
2078
    int per_row;
2127
2079
    char numbered[80];
2129
2081
    bool done = FALSE;
2130
2082
    bool opt_acsc = FALSE;
2131
2083
    bool opt_bold = FALSE;
2132
 
    bool opt_revs = FALSE;
2133
2084
    bool opt_wide = FALSE;
2134
2085
    bool opt_nums = FALSE;
2135
2086
    bool opt_xchr = FALSE;
2136
2087
    wchar_t buffer[10];
2137
2088
    WINDOW *helpwin;
2138
2089
 
2139
 
    if (COLORS * COLORS == COLOR_PAIRS) {
2140
 
        int limit = (COLORS - min_colors) * (COLORS - min_colors);
2141
 
        if (pairs_max > limit)
2142
 
            pairs_max = limit;
2143
 
    } else {
2144
 
        if (pairs_max > COLOR_PAIRS)
2145
 
            pairs_max = COLOR_PAIRS;
2146
 
    }
2147
 
 
2148
2090
    while (!done) {
2149
2091
        int shown = 0;
2150
2092
 
2158
2100
            hello = "Hello";
2159
2101
            per_row = 8;
2160
2102
        }
2161
 
        per_row -= min_colors;
2162
 
 
2163
2103
        if (opt_xchr) {
2164
2104
            make_fullwidth_text(buffer, hello);
2165
2105
            width *= 2;
2171
2111
        row_limit = (pairs_max + per_row - 1) / per_row;
2172
2112
 
2173
2113
        move(0, 0);
2174
 
        (void) printw("There are %d color pairs and %d colors%s\n",
2175
 
                      pairs_max, COLORS,
2176
 
                      min_colors ? " besides 'default'" : "");
 
2114
        (void) printw("There are %d color pairs and %d colors\n",
 
2115
                      pairs_max, COLORS);
2177
2116
 
2178
2117
        clrtobot();
2179
2118
        (void) mvprintw(top + 1, 0,
2184
2123
 
2185
2124
        /* show color names/numbers across the top */
2186
2125
        for (i = 0; i < per_row; i++)
2187
 
            show_color_name(top + 2, (i + 1) * width, i + min_colors, opt_wide);
 
2126
            show_color_name(top + 2, (i + 1) * width, i, opt_wide);
2188
2127
 
2189
2128
        /* show a grid of colors, with color names/ numbers on the left */
2190
2129
        for (i = (base_row * per_row); i < pairs_max; i++) {
2193
2132
            short pair = (short) i;
2194
2133
 
2195
2134
            if (row >= 0 && move(row, col) != ERR) {
2196
 
                init_pair(pair, InxToFG(i), InxToBG(i));
 
2135
                init_pair(pair, (short) (i % COLORS), (short) (i / COLORS));
2197
2136
                color_set(pair, NULL);
2198
2137
                if (opt_acsc)
2199
2138
                    attr_on((attr_t) A_ALTCHARSET, NULL);
2200
2139
                if (opt_bold)
2201
2140
                    attr_on((attr_t) A_BOLD, NULL);
2202
 
                if (opt_revs)
2203
 
                    attr_on((attr_t) A_REVERSE, NULL);
2204
2141
 
2205
2142
                if (opt_nums) {
2206
2143
                    sprintf(numbered, "{%02X}", i);
2213
2150
                addnwstr(buffer, width);
2214
2151
                attr_set(A_NORMAL, 0, NULL);
2215
2152
 
2216
 
                if ((i % per_row) == 0 && InxToFG(i) == min_colors) {
2217
 
                    show_color_name(row, 0, InxToBG(i), opt_wide);
 
2153
                if ((i % per_row) == 0 && (i % COLORS) == 0) {
 
2154
                    show_color_name(row, 0, i / COLORS, opt_wide);
2218
2155
                }
2219
2156
                ++shown;
2220
2157
            } else if (shown) {
2241
2178
        case 'N':
2242
2179
            opt_nums = TRUE;
2243
2180
            break;
2244
 
        case 'r':
2245
 
            opt_revs = FALSE;
2246
 
            break;
2247
 
        case 'R':
2248
 
            opt_revs = TRUE;
2249
 
            break;
2250
2181
        case case_QUIT:
2251
2182
            done = TRUE;
2252
2183
            continue;
2871
2802
} attrs_to_cycle[] = {
2872
2803
    { A_NORMAL,         "normal" },
2873
2804
    { A_BOLD,           "bold" },
2874
 
    { A_BLINK,          "blink" },
2875
2805
    { A_REVERSE,        "reverse" },
2876
2806
    { A_UNDERLINE,      "underline" },
2877
2807
};
2972
2902
        do {
2973
2903
            if (C1)
2974
2904
                nodelay(stdscr, TRUE);
2975
 
            echochar(colored_chtype(code, attr, pair));
 
2905
            echochar(code | attr | COLOR_PAIR(pair));
2976
2906
            if (C1) {
2977
2907
                /* (yes, this _is_ crude) */
2978
2908
                while ((reply = Getchar()) != ERR) {
3021
2951
                 */
3022
2952
                break;
3023
2953
            default:
3024
 
                addch(colored_chtype(code, A_ALTCHARSET | attr, pair));
 
2954
                addch(code | A_ALTCHARSET | attr | COLOR_PAIR(pair));
3025
2955
                break;
3026
2956
            }
3027
2957
        } while (--count > 0);
3039
2969
    mvaddstr(0, 20, "Display of the ACS Line-Drawing Set");
3040
2970
    attroff(A_BOLD);
3041
2971
    refresh();
 
2972
    box(stdscr, 0, 0);
3042
2973
    /* *INDENT-OFF* */
3043
 
    wborder(stdscr,
3044
 
            colored_chtype(ACS_VLINE,    attr, pair),
3045
 
            colored_chtype(ACS_VLINE,    attr, pair),
3046
 
            colored_chtype(ACS_HLINE,    attr, pair),
3047
 
            colored_chtype(ACS_HLINE,    attr, pair),
3048
 
            colored_chtype(ACS_ULCORNER, attr, pair),
3049
 
            colored_chtype(ACS_URCORNER, attr, pair),
3050
 
            colored_chtype(ACS_LLCORNER, attr, pair),
3051
 
            colored_chtype(ACS_LRCORNER, attr, pair));
3052
 
    mvhline(LINES / 2, 0,        colored_chtype(ACS_HLINE, attr, pair), COLS);
3053
 
    mvvline(0,         COLS / 2, colored_chtype(ACS_VLINE, attr, pair), LINES);
3054
 
    mvaddch(0,         COLS / 2, colored_chtype(ACS_TTEE,  attr, pair));
3055
 
    mvaddch(LINES / 2, COLS / 2, colored_chtype(ACS_PLUS,  attr, pair));
3056
 
    mvaddch(LINES - 1, COLS / 2, colored_chtype(ACS_BTEE,  attr, pair));
3057
 
    mvaddch(LINES / 2, 0,        colored_chtype(ACS_LTEE,  attr, pair));
3058
 
    mvaddch(LINES / 2, COLS - 1, colored_chtype(ACS_RTEE,  attr, pair));
 
2974
    mvhline(LINES / 2, 0,        ACS_HLINE | attr, COLS);
 
2975
    mvvline(0,         COLS / 2, ACS_VLINE | attr, LINES);
 
2976
    mvaddch(0,         COLS / 2, ACS_TTEE | attr);
 
2977
    mvaddch(LINES / 2, COLS / 2, ACS_PLUS | attr);
 
2978
    mvaddch(LINES - 1, COLS / 2, ACS_BTEE | attr);
 
2979
    mvaddch(LINES / 2, 0,        ACS_LTEE | attr);
 
2980
    mvaddch(LINES / 2, COLS - 1, ACS_RTEE | attr);
3059
2981
    /* *INDENT-ON* */
3060
2982
 
3061
2983
}
3080
3002
{
3081
3003
    int n;
3082
3004
 
3083
 
#define BOTH(name) #name, colored_chtype(name, attr, pair)
 
3005
#define BOTH(name) #name, (name | attr | COLOR_PAIR(pair))
3084
3006
 
3085
3007
    erase();
3086
3008
    attron(A_BOLD);
3290
3212
             * the display.
3291
3213
             */
3292
3214
            if (wcwidth(code) == 0)
3293
 
                addch(space | (A_REVERSE ^ attr) | COLOR_PAIR(pair));
 
3215
                addch(space | A_REVERSE);
3294
3216
            /*
3295
3217
             * This could use add_wch(), but is done for comparison with the
3296
3218
             * normal 'f' test (and to make a test-case for echo_wchar()).
3316
3238
    int col = (n / height) * COLS / 2;
3317
3239
 
3318
3240
    mvprintw(row, col, "%*s : ", COLS / 4, name);
3319
 
    while (--repeat >= 0) {
 
3241
    while (repeat-- >= 0) {
3320
3242
        add_wch(code);
3321
3243
    }
3322
3244
    return n + 1;
3385
3307
 
3386
3308
#undef MERGE_ATTR
3387
3309
 
3388
 
#define MERGE_ATTR(n,wch) merge_wide_attr(&temp[n], wch, attr, pair)
 
3310
#define MERGE_ATTR(wch) merge_wide_attr(&temp, wch, attr, pair)
3389
3311
 
3390
3312
static void
3391
3313
show_wbox_chars(int repeat, attr_t attr, short pair)
3392
3314
{
3393
 
    cchar_t temp[8];
 
3315
    cchar_t temp;
3394
3316
 
3395
3317
    (void) repeat;
3396
3318
    erase();
3399
3321
    attroff(A_BOLD);
3400
3322
    refresh();
3401
3323
 
3402
 
    wborder_set(stdscr,
3403
 
                MERGE_ATTR(0, WACS_VLINE),
3404
 
                MERGE_ATTR(1, WACS_VLINE),
3405
 
                MERGE_ATTR(2, WACS_HLINE),
3406
 
                MERGE_ATTR(3, WACS_HLINE),
3407
 
                MERGE_ATTR(4, WACS_ULCORNER),
3408
 
                MERGE_ATTR(5, WACS_URCORNER),
3409
 
                MERGE_ATTR(6, WACS_LLCORNER),
3410
 
                MERGE_ATTR(7, WACS_LRCORNER));
 
3324
    attr_set(attr, pair, 0);
 
3325
    box_set(stdscr, 0, 0);
 
3326
    attr_set(A_NORMAL, 0, 0);
3411
3327
    /* *INDENT-OFF* */
3412
 
    mvhline_set(LINES / 2, 0,        MERGE_ATTR(0, WACS_HLINE), COLS);
3413
 
    mvvline_set(0,         COLS / 2, MERGE_ATTR(0, WACS_VLINE), LINES);
3414
 
    mvadd_wch(0,           COLS / 2, MERGE_ATTR(0, WACS_TTEE));
3415
 
    mvadd_wch(LINES / 2,   COLS / 2, MERGE_ATTR(0, WACS_PLUS));
3416
 
    mvadd_wch(LINES - 1,   COLS / 2, MERGE_ATTR(0, WACS_BTEE));
3417
 
    mvadd_wch(LINES / 2,   0,        MERGE_ATTR(0, WACS_LTEE));
3418
 
    mvadd_wch(LINES / 2,   COLS - 1, MERGE_ATTR(0, WACS_RTEE));
 
3328
    mvhline_set(LINES / 2, 0,        MERGE_ATTR(WACS_HLINE), COLS);
 
3329
    mvvline_set(0,         COLS / 2, MERGE_ATTR(WACS_VLINE), LINES);
 
3330
    mvadd_wch(0,           COLS / 2, MERGE_ATTR(WACS_TTEE));
 
3331
    mvadd_wch(LINES / 2,   COLS / 2, MERGE_ATTR(WACS_PLUS));
 
3332
    mvadd_wch(LINES - 1,   COLS / 2, MERGE_ATTR(WACS_BTEE));
 
3333
    mvadd_wch(LINES / 2,   0,        MERGE_ATTR(WACS_LTEE));
 
3334
    mvadd_wch(LINES / 2,   COLS - 1, MERGE_ATTR(WACS_RTEE));
3419
3335
    /* *INDENT-ON* */
3420
3336
 
3421
3337
}
5888
5804
        break;
5889
5805
    case 2:
5890
5806
        init_pair(cpair, COLOR_RED, COLOR_GREEN);
5891
 
        wbkgdset(win, colored_chtype(' ', A_BLINK, cpair));
 
5807
        wbkgdset(win, ' ' | A_BLINK | COLOR_PAIR(cpair));
5892
5808
        break;
5893
5809
    case 3:
5894
5810
        wbkgdset(win, ' ' | A_NORMAL);