Module Name: src Committed By: blymn Date: Thu Sep 19 11:31:58 UTC 2019
Modified Files: src/tests/lib/libcurses: testframe.txt src/tests/lib/libcurses/check_files: mutt_test5.chk mutt_test6.chk src/tests/lib/libcurses/director: returns.h testlang_conf.l testlang_parse.y src/tests/lib/libcurses/slave: commands.c slave.c src/tests/lib/libcurses/tests: mutt_test Log Message: Rototill to add complex character support: - Add cchar command to director test language to allow a complex character to be defined and passed to the slave. - Removed the distinction between args and returns internally to prevent confusing the two which leads to errors and/or crashes. - Converted mutt_test to use the new cchar definition and fixed the check files for the test. To generate a diff of this commit: cvs rdiff -u -r1.3 -r1.4 src/tests/lib/libcurses/testframe.txt cvs rdiff -u -r1.1 -r1.2 src/tests/lib/libcurses/check_files/mutt_test5.chk \ src/tests/lib/libcurses/check_files/mutt_test6.chk cvs rdiff -u -r1.1 -r1.2 src/tests/lib/libcurses/director/returns.h cvs rdiff -u -r1.7 -r1.8 src/tests/lib/libcurses/director/testlang_conf.l cvs rdiff -u -r1.15 -r1.16 src/tests/lib/libcurses/director/testlang_parse.y cvs rdiff -u -r1.4 -r1.5 src/tests/lib/libcurses/slave/commands.c cvs rdiff -u -r1.6 -r1.7 src/tests/lib/libcurses/slave/slave.c cvs rdiff -u -r1.1 -r1.2 src/tests/lib/libcurses/tests/mutt_test Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.
Modified files: Index: src/tests/lib/libcurses/testframe.txt diff -u src/tests/lib/libcurses/testframe.txt:1.3 src/tests/lib/libcurses/testframe.txt:1.4 --- src/tests/lib/libcurses/testframe.txt:1.3 Thu Nov 21 11:08:08 2013 +++ src/tests/lib/libcurses/testframe.txt Thu Sep 19 11:31:57 2019 @@ -101,6 +101,27 @@ call, call2, call3, call4: that is the label STDSCR. This parameter will be substituted by the value of stdscr when the function call is made. +cchar: + Defines a variable as a complex character type (cchar_t). The + syntax is: + + cchar var_name attributes elements + + Where attributes is the attributes for the complex character, this + can be an integer, a variable or bitwise or'ed list (see below + for a description of the syntax). The elements is one or more wide + characters that make up the elements of the complex character. A + single element of either a numeric, variable, byte or single + character string can simply be wrtten at the end of the line. + Multiple elements need to be space separated and enclosed in + square ([]) brackets, the types allowed are the same as for the + single element case. In addition an element can be repeated by + following an element with a '*' then a number which will cause + the last element to be repeatedly added to the array the number + of times specified by number. Once the complex character variable + has been defined it can be used in calls to curses routines + requiring a complex character type argument. + check: Validate the value of a variable. This allows a variable to be checked for an expected return after it has been assigned in a Index: src/tests/lib/libcurses/check_files/mutt_test5.chk diff -u src/tests/lib/libcurses/check_files/mutt_test5.chk:1.1 src/tests/lib/libcurses/check_files/mutt_test5.chk:1.2 --- src/tests/lib/libcurses/check_files/mutt_test5.chk:1.1 Sun May 26 09:54:33 2019 +++ src/tests/lib/libcurses/check_files/mutt_test5.chk Thu Sep 19 11:31:57 2019 @@ -1,4 +1,4 @@ -cup13;1Xjsetaf7Xsetab0XEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE -boldEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEsgr0opjsetaf7Xsetab0XEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEj +cup13;1Xsetaf7Xsetab0XEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE +boldEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEsgr0opsetaf7Xsetab0XEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEj boldEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEsgr0opsetaf7Xsetab0XEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEj boldEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEsgr0op \ No newline at end of file Index: src/tests/lib/libcurses/check_files/mutt_test6.chk diff -u src/tests/lib/libcurses/check_files/mutt_test6.chk:1.1 src/tests/lib/libcurses/check_files/mutt_test6.chk:1.2 --- src/tests/lib/libcurses/check_files/mutt_test6.chk:1.1 Sun May 26 09:54:33 2019 +++ src/tests/lib/libcurses/check_files/mutt_test6.chk Thu Sep 19 11:31:57 2019 @@ -1 +1 @@ -jcup15;11Xsetaf7Xsetab0XsmsoRRRRRRRRRRRcup24;1Xrmsoopsetaf7Xsetab0Xjopjcup15;15Xsetaf7Xsetab0XHHHopsetaf7Xsetab0Xjop \ No newline at end of file +cup15;11Xsetaf7Xsetab0XsmsoRRRRRRRRRRRcup24;1Xrmsoopsetaf7Xsetab0Xjopcup15;15Xsetaf7Xsetab0XHHHopsetaf7Xsetab0Xjop \ No newline at end of file Index: src/tests/lib/libcurses/director/returns.h diff -u src/tests/lib/libcurses/director/returns.h:1.1 src/tests/lib/libcurses/director/returns.h:1.2 --- src/tests/lib/libcurses/director/returns.h:1.1 Sun Apr 10 09:55:09 2011 +++ src/tests/lib/libcurses/director/returns.h Thu Sep 19 11:31:57 2019 @@ -1,4 +1,4 @@ -/* $NetBSD: returns.h,v 1.1 2011/04/10 09:55:09 blymn Exp $ */ +/* $NetBSD: returns.h,v 1.2 2019/09/19 11:31:57 blymn Exp $ */ /*- * Copyright 2009 Brett Lymn <bl...@netbsd.org> @@ -33,28 +33,30 @@ typedef enum { - ret_number = 1, - ret_string, - ret_byte, - ret_err, - ret_ok, - ret_null, - ret_nonnull, - ret_var, - ret_ref, - ret_count, - ret_slave_error -} returns_enum_t; + data_number = 1, + data_static, + data_string, + data_byte, + data_cchar, + data_err, + data_ok, + data_null, + data_nonnull, + data_var, + data_ref, + data_count, + data_slave_error +} data_enum_t; typedef struct { - returns_enum_t return_type; - void *return_value; /* used if return_type is ret_num or - or ret_byte or ret_string */ - size_t return_len; /* number of bytes in return_value iff - return_type is ret_byte */ - int return_index; /* index into var array for return - if return_type is ret_var */ -} returns_t; + data_enum_t data_type; + void *data_value; /* used if data_type is data_num or + or data_byte or data_string */ + size_t data_len; /* number of bytes in return_value iff + return_type is data_byte */ + int data_index; /* index into var array for return + if data_type is data_var */ +} ct_data_t; typedef struct { size_t count; Index: src/tests/lib/libcurses/director/testlang_conf.l diff -u src/tests/lib/libcurses/director/testlang_conf.l:1.7 src/tests/lib/libcurses/director/testlang_conf.l:1.8 --- src/tests/lib/libcurses/director/testlang_conf.l:1.7 Thu Nov 21 11:06:04 2013 +++ src/tests/lib/libcurses/director/testlang_conf.l Thu Sep 19 11:31:57 2019 @@ -1,5 +1,5 @@ %{ -/* $NetBSD: testlang_conf.l,v 1.7 2013/11/21 11:06:04 blymn Exp $ */ +/* $NetBSD: testlang_conf.l,v 1.8 2019/09/19 11:31:57 blymn Exp $ */ /*- * Copyright 2009 Brett Lymn <bl...@netbsd.org> @@ -155,10 +155,14 @@ FILENAME [A-Za-z0-9.][A-Za-z0-9./_-]+ VARNAME [A-Za-z][A-Za-z0-9_-]+ NULL_RET NULL NON_NULL NON_NULL +CCHAR [cC][cC][hH][aA][rR] BYTE BYTE OR \| LHB \( RHB \) +LHSB \[ +RHSB \] +MULTIPLIER \* %x incl %option noinput nounput @@ -286,6 +290,14 @@ include BEGIN(incl); return ERR_RET; } +{MULTIPLIER} { + return MULTIPLIER; + } + +{CCHAR} { + return CCHAR; + } + {OR} { return OR; } @@ -298,6 +310,14 @@ include BEGIN(incl); return RHB; } +{LHSB} { + return LHSB; + } + +{RHSB} { + return RHSB; + } + {HEX} { /* Hex value, convert to decimal and return numeric */ unsigned long val; @@ -342,17 +362,17 @@ include BEGIN(incl); char *p; size_t len; - if ((yylval.retval = malloc(sizeof(returns_t))) == NULL) + if ((yylval.retval = malloc(sizeof(ct_data_t))) == NULL) err(1, "Cannot allocate return struct"); p = yytext; p++; /* skip the leading ' */ - if ((yylval.retval->return_value = dequote(p, &len)) + if ((yylval.retval->data_value = dequote(p, &len)) == NULL) err(1, "Cannot allocate string"); - yylval.retval->return_type = ret_byte; + yylval.retval->data_type = data_byte; /* trim trailing ' */ - yylval.retval->return_len = len - 1; + yylval.retval->data_len = len - 1; return BYTE; } @@ -362,7 +382,7 @@ include BEGIN(incl); size_t i; chtype *rv; - if ((yylval.retval = malloc(sizeof(returns_t))) == NULL) + if ((yylval.retval = malloc(sizeof(ct_data_t))) == NULL) err(1, "Cannot allocate return struct"); p = yytext; p++; /* skip the leading ' */ @@ -373,16 +393,16 @@ include BEGIN(incl); len--; chlen = ((len / 2) + 1) * sizeof(chtype); - if ((yylval.retval->return_value = malloc(chlen)) + if ((yylval.retval->data_value = malloc(chlen)) == NULL) err(1, "Cannot allocate chtype array"); - rv = yylval.retval->return_value; + rv = yylval.retval->data_value; for (i = 0; i < len; i += 2) *rv++ = (str[i] << 8) | str[i+1]; *rv = __NORMAL | '\0'; /* terminates chtype array */ - yylval.retval->return_type = ret_byte; - yylval.retval->return_len = chlen; + yylval.retval->data_type = data_byte; + yylval.retval->data_len = chlen; return BYTE; } Index: src/tests/lib/libcurses/director/testlang_parse.y diff -u src/tests/lib/libcurses/director/testlang_parse.y:1.15 src/tests/lib/libcurses/director/testlang_parse.y:1.16 --- src/tests/lib/libcurses/director/testlang_parse.y:1.15 Tue Jun 11 10:22:35 2019 +++ src/tests/lib/libcurses/director/testlang_parse.y Thu Sep 19 11:31:57 2019 @@ -1,5 +1,5 @@ %{ -/* $NetBSD: testlang_parse.y,v 1.15 2019/06/11 10:22:35 blymn Exp $ */ +/* $NetBSD: testlang_parse.y,v 1.16 2019/09/19 11:31:57 blymn Exp $ */ /*- * Copyright 2009 Brett Lymn <bl...@netbsd.org> @@ -79,27 +79,19 @@ static struct timespec delay_post_call = static char *input_str; /* string to feed in as input */ static bool no_input; /* don't need more input */ +static wchar_t *vals = NULL; /* wchars to attach to a cchar type */ +static unsigned nvals; /* number of wchars */ + #define READ_PIPE 0 #define WRITE_PIPE 1 -const char *returns_enum_names[] = { - "unused", "numeric", "string", "byte", "ERR", "OK", "NULL", "not NULL", - "variable", "reference", "returns count", "slave error" -}; - -typedef enum { - arg_static, - arg_byte, - arg_var, - arg_null -} args_state_t; - -static const char *args_enum_names[] = { - "static", "byte", "var", "NULL" +const char *enum_names[] = { + "unused", "static", "numeric", "string", "byte", "cchar", "ERR", "OK", "NULL", + "not NULL", "variable", "reference", "returns count", "slave error" }; typedef struct { - args_state_t arg_type; + data_enum_t arg_type; size_t arg_len; char *arg_string; int var_index; @@ -108,7 +100,7 @@ typedef struct { typedef struct { char *function; int nrets; /* number of returns */ - returns_t *returns; /* array of expected returns */ + ct_data_t *returns; /* array of expected returns */ int nargs; /* number of arguments */ args_t *args; /* arguments for the call */ } cmd_line_t; @@ -118,8 +110,9 @@ static cmd_line_t command; typedef struct { char *name; size_t len; - returns_enum_t type; + data_enum_t type; void *value; + cchar_t cchar; } var_t; static size_t nvars; /* Number of declared variables */ @@ -127,26 +120,28 @@ static var_t *vars; /* Variables defin static int check_function_table(char *, const char *[], int); static int find_var_index(const char *); -static void assign_arg(args_state_t, void *); +static void assign_arg(data_enum_t, void *); static int assign_var(char *); void init_parse_variables(int); static void validate(int, void *); static void validate_return(const char *, const char *, int); -static void validate_variable(int, returns_enum_t, const void *, int, int); -static void validate_byte(returns_t *, returns_t *, int); +static void validate_variable(int, data_enum_t, const void *, int, int); +static void validate_byte(ct_data_t *, ct_data_t *, int); static void write_cmd_pipe(char *); -static void write_cmd_pipe_args(args_state_t, void *); -static void read_cmd_pipe(returns_t *); +static void write_cmd_pipe_args(data_enum_t, void *); +static void read_cmd_pipe(ct_data_t *); static void write_func_and_args(void); static void compare_streams(char *, bool); static void do_function_call(size_t); static void save_slave_output(bool); -static void validate_type(returns_enum_t, returns_t *, int); -static void set_var(returns_enum_t, char *, void *); +static void validate_type(data_enum_t, ct_data_t *, int); +static void set_var(data_enum_t, char *, void *); static void validate_reference(int, void *); static char *numeric_or(char *, char *); static char *get_numeric_var(const char *); static void perform_delay(struct timespec *); +static void set_cchar(char *, void *); +static wchar_t *add_to_vals(data_enum_t, void *); static const char *input_functions[] = { "getch", "getnstr", "getstr", "mvgetnstr", "mvgetstr", "mvgetnstr", @@ -163,7 +158,8 @@ saved_data_t saved_output; %union { char *string; - returns_t *retval; + ct_data_t *retval; + wchar_t *vals; } %token <string> PATH @@ -183,7 +179,8 @@ saved_data_t saved_output; %token <string> COMPARE %token <string> COMPAREND %token <string> ASSIGN -%token EOL CALL CHECK NOINPUT OR LHB RHB +%token <string> CCHAR +%token EOL CALL CHECK NOINPUT OR MULTIPLIER LHB RHB LHSB RHSB %token CALL2 CALL3 CALL4 DRAIN %nonassoc OR @@ -202,13 +199,39 @@ statement : /* empty */ | noinput statement | compare statement | comparend statement + | cchar statement | eol statement ; -assign : ASSIGN VARNAME numeric {set_var(ret_number, $2, $3);} eol - | ASSIGN VARNAME LHB expr RHB {set_var(ret_number, $2, $<string>4);} eol - | ASSIGN VARNAME STRING {set_var(ret_string, $2, $3);} eol - | ASSIGN VARNAME BYTE {set_var(ret_byte, $2, $3);} eol +assign : ASSIGN VARNAME numeric {set_var(data_number, $2, $3);} eol + | ASSIGN VARNAME LHB expr RHB {set_var(data_number, $2, $<string>4);} eol + | ASSIGN VARNAME STRING {set_var(data_string, $2, $3);} eol + | ASSIGN VARNAME BYTE {set_var(data_byte, $2, $3);} eol + ; + +cchar : CCHAR VARNAME attributes char_vals eol + { + set_cchar($2, $<string>3); + } + ; + + +attributes : numeric + | LHB expr RHB + { $<string>$ = $<string>2; } + | VARIABLE + { $<string>$ = get_numeric_var($1); } + ; + +char_vals : numeric + { add_to_vals(data_number, $1); } + | LHSB array RHSB + | VARIABLE + { add_to_vals(data_var, $1); } + | STRING + { add_to_vals(data_string, $1); } + | BYTE + { add_to_vals(data_byte, $1); } ; call : CALL result fn_name args eol { @@ -232,67 +255,67 @@ call4 : CALL4 result result result resu ; check : CHECK var returns eol { - returns_t retvar; + ct_data_t retvar; var_t *vptr; - if (command.returns[0].return_index == -1) + if (command.returns[0].data_index == -1) err(1, "Undefined variable in check statement, line %zu" " of file %s", line, cur_file); if (verbose) { fprintf(stderr, "Checking contents of variable %s for %s\n", - vars[command.returns[0].return_index].name, - returns_enum_names[command.returns[1].return_type]); + vars[command.returns[0].data_index].name, + enum_names[command.returns[1].data_type]); } - if (((command.returns[1].return_type == ret_byte) && - (vars[command.returns[0].return_index].type != ret_byte)) || - vars[command.returns[0].return_index].type != ret_string) + if (((command.returns[1].data_type == data_byte) && + (vars[command.returns[0].data_index].type != data_byte)) || + vars[command.returns[0].data_index].type != data_string) err(1, "Var type %s (%d) does not match return type %s (%d)", - returns_enum_names[ - vars[command.returns[0].return_index].type], - vars[command.returns[0].return_index].type, - returns_enum_names[command.returns[1].return_type], - command.returns[1].return_type); + enum_names[ + vars[command.returns[0].data_index].type], + vars[command.returns[0].data_index].type, + enum_names[command.returns[1].data_type], + command.returns[1].data_type); - switch (command.returns[1].return_type) { - case ret_err: - validate_variable(0, ret_string, "ERR", - command.returns[0].return_index, 0); + switch (command.returns[1].data_type) { + case data_err: + validate_variable(0, data_string, "ERR", + command.returns[0].data_index, 0); break; - case ret_ok: - validate_variable(0, ret_string, "OK", - command.returns[0].return_index, 0); + case data_ok: + validate_variable(0, data_string, "OK", + command.returns[0].data_index, 0); break; - case ret_null: - validate_variable(0, ret_string, "NULL", - command.returns[0].return_index, 0); + case data_null: + validate_variable(0, data_string, "NULL", + command.returns[0].data_index, 0); break; - case ret_nonnull: - validate_variable(0, ret_string, "NULL", - command.returns[0].return_index, 1); + case data_nonnull: + validate_variable(0, data_string, "NULL", + command.returns[0].data_index, 1); break; - case ret_string: - case ret_number: + case data_string: + case data_number: if (verbose) { fprintf(stderr, " %s == returned %s\n", - (const char *)command.returns[1].return_value, + (const char *)command.returns[1].data_value, (const char *) - vars[command.returns[0].return_index].value); + vars[command.returns[0].data_index].value); } - validate_variable(0, ret_string, - command.returns[1].return_value, - command.returns[0].return_index, 0); + validate_variable(0, data_string, + command.returns[1].data_value, + command.returns[0].data_index, 0); break; - case ret_byte: - vptr = &vars[command.returns[0].return_index]; - retvar.return_len = vptr->len; - retvar.return_type = vptr->type; - retvar.return_value = vptr->value; + case data_byte: + vptr = &vars[command.returns[0].data_index]; + retvar.data_len = vptr->len; + retvar.data_type = vptr->type; + retvar.data_value = vptr->value; validate_byte(&retvar, &command.returns[1], 0); break; @@ -380,23 +403,23 @@ result : returns | reference ; -returns : numeric { assign_rets(ret_number, $1); } - | LHB expr RHB { assign_rets(ret_number, $<string>2); } - | STRING { assign_rets(ret_string, $1); } - | BYTE { assign_rets(ret_byte, (void *) $1); } - | ERR_RET { assign_rets(ret_err, NULL); } - | OK_RET { assign_rets(ret_ok, NULL); } - | NULL_RET { assign_rets(ret_null, NULL); } - | NON_NULL { assign_rets(ret_nonnull, NULL); } +returns : numeric { assign_rets(data_number, $1); } + | LHB expr RHB { assign_rets(data_number, $<string>2); } + | STRING { assign_rets(data_string, $1); } + | BYTE { assign_rets(data_byte, (void *) $1); } + | ERR_RET { assign_rets(data_err, NULL); } + | OK_RET { assign_rets(data_ok, NULL); } + | NULL_RET { assign_rets(data_null, NULL); } + | NON_NULL { assign_rets(data_nonnull, NULL); } ; var : VARNAME { - assign_rets(ret_var, $1); + assign_rets(data_var, $1); } ; reference : VARIABLE { - assign_rets(ret_ref, $1); + assign_rets(data_ref, $1); } fn_name : VARNAME { @@ -410,6 +433,57 @@ fn_name : VARNAME { } ; +array : numeric { $<vals>$ = add_to_vals(data_number, $1); }; + | VARIABLE + { $<vals>$ = add_to_vals(data_number, + get_numeric_var($1)); } + | BYTE + { + $<vals>$ = add_to_vals(data_byte, (void *) $1); + } + | numeric MULTIPLIER numeric + { + unsigned long i; + unsigned long acount; + + acount = strtoul($3, NULL, 10); + for (i = 0; i < acount; i++) { + $<vals>$ = add_to_vals(data_number, $1); + } + } + | VARIABLE MULTIPLIER numeric + { + unsigned long i, acount; + char *val; + + acount = strtoul($3, NULL, 10); + val = get_numeric_var($1); + for (i = 0; i < acount; i++) { + $<vals>$ = add_to_vals(data_number, val); + } + } + | BYTE MULTIPLIER numeric + { + unsigned long i, acount; + + acount = strtoul($3, NULL, 10); + for (i = 0; i < acount; i++) { + $<vals>$ = add_to_vals(data_byte, (void *) $1); + } + } + | STRING MULTIPLIER numeric + { + unsigned long i, acount; + + acount = strtoul($3, NULL, 10); + for (i = 0; i < acount; i++) { + $<vals>$ = add_to_vals(data_string, + (void *) $1); + } + } + | array array + ; + expr : numeric | VARIABLE { $<string>$ = get_numeric_var($1); } @@ -418,15 +492,15 @@ expr : numeric ; args : /* empty */ - | LHB expr RHB { assign_arg(arg_static, $<string>2); } args - | numeric { assign_arg(arg_static, $1); } args - | STRING { assign_arg(arg_static, $1); } args - | BYTE { assign_arg(arg_byte, $1); } args - | PATH { assign_arg(arg_static, $1); } args - | FILENAME { assign_arg(arg_static, $1); } args - | VARNAME { assign_arg(arg_static, $1); } args - | VARIABLE { assign_arg(arg_var, $1); } args - | NULL_RET { assign_arg(arg_null, $1); } args + | LHB expr RHB { assign_arg(data_static, $<string>2); } args + | numeric { assign_arg(data_static, $1); } args + | STRING { assign_arg(data_static, $1); } args + | BYTE { assign_arg(data_byte, $1); } args + | PATH { assign_arg(data_static, $1); } args + | FILENAME { assign_arg(data_static, $1); } args + | VARNAME { assign_arg(data_static, $1); } args + | VARIABLE { assign_arg(data_var, $1); } args + | NULL_RET { assign_arg(data_null, $1); } args ; eol : EOL @@ -464,7 +538,7 @@ get_numeric_var(const char *var) if ((i = find_var_index(var)) < 0) err(1, "Variable %s is undefined", var); - if (vars[i].type != ret_number) + if (vars[i].type != data_number) err(1, "Variable %s is not a numeric type", var); return vars[i].value; @@ -512,21 +586,97 @@ perform_delay(struct timespec *ts) } /* + * Add to temporary vals array + */ +static wchar_t *add_to_vals(data_enum_t argtype, void *arg) +{ + wchar_t *retval = NULL; + int have_malloced; + int i; + ct_data_t *ret; + + have_malloced = 0; + + if (nvals == 0) { + have_malloced = 1; + retval = malloc(sizeof(wchar_t)); + } else { + retval = realloc(vals, (nvals + 1) * sizeof(wchar_t)); + } + + if (retval == NULL) + return retval; + + vals = retval; + + switch (argtype) { + case data_number: + vals[nvals++] = (wchar_t) strtoul((char *) arg, NULL, 10); + break; + + case data_string: + vals[nvals++] = (wchar_t) ((char *)arg)[0]; + break; + + case data_byte: + ret = (ct_data_t *) arg; + vals[nvals++] = *((wchar_t *) ret->data_value); + break; + + case data_var: + if ((i = find_var_index((char *) arg)) < 0) + err(1, "Variable %s is undefined at line %zu " + "of file %s", (char *) arg, line, cur_file); + + switch (vars[i].type) { + + case data_number: + case data_string: + case data_byte: + retval = add_to_vals(vars[i].type, vars[i].value); + break; + + default: + err(1, "Variable %s is not a valid type for cchar" + " at line %zu of file %s", (char *) arg, line, + cur_file); + break; + + } + break; + + default: + err(1, "add_to_vals: Unhandled type for vals array " + "at line %zu of file %s", line, cur_file); + + /* if we get here without a value then tidy up */ + if ((nvals == 0) && (have_malloced == 1)) { + free(retval); + retval = vals; + } + break; + + } + + return retval; +} + +/* * Assign the value given to the named variable. */ static void -set_var(returns_enum_t type, char *name, void *value) +set_var(data_enum_t type, char *name, void *value) { int i; char *number; - returns_t *ret; + ct_data_t *ret; i = find_var_index(name); if (i < 0) i = assign_var(name); vars[i].type = type; - if ((type == ret_number) || (type == ret_string)) { + if ((type == data_number) || (type == data_string)) { number = value; vars[i].len = strlen(number) + 1; vars[i].value = malloc(vars[i].len + 1); @@ -536,15 +686,48 @@ set_var(returns_enum_t type, char *name, } else { /* can only be a byte value */ ret = value; - vars[i].len = ret->return_len; + vars[i].len = ret->data_len; vars[i].value = malloc(vars[i].len); if (vars[i].value == NULL) err(1, "Could not malloc memory to assign byte string"); - memcpy(vars[i].value, ret->return_value, vars[i].len); + memcpy(vars[i].value, ret->data_value, vars[i].len); } } /* + * Form up a complex character type from the given components. + */ +static void +set_cchar(char *name, void *attributes) +{ + int i; + unsigned j; + attr_t attribs; + + if (nvals >= CURSES_CCHAR_MAX) + err(1, "%s: too many characters in complex char type at " + "line %zu of file %s", __func__, line, cur_file); + + i = find_var_index(name); + if (i < 0) + i = assign_var(name); + + if (sscanf((char *) attributes, "%d", &attribs) != 1) + err(1, "%s: conversion of attributes to integer failed at" + "line %zu of file %s", __func__, line, cur_file); + + vars[i].type = data_cchar; + vars[i].cchar.attributes = attribs; + vars[i].cchar.elements = nvals; + for (j = 0; j < nvals; j++) + vars[i].cchar.vals[j] = vals[j]; + + nvals = 0; + vals = NULL; + +} + +/* * Add a new variable to the vars array, the value will be assigned later, * when a test function call returns. */ @@ -576,42 +759,34 @@ assign_var(char *varname) * Allocate and assign a new argument of the given type. */ static void -assign_arg(args_state_t arg_type, void *arg) +assign_arg(data_enum_t arg_type, void *arg) { args_t *temp, cur; char *str = arg; - returns_t *ret; + ct_data_t *ret; if (verbose) { - fprintf(stderr, "function is >%s<, adding arg >%s< type %s\n", - command.function, str, args_enum_names[arg_type]); + fprintf(stderr, "function is >%s<, adding arg >%s< type %s (%d)\n", + command.function, str, enum_names[arg_type], arg_type); } cur.arg_type = arg_type; - switch (arg_type) { - case arg_var: + if (cur.arg_type == data_var) { cur.var_index = find_var_index(arg); if (cur.var_index < 0) err(1, "Invalid variable %s at line %zu of file %s", str, line, cur_file); - cur.arg_type = ret_string; - break; - - case arg_byte: + } else if (cur.arg_type == data_byte) { ret = arg; - cur.arg_len = ret->return_len; + cur.arg_len = ret->data_len; cur.arg_string = malloc(cur.arg_len); if (cur.arg_string == NULL) err(1, "Could not malloc memory for arg bytes"); - memcpy(cur.arg_string, ret->return_value, cur.arg_len); - break; - - case arg_null: + memcpy(cur.arg_string, ret->data_value, cur.arg_len); + } else if (cur.arg_type == data_null) { cur.arg_len = 0; cur.arg_string = NULL; - break; - - default: + } else { cur.arg_len = strlen(str); cur.arg_string = malloc(cur.arg_len + 1); if (cur.arg_string == NULL) @@ -631,46 +806,46 @@ assign_arg(args_state_t arg_type, void * * Allocate and assign a new return. */ static void -assign_rets(returns_enum_t ret_type, void *ret) +assign_rets(data_enum_t ret_type, void *ret) { - returns_t *temp, cur; + ct_data_t *temp, cur; char *ret_str; - returns_t *ret_ret; + ct_data_t *ret_ret; - cur.return_type = ret_type; - if (ret_type != ret_var) { - if ((ret_type == ret_number) || (ret_type == ret_string)) { + cur.data_type = ret_type; + if (ret_type != data_var) { + if ((ret_type == data_number) || (ret_type == data_string)) { ret_str = ret; - cur.return_len = strlen(ret_str) + 1; - cur.return_value = malloc(cur.return_len + 1); - if (cur.return_value == NULL) + cur.data_len = strlen(ret_str) + 1; + cur.data_value = malloc(cur.data_len + 1); + if (cur.data_value == NULL) err(1, "Could not malloc memory for arg string"); - strcpy(cur.return_value, ret_str); - } else if (ret_type == ret_byte) { + strcpy(cur.data_value, ret_str); + } else if (ret_type == data_byte) { ret_ret = ret; - cur.return_len = ret_ret->return_len; - cur.return_value = malloc(cur.return_len); - if (cur.return_value == NULL) + cur.data_len = ret_ret->data_len; + cur.data_value = malloc(cur.data_len); + if (cur.data_value == NULL) err(1, "Could not malloc memory for byte string"); - memcpy(cur.return_value, ret_ret->return_value, - cur.return_len); - } else if (ret_type == ret_ref) { - if ((cur.return_index = find_var_index(ret)) < 0) + memcpy(cur.data_value, ret_ret->data_value, + cur.data_len); + } else if (ret_type == data_ref) { + if ((cur.data_index = find_var_index(ret)) < 0) err(1, "Undefined variable reference"); } } else { - cur.return_index = find_var_index(ret); - if (cur.return_index < 0) - cur.return_index = assign_var(ret); + cur.data_index = find_var_index(ret); + if (cur.data_index < 0) + cur.data_index = assign_var(ret); } temp = realloc(command.returns, sizeof(*temp) * (command.nrets + 1)); if (temp == NULL) err(1, "Failed to reallocate returns"); command.returns = temp; - memcpy(&command.returns[command.nrets], &cur, sizeof(returns_t)); + memcpy(&command.returns[command.nrets], &cur, sizeof(ct_data_t)); command.nrets++; } @@ -864,7 +1039,7 @@ do_function_call(size_t nresults) int do_input; size_t i; struct pollfd fds[3]; - returns_t response[MAX_RESULTS], returns_count; + ct_data_t response[MAX_RESULTS], returns_count; assert(nresults <= MAX_RESULTS); do_input = check_function_table(command.function, input_functions, @@ -877,15 +1052,15 @@ do_function_call(size_t nresults) * doing input otherwise it will confuse the input poll */ read_cmd_pipe(&returns_count); - if (returns_count.return_type != ret_count) - err(2, "expected return type of ret_count but received %s", - returns_enum_names[returns_count.return_type]); + if (returns_count.data_type != data_count) + err(2, "expected return type of data_count but received %s", + enum_names[returns_count.data_type]); perform_delay(&delay_post_call); /* let slave catch up */ if (verbose) { fprintf(stderr, "Expect %zu results from slave, slave " - "reported %zu\n", nresults, returns_count.return_len); + "reported %zu\n", nresults, returns_count.data_len); } if ((no_input == false) && (do_input == 1)) { @@ -961,7 +1136,7 @@ do_function_call(size_t nresults) /* drain any trailing output */ save_slave_output(false); - for (i = 0; i < returns_count.return_len; i++) { + for (i = 0; i < returns_count.data_len; i++) { read_cmd_pipe(&response[i]); } @@ -971,42 +1146,42 @@ do_function_call(size_t nresults) * expect but in this case we should report the slave error * instead of a return count mismatch. */ - if ((returns_count.return_len > 0) && - (response[0].return_type == ret_slave_error)) + if ((returns_count.data_len > 0) && + (response[0].data_type == data_slave_error)) err(2, "Slave returned error: %s", - (const char *)response[0].return_value); + (const char *)response[0].data_value); - if (returns_count.return_len != nresults) + if (returns_count.data_len != nresults) err(2, "Incorrect number of returns from slave, expected %zu " - "but received %zu", nresults, returns_count.return_len); + "but received %zu", nresults, returns_count.data_len); if (verbose) { for (i = 0; i < nresults; i++) { - if ((response[i].return_type != ret_byte) && - (response[i].return_type != ret_err) && - (response[i].return_type != ret_ok)) + if ((response[i].data_type != data_byte) && + (response[i].data_type != data_err) && + (response[i].data_type != data_ok)) fprintf(stderr, "received response >%s< " "expected", - (const char *)response[i].return_value); + (const char *)response[i].data_value); else fprintf(stderr, "received"); - fprintf(stderr, " return_type %s\n", - returns_enum_names[command.returns[i].return_type]); + fprintf(stderr, " data_type %s\n", + enum_names[command.returns[i].data_type]); } } for (i = 0; i < nresults; i++) { - if (command.returns[i].return_type != ret_var) { + if (command.returns[i].data_type != data_var) { validate(i, &response[i]); } else { - vars[command.returns[i].return_index].len = - response[i].return_len; - vars[command.returns[i].return_index].value = - response[i].return_value; - vars[command.returns[i].return_index].type = - response[i].return_type; + vars[command.returns[i].data_index].len = + response[i].data_len; + vars[command.returns[i].data_index].value = + response[i].data_value; + vars[command.returns[i].data_index].type = + response[i].data_type; } } @@ -1031,7 +1206,7 @@ write_func_and_args(void) write_cmd_pipe(command.function); for (i = 0; i < command.nargs; i++) { - if (command.args[i].arg_type == arg_var) + if (command.args[i].arg_type == data_var) write_cmd_pipe_args(command.args[i].arg_type, &vars[command.args[i].var_index]); else @@ -1056,13 +1231,13 @@ init_parse_variables(int initial) if (initial == 0) { free(command.function); for (i = 0; i < command.nrets; i++) { - if (command.returns[i].return_type == ret_number) - free(command.returns[i].return_value); + if (command.returns[i].data_type == data_number) + free(command.returns[i].data_value); } free(command.returns); for (i = 0; i < command.nargs; i++) { - if (command.args[i].arg_type != arg_var) + if (command.args[i].arg_type != data_var) free(command.args[i].arg_string); } free(command.args); @@ -1110,52 +1285,52 @@ static void validate(int i, void *data) { char *response; - returns_t *byte_response; + ct_data_t *byte_response; byte_response = data; - if ((command.returns[i].return_type != ret_byte) && - (command.returns[i].return_type != ret_err) && - (command.returns[i].return_type != ret_ok)) { - if ((byte_response->return_type == ret_byte) || - (byte_response->return_type == ret_err) || - (byte_response->return_type == ret_ok)) + if ((command.returns[i].data_type != data_byte) && + (command.returns[i].data_type != data_err) && + (command.returns[i].data_type != data_ok)) { + if ((byte_response->data_type == data_byte) || + (byte_response->data_type == data_err) || + (byte_response->data_type == data_ok)) err(1, "%s: expecting type %s, received type %s" " at line %zu of file %s", __func__, - returns_enum_names[command.returns[i].return_type], - returns_enum_names[byte_response->return_type], + enum_names[command.returns[i].data_type], + enum_names[byte_response->data_type], line, cur_file); - response = byte_response->return_value; + response = byte_response->data_value; } - switch (command.returns[i].return_type) { - case ret_err: - validate_type(ret_err, byte_response, 0); + switch (command.returns[i].data_type) { + case data_err: + validate_type(data_err, byte_response, 0); break; - case ret_ok: - validate_type(ret_ok, byte_response, 0); + case data_ok: + validate_type(data_ok, byte_response, 0); break; - case ret_null: + case data_null: validate_return("NULL", response, 0); break; - case ret_nonnull: + case data_nonnull: validate_return("NULL", response, 1); break; - case ret_string: - case ret_number: - validate_return(command.returns[i].return_value, + case data_string: + case data_number: + validate_return(command.returns[i].data_value, response, 0); break; - case ret_ref: + case data_ref: validate_reference(i, response); break; - case ret_byte: + case data_byte: validate_byte(&command.returns[i], byte_response, 0); break; @@ -1173,29 +1348,29 @@ static void validate_reference(int i, void *data) { char *response; - returns_t *byte_response; + ct_data_t *byte_response; var_t *varp; - varp = &vars[command.returns[i].return_index]; + varp = &vars[command.returns[i].data_index]; byte_response = data; - if (command.returns[i].return_type != ret_byte) + if (command.returns[i].data_type != data_byte) response = data; if (verbose) { fprintf(stderr, "%s: return type of %s, value %s \n", __func__, - returns_enum_names[varp->type], + enum_names[varp->type], (const char *)varp->value); } switch (varp->type) { - case ret_string: - case ret_number: + case data_string: + case data_number: validate_return(varp->value, response, 0); break; - case ret_byte: + case data_byte: validate_byte(varp->value, byte_response, 0); break; @@ -1212,21 +1387,21 @@ validate_reference(int i, void *data) * if they don't match. */ static void -validate_type(returns_enum_t expected, returns_t *value, int check) +validate_type(data_enum_t expected, ct_data_t *value, int check) { - if (((check == 0) && (expected != value->return_type)) || - ((check == 1) && (expected == value->return_type))) + if (((check == 0) && (expected != value->data_type)) || + ((check == 1) && (expected == value->data_type))) err(1, "Validate expected type %s %s %s line %zu of file %s", - returns_enum_names[expected], + enum_names[expected], (check == 0)? "matching" : "not matching", - returns_enum_names[value->return_type], line, cur_file); + enum_names[value->data_type], line, cur_file); if (verbose) { fprintf(stderr, "Validate expected type %s %s %s line %zu" " of file %s\n", - returns_enum_names[expected], + enum_names[expected], (check == 0)? "matching" : "not matching", - returns_enum_names[value->return_type], line, cur_file); + enum_names[value->data_type], line, cur_file); } } @@ -1256,22 +1431,22 @@ validate_return(const char *expected, co * if they don't match expectations. */ static void -validate_byte(returns_t *expected, returns_t *value, int check) +validate_byte(ct_data_t *expected, ct_data_t *value, int check) { char *ch; size_t i; if (verbose) { - ch = value->return_value; + ch = value->data_value; fprintf(stderr, "checking returned byte stream: "); - for (i = 0; i < value->return_len; i++) + for (i = 0; i < value->data_len; i++) fprintf(stderr, "%s0x%x", (i != 0)? ", " : "", ch[i]); fprintf(stderr, "\n"); fprintf(stderr, "%s byte stream: ", (check == 0)? "matches" : "does not match"); - ch = (char *) expected->return_value; - for (i = 0; i < expected->return_len; i++) + ch = (char *) expected->data_value; + for (i = 0; i < expected->data_len; i++) fprintf(stderr, "%s0x%x", (i != 0)? ", " : "", ch[i]); fprintf(stderr, "\n"); } @@ -1279,20 +1454,20 @@ validate_byte(returns_t *expected, retur /* * No chance of a match if lengths differ... */ - if ((check == 0) && (expected->return_len != value->return_len)) + if ((check == 0) && (expected->data_len != value->data_len)) errx(1, "Byte validation failed, length mismatch, expected %zu," - "received %zu", expected->return_len, value->return_len); + "received %zu", expected->data_len, value->data_len); /* * If check is 0 then we want to throw an error IFF the byte streams * do not match, if check is 1 then throw an error if the byte * streams match. */ - if (((check == 0) && memcmp(expected->return_value, value->return_value, - value->return_len) != 0) || - ((check == 1) && (expected->return_len == value->return_len) && - memcmp(expected->return_value, value->return_value, - value->return_len) == 0)) + if (((check == 0) && memcmp(expected->data_value, value->data_value, + value->data_len) != 0) || + ((check == 1) && (expected->data_len == value->data_len) && + memcmp(expected->data_value, value->data_value, + value->data_len) == 0)) errx(1, "Validate expected %s byte stream at line %zu" "of file %s", (check == 0)? "matching" : "not matching", line, cur_file); @@ -1310,14 +1485,14 @@ validate_byte(returns_t *expected, retur * negated. */ static void -validate_variable(int ret, returns_enum_t type, const void *value, int i, +validate_variable(int ret, data_enum_t type, const void *value, int i, int check) { - returns_t *retval; + ct_data_t *retval; var_t *varptr; retval = &command.returns[ret]; - varptr = &vars[command.returns[ret].return_index]; + varptr = &vars[command.returns[ret].data_index]; if (varptr->value == NULL) err(1, "Variable %s has no value assigned to it", varptr->name); @@ -1326,7 +1501,7 @@ validate_variable(int ret, returns_enum_ if (varptr->type != type) err(1, "Variable %s is not the expected type", varptr->name); - if (type != ret_byte) { + if (type != data_byte) { if ((((check == 0) && strcmp(value, varptr->value) != 0)) || ((check == 1) && strcmp(value, varptr->value) == 0)) err(1, "Variable %s contains %s instead of %s" @@ -1343,7 +1518,7 @@ validate_variable(int ret, returns_enum_ (const char *)varptr->value, line, cur_file); } } else { - if ((check == 0) && (retval->return_len != varptr->len)) + if ((check == 0) && (retval->data_len != varptr->len)) err(1, "Byte validation failed, length mismatch"); /* @@ -1351,10 +1526,10 @@ validate_variable(int ret, returns_enum_ * the byte streams do not match, if check is 1 then * throw an error if the byte streams match. */ - if (((check == 0) && memcmp(retval->return_value, varptr->value, + if (((check == 0) && memcmp(retval->data_value, varptr->value, varptr->len) != 0) || - ((check == 1) && (retval->return_len == varptr->len) && - memcmp(retval->return_value, varptr->value, + ((check == 1) && (retval->data_len == varptr->len) && + memcmp(retval->data_value, varptr->value, varptr->len) == 0)) err(1, "Validate expected %s byte stream at line %zu" " of file %s", @@ -1385,7 +1560,7 @@ write_cmd_pipe(char *cmd) else len = strlen(cmd); - arg.arg_type = arg_static; + arg.arg_type = data_static; arg.arg_len = len; arg.arg_string = cmd; write_cmd_pipe_args(arg.arg_type, &arg); @@ -1393,7 +1568,7 @@ write_cmd_pipe(char *cmd) } static void -write_cmd_pipe_args(args_state_t type, void *data) +write_cmd_pipe_args(data_enum_t type, void *data) { var_t *var_data; args_t *arg_data; @@ -1402,18 +1577,30 @@ write_cmd_pipe_args(args_state_t type, v arg_data = data; switch (type) { - case arg_var: + case data_var: var_data = data; len = var_data->len; cmd = var_data->value; - if (type == arg_byte) - send_type = ret_byte; - else - send_type = ret_string; + + switch (var_data->type) { + case data_byte: + send_type = data_byte; + break; + + case data_cchar: + send_type = data_cchar; + cmd = (void *) &var_data->cchar; + len = sizeof(cchar_t); + break; + + default: + send_type = data_string; + break; + } break; - case arg_null: - send_type = ret_null; + case data_null: + send_type = data_null; len = 0; break; @@ -1423,22 +1610,27 @@ write_cmd_pipe_args(args_state_t type, v else len = arg_data->arg_len; cmd = arg_data->arg_string; - if (type == arg_byte) - send_type = ret_byte; + if (type == data_byte) + send_type = data_byte; else - send_type = ret_string; + send_type = data_string; } if (verbose) { fprintf(stderr, "Writing type %s to command pipe\n", - returns_enum_names[send_type]); + enum_names[send_type]); } if (write(cmdpipe[WRITE_PIPE], &send_type, sizeof(int)) < 0) err(1, "command pipe write for type failed"); if (verbose) { - fprintf(stderr, "Writing length %d to command pipe\n", len); + if (send_type == data_cchar) + fprintf(stderr, + "Writing cchar to command pipe\n"); + else + fprintf(stderr, + "Writing length %d to command pipe\n", len); } if (write(cmdpipe[WRITE_PIPE], &len, sizeof(int)) < 0) @@ -1459,7 +1651,7 @@ write_cmd_pipe_args(args_state_t type, v * length of the response then the actual data. */ static void -read_cmd_pipe(returns_t *response) +read_cmd_pipe(ct_data_t *response) { int len, type; struct pollfd rfd[2]; @@ -1493,45 +1685,45 @@ read_cmd_pipe(returns_t *response) if (read(slvpipe[READ_PIPE], &type, sizeof(int)) < 0) err(1, "command pipe read for type failed"); - response->return_type = type; + response->data_type = type; - if ((type != ret_ok) && (type != ret_err) && (type != ret_count)) { + if ((type != data_ok) && (type != data_err) && (type != data_count)) { if (read(slvpipe[READ_PIPE], &len, sizeof(int)) < 0) err(1, "command pipe read for length failed"); - response->return_len = len; + response->data_len = len; if (verbose) { fprintf(stderr, "Reading %d bytes from command pipe\n", len); } - if ((response->return_value = malloc(len + 1)) == NULL) + if ((response->data_value = malloc(len + 1)) == NULL) err(1, "Failed to alloc memory for cmd pipe read"); - if (read(slvpipe[READ_PIPE], response->return_value, len) < 0) + if (read(slvpipe[READ_PIPE], response->data_value, len) < 0) err(1, "command pipe read of data failed"); - if (response->return_type != ret_byte) { - str = response->return_value; + if (response->data_type != data_byte) { + str = response->data_value; str[len] = '\0'; if (verbose) { fprintf(stderr, "Read data >%s< from pipe\n", - (const char *)response->return_value); + (const char *)response->data_value); } } } else { - response->return_value = NULL; - if (type == ret_count) { + response->data_value = NULL; + if (type == data_count) { if (read(slvpipe[READ_PIPE], &len, sizeof(int)) < 0) err(1, "command pipe read for number of " "returns failed"); - response->return_len = len; + response->data_len = len; } if (verbose) { fprintf(stderr, "Read type %s from pipe\n", - returns_enum_names[type]); + enum_names[type]); } } } Index: src/tests/lib/libcurses/slave/commands.c diff -u src/tests/lib/libcurses/slave/commands.c:1.4 src/tests/lib/libcurses/slave/commands.c:1.5 --- src/tests/lib/libcurses/slave/commands.c:1.4 Thu Sep 15 11:46:19 2011 +++ src/tests/lib/libcurses/slave/commands.c Thu Sep 19 11:31:58 2019 @@ -1,4 +1,4 @@ -/* $NetBSD: commands.c,v 1.4 2011/09/15 11:46:19 blymn Exp $ */ +/* $NetBSD: commands.c,v 1.5 2019/09/19 11:31:58 blymn Exp $ */ /*- * Copyright 2009 Brett Lymn <bl...@netbsd.org> @@ -43,7 +43,7 @@ extern int cmdpipe[2]; extern int slvpipe[2]; -static void report_type(returns_enum_t); +static void report_type(data_enum_t); static void report_message(int, const char *); /* @@ -104,9 +104,9 @@ void report_return(int status) { if (status == ERR) - report_type(ret_err); + report_type(data_err); else if (status == OK) - report_type(ret_ok); + report_type(data_ok); else report_status("INVALID_RETURN"); } @@ -115,7 +115,7 @@ report_return(int status) * Report the type back to the director via the command pipe */ static void -report_type(returns_enum_t return_type) +report_type(data_enum_t return_type) { int type; @@ -133,7 +133,7 @@ report_count(int count) { int type; - type = ret_count; + type = data_count; if (write(slvpipe[WRITE_PIPE], &type, sizeof(int)) < 0) err(1, "command pipe write for count type failed"); @@ -147,7 +147,7 @@ report_count(int count) void report_status(const char *status) { - report_message(ret_string, status); + report_message(data_string, status); } /* @@ -156,7 +156,7 @@ report_status(const char *status) void report_error(const char *status) { - report_message(ret_slave_error, status); + report_message(data_slave_error, status); } /* @@ -212,7 +212,7 @@ report_nstr(chtype *string) len++; /* add in the termination chtype */ len *= sizeof(chtype); - type = ret_byte; + type = data_byte; if (write(slvpipe[WRITE_PIPE], &type, sizeof(int)) < 0) err(1, "%s: command pipe write for status type failed", __func__); Index: src/tests/lib/libcurses/slave/slave.c diff -u src/tests/lib/libcurses/slave/slave.c:1.6 src/tests/lib/libcurses/slave/slave.c:1.7 --- src/tests/lib/libcurses/slave/slave.c:1.6 Thu Sep 15 11:46:19 2011 +++ src/tests/lib/libcurses/slave/slave.c Thu Sep 19 11:31:58 2019 @@ -1,4 +1,4 @@ -/* $NetBSD: slave.c,v 1.6 2011/09/15 11:46:19 blymn Exp $ */ +/* $NetBSD: slave.c,v 1.7 2019/09/19 11:31:58 blymn Exp $ */ /*- * Copyright 2009 Brett Lymn <bl...@netbsd.org> @@ -67,7 +67,7 @@ process_commands(WINDOW *mainscr) if (read(cmdpipe[READ_PIPE], &type, sizeof(int)) < 0) err(1, "slave command type read failed"); - if (type != ret_string) + if (type != data_string) errx(1, "Unexpected type for command, got %d", type); if (read(cmdpipe[READ_PIPE], &len, sizeof(int)) < 0) @@ -102,7 +102,7 @@ process_commands(WINDOW *mainscr) "failed"); args = tmpargs; - if (type != ret_null) { + if (type != data_null) { args[argslen] = malloc(len + 1); if (args[argslen] == NULL) @@ -111,14 +111,14 @@ process_commands(WINDOW *mainscr) } if (len == 0) { - if (type == ret_null) + if (type == data_null) args[argslen] = NULL; else args[argslen][0] = '\0'; } else { read(cmdpipe[READ_PIPE], args[argslen], len); - if (type != ret_byte) + if (type != data_byte) args[argslen][len] = '\0'; if (len == 6) { Index: src/tests/lib/libcurses/tests/mutt_test diff -u src/tests/lib/libcurses/tests/mutt_test:1.1 src/tests/lib/libcurses/tests/mutt_test:1.2 --- src/tests/lib/libcurses/tests/mutt_test:1.1 Sun May 26 09:54:33 2019 +++ src/tests/lib/libcurses/tests/mutt_test Thu Sep 19 11:31:58 2019 @@ -44,9 +44,10 @@ input "j" call 106 getch call OK refresh call OK move 14 14 -call OK add_wch `\000\000\000\001\000H` -call OK add_wch `\000\000\000\001\000H` -call OK add_wch `\000\000\000\001\000H` +cchar HCHAR 0 "H" +call OK add_wch $HCHAR +call OK add_wch $HCHAR +call OK add_wch $HCHAR input "j" call 106 getch call OK refresh @@ -94,9 +95,9 @@ input "j" call 106 getch call OK refresh call OK move 14 14 -call OK add_wch `\000\000\000\001\000H` -call OK add_wch `\000\000\000\001\000H` -call OK add_wch `\000\000\000\001\000H` +call OK add_wch $HCHAR +call OK add_wch $HCHAR +call OK add_wch $HCHAR input "j" call 106 getch call OK refresh