Как мне начать работать с Emacs + fcsh + Flex3?

Question

У меня есть разумный emacs-fu, и я знаю, как использовать IDE Flash Builder для работы во Flex / Actionscript, но я бы хотел перейти к использованию Emacs для выполнения большей части моего кодирования вместо flash строитель. Однако это создает некоторые проблемы, а именно то, что я не уверен, как скомпилировать мой проект flex из командной строки fcsh-mode.

Вот схема моей установки:

• Мои проекты обычно зависят от комбинации скомпилированных сторонних файлов .swc.
• Я использую некоторые внутренние библиотеки, которые я храню как библиотечные проекты Actionscript в FB.
• Время от времени я перекомпилирую зависимости, но, вероятно, я смогу продолжать делать это в FB, когда это будет необходимо.
• Каждый проект приложения Flex состоит из смеси источников MXML и ActionScript.

Я никогда не использовал компиляторы командной строки таким образом, поэтому я немного озадачен тем, как начать. Я продолжаю читать о compile 1, когда люди говорят о fcsh в сети, но это просто дает мне fcsh: Target 1 not found, что, как я понимаю, означает, что мне нужно заранее запустить «правильную» компиляцию. Но ни один веб-сайт не затрагивает, каким именно мистическим заклинанием это будет.

Итак, основной вопрос здесь: каков минимальный полный набор шагов, начиная с открытия файла ActionScript или MXML для успешной компиляции файла?

Answer 1

Вот в чем дело - fcsh на самом деле не для строительных проектов, а для поэтапной разработки.

Лучший способ понять fcsh - это сначала научиться использовать mxmlc и compc в командной строке. Детальность, необходимая для компиляции вашего проекта с использованием этих инструментов, в какой-то момент вас раздражает, поэтому вы захотите выполнить задачу муравья или что-то подобное, как прокомментировал weiji выше.

Итак, после того, как вы настроите свой проект ant, вы начнете понимать, что даже если у вас все настроено правильно, перекомпиляция все равно занимает намного больше времени, чем при использовании Flex Builder. Причина в инкрементной компиляции - FB на самом деле не все перекомпилирует, а только перекомпилирует закрытие дерева зависимостей, которое зависает от любых файлов, которые вы изменили.

Введите fcsh. Это в основном взломанная версия mxmlc, которая включает в себя тот же код инкрементальной компиляции, который используется FB. Он хранит наборы частичных результатов компиляции в индексированных результирующих наборах, так что это то, что относится к «compile 1»; это означает «восстановить то же самое, что и раньше, но перекомпилировать только измененный материал».

Хорошо, это была фактическая часть, так что теперь на мнении: не беспокойтесь. Хотя fcsh может значительно ускорить перекомпиляцию большого пушистого исходного кода, лучший ответ - «не организовывайте свой код таким образом». Я лично считаю, что более тщательное разбиение вашего исходного кода для создания SWC-файлов или модулей и создание нескольких независимых отдельно скомпилированных библиотек с зависимостями между интерфейсами - это гораздо лучший путь. Затем, когда вы перекомпилируете, вы, как правило, либо просто перестраиваете библиотеку, либо перестраиваете приложение, но не все остальные вещи. Для меня fcsh требует слишком много «мыслящего» мид-компиляции, в то время как иерархия проектов на основе библиотек почти такая же быстрая, и я могу быть более «глупым» в отношении вызова M-x compile.

OH! И не забывайте "FDB". Он в основном совместим с GDB, так что M-X GDB на самом деле работает довольно хорошо, или, по крайней мере, раньше, когда я был еще вовлечен. : -D

Answer 2

См http://nisheet.wordpress.com/category/emacs/ или же http://anirudhs.chaosnet.org/code/ani-fcsh.el.html, чтобы создать файл .emacs, а затем (необязательно) добавить actionscript-mode со следующим:

Для компиляции см .: http://anirudhs.chaosnet.org/blog/2008.03.26.html

;;; as3-mode.el --- A simple mode for editing Actionscript 3 files

;; Copyright (C) 2008 Austin Haas

;; Author: Austin Haas
;; Keywords: language modes

;; Tabbing stolen from: Aemon Cannon, http://github.com/aemoncannon/as3-mode/tree/master/as3-mode.el
;; Copyright (C) 2007 Aemon Cannon

;; This file 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.

;; This file 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:
;;
;;------------------
;;; TODO

;; Imenu (imenu-generic-expression or imenu-create-index-function)

;;------------------

;;; Code:

(require 'font-lock)
(eval-when-compile
  (require 'regexp-opt))

(defconst actionscript-mode-version "7.0"
  "Actionscript Mode version number.")

(defgroup actionscript nil
  "Major mode for editing Actionscript code."
  :group 'languages)

(defvar actionscript-mode-syntax-table nil
  "Syntax table used in actionscript-mode buffers.")

(if actionscript-mode-syntax-table
        ()
    (setq actionscript-mode-syntax-table (make-syntax-table))
  (modify-syntax-entry ?_  "w"     actionscript-mode-syntax-table)
;;  (modify-syntax-entry ?_  "_"     actionscript-mode-syntax-table)
  (modify-syntax-entry ?$  "w"     actionscript-mode-syntax-table)
  (modify-syntax-entry ?\\ "\\"    actionscript-mode-syntax-table)
  (modify-syntax-entry ?+  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?-  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?=  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?%  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?<  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?>  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?&  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?|  "."     actionscript-mode-syntax-table)
  (modify-syntax-entry ?\' "\""    actionscript-mode-syntax-table)
  (modify-syntax-entry ?\240 "."   actionscript-mode-syntax-table)
    (modify-syntax-entry ?/  ". 124b" actionscript-mode-syntax-table)
    (modify-syntax-entry ?*  ". 23"   actionscript-mode-syntax-table)
  (modify-syntax-entry ?\n "> b"  actionscript-mode-syntax-table)
  (modify-syntax-entry ?\^m "> b" actionscript-mode-syntax-table))

(defvar actionscript-mode-map ()
  "Keymap used in actionscript-mode buffers.")

(if actionscript-mode-map
        ()
    (setq actionscript-mode-map (make-sparse-keymap))
    (define-key actionscript-mode-map [(control meta a)] 'as-beginning-of-defun)
    (define-key actionscript-mode-map [(control meta e)] 'as-end-of-defun)
    (define-key actionscript-mode-map [(control meta h)] 'as-mark-defun)
    (define-key actionscript-mode-map "\C-c\C-c" 'comment-region)
    (define-key actionscript-mode-map "\C-c\C-u" 'uncomment-region))

(defcustom actionscript-mode-hook nil
  "*Hook called by `actionscript-mode'."
  :type 'hook
  :group 'actionscript)

;; Preprocessor directives (for cpp, not Actionscript).
(defconst preprocessor-kwds
    '("#include" "#define" "#else" "#endif" "#ifdef" "#ifndef"))

;; Constants
(defconst actionscript-constant-kwds 
    '("true" "false" "null" "undefined" "NaN" "Infinity" "-Infinity"))

;; Global funcs
(defconst actionscript-global-funcs
  '("Array" "Boolean" "decodeURI" "decodeURIComponent" "encodeURI" 
        "encodeURIComponent" "escape" "int" "isFinite" "isNaN" "isXMLName"
        "Number" "Object"   "parseFloat" "parseInt" "String" "trace" "uint" 
        "unescape" "XML" "XMLList"))

;; Top Level Classes
(defconst actionscript-global-classes
    '("ArgumentError" "arguments" "Array" "Boolean" "Class" "Date"
        "DefinitionError" "Error" "EvalError" "Function" "int" "Math"
        "Namespace" "Number" "Object" "QName" "RangeError" "ReferenceError"
        "RegExp" "SecurityError" "String" "SyntaxError" "TypeError" "uint"
        "URIError" "VerifyError" "XML" "XMLList"))

;; Global props
(defconst actionscript-global-props
    '("this"))

;; Operators
(defconst actionscript-symbol-operators
    '("+" "+=" "[]" "=" "&" "&=" "<<" "<<=" 
        "~" "|" "|=" ">>" ">>=" ">>>" ">>>=" 
        "^" "^=" "/*" "*/" "," "?:" "--" "/" 
        "/=" "." "==" ">" ">=" "++" "!=" "<>" 
        "<" "<=" "//" "&&" "!" "||" "%" "%=" 
        "*" "*=" "{}" "()" "===" "!==" "\"" 
        "-" "-=" ":"))

(defconst actionscript-word-operators
    '("as" "is" "instanceof" "new" "typeof" "void"))

;; Declaration specifier keywords.
(defconst actionscript-specifier-kwds
  '("override" "instrinsic" "private" "protected" "public" "static" "dynamic"))

;; Class/struct declaration keywords.
(defconst actionscript-class-kwds 
    '("class" "interface"))

(defconst actionscript-package-kwds
    '("package"))

;; Keywords introducing other declaration-level constructs.
(defconst actionscript-other-decl-kwds
    '("import"))

;; Variable and Function declarations
(defconst actionscript-other-decl-2-kwds
    '("var" "function" "const"))

;; Keywords that occur in declaration-level constructs.
(defconst actionscript-decl-level-kwds 
    '("extends" "implements"))

;; Conditionals
;; *Not sure if "catch" should be here,
;; but it's assumed to be here for the actionscript-conditional-key.
(defconst actionscript-conditional-kwds
    '("for" "for each" "if" "while" "switch" "catch"))

;; Statement keywords followed directly by a block.
(defconst actionscript-block-stmt-1-kwds
  '("do" "else" "finally" "try"))

;; Statement keywords followed by an expression or nothing.
(defconst actionscript-simple-stmt-kwds
  '("break" "continue" "return" "throw"))

;; Keywords introducing labels in blocks.
(defconst actionscript-label-kwds 
    '("case" "default"))

;; Keywords that can occur anywhere in expressions.
(defconst actionscript-expr-kwds 
    '("super"))

;; Other keywords that we haven't grouped properly.
(defconst actionscript-other-kwds
    '("delete" "get" "set" "with"))

;;  (defconst actionscript-builtin-props
;;  (regexp-opt
;;   (append actionscript-object-props
;;                   actionscript-function-props
;;                   actionscript-array-props
;;                   actionscript-string-props
;;                   actionscript-date-props
;;                   actionscript-number-props
;;                   actionscript-math-props)))

;; (defconst actionscript-builtin-funcs(regexp-opt
;;   (append actionscript-global-funcs
;;                   actionscript-math-funcs
;;                   actionscript-array-funcs
;;                   actionscript-date-funcs)))

(defconst actionscript-keywords
    (regexp-opt
     (append actionscript-constant-kwds
                     actionscript-global-funcs
                     actionscript-global-classes
                     actionscript-global-props
                     actionscript-specifier-kwds
                     actionscript-class-kwds
                     actionscript-package-kwds
                     actionscript-other-decl-kwds
                     actionscript-other-decl-2-kwds
                     actionscript-decl-level-kwds
                     actionscript-conditional-kwds
                     actionscript-block-stmt-1-kwds
                     actionscript-simple-stmt-kwds
                     actionscript-label-kwds
                     actionscript-expr-kwds
                     actionscript-other-kwds) 'words))

(defconst actionscript-identifier-re "[a-zA-Z_$][a-zA-Z0-9_$]*"
    "Regexp to match any valid identifier in actionscript.")

(defcustom actionscript-mode-hook nil
  "*Hook called by `actionscript-mode'."
  :type 'hook
  :group 'actionscript)

(defcustom actionscript-font-lock-level 2
    "*What level of syntax highlighting do we want. 1-3"
    :type '(radio (const :tag "Only keywords." 1)
                    (const :tag "Keywords and contextual tags." 2)
                    (const :tag "All of the above plus all of Actionscript's builtin classes. (not implemented)" 3))
    :group 'actionscript)

;;;; Faces -------------------------------------------------------------------

(defvar actionscript-font-lock-default-face 'actionscript-font-lock-default-face)

(let ((red "#a35757")
            (green "#7ac470")
            (yellow "#dfe14e")
            (orange "#ef6d22")
            (blue "#5083b2")
            (magenta "#b781ac")
            (cyan "#b0b5d2")
            (white "#f0f0f0"))

    (defface actionscript-preprocessor-kwds-face 
            `((t (:foreground ,yellow)))
        "*Face for preprocesor directives."
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-constant-kwds-face 
            `((t (:foreground ,cyan)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-global-funcs-face 
            `((t (:foreground ,red)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-global-classes
            `((t (:foreground ,blue)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-global-props-face 
            `((t (:foreground ,blue)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-operators-face 
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-specifier-kwds-face 
            `((t (:foreground ,magenta)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-package-kwds-face 
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-class-kwds-face 
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-other-decl-kwds-face 
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-other-decl-2-kwds-face 
            `((t (:foreground ,blue)))
        "* function, var"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-decl-level-kwds-face 
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-conditional-kwds-face
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-block-stmt-1-kwds-face
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-simple-stmt-kwds-face
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-label-kwds-face
            `((t (:foreground ,yellow)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-expr-kwds-face
            `((t (:foreground ,red)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-other-kwds-face
            `((t (:foreground ,red)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-package-name-face
            `((t (:foreground ,green)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-class-name-face
            `((t (:foreground ,cyan)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-function-name-face
            `((t (:foreground ,green)))
        "*"
        :group 'actionscript-faces :group 'faces)

    (defface actionscript-variable-name-face
            `((t (:foreground ,cyan)))
        "*"
        :group 'actionscript-faces :group 'faces)
    )

(defconst actionscript-font-lock-keywords-1
     ;; The following only highlight specific words that exist in the language.
   (list
        `(,(regexp-opt preprocessor-kwds 'words) 0 'actionscript-preprocessor-kwds-face)
        `(,(regexp-opt actionscript-constant-kwds 'words) 0 'actionscript-constant-kwds-face)
        `(,(regexp-opt actionscript-global-funcs 'words) 0 'actionscript-global-funcs-face)
        `(,(regexp-opt actionscript-global-props 'words) 0 'actionscript-global-props-face)
;;      `(,(regexp-opt actionscript-symbol-operators) 0 'actionscript-operators-face)
        `(,(regexp-opt actionscript-word-operators 'words) 0 'actionscript-operators-face)
        `(,(regexp-opt actionscript-specifier-kwds 'words) 0 'actionscript-specifier-kwds-face)
        `(,(regexp-opt actionscript-class-kwds 'words) 0 'actionscript-class-kwds-face)
        `(,(regexp-opt actionscript-package-kwds 'words) 0 'actionscript-package-kwds-face)
        `(,(regexp-opt actionscript-other-decl-kwds 'words) 0 'actionscript-other-decl-kwds-face)
        `(,(regexp-opt actionscript-other-decl-2-kwds 'words) 0 'actionscript-other-decl-2-kwds-face)
        `(,(regexp-opt actionscript-decl-level-kwds 'words) 0 'actionscript-decl-level-kwds-face)
        `(,(regexp-opt actionscript-conditional-kwds 'words) 0 'actionscript-conditional-kwds-face)
        `(,(regexp-opt actionscript-block-stmt-1-kwds 'words) 0 'actionscript-block-stmt-1-kwds-face)
        `(,(regexp-opt actionscript-simple-stmt-kwds 'words) 0 'actionscript-simple-stmt-kwds-face)
        `(,(regexp-opt actionscript-label-kwds 'words) 0 'actionscript-label-kwds-face)
        `(,(regexp-opt actionscript-expr-kwds 'words) 0 'actionscript-expr-kwds-face)
        `(,(regexp-opt actionscript-other-kwds 'words) 0 'actionscript-other-kwds-face))
    "Subdued level highlighting for Actionscript mode.")

(defconst actionscript-font-lock-keywords-2
  (append
   actionscript-font-lock-keywords-1
     ;;;; The rules in this section highlight words in the buffer by determining their context.
     (list 
        ;; Fontify package names in import directives.
        ;; TODO: support '*' as the last symbol in the package name.
        (list (concat (regexp-opt actionscript-other-decl-kwds 'words) "[ \t]*\\(?:" actionscript-identifier-re "\\.\\)*\\(" actionscript-identifier-re "\\)?")
                    '(2 'actionscript-class-name-face nil t)
                    (list (concat "[ \t]*\\(" actionscript-identifier-re "\\)\\.") '(goto-char (match-end 1)) '(goto-char (match-end 0)) '(1 'actionscript-package-name-face nil t)))

        ;; Fontify package names.
        (list (concat (regexp-opt (append actionscript-package-kwds) 'words) "[ \t]*\\(" actionscript-identifier-re "\\)?")
                    '(2 'actionscript-package-name-face nil t))

        ;; Fontify class names.
        (list (concat (regexp-opt (append actionscript-class-kwds actionscript-decl-level-kwds) 'words) "[ \t]*\\(" actionscript-identifier-re "\\)?")
                    '(2 'actionscript-class-name-face nil t))

        ;; Function names.
        (list (concat "\\<function\\>[ \t\n]+\\(?:\\(?:get\\|set\\)[ \t\n]+\\)?\\(?:\\(" actionscript-identifier-re "\\)\\)?")
                    '(1 'actionscript-function-name-face nil t))

        ;; The 'in' in 'for..in.'
        (list (concat "\\<for\\>[ \t\n]*([ \t\n]*\\(?:var[ \t\n]+\\)?" actionscript-identifier-re "[ \t\n]*\\(?::[ \t\n]*\\([a-zA-Z0-9_$*]*\\)\\)?[ \t\n]+\\(in\\)[ \t\n]+")
                    '(2 'actionscript-other-kwds-face nil t))

        ;; The 'each' and the 'in' in 'for each..in.'
;;      (list (concat "\\<for\\>[ \t\n]+\\(?:\\(each\\)[ \t\n]*\\)([ \t\n]*\\(?:var[ \t\n]+\\)?" actionscript-identifier-re "[ \t\n]*\\(?::[ \t\n]*\\([a-zA-Z0-9_$*]*\\)\\)?[ \t\n]+\\(in\\)[ \t\n]+")
;;                  '(1 'actionscript-other-kwds-face nil t)
;;                  '(3 'actionscript-other-kwds-face nil t))

        ;; Local variables.
        (list (concat "\\<var\\>"
                                    "\\([ \t]*"
                                    actionscript-identifier-re
                                    "\\)")
                    ;; Fontify each declaration item.
                    '(font-lock-match-c-style-declaration-item-and-skip-to-next
                        ;; Start and finish with point after the type specifier.
                        (goto-char (match-beginning 1))
                        (goto-char (match-beginning 1))
                        (1 'actionscript-variable-name-face)))

        ;; Objects and their functions
        ;; package(s) class property
        ;; TODO: We'd like to be able to distinguish true class names from a variable, so
        ;;       that String.parse() would look different than mystring.parse().
        ;;      -We might also want to distinguish local function calls, like parse().
;;      (list (concat "\\<" "\\(?:[A-Za-z_]\\sw*\\.\\)*" "\\(?:[A-Za-z_]\\sw*\\.\\)" "\\([A-Za-z_]*\\)")
;;                  '(1 'actionscript-function-name-face))
    ))
    "Medium level highlighting for Actionscript mode.")

(defconst actionscript-font-lock-keywords-3
  (append
   actionscript-font-lock-keywords-2
   (list
        ;; TODO: Add all the builtin objects in Actionscript.

        ;; Builtin props.
;;      (list actionscript-builtin-props 1 'actionscript-builtin-props-face)

        ;; Builtin funcs.
;;      (list actionscript-builtin-funcs 1 'actionscript-builtin-funcs-face)

    ))
  "Gaudy level highlighting for Actionscript mode.")

;; --------------------------------------------------------------------------------

(defun as-get-function-re(&optional function-name)
    "Returns a regular expression that will match the function signature
containing the supplied function-name. If function-name is omitted,
the regexp will match any function."
    (unless function-name
        (setq function-name actionscript-identifier-re))
    (let ((visibility-kwd (regexp-opt '("public" "protected" "private") nil))
                (other-kwd (regexp-opt '("final" "static" "override") nil))
                (get-set-kwd (regexp-opt '("get" "set") nil)))
        (concat "\\(?:^[ \t\n]*\\)"                                          ; Start of line, followed by any amount of whitespace.
                        "\\(?:\\(" visibility-kwd "\\|" other-kwd "\\)[ \t\n]+\\)?"  ; (1) Any of the optional keywords, which must be followed by whitespace.
                        "\\(?:\\(" visibility-kwd "\\|" other-kwd "\\)[ \t\n]+\\)?"  ; (2) A second optional keyword, which must be followed by whitespace.
                        "\\<function\\>"                                             ; 'function' keyword.
                        "[ \t\n]+"                                                   ; Mandatory whitespace.
                        "\\(?:" get-set-kwd "[ \t\n]+\\)?"                           ; Optional get/set keyword, which must be followed by whitespace.
                        "\\(" function-name "\\)"                                    ; (3) Function name.
                        "[ \t\n]*"                                                   ; Optional whitespace.
                        "("                                                          ; Opening paren for function parameters.
                        "[ \t\n]*"                                                   ; Optional whitespace.
                        "\\([\"a-zA-Z\-0-9_$*,:= \t\n]*?\\(?:\\.\\.\\.[a-zA-Z\-0-9_$]+\\)?\\)"           ; (4) Function parameters, including any trailing '...args'.
                        ")"                                                          ; Closing paren for function parameters.
                        "[ \t\n]*"                                                   ; Optional whitespace.
                        "\\(?::[ \t\n]*\\(" actionscript-identifier-re "\\|*\\)\\)?"    ; (5) Optional return value type specifier.
                        "[ \t\n]*"                                                   ; Optional whitespace.
                        "{")))                                                       ; Opening brace for function body.

(defconst as-function-re (as-get-function-re)
    "A regexp that matches a function signature in Actionscript 3.0.")

(defun as-get-attribute-re(&optional attribute-name)
    "Returns a regular expression that will match the class attribute
definition containing the supplied attribute-name. If attribute-name
is omitted, the regexp will match any class attribute."
    (unless attribute-name
        (setq attribute-name actionscript-identifier-re))
    (let ((visibility-kwd (regexp-opt '("public" "protected" "private") nil))
                (var-kwd (regexp-opt '("var" "const") nil))
                (other-kwd "static"))
        (concat "\\(?:^[ \t\n]*\\)"                                          ; Start of line, followed by any amount of whitespace.
                        "\\(?:\\(" visibility-kwd "\\|" other-kwd "\\)[ \t\n]+\\)?"  ; (1) Any of the optional keywords, which must be followed by whitespace.
                        "\\(?:\\(" visibility-kwd "\\|" other-kwd "\\)[ \t\n]+\\)?"  ; (2) A second optional keyword, which must be followed by whitespace.
                        "\\<\\(" var-kwd "\\)\\>"                                    ; (3) var keyword.
                        "[ \t\n]+"                                                   ; Mandatory whitespace.
                        "\\(" attribute-name "\\)"                                   ; (4) Attribute name.
                        "[ \t\n]*"                                                   ; Optional whitespace.
                        "\\(?::[ \t\n]*\\(" actionscript-identifier-re "*\\)\\)?"    ; (5) Optional type specifier.
                        )))

(defconst as-attribute-re (as-get-attribute-re)
    "A regexp that matches a class attribute definition in Actionscript 3.0.")

;; Support for imenu
(defvar as-imenu-generic-expression
    `((nil ,as-function-re 3)))

(defun as-imenu-init (mode-generic-expression)
  (setq imenu-generic-expression mode-generic-expression
                imenu-case-fold-search nil))

(defun as-get-beginning-of-defun()
    ;; Returns the position.
    (save-excursion
        (when   (re-search-backward as-function-re nil t)
            (match-beginning 1))))

(defun as-get-end-of-defun()
    ;; This only works if we are inside a defun.
    (save-excursion
        (when   (re-search-backward as-function-re nil t)
            (goto-char (match-end 0))
            ;; Move back a char, so that point is right on the opening
            ;; brace.
            (backward-char)
            (forward-list)
            (point))))

(defun as-get-end-of-defun2()
    ;; This should work if we are not inside any defuns.
    (save-excursion
        (beginning-of-line) ; hack, in case point is currently inside a function sig.
        (when   (re-search-forward as-function-re nil t)
            (goto-char (match-end 0))
            ;; Move back a char, so that point is right on
            ;; the opening brace.
            (backward-char)
            (forward-list)
            (point))))

(defun as-beginning-of-defun()
    (interactive)
    (let ((pos (as-get-beginning-of-defun)))
        (if pos
                (goto-char pos)
                (message "Can't find any functions."))))

(defun as-inside-defun?()
    (let ((cur (point))
                (start (as-get-beginning-of-defun))
                (end (as-get-end-of-defun)))
        (and start
                 end
                 (> cur start)
                 (< cur end))))

(defun as-end-of-defun()
    (interactive)
    (if (as-inside-defun?)
            (goto-char (as-get-end-of-defun))
        (let ((pos (as-get-end-of-defun2)))
            (if pos
                    (goto-char pos)
                (message "Can't find any functions.")))))

(defun as-mark-defun()
    (interactive)
    (let ((start (as-get-beginning-of-defun))
                (end (as-get-end-of-defun)))
        (if (not (or start end))
                (message "Can't find any functions.")
            (set-mark end)
            (goto-char start)
            (beginning-of-line))))

;; --------------------------------------------------------------------------------

;; Indentation (by Aemon Cannon: http://github.com/aemoncannon/as3-mode/tree/master/as3-mode.el)

(defun actionscript-indent-line ()
  "Indent current line of As3 code."
  (interactive)
  (indent-line-to (max 0 (as3-calculate-indentation))))

(defun as3-calculate-indentation ()
  "Return the column to which the current line should be indented."
  (save-excursion
    (as3-maybe-skip-leading-close-delim)
    (let ((pos (point)))
      (beginning-of-line)
      (if (not (search-backward-regexp "[^\n\t\r ]" 1 0))
   0
  (progn
   (as3-maybe-skip-leading-close-delim)
   (+ (current-indentation) (* standard-indent (as3-count-scope-depth (point) pos))))))))

(defun as3-maybe-skip-leading-close-delim ()
  (beginning-of-line)
  (forward-to-indentation 0)
  (if (looking-at "\\s)")
      (forward-char)
    (beginning-of-line)))

(defun as3-face-at-point (pos)
  "Return face descriptor for char at point."
  (plist-get (text-properties-at pos) 'face))

(defun as3-count-scope-depth (rstart rend)
  "Return difference between open and close scope delimeters."
  ;;Attempting Steve Yegge's solution..
  ;; (save-excursion
  ;; (let ((result (parse-partial-sexp rstart rend)))
  ;; (if (or (nth 3 result) (nth 4 result) (nth 7 result))
  ;;   0
  ;;  (nth 0 result)))))
  (save-excursion
    (goto-char rstart)
    (let ((open-count 0)
          (close-count 0)
          opoint)
      (while (and (< (point) rend)
                  (progn (setq opoint (point))
                         (re-search-forward "\\s)\\|\\s(" rend t)))
        (if (= opoint (point))
            (forward-char 1)
          (cond
           ;; Don't count if in string or comment.
           ((as3-face-at-point (- (point) 1)))
           ((looking-back "\\s)")
            (incf close-count))
           ((looking-back "\\s(")
            (incf open-count))
           )))
      (- open-count close-count))))

;; --------------------------------------------------------------------------------

;;;###autoload
(defun actionscript-mode ()
  "Major mode for editing Actionscript files.
\\{actionscript-mode-map}"
    (interactive)
    (kill-all-local-variables)
    (use-local-map actionscript-mode-map)
    (setq major-mode 'actionscript-mode
                mode-name "Actionscript")
;;              local-abbrev-table actionscript-mode-abbrev-table)
  (make-local-variable 'indent-line-function)
  (setq indent-line-function 'actionscript-indent-line)
    (set-syntax-table actionscript-mode-syntax-table)
  (make-local-variable 'parse-sexp-ignore-comments)
  (setq parse-sexp-ignore-comments t)
  (make-local-variable 'comment-start)
    (setq comment-start "//")
  (make-local-variable 'comment-start-skip)
  (setq comment-start-skip "\\(//+\\|/\\*+\\)\\s *")
  (make-local-variable 'font-lock-defaults)
  (setq font-lock-defaults
        `((,(cond 
                         ((= actionscript-font-lock-level 1) 'actionscript-font-lock-keywords-1)
                         ((= actionscript-font-lock-level 2) 'actionscript-font-lock-keywords-2)
                         ((= actionscript-font-lock-level 3) 'actionscript-font-lock-keywords-3)))
          nil nil))
    (run-mode-hooks 'actionscript-mode-hook))

;; We need to make an adjustment to hideshow to work properly with AS syntax.
(add-to-list 'hs-special-modes-alist '(actionscript-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning))

(provide 'actionscript-mode)

;; For testing
(defun reload-actionscript-mode ()
    (interactive)
    (with-current-buffer (get-buffer "actionscript-mode.el")
        (eval-buffer))
    (with-current-buffer (get-buffer "test.as")
        (actionscript-mode)
        (message "actionscript-mode reloaded.")))

(define-key global-map [f5] 'reload-actionscript-mode)