File indexing completed on 2024-04-14 04:31:15

 /* This file is part of KDevelop
  *
  * Copyright (C) 2010-2015 Miquel Sabaté Solà <mikisabate@gmail.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
 #ifndef NODE_H_
 #define NODE_H_
 
 
 #ifdef __cplusplus
 
 namespace ruby {
 extern "C" {
 #endif
 
 #include <parser/export.h>
 
 /**
  * This enumeration contains all the available tokens
  * used by this parser. This values are important for the
  * tests, so don't touch it unless you are really aware of
  * its side effects.
  */
 enum node_t {
     token_invalid = 0,
     token_comment = 1,      /* Not used anymore */
     token_plus,
     token_minus,
     token_mul,
     token_pow,
     token_div,
     token_mod,
     token_bit_and,
     token_bit_or,
     token_bit_xor,          /* 10 */
     token_kw_and,
     token_kw_or,
     token_kw_not,
     token_or,
     token_and,
     token_lshift,
     token_rshift,
     token_neg,
     token_not,
     token_unary_plus,       /* 20 */
     token_unary_minus,
     token_assign,
     token_op_assign,
     token_assoc,
     token_cmp,
     token_eq,
     token_neq,
     token_eqq,
     token_match,
     token_nmatch,           /* 30 */
     token_greater,
     token_geq,
     token_lesser,
     token_leq,
     token_dot2,
     token_dot3,
     token_ternary,
     token_if,
     token_unless,
     token_while,            /* 40 */
     token_until,
     token_case,
     token_when,
     token_up_begin,
     token_up_end,
     token_for,
     token_begin,
     token_rescue_arg,
     token_rescue,
     token_ensure,           /* 50 */
     token_object,
     token_numeric,
     token_symbol,
     token_body,
     token_function,
     token_module,
     token_class,
     token_singleton_class,
     token_super,
     token_string,           /* 60 */
     token_regexp,
     token_key,
     token_array,
     token_hash,
     token_block,
     token_method_call,
     token_heredoc,
     token_break,
     token_redo,
     token_retry,            /* 70 */
     token_next,
     token_return,
     token_yield,
     token_alias,
     token_defined,
     token_undef,
     token_array_value,
     token__end__,
     token_true,
     token_false,            /* 80 */
     token_nil,
     token_self,
     token_encoding,
     token_file,
     token_line,             /* 85 */
 };
 
 
 /**
  * This structure stores errors/warnings on the parsing.
  */
 struct error_t {
     char *msg;
     int line, column;
     unsigned char warning : 1;
     struct error_t *next;
 };
 
 /**
  * This is the AST generated by the parser. It contains the tree
  * and some stats that make things easier to the program that is
  * using this parser.
  */
 struct ast_t {
     struct Node *tree;
     struct error_t *errors;
     unsigned char unrecoverable : 1;
 };
 
 /**
  * This structure represents a position inside the document
  * that is being parsed.
  */
 struct pos_t {
     int start_line, end_line;
     int start_col, end_col;
     unsigned long long offset;
 };
 
 /**
  * These are the values that should go inside the flags
  * attribute of the node struct.
  */
 enum flags_t {
     /* Numeric literals. */
     int_l = 0,
     float_l,
     rational_l,
     imaginary_l,
 
     /* Variables */
     var,
     ivar,
     cvar,
     constant,
     global,
 
     /* Args */
     kwrest,
     star,
     label,
     opt,
     block,
 };
 
 /**
  * This structure defines a node
  * in the abstract syntax tree
  */
 struct Node {
 /* Node info */
     int kind;
     enum flags_t flags;
     char *name;
     void *context;
 
 /* Node's position */
     struct pos_t pos;
     char *comment;
 
 /* Left/Right childs */
     struct Node *l;
     struct Node *r;
 
 /* Condition expression */
     struct Node *cond;
 
 /* Ensure expression (Exception-AST only) */
     struct Node *ensure;
 
 /* List of inner statements */
     struct Node *next;
     struct Node *last;
 };
 
 /**
  * This is a convenient enum to store the version of Ruby to be used.
  */
 enum ruby_version {
     ruby18 = 0, /* 1.8.x branch */
     ruby19 = 1, /* 1.9.x branch */
     ruby20 = 2, /* 2.0.x branch */
     ruby21 = 3, /* 2.1.x branch */
 };
 
 /*
  * The different access specifiers available in Ruby.
  */
 enum access_t {
     public_a    = 0,
     protected_a = 1,
     private_a   = 2,
 };
 
 /**
  * This struct contains all the options that may be passed
  * to the parser.
  */
 struct options_t {
     const char *path;
     char *contents;
     enum ruby_version version;
 };
 
 /* Interface to the parser */
 
 /**
  * Generate the AST of a given ruby file.
  *
  * @param opts The options passed to the parser.
  * @return an AST that represents the code.
  */
 KDEVRUBYPARSER_EXPORT struct ast_t * rb_compile_file(struct options_t *opts);
 
 /**
  * Free an ast_t.
  *
  * @param ra the ast_t you want to free.
  */
 KDEVRUBYPARSER_EXPORT void rb_free(struct ast_t *ra);
 
 /**
  * Get the name node.
  *
  * @param n The root node.
  */
 KDEVRUBYPARSER_EXPORT struct Node * rb_name_node(struct Node *n);
 
 /**
  * Free the node of an ast_t. Note that this function is already called
  * by the rb_free function.
  *
  * @param n The root node.
  */
 void free_ast(struct Node *n);
 
 /**
  * Free the errors of an ast_t. Note that this function is already called
  * by the rb_free function.
  *
  * @param ra the ast_t containing the errors to be freed.
  */
 void free_errors(struct ast_t *ra);
 
 /*
  * There are three ways to allocate a node. The simplest one is
  * alloc_node. If the node has also a conditional expression, we
  * should use alloc_cond. Moreover, if the node has an ensure statement,
  * we should use alloc_ensure.
  */
 struct Node * alloc_node(int kind, struct Node *l, struct Node *r);
 struct Node * alloc_cond(int kind, struct Node *cond, struct Node *l,
                          struct Node *r);
 struct Node * alloc_ensure(int kind, struct Node * l, struct Node *r,
                            struct Node *els, struct Node *ensure);
 
 
 /*
  * These functions play with the next and last attributes of a node.
  * They're useful to create or update a list of nodes or to concatenate
  * two different lists,
  */
 struct Node * create_list(struct Node *head, struct Node *tail);
 struct Node * update_list(struct Node *head, struct Node *tail);
 struct Node * concat_list(struct Node *head, struct Node *tail);
 #define pop_list(head, tail) \
     (tail->last == NULL) ? update_list(head, tail) : create_list(head, tail)
 
 
 /* Debugging utilities */
 
 #ifdef BUILD_TESTS
 void print_node(struct Node *n);
 KDEVRUBYPARSER_EXPORT void print_errors(struct error_t *errors);
 #endif
 
 
 /*
  * Auxiliar macros.
  */
 
 #define get_last_expr(n) ((n->last) ? n->last : n)
 #define is_valid(n) (n->pos.start_line >= 0)
 #define is_rest_arg(n) (n->flags == kwrest)
 #define is_block_arg(n) (n->flags == block)
 #define is_global_var(n) (n->flags == global)
 #define is_ivar(n) (n->flags == ivar)
 #define is_cvar(n) (n->flags == cvar)
 #define is_constant (n->flags == constant)
 #define valid_children(n) (n->r && n->l)
 #define is_super(n) (!n->l)
 #define has_star(n) (n->flags == kwrest || n->flags == star)
 #define is_just_a_star(n) (n->flags == star)
 
 
 #ifdef __cplusplus
 }
 }
 #endif
 
 
 #endif /* NODE_H_ */