ConstantExpression.h

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef CONSTANT_EXPRESSION_H_

#define CONSTANT_EXPRESSION_H_

#include <android-base/macros.h>
#include <memory>
#include <string>

#include "Reference.h"
#include "ScalarType.h"

namespace android {

struct LocalIdentifier;

struct LiteralConstantExpression;
struct UnaryConstantExpression;
struct BinaryConstantExpression;
struct TernaryConstantExpression;
struct ReferenceConstantExpression;

/**
 * A constant expression is represented by a tree.
 */
struct ConstantExpression {
    static std::unique_ptr<ConstantExpression> Zero(ScalarType::Kind kind);
    static std::unique_ptr<ConstantExpression> One(ScalarType::Kind kind);
    static std::unique_ptr<ConstantExpression> ValueOf(ScalarType::Kind kind, uint64_t value);

    virtual ~ConstantExpression() {}

    /*
     * Runs recursive evaluation.
     * Provides sort of lazy computation,
     * mainly used for forward identifier reference.
     */
    virtual void evaluate() = 0;

    /* Returns true iff the value has already been evaluated. */
    bool isEvaluated() const;
    /* Evaluated result in a string form. */
    std::string value() const;
    /* Evaluated result in a string form. */
    std::string cppValue() const;
    /* Evaluated result in a string form. */
    std::string javaValue() const;
    /* Evaluated result in a string form, with given contextual kind. */
    std::string value(ScalarType::Kind castKind) const;
    /* Evaluated result in a string form, with given contextual kind. */
    std::string cppValue(ScalarType::Kind castKind) const;
    /* Evaluated result in a string form, with given contextual kind. */
    std::string javaValue(ScalarType::Kind castKind) const;
    /* Formatted expression with type. */
    const std::string& description() const;
    /* See mTrivialDescription */
    bool descriptionIsTrivial() const;
    /* Return a ConstantExpression that is 1 plus the original. */
    std::unique_ptr<ConstantExpression> addOne(ScalarType::Kind baseKind);

    size_t castSizeT() const;

   private:
    /* If the result value has been evaluated. */
    bool mIsEvaluated = false;

    /* The formatted expression. */
    std::string mExpr;
    /* The kind of the result value. */
    ScalarType::Kind mValueKind;
    /* The stored result value. */
    uint64_t mValue;
    /* true if description() does not offer more information than value(). */
    bool mTrivialDescription = false;

    /*
     * Helper function for all cpp/javaValue methods.
     * Returns a plain string (without any prefixes or suffixes, just the
     * digits) converted from mValue.
     */
    std::string rawValue(ScalarType::Kind castKind) const;

    /*
     * Return the value casted to the given type.
     * First cast it according to mValueKind, then cast it to T.
     * Assumes !containsIdentifiers()
     */
    template <typename T>
    T cast() const;

    friend struct LiteralConstantExpression;
    friend struct UnaryConstantExpression;
    friend struct BinaryConstantExpression;
    friend struct TernaryConstantExpression;
    friend struct ReferenceConstantExpression;
};

struct LiteralConstantExpression : public ConstantExpression {
    LiteralConstantExpression(ScalarType::Kind kind, uint64_t value);
    LiteralConstantExpression(const std::string& value);
    void evaluate() override;
};

struct UnaryConstantExpression : public ConstantExpression {
    UnaryConstantExpression(const std::string& mOp, ConstantExpression* value);
    void evaluate() override;

   private:
    ConstantExpression* const mUnary;
    std::string mOp;
};

struct BinaryConstantExpression : public ConstantExpression {
    BinaryConstantExpression(ConstantExpression* lval, const std::string& op,
                             ConstantExpression* rval);
    void evaluate() override;

   private:
    ConstantExpression* const mLval;
    ConstantExpression* const mRval;
    const std::string mOp;
};

struct TernaryConstantExpression : public ConstantExpression {
    TernaryConstantExpression(ConstantExpression* cond, ConstantExpression* trueVal,
                              ConstantExpression* falseVal);
    void evaluate() override;

   private:
    ConstantExpression* const mCond;
    ConstantExpression* const mTrueVal;
    ConstantExpression* const mFalseVal;
};

struct ReferenceConstantExpression : public ConstantExpression {
    ReferenceConstantExpression(const Reference<LocalIdentifier>& value, const std::string& expr);
    void evaluate() override;

   private:
    Reference<LocalIdentifier> mReference;
};

}  // namespace android

#endif  // CONSTANT_EXPRESSION_H_