Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! #0 0
parray.tclnu [ # parray:
# Print the contents of a global array on stdout.
#
# Copyright (c) 1991-1993 The Regents of the University of California.
# Copyright (c) 1994 Sun Microsystems, Inc.
#
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
proc parray {a {pattern *}} {
upvar 1 $a array
if {![array exists array]} {
return -code error "\"$a\" isn't an array"
}
set maxl 0
set names [lsort [array names array $pattern]]
foreach name $names {
if {[string length $name] > $maxl} {
set maxl [string length $name]
}
}
set maxl [expr {$maxl + [string length $a] + 2}]
foreach name $names {
set nameString [format %s(%s) $a $name]
puts stdout [format "%-*s = %s" $maxl $nameString $array($name)]
}
}
PK ! YV%^ ^ init.tclnu [ # init.tcl --
#
# Default system startup file for Tcl-based applications. Defines
# "unknown" procedure and auto-load facilities.
#
# Copyright (c) 1991-1993 The Regents of the University of California.
# Copyright (c) 1994-1996 Sun Microsystems, Inc.
# Copyright (c) 1998-1999 Scriptics Corporation.
# Copyright (c) 2004 by Kevin B. Kenny. All rights reserved.
#
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# This test intentionally written in pre-7.5 Tcl
if {[info commands package] == ""} {
error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
}
package require -exact Tcl 8.6.8
# Compute the auto path to use in this interpreter.
# The values on the path come from several locations:
#
# The environment variable TCLLIBPATH
#
# tcl_library, which is the directory containing this init.tcl script.
# [tclInit] (Tcl_Init()) searches around for the directory containing this
# init.tcl and defines tcl_library to that location before sourcing it.
#
# The parent directory of tcl_library. Adding the parent
# means that packages in peer directories will be found automatically.
#
# Also add the directory ../lib relative to the directory where the
# executable is located. This is meant to find binary packages for the
# same architecture as the current executable.
#
# tcl_pkgPath, which is set by the platform-specific initialization routines
# On UNIX it is compiled in
# On Windows, it is not used
if {![info exists auto_path]} {
if {[info exists env(TCLLIBPATH)]} {
set auto_path $env(TCLLIBPATH)
} else {
set auto_path ""
}
}
namespace eval tcl {
variable Dir
foreach Dir [list $::tcl_library] {
if {$Dir ni $::auto_path} {
lappend ::auto_path $Dir
}
}
catch {
foreach Dir $::tcl_pkgPath {
if {$Dir ni $::auto_path} {
lappend ::auto_path $Dir
}
}
}
if {![interp issafe]} {
variable Path [encoding dirs]
set Dir [file join $::tcl_library encoding]
if {$Dir ni $Path} {
lappend Path $Dir
encoding dirs $Path
}
}
# TIP #255 min and max functions
namespace eval mathfunc {
proc min {args} {
if {![llength $args]} {
return -code error \
"too few arguments to math function \"min\""
}
set val Inf
foreach arg $args {
# This will handle forcing the numeric value without
# ruining the internal type of a numeric object
if {[catch {expr {double($arg)}} err]} {
return -code error $err
}
if {$arg < $val} {set val $arg}
}
return $val
}
proc max {args} {
if {![llength $args]} {
return -code error \
"too few arguments to math function \"max\""
}
set val -Inf
foreach arg $args {
# This will handle forcing the numeric value without
# ruining the internal type of a numeric object
if {[catch {expr {double($arg)}} err]} {
return -code error $err
}
if {$arg > $val} {set val $arg}
}
return $val
}
namespace export min max
}
}
# Windows specific end of initialization
if {(![interp issafe]) && ($tcl_platform(platform) eq "windows")} {
namespace eval tcl {
proc EnvTraceProc {lo n1 n2 op} {
global env
set x $env($n2)
set env($lo) $x
set env([string toupper $lo]) $x
}
proc InitWinEnv {} {
global env tcl_platform
foreach p [array names env] {
set u [string toupper $p]
if {$u ne $p} {
switch -- $u {
COMSPEC -
PATH {
set temp $env($p)
unset env($p)
set env($u) $temp
trace add variable env($p) write \
[namespace code [list EnvTraceProc $p]]
trace add variable env($u) write \
[namespace code [list EnvTraceProc $p]]
}
}
}
}
if {![info exists env(COMSPEC)]} {
set env(COMSPEC) cmd.exe
}
}
InitWinEnv
}
}
# Setup the unknown package handler
if {[interp issafe]} {
package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
} else {
# Set up search for Tcl Modules (TIP #189).
# and setup platform specific unknown package handlers
if {$tcl_platform(os) eq "Darwin"
&& $tcl_platform(platform) eq "unix"} {
package unknown {::tcl::tm::UnknownHandler \
{::tcl::MacOSXPkgUnknown ::tclPkgUnknown}}
} else {
package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
}
# Set up the 'clock' ensemble
namespace eval ::tcl::clock [list variable TclLibDir $::tcl_library]
proc ::tcl::initClock {} {
# Auto-loading stubs for 'clock.tcl'
foreach cmd {add format scan} {
proc ::tcl::clock::$cmd args {
variable TclLibDir
source -encoding utf-8 [file join $TclLibDir clock.tcl]
return [uplevel 1 [info level 0]]
}
}
rename ::tcl::initClock {}
}
::tcl::initClock
}
# Conditionalize for presence of exec.
if {[namespace which -command exec] eq ""} {
# Some machines do not have exec. Also, on all
# platforms, safe interpreters do not have exec.
set auto_noexec 1
}
# Define a log command (which can be overwitten to log errors
# differently, specially when stderr is not available)
if {[namespace which -command tclLog] eq ""} {
proc tclLog {string} {
catch {puts stderr $string}
}
}
# unknown --
# This procedure is called when a Tcl command is invoked that doesn't
# exist in the interpreter. It takes the following steps to make the
# command available:
#
# 1. See if the autoload facility can locate the command in a
# Tcl script file. If so, load it and execute it.
# 2. If the command was invoked interactively at top-level:
# (a) see if the command exists as an executable UNIX program.
# If so, "exec" the command.
# (b) see if the command requests csh-like history substitution
# in one of the common forms !!, !, or ^old^new. If
# so, emulate csh's history substitution.
# (c) see if the command is a unique abbreviation for another
# command. If so, invoke the command.
#
# Arguments:
# args - A list whose elements are the words of the original
# command, including the command name.
proc unknown args {
variable ::tcl::UnknownPending
global auto_noexec auto_noload env tcl_interactive errorInfo errorCode
if {[info exists errorInfo]} {
set savedErrorInfo $errorInfo
}
if {[info exists errorCode]} {
set savedErrorCode $errorCode
}
set name [lindex $args 0]
if {![info exists auto_noload]} {
#
# Make sure we're not trying to load the same proc twice.
#
if {[info exists UnknownPending($name)]} {
return -code error "self-referential recursion\
in \"unknown\" for command \"$name\""
}
set UnknownPending($name) pending
set ret [catch {
auto_load $name [uplevel 1 {::namespace current}]
} msg opts]
unset UnknownPending($name)
if {$ret != 0} {
dict append opts -errorinfo "\n (autoloading \"$name\")"
return -options $opts $msg
}
if {![array size UnknownPending]} {
unset UnknownPending
}
if {$msg} {
if {[info exists savedErrorCode]} {
set ::errorCode $savedErrorCode
} else {
unset -nocomplain ::errorCode
}
if {[info exists savedErrorInfo]} {
set errorInfo $savedErrorInfo
} else {
unset -nocomplain errorInfo
}
set code [catch {uplevel 1 $args} msg opts]
if {$code == 1} {
#
# Compute stack trace contribution from the [uplevel].
# Note the dependence on how Tcl_AddErrorInfo, etc.
# construct the stack trace.
#
set errInfo [dict get $opts -errorinfo]
set errCode [dict get $opts -errorcode]
set cinfo $args
if {[string bytelength $cinfo] > 150} {
set cinfo [string range $cinfo 0 150]
while {[string bytelength $cinfo] > 150} {
set cinfo [string range $cinfo 0 end-1]
}
append cinfo ...
}
set tail "\n (\"uplevel\" body line 1)\n invoked\
from within\n\"uplevel 1 \$args\""
set expect "$msg\n while executing\n\"$cinfo\"$tail"
if {$errInfo eq $expect} {
#
# The stack has only the eval from the expanded command
# Do not generate any stack trace here.
#
dict unset opts -errorinfo
dict incr opts -level
return -options $opts $msg
}
#
# Stack trace is nested, trim off just the contribution
# from the extra "eval" of $args due to the "catch" above.
#
set last [string last $tail $errInfo]
if {$last + [string length $tail] != [string length $errInfo]} {
# Very likely cannot happen
return -options $opts $msg
}
set errInfo [string range $errInfo 0 $last-1]
set tail "\"$cinfo\""
set last [string last $tail $errInfo]
if {$last + [string length $tail] != [string length $errInfo]} {
return -code error -errorcode $errCode \
-errorinfo $errInfo $msg
}
set errInfo [string range $errInfo 0 $last-1]
set tail "\n invoked from within\n"
set last [string last $tail $errInfo]
if {$last + [string length $tail] == [string length $errInfo]} {
return -code error -errorcode $errCode \
-errorinfo [string range $errInfo 0 $last-1] $msg
}
set tail "\n while executing\n"
set last [string last $tail $errInfo]
if {$last + [string length $tail] == [string length $errInfo]} {
return -code error -errorcode $errCode \
-errorinfo [string range $errInfo 0 $last-1] $msg
}
return -options $opts $msg
} else {
dict incr opts -level
return -options $opts $msg
}
}
}
if {([info level] == 1) && ([info script] eq "")
&& [info exists tcl_interactive] && $tcl_interactive} {
if {![info exists auto_noexec]} {
set new [auto_execok $name]
if {$new ne ""} {
set redir ""
if {[namespace which -command console] eq ""} {
set redir ">&@stdout <@stdin"
}
uplevel 1 [list ::catch \
[concat exec $redir $new [lrange $args 1 end]] \
::tcl::UnknownResult ::tcl::UnknownOptions]
dict incr ::tcl::UnknownOptions -level
return -options $::tcl::UnknownOptions $::tcl::UnknownResult
}
}
if {$name eq "!!"} {
set newcmd [history event]
} elseif {[regexp {^!(.+)$} $name -> event]} {
set newcmd [history event $event]
} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name -> old new]} {
set newcmd [history event -1]
catch {regsub -all -- $old $newcmd $new newcmd}
}
if {[info exists newcmd]} {
tclLog $newcmd
history change $newcmd 0
uplevel 1 [list ::catch $newcmd \
::tcl::UnknownResult ::tcl::UnknownOptions]
dict incr ::tcl::UnknownOptions -level
return -options $::tcl::UnknownOptions $::tcl::UnknownResult
}
set ret [catch {set candidates [info commands $name*]} msg]
if {$name eq "::"} {
set name ""
}
if {$ret != 0} {
dict append opts -errorinfo \
"\n (expanding command prefix \"$name\" in unknown)"
return -options $opts $msg
}
# Filter out bogus matches when $name contained
# a glob-special char [Bug 946952]
if {$name eq ""} {
# Handle empty $name separately due to strangeness
# in [string first] (See RFE 1243354)
set cmds $candidates
} else {
set cmds [list]
foreach x $candidates {
if {[string first $name $x] == 0} {
lappend cmds $x
}
}
}
if {[llength $cmds] == 1} {
uplevel 1 [list ::catch [lreplace $args 0 0 [lindex $cmds 0]] \
::tcl::UnknownResult ::tcl::UnknownOptions]
dict incr ::tcl::UnknownOptions -level
return -options $::tcl::UnknownOptions $::tcl::UnknownResult
}
if {[llength $cmds]} {
return -code error "ambiguous command name \"$name\": [lsort $cmds]"
}
}
return -code error -errorcode [list TCL LOOKUP COMMAND $name] \
"invalid command name \"$name\""
}
# auto_load --
# Checks a collection of library directories to see if a procedure
# is defined in one of them. If so, it sources the appropriate
# library file to create the procedure. Returns 1 if it successfully
# loaded the procedure, 0 otherwise.
#
# Arguments:
# cmd - Name of the command to find and load.
# namespace (optional) The namespace where the command is being used - must be
# a canonical namespace as returned [namespace current]
# for instance. If not given, namespace current is used.
proc auto_load {cmd {namespace {}}} {
global auto_index auto_path
if {$namespace eq ""} {
set namespace [uplevel 1 [list ::namespace current]]
}
set nameList [auto_qualify $cmd $namespace]
# workaround non canonical auto_index entries that might be around
# from older auto_mkindex versions
lappend nameList $cmd
foreach name $nameList {
if {[info exists auto_index($name)]} {
namespace eval :: $auto_index($name)
# There's a couple of ways to look for a command of a given
# name. One is to use
# info commands $name
# Unfortunately, if the name has glob-magic chars in it like *
# or [], it may not match. For our purposes here, a better
# route is to use
# namespace which -command $name
if {[namespace which -command $name] ne ""} {
return 1
}
}
}
if {![info exists auto_path]} {
return 0
}
if {![auto_load_index]} {
return 0
}
foreach name $nameList {
if {[info exists auto_index($name)]} {
namespace eval :: $auto_index($name)
if {[namespace which -command $name] ne ""} {
return 1
}
}
}
return 0
}
# auto_load_index --
# Loads the contents of tclIndex files on the auto_path directory
# list. This is usually invoked within auto_load to load the index
# of available commands. Returns 1 if the index is loaded, and 0 if
# the index is already loaded and up to date.
#
# Arguments:
# None.
proc auto_load_index {} {
variable ::tcl::auto_oldpath
global auto_index auto_path
if {[info exists auto_oldpath] && ($auto_oldpath eq $auto_path)} {
return 0
}
set auto_oldpath $auto_path
# Check if we are a safe interpreter. In that case, we support only
# newer format tclIndex files.
set issafe [interp issafe]
for {set i [expr {[llength $auto_path] - 1}]} {$i >= 0} {incr i -1} {
set dir [lindex $auto_path $i]
set f ""
if {$issafe} {
catch {source [file join $dir tclIndex]}
} elseif {[catch {set f [open [file join $dir tclIndex]]}]} {
continue
} else {
set error [catch {
set id [gets $f]
if {$id eq "# Tcl autoload index file, version 2.0"} {
eval [read $f]
} elseif {$id eq "# Tcl autoload index file: each line identifies a Tcl"} {
while {[gets $f line] >= 0} {
if {([string index $line 0] eq "#") \
|| ([llength $line] != 2)} {
continue
}
set name [lindex $line 0]
set auto_index($name) \
"source [file join $dir [lindex $line 1]]"
}
} else {
error "[file join $dir tclIndex] isn't a proper Tcl index file"
}
} msg opts]
if {$f ne ""} {
close $f
}
if {$error} {
return -options $opts $msg
}
}
}
return 1
}
# auto_qualify --
#
# Compute a fully qualified names list for use in the auto_index array.
# For historical reasons, commands in the global namespace do not have leading
# :: in the index key. The list has two elements when the command name is
# relative (no leading ::) and the namespace is not the global one. Otherwise
# only one name is returned (and searched in the auto_index).
#
# Arguments -
# cmd The command name. Can be any name accepted for command
# invocations (Like "foo::::bar").
# namespace The namespace where the command is being used - must be
# a canonical namespace as returned by [namespace current]
# for instance.
proc auto_qualify {cmd namespace} {
# count separators and clean them up
# (making sure that foo:::::bar will be treated as foo::bar)
set n [regsub -all {::+} $cmd :: cmd]
# Ignore namespace if the name starts with ::
# Handle special case of only leading ::
# Before each return case we give an example of which category it is
# with the following form :
# (inputCmd, inputNameSpace) -> output
if {[string match ::* $cmd]} {
if {$n > 1} {
# (::foo::bar , *) -> ::foo::bar
return [list $cmd]
} else {
# (::global , *) -> global
return [list [string range $cmd 2 end]]
}
}
# Potentially returning 2 elements to try :
# (if the current namespace is not the global one)
if {$n == 0} {
if {$namespace eq "::"} {
# (nocolons , ::) -> nocolons
return [list $cmd]
} else {
# (nocolons , ::sub) -> ::sub::nocolons nocolons
return [list ${namespace}::$cmd $cmd]
}
} elseif {$namespace eq "::"} {
# (foo::bar , ::) -> ::foo::bar
return [list ::$cmd]
} else {
# (foo::bar , ::sub) -> ::sub::foo::bar ::foo::bar
return [list ${namespace}::$cmd ::$cmd]
}
}
# auto_import --
#
# Invoked during "namespace import" to make see if the imported commands
# reside in an autoloaded library. If so, the commands are loaded so
# that they will be available for the import links. If not, then this
# procedure does nothing.
#
# Arguments -
# pattern The pattern of commands being imported (like "foo::*")
# a canonical namespace as returned by [namespace current]
proc auto_import {pattern} {
global auto_index
# If no namespace is specified, this will be an error case
if {![string match *::* $pattern]} {
return
}
set ns [uplevel 1 [list ::namespace current]]
set patternList [auto_qualify $pattern $ns]
auto_load_index
foreach pattern $patternList {
foreach name [array names auto_index $pattern] {
if {([namespace which -command $name] eq "")
&& ([namespace qualifiers $pattern] eq [namespace qualifiers $name])} {
namespace eval :: $auto_index($name)
}
}
}
}
# auto_execok --
#
# Returns string that indicates name of program to execute if
# name corresponds to a shell builtin or an executable in the
# Windows search path, or "" otherwise. Builds an associative
# array auto_execs that caches information about previous checks,
# for speed.
#
# Arguments:
# name - Name of a command.
if {$tcl_platform(platform) eq "windows"} {
# Windows version.
#
# Note that file executable doesn't work under Windows, so we have to
# look for files with .exe, .com, or .bat extensions. Also, the path
# may be in the Path or PATH environment variables, and path
# components are separated with semicolons, not colons as under Unix.
#
proc auto_execok name {
global auto_execs env tcl_platform
if {[info exists auto_execs($name)]} {
return $auto_execs($name)
}
set auto_execs($name) ""
set shellBuiltins [list assoc cls copy date del dir echo erase ftype \
md mkdir mklink move rd ren rename rmdir start time type ver vol]
if {[info exists env(PATHEXT)]} {
# Add an initial ; to have the {} extension check first.
set execExtensions [split ";$env(PATHEXT)" ";"]
} else {
set execExtensions [list {} .com .exe .bat .cmd]
}
if {[string tolower $name] in $shellBuiltins} {
# When this is command.com for some reason on Win2K, Tcl won't
# exec it unless the case is right, which this corrects. COMSPEC
# may not point to a real file, so do the check.
set cmd $env(COMSPEC)
if {[file exists $cmd]} {
set cmd [file attributes $cmd -shortname]
}
return [set auto_execs($name) [list $cmd /c $name]]
}
if {[llength [file split $name]] != 1} {
foreach ext $execExtensions {
set file ${name}${ext}
if {[file exists $file] && ![file isdirectory $file]} {
return [set auto_execs($name) [list $file]]
}
}
return ""
}
set path "[file dirname [info nameof]];.;"
if {[info exists env(WINDIR)]} {
set windir $env(WINDIR)
}
if {[info exists windir]} {
if {$tcl_platform(os) eq "Windows NT"} {
append path "$windir/system32;"
}
append path "$windir/system;$windir;"
}
foreach var {PATH Path path} {
if {[info exists env($var)]} {
append path ";$env($var)"
}
}
foreach ext $execExtensions {
unset -nocomplain checked
foreach dir [split $path {;}] {
# Skip already checked directories
if {[info exists checked($dir)] || ($dir eq "")} {
continue
}
set checked($dir) {}
set file [file join $dir ${name}${ext}]
if {[file exists $file] && ![file isdirectory $file]} {
return [set auto_execs($name) [list $file]]
}
}
}
return ""
}
} else {
# Unix version.
#
proc auto_execok name {
global auto_execs env
if {[info exists auto_execs($name)]} {
return $auto_execs($name)
}
set auto_execs($name) ""
if {[llength [file split $name]] != 1} {
if {[file executable $name] && ![file isdirectory $name]} {
set auto_execs($name) [list $name]
}
return $auto_execs($name)
}
foreach dir [split $env(PATH) :] {
if {$dir eq ""} {
set dir .
}
set file [file join $dir $name]
if {[file executable $file] && ![file isdirectory $file]} {
set auto_execs($name) [list $file]
return $auto_execs($name)
}
}
return ""
}
}
# ::tcl::CopyDirectory --
#
# This procedure is called by Tcl's core when attempts to call the
# filesystem's copydirectory function fail. The semantics of the call
# are that 'dest' does not yet exist, i.e. dest should become the exact
# image of src. If dest does exist, we throw an error.
#
# Note that making changes to this procedure can change the results
# of running Tcl's tests.
#
# Arguments:
# action - "renaming" or "copying"
# src - source directory
# dest - destination directory
proc tcl::CopyDirectory {action src dest} {
set nsrc [file normalize $src]
set ndest [file normalize $dest]
if {$action eq "renaming"} {
# Can't rename volumes. We could give a more precise
# error message here, but that would break the test suite.
if {$nsrc in [file volumes]} {
return -code error "error $action \"$src\" to\
\"$dest\": trying to rename a volume or move a directory\
into itself"
}
}
if {[file exists $dest]} {
if {$nsrc eq $ndest} {
return -code error "error $action \"$src\" to\
\"$dest\": trying to rename a volume or move a directory\
into itself"
}
if {$action eq "copying"} {
# We used to throw an error here, but, looking more closely
# at the core copy code in tclFCmd.c, if the destination
# exists, then we should only call this function if -force
# is true, which means we just want to over-write. So,
# the following code is now commented out.
#
# return -code error "error $action \"$src\" to\
# \"$dest\": file already exists"
} else {
# Depending on the platform, and on the current
# working directory, the directories '.', '..'
# can be returned in various combinations. Anyway,
# if any other file is returned, we must signal an error.
set existing [glob -nocomplain -directory $dest * .*]
lappend existing {*}[glob -nocomplain -directory $dest \
-type hidden * .*]
foreach s $existing {
if {[file tail $s] ni {. ..}} {
return -code error "error $action \"$src\" to\
\"$dest\": file already exists"
}
}
}
} else {
if {[string first $nsrc $ndest] != -1} {
set srclen [expr {[llength [file split $nsrc]] - 1}]
set ndest [lindex [file split $ndest] $srclen]
if {$ndest eq [file tail $nsrc]} {
return -code error "error $action \"$src\" to\
\"$dest\": trying to rename a volume or move a directory\
into itself"
}
}
file mkdir $dest
}
# Have to be careful to capture both visible and hidden files.
# We will also be more generous to the file system and not
# assume the hidden and non-hidden lists are non-overlapping.
#
# On Unix 'hidden' files begin with '.'. On other platforms
# or filesystems hidden files may have other interpretations.
set filelist [concat [glob -nocomplain -directory $src *] \
[glob -nocomplain -directory $src -types hidden *]]
foreach s [lsort -unique $filelist] {
if {[file tail $s] ni {. ..}} {
file copy -force -- $s [file join $dest [file tail $s]]
}
}
return
}
PK ! ] word.tclnu [ # word.tcl --
#
# This file defines various procedures for computing word boundaries in
# strings. This file is primarily needed so Tk text and entry widgets behave
# properly for different platforms.
#
# Copyright (c) 1996 by Sun Microsystems, Inc.
# Copyright (c) 1998 by Scritpics Corporation.
#
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
# The following variables are used to determine which characters are
# interpreted as white space.
if {$::tcl_platform(platform) eq "windows"} {
# Windows style - any but a unicode space char
if {![info exists ::tcl_wordchars]} {
set ::tcl_wordchars {\S}
}
if {![info exists ::tcl_nonwordchars]} {
set ::tcl_nonwordchars {\s}
}
} else {
# Motif style - any unicode word char (number, letter, or underscore)
if {![info exists ::tcl_wordchars]} {
set ::tcl_wordchars {\w}
}
if {![info exists ::tcl_nonwordchars]} {
set ::tcl_nonwordchars {\W}
}
}
# Arrange for caches of the real matcher REs to be kept, which enables the REs
# themselves to be cached for greater performance (and somewhat greater
# clarity too).
namespace eval ::tcl {
variable WordBreakRE
array set WordBreakRE {}
proc UpdateWordBreakREs args {
# Ignores the arguments
global tcl_wordchars tcl_nonwordchars
variable WordBreakRE
# To keep the RE strings short...
set letter $tcl_wordchars
set space $tcl_nonwordchars
set WordBreakRE(after) "$letter$space|$space$letter"
set WordBreakRE(before) "^.*($letter$space|$space$letter)"
set WordBreakRE(end) "$space*$letter+$space"
set WordBreakRE(next) "$letter*$space+$letter"
set WordBreakRE(previous) "$space*($letter+)$space*\$"
}
# Initialize the cache
UpdateWordBreakREs
trace add variable ::tcl_wordchars write ::tcl::UpdateWordBreakREs
trace add variable ::tcl_nonwordchars write ::tcl::UpdateWordBreakREs
}
# tcl_wordBreakAfter --
#
# This procedure returns the index of the first word boundary after the
# starting point in the given string, or -1 if there are no more boundaries in
# the given string. The index returned refers to the first character of the
# pair that comprises a boundary.
#
# Arguments:
# str - String to search.
# start - Index into string specifying starting point.
proc tcl_wordBreakAfter {str start} {
variable ::tcl::WordBreakRE
set result {-1 -1}
regexp -indices -start $start -- $WordBreakRE(after) $str result
return [lindex $result 1]
}
# tcl_wordBreakBefore --
#
# This procedure returns the index of the first word boundary before the
# starting point in the given string, or -1 if there are no more boundaries in
# the given string. The index returned refers to the second character of the
# pair that comprises a boundary.
#
# Arguments:
# str - String to search.
# start - Index into string specifying starting point.
proc tcl_wordBreakBefore {str start} {
variable ::tcl::WordBreakRE
set result {-1 -1}
regexp -indices -- $WordBreakRE(before) [string range $str 0 $start] result
return [lindex $result 1]
}
# tcl_endOfWord --
#
# This procedure returns the index of the first end-of-word location after a
# starting index in the given string. An end-of-word location is defined to be
# the first whitespace character following the first non-whitespace character
# after the starting point. Returns -1 if there are no more words after the
# starting point.
#
# Arguments:
# str - String to search.
# start - Index into string specifying starting point.
proc tcl_endOfWord {str start} {
variable ::tcl::WordBreakRE
set result {-1 -1}
regexp -indices -start $start -- $WordBreakRE(end) $str result
return [lindex $result 1]
}
# tcl_startOfNextWord --
#
# This procedure returns the index of the first start-of-word location after a
# starting index in the given string. A start-of-word location is defined to
# be a non-whitespace character following a whitespace character. Returns -1
# if there are no more start-of-word locations after the starting point.
#
# Arguments:
# str - String to search.
# start - Index into string specifying starting point.
proc tcl_startOfNextWord {str start} {
variable ::tcl::WordBreakRE
set result {-1 -1}
regexp -indices -start $start -- $WordBreakRE(next) $str result
return [lindex $result 1]
}
# tcl_startOfPreviousWord --
#
# This procedure returns the index of the first start-of-word location before
# a starting index in the given string.
#
# Arguments:
# str - String to search.
# start - Index into string specifying starting point.
proc tcl_startOfPreviousWord {str start} {
variable ::tcl::WordBreakRE
set word {-1 -1}
regexp -indices -- $WordBreakRE(previous) [string range $str 0 $start-1] \
result word
return [lindex $word 0]
}
PK ! Fd`S `S auto.tclnu [ # auto.tcl --
#
# utility procs formerly in init.tcl dealing with auto execution of commands
# and can be auto loaded themselves.
#
# Copyright (c) 1991-1993 The Regents of the University of California.
# Copyright (c) 1994-1998 Sun Microsystems, Inc.
#
# See the file "license.terms" for information on usage and redistribution of
# this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# auto_reset --
#
# Destroy all cached information for auto-loading and auto-execution, so that
# the information gets recomputed the next time it's needed. Also delete any
# commands that are listed in the auto-load index.
#
# Arguments:
# None.
proc auto_reset {} {
global auto_execs auto_index auto_path
if {[array exists auto_index]} {
foreach cmdName [array names auto_index] {
set fqcn [namespace which $cmdName]
if {$fqcn eq ""} {
continue
}
rename $fqcn {}
}
}
unset -nocomplain auto_execs auto_index ::tcl::auto_oldpath
if {[catch {llength $auto_path}]} {
set auto_path [list [info library]]
} elseif {[info library] ni $auto_path} {
lappend auto_path [info library]
}
}
# tcl_findLibrary --
#
# This is a utility for extensions that searches for a library directory
# using a canonical searching algorithm. A side effect is to source the
# initialization script and set a global library variable.
#
# Arguments:
# basename Prefix of the directory name, (e.g., "tk")
# version Version number of the package, (e.g., "8.0")
# patch Patchlevel of the package, (e.g., "8.0.3")
# initScript Initialization script to source (e.g., tk.tcl)
# enVarName environment variable to honor (e.g., TK_LIBRARY)
# varName Global variable to set when done (e.g., tk_library)
proc tcl_findLibrary {basename version patch initScript enVarName varName} {
upvar #0 $varName the_library
global auto_path env tcl_platform
set dirs {}
set errors {}
# The C application may have hardwired a path, which we honor
if {[info exists the_library] && $the_library ne ""} {
lappend dirs $the_library
} else {
# Do the canonical search
# 1. From an environment variable, if it exists. Placing this first
# gives the end-user ultimate control to work-around any bugs, or
# to customize.
if {[info exists env($enVarName)]} {
lappend dirs $env($enVarName)
}
# 2. In the package script directory registered within the
# configuration of the package itself.
catch {
lappend dirs [::${basename}::pkgconfig get scriptdir,runtime]
}
# 2a. As a sibling of Tcl's script directory
if {[catch {
::tcl::pkgconfig get scriptdir,runtime
} value] == 0} {
lappend dirs [file join [file dirname $value] $basename$version]
}
# 3. Relative to auto_path directories. This checks relative to the
# Tcl library as well as allowing loading of libraries added to the
# auto_path that is not relative to the core library or binary paths.
foreach d $auto_path {
lappend dirs [file join $d $basename$version]
if {$tcl_platform(platform) eq "unix"
&& $tcl_platform(os) eq "Darwin"} {
# 4. On MacOSX, check the Resources/Scripts subdir too
lappend dirs [file join $d $basename$version Resources Scripts]
}
}
# 3. Various locations relative to the executable
# ../lib/foo1.0 (From bin directory in install hierarchy)
# ../../lib/foo1.0 (From bin/arch directory in install hierarchy)
# ../library (From unix directory in build hierarchy)
#
# Remaining locations are out of date (when relevant, they ought to be
# covered by the $::auto_path seach above) and disabled.
#
# ../../library (From unix/arch directory in build hierarchy)
# ../../foo1.0.1/library
# (From unix directory in parallel build hierarchy)
# ../../../foo1.0.1/library
# (From unix/arch directory in parallel build hierarchy)
set parentDir [file dirname [file dirname [info nameofexecutable]]]
set grandParentDir [file dirname $parentDir]
lappend dirs [file join $parentDir lib $basename$version]
lappend dirs [file join $grandParentDir lib $basename$version]
lappend dirs [file join $parentDir library]
if {0} {
lappend dirs [file join $grandParentDir library]
lappend dirs [file join $grandParentDir $basename$patch library]
lappend dirs [file join [file dirname $grandParentDir] \
$basename$patch library]
}
}
# uniquify $dirs in order
array set seen {}
foreach i $dirs {
# Make sure $i is unique under normalization. Avoid repeated [source].
if {[interp issafe]} {
# Safe interps have no [file normalize].
set norm $i
} else {
set norm [file normalize $i]
}
if {[info exists seen($norm)]} {
continue
}
set seen($norm) {}
set the_library $i
set file [file join $i $initScript]
# source everything when in a safe interpreter because we have a
# source command, but no file exists command
if {[interp issafe] || [file exists $file]} {
if {![catch {uplevel #0 [list source $file]} msg opts]} {
return
}
append errors "$file: $msg\n"
append errors [dict get $opts -errorinfo]\n
}
}
unset -nocomplain the_library
set msg "Can't find a usable $initScript in the following directories: \n"
append msg " $dirs\n\n"
append msg "$errors\n\n"
append msg "This probably means that $basename wasn't installed properly.\n"
error $msg
}
# ----------------------------------------------------------------------
# auto_mkindex
# ----------------------------------------------------------------------
# The following procedures are used to generate the tclIndex file from Tcl
# source files. They use a special safe interpreter to parse Tcl source
# files, writing out index entries as "proc" commands are encountered. This
# implementation won't work in a safe interpreter, since a safe interpreter
# can't create the special parser and mess with its commands.
if {[interp issafe]} {
return ;# Stop sourcing the file here
}
# auto_mkindex --
# Regenerate a tclIndex file from Tcl source files. Takes as argument the
# name of the directory in which the tclIndex file is to be placed, followed
# by any number of glob patterns to use in that directory to locate all of the
# relevant files.
#
# Arguments:
# dir - Name of the directory in which to create an index.
# args - Any number of additional arguments giving the names of files
# within dir. If no additional are given auto_mkindex will look
# for *.tcl.
proc auto_mkindex {dir args} {
if {[interp issafe]} {
error "can't generate index within safe interpreter"
}
set oldDir [pwd]
cd $dir
append index "# Tcl autoload index file, version 2.0\n"
append index "# This file is generated by the \"auto_mkindex\" command\n"
append index "# and sourced to set up indexing information for one or\n"
append index "# more commands. Typically each line is a command that\n"
append index "# sets an element in the auto_index array, where the\n"
append index "# element name is the name of a command and the value is\n"
append index "# a script that loads the command.\n\n"
if {![llength $args]} {
set args *.tcl
}
auto_mkindex_parser::init
foreach file [lsort [glob -- {*}$args]] {
try {
append index [auto_mkindex_parser::mkindex $file]
} on error {msg opts} {
cd $oldDir
return -options $opts $msg
}
}
auto_mkindex_parser::cleanup
set fid [open "tclIndex" w]
puts -nonewline $fid $index
close $fid
cd $oldDir
}
# Original version of auto_mkindex that just searches the source code for
# "proc" at the beginning of the line.
proc auto_mkindex_old {dir args} {
set oldDir [pwd]
cd $dir
set dir [pwd]
append index "# Tcl autoload index file, version 2.0\n"
append index "# This file is generated by the \"auto_mkindex\" command\n"
append index "# and sourced to set up indexing information for one or\n"
append index "# more commands. Typically each line is a command that\n"
append index "# sets an element in the auto_index array, where the\n"
append index "# element name is the name of a command and the value is\n"
append index "# a script that loads the command.\n\n"
if {![llength $args]} {
set args *.tcl
}
foreach file [lsort [glob -- {*}$args]] {
set f ""
set error [catch {
set f [open $file]
while {[gets $f line] >= 0} {
if {[regexp {^proc[ ]+([^ ]*)} $line match procName]} {
set procName [lindex [auto_qualify $procName "::"] 0]
append index "set [list auto_index($procName)]"
append index " \[list source \[file join \$dir [list $file]\]\]\n"
}
}
close $f
} msg opts]
if {$error} {
catch {close $f}
cd $oldDir
return -options $opts $msg
}
}
set f ""
set error [catch {
set f [open tclIndex w]
puts -nonewline $f $index
close $f
cd $oldDir
} msg opts]
if {$error} {
catch {close $f}
cd $oldDir
error $msg $info $code
return -options $opts $msg
}
}
# Create a safe interpreter that can be used to parse Tcl source files
# generate a tclIndex file for autoloading. This interp contains commands for
# things that need index entries. Each time a command is executed, it writes
# an entry out to the index file.
namespace eval auto_mkindex_parser {
variable parser "" ;# parser used to build index
variable index "" ;# maintains index as it is built
variable scriptFile "" ;# name of file being processed
variable contextStack "" ;# stack of namespace scopes
variable imports "" ;# keeps track of all imported cmds
variable initCommands ;# list of commands that create aliases
if {![info exists initCommands]} {
set initCommands [list]
}
proc init {} {
variable parser
variable initCommands
if {![interp issafe]} {
set parser [interp create -safe]
$parser hide info
$parser hide rename
$parser hide proc
$parser hide namespace
$parser hide eval
$parser hide puts
foreach ns [$parser invokehidden namespace children ::] {
# MUST NOT DELETE "::tcl" OR BAD THINGS HAPPEN!
if {$ns eq "::tcl"} continue
$parser invokehidden namespace delete $ns
}
foreach cmd [$parser invokehidden info commands ::*] {
$parser invokehidden rename $cmd {}
}
$parser invokehidden proc unknown {args} {}
# We'll need access to the "namespace" command within the
# interp. Put it back, but move it out of the way.
$parser expose namespace
$parser invokehidden rename namespace _%@namespace
$parser expose eval
$parser invokehidden rename eval _%@eval
# Install all the registered psuedo-command implementations
foreach cmd $initCommands {
eval $cmd
}
}
}
proc cleanup {} {
variable parser
interp delete $parser
unset parser
}
}
# auto_mkindex_parser::mkindex --
#
# Used by the "auto_mkindex" command to create a "tclIndex" file for the given
# Tcl source file. Executes the commands in the file, and handles things like
# the "proc" command by adding an entry for the index file. Returns a string
# that represents the index file.
#
# Arguments:
# file Name of Tcl source file to be indexed.
proc auto_mkindex_parser::mkindex {file} {
variable parser
variable index
variable scriptFile
variable contextStack
variable imports
set scriptFile $file
set fid [open $file]
set contents [read $fid]
close $fid
# There is one problem with sourcing files into the safe interpreter:
# references like "$x" will fail since code is not really being executed
# and variables do not really exist. To avoid this, we replace all $ with
# \0 (literally, the null char) later, when getting proc names we will
# have to reverse this replacement, in case there were any $ in the proc
# name. This will cause a problem if somebody actually tries to have a \0
# in their proc name. Too bad for them.
set contents [string map [list \$ \0] $contents]
set index ""
set contextStack ""
set imports ""
$parser eval $contents
foreach name $imports {
catch {$parser eval [list _%@namespace forget $name]}
}
return $index
}
# auto_mkindex_parser::hook command
#
# Registers a Tcl command to evaluate when initializing the slave interpreter
# used by the mkindex parser. The command is evaluated in the master
# interpreter, and can use the variable auto_mkindex_parser::parser to get to
# the slave
proc auto_mkindex_parser::hook {cmd} {
variable initCommands
lappend initCommands $cmd
}
# auto_mkindex_parser::slavehook command
#
# Registers a Tcl command to evaluate when initializing the slave interpreter
# used by the mkindex parser. The command is evaluated in the slave
# interpreter.
proc auto_mkindex_parser::slavehook {cmd} {
variable initCommands
# The $parser variable is defined to be the name of the slave interpreter
# when this command is used later.
lappend initCommands "\$parser eval [list $cmd]"
}
# auto_mkindex_parser::command --
#
# Registers a new command with the "auto_mkindex_parser" interpreter that
# parses Tcl files. These commands are fake versions of things like the
# "proc" command. When you execute them, they simply write out an entry to a
# "tclIndex" file for auto-loading.
#
# This procedure allows extensions to register their own commands with the
# auto_mkindex facility. For example, a package like [incr Tcl] might
# register a "class" command so that class definitions could be added to a
# "tclIndex" file for auto-loading.
#
# Arguments:
# name Name of command recognized in Tcl files.
# arglist Argument list for command.
# body Implementation of command to handle indexing.
proc auto_mkindex_parser::command {name arglist body} {
hook [list auto_mkindex_parser::commandInit $name $arglist $body]
}
# auto_mkindex_parser::commandInit --
#
# This does the actual work set up by auto_mkindex_parser::command. This is
# called when the interpreter used by the parser is created.
#
# Arguments:
# name Name of command recognized in Tcl files.
# arglist Argument list for command.
# body Implementation of command to handle indexing.
proc auto_mkindex_parser::commandInit {name arglist body} {
variable parser
set ns [namespace qualifiers $name]
set tail [namespace tail $name]
if {$ns eq ""} {
set fakeName [namespace current]::_%@fake_$tail
} else {
set fakeName [namespace current]::[string map {:: _} _%@fake_$name]
}
proc $fakeName $arglist $body
# YUK! Tcl won't let us alias fully qualified command names, so we can't
# handle names like "::itcl::class". Instead, we have to build procs with
# the fully qualified names, and have the procs point to the aliases.
if {[string match *::* $name]} {
set exportCmd [list _%@namespace export [namespace tail $name]]
$parser eval [list _%@namespace eval $ns $exportCmd]
# The following proc definition does not work if you want to tolerate
# space or something else diabolical in the procedure name, (i.e.,
# space in $alias). The following does not work:
# "_%@eval {$alias} \$args"
# because $alias gets concat'ed to $args. The following does not work
# because $cmd is somehow undefined
# "set cmd {$alias} \; _%@eval {\$cmd} \$args"
# A gold star to someone that can make test autoMkindex-3.3 work
# properly
set alias [namespace tail $fakeName]
$parser invokehidden proc $name {args} "_%@eval {$alias} \$args"
$parser alias $alias $fakeName
} else {
$parser alias $name $fakeName
}
return
}
# auto_mkindex_parser::fullname --
#
# Used by commands like "proc" within the auto_mkindex parser. Returns the
# qualified namespace name for the "name" argument. If the "name" does not
# start with "::", elements are added from the current namespace stack to
# produce a qualified name. Then, the name is examined to see whether or not
# it should really be qualified. If the name has more than the leading "::",
# it is returned as a fully qualified name. Otherwise, it is returned as a
# simple name. That way, the Tcl autoloader will recognize it properly.
#
# Arguments:
# name - Name that is being added to index.
proc auto_mkindex_parser::fullname {name} {
variable contextStack
if {![string match ::* $name]} {
foreach ns $contextStack {
set name "${ns}::$name"
if {[string match ::* $name]} {
break
}
}
}
if {[namespace qualifiers $name] eq ""} {
set name [namespace tail $name]
} elseif {![string match ::* $name]} {
set name "::$name"
}
# Earlier, mkindex replaced all $'s with \0. Now, we have to reverse that
# replacement.
return [string map [list \0 \$] $name]
}
# auto_mkindex_parser::indexEntry --
#
# Used by commands like "proc" within the auto_mkindex parser to add a
# correctly-quoted entry to the index. This is shared code so it is done
# *right*, in one place.
#
# Arguments:
# name - Name that is being added to index.
proc auto_mkindex_parser::indexEntry {name} {
variable index
variable scriptFile
# We convert all metacharacters to their backslashed form, and pre-split
# the file name that we know about (which will be a proper list, and so
# correctly quoted).
set name [string range [list \}[fullname $name]] 2 end]
set filenameParts [file split $scriptFile]
append index [format \
{set auto_index(%s) [list source [file join $dir %s]]%s} \
$name $filenameParts \n]
return
}
if {[llength $::auto_mkindex_parser::initCommands]} {
return
}
# Register all of the procedures for the auto_mkindex parser that will build
# the "tclIndex" file.
# AUTO MKINDEX: proc name arglist body
# Adds an entry to the auto index list for the given procedure name.
auto_mkindex_parser::command proc {name args} {
indexEntry $name
}
# Conditionally add support for Tcl byte code files. There are some tricky
# details here. First, we need to get the tbcload library initialized in the
# current interpreter. We cannot load tbcload into the slave until we have
# done so because it needs access to the tcl_patchLevel variable. Second,
# because the package index file may defer loading the library until we invoke
# a command, we need to explicitly invoke auto_load to force it to be loaded.
# This should be a noop if the package has already been loaded
auto_mkindex_parser::hook {
try {
package require tbcload
} on error {} {
# OK, don't have it so do nothing
} on ok {} {
if {[namespace which -command tbcload::bcproc] eq ""} {
auto_load tbcload::bcproc
}
load {} tbcload $auto_mkindex_parser::parser
# AUTO MKINDEX: tbcload::bcproc name arglist body
# Adds an entry to the auto index list for the given pre-compiled
# procedure name.
auto_mkindex_parser::commandInit tbcload::bcproc {name args} {
indexEntry $name
}
}
}
# AUTO MKINDEX: namespace eval name command ?arg arg...?
# Adds the namespace name onto the context stack and evaluates the associated
# body of commands.
#
# AUTO MKINDEX: namespace import ?-force? pattern ?pattern...?
# Performs the "import" action in the parser interpreter. This is important
# for any commands contained in a namespace that affect the index. For
# example, a script may say "itcl::class ...", or it may import "itcl::*" and
# then say "class ...". This procedure does the import operation, but keeps
# track of imported patterns so we can remove the imports later.
auto_mkindex_parser::command namespace {op args} {
switch -- $op {
eval {
variable parser
variable contextStack
set name [lindex $args 0]
set args [lrange $args 1 end]
set contextStack [linsert $contextStack 0 $name]
$parser eval [list _%@namespace eval $name] $args
set contextStack [lrange $contextStack 1 end]
}
import {
variable parser
variable imports
foreach pattern $args {
if {$pattern ne "-force"} {
lappend imports $pattern
}
}
catch {$parser eval "_%@namespace import $args"}
}
ensemble {
variable parser
variable contextStack
if {[lindex $args 0] eq "create"} {
set name ::[join [lreverse $contextStack] ::]
catch {
set name [dict get [lrange $args 1 end] -command]
if {![string match ::* $name]} {
set name ::[join [lreverse $contextStack] ::]$name
}
regsub -all ::+ $name :: name
}
# create artifical proc to force an entry in the tclIndex
$parser eval [list ::proc $name {} {}]
}
}
}
}
# AUTO MKINDEX: oo::class create name ?definition?
# Adds an entry to the auto index list for the given class name.
auto_mkindex_parser::command oo::class {op name {body ""}} {
if {$op eq "create"} {
indexEntry $name
}
}
auto_mkindex_parser::command class {op name {body ""}} {
if {$op eq "create"} {
indexEntry $name
}
}
return
PK ! I]| | msgs/nn.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset nn DAYS_OF_WEEK_ABBREV [list \
"su"\
"m\u00e5"\
"ty"\
"on"\
"to"\
"fr"\
"lau"]
::msgcat::mcset nn DAYS_OF_WEEK_FULL [list \
"sundag"\
"m\u00e5ndag"\
"tysdag"\
"onsdag"\
"torsdag"\
"fredag"\
"laurdag"]
::msgcat::mcset nn MONTHS_ABBREV [list \
"jan"\
"feb"\
"mar"\
"apr"\
"mai"\
"jun"\
"jul"\
"aug"\
"sep"\
"okt"\
"nov"\
"des"\
""]
::msgcat::mcset nn MONTHS_FULL [list \
"januar"\
"februar"\
"mars"\
"april"\
"mai"\
"juni"\
"juli"\
"august"\
"september"\
"oktober"\
"november"\
"desember"\
""]
::msgcat::mcset nn BCE "f.Kr."
::msgcat::mcset nn CE "e.Kr."
::msgcat::mcset nn DATE_FORMAT "%e. %B %Y"
::msgcat::mcset nn TIME_FORMAT "%H:%M:%S"
::msgcat::mcset nn DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z"
}
PK ! 6|k msgs/af.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset af DAYS_OF_WEEK_ABBREV [list \
"So"\
"Ma"\
"Di"\
"Wo"\
"Do"\
"Vr"\
"Sa"]
::msgcat::mcset af DAYS_OF_WEEK_FULL [list \
"Sondag"\
"Maandag"\
"Dinsdag"\
"Woensdag"\
"Donderdag"\
"Vrydag"\
"Saterdag"]
::msgcat::mcset af MONTHS_ABBREV [list \
"Jan"\
"Feb"\
"Mar"\
"Apr"\
"Mei"\
"Jun"\
"Jul"\
"Aug"\
"Sep"\
"Okt"\
"Nov"\
"Des"\
""]
::msgcat::mcset af MONTHS_FULL [list \
"Januarie"\
"Februarie"\
"Maart"\
"April"\
"Mei"\
"Junie"\
"Julie"\
"Augustus"\
"September"\
"Oktober"\
"November"\
"Desember"\
""]
::msgcat::mcset af AM "VM"
::msgcat::mcset af PM "NM"
}
PK ! ۂkA A msgs/uk.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset uk DAYS_OF_WEEK_ABBREV [list \
"\u043d\u0434"\
"\u043f\u043d"\
"\u0432\u0442"\
"\u0441\u0440"\
"\u0447\u0442"\
"\u043f\u0442"\
"\u0441\u0431"]
::msgcat::mcset uk DAYS_OF_WEEK_FULL [list \
"\u043d\u0435\u0434\u0456\u043b\u044f"\
"\u043f\u043e\u043d\u0435\u0434\u0456\u043b\u043e\u043a"\
"\u0432\u0456\u0432\u0442\u043e\u0440\u043e\u043a"\
"\u0441\u0435\u0440\u0435\u0434\u0430"\
"\u0447\u0435\u0442\u0432\u0435\u0440"\
"\u043f'\u044f\u0442\u043d\u0438\u0446\u044f"\
"\u0441\u0443\u0431\u043e\u0442\u0430"]
::msgcat::mcset uk MONTHS_ABBREV [list \
"\u0441\u0456\u0447"\
"\u043b\u044e\u0442"\
"\u0431\u0435\u0440"\
"\u043a\u0432\u0456\u0442"\
"\u0442\u0440\u0430\u0432"\
"\u0447\u0435\u0440\u0432"\
"\u043b\u0438\u043f"\
"\u0441\u0435\u0440\u043f"\
"\u0432\u0435\u0440"\
"\u0436\u043e\u0432\u0442"\
"\u043b\u0438\u0441\u0442"\
"\u0433\u0440\u0443\u0434"\
""]
::msgcat::mcset uk MONTHS_FULL [list \
"\u0441\u0456\u0447\u043d\u044f"\
"\u043b\u044e\u0442\u043e\u0433\u043e"\
"\u0431\u0435\u0440\u0435\u0437\u043d\u044f"\
"\u043a\u0432\u0456\u0442\u043d\u044f"\
"\u0442\u0440\u0430\u0432\u043d\u044f"\
"\u0447\u0435\u0440\u0432\u043d\u044f"\
"\u043b\u0438\u043f\u043d\u044f"\
"\u0441\u0435\u0440\u043f\u043d\u044f"\
"\u0432\u0435\u0440\u0435\u0441\u043d\u044f"\
"\u0436\u043e\u0432\u0442\u043d\u044f"\
"\u043b\u0438\u0441\u0442\u043e\u043f\u0430\u0434\u0430"\
"\u0433\u0440\u0443\u0434\u043d\u044f"\
""]
::msgcat::mcset uk BCE "\u0434\u043e \u043d.\u0435."
::msgcat::mcset uk CE "\u043f\u0456\u0441\u043b\u044f \u043d.\u0435."
::msgcat::mcset uk DATE_FORMAT "%e/%m/%Y"
::msgcat::mcset uk TIME_FORMAT "%k:%M:%S"
::msgcat::mcset uk DATE_TIME_FORMAT "%e/%m/%Y %k:%M:%S %z"
}
PK ! g{g g msgs/pt.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset pt DAYS_OF_WEEK_ABBREV [list \
"Dom"\
"Seg"\
"Ter"\
"Qua"\
"Qui"\
"Sex"\
"S\u00e1b"]
::msgcat::mcset pt DAYS_OF_WEEK_FULL [list \
"Domingo"\
"Segunda-feira"\
"Ter\u00e7a-feira"\
"Quarta-feira"\
"Quinta-feira"\
"Sexta-feira"\
"S\u00e1bado"]
::msgcat::mcset pt MONTHS_ABBREV [list \
"Jan"\
"Fev"\
"Mar"\
"Abr"\
"Mai"\
"Jun"\
"Jul"\
"Ago"\
"Set"\
"Out"\
"Nov"\
"Dez"\
""]
::msgcat::mcset pt MONTHS_FULL [list \
"Janeiro"\
"Fevereiro"\
"Mar\u00e7o"\
"Abril"\
"Maio"\
"Junho"\
"Julho"\
"Agosto"\
"Setembro"\
"Outubro"\
"Novembro"\
"Dezembro"\
""]
::msgcat::mcset pt DATE_FORMAT "%d-%m-%Y"
::msgcat::mcset pt TIME_FORMAT "%k:%M:%S"
::msgcat::mcset pt DATE_TIME_FORMAT "%d-%m-%Y %k:%M:%S %z"
}
PK ! 3 msgs/nb.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset nb DAYS_OF_WEEK_ABBREV [list \
"s\u00f8"\
"ma"\
"ti"\
"on"\
"to"\
"fr"\
"l\u00f8"]
::msgcat::mcset nb DAYS_OF_WEEK_FULL [list \
"s\u00f8ndag"\
"mandag"\
"tirsdag"\
"onsdag"\
"torsdag"\
"fredag"\
"l\u00f8rdag"]
::msgcat::mcset nb MONTHS_ABBREV [list \
"jan"\
"feb"\
"mar"\
"apr"\
"mai"\
"jun"\
"jul"\
"aug"\
"sep"\
"okt"\
"nov"\
"des"\
""]
::msgcat::mcset nb MONTHS_FULL [list \
"januar"\
"februar"\
"mars"\
"april"\
"mai"\
"juni"\
"juli"\
"august"\
"september"\
"oktober"\
"november"\
"desember"\
""]
::msgcat::mcset nb BCE "f.Kr."
::msgcat::mcset nb CE "e.Kr."
::msgcat::mcset nb DATE_FORMAT "%e. %B %Y"
::msgcat::mcset nb TIME_FORMAT "%H:%M:%S"
::msgcat::mcset nb DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z"
}
PK ! m msgs/ta_in.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset ta_IN DATE_FORMAT "%d %M %Y"
::msgcat::mcset ta_IN TIME_FORMAT_12 "%I:%M:%S %P"
::msgcat::mcset ta_IN DATE_TIME_FORMAT "%d %M %Y %I:%M:%S %P %z"
}
PK ! 7P msgs/ms_my.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset ms_MY DATE_FORMAT "%A %d %b %Y"
::msgcat::mcset ms_MY TIME_FORMAT_12 "%I:%M:%S %z"
::msgcat::mcset ms_MY DATE_TIME_FORMAT "%A %d %b %Y %I:%M:%S %z %z"
}
PK ! 1 msgs/it_ch.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset it_CH DATE_FORMAT "%e. %B %Y"
::msgcat::mcset it_CH TIME_FORMAT "%H:%M:%S"
::msgcat::mcset it_CH DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z"
}
PK ! )j msgs/sv.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset sv DAYS_OF_WEEK_ABBREV [list \
"s\u00f6"\
"m\u00e5"\
"ti"\
"on"\
"to"\
"fr"\
"l\u00f6"]
::msgcat::mcset sv DAYS_OF_WEEK_FULL [list \
"s\u00f6ndag"\
"m\u00e5ndag"\
"tisdag"\
"onsdag"\
"torsdag"\
"fredag"\
"l\u00f6rdag"]
::msgcat::mcset sv MONTHS_ABBREV [list \
"jan"\
"feb"\
"mar"\
"apr"\
"maj"\
"jun"\
"jul"\
"aug"\
"sep"\
"okt"\
"nov"\
"dec"\
""]
::msgcat::mcset sv MONTHS_FULL [list \
"januari"\
"februari"\
"mars"\
"april"\
"maj"\
"juni"\
"juli"\
"augusti"\
"september"\
"oktober"\
"november"\
"december"\
""]
::msgcat::mcset sv BCE "f.Kr."
::msgcat::mcset sv CE "e.Kr."
::msgcat::mcset sv DATE_FORMAT "%Y-%m-%d"
::msgcat::mcset sv TIME_FORMAT "%H:%M:%S"
::msgcat::mcset sv DATE_TIME_FORMAT "%Y-%m-%d %H:%M:%S %z"
}
PK ! 5j( msgs/nl_be.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset nl_BE DATE_FORMAT "%d-%m-%y"
::msgcat::mcset nl_BE TIME_FORMAT "%T"
::msgcat::mcset nl_BE TIME_FORMAT_12 "%T"
::msgcat::mcset nl_BE DATE_TIME_FORMAT "%a %d %b %Y %T %z"
}
PK ! . msgs/sw.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset sw DAYS_OF_WEEK_ABBREV [list \
"Jpi"\
"Jtt"\
"Jnn"\
"Jtn"\
"Alh"\
"Iju"\
"Jmo"]
::msgcat::mcset sw DAYS_OF_WEEK_FULL [list \
"Jumapili"\
"Jumatatu"\
"Jumanne"\
"Jumatano"\
"Alhamisi"\
"Ijumaa"\
"Jumamosi"]
::msgcat::mcset sw MONTHS_ABBREV [list \
"Jan"\
"Feb"\
"Mar"\
"Apr"\
"Mei"\
"Jun"\
"Jul"\
"Ago"\
"Sep"\
"Okt"\
"Nov"\
"Des"\
""]
::msgcat::mcset sw MONTHS_FULL [list \
"Januari"\
"Februari"\
"Machi"\
"Aprili"\
"Mei"\
"Juni"\
"Julai"\
"Agosti"\
"Septemba"\
"Oktoba"\
"Novemba"\
"Desemba"\
""]
::msgcat::mcset sw BCE "KK"
::msgcat::mcset sw CE "BK"
}
PK ! .̼ msgs/ar.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset ar DAYS_OF_WEEK_ABBREV [list \
"\u062d"\
"\u0646"\
"\u062b"\
"\u0631"\
"\u062e"\
"\u062c"\
"\u0633"]
::msgcat::mcset ar DAYS_OF_WEEK_FULL [list \
"\u0627\u0644\u0623\u062d\u062f"\
"\u0627\u0644\u0627\u062b\u0646\u064a\u0646"\
"\u0627\u0644\u062b\u0644\u0627\u062b\u0627\u0621"\
"\u0627\u0644\u0623\u0631\u0628\u0639\u0627\u0621"\
"\u0627\u0644\u062e\u0645\u064a\u0633"\
"\u0627\u0644\u062c\u0645\u0639\u0629"\
"\u0627\u0644\u0633\u0628\u062a"]
::msgcat::mcset ar MONTHS_ABBREV [list \
"\u064a\u0646\u0627"\
"\u0641\u0628\u0631"\
"\u0645\u0627\u0631"\
"\u0623\u0628\u0631"\
"\u0645\u0627\u064a"\
"\u064a\u0648\u0646"\
"\u064a\u0648\u0644"\
"\u0623\u063a\u0633"\
"\u0633\u0628\u062a"\
"\u0623\u0643\u062a"\
"\u0646\u0648\u0641"\
"\u062f\u064a\u0633"\
""]
::msgcat::mcset ar MONTHS_FULL [list \
"\u064a\u0646\u0627\u064a\u0631"\
"\u0641\u0628\u0631\u0627\u064a\u0631"\
"\u0645\u0627\u0631\u0633"\
"\u0623\u0628\u0631\u064a\u0644"\
"\u0645\u0627\u064a\u0648"\
"\u064a\u0648\u0646\u064a\u0648"\
"\u064a\u0648\u0644\u064a\u0648"\
"\u0623\u063a\u0633\u0637\u0633"\
"\u0633\u0628\u062a\u0645\u0628\u0631"\
"\u0623\u0643\u062a\u0648\u0628\u0631"\
"\u0646\u0648\u0641\u0645\u0628\u0631"\
"\u062f\u064a\u0633\u0645\u0628\u0631"\
""]
::msgcat::mcset ar BCE "\u0642.\u0645"
::msgcat::mcset ar CE "\u0645"
::msgcat::mcset ar AM "\u0635"
::msgcat::mcset ar PM "\u0645"
::msgcat::mcset ar DATE_FORMAT "%d/%m/%Y"
::msgcat::mcset ar TIME_FORMAT_12 "%I:%M:%S %P"
::msgcat::mcset ar DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z"
}
PK ! < msgs/et.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset et DAYS_OF_WEEK_ABBREV [list \
"P"\
"E"\
"T"\
"K"\
"N"\
"R"\
"L"]
::msgcat::mcset et DAYS_OF_WEEK_FULL [list \
"p\u00fchap\u00e4ev"\
"esmasp\u00e4ev"\
"teisip\u00e4ev"\
"kolmap\u00e4ev"\
"neljap\u00e4ev"\
"reede"\
"laup\u00e4ev"]
::msgcat::mcset et MONTHS_ABBREV [list \
"Jaan"\
"Veebr"\
"M\u00e4rts"\
"Apr"\
"Mai"\
"Juuni"\
"Juuli"\
"Aug"\
"Sept"\
"Okt"\
"Nov"\
"Dets"\
""]
::msgcat::mcset et MONTHS_FULL [list \
"Jaanuar"\
"Veebruar"\
"M\u00e4rts"\
"Aprill"\
"Mai"\
"Juuni"\
"Juuli"\
"August"\
"September"\
"Oktoober"\
"November"\
"Detsember"\
""]
::msgcat::mcset et BCE "e.m.a."
::msgcat::mcset et CE "m.a.j."
::msgcat::mcset et DATE_FORMAT "%e-%m-%Y"
::msgcat::mcset et TIME_FORMAT "%k:%M:%S"
::msgcat::mcset et DATE_TIME_FORMAT "%e-%m-%Y %k:%M:%S %z"
}
PK ! G msgs/te_in.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset te_IN AM "\u0c2a\u0c42\u0c30\u0c4d\u0c35\u0c3e\u0c39\u0c4d\u0c28"
::msgcat::mcset te_IN PM "\u0c05\u0c2a\u0c30\u0c3e\u0c39\u0c4d\u0c28"
::msgcat::mcset te_IN DATE_FORMAT "%d/%m/%Y"
::msgcat::mcset te_IN TIME_FORMAT_12 "%I:%M:%S %P"
::msgcat::mcset te_IN DATE_TIME_FORMAT "%d/%m/%Y %I:%M:%S %P %z"
}
PK ! msgs/fr.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset fr DAYS_OF_WEEK_ABBREV [list \
"dim."\
"lun."\
"mar."\
"mer."\
"jeu."\
"ven."\
"sam."]
::msgcat::mcset fr DAYS_OF_WEEK_FULL [list \
"dimanche"\
"lundi"\
"mardi"\
"mercredi"\
"jeudi"\
"vendredi"\
"samedi"]
::msgcat::mcset fr MONTHS_ABBREV [list \
"janv."\
"f\u00e9vr."\
"mars"\
"avr."\
"mai"\
"juin"\
"juil."\
"ao\u00fbt"\
"sept."\
"oct."\
"nov."\
"d\u00e9c."\
""]
::msgcat::mcset fr MONTHS_FULL [list \
"janvier"\
"f\u00e9vrier"\
"mars"\
"avril"\
"mai"\
"juin"\
"juillet"\
"ao\u00fbt"\
"septembre"\
"octobre"\
"novembre"\
"d\u00e9cembre"\
""]
::msgcat::mcset fr BCE "av. J.-C."
::msgcat::mcset fr CE "ap. J.-C."
::msgcat::mcset fr DATE_FORMAT "%e %B %Y"
::msgcat::mcset fr TIME_FORMAT "%H:%M:%S"
::msgcat::mcset fr DATE_TIME_FORMAT "%e %B %Y %H:%M:%S %z"
}
PK ! ;B msgs/he.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset he DAYS_OF_WEEK_ABBREV [list \
"\u05d0"\
"\u05d1"\
"\u05d2"\
"\u05d3"\
"\u05d4"\
"\u05d5"\
"\u05e9"]
::msgcat::mcset he DAYS_OF_WEEK_FULL [list \
"\u05d9\u05d5\u05dd \u05e8\u05d0\u05e9\u05d5\u05df"\
"\u05d9\u05d5\u05dd \u05e9\u05e0\u05d9"\
"\u05d9\u05d5\u05dd \u05e9\u05dc\u05d9\u05e9\u05d9"\
"\u05d9\u05d5\u05dd \u05e8\u05d1\u05d9\u05e2\u05d9"\
"\u05d9\u05d5\u05dd \u05d7\u05de\u05d9\u05e9\u05d9"\
"\u05d9\u05d5\u05dd \u05e9\u05d9\u05e9\u05d9"\
"\u05e9\u05d1\u05ea"]
::msgcat::mcset he MONTHS_ABBREV [list \
"\u05d9\u05e0\u05d5"\
"\u05e4\u05d1\u05e8"\
"\u05de\u05e8\u05e5"\
"\u05d0\u05e4\u05e8"\
"\u05de\u05d0\u05d9"\
"\u05d9\u05d5\u05e0"\
"\u05d9\u05d5\u05dc"\
"\u05d0\u05d5\u05d2"\
"\u05e1\u05e4\u05d8"\
"\u05d0\u05d5\u05e7"\
"\u05e0\u05d5\u05d1"\
"\u05d3\u05e6\u05de"\
""]
::msgcat::mcset he MONTHS_FULL [list \
"\u05d9\u05e0\u05d5\u05d0\u05e8"\
"\u05e4\u05d1\u05e8\u05d5\u05d0\u05e8"\
"\u05de\u05e8\u05e5"\
"\u05d0\u05e4\u05e8\u05d9\u05dc"\
"\u05de\u05d0\u05d9"\
"\u05d9\u05d5\u05e0\u05d9"\
"\u05d9\u05d5\u05dc\u05d9"\
"\u05d0\u05d5\u05d2\u05d5\u05e1\u05d8"\
"\u05e1\u05e4\u05d8\u05de\u05d1\u05e8"\
"\u05d0\u05d5\u05e7\u05d8\u05d5\u05d1\u05e8"\
"\u05e0\u05d5\u05d1\u05de\u05d1\u05e8"\
"\u05d3\u05e6\u05de\u05d1\u05e8"\
""]
::msgcat::mcset he BCE "\u05dc\u05e1\u05d4\u0022\u05e0"
::msgcat::mcset he CE "\u05dc\u05e4\u05e1\u05d4\u0022\u05e0"
::msgcat::mcset he DATE_FORMAT "%d/%m/%Y"
::msgcat::mcset he TIME_FORMAT "%H:%M:%S"
::msgcat::mcset he DATE_TIME_FORMAT "%d/%m/%Y %H:%M:%S %z"
}
PK ! '$ msgs/bn_in.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset bn_IN DATE_FORMAT "%A %d %b %Y"
::msgcat::mcset bn_IN TIME_FORMAT_12 "%I:%M:%S %z"
::msgcat::mcset bn_IN DATE_TIME_FORMAT "%A %d %b %Y %I:%M:%S %z %z"
}
PK ! `+9 9 msgs/be.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset be DAYS_OF_WEEK_ABBREV [list \
"\u043d\u0434"\
"\u043f\u043d"\
"\u0430\u0442"\
"\u0441\u0440"\
"\u0447\u0446"\
"\u043f\u0442"\
"\u0441\u0431"]
::msgcat::mcset be DAYS_OF_WEEK_FULL [list \
"\u043d\u044f\u0434\u0437\u0435\u043b\u044f"\
"\u043f\u0430\u043d\u044f\u0434\u0437\u0435\u043b\u0430\u043a"\
"\u0430\u045e\u0442\u043e\u0440\u0430\u043a"\
"\u0441\u0435\u0440\u0430\u0434\u0430"\
"\u0447\u0430\u0446\u0432\u0435\u0440"\
"\u043f\u044f\u0442\u043d\u0456\u0446\u0430"\
"\u0441\u0443\u0431\u043e\u0442\u0430"]
::msgcat::mcset be MONTHS_ABBREV [list \
"\u0441\u0442\u0434"\
"\u043b\u044e\u0442"\
"\u0441\u043a\u0432"\
"\u043a\u0440\u0441"\
"\u043c\u0430\u0439"\
"\u0447\u0440\u0432"\
"\u043b\u043f\u043d"\
"\u0436\u043d\u0432"\
"\u0432\u0440\u0441"\
"\u043a\u0441\u0442"\
"\u043b\u0441\u0442"\
"\u0441\u043d\u0436"\
""]
::msgcat::mcset be MONTHS_FULL [list \
"\u0441\u0442\u0443\u0434\u0437\u0435\u043d\u044f"\
"\u043b\u044e\u0442\u0430\u0433\u0430"\
"\u0441\u0430\u043a\u0430\u0432\u0456\u043a\u0430"\
"\u043a\u0440\u0430\u0441\u0430\u0432\u0456\u043a\u0430"\
"\u043c\u0430\u044f"\
"\u0447\u0440\u0432\u0435\u043d\u044f"\
"\u043b\u0456\u043f\u0435\u043d\u044f"\
"\u0436\u043d\u0456\u045e\u043d\u044f"\
"\u0432\u0435\u0440\u0430\u0441\u043d\u044f"\
"\u043a\u0430\u0441\u0442\u0440\u044b\u0447\u043d\u0456\u043a\u0430"\
"\u043b\u0438\u0441\u0442\u0430\u043f\u0430\u0434\u0430"\
"\u0441\u043d\u0435\u0436\u043d\u044f"\
""]
::msgcat::mcset be BCE "\u0434\u0430 \u043d.\u0435."
::msgcat::mcset be CE "\u043d.\u0435."
::msgcat::mcset be DATE_FORMAT "%e.%m.%Y"
::msgcat::mcset be TIME_FORMAT "%k.%M.%S"
::msgcat::mcset be DATE_TIME_FORMAT "%e.%m.%Y %k.%M.%S %z"
}
PK ! a msgs/af_za.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset af_ZA DATE_FORMAT "%d %B %Y"
::msgcat::mcset af_ZA TIME_FORMAT_12 "%l:%M:%S %P"
::msgcat::mcset af_ZA DATE_TIME_FORMAT "%d %B %Y %l:%M:%S %P %z"
}
PK ! Lp; msgs/mr.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset mr DAYS_OF_WEEK_FULL [list \
"\u0930\u0935\u093f\u0935\u093e\u0930"\
"\u0938\u094b\u092e\u0935\u093e\u0930"\
"\u092e\u0902\u0917\u0933\u0935\u093e\u0930"\
"\u092e\u0902\u0917\u0933\u0935\u093e\u0930"\
"\u0917\u0941\u0930\u0941\u0935\u093e\u0930"\
"\u0936\u0941\u0915\u094d\u0930\u0935\u093e\u0930"\
"\u0936\u0928\u093f\u0935\u093e\u0930"]
::msgcat::mcset mr MONTHS_ABBREV [list \
"\u091c\u093e\u0928\u0947\u0935\u093e\u0930\u0940"\
"\u092b\u0947\u092c\u0943\u0935\u093e\u0930\u0940"\
"\u092e\u093e\u0930\u094d\u091a"\
"\u090f\u092a\u094d\u0930\u093f\u0932"\
"\u092e\u0947"\
"\u091c\u0942\u0928"\
"\u091c\u0941\u0932\u0948"\
"\u0913\u0917\u0938\u094d\u091f"\
"\u0938\u0947\u092a\u094d\u091f\u0947\u0902\u092c\u0930"\
"\u0913\u0915\u094d\u091f\u094b\u092c\u0930"\
"\u0928\u094b\u0935\u094d\u0939\u0947\u0902\u092c\u0930"\
"\u0921\u093f\u0938\u0947\u0902\u092c\u0930"]
::msgcat::mcset mr MONTHS_FULL [list \
"\u091c\u093e\u0928\u0947\u0935\u093e\u0930\u0940"\
"\u092b\u0947\u092c\u0943\u0935\u093e\u0930\u0940"\
"\u092e\u093e\u0930\u094d\u091a"\
"\u090f\u092a\u094d\u0930\u093f\u0932"\
"\u092e\u0947"\
"\u091c\u0942\u0928"\
"\u091c\u0941\u0932\u0948"\
"\u0913\u0917\u0938\u094d\u091f"\
"\u0938\u0947\u092a\u094d\u091f\u0947\u0902\u092c\u0930"\
"\u0913\u0915\u094d\u091f\u094b\u092c\u0930"\
"\u0928\u094b\u0935\u094d\u0939\u0947\u0902\u092c\u0930"\
"\u0921\u093f\u0938\u0947\u0902\u092c\u0930"]
::msgcat::mcset mr AM "BC"
::msgcat::mcset mr PM "AD"
}
PK ! { 3 msgs/hi_in.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset hi_IN DATE_FORMAT "%d %M %Y"
::msgcat::mcset hi_IN TIME_FORMAT_12 "%I:%M:%S %P"
::msgcat::mcset hi_IN DATE_TIME_FORMAT "%d %M %Y %I:%M:%S %P %z"
}
PK ! HAm7 7 msgs/nl.msgnu [ # created by tools/loadICU.tcl -- do not edit
namespace eval ::tcl::clock {
::msgcat::mcset nl DAYS_OF_WEEK_ABBREV [list \
"zo"\
"ma"\
"di"\
"wo"\
"do"\
"vr"\
"za"]
::msgcat::mcset nl DAYS_OF_WEEK_FULL [list \
"zondag"\
"maandag"\
"dinsdag"\
"woensdag"\
"donderdag"\
"vrijdag"\
"zaterdag"]
::msgcat::mcset nl MONTHS_ABBREV [list \
"jan"\
"feb"\
"mrt"\
"apr"\
"mei"\
"jun"\
"jul"\
"aug"\
"sep"\
"okt"\
"nov"\
"dec"\
""]
::msgcat::mcset nl MONTHS_FULL [list \
"januari"\
"februari"\
"maart"\
"april"\
"mei"\
"juni"\
"juli"\
"augustus"\
"september"\
"oktober"\
"november"\
"december"\
""]
::msgcat::mcset nl DATE_FORMAT "%e %B %Y"
::msgcat::mcset nl TIME_FORMAT "%k:%M:%S"
::msgcat::mcset nl DATE_TIME_FORMAT "%e %B %Y %k:%M:%S %z"
}
PK !