---

annotation.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef annotation_h
#define annotation_h

#include "type_rep.h"
#include <ptree.h>

//
// INTERFACE definition follows 
//


class Symbol;
class Variable_symbol;
class Function_signature;

class Annotation {
    Type    type;
    Symbol* symbol;
    int     flags;
 public:
    Type    get_type() const { return type; }
    Symbol* get_symbol() const { return symbol; }

    enum Flag {
        af_DirectCall            // suppress virtual function call for this call
    };

public:  
  Annotation(Type type, Symbol* sym);
  
  virtual ~Annotation();
  
  void set_symbol(Symbol* symbol);
  
  void set_type(Type type);
  
  void add_flag(Flag f);
  
  bool has_flag(Flag f);
  
  void remove_flag(Flag f);
};

template<class T>
class Annotated : public T, public Annotation {
 public:
    template<class U>
    Annotated(Type type, Symbol* sym, U arg, Ptree* a, Ptree* b)
        : T(arg, a, b), Annotation(type, sym) { }

public:  
  Annotated(Type type, Symbol* sym);
  
  Annotated(Type type, Symbol* sym, T& src);
  
  Annotated(Type type, Symbol* sym, Ptree* a, Ptree* b);
  
  Annotated(Type type, Symbol* sym, Ptree* a, Ptree* b, Ptree* c);
};

class Annotated_funcall_maker {
    Ptree* function;
    Type result_type;
    Ptree* tree;

public:  
  /*********************** Annotated_funcall_maker *******************************/
  Annotated_funcall_maker(Ptree* function, Type result_type);
  
  ~Annotated_funcall_maker();
  
  void add_arg(Ptree* arg);
  
  Ptree* make_funcall();
};

/**************************** Accessors **************************/
Ptree* make_static_leaf(const char* txt);

Ptree* make_dup_leaf(const char* txt);

Ptree* make_dup_leaf(std::string txt);

Annotated<LeafThis>* make_this(Type type);

Annotated<LeafName>* make_name(const char* txt, Type type, Symbol* sym);

Annotated<LeafName>* make_name(std::string str, Type type, Symbol* sym);

Annotated<LeafName>* make_name(Function_signature* fsig);

Annotated<LeafName>* make_name(Variable_symbol* vsym);

Annotated<PtreeFstyleCastExpr>* make_cast_expr_unchecked(Ptree* expr, const Type& target_type);

Annotated<PtreeFstyleCastExpr>* make_cast_expr(Ptree* expr, Type target_type);

Annotated<PtreeFstyleCastExpr>* make_derived_to_base_cast(Ptree* expr, Type target_type);

Annotated<PtreeCommaExpr>* make_comma_expr(Ptree* lhs, Ptree* rhs);

Annotated<PtreeDeclaration>* make_declaration(Variable_symbol* vsym);

void fill_in_overload_annotation(Ptree* tree, Symbol* sym, Type t);

/* Handy function */
Ptree* make_unary_funcall(Ptree* function, Type result, Ptree* arg);

/* meta information -> black
   names -> red
   types -> green
   node content -> blue */
void print_annotated_tree(std::ostream& out, std::string indent, Ptree* tree, bool colors);

//
// IMPLEMENTATION includes follow (for use by inline functions)
//


#include <cstring>
#include <cstdio>
#include <typeinfo>
#include <encoding.h>
#include "symbol_table.h"
#include "variable.h"
#include "function.h"
#include "except.h"

//
// IMPLEMENTATION of inline functions (and needed classes)
//



inline void
Annotation::set_symbol(Symbol* symbol)
{
    this->symbol = symbol;
}


inline void
Annotation::set_type(Type type)
{
    this->type = type;
}


inline void
Annotation::add_flag(Flag f)
{
    flags |= 1 << f;
}


inline bool
Annotation::has_flag(Flag f)
{
    return flags & (1 << f);
}


inline void
Annotation::remove_flag(Flag f)
{
    flags &= ~(1 << f);
}

//
// IMPLEMENTATION of function templates
//




template<class T> Annotated<T>::Annotated(Type type, Symbol* sym)
    : T(), Annotation(type, sym)
{ }



template<class T> Annotated<T>::Annotated(Type type, Symbol* sym, T& src)
    : T(src),                  // hehe
      Annotation(type, sym)
{ }



template<class T> Annotated<T>::Annotated(Type type, Symbol* sym, Ptree* a, Ptree* b)
    : T(a, b), Annotation(type, sym)
{ }



template<class T> Annotated<T>::Annotated(Type type, Symbol* sym, Ptree* a, Ptree* b, Ptree* c)
    : T(a, b, c), Annotation(type, sym)
{ }

#endif // annotation_h

---