TCL de modération

[Julien23]

bonsoir à tous.

je me permet de venir ici afin de m'expliqué et voir si il est possible de corrigé l'erreur qui m'agace en party line de mon eggdrop je suis totalement novice dans le millieu du tcl :x et j'comprend pas d'ou cela puisse venir .
les erreurs party line :

tclcopier

Tcl error [moderation]: unmatched open quote in list

et celle ci:

tclcopier

Tcl error [moderation]: list element in quotes followed by "je" instead of space

voici le code "moderation"

tclcopier

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)} {putserv "KICK $channel $nick :$::kick(majuscule)"; set modmajuscule($host) 0; return}
putserv "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)} {putserv "KICK $channel $nick :$::kick(repetition)"; set modrepetition($host) 0; return}
putserv "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)} {putserv "MODE $channel +b $userhost";putserv "KICK $channel $nick :$::kick(mot)"; set modmot($host) 0; return}
putserv "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)} {putserv "MODE $channel +b $userhost";putserv "KICK $channel $nick :$::kick(spam)"; set modspam($host) 0; return}
putserv "NOTICE $nick :$::msg(spam)"
}
}

merci beaucoup de votre aides aportés.

[CrazyCat]

Désolé pour le retard. Je pense qu'il nous faudrait aussi tes variables globales (modmajuscule modrepetition modmot modspam avert rpt).
Et aussi savoir à quel moment (suite à quel déclenchement) tu as cette erreur.

[Asylum]

Bonsoir,

Je vous join le TcL complet (sans le bind dcc Xhelp). J'ai les mêmes erreurs annoncées en Partie Line. Ces erreurs sont constantes. Donc je ne peux pas vous dire à quel moment celles ci sont déclenchées.
Merci de votre aide.
(TcL de Platine)

tclcopier

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
# ~ 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) "10"

#-> Combien d'avertissement avant le kick ?
set avert(majuscule) "2"

#-> Message d'avertissement
set msg(majuscule) "Attention! Merci de ne pas ecrire en MAJUSCULE"

#-> Raison du kick
set kick(majuscule) "Pas la peine de crier on à compris!"

 
#  REPETITION :

 
#-> Expiration de la detection pour les repetitions (en seconde) ?
set expiration(repetition) "900"

#-> Nombre de repetition à détecter ?
set detect(repetition) "2"

#-> Combien d'avertissement avant le kick ?
set avert(repetition) "1"

#-> Message d'avertissement
set msg(repetition) "Attention! surveillez vos répétitions! La prochaine fois vous serez Expulsé!"

#-> Raison du kick
set kick(repetition) "Pas de repetition !"

 
#  LANGAGE :

 
#-> Expiration de la detection pour le langage (en seconde) ?
set expiration(mot) "300"

#-> Combien d'avertissement avant le kickban ?
set avert(mot) "1"

#-> Message d'avertissement
set msg(mot) "Attention! surveillez votre langage! La prochaine fois vous serez Expulsé !"

#-> Raison du kickban
set kick(mot) "Exclu 20 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) "Attention! Evitez vos Publicités! La prochaine fois vous serez Expulsé!"

#-> Raison du kickban
set kick(spam) "Exclu pour pub !"

 
#  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) "Veuillez ne pas faire de notice chan !"

 
#  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) "1"

 
#-> Puissance de la limite
set limite(puissance) "2"

 
#-> 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) "2"

 
#  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) "2"

 
###################################################
#                                                 #
#              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 +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)} {putserv "KICK $channel $nick :$::kick(majuscule)"; set modmajuscule($host) 0; return}
putserv "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)} {putserv "KICK $channel $nick :$::kick(repetition)"; set modrepetition($host) 0; return}
putserv "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)} {putserv "MODE $channel +b $userhost";putserv "KICK $channel $nick :$::kick(mot)"; set modmot($host) 0; return}
putserv "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)} {putserv "MODE $channel +b $userhost";putserv "KICK $channel $nick :$::kick(spam)"; set modspam($host) 0; return}
putserv "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}
putserv "MODE $channel +b $nick*!*"
putserv "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}
putserv "MODE $chan +b $newnick*!*"
putserv "KICK $chan $newnick :$::kick(nick)"
}
 
bind join - "*" modblacklist
proc modblacklist { nick host handle channel } { 
set hostv $nick!$host
set userhost [getchanhost $nick]
set userhost "*!*[string range $userhost [string first @ $userhost] e]"
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}
putserv "MODE $channel +b $userhost"
putserv "KICK $channel $nick :$::kick(blacklist)"
}
 
bind notc - * noticechan
proc noticechan {nick host handle text chan} {
set hostv $nick!$host
if {[verify:a $::fichier(protect) $hostv]} {return}
if {![verify:b $::fichier(modchan) $chan]} {return}
putserv "MODE $chan +b $userhost"
putserv "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)]
}
putserv "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)"} {putserv "mode $chan +m";timer $::mass(retraitm) [list putserv "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)"} {putserv "mode $chan +i";timer $::mass(retraiti) [list putserv "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
}

[fedora]

bonjour ,

il me semble qu'il y à cet erreur

Tcl error [moderation]: extra characters after close-quote

a chaque fois que tu ajoute,surprime et au joins d'un pseudo qui est ou non dans la blackliste,il y a aussi cet erreur à chaque changement d'extension de pseudo.

en espérant que cela pourra vous aidée.

cordialement.

[fedora]

il me semble qu'il manque les exceptions mais je suis pas sur.
après à confirmé.

[fedora]

bonjour après avoir testé ce TCL l'erreur

Tcl error [moderation]: extra characters after close-quote

s'affiche quand un user dial sur le général .donc elle s'affiche tout le temps

en espèrent que sa peut aidé Julien ou d'autres personnes.

[fedora]

cela viendrai t'il pas du regsub ?

[Julien23]

Hello ,
désolé pour cette réponse assez tardive j'était assez pris par mon travaille.
merci à tout ceux qui ce sont penché sur le sujet . pour ma par ayant pas réussi à trouvé le beug j'ai totalement virée ce TCL . merci

[aliasangelius]

bonjour voilà la il marchera le tcl.. désolé pas réussi a faire avec les balise donc je joint le fichier directement :)

[Julien23]

bonjour. peut ont savoir quel modification à tu apporter pour résoudre le problème stp ?

[aliasangelius]

bonjour c'est platine lui même qui à apporter les modification
en gros il a corriger notice chan et la blackliste
qui ne fonctionner pas avant ;)

[Julien23]

je vois pas vraiment ce qu'il a apporter en modification,après avoir essayé le TCL qui tu à joins les erreur citer en début du poste sont les même ...

[aliasangelius]

bah moi j'ai absolument aucune erreur avec le tcl..