libvaladoc/parser/rule.vala

   1 /* rule.vala
   2  *
   3  * Copyright (C) 2008-2009 Florian Brosch, Didier Villevalois
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Didier 'Ptitjes Villevalois <ptitjes@free.fr>
  21  */
  22
  23
  24 public abstract class Valadoc.Rule : Object {
  25
  26         public static Rule seq (Object[] scheme) {
  27                 return new SequenceRule (scheme);
  28         }
  29
  30         public static Rule one_of (Object[] scheme) {
  31                 return new OneOfRule (scheme);
  32         }
  33
  34         public static Rule many (Object[] scheme) {
  35                 if (scheme.length == 1) {
  36                         return new ManyRule (scheme[0]);
  37                 } else {
  38                         return new ManyRule (new SequenceRule (scheme));
  39                 }
  40         }
  41
  42         public static Rule option (Object[] scheme) {
  43                 if (scheme.length == 1) {
  44                         return new OptionalRule (scheme[0]);
  45                 } else {
  46                         return new OptionalRule (new SequenceRule (scheme));
  47                 }
  48         }
  49
  50         protected Rule () {
  51         }
  52
  53         private string? _name = null;
  54         private Action _start_action;
  55         private Action _reduce_action;
  56         private Action _skip_action;
  57
  58         public string name { get { return _name; } }
  59
  60         public Rule set_name (string name) {
  61                 _name = name;
  62                 return this;
  63         }
  64
  65         public delegate void Action () throws ParserError;
  66
  67         public Rule set_start (Action action) {
  68                 //TODO: Ownership Transfer
  69                 _start_action = () => { action (); };
  70                 return this;
  71         }
  72
  73         public Rule set_reduce (Action action) {
  74                 //TODO: Ownership Transfer
  75                 _reduce_action = () => { action (); };
  76                 return this;
  77         }
  78
  79         public Rule set_skip (Action action) {
  80                 //TODO: Ownership Transfer
  81                 _skip_action = () => { action (); };
  82                 return this;
  83         }
  84
  85         public enum Forward {
  86                 NONE,
  87                 PARENT,
  88                 CHILD
  89         }
  90
  91         public abstract bool is_optional ();
  92         public abstract bool starts_with_token (Token token);
  93         public abstract bool accept_token (Token token, ParserCallback parser, Rule.Forward forward) throws ParserError;
  94         public abstract bool would_accept_token (Token token, Object? state);
  95         public abstract bool would_reduce (Token token, Object? state);
  96
  97         public abstract string to_string (Object? state);
  98
  99         protected bool is_optional_rule (Object? scheme_element) {
 100                 Rule? scheme_rule = scheme_element as Rule;
 101                 if (scheme_rule != null) {
 102                         return scheme_rule.is_optional ();
 103                 }
 104                 return false;
 105         }
 106
 107         protected bool has_start_token (Object? scheme_element, Token token) {
 108                 TokenType? scheme_token_type = scheme_element as TokenType;
 109                 if (scheme_token_type != null) {
 110                         return scheme_token_type.matches (token);
 111                 }
 112                 Rule? scheme_rule = scheme_element as Rule;
 113                 if (scheme_rule != null) {
 114                         return scheme_rule.starts_with_token (token);
 115                 }
 116                 return false;
 117         }
 118
 119         protected bool try_to_apply (Object? scheme_element, Token token, ParserCallback parser,
 120                                                                  out bool handled) throws ParserError
 121         {
 122                 #if VERY_HARD_DEBUG
 123                         {
 124                                 TokenType? scheme_token = scheme_element as TokenType;
 125                                 Rule? scheme_rule = scheme_element as Rule;
 126                                 if (scheme_token != null) {
 127                                         message ("TryToApply: token='%s'; scheme_token='%s'", token.to_string (),
 128                                                 scheme_token.to_string ());
 129                                 } else if (scheme_rule != null) {
 130                                         message ("TryToApply: token='%s'; scheme_rule='%s'", token.to_string (),
 131                                                 scheme_rule.to_string (parser.get_rule_state ()));
 132                                 } else {
 133                                         assert (scheme_element != null);
 134                                 }
 135                         }
 136                 #endif
 137                 TokenType? scheme_token_type = scheme_element as TokenType;
 138                 if (scheme_token_type != null && scheme_token_type.matches (token)) {
 139                         scheme_token_type.do_action (token);
 140                         handled = true;
 141                         return true;
 142                 }
 143                 Rule? scheme_rule = scheme_element as Rule;
 144                 if (scheme_rule != null && scheme_rule.starts_with_token (token)) {
 145                         parser.push_rule (scheme_rule);
 146                         handled = false;
 147                         return true;
 148                 }
 149
 150                 handled = false;
 151                 return false;
 152         }
 153
 154         protected void do_start (ParserCallback parser) throws ParserError {
 155                 if (_start_action != null) {
 156                         _start_action ();
 157                 }
 158         }
 159
 160         protected void do_reduce (ParserCallback parser) throws ParserError {
 161                 if (_reduce_action != null) {
 162                         _reduce_action ();
 163                 }
 164                 parser.reduce ();
 165         }
 166
 167         protected void do_skip (ParserCallback parser) throws ParserError {
 168                 if (_skip_action != null) {
 169                         _skip_action ();
 170                 }
 171         }
 172 }