~ MODERATION.TCL || Cyber-TCL.com by Platine ~

zarkox · 21/03/2014 06:16:51

Ami de l'entre nuit / jour, b'sjoiur ! ( un mix de bonjour bonsoir quoi ).

Donc ce qui m'amène à vous aujourd'hui, c'est une erreur qui revient souvent et qui fait planter le bot en cas de rehash ( ou restart ) sur ce tcl.
Il tourne très bien un certain temps, et tout d'un coup lorsque quelqu'un parle j'ai ça ( je mixe ce que je vois sur le salon et le rendu en PL ) :

[04:25:47] ‹janus57› Je regarde toujours les membres du staff du site que je contact en général, cela évite bien des suprise et permet de se renseigner grâce à "Big Brother"
[04:25:48] ‹(Protect`› [03:33:08] Tcl error in script for 'timer28253':
[04:25:48] ‹(Protect`› [03:33:08] unmatched open quote in list
[04:27:16] ‹(Protect`› [03:34:36] Tcl error [moderation]: unmatched open quote in list
[04:27:16] ‹janus57› Au passage je n'est pas que /ctcp version

[04:54:30] ‹janus57› bla bla bla
[04:54:30] ‹(Protect`› [04:01:50] Tcl error [moderation]: unmatched open quote in list

[04:28:28] ‹janus57› pwet boudou hihi
[04:28:28] ‹(Protect`› [03:35:48] Tcl error [moderation]: unmatched open quote in list

etc etc ... donc à partir d'un moment, ça donne ça ! j'ai regardé mais pffffffff je ne m'en sors vraiment pas du coup, je préfère demander conseil et de l'aide.
En espérant trouver une réponse, je vous souhaite une excellente journée

Code: TCL

      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
      # ~ MODERATION.TCL || Cyber-TCL.com by Platine ~ #
      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
 
      ###################################################
      #                                                 #
      #          DEBUT DE LA CONFIGURATION              #
      #                                                 #
      ###################################################
 
 
      #  MAJUSCULES :
 
 
      #-> Expiration de la detection pour les majuscules (en seconde) ?
      set expiration(majuscule) "180"
 
      #-> Nombre de majuscule à détecter ?
      set detect(majuscule) "15"
 
      #-> Combien d'avertissement avant le kick ?
      set avert(majuscule) "1"
 
      #-> Message d'avertissement
      set msg(majuscule) "4Attention! Merci de ne pas ecrire en MAJUSCULE"
 
      #-> Raison du kick
      set kick(majuscule) "La répétition de caractères en majuscule signifie crier sur un t'Chat. Exclus 10 minutes."
 
 
      #  REPETITION :
 
 
      #-> Expiration de la detection pour les repetitions (en seconde) ?
      set expiration(repetition) "90"
 
      #-> Nombre de repetition à détecter ?
      set detect(repetition) "1"
 
      #-> Combien d'avertissement avant le kick ?
      set avert(repetition) "1"
 
      #-> Message d'avertissement
      set msg(repetition) "4Attention! surveillez vos répétitions! La prochaine fois vous serez Expulsé!"
 
      #-> Raison du kick
      set kick(repetition) "Répéter plusieurs fois la même chose signifie flooder sur un t'Chat. Exclus 10 minutes."
 
 
      #  LANGAGE :
 
 
      #-> Expiration de la detection pour le langage (en seconde) ?
      set expiration(mot) "90"
 
      #-> Combien d'avertissement avant le kickban ?
      set avert(mot) "1"
 
      #-> Message d'avertissement
      set msg(mot) "4Attention! surveillez votre langage! La prochaine fois vous serez Expulsé!"
 
      #-> Raison du kickban
      set kick(mot) "Les insultes et autres mots injurieux sont interdit. Merci de rester polis et courtois. Exclus 10 minutes."
 
 
      #  SPAM :
 
 
      #-> Expiration de la detection pour le spam (en seconde) ?
      set expiration(spam) "1800"
 
      #-> Combien d'avertissement avant le kickban ?
      set avert(spam) "1"
 
      #-> Message d'avertissement
      set msg(spam) "4Attention! Evitez vos Publicités! La prochaine fois vous serez Expulsé!"
 
      #-> Raison du kickban
      set kick(spam) "Il est strictement interdit de faire de la pub sans l'accord d'un Opérateur. Exclus 10 minutes."
 
 
      #  NICK :
 
 
      #-> Raison du kickban
      set kick(nick) "Veuillez modifier votre pseudo ou celui que vous venez de prendre !"
 
 
      #  NOTICECHAN :
 
 
      #-> Raison du kickban
      set kick(notice) "Il est strictement interdit d'envoyer des notices au salon sans l'accord d'un Opérateur. Exclus 10 minutes."
 
 
      #  BLACKLIST :
 
 
      #-> Raison du kickban
      set kick(blacklist) "Vous n'êtes pas le bienvenue sur ce salon !"
 
 
      #  LIMITE :
 
      #-> Activer la limite ? (0=non 1=oui)
      set limite(active) "0"
 
 
      #-> Puissance de la limite
      set limite(puissance) "5"
 
 
      #-> Temp de rehash pour la limite
      set limite(temp) "120"
 
 
      #  ANTI/MASSFLOOD :
 
 
      #-> Nombre de message lors d'une détection mass/flood
      set mass(flood) "6"
 
      #-> Temp de rehash pour la remise à 0 du mass/flood (en seconde)
      set mass(rehashflood) "2"
 
      #-> Temp pour le retrait du +m (en minute)
      set mass(retraitm) "1"
 
 
      #  ANTI/MASSJOIN :
 
 
      #-> Nombre de join lors d'une détection mass/join
      set mass(join) "5"
 
      #-> Temp de rehash pour la remise à 0 du mass/join (en seconde)
      set mass(rehashjoin) "3"
 
      #-> Temp pour le retrait du +i (en minute)
      set mass(retraiti) "1"
 
 
      ###################################################
      #                                                 #
      #              FIN DE CONFIGURATION               #
      #                                                 #
      ###################################################
 
      ############
      # VARIABLE #
      ############
 
      set fichier(modchan) "modchan.txt"
      set fichier(modmot) "modmot.txt"
      set fichier(modspam) "modspam.txt"
      set fichier(modnick) "modnick.txt"
      set fichier(blacklist) "blacklist.txt"
      set fichier(protect) "protect.txt"
 
      ###########
      # FICHIER #
      ###########
 
      set fichiers [list $::fichier(modchan) $::fichier(modmot) $::fichier(modspam) $::fichier(modnick) $::fichier(blacklist) $::fichier(protect)]
      foreach txt $fichiers {
           if ![file exists $txt] {
               close [open $txt w+]
           }
      }
 
      #Enregistrement des chan à modérer :
 
      bind dcc n moderation dcc:moderation
      proc dcc:moderation {hand idx arg} {
              putdcc $idx "Commandes du tcl de modération by Platine (http://www.cyber-tcl.com) :"
              putdcc $idx ""
              putdcc $idx "Gestion des chans à modérer  :"
              putdcc $idx "\002.modchan\002   14 (Permet de lister des chans modérer)"
              putdcc $idx "\002.+modchan\002  <#chan>14 (Permet d'ajouter un chan à modérer)"
              putdcc $idx "\002.-modchan\002  <#chan>14 (Permet de supprimer un chan à modérer)"
              putdcc $idx ""
              putdcc $idx "Gestion des mots interdit  :"
              putdcc $idx "\002.modmot\002    14 (Permet de lister les mots interdit)"
              putdcc $idx "\002.+modmot\002   <mot>14 (Permet d'ajouter un mot interdit)"
              putdcc $idx "\002.-modmot\002   <mot>14 (Permet de supprimer un mot interdit)"
              putdcc $idx ""
              putdcc $idx "Gestion des spams interdit :"
              putdcc $idx "\002.modspam\002   14 (Permet de lister les spams interdit)"
              putdcc $idx "\002.+modspam\002  <spam>14 (Permet d'ajouter un spam interdit)"
              putdcc $idx "\002.-modspam\002  <spam>14 (Permet de supprimer un spam interdit)"
              putdcc $idx ""
              putdcc $idx "Gestion des nicks interdit  :"
              putdcc $idx "\002.modnick\002   14 (Permet de lister les nicks interdit)"
              putdcc $idx "\002.+modnick\002  <nick>14 (Permet d'ajouter un nick interdit)"
              putdcc $idx "\002.-modnick\002  <nick>14 (Permet de supprimer un nick interdit)"
              putdcc $idx ""
              putdcc $idx "Gestion de la blacklist  :"
              putdcc $idx "\002.blacklist\002         14 (Permet de lister la blacklist)"
              putdcc $idx "\002.+blacklist\002        <host>14 (Permet d'ajouter un host à la blacklist)"
              putdcc $idx "\002.-blacklist\002        <host>14 (Permet de supprimer un host à la blacklist)"
              putdcc $idx ""
              putdcc $idx "Gestion de la protection contre la modération  :"
              putdcc $idx "\002.protect\002   14 (Permet de lister des hosts protégés)"
              putdcc $idx "\002.+protect\002  <host>14 (Permet d'ajouter un host protégé)"
              putdcc $idx "\002.-protect\002  <host>14 (Permet de supprimer un host protégé)"
              putdcc $idx ""
              putdcc $idx "Fin de la liste des commandes du tcl de modération."
      }
 
      #Enregistrement des chan à modérer :
 
      bind dcc n +modchan +modchan
      bind dcc n -modchan -modchan
      bind dcc n modchan modchan
 
 
      proc +modchan {hand idx arg} {
      set chan [lindex $arg 0]
      if {$chan eq ""||[string index $chan 0] ne "#"} {putdcc $idx "\002Erreur :\002 .+modchan <#chan>"; return}
      if {[verify:b $::fichier(modchan) $chan]} {putdcc $idx "\002Erreur :\002 $chan est déjà modérer.";return}
      putdcc $idx "\002+modchan :\002 $chan a été mis dans la liste."
      ajouter:donnee $::fichier(modchan) $chan
      }
 
      proc -modchan {hand idx arg} {
      set chan [lindex $arg 0]
      if {$chan eq ""||[string index $chan 0] ne "#"} {putdcc $idx "\002Erreur :\002 .-modchan <#chan>"; return}
      if {![verify:b $::fichier(modchan) $chan]} {putdcc $idx "\002Erreur :\002 Le chan $chan n'est pas modérer.";return}
      putdcc $idx "\002-modchan :\002 $chan n'est plus modérer."
      effacer:donnee $::fichier(modchan) $chan
      }
 
      proc modchan {hand idx arg} {
      putdcc $idx "---\002 LISTE DES CHANS MODÉRER \002---";
      liste:donnee $idx $::fichier(modchan)
      }
 
      #Enregistrement des mots interdit à modérer :
 
      bind dcc n +modmot +modmot
      bind dcc n -modmot -modmot
      bind dcc n modmot modmot
 
      proc +modmot {hand idx arg} {
      set mot [lindex $arg 0]
      if {$mot eq ""} {putdcc $idx "\002Erreur :\002 .+modmot <mot>"; return}
      if {[verify:b $::fichier(modmot) $mot]} {putdcc $idx "\002Erreur :\002 $mot est déjà enregistré.";return}
      putdcc $idx "\002+modmot :\002 $mot a été mis dans la liste."
      ajouter:donnee $::fichier(modmot) $mot
      }
 
      proc -modmot {hand idx arg} {
      set mot [lindex $arg 0]
      if {$mot eq ""} {putdcc $idx "\002Erreur :\002 .-modmot <mot>"; return}
      if {![verify:b $::fichier(modmot) $mot]} {putdcc $idx "\002Erreur :\002 Le mot $mot n'est pas enregistré.";return}
      putdcc $idx "\002-modmot :\002 $mot n'est plus enregistré."
      effacer:donnee $::fichier(modmot) $mot
      }
 
      proc modmot {hand idx arg} {
      putdcc $idx "---\002 LISTE DES MOTS INTERDIT \002---";
      liste:donnee $idx $::fichier(modmot)
      }
 
      #Enregistrement des spams à modérer :
 
      bind dcc n +modspam +modspam
      bind dcc n -modspam -modspam
      bind dcc n modspam modspam
 
      proc +modspam {hand idx arg} {
      set spam [lindex $arg 0]
      if {$spam eq ""} {putdcc $idx "\002Erreur :\002 .+modspam <spam>";putdcc $idx "\002Exemple :\002 .+modspam *.*.com*"; return}
      if {[verify:b $::fichier(modspam) $spam]} {putdcc $idx "\002Erreur :\002 $spam est déjà enregistré.";return}
      putdcc $idx "\002+modspam :\002 $spam a été mis dans la liste."
      ajouter:donnee $::fichier(modspam) $spam
      }
 
      proc -modspam {hand idx arg} {
      set spam [lindex $arg 0]
      if {$spam eq ""} {putdcc $idx "\002Erreur :\002 .-modspam <spam>"; return}
      if {![verify:b $::fichier(modspam) $spam]} {putdcc $idx "\002Erreur :\002 Le spam $spam n'est pas enregistré.";return }
      putdcc $idx "\002-modspam :\002 $spam n'est plus enregistré."
      effacer:donnee $::fichier(modspam) $spam
      }
 
      proc modspam {hand idx arg} {
      putdcc $idx "---\002 LISTE DES SPAMS \002---";
      liste:donnee $idx $::fichier(modspam)
      }
 
      #Enregistrement des nicks à modérer :
 
      bind dcc n +modnick +modnick
      bind dcc n -modnick -modnick
      bind dcc n modnick dcc:modnick
 
      proc +modnick {hand idx arg} {
      set nick [lindex $arg 0]
      if {$nick eq ""} {putdcc $idx "\002Erreur :\002 .+modnick <nick>";putdcc $idx "\002Exemple :\002 .+modnick *.*.com*"; return}
      if {[verify:b $::fichier(modnick) $nick]} {putdcc $idx "\002Erreur :\002 $nick est déjà enregistré.";return}
      putdcc $idx "\002+modnick :\002 $nick a été mis dans la liste."
      ajouter:donnee $::fichier(modnick) $nick
      }
 
      proc -modnick {hand idx arg} {
      set nick [lindex $arg 0]
      if {$nick eq ""} {putdcc $idx "\002Erreur :\002 .-modnick <nick>"; return}
      if {![verify:b $::fichier(modnick) $nick]} {putdcc $idx "\002Erreur :\002 Le nick $nick n'est pas enregistré.";return }
      putdcc $idx "\002-modnick :\002 $nick n'est plus enregistré."
      effacer:donnee $::fichier(modnick) $nick
      }
 
      proc dcc:modnick {hand idx arg} {
      putdcc $idx "---\002 LISTE DES NICKS \002---";
      liste:donnee $idx $::fichier(modnick)
      }
 
      #Enregistrement des blacklists modérer :
 
      bind dcc n +blacklist +blacklist
      bind dcc n -blacklist -blacklist
      bind dcc n blacklist dcc:blacklist
 
      proc +blacklist {hand idx arg} {
      set host [lindex $arg 0]
      if {$host eq ""} {putdcc $idx "\002Erreur :\002 .+blacklist <host>";putdcc $idx "\002Exemple :\002 .+blacklist toto*!*@*.ru"; return}
      if {[verify:b $::fichier(blacklist) $host]} {putdcc $idx "\002Erreur :\002 $host est déjà enregistré.";return}
      putdcc $idx "\002+blacklist :\002 $host a été mis dans la liste."
      ajouter:donnee $::fichier(blacklist) $host
      }
 
      proc -blacklist {hand idx arg} {
      set host [lindex $arg 0]
      if {$host eq ""} {putdcc $idx "\002Erreur :\002 .-blacklist <host>"; return}
      if {![verify:b $::fichier(blacklist) $host]} {putdcc $idx "\002Erreur :\002 Le host $host n'est pas enregistré.";return }
      putdcc $idx "\002-blacklist :\002 $host n'est plus enregistré."
      effacer:donnee $::fichier(blacklist) $host
      }
 
      proc dcc:blacklist {hand idx arg} {
      putdcc $idx "---\002 LISTE DE LA BLACKLIST \002---";
      liste:donnee $idx $::fichier(blacklist)
      }
 
      #Enregistrement d'host à ne pas modérer :
 
      bind dcc n +protect +protect
      bind dcc n -protect -protect
      bind dcc n protect protect
 
      proc +protect {hand idx arg} {
      set host [lindex $arg 0]
      if {$host eq ""} {putdcc $idx "\002Erreur :\002 .+protect <host>";putdcc $idx "\002Exemple :\002 .+protect platine*!*@*"; return}
      if {[verify:b $::fichier(protect) $host]} {putdcc $idx "\002Erreur :\002 $host est déjà enregistré.";return}
      putdcc $idx "\002+protect :\002 Le host $host est maintenant protégé."
      ajouter:donnee $::fichier(protect) $host
      }
 
      proc -protect {hand idx arg} {
      set host [lindex $arg 0]
      if {$host eq ""} {putdcc $idx "\002Erreur :\002 .-protect <host>"; return}
      if {![verify:b $::fichier(protect) $host]} {putdcc $idx "\002Erreur :\002 Le host $host n'est pas enregistré.";return }
      putdcc $idx "\002-protect :\002 Le host $host n'est plus protégé."
      effacer:donnee $::fichier(protect) $host
      }
 
      proc protect {hand idx arg} {
      putdcc $idx "---\002 LISTE DES PROTÉGÉ CONTRE LA MODERATION \002---";
      liste:donnee $idx $::fichier(protect)
      }
 
      #Modération :
 
      bind pubm - * moderation       
      proc moderation { nick host handle channel arg } {
      global modmajuscule modrepetition modmot modspam avert rpt
      set arg [split $arg]
      set msg [join [lrange [split $arg] 0 end]]
      set hostv $nick!$host
      set userhost [getchanhost $nick]
      set userhost "*!*[string range $userhost [string first @ $userhost] e]"
      regsub -all -- {\003[0-9]{0,2}(,[0-9]{0,2})?|\017|\037|\002|\026|\006|\007} $msg "" msg
      regsub -all -- {\{|\}|\\{|[}{|]}} $msg "" msg
      if {![verify:b $::fichier(modchan) $channel]} {return}
      if {[verify:a $::fichier(protect) $hostv]} {return}
      if {![info exists modmajuscule($host)]} {set modmajuscule($host) 0; utimer $::expiration(majuscule) [list unset modmajuscule($host)]}
      set nombre 0
      foreach x [split $msg {}] {
      if [string match \[A-Z\] $x] {incr nombre}
      }
      if {$nombre > $::detect(majuscule)} {
      incr modmajuscule($host) 1
      if {$::avert(majuscule) < $modmajuscule($host)} {putquick "KICK $channel $nick :$::kick(majuscule)"; set modmajuscule($host) 0; return}
      putquick "NOTICE $nick :$::msg(majuscule)"
      }
      if {[info exists rpt($nick)]} {
      if {[lrange $rpt($nick) 2 end]  eq  "$msg"} {
      set cnt [lindex $rpt($nick) 1]; incr cnt
      set rpt($nick) "[lindex $rpt($nick) 0] $cnt [lrange $rpt($nick) 2 end]"
      if {[lindex $rpt($nick) 1] > $::detect(repetition)} {
      if {![info exists modrepetition($host)]} {set modrepetition($host) 0; utimer $::expiration(repetition) [list unset modrepetition($host)]}
      incr modrepetition($host) 1
      if {$::avert(repetition) < $modrepetition($host)} {putquick "MODE $channel +b $userhost";putquick "KICK $channel $nick :$::kick(repetition)"; set modrepetition($host) 0; return}
      putquick "NOTICE $nick :$::msg(repetition)"
      unset rpt($nick)
      }
      } else {set rpt($nick) "[expr [clock seconds] + 10] 1 $msg"}
      } else {set rpt($nick) "[expr [clock seconds] + 10] 1 $msg"}
      if {[verify:a $::fichier(modmot) $msg]} {
      if {![info exists modmot($host)]} {set modmot($host) 0; utimer $::expiration(mot) [list unset modmot($host)]}
      incr modmot($host) 1
      if {$::avert(mot) < $modmot($host)} {putquick "MODE $channel +b $userhost";putquick "KICK $channel $nick :$::kick(mot)"; set modmot($host) 0; return}
      putquick "NOTICE $nick :$::msg(mot)"
      }
      if {[verify:a $::fichier(modspam) $msg]} {
      if {![info exists modspam($host)]} {set modspam($host) 0; utimer $::expiration(spam) [list unset modspam($host)]}
      incr modspam($host) 1
      if {$::avert(spam) < $modspam($host)} {putquick "MODE $channel +b $userhost";putquick "KICK $channel $nick :$::kick(spam)"; set modspam($host) 0; return}
      putquick "NOTICE $nick :$::msg(spam)"
      }
      }
 
      bind join - "*" modnick
      proc modnick { nick uhost handle channel } {
      set hostv $nick!$uhost
      if {[verify:a $::fichier(protect) $hostv]} {return}
      if {[string equal -nocase $nick $::botnick]} {return}
      if {![verify:b $::fichier(modchan) $channel]} {return}
      if {![verify:a $::fichier(modnick) $nick]} {return}
      putquick "MODE $channel +b $nick*!*"
      putquick "KICK $channel $nick :$::kick(nick)"
      }
 
      bind nick - * modnicksuite
      proc modnicksuite { nick uhost handle chan newnick } {
      set hostv $nick!$uhost
      if {[verify:a $::fichier(protect) $hostv]} {return}
      if {[string equal -nocase $nick $::botnick]} {return}
      if {![verify:b $::fichier(modchan) $chan]} {return}
      if {![verify:a $::fichier(modnick) $nick]} {return}
      putquick "MODE $chan +b $newnick*!*"
      putquick "KICK $chan $newnick :$::kick(nick)"
      }
 
      bind join - "*" modblacklist
      proc modblacklist { nick host handle channel } {
      set userhost [getchanhost $nick]
      set userhost "*!*[string range $userhost [string first @ $userhost] e]"
      set hostv $nick!$host
      if {[verify:a $::fichier(protect) $hostv]} {return}
      if {[string equal -nocase $nick $::botnick]} {return}
      if {![verify:b $::fichier(modchan) $channel]} {return}
      if {![verify:a $::fichier(blacklist) $hostv]} {return}
      putquick "MODE $channel +b $userhost"
      putquick "KICK $channel $nick :$::kick(blacklist)"
      }
 
      bind notc - * noticechan
      proc noticechan {nick host handle text chan} {
      set userhost [getchanhost $nick]
      set userhost "*!*[string range $userhost [string first @ $userhost] e]"
      set hostv $nick!$host
      if {[verify:a $::fichier(protect) $hostv]} {return}
      if {![verify:b $::fichier(modchan) $chan]} {return}
      putquick "MODE $chan +b $userhost"
      putquick "kick $chan $nick :$::kick(notice)"
      }
 
      proc zerotime {} {
              global rpt
              foreach nick [array names rpt] {
                      if {[lindex $rpt($nick) 0] < [clock seconds]} {unset rpt($nick)}
              }
              utimer 5 zerotime
      }
      foreach t [utimers] {
              if {[lindex $t 1]  eq  "zerotime"} {killutimer [lindex $t 2]}
      }
      zerotime
 
      bind join -|- "*" join_chargelimite
      proc join_chargelimite { nick host hand chan } {
      if {$::limite(active) eq 0} {return}
      set stop 0
      if {[string equal -nocase $nick $::botnick]} {
      foreach ti [utimers] {if {[lindex $ti 1] eq "limite"} {set stop 1}}
      if {$stop eq 0} {timer 2 limite}
      unset stop
      }
      }
 
      proc limite {} {
      if {$::limite(active) eq 0} {return}
      set liste [open $::fichier(modchan) r]
      while {![eof $liste]} {
      gets $liste a
      if {$a ne ""} {
      set numlimite 0
      foreach nombre [chanlist $a] {
      incr numlimite 1
      set chiffre [expr $numlimite + $::limite(puissance)]
      }
      putquick "MODE $a +l $chiffre"
      }
      }
      close $liste
      utimer $::limite(temp) limite
      }
 
      bind pubm - * massflood
      proc massflood { nick uhost handle chan arg } {
      global massflood
      set hostv $nick!$uhost
      if {[verify:a $::fichier(protect) $hostv]} {return}
      if {![verify:b $::fichier(modchan) $chan]} {return}
      if {![info exists massflood($chan)]} {set massflood($chan) 0 ;utimer $::mass(rehashflood) [list unset massflood($chan)]}
      incr massflood($chan) 1
      if {$massflood($chan) eq "$::mass(flood)"} {putquick "mode $chan +m";timer $::mass(retraitm) [list putquick "mode $chan -m"]}
      }
 
      bind join - * massjoin
      proc massjoin {nick host hand chan} {
      global massjoin
      set hostv $nick!$host
      if {[verify:a $::fichier(protect) $hostv]} {return}
      if {![verify:b $::fichier(modchan) $chan]} {return}
      if {![info exists massjoin($chan)]} {set massjoin($chan) 0 ;utimer $::mass(rehashjoin) [list unset massjoin($chan)]}
      incr massjoin($chan) 1
      if {$massjoin($chan) eq "$::mass(join)"} {putquick "mode $chan +i";timer $::mass(retraiti) [list putquick "mode $chan -i"]}
      }
 
 
      ######################
      # TRAITEMENT FICHIER #
      ######################
 
 
      proc verify:a {fichierss arg} {
      set liste [open $fichierss r]
      while {![eof $liste]} {
      gets $liste a
      regsub -all -- {\{|\}|\\{|[}{|]}} $a "" a
      if {$a ne ""} {if {[string match -nocase *$a* $arg]} {close $liste;return 1}}
      }
      close $liste
      return 0
      }
 
      proc verify:b {fichierss arg} {
      set liste [open $fichierss r]
      while {![eof $liste]} {
      gets $liste a
      regsub -all -- {\{|\}|\\{|[}{|]}} $a "" a
      if {$a ne ""} {if {[string equal -nocase $a $arg]} {close $liste;return 1}}
      }
      close $liste
      return 0
      }
 
      proc ajouter:donnee {fichierss arg} {
      set liste [open $fichierss a]
      puts $liste "$arg"             
      close $liste
      }
 
      proc effacer:donnee {fichierss arg} {
      set fichier(back) "$fichierss.back"
      set load [open $fichier(back) w+]
      close $load
      set liste [open $fichierss r]
      set bcloseback [open $fichier(back) a]
      while {![eof $liste]} {
      gets $liste a
      if {$a ne ""} {if {[string equal -nocase [lindex $a 0] $arg]} {} else {puts $bcloseback "[lindex $a]"}}
      }
      close $liste
      close $bcloseback
      file delete $fichierss
      file rename $fichier(back) $fichierss
      }
 
      proc liste:donnee {idx fichierss} {
      set liste [open $fichierss r]
      set num 0
      while {![eof $liste]} {
      gets $liste a
      if {$a ne ""} {incr num 1;putdcc $idx "(\002$num\002) [lindex $a 0]"}
      }
      if {$num eq "0"} { putdcc $idx "Aucun enregistrement." }
      putdcc $idx "---\002 FIN DE LA LISTE \002--- Total (\002$num\002)";
      close $liste
      unset num
      }

merci @Harakiri

Dernière modification par zarkox (21/03/2014 09:23:31)

SaiTek · 23/03/2014 02:11:17

Hello,

Peut-être une piste: http://www.ircz.fr/viewtopic.php?id=1693

zarkox · 23/03/2014 02:51:10

Bonsoir,

Ce n'est vraiment pas faute d'avoir cherché ( vraiment ) mais grâce à toi, j'ai trouvé la solution.
Si je ne me trompe pas, et si j'ai bien compris, mon problème venait de là :

Code: TCL

regsub -all {\"} $arg {\"} arg

du coup j'ai fais comme ça :

Code: TCL

regsub -all -- {\{|\}|\\{|[}{|]}{\"}} $msg "" msg

Je verrais bien sous quelques jours si le problème revient, mais il me semble que c'est bon.

Merci beaucoup

Forum d'aide IRC - IRCz.fr

Menus

Top posteurs

Statistiques

Partenaires

#1 21/03/2014 06:16:51

~ MODERATION.TCL || Cyber-TCL.com by Platine ~

#2 23/03/2014 02:11:17

Re : ~ MODERATION.TCL || Cyber-TCL.com by Platine ~

#3 23/03/2014 02:51:10

Re : ~ MODERATION.TCL || Cyber-TCL.com by Platine ~

Pied de page des forums