@jdeighan/coffee-utils 7.0.48 → 7.0.51

package/src/debug_utils.coffee

@@ -1,7 +1,8 @@
 # debug_utils.coffee
 
 import {
-	assert, undef, error, croak, warn, isString, isFunction, isBoolean,
+	assert, undef, error, croak, warn, defined,
+	isString, isFunction, isBoolean, sep_dash,
 	OL, escapeStr, isNumber, isArray, words, pass,
 	} from '@jdeighan/coffee-utils'
 import {blockToArray} from '@jdeighan/coffee-utils/block'
@@ -9,16 +10,15 @@ import {untabify} from '@jdeighan/coffee-utils/indent'
 import {slurp} from '@jdeighan/coffee-utils/fs'
 import {CallStack} from '@jdeighan/coffee-utils/stack'
 import {
-	log, logItem, LOG, setStringifier, orderedStringify,
+	getPrefix, addArrow, removeLastVbar,
+	} from '@jdeighan/coffee-utils/arrow'
+import {
+	log, logItem, LOG, shortEnough,
 	} from '@jdeighan/coffee-utils/log'
 
-# --- These are saved/restored on the call stack
-export debugging = false
-shouldLogFunc   = (func) -> debugging
-shouldLogString = (str) -> debugging
-
-stack = new CallStack()
+callStack = new CallStack()
 doDebugDebug = false
+shouldLog = undef     # set in resetDebugging() and setDebugging()
 
 # ---------------------------------------------------------------------------
 
@@ -33,49 +33,47 @@ export debugDebug = (flag=true) ->
 
 resetDebugging = () ->
 
-	debugging = false
 	if doDebugDebug
-		LOG "resetDebugging() - debugging = false"
-	stack.reset()
-	shouldLogFunc = (func) -> debugging
-	shouldLogString = (str)  -> debugging
+		LOG "resetDebugging()"
+	callStack.reset()
+	shouldLog = (type, str, stack) -> false
 	return
 
 # ---------------------------------------------------------------------------
 
-export setDebugging = (funcDoDebug=undef, funcDoLog=undef) ->
+export setDebugging = (option) ->
 
 	resetDebugging()
-	if isBoolean(funcDoDebug)
-		debugging = funcDoDebug
-		if doDebugDebug
-			LOG "setDebugging(): debugging = #{funcDoDebug}"
-	else if isString(funcDoDebug)
-		debugging = false
-		lFuncNames = words(funcDoDebug)
-		assert isArray(lFuncNames), "words('#{funcDoDebug}') returned non-array"
-		shouldLogFunc = (funcName) ->
-			funcMatch(funcName, lFuncNames)
+	if isBoolean(option)
+		shouldLog = (type, str, stack) -> option
+	else if isString(option)
+		shouldLog = (type, str, stack) ->
+			lFuncs = words(option)
+			switch type
+				when 'enter'
+					return funcMatch(stack, lFuncs, str)
+				else
+					return funcMatch(stack, lFuncs)
 		if doDebugDebug
-			LOG "setDebugging FUNCS: #{lFuncNames.join(',')}, debugging = false"
-	else if isFunction(funcDoDebug)
-		shouldLogFunc = funcDoDebug
+			LOG "setDebugging FUNCS: #{option}"
+	else if isFunction(option)
+		shouldLog = option
 		if doDebugDebug
 			LOG "setDebugging to custom func"
 	else
-		croak "setDebugging(): bad parameter #{OL(funcDoDebug)}"
-
-	if funcDoLog
-		assert isFunction(funcDoLog), "setDebugging: arg 2 not a function"
-		shouldLogString = funcDoLog
+		croak "setDebugging(): bad parameter #{OL(option)}"
 	return
 
 # ---------------------------------------------------------------------------
 # --- export only to allow unit tests
 
-export funcMatch = (curFunc, lFuncNames) ->
+export funcMatch = (stack, lFuncNames, enteringFunc=undef) ->
+
+	if defined(enteringFunc) && (enteringFunc in lFuncNames)
+		return true
 
-	assert isString(curFunc), "funcMatch(): not a string"
+	curFunc = stack.curFunc()
+	assert isString(curFunc), "funcMatch(): not a string #{OL(curFunc)}"
 	assert isArray(lFuncNames), "funcMatch(): bad array #{lFuncNames}"
 	if lFuncNames.includes(curFunc)
 		return true
@@ -87,120 +85,116 @@ export funcMatch = (curFunc, lFuncNames) ->
 		return false
 
 # ---------------------------------------------------------------------------
-# 1. adjust call stack on 'enter' or 'return from'
-# 2. adjust debugging flag
-# 3. return [mainPrefix, auxPrefix, hEnv] - hEnv can be undef
-# 4. disable logging by setting mainPrefix to undef
+# --- type is one of: 'enter', 'return', 'string', 'object'
 
-adjustStack = (str) ->
+export getType = (str, nObjects) ->
 
-	if (lMatches = str.match(///^
+	if lMatches = str.match(///^
 			\s*
 			enter
 			\s+
 			([A-Za-z_][A-Za-z0-9_\.]*)
-			///))
-		curFunc = lMatches[1]
-		hEnv = {
-			debugging
-			shouldLogFunc
-			shouldLogString
-			}
-		debugging = shouldLogFunc(curFunc)
-		if doDebugDebug
-			trans = "#{hEnv.debugging} => #{debugging}"
-			LOG "   ENTER #{curFunc}, debugging: #{trans}"
-		[mainPre, auxPre, _] = stack.call(curFunc, hEnv, debugging)
-		return [
-			mainPre
-			auxPre
-			undef
-			if shouldLogFunc(curFunc) then 'enter' else undef
-			]
-	else if (lMatches = str.match(///^
+			///)
+
+		# --- We are entering function curFunc
+		return ['enter', lMatches[1]]
+
+	else if lMatches = str.match(///^
 			\s*
 			return
 			.+
 			from
 			\s+
 			([A-Za-z_][A-Za-z0-9_\.]*)
-			///))
-		curFunc = lMatches[1]
-		[mainPre, auxPre, hEnv] = stack.returnFrom(curFunc)
-		if doDebugDebug
-			LOG "   RETURN FROM #{curFunc}"
-		return [
-			mainPre
-			auxPre
-			hEnv
-			if shouldLogFunc(curFunc) then 'return' else undef
-			]
+			///)
+		return ['return', lMatches[1]]
+
+	else if (nObjects > 0)
+		return ['objects', undef]
 	else
-		[mainPre, auxPre, _] = stack.logStr()
-		return [
-			mainPre
-			auxPre
-			undef
-			if shouldLogString(str) then 'string' else undef
-			]
+		return ['string', undef]
 
 # ---------------------------------------------------------------------------
 
-export debug = (lArgs...) ->
+export debug = (label, lObjects...) ->
 
-	# --- We want to allow item to be undef. Therefore, we need to
-	#     distinguish between 1 arg sent vs. 2 args sent
-	nArgs = lArgs.length
-	assert (nArgs==1) || (nArgs==2), "debug(): #{nArgs} args"
-	[label, item] = lArgs
-	assert isString(label),
-			"debug(): 1st arg #{OL(label)} should be a string"
+	assert isString(label), "1st arg #{OL(label)} should be a string"
 
-	if doDebugDebug
-		if nArgs==1
-			LOG "debug('#{escapeStr(label)}') - 1 arg"
-		else
-			LOG "debug('#{escapeStr(label)}', #{typeof item}) - 2 args"
-
-	# --- We always need to manipulate the stack when we encounter
-	#     either "enter X" or "return from X", so we can't short-circuit
-	#     when debugging is off
-
-	lResult = adjustStack(label)
-	if doDebugDebug
-		LOG 'lResult', lResult
-	[mainPre, auxPre, hEnv, type] = lResult
-	if doDebugDebug && (type == undef)
-		LOG "type is undef - NOT LOGGING"
-
-	hOptions = {
-		prefix: mainPre
-		itemPrefix: auxPre
-		}
+	# --- We want to allow objects to be undef. Therefore, we need to
+	#     distinguish between 1 arg sent vs. 2 or more args sent
+	nObjects = lObjects.length
 
+	# --- funcName is only set for types 'enter' and 'return'
+	[type, funcName] = getType(label, nObjects)
 	switch type
 		when 'enter'
-			log label, hOptions
-			if (nArgs==2)
-				# --- don't repeat the label
-				logItem undef, item, hOptions
+			doLog = shouldLog(type, funcName, callStack)
+
+			# --- If we won't be logging when funcName is activated
+			#     then change 'enter' to 'call'
+			callStack.enter funcName       # add to call stack
+			if ! shouldLog('string', 'abc', callStack)
+				label = label.replace('enter', 'call')
+			callStack.returnFrom funcName  # remove from call stack
 		when 'return'
-			log label, hOptions
-			if (nArgs==2)
-				# --- don't repeat the label
-				logItem undef, item, hOptions
+			doLog = shouldLog(type, funcName, callStack)
 		when 'string'
-			if (nArgs==2)
-				logItem label, item, hOptions
-			else
-				log label, hOptions
+			doLog = shouldLog(type, label, callStack)
+			assert (nObjects == 0),
+					"multiple objects only not allowed for #{OL(type)}"
+		when 'objects'
+			doLog = shouldLog(type, label, callStack)
+			assert (nObjects > 0),
+					"multiple objects only not allowed for #{OL(type)}"
+
+	if doDebugDebug
+		if nObjects == 0
+			LOG "debug(#{OL(label)}) - 1 arg"
+		else
+			LOG "debug(#{OL(label)}), #{nObjects} args"
+		LOG "doLog = #{OL(doLog)}"
+		LOG "type = #{OL(type)}"
+		LOG "funcName = #{OL(funcName)}"
+
+	if doLog
+		level = callStack.getLevel()
+		prefix = getPrefix(level)
 
-	if hEnv
-		orgDebugging = debugging
-		{debugging, shouldLogFunc, shouldLogString} = hEnv
 		if doDebugDebug
-			trans = "#{orgDebugging} => #{debugging}"
-			LOG "   Restore hEnv: debugging: #{trans}"
+			LOG "callStack", callStack
+			LOG "level = #{OL(level)}"
+			LOG "prefix = #{OL(prefix)}"
+
+		switch type
+			when 'enter'
+				log label, {prefix}
+				for obj,i in lObjects
+					if (i > 0)
+						log sep_dash, {prefix: removeLastVbar(prefix)}
+					logItem undef, obj, {prefix: removeLastVbar(prefix)}
+			when 'return'
+				log label, {prefix: addArrow(prefix)}
+				for obj,i in lObjects
+					if (i > 0)
+						log sep_dash, {prefix: removeLastVbar(prefix)}
+					logItem undef, obj, {prefix: removeLastVbar(prefix)}
+			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}
+
+	if (type == 'enter')
+		callStack.enter funcName, doLog
+	else if (type == 'return')
+		callStack.returnFrom funcName
+
 	return true   # allow use in boolean expressions
 
 # ---------------------------------------------------------------------------

package/src/debug_utils.js

@@ -1,6 +1,7 @@
 // Generated by CoffeeScript 2.7.0
-// debug_utils.coffee
-var adjustStack, doDebugDebug, reMethod, resetDebugging, shouldLogFunc, shouldLogString, stack;
+  // debug_utils.coffee
+var callStack, doDebugDebug, reMethod, resetDebugging, shouldLog,
+  indexOf = [].indexOf;
 
 import {
   assert,
@@ -8,9 +9,11 @@ import {
   error,
   croak,
   warn,
+  defined,
   isString,
   isFunction,
   isBoolean,
+  sep_dash,
   OL,
   escapeStr,
   isNumber,
@@ -35,28 +38,25 @@ import {
   CallStack
 } from '@jdeighan/coffee-utils/stack';
 
+import {
+  getPrefix,
+  addArrow,
+  removeLastVbar
+} from '@jdeighan/coffee-utils/arrow';
+
 import {
   log,
   logItem,
   LOG,
-  setStringifier,
-  orderedStringify
+  shortEnough
 } from '@jdeighan/coffee-utils/log';
 
-// --- These are saved/restored on the call stack
-export var debugging = false;
+callStack = new CallStack();
 
-shouldLogFunc = function(func) {
-  return debugging;
-};
-
-shouldLogString = function(str) {
-  return debugging;
-};
+doDebugDebug = false;
 
-stack = new CallStack();
+shouldLog = undef; // set in resetDebugging() and setDebugging()
 
-doDebugDebug = false;
 
 // ---------------------------------------------------------------------------
 export var debugDebug = function(flag = true) {
@@ -68,57 +68,55 @@ export var debugDebug = function(flag = true) {
 
 // ---------------------------------------------------------------------------
 resetDebugging = function() {
-  debugging = false;
   if (doDebugDebug) {
-    LOG("resetDebugging() - debugging = false");
+    LOG("resetDebugging()");
   }
-  stack.reset();
-  shouldLogFunc = function(func) {
-    return debugging;
-  };
-  shouldLogString = function(str) {
-    return debugging;
+  callStack.reset();
+  shouldLog = function(type, str, stack) {
+    return false;
   };
 };
 
 // ---------------------------------------------------------------------------
-export var setDebugging = function(funcDoDebug = undef, funcDoLog = undef) {
-  var lFuncNames;
+export var setDebugging = function(option) {
   resetDebugging();
-  if (isBoolean(funcDoDebug)) {
-    debugging = funcDoDebug;
-    if (doDebugDebug) {
-      LOG(`setDebugging(): debugging = ${funcDoDebug}`);
-    }
-  } else if (isString(funcDoDebug)) {
-    debugging = false;
-    lFuncNames = words(funcDoDebug);
-    assert(isArray(lFuncNames), `words('${funcDoDebug}') returned non-array`);
-    shouldLogFunc = function(funcName) {
-      return funcMatch(funcName, lFuncNames);
+  if (isBoolean(option)) {
+    shouldLog = function(type, str, stack) {
+      return option;
+    };
+  } else if (isString(option)) {
+    shouldLog = function(type, str, stack) {
+      var lFuncs;
+      lFuncs = words(option);
+      switch (type) {
+        case 'enter':
+          return funcMatch(stack, lFuncs, str);
+        default:
+          return funcMatch(stack, lFuncs);
+      }
     };
     if (doDebugDebug) {
-      LOG(`setDebugging FUNCS: ${lFuncNames.join(',')}, debugging = false`);
+      LOG(`setDebugging FUNCS: ${option}`);
     }
-  } else if (isFunction(funcDoDebug)) {
-    shouldLogFunc = funcDoDebug;
+  } else if (isFunction(option)) {
+    shouldLog = option;
     if (doDebugDebug) {
       LOG("setDebugging to custom func");
     }
   } else {
-    croak(`setDebugging(): bad parameter ${OL(funcDoDebug)}`);
-  }
-  if (funcDoLog) {
-    assert(isFunction(funcDoLog), "setDebugging: arg 2 not a function");
-    shouldLogString = funcDoLog;
+    croak(`setDebugging(): bad parameter ${OL(option)}`);
   }
 };
 
 // ---------------------------------------------------------------------------
 // --- export only to allow unit tests
-export var funcMatch = function(curFunc, lFuncNames) {
-  var _, cls, lMatches, meth;
-  assert(isString(curFunc), "funcMatch(): not a string");
+export var funcMatch = function(stack, lFuncNames, enteringFunc = undef) {
+  var _, cls, curFunc, lMatches, meth;
+  if (defined(enteringFunc) && (indexOf.call(lFuncNames, enteringFunc) >= 0)) {
+    return true;
+  }
+  curFunc = stack.curFunc();
+  assert(isString(curFunc), `funcMatch(): not a string ${OL(curFunc)}`);
   assert(isArray(lFuncNames), `funcMatch(): bad array ${lFuncNames}`);
   if (lFuncNames.includes(curFunc)) {
     return true;
@@ -130,95 +128,123 @@ export var funcMatch = function(curFunc, lFuncNames) {
 };
 
 // ---------------------------------------------------------------------------
-// 1. adjust call stack on 'enter' or 'return from'
-// 2. adjust debugging flag
-// 3. return [mainPrefix, auxPrefix, hEnv] - hEnv can be undef
-// 4. disable logging by setting mainPrefix to undef
-adjustStack = function(str) {
-  var _, auxPre, curFunc, hEnv, lMatches, mainPre, trans;
-  if ((lMatches = str.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
-    curFunc = lMatches[1];
-    hEnv = {debugging, shouldLogFunc, shouldLogString};
-    debugging = shouldLogFunc(curFunc);
-    if (doDebugDebug) {
-      trans = `${hEnv.debugging} => ${debugging}`;
-      LOG(`   ENTER ${curFunc}, debugging: ${trans}`);
-    }
-    [mainPre, auxPre, _] = stack.call(curFunc, hEnv, debugging);
-    return [mainPre, auxPre, undef, shouldLogFunc(curFunc) ? 'enter' : undef];
-  } else if ((lMatches = str.match(/^\s*return.+from\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
-    curFunc = lMatches[1];
-    [mainPre, auxPre, hEnv] = stack.returnFrom(curFunc);
-    if (doDebugDebug) {
-      LOG(`   RETURN FROM ${curFunc}`);
-    }
-    return [mainPre, auxPre, hEnv, shouldLogFunc(curFunc) ? 'return' : undef];
+// --- type is one of: 'enter', 'return', 'string', 'object'
+export var getType = function(str, nObjects) {
+  var lMatches;
+  if (lMatches = str.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
+    // --- We are entering function curFunc
+    return ['enter', lMatches[1]];
+  } else if (lMatches = str.match(/^\s*return.+from\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
+    return ['return', lMatches[1]];
+  } else if (nObjects > 0) {
+    return ['objects', undef];
   } else {
-    [mainPre, auxPre, _] = stack.logStr();
-    return [mainPre, auxPre, undef, shouldLogString(str) ? 'string' : undef];
+    return ['string', undef];
   }
 };
 
 // ---------------------------------------------------------------------------
-export var debug = function(...lArgs) {
-  var auxPre, hEnv, hOptions, item, lResult, label, mainPre, nArgs, orgDebugging, trans, type;
-  // --- We want to allow item to be undef. Therefore, we need to
-  //     distinguish between 1 arg sent vs. 2 args sent
-  nArgs = lArgs.length;
-  assert((nArgs === 1) || (nArgs === 2), `debug(): ${nArgs} args`);
-  [label, item] = lArgs;
-  assert(isString(label), `debug(): 1st arg ${OL(label)} should be a string`);
-  if (doDebugDebug) {
-    if (nArgs === 1) {
-      LOG(`debug('${escapeStr(label)}') - 1 arg`);
-    } else {
-      LOG(`debug('${escapeStr(label)}', ${typeof item}) - 2 args`);
-    }
-  }
-  // --- We always need to manipulate the stack when we encounter
-  //     either "enter X" or "return from X", so we can't short-circuit
-  //     when debugging is off
-  lResult = adjustStack(label);
-  if (doDebugDebug) {
-    LOG('lResult', lResult);
-  }
-  [mainPre, auxPre, hEnv, type] = lResult;
-  if (doDebugDebug && (type === undef)) {
-    LOG("type is undef - NOT LOGGING");
-  }
-  hOptions = {
-    prefix: mainPre,
-    itemPrefix: auxPre
-  };
+export var debug = function(label, ...lObjects) {
+  var doLog, funcName, i, j, k, l, len1, len2, len3, level, nObjects, obj, prefix, 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
+  nObjects = lObjects.length;
+  // --- funcName is only set for types 'enter' and 'return'
+  [type, funcName] = getType(label, nObjects);
   switch (type) {
     case 'enter':
-      log(label, hOptions);
-      if (nArgs === 2) {
-        // --- don't repeat the label
-        logItem(undef, item, hOptions);
+      doLog = shouldLog(type, funcName, callStack);
+      // --- If we won't be logging when funcName is activated
+      //     then change 'enter' to 'call'
+      callStack.enter(funcName); // add to call stack
+      if (!shouldLog('string', 'abc', callStack)) {
+        label = label.replace('enter', 'call');
       }
+      callStack.returnFrom(funcName); // remove from call stack
       break;
     case 'return':
-      log(label, hOptions);
-      if (nArgs === 2) {
-        // --- don't repeat the label
-        logItem(undef, item, hOptions);
-      }
+      doLog = shouldLog(type, funcName, callStack);
       break;
     case 'string':
-      if (nArgs === 2) {
-        logItem(label, item, hOptions);
-      } else {
-        log(label, hOptions);
-      }
+      doLog = shouldLog(type, label, callStack);
+      assert(nObjects === 0, `multiple objects only not allowed for ${OL(type)}`);
+      break;
+    case 'objects':
+      doLog = shouldLog(type, label, callStack);
+      assert(nObjects > 0, `multiple objects only not allowed for ${OL(type)}`);
   }
-  if (hEnv) {
-    orgDebugging = debugging;
-    ({debugging, shouldLogFunc, shouldLogString} = hEnv);
+  if (doDebugDebug) {
+    if (nObjects === 0) {
+      LOG(`debug(${OL(label)}) - 1 arg`);
+    } else {
+      LOG(`debug(${OL(label)}), ${nObjects} args`);
+    }
+    LOG(`doLog = ${OL(doLog)}`);
+    LOG(`type = ${OL(type)}`);
+    LOG(`funcName = ${OL(funcName)}`);
+  }
+  if (doLog) {
+    level = callStack.getLevel();
+    prefix = getPrefix(level);
     if (doDebugDebug) {
-      trans = `${orgDebugging} => ${debugging}`;
-      LOG(`   Restore hEnv: debugging: ${trans}`);
+      LOG("callStack", callStack);
+      LOG(`level = ${OL(level)}`);
+      LOG(`prefix = ${OL(prefix)}`);
     }
+    switch (type) {
+      case 'enter':
+        log(label, {prefix});
+        for (i = j = 0, len1 = lObjects.length; j < len1; i = ++j) {
+          obj = lObjects[i];
+          if (i > 0) {
+            log(sep_dash, {
+              prefix: removeLastVbar(prefix)
+            });
+          }
+          logItem(undef, obj, {
+            prefix: removeLastVbar(prefix)
+          });
+        }
+        break;
+      case 'return':
+        log(label, {
+          prefix: addArrow(prefix)
+        });
+        for (i = k = 0, len2 = lObjects.length; k < len2; i = ++k) {
+          obj = lObjects[i];
+          if (i > 0) {
+            log(sep_dash, {
+              prefix: removeLastVbar(prefix)
+            });
+          }
+          logItem(undef, obj, {
+            prefix: removeLastVbar(prefix)
+          });
+        }
+        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, len3 = lObjects.length; l < len3; l++) {
+            obj = lObjects[l];
+            logItem(undef, obj, {prefix});
+          }
+        }
+    }
+  }
+  if (type === 'enter') {
+    callStack.enter(funcName, doLog);
+  } else if (type === 'return') {
+    callStack.returnFrom(funcName);
   }
   return true; // allow use in boolean expressions
 };
@@ -229,12 +255,12 @@ reMethod = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
 
 // ---------------------------------------------------------------------------
 export var checkTrace = function(block) {
-  var funcName, i, lMatches, lStack, len, len1, line, ref;
+  var funcName, j, lMatches, lStack, len, len1, line, ref;
   // --- export only to allow unit tests
   lStack = [];
   ref = blockToArray(block);
-  for (i = 0, len1 = ref.length; i < len1; i++) {
-    line = ref[i];
+  for (j = 0, len1 = ref.length; j < len1; j++) {
+    line = ref[j];
     if (lMatches = line.match(/enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
       funcName = lMatches[1];
       lStack.push(funcName);