| /external/clang/test/Misc/ |
| ast-dump-stmt.cpp | 5 int Variable;
8 using n::Variable;
12 Variable = 4;
13 // CHECK: DeclRefExpr{{.*}} (UsingShadow{{.*}}Variable
|
| /frameworks/base/tools/aidl/ |
| Type.h | 48 virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
49 Variable* parcel, int flags);
50 virtual void CreateFromParcel(StatementBlock* addTo, Variable* v,
51 Variable* parcel, Variable** cl);
52 virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,
53 Variable* parcel, Variable** cl);
57 virtual void WriteArrayToParcel(StatementBlock* addTo, Variable* v,
58 Variable* parcel, int flags)
[all...] |
| Type.cpp | 230 Type::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
239 Type::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
248 Type::ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Variable**)
257 Type::WriteArrayToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags
[all...] |
| generate_java.h | 24 Variable* Get(Type* type);
25 Variable* Get(int index);
27 vector<Variable*> m_vars;
|
| generate_java_rpc.cpp | 33 Variable* v, Variable* data, Variable** cl);
34 static void generate_new_array(Type* t, StatementBlock* addTo, Variable* v, Variable* from);
35 static void generate_write_to_data(Type* t, StatementBlock* addTo, Expression* k, Variable* v,
36 Variable* data);
95 Variable* actionParam;
96 Variable* requestParam;
97 Variable* rpcContextParam
[all...] |
| generate_java_binder.cpp | 15 Variable* transact_code;
16 Variable* transact_data;
17 Variable* transact_reply;
18 Variable* transact_flags;
36 new Variable(STRING_TYPE, "DESCRIPTOR"));
65 this->transact_code = new Variable(INT_TYPE, "code");
66 this->transact_data = new Variable(PARCEL_TYPE, "data");
67 this->transact_reply = new Variable(PARCEL_TYPE, "reply");
68 this->transact_flags = new Variable(INT_TYPE, "flags");
96 Variable* obj = new Variable(IBINDER_TYPE, "obj")
[all...] |
| /external/deqp/framework/randomshaders/ |
| rsgVariableManager.hpp | 23 * \brief Variable manager.
26 * Variable manager owns variable objects until they are either explictly
46 ValueEntry (const Variable* variable);
49 const Variable* getVariable (void) const { return m_variable; }
55 const Variable* m_variable;
59 // Variable scope manages variable allocation.
66 Variable* allocate (const VariableType& type, Variable::Storage storage, const char* name)
[all...] |
| rsgFunctionGenerator.hpp | 41 void requireAssignment (Variable* variable) { m_requiredAssignments.push_back(variable); }
48 std::vector<Variable*> m_requiredAssignments;
|
| rsgExecutionContext.hpp | 46 typedef std::map<const Variable*, ExecValueStorage*> VarValueMap;
66 ExecValueAccess getValue (const Variable* variable);
67 const Sampler2D& getSampler2D (const Variable* variable) const;
68 const SamplerCube& getSamplerCube (const Variable* variable) const;
|
| rsgVariableManager.cpp | 21 * \brief Variable manager.
95 ValueEntry::ValueEntry (const Variable* variable)
96 : m_variable (variable)
97 , m_valueRange (variable->getType())
107 for (vector<Variable*>::iterator i = m_declaredVariables.begin(); i != m_declaredVariables.end(); i++)
110 for (vector<Variable*>::iterator i = m_liveVariables.begin(); i != m_liveVariables.end(); i++)
114 Variable* VariableScope::allocate (const VariableType& type, Variable::Storage storage, const char* name)
116 Variable* variable = new Variable(type, storage, name) local
249 Variable* variable = varScope.allocate(type, Variable::STORAGE_LOCAL, name); local
[all...] |
| rsgShaderGenerator.cpp | 65 void createAssignment (BlockStatement& block, const Variable* dstVar, const Variable* srcVar)
101 const Variable* outVar = entry->getVariable();
104 if (outVar->getStorage() != Variable::STORAGE_SHADER_OUT)
114 Variable* inVar = state.getVariableManager().allocate(outVar->getType(), Variable::STORAGE_SHADER_IN, inVarName.c_str());
130 Variable* inColorVariable = state.getVariableManager().allocate(fragColorEntry->getVariable()->getType(), Variable::STORAGE_SHADER_IN, "v_color");
197 Variable* variable = m_state.getVariableManager().allocate(input->getVariable()->getType(), Variable::STORAGE_SHADER_ (…) local
231 Variable* variable = *i; local
277 Variable* variable = *i; local
[all...] |
| rsgVariable.hpp | 23 * \brief Variable class.
37 class Variable
54 Variable (const VariableType& type, Storage storage, const char* name);
55 ~Variable (void);
|
| rsgShader.hpp | 49 void addParameter (Variable* variable);
58 std::vector<Variable*> m_parameters;
67 ShaderInput (const Variable* variable, ConstValueRangeAccess valueRange);
70 const Variable* getVariable (void) const { return m_variable; }
75 const Variable* m_variable;
115 void getOutputs (std::vector<const Variable*>& outputs) const;
|
| rsgVariable.cpp | 21 * \brief Variable class.
31 Variable::Variable (const VariableType& type, Storage storage, const char* name)
39 Variable::~Variable (void)
43 void Variable::tokenizeDeclaration (GeneratorState& state, TokenStream& str) const
|
| /external/javassist/src/main/javassist/compiler/ast/ |
| Variable.java | 21 * Variable.
23 public class Variable extends Symbol {
26 public Variable(String sym, Declarator d) {
|
| /external/chromium_org/v8/src/ |
| variables.cc | 15 // Implementation Variable.
17 const char* Variable::Mode2String(VariableMode mode) {
35 Variable::Variable(Scope* scope,
62 bool Variable::IsGlobalObjectProperty() const {
71 int Variable::CompareIndex(Variable* const* v, Variable* const* w) {
|
| scopes.h | 17 // A hash map to support fast variable declaration and lookup.
24 Variable* Declare(Scope* scope,
28 Variable::Kind kind,
32 Variable* Lookup(Handle<String> name);
64 // to a JavaScript variable (including global properties) is represented by a
65 // VariableProxy node. Immediately after AST construction and before variable
67 // corresponding variable (though some are bound during parse time). Variable
68 // allocation binds each unresolved VariableProxy to one Variable and assigns
70 // Script variable
[all...] |
| variables.h | 17 // after binding and variable allocation.
19 class Variable: public ZoneObject {
28 // Before and during variable allocation, a variable whose location is
29 // not yet determined. After allocation, a variable looked up as a
31 // variable name, index() is invalid.
39 // A slot in the local section on the stack. index() is the variable
43 // An indexed slot in a heap context. index() is the variable index in
48 // A named slot in a heap context. name() is the variable name in the
54 Variable(Scope* scope
[all...] |
| scopes.cc | 22 // When inserting a new variable via Declare(), we rely on the fact that
23 // the handle location remains alive for the duration of that variable
24 // use. Because a Variable holding a handle with the same location exists
42 Variable* VariableMap::Declare(
47 Variable::Kind kind,
53 // The variable has not been declared yet -> insert it.
55 p->value = new(zone()) Variable(scope,
63 return reinterpret_cast<Variable*>(p->value);
67 Variable* VariableMap::Lookup(Handle<String> name) {
73 return reinterpret_cast<Variable*>(p->value)
145 Variable* variable = variables_.Declare(this, local
[all...] |
| /external/lldb/include/lldb/Symbol/ |
| Variable.h | 1 //===-- Variable.h ----------------------------------------------*- C++ -*-===//
24 class Variable : public UserID
30 Variable (lldb::user_id_t uid,
32 const char *mangled, // The mangled variable name for variables in namespaces
42 ~Variable();
67 // Since a variable can have a basename "i" and also a mangled
167 ConstString m_name; // The basename of the variable (no namespaces)
168 Mangled m_mangled; // The mangled name of the variable
169 lldb::SymbolFileTypeSP m_symfile_type_sp; // The type pointer of the variable (int, struct, class, etc)
171 SymbolContextScope *m_owner_scope; // The symbol file scope that this variable was defined i
[all...] |
| /external/deqp/modules/glshared/ |
| glsRandomShaderProgram.hpp | 57 const rsg::Variable* m_positionVar;
58 std::vector<const rsg::Variable*> m_vertexOutputs; //!< Other vertex outputs in the order they are passed to fragment shader.
59 const rsg::Variable* m_fragColorVar;
|
| /external/apache-xml/src/main/java/org/apache/xalan/templates/ |
| VarNameCollector.java | 28 import org.apache.xpath.operations.Variable;
31 * This class visits variable refs in an XPath and collects their QNames.
46 * Get the number of variable references that were collected.
67 * Visit a variable reference.
70 * @param var The variable reference object.
73 public boolean visitVariableRef(ExpressionOwner owner, Variable var)
|
| /external/clang/lib/Analysis/ |
| ThreadSafetyTIL.cpp | 55 for (Variable *V : Args) {
66 for (Variable *V : Args) {
75 for (Variable *V : Args) {
78 for (Variable *V : Instrs) {
92 // If E is a variable, then trace back through any aliases or redundant
95 while (auto *V = dyn_cast<Variable>(E)) {
98 if (V->kind() != Variable::VK_Let)
101 auto *V2 = dyn_cast<Variable>(D);
129 void simplifyIncompleteArg(Variable *V, til::Phi *Ph) {
|
| /external/valgrind/main/coregrind/ |
| m_addrinfo.c | 50 /* -- Perhaps the variable type/location data describes it? -- */
51 ai->Addr.Variable.descr1
54 ai->Addr.Variable.descr2
58 (void) VG_(get_data_description)( ai->Addr.Variable.descr1,
59 ai->Addr.Variable.descr2, a );
66 if (0 == VG_(strlen)( VG_(indexXA)( ai->Addr.Variable.descr1, 0 ))) {
67 VG_(deleteXA)( ai->Addr.Variable.descr1 );
68 ai->Addr.Variable.descr1 = NULL;
70 if (0 == VG_(strlen)( VG_(indexXA)( ai->Addr.Variable.descr2, 0 ))) {
71 VG_(deleteXA)( ai->Addr.Variable.descr2 )
[all...] |
| /external/clang/test/CXX/expr/expr.prim/expr.prim.lambda/ |
| p10.cpp | 19 int variable; // expected-note {{declared here}} local
20 (void)[&Overload] () {}; // expected-error {{does not name a variable}}
23 (void)[&Variable] () {}; // expected-error {{use of undeclared identifier 'Variable'; did you mean 'variable'}}
33 (void)[local, // expected-error{{reference to local variable 'local' declared in enclosing function 'test_reaching_scope'}}
|
