butler 1.8.0

data/lib/butler/irc/message.rb

@@ -0,0 +1,184 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+#require 'ruby/string' # we need the transcode! method
+
+class Butler
+	module IRC
+	
+		# Butler::IRC::Message represents messages received by the server.
+		# It provides convenience methods that allow to access information about
+		# those messages easier, e.g. who (as Butler::IRC::User object) sent the
+		# message in which channel (IRC::Channel object) with what text.
+		# Raw message and raw parsed data are still available though.
+		#
+		# =FIXME
+		class Message
+			# the command-symbol, see COMMANDS (e.g. :PRIVMSG, :JOIN, ...)
+			attr_reader :symbol
+	
+			# a string containing the raw message as received
+			attr_reader :raw
+	
+			# the prefix, normally either the sending user or your irc-server
+			attr_reader :prefix
+			# the raw command (e.g. "352", "notice", ...)
+			attr_reader :command
+			# the parameter part
+			attr_reader :params
+	
+			def initialize(client, symbol, raw, prefix, command, params)
+				@client  = client
+	
+				#raw message
+				@raw     = raw
+	
+				#parsed data
+				@prefix  = prefix
+				@command = command
+				@params  = params
+				@symbol  = symbol
+	
+				#specific data
+				@fields = Hash.new { |h,k| raise IndexError, "No member '#{k}' available." }.merge({
+					:raw     => @raw,
+					:prefix  => @prefix,
+					:command => @command,
+					:params  => @params,
+					:symbol  => @symbol,
+					:from    => nil,
+					:for     => nil,
+					:channel => nil,
+					:text    => nil,
+				})
+			end
+	
+			def initialize_copy(original) #:nodoc:
+				super
+				@client  = original.instance_variable_get(:@client)
+				@fields  = original.to_hash
+				@raw     = @fields[:raw]
+				@prefix  = @fields[:prefix]
+				@command = @fields[:command]
+				@params  = @fields[:params]
+				@symbol  = @fields[:symbol]
+			end
+			
+			def answer(text)
+				reply = channel || from
+				case @symbol
+					when :PRIVMSG: @client.irc.privmsg(text, reply)
+					when :NOTICE:  @client.irc.notice(text, reply)
+				end
+			end
+			
+			def from
+				@fields[:from]
+			end
+	
+			def for
+				@fields[:for]
+			end
+	
+			def channel
+				@fields[:channel]
+			end
+	
+			def text
+				@fields[:text]
+			end
+			
+			# access to raw parsed data
+			def [](index)
+				@fields[index.to_sym]
+			end
+	
+			def []=(index, value)
+				raise NoMethodError, "Can't write to #{index}" unless respond_to?("#{index}=")
+				index = index.to_sym
+				@fields[index] = value
+			end
+			
+			def has_key?(key)
+				@fields.has_key?(key.to_sym)
+			end
+			
+			def create_method(name, &code)
+				singleton = class << self; self; end
+				singleton.send(:define_method, name, &code)
+				name
+			end
+			
+			# create a member with it's value, if writable is true, it creates a member= method too
+			def create_member(index, value=nil, writable=false)
+				index = index.to_sym
+				raise IndexError, "Member '#{index}' exists already" if @fields.has_key?(index)
+				singleton = class << self; self; end
+				singleton.send(:define_method, index) { @fields[index] }
+				singleton.send(:define_method, "#{index}=") { |val| @fields[index] = val } if writable
+				@fields[index] = value
+			end
+	
+			# alter a member value with it's value
+			# should not be used other than by Butler::IRC::Parser
+			def alter_member(index, value=nil, create=false)
+				index = index.to_sym
+				if @fields.has_key?(index)
+					@fields[index] = value
+				elsif create then
+					create_member(index, value)
+				else
+					raise IndexError, "No member '#{index}' available."
+				end
+			end
+			
+			# delete a field
+			def delete_member(index)
+				index = index.to_sym
+				raise IndexError, "No member '#{index}' available." unless @fields.has_key?(index)
+				remove_method(index)
+				remove_method("#{index}=") if respond_to?("#{index}=")
+				@fields.delete(index)
+			end
+			
+			# change charset encoding
+			def transcode!(from, to)
+			end
+			
+			def ===(other)
+				case other
+					when Symbol: @symbol == other
+					when Regexp: @text && @text =~ other
+				end
+			end
+	
+			# return a hash of the fields
+			def to_hash
+				@fields.dup
+			end
+			
+			def hash #:nodoc:
+				@raw.hash
+			end
+			
+			def eql?(other) #:nodoc:
+				@raw == other.raw
+			end
+			
+			def inspect #:nodoc:
+				fields = @fields.dup
+				#[:raw, :prefix, :command, :params, :command_raw]
+				[:raw, :command, :prefix, :params].each { |field| fields.delete(field) }
+				fields = fields.map { |k,v| "#{k}=#{v.inspect}" }.join(" ")
+				"#<%s:0x%x\n%s\n%s>" %  [self.class, object_id, @raw.inspect, fields]
+			end
+			
+			alias to_s inspect
+		end
+	end
+end

data/lib/butler/irc/parser.rb

@@ -0,0 +1,125 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'butler/irc/channels'
+require 'butler/irc/hostmask'
+require 'butler/irc/message'
+require 'butler/irc/parser/commands'
+require 'butler/irc/string'
+require 'butler/irc/users'
+require 'ruby/exception/detailed'
+require 'ruby/hash/zip'
+
+
+
+class Butler
+	module IRC
+		# Parses messages, automatically converts 
+		# provides a parser that automatically connects users and channels
+		# regarding who myself is (out_of_sight, back_in_sight for users)
+		# allows creation of dialogs from privmsg and notice messages
+		class Parser
+			# RFC 2812, Parser itself uses a simplified matching
+			module Expressions
+				Special     = /[\[\]\\`_^{|}]/
+				Letter      = /[A-Za-z]/
+				Hex         = /[\dA-Fa-f]/
+				ChannelID   = /[A-Z\d]{5}/
+				Chanstring  = /[^\x00\x07\x10\x0D\x20,:]/
+				Channel     = /(?:[#+&]|!#{ChannelID})#{Chanstring}(?::#{Chanstring})?/
+				User        = /[^\x00\x10\x0D\x20@]/
+				Nick        = /[A-Za-z\[\]\\`_^{|}][A-Za-z\d\[\]\\`_^{|}-]*/
+				Command     = /[A-Za-z]+|\d{3}/
+				IP4addr     = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+				IP6addr     = /[\dA-Fa-f](?::[\dA-Fa-f]){7}|0:0:0:0:0:(?:0|[Ff]{4}):#{IP4addr}/
+				Hostaddr    = /#{IP4addr}|#{IP6addr}/
+				Shortname   = /[A-Za-z0-9][A-Za-z0-9-]*/
+				Hostname    = /#{Shortname}(?:\.#{Shortname})*/
+				Host        = /#{Hostname}|#{Hostaddr}/
+				Prefix      = /#{Hostname}|#{Nick}(?:(?:!#{User})?@#{Host})?/
+				Params      = /.*/ # FIXME
+				Message     = /(:#{Prefix} )?#{Command}(#{Params})?/
+			end
+			
+			class InvalidMessageFormat < RuntimeError; end
+			class UnknownCommand < RuntimeError; end
+			module ParseError
+				include Exception::Detailed
+			end
+	
+			RMessage  = /\A(?::([^ \0]+) )?([A-Za-z\d]+|\d{3})(?: (.*))?\z/
+			RHostmask = /(#{Expressions::Nick})(?:(?:!(#{Expressions::User}))?@(#{Expressions::Host}))?/
+	
+			attr_reader :client
+			attr_reader :users
+			attr_reader :channels
+	
+			def initialize(client, users, channels)
+				@client      = client
+				@users       = users
+				@channels    = channels
+				@commands    = Commands.new
+			end
+	
+			# parses an incomming message and returns a Message object from which you
+			# can easily access parsed data.
+			# Expects the newlines to be already chomped off.
+			def server_message(raw)
+				prefix, command, params, symbol, from = nil
+	
+				# Basic analysis of the message
+				raise InvalidMessageFormat, raw unless matched = raw.match(RMessage)
+				prefix, command, params	= *matched.captures
+				command.downcase!
+		
+				# Parse prefix if possible (<nick>!<user>@<host>)
+				from	= @users.create(*matched.captures) if prefix and matched = prefix.match(RHostmask)
+				
+				# in depth analyzis of the message
+				parser  = @commands[command]
+				symbol  = parser.symbol
+				message	= Message.new(@client, symbol, raw, prefix, command, params)
+				message.alter_member(:from, from)
+	
+				parser.create_fields(message)
+				
+				if message.for then
+					if message.for.valid_channelname? then
+						channel = @channels.create(message.for)
+						message.alter_member(:channel, channel)
+						message.alter_member(:for, channel)
+					else
+						message.alter_member(:for,	@users.create(message.for))
+					end
+				end
+				message.alter_member(:channel, @channels.create(message.channel)) if message.channel
+	
+				parser.process(message, self)
+	
+				return message
+			rescue IndexError
+					raise UnknownCommand, "Unknown command #{command}: #{raw.inspect}"
+			rescue => e
+				e.extend ParseError
+				e.prepend "Message: #{raw.inspect}"
+				raise e
+			end
+	
+			def leave_channel(message, reason1, reason2)
+				if message.from && message.channel then
+					message.from.delete_channel(message.channel, reason1)
+					message.channel.delete_user(message.from, reason1)
+					if message.from == @users.myself then
+						@channels.delete(message.channel)
+						@users.delete_channel(message.channel, reason2)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/butler/irc/parser/commands.rb

@@ -0,0 +1,83 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'butler/irc/parser'
+
+
+
+class Butler
+	module IRC
+		class Parser
+			class Commands
+				def initialize(specifics=nil)
+					@commands = Hash.new { |h,k| raise IndexError, "Unknown command #{k}" }
+					file      = "#{File.dirname(__FILE__)}/generic.rb"
+					instance_eval(File.read(file), file)
+				end
+				
+				def add(raw, *args, &proc)
+					raise IndexError, "Command #{raw} is already registered. Did you want 'alter'?" if @commands.has_key?(raw)
+					@commands[raw.downcase] = Command.new(raw, *args, &proc)
+				end
+	
+				def alter(raw, *args, &proc)
+					raise IndexError, "Command #{raw} is not registered. Did you want 'add'?" unless @commands.has_key?(raw)
+					@commands[raw.downcase] = Command.new(raw, *args, &proc)
+				end
+	
+				def [](raw)
+					@commands[raw.downcase]
+				end
+				
+				def inspect
+					"#<%s:0x%x>" %  [self.class, object_id]
+				end
+			end
+	
+			# Provides parsing information about specific commands.
+			class Command
+				attr_reader	:raw
+				attr_reader	:symbol
+				attr_reader	:matcher
+				attr_reader	:mapping
+				attr_reader :processor
+		
+				# See Butler::IRC::COMMANDS for samples on instanciation of
+				# Butler::IRC::Command objects.
+				def initialize(raw, symbol, matcher=nil, mapping=nil, &processor)
+					@raw       = raw
+					@symbol    = symbol
+					@matcher   = matcher
+					@mapping   = mapping
+					@processor = processor
+				end
+	
+				def match(message)
+					@matcher.match(message)
+				end
+				
+				def fields(message)
+					return nil unless @matcher and match = @matcher.match(message.params)
+					Hash.zip(@mapping, match.captures)
+				end
+				
+				def create_fields(message)
+					if @matcher and match = @matcher.match(message.params) then
+						@mapping.zip(match.captures) { |name, value|
+							message.alter_member(name, value, true)
+						}
+					end
+				end
+				
+				def process(message, parser)
+					@processor.call(message, parser) if @processor
+				end
+			end
+		end
+	end
+end

data/lib/butler/irc/parser/generic.rb

@@ -0,0 +1,343 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+# A list with all known IRC-Commands and it's parsing instructions
+# Commands with __ in it are customs, not verified towards any standard.
+
+#Text based codes
+add("error",   :ERROR)		# ERROR :<error-message>
+
+add("invite",  :INVITE, /^([^\s]*) :(.*)/, [:invited, :channel])
+
+add("join",    :JOIN,   /^:(.*)/,          [:channel]) { |message, parser|
+	if message.from && message.channel then
+		message.from.add_channel(message.channel, :join)
+		message.channel.add_user(message.from, :join)
+	end
+}
+
+add("kick",    :KICK,   /^([^\s]*) ([^\s]*) :(.*)/, [:channel, :for, :text]) { |message, parser|
+	parser.leave_channel(message, :kick, :kicked)
+}
+
+add("kill",    :KILL,   /^([^\s]*) ([^\s]*) (.*)/, [:channel, :for, :text]) { |message, parser|
+	if message.for then
+		message.for.kill
+		parser.channels.delete_user(message.for, :kill)
+	end
+}
+
+# FIXME, really ':?' or just plain ':'?
+add("mode",    :MODE,   /^([^\s]*) :?(.*)/, [:for, :arguments]) { |message, parser|
+	modifiers				= message[:arguments].split(" ")
+	modes					= modifiers.shift.split("")
+	flags					= {"o" => User::Flags::OP, "v" => User::Flags::VOICE, "u" => User::Flags::UOP}
+	message.create_member(:modes, [])
+	argumentIndex			= 0
+	direction				= "+"
+
+	modes.each { |mode|
+		# MODEs direction
+		if (["+", "-"].include?(mode)) then
+			direction	= mode
+		# MODEs taking an argument
+		elsif (["k", "o", "v", "u"].include?(mode) || (mode == "l" && direction == "+")) then
+			if ["o", "v", "u"].include?(mode) then
+				if (direction == "+") then
+					parser.users[modifiers[argumentIndex]].add_flags(message.channel, flags[mode]) #adding flags to user
+				else
+					parser.users[modifiers[argumentIndex]].delete_flags(message.channel, flags[mode]) #removing flags from user
+				end
+			end
+			message.modes << [direction, mode, modifiers[argumentIndex]]
+			argumentIndex	= argumentIndex+1
+		# MODEs without argument
+		else
+			message.modes << [direction, mode, nil]
+		end
+	}
+}
+add("nick",    :NICK,    /^:(.*)/, [:nick]) { |message, parser|
+	message.create_member(:old_nick, message.from.nick)
+	message.from.nick = message.nick if message.from
+}
+
+add("notice",  :NOTICE,  /([^\s]+) :(.*)/, [:for, :text]) { |message, parser|
+	if message.channel then
+		message.create_member(:realm, :public)
+		message.create_method(:private?) { false }
+		message.create_method(:public?) { true }
+	else
+		message.create_member(:realm, :private)
+		message.create_method(:private?) { true }
+		message.create_method(:public?) { false }
+	end
+}
+
+add("part",    :PART,    /^([^\x00\x07\x10\x0D\x20,:]+)(?: :(.*))?/, [:channel, :reason]) { |message, parser|
+	parser.leave_channel(message, :part, :parted)
+}
+
+add("ping",    :PING,    /:(.*)/, [:pong])
+
+add("pong",    :PONG)
+
+add("privmsg", :PRIVMSG, /([^\s]+) :(.*)/, [:for, :text]) { |message, parser|
+	if message.channel then
+		message.create_member(:realm, :public)
+		message.create_method(:private?) { false }
+		message.create_method(:public?) { true }
+	else
+		message.create_member(:realm, :private)
+		message.create_method(:private?) { true }
+		message.create_method(:public?) { false }
+	end
+}
+
+add("quit",    :QUIT,    /(.*)/, [:text]) { |message, parser|
+	if message.from then
+		message.from.quit
+		parser.channels.delete_user(message.from, :quit)
+		parser.users.delete(message.from, :quit)
+	end
+}
+add("topic",   :TOPIC, /([^\s]+) :(.*)/, [:channel, :text])
+
+	#Unknown/Non-RFC codes
+add("007", :UNK_007)
+add("008", :UNK_008)
+add("009", :UNK_009)
+add("307", :RPL_REGISTERED_INFO)	#FIXME non2812 "ConferenceRoom" bluewin, sent if a nick is registered
+add("329", :RPL_CHANNEL_INFO)		#channel creation time
+add("377", :UNK_377)
+
+	#0** Codes
+add("001", :RPL_WELCOME)
+add("002", :RPL_YOURHOST)
+add("003", :RPL_CREATED)
+add("004", :RPL_MYINFO)
+add("005", :RPL_ISUPPORT)
+
+	#2** Codes
+add("200", :RPL_TRACELINK)
+add("201", :RPL_TRACECONNECTING)
+add("202", :RPL_TRACEHANDSHAKE)
+add("203", :RPL_TRACEUNKNOWN)
+add("204", :RPL_TRACEOPERATOR)
+add("205", :RPL_TRACEUSER)
+add("206", :RPL_TRACESERVER)
+add("207", :RPL_TRACESERVICE)
+add("208", :RPL_TRACENEWTYPE)
+add("209", :RPL_TRACECLASS)
+add("210", :RPL_TRACERECONNECT)
+add("211", :RPL_STATSLINKINFO)
+add("212", :RPL_STATSCOMMANDS)
+add("213", :RPL_STATSCLINE)
+add("214", :RPL_STATSNLINE)
+add("215", :RPL_STATSILINE)
+add("216", :RPL_STATSKLINE)
+add("217", :RPL_STATSQLINE)
+add("218", :RPL_STATSYLINE)
+add("219", :RPL_ENDOFSTATS)
+add("221", :RPL_UMODEIS)
+add("231", :RPL_SERVICEINFO)
+add("232", :RPL_ENDOFSERVICES)
+add("233", :RPL_SERVICE)
+add("234", :RPL_SERVLIST)
+add("235", :RPL_SERVLISTEND)
+add("240", :RPL_STATSVLINE)
+add("241", :RPL_STATSLLINE)
+add("242", :RPL_STATSUPTIME)
+add("243", :RPL_STATSOLINE)
+add("244", :RPL_STATSHLINE)
+add("245", :RPL_STATSSLINE)	# RFC 2812 seems to be erroneous, it assigns 244 double
+add("246", :RPL_STATSPING)
+add("247", :RPL_STATSBLINE)
+add("250", :RPL_STATSCONN)
+add("251", :RPL_LUSERCLIENT)
+add("252", :RPL_LUSEROP)
+add("253", :RPL_LUSERUNKNOWN)
+add("254", :RPL_LUSERCHANNELS)
+add("255", :RPL_LUSERME)
+add("256", :RPL_ADMINME)
+add("257", :RPL_ADMINLOC1)
+add("258", :RPL_ADMINLOC2)
+add("259", :RPL_ADMINEMAIL)
+add("261", :RPL_TRACELOG)
+add("262", :RPL_TRACEEND)
+add("263", :RPL_TRYAGAIN)
+add("265", :RPL_LOCALUSERS)
+add("266", :RPL_GLOBALUSERS)
+add("290", :RPL_IDENTIFY_MSG) # FIXME non2812 "hyperion-1.0.2b"
+
+	#3** Codes
+add("300", :RPL_NONE)
+add("301", :RPL_AWAY)
+add("302", :RPL_USERHOST)
+add("303", :RPL_ISON)
+add("305", :RPL_UNAWAY)
+add("306", :RPL_NOWAWAY)
+add("311", :RPL_WHOISUSER, /^([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+) \* :(.*)/, [:for, :nick, :user, :host, :real])
+add("312", :RPL_WHOISSERVER)
+add("313", :RPL_WHOISOPERATOR)
+add("314", :RPL_WHOWASUSER)
+add("315", :RPL_ENDOFWHO)
+add("316", :RPL_WHOISCHANOP)
+add("317", :RPL_WHOISIDLE, /^([^\s]+) ([^\s]+) ([^:]+) :(.*)/, [:for, :nick, :values, :descriptions]) { |message, parser|
+	values			= message[:values].split(" ");
+	descriptions	= message[:descriptions].split(", ").map { |desc| desc.gsub(" ", "_").to_sym };
+	message.delete(:values)
+	message.delete(:descriptions)
+	0.upto([values.length, descriptions.length].min-1) { |index|
+		message[descriptions[index]]	= values[index]
+	}
+}
+add("318", :RPL_ENDOFWHOIS)
+add("319", :RPL_WHOISCHANNELS, /^([^\s]+) ([^\s]+) :(.*)/, [:for, :nick, :channels]) { |message, parser|
+	# FIXME
+	message.alter_member(:channels, message.channels.split(" ").map { |channel| parser.channels.create(channel) })
+}
+add("320", :RPL_IDENTIFIED_TO_SERVICES) # possibly hyperion only
+add("321", :RPL_LISTSTART)
+add("322", :RPL_LIST, /^([^\s]+) ([^\s]+) (\d+) :(.*)/, [:for, :channelname, :usercount, :topic])
+add("323", :RPL_LISTEND)
+add("324", :RPL_CHANNELMODEIS)
+add("325", :RPL_UNIQOPIS)
+add("331", :RPL_NOTOPIC)
+		# :irc.server.net 332 YourNickname #channel :Topic
+add("332", :RPL_TOPIC, /^([^\s]+) ([^\s]+) :(.*)/, [:for, :channel, :topic]) { |message, parser|
+	message.channel.topic.text = message[:topic]
+}
+
+		# :irc.server.net 333 YourNickname #channel SetByNick 1139902138
+add("333", :RPL_TOPIC_INFO, /^([^\s]+) ([^\s]+) ([^\s]+) (\d+)/, [:for, :channel, :set_by, :set_at]) { |message, parser|
+	topic = message.channel.topic
+	topic.set_by = message[:set_by]
+	topic.set_at = message[:set_at]
+}
+add("341", :RPL_INVITING)
+add("342", :RPL_SUMMONING)
+add("343", :RPL__MAINTENANCE)	#mainenance notice?
+add("346", :RPL_INVITELIST)
+add("347", :RPL_ENDOFINVITELIST)
+add("348", :RPL_EXCEPTLIST)
+add("349", :RPL_ENDOFEXCEPTLIST)
+add("351", :RPL_VERSION)
+		# :irc.server.net 352 YourNickname <channel> <user> <host> <server> <nick> ( "H" / "G" > ["*"] [ ( "@" / "+" ) ] :<hopcount> <real name>
+add("352", :RPL_WHOREPLY,
+			/([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+) ([HG])[*%]{0,2}([@+-]{0,3}) :(\d+) (.*)/,
+			[:for, :channel, :user, :host, :server, :nick, :status, :flags, :hopcount, :real]) { |message, parser|
+#"for", "channel", "user", "host", "server", "nick", "status", "flags", "hopcount", "real"
+	user	= parser.users.create(message[:nick])
+	user.update(message[:user], message[:host], message[:real])
+	user.away	= message[:status] == "G"
+	user.add_channel(message.channel, :joined)
+	message.channel.add_user(user, :joined)
+	user.add_flags(message.channel, message[:flags].to_flags)
+}
+add("353", :RPL_NAMEREPLY, /([^\s]+) [=@] ([^\s]+) :(.*)/, [:for, :channel, :users]) { |message, parser|
+	users	= message[:users]
+	message.alter_member(:users, [])
+	users.split(/ /).each { |nick|
+		user	= parser.users.create(nick)
+		message[:users]	<< user
+		user.add_channel(message.channel, :joined)
+		message.channel.add_user(user, :joined)
+	}
+}
+add("361", :RPL_KILLDONE)
+add("362", :RPL_CLOSING)
+add("363", :RPL_CLOSEEND)
+add("364", :RPL_LINKS)
+add("365", :RPL_ENDOFLINKS)
+add("366", :RPL_ENDOFNAMES)
+add("367", :RPL_BANLIST,
+			/([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+) (\d+)/,
+			[:for, :channel, :banmask, :banned_by, :bantime]
+) { |message, parser| #367 nickname #channel nick!user@host nickname 1140125288
+	message[:bantime]	= Time.at(message[:bantime].to_i)
+	message[:banmask]	= Hostmask.new(message[:banmask])
+}
+
+add("368", :RPL_ENDOFBANLIST)
+add("369", :RPL_ENDOFWHOWAS)
+add("371", :RPL_INFO)
+add("372", :RPL_MOTD)
+add("373", :RPL_INFOSTART)
+add("374", :RPL_ENDOFINFO)
+add("375", :RPL_MOTDSTART)
+add("376", :RPL_ENDOFMOTD)
+add("381", :RPL_YOUREOPER)
+add("382", :RPL_REHASHING)
+add("383", :RPL_YOURESERVICE)
+add("384", :RPL_MYPORTIS)
+add("386", :RPL_PASSWORDACCEPTED) # Custom (chatroom)
+add("391", :RPL_TIME)
+add("392", :RPL_USERSSTART)
+add("393", :RPL_USERS)
+add("394", :RPL_ENDOFUSERS)
+add("395", :RPL_NOUSERS)
+
+#4** Codes
+add("401", :ERR_NOSUCHNICK)
+add("402", :ERR_NOSUCHSERVER)
+add("403", :ERR_NOSUCHCHANNEL)
+add("404", :ERR_CANNOTSENDTOCHAN)
+add("405", :ERR_TOOMANYCHANNELS)
+add("406", :ERR_WASNOSUCHNICK)
+add("407", :ERR_TOOMANYTARGETS)
+add("408", :ERR_NOSUCHSERVICE)
+add("409", :ERR_NOORIGIN)
+add("411", :ERR_NORECIPIENT)
+add("412", :ERR_NOTEXTTOSEND)
+add("413", :ERR_NOTOPLEVEL)
+add("414", :ERR_WILDTOPLEVEL)
+add("415", :ERR_BADMASK)
+add("421", :ERR_UNKNOWNCOMMAND)
+add("422", :ERR_NOMOTD)
+add("423", :ERR_NOADMININFO)
+add("424", :ERR_FILEERROR)
+add("431", :ERR_NONICKNAMEGIVEN)
+add("432", :ERR_ERRONEUSNICKNAME)
+add("433", :ERR_NICKNAMEINUSE)
+add("436", :ERR_NICKCOLLISION)
+add("437", :ERR_UNAVAILRESOURCE)
+add("441", :ERR_USERNOTINCHANNEL)
+add("442", :ERR_NOTONCHANNEL)
+add("443", :ERR_USERONCHANNEL)
+add("444", :ERR_NOLOGIN)
+add("445", :ERR_SUMMONDISABLED)
+add("446", :ERR_USERSDISABLED)
+add("451", :ERR_NOTREGISTERED)
+add("461", :ERR_NEEDMOREPARAMS)
+add("462", :ERR_ALREADYREGISTRED)
+add("463", :ERR_NOPERMFORHOST)
+add("464", :ERR_PASSWDMISMATCH)
+add("465", :ERR_YOUREBANNEDCREEP)
+add("466", :ERR_YOUWILLBEBANNED)
+add("467", :ERR_KEYSET)
+add("471", :ERR_CHANNELISFULL)
+add("472", :ERR_UNKNOWNMODE)
+add("473", :ERR_INVITEONLYCHAN)
+add("474", :ERR_BANNEDFROMCHAN)
+add("475", :ERR_BADCHANNELKEY)
+add("476", :ERR_BADCHANMASK)
+add("477", :ERR_NOCHANMODES)
+add("478", :ERR_BANLISTFULL)
+add("481", :ERR_NOPRIVILEGES)
+add("482", :ERR_CHANOPRIVSNEEDED)
+add("483", :ERR_CANTKILLSERVER)
+add("484", :ERR_RESTRICTED)
+add("485", :ERR_UNIQOPPRIVSNEEDED)
+add("491", :ERR_NOOPERHOST)
+add("492", :ERR_NOSERVICEHOST)
+
+	#5** Codes
+add("501", :ERR_UMODEUNKNOWNFLAG)
+add("502", :ERR_USERSDONTMATCH)
+add("505", :ERR__NOPRIVMSG)