| /external/apache-xml/src/main/java/org/apache/xpath/ |
| ExpressionOwner.java | 24 * Classes that implement this interface own an expression, which
30 * Get the raw Expression object that this class wraps.
32 * @return the raw Expression object, which should not normally be null.
34 public Expression getExpression();
37 * Set the raw expression object for this object.
39 * @param exp the raw Expression object, which should not normally be null.
41 public void setExpression(Expression exp);
|
| /system/tools/hidl/c2hal/ |
| Expression.h | 30 struct Expression {
31 Expression() {}
32 virtual ~Expression() {}
69 static Expression *parenthesize(Expression *inner);
70 static Expression *atom(Type type, const std::string &value, bool isId = false);
71 static Expression *unary(std::string op, Expression *rhs);
72 static Expression *binary(Expression *lhs, std::string op, Expression *rhs)
[all...] |
| Expression.cpp | 17 #include "Expression.h"
32 Expression::Type Expression::integralType(std::string integer) {
54 Expression::Type Expression::coalesceTypes(Type lhs, Type rhs) {
82 struct ParenthesizedExpression : Expression {
83 ParenthesizedExpression(Expression* inner)
97 Expression* mInner;
102 struct AtomExpression : Expression {
133 struct UnaryExpression : Expression {
[all...] |
| EnumVarDeclaration.h | 28 struct Expression;
31 EnumVarDeclaration(const std::string &name, Expression *expression);
38 Expression *getExpression() const;
44 Expression *mExpression = NULL;
|
| Define.h | 25 #include "Expression.h"
39 Expression::Type getExpressionType() const;
40 Expression *getExpression() const;
41 void setExpression(Expression* expression);
46 Expression::Type mExpressionType;
47 Expression* mExpression = NULL;
|
| /external/v8/src/parsing/ |
| parameter-initializer-rewriter.h | 13 class Expression;
23 void ReparentParameterExpressionScope(uintptr_t stack_limit, Expression* expr,
|
| /device/linaro/bootloader/edk2/StdLib/Include/ |
| assert.h | 46 @param[in] failedexpr A literal representation of the assert's expression.
56 void expression.
58 When it is executed, if expression (which must have a scalar type) is
66 If NDEBUG is not defined, Expression is evaluated. If Expression evaluates to FALSE,
68 line number, and the Expression.
70 @param Expression Boolean expression.
75 #define assert(Expression) /* ignored */
78 #define assert(Expression) ((Expression) ? (void)0 :\
[all...] |
| /external/skia/src/sksl/ir/ |
| SkSLTernaryExpression.h | 17 * A ternary expression (test ? ifTrue : ifFalse).
19 struct TernaryExpression : public Expression {
20 TernaryExpression(Position position, std::unique_ptr<Expression> test,
21 std::unique_ptr<Expression> ifTrue, std::unique_ptr<Expression> ifFalse)
38 std::unique_ptr<Expression> fTest;
39 std::unique_ptr<Expression> fIfTrue;
40 std::unique_ptr<Expression> fIfFalse;
42 typedef Expression INHERITED;
|
| SkSLSetting.h | 20 struct Setting : public Expression {
21 Setting(Position position, String name, std::unique_ptr<Expression> value)
28 std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
44 std::unique_ptr<Expression> fValue;
46 typedef Expression INHERITED;
|
| SkSLBinaryExpression.h | 21 struct BinaryExpression : public Expression {
22 BinaryExpression(Position position, std::unique_ptr<Expression> left, Token::Kind op,
23 std::unique_ptr<Expression> right, const Type& type)
29 std::unique_ptr<Expression> constantPropagate(const IRGenerator& irGenerator,
46 std::unique_ptr<Expression> fLeft;
48 std::unique_ptr<Expression> fRight;
50 typedef Expression INHERITED;
|
| SkSLExpression.h | 18 struct Expression;
21 typedef std::unordered_map<const Variable*, std::unique_ptr<Expression>*> DefinitionMap;
26 struct Expression : public IRNode {
47 Expression(Position position, Kind kind, const Type& type)
53 * Returns true if this expression is constant. compareConstant must be implemented for all
61 * Compares this constant expression against another constant expression of the same type. It is
65 virtual bool compareConstant(const Context& context, const Expression& other) const {
70 * Returns true if evaluating the expression potentially has side effects. Expressions may never
78 * variables occurring in this expression and its subexpressions. Similar simplifications, suc
[all...] |
| SkSLPostfixExpression.h | 17 * An expression modified by a unary operator appearing after it, such as 'i++'.
19 struct PostfixExpression : public Expression {
20 PostfixExpression(std::unique_ptr<Expression> operand, Token::Kind op)
33 std::unique_ptr<Expression> fOperand;
36 typedef Expression INHERITED;
|
| SkSLVariableReference.h | 28 struct VariableReference : public Expression {
81 static std::unique_ptr<Expression> copy_constant(const IRGenerator& irGenerator,
82 const Expression* expr) {
85 case Expression::kIntLiteral_Kind:
86 return std::unique_ptr<Expression>(new IntLiteral(
90 case Expression::kFloatLiteral_Kind:
91 return std::unique_ptr<Expression>(new FloatLiteral(
95 case Expression::kBoolLiteral_Kind:
96 return std::unique_ptr<Expression>(new BoolLiteral(irGenerator.fContext,
99 case Expression::kConstructor_Kind:
[all...] |
| SkSLExpressionStatement.h | 17 * A lone expression being used as a statement.
20 ExpressionStatement(std::unique_ptr<Expression> expression)
21 : INHERITED(expression->fPosition, kExpression_Kind)
22 , fExpression(std::move(expression)) {}
28 std::unique_ptr<Expression> fExpression;
|
| SkSLTypeReference.h | 20 struct TypeReference : public Expression {
35 typedef Expression INHERITED;
|
| /external/deqp/framework/randomshaders/ |
| rsgExpressionGenerator.hpp | 23 * \brief Expression generator.
42 Expression* generate (const ValueRange& valueRange, int initialDepth = 0);
45 void generate (Expression* root);
48 std::vector<Expression*> m_expressionStack;
|
| rsgExpressionGenerator.cpp | 21 * \brief Expression generator.
38 Expression* ExpressionGenerator::generate (const ValueRange& valueRange, int initialDepth)
42 Expression* root = Expression::createRandom(m_state, valueRange);
46 // Generate full expression
59 void ExpressionGenerator::generate (Expression* root)
72 Expression* curExpr = m_expressionStack[m_expressionStack.size()-1];
73 Expression* child = curExpr->createNextChild(m_state);
|
| rsgExpression.hpp | 50 class Expression
53 virtual ~Expression (void);
56 virtual Expression* createNextChild (GeneratorState& state) = DE_NULL;
62 virtual ExecValueAccess getLValue (void) const { DE_ASSERT(DE_FALSE); throw Exception("Expression::getLValue(): not L-value node"); }
64 static Expression* createRandom (GeneratorState& state, ConstValueRangeAccess valueRange);
65 static Expression* createRandomLValue (GeneratorState& state, ConstValueRangeAccess valueRange);
68 class VariableAccess : public Expression
73 Expression* createNextChild (GeneratorState& state) { DE_UNREF(state); return DE_NULL; }
106 class FloatLiteral : public Expression
112 Expression* createNextChild (GeneratorState& state) { DE_UNREF(state); return DE_NULL;
[all...] |
| /external/v8/src/ast/ |
| ast-type-bounds.h | 5 // A container to associate type bounds with AST Expression nodes.
16 class Expression;
23 AstBounds get(Expression* expression) const {
24 ZoneMap<Expression*, AstBounds>::const_iterator i =
25 bounds_map_.find(expression);
29 void set(Expression* expression, AstBounds bounds) {
30 bounds_map_[expression] = bounds;
34 ZoneMap<Expression*, AstBounds> bounds_map_
[all...] |
| compile-time-value.h | 14 class Expression;
26 static bool IsCompileTimeValue(Expression* expression);
29 static Handle<FixedArray> GetValue(Isolate* isolate, Expression* expression);
|
| /external/skia/src/sksl/ |
| SkSLIRGenerator.h | 70 * If both operands are compile-time constants and can be folded, returns an expression
74 std::unique_ptr<Expression> constantFold(const Expression& left,
76 const Expression& right) const;
101 std::unique_ptr<Expression> convertExpression(const ASTExpression& expression);
106 std::unique_ptr<Expression> call(Position position,
108 std::vector<std::unique_ptr<Expression>> arguments);
110 const std::vector<std::unique_ptr<Expression>>& arguments,
112 std::unique_ptr<Expression> call(Position position, std::unique_ptr<Expression> function
[all...] |
| /system/tools/aidl/ |
| ast_java.h | 64 struct Expression {
65 virtual ~Expression() = default;
69 struct LiteralExpression : public Expression {
78 struct StringLiteralExpression : public Expression {
86 struct Variable : public Expression {
100 struct FieldVariable : public Expression {
101 Expression* object;
105 FieldVariable(Expression* object, const std::string& name);
138 void Add(Expression* expression);
142 Expression* expression; member in struct:android::aidl::java::ExpressionStatement
225 Expression* expression = nullptr; member in struct:android::aidl::java::Cast
246 Expression* expression = nullptr; member in struct:android::aidl::java::IfStatement
256 Expression* expression; member in struct:android::aidl::java::ReturnStatement
299 Expression* expression; member in struct:android::aidl::java::SwitchStatement
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/operations/ |
| UnaryOperation.java | 23 import org.apache.xpath.Expression;
32 public abstract class UnaryOperation extends Expression implements ExpressionOwner
38 protected Expression m_right;
56 * Tell if this expression or it's subexpressions can traverse outside
71 * Set the expression operand for the operation.
74 * @param r The expression operand to which the unary operation will be
77 public void setRight(Expression r)
113 /** @return the operand of unary operation, as an Expression.
115 public Expression getOperand(){
134 public Expression getExpression(
[all...] |
| Operation.java | 23 import org.apache.xpath.Expression;
32 public class Operation extends Expression implements ExpressionOwner
36 /** The left operand expression.
38 protected Expression m_left;
40 /** The right operand expression.
42 protected Expression m_right;
62 * Tell if this expression or it's subexpressions can traverse outside
83 * @param l The left expression operand.
84 * @param r The right expression operand.
86 public void setLeftRight(Expression l, Expression r
[all...] |
| /external/apache-xml/src/main/java/org/apache/xpath/functions/ |
| Function2Args.java | 24 import org.apache.xpath.Expression;
38 Expression m_arg1;
43 * @return An expression that represents the second argument passed to the
46 public Expression getArg1()
70 * Set an argument expression for a function. This method is called by the
73 * @param arg non-null expression that represents the argument.
78 public void setArg(Expression arg, int argNum)
119 * Tell if this expression or it's subexpressions can traverse outside
135 public Expression getExpression()
142 * @see ExpressionOwner#setExpression(Expression)
[all...] |
