/* This file is part of NIT ( http://www.nitlanguage.org ).
 *
 * Copyright 2008 Jean Privat <jean@pryen.org>
 * Based on algorithms developped for ( http://www.sablecc.org/ ).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

$ template make_abs_nodes()
# Root of the AST hierarchy
abstract class PNode
end

# Ancestor of all tokens
abstract class Token
special PNode
end

# Ancestor of all productions
abstract class Prod
special PNode
end
$ end template

$ template make_nodes()
redef class PNode
	# Parent of the node in the AST
	readable writable var _parent: nullable PNode

	# Remove a child from the AST
	fun remove_child(child: PNode)
	do
		replace_child(child, null)
	end

	# Replace a child with an other node in the AST
	fun replace_child(old_child: PNode, new_child: nullable PNode) is abstract

	# Replace itself with an other node in the AST
	fun replace_with(node: PNode)
	do
		if (_parent != null) then
			_parent.replace_child(self, node)
		end
	end

	# Visit all nodes in order.
	# Thus, call "v.visit(e)" for each node e
	fun visit_all(v: Visitor) is abstract

	# Visit all nodes in reverse order.
	# Thus, call "v.visit(e)" for each node e starting from the last child
	fun visit_all_reverse(v: Visitor) is abstract

	# Give a human readable location of the node.
	fun locate: String is abstract

	# Return only the line number of the node
	fun line_number: Int is abstract

	# Debug method: output a message prefixed with the location.
	fun printl(str: String)
	do
		print("{locate}: {str}\n")
	end
end

redef class Token
	redef fun visit_all(v: Visitor) do end
	redef fun visit_all_reverse(v: Visitor) do end
	redef fun replace_child(old_child: PNode, new_child: nullable PNode) do end

	redef fun locate: String
	do
		return "{filename}:{line},{pos}"
	end

	redef fun line_number do return line
end

redef class Prod
	# The first token of the production node
	readable writable var _first_token: nullable Token

	# The last token of the production node
	readable writable var _last_token: nullable Token

	redef fun locate: String
	do
		if first_token == null then
			return "????"
		end
		if last_token == null then
			return "{first_token.locate}--????"
		end
		var lastpos = last_token.pos + last_token.text.length - 1
		if first_token.line == last_token.line then
			return "{first_token.locate}--{lastpos}"
		else
			return "{first_token.locate}--{last_token.line}:{lastpos}"
		end
	end

	redef fun replace_with(n: PNode)
        do
                super
                assert n isa Prod
                n.first_token = first_token
                n.last_token = last_token
        end

	redef fun line_number
	do
		if first_token != null then
			return first_token.line
		else
			return 0
		end
	end
end

# Abstract standard visitor
class Visitor
        # Ask the visitor to visit a given node.
        # Usually automatically called by visit_all* methods.
        # Concrete visitors should redefine this method.
        fun visit(e: nullable PNode) is abstract
end

$ end template