Returns a parameter variable declaration for an output variable for the specified
    parameter.
779464
def _ctypes_out(parameter):
    
    if (parameter.dimension is not None and ":" in parameter.dimension
        and "out" in parameter.direction and ("allocatable" in parameter.modifiers or
                                              "pointer" in parameter.modifiers)):
        if parameter.direction == "(inout)":
            return ("type(C_PTR), intent(inout) :: {}_o".format(parameter.name), True)
        else: #self.direction == "(out)" since that is the only other option.
            return ("type(C_PTR), intent(inout) :: {}_c".format(parameter.name), True)
1131835
def emit_var_assign(self, var, t):
        
        p = '*' if var.byref else ''  # Indirection prefix
        if self.O_LEVEL > 1 and not var.accessed:
            return

        if not var.type_.is_basic:
            raise NotImplementedError()

        if var.scope == SCOPE.global_:
            self.emit('store' + self.TSUFFIX(var.type_), var.mangled, t)
        elif var.scope == SCOPE.parameter:
            self.emit('pstore' + self.TSUFFIX(var.type_), p + str(var.offset), t)
        elif var.scope == SCOPE.local:
            if var.alias is not None and var.alias.class_ == CLASS.array:
                var.offset -= 1 + 2 * var.alias.count
            self.emit('pstore' + self.TSUFFIX(var.type_), p + str(-var.offset), t)
158014
def visit_FunctionDeclaration(self, node):
        """"""
        for parameter in node.parameters:
            try:
                var_name = parameter.variable.identifier.name
                var_is_mutable = parameter.variable.is_mutable
            except AttributeError:
                raise SementicError('Invalid parameter.')

            var_symbol = VariableSymbol(var_name, var_is_mutable)

            if self.table[var_name] is not None:
                raise SementicError(f"Duplicated `{var_name}` function parameter.")

            self.table[var_name] = var_symbol

        self.visit(node.body)
618811
public static Variable getDeclaredVariable(Class<?> type, String name) {
        if (!isGeneratedClass(type))
            return null;
        Variable var = getVariable(type, name);
        if (null == var && !type.isInterface())
            return getVariable(getNewInstance(type), name);
        return var;
    }
420033
protected static Variable findTargetVariable(VariableExpression ve) {
        final Variable accessedVariable = ve.getAccessedVariable() != null ? ve.getAccessedVariable() : ve;
        if (accessedVariable != ve) {
            if (accessedVariable instanceof VariableExpression)
                return findTargetVariable((VariableExpression) accessedVariable);
        }
        return accessedVariable;
    }
1368638
def variable_declaration(self):
        
        self._process(Nature.LET)
        node = VariableDeclaration(assignment=self.assignment())
        self._process(Nature.SEMI)
        return node
369583
def p_variable_declaration(self, p):
        
        if len(p) == 2:
            p[0] = self.asttypes.VarDecl(p[1])
            p[0].setpos(p)  # require yacc_tracking
        else:
            p[0] = self.asttypes.VarDecl(p[1], p[2])
            p[0].setpos(p, additional=(('=', 2),))
843466
public static String get(VariableElement variable) {
    StringBuilder result = new StringBuilder();
    AnnotationMirror qualifier = getQualifier(variable.getAnnotationMirrors());
    if (qualifier != null) {
      qualifierToString(qualifier, result);
    }
    typeToString(variable.asType(), result, '$');
    return result.toString();
  }
1062410
def variable(
            self,
            name=None,
            function=None,
            decl_type=None,
            header_dir=None,
            header_file=None,
            recursive=None):
        """"""

        return (
            self._find_single(
                self._impl_matchers[
                    scopedef_t.variable],
                name=name,
                function=function,
                decl_type=decl_type,
                header_dir=header_dir,
                header_file=header_file,
                recursive=recursive)
        )
159615
def getParameterByValue(self, value):
        """"""
        result = None
        for parameter in self.getParameters():
            valueParam = parameter.getValue()
            if valueParam == value:
                result = parameter
                break
        return result
360573
function parseVariableIdentifier() {
        var token = lex();

        if (token.type !== Token.Identifier) {
            throwUnexpected(token);
        }

        return {
            type: Syntax.Identifier,
            name: token.value
        };
    }
631294
private Variable createVariableInferred(TokenList.Token t0, Variable variableRight) {
        Variable result;

        if( t0.getType() == Type.WORD ) {
            switch( variableRight.getType()) {
                case MATRIX:
                    alias(new DMatrixRMaj(1,1),t0.getWord());
                    break;

                case SCALAR:
                    if( variableRight instanceof VariableInteger) {
                        alias(0,t0.getWord());
                    } else {
                        alias(1.0,t0.getWord());
                    }
                    break;

                case INTEGER_SEQUENCE:
                    alias((IntegerSequence)null,t0.getWord());
                    break;

                default:
                    throw new RuntimeException("Type not supported for assignment: "+variableRight.getType());
            }

            result = variables.get(t0.getWord());
        } else {
            result = t0.getVariable();
        }
        return result;
    }
734740
def parameter(self, parameter_id):
        """"""
        for parametergroup, parameters in self.parameters: #pylint: disable=unused-variable
            for parameter in parameters:
                if parameter.id == parameter_id:
                    return parameter
        raise KeyError("No such parameter exists: " + parameter_id )
1373726
public Map<String, String> results(OutputVariable outputVariable) {
        return results(outputVariable, TimeUnit.NanoSeconds);
    }
1297804
def p_variable(p):
    ''''''
    if len(p) == 6:
        name, dims = p[3]
        params = p[4]
        if params is not None:
            p[0] = ast.MethodCall(p[1], name, params, lineno=p.lineno(2))
        else:
            p[0] = ast.ObjectProperty(p[1], name, lineno=p.lineno(2))
        for class_, dim, lineno in dims:
            p[0] = class_(p[0], dim, lineno=lineno)
        for (name, dims), params in p[5]:
            if params is not None:
                p[0] = ast.MethodCall(p[0], name, params, lineno=p.lineno(2))
            else:
                p[0] = ast.ObjectProperty(p[0], name, lineno=p.lineno(2))
            for class_, dim, lineno in dims:
                p[0] = class_(p[0], dim, lineno=lineno)
    else:
        p[0] = p[1]
1357895
private WyalFile.VariableDeclaration[] generateLoopInvariantParameterDeclarations(Stmt.Loop loop,
			LocalEnvironment environment) {
		// Extract all used variables within the loop invariant. This is necessary to
		// determine what parameters are required for the loop invariant macros.
		Tuple<Decl.Variable> modified = determineUsedVariables(loop.getInvariant());
		WyalFile.VariableDeclaration[] vars = new WyalFile.VariableDeclaration[modified.size()];
		// second, set initial environment
		for (int i = 0; i != modified.size(); ++i) {
			WyilFile.Decl.Variable var = modified.get(i);
			vars[i] = environment.read(var);
		}
		return vars;
	}
170138
def __handle_variable(self, shell_entry, output):
        
        if 'variable' in shell_entry:
            variable_name = shell_entry['variable']
            self.pipeline.variables[variable_name] = "\n".join(output)