src/parser/xss/nodes.xss

   1 $ // This file is part of NIT ( http://www.nitlanguage.org ).
   2 $ //
   3 $ // Copyright 2008 Jean Privat <jean@pryen.org>
   4 $ // Based on algorithms developped for ( http://www.sablecc.org/ ).
   5 $ //
   6 $ // Licensed under the Apache License, Version 2.0 (the "License");
   7 $ // you may not use this file except in compliance with the License.
   8 $ // You may obtain a copy of the License at
   9 $ //
  10 $ //     http://www.apache.org/licenses/LICENSE-2.0
  11 $ //
  12 $ // Unless required by applicable law or agreed to in writing, software
  13 $ // distributed under the License is distributed on an "AS IS" BASIS,
  14 $ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 $ // See the License for the specific language governing permissions and
  16 $ // limitations under the License.
  17
  18 $ template make_abs_nodes()
  19 # Root of the AST hierarchy
  20 abstract class PNode
  21         readable var _location: nullable Location
  22 end
  23
  24 # Ancestor of all tokens
  25 abstract class Token
  26 special PNode
  27 end
  28
  29 # Ancestor of all productions
  30 abstract class Prod
  31 special PNode
  32         fun location=(loc: nullable Location) do _location = loc
  33 end
  34 $ end template
  35
  36 $ template make_nodes()
  37 redef class PNode
  38         # Parent of the node in the AST
  39         readable writable var _parent: nullable PNode
  40
  41         # Remove a child from the AST
  42         fun remove_child(child: PNode)
  43         do
  44                 replace_child(child, null)
  45         end
  46
  47         # Replace a child with an other node in the AST
  48         fun replace_child(old_child: PNode, new_child: nullable PNode) is abstract
  49
  50         # Replace itself with an other node in the AST
  51         fun replace_with(node: PNode)
  52         do
  53                 if (_parent != null) then
  54                         _parent.replace_child(self, node)
  55                 end
  56         end
  57
  58         # Visit all nodes in order.
  59         # Thus, call "v.visit(e)" for each node e
  60         fun visit_all(v: Visitor) is abstract
  61
  62         # Visit all nodes in reverse order.
  63         # Thus, call "v.visit(e)" for each node e starting from the last child
  64         fun visit_all_reverse(v: Visitor) is abstract
  65 end
  66
  67 redef class Token
  68         redef fun visit_all(v: Visitor) do end
  69         redef fun visit_all_reverse(v: Visitor) do end
  70         redef fun replace_child(old_child: PNode, new_child: nullable PNode) do end
  71 end
  72
  73 redef class Prod
  74         redef fun replace_with(n: PNode)
  75         do
  76                 super
  77                 assert n isa Prod
  78                 n.location = location
  79         end
  80 end
  81
  82 # Abstract standard visitor
  83 class Visitor
  84         # What the visitor do when a node is visited
  85         # Concrete visitors should redefine this method.
  86         protected fun visit(e: nullable PNode) is abstract
  87
  88         # Ask the visitor to visit a given node.
  89         # Usually automatically called by visit_all* methods.
  90         # This methos should not be redefined
  91         fun enter_visit(e: nullable PNode)
  92         do
  93                 var old = _current_node
  94                 _current_node = e
  95                 visit(e)
  96                 _current_node = old
  97         end
  98
  99         # The current visited node
 100         readable var _current_node: nullable PNode = null
 101 end
 102
 103 $ end template