Mark scripts as having already been evaluated
348066
function setGlobalEval( elems, refElements ) {
	var elem,
		i = 0;
	for ( ; (elem = elems[i]) != null; i++ ) {
		jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) );
	}
}
1281036
def script(klass, args, interval):
        
        if isinstance(args, six.string_types) \
                or isinstance(args, six.binary_type):
            warnings.warn(
                "Check.script should take a list of args", DeprecationWarning)
            args = ["sh", "-c", args]
        return {'args': args, 'interval': interval}
922454
function(markName) {
			if (window.performance && window.performance.mark !== undefined) {
				window.performance.mark(markName);
			}
		}
416003
def make_script_sig(stack_script, redeem_script):
    '''
    
    '''
    stack_script += ' {}'.format(
        serialization.hex_serialize(redeem_script))
    return serialization.serialize(stack_script)
706955
def script_repr(self,imports=[],prefix="    "):
        
        return self.pprint(imports,prefix,unknown_value='',qualify=True,
                           separator="\n")
478349
void markAllParametersEscaped() {
    Node paramList = NodeUtil.getFunctionParameters(jsScope.getRootNode());
    for (Node arg = paramList.getFirstChild(); arg != null; arg = arg.getNext()) {
      if (arg.isRest() || arg.isDefaultValue()) {
        escaped.add(jsScope.getVar(arg.getFirstChild().getString()));
      } else {
        escaped.add(jsScope.getVar(arg.getString()));
      }
    }
  }
348181
def pre_init():
    

    logger.info("Run pre-initiation hook of {} plugin.".format(__file__.split(os.path.sep)[-2]))

    # Example: Monkey-Path rafcon.core.script.Script class to print additional log-message while execution
    from rafcon.core.script import Script
    old_execute_method = Script.execute

    def new_execute_method(self, state, inputs=None, outputs=None, backward_execution=False):
        logger.debug("patched version of Script class is used.")
        result = old_execute_method(self, state, inputs, outputs, backward_execution)
        logger.debug("patched version of Script execute-method is finished with result: {}.".format(result))
        return result

    Script.execute = new_execute_method
29866
private function addScriptBefore($script) {
        $script = trim($script);
        if ($script != '') {
            if (strpos($this->script, $script) === false) {
                $this->script = "
				 {$script} 
				 {$this->script}";
            }
        }
    }
158102
def eval(self, script, keys=[], args=[]):
        """"""
        return self.execute(b'EVAL', script, len(keys), *(keys + args))
1259170
function eval$if(params) {
  var script = params.$if
              ? params.$then
              : typeof params.$else == 'undefined' ? null : params.$else;
  return isScript(script)
          ? new this.js.Script(script)
          : script;
}
900577
def get_script_str(self, reset=True):
        """"""
        s = "\n".join(l for l in self._lines)
        if reset:
            self.reset()
        return s
311526
function evalSha(redis, sha, keys, args, callback) {
  if (sha) {
    return redis.evalsha.apply(redis, _.flatten([sha, keys.length, keys, args, callback]));
  }
  return callback(new Error('evalsha called for not loaded script'));
}
1168981
function ScriptRunner() {
  this.flush();

  function onMessage(msg, handle) {
    var script, digest;
    switch(msg.event) {
      case 'loglevel':
        log.level(msg.level);
        break;
      case 'eval':
        try {
          script = this.load(msg.source).script;
          this.run(script, msg.args);
        }catch(e) {
          process.send({err: true, data: e.message});
        }
        break;
      case 'evalsha':
        try {
          script = this._cache[msg.sha];
          if(!script) throw NoScript;
          this.run(script, msg.args);
        }catch(e) {
          process.send({err: true, data: e.message});
        }
        break;
      case 'load':
        try {
          digest = this.load(msg.source).sha;
          process.send({data: digest});
        }catch(e) {
          process.send({err: true, data: e.message});
        }
        break;
      case 'exists':
        process.send({data: this.exists(msg.args)});
        break;
      case 'flush':
        this.flush();
        process.send({data: Constants.OK});
        break;
    }
  }

  process.on('message', onMessage.bind(this));
}
1189943
def _eval_script(redis, script_id, *keys, **kwargs):
    
    args = kwargs.pop('args', ())
    if kwargs:
        raise TypeError("Unexpected keyword arguments %s" % kwargs.keys())
    try:
        return redis.evalsha(SCRIPTS[script_id], len(keys), *keys + args)
    except NoScriptError:
        logger.info("%s not cached.", SCRIPTS[script_id + 2])
        return redis.eval(SCRIPTS[script_id + 1], len(keys), *keys + args)
419408
function(script)
	{
		// create local undefined vars so that script cannot access private vars
		var _namespaces = undefined;
		var _imported = undefined;
		var _loading = undefined;
		var _classPaths = undefined;
		var _classInfo = undefined;
		var _classDependencyList = undefined;
		var _mixinCount = undefined;
		var _mixinDependencies = undefined;
		var _evalScript = undefined;
		var _appendConstructor = undefined;

		// set arguments to undefined so that script cannot access
		arguments = undefined;

		// eval script in context of window
		eval.call(window, script);
	}
937964
private void notifyScriptChanged(ScriptWrapper script) {
		for (ScriptEventListener listener : this.listeners) {
			try {
				listener.scriptChanged(script);
			} catch (Exception e) {
				logScriptEventListenerException(listener, script, e);
			}
		}
	}
991708
public void markExecuted(@NonNull String nodeName, boolean executed) {

        states.get(nodeName).setExecuted(executed);
    }