Example #1
0
        void Composition::
        begin (SimpleIdentifierPtr const& id, Category::Value c)
        {
          if (ctx.trace ()) cerr << "composition " << id << endl;

          if(c == Category::entity)
          {
            now (ctx.tu ().new_node<EntityComposition> (
                   ctx.file (), id->line ()));
          }
          else if (c == Category::process)
          {
            now (ctx.tu ().new_node<ProcessComposition> (
                   ctx.file (), id->line ()));
          }
          else if (c == Category::service)
          {
            now (ctx.tu ().new_node<ServiceComposition> (
                   ctx.file (), id->line ()));
          }
          else
          {
            now (ctx.tu ().new_node<SessionComposition> (
                   ctx.file (), id->line ()));
          }

          ctx.tu ().new_edge<Defines> (ctx.scope (), now (), id->lexeme ());
        }
        void Operation::
        name (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << " " << id << endl;

          if (one_way_)
          {
            if (dynamic_cast<Void*> (type_) == 0)
            {
              cerr << ctx.file () << ":" << id->line () << ": error: "
                   << "invalid operation declaration" << endl;

              cerr << ctx.file () << ":" << id->line () << ": error: "
                   << "oneway operation should have void as a return type"
                   << endl;
            }

            op_ = &ctx.tu ().new_node<OneWayOperation> (
              ctx.file (), id->line ());
          }
          else
            op_ = &ctx.tu ().new_node<TwoWayOperation> (
              ctx.file (), id->line ());

          SimpleName name (id->lexeme ());
          ctx.tu ().new_edge<Defines> (ctx.scope (), *op_, name);

          if (type_)
          {
            ctx.tu ().new_edge<Returns> (*op_, *type_);
          }
        }
Example #3
0
void Typedef::
declarator (SimpleIdentifierPtr const& id)
{
    if (ctx.trace ()) cerr << " " << id << endl;

    SimpleName name (id->lexeme ());

    try
    {
        if (lookup (ctx.tu (), ctx.scope (), name) == 0)
        {
            if (array_type_ != 0)
            {
                assert (define_);

                ctx.tu ().new_edge<Defines> (ctx.scope (), *array_type_, name);

                define_ = false;
                array_type_ = 0;
            }
            else if (type_ != 0)
            {
                if (define_)
                {
                    ctx.tu ().new_edge<Defines> (ctx.scope (), *type_, name);
                    define_ = false;
                }
                else
                {
                    ctx.tu ().new_edge<Aliases> (ctx.scope (), *type_, name);
                }
            }
            return;
        }
    }
    catch (NotUnique const& )
    {
    }

    cerr << ctx.file () << ":" << id->line () << ": error: "
         << "invalid typedef declaration" << endl;

    cerr << ctx.file () << ":" << id->line () << ": error: "
         << "redeclaration of name " << name << endl;

    array_type_ = 0;
}
Example #4
0
        void EventTypeFactory::
        parameter (IdentifierPtr const& type_id,
                   SimpleIdentifierPtr const& name_id)
        {
          if (ctx.trace ()) cerr << "parameter in " << " "
                                 << type_id << " " << name_id << endl;

          if (f_ == 0) return;

          Name name (type_id->lexeme ());
          ScopedName from (ctx.scope ().scoped_name ());

          try
          {
            try
            {
              Type& t (resolve<Type> (from, name, Flags::complete));

              Parameter& p (
                ctx.tu ().new_node<InParameter> (
                  ctx.file (), name_id->line (), name_id->lexeme ()));

              ctx.tu ().new_edge<Belongs> (p, t);
              ctx.tu ().new_edge<Receives> (*f_, p);
            }
            catch (Resolve const&)
            {
              cerr << ctx.file () << ":" << type_id->line () << ": error: "
                   << "invalid parameter declaration" << endl;
              throw;
            }
          }
          catch (NotFound const&)
          {
            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "no type with name \'" << name
                 << "\' visible from scope \'" << from << "\'" << endl;
          }
          catch (WrongType const&)
          {
            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "declaration with name \'" << name
                 << "\' visible from scope \'" << from
                 << "\' is not a type declaration" << endl;

            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "using non-type as an factory parameter type is "
                 << "illegal" << endl;
          }
          catch (NotComplete const& e)
          {
            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "type \'" << e.name () << "\' is not complete" << endl;
          }
        }
Example #5
0
        void Native::
        name (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << "native " << id << endl;

          SimpleName name (id->lexeme ());

          SemanticGraph::Native& n (
            ctx.tu ().new_node<SemanticGraph::Native> (
              ctx.file (), id->line ()));

          ctx.tu ().new_edge<Defines> (ctx.scope (), n, name);
        }
Example #6
0
void Enum::
begin (SimpleIdentifierPtr const& id)
{
    if (ctx.trace ()) cerr << "enum " << id << endl;

    type_ = 0;

    SimpleName name (id->lexeme ());

    type_ = &ctx.tu ().new_node<SemanticGraph::Enum> (
                ctx.file (), id->line ());

    ctx.tu ().new_edge<Defines> (ctx.scope (), *type_, name);
}
        void ValueTypeMember::
        name (SimpleIdentifierPtr const& id)
        {
          using namespace SemanticGraph;

          if (ctx.trace ()) cerr << " name: " << id << endl;

          if (type_)
          {
            SimpleName name (id->lexeme ());

            SemanticGraph::ValueTypeMember* m;

            switch (access_)
            {
            case SemanticGraph::ValueTypeMember::Access::private_:
              {
                m = &ctx.tu ().new_node<ValueTypePrivateMember> (
                  ctx.file (), id->line ());
                break;
              }
            case SemanticGraph::ValueTypeMember::Access::public_:
              {
                m = &ctx.tu ().new_node<ValueTypePublicMember> (
                  ctx.file (), id->line ());
                break;
              }
            default:
              {
                abort ();
              }
            }

            ctx.tu ().new_edge<Belongs> (*m, *type_);
            ctx.tu ().new_edge<Defines> (ctx.scope (), *m, name);
          }
        }
Example #8
0
        void Publishes::
        name (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << " " << id << endl;

          if (type_)
          {
            Publisher& p (
              ctx.tu ().new_node<Publisher> (
                ctx.file (), id->line ()));

            ctx.tu ().new_edge<Belongs> (p, *type_);
            ctx.tu ().new_edge<Defines> (ctx.scope (), p, id->lexeme ());
          }
        }
Example #9
0
File: Member.cpp Project: SEDS/CUTS
        void Member::
        name (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << " " << id << endl;

          if (type_)
          {
            SimpleName name (id->lexeme ());

            SemanticGraph::Member& m (
              ctx.tu ().new_node<SemanticGraph::Member> (
                ctx.file (), id->line ()));

            ctx.tu ().new_edge<Belongs> (m, *type_);
            ctx.tu ().new_edge<Defines> (ctx.scope (), m, name);
          }
        }
Example #10
0
        void EventTypeFactory::
        name (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << " " << id << endl;

          f_ = 0;

          SemanticGraph::EventType& h (
            dynamic_cast<SemanticGraph::EventType&>(ctx.scope ()));

          SimpleName name (id->lexeme ());

          f_ = &ctx.tu ().new_node<SemanticGraph::EventTypeFactory> (
            ctx.file (), id->line ());

          ctx.tu ().new_edge<Returns> (*f_, h);
          ctx.tu ().new_edge<Defines> (ctx.scope (), *f_, name);
        }
Example #11
0
        void Interface::
        begin_local_fwd (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << "local interface fwd " << id << endl;

          SimpleName name (id->lexeme ());

          if (Nameable* s = lookup (ctx.tu (), ctx.scope (), name))
          {
            now (dynamic_cast<LocalInterface&>(*s));
          }
          else
          {
            now (ctx.tu ().new_node<LocalInterface> (
                   ctx.file (), id->line ()));
          }

          ctx.tu ().new_edge<Mentions> (ctx.scope (), now (), name);
        }
Example #12
0
        void Component::
        begin_def (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << "component def " << id << endl;

          SimpleName name (id->lexeme ());

          if (Nameable* s = lookup (ctx.tu (), ctx.scope (), name))
          {
            now (dynamic_cast<SemanticGraph::Component&>(*s));
          }
          else
          {
            now (ctx.tu ().new_node<SemanticGraph::Component> (
                   ctx.file (), id->line ()));
          }

          ctx.tu ().new_edge<Defines> (ctx.scope (), now (), name);
        }
Example #13
0
File: Union.cpp Project: SEDS/CUTS
        void Union::
        begin_fwd (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << "union fwd " << id << endl;

          SimpleName name (id->lexeme ());

          if (Nameable* s = lookup (ctx.tu (), ctx.scope (), name))
          {
            now (dynamic_cast<SemanticGraph::Union&>(*s));
          }
          else
          {
            now (ctx.tu ().new_node<SemanticGraph::Union> (
                   ctx.file (), id->line ()));
          }

          ctx.tu ().new_edge<Mentions> (ctx.scope (), now (), name);
        }
Example #14
0
void Enum::
enumerator (SimpleIdentifierPtr const& id)
{
    if (ctx.trace ()) cerr << "enumerator " << id << endl;

    //@@ Need to check for redeclaration of the name.
    //

    SimpleName name (id->lexeme ());

    if (type_ != 0)
    {
        Enumerator& e (
            ctx.tu ().new_node<Enumerator> (
                ctx.file (), id->line ()));

        ctx.tu ().new_edge<Belongs> (e, *type_);
        ctx.tu ().new_edge<Defines> (ctx.scope (), e, name);
    }
}
Example #15
0
        void HomeFinder::
        name (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << " " << id << endl;

          hf_ = 0;

          SemanticGraph::Home& h (
            dynamic_cast<SemanticGraph::Home&>(ctx.scope ()));

          SemanticGraph::Component& c (
            dynamic_cast<SemanticGraph::Component&>(h.manages ().managee ()));

          SimpleName name (id->lexeme ());

          hf_ = &ctx.tu ().new_node<SemanticGraph::HomeFinder> (
            ctx.file (), id->line ());

          ctx.tu ().new_edge<Returns> (*hf_, c);
          ctx.tu ().new_edge<Defines> (ctx.scope (), *hf_, name);
        }
Example #16
0
        void Interface::
        begin_unconstrained_def (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << "unconstrained interface def " << id
                                 << endl;

          qualifier_ = Qualifier::unconstrained;

          SimpleName name (id->lexeme ());

          if (Nameable* s = lookup (ctx.tu (), ctx.scope (), name))
          {
            now (dynamic_cast<UnconstrainedInterface&>(*s));
          }
          else
          {
            now (ctx.tu ().new_node<UnconstrainedInterface> (
                   ctx.file (), id->line ()));
          }

          ctx.tu ().new_edge<Defines> (ctx.scope (), now (), name);
        }
Example #17
0
        void Interface::
        begin_abstract_def (SimpleIdentifierPtr const& id)
        {
          if (ctx.trace ()) cerr << "abstract interface def " << id << endl;

          qualifier_ = Qualifier::abstract;

          SimpleName name (id->lexeme ());

          //@@ Not handling NotUnique exception.
          //
          if (Nameable* s = lookup (ctx.tu (), ctx.scope (), name))
          {
            now (dynamic_cast<AbstractInterface&>(*s));
          }
          else
          {
            now (ctx.tu ().new_node<AbstractInterface> (
                   ctx.file (), id->line ()));
          }

          ctx.tu ().new_edge<Defines> (ctx.scope (), now (), name);
        }
Example #18
0
        void Operation::
        parameter (Direction::Value direction,
                   IdentifierPtr const& type_id,
                   SimpleIdentifierPtr const& name_id)
        {
          if (ctx.trace ()) cerr << "parameter " << direction << " "
                                 << type_id << " " << name_id << endl;

          Name name (type_id->lexeme ());
          ScopedName from (ctx.scope ().scoped_name ());

          struct NotIn : Resolve {};

          try
          {
            try
            {
              if (one_way_ && direction != Direction::in)
                throw NotIn ();

              Type& t (resolve<Type> (from, name, Flags::complete));

              Parameter* p (0);

              switch (direction)
              {
              case Direction::in:
                {
                  p = &ctx.tu ().new_node<InParameter> (
                    ctx.file (), name_id->line (), name_id->lexeme ());
                  break;
                }
              case Direction::out:
                {
                  p = &ctx.tu ().new_node<OutParameter> (
                    ctx.file (), name_id->line (), name_id->lexeme ());
                  break;
                }
              case Direction::inout:
                {
                  p = &ctx.tu ().new_node<InOutParameter> (
                    ctx.file (), name_id->line (), name_id->lexeme ());
                  break;
                }
              }

              ctx.tu ().new_edge<Belongs> (*p, t);
              ctx.tu ().new_edge<Receives> (*op_, *p);
            }
            catch (Resolve const&)
            {
              cerr << ctx.file () << ":" << type_id->line () << ": error: "
                   << "invalid parameter declaration" << endl;
              throw;
            }
          }
          catch (NotFound const&)
          {
            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "no type with name \'" << name
                 << "\' visible from scope \'" << from << "\'" << endl;
          }
          catch (WrongType const&)
          {
            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "declaration with name \'" << name
                 << "\' visible from scope \'" << from
                 << "\' is not a type declaration" << endl;

            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "using non-type as an operation parameter type is "
                 << "illegal" << endl;
          }
          catch (NotComplete const& e)
          {
            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "type \'" << e.name () << "\' is not complete" << endl;
          }
          catch (NotIn const&)
          {
            cerr << ctx.file () << ":" << type_id->line () << ": error: "
                 << "parameter of oneway operation should have \'in\' "
                 << "direction" << endl;
          }
        }