Merge branch 'command-dispatch'

Author: sourrust

src/commands.c

@@ -9,27 +9,48 @@
 
 static const char* quit_matches[] = {"quit", "q", NULL};
 static const char* help_matches[] = {"help", "?", NULL};
-
-/* Debugger commands */
 static const char* debug_info_matches[] = {"info", NULL};
 
-static void print_commands_help() {
+static void handle_quit(struct LacoState* laco, const char** arguments) {
+  laco_kill(laco, 0, "Exiting laco...");
+}
+
+static void handle_help(struct LacoState* laco, const char** arguments) {
   puts("  Commands available:\n");
   puts("    :quit, :q     \tExit laco");
   puts("    :help, :?     \tDisplay this list of commands");
   puts("    :info <name>  \tShow information on given function");
 }
 
-static inline bool is_quit(const char* command) {
-  return laco_is_match(quit_matches, command);
+static void handle_debug_info(struct LacoState* laco,
+                              const char** arguments) {
+  laco_print_debug_info(laco, arguments[0]);
 }
 
-static inline bool is_help(const char* command) {
-  return laco_is_match(help_matches, command);
-}
+static const struct LacoCommand line_commands[] = {
+  { quit_matches, handle_quit },
+  { help_matches, handle_help },
+
+  /* Debugger commands */
+  { debug_info_matches, handle_debug_info },
+
+  { NULL, NULL }
+};
 
-static inline bool is_debug_info(const char* command) {
-  return laco_is_match(debug_info_matches, command);
+/* External API */
+
+void laco_dispatch(const struct LacoCommand* commands,
+                   struct LacoState* laco, const char* command_keyword,
+                   const char** arguments) {
+  int i;
+  const char** matches;
+
+  for(i = 0; (matches = commands[i].matches); i++) {
+    if(laco_is_match(matches, command_keyword)) {
+      commands[i].handler(laco, arguments);
+      break;
+    }
+  }
 }
 
 void laco_handle_command(struct LacoState* laco, char* line) {
@@ -41,13 +62,7 @@ void laco_handle_command(struct LacoState* laco, char* line) {
     const char* command    = command_words[0];
     const char** arguments = (const char**) command_words + 1;
 
-    if(is_quit(command)) {
-      laco_kill(laco, 0, "Exiting laco...");
-    } else if(is_help(command))  {
-      print_commands_help();
-    } else if(is_debug_info(command)) {
-      laco_print_debug_info(laco, arguments[0]);
-    }
+    laco_dispatch(line_commands, laco, command, arguments);
 
     free(command_line);
     free(command_words);

src/commands.h

@@ -3,6 +3,24 @@
 
 struct LacoState;
 
+typedef void (*LacoHandler)(struct LacoState* laco, const char** arguments);
+
+struct LacoCommand {
+  const char** matches;
+  LacoHandler handler;
+};
+
+/**
+ * Goes through each instance from the list of commands and see if there is
+ * a match with for command_keyword. When there is a match, the defined
+ * handler inside the LacoCommand gets called -- passing in LacoState and
+ * the arguments. The list of commands expects the last entry of the array
+ * to be `{ NULL, NULL }` for ease of iteration.
+ */
+void laco_dispatch(const struct LacoCommand* commands,
+                   struct LacoState* laco, const char* command_keyword,
+                   const char** arguments);
+
 /**
  * Gets passed ever line to see if it matches one of the REPL command. If it
  * does, that command will be executed.

src/flags.c

@@ -2,37 +2,23 @@
 
 #include <stdio.h>
 
+#include "commands.h"
 #include "laco.h"
 #include "util.h"
 
-enum LacoFlags {
-  LACO_HELP,
-  LACO_VERSION
-};
-
 static const char* version_matches[] = {"-v", "--version", NULL};
 static const char* help_matches[]    = {"-h", "-?", "--help", NULL};
 
-/* Check if the command flag is for version */
-static inline bool is_version(const char* arg) {
-  return laco_is_match(version_matches, arg);
-}
-
-/* Check if the command flag is for help */
-static inline bool is_help(const char* arg) {
-  return laco_is_match(help_matches, arg);
-}
-
 /* Print off the current version of laco */
-static void print_version(LacoState* laco) {
+static void handle_version(LacoState* laco, const char** arguments) {
   const char* version = laco_get_laco_version(laco);
 
   printf("laco version %s\n", version);
   laco_kill(laco, 0, NULL);
 }
 
 /* Print off the help screen */
-static void print_help(LacoState* laco) {
+static void handle_help(LacoState* laco, const char** arguments) {
   puts("A better REPL for Lua.\n");
   puts("Usage: laco [options]\n");
   puts("-h | -? | --help   \tPrint this help screen");
@@ -41,25 +27,16 @@ static void print_help(LacoState* laco) {
   laco_kill(laco, 0, NULL);
 }
 
+static const struct LacoCommand flag_commands[] = {
+  { version_matches, handle_version },
+  { help_matches,    handle_help },
+  { NULL, NULL}
+};
+
 /* External API */
 
 void laco_handle_flag(LacoState* laco) {
-  int arg_type;
-  const char* arg = laco_get_laco_args(laco)[1];
-  if(arg == NULL) return;
-
-  if(is_version(arg)) {
-    arg_type = LACO_VERSION;
-  } else if(is_help(arg)) {
-    arg_type = LACO_HELP;
-  }
+  const char* command = laco_get_laco_args(laco)[1];
 
-  switch(arg_type) {
-    case LACO_VERSION:
-      print_version(laco);
-    case LACO_HELP:
-      print_help(laco);
-    default:
-      break;
-  }
+  laco_dispatch(flag_commands, laco, command, NULL);
 }

src/util/line.c

@@ -112,6 +112,8 @@ static bool pushline(LacoState* laco, bool isFirstLine) {
   return result;
 }
 
+/* External API */
+
 bool laco_load_line(LacoState* laco) {
   int status   = laco_get_laco_status(laco);
   lua_State* L = laco_get_laco_lua_state(laco);

src/util/print.c

@@ -77,7 +77,7 @@ static void print_table(lua_State* L) {
   lua_pop(L, 1);
 }
 
-/* External API*/
+/* External API */
 
 int laco_print_type(LacoState* laco) {
   lua_State* L = laco_get_laco_lua_state(laco);