CODEWITHSUNDEEP
command-linelispcommon-lisp
yoktur
yoktur

Reputation:

Getting command line arguments in Common Lisp

How can I get the command line arguments in (specifically in GNU, if there are any differences) Common Lisp?

Upvotes: 23

Views: 17231

Answers (7)

mog
mog

Reputation: 1343

http://cl-cookbook.sourceforge.net/os.html provides some insight

  (defun my-command-line ()
  (or 
   #+CLISP *args*
   #+SBCL *posix-argv*  
   #+LISPWORKS system:*line-arguments-list*
   #+CMU extensions:*command-line-words*
   nil))

is what you are looking for, I think.

(edit): see the newer Cookbook: https://lispcookbook.github.io/cl-cookbook/scripting.html

Upvotes: 28

Tomás F. N.
Tomás F. N.

Reputation: 121

Just go for it on SBCL (2.1.11.debian):

(defun main ()
    (let (
        (args sb-ext:*posix-argv*))

    (format t "args = ~a~%" args)))

(main)

Upvotes: 0

Leslie Zhu
Leslie Zhu

Reputation: 149

In SBCL,we can use sb-ext:*posix-argv* to get the argv from a Common Lisp script. sb-ext:*posix-argv* is a list holding all the arguments, the first member of the list is the script filename.

Upvotes: 4

Ehvince
Ehvince

Reputation: 18375

A portable way is uiop:command-line-arguments (available in ASDF3, shipped by default in all major implementations).

Libraries-wise, there is the mentioned Clon library that abstracts mechanisms for each implementation, and now also the simpler unix-opts, and a tutorial on the Cookbook.

(ql:quickload "unix-opts")

(opts:define-opts
    (:name :help
       :description "print this help text"
       :short #\h
       :long "help")
    (:name :nb
       :description "here we want a number argument"
       :short #\n
       :long "nb"
       :arg-parser #'parse-integer) ;; <- takes an argument
    (:name :info
       :description "info"
       :short #\i
       :long "info"))

Then actual parsing is done with (opts:get-opts), which returns two values: the options, and the remaining free arguments.

Upvotes: 3

Svante
Svante

Reputation: 51501

As seen in https://stackoverflow.com/a/1021843/31615, each implementation has its own mechanism. The usual way to deal with this is to use a wrapper library that presents a unified interface to you.

Such a library can provide further assistance in not only reading things in, but also converting them and giving helpful output to the user. A quite complete package is CLON (not to be confused with CLON or CLON, sorry), the Command Line Options Nuker, which also brings extensive documentation. There are others, though, should your needs be more lightweight, for example, command-line-arguments and apply-argv.

The packages in quicklisp for these are named net.didierverna.clon, command-line-arguments, and apply-argv, respectively.

Upvotes: 2

user50685
user50685

Reputation:

I'm assuming that you are scripting with CLisp. You can create a file containing

#! /usr/local/bin/clisp
(format t "~&~S~&" *args*)

Make it executable by running 

$ chmod 755 <filename>

Running it gives

$ ./<filename>
NIL
$ ./<filename> a b c
("a" "b" "c")
$ ./<filename> "a b c" 1 2 3
("a b c" "1" "2" "3")

Upvotes: 19

js.
js.

Reputation: 1867

Are you talking about Clisp or GCL? Seems like in GCL the command line arguments get passed in si::*command-args*.

Upvotes: 4

Related Questions