phpwiki-talk

[Phpwiki-talk] php-mode

[Steve W. <sw...@pa...>]

If there are no objections I'd like to reformat the code to comply with
php-mode in Emacs.

The downside to this is all the whitespace will change, which means it
will ruin diff output from CVS at that point.

However that's why we have alpha branches of the software :-)

speak up or put up...
~swain

---
                  http://www.panix.com/~swain/
"Without music to decorate it, time is just a bunch of boring
production deadlines or dates by which bills must be paid."
                     -- Frank Zappa

Re: [Phpwiki-talk] php-mode

[Jon <d9...@na...>]

On Wed, Apr 11, 2001 at 05:35:52PM -0400, Steve Wainstead wrote:
>=20
> If there are no objections I'd like to reformat the code to comply with
> php-mode in Emacs.

Where can I find this "php-mode"? :) Doesn't seem to be in FSF Emacs 20.7

--=20
___\ Jon =C5slund

Re: [Phpwiki-talk] php-mode

[Steve W. <sw...@pa...>]

Here it is! :-)

~swain

On Thu, 12 Apr 2001, Jon =C5slund wrote:

> On Wed, Apr 11, 2001 at 05:35:52PM -0400, Steve Wainstead wrote:
> >
> > If there are no objections I'd like to reformat the code to comply with
> > php-mode in Emacs.
>
> Where can I find this "php-mode"? :) Doesn't seem to be in FSF Emacs 20.7
>
> --
> ___\ Jon =C5slund
>
> _______________________________________________
> Phpwiki-talk mailing list
> Php...@li...
> http://lists.sourceforge.net/lists/listinfo/phpwiki-talk
>

---
                  http://www.panix.com/~swain/
"Without music to decorate it, time is just a bunch of boring
production deadlines or dates by which bills must be paid."
                     -- Frank Zappa


;;; php-mode.el -- major mode for editing PHP source files

;; Author: Fred Yankowski <fc...@ac...>
;; Keywords: PHP, PHP3, languages
;; $Id: php-mode.el,v 1.24 2000/12/08 17:44:17 fred Exp $

;; php-mode.el is Copyright (c) 1999,2000 by Fred Yankowski <fc...@ac...>
;;
;;=09This is free software; you can redistribute it and/or modify
;;=09it under the terms of the GNU General Public License as
;;=09published by the Free Software Foundation; either version 2,
;;=09or (at your option) any later version.
;;
;;=09This is distributed in the hope that it will be useful, but
;;=09WITHOUT ANY WARRANTY; without even the implied warranty of
;;=09MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;=09GNU General Public License for more details.
;;
;;=09You should have received a copy of the GNU General Public
;;=09License as the file COPYING.  If not, write to the Free
;;=09Software Foundation, Inc., 59 Temple Place - Suite 330,
;;=09Boston, MA 02111-1307, USA.

;;; Commentary;
;;
;; PHP mode is a major mode for editing the PHP programming language
;; <www.php.net>.  It is mostly concerned with setting up syntax
;; coloring via the font-lock library.
;;
;; To use PHP mode, add this to your ~/.emacs file:
;;
;;=09(autoload 'php-mode "php-mode" "PHP editing mode" t)
;;=09(add-to-list 'auto-mode-alist '("\\.php3\\'" . php-mode))
;;
;; Repeat the second line for any other filename suffixes that you
;; want to associate with PHP mode.  Then, install this file in some
;; directory in your Emacs load-path and run byte-compile-file on it.
;; Voila'.
;;
;; If php-mode does not colorize the text of your PHP code, you may need
;; to tweak the supporting font-lock mode a bit.  Here is more code for
;; .emacs that demonstrates one approach:
;;
;;=09(cond (window-system
;;       (require 'font-lock)
;;       (setq font-lock-support-mode 'lazy-lock-mode)
;;       (setq font-lock-maximum-decoration t)
;;       (global-font-lock-mode t)
;;       ))
;;
;; The above configuration treats the entire file as being PHP code,
;; causing interspersed HTML code to be handled very poorly.  An
;; option that provides very satisfying results is to use php-mode in
;; conjuction with the Multiple Major Modes package.  Get that package
;; from mmm-mode.sourceforge.net, install it, and use something like
;; the following in your .emacs file to configure it:
;;
;;=09(require 'mmm-mode)
;;=09(setq mmm-global-mode 'maybe)
;;=09(mmm-add-mode-ext-class nil "\\.php3?\\'" 'html-php)
;;=09(mmm-add-classes
;;=09 '((html-php
;;=09    :submode php-mode
;;=09    :front "<\\?\\(php\\)?"
;;=09    :back "\\?>"
;;=09    )))
;;=09(autoload 'php-mode "php-mode" "PHP editing mode" t)
;;=09(add-to-list 'auto-mode-alist '("\\.php3?\\'" . sgml-html-mode))
;;
;; Note that .php files now have the PSGML/HTML mode as their major
;; mode and PHP mode as a submode applied by the MMM minor mode.  You
;; can force a file to get PHP mode as a submode by starting the file
;; with a line like this:
;;
;;=09<?php // -*- mmm-classes: html-php -*-
;;
;; For files with HTML and PHP code that generates some of the
;; top-level elements of the HTML document, the following convinces
;; PSGML to treat the HTML content as if it were in the context of the
;; BODY element of an HTML document:
;;
;;=09<?php // -*- sgml-parent-document: ("dummy.html" "html" "body" ()) -*-
;;
;; This depends on having a dummy.html file that contains just the
;; DOCTYPE element for the desired HTML document type.  See the PSGML
;; info file for more help.
;;
;; The font-coloring applied by the PSGML/HTML mode may collide with
;; the coloring applied by PHP mode.  I got around this by removing
;; the list element for 'pi' in the sgml-markup-faces value.

;; Xemacs users report that regexp-opt is not defined.
(eval-when-compile
  (unless (fboundp 'regexp-opt)
    (defun regexp-opt (strings paren)
      (let ((open-paren (if paren "\\(" ""))
=09    (close-paren (if paren "\\)" "")))
=09(concat open-paren
=09=09(mapconcat 'regexp-quote strings "\\|")
=09=09close-paren)))))

(defconst xemacsp (string-match "Lucid\\|XEmacs" emacs-version) "\
Non nil if using XEmacs.")

(let* ((php-keywords
=09(eval-when-compile
=09  (regexp-opt
=09   '("and" "break" "case" "continue" "default" "do" "echo"
=09     "else" "elseif" "endfor" "endif" "endswitch" "endwhile" "exit"
=09     "extends" "for" "global" "if" "include"
=09     "or" "require" "return" "static" "switch" "then"
=09     "var" "while" "xor") t)))
       ;; "class", "new" and "extends" get special treatment below

       (php-constants
=09(eval-when-compile
=09  (regexp-opt
=09   '("false" "true"
=09     "E_ERROR" "E_NOTICE" "E_PARSE" "E_WARNING" "E_ALL"
=09     "PHP_OS" "PHP_VERSION"
=09     "__LINE__" "__FILE__") t)))

       (php-types
=09(eval-when-compile
=09  (regexp-opt '("array" "bool" "char" "double" "float" "int"
=09=09=09 "integer" "long" "mixed" "object" "real"
=09=09=09 "string" "void") t)))
       )

  (defconst php-font-lock-keywords-1
   (list
    '("^[ \t]*\\(class\\)[ \t]*\\(\\sw+\\)?"
      (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t))

    '("^[ \t]*\\(function\\)[ \t]*\\(\\sw+\\)?"
      (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t))
    ))

  (defconst php-font-lock-keywords-2
   (append php-font-lock-keywords-1
    (list
     (concat "\\<\\(" php-keywords "\\)\\>")

     `(,(concat "\\<\\(" php-constants "\\)\\>")
       1 font-lock-constant-face)

     ;; handle several words specially, to include following word,
     ;; thereby excluding it from unknown-symbol checks later
     '("\\<\\(new\\|extends\\)\\s-+\\$?\\(\\sw+\\)"
       (1 font-lock-keyword-face) (2 default))

     ;; treat 'print' as keyword only when not used like a function name
     '("\\<print\\s-*(" . default)
     '("\\<print\\>" . font-lock-keyword-face)

     '("<\\?\\(php\\)?" . font-lock-constant-face)
     '("\\?>" . font-lock-constant-face)
     )))

  (defconst php-font-lock-keywords-3
   (append
    (list
     ;; warn about 'new FooBar()' -- empty parens are tempting but wrong
     '("\\<\\(new\\)\\s-+\\(\\sw+\\)\\((\\s-*)\\)"
       (1 font-lock-keyword-face) (2 default) (3 font-lock-warning-face))
     )
    php-font-lock-keywords-2
    (list
     ;'("</?\\sw+[^>]*>" . font-lock-constant-face) ; <word> or </word>

     ;; warn about '$' immediately after ->
     '("\\$\\sw+->\\s-*\\(\\$\\)\\(\\sw+\\)"
       (1 font-lock-warning-face) (2 default))

     ;; warn about $word.word -- it could be a valid concatenation,
     ;; but without any spaces we'll assume $word->word was meant.
     '("\\$\\sw+\\(\\.\\)\\sw"
       1 font-lock-warning-face)

     ;; exclude casts from bare-word treatment
     `(,(concat "(\\(" php-types "\\))")
       1 default)

     ;; Warn about bare symbols, those that don't follow '$' or precede
     ;; '('.  But first explicitly mark some words that are OK.
     '("->\\s-*\\sw+" . default)=09; -->word
     '("\\$\\sw+" . default)=09=09; $word
     '("\\<\\sw+\\s-*[[(]" . default)=09; word( or word[
     '("\\<[0-9]+" . default)=09=09; number (also matches word)
     '("\\<\\sw+\\>" . font-lock-warning-face)

     ;; Warn about =3D=3D> instead of =3D> (why do I *do* that?)
     '("=3D=3D+>" . font-lock-warning-face)
     ))))

(defconst php-font-lock-syntactic-keywords
  (if xemacsp nil
    ;; Mark shell-style comments.  font-lock handles this in a
    ;; separate pass from normal syntactic scanning (somehow), so we
    ;; get a chance to mark these in addition to C and C++ style
    ;; comments.  This only works in GNU Emacs, not Xemacs 21 which
    ;; seems to ignore this same code if we try to use it.
    (list
     ;; Mark _all_ # chars as being comment-start.  That will be
     ;; ignored when inside a quoted string.
     '("\\(\#\\)"
       (1 (11 . nil)))
     ;; Mark all newlines ending a line with # as being comment-end.
     ;; This causes a problem, premature end-of-comment, when '#'
     ;; appears inside a multiline C-style comment.  Oh well.
     '("#.*\\([\n]\\)"
       (1 (12 . nil)))
     )))

(define-derived-mode php-mode c-mode "PHP"
  "A major mode for editing PHP source code.

Key bindings:
\\{php-mode-map}"

  (setq comment-start "// "
=09comment-end   ""
=09comment-start-skip "// *")

  (defvar php-mode-syntax-table php-mode-syntax-table)

  (modify-syntax-entry ?_ "w" php-mode-syntax-table)
  ;; underscore considered part of word
  (modify-syntax-entry ?$ "." php-mode-syntax-table)
  ;; dollar-sign considered punctuation, not part of word

  (if xemacsp (progn
=09=09(modify-syntax-entry ?# "< b" php-mode-syntax-table)
=09=09(modify-syntax-entry ?\n "> b" php-mode-syntax-table)))
  ;; The above causes Xemacs to handle shell-style comments correctly,
  ;; but fails to work in GNU Emacs which fails to interpret \n as the
  ;; end of the comment.

  (make-local-variable 'font-lock-defaults)
  (setq font-lock-defaults
=09'((php-font-lock-keywords-1
=09   php-font-lock-keywords-2
=09   ;; Comment-out the next line if the font-coloring is too
=09   ;; extreme/ugly for you.
=09   php-font-lock-keywords-3
=09   )
=09  nil=09=09=09=09; KEYWORDS-ONLY
=09  T=09=09=09=09; CASE-FOLD
=09  nil=09=09=09=09; SYNTAX-ALIST
=09  nil=09=09=09=09; SYNTAX-BEGIN
=09  (font-lock-syntactic-keywords . php-font-lock-syntactic-keywords)))

  (make-local-variable 'require-final-newline)
  (setq require-final-newline  nil)
  (make-local-variable 'next-line-add-newlines)
  (setq next-line-add-newlines nil)
  ;; Will not force newline at end of file.  Such newlines can cause
  ;; trouble if the PHP file is included in another file before calls
  ;; to header() or cookie().
)


(unless (boundp 'default)
  (defvar default 'default))
;; Created "default" symbol for GNU Emacs so that both Xemacs and GNU
;; emacs can refer to the default face by a variable named "default".

(unless (boundp 'font-lock-keyword-face)
  (copy-face 'bold 'font-lock-keyword-face))
;; font-lock-keyword-face is sure to be valid now, assuming that the
;; bold face exists

(unless (boundp 'font-lock-constant-face)
  (copy-face 'font-lock-keyword-face 'font-lock-constant-face))
;; font-lock-constant-face now exists, which Xemacs doesn't seem to have
;; by default

(provide 'php-mode)