Process with statements.
508615
def with_stmt_handle(self, tokens):
        """"""
        internal_assert(len(tokens) == 2, "invalid with statement tokens", tokens)
        withs, body = tokens
        if len(withs) == 1 or self.target_info >= (2, 7):
            return "with " + ", ".join(withs) + body
        else:
            return (
                "".join("with " + expr + ":\n" + openindent for expr in withs[:-1])
                + "with " + withs[-1] + body
                + closeindent * (len(withs) - 1)
            )
285449
private function processEntries(): void
    {
        if (empty($this->lines)) {
            return;
        }

        foreach ($this->lines as $line) {

            if ($this->isLineComment($line) || !$this->isLineSetter($line)) {
                continue;
            }

            $this->setVariable($line);
        }
    }
566381
public function postProcess()
    {
        foreach ($this->info as $key => $v) {
            if (count((array) $v) == 1) {
                $this->info[$key] = $v->type;
            } elseif (count((array) $v) == 2 && isset($v->allow_null)) {
                $this->info[$key] = -$v->type;
            }
        }
    }
1268428
def expressions(self):
        
        for s in self.statements:
            for expr_ in s.expressions:
                yield expr_
        yield self.next
944278
def process_defs(exp, parent)
      inside_new_context(Context::SingletonMethodContext, exp, parent) do
        increase_statement_count_by(exp.body)
        process(exp)
      end
    end
379011
def _Execute(statements, context, callback, trace):
    
    # Every time we call _Execute, increase this depth
    if trace:
        trace.exec_depth += 1
    for i, statement in enumerate(statements):
        if isinstance(statement, six.string_types):
            callback(statement)
        else:
            # In the case of a substitution, args is a pair (name, formatters).
            # In the case of a section, it's a _Section instance.
            try:
                func, args = statement
                func(args, context, callback, trace)
            except UndefinedVariable as e:
                # Show context for statements
                start = max(0, i - 3)
                end = i + 3
                e.near = statements[start:end]
                e.trace = trace  # Attach caller's trace (could be None)
                raise
1025284
public function process() : void
    {
        if (isset($this->output)) {
            $this->output->call($this);
        } elseif (!$this->delegated) {
            self::$inout->error("Recipe is missing a call to `output` and did not delegate anything, not very useful probably...\n");
        }
    }
841046
function (statements) {
            for (var i = 0, len = statements.length; i < len; i += 1) {
                var statement = statements[i];
                this.STATEMENTS[statement] = this.ALLSTATEMENTS[statement];
            }
        }
1351567
private Object exec(StatementContext statement) {
    if (statement == null)
      return null;
    return statement.accept(visitor);
  }
42930
public void perform() {
        for (int i = 0; i < operations.size(); i++) {
            operations.get(i).process();
        }
    }
1302913
def assign(self, expr):
        """"""
        name = self.variable()
        self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr))
        return ast.Name(name, ast.Load())
434946
private void processTypeVariables(TypeVariable<?>[] variables, Type[] values) {
        for (int i = 0; i < variables.length; i++) {
            processTypeVariable(variables[i], values[i]);
        }
    }
543288
private void setupEPStatements() {
        for (EsperStatement statement : statements) {
            EPStatement epStatement = epServiceProvider.getEPAdministrator().createEPL(statement.getEPL());
            statement.setEPStatement(epStatement);
        }
    }
924976
private WithList XreadWithClause() {
        boolean recursive = false;
        if (withStatementDepth > 0) {
        	throw Error.error("With statements may not be nested.");
        }
        int oldStatementDepth = withStatementDepth;
        try {
        	session.clearLocalTables();
	        withStatementDepth += 1;
	        readThis(Tokens.WITH);
	        if (token.tokenType == Tokens.RECURSIVE) {
	            recursive = true;
	            read();
	        }
	        WithList withList = new WithList(recursive);
	        XreadWithList(withList);
	        return withList;
        } finally {
        	withStatementDepth = oldStatementDepth;
        }
    }
222088
def process(ctx, dataset, kwargs):
    ""

    kwargs = parse_kwargs(kwargs)
    data(dataset, **ctx.obj).process(**kwargs)
1006778
def execute(self, *args, **kwargs):
        
        args = self.parser.parse_args(*args, **kwargs)
        self.process(args)
883828
def print_statements(self):
        """"""
        for i, stmt in enumerate(self.statements):
            print("%s: %s" % (i, stmt))