Skip to content

Commit

Permalink
Moved over ValueTranslator functionality to cpp.
Browse files Browse the repository at this point in the history
  • Loading branch information
@azreika
azreika committed Oct 16, 2020
1 parent 34d3d11 commit 16ea32d
Show file tree
Hide file tree
Showing 2 changed files with 98 additions and 102 deletions.
67 changes: 67 additions & 0 deletions src/ast2ram/ValueTranslator.cpp
View file
Expand Up @@ -13,13 +13,27 @@
***********************************************************************/

#include "ast2ram/ValueTranslator.h"
#include "ast/IntrinsicFunctor.h"
#include "ast/NumericConstant.h"
#include "ast/RecordInit.h"
#include "ast/StringConstant.h"
#include "ast/UserDefinedFunctor.h"
#include "ast/analysis/Functor.h"
#include "ast2ram/AstToRamTranslator.h"
#include "ast2ram/ValueIndex.h"
#include "ram/AutoIncrement.h"
#include "ram/FloatConstant.h"
#include "ram/IntrinsicOperator.h"
#include "ram/PackRecord.h"
#include "ram/SignedConstant.h"
#include "ram/SubroutineArgument.h"
#include "ram/TupleElement.h"
#include "ram/UndefValue.h"
#include "ram/UnsignedConstant.h"
#include "ram/UserDefinedOperator.h"
#include "ram/utility/Utils.h"
#include "souffle/SymbolTable.h"
#include "souffle/utility/StringUtil.h"

namespace souffle::ast2ram {

Expand All @@ -46,4 +60,57 @@ Own<ram::Expression> ValueTranslator::visitNumericConstant(const ast::NumericCon
fatal("unexpected numeric constant type");
}

Own<ram::Expression> ValueTranslator::visitStringConstant(const ast::StringConstant& c) {
return mk<ram::SignedConstant>(symTab.lookup(c.getConstant()));
}

Own<ram::Expression> ValueTranslator::visitNilConstant(const ast::NilConstant&) {
return mk<ram::SignedConstant>(0);
}

Own<ram::Expression> ValueTranslator::visitIntrinsicFunctor(const ast::IntrinsicFunctor& inf) {
VecOwn<ram::Expression> values;
for (const auto& cur : inf.getArguments()) {
values.push_back(translator.translateValue(cur, index));
}

if (ast::analysis::FunctorAnalysis::isMultiResult(inf)) {
return translator.makeRamTupleElement(index.getGeneratorLoc(inf));
} else {
return mk<ram::IntrinsicOperator>(inf.getFunctionOp().value(), std::move(values));
}
}

Own<ram::Expression> ValueTranslator::visitUserDefinedFunctor(const ast::UserDefinedFunctor& udf) {
VecOwn<ram::Expression> values;
for (const auto& cur : udf.getArguments()) {
values.push_back(translator.translateValue(cur, index));
}
auto returnType = translator.getFunctorAnalysis()->getReturnType(&udf);
auto argTypes = translator.getFunctorAnalysis()->getArgTypes(udf);
return mk<ram::UserDefinedOperator>(udf.getName(), argTypes, returnType,
translator.getFunctorAnalysis()->isStateful(&udf), std::move(values));
}

Own<ram::Expression> ValueTranslator::visitCounter(const ast::Counter&) {
return mk<ram::AutoIncrement>();
}

Own<ram::Expression> ValueTranslator::visitRecordInit(const ast::RecordInit& init) {
VecOwn<ram::Expression> values;
for (const auto& cur : init.getArguments()) {
values.push_back(translator.translateValue(cur, index));
}
return mk<ram::PackRecord>(std::move(values));
}

Own<ram::Expression> ValueTranslator::visitAggregator(const ast::Aggregator& agg) {
// here we look up the location the aggregation result gets bound
return translator.makeRamTupleElement(index.getGeneratorLoc(agg));
}

Own<ram::Expression> ValueTranslator::visitSubroutineArgument(const ast::SubroutineArgument& subArg) {
return mk<ram::SubroutineArgument>(subArg.getNumber());
}

} // namespace souffle::ast2ram
133 changes: 31 additions & 102 deletions src/ast2ram/ValueTranslator.h
View file
Expand Up @@ -14,122 +14,51 @@

#pragma once

#include "ast/UnnamedVariable.h"
#include "ast/Variable.h"
#include "ast/analysis/Functor.h"
#include "ast/utility/Visitor.h"
#include "ast2ram/AstToRamTranslator.h"
#include "ast2ram/ValueIndex.h"
#include "ram/AutoIncrement.h"
#include "ram/Call.h"
#include "ram/Clear.h"
#include "ram/Condition.h"
#include "ram/Conjunction.h"
#include "ram/Constraint.h"
#include "ram/DebugInfo.h"
#include "ram/EmptinessCheck.h"
#include "ram/ExistenceCheck.h"
#include "ram/Exit.h"
#include "ram/Expression.h"
#include "ram/Extend.h"
#include "ram/Filter.h"
#include "ram/IO.h"
#include "ram/IntrinsicOperator.h"
#include "ram/LogRelationTimer.h"
#include "ram/LogSize.h"
#include "ram/LogTimer.h"
#include "ram/Loop.h"
#include "ram/Negation.h"
#include "ram/PackRecord.h"
#include "ram/Parallel.h"
#include "ram/Program.h"
#include "ram/Project.h"
#include "ram/ProvenanceExistenceCheck.h"
#include "ram/Query.h"
#include "ram/Relation.h"
#include "ram/RelationSize.h"
#include "ram/Scan.h"
#include "ram/Sequence.h"
#include "ram/SignedConstant.h"
#include "ram/Statement.h"
#include "ram/SubroutineArgument.h"
#include "ram/SubroutineReturn.h"
#include "ram/Swap.h"
#include "ram/TranslationUnit.h"
#include "ram/TupleElement.h"
#include "ram/UserDefinedOperator.h"
#include "ram/utility/Utils.h"

namespace souffle {
class SymbolTable;
}

namespace souffle::ast {
class Variable;
class UnnamedVariable;
class Aggregator;
class Counter;
class IntrinsicFunctor;
class NilConstant;
class NumericConstant;
class RecordInit;
class StringConstant;
class SubroutineArgument;
class UnnamedVariable;
class UserDefinedFunctor;
class Variable;
} // namespace souffle::ast

namespace souffle::ram {
class Expression;
}

namespace souffle::ast2ram {

class AstToRamTranslator;
class ValueIndex;

class ValueTranslator : public ast::Visitor<Own<ram::Expression>> {
public:
ValueTranslator(AstToRamTranslator& translator, const ValueIndex& index, SymbolTable& symTab)
: translator(translator), index(index), symTab(symTab) {}

Own<ram::Expression> visitVariable(const ast::Variable& var) override;

Own<ram::Expression> visitUnnamedVariable(const ast::UnnamedVariable&) override;

Own<ram::Expression> visitNumericConstant(const ast::NumericConstant& c);
Own<ram::Expression> visitStringConstant(const ast::StringConstant& c) override {
return mk<ram::SignedConstant>(symTab.lookup(c.getConstant()));
}

Own<ram::Expression> visitNilConstant(const ast::NilConstant&) override {
return mk<ram::SignedConstant>(0);
}

Own<ram::Expression> visitIntrinsicFunctor(const ast::IntrinsicFunctor& inf) override {
VecOwn<ram::Expression> values;
for (const auto& cur : inf.getArguments()) {
values.push_back(translator.translateValue(cur, index));
}

if (ast::analysis::FunctorAnalysis::isMultiResult(inf)) {
return translator.makeRamTupleElement(index.getGeneratorLoc(inf));
} else {
return mk<ram::IntrinsicOperator>(inf.getFunctionOp().value(), std::move(values));
}
}

Own<ram::Expression> visitUserDefinedFunctor(const ast::UserDefinedFunctor& udf) override {
VecOwn<ram::Expression> values;
for (const auto& cur : udf.getArguments()) {
values.push_back(translator.translateValue(cur, index));
}
auto returnType = translator.getFunctorAnalysis()->getReturnType(&udf);
auto argTypes = translator.getFunctorAnalysis()->getArgTypes(udf);
return mk<ram::UserDefinedOperator>(udf.getName(), argTypes, returnType,
translator.getFunctorAnalysis()->isStateful(&udf), std::move(values));
}

Own<ram::Expression> visitCounter(const ast::Counter&) override {
return mk<ram::AutoIncrement>();
}

Own<ram::Expression> visitRecordInit(const ast::RecordInit& init) override {
VecOwn<ram::Expression> values;
for (const auto& cur : init.getArguments()) {
values.push_back(translator.translateValue(cur, index));
}
return mk<ram::PackRecord>(std::move(values));
}

Own<ram::Expression> visitAggregator(const ast::Aggregator& agg) override {
// here we look up the location the aggregation result gets bound
return translator.makeRamTupleElement(index.getGeneratorLoc(agg));
}

Own<ram::Expression> visitSubroutineArgument(const ast::SubroutineArgument& subArg) override {
return mk<ram::SubroutineArgument>(subArg.getNumber());
}
Own<ram::Expression> visitUnnamedVariable(const ast::UnnamedVariable& var) override;
Own<ram::Expression> visitNumericConstant(const ast::NumericConstant& c) override;
Own<ram::Expression> visitStringConstant(const ast::StringConstant& c) override;
Own<ram::Expression> visitNilConstant(const ast::NilConstant& c) override;
Own<ram::Expression> visitIntrinsicFunctor(const ast::IntrinsicFunctor& inf) override;
Own<ram::Expression> visitUserDefinedFunctor(const ast::UserDefinedFunctor& udf) override;
Own<ram::Expression> visitCounter(const ast::Counter& ctr) override;
Own<ram::Expression> visitRecordInit(const ast::RecordInit& init) override;
Own<ram::Expression> visitAggregator(const ast::Aggregator& agg) override;
Own<ram::Expression> visitSubroutineArgument(const ast::SubroutineArgument& subArg) override;

private:
AstToRamTranslator& translator;
Expand Down

0 comments on commit 16ea32d

Please sign in to comment.