caraway/caraway/node.h

#ifndef TREE_H
#define TREE_H

/* These are the possible types of parse-tree nodes */
typedef enum
  {
    TREE_METHOD_NODE,
    TREE_UNARY_EXPR,
    TREE_BINARY_EXPR,
    TREE_KEYWORD_EXPR,
    TREE_VARIABLE_NODE,
    TREE_KEYWORD_LIST,
    TREE_VAR_DECL_LIST,
    TREE_VAR_ASSIGN_LIST,
    TREE_STATEMENT_LIST,
    TREE_RETURN_EXPR,
    TREE_ASSIGN_EXPR,
    TREE_CONST_EXPR,
    TREE_SYMBOL_NODE,
    TREE_ARRAY_ELT_LIST,
    TREE_BLOCK_NODE,
    TREE_CASCADE_EXPR,
    TREE_MESSAGE_LIST,
    TREE_DYNAMIC_ARRAY,

    TREE_FIRST = TREE_METHOD_NODE,
    TREE_LAST = TREE_DYNAMIC_ARRAY
  }
node_type;

/* A structure holding a constant for objects having byte-sized
   indexed instance variables(ByteArrays and LargeIntegers).  */
typedef struct byte_object
{
  OOP class;
  int size;
  //gst_uchar body[1];
}
*byte_object;

/* A forward declaration. */
typedef struct tree_node *tree_node;

/* A generic kind of parse-tree node that stores a list of nodes.  In
   particular, NEXTADDR points to the last NEXT pointer in the list so
   that tail adds are easier.  These nodes are also used for variables
   by storing their name in the NAME member and by setting an
   appropriate node type like TREE_VARIABLE_NODE(when the variable is
   an argument or the receiver of a message) or TREE_VAR_DECL_LIST(when
   the nodes is a list of arguments or temporaries).  */
typedef struct list_node
{
  char *name;
  tree_node value;
  tree_node next;
  tree_node *nextAddr;
}
list_node;

/* A parse-tree node for a message send.  EXPRESSION is a list_node
   containing the arguments.  The same data structure is also used for
   assignments(TREE_ASSIGN_EXPR) and in this case RECEIVER is the list
   of assigned-to variables, SELECTOR is dummy and EXPRESSION is the
   assigned value. */
typedef struct expr_node
{
  tree_node receiver;
  OOP selector;
  tree_node expression;
}
expr_node;

/* The different kinds of constants that can be stored in a
   const_node. */
typedef enum {
  CONST_INT,
  CONST_LARGE_INT,
  CONST_FLOAT,
  CONST_DECIMAL,
  CONST_STRING,
  CONST_SYMBOL,
  CONST_OOP,
  CONST_BINDING,
  CONST_DATA,
  CONST_URI,
  CONST_ARRAY,
  PSEUDO_TRUE,
  PSEUDO_FALSE,
  PSEUDO_NIL,
  PSEUDO_SELF,
  PSEUDO_SUPER,
  PSEUDO_CONTEXT
} const_type;

/* A parse-tree node holding a constant.  CONSTTYPE identifies which
   kind of constant is stored, the VAL union can include a long, a
   double, a string(char *), an OOP(typically a Symbol, Association
   or ScaledDecimal), an array(stored as a list_node) or a
   byte_object struct(for ByteArrays and LargeIntegers). */
typedef struct const_node
{
  const_type constType;
  union
  {
    long iVal;
    long double fVal;
    char *sVal;
    OOP oopVal;
    tree_node aVal;
  }
  val;
}
const_node;

/* A parse-tree node defining a method.  SELECTOREXPR is an expr_node
   with a nil receiver, holding the selector for the method and
   a list_node(of type TREE_VAR_DECL_LIST) for the arguments.  The
   method's temporaries and statements are also held in list_nodes
   (respectively, of course, TEMPORARIES and STATEMENTS). */
typedef struct method_node
{
  tree_node selectorExpr;
  tree_node temporaries;
  char *primitiveName;
  tree_node statements;
}
method_node;

/* A parse-tree node defining a block.  Not having a name, blocks
   hold arguments in a simple list_node as well. */
typedef struct block_node
{
  tree_node arguments;
  tree_node temporaries;
  tree_node statements;
}
block_node;


/* A generic parse-tree node has a field marking the kind of
   node(NODETYPE) and a union holding the five different
   kinds of node(list_nodes, expr_nodes, const_node,
   method_nodes and block_nodes).  */
struct tree_node
{
  node_type nodeType;
  union
  {
    list_node nvList;
    expr_node nvExpr;
    const_node nvConst;
    method_node nvMethod;
    block_node nvBlock;
  }
  nodeVal;
};

#define v_block         nodeVal.nvBlock
#define v_list          nodeVal.nvList
#define v_expr          nodeVal.nvExpr
#define v_const         nodeVal.nvConst
#define v_method        nodeVal.nvMethod


/* This is how nil is printed.  */
extern char *nil_name;


/* Create a method_node with the given fields(see description under
   struct method_node).  TEMPORARIES can possibly be NULL.  If the
   method has a primitive associated with it, then the PRIMITIVENAME
   is not NULL.  */
extern tree_node make_method(tree_node selectorExpr,
                             tree_node temporaries,
                             char *primitiveName,
                             tree_node statements);

/* Create a const_node for an object, OVAL, which is typically a
   ScaledDecimal.  */
extern tree_node make_oop_constant(OOP oval);

/* Create a TREE_SYMBOL_NODE describing an identifier(variable,
   unary/binary selector or symbol constant, it doesn't patter) pointed
   to by IDENT.  */
extern tree_node intern_ident(char *ident);

/* Free the objects on the compilation obstack.  */
extern void free_tree();

/* Print the NODE with LEVEL spaces of indentation.  */
extern void print_tree(tree_node node,
                       int level);


#endif /* TREE_H */