Re: first steps in elisp

[Steve <loft@centurylink.net>]

Mark Piffer <mark.piffer@gmail.com> writes:

< I am trying to write some helper functions which should ease
< documentation of C as per the method which my customers require
< (mostly repetition of parameters as Doxygen-enabled comments - I don't
< think that that's a good idea, but the customer wants it). I coudn't
< find a package that was primitive enough to help me with the parsing -
< the code is embedded C and quite non-standard with respect to compiler
< extensions.

I have some terrible ideas, but you might find them useful or
interesting.

using grep as a shell command process. I would try looking at
`grep-process-startup' or `shell-command on region'. You don't need to
use an external program (shell script). also, emacs has the
`combine-and-quote-strings' function which is very nice. Also
`looking-at-p' is a newer one, does not load match-data.

I'm sure the doxygen docstrings are parsable with emacs - they are font
locked when I check some C buffers; doxygen is not something I know much
about.

check in site-lisp/progmodes/cc-mode.el - has some functions to
determine if your inside a string or comment.

< Which things are especially bad or unusual concerning both, Lisp and
< emacs?

Concerning lisp, I often hear that lisp programmers are considered a tad
bit goofy :) they seem to like to write everything from scratch until it
becomes a command interpreter; the course of just a few bytecodes...

They used to say emacs and vi are religions; these days they are
starting to seem like latin.

< [ ... ]

>
< (defun ignore-line-comments (nlines)
<   "return the text starting at point as a list,
< going nlines lines down, stripped of 
< all C comments (except pathological cases w/ string literals)"
<   (if (zerop nlines)
<       nil    
<     (setq ml-e (if (looking-at "\\(.*?\\)/\\*") ;; test on /* comment
<                                  (match-end 1)
<                                nil))

using setq will bind the variable with dynamic scope. to get lexical
scope youe use a lambda function (lambda function usually means `let'.

(defun ignore-line-comments (nlines)
  "return [ ... ] "
;; new
 (let ((ml-e nil))

 ;; now setq will bind ml-e lexically for the function
 
  (if (zerop nlines)
       nil    
     (setq ml-e (if (looking-at "\\(.*?\\)/\\*") ;; test on /* comment
                                  (match-end 1)
                                nil))


Hops this helps.

P.S. in another article about the `serial-term' ; Emacs serial term is
woring great with a parallax propeller. The trick is to use pst#NL (that
is insert newline and then form feed. Arg... just had to get that off my
chest.