Optionally specify the variable name to use for the output of this condition
548885
@Override
    public ConditionBuilder as(String variable)
    {
        Assert.notNull(variable, "Variable name must not be null.");
        this.setOutputVariablesName(variable);
        return this;
    }
1298090
def _arg_varname(self, wire):
        
        if isinstance(wire, (Input, Register)):
            return 'd[' + repr(wire.name) + ']'  # passed in
        elif isinstance(wire, Const):
            return str(wire.val)  # hardcoded
        else:
            return self._varname(wire)
496604
def after_or_asgn
      variable = variable_stack.pop.first
      value    = value_stack.pop.first

      if variable and value
        conditional_assignment(variable, value, false)
      end
    end
1197665
private function VarNameState()
	{
		$this->SkipWhitespace();
		if ( ord( $this->Peek( 0 ) ) == 0 )
			return;
		$this->BeginToken();
		$c = $this->Peek( 0 );
		if ( preg_match( "/[\p{L}\p{N}_\-.]/u", $c ) )
		{
			$prefix = "";
			$sb = array();
			while ( ( $c = $this->Peek( 0 ) ) !== 0 && ord( $c ) != 0 && preg_match( "/[\p{L}\p{N}_\-.]/u", $c ) )
				$sb[] = $this->Read();
			if ( $this->Peek( 0 ) == ':' && preg_match( "/[\p{L}\p{N}_\-.]/u", $this->Peek( 1 ) ) )
			{
				$prefix = implode( "", $sb );
				$this->Read();
				$sb = array();
				while ( ( $c = $this->Peek( 0 ) ) !== 0 && ord( $c ) != 0 && preg_match( "/[\p{L}\p{N}_\-.]/u", $c ) )
					$sb[] = $this->Read();
			}
			$this->EndToken();
			$this->ConsumeToken2( Token::VarName, new VarName( $prefix, implode( "", $sb ) ) );
			$this->m_state = LexerState::Operator;
		}
	}
706249
void popOutputVar() {
    outputVars.pop();
    OutputVar outputVar = outputVars.peek(); // null if outputVars is now empty
    if (outputVar != null) {
      currOutputVarName = outputVar.name();
      currOutputVarIsInited = outputVar.isInited();
    } else {
      currOutputVarName = null;
      currOutputVarIsInited = false;
    }
  }
989227
def printed_out(self, name):
        
        opt = self.variables().optional_namestring()
        req = self.variables().required_namestring()
        out = ''
        out += '|   |\n'
        out += '|   |---{}({}{})\n'.format(name, req, opt)
        if self.description:
            out += '|   |       {}\n'.format(self.description)
        return out
1086450
def setval(self, varname, value):
        
        if varname in self:
            self[varname]['value'] = value
        else:
            self[varname] = Variable(self.default_type, value=value)
155496
def var(name)
    res = send_cmd("print #{name}").join("").chomp
    if /undefined variable:/ =~ res
      kernel_raise GnuplotError,res.strip
    end
    res
  end
1356542
def output(output_id, name, value_class=NumberValue):
        """"""
        def _init():
            return value_class(
                name,
                input_id=output_id,
                is_input=False,
                index=-1
            )
        def _decorator(cls):
            setattr(cls, output_id, _init())
            return cls
        return _decorator
531341
private static function setUndefinedVariables()
    {
        $list = array(
            'REQUEST_METHOD',
            'REMOTE_ADDR',
            'SERVER_NAME',
            'SERVER_PORT',
            'REQUEST_URI',
        );

        foreach ($list as $name) {
            if (!array_key_exists($name, $_SERVER)) {
                $_SERVER[$name] = '';
            }
        }
    }
1077626
def printed_out(self, name):
        
        out = ''
        out += '|\n'
        if self._id_variable:
            subs = '[{}]'.format(self._id_variable)
        else:
            subs = ''
        out += '|---{}{}\n'.format(name, subs)
        if self._description:
            out += '|   |   {}\n'.format(self._description)
        for name, action in self._actions.items():
            out += action.printed_out(name)
        return out
647498
def match_var(self, tokens, item):
        """"""
        setvar, = tokens
        if setvar != wildcard:
            if setvar in self.names:
                self.add_check(self.names[setvar] + " == " + item)
            else:
                self.add_def(setvar + " = " + item)
                self.names[setvar] = item
272438
def var_set(session, **kwargs):
        
        if not kwargs:
            for name, value in session.variables.items():
                session.write_line("{0}={1}".format(name, value))
        else:
            for name, value in kwargs.items():
                name = name.strip()
                session.set(name, value)
                session.write_line("{0}={1}", name, value)
583752
def get_output_var_names(self):
        
        # Return all the variables that aren't input variables
        all_vars = list(self.species_name_map.keys())
        output_vars = list(set(all_vars) - set(self.input_vars))
        # Re-map to outside var names if needed
        for idx, var in enumerate(output_vars):
            if self._map_in_out(var) is not None:
                output_vars[idx] = self._map_in_out(var)
        return output_vars
625630
def _py_outvar(parameter, lparams, tab):
    
    if ("out" in parameter.direction and parameter.D > 0 and ":" in parameter.dimension and
        ("allocatable" in parameter.modifiers or "pointer" in parameter.modifiers)):
        lparams.append("byref({}_o)".format(parameter.lname))
        blank = True if parameter.direction == "(inout)" else False
        return ("{0}_o = POINTER({1})()".format(parameter.lname, _py_ctype(parameter)), blank)
459683
def _variable(lexer):
    """"""
    names = _names(lexer)

    tok = next(lexer)
    # NAMES '[' ... ']'
    if isinstance(tok, LBRACK):
        indices = _indices(lexer)
        _expect_token(lexer, {RBRACK})
    # NAMES
    else:
        lexer.unpop_token(tok)
        indices = tuple()

    return ('var', names, indices)
692022
def assign_variable_names(self):
        

        for var in self._variables:
            if isinstance(var, SimStackVariable):
                if var.name is not None:
                    continue
                if var.ident.startswith('iarg'):
                    var.name = 'arg_%x' % var.offset
                else:
                    var.name = 's_%x' % (-var.offset)
                    # var.name = var.ident
            elif isinstance(var, SimRegisterVariable):
                if var.name is not None:
                    continue
                var.name = var.ident