/* tab:8

*

* adventure.c - main source file for ECE391 adventure game (F11 MP2)

*

* "Copyright (c) 2004-2011 by Steven S. Lumetta."

*

* Permission to use, copy, modify, and distribute this software and its

* documentation for any purpose, without fee, and without written agreement is

* hereby granted, provided that the above copyright notice and the following

* two paragraphs appear in all copies of this software.

*

* IN NO EVENT SHALL THE AUTHOR OR THE UNIVERSITY OF ILLINOIS BE LIABLE TO

* ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL

* DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,

* EVEN IF THE AUTHOR AND/OR THE UNIVERSITY OF ILLINOIS HAS BEEN ADVISED

* OF THE POSSIBILITY OF SUCH DAMAGE.

*

* THE AUTHOR AND THE UNIVERSITY OF ILLINOIS SPECIFICALLY DISCLAIM ANY

* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

* PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND NEITHER THE AUTHOR NOR

* THE UNIVERSITY OF ILLINOIS HAS ANY OBLIGATION TO PROVIDE MAINTENANCE,

* SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."

*

* Author: Steve Lumetta

* Version: 3

* Creation Date: Fri Sep 9 21:42:12 2011

* Filename: adventure.c

* History:

* SL 1 Fri Sep 9 21:42:12 2011

* First written (based on mazegame).

* SL 2 Wed Sep 14 01:27:29 2011

* Redesigned simple game loop to manage ticks and timing.

* SL 3 Wed Sep 14 20:57:22 2011

* Cleaned up code for distribution.

*/

#include <errno.h>

#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/time.h>

#include <time.h>

#include "assert.h"

#include "input.h"

#include "modex.h"

#include "photo.h"

#include "text.h"

#include "world.h"

/*

* If NDEBUG is not defined, we execute sanity checks to make sure that

* changes to enumerations, bit maps, etc., have been made consistently.

*/

#if defined(NDEBUG)

#define sanity_check() 0

#else

static int sanity_check (void);

#endif

/* a few constants */

#define TICK_USEC 50000 /* tick length in microseconds */

#define STATUS_MSG_LEN 40 /* maximum length of status message */

#define MOTION_SPEED 2 /* pixels moved per command */

/* outcome of the game */

typedef enum {GAME_WON, GAME_QUIT} game_condition_t;

/* structure used to hold game information */

typedef struct {

room_t* where; /* current room for player */

unsigned int map_x, map_y; /* current upper left display pixel */

int x_speed; /* number of pixels of x motion per move */

int y_speed; /* number of pixels of y motion per move */

} game_info_t;

/*

* enumerated values, structure, and static data used for parsing typed

* commands

*

* Note that the structure allows us to abbreviate commands and to create

* synonyms for verbs (e.g., get and grab).

*/

typedef enum { /* TC = typed command */

TC_BUY,

TC_CHARGE,

TC_DO,

TC_DRINK,

TC_DROP,

TC_FIX,

TC_FLASH,

TC_GET,

TC_GO,

TC_INSTALL,

TC_INVENTORY,

TC_SIGH,

TC_USE,

TC_WEAR,

NUM_TC_VALUES

} cmd_id_t;

typedef struct typed_cmd_t typed_cmd_t;

struct typed_cmd_t {

};

static const typed_cmd_t cmd_list[] = {

{"buy", 3, TC_BUY},

{"charge", 2, TC_CHARGE},

{"do", 2, TC_DO},

{"drink", 3, TC_DRINK},

{"drop", 2, TC_DROP},

{"fix", 3, TC_FIX},

{"flash", 5, TC_FLASH},

{"get", 1, TC_GET},

{"go", 2, TC_GO},

{"grab", 2, TC_GET},

{"install", 3, TC_INSTALL},

{"inventory", 1, TC_INVENTORY},

{"sigh", 4, TC_SIGH},

{"use", 3, TC_USE},

{"wear", 4, TC_WEAR},

{NULL, 0, 0}

};

/* local functions--see function headers for details */

static void cancel_status_thread (void* ignore);

static game_condition_t game_loop (void);

static int32_t handle_typing (void);

static void init_game (void);

static void move_photo_down (void);

static void move_photo_left (void);

static void move_photo_right (void);

static void move_photo_up (void);

static void redraw_room (void);

static void* status_thread (void* ignore);

static int time_is_after (struct timeval* t1, struct timeval* t2);

/* file-scope variables */

static game_info_t game_info; /* game information */

/*

* The variables below are used to keep track of the status message helper

* thread, with Posix thread id recorded in status_thread_id.

*

* The status_msg records the current status message: when the

* string recorded there is empty, no status message need be displayed, and

* the status bar should instead reflect the name of the current room and the

* player's typing (for typed commands).

*

* The status_msg is protected by the msg_lock mutex, which should be

* acquired before reading or writing the message. Further, if the message

* is changed, the helper thread must be notified by signaling it with the

* condition variable msg_cv (while holding the msg_lock).

*/

static pthread_t status_thread_id;

static pthread_mutex_t msg_lock = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t msg_cv = PTHREAD_COND_INITIALIZER;

static char status_msg[STATUS_MSG_LEN + 1] = {'\0'};

/*

* cancel_status_thread

* DESCRIPTION: Terminates the status message helper thread. Used as

* a cleanup method to ensure proper shutdown.

* INPUTS: none (ignored)

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: none

*/

static void

cancel_status_thread (void* ignore)

{

(void)pthread_cancel (status_thread_id);

}

/*

* game_loop

* DESCRIPTION: Main event loop for the adventure game.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: GAME_QUIT if the player quits, or GAME_WON if they have won

* SIDE EFFECTS: drives the display, etc.

*/

static game_condition_t

game_loop ()

{

/*

* Variables used to carry information between event loop ticks; see

* initialization below for explanations of purpose.

*/

struct timeval start_time, tick_time;

struct timeval cur_time; /* current time (during tick) */

cmd_t cmd; /* command issued by input control */

int32_t enter_room; /* player has changed rooms */

/* Record the starting time--assume success. */

(void)gettimeofday (&start_time, NULL);

/* Calculate the time at which the first event loop tick should occur. */

tick_time = start_time;

if ((tick_time.tv_usec += TICK_USEC) > 1000000) {

tick_time.tv_sec++;

tick_time.tv_usec -= 1000000;

}

/* The player has just entered the first room. */

enter_room = 1;

/* The main event loop. */

while (1) {

/*

* Update the screen, preparing the VGA palette and photo-drawing

* routines and drawing a new room photo first if the player has

* entered a new room, then showing the screen (and status bar,

* once you have it working).

*/

if (enter_room) {

/* Reset the view window to (0,0). */

game_info.map_x = game_info.map_y = 0;

set_view_window (game_info.map_x, game_info.map_y);

/* Discard any partially-typed command. */

reset_typed_command ();

/* Adjust colors and photo drawing for the current room photo. */

prep_room (game_info.where);

/* Draw the room (calls show. */

redraw_room ();

/* Only draw once on entry. */

enter_room = 0;

}

show_screen ();

//lock status_msg to prevent changes

(void)pthread_mutex_lock (&msg_lock);

room_t* curr_room = game_info.where; // This is the current room pointer

// Now call fill_status_bar with all the possible strings as params

fill_status_bar(room_name(curr_room), get_typed_command(), status_msg);

(void)pthread_mutex_unlock (&msg_lock); //unlock

// Calculate game time

display_time_on_tux (cur_time.tv_sec - start_time.tv_sec);

/*

* Wait for tick. The tick defines the basic timing of our

* event loop, and is the minimum amount of time between events.

*/

do {

if (gettimeofday (&cur_time, NULL) != 0) {

/* Panic! (should never happen) */

clear_mode_X ();

shutdown_input ();

perror ("gettimeofday");

exit (3);

}

} while (!time_is_after (&cur_time, &tick_time));

/*

* Advance the tick time. If we missed one or more ticks completely,

* i.e., if the current time is already after the time for the next

* tick, just skip the extra ticks and advance the clock to the one

* that we haven't missed.

*/

do {

if ((tick_time.tv_usec += TICK_USEC) > 1000000) {

tick_time.tv_sec++;

tick_time.tv_usec -= 1000000;

}

} while (time_is_after (&cur_time, &tick_time));

/*

* Handle asynchronous events. These events use real time rather

* than tick counts for timing, although the real time is rounded

* off to the nearest tick by definition.

*/

/* (none right now...) */

/*

* Handle synchronous events--in this case, only player commands.

* Note that typed commands that move objects may cause the room

* to be redrawn.

*/

cmd = get_command ();

switch (cmd) {

case CMD_UP: move_photo_down (); break;

case CMD_RIGHT: move_photo_left (); break;

case CMD_DOWN: move_photo_up (); break;

case CMD_LEFT: move_photo_right (); break;

case CMD_MOVE_LEFT:

enter_room = (TC_CHANGE_ROOM ==

try_to_move_left (&game_info.where));

break;

case CMD_ENTER:

enter_room = (TC_CHANGE_ROOM ==

try_to_enter (&game_info.where));

break;

case CMD_MOVE_RIGHT:

enter_room = (TC_CHANGE_ROOM ==

try_to_move_right (&game_info.where));

break;

case CMD_TYPED:

if (handle_typing ()) {

enter_room = 1;

}

break;

case CMD_QUIT: return GAME_QUIT;

default: break;

}

// Repeat the same thing for the tux

cmd = get_tux_command();

switch (cmd) {

case CMD_UP: move_photo_down (); break;

case CMD_RIGHT: move_photo_left (); break;

case CMD_DOWN: move_photo_up (); break;

case CMD_LEFT: move_photo_right (); break;

case CMD_MOVE_LEFT:

enter_room = (TC_CHANGE_ROOM ==

try_to_move_left (&game_info.where));

break;

case CMD_ENTER:

enter_room = (TC_CHANGE_ROOM ==

try_to_enter (&game_info.where));

break;

case CMD_MOVE_RIGHT:

enter_room = (TC_CHANGE_ROOM ==

try_to_move_right (&game_info.where));

break;

case CMD_QUIT: return GAME_QUIT;

default: break;

}

/* If player wins the game, their room becomes NULL. */

if (NULL == game_info.where) {

return GAME_WON;

}

} /* end of the main event loop */

}

/*

* handle_typing

* DESCRIPTION: Parse and execute a typed command.

* INPUTS: none (reads typed command)

* OUTPUTS: none

* RETURN VALUE: 1 if the player's room changes, 0 otherwise

* SIDE EFFECTS: may move the player, move objects, and/or redraw the screen

*/

static int32_t

handle_typing ()

{

const char* cmd; /* command verb typed */

int32_t cmd_len; /* length of command verb */

const char* arg; /* argument given to command verb */

int32_t idx; /* loop index over command list */

tc_action_t result; /* result of typed command execution */

/* Read the command and strip leading spaces. If it's empty, return. */

cmd = get_typed_command ();

while (' ' == *cmd) { cmd++; }

if ('\0' == *cmd) { return 0; }

/*

* Walk over the command verb, calculating its length as we go. Space

* or NUL marks the end of the verb, after which the argument begins.

* Leading spaces are first stripped from the argument, but we make no

* attempt to deal with trailing spaces (argument names must match

* exactly).

*/

for (cmd_len = 0; ' ' != cmd[cmd_len] && '\0' != cmd[cmd_len]; cmd_len++);

arg = &cmd[cmd_len];

while (' ' == *arg) { arg++; }

/* Compare the typed verb with each command in our list. */

for (idx = 0; NULL != cmd_list[idx].name; idx++) {

/* If the typed verb is not long enough, it can't match. */

if (cmd_list[idx].min_len > cmd_len) { continue; }

/* Compare the prefix of the command with the typed verb. */

if (0 != strncasecmp (cmd_list[idx].name, cmd, cmd_len)) { continue; }

/* Execute the command found. */

switch (cmd_list[idx].cmd) {

case TC_BUY:

result = typed_cmd_buy (&game_info.where, arg);

break;

case TC_CHARGE:

result = typed_cmd_charge (&game_info.where, arg);

break;

case TC_DO:

result = typed_cmd_do (&game_info.where, arg);

break;

case TC_DRINK:

result = typed_cmd_drink (&game_info.where, arg);

break;

case TC_DROP:

result = typed_cmd_drop (&game_info.where, arg);

if (!player_has_board ()) {

game_info.x_speed = MOTION_SPEED;

}

if (!player_has_jetpack ()) {

game_info.y_speed = MOTION_SPEED;

}

break;

case TC_FIX:

result = typed_cmd_fix (&game_info.where, arg);

break;

case TC_FLASH:

result = typed_cmd_flash (&game_info.where, arg);

break;

case TC_GET:

result = typed_cmd_get (&game_info.where, arg);

if (player_has_board ()) {

game_info.x_speed = MOTION_SPEED * 3;

}

if (player_has_jetpack ()) {

game_info.y_speed = MOTION_SPEED * 3;

}

break;

case TC_GO:

result = typed_cmd_go (&game_info.where, arg);

break;

case TC_INSTALL:

result = typed_cmd_install (&game_info.where, arg);

break;

case TC_INVENTORY:

result = typed_cmd_inventory (&game_info.where, arg);

break;

case TC_SIGH:

result = typed_cmd_sigh (&game_info.where, arg);

break;

case TC_USE:

result = typed_cmd_use (&game_info.where, arg);

break;

case TC_WEAR:

result = typed_cmd_wear (&game_info.where, arg);

break;

default:

show_status ("Bug...!");

result = TC_ALLOW_EDIT;

break;

}

/* Handle command result and return. */

if (TC_CHANGE_ROOM == result) {

return 1;

}

if (TC_ALLOW_EDIT != result) {

reset_typed_command ();

if (TC_REDRAW_ROOM == result) {

redraw_room ();

}

}

return 0;

}

/* The command was not recognized. */

show_status ("What are you babbling about?");

return 0;

}

/*

* init_game

* DESCRIPTION: Initialize the game information, including the initial

* room, photo display, motion speed, and so forth.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: none

*/

static void

init_game ()

{

game_info.where = start_in_room ();

game_info.map_x = 0;

game_info.map_y = 0;

game_info.x_speed = MOTION_SPEED;

game_info.y_speed = MOTION_SPEED;

}

/*

* move_photo_down

* DESCRIPTION: Move background photo down one or more pixels. Amount of

* motion depends on game_info.y_speed. Movement stops at

* upper edge of photo.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: shifts view window

*/

static void

move_photo_down ()

{

int32_t delta; /* Number of pixels by which to move. */

int32_t idx; /* Index over rows to redraw. */

/* Calculate the number of pixels by which to move. */

delta = (game_info.y_speed > game_info.map_y ?

game_info.map_y : game_info.y_speed);

/* Shift the logical view upward. */

game_info.map_y -= delta;

set_view_window (game_info.map_x, game_info.map_y);

/* Draw the newly exposed lines. */

for (idx = 0; delta > idx; idx++) {

(void)draw_horiz_line (idx);

}

}

/*

* move_photo_left

* DESCRIPTION: Move background photo left one or more pixels. Amount of

* motion depends on game_info.x_speed. Movement stops at

* right edge of photo.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: shifts view window

*/

static void

move_photo_left ()

{

int32_t delta; /* Number of pixels by which to move. */

int32_t idx; /* Index over columns to redraw. */

/* Calculate the number of pixels by which to move. */

delta = room_photo_width (game_info.where) - SCROLL_X_DIM -

game_info.map_x;

delta = (game_info.x_speed > delta ? delta : game_info.x_speed);

/* Shift the logical view to the right. */

game_info.map_x += delta;

set_view_window (game_info.map_x, game_info.map_y);

/* Draw the newly exposed lines. */

for (idx = 1; delta >= idx; idx++) {

(void)draw_vert_line (SCROLL_X_DIM - idx);

}

}

/*

* move_photo_right

* DESCRIPTION: Move background photo right one or more pixels. Amount of

* motion depends on game_info.x_speed. Movement stops at

* left edge of photo.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: shifts view window

*/

static void

move_photo_right ()

{

int32_t delta; /* Number of pixels by which to move. */

int32_t idx; /* Index over columns to redraw. */

/* Calculate the number of pixels by which to move. */

delta = (game_info.x_speed > game_info.map_x ?

game_info.map_x : game_info.x_speed);

/* Shift the logical view to the left. */

game_info.map_x -= delta;

set_view_window (game_info.map_x, game_info.map_y);

/* Draw the newly exposed lines. */

for (idx = 0; delta > idx; idx++) {

(void)draw_vert_line (idx);

}

}

/*

* move_photo_up

* DESCRIPTION: Move background photo up one or more pixels. Amount of

* motion depends on game_info.y_speed. Movement stops at

* lower edge of photo.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: shifts view window

*/

static void

move_photo_up ()

{

int32_t delta; /* Number of pixels by which to move. */

int32_t idx; /* Index over rows to redraw. */

/* Calculate the number of pixels by which to move. */

delta = room_photo_height (game_info.where) - SCROLL_Y_DIM -

game_info.map_y;

delta = (game_info.y_speed > delta ? delta : game_info.y_speed);

/* Shift the logical view upward. */

game_info.map_y += delta;

set_view_window (game_info.map_x, game_info.map_y);

/* Draw the newly exposed lines. */

for (idx = 1; delta >= idx; idx++) {

(void)draw_horiz_line (SCROLL_Y_DIM - idx);

}

}

/*

* redraw_room

* DESCRIPTION: Draw all lines on the screen.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: Draws the entire screen (but not the status bar).

*/

static void

redraw_room ()

{

int32_t i; /* index over rows */

/* Draw all lines in the scroll region. */

for (i = 0; i < SCROLL_Y_DIM; i++) {

(void)draw_horiz_line (i);

}

}

/*

* status_thread

* DESCRIPTION: Function executed by status message helper thread.

* Waits for a message to be displayed, then shows the

* message for 1.5 seconds before deleting it. If a

* new message has appeared in the meantime, restarts the

* clock and tries again.

* INPUTS: none (ignored)

* OUTPUTS: none

* RETURN VALUE: NULL

* SIDE EFFECTS: Changes the status message to an empty string.

*/

static void*

status_thread (void* ignore)

{

struct timespec ts; /* absolute wake-up time */

while (1) {

/*

* Wait for a message to appear. Note that we must check the

* condition after acquiring the lock, and that pthread_cond_wait

* yields the lock, then reacquires the lock before returning.

*/

(void)pthread_mutex_lock (&msg_lock);

while ('\0' == status_msg[0]) {

pthread_cond_wait (&msg_cv, &msg_lock);

}

/*

* A message is present: if we stop before the timeout

* passes, assume that a new one has been posted; if the

* timeout passes, clear the message and wait for a new one.

*/

do {

/* Get the current time. */

clock_gettime (CLOCK_REALTIME, &ts);

/* Add 1.5 seconds to it. */

if (500000000 <= ts.tv_nsec) {

ts.tv_sec += 2;

ts.tv_nsec -= 500000000;

} else {

ts.tv_sec += 1;

ts.tv_nsec += 500000000;

}

/*

* And go to sleep. If we wake up due to anything but a

* timeout, we assume (possibly incorrectly) that a new

* message has appeared and try to wait 1.5 seconds again.

*/

} while (ETIMEDOUT !=

pthread_cond_timedwait (&msg_cv, &msg_lock, &ts));

/*

* Clear the message, then release the lock (remember that

* pthread_cond_timedwait reacquires the lock before returning).

*/

status_msg[0] = '\0';

(void)pthread_mutex_unlock (&msg_lock);

}

/* This code never executes--the thread should always be cancelled. */

return NULL;

}

/*

* time_is_after

* DESCRIPTION: Check whether one time is at or after a second time.

* INPUTS: t1 -- the first time

* t2 -- the second time

* OUTPUTS: none

* RETURN VALUE: 1 if t1 >= t2

* 0 if t1 < t2

* SIDE EFFECTS: none

*/

static int

time_is_after (struct timeval* t1, struct timeval* t2)

{

if (t1->tv_sec == t2->tv_sec)

return (t1->tv_usec >= t2->tv_usec);

if (t1->tv_sec > t2->tv_sec)

return 1;

return 0;

}

/*

* show_status (interface function; declared in world.h)

* DESCRIPTION: Show a specific status message of up to STATUS_MSG_LEN

* characters.

* INPUTS: s -- the string used for the status message

* OUTPUTS: none

* RETURN VALUE: none

* SIDE EFFECTS: Overwrites any previous message.

*/

void

show_status (const char* s)

{

/* msg_lock critical section starts here. */

(void)pthread_mutex_lock (&msg_lock);

/* Copy the new message under the protection of msg_lock. */

strncpy (status_msg, s, STATUS_MSG_LEN);

status_msg[STATUS_MSG_LEN] = '\0';

/*

* Wake up the status message helper thread. Note that we still hold

* the msg_lock, so the thread can't wake up until we release it.

*/

(void)pthread_cond_signal (&msg_cv);

/* msg_lock critical section ends here. */

(void)pthread_mutex_unlock (&msg_lock);

}

/*

* main

* DESCRIPTION: Play the adventure game.

* INPUTS: none (command line arguments are ignored)

* OUTPUTS: none

* RETURN VALUE: 0 on success, 3 in panic situations

*/

int

main ()

{

game_condition_t game; /* outcome of playing */

/* Randomize for more fun (remove for deterministic layout). */

srand (time (NULL));

/* Provide some protection against fatal errors. */

clean_on_signals ();

if (!build_world ()) {PANIC ("can't build world");}

init_game ();

/* Perform sanity checks. */

if (0 != sanity_check ()) {

PANIC ("failed sanity checks");

}

/* Create status message thread. */

if (0 != pthread_create (&status_thread_id, NULL, status_thread, NULL)) {

PANIC ("failed to create status thread");

}

push_cleanup (cancel_status_thread, NULL); {

/* Start mode X. */

if (0 != set_mode_X (fill_horiz_buffer, fill_vert_buffer)) {

PANIC ("cannot initialize mode X");

}

push_cleanup ((cleanup_fn_t)clear_mode_X, NULL); {

/* Initialize the keyboard and/or Tux controller. */

if (0 != init_input ()) {

PANIC ("cannot initialize input");

}

push_cleanup ((cleanup_fn_t)shutdown_input, NULL); {

game = game_loop ();

} pop_cleanup (1);

} pop_cleanup (1);

} pop_cleanup (1);

/* Print a message about the outcome. */

switch (game) {

case GAME_WON: printf ("You win the game! CONGRATULATIONS!\n"); break;

case GAME_QUIT: printf ("Quitter!\n"); break;

}

/* Return success. */

return 0;

}

#if !defined(NDEBUG)

/*

* sanity_check

* DESCRIPTION: Perform checks on changes to constants and enumerated values.

* INPUTS: none

* OUTPUTS: none

* RETURN VALUE: 0 if checks pass, -1 if any fail

* SIDE EFFECTS: none

*/

static int

sanity_check ()

{

int32_t cnt[NUM_TC_VALUES]; /* count of synonymous commands */

int32_t idx; /* index over list of typed commands */

int32_t ret_val; /* return value */

/* Initialize return value. */

ret_val = 0;

/* Check typed command list. */

(void)memset (cnt, 0, sizeof (cnt));

for (idx = 0; NULL != cmd_list[idx].name; idx++) {

if (1 > cmd_list[idx].min_len) {

fprintf (stderr, "Typed command %s always matches.\n",

cmd_list[idx].name);

ret_val = -1;

continue;

}

if (cmd_list[idx].min_len > strlen (cmd_list[idx].name)) {

fprintf (stderr, "Typed command %s can never match.\n",

cmd_list[idx].name);

ret_val = -1;

continue;

}

if (0 > cmd_list[idx].cmd || NUM_TC_VALUES <= cmd_list[idx].cmd) {

fprintf (stderr, "Typed command %s has invalid command number.\n",

cmd_list[idx].name);

ret_val = -1;

continue;

}

cnt[cmd_list[idx].cmd]++;

}

/*

* Now check that every typed command can be issued with some string.

* We could be fancier and check that it's possible to match (shadowing

* can prevent it: matching "a" in entry #1 prevents matching "an" in

* entry #2.).

*/

for (idx = 0; NUM_TC_VALUES > idx; idx++) {

if (0 == cnt[idx]) {

fprintf (stderr, "TC_ #%d has no valid command strings.\n", idx);

ret_val = -1;

}

}

/* Return success/failure. */

return ret_val;

}

#endif /* !defined(NDEBUG) */