EFL 1.0

data/lib/EFL_array.rb

@@ -0,0 +1,20 @@
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL 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 Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+
+class Array #:nodoc: all
+	
+	def oneOnRest
+		0.upto(length-2) {|i|
+			(i+1).upto(length-1) {|j|
+				return true if yield(at(i), at(j))				
+			} #j
+		} #i
+		return false
+	end #oneOnRest
+	
+end #Array

data/lib/EFL_errors.rb

@@ -0,0 +1,48 @@
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL 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 Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+
+module Error #:nodoc: all
+	
+		def Error.arg_class(*args)
+			code = ""
+			args.each {|a|
+				code += "
+				if !#{a.at(0)}.kind_of?(#{a.at(1)}) && #{a.at(0)}
+					raise 'argument number #{args.index(a) + 1} ' +
+					'should be of class #{a.at(1)}'			        
+				end"
+			}
+			return code
+		end #Error.arg_class
+		
+		def Error.without_declaration(element)
+		# Un elemento de una lista (pasada como parametro) no existe en la tabla hash correspondiente
+			<<-CODE
+			#{element}_list.each {|e|
+				if !@#{element}_hash.include?(e)
+					raise "\#\{e\} needs a prior declaration"
+				end
+			}
+			CODE
+		end #Error.without_declaration
+		
+		def Error.collision(receiver)
+			c = {
+				'prod' => [['i_file', 'o_file', 'sub_list'], 'Substitution'],
+				'gen' => [['prod_list'], 'Production'],
+				'add' => [['generator'], 'Generator'],
+				'sup' => [['generator'], 'Generator']				
+			}
+			<<-CODE
+				if !#{receiver}?(#{c[receiver].at(0).join(', ')})
+					raise "Collision between #{c[receiver].at(1)}s"
+				end
+			CODE
+		end #Error.collision
+		
+	end #Error

data/lib/EFL_hash.rb

@@ -0,0 +1,18 @@
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL 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 Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+
+class Hash #:nodoc: all
+	def my_collect
+		result = {}
+		each {|key, value|
+			new_key, new_value = yield(key, value.dup)
+			result[new_key] = new_value
+		}
+		return result
+	end
+end #Hash

data/lib/EFL_production.rb

@@ -0,0 +1,49 @@
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL 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 Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+
+class Production #:nodoc: all
+	attr_accessor :i_file, :o_file, :sub_list
+	def initialize(i_file, o_file, sub_list)
+		@i_file = i_file
+		@o_file = o_file
+		@sub_list = sub_list
+	end
+
+	def dup
+		return Production.new(@i_file.dup, @o_file.dup, @sub_list.dup)
+	end
+	
+	def crash?(sub_hash, production = nil)
+		return crashSelf?(sub_hash) unless production
+		if @o_file != production.o_file
+			return false
+		else
+			if @i_file != production.i_file
+				return true
+			else
+				return Production.new(@i_file, @o_file, 
+								(@sub_list + production.sub_list)).crashSelf?(sub_hash)
+			end #if
+		end #if		
+	end #crash?
+	
+	#####################################################
+	# <crash? auxiliar method>
+	#####################################################
+
+	def crashSelf?(sub_hash)
+		@sub_list.oneOnRest {|s1, s2|
+			sub_hash[s1].crash?(sub_hash[s2], @i_file)
+		}
+	end #crashSelf?
+
+	#####################################################
+	# </crash? auxiliar method>
+	#####################################################
+
+end #Production

data/lib/EFL_regexp.rb

@@ -0,0 +1,112 @@
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL 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 Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+#
+# = Extensions of the Ruby regular expressions
+#
+# The next operators are included:
+# * zoom Regexp#>
+# * complement Regexp#o
+# * minus Regexp#-
+
+class Regexp
+
+	attr_accessor :zoom_list #:nodoc:
+	attr_accessor :minus_list #:nodoc:
+	attr_accessor :complemented #:nodoc:
+	
+	
+	# Using the "zoom operator", regular expressions can be chained to specify progressively a text pattern.
+	#
+  # For example:
+	# <tt>regular_expression_1 > regular_expression_2 > regular_expression_3 > ... regular_expression_N</tt>
+	#
+  # runs the <tt>regular_expression_2</tt> over the selection made by the <tt>regular_expression_1</tt>, 
+	#
+	# the <tt>regular_expression_3</tt> over the selection made by the <tt>regular_expression_2</tt>, etcetera
+	
+	def > (zoom_regular_expression)		
+  	op2 = zoom_regular_expression.dup		
+  	if !op2.zoom_list then
+			op2.zoom_list = [op2]
+		end
+		
+		op1 = self.dup
+  	if op1.minus_list && (op1.minus_list !=[]) then #due '-' has major precedence than '>', this error is detected here
+  		raise "erroooor minus"
+  	end
+		if op1.zoom_list
+			op1.zoom_list = op1.zoom_list + op2.zoom_list
+		else 
+			op1.zoom_list = [op1] + op2.zoom_list
+		end
+    
+  	op1.minus_list = [] unless op1.minus_list
+  	op1.zoom_list.each {|e|
+  		op1.minus_list = op1.minus_list + e.minus_list unless !e.minus_list 
+  	}
+  	return op1
+	end # >
+	
+	
+	# Using the "minus operator", regular expressions can be refined by deleting specific patterns.
+	# For example, let suppose we have the text: <tt>text_1, text_2, text_3, text_4</tt>.
+	#
+	# The matching of the regular expression <tt>/text_[0-9]/</tt> is <tt>['text_1', 'text_2', 'text_3', 'text_4']</tt>.
+	#
+	# Applying the <tt>-</tt> operator: <tt>/text_[0-9]/ - /text_1/ - /text_3/</tt>, the matching will be refined to <tt>['text_2', 'text_4']</tt>.
+	#
+	# Note that:
+	# * <tt>re1 - re2</tt> deletes the <tt>re2</tt> matchings in the context of <tt>re1</tt>.
+	#   That is, <tt>re_1 > re_2 > ... > re_n - re_minus</tt> it would be equivalent to
+	#   <tt>re_1 > re_2 > ... > re_n - (re_1 > re_2 > ... > re_n > re_minus)</tt>
+	# * To avoid inconsistent expressions, on the right side of the <tt>-</tt> operator is not permitted the use of the <tt>></tt> operator.
+	
+  def - (minus_regular_expression)				
+    op2 = minus_regular_expression.dup		
+    if !op2.minus_list then
+      op2.minus_list = [op2]
+    end
+		
+    op1 = self.dup
+    if op1.minus_list
+      op1.minus_list = op1.minus_list + op2.minus_list
+    else 
+      op1.minus_list = op2.minus_list
+    end
+    return op1
+  end # -
+  
+	
+	# Complements a regular expression.
+	# For example:
+	# <tt>regular_expression_1.o > regular_expression_2</tt>
+	# matchs <tt>regular_expression_2</tt> outside the text matched by <tt>regular_expression_1</tt> 
+  	#
+	# Note that:
+	# * <tt>regular_expresion.o.o = regular_expresion</tt>
+	# * <tt>(regular_expression_1 > regular_expression_2 > ... > regular_expression_N).o = regular_expression_1 > regular_expression_2 > ... > regular_expresion_N.o</tt>	
+	
+	def o
+		result = self.dup
+		if result.zoom_list then
+			if not result.zoom_list.last.complemented then
+				result.zoom_list.last.complemented = true
+			else
+				result.zoom_list.last.complemented = false
+			end
+		else
+			if not result.complemented then
+				result.complemented = true
+			else
+				result.complemented = false
+			end
+		end
+		return result	
+	end # o
+	
+end # Regexp

data/lib/EFL_regexp_generator.rb

@@ -0,0 +1,70 @@
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL 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 Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+#
+# = Regular expression generators and facilities
+
+#Returns a Regular Expression who matches nested symbols. 
+#By default, 10 is the maximum possible nested levels.
+#
+#Example: 
+#	y = '( 1 + (3 + 9 - (45 + 9) ) ) (89(14))'
+#        y =~ nestedSymbols( '(' , ')' )
+#	puts $& 
+#       	------------>
+#			 1 + (3 + 9 - (45 + 9) ) 
+def nested_symbols(beginSymbol, endSymbol, levels=10)
+	eval('@level0 = "[' + beginSymbol + ']([^' + beginSymbol + endSymbol + '])*[' + endSymbol + ']"')
+	(1..(levels-2)).reject {|i|
+		eval("@level#{i}" + '= "[' + beginSymbol + ']([^' + beginSymbol + endSymbol +'] | #{@level' + "#{i-1}" + '} )*[' + endSymbol + ']"')
+	}
+	if levels > 1 then
+    eval("@level#{levels-1}" + '= /[' + beginSymbol + ']([^' + beginSymbol + endSymbol +'] | #{@level' + "#{levels-2}" + '} )*[' + endSymbol + ']/mx')
+	  eval "return @level#{levels-1}"
+  else 
+	  eval "return /#{@level0}/mx"    
+  end
+end #nested_symbols
+
+#Returns a Regular Expression who matches nested symbols. 
+#By default, 10 is the maximum possible nested levels.
+#
+#Example: 
+#	puts nested_symbol('=', 2)
+#       	------------>
+#			(?mx-i:[=]([^=] | [=]([^=])*[=] )*[=])
+def nested_symbol(symbol, levels=10)
+	eval('@level0 = "[' + symbol + ']([^' + symbol + '])*[' + symbol + ']"')
+	(1..(levels-2)).reject {|i|
+		eval("@level#{i}" + '= "[' + symbol + ']([^' + symbol +'] | #{@level' + "#{i-1}" + '} )*[' + symbol + ']"')
+	}
+	if levels > 1 then
+    eval("@level#{levels-1}" + '= /[' + symbol + ']([^' + symbol +'] | #{@level' + "#{levels-2}" + '} )*[' + symbol + ']/mx')
+	  eval "return @level#{levels-1}"
+  else 
+	  eval "return /#{@level0}/mx"    
+  end
+end #nested_symbol
+
+def regexp2string(reg_exp)
+  reg_exp.to_s =~ /:(.*?)[)]$/mx
+  return $1
+end
+
+#Returns a Regular Expression who matches nested quotes ("..."..."..."). 
+#By default, 10 is the maximum possible nested levels.
+def nested_quotes(levels=10)
+  nq_regexp = nested_symbol('\"', levels)
+  nq_string = regexp2string(nq_regexp).gsub(/\\/, '')
+  return /#{nq_string}/mx
+end
+
+def inside_nested_symbols(beginSymbol, endSymbol, levels=50)
+	quit_begin_and_end_symbols = /[^#{beginSymbol}].*(?=#{endSymbol})/xm
+	return (nested_symbols(beginSymbol, endSymbol, levels) > quit_begin_and_end_symbols)
+end #nestedSymbols
+

data/lib/EFL_substitution.rb

@@ -0,0 +1,221 @@
+# <em>Copyright � 2007 by Ruben Heradio Gil, Jose Antonio Cerrada Somolinos, Jose Ramon Coz Fernandez and Jose Carlos Lopez Ruiz.</em>
+# <em>This file is part of <b>EFL-A Ruby implementation of the Exemplar Flexibilization Language.</b></em>
+# <em>EFL is distributed under the terms of the GNU Lesser General Public License (LGPL).</em>
+# <em>EFL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.</em>
+# <em>EFL 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 Lesser General Public License for more details.</em>
+# <em>You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.</em>
+# <em>Contact Information: Ruben Heradio Gil (rheradio@issi.uned.es). Phone number: 00 34 91 398 8242, Postal address: Dpto. de Ingenier�a de SW y Sistemas Inform�ticos. E.T.S.I. Inform�tica, UNED. C/ Juan del Rosal, 16. 28040 Madrid.</em>
+
+class Substitution #:nodoc: all
+attr_accessor :reg_exp, :text, :scope, :match_hash
+
+def initialize(reg_exp, text, scope)
+	@reg_exp = reg_exp
+	@text = text
+	@scope = scope
+	@match_hash = {}
+end
+
+#####################################################
+# <matching>
+#####################################################
+
+	#####################################################
+	# <complemented regular expressions matching>
+	#####################################################
+
+	def local_o(str, array)
+		if array == [] then
+			return [ [0, str.length-1] ]
+		else
+			if array[0][0] == 0 then
+				array_complemented = []
+			else
+				array_complemented = [ [0, array[0][0]-1] ]
+			end
+			array_complemented << [array[0][1]+1, str.length-1]
+			return array_complemented	
+		end
+	end
+
+	def global_o(str, array)
+		if array == [] then
+			return [ [0, str.length-1] ]
+		else
+			if array[0][0] == 0 then
+				array_complemented = []
+			else
+				array_complemented = [ [0, array[0][0]-1] ]
+			end
+			i = -1
+			for i in 0..array.length-2
+				array_complemented << [array[i][1]+1, array[i+1][0]-1]
+			end
+			array_complemented << [array[i+1][1]+1, str.length-1]
+			return array_complemented
+		end
+	end
+	
+	#####################################################
+	# </complemented regular expressions matching>
+	#####################################################
+	
+def match_pos(str, reg_exp, scope)
+	pos =[]			
+	aux_str = str.dup
+	while aux_str != nil
+		m = reg_exp.match(aux_str)
+		if m
+			range = m.offset(0)
+			range[1] = range[1] - 1
+			pos << range.dup
+			if pos.length > 1
+				pos[pos.length - 1][0] = pos[pos.length-2][1] + 
+					pos[pos.length - 1][0] + 1
+				pos[pos.length - 1][1] = pos[pos.length-2][1] + 
+					pos[pos.length - 1][1] + 1
+			end
+			aux_str = aux_str[range[1] + 1, aux_str.length-1]
+		else
+			aux_str = nil
+		end
+	end
+	if reg_exp.complemented then
+		if /local/ =~ scope then
+			pos = local_o(str, pos)	
+		else #/global/ =~ scope
+			pos = global_o(str, pos)	
+		end
+	else
+		return pos
+	end
+end #match_pos
+
+def format_array(array)
+	a1 = array.dup
+	a1.flatten!
+	i = 0
+	a2 = []
+	while i<a1.length
+		a2 << [a1[i], a1[i+1]]
+		i += 2
+	end
+	return a2
+end
+
+def get_match_pos(str, reg_exp, scope)
+	
+      ############################
+      # zoom matching
+      ############################      
+      reg_exp.zoom_list = [reg_exp.dup] unless reg_exp.zoom_list 	
+	pos1 = match_pos(str, reg_exp.zoom_list[0], scope)
+	pos2, pos3 = [], []
+	i = 1
+	while i<reg_exp.zoom_list.length
+		j = 0
+		pos1.each {|aux|
+			pos2 = match_pos(str[aux[0], aux[1]-aux[0]+1], reg_exp.zoom_list[i], scope)
+			pos2.map! {|e|
+				e[0] = e[0] + pos1[j][0] 
+				e[1] = e[1] + pos1[j][0]
+				e
+			}
+			pos3 << pos2.dup
+			j += 1	
+		}
+		pos1 = format_array(pos3)
+		pos3 = []
+		i += 1
+	end #while
+      
+      ############################
+      # minus matching
+      ############################           
+      if reg_exp.minus_list then
+        pos2, pos3 = [], []
+        i = 0
+        while i<reg_exp.minus_list.length
+          j = 0
+          pos1.each {|aux|
+            pos2 = match_pos(str[aux[0], aux[1]-aux[0]+1], reg_exp.minus_list[i], scope)
+            pos2.map! {|e|
+              e[0] = e[0] + pos1[j][0] 
+              e[1] = e[1] + pos1[j][0]
+              e
+            }
+            pos3 << pos2.dup
+            j += 1	
+          }
+          i += 1
+        end #while
+        pos3 = format_array(pos3)
+        return pos1 - pos3  
+       else
+        return pos1
+      end
+end
+	
+#####################################################
+# </matching>
+#####################################################
+
+def crash?(substitution, i_file)
+
+	i_string = ''
+	File.open(i_file) { |f| i_string = f.read }
+	
+	self.match_hash[i_file] = get_match_pos(i_string, self.reg_exp, self.scope) unless self.match_hash[i_file]
+				
+	substitution.match_hash[i_file] = get_match_pos(i_string, substitution.reg_exp, substitution.scope) unless substitution.match_hash[i_file]
+
+	crash = false
+							
+	if (/before/  =~ self.scope) or  (/after/  =~ self.scope) or 
+		(/before/  =~ substitution.scope) or  (/after/  =~ substitution.scope)
+		return false
+	
+	elsif (/local/ =~ self.scope) and (/local/ =~ substitution.scope)
+		crash = crash_one_on_one?(self, 0, substitution, 0, i_file)
+	
+	elsif (/local/ =~ self.scope) and (/global/ =~ substitution.scope)
+		index_2 = 0
+		while !crash and index_2 < substitution.match_hash[i_file].length - 1 do
+			crash = crash_one_on_one?(self, 0, substitution, index_2, i_file)
+			index_2 += 1
+		end
+	
+	elsif (/global/ =~ self.scope) and (/local/ =~ substitution.scope)
+		index_1 = 0
+		while !crash and index_1 < self.match_hash[i_file].length - 1 do
+			crash = crash_one_on_one?(self, index_1, substitution, 0, i_file)
+			index_1 += 1
+		end
+	
+	else #if (/global/ =~ self.scope) and (/global/ =~ substitution.scope)
+		index_1 = 0
+		while !crash and index_1 < self.match_hash[i_file].length - 1 do
+			index_2 = 0
+			while !crash and index_2 < substitution.match_hash[i_file].length - 1 do
+				crash = crash_one_on_one?(self, index_1, substitution, index_2, i_file)
+				index_2 += 1
+			end
+			index_1 += 1
+		end
+	end #if
+
+	return crash
+
+end #crash?
+		
+def crash_one_on_one?(substitution1, index_1, substitution2, index_2, i_file)
+	return false if (substitution1.match_hash[i_file] == nil) or (substitution2.match_hash[i_file] ==nil)
+	if substitution1.match_hash[i_file][index_1][0] <= substitution2.match_hash[i_file][index_2][0] 
+		return true if substitution1.match_hash[i_file][index_1][1] >= substitution2.match_hash[i_file][index_2][0]
+	else
+		return true if substitution2.match_hash[i_file][index_2][1] >= substitution1.match_hash[i_file][index_1][0]
+	end #if
+	return false
+end #crash_one_on_one?
+	
+end #Substitution