Caller interface prototype.

From now on the caller object is used instead of response pointer. It is more failsafe, because the caller object acts like a Stream object.

Author: dani007200964

.vscode/settings.json

@@ -13,5 +13,6 @@
         "ios": "cpp",
         "xmemory": "cpp",
         "system_error": "cpp"
-    }
+    },
+    "C_Cpp.errorSquiggles": "disabled"
 }

CMakeLists.txt

@@ -49,6 +49,8 @@ set( SOURCES
     #src/Commander-Database.cpp
     src/Commander-Database.hpp
     src/Commander-DefaultSettings.hpp
+    src/Commander-Caller-Interface.hpp
+    src/Commander-Caller-Interface.cpp
 
     extras/simulator/Arduino.h
     extras/simulator/Print.cpp

extras/examples_desktop/Desktop/Memory/Memory.cpp

@@ -39,13 +39,21 @@ stdioStream stdioChannel;
 // We have to create an object from Commander class.
 Commander commander;
 
+bool cat_func( char *args, CommandCaller* caller );
+bool dog_func( char *args, CommandCaller* caller );
+bool sum_func( char *args, CommandCaller* caller );
+
 // Add echo and env commands to the API tree.
 Commander::systemCommand_t API_tree[] = {
-    SYSTEM_COMMAND_MEMDUMP
+    systemCommand( "cat", "Description for cat command.", cat_func ),
+    systemCommand( "dog", "Description for dog command.", dog_func ),
+    systemCommand( "sum", "This function sums two number from the argument list.", sum_func )    
 };
 
 char commandBuffer[ COMMAND_SIZE ];
 
+char pipeBuffer[ COMMANDER_PIPE_BUFFER_SIZE ];
+commanderPipeChannel pipeChannel;
 
 
 
@@ -74,10 +82,12 @@ int main(){
     // itself for the fastest runtime possible. It creates a balanced
     // binary tree from the API_tree to boost the search speed.
     // This part uses some recursion, to make the code space small.
-    // But recursion is a bit stack hungry, so please initialize
+    // But recursion is a bit stack hungry, so pleacatse initialize
     // Commander at the beginning of your code to prevent stack-overlow.
     commander.init();
 
+    commander.enablePipeModule( pipeBuffer, &pipeChannel );
+
     stdioChannel.println();
     stdioChannel.println( "---- Init Finished ----" );
     stdioChannel.println();
@@ -101,3 +111,62 @@ int main(){
     return 0;
 
 }
+
+
+/// This is an example function for the cat command
+bool cat_func( char *args, CommandCaller* caller ){
+
+  caller -> print("Hello from cat function!\r\n");
+  return true;
+
+}
+
+/// This is an example function for the dog command
+bool dog_func( char *args, CommandCaller* caller ){
+
+  caller -> print("Hello from dog function!\r\n");
+  return true;
+
+}
+
+/// This is an example function for the sum command
+bool sum_func( char *args, CommandCaller* caller ){
+
+  // These variables will hold the value of the
+  // two numbers, that has to be summed.
+  int a = 0;
+  int b = 0;
+
+  // This variable will hold the result of the
+  // argument parser.
+  int argResult;
+
+  // This variable will hold the sum result.
+  int sum = 0;
+
+  argResult = sscanf( args, "%d %d", &a, &b );
+
+  // We have to check that we parsed successfully the two
+  // numbers from the argument string.
+  if( argResult != 2 ){
+
+    // If we could not parse two numbers, we have an argument problem.
+    // We print out the problem to the response channel.
+    caller -> print( "Argument error! Two numbers required, separated with a blank space.\r\n" );
+
+    // Sadly we have to stop the command execution and return.
+    return false;
+
+  }
+
+  // Calculate the sum.
+  sum = a + b;
+
+  // Print out the result.
+  caller -> print( a );
+  caller -> print( " + " );
+  caller -> print( b );
+  caller -> print( " = " );
+  caller -> println( sum );
+    return true;
+}

src/Commander-API-Commands.hpp

@@ -54,6 +54,7 @@ SOFTWARE.
 
 #include "Commander-API.hpp"
 #include "Commander-Arguments.hpp"
+#include "Commander-Caller-Interface.hpp"
 
 void printCommandNotImplemented( Stream* channel_p );
 
@@ -462,7 +463,7 @@ bool commander_export_func( char *args, Stream *response, void* parent );
 /// Premade function for memDump command.
 /// @param args Pointer to the argument string.
 /// @param response Response channel for messages.
-bool commander_memDump_func( char *args, Stream *response, void* parent );
+bool commander_memDump_func( char *args, CommandCaller* caller );
 
 //-------- i2cScan function --------//
 #define SYSTEM_COMMAND_I2CSCAN_NAME         "i2cScan"

src/Commander-API.cpp

@@ -82,7 +82,7 @@ bool Commander::enablePipeModuleFunc( char* buffer, int bufferSize, commanderPip
     return true;
 }
 
-bool Commander::executeCommand( const char *cmd, void* parent ){
+bool Commander::executeCommand( const char *cmd ){
 
 	// The beginning of the argument list will be stored in this pointer
 	char *arg;
@@ -120,13 +120,13 @@ bool Commander::executeCommand( const char *cmd, void* parent ){
         // Check if piping is requested, but disabled.
         if( pipeArgBuffer == NULL ){
 
-            if( response != NULL ){
-                response -> print( __CONST_TXT__( "The command contains piping but the pipe module is disabled!" ) );
-            }
+            //if( caller -> channel != NULL ){
+                caller -> print( __CONST_TXT__( "The command contains piping but the pipe module is disabled!" ) );
+            //}
             return false;
         }
 
-		// Terminate where pip is found.
+		// Terminate where pipe is found.
 		tempBuff[ pipePos ] = '\0';
 
 	}
@@ -181,31 +181,31 @@ bool Commander::executeCommand( const char *cmd, void* parent ){
 
 			if( memoryType == MEMORY_REGULAR ){
 
-                if( response != NULL ){
+                //if( caller -> channel != NULL ){
 
                     // Print the description text to the output channel.
-                    response -> print( commandData_ptr -> name );
-                    response -> print( ':' );
-                    response -> print( ' ' );
-                    response -> println( commandData_ptr -> data.desc );
+                    caller -> print( commandData_ptr -> name );
+                    caller -> print( ':' );
+                    caller -> print( ' ' );
+                    caller -> println( commandData_ptr -> data.desc );
 
-                }
+                //}
 
 			}
 
 			#ifdef __AVR__
 
 			else if( memoryType == MEMORY_PROGMEM ){
 
-                if( response != NULL ){
+                //if( response != NULL ){
 
                     // Print the description text to the output channel.
-                    response -> print( commandData_ptr -> name_P );
-                    response -> print( ':' );
-                    response -> print( ' ' );
-                    response -> println( commandData_ptr -> data.desc_P );
+                    caller -> print( commandData_ptr -> name_P );
+                    caller -> print( ':' );
+                    caller -> print( ' ' );
+                    caller -> println( commandData_ptr -> data.desc_P );
 
-                }
+                //}
 
 			}
 
@@ -257,7 +257,10 @@ bool Commander::executeCommand( const char *cmd, void* parent ){
 			if( ( pipeArgBuffer != NULL ) && ( pipePos > 0 ) ){
 
 				// Execute commands function and redirect the output to the pipe channel.
-				executionStat = ( commandData_ptr -> data.func )( arg, pipeChannel, parent );
+                Stream* tmp = caller -> getChannel();
+                caller -> setChannel( pipeChannel );
+				executionStat = ( commandData_ptr -> data.func )( arg, caller );
+                caller -> setChannel( tmp );
 
                 // If the actual command execution was successful, we have to increment the pipeCounter
                 if( executionStat ){
@@ -271,7 +274,7 @@ bool Commander::executeCommand( const char *cmd, void* parent ){
 			else{
 
 				// Execute command function.
-				executionStat = ( commandData_ptr -> data.func )( arg, response, parent );
+				executionStat = ( commandData_ptr -> data.func )( arg, caller );
 
 			}
 
@@ -369,21 +372,21 @@ bool Commander::executeCommand( const char *cmd, void* parent ){
 		// We have to check for single or described help function.
 		if( strcmp( arg, (const char*)"-d" ) == 0 ){
 
-			printHelp( response, true, formatting );
+			printHelp( caller, true, formatting );
 
 		}
 
 		else{
 
-			printHelp( response, false, formatting );
+			printHelp( caller, false, formatting );
 
 		}
 
 	}
 
 	else{
 
-        if( response != NULL ){
+        //if( caller -> channel != NULL ){
             if( pipePos > 0 ){
 				tempBuff[ pipePos ] = '|';
                 printBrokenPipe();
@@ -395,45 +398,34 @@ bool Commander::executeCommand( const char *cmd, void* parent ){
 
             // If we went through the whole tree and we did not found the command in it,
             // we have to notice the user abut the problem. Maybe a Type-O
-            response -> print( __CONST_TXT__( "Command \'" ) );
-            response -> print( tempBuff );
-            response -> print( __CONST_TXT__( "\' not found!" ) );
+            caller -> print( __CONST_TXT__( "Command \'" ) );
+            caller -> print( tempBuff );
+            caller -> print( __CONST_TXT__( "\' not found!" ) );
 
-        }
+        //}
         return false;
 
 	}
     return true;
 }
 
-bool Commander::execute( const char *cmd ){
-
-	// Default execute handler, so the default response will be chosen.
-	response = NULL;
-
-    // Reset the pipe position tracker.
-    pipeCounter = 0;
+bool Commander::execute( const char *cmd, Stream* channel_p, CommandCaller* caller_p ){
 
-    // Save the address of the original message.
-    originalCommandData = cmd;
+    if( channel_p == NULL ){
+        caller = &defaultCommandCaller;
+        caller -> clearChannel();
+    }
 
-    // If piping is enabled, we have to flush the pipe channel before command execution.
-    if( pipeArgBuffer != NULL ){
-        while( pipeChannel -> available() ){
-            pipeChannel -> read();
+    else{
+        if( caller_p == NULL ){
+            caller = &defaultCommandCaller;
+            caller -> setChannel( channel_p );
+        }
+        else{
+            caller = caller_p;
         }
     }
 
-	// Execute the command.
-	return( executeCommand( cmd ) );
-
-}
-
-bool Commander::execute( const char *cmd, Stream *resp, void* parent ){
-
-    // Redirect the response to the specified Stream.
-	response = resp;
-
     // Reset the pipe position tracker.
     pipeCounter = 0;
 
@@ -448,7 +440,7 @@ bool Commander::execute( const char *cmd, Stream *resp, void* parent ){
     }
 
 	// Execute the command.
-	return( executeCommand( cmd, parent ) );
+	return( executeCommand( cmd ) );
 
 }
 
@@ -891,51 +883,51 @@ void Commander::printBrokenPipe(){
 
     if( brokenPipePos >= 0 ){
 
-        if( response != NULL ){
+        //if( caller -> channel != NULL ){
 
             // In case of broken pipe, inform the user about the problematic section.
             if( formatting ){
-                response -> print( __CONST_TXT__( "\033[1;35m" ) );
+                caller -> print( __CONST_TXT__( "\033[1;35m" ) );
             }
 
-            response -> println( __CONST_TXT__( "\r\nBroken pipe!" ) );
+            caller -> println( __CONST_TXT__( "\r\nBroken pipe!" ) );
 
             if( formatting ){
-                response -> print( __CONST_TXT__( "\033[0;37m" ) );
+                caller -> print( __CONST_TXT__( "\033[0;37m" ) );
             }
 
-            response -> println( originalCommandData );
+            caller -> println( originalCommandData );
 
             for( i = 0; i < brokenPipePos; i++ ){
-                response -> print( ' ' );
+                caller -> print( ' ' );
             }
 
             if( formatting ){
-                response -> print( __CONST_TXT__( "\033[1;31m" ) );
+                caller -> print( __CONST_TXT__( "\033[1;31m" ) );
             }
 
-            response -> println( "\u25B2" );
+            caller -> println( "\u25B2" );
 
             for( i = 0; i < brokenPipePos; i++ ){
-                response -> print( ' ' );
+                caller -> print( ' ' );
             }
 
-            response -> println( "\u2514 The pipe broke here" );
+            caller -> println( "\u2514 The pipe broke here" );
 
             if( formatting ){
-                response -> print( __CONST_TXT__( "\033[0;37m" ) );
+                caller -> print( __CONST_TXT__( "\033[0;37m" ) );
             }
 
             if( pipeChannel -> available() ){
-            	response -> print( __CONST_TXT__( "Pipe data: " ) );
+            	caller -> print( __CONST_TXT__( "Pipe data: " ) );
                 while( pipeChannel -> available() ){
-                	response -> print( (char)pipeChannel -> read() );
+                	caller -> print( (char)pipeChannel -> read() );
                 }
-            	response -> println();
+            	caller -> println();
 
             }
 
-        }
+        //}
 
     }