AST.hxx

Go to the documentation of this file.

#ifndef AST_HXX
#define AST_HXX


/*
 * Copyright (C) 2008, The EROS Group, LLC.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 *   - Redistributions of source code must contain the above
 *     copyright notice, this list of conditions, and the following
 *     disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions, and the following
 *     disclaimer in the documentation and/or other materials
 *     provided with the distribution.
 *
 *   - Neither the names of the copyright holders nor the names of any
 *     of any contributors may be used to endorse or promote products
 *     derived from this software without specific prior written
 *     permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <string>
#include <vector>


#include <stdint.h>

#include "libsherpa/EnumSet.hxx"
#include "libsherpa/INOstream.hxx"

#include "FQName.hxx"
#include "LitValue.hxx"
#include "Environment.hxx"
#include "debug.hxx"
#include "shared_ptr.hxx"


#define AST_SMART_PTR boost::shared_ptr
#define AST_SUPERCLASS boost::enable_shared_from_this<AST>



struct Type;
struct TypeScheme;
struct spStruct;
struct UocInfo;
struct Instance;


enum IdentType {
  id_unresolved,

  id_tvar,

  id_union,

  id_struct,

  id_object,

  id_typeclass,

  id_tcmethod,

  id_field,

  id_method,

  id_interface,

  id_value,

  id_ucon,

  id_ucon0,

  id_block,

  //
  // Anything below here is a category that is some union of
  // IdentTypes above
  //
  // The value of idc_FIRST_CATEGORY matches the value of idc_type,
  // but we list idc_type first so that debuggers will report the
  // value at runtime using that identifier.

  idc_type,

  idc_FIRST_CATEGORY = idc_type,

  idc_value,

  idc_uctor,

  idc_ctor,

  idc_apply,

  idc_usesel_lhs,
};

std::string identTypeToString(IdentType id);


/* Declarations for AST FLAGS */

enum AstFlagValues {

  // @brief Useful to have an empty set initializer:
  NO_FLAGS = 0,

  ID_IS_GLOBAL = 0x00000001u,
  ID_IS_GENSYM = 0x00000002u,

  SELF_TAIL = 0x00000004u,

  LB_IS_DUMMY = 0x00000008u,

  LB_POSTPONED = LB_IS_DUMMY,

  ID_IS_PRIVATE = 0x00000010u,

  DEF_IS_ENTRYPT = 0x00000020u,

  LB_REC_BIND = 0x00000040u,

  DEF_IS_EXTERNAL = 0x00000080u,

  ENUM_UN = 0x00000100u,

  SINGLE_LEG_UN = 0x00000200u,

  CARDELLI_UN = 0x00000400u,

  NULLABLE_UN = 0x00000800u,


  ID_FOR_USWITCH = 0x00001000u,

  ID_IS_CAPTURED = 0x00002000u,

  ID_IS_CLOSED = 0x00004000u,

  ID_NEEDS_HEAPIFY = 0x00008000u,

  ID_IS_MUTATED = 0x00010000u,

  ID_MUT_CLOSED = 0x00020000u,

  PROCLAIM_IS_INTERNAL = 0x00040000u,

  DEF_IS_TRIVIAL_INIT = 0x00080000u,

  IDENT_MANGLED = 0x00100000u,

  LOCAL_NOGEN_VAR = 0x00200000u,

  LBS_PROCESSED = 0x00400000u,

  ID_OBSERV_DEF = 0x00800000u,

  TVAR_POLY_SPECIAL = 0x01000000u,

  UNION_IS_REPR = 0x02000000u,

  FLD_IS_DISCM = 0x04000000u,

  LAM_NEEDS_TRANS = 0x08000000u,

  INNER_REF_NDX = 0x10000000u,

  ARG_BYREF = 0x20000000u,

  MASK_FLAGS_FROM_USE = (DEF_IS_ENTRYPT|ID_IS_CAPTURED)

} /* AstFlagValues */;
typedef sherpa::EnumSet<AstFlagValues> AstFlags;

enum PrintFlagValues {
  pf_NONE,
  pf_IMPLIED,

  pf_PARENWRAP
};
typedef sherpa::EnumSet<PrintFlagValues> PrintFlags;

enum PrettyPrintFlagValues {
  pp_NONE,

  pp_ShowTypes,

  pp_LitValues,

  pp_FinalNewline,

  pp_Raw,

  pp_InLayoutBlock
};

typedef sherpa::EnumSet<PrettyPrintFlagValues> PrettyPrintFlags;

struct AST;

struct EnvSet {
  boost::shared_ptr<ASTEnvironment> env;
  boost::shared_ptr<TSEnvironment> gamma;
  boost::shared_ptr<InstEnvironment> instEnv;

  EnvSet()
  {
    env = boost::GC_NULL;
    gamma = boost::GC_NULL;
    instEnv = boost::GC_NULL;
  }

  EnvSet(boost::shared_ptr<ASTEnvironment > _env, boost::shared_ptr<TSEnvironment >_gamma,
         boost::shared_ptr<InstEnvironment > _instEnv)
  {
    env = _env;
    gamma = _gamma;
    instEnv = _instEnv;
  }

  EnvSet(EnvSet &envs)
  {
    env = envs.env;
    gamma = envs.gamma;
    instEnv = envs.instEnv;
  }

  void
  updateKey(const std::string from, const std::string to)
  {
    env->updateKey(from, to);
    gamma->updateKey(from, to);
  }

  // Quasi-constructors:
  static inline boost::shared_ptr<EnvSet>
  make()
  {
    EnvSet *tmp = new EnvSet();
    return boost::shared_ptr<EnvSet>(tmp);
  }

  static inline boost::shared_ptr<EnvSet>
  make(boost::shared_ptr<ASTEnvironment> _env,
       boost::shared_ptr<TSEnvironment>_gamma,
       boost::shared_ptr<InstEnvironment> _instEnv)
  {
    EnvSet *tmp = new EnvSet(_env, _gamma, _instEnv);
    return boost::shared_ptr<EnvSet>(tmp);
  }

  static inline boost::shared_ptr<EnvSet>
  make(EnvSet &envs)
  {
    EnvSet *tmp = new EnvSet(envs);
    return boost::shared_ptr<EnvSet>(tmp);
  }
};


enum AstType {
  at_Null,
  at_AnyGroup,
  at_ident,
  at_ifident,
  at_usesel,
  at_boolLiteral,
  at_charLiteral,
  at_intLiteral,
  at_floatLiteral,
  at_stringLiteral,
  at_module,
  at_interface,
  at_defunion,
  at_declunion,
  at_defstruct,
  at_declstruct,
  at_defobject,
  at_defrepr,
  at_declrepr,
  at_reprctrs,
  at_reprctr,
  at_reprrepr,
  at_boxedCat,
  at_unboxedCat,
  at_opaqueCat,
  at_oc_closed,
  at_oc_open,
  at_defexception,
  at_deftypeclass,
  at_tcdecls,
  at_tyfn,
  at_tcapp,
  at_method_decls,
  at_method_decl,
  at_qualType,
  at_constraints,
  at_definstance,
  at_tcmethods,
  at_tcmethod_binding,
  at_proclaim,
  at_define,
  at_recdef,
  at_importAs,
  at_provide,
  at_import,
  at_ifsel,
  at_declares,
  at_declare,
  at_tvlist,
  at_constructors,
  at_constructor,
  at_fields,
  at_field,
  at_fill,
  at_methdecl,
  at_bitfieldType,
  at_byRefType,
  at_arrayRefType,
  at_boxedType,
  at_unboxedType,
  at_fn,
  at_methType,
  at_primaryType,
  at_fnargVec,
  at_arrayType,
  at_vectorType,
  at_mutableType,
  at_constType,
  at_typeapp,
  at_exceptionType,
  at_fieldType,
  at_dummyType,
  at_identPattern,
  at_typeAnnotation,
  at_mixfix,
  at_unit,
  at_suspend,
  at_sizeof,
  at_bitsizeof,
  at_MakeVector,
  at_vector,
  at_array,
  at_begin,
  at_select,
  at_fqCtr,
  at_sel_ctr,
  at_array_nth,
  at_array_ref_nth,
  at_vector_nth,
  at_nth,
  at_lambda,
  at_argVec,
  at_apply,
  at_struct_apply,
  at_object_apply,
  at_ucon_apply,
  at_if,
  at_when,
  at_unless,
  at_and,
  at_or,
  at_cond,
  at_cond_legs,
  at_cond_leg,
  at_condelse,
  at_setbang,
  at_deref,
  at_dup,
  at_inner_ref,
  at_allocREF,
  at_copyREF,
  at_mkClosure,
  at_setClosure,
  at_mkArrayRef,
  at_labeledBlock,
  at_return_from,
  at_uswitch,
  at_usw_legs,
  at_usw_leg,
  at_otherwise,
  at_try,
  at_throw,
  at_let,
  at_letbindings,
  at_letbinding,
  at_letrec,
  at_loop,
  at_loopbindings,
  at_loopbinding,
  at_looptest,
  at_localFrame,
  at_frameBindings,
  at_letStar,
  at_identList,
  at_container,
  at_docString,
  at_letGather,
  agt_var,
  agt_uselhs,
  agt_literal,
  agt_tvar,
  agt_CompilationUnit,
  agt_definition,
  agt_type_definition,
  agt_tc_definition,
  agt_value_definition,
  agt_if_definition,
  agt_category,
  agt_openclosed,
  agt_fielditem,
  agt_qtype,
  agt_type,
  agt_expr,
  agt_expr_or_define,
  agt__AnonGroup0,
  agt_eform,
  agt_ucon,
  agt_ow,
};

enum { at_NUM_ASTTYPE = agt_ow };

#ifndef AST_SMART_PTR
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#define AST_SMART_PTR boost::shared_ptr
#endif /* AST_SMART_PTR */

#ifndef AST_LOCATION_TYPE
#include <libsherpa/LexLoc.hxx>
#define AST_LOCATION_TYPE sherpa::LexLoc
#endif /* AST_LOCATION_TYPE */

#ifndef AST_TOKEN_TYPE
#include <libsherpa/LToken.hxx>
#define AST_TOKEN_TYPE sherpa::LToken
#endif /* AST_TOKEN_TYPE */

#ifndef AST_SUPERCLASS
#define AST_SUPERCLASS boost::enable_shared_from_this<AST>
#endif /* AST_SUPERCLASS */

class AST :public AST_SUPERCLASS { 
  bool isOneOf(AstType);
public:
  AstType        astType;
  ::std::string    s;
  AST_LOCATION_TYPE loc;
  ::std::vector<AST_SMART_PTR<AST> > children;


 private:
  static unsigned long long astCount;

 public:
  AST_LOCATION_TYPE endLoc() { return loc; }

  unsigned long long ID; // Unique ID of this AST

  LitValue litValue;
  unsigned long litBase;

  IdentType identType;
  AstFlags flags;

  PrintFlags printVariant;  // which syntax to use for pretty printing

  boost::shared_ptr<TypeScheme> scheme; // defining occurrences only
  boost::shared_ptr<Type> symType;      // the (pre-unified) type
  boost::shared_ptr<AST> symbolDef;

  bool isDecl;                  // is This a declaration or definition?

  bool isGlobal() { return (flags & ID_IS_GLOBAL); }
  bool isFnxn(); // Function
  size_t nBits();
  bool isLiteral();
  bool isTopLevelForm();
  bool isIdentType(IdentType idt);
  bool leadsToTopLevelForm();
  void clearTypes(); // Clear the sumType and scheme fields
                     // of this AST and ALL children RECURSIVELY.
                     // This needs to be done before re-typing an
                     // expression, for example post-clconv
                     // otherwise, old types will infulence
                     // new type records.

  boost::shared_ptr<AST> defn;

  boost::shared_ptr<AST> decl;

  FQName fqn;

  std::string externalName;

  EnvSet envs;


  boost::shared_ptr<AST> defForm;

  boost::shared_ptr<AST> defbps;

  boost::shared_ptr<Type> tagType;

  size_t field_bits;

  size_t unin_discm;

  size_t total_fill;

  boost::shared_ptr<TypeScheme> stSigma;

  boost::shared_ptr<AST> stCtr;

  // Tracking scope of type-variables:

  boost::shared_ptr<AST> tvarLB;

  boost::shared_ptr<AST> parentLB;

  static boost::shared_ptr<AST> makeBoolLit(const sherpa::LToken &tok);
  static boost::shared_ptr<AST> makeIntLit(const sherpa::LToken &tok);
  static boost::shared_ptr<AST> makeStringLit(const sherpa::LToken &tok);
  static boost::shared_ptr<AST> makeCharLit(const sherpa::LToken &tok);
  static boost::shared_ptr<AST> makeFloatLit(const sherpa::LToken &tok);

  void disown(size_t s);

  static boost::shared_ptr<AST>
    genIdent(const char *pfx = "tmp", const bool isTV = false);

  static boost::shared_ptr<AST> genSym(boost::shared_ptr<AST> lhs,
                     const char *pfx="tmp",
                     const bool isTV = false);

  std::string atKwd() const;
  std::string old_atKwd() const;

  void getIds(std::ostream &errStream,
              std::vector<boost::shared_ptr<AST> >& ids,
              bool getPattern = false);

  boost::shared_ptr<Type> getType();
  boost::shared_ptr<const Type> getType() const;

  boost::shared_ptr<AST> getCtr();


  boost::shared_ptr<AST> Use();

  AST(boost::shared_ptr<AST> ast, bool shallowCopyChildren=true);

  static inline boost::shared_ptr<AST>
  make(boost::shared_ptr<AST> ast, bool shallowCopyChildren=true) {
    AST *tmp = new AST(ast,shallowCopyChildren);
    return boost::shared_ptr<AST>(tmp);
  }

  boost::shared_ptr<AST> getTrueCopy();

  boost::shared_ptr<AST> getDeepCopy();

  void rename(boost::shared_ptr<AST> from, std::string newName);

  std::string asString() const;
  std::string asString(PrettyPrintFlags flags) const;

  boost::shared_ptr<AST> getID();

  boost::shared_ptr<AST> getInstanceMethod(std::string name);

  bool isUnionLeg();
  bool isTcMethod();

  // @brief Return the precedence of this AST node, for use in
  // pretty-printing the block syntax.
  int precedence() const;

  void PrettyPrint(std::ostream& out,
                   PrettyPrintFlags flags = pp_FinalNewline) const;

  void PrettyPrint(sherpa::INOstream& out,
                   PrettyPrintFlags flags = pp_FinalNewline) const;

  // For use in GDB:
  void PrettyPrint(bool decorated) const;

  AST(const AstType at = at_Null);
  // for literals:
  AST(const AstType at, const AST_TOKEN_TYPE& tok);
  AST(const AstType at, const AST_LOCATION_TYPE &loc);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1,
      AST_SMART_PTR<AST> child2);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1,
      AST_SMART_PTR<AST> child2,
      AST_SMART_PTR<AST> child3);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1,
      AST_SMART_PTR<AST> child2,
      AST_SMART_PTR<AST> child3,
      AST_SMART_PTR<AST> child4);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1,
      AST_SMART_PTR<AST> child2,
      AST_SMART_PTR<AST> child3,
      AST_SMART_PTR<AST> child4,
      AST_SMART_PTR<AST> child5);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1,
      AST_SMART_PTR<AST> child2,
      AST_SMART_PTR<AST> child3,
      AST_SMART_PTR<AST> child4,
      AST_SMART_PTR<AST> child5,
      AST_SMART_PTR<AST> child6);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1,
      AST_SMART_PTR<AST> child2,
      AST_SMART_PTR<AST> child3,
      AST_SMART_PTR<AST> child4,
      AST_SMART_PTR<AST> child5,
      AST_SMART_PTR<AST> child6,
      AST_SMART_PTR<AST> child7);
  AST(const AstType at, const AST_LOCATION_TYPE &loc,
      AST_SMART_PTR<AST> child1,
      AST_SMART_PTR<AST> child2,
      AST_SMART_PTR<AST> child3,
      AST_SMART_PTR<AST> child4,
      AST_SMART_PTR<AST> child5,
      AST_SMART_PTR<AST> child6,
      AST_SMART_PTR<AST> child7,
      AST_SMART_PTR<AST> child8);
  ~AST();

  // Helper quasi-constructors
  static inline AST_SMART_PTR<AST>
  make(const AstType at = at_Null)
  {
    AST *ast = new AST(at);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_TOKEN_TYPE& tok)
  {
    AST *ast = new AST(at, tok);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc)
  {
    AST *ast = new AST(at, loc);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       AST_SMART_PTR<AST> child1)
  {
    AST *ast = new AST(at, loc, child1);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       const AST_SMART_PTR<AST> child1,
       const AST_SMART_PTR<AST> child2)
  {
    AST *ast = new AST(at, loc, child1, child2);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       const AST_SMART_PTR<AST> child1,
       const AST_SMART_PTR<AST> child2,
       const AST_SMART_PTR<AST> child3)
  {
    AST *ast = new AST(at, loc, child1, child2,
                       child3);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       const AST_SMART_PTR<AST> child1,
       const AST_SMART_PTR<AST> child2,
       const AST_SMART_PTR<AST> child3,
       const AST_SMART_PTR<AST> child4)
  {
    AST *ast = new AST(at, loc, child1, child2,
                       child3, child4);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       const AST_SMART_PTR<AST> child1,
       const AST_SMART_PTR<AST> child2,
       const AST_SMART_PTR<AST> child3,
       const AST_SMART_PTR<AST> child4,
       const AST_SMART_PTR<AST> child5)
  {
    AST *ast = new AST(at, loc, child1, child2,
                       child3, child4, child5);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       const AST_SMART_PTR<AST> child1,
       const AST_SMART_PTR<AST> child2,
       const AST_SMART_PTR<AST> child3,
       const AST_SMART_PTR<AST> child4,
       const AST_SMART_PTR<AST> child5,
       const AST_SMART_PTR<AST> child6)
  {
    AST *ast = new AST(at, loc, child1, child2,
                       child3, child4, child5,
                       child6);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       const AST_SMART_PTR<AST> child1,
       const AST_SMART_PTR<AST> child2,
       const AST_SMART_PTR<AST> child3,
       const AST_SMART_PTR<AST> child4,
       const AST_SMART_PTR<AST> child5,
       const AST_SMART_PTR<AST> child6,
       const AST_SMART_PTR<AST> child7)
  {
    AST *ast = new AST(at, loc, child1, child2,
                       child3, child4, child5,
                       child6, child7);
    return AST_SMART_PTR<AST>(ast);
  }

  static inline AST_SMART_PTR<AST>
  make(const AstType at, const AST_LOCATION_TYPE &loc,
       const AST_SMART_PTR<AST> child1,
       const AST_SMART_PTR<AST> child2,
       const AST_SMART_PTR<AST> child3,
       const AST_SMART_PTR<AST> child4,
       const AST_SMART_PTR<AST> child5,
       const AST_SMART_PTR<AST> child6,
       const AST_SMART_PTR<AST> child7,
       const AST_SMART_PTR<AST> child8)
  {
    AST *ast = new AST(at, loc, child1, child2,
                       child3, child4, child5,
                       child6, child7, child8);
    return AST_SMART_PTR<AST>(ast);
  }


  const AST_SMART_PTR<AST>
  child(size_t i) const
  {
    return children[i];
  }

  AST_SMART_PTR<AST>&
  child(size_t i)
  {
    return children[i];
  }

  void addChild(AST_SMART_PTR<AST> cld);
  ::std::string getTokenString();

  void
  addChildrenFrom(AST_SMART_PTR<AST> other)
  {
    for(size_t i = 0; i < other->children.size(); i++)
      addChild(other->child(i));
  }

  static const char *tagName(const AstType at);
  static const char *nodeName(const AstType at);
  static const char *printName(const AstType at);

  inline const char *tagName() const
  { return tagName(astType); }

  inline const char *nodeName() const
  { return nodeName(astType); }

  inline const char *printName() const
  { return printName(astType); }

  bool isMemberOfType(AstType) const;
  bool isValid() const;
};


#endif /* AST_HXX */

---