I am trying to run a scheme program using MIT-scheme (MIT/GNU Scheme running under GNU/Linux, Release 7.7.90.+ || Microcode 15.1 || Runtime 15.7) and I would like to access the command-line arguments.
I have looked in the documentation but I haven't found anything specific.
I have tried command-line, but I get an error message:
;Unbound variable: command-line
Do I have to load some library in order to use command-line, or is there some other function for this?
I have managed to find the following solution.
I have created a file init.scm with the following definitions:
(define command-line-args '())
(define parse-argument-list
(lambda (arg-list)
(set! command-line-args
(if (null? arg-list)
(list)
(cdr arg-list)))))
(set-command-line-parser! "args" parse-argument-list)
In this way, when the command line option --args is found, the function
parse-argument-list is invoked.
I have loaded this file into the mit-scheme interpreter and saved a world image
(init.com) using the procedure disk.save.
I have then written a shell script (bash) that invokes my main Scheme script as follows:
mit-scheme --band "init.com" --interactive --batch-mode --args $* < myscript.scm
Finally, in my main script I can access the command line arguments through the variable
command-line-args
I am not sure whether this is the standard / correct way to do this but at least it works.
Related
I am trying build a shell script to 1. Open the racket language interactive session using racket and 2. adding the appropriate language and version in the racket session via require (planet dyoo/simply-scheme:2:2)).
Rather than typing racket, waiting for it to load, then typing require (planet dyoo/simply-scheme:2:2)), I'd like to build a shell script to automate this.
How would I do this?
The command line to achieve this is racket -i -p dyoo/simply-scheme:2:2 (or alternatively with -e flag). It is then trivial to build in sh/bash:
#!/bin/sh
racket -i -p dyoo/simply-scheme:2:2
You can even write a script in Racket like this, which accept an argument to require any package:
;; repl.rkt
#! /usr/bin/env racket
(require racket/cmdline)
(require racket/system)
(define package (make-parameter ""))
(define parser
(command-line
#:usage-help
"Start a racket REPL and require an initial package."
#:once-each
[("-p" "--package") PACKAGE
"Add an initial package to require."
(package PACKAGE)]
#:args () (void)))
(define (run (package-name))
(system (~a (printf "racket -i -p ~a" package-name))))
(run package)
And run repl.rkt -p dyoo/simply-scheme:2:2.
Alternative command is racket -i -e '(require (planet "dyoo/simply-scheme:2:2"))'
UPDATE: The shebang has been corrected per the comments.
I wrote this Scheme source file on notepad. I have gambit scheme installed.
(define hello-world
(lambda ()
(begin
(write ‘Hello-World)
(newline)
(hello-world))))
I use windows command line. i type in 'gsc hello.scm' in the command line. It spits out a file on my desktop called "hello.o2". I want to see "Hello-World" pop up on my command line. For example, when I compile stuff in c++ it gives me a file called a.exe and I am able to observe it on the command line.
how can I do this with the gambit compiler for scheme?
You can create an executable by adding the -exe compiler switch:
gsc -exe hello.scm
will produce hello.exe . Alternatively you can produce the .o1 (or .o2, etc) file and execute it with:
gsc hello.scm
gsi hello
If you want an executable that will run on its own, you need to do a couple of things to make it work correctly.
#;gsi-script %~f0 %*
;
(define hello-world
(lambda ()
(begin (write `Hello-World) (newline) (hello-world))))
(define (main)
(hello-world))
That first line is for DOS/Windows only. The Unix version of that top line is
;#!/usr/local/bin/gsi-script -:d0
Those lines tell the compiler how to execute the code once its compiled.
Also, you need a main procedure. If you're not passing any parameters, then you can use the form I gave you. If you need to pass parameters, you will need to write the main procedure appropriately, noting that all parameters are passed as strings and may need to be parsed or converted before use.
I am newbie to Emacs.
I want to define a function in elisp to run a command in interactive command line mode (Asynchronously if possible).
my current code is:
(defun ma () ;run maxima batch on the current file
(interactive)
(let*
((fn (buffer-file-name)) (cmd (concat "maxima -b " fn)))
(message "cmd:%s" cmd)
(shell-command cmd)
)
)
this works fine when I do not have break points in the maxima code. When I have break points "break()", I have to interact with the program. The current shell-command function does not work.
I also like the mechanism of "shell-command" function that the screen will automatically split into two and show the programming running info in a second window. If possible, I still want this feature in the code that you can help me with.
Any help would be appreciated.
I want to define a function in elisp to run a command in interactive
command line mode (Asynchronously if possible).
Maybe async-shell-command is what you are looking for do C-h f async-shell-command RET for help on the function.
Use the built in compile function in commint mode.
(defun ma (&optional filename)
(interactive)
(compile (format "maxima -b %s" (or filename (buffer-file-name))) t))
This will open up a new window and will show you the output of the program running. Commint mode means that the compilation process is interactive, you will be able to send input to the program from the compilation buffer.
C-u C-M-x evaluates a defun form with edebug instrumented. Can I do that programmatically? I want to do that because I want to write an elisp file of the following form:
;;; define a function with edebug instrumented.
...
;;; do something that invokes the function with particular arguments.
...
then I can run emacs -q --load on that elisp file, step through code, get an idea on further investigation on the bug, edit the elisp file in my original emacs session, run emacs -q --load on it again, and repeat.
In ~/test.el:
(defun square (x)
(* x x))
In ~/testtest.el:
(with-current-buffer (find-file-noselect "~/test.el")
(re-search-forward "square")
(edebug-defun))
(square 5)
In bash:
emacs -q -l ~/testtest.el
Emacs obviously can handle multiple asynchronous sub-processes, otherwise a multi-language programming environment like org-babel, to give an example, wouldn't be possible.
However, when I'm in Dired and start an asynchronous shell command to view a pdf file (& evince), and then try to do the same on a second pdf file, I get the following message:
"A command is running - kill it? Yes or No?"
Is there a way to run several asynchronous shell commands in parallel, when in Dired?
When you use dired-do-async-shell-command Emacs create a *Async Shell Command* buffer. If you want another async command you need to rename this buffer, for example using M-x rename-uniquely
you could try to change the comportment of dired-do-async-shell-command by advising it:
(defadvice shell-command (after shell-in-new-buffer (command &optional output-buffer error-buffer))
(when (get-buffer "*Async Shell Command*")
(with-current-buffer "*Async Shell Command*"
(rename-uniquely))))
(ad-activate 'shell-command)
note that I really advice the shell-command Emacs command because it's called by dired.
I don't think it's possible with dired-do-async-shell-command, but if you just want to open some file is certain external application I suggest using OpenWith, which allows any number of external processes running.
I've just setup the following which erases the current definition of dired-run-shell-command to pass a dedicated buffer name to shell-command:
(defun dired-run-shell-command (command)
(let ((handler
(find-file-name-handler (directory-file-name default-directory)
'shell-command)))
(if handler (apply handler 'shell-command (list command))
(shell-command command
(generate-new-buffer-name
(concat "*Shell Command Output: '" command "'*")))))
;; Return nil for sake of nconc in dired-bunch-files.
nil)