Re: [patch] enhancements to package-ui.el
27 years
Greg Klanderman
Greg Klanderman
>>>>> "Stephen" == Stephen J Turnbull <turnbull(a)sk.tsukuba.ac.jp> writes:
Stephen>
>>>>> "Pete" == Pete Ware <ware(a)cis.ohio-state.edu> writes:
Pete> When I originally wrote the code, one thing I was concerned
Pete> about was XEmacs being easily exploited for trojan horse
Pete> attacks.
Stephen>
Stephen> Good. I disagree with Greg Klandermann here; you need to cater to the
Stephen> _most_ paranoid among us, not the _least_.
I didn't mean to suggest that we should only have an insecure method but
rather that we not be required to use a secure method. From what Pete
wrote I was imagining a mechanism where the package-get-base.el was
encrypted and completely useless unless I'd installed PGP, etc. Your
suggestion for something that works even if you don't have PGP, and
incurs no pain to check the signature if you do is ideal. Now we
just need someone to implement it.
So is something like the following reasonable:
On entry to any of the package update code, if we haven't loaded an
up-to-date package-get-base.el
* find-file-noselect
/ftp.xemacs.org:/pub/xemacs/packages/package-get-base.el.current
(location should be customizable for those behind firewalls,
but it sure would be nice if it were in a fixed location so
this is completely automatic for those on the net with EFS)
* check the signature if you have PGP, otherwise warn the
user and ask if they want to continue. i guess this means
you have to have previously grabbed the XEmacs public key?
* eval the buffer.
* kill the buffer.
greg
- 2 participants
- 1 comments
Re: efs-load/require sllloooooowwww
27 years
Christoph Wedler
Christoph Wedler
>>>>>"AP" == Andy Piper <andyp(a)parallax.co.uk> writes:
AP> efs-load appears to slow down package loading under cygwin by a
AP> considerable amount. For instance without efs jde takes about 7
AP> seconds to load, with efs it takes 40 seconds.
How many peoply actually use remote files for `load' and `require'? efs
shouldn't probably overload these functions by default. BTW, my efs
installation is
(require 'efs)
(fset 'require 'efs-real-require)
(fset 'load 'efs-real-load)
- Christoph
- 2 participants
- 1 comments
Leim load-path
27 years
tom
tom
When i run select-input-method (C-x C-m C-\)
loaded from
"/usr/local/lib/xemacs/mule-packages/lisp/mule-base/mule-cmds.elc
i get :
Quail package "german-alt-postfix" can't be activated
because library "quail/latin-alt" is not in `load-path'.
True, path the package puts it is leim/latin-alt.
setting up a simple link (ln -s leim quail) fixed this quick and dirty,
maybe i could also rename the diretory name. The cleaner approache seems to
be to fix lisp/leim/leim-list.el.
(register-input-method
"german-prefix" "Latin-1" 'quail-use-package
"DE>" "German (Deutsch) input method with prefix modifiers"
"quail/latin-pre")
^^^^^
gruss tom roth
- 1 participants
- 0 comments
efs-load/require sllloooooowwww
27 years
Andy Piper
Andy Piper
efs-load appears to slow down package loading under cygwin by a
considerable amount. For instance without efs jde takes about 7 seconds to
load, with efs it takes 40 seconds. There is a comment in the code about
possibly adding file-name-handler-alist support to Fload in C. Would this
make a difference?
andy
---------------------------------------------------------------------------
" .sigs are like your face - rarely seen by you and uglier than you think"
Dr Andy Piper, Technical Architect, Parallax Solutions Ltd
mail: andyp(a)parallax.co.uk web: www.parallax.co.uk/~andyp
- 1 participants
- 0 comments
[URGENT PATCH] fix concat usage in time-stamp-strftime
27 years
Didier Verna
Didier Verna
1998-10-08 Didier Verna <verna(a)inf.enst.fr>
* time-stamp.el (time-stamp-strftime): fixed usage of `concat'
(which now accepts only strings) when `field-result' is a number.
--- time-stamp.el.orig Thu Oct 8 09:56:44 1998
+++ time-stamp.el Thu Oct 8 10:06:55 1998
＠＠ -390,7 +390,9 ＠＠
(time-stamp-mail-host-name))
))
(if (string-equal field-width "")
- field-result
+ (if (numberp field-result)
+ (number-to-string field-result)
+ field-result)
(let ((padded-result
(format (format "%%%s%c"
field-width
--
/ / _ _ Didier Verna http://www.inf.enst.fr/~verna/
- / / - / / /_/ / E.N.S.T. INF C201.1 mailto:verna＠inf.enst.fr
/_/ / /_/ / /__ / 46 rue Barrault Tel. (33) 01 45 81 73 46
75634 Paris cedex 13 Fax. (33) 01 45 81 31 19
- 1 participants
- 0 comments
Re: [patch] enhancements to package-ui.el
27 years
Pete Ware
Pete Ware
greg(a)alphatech.com (Greg Klanderman) writes:
> All this package-get-base.el stuff is such a pain. Now there's the
> incremental updates to deal with... blech. I wish we could just
> reliably and automagically snarf the current one off ftp.xemacs.org.
> Suggestions anyone?
When I originally wrote the code, one thing I was concerned about was
XEmacs being easily exploited for trojan horse attacks. In
particular, a talented hacker could intercept ftp requests to
ftp.xemacs.org and substitude their own versions of packages -- hence
the md5 checksum for each package. But then the problem becomes
grabing package-get-base.el -- if that gets intercepted then there is
a problem. Bogus md5sum's can be substituted, host names
changed, package locations, etc.
I pictured two distribution methods for package-get-base.el. It
either gets sent with the entire distribution (which are signed). If
that is corrupted, well you have bigger problems anyway. The second
was a periodic posting to a newsgroup/mailing list. Presumably, such
an article would be PGP signed and could be verified as being from the
poster.
Automatic access to package-get-base.el is dangerous.
--pete
- 3 participants
- 2 comments
Wrong behaviour with delete-key-deletes-forward
27 years
Hrvoje Niksic
Hrvoje Niksic
`delete-key-deletes-forward' should not be used by itself. The right
way is to use `delete-forward-p' instead.
If you use `delete-key-deletes-forward', then the code will fail on X
keyboards without the backspace key, as well as on most TTY setups.
--- cc-cmds.el.orig Mon Sep 21 18:53:19 1998
+++ cc-cmds.el Mon Sep 21 18:53:43 1998
＠＠ -131,8 +131,8 ＠＠
nil, or point is inside a literal then the function in the variable
`c-delete-function' is called."
(interactive "*P")
- (if (and (boundp 'delete-key-deletes-forward)
- delete-key-deletes-forward)
+ (if (and (fboundp 'delete-forward-p)
+ (delete-forward-p))
(if (or (not c-hungry-delete-key)
arg
(c-in-literal))
--
Hrvoje Niksic <hniksic(a)srce.hr> | Student at FER Zagreb, Croatia
--------------------------------+--------------------------------
A jury consists of 12 persons chosen to decide who has the better
lawyer.
- 2 participants
- 1 comments
File missing from Gnus Package (gnus-mh.el)
27 years
Reginald Perry
Reginald Perry
I noticed that the file gnus-mh.el is missing from the gnus package. I
noticed this because when I tried to save a news article in my MH folder the
loader told me that it could not load this file. I had to retrieve it from
my old package which I moved before I created the xemacs-packages directory
and put all of the new packages in there.
I am running XEmacs 2.01 "Poitou"
-Reggie
- 1 participants
- 0 comments
Re: [bug] auctex 1.12 binkit
27 years
Greg Klanderman
Greg Klanderman
>>>>> "sb" == SL Baur <steve(a)xemacs.org> writes:
sb>
sb> Greg Klanderman <greg(a)alphatech.com> writes in xemacs-beta(a)xemacs.org:
>> auto-autoloads.el has the wrong version:
sb>
>> (package-provide 'auctex :version 1.09 :type 'regular)
sb>
sb> AUC TeX was repackaged. Do you still have problems with 1.13?
Yes, it has the same problem.
greg
- 1 participants
- 0 comments
update verilog-mode.el (3/6)
27 years
Neal D. Becker
Neal D. Becker
(;- this is end{function,task,module}
t
(let (string reg (width nil))
(end-of-line)
(if kill-existing-comment
(kill-existing-comment))
(delete-horizontal-space)
(backward-sexp)
(cond
((match-end 5)
(setq reg "\\(\\<function\\>\\)\\|\\(\\<\\(endfunction\\|task\\|\\(macro\\)?module\\|primitive\\)\\>\\)")
(setq width "\\(\\s-*\\(\\[[^]]*\\]\\)\\|\\(real\\(time\\)?\\)\\|\\(integer\\)\\|\\(time\\)\\)?")
)
((match-end 6)
(setq reg "\\(\\<task\\>\\)\\|\\(\\<\\(endtask\\|function\\|\\(macro\\)?module\\|primitive\\)\\>\\)"))
((match-end 7)
(setq reg "\\(\\<\\(macro\\)?module\\>\\)\\|\\<endmodule\\>"))
((match-end 8)
(setq reg "\\(\\<primitive\\>\\)\\|\\(\\<\\(endprimitive\\|function\\|task\\|\\(macro\\)?module\\)\\>\\)"))
)
(let (b e)
(save-excursion
(verilog-re-search-backward reg nil 'move)
(cond
((match-end 1)
(setq b (progn
(skip-chars-forward "^ \t")
(verilog-forward-ws&directives)
(if (and width (looking-at width))
(progn
(goto-char (match-end 0))
(verilog-forward-ws&directives)
))
(point))
e (progn
(skip-chars-forward "a-zA-Z0-9_")
(point)))
(setq string (buffer-substring b e)))
(t
(ding 't)
(setq string "unmactched end(function|task|module|primitive)")))))
(end-of-line)
(insert (concat " // " string )))
)
)
)
)
)
)
)
)
)
(defun verilog-get-expr()
"Grab expression at point, e.g, case ( a | b & (c ^d))"
(let* ((b (progn
(verilog-forward-syntactic-ws)
(skip-chars-forward " \t")
(point)))
(e (let ((par 1))
(cond
((looking-at "(")
(forward-char 1)
(while (and (/= par 0)
(verilog-re-search-forward "\\((\\)\\|\\()\\)" nil 'move))
(cond
((match-end 1)
(setq par (1+ par)))
((match-end 2)
(setq par (1- par)))))
(point))
((looking-at "\\[")
(forward-char 1)
(while (and (/= par 0)
(verilog-re-search-forward "\\(\\[\\)\\|\\(\\]\\)" nil 'move))
(cond
((match-end 1)
(setq par (1+ par)))
((match-end 2)
(setq par (1- par)))))
(verilog-forward-syntactic-ws)
(skip-chars-forward "^ \t\n")
(point))
((looking-at "/[/\\*]")
b)
('t
(skip-chars-forward "^: \t\n")
(point)
))))
(str (buffer-substring b e)))
(if (setq e (string-match "[ \t]*\\(\\(\n\\)\\|\\(//\\)\\|\\(/\\*\\)\\)" str))
(setq str (concat (substring str 0 e) "...")))
str)
)
(defun verilog-expand-vector ()
"Take a signal vector on the current line and expand it to multiple lines.
Useful for creating tri's and other expanded fields."
(interactive)
(verilog-expand-vector-internal "[" "]"))
(defun verilog-expand-vector-internal (bra ket)
"Given a start brace and end brace, expand one line into many lines."
(interactive)
(save-excursion
(forward-line 0)
(let ((signal-string (buffer-substring (point)
(progn
(end-of-line) (point)))))
(if (string-match (concat "\\(.*\\)"
(regexp-quote bra)
"\\([0-9]*\\)\\(:[0-9]*\\|\\)\\(::[0-9---]*\\|\\)"
(regexp-quote ket)
"\\(.*\\)$") signal-string)
(let* ((sig-head (match-string 1 signal-string))
(vec-start (string-to-int (match-string 2 signal-string)))
(vec-end (if (= (match-beginning 3) (match-end 3))
vec-start
(string-to-int (substring signal-string (1+ (match-beginning 3)) (match-end 3)))))
(vec-range (if (= (match-beginning 4) (match-end 4))
1
(string-to-int (substring signal-string (+ 2 (match-beginning 4)) (match-end 4)))))
(sig-tail (match-string 5 signal-string))
vec)
;; Decode vectors
(setq vec nil)
(if (< vec-range 0)
(let ((tmp vec-start))
(setq vec-start vec-end
vec-end tmp
vec-range (- vec-range))))
(if (< vec-end vec-start)
(while (<= vec-end vec-start)
(setq vec (append vec (list vec-start)))
(setq vec-start (- vec-start vec-range)))
(while (<= vec-start vec-end)
(setq vec (append vec (list vec-start)))
(setq vec-start (+ vec-start vec-range))))
;;
;; Delete current line
(delete-region (point) (progn (forward-line 0) (point)))
;;
;; Expand vector
(while vec
(insert (concat sig-head bra (int-to-string (car vec)) ket sig-tail "\n"))
(setq vec (cdr vec)))
(delete-char -1)
;;
)))))
(defun verilog-strip-comments ()
"Strip all comments from the verilog code."
(interactive)
(goto-char (point-min))
(while (re-search-forward "//" nil t)
(let ((bpt (- (point) 2)))
(end-of-line)
(delete-region bpt (point))))
;;
(goto-char (point-min))
(while (re-search-forward "/\\*" nil t)
(let ((bpt (- (point) 2)))
(re-search-forward "\\*/")
(delete-region bpt (point))))
)
(defun verilog-one-line ()
"Converts structural verilog instances to occupy one line."
(interactive)
(goto-char (point-min))
(while (re-search-forward "\\([^;]\\)[ \t]*\n[ \t]*" nil t)
(replace-match "\\1 " nil nil)))
(defun verilog-verilint-off ()
"Convert a verilint warning line into a disable statement.
(W240) pci_bfm_null.v, line 46: Unused input: pci_rst_
becomes:
//Verilint 240 off // WARNING: Unused input
"
(interactive)
(save-excursion
(beginning-of-line)
(when (looking-at "\\(.*\\)([WE]\\([0-9A-Z]+\\)).*,\\s +line\\s +[0-9]+:\\s +\\([^:\n]+\\):?.*$")
(replace-match (format
;; %3s makes numbers 1-999 line up nicely
"\\1//Verilint %3s off // WARNING: \\3"
(match-string 2)))
(verilog-indent-line))))
(defun verilog-auto-save-compile ()
"Update automatics with \\[verilog-auto],
save the buffer, and compile to check syntax."
(interactive)
(verilog-auto)
(save-buffer)
(compile compile-command))
;;;
;;; Indentation
;;;
(defconst verilog-indent-alist
'((block . (+ ind verilog-indent-level))
(case . (+ ind verilog-case-indent))
(cparenexp . (+ ind verilog-indent-level))
(cexp . (+ ind verilog-cexp-indent))
(defun . verilog-indent-level-module)
(declaration . verilog-indent-level-declaration)
(tf . verilog-indent-level)
(behavioral . (+ verilog-indent-level-behavioral verilog-indent-level-module))
(statement . ind)
(cpp . 0)
(comment . (verilog-comment-indent))
(unknown . 3)
(string . 0)))
(defun verilog-continued-line-1 (lim)
"Return true if this is a continued line.
Set point to where line starts"
(let ((continued 't))
(if (eq 0 (forward-line -1))
(progn
(end-of-line)
(verilog-backward-ws&directives lim)
(if (bobp)
(setq continued nil)
(setq continued (verilog-backward-token))
)
)
(setq continued nil)
)
continued)
)
(defun verilog-calculate-indent ()
"Calculate the indent of the current Verilog line, through examination
of previous lines. Once a line is found that is definitive as to the
type of the current line, return that lines' indent level and it's
type. Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
(save-excursion
(let* ((starting_position (point))
(par 0)
(begin (looking-at "[ \t]*begin\\>"))
(lim (save-excursion (verilog-re-search-backward "\\(\\<begin\\>\\)\\|\\(\\<module\\>\\)" nil t)))
(type (catch 'nesting
;; Keep working backwards until we can figure out
;; what type of statement this is.
;; Basically we need to figure out
;; 1) if this is a continuation of the previous line;
;; 2) are we in a block scope (begin..end)
;; if we are in a comment, done.
(if (verilog-in-star-comment-p) (throw 'nesting 'comment))
;; if we are in a parenthesized list, done.
(if (verilog-in-paren) (progn (setq par 1) (throw 'nesting 'block)))
; (if (/= 0 (verilog-parenthesis-depth)) (progn (setq par 1) (throw 'nesting 'block)))
;; See if we are continuing a previous line
(while t
;; trap out if we crawl off the top of the buffer
(if (bobp) (throw 'nesting 'cpp))
(if (verilog-continued-line-1 lim)
(let ((sp (point)))
(if (and
(not (looking-at verilog-complete-reg))
(verilog-continued-line-1 lim))
(progn (goto-char sp)
(throw 'nesting 'cexp))
(goto-char sp))
(if (and begin
(not verilog-indent-begin-after-if)
(looking-at verilog-no-indent-begin-re))
(throw 'nesting 'statement)
(progn
(throw 'nesting 'cexp)
)
))
;; not a continued line
(goto-char starting_position))
(if (looking-at "\\<else\\>")
;; search back for governing if, striding across begin..end pairs
;; appropriately
(let ((elsec 1))
(while (verilog-re-search-backward verilog-ends-re nil 'move)
(cond
((match-end 1) ; else, we're in deep
(setq elsec (1+ elsec))
)
((match-end 2) ; found it
(setq elsec (1- elsec))
(if (= 0 elsec)
(if verilog-align-ifelse
(throw 'nesting 'statement)
(progn ;; back up to first word on this line
(beginning-of-line)
(verilog-forward-syntactic-ws)
(throw 'nesting 'statement))
)))
(t ; endblock
; try to leap back to matching outward block by striding across
; indent level changing tokens then immediately
; previous line governs indentation.
(let ((reg)(nest 1))
;; verilog-ends => else|if|end|join|endcase|endtable|endspecify|endfunction|endtask
(cond
((match-end 3) ; end
;; Search back for matching begin
(setq reg "\\(\\<begin\\>\\)\\|\\(\\<end\\>\\)" )
)
((match-end 5) ; endcase
;; Search back for matching case
(setq reg "\\(\\<case[xz]?\\>[^:]\\)\\|\\(\\<endcase\\>\\)" )
)
((match-end 7) ; endspecify
;; Search back for matching specify
(setq reg "\\(\\<specify\\>\\)\\|\\(\\<endspecify\\>\\)" )
)
((match-end 8) ; endfunction
;; Search back for matching function
(setq reg "\\(\\<function\\>\\)\\|\\(\\<endfunction\\>\\)" )
)
((match-end 9) ; endtask
;; Search back for matching task
(setq reg "\\(\\<task\\>\\)\\|\\(\\<endtask\\>\\)" )
)
((match-end 4) ; join
;; Search back for matching fork
(setq reg "\\(\\<fork\\>\\)\\|\\(\\<join\\>\\)" )
)
((match-end 6) ; endtable
;; Search back for matching table
(setq reg "\\(\\<table\\>\\)\\|\\(\\<endtable\\>\\)" )
)
)
(catch 'skip
(while (verilog-re-search-backward reg nil 'move)
(cond
((match-end 1) ; begin
(setq nest (1- nest))
(if (= 0 nest)
(throw 'skip 1)))
((match-end 2) ; end
(setq nest (1+ nest)))))
)
)
)
)
)
)
)
(throw 'nesting (verilog-calc-1))
)
)
)
)
;; Return type of block and indent level.
(if (not type)
(setq type 'cpp))
(if (> par 0) ; Unclosed Parenthesis
(list 'cparenexp par)
(cond
((eq type 'case)
(list type (verilog-case-indent-level)))
((eq type 'statement)
(list type (current-column)))
((eq type 'defun)
(list type 0))
(t
(list type (verilog-indent-level)))))
)
)
)
(defun verilog-calc-1 ()
""
(catch 'nesting
(while (verilog-re-search-backward verilog-indent-re nil 'move)
(cond
((looking-at verilog-behavioral-level-re)
(throw 'nesting 'behavioral))
((looking-at verilog-beg-block-re-1)
(cond
((match-end 2) (throw 'nesting 'case))
(t (throw 'nesting 'block))))
((looking-at verilog-end-block-re)
(verilog-leap-to-head)
(if (verilog-in-case-region-p)
(progn
(verilog-leap-to-case-head)
(if (looking-at verilog-case-re)
(throw 'nesting 'case))
)))
((looking-at verilog-defun-level-re)
(throw 'nesting 'defun))
((looking-at verilog-cpp-level-re)
(throw 'nesting 'cpp))
((bobp)
(throw 'nesting 'cpp))
)
)
)
)
(defun verilog-leap-to-case-head () ""
(let ((nest 1))
(while (/= 0 nest)
(verilog-re-search-backward "\\(\\<case[xz]?\\>[^:]\\)\\|\\(\\<endcase\\>\\)" nil 'move)
(cond
((match-end 1)
(setq nest (1- nest)))
((match-end 2)
(setq nest (1+ nest)))
((bobp)
(ding 't)
(setq nest 0))
)
)
)
)
(defun verilog-leap-to-head ()
"Move point to the head of this block; jump from end to matching begin,
from endcase to matching case, and so on."
(let (reg
snest
(nest 1))
(cond
((looking-at "\\<end\\>")
;; Search back for matching begin
(setq reg (concat "\\(\\<begin\\>\\)\\|\\(\\<end\\>\\)\\|"
"\\(\\<endcase\\>\\)\\|\\(\\<join\\>\\)" )))
((looking-at "\\<endcase\\>")
;; Search back for matching case
(setq reg "\\(\\<case[xz]?\\>\\)\\|\\(\\<endcase\\>\\)" )
)
((looking-at "\\<join\\>")
;; Search back for matching fork
(setq reg "\\(\\<fork\\>\\)\\|\\(\\<join\\>\\)" )
)
((looking-at "\\<endtable\\>")
;; Search back for matching table
(setq reg "\\(\\<table\\>\\)\\|\\(\\<endtable\\>\\)" )
)
((looking-at "\\<endspecify\\>")
;; Search back for matching specify
(setq reg "\\(\\<specify\\>\\)\\|\\(\\<endspecify\\>\\)" )
)
((looking-at "\\<endfunction\\>")
;; Search back for matching function
(setq reg "\\(\\<function\\>\\)\\|\\(\\<endfunction\\>\\)" )
)
((looking-at "\\<endtask\\>")
;; Search back for matching task
(setq reg "\\(\\<task\\>\\)\\|\\(\\<endtask\\>\\)" )
)
)
(catch 'skip
(let (sreg)
(while (verilog-re-search-backward reg nil 'move)
(cond
((match-end 1) ; begin
(setq nest (1- nest))
(if (= 0 nest)
;; Now previous line describes syntax
(throw 'skip 1))
(if (and snest
(= snest nest))
(setq reg sreg))
)
((match-end 2) ; end
(setq nest (1+ nest))
)
((match-end 3)
;; endcase, jump to case
(setq snest nest)
(setq nest (1+ nest))
(setq sreg reg)
(setq reg "\\(\\<case[xz]?\\>[^:]\\)\\|\\(\\<endcase\\>\\)" )
)
((match-end 4)
;; join, jump to fork
(setq snest nest)
(setq nest (1+ nest))
(setq sreg reg)
(setq reg "\\(\\<fork\\>\\)\\|\\(\\<join\\>\\)" )
)
)
)
)
)
)
)
(defun verilog-continued-line ()
"Return true if this is a continued line.
Set point to where line starts"
(let ((continued 't))
(if (eq 0 (forward-line -1))
(progn
(end-of-line)
(verilog-backward-ws&directives)
(if (bobp)
(setq continued nil)
(while (and continued
(save-excursion
(skip-chars-backward " \t")
(not (bolp))))
(setq continued (verilog-backward-token))
) ;; while
)
)
(setq continued nil)
)
continued)
)
(defun verilog-backward-token ()
"step backward token, returning true if we are now at an end of line token"
(verilog-backward-syntactic-ws)
(cond
((bolp)
nil)
(;-- Anything ending in a ; is complete
(= (preceding-char) ?\;)
nil)
(;-- Could be 'case (foo)' or 'always ＠(bar)' which is complete
(= (preceding-char) ?\))
(progn
(backward-char)
(backward-up-list 1)
(verilog-backward-syntactic-ws)
(forward-word -1)
(not (looking-at "\\<case[xz]?\\>[^:]"))))
(;-- any of begin|initial|while are complete statements; 'begin : foo' is also complete
t
(forward-word -1)
(cond
(
(looking-at "\\(else\\)\\|\\(initial\\>\\)\\|\\(always\\>\\)")
t)
(
(looking-at verilog-indent-reg)
nil)
(t
(let
((back (point)))
(verilog-backward-syntactic-ws)
(cond
((= (preceding-char) ?\:)
(backward-char)
(verilog-backward-syntactic-ws)
(backward-sexp)
(if (looking-at "begin")
nil
t)
)
((= (preceding-char) ?\#)
(backward-char)
t)
((= (preceding-char) ?\`)
(backward-char)
t)
(t
(goto-char back)
t)
)
)
)
)
)
)
)
(defun verilog-backward-syntactic-ws (&optional lim)
;; Backward skip over syntactic whitespace for Emacs 19.
(save-restriction
(let* ((lim (or lim (point-min))) (here lim) )
(if (< lim (point))
(progn
(narrow-to-region lim (point))
(while (/= here (point))
(setq here (point))
(forward-comment (-(buffer-size)))
)))
))
t)
(defun verilog-forward-syntactic-ws (&optional lim)
;; forward skip over syntactic whitespace for Emacs 19.
(save-restriction
(let* ((lim (or lim (point-max)))
(here lim)
)
(if (> lim (point))
(progn
(narrow-to-region (point) lim)
(while (/= here (point))
(setq here (point))
(forward-comment (buffer-size))
)))
)))
(defun verilog-backward-ws&directives (&optional lim)
;; Backward skip over syntactic whitespace and compiler directives for Emacs 19.
(save-restriction
(let* ((lim (or lim (point-min)))
(here lim)
jump
)
(if (< lim (point))
(progn
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(cond
((nth 4 state) ;; in /* */ comment
(verilog-re-search-backward "/\*" nil 'move)
)
((nth 7 state) ;; in // comment
(verilog-re-search-backward "//" nil 'move)
)))
(narrow-to-region lim (point))
(while (/= here (point))
(setq here (point))
(forward-comment (-(buffer-size)))
(save-excursion
(beginning-of-line)
(if (looking-at verilog-directive-re-1)
(setq jump t)
(setq jump nil)))
(if jump
(beginning-of-line))
)))
)))
(defun verilog-forward-ws&directives (&optional lim)
;; forward skip over syntactic whitespace and compiler directives for Emacs 19.
(save-restriction
(let* ((lim (or lim (point-max)))
(here lim)
jump
)
(if (> lim (point))
(progn
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(cond
((nth 4 state) ;; in /* */ comment
(verilog-re-search-forward "/\*" nil 'move)
)
((nth 7 state) ;; in // comment
(verilog-re-search-forward "//" nil 'move)
)))
(narrow-to-region (point) lim)
(while (/= here (point))
(setq here (point))
(forward-comment (buffer-size))
(save-excursion
(beginning-of-line)
(if (looking-at verilog-directive-re-1)
(setq jump t)))
(if jump
(beginning-of-line 2))
)))
)))
(defun verilog-in-comment-p ()
"Return true if in a star or // comment"
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(or (nth 4 state) (nth 7 state)))
)
(defun verilog-in-star-comment-p ()
"Return true if in a star comment"
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(nth 4 state))
)
(defun verilog-in-comment-or-string-p ()
"Return true if in a string or comment"
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(or (nth 3 state) (nth 4 state) (nth 7 state))) ; Inside string or comment
)
(defun verilog-in-escaped-name-p ()
"Return true if in an escaped name"
(save-excursion
(backward-char)
(skip-chars-backward "^ \t\n")
(if (= (char-after (point) ) ?\\ )
t
nil)
)
)
(defun verilog-in-paren ()
"Return true if in a parenthetical expression"
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(/= 0 (nth 0 state)))
)
(defun verilog-parenthesis-depth ()
"Return non zero if in parenthetical-expression"
(save-excursion
(nth 1 (parse-partial-sexp (point-min) (point)))))
(defun verilog-skip-forward-comment-or-string ()
"Return true if in a string or comment"
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(cond
((nth 3 state) ;Inside string
(goto-char (nth 3 state))
t)
((nth 7 state) ;Inside // comment
(forward-line 1)
t)
((nth 4 state) ;Inside any comment (hence /**/)
(search-forward "*/"))
(t
nil)
)
)
)
(defun verilog-skip-backward-comment-or-string ()
"Return true if in a string or comment"
(let ((state
(save-excursion
(parse-partial-sexp (point-min) (point)))))
(cond
((nth 3 state) ;Inside string
(search-backward "\"")
t)
((nth 7 state) ;Inside // comment
(search-backward "//")
t)
((nth 4 state) ;Inside /* */ comment
(search-backward "/*")
t)
(t
nil)
)
)
)
(defun verilog-skip-forward-comment-p ()
"If in comment, move to end and return true"
(let (state)
(progn
(setq state
(save-excursion
(parse-partial-sexp (point-min) (point))))
(cond
((nth 3 state)
t)
((nth 7 state) ;Inside // comment
(end-of-line)
(forward-char 1)
t)
((nth 4 state) ;Inside any comment
t)
(t
nil)
)
)
)
)
(defun verilog-indent-line-relative ()
"Cheap version of indent line that only looks at
a few lines to determine indent level"
(interactive)
(let ((indent-str)
(sp (point)))
(if (looking-at "^[ \t]*$")
(cond ;- A blank line; No need to be too smart.
((bobp)
(setq indent-str (list 'cpp 0)))
((verilog-continued-line)
(let ((sp1 (point)))
(if (verilog-continued-line)
(progn (goto-char sp)
(setq indent-str (list 'statement (verilog-indent-level))))
(goto-char sp1)
(setq indent-str (list 'block (verilog-indent-level))))
)
(goto-char sp)
)
((goto-char sp)
(setq indent-str (verilog-calculate-indent))))
(progn (skip-chars-forward " \t")
(setq indent-str (verilog-calculate-indent)))
)
(verilog-do-indent indent-str)
)
)
(defun verilog-indent-line ()
"Indent for special part of code."
(if (looking-at verilog-directive-re)
;; We could nicely nest `ifdef's, but...
(progn
(delete-horizontal-space)
(indent-to 0)
(list 'cpp 0)) ; Return verilog-calculate-indent data
(verilog-do-indent (verilog-calculate-indent)))
)
(defun verilog-do-indent (indent-str)
""
(let ((type (car indent-str))
(ind (car (cdr indent-str))))
(cond
(; handle continued exp
(eq type 'cexp)
(let ((here (point)))
(verilog-backward-syntactic-ws)
(cond
((or
(= (preceding-char) ?\,)
(= (preceding-char) ?\])
(save-excursion
(verilog-beg-of-statement-1)
(looking-at verilog-declaration-re)))
(let* ( fst
(val
(save-excursion
(backward-char 1)
(verilog-beg-of-statement-1)
(setq fst (point))
(if (looking-at verilog-declaration-re)
(progn ;; we have multiple words
(goto-char (match-end 0))
(skip-chars-forward " \t")
(if (= (following-char) ?\[)
(progn
(forward-char 1)
(backward-up-list -1)
(skip-chars-forward " \t")
)
)
(current-column)
)
(progn
(goto-char fst)
(+ (current-column) verilog-cexp-indent)
)
)
)
)
)
(goto-char here)
(if (/= (current-column) val)
(progn
(delete-horizontal-space)
(indent-to val)))
)
)
((= (preceding-char) ?\) )
(goto-char here)
(let ((val (eval (cdr (assoc type verilog-indent-alist)))))
(if (/= (current-column) val)
(progn
(delete-horizontal-space)
(indent-to val)))
)
- 1 participants
- 0 comments