[Arjen Markus] (15 august 2022) During this month's monthly meet-up we discussed, among other things, the
possibilities of DLLs (or shared objects) that contain the Tcl and Tk libraries as well as all the
configuration files. Such "KitDLLs" are part of the [KitCreator] build system by [Roy Keene]. There are more
solutions, like [tclkit], [BAWT], with similar goals and their own pros and cons. But I decided to
have a closer look at [KitCreator], as I thought it might be used to build Fortran programs with Tcl/Tk
as embedded resource. The fact that all configuration files are part of the KitDLL library makes distribution
very easy.
So, I downloaded the source code at [http://kitcreator.rkeene.org/fossil/index] and started building
under MinGW-w64/MSYS2, as that is the build environment on Windows that is close to native Windows and
still support the autotools build tools. Unfortunately, this failed. The crucial error occurred in
building "tclvfs". I have not found the apparent quoting error yet in the generated code:
======none
checking for a BSD-compatible install... /usr/bin/install -c
checking whether make sets $(MAKE)... ./configure: eval: line 2963: unexpected EOF while looking for matching `"'
./configure: eval: line 2964: syntax error: unexpected end of file
+ for tryopt in "${tryopts[@]}" __fail__
+ '[' __fail__ = __fail__ ']'
+ return 1
+ die 'configure failed'
+ local msg
+ msg='configure failed'
+ echo 'configure failed'
configure failed
+ exit 1
======
As is usual with such code in a `configure` file, it is rather convoluted.
Therefore I tried instead a prebuilt KitDLL - the http://www.rkeene.org/devel/kitcreator/kitbuild/nightly/%|%Tclkit for Tcl version 8.6.12 for Win64 on amd64%|%.
The file is called `libtclkit-8.6.12-win64-amd64-kitdll-xcompile` - this name does not end with `.dll` or `.lib`
as a typical compiler on Windows would expect. I renamed the file to `libtclkit-8.6.12-win64-amd64.dll` and I used the
following tiny source file for `tclsh`:
======c
#include <tcl.h>
int Tcl_AppInit(Tcl_Interp *interp) {
return(Tcl_Init(interp));
}
int main(int argc, char **argv) {
Tcl_Main(argc, argv, Tcl_AppInit);
return(1);
}
======
The relevant include file `tcl.h` comes from a suitable Tcl installation or source tree.
There was one small problem still: on Windows a DLL should be accompanied by a so-called import library.
The GNU gcc compiler, however, circumvents this problem. Or you could use a utility to create one from
the DLL.
----
'''NOTE:'''
You better use, instead, the "software development kit", `sdk`, that is associated with the KitDLL.
It contains the required libraries and include files in a ready form. It does not contain the above sample code for `tclsh`.
----
Anyway, I used the distribution of the GNU compilers from [http://www.equation.com] as they can be used
in an ordinary DOS box (command window). The build step was easy and I got a `tclsh.exe`. However, the
runtime name of the DLL is `libtcl8612.dll`, so I had to rename the DLL to that and it worked!
(As noted above: the SDK contains just about all the files you need with the right names.)
Simple session:
======tcl
> package require Tk
> pack [canvas .c]
> exit
======
I also tried to use a Fortran program to call `Tcl_Main()` and get an easy way to embed Tcl and Tk
in such a program. That did not work immediately, most likely because of the `argv` argument.
By using a C main program and passing the arguments `argc` and `argv` to a Fortran routine,
I did get things to work - albeit in a rather primitive way:
The C main program calls a Fortran routine:
======c
#include <tcl.h>
void ftcl_main( int argc, char **argv );
int main(int argc, char **argv) {
ftcl_main(&argc, argv);
return(1);
}
======
The Fortran code looks like this (mimicking the interfaces to the two Tcl functions):
======none
module ftcl
use iso_c_binding
implicit none
interface
integer function Tcl_Init( interp ) bind(C, name = "Tcl_Init")
import :: c_ptr
type(c_ptr), value :: interp
end function Tcl_Init
end interface
interface
integer function Tcl_Main( argc, argv, inifunc ) bind(C, name = "Tcl_Main")
import :: c_ptr, c_funptr
integer, value :: argc
type(c_ptr), value :: argv
type(c_funptr), value :: inifunc
end function Tcl_Main
end interface
contains
integer function ftcl_appinit( interp ) bind(C, name = "ftcl_appinit")
type(c_ptr), value :: interp
write(*,*) 'In ftcl_appinit'
ftcl_appinit = Tcl_Init( interp )
end function ftcl_appinit
integer function ftcl_main( argc, argv ) bind(C, name = 'ftcl_main')
integer, value :: argc
type(c_ptr), value :: argv
write(*,*) 'In ftcl_main'
ftcl_main = Tcl_Main( argc, argv, c_funloc(ftcl_appinit) )
end function ftcl_main
end module ftcl
======
The ideal is to use a Fortran main program, but the `argv` argument presented some problems.
It took me a bit of experimentation and soul searching, but this Fortran program gives me
the `tclsh` I was looking for:
======
module ftcl
use iso_c_binding
implicit none
interface
integer function Tcl_Init( interp ) bind(C, name = "Tcl_Init")
import :: c_ptr
type(c_ptr), value :: interp
end function Tcl_Init
end interface
interface
integer function Tcl_Main( argc, argv, inifunc ) bind(C, name = "Tcl_Main")
import :: c_ptr, c_funptr
integer, value :: argc
type(c_ptr), value :: argv
type(c_funptr), value :: inifunc
end function Tcl_Main
end interface
contains
integer function ftcl_appinit( interp ) bind(C, name = "ftcl_appinit")
type(c_ptr), value :: interp
ftcl_appinit = Tcl_Init( interp )
end function ftcl_appinit
integer function ftcl_main( inifunc )
interface
integer function inifunc( interp) bind(C)
import :: c_ptr
type(c_ptr), value :: interp
end function inifunc
end interface
integer :: i, length, argc
type(c_ptr), dimension(:), allocatable, target :: argv
character(len=256), dimension(:), allocatable, target :: arg
argc = command_argument_count()
allocate( argv(argc+1), arg(argc+1) )
do i = 0,argc
call get_command_argument( i, arg(i+1) )
length = len_trim(arg(i+1))
arg(i+1)(length+1:) = c_null_char
argv(i+1) = c_loc(arg(i+1))
enddo
ftcl_main = Tcl_Main( argc+1, c_loc(argv), c_funloc(inifunc) )
end function ftcl_main
end module ftcl
program ftclsh
use iso_c_binding
use ftcl
implicit none
type(c_ptr), pointer :: argv
integer :: rc
rc = ftcl_main( ftcl_appinit )
end program ftclsh
======
Most of the above code is dedicated to mimicking the proper interfaces and can be
put into a library. The `iso_c_binding` features hide all the platform dependencies:
the program works with both `gfortran` and `Intel Fortran oneAPI`.
<<categories>>Example|Tclkit