[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [Chicken-users] Noob question: (re)compile FFI-accessing code within
Re: [Chicken-users] Noob question: (re)compile FFI-accessing code within REPL
Mon, 02 Jul 2007 10:12:03 +0000
Mozilla Thunderbird 1.0.7-1.1.fc3 (X11/20050929)
Graham, many thanks for you reply; your pointers were very helpful.
First: another question. Then: a few comments regarding chicken based on
my (limited) use.
Question: there seem to be several ways to load a scheme source file:
What are the differences, and which should I prefer?
Second: some comments on chicken:
Chicken on unix works very well. The integration with emacs via quack is
quite good, although not quite as good as, say, SBCL with slime (since
that has auto-completion in emacs; as mentioned in my previous email, I
can get it in csi REPL, but not from within emacs). chicken-setup works
beautifully, with the caveat that it dumps what seems like
implementation files in the directory from which the command was run. In
order to keep things tidy, this requires me to always switch to a
standard directory (I put mine in ~/programming/scheme/chicken/eggs).
I've played around with a few eggs, such as csv, readline, man, openal,
octave -- and I'm very impressed with the fact that they Just Work. This
is probably attributable to chicken's multiple and excellent FFI
interfaces. This really invites the programmer to reuse existing C
libraries -- and is indeed one primary reason I'm interested in Chicken.
On windows, it's a whole different story. I didn't manage to get the
setup that I wanted. I'm not sure if that's because what I wanted can't
be done, or if I did the setup wrong, etc. What I wanted was to
*program* in a "unix-like" environment -- like MSYS -- but *targetting*
native windows applications -- no extra, special cygwin dlls or the
like. So I tried, and actually succeeded (after several aborted
attempts) to build using CMake with MSYS buildfiles, having installed
MSYS and MinGW into C:\MSYS\1.0 and C:\mingw, respectively. I realized
after searching more on google, that while csi works from a windows
CMD.EXE, it doesn't work from an MSYS rxvt -- in order for it to work in
MSYS, I need the command `csi -:c'. No big deal for either of these. But
now the show-stopper: chicken-setup doesn't work properly from either
CMD.EXE or the MSYS shell. On CMD.EXE, chicken-setup crashes because it
attempts to execute a pipe: `gunzip <FILE> | tar xvf -'. Unfortunately
gunzip doesn't exist, and as a result the command fails (even if it did
succeed, I'm not sure that windows supports piping so that the command
would fail at the next step anyway!). So I tried unarchiving the
tarballs myself in MSYS. Unfortunately, this solution is pretty bad.
Firstly, because it only seemed to lead to more problems: on CMD.EXE,
more commands that required "unix-like" features, and on MSYS, I would
get an error message complaining that I couldn't generate executables (I
think the problem is trying to invoke the "standard" gcc windows/msdos
executable from the "cygwin-like" environment that is MSYS). Secondly,
even if I had gotten it to work, it would have been highly impractical
because each egg can have multiple dependencies, and I would need to
repeat the above steps for all the dependencies.
So after spending five hours on the windows installation, I just gave
up. This is a real shame, because win32 should be an ideal platform for
chicken, with its great integration with other languages. It would be
lovely to have a nice win32 GUI wrapper. It would be cool to use
direct-x. It would be cool to be able to use Microsoft Speech API, etc,
etc. And I think the fixes in chicken-setup.scm wouldn't be all that
hard. There should be a new "build-platform" -- msys (currently, there
is only cygwin and windows) -- that does the right thing assuming that
you want to build native windows applications within a MSYS environment.
I've seen a open ticket which details the changes necessary: replacing
the tar and gzip commands with scheme versions that come preinstalled
with the distribution.
More ambitiously, there should be a simple .msi installer which would
query the user for installation directories of MSYS, CMake, MinGW, and
Chicken, and then just unpack everything and possibly build -- so that
at the end of the install, the user is dropped into an MSYS terminal,
with all the tools ready to use. Currently, however, I get the
impression that Windows compatibility is at very best an afterthought.
All in all, I'm very satisfied with Chicken, and will continue to use
chicken for my scheme programming on Unix. I will however, steer clear
of windows, at least until I'm better at scheme programming and I can do
better than just pepper chicken-setup.scm with (print "Got here!")