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.ast.types;

import java.util.ArrayList;

import org.momut.ooas.ast.IAstVisitor;

import org.momut.ooas.ast.IScope;

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

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

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

import org.momut.ooas.parser.SymbolTable;

import org.momut.ooas.utils.exceptions.ArgumentException;

import org.momut.ooas.utils.exceptions.InternalCompilerException;

public class OoActionSystemType extends Type implements IScope

{

        private final boolean m_autoCons;

        private OoActionSystemType m_baseType;

        private Block m_doOdBlock;

        private IScope m_parentScope;

        private final SymbolTable m_symbols;

        private final ArrayList<OoActionSystemInstance> m_objects;

        private final ArrayList<OoActionSystemInstance> m_derivedObjects;

        private boolean m_isInSystemDescription;

        public Block doOdBlock() { return m_doOdBlock; }

        public boolean autoConstruction() { return m_autoCons; }

        public OoActionSystemType baseType() { return m_baseType; }

        public SymbolTable symbols() { return m_symbols; }

        public ArrayList<OoActionSystemInstance> objects() { return m_objects; }

        public ArrayList<OoActionSystemInstance> derivedObjects() { return m_derivedObjects; }

        public boolean isInSystemDescription() { return m_isInSystemDescription; }

        public OoActionSystemType(

                        boolean autoCons,

                        OoActionSystemType refinedSystem,

                        TypeIdentifier typeName)

        {

                super(TypeKind.OoActionSystemType, typeName);

                m_symbols = new SymbolTable();

                m_autoCons = autoCons;

                m_baseType = refinedSystem;

                m_objects = new ArrayList<OoActionSystemInstance>();

                m_derivedObjects = new ArrayList<OoActionSystemInstance>();

                m_isInSystemDescription = false;

        }

        public final void SetDoOdBlock(Block anArg)

        {

                m_doOdBlock = anArg;

                if (anArg.GetParentScope() == null)

                        anArg.SetParentScope(this);

                else if (anArg.GetParentScope() != this)

                        throw new InternalCompilerException("Internal Error: Do-Od block has different parent set.");

        }

        @Override

        public IScope GetParentScope()

        {

                return m_parentScope;

        }

        @Override

        public void SetParentScope(IScope parentScope)

        {

                m_parentScope = parentScope;

        }

        public Identifier ResolveLocal(String aName)

        {

                if (m_symbols.Defined(aName))

                        return m_symbols.Get(aName);

                else

                        return null;

        }

        @Override

        public Identifier ResolveIdentifier(String aName)

        {

                Identifier result = ResolveLocal(aName);

                if ((result == null) && (m_baseType != null))

                        result = m_baseType.ResolveIdentifier(aName);

                return result;

        }

        @Override

        public void AddIdentifier(Identifier anIdentifier, Object tag)

        {

                m_symbols.AddIdentifier(anIdentifier);

        }

        @Override

        public void Accept(IAstVisitor visitor)

        {

                visitor.visit(this);

        }

        public void SetBaseType(OoActionSystemType newType)

        {

                if (newType == null)

                        throw new ArgumentException();

                m_baseType = newType;

        }

        public SymbolTable getAllSymbols()

        {

                OoActionSystemType system;

                final ArrayList<OoActionSystemType> inheritance = new ArrayList<OoActionSystemType>();

                system = this;

                while (system != null)

                {

                        inheritance.add(0, system);

                        system = system.baseType();

                }

                final SymbolTable result = new SymbolTable();

                for (final OoActionSystemType ooas: inheritance)

                        result.AddSymbolTable(ooas.symbols());

                result.Replace("self", this.symbols().Get("self"));

                return result;

        }

        @Override

        public /*override*/ String AnonymousName()

        {

                return String.format("class_%s", Math.abs((long) this.hashCode())); //FIXME: should be unit!

        }

        public final void SetIsInSystemDescription(boolean p)

        {

                m_isInSystemDescription = p;

        }

        @Override

        public int valueCount() {

                return m_objects.size() + m_derivedObjects.size() + 1;

        }

}