| Home Page | Recent Changes

Emacs

Emacs can do everything. Check out shell-mode or compile-mode for compiling unrealscript, and launching unreal.

Here is the source of unrealscript-mode. Suggestions, bug reports, etc, welcome,

;;; unrealscript-mode.el --- unrealscript mode derived from cc-mode

;; Author:     2007 John Connors
;; Maintainer: John Connors <johnc at yagc dot co dot uk>
;; Created:    March 2007
;; Version:    See cc-mode.el
;; Keywords:   unrealscript cc-mode 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:


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

;;; 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
  (require 'cc-langs)
  (require 'cc-fonts))

(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 'unrealscript-mode 'java-mode))

;; unrealscript has no boolean but a string and a vector type.
(c-lang-defconst c-primitive-type-kwds
  unrealscript 
  (append 
   '("bool" "name" "object" "actor" "string" "vector")
   (delete "boolean"
           ;; Use append to not be destructive on the
           ;; return value below.
           (append
            ;; Due to the fallback to Java, we need not give
            ;; a language to `c-lang-const'.
            (c-lang-const c-primitive-type-kwds)
            nil))))

(c-lang-defconst c-type-modifier-keywds
   unrealscript
    (append 
      '("config" "deprecated" "edfindable" "editconstarray" 
        "editinline" "export" "noexport" "globalconfig" 
        "localized" "const" "editconst" "input" "travel" 
        "skip" "export") 
      (c-lang-const c-type-modifier-keywds) 
      nil))


;;   "Keywords introducing extra declaration specifiers in the region
;; between the header and the body \(i.e. the \"K&R-region\") in
;; declarations."

(c-lang-defconst c-postfix-decl-spec-kwds
  unrealscript
  (append
   '("abstract" "native" "nativereplication" "nousercreate" "within" 
     "perobjectconfig" "transient" "noexport" "dependson" "exportstructs" 
     "cacheexempt" "hidedropdown" "parseconfig" "dontcollapsecategories"
     "collapsecategories" "hidecategories" "showcategories" "placeable"
     "notplaceable" "instanced")
   (c-lang-const c-postfix-decl-spec-kwds)
   nil))

;;   "Keywords that may be followed by a comma separated list of type
;; identifiers, where each optionally can be prefixed by keywords.  (Can
;; also be used for the special case when the list can contain only one
;; element.)"
(c-lang-defconst c-type-list-kwds
  unrealscript
  (cons "within"
        (c-lang-const c-type-list-kwds)))

;; Function declarations begin with "function" in this language.
;; There's currently no special keyword list for that in CC Mode, but
;; treating it as a modifier works fairly well.
(c-lang-defconst c-modifier-kwds
 unrealscript 
  (cons
    "function" 
   (c-lang-const c-modifier-kwds)))


(c-lang-defconst c-block-decls-with-vars
  unrealscript
  (cons 
   "state" 
        (c-lang-const c-other-block-decl-kwds)))

;; "Keywords that may be followed by a parenthesis expression that doesn't
;; contain type identifiers."
(c-lang-defconst c-paren-nontype-kwds
  unrealscript
  (append 
   '("state" "var")
   (c-lang-const c-paren-nontype-kwds)
   nil))


;;   "Keywords that may be followed by a parenthesis expression containing
;; type identifiers separated by arbitrary tokens."
(c-lang-defconst c-paren-type-kwds
  unrealscript
  (append
   '("config" "dependson")
   (c-lang-const c-paren-type-kwds)))

;; ;; No cpp in this language, but there's still a "#exec" directive to
;; ;; fontify.  (The definitions for the extra keywords above are enough
;; ;; to incorporate them into the fontification regexps for types and
;; ;; keywords, so no additional font-lock patterns are required.)
;; (c-lang-defconst c-cpp-matchers
;;   unrealscript 
;;       ;; Use the eval form for `font-lock-keywords' to be able to use
;;       ;; the `c-preprocessor-face-name' variable that maps to a
;;       ;; suitable face depending on the (X)Emacs version.
;;       '(eval . (list "^\\s *\\(#exec\\)\\>\\(.*\\)"
;; 		     (list 1 c-preprocessor-face-name)
;; 		     '(2 font-lock-string-face))))

(defcustom unrealscript-font-lock-extra-types nil
  "*List of extra types (aside from the type keywords) to recognize in Unrealscript mode.
Each list item should be a regexp matching a single identifier.")

(defconst unrealscript-font-lock-keywords-1 
  (c-lang-const c-matchers-1 unrealscript)
  "Minimal highlighting for UNREALSCRIPT mode.")

(defconst unrealscript-font-lock-keywords-2 
  (c-lang-const c-matchers-2 unrealscript)
  "Fast normal highlighting for UNREALSCRIPT mode.")

(defconst unrealscript-font-lock-keywords-3 
  (c-lang-const c-matchers-3 unrealscript)
  "Accurate normal highlighting for UNREALSCRIPT mode.")

(defvar unrealscript-font-lock-keywords unrealscript-font-lock-keywords-3
  "Default expressions to highlight in UNREALSCRIPT mode.")

(defvar unrealscript-mode-syntax-table nil
  "Syntax table used in unrealscript-mode buffers.")
(or unrealscript-mode-syntax-table
    (setq unrealscript-mode-syntax-table
	  (funcall (c-lang-const c-make-mode-syntax-table unrealscript))))

(defvar unrealscript-mode-abbrev-table nil
  "Abbreviation table used in unrealscript-mode buffers.")

(c-define-abbrev-table 'unrealscript-mode-abbrev-table
  ;; Keywords that if they occur first on a line might alter the
  ;; syntactic context, and which therefore should trig reindentation
  ;; when they are completed.
  '(("else" "else" c-electric-continued-statement 0)
    ("while" "while" c-electric-continued-statement 0)))

(defvar unrealscript-mode-map (let ((map (c-make-inherited-keymap)))
		      ;; Add bindings which are only useful for UNREALSCRIPT
		      map)
  "Keymap used in unrealscript-mode buffers.")

(easy-menu-define unrealscript-menu unrealscript-mode-map "UNREALSCRIPT Mode Commands"
		  ;; Can use `unrealscript' as the language for `c-mode-menu'
		  ;; since its definition covers any language.  In
		  ;; this case the language is used to adapt to the
		  ;; nonexistence of a cpp pass and thus removing some
		  ;; irrelevant menu alternatives.
		  (cons "UNREALSCRIPT" (c-lang-const c-mode-menu unrealscript)))

;;;###Autoload
(add-to-list 'auto-mode-alist '("\\.uc\\'" . unrealscript-mode))

;;;###autoload
(defun unrealscript-mode ()
  "Major mode for editing UNREALSCRIPT UnrealScript is a
Java-like object-orientated programming (OOP) language created by
Epic Games for programming in-game content for the UnrealEngine.
 
The hook `c-mode-common-hook' is run with no args at mode
initialization, then `unrealscript-mode-hook'.

Key bindings:
\\{unrealscript-mode-map}"
  (interactive)
  (kill-all-local-variables)
  (c-initialize-cc-mode t)
  (set-syntax-table unrealscript-mode-syntax-table)
  (setq major-mode 'unrealscript-mode
	mode-name "UnrealScript"
	local-abbrev-table unrealscript-mode-abbrev-table
	abbrev-mode t)
  (use-local-map c-mode-map)
  ;; `c-init-language-vars' is a macro that is expanded at compile
  ;; time to a large `setq' with all the language variables and their
  ;; customized values for our language.
  (c-init-language-vars unrealscript-mode)
  ;; `c-common-init' initializes most of the components of a CC Mode
  ;; buffer, including setup of the mode menu, font-lock, etc.
  ;; There's also a lower level routine `c-basic-common-init' that
  ;; only makes the necessary initialization to get the syntactic
  ;; analysis and similar things working.
  (c-common-init 'unrealscript-mode)
  (easy-menu-add unrealscript-menu)
  (run-hooks 'c-mode-common-hook)
  (run-hooks 'unrealscript-mode-hook)
  (setq font-lock-keywords-case-fold-search t)
  (c-update-modeline))

(provide 'unrealscript-mode)

The Unreal Engine Documentation Site

Wiki Community

Topic Categories

Recent Changes

Offline Wiki

Unreal Engine

Console Commands

Terminology

FAQs

Help Desk

Mapping Topics

Mapping Lessons

UnrealEd Interface

UnrealScript Topics

UnrealScript Lessons

Making Mods

Class Tree

Modeling Topics

Chongqing Page

Log In