OoasTools

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/BinaryOperator.hpp>

#include <ast/IAstVisitor.hpp>

namespace Ast {

class AccessExpression final

	: public BinaryOperator

{

protected:

	AccessExpression():

		BinaryOperator(ExpressionKind::Access)

	{};

	AccessExpression(const AccessExpression &toCopy):

		BinaryOperator(toCopy)

	{};

	static AccessExpression* create(ExpressionKind){return new AccessExpression();}

	static AccessExpression* createCopy(const AccessExpression& toCopy){return new AccessExpression(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/Expression.hpp>

#include <ast/IAstVisitor.hpp>

namespace Ast {

class BinaryOperator

	: public Expression

{

protected:

	Expression* m_left;

	Expression* m_right;

	BinaryOperator(ExpressionKind kind):

		Expression(kind),

		m_left (nullptr),

		m_right (nullptr)

	{};

	BinaryOperator(const BinaryOperator& toCopy):

		Expression(toCopy),

		m_left (toCopy.m_left),

		m_right (toCopy.m_right)

	{};

	static BinaryOperator* create(ExpressionKind k) {return new BinaryOperator(k);}

	static BinaryOperator* createCopy(const BinaryOperator& toCopy) {return new BinaryOperator(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef,

				SymbolTable* symbTabRef, Expression* left, Expression* right)

	{

		Expression::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef);

		m_left = left;

		m_right = right;

	}

	Expression* left() {return m_left;};

	Expression* right(){return m_right;};

	void setRightChild(Expression* child) {m_right = child;};

	void setLeftChild(Expression* child) {m_left = child;};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/UnaryOperator.hpp>

#include <ast/IAstVisitor.hpp>

#include <deque>

#include <ast/IScope.hpp>

namespace Ast {

class CallExpression final

	: public UnaryOperator

{

private:

	ExpressionList m_arguments;

	IScope* m_callScope;

	CallExpression():

		UnaryOperator(ExpressionKind::Call),

		m_arguments (),

		m_callScope (nullptr)

	{};

	CallExpression(const CallExpression &toCopy):

		UnaryOperator(toCopy),

		m_arguments (toCopy.m_arguments),

		m_callScope (toCopy.m_callScope)

	{};

	static CallExpression* create(ExpressionKind) {return new CallExpression();}

	static CallExpression* createCopy(const CallExpression& toCopy) {return new CallExpression(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef, SymbolTable* symbTabRef,

			Expression* child, ExpressionList* argumentList, IScope* scopeRef)

	{

		UnaryOperator::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef,child);

		m_arguments = std::move(*argumentList);

		m_callScope = scopeRef;

	}

	ExpressionList& arguments() {return m_arguments;};

	IScope* scope() {return m_callScope;};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

	//void setArguments(ExpressionList& newArgs) {m_arguments = newArgs;};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/Quantifier.hpp>

#include <ast/IAstVisitor.hpp>

namespace Ast {

class ExistsQuantifier final

	: public Quantifier

{

protected:

	ExistsQuantifier():

		Quantifier(ExpressionKind::exists)

	{};

	ExistsQuantifier(const ExistsQuantifier &toCopy):

		Quantifier(toCopy)

	{};

	static ExistsQuantifier* create(ExpressionKind) {return new ExistsQuantifier();}

	static ExistsQuantifier* createCopy(const ExistsQuantifier& toCopy) {return new ExistsQuantifier(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#include "Expression.hpp"

#include <ast/expressions/TernaryOperator.hpp>

#include <ast/expressions/BinaryOperator.hpp>

#include <ast/expressions/UnaryOperator.hpp>

#include <ast/expressions/ForallQuantifier.hpp>

#include <ast/expressions/ExistsQuantifier.hpp>

#include <ast/expressions/ListConstructor.hpp>

#include <ast/expressions/TupleConstructor.hpp>

#include <ast/expressions/ObjectConstructor.hpp>

#include <ast/expressions/IdentifierExpression.hpp>

#include <ast/expressions/TypeExpression.hpp>

#include <ast/expressions/TupleMapAccessExpression.hpp>

#include <ast/expressions/CallExpression.hpp>

#include <ast/expressions/AccessExpression.hpp>

#include <ast/expressions/ValueExpression.hpp>

#include <ast/expressions/SetConstructor.hpp>

#include <ast/expressions/TupleMapAccessExpression.hpp>

#include <ast/expressions/CallExpression.hpp>

#include <ast/expressions/AccessExpression.hpp>

namespace Ast {

static void abstractError(ExpressionKind ) {

	throw new Base::NotImplementedException();

}

Base::FuncPtr Expression::s_exprVmt [2][EXPRESSIONKIND_NR_ITEMS] =

{

		{

			/* conditional = 0, */                 (Base::FuncPtr) &TernaryOperator::create,

			/* domresby = 1, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* domresto = 2, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* rngresby = 3, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* rngresto = 4, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* munion = 5, */                      (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* conc = 6, */                        (Base::FuncPtr) &BinaryOperator::create,

			/* diff = 7, */                        (Base::FuncPtr) &BinaryOperator::create,

			/* inter = 8, */                       (Base::FuncPtr) &BinaryOperator::create,

			/* elemin = 9, */                      (Base::FuncPtr) &BinaryOperator::create,

			/* notelemin = 10, */                  (Base::FuncPtr) &BinaryOperator::create,

			/* subset = 11, */                     (Base::FuncPtr) &BinaryOperator::create,

			/* _union = 12, */                     (Base::FuncPtr) &BinaryOperator::create,

			/* div = 13, */                        (Base::FuncPtr) &BinaryOperator::create,

			/* greater = 14, */                    (Base::FuncPtr) &BinaryOperator::create,

			/* greaterequal = 15, */               (Base::FuncPtr) &BinaryOperator::create,

			/* idiv = 16, */                       (Base::FuncPtr) &BinaryOperator::create,

			/* less = 17, */                       (Base::FuncPtr) &BinaryOperator::create,

			/* lessequal = 18, */                  (Base::FuncPtr) &BinaryOperator::create,

			/* minus = 19, */                      (Base::FuncPtr) &BinaryOperator::create,

			/* mod = 20, */                        (Base::FuncPtr) &BinaryOperator::create,

			/* pow = 21, */                        (Base::FuncPtr) &BinaryOperator::create,

			/* prod = 22, */                       (Base::FuncPtr) &BinaryOperator::create,

			/* sum = 23, */                        (Base::FuncPtr) &BinaryOperator::create,

			/* _and = 24, */                       (Base::FuncPtr) &BinaryOperator::create,

			/* biimplies = 25, */                  (Base::FuncPtr) &BinaryOperator::create,

			/* implies = 26, */                    (Base::FuncPtr) &BinaryOperator::create,

			/* _or = 27, */                        (Base::FuncPtr) &BinaryOperator::create,

			/* equal = 28, */                      (Base::FuncPtr) &BinaryOperator::create,

			/* notequal = 29, */                   (Base::FuncPtr) &BinaryOperator::create,

			/* seqmod_mapoverride = 30, */         (Base::FuncPtr) &abstractError,

			/* dom = 31, */                        (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* range = 32, */                      (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* merge = 33, */                      (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* card = 34, */                       (Base::FuncPtr) &UnaryOperator::create,

			/* dconc = 35, */                      (Base::FuncPtr) &UnaryOperator::create,

			/* dinter = 36, */                     (Base::FuncPtr) &UnaryOperator::create,

			/* dunion = 37, */                     (Base::FuncPtr) &UnaryOperator::create,

			/* elems = 38, */                      (Base::FuncPtr) &UnaryOperator::create,

			/* head = 39, */                       (Base::FuncPtr) &UnaryOperator::create,

			/* inds = 40, */                       (Base::FuncPtr) &UnaryOperator::create,

			/* len = 41, */                        (Base::FuncPtr) &UnaryOperator::create,

			/* tail = 42, */                       (Base::FuncPtr) &UnaryOperator::create,

			/* unminus = 43, */                    (Base::FuncPtr) &UnaryOperator::create,

			/* unplus = 44, */                     (Base::FuncPtr) &UnaryOperator::create,

			/* _not = 45, */                       (Base::FuncPtr) &UnaryOperator::create,

			/* abs = 46, */                        (Base::FuncPtr) &UnaryOperator::create,

			/* forall = 47, */                     (Base::FuncPtr) &ForallQuantifier::create,

			/* exists = 48, */                     (Base::FuncPtr) &ExistsQuantifier::create,

			/* ListConstr = 49, */                 (Base::FuncPtr) &ListConstructor::create,

			/* SetConstr = 50, */                  (Base::FuncPtr) &SetConstructor::create,

			/* MapConstr = 51, */                  (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* TupleConstr = 52, */                (Base::FuncPtr) &TupleConstructor::create,

			/* ObjectConstr = 53, */               (Base::FuncPtr) &ObjectConstructor::create,

			/* QValConstr = 54, */                 (Base::FuncPtr) &abstractError,

			/* Identifier = 55, */                 (Base::FuncPtr) &IdentifierExpression::create,

			/* UnresolvedIdentifier = 56, */       (Base::FuncPtr) &abstractError,

			/* Type = 57, */                       (Base::FuncPtr) &TypeExpression::create,

			/* TupleMapAccess = 58, */             (Base::FuncPtr) &TupleMapAccessExpression::create,

			/* Call = 59, */                       (Base::FuncPtr) &CallExpression::create,

			/* Access = 60, */                     (Base::FuncPtr) &AccessExpression::create,

			/* Primed = 61, */                     (Base::FuncPtr) &abstractError,

			/* Cast = 62, */                       (Base::FuncPtr) &UnaryOperator::create,

			/* foldLR = 63, */                     (Base::FuncPtr) &TernaryOperator::create,

			/* foldRL = 64, */                     (Base::FuncPtr) &abstractError,

			/* Value_Integer = 65, */              (Base::FuncPtr) &IntValueExpression::create,

			/* Value_Bool = 66, */                 (Base::FuncPtr) &BoolValueExpression::create,

			/* Value_Reference = 67, */            (Base::FuncPtr) &RefValueExpression::create

		},

		{

			/* conditional = 0, */                 (Base::FuncPtr) &TernaryOperator::createCopy,

			/* domresby = 1, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* domresto = 2, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* rngresby = 3, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* rngresto = 4, */                    (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* munion = 5, */                      (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* conc = 6, */                        (Base::FuncPtr) &BinaryOperator::createCopy,

			/* diff = 7, */                        (Base::FuncPtr) &BinaryOperator::createCopy,

			/* inter = 8, */                       (Base::FuncPtr) &BinaryOperator::createCopy,

			/* elemin = 9, */                      (Base::FuncPtr) &BinaryOperator::createCopy,

			/* notelemin = 10, */                  (Base::FuncPtr) &BinaryOperator::createCopy,

			/* subset = 11, */                     (Base::FuncPtr) &BinaryOperator::createCopy,

			/* _union = 12, */                     (Base::FuncPtr) &BinaryOperator::createCopy,

			/* div = 13, */                        (Base::FuncPtr) &BinaryOperator::createCopy,

			/* greater = 14, */                    (Base::FuncPtr) &BinaryOperator::createCopy,

			/* greaterequal = 15, */               (Base::FuncPtr) &BinaryOperator::createCopy,

			/* idiv = 16, */                       (Base::FuncPtr) &BinaryOperator::createCopy,

			/* less = 17, */                       (Base::FuncPtr) &BinaryOperator::createCopy,

			/* lessequal = 18, */                  (Base::FuncPtr) &BinaryOperator::createCopy,

			/* minus = 19, */                      (Base::FuncPtr) &BinaryOperator::createCopy,

			/* mod = 20, */                        (Base::FuncPtr) &BinaryOperator::createCopy,

			/* pow = 21, */                        (Base::FuncPtr) &BinaryOperator::createCopy,

			/* prod = 22, */                       (Base::FuncPtr) &BinaryOperator::createCopy,

			/* sum = 23, */                        (Base::FuncPtr) &BinaryOperator::createCopy,

			/* _and = 24, */                       (Base::FuncPtr) &BinaryOperator::createCopy,

			/* biimplies = 25, */                  (Base::FuncPtr) &BinaryOperator::createCopy,

			/* implies = 26, */                    (Base::FuncPtr) &BinaryOperator::createCopy,

			/* _or = 27, */                        (Base::FuncPtr) &BinaryOperator::createCopy,

			/* equal = 28, */                      (Base::FuncPtr) &BinaryOperator::createCopy,

			/* notequal = 29, */                   (Base::FuncPtr) &BinaryOperator::createCopy,

			/* seqmod_mapoverride = 30, */         (Base::FuncPtr) &abstractError,

			/* dom = 31, */                        (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* range = 32, */                      (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* merge = 33, */                      (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* card = 34, */                       (Base::FuncPtr) &UnaryOperator::createCopy,

			/* dconc = 35, */                      (Base::FuncPtr) &UnaryOperator::createCopy,

			/* dinter = 36, */                     (Base::FuncPtr) &UnaryOperator::createCopy,

			/* dunion = 37, */                     (Base::FuncPtr) &UnaryOperator::createCopy,

			/* elems = 38, */                      (Base::FuncPtr) &UnaryOperator::createCopy,

			/* head = 39, */                       (Base::FuncPtr) &UnaryOperator::createCopy,

			/* inds = 40, */                       (Base::FuncPtr) &UnaryOperator::createCopy,

			/* len = 41, */                        (Base::FuncPtr) &UnaryOperator::createCopy,

			/* tail = 42, */                       (Base::FuncPtr) &UnaryOperator::createCopy,

			/* unminus = 43, */                    (Base::FuncPtr) &UnaryOperator::createCopy,

			/* unplus = 44, */                     (Base::FuncPtr) &UnaryOperator::createCopy,

			/* _not = 45, */                       (Base::FuncPtr) &UnaryOperator::createCopy,

			/* abs = 46, */                        (Base::FuncPtr) &UnaryOperator::createCopy,

			/* forall = 47, */                     (Base::FuncPtr) &ForallQuantifier::createCopy,

			/* exists = 48, */                     (Base::FuncPtr) &ExistsQuantifier::createCopy,

			/* ListConstr = 49, */                 (Base::FuncPtr) &ListConstructor::createCopy,

			/* SetConstr = 50, */                  (Base::FuncPtr) &SetConstructor::createCopy,

			/* MapConstr = 51, */                  (Base::FuncPtr) &abstractError,  // ops on maps not supported

			/* TupleConstr = 52, */                (Base::FuncPtr) &TupleConstructor::createCopy,

			/* ObjectConstr = 53, */               (Base::FuncPtr) &ObjectConstructor::createCopy,

			/* QValConstr = 54, */                 (Base::FuncPtr) &abstractError,

			/* Identifier = 55, */                 (Base::FuncPtr) &IdentifierExpression::createCopy,

			/* UnresolvedIdentifier = 56, */       (Base::FuncPtr) &abstractError,

			/* Type = 57, */                       (Base::FuncPtr) &TypeExpression::createCopy,

			/* TupleMapAccess = 58, */             (Base::FuncPtr) &TupleMapAccessExpression::createCopy,

			/* Call = 59, */                       (Base::FuncPtr) &CallExpression::createCopy,

			/* Access = 60, */                     (Base::FuncPtr) &AccessExpression::createCopy,

			/* Primed = 61, */                     (Base::FuncPtr) &abstractError,

			/* Cast = 62, */                       (Base::FuncPtr) &UnaryOperator::createCopy,

			/* foldLR = 63, */                     (Base::FuncPtr) &TernaryOperator::createCopy,

			/* foldRL = 64, */                     (Base::FuncPtr) &abstractError,

			/* Value_Integer = 65, */              (Base::FuncPtr) &IntValueExpression::createCopy,

			/* Value_Bool = 66, */                 (Base::FuncPtr) &BoolValueExpression::createCopy,

			/* Value_Reference = 67, */            (Base::FuncPtr) &RefValueExpression::createCopy

		}

};

Expression* Expression::createVirtual(ExpressionKind k) {

	return (std::uint8_t)k < EXPRESSIONKIND_NR_ITEMS ? ((ConstrPtr)s_exprVmt[0][(std::uint8_t)k])(k) : nullptr;

}

Expression* Expression::createVirtual(const Expression& toCopy) {

	std::uint8_t kind ((std::uint8_t)toCopy.kind());

	return ((CopyConstrPtr)s_exprVmt[1][kind])(toCopy);

}

void Expression::accept(IAstVisitor& ) {

	throw new Base::NotImplementedException();

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <base/TiresiasObject.hpp>

#include <ast/AstElement.hpp>

#include <ast/types/Type.hpp>

#include <cstdint>

#include <ast/Containers.hpp>

#include <ast/IAstVisitor.hpp>

#include <base/Exceptions.hpp>

namespace Ast {

/**

 * You must not change the assigned values as this

 * needs to be kept in sync with the definitions in Argos!

 */

enum class ExpressionKind : std::uint8_t

{

	/*tern.*/

	conditional = 0,

	/*map binary*/

	domresby = 1, domresto = 2, rngresby = 3, rngresto = 4, munion = 5,

	/*set/list binary*/

	conc = 6, diff = 7, inter = 8, elemin = 9, notelemin = 10, subset = 11, _union = 12,

	/*numeric binary*/

	div = 13, greater = 14, greaterequal = 15, idiv = 16, less = 17, lessequal = 18,

	minus = 19, mod = 20, pow = 21, prod = 22, sum = 23,

	/*bool binary*/

	_and = 24, biimplies = 25, implies = 26, _or = 27,

	/*other binary*/

	equal = 28, notequal = 29, seqmod_mapoverride = 30,

	/*map unary*/

	dom = 31, range = 32, merge = 33,

	/*set/list unary*/

	card = 34, dconc = 35, dinter = 36, dunion = 37, elems = 38, head = 39,

	inds = 40, len = 41, tail = 42,

	/*unary numberic*/

	unminus = 43, unplus = 44, _not = 45, abs = 46,

	/*unary quantors*/

	forall = 47, exists = 48,

	/*Constructors*/

	ListConstr = 49, SetConstr = 50, MapConstr = 51, TupleConstr = 52, ObjectConstr = 53, QValConstr = 54,

	/* identifier */

	Identifier = 55,

	UnresolvedIdentifier = 56,

	Type = 57,

	/* tuple access and method call */

	TupleMapAccess = 58, Call = 59,

	/* point operator */

	Access = 60,

	/* primed */

	Primed = 61,

	/* cast */

	Cast = 62,

	/* fold */

	foldLR = 63,

	foldRL = 64,

	/* values */

	Value_Integer = 65,

	Value_Bool = 66,

	Value_Reference = 67,

	EXPRESSIONKIND_LAST_ITEM = Value_Reference

};

#define EXPRESSIONKIND_NR_ITEMS ((std::uint8_t)ExpressionKind::EXPRESSIONKIND_LAST_ITEM + 1)

class Expression:

	public AstElement

{

protected:

	typedef Expression* (*ConstrPtr)(ExpressionKind k);

	typedef Expression* (*CopyConstrPtr) (const Expression& toCopy);

	ExpressionKind m_kind;

	Type* m_type;

	std::int32_t m_line;

	std::int32_t m_pos;

	SymbolTable* m_freeVariables;

	FunctionIdentifierList m_callTargets;

	Expression(ExpressionKind kind):

		AstElement(AstNodeTypeEnum::expression),

		m_kind(kind),

		m_type (nullptr),

		m_line (-1),

		m_pos  (-1),

		m_freeVariables (nullptr)

	{}

	Expression(const Expression& toCopy):

		AstElement(AstNodeTypeEnum::expression),

		m_kind (toCopy.m_kind),

		m_type (toCopy.m_type),

		m_line (toCopy.m_line),

		m_pos  (toCopy.m_pos),

		m_freeVariables (toCopy.m_freeVariables)

	{}

	~Expression()

	{}

	static Base::FuncPtr s_exprVmt [2][EXPRESSIONKIND_NR_ITEMS];

	static Expression* createVirtual(ExpressionKind k);

	static Expression* createVirtual(const Expression& toCopy);

public:

	friend class Ast;

	void init(

			std::int32_t line,

			std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef,

			SymbolTable* symbTabRef)

	{

		m_line = line;

		m_pos = pos;

		m_type = typeRef;

		m_callTargets.clear();

		if (callTargetsIdentifierListRef != nullptr) {

			for (auto& id: *callTargetsIdentifierListRef) {

				IdentifierKind kind = id->kind();

				if (kind != IdentifierKind::MethodIdentifier &&

				    kind != IdentifierKind::NamedActionIdentifier)

				{

					throw new Base::InvalidArgumentException("Calltargets must be methods or actions.");

				}

				m_callTargets.push_back((FunctionIdentifier*)id);

			}

		}

		m_freeVariables = symbTabRef;

	}

	ExpressionKind kind() const { return m_kind; };

	Type* type() const { return m_type; };

	std::int32_t line() const { return m_line; };

	std::int32_t pos() const { return m_pos; };

	SymbolTable* freeVariables() { return m_freeVariables; };

	FunctionIdentifierList& callTargets() { return m_callTargets; };

	void accept(IAstVisitor& visitor) override;

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/Quantifier.hpp>

#include <ast/IAstVisitor.hpp>

namespace Ast {

class ForallQuantifier final

	: public Quantifier

{

protected:

	ForallQuantifier():

		Quantifier(ExpressionKind::forall)

	{};

	ForallQuantifier(const ForallQuantifier& toCopy):

		Quantifier(toCopy)

	{};

	static ForallQuantifier* create(ExpressionKind) {return new ForallQuantifier();};

	static ForallQuantifier* createCopy(const ForallQuantifier& toCopy) {return new ForallQuantifier(toCopy);};

public:

	friend class Ast;

	friend class Expression;

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/LeafExpression.hpp>

#include <ast/identifiers/Identifier.hpp>

namespace Ast {

class IdentifierExpression

	: public LeafExpression

{

protected:

	bool m_self;

	Identifier* m_identifier;

	IdentifierExpression():

		LeafExpression(LeafTypeEnum::identifier, ExpressionKind::Identifier),

		m_self (false),

		m_identifier (nullptr)

	{};

	IdentifierExpression(const IdentifierExpression &toCopy):

		LeafExpression(toCopy),

		m_self (toCopy.m_self),

		m_identifier (toCopy.m_identifier)

	{};

	static IdentifierExpression* create(ExpressionKind){return new IdentifierExpression();}

	static IdentifierExpression* createCopy(const IdentifierExpression& toCopy) {return new IdentifierExpression(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef,

				SymbolTable* symbTabRef, Identifier* identifierRef, bool isSelf)

	{

		LeafExpression::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef);

		m_identifier = identifierRef;

		m_self = isSelf;

	}

	Identifier* identifier() {return m_identifier;};

	bool isSelf() const {return m_self;};

	void setIsSelf(bool newValue) {m_self = newValue;};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

	void setIdentifier(Identifier* newIdentifier) {m_identifier = newIdentifier;};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/Expression.hpp>

namespace Ast {

enum class LeafTypeEnum {

	unset = 0,

	_bool = 1,

	integer  = 2,

	real  = 3,

	chr  = 4,

	qval = 5,

	reference = 6,

	identifier = 7,

	type = 8,

	complex = 9

};

class LeafExpression

	: public Expression

{

protected:

	LeafTypeEnum m_valueType;

	LeafExpression(LeafTypeEnum lt, ExpressionKind kind):

		Expression(kind),

		m_valueType (lt)

	{};

	LeafExpression(const LeafExpression &toCopy):

		Expression(toCopy),

		m_valueType (toCopy.m_valueType)

	{};

public:

	~LeafExpression() override {};

	LeafTypeEnum valueType() const {return m_valueType;};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/TypeConstructionExpression.hpp>

#include <ast/IScope.hpp>

#include <deque>

#include <ast/SymbolTable.hpp>

#include <base/Exceptions.hpp>

#include <string>

#include <ast/IAstVisitor.hpp>

namespace Ast {

class ListConstructor final

	: public TypeConstructionExpression

	, public IScope

{

protected:

	ExpressionList m_elements;

	IScope* m_parentScope;

	SymbolTable* m_comprehensionVars;

	Expression* m_comprehension;

	bool m_hasComprehension;

	ListConstructor():

		TypeConstructionExpression(ExpressionKind::ListConstr),

		m_elements(),

		m_parentScope(nullptr),

		m_comprehensionVars(nullptr),

		m_comprehension(nullptr),

		m_hasComprehension(false)

	{};

	ListConstructor(const ListConstructor &toCopy):

		TypeConstructionExpression(toCopy),

		m_elements(toCopy.m_elements),

		m_parentScope(toCopy.m_parentScope),

		m_comprehensionVars(toCopy.m_comprehensionVars),

		m_comprehension(toCopy.m_comprehension),

		m_hasComprehension(toCopy.m_hasComprehension)

	{};

	static ListConstructor* create(ExpressionKind){return new ListConstructor();}

	static ListConstructor* createCopy(const ListConstructor& toCopy){return new ListConstructor(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef, SymbolTable* symbTabRef,

			ExpressionList* exprList, SymbolTable *symTab, IScope* parentScope,

			Expression* comprehension, bool hasComprehension)

	{

		TypeConstructionExpression::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef);

		m_elements = std::move(*exprList);

		m_parentScope = parentScope;

		m_comprehensionVars = symTab;

		m_comprehension = comprehension;

		m_hasComprehension = hasComprehension;

	}

	ExpressionList& elements() {return m_elements;};

	Expression* comprehension() {return m_comprehension;};

	bool hasComprehension() {return m_hasComprehension;};

	SymbolTable* comprehensionVariables() {return m_comprehensionVars;};

	void addElement(Expression* anElement) {m_elements.push_back(anElement);};

	void setComprehension(Expression* comprehension) {m_comprehension = comprehension;};

	void setHasComprehension(bool flag) {m_hasComprehension = flag;};

	Identifier* resolveIdentifier(const std::string& aName) const override { return m_comprehensionVars->get(aName); };

	IScope* getParentScope() const override {return m_parentScope;};

	std::string getScopeName() const override {return "";}

	void setParentScope(IScope* parentScope) override {m_parentScope = parentScope;};

	void addIdentifier(Identifier* anIdentifier, void* ) override {m_comprehensionVars->addIdentifier(anIdentifier);};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

//	void setElements(std::deque<Expression*>& newElements) {};

	IScope* asScope() final {return (IScope*) this;}

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/TypeConstructionExpression.hpp>

#include <ast/IAstVisitor.hpp>

#include <ast/types/ActionSystemType.hpp>

#include <deque>

#include <cstdint>

#include <string>

namespace Ast {

class ObjectConstructor final

	: public TypeConstructionExpression

{

protected:

	/*std::int32_t*/ ActionSystemInstanceList::size_type m_currentInstance;

	ActionSystemInstanceList m_instances;

	std::string m_fixedObjectName;

	ObjectConstructor():

		TypeConstructionExpression(ExpressionKind::ObjectConstr),

		m_currentInstance (0),

		m_instances(),

		m_fixedObjectName ("")

	{};

	ObjectConstructor(const ObjectConstructor &toCopy):

		TypeConstructionExpression(toCopy),

		m_currentInstance(toCopy.m_currentInstance),

		m_instances(toCopy.m_instances),

		m_fixedObjectName (toCopy.m_fixedObjectName)

	{};

	static ObjectConstructor* create(ExpressionKind){return new ObjectConstructor();}

	static ObjectConstructor* createCopy(const ObjectConstructor& toCopy){return new ObjectConstructor(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef, SymbolTable* symbTabRef,

			ActionSystemInstanceList* instanceList, std::uint32_t currentInstance, const char* name)

	{

		TypeConstructionExpression::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef);

		m_instances = std::move(*instanceList);

		m_currentInstance = currentInstance;

		m_fixedObjectName = name == nullptr ? "" : name;

	}

	std::uint32_t currentInstance() const {return (std::uint32_t) m_currentInstance;};

	ActionSystemInstanceList& instances() {return m_instances;};

	std::string givenObjectName() {return m_fixedObjectName;};

	void resetCurrentInstance() {m_currentInstance = 0;};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

	void addInstance(ActionSystemInstance* anInstance) {m_instances.push_back(anInstance);};

	ActionSystemInstance* GetNextInstance() {

		ActionSystemInstance* result = m_instances[m_currentInstance];

		m_currentInstance++;

		return result;

	};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/UnaryOperator.hpp>

#include <ast/IScope.hpp>

#include <ast/SymbolTable.hpp>

#include <base/Exceptions.hpp>

#include <string>

#include <ast/identifiers/Identifier.hpp>

namespace Ast {

class Quantifier

	: public UnaryOperator

	, public IScope

{

protected:

	SymbolTable* m_symbols;

	IScope* m_parentScope;

	Quantifier(ExpressionKind kind):

		UnaryOperator(kind),

		m_symbols (nullptr),

		m_parentScope (nullptr)

	{}

	Quantifier(const Quantifier &toCopy):

		UnaryOperator(toCopy),

		m_symbols (toCopy.m_symbols),

		m_parentScope (toCopy.m_parentScope)

	{}

public:

	~Quantifier() override {}

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef, SymbolTable* symbTabRef,

			Expression* child, SymbolTable* symTabRef, IScope* scopeRef)

	{

		UnaryOperator::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef,child);

		m_symbols = symTabRef;

		m_parentScope = scopeRef;

	}

	SymbolTable* symbols() {return m_symbols;};

	Identifier* resolveIdentifier(const std::string& aName) const override { return m_symbols->get(aName); };

	IScope* getParentScope() const override {return m_parentScope;};

	std::string getScopeName() const override {return "";}

	void setParentScope(IScope* parentScope) override {m_parentScope = parentScope;};

	void addIdentifier(Identifier* anIdentifier, void* ) override {m_symbols->addIdentifier(anIdentifier);};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/TypeConstructionExpression.hpp>

#include <ast/IScope.hpp>

#include <ast/expressions/Expression.hpp>

#include <ast/IAstVisitor.hpp>

#include <ast/SymbolTable.hpp>

#include <base/Exceptions.hpp>

#include <ast/identifiers/Identifier.hpp>

#include <deque>

namespace Ast {

class SetConstructor final

	: public TypeConstructionExpression

	, public IScope

{

protected:

	ExpressionList m_items;

	SymbolTable* m_comprehensionVars;

	IScope* m_parentScope;

	Expression* m_comprehension;

	bool m_hasComprehension;

	SetConstructor():

		TypeConstructionExpression(ExpressionKind::SetConstr),

		m_items (),

		m_comprehensionVars (nullptr),

		m_parentScope (nullptr),

		m_comprehension (nullptr),

		m_hasComprehension (false)

	{};

	SetConstructor(const SetConstructor &toCopy):

		TypeConstructionExpression(toCopy),

		m_items (toCopy.m_items),

		m_comprehensionVars (toCopy.m_comprehensionVars),

		m_parentScope (toCopy.m_parentScope),

		m_comprehension (toCopy.m_comprehension),

		m_hasComprehension (toCopy.m_hasComprehension)

	{};

	static SetConstructor* create(ExpressionKind) {return new SetConstructor();}

	static SetConstructor* createCopy(const SetConstructor& toCopy) {return new SetConstructor(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef, SymbolTable* symbTabRef,

			ExpressionList* exprList, SymbolTable *symTab, IScope* parentScope,

			Expression* comprehension, bool hasComprehension)

	{

		TypeConstructionExpression::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef);

		m_items = std::move(*exprList);

		m_parentScope = parentScope;

		m_comprehensionVars = symTab;

		m_comprehension = comprehension;

		m_hasComprehension = hasComprehension;

	}

	ExpressionList& items() {return m_items;}

	Expression* comprehension() {return m_comprehension;}

	bool hasComprehension() const {return m_hasComprehension;};

	SymbolTable* comprehensionVariables() {return m_comprehensionVars;};

	void addItem(Expression* anItem) {m_items.push_back(anItem);};

	void setComprehension(Expression* anExpr) {m_comprehension = anExpr;};

	void setHasComprehension(bool flag) {m_hasComprehension = flag;};

	Identifier* resolveIdentifier(const string& aName) const override {return m_comprehensionVars->get(aName);};

	IScope* getParentScope() const override {return m_parentScope;};

	std::string getScopeName() const override {return "";}

	void setParentScope(IScope* parentScope) override {m_parentScope = parentScope;};

	void addIdentifier(Identifier* anIdentifier, void* ) override {m_comprehensionVars->addIdentifier(anIdentifier);};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

	//void setItems(ExpressionList& newItems) {m_items = newItems;};

	IScope* asScope() final {return (IScope*) this;}

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/Expression.hpp>

#include <ast/IScope.hpp>

namespace Ast {

class TernaryOperator final

	: public Expression

{

protected:

	Expression* m_left;

	Expression* m_mid;

	Expression* m_right;

	IScope* m_definingScope;

	TernaryOperator(ExpressionKind kind):

		Expression(kind),

		m_left (nullptr),

		m_mid (nullptr),

		m_right(nullptr),

		m_definingScope (nullptr)

	{}

	TernaryOperator(const TernaryOperator& toCopy):

		Expression(toCopy),

		m_left (toCopy.m_left),

		m_mid (toCopy.m_mid),

		m_right(toCopy.m_right),

		m_definingScope (toCopy.m_definingScope)

	{}

	static TernaryOperator* create(ExpressionKind k){return new TernaryOperator(k);}

	static TernaryOperator* createCopy(const TernaryOperator& toCopy){return new TernaryOperator(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef,

				SymbolTable* symbTabRef, Expression* left, Expression* mid,

				Expression* right, IScope* defScopeRef)

	{

		Expression::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef);

		m_left = left;

		m_mid = mid;

		m_right = right;

		m_definingScope = defScopeRef;

	}

	Expression* left() {return m_left;};

	Expression* mid() {return m_mid;};

	Expression* right() {return m_right;};

	IScope* definingScope() {return m_definingScope;};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

	void setLeftChild(Expression* newExpression) {m_left = newExpression;};

	void setMidChild(Expression* newExpression) {m_mid = newExpression;};

	void setRightChild(Expression* newExpression) {m_right = newExpression;};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/TypeConstructionExpression.hpp>

#include <ast/IAstVisitor.hpp>

#include <ast/identifiers/Identifier.hpp>

#include <deque>

namespace Ast {

class TupleConstructor final

	: public TypeConstructionExpression

{

protected:

	ExpressionList m_values;

	Identifier* m_tupleType;

	bool m_matcher;

	TupleConstructor():

		TypeConstructionExpression(ExpressionKind::TupleConstr),

		m_values(),

		m_tupleType(nullptr),

		m_matcher(false)

	{};

	TupleConstructor(const TupleConstructor &toCopy):

		TypeConstructionExpression(toCopy),

		m_values(toCopy.m_values),

		m_tupleType(toCopy.m_tupleType),

		m_matcher(toCopy.m_matcher)

	{};

	static TupleConstructor* create(ExpressionKind) {return new TupleConstructor();}

	static TupleConstructor* createCopy(const TupleConstructor& toCopy) {return new TupleConstructor(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef, SymbolTable* symbTabRef,

			ExpressionList* exprList, Identifier* tupleTypeId, bool isMatcher)

	{

		TypeConstructionExpression::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef);

		m_values = std::move(*exprList);

		m_tupleType = tupleTypeId,

		m_matcher = isMatcher;

	}

	ExpressionList& values() {return m_values;}

	Identifier* tupleType() {return m_tupleType;};

	bool isMatcher() {return m_matcher;}

	void setIsMatcher(bool newVal) {m_matcher = newVal;};

	void accept(IAstVisitor& visitor) override {visitor.visit(this);};

	//void setTupleValues(ExpressionList& values) {m_values = values;};

};

}

/**

  *

  *                  OOAS Compiler - C++ AST

  *

  * Copyright 2015, AIT Austrian Institute of Technology.

  * All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Christoph Czurda (AIT)

  *

  */

#pragma once

#include <ast/expressions/UnaryOperator.hpp>

#include <ast/IAstVisitor.hpp>

namespace Ast {

class TupleMapAccessExpression final

	: public UnaryOperator

{

protected:

	Expression* m_argument;

	TupleMapAccessExpression():

		UnaryOperator(ExpressionKind::TupleMapAccess),

		m_argument (nullptr)

	{};

	TupleMapAccessExpression(const TupleMapAccessExpression &toCopy):

		UnaryOperator(toCopy),

		m_argument (toCopy.m_argument)

	{};

	static TupleMapAccessExpression* create(ExpressionKind){return new TupleMapAccessExpression();}

	static TupleMapAccessExpression* createCopy(const TupleMapAccessExpression& toCopy){return new TupleMapAccessExpression(toCopy);}

public:

	friend class Ast;

	friend class Expression;

	void init(std::int32_t line, std::int32_t pos,

			Type* typeRef,IdentifierList* callTargetsIdentifierListRef, SymbolTable* symbTabRef,

			Expression* child, Expression* arg)

	{

		UnaryOperator::init(line,pos,typeRef,callTargetsIdentifierListRef, symbTabRef,child);