I want to set up the indentation for if-else statements to be 4 spaces.
I have defined in my xemacs setup file
(add-hook 'c-mode-hook
(function
(lambda()
(setq c-if-indent 4) )))
And I also have
(setq-default tab-width 4)
(setq-default indent-tabs-mode nil)
After setting the above parameters, My tabs are being converted to spaces but the if else statement indentation is still coming out to be 8 characters after "{"
So, If I write
if (test)
{
j++
}
j++ starts at 8th column after "{", I want it to make 4 spaces instead of 8. Which hook do I need to set up for this?
(add-hook 'c-mode-hook (lambda () (setq c-basic-offset 4)))
Related
This question already has an answer here:
How to handle accents in Common Lisp (SBCL)?
(1 answer)
Closed 6 years ago.
Trying
loading contents of file containing one line with word: λέξη
(with-open-file (s PATH-TO-FILE :direction :input)
(let ((a (read-line s)))
(print a)))
outputs
""
T
Trying:
(with-open-file (s PATH-TO-FILE :direction :input)
(let ((buffer ""))
(do ((character (read-char s nil) (read-char s nil)))
((null character))
(setf buffer (concatenate 'string buffer (format nil "~a" character))))
(format t "~a" buffer)))
outputs
funny characters (nothing like the original contents)
T
What I would like to do is to load all lines of file containing such non-standard characters.
Then I want to be able to output these words to console or via LTK widgets (text on button for example).
You need to pass :external-format X to with-open-file, where
X is the actual encoding used in the file (:utf-8 or :ISO-8859-7 or whatever).
(with-open-file (stream PATH-TO-FILE :external-format :utf-8)
(let ((line (read-line stream)))
(loop :for char :across line :do
(print (list (char-name char) (char-code char))))
line))
Since it prints
("ZERO_WIDTH_NO-BREAK_SPACE" 65279)
("GREEK_SMALL_LETTER_LAMDA" 955)
("GREEK_SMALL_LETTER_EPSILON_WITH_TONOS" 941)
("GREEK_SMALL_LETTER_XI" 958)
("GREEK_SMALL_LETTER_ETA" 951)
you can see that you are, indeed, reading the file correctly.
Your problem now if how to print those non-ASCII characters to the screen, and that is an entirely different question.
I just migrated from VIM to Spacemacs and would like to change the tab width from default (\t?) to only 2 spaces. I found commands like
(setq-default indent-tabs-mode nil)
and
(setq tab-width 4) ; or any other preferred value
(defvaralias 'c-basic-offset 'tab-width)
(defvaralias 'cperl-indent-level 'tab-width)
My problem is that I don't know if they are correct, where in the .spacemacs file I should insert them, and what they even mean.
I found this article:
http://blog.binchen.org/posts/easy-indentation-setup-in-emacs-for-web-development.html
I added this part of the code into my .spacemacs file outside of any function (but before (defun dotspacemacs/user-init () ... )):
(defun my-setup-indent (n)
;; java/c/c++
(setq c-basic-offset n)
;; web development
(setq coffee-tab-width n) ; coffeescript
(setq javascript-indent-level n) ; javascript-mode
(setq js-indent-level n) ; js-mode
(setq js2-basic-offset n) ; js2-mode, in latest js2-mode, it's alias of js-indent-level
(setq web-mode-markup-indent-offset n) ; web-mode, html tag in html file
(setq web-mode-css-indent-offset n) ; web-mode, css in html file
(setq web-mode-code-indent-offset n) ; web-mode, js code in html file
(setq css-indent-offset n) ; css-mode
)
and added the line
(my-setup-indent 2) ; indent 2 spaces width
into the (defun dotspacemacs/user-init () ... ) like this:
(defun dotspacemacs/user-init ()
"Initialization function for user code.
It is called immediately after `dotspacemacs/init', before layer configuration
executes.
This function is mostly useful for variables that need to be set
before packages are loaded. If you are unsure, you should try in setting them in
`dotspacemacs/user-config' first."
(my-setup-indent 2) ; indent 2 spaces width
)
You can also just customize the the standard-indent variable, setting it to 2, by calling the command customize-variable within spacemacs. This will save the customization into your .spacemacs file.
Edit:
to run 'customize-variable' use the hotkey M-x (alt-x on most systems) then type customize-variable in to the prompt.
you can use the search to search for 'standard-indent'
I want to count the number of rows in a flat file, and so I wrote the code:
(defun ff-rows (dir file)
(with-open-file (str (make-pathname :name file
:directory dir)
:direction :input)
(let ((rownum 0))
(do ((line (read-line str file nil 'eof)
(read-line str file nil 'eof)))
((eql line 'eof) rownum)
(incf rownum )))))
However I get the error:
*** - READ: input stream
#<INPUT BUFFERED FILE-STREAM CHARACTER #P"/home/lambda/Documents/flatfile"
#4>
ends within an object
May I ask what the problem is here? I tried counting the rows; this operation is fine.
Note: Here is contents of the flat file that I used to test the function:
2 3 4 6 2
1 2 3 1 2
2 3 4 1 6
A bit shorter.
(defun ff-rows (dir file)
(with-open-file (stream (make-pathname :name file
:directory dir)
:direction :input)
(loop for line = (read-line stream nil nil)
while line count line)))
Note that you need to get the arguments for READ-LINE right. First is the stream. A file is not part of the parameter list.
Also generally is not a good idea to mix pathname handling into general Lisp functions.
(defun ff-rows (pathname)
(with-open-file (stream pathname :direction :input)
(loop for line = (read-line stream nil nil)
while line count line)))
Do the pathname handling in another function or some other code. Passing pathname components to functions is usually a wrong design. Pass complete pathnames.
Using a LispWorks file selector:
CL-USER 2 > (ff-rows (capi:prompt-for-file "some file"))
27955
Even better is when all the basic I/O functions work on streams, and not pathnames. Thus you you could count lines in a network stream, a serial line or some other stream.
The problem, as far as I can tell, is the "file" in your (read-line ... ) call.
Based on the hyperspec, the signature of read-line is:
read-line &optional input-stream eof-error-p eof-value recursive-p
=> line, missing-newline-p
...which means that "file" is interpreted as eof-error-p, nil as eof-value and 'eof as recursive-p. Needless to say, problems ensue. If you remove "file" from the read-line call (e.g. (read-line str nil :eof)), the code runs fine without further modifications on my machine (AllegroCL & LispWorks.)
(defun ff-rows (dir file)
(with-open-file
(str (make-pathname :name file :directory dir)
:direction :input)
(let ((result 0))
(handler-case
(loop (progn (incf result) (read-line str)))
(end-of-file () (1- result))
(error () result)))))
Now, of course if you were more pedantic then I am, you could've specified what kind of error you want to handle exactly, but for the simple example this will do.
EDIT: I think #Moritz answered the question better, still this may be an example of how to use the error thrown by read-line to your advantage instead of trying to avoid it.
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).