cfengine.el 18.3 KB
Newer Older
Dave Love's avatar
Dave Love committed
1 2
;;; cfengine.el --- mode for editing Cfengine files

3
;; Copyright (C) 2001-2011  Free Software Foundation, Inc.
Dave Love's avatar
Dave Love committed
4 5

;; Author: Dave Love <fx@gnu.org>
6
;; Maintainer: Ted Zlatanov <tzz@lifelogs.com>
Dave Love's avatar
Dave Love committed
7
;; Keywords: languages
8
;; Version: 1.1
Dave Love's avatar
Dave Love committed
9 10 11

;; This file is part of GNU Emacs.

12
;; GNU Emacs is free software: you can redistribute it and/or modify
Dave Love's avatar
Dave Love committed
13
;; it under the terms of the GNU General Public License as published by
14 15
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
Dave Love's avatar
Dave Love committed
16 17 18 19 20 21 22

;; 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
23
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
Dave Love's avatar
Dave Love committed
24 25 26 27

;;; Commentary:

;; Provides support for editing GNU Cfengine files, including
Juanma Barranquero's avatar
Juanma Barranquero committed
28
;; font-locking, Imenu and indentation, but with no special keybindings.
Dave Love's avatar
Dave Love committed
29

30 31
;; The CFEngine 3.x support doesn't have Imenu support but patches are
;; welcome.
32

33 34
;; You can set it up so either `cfengine2-mode' (2.x and earlier) or
;; `cfengine3-mode' (3.x) will be picked, depending on the buffer
35
;; contents:
36

37
;; (add-to-list 'auto-mode-alist '("\\.cf\\'" . cfengine-mode))
38 39

;; OR you can choose to always use a specific version, if you prefer
40
;; it:
41 42

;; (add-to-list 'auto-mode-alist '("\\.cf\\'" . cfengine3-mode))
43 44
;; (add-to-list 'auto-mode-alist '("^cf\\." . cfengine2-mode))
;; (add-to-list 'auto-mode-alist '("^cfagent.conf\\'" . cfengine2-mode))
Dave Love's avatar
Dave Love committed
45 46 47 48 49 50 51 52

;; This is not the same as the mode written by Rolf Ebert
;; <ebert@waporo.muc.de>, distributed with cfengine-2.0.5.  It does
;; better fontification and indentation, inter alia.

;;; Code:

(defgroup cfengine ()
53
  "Editing CFEngine files."
Dave Love's avatar
Dave Love committed
54 55 56
  :group 'languages)

(defcustom cfengine-indent 2
57
  "*Size of a CFEngine indentation step in columns."
Dave Love's avatar
Dave Love committed
58 59 60
  :group 'cfengine
  :type 'integer)

61 62 63
(defvar cfengine-mode-debug nil
  "Whether `cfengine-mode' should print debugging info.")

Dave Love's avatar
Dave Love committed
64
(defcustom cfengine-mode-abbrevs nil
65
  "Abbrevs for CFEngine2 mode."
Dave Love's avatar
Dave Love committed
66 67 68 69 70
  :group 'cfengine
  :type '(repeat (list (string :tag "Name")
		       (string :tag "Expansion")
		       (choice  :tag "Hook" (const nil) function))))

71 72
(make-obsolete-variable 'cfengine-mode-abbrevs 'edit-abbrevs "24.1")

Dave Love's avatar
Dave Love committed
73 74
;; Taken from the doc for pre-release 2.1.
(eval-and-compile
75
  (defconst cfengine2-actions
Dave Love's avatar
Dave Love committed
76 77 78 79 80 81
    '("acl" "alerts" "binservers" "broadcast" "control" "classes" "copy"
      "defaultroute" "disks" "directories" "disable" "editfiles" "files"
      "filters" "groups" "homeservers" "ignore" "import" "interfaces"
      "links" "mailserver" "methods" "miscmounts" "mountables"
      "processes" "packages" "rename" "required" "resolve"
      "shellcommands" "tidy" "unmount"
82
      ;; Keywords for cfservd.
Dave Love's avatar
Dave Love committed
83 84
      "admit" "grant" "deny")
    "List of the action keywords supported by Cfengine.
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
This includes those for cfservd as well as cfagent.")

  (defconst cfengine3-defuns
    (mapcar
     'symbol-name
     '(bundle body))
    "List of the CFEngine 3.x defun headings.")

  (defconst cfengine3-defuns-regex
    (regexp-opt cfengine3-defuns t)
    "Regex to match the CFEngine 3.x defuns.")

  (defconst cfengine3-class-selector-regex "\\([[:alnum:]_().&|!]+\\)::")

  (defconst cfengine3-category-regex "\\([[:alnum:]_]+\\):")

  (defconst cfengine3-vartypes
    (mapcar
     'symbol-name
     '(string int real slist ilist rlist irange rrange counter))
    "List of the CFEngine 3.x variable types."))
Dave Love's avatar
Dave Love committed
106

107
(defvar cfengine2-font-lock-keywords
Dave Love's avatar
Dave Love committed
108 109 110
  `(;; Actions.
    ;; List the allowed actions explicitly, so that errors are more obvious.
    (,(concat "^[ \t]*" (eval-when-compile
111
			  (regexp-opt cfengine2-actions t))
Dave Love's avatar
Dave Love committed
112 113 114 115 116 117 118 119 120 121 122 123
	      ":")
     1 font-lock-keyword-face)
    ;; Classes.
    ("^[ \t]*\\([[:alnum:]_().|!]+\\)::" 1 font-lock-function-name-face)
    ;; Variables.
    ("$(\\([[:alnum:]_]+\\))" 1 font-lock-variable-name-face)
    ("${\\([[:alnum:]_]+\\)}" 1 font-lock-variable-name-face)
    ;; Variable definitions.
    ("\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
    ;; File, acl &c in group:   { token ... }
    ("{[ \t]*\\([^ \t\n]+\\)" 1 font-lock-constant-face)))

124 125
(defvar cfengine3-font-lock-keywords
  `(
126 127 128 129 130 131 132 133 134 135 136 137 138
    ;; Defuns.  This happens early so they don't get caught by looser
    ;; patterns.
    (,(concat "\\<" cfengine3-defuns-regex "\\>"
              "[ \t]+\\<\\([[:alnum:]_]+\\)\\>"
              "[ \t]+\\<\\([[:alnum:]_]+\\)"
              ;; Optional parentheses with variable names inside.
              "\\(?:(\\([^)]*\\))\\)?")
     (1 font-lock-builtin-face)
     (2 font-lock-constant-face)
     (3 font-lock-function-name-face)
     (4 font-lock-variable-name-face nil t))

    ;; Class selectors.
139 140
    (,(concat "^[ \t]*" cfengine3-class-selector-regex)
     1 font-lock-keyword-face)
141 142

    ;; Categories.
143 144
    (,(concat "^[ \t]*" cfengine3-category-regex)
     1 font-lock-builtin-face)
145

146 147 148
    ;; Variables, including scope, e.g. module.var
    ("[@$](\\([[:alnum:]_.]+\\))" 1 font-lock-variable-name-face)
    ("[@$]{\\([[:alnum:]_.]+\\)}" 1 font-lock-variable-name-face)
149

150 151 152
    ;; Variable definitions.
    ("\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)

153
    ;; Variable types.
154 155 156
    (,(concat "\\<" (eval-when-compile (regexp-opt cfengine3-vartypes t)) "\\>")
     1 font-lock-type-face)))

157
(defvar cfengine2-imenu-expression
Dave Love's avatar
Dave Love committed
158
  `((nil ,(concat "^[ \t]*" (eval-when-compile
159
			      (regexp-opt cfengine2-actions t))
Dave Love's avatar
Dave Love committed
160 161 162 163 164
		  ":[^:]")
	 1)
    ("Variables/classes" "\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1)
    ("Variables/classes" "\\<define=\\([[:alnum:]_]+\\)" 1)
    ("Variables/classes" "\\<DefineClass\\>[ \t]+\\([[:alnum:]_]+\\)" 1))
165
  "`imenu-generic-expression' for CFEngine mode.")
Dave Love's avatar
Dave Love committed
166

167 168
(defun cfengine2-outline-level ()
  "`outline-level' function for CFEngine mode."
Dave Love's avatar
Dave Love committed
169 170 171
  (if (looking-at "[^:]+\\(?:[:]+\\)$")
      (length (match-string 1))))

172 173
(defun cfengine2-beginning-of-defun ()
  "`beginning-of-defun' function for CFEngine mode.
Dave Love's avatar
Dave Love committed
174
Treats actions as defuns."
175 176
  (unless (<= (current-column) (current-indentation))
    (end-of-line))
Dave Love's avatar
Dave Love committed
177 178 179 180 181
  (if (re-search-backward "^[[:alpha:]]+: *$" nil t)
      (beginning-of-line)
    (goto-char (point-min)))
  t)

182 183
(defun cfengine2-end-of-defun ()
  "`end-of-defun' function for CFEngine mode.
Dave Love's avatar
Dave Love committed
184 185 186
Treats actions as defuns."
  (end-of-line)
  (if (re-search-forward "^[[:alpha:]]+: *$" nil t)
187
      (beginning-of-line)
Dave Love's avatar
Dave Love committed
188 189 190 191 192
    (goto-char (point-max)))
  t)

;; Fixme: Should get an extra indent step in editfiles BeginGroup...s.

193
(defun cfengine2-indent-line ()
Dave Love's avatar
Dave Love committed
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
  "Indent a line in Cfengine mode.
Intended as the value of `indent-line-function'."
  (let ((pos (- (point-max) (point))))
    (save-restriction
      (narrow-to-defun)
      (back-to-indentation)
      (cond
       ;; Action selectors aren't indented; class selectors are
       ;; indented one step.
       ((looking-at "[[:alnum:]_().|!]+:\\(:\\)?")
	(if (match-string 1)
	    (indent-line-to cfengine-indent)
	  (indent-line-to 0)))
       ;; Outdent leading close brackets one step.
       ((or (eq ?\} (char-after))
	    (eq ?\) (char-after)))
	(condition-case ()
	    (indent-line-to (save-excursion
			      (forward-char)
			      (backward-sexp)
			      (current-column)))
	  (error nil)))
       ;; Inside brackets/parens: indent to start column of non-comment
       ;; token on line following open bracket or by one step from open
       ;; bracket's column.
       ((condition-case ()
	    (progn (indent-line-to (save-excursion
				     (backward-up-list)
				     (forward-char)
				     (skip-chars-forward " \t")
				     (if (looking-at "[^\n#]")
					 (current-column)
				       (skip-chars-backward " \t")
				       (+ (current-column) -1
					  cfengine-indent))))
		   t)
	  (error nil)))
       ;; Indent by  two steps after a class selector.
       ((save-excursion
	  (re-search-backward "^[ \t]*[[:alnum:]_().|!]+::" nil t))
	(indent-line-to (* 2 cfengine-indent)))
       ;; Indent by one step if we're after an action header.
       ((save-excursion
	  (goto-char (point-min))
	  (looking-at "[[:alpha:]]+:[ \t]*$"))
	(indent-line-to cfengine-indent))
       ;; Else don't indent.
       (t
	(indent-line-to 0))))
    ;; If initial point was within line's indentation,
    ;; position after the indentation.  Else stay at same point in text.
    (if (> (- (point-max) pos) (point))
	(goto-char (- (point-max) pos)))))

248
;; This doesn't work too well in Emacs 21.2.  See 22.1 development
Dave Love's avatar
Dave Love committed
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
;; code.
(defun cfengine-fill-paragraph (&optional justify)
  "Fill `paragraphs' in Cfengine code."
  (interactive "P")
  (or (if (fboundp 'fill-comment-paragraph)
	  (fill-comment-paragraph justify) ; post Emacs 21.3
	;; else do nothing in a comment
	(nth 4 (parse-partial-sexp (save-excursion
				     (beginning-of-defun)
				     (point))
				   (point))))
      (let ((paragraph-start
	     ;; Include start of parenthesized block.
	     "\f\\|[ \t]*$\\|.*\(")
	    (paragraph-separate
	     ;; Include action and class lines, start and end of
	     ;; bracketed blocks and end of parenthesized blocks to
	     ;; avoid including these in fill.  This isn't ideal.
	     "[ \t\f]*$\\|.*#\\|.*[\){}]\\|\\s-*[[:alpha:]_().|!]+:")
	    fill-paragraph-function)
	(fill-paragraph justify))
      t))

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
(defun cfengine3-beginning-of-defun ()
  "`beginning-of-defun' function for Cfengine 3 mode.
Treats body/bundle blocks as defuns."
  (unless (<= (current-column) (current-indentation))
    (end-of-line))
  (if (re-search-backward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
      (beginning-of-line)
    (goto-char (point-min)))
  t)

(defun cfengine3-end-of-defun ()
  "`end-of-defun' function for Cfengine 3 mode.
Treats body/bundle blocks as defuns."
  (end-of-line)
  (if (re-search-forward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
      (beginning-of-line)
    (goto-char (point-max)))
  t)

(defun cfengine3-indent-line ()
  "Indent a line in Cfengine 3 mode.
Intended as the value of `indent-line-function'."
  (let ((pos (- (point-max) (point)))
        parse)
    (save-restriction
      (narrow-to-defun)
      (back-to-indentation)
      (setq parse (parse-partial-sexp (point-min) (point)))
300 301 302
      (when cfengine-mode-debug
        (message "%S" parse))

303
      (cond
304
       ;; Body/bundle blocks start at 0.
305 306
       ((looking-at (concat cfengine3-defuns-regex "\\>"))
        (indent-line-to 0))
307
       ;; Categories are indented one step.
308 309
       ((looking-at (concat cfengine3-category-regex "[ \t]*$"))
        (indent-line-to cfengine-indent))
310
       ;; Class selectors are indented two steps.
311 312 313 314 315 316 317 318 319 320 321
       ((looking-at (concat cfengine3-class-selector-regex "[ \t]*$"))
        (indent-line-to (* 2 cfengine-indent)))
       ;; Outdent leading close brackets one step.
       ((or (eq ?\} (char-after))
            (eq ?\) (char-after)))
        (condition-case ()
            (indent-line-to (save-excursion
                              (forward-char)
                              (backward-sexp)
                              (current-column)))
          (error nil)))
322
       ;; Inside a string and it starts before this line.
323 324 325
       ((and (nth 3 parse)
             (< (nth 8 parse) (save-excursion (beginning-of-line) (point))))
        (indent-line-to 0))
326 327 328 329 330 331 332

       ;; Inside a defun, but not a nested list (depth is 1).  This is
       ;; a promise, usually.

       ;; Indent to cfengine-indent times the nested depth
       ;; plus 2.  That way, promises indent deeper than class
       ;; selectors, which in turn are one deeper than categories.
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
       ((= 1 (nth 0 parse))
        (indent-line-to (* (+ 2 (nth 0 parse)) cfengine-indent)))
       ;; Inside brackets/parens: indent to start column of non-comment
       ;; token on line following open bracket or by one step from open
       ;; bracket's column.
       ((condition-case ()
            (progn (indent-line-to (save-excursion
                                     (backward-up-list)
                                     (forward-char)
                                     (skip-chars-forward " \t")
                                     (cond
                                      ((looking-at "[^\n#]")
                                       (current-column))
                                      ((looking-at "[^\n#]")
                                       (current-column))
                                      (t
                                       (skip-chars-backward " \t")
                                       (+ (current-column) -1
                                          cfengine-indent)))))
                   t)
          (error nil)))
       ;; Else don't indent.
       (t (indent-line-to 0))))
    ;; If initial point was within line's indentation,
    ;; position after the indentation.  Else stay at same point in text.
    (if (> (- (point-max) pos) (point))
        (goto-char (- (point-max) pos)))))

;; CFEngine 3.x grammar

;; specification: blocks
;; blocks: block | blocks block;
;; block:                 bundle typeid blockid bundlebody
;;                      | bundle typeid blockid usearglist bundlebody
;;                      | body typeid blockid bodybody
;;                      | body typeid blockid usearglist bodybody;

;; typeid: id
;; blockid: id
;; usearglist: '(' aitems ')';
;; aitems: aitem | aitem ',' aitems |;
;; aitem: id

;; bundlebody: '{' statements '}'
;; statements: statement | statements statement;
;; statement: category | classpromises;

;; bodybody: '{' bodyattribs '}'
;; bodyattribs: bodyattrib | bodyattribs bodyattrib;
;; bodyattrib: class | selections;
;; selections: selection | selections selection;
;; selection: id ASSIGN rval ';' ;

;; classpromises: classpromise | classpromises classpromise;
;; classpromise: class | promises;
;; promises: promise | promises promise;
;; category: CATEGORY
;; promise: promiser ARROW rval constraints ';' | promiser constraints ';';
;; constraints: constraint | constraints ',' constraint |;
;; constraint: id ASSIGN rval;
;; class: CLASS
;; id: ID
;; rval: ID | QSTRING | NAKEDVAR | list | usefunction
;; list: '{' litems '}' ;
;; litems: litem | litem ',' litems |;
;; litem: ID | QSTRING | NAKEDVAR | list | usefunction

;; functionid: ID | NAKEDVAR
;; promiser: QSTRING
;; usefunction: functionid givearglist
;; givearglist: '(' gaitems ')'
;; gaitems: gaitem | gaitems ',' gaitem |;
;; gaitem: ID | QSTRING | NAKEDVAR | list | usefunction

;; # from lexer:

;; bundle: "bundle"
;; body: "body"
;; COMMENT    #[^\n]*
;; NAKEDVAR   [$@][(][a-zA-Z0-9_\200-\377.]+[)]|[$@][{][a-zA-Z0-9_\200-\377.]+[}]
;; ID: [a-zA-Z0-9_\200-\377]+
;; ASSIGN: "=>"
;; ARROW: "->"
;; QSTRING: \"((\\\")|[^"])*\"|\'((\\\')|[^'])*\'|`[^`]*`
;; CLASS: [.|&!()a-zA-Z0-9_\200-\377]+::
;; CATEGORY: [a-zA-Z_]+:

(defun cfengine-common-settings ()
  (set (make-local-variable 'syntax-propertize-function)
       ;; In the main syntax-table, \ is marked as a punctuation, because
       ;; of its use in DOS-style directory separators.  Here we try to
       ;; recognize the cases where \ is used as an escape inside strings.
       (syntax-propertize-rules ("\\(\\(?:\\\\\\)+\\)\"" (1 "\\"))))
  (set (make-local-variable 'parens-require-spaces) nil)
  (set (make-local-variable 'comment-start)  "# ")
  (set (make-local-variable 'comment-start-skip)
       "\\(\\(?:^\\|[^\\\\\n]\\)\\(?:\\\\\\\\\\)*\\)#+[ \t]*")
  ;; Like Lisp mode.  Without this, we lose with, say,
  ;; `backward-up-list' when there's an unbalanced quote in a
  ;; preceding comment.
  (set (make-local-variable 'parse-sexp-ignore-comments) t))

(defun cfengine-common-syntax (table)
436
  ;; The syntax defaults seem OK to give reasonable word movement.
437 438 439
  (modify-syntax-entry ?# "<" table)
  (modify-syntax-entry ?\n ">#" table)
  (modify-syntax-entry ?\" "\"" table)
440
  ;; Variable substitution.
441
  (modify-syntax-entry ?$ "." table)
442
  ;; Doze path separators.
443 444 445
  (modify-syntax-entry ?\\ "." table))

;;;###autoload
446 447
(define-derived-mode cfengine3-mode prog-mode "CFE3"
  "Major mode for editing CFEngine3 input.
448 449 450 451 452 453 454 455 456 457 458
There are no special keybindings by default.

Action blocks are treated as defuns, i.e. \\[beginning-of-defun] moves
to the action header."
  (cfengine-common-settings)
  (cfengine-common-syntax cfengine3-mode-syntax-table)

  (set (make-local-variable 'indent-line-function) #'cfengine3-indent-line)
  (setq font-lock-defaults
        '(cfengine3-font-lock-keywords nil nil nil beginning-of-defun))

459
  ;; Use defuns as the essential syntax block.
460 461 462 463 464
  (set (make-local-variable 'beginning-of-defun-function)
       #'cfengine3-beginning-of-defun)
  (set (make-local-variable 'end-of-defun-function)
       #'cfengine3-end-of-defun))

Dave Love's avatar
Dave Love committed
465
;;;###autoload
466 467
(define-derived-mode cfengine2-mode prog-mode "CFE2"
  "Major mode for editing CFEngine2 input.
Dave Love's avatar
Dave Love committed
468 469 470 471
There are no special keybindings by default.

Action blocks are treated as defuns, i.e. \\[beginning-of-defun] moves
to the action header."
472
  (cfengine-common-settings)
473
  (cfengine-common-syntax cfengine2-mode-syntax-table)
474

Dave Love's avatar
Dave Love committed
475 476 477
  ;; Shell commands can be quoted by single, double or back quotes.
  ;; It's debatable whether we should define string syntax, but it
  ;; should avoid potential confusion in some cases.
478 479
  (modify-syntax-entry ?\' "\"" cfengine2-mode-syntax-table)
  (modify-syntax-entry ?\` "\"" cfengine2-mode-syntax-table)
Dave Love's avatar
Dave Love committed
480

481
  (set (make-local-variable 'indent-line-function) #'cfengine2-indent-line)
Dave Love's avatar
Dave Love committed
482
  (set (make-local-variable 'outline-regexp) "[ \t]*\\(\\sw\\|\\s_\\)+:+")
483
  (set (make-local-variable 'outline-level) #'cfengine2-outline-level)
Dave Love's avatar
Dave Love committed
484 485
  (set (make-local-variable 'fill-paragraph-function)
       #'cfengine-fill-paragraph)
486
  (define-abbrev-table 'cfengine2-mode-abbrev-table cfengine-mode-abbrevs)
Dave Love's avatar
Dave Love committed
487
  (setq font-lock-defaults
488
        '(cfengine2-font-lock-keywords nil nil nil beginning-of-line))
489 490
  ;; Fixme: set the args of functions in evaluated classes to string
  ;; syntax, and then obey syntax properties.
491
  (setq imenu-generic-expression cfengine2-imenu-expression)
Dave Love's avatar
Dave Love committed
492
  (set (make-local-variable 'beginning-of-defun-function)
493 494
       #'cfengine2-beginning-of-defun)
  (set (make-local-variable 'end-of-defun-function) #'cfengine2-end-of-defun))
Dave Love's avatar
Dave Love committed
495

496 497
;;;###autoload
(defun cfengine-auto-mode ()
498
  "Choose between `cfengine2-mode' and `cfengine3-mode' depending
499 500 501 502 503 504 505
on the buffer contents"
  (let ((v3 nil))
    (save-restriction
      (goto-char (point-min))
      (while (not (or (eobp) v3))
        (setq v3 (looking-at (concat cfengine3-defuns-regex "\\>")))
        (forward-line)))
506 507 508
    (if v3 (cfengine3-mode) (cfengine2-mode))))

(defalias 'cfengine-mode 'cfengine-auto-mode)
509

510
(provide 'cfengine3)
Dave Love's avatar
Dave Love committed
511 512 513
(provide 'cfengine)

;;; cfengine.el ends here