The usual way to avoid inadvertant variable capture in macros seems to involve introducing a layer of indirection via (gensym). For example, Paul Graham in On Lisp(http://www.bookshelf.jp/texi/onlisp/onlisp_10.html#SEC67) Ch 9.6, presents a basic for loop as:
(defmacro for ((var start stop) &body body)
(let ((gstop (gensym)))
`(do ((,var ,start (1+ ,var))
(,gstop ,stop))
((> ,var ,gstop))
,#body)))
FOR
So then the expansion introduces a gensym variable #:G450 for the stop value:
(macroexpand '(for (i 1 3) (princ i)))
(BLOCK NIL
(LET ((I 1) (#:G450 3))
(TAGBODY
(GO #:G452)
#:G451
(TAGBODY (PRINC I))
(PSETQ I (1+ I))
#:G452
(UNLESS (> I #:G450) (GO #:G451))
(RETURN-FROM NIL (PROGN)))))
T
But this expansion seems like it should be equivalent to the loop macro expansion:
(macroexpand '(loop for i from 1 upto 3 do (princ i)))
(BLOCK NIL
(LET ((I 1))
(DECLARE (TYPE (AND REAL NUMBER) I))
(SB-LOOP::LOOP-BODY NIL
(NIL NIL (WHEN (> I '3) (GO SB-LOOP::END-LOOP)) NIL)
((PRINC I))
(NIL (SB-LOOP::LOOP-REALLY-DESETQ I (1+ I))
(WHEN (> I '3) (GO SB-LOOP::END-LOOP)) NIL)
NIL)))
T
where there are no gensym variables.
How does loop avoid variable capture? And is it a reliable general principle that whenever a macro expands (only) into other macros with variables, that variable capture will not be a problem (since the other macros already deal with it)?
Related
Need create macros/lisp/vba/diesel that user may do next steps:
user clicking on TEXT on scheme and script getting this text value (it will be number) to buffer or into varialbe
after that script changing cursor to PO (point)
user will click on scheme and creates point
our number from first steps will set automatically into point property as Z coordinate
How better to do it? With macros possible? Or need VBA or something else?
IMO, the simplest is AutoLISP
(defun c:foo (/ txt data z pt)
(if (setq txt (car (entsel "\nSelect text: ")))
(if (wcmatch (cdr (assoc 0 (setq data (entget txt)))) "*TEXT")
(if (setq z (distof (cdr (assoc 1 data))))
(if (setq pt (getpoint "\nPick a point: "))
(command "_.point" (list (car pt) (cadr pt) z))
)
(prompt "\nSelected text is not a number.")
)
(prompt "\nSelected object is not a text or mtext.")
)
)
(princ)
)
I've been scratching my head on this for a while now - maybe someone could shed some light on how to format an initialization argument list for 'make-instance' from a nested list containing (key value) sublists. Example:
(make-instance 'myclass :initarg1 1 :initarg2 2 :initarg3 '(a b))
If I have the keywords and values in a list like so:
'((initarg1 1) (initarg2 2) (initarg3 '(a b)))
Any help and pointers appreciated!
Thanks,
Marleynoe
(apply #'make-instance 'myclass
(loop for (parameter value) in '((initarg1 1) (initarg2 2) (initarg3 '(a b)))
collect (intern (symbol-name parameter) (find-package :keyword))
collect value))
(apply #'make-instance 'myclass
(mapcan #'(lambda (param)
(list (intern (symbol-name (car param)) (find-package :keyword))
(cadr param)))
'((initarg1 1) (initarg2 2) (initarg3 '(a b)))))
The idea is that each (initargk k) parameter pair is mapped to a fresh list (:initargk k) and then all of them are concatenated in order together. This is a typical pattern for the map function mapcan.
I need to make the function defmacro for my meta-circular interpreter that can read this syntax:
pseudoscheme> (defmacro (minus x y) (list ‘- y x))
MINUS
pseudoscheme> (expand-macro '(minus 3 2))
(- 3 2)
When I use this:
(defmacro my-defmacro ((name &rest args) &body body)
(let ((form (gensym))(env (gensym)))
(progn
`(setf (macro-function ',name)
(lambda (,form ,env))
(destructuring-bind ,args (rest, form) ,#body))
name
)
)
)
and then:
(my-defmacro (min a b)(list '- a b))
I get this error:
Error: The variable MIN is unbound.
I can't understand why.
-----EDITED-----
If I use this:
(defmacro my-defmacro ((name &rest args) &body body)
(let ((form (gensym))(env (gensym)))
`(progn (setf (macro-function ',name)
(lambda (,form ,env))
(destructuring-bind ,args (rest, form) ,#body))
',name)
)
)
and then:
(my-defmacro (min a b)(list '- a b))
I get this error:
Error: Odd number of args to SETF: ((MACRO-FUNCTION (QUOTE PLUS)) (LAMBDA (#:G786 #:G787)) (DESTRUCTURING-BIND (A B) (REST #:G786) (LIST # A B)))
Your my-defmacro works for you host CL system, but I get the feeling you want macro capabilities in your interpreter and this won't do it. (except if ythe interpreter environment is the global host implementations environment, but that would make a lot of challenges)
I don't know how you do compound procedures in your evaluator but when my evaluator gets a (lambda (x) (+ x x)) it is turned into (compound-procedure <env> (x) (+ x x)). My macros turn into almost the same except the first element is compound-syntax.
Every evaluated operator has a tag which tells it what it is (one of primitive-syntax, primitive-procedure, compound-syntax, compound-procedure) and I only need a general way of dealing with those 4.
The real difference between a compound procedure and compound syntax is that the arguments gets evaluated for a procedure and in a compound syntax the result gets evaluated.
So. Have you implemented so that ((lambda (x) (+ x x)) 5) works? Well, then you'll almost implemented macros as well. This is of course not true for a compiler, since this approach would expand the code every time it's run instead of expanding once when the closure gets created. (Optimizations is no way to go on the first version anyway)
For your 'edited code' you have a misplaced paren:
(defmacro my-defmacro ((name &rest args) &body body)
(let ((form (gensym))(env (gensym)))
`(progn (setf (macro-function ',name)
(lambda (,form ,env)) ;; <== HERE
(destructuring-bind ,args (rest, form) ,#body))
',name)
)
)
which leads to setf having three subforms. Rewrite it like this (while using standard Lisp formatting):
(defmacro my-defmacro ((name &rest args) &body body)
(let ((form (gensym))
(env (gensym)))
`(progn (setf (macro-function ',name)
(lambda (,form ,env)
(destructuring-bind ,args (rest, form)
,#body)))
',name)))
I think I read somewhere that you could bind multiple definitions to a single name in scheme. I know I might be using the terminology incorrectly. By this I mean it is possible to do the following (which would be really handy to defining an operator)?
I believe I read something like this (I know this is not real syntax)
(let ()
define operator "+"
define operator "-"
define operator "*"
define operator "/"))
I want to test another variable against every operator.
I'm not really sure what you're asking. Do you want a single procedure that can handle different types of arguments?
(define (super-add arg1 arg2)
(cond ((and (string? arg1) (string? arg2))
(string-append arg1 arg2))
((and (number? arg1) (number? arg2))
(+ arg1 arg2))
(else
(error "UNKNOWN TYPE -- SUPER-ADD"))))
(super-add "a" "b") => "ab"
(super-add 2 2) => 4
Are you interested in message passing?
(define (math-ops msg) ;<---- returns a procedure depending on the msg
(cond ((eq? msg 'add) +)
((eq? msg 'sub) -)
((eq? msg 'div) /)
((eq? msg 'multi) *)
(else
(error "UNKNOWN MSG -- math-ops"))))
((math-ops 'add) 2 2) => 4
((math-ops 'sub) 2 2) => 0
Also the proper syntax for a let binding:
(let (([symbol] [value])
([symbol] [value]))
([body]))
(let ((a 2)
(b (* 3 3)))
(+ a b))
=> 11
It will be very hard to help more than this without you clarifying what it is you are trying to do.
EDIT: After your comment, I have a little bit better of an idea for what you're looking for. There is not way to bind multiple values to the same name in the way that you mean. You are looking for a predicate that will tell you whether the thing you are looking at is one of your operators. From your comment it looked like you will be taking in a string, so that's what this is based on:
(define (operator? x)
(or (string=? "+" x) (string=? "-" x) (string=? "*" x) (string=? "/" x)))
If you are taking in a single string then you will need to split it into smaller parts. Racket has a built in procedure regexp-split that will do this for you.
(define str-lst (regexp-split #rx" +" [input str]))
You may be referring to the values construct, which "delivers arguments to a continuation". It can be used to return multiple values from a function. For example,
(define (addsub x y)
(values (+ x y) (- x y)))
(call-with-values
(lambda () (addsub 33 12))
(lambda (sum difference)
(display "33 + 12 = ") (display sum) (newline)
(display "33 - 12 = ") (display difference) (newline)))
Is Xemacs available with Windows Style Key Bindings ?
Emacs has these Windows key bindings
The keybindings of Emacs predate
modern GUIs, and the keys that were
chosen by later GUIs for cut and copy
were given important functions as
extended keymaps in Emacs. CUA mode
attempts to let both bindings co-exist
by defining C-x and C-c as kill-region
and copy-region-as-kill when the
region is active, and letting them
have their normal Emacs bindings when
the region is not active. Many people
find this to be an acceptable
compromise. CUA mode also defines a
number of other keys (C-v, Shift
selection), and can be turned on from
the Options menu
If you could put up with emacs instead of Xemacs there is EmacsW32
it's plain emacs modified to integrate better with windows. It has a lot of features including a choice between emacs/win keybindings.
From webpage:
EmacsW32 is a collection of Emacs
lisp modules and MS Windows programs
you can use from Emacs. It can make
the keyboard and other things in Emacs
function more like they do usually in
MS Windows programs.
EmacsW32 is not Emacs for MS Windows.
Instead it is an add-on to Emacs for
MS Windows. You can however download
Emacs+EmacsW32 in one installer.
I'm not sure which Windows key bindings you are looking for, probably cut.copy,paste? That is called CUA and no it does not come with those key bindings by default, but they can be easily added.
Here's a link to a site that has a CUA-mode for xemacs. You should be able to install XEmacs, then add the CUA-mode, effectively creating what you are wanting.
http://sites.google.com/site/olegalexandrov/xemacs
Alternatively, you can add them yourself with a few lines of key assignments added to your init.el file. Try them first in a buffer with C-x C-e to run them and make sure they work.
I do not use the kill-ring and wanted to mark blocks a different way, so I wrote some functions in a file skm-mark-blocks.el which I will try to insert or attach here. At the end of the file you can see the global-set-key lines and use them as a template for making the Windows keys work the way they do in Windows.
-snip--------------------------------------
; skm-blocks.el
; Byrel and Steve Mitchell
; Nov 12, 2009
; mark blocks by:
; same key for marking first and second block end markers
; once both ends marked, keys to copy, cut, move, & delete block
;
; Goal:
; to do all block commands: mark, copy, move, del, etc. with the left hand
; while the right hand used for positioning in buffer with cursor keys
;
; first written mimicing Vedit+ method (for right hand)::
; F9 to mark first end,
; F9 to mark second end,
; then Cntl-F9 (copy to cursor) or Alt-F9 (move to cursor)
; Vedit+ uses the delete key while block highlighted to delete
block. Won't work here
; so we define a key with the same prefix (super) for deleting highlighted block
;
; possible improvements:
; add vars to choose how point (or cursor position or block markers) is moved when block
; is copied, etc.
; that is, do these things move with the block, stay where they were was,
; or move to end of new block, etc.
; add function to unmark all block ends?
; currently marking a "third" end unmarks the 2 previously
selected block ends
; and counts the third end as marking a new first end of block
; find a name for this kind of block marking other than my intials.
; add functions to do columnar block marking (rectangles), with new key combinations.
; add vars to config how columnar block marking should work, insert, overwrite, etc.
;
(defvar block-marker-highlight-mode 1
"block-marker-highlight-mode can have 3 values:
0 = highlighing is removed following a block copy or block move
1 = w/ a copy, orig block remains highlighted
w/ a move, block is highlighted at new position
2 = w/ copy or move, block is highlighted at new position" )
(defvar block-marker-end-position-mode t
"block-marker-end-position-mode has 2 values:
t = after a block copy/move, cursor is positioned at end of
inserted block
nil = after a block copy/move, cursor is positioned at beginning of inserted block
note: t is similar to the way Xemacs works by default")
(defvar block-mark1 (point-marker)) ;var to hold 1st end of our block
(defvar block-mark2 (point-marker)) ;var to hold 2nd end of our block
(defvar block-ends-marked 0) ;0 if no ends marked,
;1 or 2 for number of ends marked
(defvar block-copiedp nil) ;t if block copied
;-------- mark-block --------------------------
(defun mark-block ()
"Marks either end of block with skm type blocks."
(interactive)
(if ( or (eq block-ends-marked 0 ) (eq block-ends-marked 2))
;are we marking the first end of a block?
(progn
(setq block-mark1 (point-marker))
(setq block-ends-marked 1)
(clear-highlighting )
(set-mark-command nil)) ;starts highlighting
( if (eq block-ends-marked 1) ; if there is 1 block marker already, we are marking the second end.
(progn (setq block-mark2 (point-marker))
(setq block-ends-marked 2)
(highlight-region ) ))) )
;-------- copy-block-to-point -----------------
(defun copy-block-to-point ()
"Copies skm-marked block to cur. cursor pos. "
(interactive)
(let ((start-pos (point)))
(if ( < block-ends-marked 2)
(message "Both ends not marked: %d end(s) marked." block-ends-marked ) ;error if there aren't 2 ends marked
(save-excursion
(set-buffer (marker-buffer block-mark1))
(copy-to-register ?c block-mark1 block-mark2))
(insert-register ?c t)
(setq block-copiedp t)
(let ((end-pos (point)))
(if (eq block-marker-highlight-mode 0) ;0 = clear all highlighting
(clear-highlighting-at-point ( marker-buffer block-mark1) block-mark1)
(if (eq block-marker-highlight-mode 2 ) ;2 = highlight at new position
(progn
(clear-highlighting-at-point ( marker-buffer block-mark1) block-mark1)
(goto-char start-pos)
(push-mark)
(goto-char end-pos)
(highlight-region))))))
(if (not block-marker-end-position-mode) ;determine where to leave cursor
(goto-char start-pos)) ))
;-------- move-block-to-point -----------------
(defun move-block-to-point ()
"Moves skm-marked block to current cursor pos. "
(interactive)
(if ( < block-ends-marked 2)
(message "Both ends not marked: %d end(s) marked." block-ends-marked )
(save-excursion
(set-buffer (marker-buffer block-mark1))
(copy-to-register ?c block-mark1 block-mark2 t))
(let ((start-pos (point)) end-pos )
(insert-register ?c t)
(setq end-pos (point))
(setq block-copiedp t)
(clear-highlighting-at-point ( marker-buffer block-mark1) block-mark1)
(if (eq block-marker-highlight-mode 0) ;0 = clear all highlighting
nil
(goto-char start-pos)
(push-mark)
(goto-char end-pos)
(highlight-region))
(if (not block-marker-end-position-mode) ;determine where to leave cursor
(goto-char start-pos)) )))
;-------- cut-block ---------------------------
(defun cut-block ()
"Cuts skm-marked block from file."
(interactive)
(if ( < block-ends-marked 2)
(message "Both ends not marked: %d end(s) marked." block-ends-marked )
(copy-to-register ?c block-mark1 block-mark2 t)
(setq block-copiedp t)))
;------- highlight a block persistantly -----------
(defun highlight-region ()
(interactive)
(let (new-extent) (setq new-extent (make-extent (mark t)
(point)))
(set-extent-property new-extent 'face 'zmacs-region)
(set-extent-property new-extent 'wordstar-block t)))
;------- clear the highlighted blocks in a buffer -----------
(defun clear-highlighting-whole-buffer (&optional buffer)
(interactive)
(let ((highlighted-list (extent-list buffer nil nil nil 'face 'zmacs-region)))
(while highlighted-list
(delete-extent (car highlighted-list))
(setq highlighted-list (cdr highlighted-list)))))
(defun clear-highlighting-at-point (&optional buffer position)
(interactive)
(if (not position)
(setq position (point)))
(while (extent-at position buffer 'wordstar-block nil 'at )
(delete-extent (extent-at position buffer 'wordstar-block nil 'at )) ))
;------------key assignments ------------------
;--- key assignments to mimic VEdit+ method
;--- to verify we have algorithm correct
;--- comment out once they are not needed
(global-set-key [ f9 ] 'mark-block)
(global-set-key [ (control f9) ] 'copy-block-to-point)
(global-set-key [ (meta f9) ] 'move-block-to-point)
(global-set-key [ (control meta f9) ] 'cut-block) ;not in Vedit, but for testing
(global-set-key [ (control shift f9) ] 'clear-highlighting) ;not in Vedit, but for testing
;------- key assignments for left hand use
;--- using only super key (left windows-logo key) shifting
;Doesn't work with xemacs in Windows since Windows preempts the super key
; have to experiment to find something to work for windows'
xemacs...
(global-set-key [ (super space) ] 'mark-block)
(global-set-key [ (super v) ] 'copy-block-to-point) ;mnemonic: V for insert, drive a V (wedge) in
(global-set-key [ (super m) ] 'move-block-to-point) ;mnemonic: M for move
(global-set-key [ (super c) ] 'cut-block) ;mnemonic: C for Cut
(global-set-key [ (super n) ] 'clear-highlighting-at-point)
;mnemonic: think N for No highlighting
--snip-----------------
Hope this helps you see how easy it is to do.
After seeing how the code went into this message, it is obvious that I need some practice putting code into this editor (grin).