Using Emacs with VxWorks

(add-to-list 'load-path "~/.emacs.d/lisp/ecb-master")
(require 'ecb)

(setq gtags-suggested-key-mapping t)
(setq load-path (cons "~/.emacs.d/lisp" load-path))
(autoload 'gtags-mode "gtags" "" t)
(add-hook 'c-mode-hook (lambda () (gtags-mode 1)))
(global-set-key "M-]" 'gtags-find-tag-from-here)
(global-set-key "M-[" 'gtags-pop-stack)
(global-set-key "M-#" 'gtags-find-rtag)

;;
;; get gtags to update for new files
;;
(defun gtags-root-dir ()
  "Returns GTAGS root directory or nil if doesn't exist."
  (with-temp-buffer
    (if (zerop (call-process "global" nil t nil "-pr"))
        (buffer-substring (point-min) (1- (point-max)))
      nil)))
(defun gtags-update-single(filename)  
  "Update Gtags database for changes in a single file"
  (interactive)
  (start-process "update-gtags" "update-gtags" "cmd" "-c" (concat "cd " (gtags-root-dir) " ; gtags --single-update " filename )))
(defun gtags-update-current-file()
  (interactive)
  (defvar filename)
  (setq filename (replace-regexp-in-string (gtags-root-dir) "." (buffer-file-name (current-buffer))))
  (gtags-update-single filename)
  (message "Gtags updated for %s" filename))
(defun gtags-update-hook()
  "Update GTAGS file incrementally upon saving a file"
  (when (bound-and-true-p gtags-mode)
    (when (gtags-root-dir)
      (gtags-update-current-file)))) 
(add-hook 'after-save-hook 'gtags-update-hook)

(ac-config-default)

(semantic-mode 1)
(global-ede-mode 1)
;; turn on idle time semantic scheduling of current buffer
(global-semantic-idle-scheduler-mode 1)
(global-semantic-idle-completions-mode 1)
;;
;; add semantic as a backend to auto complete and hook into c-mode-common-hook
;;
(defun ed-add-semantic-to-autocomplete ()
  (add-to-list 'ac-sources 'ac-source-semantic))
(add-hook 'c-mode-common-hook 'ed-add-semantic-to-autocomplete)
;;
;; enable support for gnu global
;;
(semanticdb-enable-gnu-global-databases 'c-mode)
(semanticdb-enable-gnu-global-databases 'c++-mode)
;;
;; semantic push and pop routines
;;
(defvar semantic-tags-location-ring (make-ring 20))
(defun semantic-goto-definition (point)
  "Goto definition using semantic-ia-fast-jump   
save the pointer marker if tag is found"
  (interactive "d")
  (condition-case err
      (progn                            
        (ring-insert semantic-tags-location-ring (point-marker))  
        (semantic-ia-fast-jump point))
    (error
     ;;if not found remove the tag saved in the ring  
     (set-marker (ring-remove semantic-tags-location-ring 0) nil nil)
     (signal (car err) (cdr err)))))
(defun semantic-pop-tag-mark ()             
  "popup the tag save by semantic-goto-definition"   
  (interactive)                                                    
  (if (ring-empty-p semantic-tags-location-ring)                   
      (message "%s" "No more tags available")                      
    (let* ((marker (ring-remove semantic-tags-location-ring 0))    
              (buff (marker-buffer marker))                        
                 (pos (marker-position marker)))                   
      (if (not buff)                                               
            (message "Buffer has been deleted")                    
        (switch-to-buffer buff)                                    
        (goto-char pos))                                           
      (set-marker marker nil nil))))
;;
;; had to hack gtags.el to remove gtags-find-tag binding for this to work
;;
(global-set-key "M-." 'semantic-goto-definition)
(global-set-key "M-," 'semantic-pop-tag-mark)
(global-set-key "M-/" 'semantic-ia-show-doc)
(global-set-key "C-c/" 'semantic-ia-show-summary)

(defconst wrs-c-style
  '((c-tab-always-indent        . t)
    (c-comment-only-line-offset . 0)
    (c-hanging-braces-alist     . ((substatement-open after)
                                   (brace-list-open)))
    (c-hanging-colons-alist     . ((member-init-intro before)
                                   (inher-intro)
                                   (case-label after)
                                   (label after)
                                   (access-label after)))
    (c-cleanup-list             . (scope-operator
                                   empty-defun-braces
                                   defun-close-semi))
    (c-offsets-alist            . ((arglist-close . c-lineup-arglist-close-under-paren)
                                   (topmost-intro     . 0)
                                   (topmost-intro-cont . 4)
                                   (class-open  . 4)
                                   (class-close . 4)
                                   (defun-open  . 4)
                                   (defun-close . 0)
                                   (defun-block-intro . 0)
                                   (substatement-open . 4)
                                   (brace-list-open . 4)
                                   (statement-block-intro . 0)
                                   (case-label        . 0)
                                   (statement-case-intro . 4)
                                   (block-open        . 0)
                                   (arglist-intro . 0)
                                   (knr-argdecl-intro . -)))
    (c-echo-syntactic-information-p . t)
    )
  "WRS Programming Style")
;; offset customizations not in my-c-style
(setq c-offsets-alist '((member-init-intro . ++)))
;; Customizations for all modes in CC Mode.
(defun my-c-mode-common-hook ()
  (c-add-style "WRS" wrs-c-style t)
  (setq tab-width 4
        ;; this will make sure spaces are used instead of tabs
        indent-tabs-mode nil)
  (define-key c-mode-base-map "C-m" 'c-context-line-break)
  )
(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)

wrenv -p vxworks-7 -o print_env

(load-file "<path-to-file>/vxworks.el")
(setq vxworks-install-dir "<your vxworks install dir - with a trailing slash!>")
(setq vxworks-workspace-dir "<your workspace directory - with a trailing slash!>")
(setup-vxworks-7-env)