I've been using CMUCL as a user shell for awhile, it generally works
out fine. Recently, I started trying some of the more advanced
options to various utilities and need away around the following:
CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
which works fine. But wanting to write the commandline options in a
'normal' form, as in:
CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
but is there a leave-the-case-alone function that would pass thru the
above chain?
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
GP lisper wrote:
> I've been using CMUCL as a user shell for awhile, it generally works
> out fine. Recently, I started trying some of the more advanced
> options to various utilities and need away around the following:
>
> CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>
> which works fine. But wanting to write the commandline options in a
> 'normal' form, as in:
>
> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>
> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
> but is there a leave-the-case-alone function that would pass thru the
> above chain?
I'm not sure how you justify calling #'mapcar and #'string part of a
'normal' form for UNIX commands. It seems very abnormal from that point
of view.
I agree that the double-quotes seem somewhat abnormal; from a
programming point of view, however, all those arguments end up as
strings in char **argv, so using symbols instead is unnatural from the
UNIX point of view.
If you want to do this in code, I would suggest a reader macro of some
kind, or, given that you are apparently willing to use ext:run-program,
an ordinary macro, which could digest its symbolic arguments which have
been quoted to preserve case.
If you want to do this interactively, I would suggest a new
read-eval-print loop, which preserves case, and discards some of the
S-expression syntax.
The main use I see of the REPL accepting atoms as well as lists is to
check on the values of variables. UNIX shells provide echo for this
kind of thing. One idea I've been toying with is an implied outer level
of parenthesis
instead of
> (cd "home:lisp;")
home:# cd "home:lisp;"
and have an "echo" which can be used to print out variable values when
needed
home:# echo CWD
--> "home:"
I (perhaps obviously) haven't thought through this much further at all.
The semantics of the car position would probably have to change,
because executing UNIX programs is different from function evaluation
e.g.
home:# + 1 2
--> 3
home:# pipe (ls) (grep ".lisp")
bar.lisp
baz.lisp
foo.lisp ; output occurs
--> 1 ; UNIX return code is the expression value
The idea is somehow a path variable causes quasi-Lisp-functions to be
associated with UNIX executables. The exact way to capture various
output streams and the return codes in a useful way would have to be
worked out. Also, the case used to get Lisp functions would have to be
standardized.
GP lisper wrote:
> I've been using CMUCL as a user shell for awhile, it generally works
> out fine. Recently, I started trying some of the more advanced
> options to various utilities and need away around the following:
>
> CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>
> which works fine. But wanting to write the commandline options in a
> 'normal' form, as in:
>
> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>
> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
> but is there a leave-the-case-alone function that would pass thru the
> above chain?
>
>
I believe you can put a pair of | around the symbol you wish to preserve
case with. For example, (quote |cows|) -> cows, whereas (quote cows) ->
COWS.
On Fri, 17 Jun 2005 23:33:07 -0500, <·············@gmail.com> wrote:
> GP lisper wrote:
>> I've been using CMUCL as a user shell for awhile, it generally works
>> out fine. Recently, I started trying some of the more advanced
>> options to various utilities and need away around the following:
>>
>> CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>>
>> which works fine. But wanting to write the commandline options in a
>> 'normal' form, as in:
>>
>> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>>
>> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
>> but is there a leave-the-case-alone function that would pass thru the
>> above chain?
>>
>>
> I believe you can put a pair of | around the symbol you wish to preserve
> case with. For example, (quote |cows|) -> cows, whereas (quote cows) ->
> COWS.
Gets away from my desire to just type out a shell command to a lisp
function. If I need to quote everything, the first form will do.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
"GP lisper" > CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>
> which works fine. But wanting to write the commandline options in a
> 'normal' form, as in:
>
> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>
> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
> but is there a leave-the-case-alone function that would pass thru the
> above chain?
Can't you just escape it?
CL-USER 16 > (mapcar #'string '(|-f rmail|))
("-f rmail")
>
>
> --
> The LOOP construct is really neat, it's got a lot of knobs to turn!
> Don't push the yellow one on the bottom.
>
On Fri, 17 Jun 2005 23:45:56 -0500, <······@alltel.net> wrote:
>
>
>
> "GP lisper" > CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>>
>> which works fine. But wanting to write the commandline options in a
>> 'normal' form, as in:
>>
>> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>>
>> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
>> but is there a leave-the-case-alone function that would pass thru the
>> above chain?
>
> Can't you just escape it?
> CL-USER 16 > (mapcar #'string '(|-f rmail|))
> ("-f rmail")
("-f rmail") will not work, note the first example.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
"Joe Manby" <······@alltel.net> writes:
>Can't you just escape it?
>CL-USER 16 > (mapcar #'string '(|-f rmail|))
>("-f rmail")
I _think_ he wants to stay as near to the shell, in syntax, as
possible, without actually using it. This apparently precludes using
strings. I suggest that he writes a reader-macro, perhaps #$, that
remaps the whole stuff into the appropriate s-expression (if that's
possible). So he could type: "#$ emacs -f rmail" instead of "(...
gobbledygook ...)". I won't comment on the sense of the whole thing, I
assume, it's for some kind of prototyping or other experimental
somesuch.
mkb.
GP lisper wrote:
> I've been using CMUCL as a user shell for awhile, it generally works
> out fine. Recently, I started trying some of the more advanced
> options to various utilities and need away around the following:
>
> CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>
> which works fine. But wanting to write the commandline options in a
> 'normal' form, as in:
>
> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>
> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
> but is there a leave-the-case-alone function that would pass thru the
> above chain?
>
Uhh... '-f's string is "-F"
Try
CL-USER> (ext:run-program "emacs" (mapcar #'string-downcase '(-f rmail)) :wait nil)
Wade
On Sat, 18 Jun 2005 04:37:26 GMT, <··················@telus.net> wrote:
>
> GP lisper wrote:
>> I've been using CMUCL as a user shell for awhile, it generally works
>> out fine. Recently, I started trying some of the more advanced
>> options to various utilities and need away around the following:
>>
>> CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>>
>> which works fine. But wanting to write the commandline options in a
>> 'normal' form, as in:
>>
>> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>>
>> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
>> but is there a leave-the-case-alone function that would pass thru the
>> above chain?
>>
> Try
>
> CL-USER> (ext:run-program "emacs" (mapcar #'string-downcase '(-f rmail)) :wait nil)
Probably the best choice in this case...until I run into the opposite
case problem. So string-leave-the-case-alone is something I need to
write it seems.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
GP lisper wrote:
>>
>>CL-USER> (ext:run-program "emacs" (mapcar #'string-downcase '(-f rmail)) :wait nil)
>
>
> Probably the best choice in this case...until I run into the opposite
> case problem. So string-leave-the-case-alone is something I need to
> write it seems.
>
Well you need to really a command line reader macro. Here an example
of a simple version (does not handle sh like handling of ' or " or
other shell syntax. just straight forward args)
(in-package :cl-user)
(defun command-line-lexer (stream)
(let ((c (read-char stream nil)))
(cond
((null c) (values nil nil))
((member c '(#\space #\newline)) (command-line-lexer stream))
(t
(let ((buffer (make-array 32 :element-type 'base-char
:adjustable t
:fill-pointer 0)))
(vector-push c buffer)
(loop for c = (read-char stream nil)
while c do
(cond
((member c '(#\space #\newline)) (return))
(t (vector-push-extend c buffer))))
(values (copy-seq buffer) 'simple-token))))))
(defun command-line-reader (stream subchar arg)
(declare (ignore subchar arg))
(let ((split-command
(loop for arg = (command-line-lexer stream)
while arg collect arg)))
(assert (> (length split-command) 0))
(ext:run-program (car split-command) (cdr split-command)
:wait nil)))
(defun set-command-line-dispatch ()
(set-dispatch-macro-character #\# #\! 'command-line-reader))
CL-USER> (set-command-line-dispatch)
#<Function COMMAND-LINE-READER {481587F1}>
CL-USER> #!emacs -f rmail
#<process 68852 :RUNNING>
CL-USER>
Wade
On Sat, 18 Jun 2005 14:18:59 GMT, <··················@telus.net> wrote:
> GP lisper wrote:
>>>
>>>CL-USER> (ext:run-program "emacs" (mapcar #'string-downcase '(-f rmail)) :wait nil)
>>
>> Probably the best choice in this case...until I run into the opposite
>> case problem. So string-leave-the-case-alone is something I need to
>> write it seems.
>>
>
> Well you need to really a command line reader macro. Here an example
> of a simple version (does not handle sh like handling of ' or " or
> other shell syntax. just straight forward args)
Thanks! That gives me enough clues to work out any tougher examples.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
GP lisper <········@CloudDancer.com> writes:
> Probably the best choice in this case...until I run into the opposite
> case problem. So string-leave-the-case-alone is something I need to
> write it seems.
But the function is called after the symbols are read. At this
point, there are "already" upper case. IMHO, you can 1) change
the way the symbols are read (by example with |-f|), or 2) change
the symbol names (by example with string-downcase).
--drkm
On Sat, 18 Jun 2005 15:37:44 +0200, <······@fgeorges.org> wrote:
>
>
> GP lisper <········@CloudDancer.com> writes:
>
>> Probably the best choice in this case...until I run into the opposite
>> case problem. So string-leave-the-case-alone is something I need to
>> write it seems.
>
> But the function is called after the symbols are read. At this
> point, there are "already" upper case.
No. Wade's suggestion works fine.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
GP lisper <········@CloudDancer.com> writes:
> On Sat, 18 Jun 2005 15:37:44 +0200, <······@fgeorges.org> wrote:
>> But the function is called after the symbols are read. At this
>> point, there are "already" upper case.
> No.
Yes. I spook about your example.
> Wade's suggestion works fine.
Yes. I though about something like this (and other things)
when I said "change the way the symbols are read". But I don't
enough know Common Lisp to write an example as Wade does.
--drkm
GP lisper <········@CloudDancer.com> writes:
>I've been using CMUCL as a user shell for awhile, it generally works
>out fine. Recently, I started trying some of the more advanced
>options to various utilities and need away around the following:
>
>CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>
>which works fine. But wanting to write the commandline options in a
>'normal' form, as in:
>
>CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>
>fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
>but is there a leave-the-case-alone function that would pass thru the
>above chain?
Err... readtable-case?
That would accomplish what you want ("leave symbols alone", if you
setf it to :preserve). But what on earth are you trying to do?!
mkb.
On Sat, 18 Jun 2005 06:37:17 +0200, <···@incubus.de> wrote:
>
> GP lisper <········@CloudDancer.com> writes:
>
>>I've been using CMUCL as a user shell for awhile, it generally works
>>out fine. Recently, I started trying some of the more advanced
>>options to various utilities and need away around the following:
>>
>>CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>>
>>which works fine. But wanting to write the commandline options in a
>>'normal' form, as in:
>>
>>CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>>
>>fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
>>but is there a leave-the-case-alone function that would pass thru the
>>above chain?
>
> Err... readtable-case?
looks like an answer. Guess I needed to learn the readtable stuff
sometime.
> That would accomplish what you want ("leave symbols alone", if you
> setf it to :preserve). But what on earth are you trying to do?!
unix> emacs -f rmail
lisp> (shell '(emacs -f rmail))
But before the shell function is useful, one needs a way to feed the
args to run-program.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
GP lisper wrote:
> On Sat, 18 Jun 2005 06:37:17 +0200, <···@incubus.de> wrote:
>
> > setf it to :preserve). But what on earth are you trying to do?!
>
> unix> emacs -f rmail
> lisp> (shell '(emacs -f rmail))
>
> But before the shell function is useful, one needs a way to feed the
> args to run-program.
what about (shell "emacs -f rmail")
#'shell would have to break the string into substrings, but that is a
relatively simple utility function.
Or, if you want to do this with smaller molecules (assembled by code,
presumably)
(shell-list "emacs" "-f" "rmail")
where the &rest list already has the strings broken up. The quoting in
my example is artificial: the #'shell version would be for manual usage
(and could even have a reader-macro that switches to case-preserve
while reading in the string argument.)
GP lisper <········@CloudDancer.com> writes:
>unix> emacs -f rmail
>lisp> (shell '(emacs -f rmail))
Have you looked at the Scheme shell (scsh)? I've never used it but it
might be beneficial to look at how they're doing things, and trying to
implement that on top of the Lisp repl.
mkb.
On 2005-06-18, GP lisper <········@CloudDancer.com> wrote:
> I've been using CMUCL as a user shell for awhile, it generally works
> out fine. Recently, I started trying some of the more advanced
> options to various utilities and need away around the following:
>
> CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
>
> which works fine. But wanting to write the commandline options in a
> 'normal' form, as in:
>
> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>
> fails, as the "-f" is converted to "-F". ANSI CL is case-invariant,
> but is there a leave-the-case-alone function that would pass thru the
> above chain?
I'm not sure how similar CMU CL's run-program is to CLisp's, but you
might find http://clisp.cons.org/clash.html useful if you haven't
already read it.
Bruce
On Sat, 18 Jun 2005 13:26:15 -0500, <·······@wowway.com> wrote:
> On 2005-06-18, GP lisper <········@CloudDancer.com> wrote:
>>
>> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
>
> I'm not sure how similar CMU CL's run-program is to CLisp's, but you
> might find http://clisp.cons.org/clash.html useful if you haven't
> already read it.
Actually reading it long ago is what prompted the above experiment. I
had forgotten about it in the meantime, thanks for the reminder.
"Lisp as a Shell" does work OK, once McCLIM really kicks in, then File
Managers similar to TkDesk should be handy.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
From: Robert Maas, see http://tinyurl.com/uh3t
Subject: Re: CL as a shell and lower case
Date:
Message-ID: <REM-2005jun18-003@Yahoo.Com>
> From: GP lisper <········@CloudDancer.com>
> CL-USER> (ext:run-program "emacs" '("-f" "rmail") :wait nil)
> which works fine.
Good. If it ain't broke, don't mess with it!
> But wanting to write the commandline options in a 'normal' form, as
> in:
> CL-USER> (ext:run-program "emacs" (mapcar #'string '(-f rmail)) :wait nil)
There's nothing normal about that. Here's my view on this: The purpose
of strings is to pass textual data verbatim. This is what you want here
so you should use strings. The purpose of symbols is to provide a hook
on which to hang values functions and other properties, with all
typecase standardized so code can accomodate different styles of
capitalization and still do "the right thing" of ignoring case in names
of symbols. This obviously isn't want you want, so why mess with it at
all for ths task?
More than 25 years ago the various dialects of LISP didn't have
strings, so other kinds of data had to be hacked to fill in the gap.
Lists of 8-bit fixnums, and pnames of symbols, were two common choices.
Nowadays and for more than the past 20 years, Common Lisp has
strings, so you can do things the right way, with verbatim strings,
instead of hacking around with other inappropriate data types. So why
are you pretending strings don't exist and trying to hack around like
it's 30 years ago?
Try doing somemore useful, such as encapsulating the running of emacs
with the particular command-line options for putting it in rmail mode,
so those Unix-style command-line strings you have so much are hidden
away inside this function you can just call instead of copying&pasting
the details again and again. For example, as a starter:
(defun emacs-rmail-nowait ()
(ext:run-program "emacs" '("-f" "rmail") :wait nil))
And if you use it very often, and don't like to type it all each time,
make up very short nicknames, such as:
(defun qer () (emacs-rmail-nowait))
Personally I use a convention that q-something is a common nickname
that takes arguments, whereas qsomething is a common nickname that
doesn't take any arguments. Make up your own convention for common
nicknames, and use them liberally to save pain on your fingers.
And before you complain, yeah I'm lazy and didn't include any
documentations strings in my samples.
From: =?ISO-8859-15?Q?Andr=E9_Thieme?=
Subject: Re: CL as a shell and lower case
Date:
Message-ID: <d92h6f$amo$1@ulric.tng.de>
GP lisper schrieb:
> ANSI CL is case-invariant,
What do you mean by that?
Andr�
--
On Sun, 19 Jun 2005 03:21:29 +0200, <······························@justmail.de> wrote:
>
> GP lisper schrieb:
>> ANSI CL is case-invariant,
>
> What do you mean by that?
YOu cAn feED liSP lETteRcase IN ANY form you like.
It's all the same, there are not two objects named "upper" or "UPPER"
or any other lettercase mixture, just one.
unix on the other hand is touchy about lettercase.
--
The LOOP construct is really neat, it's got a lot of knobs to turn!
Don't push the yellow one on the bottom.
From: Christophe Rhodes
Subject: Re: CL as a shell and lower case
Date:
Message-ID: <sq8y164pf2.fsf@cam.ac.uk>
GP lisper <········@CloudDancer.com> writes:
> On Sun, 19 Jun 2005 03:21:29 +0200, <······························@justmail.de> wrote:
>>
>> GP lisper schrieb:
>>> ANSI CL is case-invariant,
>>
>> What do you mean by that?
>
> YOu cAn feED liSP lETteRcase IN ANY form you like.
>
> It's all the same, there are not two objects named "upper" or "UPPER"
> or any other lettercase mixture, just one.
Please, please, grow a clue. There is no particular need for you to
demonstrate your ignorance to the world, so why do you do it?
Christophe
From: =?ISO-8859-15?Q?Andr=E9_Thieme?=
Subject: Re: CL as a shell and lower case
Date:
Message-ID: <d93msh$bpr$1@ulric.tng.de>
GP lisper schrieb:
> On Sun, 19 Jun 2005 03:21:29 +0200, <······························@justmail.de> wrote:
>
>>GP lisper schrieb:
>>
>>>ANSI CL is case-invariant,
>>
>>What do you mean by that?
>
> It's all the same, there are not two objects named "upper" or "UPPER"
> or any other lettercase mixture, just one.
>
> unix on the other hand is touchy about lettercase.
Hmm, now I am a bit confused, see:
"some were case-sensitive but case-translating (like CL)."
(Kent Pitman)
http://groups.google.de/group/comp.lang.lisp/msg/7998593b3fee79b6
Did Kent only mean Lisps handling of file systems or did he mean CL in
general?
Andr�
--
On Sun, 19 Jun 2005 14:04:41 +0200, Andr� Thieme <······························@justmail.de> wrote:
> GP lisper schrieb:
>> On Sun, 19 Jun 2005 03:21:29 +0200, <······························@justmail.de> wrote:
>>
>>>GP lisper schrieb:
>>>
>>>>ANSI CL is case-invariant,
>>>
>>>What do you mean by that?
>> It's all the same, there are not two objects named "upper" or
>> "UPPER" or any other lettercase mixture, just one. unix on the
>> other hand is touchy about lettercase.
>
> Hmm, now I am a bit confused
No reason to be confused. What "GP lisper" wrote is simply wrong.
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq ·········@agharta.de" 5) "edi")