source: translator/Parser/ParseNode.h @ 2c2242c

#ifndef PARSENODE_H
#define PARSENODE_H

#include <iostream>
#include <string>
#include <list>
#include <iterator>

#include "utility.h"
#include "SynTree/SynTree.h"
#include "SynTree/Declaration.h"
#include "SemanticError.h"
#include "UniqueName.h"

class ExpressionNode;
class CompositeExprNode;
class CommaExprNode;
class StatementNode;
class CompoundStmtNode;
class DeclarationNode;
class InitializerNode;

// Builder
class ParseNode {
public:
  ParseNode(void);
  ParseNode (std::string);
  virtual ~ParseNode(void);

  ParseNode *set_name (std::string) ;
  ParseNode *set_name (std::string *) ;

  std::string get_name(void);

  ParseNode *get_link(void) const;
  ParseNode *get_last(void);
  ParseNode *set_link(ParseNode *);
  void set_next( ParseNode *newlink ) { next = newlink; }

  virtual ParseNode *clone() const { return 0; };

  const std::string get_name(void) const;
  virtual void print( std::ostream &, int indent = 0 ) const;
  virtual void printList( std::ostream &, int indent = 0 ) const;

  ParseNode &operator,(ParseNode &);

protected:
  std::string name;
  ParseNode *next;
  static int indent_by;
};

ParseNode *mkList(ParseNode &);

class ExpressionNode : public ParseNode {
public:
  ExpressionNode();
  ExpressionNode(std::string *);
  ExpressionNode( const ExpressionNode &other );
  virtual ~ExpressionNode() { /* can't delete asArgName because it might be referenced elsewhere */ };

  virtual ExpressionNode *clone() const = 0;

  virtual CommaExprNode *add_to_list(ExpressionNode *);

  ExpressionNode *get_argName() const { return argName; }
  ExpressionNode *set_asArgName( std::string *aName );
  ExpressionNode *set_asArgName( ExpressionNode *aDesignator );

  virtual void print(std::ostream &, int indent = 0) const = 0;
  virtual void printOneLine(std::ostream &, int indent = 0) const = 0;

  virtual Expression *build() const = 0;
protected:
  void printDesignation (std::ostream &, int indent = 0) const;

private:
  ExpressionNode *argName;
};

// NullExprNode is used in tuples as a place-holder where a tuple component is omitted
// e.g., [ 2, , 3 ]
class NullExprNode : public ExpressionNode
{
public:
  NullExprNode();

  virtual NullExprNode *clone() const;

  virtual void print(std::ostream &, int indent = 0) const;
  virtual void printOneLine(std::ostream &, int indent = 0) const;

  virtual Expression *build() const;
};

class ConstantNode : public ExpressionNode {
public:
  enum Type {
    Integer, Float, Character, String /* , Range, EnumConstant  */
  };

  ConstantNode(void);
  ConstantNode(std::string *);
  ConstantNode(Type, std::string *);
  ConstantNode( const ConstantNode &other );

  virtual ConstantNode *clone() const { return new ConstantNode( *this ); }

  Type get_type(void) const ;
  virtual void print(std::ostream &, int indent = 0) const;
  virtual void printOneLine(std::ostream &, int indent = 0) const;

  std::string get_value() const { return value; }
  ConstantNode *append( std::string *newValue );

  Expression *build() const;

private:
  void classify(std::string &);
  Type type;
  std::string value;
  bool sign;
  short base;
  int longs, size;
};

class VarRefNode : public ExpressionNode {
public:
  VarRefNode();
  VarRefNode(std::string *, bool isLabel = false );
  VarRefNode( const VarRefNode &other );

  virtual Expression *build() const ;

  virtual VarRefNode *clone() const { return new VarRefNode( *this ); }

  virtual void print(std::ostream &, int indent = 0) const;
  virtual void printOneLine(std::ostream &, int indent = 0) const;
private:
  bool isLabel;
};

class TypeValueNode : public ExpressionNode
{
public:
  TypeValueNode(DeclarationNode *);
  TypeValueNode( const TypeValueNode &other );

  DeclarationNode *get_decl() const { return decl; }

  virtual Expression *build() const ;

  virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }

  virtual void print(std::ostream &, int indent = 0) const;
  virtual void printOneLine(std::ostream &, int indent = 0) const;
private:
  DeclarationNode *decl;
};

class OperatorNode : public ExpressionNode {
public:
  enum Type { TupleC, Comma, TupleFieldSel,
              Cond, NCond, 
              SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, 
                BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, 
                Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, 
                ERAssn, OrAssn, Index, FieldSel, PFieldSel, Range,
              UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
            };

  OperatorNode(Type t);
  OperatorNode( const OperatorNode &other );
  virtual ~OperatorNode();

  virtual OperatorNode *clone() const { return new OperatorNode( *this ); }

  Type get_type(void) const;
  std::string get_typename(void) const;

  virtual void print(std::ostream &, int indent = 0) const;
  virtual void printOneLine(std::ostream &, int indent = 0) const;

  virtual Expression *build() const { return 0; }
  
private:
  Type type;
  static const char *OpName[];
};


class CompositeExprNode : public ExpressionNode {
public:
  CompositeExprNode(void);
  CompositeExprNode(std::string *);
  CompositeExprNode(ExpressionNode *f, ExpressionNode *args = 0);
  CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2);
  CompositeExprNode( const CompositeExprNode &other );
  virtual ~CompositeExprNode();

  virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
  virtual Expression *build() const;

  virtual void print(std::ostream &, int indent = 0) const;
  virtual void printOneLine(std::ostream &, int indent = 0) const;

  void set_function(ExpressionNode *);
  void set_args(ExpressionNode *);

  void add_arg(ExpressionNode *);

  ExpressionNode *get_function() const;
  ExpressionNode *get_args() const;

private:
  ExpressionNode *function;
  ExpressionNode *arguments;
};

class CommaExprNode : public CompositeExprNode {
public:
  CommaExprNode();
  CommaExprNode(ExpressionNode *);
  CommaExprNode(ExpressionNode *, ExpressionNode *);
  CommaExprNode( const CommaExprNode &other );

  virtual CommaExprNode *add_to_list(ExpressionNode *);
  virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
};

class ForCtlExprNode : public ExpressionNode {
public:
  ForCtlExprNode(ParseNode *, ExpressionNode *, ExpressionNode *) throw (SemanticError);
  ForCtlExprNode( const ForCtlExprNode &other );
  ~ForCtlExprNode();

  StatementNode *get_init() const { return init; }
  ExpressionNode *get_condition() const { return condition; }
  ExpressionNode *get_change() const { return change; }

  virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
  virtual Expression *build() const;

  virtual void print( std::ostream &, int indent = 0 ) const;
  virtual void printOneLine( std::ostream &, int indent = 0 ) const;
private:
  StatementNode *init;
  ExpressionNode *condition;
  ExpressionNode *change;
};

class ValofExprNode : public ExpressionNode {
public:
  ValofExprNode();
  ValofExprNode( StatementNode *s = 0 );
  ValofExprNode( const ValofExprNode &other );
  ~ValofExprNode();
  
  virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }

  StatementNode *get_body() const { return body; }
  void print( std::ostream &, int indent = 0 ) const;
  void printOneLine( std::ostream &, int indent = 0 ) const;
  Expression *build() const;

private:
  StatementNode *body;
};

class TypeData;

class DeclarationNode : public ParseNode
{
public:
  enum Qualifier { Const, Restrict, Volatile, Lvalue };
  enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran };
  enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
  enum Modifier { Signed, Unsigned, Short, Long };
  enum TyCon { Struct, Union, Context };
  enum TypeClass { Type, Dtype, Ftype };

  static const char *qualifierName[];
  static const char *basicTypeName[];
  static const char *modifierName[];
  static const char *tyConName[];
  static const char *typeClassName[];

  static DeclarationNode *newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param,
                                       StatementNode *body, bool newStyle = false );
  static DeclarationNode *newQualifier( Qualifier );
  static DeclarationNode *newStorageClass( StorageClass );
  static DeclarationNode *newBasicType( BasicType );
  static DeclarationNode *newModifier( Modifier );
  static DeclarationNode *newForall( DeclarationNode* );
  static DeclarationNode *newFromTypedef( std::string* );
  static DeclarationNode *newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
  static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
  static DeclarationNode *newEnumConstant( std::string* name, ExpressionNode *constant );
  static DeclarationNode *newName( std::string* );
  static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params );
  static DeclarationNode *newTypeParam( TypeClass, std::string* );
  static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
  static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
  static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
  static DeclarationNode *newPointer( DeclarationNode *qualifiers );
  static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
  static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
  static DeclarationNode *newBitfield( ExpressionNode *size );
  static DeclarationNode *newTuple( DeclarationNode *members );
  static DeclarationNode *newTypeof( ExpressionNode *expr );
  static DeclarationNode *newAttr( std::string*, ExpressionNode *expr );
  static DeclarationNode *newAttr( std::string*, DeclarationNode *type );

  DeclarationNode *addQualifiers( DeclarationNode* );
  DeclarationNode *copyStorageClasses( DeclarationNode* );
  DeclarationNode *addType( DeclarationNode* );
  DeclarationNode *addTypedef();
  DeclarationNode *addAssertions( DeclarationNode* );
  DeclarationNode *addName( std::string* );
  DeclarationNode *addBitfield( ExpressionNode *size );
  DeclarationNode *addVarArgs();
  DeclarationNode *addFunctionBody( StatementNode *body );
  DeclarationNode *addOldDeclList( DeclarationNode *list );
  DeclarationNode *addPointer( DeclarationNode *qualifiers );
  DeclarationNode *addArray( DeclarationNode *array );
  DeclarationNode *addNewPointer( DeclarationNode *pointer );
  DeclarationNode *addNewArray( DeclarationNode *array );
  DeclarationNode *addParamList( DeclarationNode *list );
  DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
  DeclarationNode *addInitializer( InitializerNode *init );

  DeclarationNode *cloneType( std::string *newName );
  DeclarationNode *cloneType( DeclarationNode *existing );
  DeclarationNode *cloneType( int ) { return cloneType( (std::string*)0 ); }
  DeclarationNode *cloneBaseType( std::string *newName );
  DeclarationNode *cloneBaseType( DeclarationNode *newdecl );

  DeclarationNode *appendList( DeclarationNode * );

  DeclarationNode *clone() const;
  void print( std::ostream &, int indent = 0 ) const;
  void printList( std::ostream &, int indent = 0 ) const;

  Declaration *build() const;
  ::Type *buildType() const;

  bool get_hasEllipsis() const;
  std::string get_name() const { return name; }
  LinkageSpec::Type get_linkage() const { return linkage; }
  DeclarationNode *extractAggregate() const;

  DeclarationNode();
  ~DeclarationNode();
private:
  Declaration::StorageClass buildStorageClass() const;
  bool buildInline() const;

  TypeData *type;
  std::string name;
  std::list< StorageClass > storageClasses;
  ExpressionNode *bitfieldWidth;
  InitializerNode *initializer;
  bool hasEllipsis;
  LinkageSpec::Type linkage;

  static UniqueName anonymous;
};

class StatementNode : public ParseNode {
public:
  enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru, 
              While, Do,        For,
              Goto,  Continue,  Break,   Return,  Throw,
              Try,   Catch,     Finally, Asm,
              Decl
            };

  StatementNode( void );
  StatementNode( std::string );
  StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
  StatementNode( Type, std::string *target );
  StatementNode( DeclarationNode *decl );


  ~StatementNode(void);

  static StatementNode * newCatchStmt(DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );

  void set_control(ExpressionNode *);
  StatementNode * set_block(StatementNode *);

  ExpressionNode *get_control() const ;
  StatementNode *get_block() const;
  StatementNode::Type get_type(void) const;

  StatementNode *add_label(std::string *);
  std::list<std::string> *get_labels() const;

  void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
  void setCatchRest( bool newVal ) { isCatchRest = newVal; }

  std::string get_target() const;

  StatementNode *add_controlexp(ExpressionNode *);
  StatementNode *append_block(StatementNode *);
  StatementNode *append_last_case(StatementNode *);

  void print( std::ostream &, int indent = 0) const;

  virtual StatementNode *clone() const;

  virtual Statement *build() const;

private:
  static const char *StType[];
  Type type;
  ExpressionNode *control;
  StatementNode *block;
  std::list<std::string> *labels;
  std::string *target; // target label for jump statements
  DeclarationNode *decl;

  bool isCatchRest;
};

class CompoundStmtNode : public StatementNode {
public:
  CompoundStmtNode(void);
  CompoundStmtNode(std::string *);
  CompoundStmtNode(StatementNode *);
  ~CompoundStmtNode();

  void add_statement(StatementNode *);

  void print( std::ostream &, int indent = 0 ) const;

  virtual Statement *build() const;

private:
  StatementNode *first, *last;
};

class NullStmtNode : public CompoundStmtNode {
public:
  Statement *build() const;
  void print(std::ostream &, int indent = 0) const;
};

class InitializerNode : public ParseNode {
public:
  InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
  InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
  ~InitializerNode();

  ExpressionNode *get_expression() const { return expr; }

  InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
  ExpressionNode *get_designators() const { return designator; }

  InitializerNode *next_init() const { return kids; }

  void print( std::ostream &, int indent = 0 ) const;
  void printOneLine( std::ostream & ) const;

  virtual Initializer *build() const;

private:
  ExpressionNode *expr;
  bool aggregate;
  ExpressionNode *designator; // may be list
  InitializerNode *kids;
};



template< typename SynTreeType, typename NodeType >
void
buildList( const NodeType *firstNode, std::list< SynTreeType* > &outputList )
{
  SemanticError errors;
  std::back_insert_iterator< std::list< SynTreeType* > > out( outputList );
  const NodeType *cur = firstNode;

  while( cur ) {
    try {
      SynTreeType *result = dynamic_cast< SynTreeType* >( cur->build() );
      if( result ) {
        *out++ = result;
      } else {
      }
    } catch( SemanticError &e ) {
      errors.append( e );
    }
    cur = dynamic_cast< NodeType* >( cur->get_link() );
  }
  if( !errors.isEmpty() ) {
    throw errors;
  }
}

// in DeclarationNode.cc
void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList );
void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList );
void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList );

// in ExpressionNode.cc
ExpressionNode *flattenCommas( ExpressionNode *list );
ExpressionNode *tupleContents( ExpressionNode *tuple );

#endif /* #ifndef PARSENODE_H */

// Local Variables: //
// mode: C++ //
// compile-command: "gmake" //
// End: //