--- /dev/null
+;;; vera-mode.el --- major mode for editing Vera files.
+
+;; Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+;; 2006, 2007 Free Software Foundation, Inc.
+
+;; Author: Reto Zimmermann <reto@gnu.org>
+;; Maintainer: Reto Zimmermann <reto@gnu.org>
+;; Version: 2.26
+;; 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-11"
+ "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
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; 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) auto-mode-alist))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; 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-"
+ :version "22.2"
+ :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-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."
+ '("Vera"
+ ["(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" describe-mode]
+ ["Version" vera-version t]
+ ["Bug Report..." vera-submit-bug-report t]
+ "--"
+ ("Options"
+ ["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)
+ "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)
+ "Syntax table extended by `_' used in `vera-mode' buffers.")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Mode definition
+
+;;;###autoload (add-to-list 'auto-mode-alist '("\\.vr[hi]?\\'" . vera-mode))
+
+;;;###autoload
+(defun vera-mode ()
+ "Major mode for editing Vera code.
+
+Usage:
+------
+
+ 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
+ completions.
+
+ 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.
+
+
+Maintenance:
+------------
+
+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 <reto@gnu.org>.
+
+Official distribution is at
+<http://www.iis.ee.ethz.ch/~zimmi/emacs/vera-mode.html>.
+
+
+ The Vera Mode Maintainer
+ Reto Zimmermann <reto@gnu.org>
+
+Key bindings:
+-------------
+
+\\{vera-mode-map}"
+ (interactive)
+ (kill-all-local-variables)
+ (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)
+ ;; 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"
+ "join"
+ "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"
+ "unpacked"
+ "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"
+ "ASYNC" "CLOCK"
+ "NDRIVE" "NHOLD" "NRX" "NRZ" "NR0" "NR1" "NSAMPLE"
+ "PDRIVE" "PHOLD" "PRX" "PRZ" "PR0" "PR1" "PSAMPLE"
+ )
+ "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
+ "alloc"
+ "call_func" "call_task" "cast_assign" "close_conn" "cm_coverage"
+ "cm_get_coverage" "cm_get_limit"
+ "coverage_backup_database_file" "coverage_save_database"
+ "delay"
+ "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"
+ "getstate"
+ "initstate"
+ "lock_file"
+ "mailbox_get" "mailbox_put" "mailbox_receive" "mailbox_send"
+ "make_client" "make_server"
+ "os_command"
+ "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"
+ "Wait"
+ "atobin" "atohex" "atoi" "atooct"
+ "backref" "bittostr" "capacity" "compare" "constraint_mode"
+ "delete"
+ "empty"
+ "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"
+ "hash"
+ "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"
+ "itoa"
+ "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"
+ "BAD_STATE" "BAD_TRANS"
+ "CALL" "CHECK" "CHGEDGE" "CLEAR" "COPY_NO_WAIT" "COPY_WAIT"
+ "CROSS" "CROSS_TRANS"
+ "DEBUG" "DELETE"
+ "EC_ARRAYX" "EC_CODE_END" "EC_CONFLICT" "EC_EVNTIMOUT" "EC_EXPECT"
+ "EC_FULLEXPECT" "EC_MBXTMOUT" "EC_NEXPECT" "EC_RETURN" "EC_RGNTMOUT"
+ "EC_SCONFLICT" "EC_SEMTMOUT" "EC_SEXPECT" "EC_SFULLEXPECT" "EC_SNEXTPECT"
+ "EC_USERSET" "EQ" "EVENT"
+ "FAIL" "FIRST" "FORK"
+ "GE" "GOAL" "GT" "HAND_SHAKE" "HI" "HIGH" "HNUM"
+ "LE" "LIC_EXIT" "LIC_PRERR" "LIC_PRWARN" "LIC_WAIT" "LO" "LOAD" "LOW" "LT"
+ "MAILBOX" "MAX_COM"
+ "NAME" "NE" "NEGEDGE" "NEXT" "NO_OVERLAP" "NO_OVERLAP_STATE"
+ "NO_OVERLAP_TRANS" "NO_VARS" "NO_WAIT" "NUM" "NUM_BIN" "NUM_DET"
+ "OFF" "OK" "OK_LAST" "ON" "ONE_BLAST" "ONE_SHOT" "ORDER"
+ "PAST_IT" "PERCENT" "POSEDGE" "PROGRAM"
+ "RAWIN" "REGION" "REPORT"
+ "SAMPLE" "SAVE" "SEMAPHORE" "SET" "SILENT" "STATE" "STR"
+ "STR_ERR_OUT_OF_RANGE" "STR_ERR_REGEXP_SYNTAX" "SUM"
+ "TRANS"
+ "VERBOSE"
+ "WAIT"
+ "stderr" "stdin" "stdout"
+ )
+ "List of Vera predefined constants.")
+
+(defconst vera-rvm-types
+ '(
+ "VeraListIterator_VeraListIterator_rvm_log"
+ "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_NUMERIC_VERSION_MACROS" "RVM_VERSION" "RVM_MINOR" "RVM_PATCH"
+ "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"
+ "RVM_SCHEDULER_IS_XACTOR" "RVM_BROADCAST_IS_XACTOR"
+ )
+ "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
+`font-lock-match-c-style-declaration-item-and-skip-to-next'."
+ (condition-case nil
+ (save-restriction
+ (narrow-to-region (point-min) limit)
+ ;; match item
+ (when (looking-at "\\s-*\\(\\w+\\)")
+ (save-match-data
+ (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
+ (list
+ ;; 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)
+ ;; highlight predefined RVM functions
+ (list vera-rvm-functions-regexp 1 'vera-font-lock-function)
+ ;; highlight functions
+ '("\\<\\(\\w+\\)\\s-*(" 1 font-lock-function-name-face)
+ ;; highlight various declaration names
+ '("^\\s-*\\(port\\|program\\|task\\)\\s-+\\(\\w+\\)\\>"
+ 2 font-lock-function-name-face)
+ '("^\\s-*bind\\s-+\\(\\w+\\)\\s-+\\(\\w+\\)\\>"
+ (1 font-lock-function-name-face) (2 font-lock-function-name-face))
+ ;; highlight interface declaration names
+ '("^\\s-*\\(class\\|interface\\)\\s-+\\(\\w+\\)\\>"
+ 2 vera-font-lock-interface)
+ ;; 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)
+ ;; highlight filenames in #include directives
+ '("^#\\s-*include\\s-*\\(<[^>\"\n]*>?\\)"
+ 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 `#'
+ '("\\([@$#]\\)" 1 font-lock-keyword-face)
+ ;; highlight @ and # definitions
+ '("@\\s-*\\(\\w*\\)\\(\\s-*,\\s-*\\(\\w+\\)\\)?\\>[^.]"
+ (1 vera-font-lock-number) (3 vera-font-lock-number nil t))
+ ;; highlight interface signal name
+ '("\\(\\w+\\)\\.\\w+" 1 vera-font-lock-interface)
+ )
+ "Regular expressions to highlight in Vera Mode.")
+
+(defvar vera-font-lock-number 'vera-font-lock-number
+ "Face name to use for @ definitions.")
+
+(defvar vera-font-lock-function 'vera-font-lock-function
+ "Face name to use for predefined functions and tasks.")
+
+(defvar vera-font-lock-interface 'vera-font-lock-interface
+ "Face name to use for interface names.")
+
+(defface vera-font-lock-number
+ '((((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)
+(put 'vera-font-lock-number-face 'face-alias 'vera-font-lock-number)
+
+(defface vera-font-lock-function
+ '((((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)
+(put 'vera-font-lock-function-face 'face-alias 'vera-font-lock-function)
+
+(defface vera-font-lock-interface
+ '((((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)
+(put 'vera-font-lock-interface-face 'face-alias 'vera-font-lock-interface)
+
+(defun vera-fontify-buffer ()
+ "Fontify buffer."
+ (interactive)
+ (font-lock-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 -."
+ (cond
+ ((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)
+ 0
+ done))))
+ ((not (numberp offset)) (setq offset (symbol-value offset))))
+ 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))))
+ (save-excursion
+ (goto-char relpos)
+ (current-column))
+ 0)
+ (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."
+ (save-excursion
+ (cond
+ ((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)))
+ (point)))
+
+(defun vera-in-literal (&optional lim)
+ "Determine if point is in a Vera literal."
+ (save-excursion
+ (let ((state (parse-partial-sexp (or lim (point-min)) (point))))
+ (cond
+ ((nth 3 state) 'string)
+ ((nth 4 state) 'comment)
+ (t nil)))))
+
+(defun vera-in-comment-p ()
+ "Determine if point is in a Vera comment."
+ (save-excursion
+ (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)))))
+ (cond
+ ((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)))))
+ (cond
+ ((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)
+ (vera-skip-forward-literal)
+ (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)
+ (vera-skip-backward-literal)
+ (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."
+ (save-restriction
+ (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-*#"))
+ (end-of-line))))))
+
+(defun vera-backward-syntactic-ws (&optional lim skip-directive)
+ "Backward skip over syntactic whitespace."
+ (save-restriction
+ (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) ?\#)))
+ (beginning-of-line)))))))
+
+(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))
+ result
+ (restore-prog ; program to restore enviroment
+ '(progn
+ ;; 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)
+ result))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 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'."
+ (save-excursion
+ (let ((here (point))
+ (stars (progn (back-to-indentation)
+ (skip-chars-forward "*")))
+ (langelem-col (vera-langelem-col langelem)))
+ (back-to-indentation)
+ (if (not (re-search-forward "/\\([*]+\\)" (vera-point 'eol) t))
+ (progn
+ (if (not (looking-at "[*]+"))
+ (progn
+ ;; we now have to figure out where this comment begins.
+ (goto-char here)
+ (back-to-indentation)
+ (if (looking-at "[*]+/")
+ (progn (goto-char (match-end 0))
+ (forward-comment -1))
+ (goto-char (cdr langelem))
+ (back-to-indentation))))
+ (- (current-column) langelem-col))
+ (if (zerop stars)
+ (progn
+ (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)
+ (progn
+ (back-to-indentation)
+ (- (current-column) -1 langelem-col))
+ (- (current-column) stars langelem-col)))))))
+
+(defun vera-lineup-comment (langelem)
+ "Line up a comment start."
+ (save-excursion
+ (back-to-indentation)
+ (if (bolp)
+ ;; not indent if at beginning of line
+ -1000
+ ;; otherwise indent accordingly
+ (goto-char (cdr langelem))
+ (current-column))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; move functions
+
+(defconst vera-beg-block-re "{\\|\\<\\(begin\\|fork\\)\\>")
+
+(defconst vera-end-block-re "}\\|\\<\\(end\\|join\\(\\s-+\\(all\\|any\\|none\\)\\)?\\)\\>")
+
+(defconst vera-beg-substatement-re "\\<\\(else\\|for\\|if\\|repeat\\|while\\)\\>")
+
+(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")
+ (vera-corresponding-if)
+ (forward-char)
+ (backward-sexp))))
+
+(defun vera-beginning-of-statement ()
+ "Go to beginning of current statement."
+ (let (pos)
+ (while
+ (progn
+ ;; search for end of previous statement
+ (while
+ (and (vera-re-search-backward
+ (concat "[);]\\|" vera-beg-block-re
+ "\\|" vera-end-block-re) nil t)
+ (equal (match-string 0) ")"))
+ (forward-char)
+ (backward-sexp))
+ (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 "(")
+ (forward-sexp)
+ (vera-forward-syntactic-ws nil t))
+ ;; if "else" found, go to "if" and search again
+ (when (looking-at "\\<else\\>")
+ (vera-corresponding-if)
+ (setq pos (point))
+ t))
+ ;; 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))
+ pos)
+ ;; go to beginning of statement
+ (vera-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 "(")
+ (forward-sexp)
+ (vera-forward-syntactic-ws nil t))
+ (when (< (point) lim)
+ (setq pos (point)))
+ (goto-char pos)))
+
+(defun vera-forward-statement ()
+ "Move forward one statement."
+ (interactive)
+ (vera-prepare-search
+ (while (and (vera-re-search-forward
+ (concat "[(;]\\|" vera-beg-block-re "\\|" vera-end-block-re)
+ nil t)
+ (equal (match-string 0) "("))
+ (backward-char)
+ (forward-sexp))
+ (vera-beginning-of-substatement)))
+
+(defun vera-backward-statement ()
+ "Move backward one statement."
+ (interactive)
+ (vera-prepare-search
+ (vera-backward-syntactic-ws nil t)
+ (unless (= (preceding-char) ?\))
+ (backward-char))
+ (vera-beginning-of-substatement)))
+
+(defun vera-forward-same-indent ()
+ "Move forward to next line with same indent."
+ (interactive)
+ (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)
+ (back-to-indentation)
+ (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."
+ (interactive)
+ (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)
+ (back-to-indentation)
+ (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."
+ (save-excursion
+ (beginning-of-line)
+ (let ((indent-point (point))
+ syntax state placeholder pos)
+ ;; determine syntax state
+ (setq state (parse-partial-sexp (point-min) (point)))
+ (cond
+ ;; 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) ?,))
+ (save-excursion
+ (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-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
+ (vera-beginning-of-substatement)
+ (setq placeholder (point))))
+ ;; not if "fork" is followed by "{"
+ (save-excursion
+ (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-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 "\\|"
+ vera-end-block-re))))
+ ;; if at a block closing, go to beginning
+ (when (looking-at vera-end-block-re)
+ (vera-corresponding-begin))
+ ;; go to beginning of the statement
+ (vera-beginning-of-statement)
+ (setq placeholder (point)))
+ ;; at a directive?
+ (when (progn (back-to-indentation) (looking-at "#"))
+ ;; go to previous statement
+ (vera-beginning-of-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
+ (vera-beginning-of-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!
+ (t
+ ;; go to beginning of statement
+ (vera-beginning-of-substatement)
+ (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
+ 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)."
+ (interactive)
+ (vera-prepare-search
+ (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)
+ (beginning-of-line)
+ (delete-region (point) (vera-point 'boi))
+ (indent-to indent))
+ (if (< (point) (vera-point 'boi))
+ (back-to-indentation)
+ ;; 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))))
+ shift-amt)))
+
+(defun vera-indent-buffer ()
+ "Indent whole buffer as Vera code.
+Calls `indent-region' for whole buffer."
+ (interactive)
+ (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)
+ (save-excursion
+ (backward-word 1)
+ (when (and (not (vera-in-literal))
+ (looking-at (concat vera-end-block-re "\\|\\<else\\>")))
+ (indent-according-to-mode)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 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
+ (progn
+ (cond ((memq (char-syntax (preceding-char)) '(?w ?_))
+ (let ((case-fold-search t)
+ (case-replace nil)
+ (hippie-expand-only-buffers
+ (or (and (boundp 'hippie-expand-only-buffers)
+ hippie-expand-only-buffers)
+ '(vera-mode))))
+ (vera-expand-abbrev prefix-arg)))
+ ((> (current-column) (current-indentation))
+ (tab-to-tab-stop))
+ ((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))
+ (indent-according-to-mode)))
+
+(defun vera-electric-return ()
+ "Insert newline and indent. Indent current line if it is a block closing."
+ (interactive)
+ (vera-indent-block-closing)
+ (newline-and-indent))
+
+(defun vera-electric-space (arg)
+ "Insert a space. Indent current line if it is a block closing."
+ (interactive "*P")
+ (unless arg
+ (vera-indent-block-closing))
+ (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
+ (indent-according-to-mode)))
+
+(defun vera-electric-closing-brace (arg)
+ "Outdent closing brace."
+ (interactive "*P")
+ (self-insert-command (prefix-numeric-value arg))
+ (unless arg
+ (indent-according-to-mode)))
+
+(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
+ (save-excursion
+ (backward-char)
+ (skip-chars-backward " \t")
+ (when (bolp)
+ (delete-horizontal-space)))))
+
+(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) ?*)
+ (save-excursion
+ (forward-char -1)
+ (skip-chars-backward "*")
+ (if (eq (char-before) ?/)
+ (forward-char -1))
+ (skip-chars-backward " \t")
+ (bolp)))
+ (indent-according-to-mode)))
+
+(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 ?*)
+ (vera-in-literal))))))
+ (self-insert-command (prefix-numeric-value arg))
+ (when indentp
+ (indent-according-to-mode))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; 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)))
+ (string-match
+ (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))
+ nil)
+ (he-substitute-string
+ (if vera-expand-upper-case
+ (upcase (car he-expand-list))
+ (car he-expand-list))
+ t)
+ (setq he-expand-list (cdr he-expand-list))
+ t))
+
+;; function for expanding abbrevs and dabbrevs
+(defun vera-expand-abbrev (arg))
+(fset 'vera-expand-abbrev (make-hippie-expand-function
+ '(try-expand-dabbrev
+ try-expand-dabbrev-all-buffers
+ vera-try-expand-abbrev)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 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."
+ (interactive)
+ (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 <reto@gnu.org>"
+ "Address for Vera Mode bug reports.")
+
+;; get reporter-submit-bug-report when byte-compiling
+(eval-when-compile
+ (require 'reporter))
+
+(defun vera-submit-bug-report ()
+ "Submit via mail a bug report on Vera Mode."
+ (interactive)
+ ;; load in reporter
+ (and
+ (y-or-n-p "Do you want to submit a report on Vera Mode? ")
+ (require 'reporter)
+ (let ((reporter-prompt-for-summary-p t))
+ (reporter-submit-bug-report
+ vera-mode-help-address
+ (concat "Vera Mode " vera-version)
+ (list
+ ;; report all important variables
+ 'vera-basic-offset
+ 'vera-underscore-is-part-of-word
+ 'vera-intelligent-tab
+ )
+ nil nil
+ "Hi Reto,"))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Documentation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun vera-version ()
+ "Echo the current version of Vera Mode in the minibuffer."
+ (interactive)
+ (message "Vera Mode %s (%s)" vera-version vera-time-stamp))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(provide 'vera-mode)
+
+;;; vera-mode.el ends here
projects / emacs.git / commitdiff