Tk Source Code

# Directory in which to install the demo files:
DEMO_INSTALL_DIR	= $(INSTALL_ROOT)@DEMO_DIR@

# The directory containing the Tcl sources and headers appropriate
# for this version of Tk ("srcdir" will be replaced or has already
# been replaced by the configure script):
TCL_GENERIC_DIR		= @TCL_ACTUAL_SRC_DIR@/generic

# The directory containing the platform specific Tcl sources and headers
# appropriate for this version of Tk:
TCL_PLATFORM_DIR	= @TCL_ACTUAL_SRC_DIR@/unix

# The directory containing the Tcl library archive file appropriate
# for this version of Tk:
TCL_BIN_DIR		= @TCL_BIN_DIR@

# The linker flags needed to link in the Tcl library (ex: -ltcl8.2)
TCL_LIB_FLAG		= @TCL_LIB_FLAG@

RANLIB			= @RANLIB@
SRC_DIR			= @srcdir@
TOP_DIR			= $(SRC_DIR)/..
GENERIC_DIR		= $(TOP_DIR)/generic
TTK_DIR			= $(GENERIC_DIR)/ttk
UNIX_DIR		= $(TOP_DIR)/unix
BMAP_DIR		= $(TOP_DIR)/bitmaps
TOOL_DIR		= @TCL_ACTUAL_SRC_DIR@/tools
TEST_DIR		= $(TOP_DIR)/tests
MAC_OSX_DIR		= $(TOP_DIR)/macosx
XLIB_DIR		= $(TOP_DIR)/xlib

#----------------------------------------------------------------
# The information below should be usable as is.  The configure
# script won't modify it and you shouldn't need to modify it

	$(TTK_HDRS) $(@TK_WINDOWINGSYSTEM@_PRIVATE_HDRS)

DEMOPROGS = browse hello ixset rmt rolodex square tcolor timer widget

SHELL_ENV = \
	@LD_LIBRARY_PATH_VAR@="`pwd`:${TCL_BIN_DIR}:$${@LD_LIBRARY_PATH_VAR@}"; \
	export @LD_LIBRARY_PATH_VAR@; \
	TCL_LIBRARY=@TCL_ACTUAL_SRC_DIR@/library; export TCL_LIBRARY; \
	TK_LIBRARY=@TK_SRC_DIR@/library; export TK_LIBRARY;

all: binaries libraries doc

binaries: ${LIB_FILE} ${WISH_EXE}

libraries:

$(TOP_DIR)/doc/man.macros:
	$(INSTALL_DATA) $(TCLDIR)/doc/man.macros $(TOP_DIR)/doc/man.macros

doc: $(TOP_DIR)/doc/man.macros

# The following target is configured by autoconf to generate either
# a shared library or non-shared library for Tk.
${LIB_FILE}: ${STUB_LIB_FILE} @LIB_RSRC_FILE@ ${OBJS}
	rm -f $@

demo:
	$(SHELL_ENV) ./${WISH_EXE} $(TOP_DIR)/library/demos/widget

# This target can be used to run wish inside either gdb or insight
gdb: ${WISH_EXE}
	@echo "set env @LD_LIBRARY_PATH_VAR@=\"`pwd`:${TCL_BIN_DIR}:$${@LD_LIBRARY_PATH_VAR@}\"" > gdb.run
	@echo "set env TCL_LIBRARY=@TCL_ACTUAL_SRC_DIR@/library" >> gdb.run
	@echo "set env TK_LIBRARY=@TK_SRC_DIR@/library" >> gdb.run
	gdb ./${WISH_EXE} --command=gdb.run
	rm gdb.run

VALGRINDARGS=--tool=memcheck --num-callers=8 --leak-resolution=high --leak-check=yes --show-reachable=yes -v

valgrind: $(TKTEST_EXE)

# to put the distribution.  DISTDIR must be an absolute path name.
#

DISTROOT = /tmp/dist
DISTNAME = tk${VERSION}${PATCH_LEVEL}
ZIPNAME	 = tk${MAJOR_VERSION}${MINOR_VERSION}${PATCH_LEVEL}-src.zip
DISTDIR	 = $(DISTROOT)/$(DISTNAME)
TCLDIR   = @TCL_ACTUAL_SRC_DIR@
DIST_INSTALL_DATA   = CPPROG='cp -p' $(INSTALL) -m 644
DIST_INSTALL_SCRIPT = CPPROG='cp -p' $(INSTALL) -m 755

$(UNIX_DIR)/configure: $(UNIX_DIR)/configure.ac $(UNIX_DIR)/tcl.m4 \
		$(UNIX_DIR)/aclocal.m4
	cd $(UNIX_DIR); autoconf
$(MAC_OSX_DIR)/configure: $(MAC_OSX_DIR)/configure.ac $(UNIX_DIR)/configure

	@EXTRA_BUILD_HTML@

BUILD_HTML = \
	@if test -f "$(BUILD_TCLSH)"; then \
	$(SHELL_ENV) TCLSH="$(BUILD_TCLSH)"; else \
	TCLSH="$(TCL_EXE)"; fi ;\
	"$${TCLSH}" $(TOOL_DIR)/tcltk-man2html.tcl --htmldir="$(HTML_INSTALL_DIR)" \
		--tk --srcdir=$(TOP_DIR) $(BUILD_HTML_FLAGS)

#
# The list of all the targets that do not correspond to real files. This stops
# 'make' from getting confused when someone makes an error in a rule.
#

.PHONY: all binaries libraries objs doc html html-tcl html-tk test runtest

EXEEXT
ac_ct_CC
CPPFLAGS
LDFLAGS
CFLAGS
CC
MAN_FLAGS


TCL_STUB_LIB_SPEC
TCL_STUB_LIB_FLAG
TCL_STUB_LIB_FILE
TCL_LIB_SPEC
TCL_LIB_FLAG
TCL_LIB_FILE
TCL_SRC_DIR
TCL_BIN_DIR
TCL_PATCH_LEVEL
TCL_VERSION
TCL_ACTUAL_SRC_DIR
TCL_SOURCE_MINOR_VERSION
TCL_SOURCE_MAJOR_VERSION
BUILD_TCLSH
TCLSH_PROG
target_alias
host_alias
build_alias
LIBS
ECHO_T
ECHO_N
ECHO_C

VERSION=${TK_VERSION}
LOCALES="cs da de el en en_gb eo es fr hu it nl pl pt ru sv"

#--------------------------------------------------------------------
# Find and load the tclConfig.sh file
#--------------------------------------------------------------------

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for tclsh" >&5
$as_echo_n "checking for tclsh... " >&6; }
    if ${ac_cv_path_tclsh+:} false; then :
  $as_echo_n "(cached) " >&6
else

	search_path=`echo ${PATH} | sed -e 's/:/ /g'`
	for dir in $search_path ; do
	    for j in `ls -r $dir/tclsh[8-9]* 2> /dev/null` \
		    `ls -r $dir/tclsh* 2> /dev/null` ; do
		if test x"$ac_cv_path_tclsh" = x ; then
		    if test -f "$j" ; then
			ac_cv_path_tclsh=$j
			break
		    fi
		fi
	    done
	done

fi


    if test -f "$ac_cv_path_tclsh" ; then
	TCLSH_PROG="$ac_cv_path_tclsh"
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $TCLSH_PROG" >&5
$as_echo "$TCLSH_PROG" >&6; }
    else
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: No tclsh avaliable" >&5
$as_echo "No tclsh avaliable" >&6; }
    fi



    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for tclsh in Tcl build directory" >&5
$as_echo_n "checking for tclsh in Tcl build directory... " >&6; }
    BUILD_TCLSH="${TCL_BIN_DIR}"/tclsh
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_TCLSH" >&5
$as_echo "$BUILD_TCLSH" >&6; }




    #
    # Ok, lets find the tcl configuration
    # First, look for one uninstalled.
    # the alternative search directory is invoked by --with-tcl
    #

    # eval is required to do the TCL_DBGX substitution
    eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\""
    eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\""
    eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\""
    eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\""


    TCL_ACTUAL_SRC_DIR=` <<-'EOF' "$TCLSH_PROG" - "$srcdir" "$TCL_SRC_DIR" \
	"$TCL_MAJOR_VERSION" "$TCL_MINOR_VERSION"

    proc cat fname {
	set chan [open $fname]
	try {
	    read $chan
	} finally {
	    close $chan
	}
    }

    proc main {argv0 argv} {
	try {
	    lassign $argv -> srcdir tcl_src_dir majortarget minortarget
	    lappend candidates $tcl_src_dir
	    set srcdir [file dirname [file normalize $srcdir/...]]
	    set topsrcdir [file dirname $srcdir]
	    set sources [file dirname $topsrcdir]
	    foreach dirname [glob -nocomplain -directory $sources *] {
		if {$dirname ni $candidates} {
		    lappend candidates $dirname
		}
	    }
	    foreach candidate $candidates {
		set res [check $candidate $majortarget $minortarget]
		if {$res eq {}} continue else {
		    puts -nonewline $res
		    break
		}
	    }
	    set status 0
	} on error {tres topts} {
	    puts stderr [dict get $topts -errorinfo]
	    set status 1
	}
	exit $status
    }

    proc check {candidate majortarget minortarget} {
	set tclh $candidate/generic/tcl.h

	if {![file exists $tclh]} {
	    return {}
	}

	set version [tclhversion [cat $tclh]]
	if {[llength $version]} {
	    lassign $version major minor
	    if {[package vcompare $major.$minor \
		$majortarget.$minortarget] >= 0} {
		return [list $candidate $major $minor]
	    }
	}

	return {}
    }

    proc tclhversion data {
	if {[regexp -line {^#define\s+_TCL} $data]} {
	    if {[
		regexp -line {^#define\s+TCL_VERSION\s+\"([^.])+\.([^.\"]+)} \
		    $data -> major minor
	    ]} {
		return [list $major $minor]
	    }
	}
	return {}
    }
    main $argv0 $argv
    EOF

    `

    if test "x${TCL_ACTUAL_SRC_DIR}" = x; then
	as_fn_error $? "could not find Tcl sources" "$LINENO" 5
    else
	TCL_SOURCE_MAJOR_VERSION=` <<-'EOF' "$TCLSH_PROG" - "$TCL_ACTUAL_SRC_DIR " "1"
	proc main {argv0 argv} {
	    try {
		lassign $argv -> list index
		puts -nonewline [lindex $list $index]
		set status 0
	    } on error {tres topts} {
		puts stderr [dict get $topts -errorinfo]
		set status 1
	    }
	    exit $status
	}
	main $argv0 $argv
	EOF
    `




	TCL_SOURCE_MINOR_VERSION=` <<-'EOF' "$TCLSH_PROG" - "$TCL_ACTUAL_SRC_DIR " "2"
	proc main {argv0 argv} {
	    try {
		lassign $argv -> list index
		puts -nonewline [lindex $list $index]
		set status 0
	    } on error {tres topts} {
		puts stderr [dict get $topts -errorinfo]
		set status 1
	    }
	    exit $status
	}
	main $argv0 $argv
	EOF
    `




	TCL_ACTUAL_SRC_DIR=` <<-'EOF' "$TCLSH_PROG" - "$TCL_ACTUAL_SRC_DIR " "0"
	proc main {argv0 argv} {
	    try {
		lassign $argv -> list index
		puts -nonewline [lindex $list $index]
		set status 0
	    } on error {tres topts} {
		puts stderr [dict get $topts -errorinfo]
		set status 1
	    }
	    exit $status
	}
	main $argv0 $argv
	EOF
    `




    fi

Found config for Tcl ${TCL_VERSION}" "$LINENO" 5
fi
if test "${TCL_MINOR_VERSION}" -lt 6 ; then
    as_fn_error $? "${PACKAGE_NAME} ${PACKAGE_VERSION} requires Tcl 8.6+
Found config for Tcl ${TCL_VERSION}" "$LINENO" 5
fi
fi













































#------------------------------------------------------------------------
# Handle the --prefix=... option
#------------------------------------------------------------------------

if test "${prefix}" = "NONE"; then

TK_PATCH_LEVEL="a2"
VERSION=${TK_VERSION}
LOCALES="cs da de el en en_gb eo es fr hu it nl pl pt ru sv"

#--------------------------------------------------------------------
# Find and load the tclConfig.sh file
#--------------------------------------------------------------------
SC_PROG_TCLSH
SC_BUILD_TCLSH

SC_PATH_TCLCONFIG
SC_LOAD_TCLCONFIG

if test "${TCL_MAJOR_VERSION}" -lt 9 ; then
if test "${TCL_MAJOR_VERSION}" -ne 8 ; then
    AC_MSG_ERROR([${PACKAGE_NAME} ${PACKAGE_VERSION} requires Tcl 8.6+
Found config for Tcl ${TCL_VERSION}])
fi
if test "${TCL_MINOR_VERSION}" -lt 6 ; then
    AC_MSG_ERROR([${PACKAGE_NAME} ${PACKAGE_VERSION} requires Tcl 8.6+
Found config for Tcl ${TCL_VERSION}])
fi
fi




#------------------------------------------------------------------------
# Handle the --prefix=... option
#------------------------------------------------------------------------

if test "${prefix}" = "NONE"; then
    prefix="$TCL_PREFIX"

    fi

    # eval is required to do the TCL_DBGX substitution
    eval "TCL_LIB_FLAG=\"${TCL_LIB_FLAG}\""
    eval "TCL_LIB_SPEC=\"${TCL_LIB_SPEC}\""
    eval "TCL_STUB_LIB_FLAG=\"${TCL_STUB_LIB_FLAG}\""
    eval "TCL_STUB_LIB_SPEC=\"${TCL_STUB_LIB_SPEC}\""

	SC_TCL_FIND_SOURCES()

    AC_SUBST(TCL_VERSION)
    AC_SUBST(TCL_PATCH_LEVEL)
    AC_SUBST(TCL_BIN_DIR)
    AC_SUBST(TCL_SRC_DIR)

    AC_SUBST(TCL_LIB_FILE)

    AC_SUBST(TK_LIB_SPEC)

    AC_SUBST(TK_STUB_LIB_FILE)
    AC_SUBST(TK_STUB_LIB_FLAG)
    AC_SUBST(TK_STUB_LIB_SPEC)
])


#------------------------------------------------------------------------
# SC_TCL_FIND_SOURCES
#	Find a directory containing Tcl sources that match the version required by
#	tclConfig.sh.  The sources indicated by tclConfig.sh are preferred.
#
# Arguments:
#	none
#
# Results:
#	Substitutes the following vars:
#		TCL_SOURCE_MAJOR_VERSION
#		TCL_SOURCE_MINOR_VERSION
#		TCL_ACTUAL_SRC_DIR
#------------------------------------------------------------------------

AC_DEFUN([SC_TCL_FIND_SOURCES],[
    [TCL_ACTUAL_SRC_DIR=` <<-'EOF' "$TCLSH_PROG" - "$srcdir" "$TCL_SRC_DIR" \
	"$TCL_MAJOR_VERSION" "$TCL_MINOR_VERSION"

    proc cat fname {
	set chan [open $fname]
	try {
	    read $chan
	} finally {
	    close $chan
	}
    }

    proc main {argv0 argv} {
	try {
	    lassign $argv -> srcdir tcl_src_dir majortarget minortarget
	    lappend candidates $tcl_src_dir
	    set srcdir [file dirname [file normalize $srcdir/...]]
	    set topsrcdir [file dirname $srcdir]
	    set sources [file dirname $topsrcdir]
	    foreach dirname [glob -nocomplain -directory $sources *] {
		if {$dirname ni $candidates} {
		    lappend candidates $dirname
		}
	    }
	    foreach candidate $candidates {
		set res [check $candidate $majortarget $minortarget]
		if {$res eq {}} continue else {
		    puts -nonewline $res
		    break
		}
	    }
	    set status 0
	} on error {tres topts} {
	    puts stderr [dict get $topts -errorinfo]
	    set status 1
	}
	exit $status
    }

    proc check {candidate majortarget minortarget} {
	set tclh $candidate/generic/tcl.h

	if {![file exists $tclh]} {
	    return {}
	}

	set version [tclhversion [cat $tclh]]
	if {[llength $version]} {
	    lassign $version major minor
	    if {[package vcompare $major.$minor \
		$majortarget.$minortarget] >= 0} {
		return [list $candidate $major $minor]
	    }
	}

	return {}
    }

    proc tclhversion data {
	if {[regexp -line {^#define\s+_TCL} $data]} {
	    if {[
		regexp -line {^#define\s+TCL_VERSION\s+\"([^.])+\.([^.\"]+)} \
		    $data -> major minor
	    ]} {
		return [list $major $minor]
	    }
	}
	return {}
    }
    main $argv0 $argv
    EOF
    ]
    `

    if test "x${TCL_ACTUAL_SRC_DIR}" = x; then
	AC_MSG_ERROR([could not find Tcl sources])
    else
	TCL_SOURCE_MAJOR_VERSION=SC_TCL_LINDEX([$TCL_ACTUAL_SRC_DIR] ,1)
	AC_SUBST(TCL_SOURCE_MAJOR_VERSION)
	TCL_SOURCE_MINOR_VERSION=SC_TCL_LINDEX([$TCL_ACTUAL_SRC_DIR] ,2)
	AC_SUBST(TCL_SOURCE_MINOR_VERSION)
	TCL_ACTUAL_SRC_DIR=SC_TCL_LINDEX([$TCL_ACTUAL_SRC_DIR] ,0)
	AC_SUBST(TCL_ACTUAL_SRC_DIR)
    fi
])


#------------------------------------------------------------------------
# SC_TCL_LINDEX
#------------------------------------------------------------------------

AC_DEFUN([SC_TCL_LINDEX],
    [[` <<-'EOF' "$TCLSH_PROG" - "$1" "$2"
	proc main {argv0 argv} {
	    try {
		lassign $argv -> list index
		puts -nonewline [lindex $list $index]
		set status 0
	    } on error {tres topts} {
		puts stderr [dict get $topts -errorinfo]
		set status 1
	    }
	    exit $status
	}
	main $argv0 $argv
	EOF
    `
    ]]

)

#------------------------------------------------------------------------
# SC_PROG_TCLSH
#	Locate a tclsh shell installed on the system path. This macro
#	will only find a Tcl shell that already exists on the system.
#	It will not find a Tcl shell in the Tcl build directory or
#	a Tcl shell that has been installed from the Tcl build directory.
#	If a Tcl shell can't be located on the PATH, then TCLSH_PROG will

	done
    ])

    if test -f "$ac_cv_path_tclsh" ; then
	TCLSH_PROG="$ac_cv_path_tclsh"
	AC_MSG_RESULT([$TCLSH_PROG])
    else


	AC_MSG_RESULT([No tclsh avaliable])
    fi
    AC_SUBST(TCLSH_PROG)
])

#------------------------------------------------------------------------
# SC_BUILD_TCLSH
#	Determine the fully qualified path name of the tclsh executable