;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; CHANLEVEXEC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;info:
;
;  by wiebe @ QuakeNet
;  version 1.0     (written and tested on mIRC 6.14)
;                  
;
;  last edit: Sun Feb 29 2004
;
;
;What does this script do?
;
;  gets the chanlev list for a channel and sends this to the specified alias
;  script is made to work with L and Q bot (QuakeNet services)
;  for this script to work, you have to be logged in with the service
;
; (script is dynamic, it can work with any L or Q based service regardless of its irc nick)
;
;
;How to use this script?
;
;  /chanlevexec <bot> <channel> <alias> [params]
;    to request the chanlev list for channel from bot and send the info to alias
;    makes sure you are logged in with the service
;
;  /chanlevexec -n <bot> <channel> <nick|#account> <alias> [params]
;    to request the chanlev from bot for a specific user and send the info to alias
;
;  /chanlevexec -c
;    to clear the queue
;
;   the script sends the following things to the alias:
;
;    <nick> <channel> <account> <flags>
;     nick, the bot from which the chanlev is requested from, like Q or L
;     channel, from which channel the list is
;     account, account from the list
;     flags, the access flags account has
;
;    <nick> <channel> end
;     this marks the end of the list
;
;    <nick> <channel> unknownchannel
;     this is returned if the requested channel does not exist on nick
;
;    <nick> <channel> noaccess
;     this is returned if you have no access to see the list
;
;   the script uses a queue, which does not allow duplicates
;   chanlev requests are send out with a delay specified below
;
;   script can work with notices and messages
;
;   make sure L or Q (or whatever nick, is not ignored for notices/queries or is on your silence list)
; 
;  WARNING: DO NOT USE HALT IN AN ALIAS, USE RETURN!
;   halt also halts the calling alias/event, return only stops the current alias
;   and gives control back to the calling alias/event
;   using halt in alias'es that are called from this script can cause it not to work 100%
;
;
;Example:
;
; command:
;  /chanlevexec L #channel echo -a
;
; and this is echoed in active:
;
;  L #channel nick1 amnovg
;  L #channel nick2 ao
;  L #channel nick3 aov
;  L #channel nick4 gv
;  L #channel end of chanlev
;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC.DELAY ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l chanlevexec.delay {
  ; what delay in seconds should chanlevexec have when it is called
  !return 1
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC.RESTART ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l chanlevexec.restart {
  ; what delay in seconds should be between multiple chanlev requests
  ; do not set this too low
  ; per request 3 commands are send
  ; 10 seconds should be ok
  !return 10
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; /chanlevexec [-cqln] <bot> <chan> [nick] <alias> [params..]
alias chanlevexec {

  ; we are connected and '$2' is a channel prefixed with a '#'
  if ($status == connected) {

    !var %b = $+($chr(44),-), %n

    if ($left($1,1) == -) {

      if (c isin $1) {

        ; clear the queue
        $chanlevexec.queue($+(chanlevexec.queue.,$cid)).clear

        chanlevexec.disable

        ; stop
        !return
      }

      if (q isin $1) {

        !var %b = $+($chr(44),-q)
      }

      elseif (l isin $1) {

        !var %b = $+($chr(44),-l)
      }

      if (n isin $1) {

        !var %n = $+($chr(44),$4)

        !tokenize 32 $1-3 $5-
      }

      !tokenize 32 $2-
    }

    ; less then 3 parameters, stop
    if ($0 < 3) || ($left($2,1) != $chr(35)) { return }

    ; script only works with 1 nick, so we leave out the rest
    ; replace some chars in '$1', see in the alias itself why
    !tokenize 32 $chanlevexec.lower($gettok($1,1,44)) $gettok($1,1,44) $+($gettok($2,1,44),%b,%n) $3-

    ; add queue '$1-2' to the queue
    chanlevexec.queue $+(chanlevexec.queue.,$cid) $1 $3

    ; check if '$2-' is not already in the hash table
    if (!$hfind($+(chanlevexec.queue.,$cid,.item),* $2-,0,w).data) {

      ; increase item 'last' in the hash table
      !hinc -m $+(chanlevexec.queue.,$cid,.item) last

      ; add an item with the value 'last' has with value '$1-'
      !hadd $+(chanlevexec.queue.,$cid,.item) $hget($+(chanlevexec.queue.,$cid,.item),last) $1-
      ;2 $gettok($3,1,44) $4-
    }

    ; check if the timer does not already run
    if (!$timer($+($cid,.chanlevexec))) {

      ; start a timer
      .!timer $+ $cid $+ .chanlevexec 1 $$chanlevexec.delay chanlevexec.dump
    }
  }
}

; start of '#chanlevexec' group
#chanlevexec off

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; CTCPREPLY EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:CTCPREPLY:PING & &:{

  ; we get back 'PING chanlevexec #channel' and '#channel' is in the hash table
  if ($1-2 == PING chanlevexec) && ($hfind($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick) & $3 $+ $chr(44) $+ -* *,0,w).data) {

    ; set a var
    !var %x = $hfind($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick) & $3 $+ $chr(44) $+ -* *,0,w).data

    ; loop through each item
    while (%x) {

      ; add it to a var
      !var %y = $addtok(%y,$hfind($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick) & $3 $+ $chr(44) $+ -* *,%x,w).data,32)

      ; go to the next item
      !dec %x
    }

    ; add the result to the hash table under item '$nick'
    !hadd $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick) %y

    ; stop mirc from showing this event
    !haltdef
  }
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; NOTICE EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on ^*:notice:*:?:{
  chanlevexec.check $1-
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; OPEN EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on ^*:open:?:*:{
  chanlevexec.check $1-
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; TEXT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on ^*:text:*:?:{
  chanlevexec.check $1-
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC.CHECK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l chanlevexec.check {

  ; part for Q

  ; reply from a succesfull chanlev request for a channel:
  ; -Q- Channeltype: clan
  ; -Q- Known users on #channel are:
  ; -Q- nick Modes: +abmnotv
  ; -Q- End of list.
  ; -Q- Total: 28 (owner: 3, master: 2, op: 19, voice: 2, ban: 2).

  ; reply when channel is unknown:
  ; -Q- Couldn't find that channel

  ; reply when we do not have access
  ; -Q- You are not known or banned on this channel and can't dump the userlist!

  ; reply to the 'help <command>' message
  ; -Q- No help found on that topic. Try /msg Q SHOWCOMMANDS.

  ; reply to a ping request
  ; [Q PING reply]: <things>

  ; reply from a succesfull chanlev request for a nick/account
  ; -Q- #account/nick modes on channel <channel>: +abmnotv

  ; account/nick not known
  ; -Q- User is not known on that channel.

  ; nick not online / account does not exist
  ; -Q- Can't find that nickname. If the user isn't logged on, but is known by Q
  ; -Q- Try: /msg Q CHANLEV #chan #nickname

  ; when not authed to Q
  ; -Q- You don't have access to this command.
  ; -Q- If you are known by Q type: "/msg Q@CServe.quakenet.org AUTH nickname password"
  ; -Q- Otherwise introduce yourself with: "/msg Q HELLO"

  ; this part is not used by the script, but this is caused by it
  if (No help found on that topic. Try /msg Q SHOWCOMMANDS. == $1-) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {

    ; stop mirc from showing this notice
    !haltdef
  }

  ; when we are not authed
  if (You don't have access to this command. == $1-) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {

    !haltdef
  }

  ; when we are not authed
  if (If you are known by Q type: == $1-7) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {

    !haltdef
  }

  ; when we are not authed
  if (Otherwise introduce yourself with: == $1-4) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan notauthed
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  ; we get notice 'End of list.' and nick is in the hash table
  elseif (End of list. == $1-) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan end

        ; delete that item
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }

    ; delete nick from the hash table
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)

    ; 1 or 0 items left
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {

      ; free the hash table
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }

    ; disable the group
    chanlevexec.disable

    !haltdef
  }

  elseif (Couldn't find that channel == $1-) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan unknownchannel
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  elseif (You are not known or banned on this channel and can't dump the userlist! == $1-) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan noaccess
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  ; requested flags for a user/account which does not exist 1
  elseif (Can't find that nickname. If the user isn't logged on, but is known by == $1-14 ) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !haltdef
  }

  ; requested flags for a user/account which does not exist 2
  elseif (Try: /msg CHANLEV #chan #nickname == $1-2 $4-6 ) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      !var %rnick = $gettok(%t,2,32)
      !var %chan = $gettok($gettok(%t,3,32),1,44)
      !var %account = $gettok($gettok(%t,3,32),3,44)
      !var %alias = $gettok(%t,4-,32)
      if ($chanlevexec.lower($nick) == %nick) {
        %alias %rnick %chan unknownuser %account 
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !haltdef
  }

  ; request flags for a user/account but is not known on the channel
  elseif (User is not known on that channel. == $1- ) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      !var %rnick = $gettok(%t,2,32)
      !var %chan = $gettok($gettok(%t,3,32),1,44)
      !var %account = $gettok($gettok(%t,3,32),3,44)
      !var %alias = $gettok(%t,4-,32)
      if ($chanlevexec.lower($nick) == %nick) {
        %alias %rnick %chan user %account 0
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !haltdef
  }

  ; request flags for a user/account on a channel and here they are
  elseif (*?modes?on?channel?*:?& iswm $1-6) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) && ($remove($right($6,-1),a,b,m,n,o,t,v) == $null) && ($len($6) <= 8) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      !var %rnick = $gettok(%t,2,32)
      !var %chan = $gettok($gettok(%t,3,32),1,44)
      !var %account = $gettok($gettok(%t,3,32),3,44)
      !var %alias = $gettok(%t,4-,32)
      if ($chanlevexec.lower($nick) == %nick) && ($left($5,-1) == %chan) && ($1 == %account) {
        %alias %rnick %chan user $1 $right($6,-1)
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !haltdef
  }

  ; we get '<account> modes: +<flags>', '$nick' is in the hash table
  elseif (& modes: +& iswm $1-) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) && ($remove($right($3,-1),a,b,m,n,o,t,v) == $null) && ($len($3) <= 8) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %nick %chan chanlev $1 $right($3,-1)
      }
      !unset %t
      !inc %x
    }
    !haltdef
  }

  ; part for L
  ; -L- Users for channel <channel>
  ; -L- Authname Access flags
  ; -L- -----------------------------
  ; -L- <nick> <flags>
  ; -L- End of chanlev for <channel>.
  ; -L- Unknown channel <channel>.
  ; -L- Sorry, you do not have permission to view/change user flags on <channel>.
  ; -L- Sorry, no help available for 'chanlevexec <channel>'
  ; -L- Unknown user <nick/account>.
  ; -L- <nick/account> is not known on <channel>.
  ; -L- You are not authed.  Please auth with Q before sending me commands.

  ; not logged in
  elseif (You are not authed. == $1-4) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan not authed
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  ; help reply
  elseif (Sorry, no help available for 'chanlevexec == $1-6) && ($hfind($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick) & $left($7,-1) $+ $chr(44) $+ -* *,0,w).data) {
    !var %x = $hfind($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick) & $left($7,-1) $+ $chr(44) $+ -* *,0,w).data
    while (%x) {
      !var %y = $addtok(%y,$hfind($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick) & $left($7,-1) $+ $chr(44) $+ -* *,%x,w).data,32)
      !dec %x
    }
    !hadd $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick) %y
    !haltdef
  }

  ; start of list 1
  elseif (Users for channel == $1-3) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !haltdef
  }

  ; start of list 2
  elseif (Authname Access flags == $1-3) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !haltdef
  }

  ; start of list 3
  elseif (----------------------------- == $1-3) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !haltdef
  }

  ; chanlev list
  elseif ($0 == 2) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) && ($remove($2,a,m,n,o,g,v) == $null) && ($len($2) <= 6) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %account = $gettok($gettok(%t,3,32),3,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan $iif(%account,user $ifmatch,chanlev) $1 $2
      }
      !unset %t
      !inc %x
    }
    !haltdef
  }

  ; end of chanlev list
  elseif (End of chanlev for == $1-4) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %account = $gettok($gettok(%t,3,32),3,44)
        !var %alias = $gettok(%t,4-,32)
        if (!%account) {
          %alias %rnick %chan end
        }
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  ; unknown nick/account
  elseif (Unknown?user?& iswm $1-3) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      !var %rnick = $gettok(%t,2,32)
      !var %chan = $gettok($gettok(%t,3,32),1,44)
      !var %account = $gettok($gettok(%t,3,32),3,44)
      !var %alias = $gettok(%t,4-,32)
      if ($chanlevexec.lower($nick) == %nick) && (%account == $left($3,-1)) {
        %alias %rnick %chan unknownuser %account
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  ; nick/account not known on channel
  elseif (is not known on == $2-5) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      !var %rnick = $gettok(%t,2,32)
      !var %chan = $gettok($gettok(%t,3,32),1,44)
      !var %account = $gettok($gettok(%t,3,32),3,44)
      if ($left(%account,1) == $chr(35)) { !var %account = $right(%account,-1) }
      !var %alias = $gettok(%t,4-,32)
      if ( $chanlevexec.lower($nick) == %nick ) && ( %account == $1 ) && ( %chan == $left($6,-1) ) {
        %alias %rnick %chan user $gettok($gettok(%t,3,32),3,44) 0
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  ; unknown channel
  elseif (Unknown channel == $1-2) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan unknownchannel
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }

  ; no access
  elseif (Sorry, you do not have permission to view/change user flags on == $1-11) && ($hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))) {
    !var %items = $hget($+(chanlevexec.queue.,$cid,.item),$chanlevexec.lower($nick))
    !var %x = 1
    while (%x <= $numtok(%items,32)) {
      !var %t = $hget($+(chanlevexec.queue.,$cid,.item),$gettok(%items,%x,32))
      !var %nick = $gettok(%t,1,32)
      if ($chanlevexec.lower($nick) == %nick) {
        !var %rnick = $gettok(%t,2,32)
        !var %chan = $gettok($gettok(%t,3,32),1,44)
        !var %alias = $gettok(%t,4-,32)
        %alias %rnick %chan noaccess
        !hdel $+(chanlevexec.queue.,$cid,.item) $gettok(%items,%x,32)
      }
      !unset %t
      !inc %x
    }
    !hdel $+(chanlevexec.queue.,$cid,.item) $chanlevexec.lower($nick)
    if ($hget($+(chanlevexec.queue.,$cid,.item),0).item <= 1) {
      !hfree $+(chanlevexec.queue.,$cid,.item)
    }
    chanlevexec.disable
    !haltdef
  }
}

; end of '#chanlevexec' group
#chanlevexec end

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC.LOWER ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $chanlevexec.lower(nick/chan)
alias -l chanlevexec.lower {

  ; on IRC these chars are upper(lower) case of eachother: { = [, } = ], | = \, ~ = ^
  ; so here we replace them to make sure we compare the right things right
  !return $replace($1,$chr(123),$chr(91),$chr(125),$chr(93),$chr(124),$chr(92),$chr(126),$chr(94))
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC.QUEUE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $1 = table, $2- = thing
alias -l chanlevexec.queue {

  ; there is a 2nd parameter and it is not already in the queue
  if ($2 != $null) && ((!$hfind($1,$2-)) || ($hfind($1,$2-).data == 0)) {

    ; increase item 'last'
    !hinc -m $1 last

    ; add mode '$2-' to the hashtable with item name that 'last' has
    !hadd -m $1 $hget($1,last) $2-
  }

  ; called as identifier ($alias) and propertie is next ($alias().next) and hash table '$1' exists
  elseif ($isid) && ($prop == next) && ($hget($1)) {

    ; increase item 'first'
    !hinc -m $1 first

    ; 'first' is smaller or equal to 'last'
    if ($hget($1,first) <= $hget($1,last)) {

      ; store next item in var '%next'
      !var %next = $hget($1,$hget($1,first))

      ; delete this item from the hashtable
      !hdel $1 $hget($1,first)

      ; this is the last item
      if ($hget($1,first) >= $hget($1,last)) {

        ; free the hash table
        !hfree $1
      }

      ; return '%next'
      !return %next
    }
  }

  ; called as identifier ($alias) and propertie is size ($alias().size)
  elseif ($isid) && ($prop == size) {

    ; decrease number of items with 1, (1 item in queue, and last is there)
    !return $iif($calc($hget($1,0).item -1) >= 0,$ifmatch,0)
  }

  ; called as identifier ($alias) and propertie is clear ($alias().clear)
  elseif ($isid) && ($prop == clear) {

    ; free hashtables that match $1
    !hfree -w $1
  }
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC.DUMP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l chanlevexec.dump {

  ; set the next item
  !var %next = $chanlevexec.queue($+(chanlevexec.queue.,$cid)).next
  !var %n = $gettok(%next,1,32)
  !var %c = $gettok($gettok(%next,2,32),1,44)
  !var %b = $gettok($gettok(%next,2,32),2,44)
  !var %a = $gettok($gettok(%next,2,32),3,44)

  if (%b == -q) || (%b == -) {

    ; send a ping (for Q), which will be replied with, and then we know the next message(s) are from the chanlev request
    .!msg %n $+($chr(1),PING) chanlevexec $+(%c,$chr(1))
  }

  if (%b == -l) || (%b == -) {

    ; send a help command, same as above (but for L)
    .!msg %n HELP chanlevexec %c
  }

  ; send a chanlev request
  .!msg %n CHANLEV %c %a

  ; enable the group
  .!enable #chanlevexec

  ; there are items left in the queue
  if ($chanlevexec.queue($+(chanlevexec.queue.,$cid)).size > 0) {

    ; start a timer to start this alias again
    .!timer $+ $cid $+ .chanlevexec 1 $$chanlevexec.restart chanlevexec.dump
  }
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RAW 401 NO SUCH NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; raw 401 <you> <nick> :No such nick
raw 401:& & No such nick*:{
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS CHANLEVEXEC.DISABLE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; this alias will only disable the group '#chanlevexec' if it is nolonger needed (checks all connections)
alias -l chanlevexec.disable {

  ; set a var
  !var %x = 1

  ; loop through all connection id's
  while (%x <= $scid(0)) {

    ; there is 1 item in the 'item' queue
    if ($hget($+(chanlevexec.queue.,$scid(%x),.item),0).item == 1) {

      ; free the hash table
      !hfree $+(chanlevexec.queue.,$scid(%x),.item)
    }

    ; more then 1 item in the 'item' queue
    elseif ($hget($+(chanlevexec.queue.,$scid(%x),.item),0).item > 1) {

      ; stop
      !return
    }

    ; increase '%x' and go on to the next connection id
    !inc %x
  }

  ; disable the '#chanlevexec' group
  .!disable #chanlevexec
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:disconnect: {

  ; check if the 'item' hash table exist
  if ($hget($+(chanlevexec.queue.,$cid,.item))) {

    ; free the hash table
    !hfree $+(chanlevexec.queue.,$cid,.item)
  }

  ; clear the queue
  $chanlevexec.queue($+(chanlevexec.queue.,$cid)).clear

  ; disable the '#chanlevexec' group
  chanlevexec.disable
}




; example script
; VERY SIMPLE AND NOT VERY SECURE, YOU CAN EASILY REMOVE YOURSELF WITH THIS IF YOU ARE MASTER OR LOWER!
; also may cause excess flood, enable mirc's flood protection or write a better script :)
; /masschanlev <nick> <channel> <+/-flags>
alias masschanlev {
  if (!$1) {
    !echo -a /masschanlev <nick> <channel> <+/-flags>
  }
  elseif (n !isin $3) && ($istok(+ -,$left($3,1),32)) && ($remove($3,+,-,a,b,m,o,t,v,g) == $null) && ($left($2,1) == $chr(35)) {
    chanlevexec $1-2 masschanlev.do $3
  }
}

; <changes> <nick> <channel> <account> <flags>
alias -l masschanlev.do {
  if ($istok(end of chanlev.unknown channel.no access,$4-,46)) {
    !echo -a $3-
  }
  elseif ($remove($1,+,-,a,b,m,o,t,v,g) == $null) {
    .!msg $2 CHANLEV $3 $+($chr(35),$4) $1
  }
}





; end