Return both variable names used in the #for loop in the
        current line.
190245
def _compile(cls, lines):
        ''''''
        m = cls.RE_FOR.match(lines.current)
        if m is None:
            raise DefineBlockError(
                'Incorrect block definition at line {}, {}\nShould be '
                'something like: #for @item in @items:'
                .format(lines.pos, lines.current))
        return m.group(1), m.group(2).replace('.', '-')
1355827
def __getVariables(self):
        """'"""
        try:
            startupinfo = None
            if os.name == 'nt':
                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            output = subprocess.check_output(['p4', 'set'], startupinfo=startupinfo)
            if six.PY3:
                output = str(output, 'utf8')
        except subprocess.CalledProcessError as err:
            LOGGER.error(err)
            return

        p4vars = {}
        for line in output.splitlines():
            if not line:
                continue
            try:
                k, v = line.split('=', 1)
            except ValueError:
                continue
            p4vars[k.strip()] = v.strip().split(' (')[0]
            if p4vars[k.strip()].startswith('(config'):
                del p4vars[k.strip()]

        self._port = self._port or os.getenv('P4PORT', p4vars.get('P4PORT'))
        self._user = self._user or os.getenv('P4USER', p4vars.get('P4USER'))
        self._client = self._client or os.getenv('P4CLIENT', p4vars.get('P4CLIENT'))
852169
def _var(ins):
    
    output = []
    output.append('%s:' % ins.quad[1])
    output.append('DEFB %s' % ((int(ins.quad[2]) - 1) * '00, ' + '00'))

    return output
35596
def varnames(self):
        
        # We must sort to preserve the order between calls.
        # The set comprehension is to drop the duplicates.
        return self._argnames + tuple(sorted({
            instr.arg
            for instr in self.instrs
            if instr.uses_varname and instr.arg not in self._argnames
        }))
226688
def _varname_inj(self):
        """"""
        # Bus Pi
        if not self.n:
            return
        m = self.system.dae.m
        xy_idx = range(m, self.n + m)
        self.system.varname.append(
            listname='unamey',
            xy_idx=xy_idx,
            var_name='P',
            element_name=self.name)
        self.system.varname.append(
            listname='fnamey',
            xy_idx=xy_idx,
            var_name='P',
            element_name=self.name)

        # Bus Qi
        xy_idx = range(m + self.n, m + 2 * self.n)
        self.system.varname.append(
            listname='unamey',
            xy_idx=xy_idx,
            var_name='Q',
            element_name=self.name)
        self.system.varname.append(
            listname='fnamey',
            xy_idx=xy_idx,
            var_name='Q',
            element_name=self.name)
1295950
def FOR(self, node):
        """"""
        vars = []

        def collectLoopVars(n):
            if isinstance(n, ast.Name):
                vars.append(n.id)
            elif isinstance(n, ast.expr_context):
                return
            else:
                for c in ast.iter_child_nodes(n):
                    collectLoopVars(c)

        collectLoopVars(node.target)
        for varn in vars:
            if (isinstance(self.scope.get(varn), Importation)
                    # unused ones will get an unused import warning
                    and self.scope[varn].used):
                self.report(messages.ImportShadowedByLoopVar,
                            node, varn, self.scope[varn].source)

        self.handle_children(node)
747170
def select(self, fixed):
        
        names = [n for n in self.names() if self[n].isfixed == fixed]
        return Variables({n: self[n] for n in names})
1367448
def get_vars(n):
    
    op = n[0]
    if op.startswith('_') and op.endswith('_'):
        op = op.strip('_')
        if op == 'var':
            return [n[1]]
        return []
    else:
        ret = []
        for c in n[1:]:
            vs = get_vars(c)
            if vs:
                ret.extend(vs)
        return ret
24334
def _get_variable_name_or_register(var, variables, names, params, prefix):
    '''
    
    '''
    if var not in variables.values():
        vname = prefix
        if var.data in params:
            vname = params[var.data]
        elif var in names:
            vname = names[var]
        vname = _get_unique_variable_name(vname, variables)
        variables[vname] = var
    else:
        vname = list(variables.keys())[list(variables.values()).index(var)]

    return vname
891989
function getVariableName()
		{
			$arrBacktrace = debug_backtrace();

			//possible 'included' functions
			$arrInclude = array("include","include_once","require","require_once");

			//check for any included/required files. if found, get array of the last included file (they contain the right line numbers)
			$countBt = count($arrBacktrace);
			for($i = $countBt - 1 ; $i >= 0 ; $i--) {
				$arrCurrent = $arrBacktrace[$i];
				if(Arrays::exists("function", $arrCurrent) && (Arrays::inArray($arrCurrent["function"], $arrInclude) || (0 != strcasecmp($arrCurrent["function"], "dbug")))) {
					continue;
				}

				$arrFile = $arrCurrent;

				break;
			}

			if(isset($arrFile)) {
				$arrLines = file($arrFile["file"]);
				$code = $arrLines[($arrFile["line"]-1)];

				//find call to dBug class
				preg_match('/\bnew dBug\s*\(\s*(.+)\s*\);/i', $code, $arrMatches);

				return $arrMatches[1];
			}
			return "";
		}
365997
function findVariableForAliases(varNames, aliases) {
  for (var j = 0; j < aliases.length; j++) {
    var re = new RegExp("^" + aliases[j] + "$", "i");
    for (var i = 0; i < varNames.length; i++) {
      if (re.test(varNames[i])) {
        return varNames[i];
      }
    }
  }
  return undefined;
}
488690
def get_variables
      return unless File.exists?(ENV_FILE)

      File.open(ENV_FILE).each do |line|
        var_name = line.split("=").first
        yield var_name unless line =~ /^\#/
      end
    end
1316
public String getMethodVariables(String strMethodInterface)
    {
        int endChar = 0, startChar = 0;
        String strMethodVariables = "";
        int i = 0;
        boolean bBracketFound = false;
        for (i = 0; i < strMethodInterface.length(); i++)
        {
            if (strMethodInterface.charAt(i) == '<')
                bBracketFound = true;
            if (strMethodInterface.charAt(i) == '>')
                bBracketFound = false;
            if (bBracketFound)
                continue;   // Skip the area between the brackets.
            if (strMethodInterface.charAt(i) == ' ')
                startChar = i + 1;
            if (strMethodInterface.charAt(i) == ',')
            {
                endChar = i;
                if (endChar > startChar)
                {
                    if (strMethodVariables.length() != 0)
                        strMethodVariables += ", ";
                    strMethodVariables += strMethodInterface.substring(startChar, endChar);
                }
            }
        }
        endChar = i;
        if (endChar > startChar)
        {
            if (strMethodVariables.length() != 0)
                strMethodVariables += ", ";
            strMethodVariables += strMethodInterface.substring(startChar, endChar);
        }
        return strMethodVariables;
    }
1225116
def getvariable(name):
    """"""
    import inspect
    fr = inspect.currentframe()
    try:
        while fr:
            fr = fr.f_back
            vars = fr.f_locals
            if name in vars:
                return vars[name]
    except:
        pass
    return None
505225
public List<Variable> getUsedVariables() {
        ArrayList<Variable> vars = new ArrayList<Variable>();

        for (Operand o : getOperands()) {
            o.addUsedVariables(vars);
        }

        return vars;
    }
1032388
def get_variables(self) -> Set[str]:
        
        variables = set()
        for cmd in self._cmd:
            for var in self.__formatter.parse(cmd):
                logger.debug("Checking variable: %s", var)
                # creates and requires are special class values
                if var[1] is not None and var[1] not in ["creates", "requires"]:
                    variables.add(var[1])
        return variables
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)