Vous n'êtes pas identifié(e).

Top posteurs

Statistiques

Partenaires

  • eXolia Hosting
  • Eggdrop.fr

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

zarkox
Nouveau IRCzien
Inscription : 04/03/2014
Messages : 3

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

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 wink

[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 smile


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 smile

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


Le TChat n'attend que vous!
Rejoignez une communauté sympathique. Connectez-vous, c'est totalement gratuit et sans inscription.
http://www.TChat-IRC.com

Hors ligne

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

SaiTek
IRCzien
Inscription : 07/12/2011
Messages : 108

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

Hello,

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

Hors ligne

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

zarkox
Nouveau IRCzien
Inscription : 04/03/2014
Messages : 3

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

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 wink


Le TChat n'attend que vous!
Rejoignez une communauté sympathique. Connectez-vous, c'est totalement gratuit et sans inscription.
http://www.TChat-IRC.com

Hors ligne

Pied de page des forums

502888 visites ( 28 aujourd'hui ) 11 visiteurs en ligne
Copyright © 2004 - 2013 IRCz