OoasTools

/**

  *

  *                      OOAS Compiler

  *

  *       Copyright 2015, AIT Austrian Institute of Technology.

  * This code is based on the C# Version of the OOAS Compiler, which is

  * copyright 2015 by the Institute of Software Technology, Graz University

  * of Technology with portions copyright by the 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)

  *               Markus Demetz (AIT)

  *               Christoph Czurda (AIT)

  *

  */

package org.momut.ooas.codegen.ast;

import org.momut.ooas.ast.expressions.ExpressionKind;

import org.momut.ooas.ast.identifiers.IdentifierKind;

import org.momut.ooas.ast.identifiers.MainModule;

import org.momut.ooas.ast.statements.StatementKind;

import org.momut.ooas.ast.types.TypeKind;

/**

 * Defines a low-level interface that can be used to copy

 * the OOAS AST. Initially defined for the C++ backend.

 *

 * @author willibald

 */

public interface IAstDuplicator<T> {

        /** Allocate an identifier */

        T createIdentifier(IdentifierKind kind, int subOrd);

        /** Allocate a type */

        T createType(TypeKind kind);

        /** Allocate an expression */

        T createExpression(ExpressionKind kind, int subOrd);

        /** Allocate a statement */

        T createStatement(StatementKind kind);

        /** Allocate a new action system instance object */

        T createActionSystemInstance();

        /** Allocate a new symbol table */

        T createSymbolTable();

        /** Allocate a new list for method/function parameters */

        T createParameterList();

        /** Allocate a new list for types */

        T createTypeList();

        /** Allocate a new list for action system instances */

        T createActionSystemInstanceList();

        /** Allocate a new statement list */

        T createStatementList();

        /** Allocate a new expression list */

        T createExpressionList();

        /** Allocate a new list of identifiers */

        T createIdentifierList();

        /** Cast an AstElement object to IScope */

        T castToIScope(T input);

        /** Adds an identifier to a symbol table */

        boolean addIdentifierToSymbolTable(T symbolTable, T identifier);

        /** Adds a parameter identifier to a parameter list */

        boolean addParameterIdentifierToList(T parameterList, T param);

        /** Adds a type to a type-list */

        boolean addTypeToList(T typeList, T type);

        /** Adds an instance (ref) to a instance list */

        boolean addActionSystemInstanceToList(T objectsList, T instanceRef);

        /** Adds an identifier to an identifier block */

        boolean addIdentifierToBlock(T idBlock, T idRef);

        /** Adds a statement to a statement list */

        boolean addStatementToList(T stmtList, T stmntRef);

        /** Adds an expression to an expression list */

        boolean addExpressionToList(T exprList, T exprRef);

        /** Adds an identifier to an identifier list */

        boolean addIdentifierToList(T idList, T idRef);

        /** Initialize an EnumIdentifier */

        boolean initEnumIdentifier(

                        T enumId,

                        int line,

                        int col,

                        String text,

                        T scopeRef,

                        T typeRef,

                        boolean haveValue,

                        int value);

        /** Initialize an ConstantIdentifier*/

        boolean initConstantIdentifier(

                        T constId,

                        int line,

                        int col,

                        String text,

                        T scopeRef,

                        T typeRef,

                        T valueRef);

        /** Initialize an AttributeIdentifier */

        boolean initAttributeIdentifier(

                        T attrId,

                        int line,

                        int col,

                        String text,

                        T scopeRef,

                        T typeRef,

                        T initRef,

                        boolean isStatic,

                        boolean isControllable,

                        boolean isObservable);

        /** Initialize an ExpressionVarIdentifier */

        boolean initExprVarIdentifier(

                        T exprVarId,

                        int line,

                        int col,

                        String text,

                        T scopeRef,

                        T typeRef,

                        boolean initialized);

        /** Initialize a ParamIdentifier */

        boolean initParamIdentifier(

                        T paramId,

                        int line,

                        int column,

                        String text,

                        T scopeRef,

                        T typeRef);

        /** Initialize a LocalVarIdentifier */

        boolean initLocalVarIdentifier(

                        T locVarId,

                        int line,

                        int column,

                        String text,

                        T scopeRef,

                        T typeRef);

        /** Initialize a TypeIdentifier */

        boolean initTypeIdentifier(

                        T typeId,

                        int line,

                        int column,

                        String text,

                        T scopeRef,

                        T typeRef,

                        String prefix);

        /** Special version of the TypeIdentifier: */

        boolean initSelfIdentifier(

                        T typeId,

                        int line,

                        int column,

                        String text,

                        T scopeRef,

                        T typeRef,

                        String prefix);

        /** Initialize a MethodIdentifier */

        boolean initMethodIdentifier(

                        T methodId,

                        int line,

                        int column,

                        String text,

                        T scopeRef,

                        T typeRef,

                        String prefix,

                        T parameterListRef,

                        T symbolTableRef,

                        T bodyRef);

        /** Initialize a Module */

        boolean initModule(

                        T moduleId,

                        int line,

                        int column,

                        String text,

                        T scopeRef,

                        T typeRef,

                        String prefix,

                        T symTabRef);

        /** Initialize the Main Module */

        boolean initMainModule(

                        T moduleId,

                        int line,

                        int column,

                        String text,

                        T scopeRef,

                        T typeRef,

                        String prefix,

                        T symTabRef,

                        T identifierListRef);

        /** Initialize an integer type */

        boolean initIntType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType,

                        int low,

                        int high);

        /** Initialize a bool type */

        boolean initBoolType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType);

        /** Initialize a valued enum type */

        boolean initValuedEnumType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType,

                        T symTabRef,

                        T intTypeRef);

        /** Initialize a normal enum type */

        boolean initEnumType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType,

                        T symTabRef);

        /** Initialize a list type */

        boolean initListType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType,

                        T innerTypeRef,

                        int maxNumberOfElements);

        /** Initialize a tuple type */

        boolean initTupleType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType,

                        T typeListRef);

        /** Initialize a function type */

        boolean initFunctionType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType,

                        T paramTypeListRef,

                        T returnTypeRef,

                        int functionKind,

                        boolean isPure);

        /** Initialize an action system instance */

        boolean initActionSystemInstance(

                        T instance,

                        T typeRef,

                        String name,

                        int numOfCreatedObjs,

                        T parentInstanceRef);

        /** Initialize an action system type */

        boolean initActionSystemType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType,

                        T baseTypeRef,

                        T parentScopeRef,

                        T doOdBlockRef,

                        T symTab,

                        T objectsListRef,

                        T derivedObjectsListRef,

                        boolean autoConstruction,

                        boolean isInSystemDescription);

        /** Initialize a null-type */

        boolean initNullType(

                        T typeId,

                        T identifierRef,

                        boolean anonymousType);

        /** Initialize a skip statement */

        boolean initSkipStatement(

                        T stmnt,

                        int line,

                        int col);

        /** Initialize a break statement */

        boolean initBreakStatement(

                        T stmnt,

                        int line,

                        int col);

        /** Initialize an abort statement */

        boolean initAbortStatement(

                        T stmnt,

                        int line,

                        int col);

        /** Initialize a nondet block */

        boolean initNondetBlock(

                        T block,

                        int line,

                        int col,

                        T symTabRef,

                        T stmtListRef,

                        T scopeRef);

        /** Initialize a nondet block */

        boolean initSeqBlock(

                        T block,

                        int line,

                        int col,

                        T symTabRef,

                        T stmtListRef,

                        T scopeRef,

                        T filterExprRef);

        /** Initialize a nondet block */

        boolean initPrioBlock(

                        T block,

                        int line,

                        int col,

                        T symTabRef,

                        T stmtListRef,

                        T scopeRef);

        /** Initialize a guarded command */

        boolean initGuardedCommand(

                        T stmt,

                        int line,

                        int pos,

                        T scopeRef,

                        T guardExprRef,

                        T bodyRef);

        /** Initialize an assignment statement */

        boolean initAssignment(

                        T stmt,

                        int line,

                        int pos,

                        T scopeRef,

                        T nonDetExprRef,

                        T placeExprListRef,

                        T valueExprListRef,

                        T symTabRef);

        /** Initialize a call expression */

        boolean initCall(

                        T stmt,

                        int line,

                        int pos,

                        T callExprRef);

        /** Initialize a type expression */

        boolean initTypeExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef);

        /** Initialize an identifier expression */

        boolean initIdentifierExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T identifierRef,

                        boolean isSelf);

        /** Initialize a unary operator */

        boolean initUnaryExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T child);

        /** Initialize a binary expression */

        boolean initBinaryExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T left,

                        T right);

        /** Initialize a ternary expression */

        boolean initTernaryExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T left,

                        T mid,

                        T right,

                        T defScopeRef);

        /** Initialize an IntValue expression */

        boolean initIntValueExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        int value);

        /** Initialize a BoolValue expression */

        boolean initBoolValueExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        boolean value);

        /** Initialize a RefValue expression */

        boolean initNullValueExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef);

        /** Initialize a ListConstructor expression */

        boolean initListConstructor(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T exprList,

                        T symTab,

                        T parentScope,

                        T comprehension,

                        boolean hasComprehension);

        /** Initialize a SetConstructor expression */

        boolean initSetConstructor(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T exprList,

                        T symTab,

                        T parentScope,

                        T comprehension,

                        boolean hasComprehension);

        /** Initialize a TupleConstructor expression */

        boolean initTupleConstructor(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T exprList,

                        T tupleTypeId,

                        boolean isMatcher);

        /** Initialize an access expression */

        boolean initAccessExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T left,

                        T right);

        /** Initialize a tuple/map access expression */

        boolean initTupleMapAccessExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T child,

                        T argument);

        /** Initialize a tuple/map access expression */

        boolean initCallExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T child,

                        T argumentList,

                        T scopeRef);

        /** Initialize a quantifier expression */

        boolean initQuantifierExpression(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T child,

                        T symTabRef,

                        T scopeRef);

        /** Initialize an object constructor expression */

        boolean initObjectConstructor(

                        T expr,

                        int line,

                        int pos,

                        T typeRef,

                        T callTargetsIdentifierListRef,

                        T symbTabRef,

                        T instanceList,

                        int currentInstance,

                        String name);

        /** Sets the top level structure of the AST - the main module. */

        void setMainModule(MainModule mainModule, T id);

}