dsktool 0.2.1 → 0.4.1

data/lib/NADOLDisk.rb

@@ -9,25 +9,186 @@ $:.unshift(File.dirname(__FILE__)) unless
 # 0C-0D - filesize (low byte first)
 # 0E - track of track sector list sector
 # 0F - sector of track sector list sector
-
+#
 #TRACK/SECTOR LIST FORMAT 
 # pairs of track/sectors in order. up to 128 entries [assumes that no file can be > 128 sectors]
+#
+#SECTOR USAGE BITMAP
+#is at Track $00, Sector $2, from bytes $20 .. $65
+#bitmap is of form:
+#
+# ----hi bit--
+# |             |
+# 01234567 89ABCDEF
+#  ^^^^^^      ^^^^^^^
+#   low byte    hi byte
 
 require 'NADOLFile'
 
 class NADOLDisk < DSK
 
-	def dump_catalog
-		files.each_value { |file|		
-			puts "#{sprintf('% 6d',file.contents.length)} #{file.filename}"
-		}
+	def dump_catalog
+		s=""
+		files.keys.sort.each { |file_name|		
+			file=files[file_name]	
+			s<< "#{sprintf('% 6d',file.contents.length)} #{file.filename}\n"
+		}
+		s
 	end
 
-	def initialize(file_bytes)
-		super(file_bytes)
+	def initialize(file_bytes,sector_order)
+		super(file_bytes,sector_order)
 		self.read_catalog
+	end
+
+	def file_system
+		:nadol
 	end
-	
+
+
+def set_sector(track,sector,contents)
+  super(track,sector,contents)  
+  
+  #now mark sector as used in sector usage list
+  #don't bother marking the 'system' sectors used
+  if ((track>0) || (sector>9)) then
+    sector_usage_bitmap_sector=get_sector(0,2)  
+    offset_of_byte_containing_this_sector=0x20+(track*2)+(sector/8)
+    byte_containing_this_sector=sector_usage_bitmap_sector[offset_of_byte_containing_this_sector]
+    byte_containing_this_sector=byte_containing_this_sector|(2**(7-(sector%8)))
+    sector_usage_bitmap_sector[offset_of_byte_containing_this_sector]=byte_containing_this_sector
+    set_sector(0,2,sector_usage_bitmap_sector)
+  end
+end
+
+
+#iterate through the CATALOG to find either the named file or (if nil is passed in) an empty slot
+def find_catalog_slot(filename)
+  track=0
+  sector=3
+  catalog_filename=NADOLFile.catalog_filename(filename.upcase) unless filename.nil?
+  while (sector<=9) do
+    sector_data=get_sector(track,sector)
+    (0..15).each do |slot_no|
+      slot_start=slot_no*0x10
+      if (filename.nil? && (sector_data[slot_start]==0x00)|| (sector_data[slot_start]==0xFF)) then
+        return DSKTrackSector.new(track,sector,slot_start)
+      end
+      if (!filename.nil?) && (sector_data[slot_start..slot_start+0x0B]==catalog_filename) then
+        return DSKTrackSector.new(track,sector,slot_start)
+      end
+    end
+    sector+=1
+  end
+  nil
+end
+
+#iterate through the sector usage bitmap, return a list of [track,sector] for sectors marked available
+def free_sector_list  
+  sector_usage_bitmap=get_sector(0,2)[0x20..0x65]
+   free_sectors=[]
+    (0..(sector_usage_bitmap.length/2)-1).each do |track|
+      track_bitmap_lo=sector_usage_bitmap[track*2]
+      track_bitmap_hi=sector_usage_bitmap[1+track*2]
+      (0..7).each do |sector|
+        if ((track_bitmap_lo & (2**(7-sector)))==0) then
+          free_sectors<<DSKTrackSector.new(track,sector)
+        end
+        if ((track_bitmap_hi & (2**(7-sector)))==0) then
+          free_sectors<<DSKTrackSector.new(track,sector+8)
+        end        
+      end
+    end
+    free_sectors.sort  
+end
+
+def make_file(filename,contents,file_options={})
+  if (file_options[:tokenise]) then
+    return NADOLTokenisedFile.new(filename,NADOLTokenisedFile.tokenise(contents))  
+  else
+    return NADOLFile.new(filename,contents)
+  end
+end
+
+  def delete_file(filename)
+    this_files_catalog_slot=find_catalog_slot(filename)    
+    #if file not in catalog, do nothing
+    return if this_files_catalog_slot.nil? 
+    file_descriptive_entry=get_sector(this_files_catalog_slot.track_no,this_files_catalog_slot.sector_no)[this_files_catalog_slot.offset..this_files_catalog_slot.offset+0x0f]
+    
+    #mark sector as free in sector usage list
+    sector_usage_bitmap_sector=get_sector(0,2)  
+    sectors_to_mark_available=get_track_sector_list(file_descriptive_entry[0x0E],file_descriptive_entry[0x0F])
+    sectors_to_mark_available<<DSKTrackSector.new(file_descriptive_entry[0x0E],file_descriptive_entry[0x0F])
+    sectors_to_mark_available.each do |ts|
+      offset_of_byte_containing_this_sector=0x20+(ts.track_no*2)+(ts.sector_no/8)
+      byte_containing_this_sector=sector_usage_bitmap_sector[offset_of_byte_containing_this_sector]
+      byte_containing_this_sector=byte_containing_this_sector&(0xff-(2**(7-(ts.sector_no%8))))
+      sector_usage_bitmap_sector[offset_of_byte_containing_this_sector]=byte_containing_this_sector
+    end
+    set_sector(0,2,sector_usage_bitmap_sector)
+    
+    #mark slot as available in catalog
+    catalog_sector=get_sector(this_files_catalog_slot.track_no,this_files_catalog_slot.sector_no)
+    catalog_sector[this_files_catalog_slot.offset]=0xFF
+    set_sector(this_files_catalog_slot.track_no,this_files_catalog_slot.sector_no,catalog_sector)
+  end
+  
+  
+  #given a track and sector, treat it as a track/sector list and return an array containing track/sector pairs
+  def get_track_sector_list(ts_list_track_no,ts_list_sector_no)
+    ts_list_sector=get_sector(ts_list_track_no,ts_list_sector_no)
+    ts_list=[]
+    for entry_number in 0..0x7f    
+      data_track_no=ts_list_sector[entry_number*2]
+      data_sector_no=ts_list_sector[entry_number*2+1]
+      if( (data_track_no!=0 || data_sector_no!=0)  && data_track_no<track_count && data_sector_no<=0x0f) then
+        ts_list<<DSKTrackSector.new(data_track_no,data_sector_no)
+      end
+    end
+    ts_list
+  end
+  
+#add a file to the in-memory image of this DSK 
+ def add_file(file)
+   raise "only NADOLFiles may be added to NADOL format disks!" unless file.kind_of?(NADOLFile)
+   
+  delete_file(file.filename) unless files[file.filename].nil?
+  catalog_slot=find_catalog_slot(nil)
+  raise "CATALOG IS FULL!" if catalog_slot.nil?
+  
+  free_sectors=free_sector_list
+    
+  sectors_needed=1+file.length_in_sectors
+  raise "not enough free space - #{sectors_needed} sectors needed, #{free_sector_list.length} available " unless sectors_needed<=free_sectors.length
+  
+  #for each sector in the file, copy it to disk and then record it in the track/sector list
+  track_sector_list="\0"*256
+  track_sector_list_sector=free_sectors[0]
+  (0..sectors_needed-2).each do |sector_in_file|
+    sector_to_use=free_sectors[sector_in_file+1]
+    track_sector_list[sector_in_file*2]=sector_to_use.track_no
+    track_sector_list[(sector_in_file*2)+1]=sector_to_use.sector_no
+    sector_contents=file.contents[(sector_in_file*256)..(sector_in_file*256)+255] || ""
+    set_sector(sector_to_use.track_no,sector_to_use.sector_no,sector_contents)
+  end
+  #write the track/sector list
+  set_sector(track_sector_list_sector.track_no,track_sector_list_sector.sector_no,track_sector_list)
+  
+  #update the catalog
+  catalog_sector=get_sector(catalog_slot.track_no,catalog_slot.sector_no)
+  catalog_sector[catalog_slot.offset..catalog_slot.offset+0x0B]=file.catalog_filename
+  catalog_sector[catalog_slot.offset+0x0C]=file.contents.length % 0x100
+  catalog_sector[catalog_slot.offset+0x0D]=file.contents.length / 0x100
+  catalog_sector[catalog_slot.offset+0x0E]=track_sector_list_sector.track_no
+  catalog_sector[catalog_slot.offset+0x0F]=track_sector_list_sector.sector_no
+  set_sector(catalog_slot.track_no,catalog_slot.sector_no,catalog_sector)
+  
+  raise "catalog not updated correctly!" if find_catalog_slot(file.filename).nil?
+  #reread the catalog to populate the files list
+  read_catalog
+ end
+ 
 	#reads the catalog, and populate the "files" array with files
 	#CATALOG will be at track $00, sector $03 to track $00, sector $09
 	#each entry consists of $10 bytes, which are:
@@ -36,40 +197,36 @@ class NADOLDisk < DSK
 	# 0E - track of track sector list sector
 	# 0F - sector of track sector list sector
 	def read_catalog
-		0x300.step(0x9FF,0x10) do |file_descriptive_entry_start|
-			file_descriptive_entry=@file_bytes[file_descriptive_entry_start..file_descriptive_entry_start+0x0F]
-			break if (file_descriptive_entry[0]==0xFF) # skip deleted files
-			filename=""
-			file_descriptive_entry[0..11].to_s.each_byte{|b| filename+=(b.%128).chr} #strip off high bit
-			filename.sub!(/ *$/,"") #strip off trailing spaces
-			full_sectors=file_descriptive_entry[0x0D]
-			bytes_in_last_sector=file_descriptive_entry[0x0C]
-			file_size=full_sectors*256+bytes_in_last_sector
-			if (file_size>0) then
-				contents=""					
-				ts_list_track_no=file_descriptive_entry[0x0E]
-				ts_list_sector_no=file_descriptive_entry[0x0F]
-				ts_list=get_sector(ts_list_track_no,ts_list_sector_no)
-				entry_number=0
-				while entry_number<full_sectors do						
-					data_track_no=ts_list[entry_number*2]
-					data_sector_no=ts_list[entry_number*2+1]
-					contents+=get_sector(data_track_no,data_sector_no)
-					entry_number+=1
-				end
-				if (bytes_in_last_sector>0) then
-					data_track_no=ts_list[entry_number*2]
-					data_sector_no=ts_list[entry_number*2+1]
-					contents+=get_sector(data_track_no,data_sector_no)[0..bytes_in_last_sector-1]
-				end	
-				if (NADOLTokenisedFile.can_be_nadol_tokenised_file?(contents)) then
-					@files[filename]= NADOLTokenisedFile.new(filename,contents)
-				else
-					@files[filename]= NADOLFile.new(filename,contents)
-				end
-			end
-		end
-	end
+    @files={}
+    track=0
+    sector=3
+    while (sector<=9) do
+      sector_data=get_sector(track,sector)
+      (0..15).each do |slot_no|
+        slot_offset=slot_no*0x10
+        file_descriptive_entry=sector_data[slot_offset..slot_offset+0x10]
+        if (file_descriptive_entry[0]!=0xFF && file_descriptive_entry[0]!=0x00) then # skip deleted /empty files
+          filename=""
+          file_descriptive_entry[0..11].to_s.each_byte{|b| filename+=(b.%128).chr} #strip off high bit
+          filename.sub!(/ *$/,"") #strip off trailing spaces
+          file_size=file_descriptive_entry[0x0D]*256+file_descriptive_entry[0x0C]
+          if (file_size>0) then
+            contents=""	
+            get_track_sector_list(file_descriptive_entry[0x0E],file_descriptive_entry[0x0F]).each do |ts|
+              contents<<get_sector(ts.track_no,ts.sector_no)
+            end
+            contents=contents[0..file_size-1]
+            if (NADOLTokenisedFile.can_be_nadol_tokenised_file?(contents)) then
+              @files[filename]= NADOLTokenisedFile.new(filename,contents)
+            else
+              @files[filename]= NADOLBinaryFile.new(filename,contents)
+            end
+          end
+        end
+      end
+    sector+=1
+    end
+  end
 end
 # == Author
 # Jonno Downes (jonno@jamtronix.com)

data/lib/NADOLFile.rb

@@ -2,38 +2,32 @@ $:.unshift(File.dirname(__FILE__)) unless
 	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'D65'
-
+require 'DSKFile'
+require 'HGR'
 #NADOL (Nibbles Away Disk Optimized Language) file
-class NADOLFile	
-	attr_accessor(:filename,:contents) 
-	def initialize(filename,contents)
-		@filename=filename
-		@contents=contents
-	end
-
-	def to_s
-		@contents
-	end
-
+class NADOLFile	< DSKFile
 	def file_extension
 		".bin"
 	end
-	def hex_dump
-		#assumes file is a multiple of 16 bytes, which it always should be
-		s=""
-		(0..(@contents.length/16)-1).each {|line_number|
-			 lhs=""
-			 rhs=""
-			 start_byte=line_number*16
-			 line=@contents[start_byte..start_byte+15]
-			 line.each_byte {|byte|
-				  lhs+= sprintf("%02X ", byte)
-				  rhs+= (byte%128).chr.sub(/[\x00-\x1f]/,'.')
-		 	}
-			s+=sprintf("%02X\t%s %s\n",start_byte,lhs,rhs)
-		}
-		s
-	end
+  
+  def catalog_filename
+    NADOLFile.catalog_filename(filename)
+  end
+  
+  #render the filename in form suitable for inclusion in a NADOL catalog
+  def  NADOLFile.catalog_filename(filename)
+    s=""
+    for i in 0..0X0B
+      c=(filename[i])
+      if c.nil? then
+        c=0xA0        
+        else 
+        c=(c|0x80)
+      end
+      s+=c.chr
+    end
+    s
+  end
 end
 
 #a file on a NADOL dsk that does not appear to be in NADOL tokenised format
@@ -41,21 +35,29 @@ class NADOLBinaryFile<NADOLFile
 	def disassembly(start_address=0x8000) 
 		require 'D65'
 		D65.disassemble(@contents,start_address)
+	end
+
+	def can_be_picture?
+		HGR.can_be_hgr_screen?(@contents)
+	end
+
+	def to_png(pallete_mode=:amber)
+		HGR.buffer_to_png(@contents)
 	end
 end
 
 
 #file packed by the NADOL EDITOR application.
 #format is a series of  unnumbered lines, where each line has the following format:
-#  <Length>     (8-bit: including length byte, line no, contents, zero>
-#  <Tokens and/orCharacters>
-#  <Zero byte>  ($00, to mark the end of the S-C Asm source line)
+#  <Length>     (8-bit: including length byte,  contents, zero>
+#  <Tokens and/or Characters>
+#  <Zero byte>  ($00, to mark the end of the line)
 # each byte in the line is interpreted as follows:
 # $00 - end of line marker
 # $01 - $64 - NADOL tokens
-# $65-$70 - ??? unknown
+# $65 - $70 - ??? unknown
 # $71 - $7f - 1 to F spaces
-# $80-$FF - ASCII character with high bit set
+# $80 - $FF - ASCII character with high bit set
 class NADOLTokenisedFile < NADOLFile
 	NADOL_EDITOR_TOKENS = [
 	"?",		#00 (so we can use token as an index in to this array)
@@ -164,7 +166,7 @@ class NADOLTokenisedFile < NADOLFile
 
 	#check whether a given series of bytes can be a valid NADOL tokenised file
 	#heuristics are:
-	# - bytes 
+	#that each line starts with a line length and ends with a "0"
 	def  NADOLTokenisedFile.can_be_nadol_tokenised_file?(buffer)
 		r=true
 		i=0
@@ -178,10 +180,46 @@ class NADOLTokenisedFile < NADOLFile
 		end
 		r
 	end
-	
+	#
+  def NADOLTokenisedFile.tokenise(buffer)
+   
+    s=""
+    buffer.each("\n") do |line|
+      #trim the trailing \n
+      line.chomp!
+      #first set the high bit in each char
+      for i in 0..line.length-1
+      line[i]=line[i]|0x80
+      end
+
+      #now replace token strings with token number
+      for i in 1..0x64
+        token=" "*NADOL_EDITOR_TOKENS[i].length
+        for j in 0..token.length-1
+          token[j]=NADOL_EDITOR_TOKENS[i][j]|0x80
+        end
+        line.gsub!(token,i.chr)
+      end
+
+      #replace 2 to 15 spaces with a run-length-encoding
+      0x0f.downto(2) do |i|
+      line.gsub!(" "*i,(0x70+i).chr)
+      end
+
+      #now add length to each line
+      s+=((line.length+2).chr)+line+"\0"
+    end
+    
+    if ! NADOLTokenisedFile.can_be_nadol_tokenised_file?(s)
+      raise "tokenisation appears to have failed!"
+  end
+  s
+  end
+  
 	def to_s
 		NADOLTokenisedFile.buffer_as_tokenised_file(@contents)
 	end
+  
 	def file_extension
 		".nad"
 	end

data/lib/PascalDisk.rb

@@ -0,0 +1,121 @@
+$:.unshift(File.dirname(__FILE__)) unless
+	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# Disk image with Pascal File System
+#catalog  will be at block 2.
+#each entry consists of $1A bytes, which are:
+#VOLUME HEADER
+#	00..01 FIRST BLOCK (word)	
+#	02..03 LAST BLOCK+1 (word)
+#	04 	FILE TYPE (byte) =  untypedfile,xdskfile,codefile,textfile,infofile,datafile,graffile,fotofile,securdir
+#	05 	FILLER
+#	06	VOLUME NAME LENGTH (1 byte)
+#	07..0D	VOLUME NAME (17 bytes)
+#	0E..0F 	VOLUME SIZE (WORD)
+#	10 	NUMBER OF FILES (BYTE)
+#	11..1A	FILLER
+#
+#FILES
+#	00..01 	FIRST BLOCK (word)	
+#	02..03 	LAST BLOCK+1 (word)
+#	04 	FILE TYPE (byte) =  untypedfile,xdskfile,codefile,textfile,infofile,datafile,graffile,fotofile,securdir
+#	05 	STATUS (byte)
+#	06	FILENAME LENGTH (1 byte)
+#	07..16	FILENAME (15 bytes)
+#	17..18 	BYTES IN LAST BLOCK (word)
+#	19..1A	FILE ACCESS DATE 
+
+require 'PascalFile'
+class PascalDisk < DSK
+	attr_accessor :volume_name
+
+	def dump_catalog
+		s=""
+		files.keys.sort.each { |file_name|		
+			file=files[file_name]	
+			s<< "#{sprintf('% 6d',file.contents.length)}\t #{file.file_type}\t#{file.filename}\n"
+		}
+		s
+	end
+
+
+	def initialize(file_bytes,sector_order)    
+		super(file_bytes,sector_order)
+		self.read_catalog
+	end
+
+	def file_system
+		:pascal
+	end
+	
+	#reads the catalog, and populate the "files" array with files
+	def read_catalog
+        catalog=get_block(2)
+        #we've read the first block in the catalog, now read the rest
+        catalog_size=catalog[2]
+        3.upto(catalog_size-1) do |i|
+          catalog<<get_block(i)
+        end
+#	06	VOLUME NAME LENGTH (1 byte)
+#	07..0D	VOLUME NAME (17 bytes)
+#	0E..0F 	VOLUME SIZE (WORD)
+#	10 	NUMBER OF FILES (BYTE)
+        volume_name_length=catalog[6]
+        self.volume_name=catalog[7..6+volume_name_length]
+        files_in_volume=catalog[0x10]
+        #read in all the files
+        
+#	00..01 	FIRST BLOCK (word)	
+#	02..03 	LAST BLOCK+1 (word)
+#	04 	FILE TYPE (byte) =  untypedfile,xdskfile,codefile,textfile,infofile,datafile,graffile,fotofile,securdir
+#	05 	STATUS (byte)
+#	06	FILENAME LENGTH (1 byte)
+#	07..15	FILENAME (15 bytes)
+#	16..17 	BYTES IN LAST BLOCK (word)
+#	18.1A	FILE ACCESS DATE
+        1.upto(files_in_volume) do |file_no|
+          file_record=catalog[file_no*0x1a..(file_no*0x1a+0x19)]
+          first_block=file_record[0]+file_record[1]*0x100
+          first_block_in_next_file=file_record[2]+file_record[3]*0x100
+          last_block=first_block_in_next_file-1
+          file_type=file_record[4]
+          file_name_length=file_record[6]
+          file_name=file_record[7..6+file_name_length]
+          bytes_in_last_block=file_record[0x16]+file_record[0x17]*0x100
+          file_contents=""
+          first_block.upto(last_block) do |block_no|
+            this_block=get_block(block_no)
+            if block_no==last_block then
+              file_contents<<this_block[0..bytes_in_last_block-1]
+            else
+              file_contents<<this_block 
+            end
+          files[file_name]=PascalFile.new(file_name,file_contents,file_type)
+        end        
+      end
+	end
+end
+# == Author
+# Jonno Downes (jonno@jamtronix.com)
+#
+# == Copyright
+# Copyright (c) 2007 Jonno Downes (jonno@jamtronix.com)
+#
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/PascalFile.rb

@@ -0,0 +1,62 @@
+$:.unshift(File.dirname(__FILE__)) unless
+	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'DSKFile'
+require 'HGR'
+#Pascal file
+class PascalFile < DSKFile
+	attr_accessor :file_type
+
+  PASCAL_FILE_TYPES=[:untyped,:xdsk,:code,:text,:info,:data,:graf,:foto,:securedir]
+
+	def initialize(filename,contents,file_type)
+		raise "filename too long - #{filename}" unless filename.length<=15
+		@filename=filename
+		@contents=contents
+		@file_type=PASCAL_FILE_TYPES[file_type]
+	end
+  
+	def to_s
+		s=""
+		@contents.each_byte{|b| s<<(b%0x80).chr.tr(0x0D.chr,"\n")}
+		s
+	end
+  
+	def file_extension
+		return "."+@file_type.downcase
+	end
+
+	def can_be_picture?
+		
+		file_type==:foto && HGR.can_be_hgr_screen?(@contents)
+	end
+
+	def to_png(pallete_mode=:amber)
+		HGR.buffer_to_png(@contents,pallete_mode)
+	end
+end
+
+# == Author
+# Jonno Downes (jonno@jamtronix.com)
+#
+# == Copyright
+# Copyright (c) 2007 Jonno Downes (jonno@jamtronix.com)
+#
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.