@jdeighan/coffee-utils 7.0.57 → 7.0.60

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "7.0.57",
+	"version": "7.0.60",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {

package/src/call_stack.coffee

@@ -1,7 +1,7 @@
 # call_stack.coffee
 
 import {
-	undef, defined, croak, assert, OL, isBoolean, escapeStr,
+	undef, defined, croak, assert, OL, isBoolean, escapeStr, deepCopy,
 	} from '@jdeighan/coffee-utils'
 import {log, LOG} from '@jdeighan/coffee-utils/log'
 import {getPrefix} from '@jdeighan/coffee-utils/arrow'
@@ -36,10 +36,9 @@ export class CallStack
 
 	# ........................................................................
 
-	enter: (funcName, oldFlag=undef) ->
+	enter: (funcName, lArgs=[]) ->
 		# --- funcName might be <object>.<method>
 
-		assert (oldFlag == undef), "enter() takes only 1 arg"
 		if doDebugStack
 			LOG "[--> ENTER #{funcName}]"
 
@@ -54,20 +53,28 @@ export class CallStack
 		[_, ident1, ident2] = lMatches
 		if ident2
 			@lStack.push({
-				fullName: "#{ident1}.#{ident2}"
+				fullName: funcName     #    "#{ident1}.#{ident2}"
 				funcName: ident2
 				isLogged: false
+				lArgs: deepCopy(lArgs)
 				})
 		else
 			@lStack.push({
-				fullName: ident1
+				fullName: funcName
 				funcName: ident1
 				isLogged: false
+				lArgs: deepCopy(lArgs)
 				})
 		return
 
 	# ........................................................................
 
+	getLevel: () ->
+
+		return @level
+
+	# ........................................................................
+
 	isLogging: () ->
 
 		if (@lStack.length == 0)
@@ -86,12 +93,17 @@ export class CallStack
 
 	# ........................................................................
 
-	logCurFunc: () ->
+	logCurFunc: (funcName) ->
 
 		# --- funcName must be  the current function
 		#     and the isLogged flag must currently be false
+
 		cur = @lStack[@lStack.length - 1]
 		assert (cur.isLogged == false), "isLogged is already true"
+		if (funcName != cur.fullName)
+			LOG "cur func #{cur.fullName} is not #{funcName}"
+			LOG @dump()
+			croak "BAD"
 		cur.isLogged = true
 		@level += 1
 		return
@@ -126,12 +138,6 @@ export class CallStack
 
 	# ........................................................................
 
-	getLevel: () ->
-
-		return @level
-
-	# ........................................................................
-
 	curFunc: () ->
 
 		if (@lStack.length == 0)
@@ -151,14 +157,38 @@ export class CallStack
 		return false
 
 	# ........................................................................
-	# ........................................................................
 
-	dump: (prefix='', label='CALL STACK') ->
+	dump: () ->
 
-		lLines = ["#{label}:"]
+		lLines = ["CALL STACK:"]
 		if @lStack.length == 0
 			lLines.push "   <EMPTY>"
 		else
 			for item, i in @lStack
-				lLines.push "   #{i}: #{item.fullName} #{item.isLogged}"
-		return lLines.join("\n") + "\n"
+				lLines.push "   " + @callStr(i, item)
+		return lLines.join("\n")
+
+	# ........................................................................
+
+	callStr: (i, item) ->
+
+		sym = if item.isLogged then '*' else ''
+		str = "#{i}#{sym}: #{item.fullName}"
+		for arg in item.lArgs
+			str += " #{OL(arg)}"
+		return str
+
+	# ........................................................................
+
+	sdump: (label='CALL STACK') ->
+
+		lFuncNames = []
+		for item in @lStack
+			if item.isLogged
+				lFuncNames.push '*' + item.fullName
+			else
+				lFuncNames.push item.fullName
+		if @lStack.length == 0
+			return "#{label} <EMPTY>"
+		else
+			return "#{label} #{lFuncNames.join(' ')}"

package/src/call_stack.js

@@ -9,7 +9,8 @@ import {
   assert,
   OL,
   isBoolean,
-  escapeStr
+  escapeStr,
+  deepCopy
 } from '@jdeighan/coffee-utils';
 
 import {
@@ -45,10 +46,9 @@ export var CallStack = class CallStack {
   }
 
   // ........................................................................
-  enter(funcName, oldFlag = undef) {
+  enter(funcName, lArgs = []) {
     var _, ident1, ident2, lMatches;
     // --- funcName might be <object>.<method>
-    assert(oldFlag === undef, "enter() takes only 1 arg");
     if (doDebugStack) {
       LOG(`[--> ENTER ${funcName}]`);
     }
@@ -57,19 +57,26 @@ export var CallStack = class CallStack {
     [_, ident1, ident2] = lMatches;
     if (ident2) {
       this.lStack.push({
-        fullName: `${ident1}.${ident2}`,
+        fullName: funcName, //    "#{ident1}.#{ident2}"
         funcName: ident2,
-        isLogged: false
+        isLogged: false,
+        lArgs: deepCopy(lArgs)
       });
     } else {
       this.lStack.push({
-        fullName: ident1,
+        fullName: funcName,
         funcName: ident1,
-        isLogged: false
+        isLogged: false,
+        lArgs: deepCopy(lArgs)
       });
     }
   }
 
+  // ........................................................................
+  getLevel() {
+    return this.level;
+  }
+
   // ........................................................................
   isLogging() {
     if (this.lStack.length === 0) {
@@ -89,12 +96,17 @@ export var CallStack = class CallStack {
   }
 
   // ........................................................................
-  logCurFunc() {
+  logCurFunc(funcName) {
     var cur;
     // --- funcName must be  the current function
     //     and the isLogged flag must currently be false
     cur = this.lStack[this.lStack.length - 1];
     assert(cur.isLogged === false, "isLogged is already true");
+    if (funcName !== cur.fullName) {
+      LOG(`cur func ${cur.fullName} is not ${funcName}`);
+      LOG(this.dump());
+      croak("BAD");
+    }
     cur.isLogged = true;
     this.level += 1;
   }
@@ -128,11 +140,6 @@ export var CallStack = class CallStack {
     }
   }
 
-  // ........................................................................
-  getLevel() {
-    return this.level;
-  }
-
   // ........................................................................
   curFunc() {
     if (this.lStack.length === 0) {
@@ -158,20 +165,52 @@ export var CallStack = class CallStack {
   }
 
   // ........................................................................
-  // ........................................................................
-  dump(prefix = '', label = 'CALL STACK') {
+  dump() {
     var i, item, j, lLines, len, ref;
-    lLines = [`${label}:`];
+    lLines = ["CALL STACK:"];
     if (this.lStack.length === 0) {
       lLines.push("   <EMPTY>");
     } else {
       ref = this.lStack;
       for (i = j = 0, len = ref.length; j < len; i = ++j) {
         item = ref[i];
-        lLines.push(`   ${i}: ${item.fullName} ${item.isLogged}`);
+        lLines.push("   " + this.callStr(i, item));
       }
     }
-    return lLines.join("\n") + "\n";
+    return lLines.join("\n");
+  }
+
+  // ........................................................................
+  callStr(i, item) {
+    var arg, j, len, ref, str, sym;
+    sym = item.isLogged ? '*' : '';
+    str = `${i}${sym}: ${item.fullName}`;
+    ref = item.lArgs;
+    for (j = 0, len = ref.length; j < len; j++) {
+      arg = ref[j];
+      str += ` ${OL(arg)}`;
+    }
+    return str;
+  }
+
+  // ........................................................................
+  sdump(label = 'CALL STACK') {
+    var item, j, lFuncNames, len, ref;
+    lFuncNames = [];
+    ref = this.lStack;
+    for (j = 0, len = ref.length; j < len; j++) {
+      item = ref[j];
+      if (item.isLogged) {
+        lFuncNames.push('*' + item.fullName);
+      } else {
+        lFuncNames.push(item.fullName);
+      }
+    }
+    if (this.lStack.length === 0) {
+      return `${label} <EMPTY>`;
+    } else {
+      return `${label} ${lFuncNames.join(' ')}`;
+    }
   }
 
 };

package/src/coffee_utils.coffee

@@ -349,7 +349,15 @@ export ltrunc = (str, nChars) ->
 
 export deepCopy = (obj) ->
 
-	return JSON.parse(JSON.stringify(obj))
+	if (obj == undef)
+		return undef
+	objStr = JSON.stringify(obj)
+	try
+		newObj = JSON.parse(objStr)
+	catch err
+		croak "ERROR: err.message", objStr
+
+	return newObj
 
 # ---------------------------------------------------------------------------
 #   escapeStr - escape newlines, TAB chars, etc.

package/src/coffee_utils.js

@@ -347,7 +347,18 @@ export var ltrunc = function(str, nChars) {
 // ---------------------------------------------------------------------------
 //   deepCopy - deep copy an array or object
 export var deepCopy = function(obj) {
-  return JSON.parse(JSON.stringify(obj));
+  var err, newObj, objStr;
+  if (obj === undef) {
+    return undef;
+  }
+  objStr = JSON.stringify(obj);
+  try {
+    newObj = JSON.parse(objStr);
+  } catch (error1) {
+    err = error1;
+    croak("ERROR: err.message", objStr);
+  }
+  return newObj;
 };
 
 // ---------------------------------------------------------------------------

package/src/debug_utils.coffee

@@ -16,11 +16,12 @@ import {
 	log, logItem, LOG, shortEnough, dashes,
 	} from '@jdeighan/coffee-utils/log'
 
-callStack = new CallStack()
-
 # --- set in resetDebugging() and setDebugging()
+export callStack = new CallStack()
 export shouldLog = () -> undef
-export lFuncList = []
+
+lFuncList = []
+strFuncList = undef     # original string
 
 # --- internal debugging
 doDebugDebug = false
@@ -28,6 +29,13 @@ lFunctions = undef     # --- only used when doDebugDebug is true
 
 # ---------------------------------------------------------------------------
 
+export dumpCallStack = () ->
+
+	LOG callStack.dump()
+	return
+
+# ---------------------------------------------------------------------------
+
 export setDebugDebugging = (value=true) ->
 	# --- value can be a boolean or string of words
 
@@ -42,54 +50,72 @@ export setDebugDebugging = (value=true) ->
 
 # ---------------------------------------------------------------------------
 
-logif = (label, lObjects...) ->
+debugDebug = (label, lObjects...) ->
+	# --- For debugging functions in this module
 
 	if ! doDebugDebug
 		return
 
+	# --- At this point, doDebugDebug is true
+	doDebugDebug = false   # temp - reset before returning
+
 	assert isString(label), "1st arg #{OL(label)} should be a string"
 	nObjects = lObjects.length
 	[type, funcName] = getType(label, nObjects)
+
 	switch type
 		when 'enter'
-			if defined(lFunctions) && (funcName not in lFunctions)
-				return
-			callStack.enter funcName
-			log label, lObjects...
+			assert defined(funcName), "type enter, funcName = undef"
+			callStack.enter funcName, lObjects
+			doLog = (lFunctions == undef) || (funcName in lFunctions)
+
 		when 'return'
-			if defined(lFunctions) && (funcName not in lFunctions)
-				return
-			log label, lObjects...
-			callStack.returnFrom funcName
+			assert defined(funcName), "type return, funcName = undef"
+			doLog = (lFunctions == undef) || (funcName in lFunctions)
+
 		when 'string'
-			log label, lObjects...
+			assert (funcName == undef), "type string, funcName defined"
+			assert (nObjects == 0), "Objects not allowed for #{OL(type)}"
+			doLog = true
+
 		when 'objects'
-			log label, lObjects...
+			assert (funcName == undef), "type objects, funcName defined"
+			assert (nObjects > 0), "Objects required for #{OL(type)}"
+			dolog = true
+
+	if doLog
+		doTheLogging type, label, lObjects
+
+	if (type == 'enter') && doLog
+		callStack.logCurFunc(funcName)
+	else if (type == 'return')
+		callStack.returnFrom funcName
+
+	doDebugDebug = true
 	return
 
 # ---------------------------------------------------------------------------
 
 export debug = (label, lObjects...) ->
 
-	logif "enter debug(#{OL(label)})", lObjects...
-
 	assert isString(label), "1st arg #{OL(label)} should be a string"
 
-	# --- We want to allow objects to be undef. Therefore, we need to
-	#     distinguish between 1 arg sent vs. 2 or more args sent
+	# --- If label is "enter <funcname>, we need to put that on the stack
+	#     BEFORE we do any internal logging
 	nObjects = lObjects.length
-
-	# --- funcName is only set for types 'enter' and 'return'
 	[type, funcName] = getType(label, nObjects)
-	logif "type = #{OL(type)}"
-	logif "funcName = #{OL(funcName)}"
+	if (type == 'enter')
+		callStack.enter funcName, lObjects
+
+	debugDebug "enter debug(#{OL(label)})", lObjects...
+	debugDebug "type = #{OL(type)}"
+	debugDebug "funcName = #{OL(funcName)}"
 
 	# --- function shouldLog() returns the (possibly modified) label
 	#     if we should log this, else it returns undef
 
 	switch type
 		when 'enter'
-			callStack.enter funcName
 			label = shouldLog(label, type, funcName, callStack)
 		when 'return'
 			label = shouldLog(label, type, funcName, callStack)
@@ -105,57 +131,67 @@ export debug = (label, lObjects...) ->
 	assert (label == undef) || isString(label),
 			"label not a string: #{OL(label)}"
 	doLog = defined(label)
-	logif "doLog = #{OL(doLog)}"
-	logif "#{nObjects} objects"
+	debugDebug "doLog = #{OL(doLog)}"
+	debugDebug "#{nObjects} objects"
 
 	if doLog
-		level = callStack.getLevel()
-		prefix = getPrefix(level)
-		itemPrefix = removeLastVbar(prefix)
-		sep = dashes(itemPrefix, 40)
-		assert isString(sep), "sep is not a string"
-
-		logif "callStack", callStack
-		logif "level = #{OL(level)}"
-		logif "prefix = #{OL(prefix)}"
-		logif "itemPrefix = #{OL(itemPrefix)}"
-		logif "sep = #{OL(sep)}"
-
-		switch type
-			when 'enter'
-				log label, {prefix}
-				for obj,i in lObjects
-					if (i > 0)
-						log sep
-					logItem undef, obj, {itemPrefix}
-			when 'return'
-				log label, {prefix: addArrow(prefix)}
-				for obj,i in lObjects
-					if (i > 0)
-						log sep
-					logItem undef, obj, {itemPrefix}
-			when 'string'
-				log label, {prefix}
-			when 'objects'
-				if (nObjects==1) && shortEnough(label, lObjects[0])
-					logItem label, lObjects[0], {prefix}
-				else
-					if (label.indexOf(':') != label.length - 1)
-						label += ':'
-					log label, {prefix}
-					for obj in lObjects
-						logItem undef, obj, {prefix}
+		doTheLogging type, label, lObjects
 
 	if (type == 'enter') && doLog && (label.indexOf('call') == -1)
-		callStack.logCurFunc()
-	else if (type == 'return')
+		callStack.logCurFunc(funcName)
+
+	# --- This must be called BEFORE we return from funcName
+	debugDebug "return from debug()"
+
+	if (type == 'return')
 		callStack.returnFrom funcName
 
-	logif "return from debug()"
 	return true   # allow use in boolean expressions
 
 # ---------------------------------------------------------------------------
 
+export doTheLogging = (type, label, lObjects) ->
+
+	level = callStack.getLevel()
+	prefix = getPrefix(level)
+	itemPrefix = removeLastVbar(prefix)
+	sep = dashes(itemPrefix, 40)
+	assert isString(sep), "sep is not a string"
+
+	debugDebug "callStack", callStack
+	debugDebug "level = #{OL(level)}"
+	debugDebug "prefix = #{OL(prefix)}"
+	debugDebug "itemPrefix = #{OL(itemPrefix)}"
+	debugDebug "sep = #{OL(sep)}"
+
+	switch type
+		when 'enter'
+			log label, {prefix}
+			for obj,i in lObjects
+				if (i > 0)
+					log sep
+				logItem undef, obj, {itemPrefix}
+		when 'return'
+			log label, {prefix: addArrow(prefix)}
+			for obj,i in lObjects
+				if (i > 0)
+					log sep
+				logItem undef, obj, {itemPrefix}
+		when 'string'
+			log label, {prefix}
+		when 'objects'
+			if (lObjects.length==1) && shortEnough(label, lObjects[0])
+				logItem label, lObjects[0], {prefix}
+			else
+				if (label.indexOf(':') != label.length - 1)
+					label += ':'
+				log label, {prefix}
+				for obj in lObjects
+					logItem undef, obj, {prefix}
+	return
+
+# ---------------------------------------------------------------------------
+
 export stdShouldLog = (label, type, funcName, stack) ->
 	# --- if type is 'enter', then funcName won't be on the stack yet
 	#     returns the (possibly modified) label to log
@@ -172,13 +208,12 @@ export stdShouldLog = (label, type, funcName, stack) ->
 		assert funcName == undef, "func name #{OL(funcName)} not undef"
 	assert stack instanceof CallStack, "not a call stack object"
 
-	logif "stdShouldLog(#{OL(label)}, #{OL(type)}, #{OL(funcName)}, stack)"
-	logif "stack", stack
-	logif "lFuncList", lFuncList
+	debugDebug "enter stdShouldLog(#{OL(label)}, #{OL(type)}, #{OL(funcName)}, stack)"
 
 	switch type
 		when 'enter'
-			if funcMatch(stack, lFuncList)
+			if funcMatch()
+				debugDebug "return #{OL(label)} from stdShouldLog() - funcMatch"
 				return label
 
 			else
@@ -188,10 +223,14 @@ export stdShouldLog = (label, type, funcName, stack) ->
 
 				prevLogged = stack.isLoggingPrev()
 				if prevLogged
-					return label.replace('enter', 'call')
+					result = label.replace('enter', 'call')
+					debugDebug "return #{OL(result)} from stdShouldLog() - s/enter/call/"
+					return result
 		else
-			if funcMatch(stack, lFuncList)
+			if funcMatch()
+				debugDebug "return #{OL(label)} from stdShouldLog()"
 				return label
+	debugDebug "return undef from stdShouldLog()"
 	return undef
 
 # ---------------------------------------------------------------------------
@@ -218,6 +257,7 @@ export setDebugging = (option) ->
 
 export getFuncList = (str) ->
 
+	strFuncList = str     # store original string for debugging
 	lFuncList = []
 	for word in words(str)
 		if lMatches = word.match(///^
@@ -247,23 +287,23 @@ export getFuncList = (str) ->
 # ---------------------------------------------------------------------------
 # --- export only to allow unit tests
 
-export funcMatch = (stack, lFuncList) ->
+export funcMatch = () ->
 
 	assert isArray(lFuncList), "not an array #{OL(lFuncList)}"
 
-	curFunc = stack.curFunc()
-	logif "funcMatch(): curFunc = #{OL(curFunc)}"
-	logif stack.dump('   ')
-	logif 'lFuncList', lFuncList
+	debugDebug "enter funcMatch()"
+	curFunc = callStack.curFunc()
+	debugDebug "curFunc = #{OL(curFunc)}"
+	debugDebug "lFuncList = #{strFuncList}"
 	for h in lFuncList
 		{name, object, plus} = h
 		if (name == curFunc)
-			logif "   curFunc in lFuncList - match successful"
+			debugDebug "return from funcMatch() - curFunc in lFuncList"
 			return true
-		if plus && stack.isActive(name)
-			logif "   func #{OL(name)} is active - match successful"
+		if plus && callStack.isActive(name)
+			debugDebug "return from funcMatch() - func #{OL(name)} is active"
 			return true
-	logif "   - no match"
+	debugDebug "return from funcMatch() - no match"
 	return false
 
 # ---------------------------------------------------------------------------

package/src/debug_utils.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
   // debug_utils.coffee
-var callStack, doDebugDebug, lFunctions, logif, reMethod,
+var debugDebug, doDebugDebug, lFuncList, lFunctions, reMethod, strFuncList,
   indexOf = [].indexOf;
 
 import {
@@ -51,14 +51,17 @@ import {
   dashes
 } from '@jdeighan/coffee-utils/log';
 
-callStack = new CallStack();
-
 // --- set in resetDebugging() and setDebugging()
+export var callStack = new CallStack();
+
 export var shouldLog = function() {
   return undef;
 };
 
-export var lFuncList = [];
+lFuncList = [];
+
+strFuncList = undef; // original string
+
 
 // --- internal debugging
 doDebugDebug = false;
@@ -66,6 +69,11 @@ doDebugDebug = false;
 lFunctions = undef; // --- only used when doDebugDebug is true
 
 
+// ---------------------------------------------------------------------------
+export var dumpCallStack = function() {
+  LOG(callStack.dump());
+};
+
 // ---------------------------------------------------------------------------
 export var setDebugDebugging = function(value = true) {
   // --- value can be a boolean or string of words
@@ -80,54 +88,65 @@ export var setDebugDebugging = function(value = true) {
 };
 
 // ---------------------------------------------------------------------------
-logif = function(label, ...lObjects) {
-  var funcName, nObjects, type;
+debugDebug = function(label, ...lObjects) {
+  var doLog, dolog, funcName, nObjects, type;
   if (!doDebugDebug) {
     return;
   }
+  // --- At this point, doDebugDebug is true
+  doDebugDebug = false; // temp - reset before returning
   assert(isString(label), `1st arg ${OL(label)} should be a string`);
   nObjects = lObjects.length;
   [type, funcName] = getType(label, nObjects);
   switch (type) {
     case 'enter':
-      if (defined(lFunctions) && (indexOf.call(lFunctions, funcName) < 0)) {
-        return;
-      }
-      callStack.enter(funcName);
-      log(label, ...lObjects);
+      assert(defined(funcName), "type enter, funcName = undef");
+      callStack.enter(funcName, lObjects);
+      doLog = (lFunctions === undef) || (indexOf.call(lFunctions, funcName) >= 0);
       break;
     case 'return':
-      if (defined(lFunctions) && (indexOf.call(lFunctions, funcName) < 0)) {
-        return;
-      }
-      log(label, ...lObjects);
-      callStack.returnFrom(funcName);
+      assert(defined(funcName), "type return, funcName = undef");
+      doLog = (lFunctions === undef) || (indexOf.call(lFunctions, funcName) >= 0);
       break;
     case 'string':
-      log(label, ...lObjects);
+      assert(funcName === undef, "type string, funcName defined");
+      assert(nObjects === 0, `Objects not allowed for ${OL(type)}`);
+      doLog = true;
       break;
     case 'objects':
-      log(label, ...lObjects);
+      assert(funcName === undef, "type objects, funcName defined");
+      assert(nObjects > 0, `Objects required for ${OL(type)}`);
+      dolog = true;
+  }
+  if (doLog) {
+    doTheLogging(type, label, lObjects);
+  }
+  if ((type === 'enter') && doLog) {
+    callStack.logCurFunc(funcName);
+  } else if (type === 'return') {
+    callStack.returnFrom(funcName);
   }
+  doDebugDebug = true;
 };
 
 // ---------------------------------------------------------------------------
 export var debug = function(label, ...lObjects) {
-  var doLog, funcName, i, itemPrefix, j, k, l, len, len1, len2, level, nObjects, obj, prefix, sep, type;
-  logif(`enter debug(${OL(label)})`, ...lObjects);
+  var doLog, funcName, nObjects, type;
   assert(isString(label), `1st arg ${OL(label)} should be a string`);
-  // --- We want to allow objects to be undef. Therefore, we need to
-  //     distinguish between 1 arg sent vs. 2 or more args sent
+  // --- If label is "enter <funcname>, we need to put that on the stack
+  //     BEFORE we do any internal logging
   nObjects = lObjects.length;
-  // --- funcName is only set for types 'enter' and 'return'
   [type, funcName] = getType(label, nObjects);
-  logif(`type = ${OL(type)}`);
-  logif(`funcName = ${OL(funcName)}`);
+  if (type === 'enter') {
+    callStack.enter(funcName, lObjects);
+  }
+  debugDebug(`enter debug(${OL(label)})`, ...lObjects);
+  debugDebug(`type = ${OL(type)}`);
+  debugDebug(`funcName = ${OL(funcName)}`);
   // --- function shouldLog() returns the (possibly modified) label
   //     if we should log this, else it returns undef
   switch (type) {
     case 'enter':
-      callStack.enter(funcName);
       label = shouldLog(label, type, funcName, callStack);
       break;
     case 'return':
@@ -143,73 +162,81 @@ export var debug = function(label, ...lObjects) {
   }
   assert((label === undef) || isString(label), `label not a string: ${OL(label)}`);
   doLog = defined(label);
-  logif(`doLog = ${OL(doLog)}`);
-  logif(`${nObjects} objects`);
+  debugDebug(`doLog = ${OL(doLog)}`);
+  debugDebug(`${nObjects} objects`);
   if (doLog) {
-    level = callStack.getLevel();
-    prefix = getPrefix(level);
-    itemPrefix = removeLastVbar(prefix);
-    sep = dashes(itemPrefix, 40);
-    assert(isString(sep), "sep is not a string");
-    logif("callStack", callStack);
-    logif(`level = ${OL(level)}`);
-    logif(`prefix = ${OL(prefix)}`);
-    logif(`itemPrefix = ${OL(itemPrefix)}`);
-    logif(`sep = ${OL(sep)}`);
-    switch (type) {
-      case 'enter':
-        log(label, {prefix});
-        for (i = j = 0, len = lObjects.length; j < len; i = ++j) {
-          obj = lObjects[i];
-          if (i > 0) {
-            log(sep);
-          }
-          logItem(undef, obj, {itemPrefix});
-        }
-        break;
-      case 'return':
-        log(label, {
-          prefix: addArrow(prefix)
-        });
-        for (i = k = 0, len1 = lObjects.length; k < len1; i = ++k) {
-          obj = lObjects[i];
-          if (i > 0) {
-            log(sep);
-          }
-          logItem(undef, obj, {itemPrefix});
-        }
-        break;
-      case 'string':
-        log(label, {prefix});
-        break;
-      case 'objects':
-        if ((nObjects === 1) && shortEnough(label, lObjects[0])) {
-          logItem(label, lObjects[0], {prefix});
-        } else {
-          if (label.indexOf(':') !== label.length - 1) {
-            label += ':';
-          }
-          log(label, {prefix});
-          for (l = 0, len2 = lObjects.length; l < len2; l++) {
-            obj = lObjects[l];
-            logItem(undef, obj, {prefix});
-          }
-        }
-    }
+    doTheLogging(type, label, lObjects);
   }
   if ((type === 'enter') && doLog && (label.indexOf('call') === -1)) {
-    callStack.logCurFunc();
-  } else if (type === 'return') {
+    callStack.logCurFunc(funcName);
+  }
+  // --- This must be called BEFORE we return from funcName
+  debugDebug("return from debug()");
+  if (type === 'return') {
     callStack.returnFrom(funcName);
   }
-  logif("return from debug()");
   return true; // allow use in boolean expressions
 };
 
 
+// ---------------------------------------------------------------------------
+export var doTheLogging = function(type, label, lObjects) {
+  var i, itemPrefix, j, k, l, len, len1, len2, level, obj, prefix, sep;
+  level = callStack.getLevel();
+  prefix = getPrefix(level);
+  itemPrefix = removeLastVbar(prefix);
+  sep = dashes(itemPrefix, 40);
+  assert(isString(sep), "sep is not a string");
+  debugDebug("callStack", callStack);
+  debugDebug(`level = ${OL(level)}`);
+  debugDebug(`prefix = ${OL(prefix)}`);
+  debugDebug(`itemPrefix = ${OL(itemPrefix)}`);
+  debugDebug(`sep = ${OL(sep)}`);
+  switch (type) {
+    case 'enter':
+      log(label, {prefix});
+      for (i = j = 0, len = lObjects.length; j < len; i = ++j) {
+        obj = lObjects[i];
+        if (i > 0) {
+          log(sep);
+        }
+        logItem(undef, obj, {itemPrefix});
+      }
+      break;
+    case 'return':
+      log(label, {
+        prefix: addArrow(prefix)
+      });
+      for (i = k = 0, len1 = lObjects.length; k < len1; i = ++k) {
+        obj = lObjects[i];
+        if (i > 0) {
+          log(sep);
+        }
+        logItem(undef, obj, {itemPrefix});
+      }
+      break;
+    case 'string':
+      log(label, {prefix});
+      break;
+    case 'objects':
+      if ((lObjects.length === 1) && shortEnough(label, lObjects[0])) {
+        logItem(label, lObjects[0], {prefix});
+      } else {
+        if (label.indexOf(':') !== label.length - 1) {
+          label += ':';
+        }
+        log(label, {prefix});
+        for (l = 0, len2 = lObjects.length; l < len2; l++) {
+          obj = lObjects[l];
+          logItem(undef, obj, {prefix});
+        }
+      }
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var stdShouldLog = function(label, type, funcName, stack) {
-  var prevLogged;
+  var prevLogged, result;
   // --- if type is 'enter', then funcName won't be on the stack yet
   //     returns the (possibly modified) label to log
 
@@ -224,12 +251,11 @@ export var stdShouldLog = function(label, type, funcName, stack) {
     assert(funcName === undef, `func name ${OL(funcName)} not undef`);
   }
   assert(stack instanceof CallStack, "not a call stack object");
-  logif(`stdShouldLog(${OL(label)}, ${OL(type)}, ${OL(funcName)}, stack)`);
-  logif("stack", stack);
-  logif("lFuncList", lFuncList);
+  debugDebug(`enter stdShouldLog(${OL(label)}, ${OL(type)}, ${OL(funcName)}, stack)`);
   switch (type) {
     case 'enter':
-      if (funcMatch(stack, lFuncList)) {
+      if (funcMatch()) {
+        debugDebug(`return ${OL(label)} from stdShouldLog() - funcMatch`);
         return label;
       } else {
         // --- As a special case, if we enter a function where we will not
@@ -237,15 +263,19 @@ export var stdShouldLog = function(label, type, funcName, stack) {
         //     we'll log out the call itself
         prevLogged = stack.isLoggingPrev();
         if (prevLogged) {
-          return label.replace('enter', 'call');
+          result = label.replace('enter', 'call');
+          debugDebug(`return ${OL(result)} from stdShouldLog() - s/enter/call/`);
+          return result;
         }
       }
       break;
     default:
-      if (funcMatch(stack, lFuncList)) {
+      if (funcMatch()) {
+        debugDebug(`return ${OL(label)} from stdShouldLog()`);
         return label;
       }
   }
+  debugDebug("return undef from stdShouldLog()");
   return undef;
 };
 
@@ -276,6 +306,7 @@ export var setDebugging = function(option) {
 // --- export only to allow unit tests
 export var getFuncList = function(str) {
   var _, ident1, ident2, j, lMatches, len, plus, ref, word;
+  strFuncList = str; // store original string for debugging
   lFuncList = [];
   ref = words(str);
   for (j = 0, len = ref.length; j < len; j++) {
@@ -303,26 +334,26 @@ export var getFuncList = function(str) {
 
 // ---------------------------------------------------------------------------
 // --- export only to allow unit tests
-export var funcMatch = function(stack, lFuncList) {
+export var funcMatch = function() {
   var curFunc, h, j, len, name, object, plus;
   assert(isArray(lFuncList), `not an array ${OL(lFuncList)}`);
-  curFunc = stack.curFunc();
-  logif(`funcMatch(): curFunc = ${OL(curFunc)}`);
-  logif(stack.dump('   '));
-  logif('lFuncList', lFuncList);
+  debugDebug("enter funcMatch()");
+  curFunc = callStack.curFunc();
+  debugDebug(`curFunc = ${OL(curFunc)}`);
+  debugDebug(`lFuncList = ${strFuncList}`);
   for (j = 0, len = lFuncList.length; j < len; j++) {
     h = lFuncList[j];
     ({name, object, plus} = h);
     if (name === curFunc) {
-      logif("   curFunc in lFuncList - match successful");
+      debugDebug("return from funcMatch() - curFunc in lFuncList");
       return true;
     }
-    if (plus && stack.isActive(name)) {
-      logif(`   func ${OL(name)} is active - match successful`);
+    if (plus && callStack.isActive(name)) {
+      debugDebug(`return from funcMatch() - func ${OL(name)} is active`);
       return true;
     }
   }
-  logif("   - no match");
+  debugDebug("return from funcMatch() - no match");
   return false;
 };