[[ Log ]] Implement log command

montegoulding · montegoulding · commit 70271623a352 · 2019-05-09T08:41:45.000+10:00
diff --git a/docs/dictionary/command/log.lcdoc b/docs/dictionary/command/log.lcdoc
@@ -0,0 +1,52 @@
+Name: log
+
+Type: command
+
+Syntax: log [ <argumentList> ]
+
+Summary:
+Invokes the <logMessage> if it is not empty.
+
+Introduced: 9.5
+
+OS: mac, windows, linux, ios, android, html5
+
+Platforms: desktop, server, mobile
+
+Example:
+on preOpenStack
+   -- uBuildMode property set before building standalone
+   if the uBuildMode of this stack is "release" then
+      set the logMessage to empty
+   end if
+   
+   loadResources
+end preOpenStack
+
+command loadResources
+   log "loading resources"
+end loadResources
+
+on log pInfo
+   -- unhandled put will go to system logs
+   put pInfo
+end log
+
+Parameters:
+argumentList:
+A comma separated list of expressions containing the arguments to send.
+Arrays are expressions and are valid to send as arguments.
+
+Description:
+The <log> command invokes the <logMessage> handler. When the <logMessage> is the
+default value of `log` then the <log> command behaves in the same way as any
+other scripted handler. If the <logMessage> is set to empty then the <log>
+command does not invoke any handler or evaluate parameters, therefore, allowing
+for many logs to be added to scripts for development and an easy low-cost method
+to turn the logging off for a release build. The <logMessage> may be set to any
+handler name, however, if the handler is not in the message path then use of the
+<log> command will throw a `can't find handler` error.
+
+References: log (command), put (command), msgChanged (message)
+
+Tags: debugging
diff --git a/engine/src/cmds.h b/engine/src/cmds.h
@@ -1020,6 +1020,26 @@ class MCDispatchCmd: public MCStatement
     virtual void exec_ctxt(MCExecContext &ctxt);
 };
 
+class MCLogCmd: public MCStatement
+{
+    MCParameter *params;
+    struct
+    {
+        unsigned container_count : 16;
+    };
+    
+public:
+    MCLogCmd(void)
+    {
+        params = nullptr;
+        container_count = 0;
+    }
+    ~MCLogCmd(void);
+    
+    virtual Parse_stat parse(MCScriptPoint& sp);
+    virtual void exec_ctxt(MCExecContext &ctxt);
+};
+
 class MCFocus : public MCStatement
 {
 	MCChunk *object;
diff --git a/engine/src/cmdse.cpp b/engine/src/cmdse.cpp
@@ -527,6 +527,101 @@ void MCDispatchCmd::exec_ctxt(MCExecContext &ctxt)
     MCKeywordsExecTeardownCommandOrFunction(params);
 }
 
+MCLogCmd::~MCLogCmd(void)
+{
+    while(params != NULL)
+    {
+        MCParameter *t_param;
+        t_param = params;
+        params = params -> getnext();
+        delete t_param;
+    }
+}
+
+Parse_stat MCLogCmd::parse(MCScriptPoint& sp)
+{
+    initpoint(sp);
+    
+    if (getparams(sp, &params) != PS_NORMAL)
+    {
+        MCperror -> add(PE_STATEMENT_BADPARAMS, sp);
+        return PS_ERROR;
+    }
+    
+    /* If there are any parameters then compute the number of containers needed
+     * to execute the command. */
+    if (params != nullptr)
+    {
+        container_count = params->count_containers();
+    }
+    
+    return PS_NORMAL;
+}
+
+// This method follows along the same lines as MCComref::exec
+void MCLogCmd::exec_ctxt(MCExecContext &ctxt)
+{
+    // no-op if logMessage is empty
+    if (MCNameIsEmpty(MClogmessage))
+    {
+        return;
+    }
+    
+    /* Attempt to allocate the number of containers needed for the call. */
+    MCAutoPointer<MCContainer[]> t_containers = new MCContainer[container_count];
+    if (!t_containers)
+    {
+        ctxt.LegacyThrow(EE_NO_MEMORY);
+        return;
+    }
+    
+    /* If the argument list is successfully evaluated, then do the dispatch. */
+    if (MCKeywordsExecSetupCommandOrFunction(ctxt,
+                                             params,
+                                             *t_containers,
+                                             line,
+                                             pos,
+                                             false))
+    {
+        if (!ctxt.HasError())
+        {
+            ctxt.SetLineAndPos(line, pos);
+            MCHandler * t_handler = nullptr;
+            MCKeywordsExecResolveCommandOrFunction(ctxt, MClogmessage, false, t_handler);
+            MCKeywordsExecCommandOrFunction(ctxt, t_handler, params, MClogmessage, line, pos, false, false);
+        }
+    }
+    
+    /* Clean up the evaluated argument list */
+    MCKeywordsExecTeardownCommandOrFunction(params);
+    
+    if (MCresultmode == kMCExecResultModeReturn)
+    {
+        // Do nothing!
+    }
+    else if (MCresultmode == kMCExecResultModeReturnValue)
+    {
+        // Set 'it' to the result and clear the result
+        MCAutoValueRef t_value;
+        if (!MCresult->eval(ctxt, &t_value))
+        {
+            ctxt.Throw();
+            return;
+        }
+        
+        ctxt.SetItToValue(*t_value);
+        ctxt.SetTheResultToEmpty();
+    }
+    else if (MCresultmode == kMCExecResultModeReturnError)
+    {
+        // Set 'it' to empty
+        ctxt.SetItToEmpty();
+        // Leave the result as is but make sure we reset the 'return mode' to default.
+        MCresultmode = kMCExecResultModeReturn;
+    }
+}
+
+
 Parse_stat MCMessage::parse(MCScriptPoint &sp)
 {
 	initpoint(sp);
diff --git a/engine/src/handler.cpp b/engine/src/handler.cpp
@@ -169,8 +169,9 @@ Parse_stat MCHandler::parse(MCScriptPoint &sp, Boolean isprop)
 	
 	const LT *te;
 	// MW-2010-01-08: [[Bug 7792]] Check whether the handler name is a reserved function identifier
+    // special case log command is a permitted handler name
 	if (t_type != ST_ID ||
-			sp.lookup(SP_COMMAND, te) != PS_NO_MATCH ||
+			(sp.lookup(SP_COMMAND, te) != PS_NO_MATCH && te -> which != S_LOG) ||
 			(sp.lookup(SP_FACTOR, te) != PS_NO_MATCH &&
 			te -> type == TT_FUNCTION))
 	{
diff --git a/engine/src/lextable.cpp b/engine/src/lextable.cpp
@@ -363,6 +363,7 @@ const LT command_table[] =
         {"load", TT_STATEMENT, S_LOAD},
         {"local", TT_STATEMENT, S_LOCAL},
         {"lock", TT_STATEMENT, S_LOCK},
+        {"log", TT_STATEMENT, S_LOG},
         {"mark", TT_STATEMENT, S_MARK},
         {"modal", TT_STATEMENT, S_MODAL},
         {"modeless", TT_STATEMENT, S_MODELESS},
diff --git a/engine/src/newobj.cpp b/engine/src/newobj.cpp
@@ -164,7 +164,9 @@ MCStatement *MCN_new_statement(int2 which)
 		return new MCLocalVariable;
 	case S_LOCK:
 		return new MCLock;
-	case S_MARK:
+    case S_LOG:
+        return new MCLogCmd;
+    case S_MARK:
 		return new MCMarkCommand;
 	case S_MODAL:
 		return new MCModal;
diff --git a/engine/src/parsedef.h b/engine/src/parsedef.h
@@ -2062,6 +2062,7 @@ enum Statements {
     S_LOCAL,
     S_LOAD,
     S_LOCK,
+    S_LOG,
     S_MARK,
     S_MODAL,
     S_MODELESS,
