[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: vera-mode.el

From: Reto Zimmermann
Subject: Re: vera-mode.el
Date: Wed, 06 Jun 2007 23:30:40 +0200
User-agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.2) Gecko/20040804 Netscape/7.2 (ax)

Stefan Monnier wrote:

Attached is the latest version of the new vera-mode.el for review and
addition to the Emacs distribution.

- What's end-comment-column?  Sounds like comment-fill-column.

This is a remnant from vhdl-mode, but it's not used in vera-mode. I've removed it.

- It seems the language allows both //...\n and /*...*/ for comments, but the
  comment-start-skip does not reflect that.  And it should also define the
  corresponding comment-end-skip.

Fixed (even though I haven't found comment-end-skip in any of the existing modes).

- Also it should not (require 'font-lock) and neither should it call

People often asked why fontification is not on by default, so I just explicitely turned it on here. Is it on in the latest Emacs release? Seems odd if not. I made above changes.

- The call to easy-menu-define should be at toplevel rather than inside
  vera-mode.  And then the call to easy-menu-add should refer to
  vera-mode-menu rather than vera-mode-menu-list (which could be inlined
  into the call to easy-menu-define and then removed).


- The calls to modify-syntax-entry should not be at toplevel and neither
  should the (setq vera-mode-syntax-table (make-syntax-table)).  Best is to
  move it all inside the "defvar vera-mode-syntax-table" in the usual form
  (defvar vera-mode-syntax-table (let ((st (make-syntax-table))) ... st)).



;;; vera-mode.el --- major mode for editing Vera files.

;; Copyright (C) 1999-2007 Reto Zimmermann, Synopsys Inc.

;; Author:      Reto Zimmermann <address@hidden>
;; Maintainer:  Reto Zimmermann <address@hidden>
;; RCS:         $Id: vera-mode.el,v 2.24 2007/06/06 21:29:49 reto Exp reto $
;; Keywords:    languages vera
;; WWW:         http://www.iis.ee.ethz.ch/~zimmi/emacs/vera-mode.html

(defconst vera-version "2.18"
  "Vera Mode version number.")

(defconst vera-time-stamp "2007-06-06"
  "Vera Mode time stamp for last update.")

;; This file is not part of GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;; This package provides a simple Emacs major mode for editing Vera code.
;; It includes the following features:

;;   - Syntax highlighting
;;   - Indentation
;;   - Word/keyword completion
;;   - Block commenting
;;   - Works under GNU Emacs and XEmacs

;; Documentation

;; See comment string of function `vera-mode' or type `C-c C-h' in Emacs.

;; Installation

;; Prerequisites:  GNU Emacs 20.X/21.X, XEmacs 20.X/21.X

;; Put `vera-mode.el' into the `site-lisp' directory of your Emacs installation
;; or into an arbitrary directory that is added to the load path by the
;; following line in your Emacs start-up file (`.emacs'):

;;   (setq load-path (cons (expand-file-name "<directory-name>") load-path))

;; If you already have the compiled `vera-mode.elc' file, put it in the same
;; directory.  Otherwise, byte-compile the source file:
;;   Emacs:  M-x byte-compile-file  ->  vera-mode.el
;;   Unix:   emacs -batch -q -no-site-file -f batch-byte-compile vera-mode.el

;; Add the following lines to the `site-start.el' file in the `site-lisp'
;; directory of your Emacs installation or to your Emacs start-up file
;; (`.emacs'):

;;   (autoload 'vera-mode "vera-mode" "Vera Mode" t)
;;   (setq auto-mode-alist (cons '("\\.vr[hi]?\\'" . vera-mode) 


;;; Code:

;; XEmacs handling
(defconst vera-xemacs (string-match "XEmacs" emacs-version)
  "Non-nil if XEmacs is used.")

;;; Variables

(defgroup vera nil
  "Customizations for Vera Mode."
  :prefix "vera-"
  :group 'languages)

(defcustom vera-basic-offset 2
  "*Amount of basic offset used for indentation."
  :type 'integer
  :group 'vera)

(defcustom vera-underscore-is-part-of-word nil
  "*Non-nil means consider the underscore character `_' as part of word.
An identifier containing underscores is then treated as a single word in
select and move operations.  All parts of an identifier separated by underscore
are treated as single words otherwise."
  :type 'boolean
  :group 'vera)

(defcustom vera-intelligent-tab t
  "*Non-nil means `TAB' does indentation, word completion and tab insertion.
That is, if preceeding character is part of a word then complete word,
else if not at beginning of line then insert tab,
else if last command was a `TAB' or `RET' then dedent one step,
else indent current line.
If nil, TAB always indents current line."
  :type 'boolean
  :group 'vera)

;;; Mode definitions

;; Key bindings

(defvar vera-mode-map ()
  "Keymap for Vera Mode.")

(setq vera-mode-map (make-sparse-keymap))
;; backspace/delete key bindings
(define-key vera-mode-map [backspace] 'backward-delete-char-untabify)
(unless (boundp 'delete-key-deletes-forward) ; XEmacs variable
  (define-key vera-mode-map [delete]       'delete-char)
  (define-key vera-mode-map [(meta delete)] 'kill-word))
;; standard key bindings
(define-key vera-mode-map "\M-e"     'vera-forward-statement)
(define-key vera-mode-map "\M-a"     'vera-backward-statement)
(define-key vera-mode-map "\M-\C-e"  'vera-forward-same-indent)
(define-key vera-mode-map "\M-\C-a"  'vera-backward-same-indent)
;; mode specific key bindings
(define-key vera-mode-map "\C-c\t"   'indent-according-to-mode)
(define-key vera-mode-map "\M-\C-\\" 'vera-indent-region)
(define-key vera-mode-map "\C-c\C-c" 'vera-comment-uncomment-region)
(define-key vera-mode-map "\C-c\C-f" 'vera-fontify-buffer)
(define-key vera-mode-map "\C-c\C-h" 'vera-doc-mode)
(define-key vera-mode-map "\C-c\C-v" 'vera-version)
(define-key vera-mode-map "\M-\t"    'tab-to-tab-stop)
;; electric key bindings
(define-key vera-mode-map "\t"       'vera-electric-tab)
(define-key vera-mode-map "\r"       'vera-electric-return)
(define-key vera-mode-map " "        'vera-electric-space)
(define-key vera-mode-map "{"        'vera-electric-opening-brace)
(define-key vera-mode-map "}"        'vera-electric-closing-brace)
(define-key vera-mode-map "#"        'vera-electric-pound)
(define-key vera-mode-map "*"        'vera-electric-star)
(define-key vera-mode-map "/"        'vera-electric-slash)

;; Menu

(require 'easymenu)

(easy-menu-define vera-mode-menu vera-mode-map
  "Menu keymap for Vera Mode."
    ["(Un)Comment Out Region"   vera-comment-uncomment-region (mark)]
    ["Move Forward Statement"   vera-forward-statement t]
    ["Move Backward Statement"  vera-backward-statement t]
    ["Move Forward Same Indent" vera-forward-same-indent t]
    ["Move Backward Same Indent" vera-backward-same-indent t]
    ["Indent Line"              indent-according-to-mode t]
    ["Indent Region"            vera-indent-region (mark)]
    ["Indent Buffer"            vera-indent-buffer t]
    ["Fontify Buffer"           vera-fontify-buffer t]
    ["Documentation"            vera-doc-mode :keys "C-c C-h"]
    ["Version"                  vera-version t]
    ["Bug Report..."            vera-submit-bug-report t]
     ["Indentation Offset..." (customize-option 'vera-basic-offset) t]
     ["Underscore is Part of Word"
      (customize-set-variable 'vera-underscore-is-part-of-word
                              (not vera-underscore-is-part-of-word))
      :style toggle :selected vera-underscore-is-part-of-word]
     ["Use Intelligent Tab"
      (customize-set-variable 'vera-intelligent-tab
                              (not vera-intelligent-tab))
      :style toggle :selected vera-intelligent-tab]
     ["Save Options" customize-save-customized t]
     ["Customize..."            vera-customize t])))

;; Syntax table

(defvar vera-mode-syntax-table
  (let ((syntax-table (make-syntax-table)))
    ;; punctuation
    (modify-syntax-entry ?\# "."    syntax-table)
    (modify-syntax-entry ?\$ "."    syntax-table)
    (modify-syntax-entry ?\% "."    syntax-table)
    (modify-syntax-entry ?\& "."    syntax-table)
    (modify-syntax-entry ?\' "."    syntax-table)
    (modify-syntax-entry ?\* "."    syntax-table)
    (modify-syntax-entry ?\- "."    syntax-table)
    (modify-syntax-entry ?\+ "."    syntax-table)
    (modify-syntax-entry ?\. "."    syntax-table)
    (modify-syntax-entry ?\/ "."    syntax-table)
    (modify-syntax-entry ?\: "."    syntax-table)
    (modify-syntax-entry ?\; "."    syntax-table)
    (modify-syntax-entry ?\< "."    syntax-table)
    (modify-syntax-entry ?\= "."    syntax-table)
    (modify-syntax-entry ?\> "."    syntax-table)
    (modify-syntax-entry ?\\ "."    syntax-table)
    (modify-syntax-entry ?\| "."    syntax-table)
    ;; string
    (modify-syntax-entry ?\" "\""   syntax-table)
    ;; underscore
    (when vera-underscore-is-part-of-word
      (modify-syntax-entry ?\_ "w"    syntax-table))
    ;; escape
    (modify-syntax-entry ?\\ "\\"   syntax-table)
    ;; parentheses to match
    (modify-syntax-entry ?\( "()"   syntax-table)
    (modify-syntax-entry ?\) ")("   syntax-table)
    (modify-syntax-entry ?\[ "(]"   syntax-table)
    (modify-syntax-entry ?\] ")["   syntax-table)
    (modify-syntax-entry ?\{ "(}"   syntax-table)
    (modify-syntax-entry ?\} "){"   syntax-table)
    ;; comment
    (if vera-xemacs
        (modify-syntax-entry ?\/ ". 1456" syntax-table) ; XEmacs
      (modify-syntax-entry ?\/ ". 124b" syntax-table)) ; Emacs
    (modify-syntax-entry ?\* ". 23" syntax-table)
    ;; newline and CR
    (modify-syntax-entry ?\n "> b"    syntax-table)
    (modify-syntax-entry ?\^M "> b"   syntax-table)
  "Syntax table used in `vera-mode' buffers.")

(defvar vera-mode-ext-syntax-table
  (let ((syntax-table (copy-syntax-table vera-mode-syntax-table)))
    ;; extended syntax table including '_' (for simpler search regexps)
    (modify-syntax-entry ?_ "w" syntax-table)
  "Syntax table extended by `_' used in `vera-mode' buffers.")

;; Mode definition

(defun vera-mode ()
  "Major mode for editing Vera code.


  INDENTATION:  Typing `TAB' at the beginning of a line indents the line.
    The amount of indentation is specified by option `vera-basic-offset'.
    Indentation can be done for an entire region \(`M-C-\\') or buffer (menu).
    `TAB' always indents the line if option `vera-intelligent-tab' is nil.

  WORD/COMMAND COMPLETION:  Typing `TAB' after a (not completed) word looks
    for a word in the buffer or a Vera keyword that starts alike, inserts it
    and adjusts case.  Re-typing `TAB' toggles through alternative word

    Typing `TAB' after a non-word character inserts a tabulator stop (if not
    at the beginning of a line).  `M-TAB' always inserts a tabulator stop.

  COMMENTS:  `C-c C-c' comments out a region if not commented out, and
    uncomments a region if already commented out.

  HIGHLIGHTING (fontification):  Vera keywords, predefined types and
    constants, function names, declaration names, directives, as well as
    comments and strings are highlighted using different colors.

  VERA VERSION:  OpenVera 1.4 and Vera version 6.2.8.


To submit a bug report, use the corresponding menu entry within Vera Mode.
Add a description of the problem and include a reproducible test case.

Feel free to send questions and enhancement requests to <address@hidden>.

Official distribution is at

                                                  The Vera Mode Maintainer
                                               Reto Zimmermann <address@hidden>

Key bindings:

  (setq major-mode 'vera-mode)
  (setq mode-name "Vera")
  ;; set maps and tables
  (use-local-map vera-mode-map)
  (set-syntax-table vera-mode-syntax-table)
  ;; set local variables
  (require 'cc-cmds)
  (set (make-local-variable 'comment-start) "//")
  (set (make-local-variable 'comment-end) "")
  (set (make-local-variable 'comment-column) 40)
  (set (make-local-variable 'comment-start-skip) "/\\*+ *\\|//+ *")
  (set (make-local-variable 'comment-end-skip) " *\\*+/\\| *//+")
  (set (make-local-variable 'comment-indent-function) 'c-comment-indent)
  (set (make-local-variable 'paragraph-start) "^$")
  (set (make-local-variable 'paragraph-separate) paragraph-start)
  (set (make-local-variable 'require-final-newline) t)
  (set (make-local-variable 'indent-tabs-mode) nil)
  (set (make-local-variable 'indent-line-function) 'vera-indent-line)
  (set (make-local-variable 'parse-sexp-ignore-comments) t)
  ;; initialize font locking
  (set (make-local-variable 'font-lock-defaults)
       '(vera-font-lock-keywords nil nil ((?\_ . "w"))))
  ;; add menu (XEmacs)
  (easy-menu-add vera-mode-menu)
  (run-hooks 'menu-bar-update-hook)
  ;; miscellaneous
  (message "Vera Mode %s.  Type C-c C-h for documentation." vera-version)
  ;; run hooks
  (run-hooks 'vera-mode-hook))

;;; Vera definitions

;;; Keywords

(defconst vera-keywords
    "after" "all" "any" "around" "assoc_index" "assoc_size" "async"
    "bad_state" "bad_trans" "before" "begin" "big_endian" "bind"
    "bin_activation" "bit_normal" "bit_reverse" "break" "breakpoint"
    "case" "casex" "casez" "class" "constraint" "continue"
    "coverage" "coverage_block" "coverage_def" "coverage_depth"
    "coverage_goal" "coverage_group" "coverage_option" "coverage_val"
    "cross_num_print_missing" "cross_auto_bin_max" "cov_comment"
    "default" "depth" "dist" "do"
    "else" "end" "enum" "exhaustive" "export" "extends" "extern"
    "for" "foreach" "fork" "function"
    "hdl_task" "hdl_node" "hide"
    "if" "illegal_self_transition" "illegal_state" "illegal_transition"
    "in" "interface" "invisible"
    "little_endian" "local"
    "m_bad_state" "m_bad_trans" "m_state" "m_trans"
    "negedge" "new" "newcov" "non_rand" "none" "not" "null"
    "or" "ordered"
    "packed" "port" "posedge" "proceed" "prod" "prodget" "prodset"
    "program" "protected" "public"
    "rand" "randc" "randcase" "randseq" "repeat" "return" "rules"
    "sample" "sample_event" "shadow" "soft" "state" "static" "super"
    "task" "terminate" "this" "trans" "typedef"
    "var" "vca" "vector" "verilog_node" "verilog_task"
    "vhdl_node" "vhdl_task" "virtual" "virtuals" "visible" "void"
    "while" "wildcard" "with"
  "List of Vera keywords.")

(defconst vera-types
    "integer" "bit" "reg" "string" "bind_var" "event"
    "inout" "input" "output"
  "List of Vera predefined types.")

(defconst vera-q-values
    "gnr" "grx" "grz" "gr0" "gr1"
    "nr" "rx" "rz" "r0" "r1"
    "snr" "srx" "srz" "sr0" "sr1"
  "List of Vera predefined VCA q_values.")

(defconst vera-functions
    ;; system functions and tasks
    "call_func" "call_task" "cast_assign" "close_conn" "cm_coverage"
    "cm_get_coverage" "cm_get_limit"
    "coverage_backup_database_file" "coverage_save_database"
    "error" "error_mode" "error_wait" "exit"
    "fclose" "feof" "ferror" "fflush" "flag" "fopen" "fprintf" "freadb"
    "freadb" "freadh" "freadstr"
    "get_bind" "get_bind_id" "get_conn_err" "get_cycle" "get_env"
    "get_memsize" "get_plus_arg" "get_systime" "get_time" "get_time_unit"
    "mailbox_get" "mailbox_put" "mailbox_receive" "mailbox_send"
    "make_client" "make_server"
    "printf" "psprintf"
    "query" "query_str" "query_x"
    "rand48" "random" "region_enter" "region_exit" "rewind"
    "semaphore_get" "semaphore_put" "setstate" "signal_connect" "simwave_plot"
    "srandom" "sprintf" "sscanf" "stop" "suspend_thread" "sync"
    "timeout" "trace" "trigger"
    "unit_delay" "unlock_file" "up_connections"
    "urand48" "urandom" "urandom_range"
    "vera_bit_reverse" "vera_crc" "vera_pack" "vera_pack_big_endian"
    "vera_plot" "vera_report_profile" "vera_unpack" "vera_unpack_big_endian"
    "vsv_call_func" "vsv_call_task" "vsv_close_conn" "vsv_get_conn_err"
    "vsv_make_client" "vsv_make_server" "vsv_up_connections"
    "vsv_wait_for_done" "vsv_wait_for_input"
    "wait_child" "wait_var"
    ;; class methods
    "Configure" "DisableTrigger" "DoAction" "EnableCount" "EnableTrigger"
    "Event" "GetAssert" "GetCount" "GetFirstAssert" "GetName" "GetNextAssert"
    "atobin" "atohex" "atoi" "atooct"
    "backref" "bittostr" "capacity" "compare" "constraint_mode"
    "find" "find_index" "first" "first_index"
    "get_at_least" "get_auto_bin" "get_cov_weight" "get_coverage_goal"
    "get_cross_bin_max" "get_status" "get_status_msg" "getc"
    "icompare" "insert" "inst_get_at_least" "inst_get_auto_bin_max"
    "inst_get_collect" "inst_get_cov_weight" "inst_get_coverage_goal"
    "inst_getcross_bin_max" "inst_query" "inst_set_at_least"
    "inst_set_auto_bin_max" "inst_set_bin_activiation" "inst_set_collect"
    "inst_set_cov_weight" "inst_set_coverage_goal" "inst_set_cross_bin_max"
    "last" "last_index" "len" "load"
    "match" "max" "max_index" "min" "min_index"
    "object_compare" "object_copy" "object_print"
    "pack" "pick_index" "pop_back" "pop_front" "post_pack" "post_randomize"
    "post_unpack" "postmatch" "pre_pack" "pre_randomize" "prematch" "push_back"
    "push_front" "putc"
    "query" "query_str"
    "rand_mode" "randomize" "reserve" "reverse" "rsort"
    "search" "set_at_least" "set_auto_bin_max" "set_bin_activiation"
    "set_cov_weight" "set_coverage_goal" "set_cross_bin_max" "set_name" "size"
    "sort" "substr" "sum"
    "thismatch" "tolower" "toupper"
    "unique_index" "unpack"
    ;; empty methods
    "new" "object_compare"
    "post_boundary" "post_pack" "post_randomize" "post_unpack" "pre-randomize"
    "pre_boundary" "pre_pack" "pre_unpack"
  "List of Vera predefined system functions, tasks and class methods.")

(defconst vera-constants
    "ALL" "ANY"
    "stderr" "stdin" "stdout"
  "List of Vera predefined constants.")

(defconst vera-rvm-types
    "VeraListIterator_rvm_data" "VeraListIterator_rvm_log"
    "VeraListNodeVeraListIterator_rvm_log" "VeraListNodervm_data"
    "VeraListNodervm_log" "VeraList_VeraListIterator_rvm_log"
    "VeraList_rvm_data" "VeraList_rvm_log"
    "rvm_broadcast" "rvm_channel_class" "rvm_data" "rvm_data" "rvm_env"
    "rvm_log" "rvm_log_modifier" "rvm_log_msg" "rvm_log_msg" "rvm_log_msg_info"
    "rvm_log_watchpoint" "rvm_notify" "rvm_notify_event"
    "rvm_notify_event_config" "rvm_scheduler" "rvm_scheduler_election"
    "rvm_watchdog" "rvm_watchdog_port" "rvm_xactor" "rvm_xactor_callbacks"
  "List of Vera-RVM keywords.")

(defconst vera-rvm-functions
    "extern_rvm_atomic_gen" "extern_rvm_channel" "extern_rvm_scenario_gen"
    "rvm_OO_callback" "rvm_atomic_gen" "rvm_atomic_gen_callbacks_decl"
    "rvm_atomic_gen_decl" "rvm_atomic_scenario_decl" "rvm_channel"
    "rvm_channel_" "rvm_channel_decl" "rvm_command" "rvm_cycle" "rvm_debug"
    "rvm_error" "rvm_fatal" "rvm_note" "rvm_protocol" "rvm_report"
    "rvm_scenario_decl" "rvm_scenario_election_decl" "rvm_scenario_gen"
    "rvm_scenario_gen_callbacks_decl" "rvm_scenario_gen_decl"
    "rvm_trace" "rvm_transaction" "rvm_user" "rvm_verbose" "rvm_warning"
  "List of Vera-RVM functions.")

(defconst vera-rvm-constants
   "rvm_channel__SOURCE" "rvm_channel__SINK" "rvm_channel__NO_ACTIVE"
   "rvm_channel__ACT_PENDING" "rvm_channel__ACT_STARTED"
   "rvm_channel__ACT_COMPLETED" "rvm_channel__FULL" "rvm_channel__EMPTY"
   "rvm_channel__PUT" "rvm_channel__GOT" "rvm_channel__PEEKED"
   "rvm_channel__ACTIVATED" "rvm_channel__STARTED" "rvm_channel__COMPLETED"
   "rvm_channel__REMOVED" "rvm_channel__LOCKED" "rvm_channel__UNLOCKED"
   "rvm_data__EXECUTE" "rvm_data__STARTED" "rvm_data__ENDED"
   "rvm_env__CFG_GENED" "rvm_env__BUILT" "rvm_env__DUT_CFGED"
   "rvm_env__STARTED" "rvm_env__RESTARTED" "rvm_env__ENDED" "rvm_env__STOPPED"
   "rvm_env__CLEANED" "rvm_env__DONE" "rvm_log__DEFAULT" "rvm_log__UNCHANGED"
   "rvm_log__FAILURE_TYP" "rvm_log__NOTE_TYP" "rvm_log__DEBUG_TYP"
   "rvm_log__REPORT_TYP" "rvm_log__NOTIFY_TYP" "rvm_log__TIMING_TYP"
   "rvm_log__XHANDLING_TYP" "rvm_log__PROTOCOL_TYP" "rvm_log__TRANSACTION_TYP"
   "rvm_log__COMMAND_TYP" "rvm_log__CYCLE_TYP" "rvm_log__USER_TYP_0"
   "rvm_log__USER_TYP_1" "rvm_log__USER_TYP_2" "rvm_log__USER_TYP_3"
   "rvm_log__DEFAULT_TYP" "rvm_log__ALL_TYPES" "rvm_log__FATAL_SEV"
   "rvm_log__ERROR_SEV" "rvm_log__WARNING_SEV" "rvm_log__NORMAL_SEV"
   "rvm_log__TRACE_SEV" "rvm_log__DEBUG_SEV" "rvm_log__VERBOSE_SEV"
   "rvm_log__HIDDEN_SEV" "rvm_log__IGNORE_SEV" "rvm_log__DEFAULT_SEV"
   "rvm_log__ALL_SEVERITIES" "rvm_log__CONTINUE" "rvm_log__COUNT_AS_ERROR"
   "rvm_log__DEBUGGER" "rvm_log__DUMP" "rvm_log__STOP" "rvm_log__ABORT"
   "rvm_notify__ONE_SHOT_TRIGGER" "rvm_notify__ONE_BLAST_TRIGGER"
   "rvm_notify__HAND_SHAKE_TRIGGER" "rvm_notify__ON_OFF_TRIGGER"
   "rvm_xactor__XACTOR_IDLE" "rvm_xactor__XACTOR_BUSY"
   "rvm_xactor__XACTOR_STARTED" "rvm_xactor__XACTOR_STOPPED"
   "rvm_xactor__XACTOR_RESET" "rvm_xactor__XACTOR_SOFT_RST"
   "rvm_xactor__XACTOR_FIRM_RST" "rvm_xactor__XACTOR_HARD_RST"
   "rvm_xactor__XACTOR_PROTOCOL_RST" "rvm_broadcast__AFAP"
   "rvm_broadcast__ALAP" "rvm_watchdog__TIMEOUT"
   "rvm_env__DUT_RESET" "rvm_log__INTERNAL_TYP"
  "List of Vera-RVM predefined constants.")

;; `regexp-opt' undefined (`xemacs-devel' not installed)
(unless (fboundp 'regexp-opt)
  (defun regexp-opt (strings &optional paren)
    (let ((open (if paren "\\(" "")) (close (if paren "\\)" "")))
      (concat open (mapconcat 'regexp-quote strings "\\|") close))))

(defconst vera-keywords-regexp
  (concat "\\<\\(" (regexp-opt vera-keywords) "\\)\\>")
  "Regexp for Vera keywords.")

(defconst vera-types-regexp
  (concat "\\<\\(" (regexp-opt vera-types) "\\)\\>")
  "Regexp for Vera predefined types.")

(defconst vera-q-values-regexp
  (concat "\\<\\(" (regexp-opt vera-q-values) "\\)\\>")
  "Regexp for Vera predefined VCA q_values.")

(defconst vera-functions-regexp
  (concat "\\<\\(" (regexp-opt vera-functions) "\\)\\>")
  "Regexp for Vera predefined system functions, tasks and class methods.")

(defconst vera-constants-regexp
  (concat "\\<\\(" (regexp-opt vera-constants) "\\)\\>")
  "Regexp for Vera predefined constants.")

(defconst vera-rvm-types-regexp
  (concat "\\<\\(" (regexp-opt vera-rvm-types) "\\)\\>")
  "Regexp for Vera-RVM keywords.")

(defconst vera-rvm-functions-regexp
  (concat "\\<\\(" (regexp-opt vera-rvm-functions) "\\)\\>")
  "Regexp for Vera-RVM predefined system functions, tasks and class methods.")

(defconst vera-rvm-constants-regexp
  (concat "\\<\\(" (regexp-opt vera-rvm-constants) "\\)\\>")
  "Regexp for Vera-RVM predefined constants.")

;;; Font locking

;; XEmacs compatibility
(when vera-xemacs
  (require 'font-lock)
  (copy-face 'font-lock-reference-face 'font-lock-constant-face)
  (copy-face 'font-lock-preprocessor-face 'font-lock-builtin-face))

(defun vera-font-lock-match-item (limit)
  "Match, and move over, any declaration item after point. Adapted from
  (condition-case nil
        (narrow-to-region (point-min) limit)
        ;; match item
        (when (looking-at "\\s-*\\(\\w+\\)")
            (goto-char (match-end 1))
            ;; move to next item
            (if (looking-at "\\(\\s-*\\(\\[[^]]*\\]\\s-*\\)?,\\)")
                (goto-char (match-end 1))
              (end-of-line) t))))
    (error t)))

(defvar vera-font-lock-keywords
   ;; highlight keywords
   (list vera-keywords-regexp 1 'font-lock-keyword-face)
   ;; highlight types
   (list vera-types-regexp 1 'font-lock-type-face)
   ;; highlight RVM types
   (list vera-rvm-types-regexp 1 'font-lock-type-face)
   ;; highlight constants
   (list vera-constants-regexp 1 'font-lock-constant-face)
   ;; highlight RVM constants
   (list vera-rvm-constants-regexp 1 'font-lock-constant-face)
   ;; highlight q_values
   (list vera-q-values-regexp 1 'font-lock-constant-face)
   ;; highlight predefined functions, tasks and methods
   (list vera-functions-regexp 1 'vera-font-lock-function-face)
   ;; highlight predefined RVM functions
   (list vera-rvm-functions-regexp 1 'vera-font-lock-function-face)
   ;; highlight functions
   '("\\<\\(\\w+\\)\\s-*(" 1 font-lock-function-name-face)
   ;; highlight various declaration names
     2 font-lock-function-name-face)
     (1 font-lock-function-name-face) (2 font-lock-function-name-face))
   ;; highlight interface declaration names
     2 vera-font-lock-interface-face)
   ;; highlight variable name definitions
   (list (concat "^\\s-*" vera-types-regexp "\\s-*\\(\\[[^]]+\\]\\s-+\\)?")
         '(vera-font-lock-match-item nil nil (1 font-lock-variable-name-face)))
   (list (concat "^\\s-*" vera-rvm-types-regexp "\\s-*\\(\\[[^]]+\\]\\s-+\\)?")
         '(vera-font-lock-match-item nil nil (1 font-lock-variable-name-face)))
   ;; highlight numbers
   '("\\([0-9]*'[bdoh][0-9a-fA-FxXzZ_]+\\)" 1 vera-font-lock-number-face)
   ;; highlight filenames in #include directives
     1 font-lock-string-face)
   ;; highlight directives and directive names
   '("^#\\s-*\\(\\w+\\)\\>[ \t!]*\\(\\w+\\)?"
     (1 font-lock-builtin-face) (2 font-lock-variable-name-face nil t))
   ;; highlight `@', `$' and `#'
   '("\\(address@hidden)" 1 font-lock-keyword-face)
   ;; highlight @ and # definitions
     (1 vera-font-lock-number-face) (3 vera-font-lock-number-face nil t))
   ;; highlight interface signal name
   '("\\(\\w+\\)\\.\\w+" 1 vera-font-lock-interface-face)
  "Regular expressions to highlight in Vera Mode.")

(defvar vera-font-lock-number-face 'vera-font-lock-number-face
  "Face name to use for @ definitions.")

(defvar vera-font-lock-function-face 'vera-font-lock-function-face
  "Face name to use for predefined functions and tasks.")

(defvar vera-font-lock-interface-face 'vera-font-lock-interface-face
  "Face name to use for interface names.")

(defface vera-font-lock-number-face
  '((((class color) (background light)) (:foreground "Gold4"))
    (((class color) (background dark)) (:foreground "BurlyWood1"))
    (t (:italic t :bold t)))
  "Font lock mode face used to highlight @ definitions."
  :group 'font-lock-highlighting-faces)

(defface vera-font-lock-function-face
  '((((class color) (background light)) (:foreground "DarkCyan"))
    (((class color) (background dark)) (:foreground "Orchid1"))
    (t (:italic t :bold t)))
  "Font lock mode face used to highlight predefined functions and tasks."
  :group 'font-lock-highlighting-faces)

(defface vera-font-lock-interface-face
  '((((class color) (background light)) (:foreground "Grey40"))
    (((class color) (background dark)) (:foreground "Grey80"))
    (t (:italic t :bold t)))
  "Font lock mode face used to highlight interface names."
  :group 'font-lock-highlighting-faces)

(defun vera-fontify-buffer ()
  "Fontify buffer."

;;; Indentation

(defvar vera-echo-syntactic-information-p nil
  "If non-nil, syntactic info is echoed when the line is indented.")

;; offset functions

(defconst vera-offsets-alist
  '((comment        . vera-lineup-C-comments)
    (comment-intro  . vera-lineup-comment)
    (string         . -1000)
    (directive      . -1000)
    (block-open     . 0)
    (block-intro    . +)
    (block-close    . 0)
    (arglist-intro  . +)
    (arglist-cont   . +)
    (arglist-cont-nonempty . 0)
    (arglist-close  . 0)
    (statement      . 0)
    (statement-cont . +)
    (substatement   . +)
    (else-clause    . 0))
  "Association list of syntactic element symbols and indentation offsets.
Adapted from `c-offsets-alist'.")

(defun vera-evaluate-offset (offset langelem symbol)
  "OFFSET can be a number, a function, a variable, a list, or one of
the symbols + or -."
   ((eq offset '+)         (setq offset vera-basic-offset))
   ((eq offset '-)         (setq offset (- vera-basic-offset)))
   ((eq offset '++)        (setq offset (* 2 vera-basic-offset)))
   ((eq offset '--)        (setq offset (* 2 (- vera-basic-offset))))
   ((eq offset '*)         (setq offset (/ vera-basic-offset 2)))
   ((eq offset '/)         (setq offset (/ (- vera-basic-offset) 2)))
   ((functionp offset)     (setq offset (funcall offset langelem)))
   ((listp offset)
    (setq offset
          (let (done)
            (while (and (not done) offset)
              (setq done (vera-evaluate-offset (car offset) langelem symbol)
                    offset (cdr offset)))
            (if (not done)
   ((not (numberp offset)) (setq offset (symbol-value offset))))

(defun vera-get-offset (langelem)
  "Get offset from LANGELEM which is a cons cell of the form:
\(SYMBOL . RELPOS).  The symbol is matched against
vera-offsets-alist and the offset found there is either returned,
or added to the indentation at RELPOS.  If RELPOS is nil, then
the offset is simply returned."
  (let* ((symbol (car langelem))
         (relpos (cdr langelem))
         (match  (assq symbol vera-offsets-alist))
         (offset (cdr-safe match)))
    (if (not match)
        (setq offset 0
              relpos 0)
      (setq offset (vera-evaluate-offset offset langelem symbol)))
    (+ (if (and relpos
                (< relpos (save-excursion (beginning-of-line) (point))))
             (goto-char relpos)
       (vera-evaluate-offset offset langelem symbol))))

;; help functions

(defsubst vera-point (position)
  "Returns the value of point at certain commonly referenced POSITIONs.
POSITION can be one of the following symbols:
  bol  -- beginning of line
  eol  -- end of line
  boi  -- back to indentation
  ionl -- indentation of next line
  iopl -- indentation of previous line
  bonl -- beginning of next line
  bopl -- beginning of previous line
This function does not modify point or mark."
     ((eq position 'bol)  (beginning-of-line))
     ((eq position 'eol)  (end-of-line))
     ((eq position 'boi)  (back-to-indentation))
     ((eq position 'bonl) (forward-line 1))
     ((eq position 'bopl) (forward-line -1))
     ((eq position 'iopl) (forward-line -1) (back-to-indentation))
     ((eq position 'ionl) (forward-line 1) (back-to-indentation))
     (t (error "Unknown buffer position requested: %s" position)))

(defun vera-in-literal (&optional lim)
  "Determine if point is in a Vera literal."
    (let ((state (parse-partial-sexp (or lim (point-min)) (point))))
       ((nth 3 state) 'string)
       ((nth 4 state) 'comment)
       (t nil)))))

(defun vera-in-comment-p ()
  "Determine if point is in a Vera comment."
    (re-search-backward "\\(/\\*\\)\\|\\(\\*/\\)" nil t)
    (match-string 1)))

(defun vera-skip-forward-literal ()
  "Skip forward literal and return t if within one."
  (let ((state (save-excursion (parse-partial-sexp (point-min) (point)))))
     ((nth 3 state) (search-forward "\"") t) ; inside string
     ((nth 7 state) (forward-line 1) t)      ; inside // comment
     ((nth 4 state) (search-forward "*/") t) ; inside /* */ comment
     (t nil))))

(defun vera-skip-backward-literal ()
  "Skip backward literal and return t if within one."
  (let ((state (save-excursion (parse-partial-sexp (point-min) (point)))))
     ((nth 3 state) (search-backward "\"") t) ; inside string
     ((nth 7 state) (search-backward "//") t) ; inside // comment
     ((nth 4 state) (search-backward "/*") t) ; inside /* */ comment
     (t nil))))

(defsubst vera-re-search-forward (regexp &optional bound noerror)
  "Like `re-search-forward', but skips over matches in literals."
  (store-match-data '(nil nil))
  (while (and (re-search-forward regexp bound noerror)
              (progn (store-match-data '(nil nil))
                     (if bound (< (point) bound) t))))
  (match-end 0))

(defsubst vera-re-search-backward (regexp &optional bound noerror)
  "Like `re-search-backward', but skips over matches in literals."
  (store-match-data '(nil nil))
  (while (and (re-search-backward regexp bound noerror)
              (progn (store-match-data '(nil nil))
                     (if bound (> (point) bound) t))))
  (match-end 0))

(defun vera-forward-syntactic-ws (&optional lim skip-directive)
  "Forward skip of syntactic whitespace."
    (let* ((lim (or lim (point-max)))
           (here lim)
           (hugenum (point-max)))
      (narrow-to-region lim (point))
      (while (/= here (point))
        (setq here (point))
        (forward-comment hugenum)
        (when (and skip-directive (looking-at "^\\s-*#"))

(defun vera-backward-syntactic-ws (&optional lim skip-directive)
  "Backward skip over syntactic whitespace."
    (let* ((lim (or lim (point-min)))
           (here lim)
           (hugenum (- (point-max))))
      (when (< lim (point))
        (narrow-to-region lim (point))
        (while (/= here (point))
          (setq here (point))
          (forward-comment hugenum)
          (when (and skip-directive
                     (save-excursion (back-to-indentation)
                                     (= (following-char) ?\#)))

(defmacro vera-prepare-search (&rest body)
  "Switch to syntax table that includes '_', then execute BODY, and finally
restore the old environment.  Used for consistent searching."
  `(let ((current-syntax-table (syntax-table))
         (restore-prog                  ; program to restore enviroment
             ;; restore syntax table
             (set-syntax-table current-syntax-table))))
     ;; use extended syntax table
     (set-syntax-table vera-mode-ext-syntax-table)
     ;; execute BODY safely
     (setq result
           (condition-case info
               (progn ,@body)
             (error (eval restore-prog) ; restore environment on error
                    (error (cadr info))))) ; pass error up
     ;; restore environment
     (eval restore-prog)

;; comment indentation functions

(defsubst vera-langelem-col (langelem &optional preserve-point)
  "Convenience routine to return the column of LANGELEM's relpos.
Leaves point at the relpos unless PRESERVE-POINT is non-nil."
  (let ((here (point)))
    (goto-char (cdr langelem))
    (prog1 (current-column)
      (if preserve-point
          (goto-char here)))))

(defun vera-lineup-C-comments (langelem)
  "Line up C block comment continuation lines.
Nicked from `c-lineup-C-comments'."
    (let ((here (point))
          (stars (progn (back-to-indentation)
                        (skip-chars-forward "*")))
          (langelem-col (vera-langelem-col langelem)))
      (if (not (re-search-forward "/\\([*]+\\)" (vera-point 'eol) t))
            (if (not (looking-at "[*]+"))
                  ;; we now have to figure out where this comment begins.
                  (goto-char here)
                  (if (looking-at "[*]+/")
                      (progn (goto-char (match-end 0))
                             (forward-comment -1))
                    (goto-char (cdr langelem))
            (- (current-column) langelem-col))
        (if (zerop stars)
              (skip-chars-forward " \t")
              (- (current-column) langelem-col))
          ;; how many stars on comment opening line?  if greater than
          ;; on current line, align left.  if less than or equal,
          ;; align right.  this should also pick up Javadoc style
          ;; comments.
          (if (> (length (match-string 1)) stars)
                (- (current-column) -1 langelem-col))
            (- (current-column) stars langelem-col)))))))

(defun vera-lineup-comment (langelem)
  "Line up a comment start."
    (if (bolp)
        ;; not indent if at beginning of line
      ;; otherwise indent accordingly
      (goto-char (cdr langelem))

;; move functions

(defconst vera-beg-block-re "{\\|\\<\\(begin\\|fork\\)\\>")

(defconst vera-end-block-re 

(defconst vera-beg-substatement-re 

(defun vera-corresponding-begin (&optional recursive)
  "Find corresponding block begin if cursor is at a block end."
  (while (and (vera-re-search-backward
               (concat "\\(" vera-end-block-re "\\)\\|" vera-beg-block-re)
               nil t)
              (match-string 1))
    (vera-corresponding-begin t))
  (unless recursive (vera-beginning-of-substatement)))

(defun vera-corresponding-if ()
  "Find corresponding `if' if cursor is at `else'."
  (while (and (vera-re-search-backward "}\\|\\<\\(if\\|else\\)\\>" nil t)
              (not (equal (match-string 0) "if")))
    (if (equal (match-string 0) "else")

(defun vera-beginning-of-statement ()
  "Go to beginning of current statement."
  (let (pos)
          ;; search for end of previous statement
              (and (vera-re-search-backward
                    (concat "[);]\\|" vera-beg-block-re
                            "\\|" vera-end-block-re) nil t)
                   (equal (match-string 0) ")"))
          (setq pos (match-beginning 0))
          ;; go back to beginning of current statement
          (goto-char (or (match-end 0) 0))
          (vera-forward-syntactic-ws nil t)
          (when (looking-at "(")
            (vera-forward-syntactic-ws nil t))
          ;; if "else" found, go to "if" and search again
          (when (looking-at "\\<else\\>")
            (setq pos (point))
      ;; if search is repeated, go to beginning of last search
      (goto-char pos))))

(defun vera-beginning-of-substatement ()
  "Go to beginning of current substatement."
  (let ((lim (point))
  ;; go to beginning of statement
    (setq pos (point))
    ;; go forward all substatement opening statements until at LIM
    (while (and (< (point) lim)
                (vera-re-search-forward vera-beg-substatement-re lim t))
      (setq pos (match-beginning 0)))
    (vera-forward-syntactic-ws nil t)
    (when (looking-at "(")
      (vera-forward-syntactic-ws nil t))
    (when (< (point) lim)
      (setq pos (point)))
    (goto-char pos)))

(defun vera-forward-statement ()
  "Move forward one statement."
   (while (and (vera-re-search-forward
                (concat "[(;]\\|" vera-beg-block-re "\\|" vera-end-block-re)
                nil t)
               (equal (match-string 0) "("))

(defun vera-backward-statement ()
  "Move backward one statement."
   (vera-backward-syntactic-ws nil t)
   (unless (= (preceding-char) ?\))

(defun vera-forward-same-indent ()
  "Move forward to next line with same indent."
  (let ((pos (point))
        (indent (current-indentation)))
    (beginning-of-line 2)
    (while (and (not (eobp))
                (or (looking-at "^\\s-*$")
                    (> (current-indentation) indent)))
      (beginning-of-line 2))
    (if (= (current-indentation) indent)
      (message "No following line with same indent found in this block")
      (goto-char pos))))

(defun vera-backward-same-indent ()
  "Move backward to previous line with same indent."
  (let ((pos (point))
        (indent (current-indentation)))
    (beginning-of-line -0)
    (while (and (not (bobp))
                (or (looking-at "^\\s-*$")
                    (> (current-indentation) indent)))
      (beginning-of-line -0))
    (if (= (current-indentation) indent)
      (message "No preceding line with same indent found in this block")
      (goto-char pos))))

;; syntax analysis

(defmacro vera-add-syntax (symbol &optional relpos)
  "A simple macro to append the syntax in SYMBOL to the syntax list.
try to increase performance by using this macro."
  `(setq syntax (cons (cons ,symbol ,(or relpos 0)) syntax)))

(defun vera-guess-basic-syntax ()
  "Determine syntactic context of current line of code."
    (let ((indent-point (point))
          syntax state placeholder pos)
      ;; determine syntax state
      (setq state (parse-partial-sexp (point-min) (point)))
       ;; CASE 1: in a comment?
       ((nth 4 state)
        ;; skip empty lines
        (while (and (zerop (forward-line -1))
                    (looking-at "^\\s-*$")))
        (vera-add-syntax 'comment (vera-point 'boi)))
       ;; CASE 2: in a string?
       ((nth 3 state)
        (vera-add-syntax 'string))
       ;; CASE 3: at a directive?
       ((save-excursion (back-to-indentation) (= (following-char) ?\#))
        (vera-add-syntax 'directive (point)))
       ;; CASE 4: after an opening parenthesis (argument list continuation)?
       ((and (nth 1 state)
             (or (= (char-after (nth 1 state)) ?\()
                 ;; also for concatenation (opening '{' and ',' on eol/eopl)
                 (and (= (char-after (nth 1 state)) ?\{)
                      (or (save-excursion
                            (vera-backward-syntactic-ws) (= (char-before) ?,))
                            (end-of-line) (= (char-before) ?,))))))
        (goto-char (1+ (nth 1 state)))
        ;; is there code after the opening parenthesis on the same line?
        (if (looking-at "\\s-*$")
            (vera-add-syntax 'arglist-cont (vera-point 'boi))
          (vera-add-syntax 'arglist-cont-nonempty (point))))
       ;; CASE 5: at a block closing?
       ((save-excursion (back-to-indentation) (looking-at vera-end-block-re))
        ;; look for the corresponding begin
        (vera-add-syntax 'block-close (vera-point 'boi)))
       ;; CASE 6: at a block intro (the first line after a block opening)?
       ((and (save-excursion
               (vera-backward-syntactic-ws nil t)
               ;; previous line ends with a block opening?
               (or (/= (skip-chars-backward "{") 0) (backward-word 1))
               (when (looking-at vera-beg-block-re)
                 ;; go to beginning of substatement
                 (setq placeholder (point))))
             ;; not if "fork" is followed by "{"
               (not (and (progn (back-to-indentation) (looking-at "{"))
                         (progn (goto-char placeholder)
                                (looking-at "\\<fork\\>"))))))
        (goto-char placeholder)
        (vera-add-syntax 'block-intro (vera-point 'boi)))
       ;; CASE 7: at the beginning of an else clause?
       ((save-excursion (back-to-indentation) (looking-at "\\<else\\>"))
        ;; find corresponding if
        (vera-add-syntax 'else-clause (vera-point 'boi)))
       ;; CASE 8: at the beginning of a statement?
       ;; is the previous command completed?
       ((or (save-excursion
              (vera-backward-syntactic-ws nil t)
              (setq placeholder (point))
              ;; at the beginning of the buffer?
              (or (bobp)
                  ;; previous line ends with a semicolon or
                  ;; is a block opening or closing?
                  (when (or (/= (skip-chars-backward "{};") 0)
                            (progn (back-to-indentation)
                                   (looking-at (concat vera-beg-block-re "\\|"
                    ;; if at a block closing, go to beginning
                    (when (looking-at vera-end-block-re)
                    ;; go to beginning of the statement
                    (setq placeholder (point)))
                  ;; at a directive?
                  (when (progn (back-to-indentation) (looking-at "#"))
                    ;; go to previous statement
                    (setq placeholder (point)))))
            ;; at a block opening?
            (when (save-excursion (back-to-indentation)
                                  (looking-at vera-beg-block-re))
              ;; go to beginning of the substatement
              (setq placeholder (point))))
        (goto-char placeholder)
        (vera-add-syntax 'statement (vera-point 'boi)))
       ;; CASE 9: at the beginning of a substatement?
       ;; is this line preceeded by a substatement opening statement?
       ((save-excursion (vera-backward-syntactic-ws nil t)
                        (when (= (preceding-char) ?\)) (backward-sexp))
                        (backward-word 1)
                        (setq placeholder (point))
                        (looking-at vera-beg-substatement-re))
        (goto-char placeholder)
        (vera-add-syntax 'substatement (vera-point 'boi)))
       ;; CASE 10: it must be a statement continuation!
        ;; go to beginning of statement
        (vera-add-syntax 'statement-cont (vera-point 'boi))))
      ;; special case: look for a comment start
      (goto-char indent-point)
      (skip-chars-forward " \t")
      (when (looking-at comment-start)
        (vera-add-syntax 'comment-intro))
      ;; return syntax

;; indentation functions

(defun vera-indent-line ()
  "Indent the current line as Vera code. Optional SYNTAX is the
syntactic information for the current line. Returns the amount of
indentation change (in columns)."
   (let* ((syntax (vera-guess-basic-syntax))
          (pos (- (point-max) (point)))
          (indent (apply '+ (mapcar 'vera-get-offset syntax)))
          (shift-amt  (- (current-indentation) indent)))
     (when vera-echo-syntactic-information-p
       (message "syntax: %s, indent= %d" syntax indent))
     (unless (zerop shift-amt)
       (delete-region (point) (vera-point 'boi))
       (indent-to indent))
     (if (< (point) (vera-point 'boi))
       ;; If initial point was within line's indentation, position after
       ;; the indentation.  Else stay at same point in text.
       (when (> (- (point-max) pos) (point))
         (goto-char (- (point-max) pos))))

(defun vera-indent-buffer ()
  "Indent whole buffer as Vera code.
Calls `indent-region' for whole buffer."
  (message "Indenting buffer...")
  (indent-region (point-min) (point-max) nil)
  (message "Indenting buffer...done"))

(defun vera-indent-region (start end column)
  "Indent region as Vera code."
  (interactive "r\nP")
  (message "Indenting region...")
  (indent-region start end column)
  (message "Indenting region...done"))

(defsubst vera-indent-block-closing ()
  "If previous word is a block closing or `else', indent line again."
  (when (= (char-syntax (preceding-char)) ?w)
      (backward-word 1)
      (when (and (not (vera-in-literal))
                 (looking-at (concat vera-end-block-re "\\|\\<else\\>")))

;; electrifications

(defun vera-electric-tab (&optional prefix-arg)
  "If preceeding character is part of a word or a paren then hippie-expand,
else if right of non whitespace on line then tab-to-tab-stop,
else if last command was a tab or return then dedent one step or if a comment
toggle between normal indent and inline comment indent,
else indent `correctly'.
If `vera-intelligent-tab' is nil, always indent line."
  (interactive "*P")
  (if vera-intelligent-tab
        (cond ((memq (char-syntax (preceding-char)) '(?w ?_))
               (let ((case-fold-search t)
                     (case-replace nil)
                      (or (and (boundp 'hippie-expand-only-buffers)
                 (vera-expand-abbrev prefix-arg)))
              ((> (current-column) (current-indentation))
              ((and (or (eq last-command 'vera-electric-tab)
                        (eq last-command 'vera-electric-return))
                    (/= 0 (current-indentation)))
               (backward-delete-char-untabify vera-basic-offset nil))
              (t (indent-according-to-mode)))
        (setq this-command 'vera-electric-tab))

(defun vera-electric-return ()
  "Insert newline and indent.  Indent current line if it is a block closing."

(defun vera-electric-space (arg)
  "Insert a space.  Indent current line if it is a block closing."
  (interactive "*P")
  (unless arg
  (self-insert-command (prefix-numeric-value arg)))

(defun vera-electric-opening-brace (arg)
  "Outdent opening brace."
  (interactive "*P")
  (self-insert-command (prefix-numeric-value arg))
  (unless arg

(defun vera-electric-closing-brace (arg)
  "Outdent closing brace."
  (interactive "*P")
  (self-insert-command (prefix-numeric-value arg))
  (unless arg

(defun vera-electric-pound (arg)
  "Insert `#' and indent as directive it first character of line."
  (interactive "*P")
  (self-insert-command (prefix-numeric-value arg))
  (unless arg
      (skip-chars-backward " \t")
      (when (bolp)

(defun vera-electric-star (arg)
  "Insert a star character.  Nicked from `c-electric-star'."
  (interactive "*P")
  (self-insert-command (prefix-numeric-value arg))
  (if (and (not arg)
           (memq (vera-in-literal) '(comment))
           (eq (char-before) ?*)
             (forward-char -1)
             (skip-chars-backward "*")
             (if (eq (char-before) ?/)
                 (forward-char -1))
             (skip-chars-backward " \t")

(defun vera-electric-slash (arg)
  "Insert a slash character.  Nicked from `c-electric-slash'."
  (interactive "*P")
  (let* ((ch (char-before))
         (indentp (and (not arg)
                       (eq last-command-char ?/)
                       (or (and (eq ch ?/)
                                (not (vera-in-literal)))
                           (and (eq ch ?*)
    (self-insert-command (prefix-numeric-value arg))
    (when indentp

;;; Miscellaneous

;; Hippie expand customization (for expansion of Vera commands)

(defvar vera-abbrev-list
  (append (list nil) vera-keywords
          (list nil) vera-types
          (list nil) vera-functions
          (list nil) vera-constants
          (list nil) vera-rvm-types
          (list nil) vera-rvm-functions
          (list nil) vera-rvm-constants)
  "Predefined abbreviations for Vera.")

(defvar vera-expand-upper-case nil)

(eval-when-compile (require 'hippie-exp))

(defun vera-try-expand-abbrev (old)
  "Try expanding abbreviations from `vera-abbrev-list'."
  (unless old
    (he-init-string (he-dabbrev-beg) (point))
    (setq he-expand-list
          (let ((abbrev-list vera-abbrev-list)
                (sel-abbrev-list '()))
            (while abbrev-list
              (when (or (not (stringp (car abbrev-list)))
                         (concat "^" he-search-string) (car abbrev-list)))
                (setq sel-abbrev-list
                      (cons (car abbrev-list) sel-abbrev-list)))
              (setq abbrev-list (cdr abbrev-list)))
            (nreverse sel-abbrev-list))))
  (while (and he-expand-list
              (or (not (stringp (car he-expand-list)))
                  (he-string-member (car he-expand-list) he-tried-table t)))
    (unless (stringp (car he-expand-list))
      (setq vera-expand-upper-case (car he-expand-list)))
    (setq he-expand-list (cdr he-expand-list)))
  (if (null he-expand-list)
      (progn (when old (he-reset-string))
     (if vera-expand-upper-case
         (upcase (car he-expand-list))
       (car he-expand-list))
    (setq he-expand-list (cdr he-expand-list))

;; function for expanding abbrevs and dabbrevs
(defun vera-expand-abbrev (arg))
(fset 'vera-expand-abbrev (make-hippie-expand-function

;; Comments

(defun vera-comment-uncomment-region (beg end &optional arg)
  "Comment region if not commented, uncomment region if already commented."
  (interactive "r\nP")
  (goto-char beg)
  (if (looking-at (regexp-quote comment-start))
      (comment-region beg end '(4))
    (comment-region beg end)))

;; Help functions

(defun vera-customize ()
  "Call the customize function with `vera' as argument."
  (customize-group 'vera))

;; Other

;; remove ".vr" from `completion-ignored-extensions'
(setq completion-ignored-extensions
      (delete ".vr" completion-ignored-extensions))

;;; Bug reports

(defconst vera-mode-help-address "Reto Zimmermann <address@hidden>"
  "Address for Vera Mode bug reports.")

;; get reporter-submit-bug-report when byte-compiling
  (require 'reporter))

(defun vera-submit-bug-report ()
  "Submit via mail a bug report on Vera Mode."
  ;; load in reporter
   (y-or-n-p "Do you want to submit a report on Vera Mode? ")
   (require 'reporter)
   (let ((reporter-prompt-for-summary-p t))
      (concat "Vera Mode " vera-version)
       ;; report all important variables
      nil nil
      "Hi Reto,"))))

;;; Documentation

(defun vera-version ()
  "Echo the current version of Vera Mode in the minibuffer."
  (message "Vera Mode %s (%s)" vera-version vera-time-stamp))

(defun vera-doc-mode ()
  "Display Vera Mode documentation in *Help* buffer."
  (with-output-to-temp-buffer "*Help*"
    (princ mode-name)
    (princ " mode:\n")
    (princ (documentation 'vera-mode))
    (unless vera-xemacs
      (help-setup-xref (list #'vera-doc-mode) (interactive-p)))
      (set-buffer standard-output)


(provide 'vera-mode)

;;; vera-mode.el ends here

reply via email to

[Prev in Thread] Current Thread [Next in Thread]