;;; vala-mode.el --- Vala mode derived mode

;; Author:     2005 Dylan R. E. Moonfire

;;	       2008 Étienne BERSAC

;; Maintainer: Étienne BERSAC <[email protected]>

;; Created:    2008 May the 4th

;; Modified:   May 2008

;; Version:    0.1

;; Keywords:   vala languages oop

;; This program 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 of the License, or

;; (at your option) any later version.

;; 

;; This program 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 this program; see the file COPYING.  If not, write to

;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

;; Boston, MA 02111-1307, USA.

;;; Commentary:

;;

;;    See http://live.gnome.org/Vala for details about Vala language.

;;

;;    This is a separate mode to implement the Vala constructs and

;;    font-locking. It is mostly the csharp-mode from

;;    http://mfgames.com/linux/csharp-mode with vala specific keywords

;;    and filename suffixes.

;;

;;    Note: The interface used in this file requires CC Mode 5.30 or

;;    later.

;;; .emacs (don't put in (require 'vala-mode))

;; (autoload 'vala-mode "vala-mode" "Major mode for editing Vala code." t)

;; (setq auto-mode-alist

;;    (append '(("\\.vala$" . vala-mode)) auto-mode-alist))

;;; Versions:

;;

;;	0.1	: Initial version based on csharp-mode

;;

;; This is a copy of the function in cc-mode which is used to handle

;; the eval-when-compile which is needed during other times.

(defun c-filter-ops (ops opgroup-filter op-filter &optional xlate)

  ;; See cc-langs.el, a direct copy.

  (unless (listp (car-safe ops))

    (setq ops (list ops)))

  (cond ((eq opgroup-filter t)

	 (setq opgroup-filter (lambda (opgroup) t)))

	((not (functionp opgroup-filter))

	 (setq opgroup-filter `(lambda (opgroup)

				 (memq opgroup ',opgroup-filter)))))

  (cond ((eq op-filter t)

	 (setq op-filter (lambda (op) t)))

	((stringp op-filter)

	 (setq op-filter `(lambda (op)

			    (string-match ,op-filter op)))))

  (unless xlate

    (setq xlate 'identity))

  (c-with-syntax-table (c-lang-const c-mode-syntax-table)

    (delete-duplicates

     (mapcan (lambda (opgroup)

	       (when (if (symbolp (car opgroup))

			 (when (funcall opgroup-filter (car opgroup))

			   (setq opgroup (cdr opgroup))

			   t)

		       t)

		 (mapcan (lambda (op)

			   (when (funcall op-filter op)

			     (let ((res (funcall xlate op)))

			       (if (listp res) res (list res)))))

			 opgroup)))

	     ops)

     :test 'equal)))

;; This inserts the bulk of the code.

(require 'cc-mode)

;; These are only required at compile time to get the sources for the

;; language constants.  (The cc-fonts require and the font-lock

;; related constants could additionally be put inside an

;; (eval-after-load "font-lock" ...) but then some trickery is

;; necessary to get them compiled.)

(eval-when-compile

  (let ((load-path

	 (if (and (boundp 'byte-compile-dest-file)

		  (stringp byte-compile-dest-file))

	     (cons (file-name-directory byte-compile-dest-file) load-path)

	   load-path)))

    (load "cc-mode" nil t)

    (load "cc-fonts" nil t)

    (load "cc-langs" nil t)))

(eval-and-compile

  ;; Make our mode known to the language constant system.  Use Java

  ;; mode as the fallback for the constants we don't change here.

  ;; This needs to be done also at compile time since the language

  ;; constants are evaluated then.

  (c-add-language 'vala-mode 'java-mode))

;; Java uses a series of regexes to change the font-lock for class

;; references. The problem comes in because Java uses Pascal (leading

;; space in names, SomeClass) for class and package names, but

;; Camel-casing (initial lowercase, upper case in words,

;; i.e. someVariable) for variables.

;;(error (byte-compile-dest-file))

;;(error (c-get-current-file))

(c-lang-defconst c-opt-after-id-concat-key

  vala (if (c-lang-const c-opt-identifier-concat-key)

	   (c-lang-const c-symbol-start)))

(c-lang-defconst c-basic-matchers-before

  vala `(

;;;; Font-lock the attributes by searching for the

;;;; appropriate regex and marking it as TODO.

	 ;;,`(,(concat "\\(" vala-attribute-regex "\\)")

	 ;;   0 font-lock-function-name-face)	   

	 ;; Put a warning face on the opener of unclosed strings that

	 ;; can't span lines.  Later font

	 ;; lock packages have a `font-lock-syntactic-face-function' for

	 ;; this, but it doesn't give the control we want since any

	 ;; fontification done inside the function will be

	 ;; unconditionally overridden.

	 ,(c-make-font-lock-search-function

	   ;; Match a char before the string starter to make

	   ;; `c-skip-comments-and-strings' work correctly.

	   (concat ".\\(" c-string-limit-regexp "\\)")

	   '((c-font-lock-invalid-string)))

	 ;; Fontify keyword constants.

	 ,@(when (c-lang-const c-constant-kwds)

	     (let ((re (c-make-keywords-re nil

			 (c-lang-const c-constant-kwds))))

	       `((eval . (list ,(concat "\\<\\(" re "\\)\\>")

			       1 c-constant-face-name)))))

	 ;; Fontify all keywords except the primitive types.

	 ,`(,(concat "\\<" (c-lang-const c-regular-keywords-regexp))