home *** CD-ROM | disk | FTP | other *** search
/ Peanuts NeXT Software Archives / Peanuts-2.iso / Developer / languages / emacs / objective-C-mode.el
Encoding:
Text File  |  1991-09-07  |  43.6 KB  |  1,352 lines
  1. ;; objective-C-mode.el
  2. ;; -------------------
  3. ;; Major mode for editing Objective-C programs.
  4. ;; The Objective-C-mode is an extension of the
  5. ;; default C-mode. Unfortunately there are many
  6. ;; hardcoded parts for EB SIGNAL use only. However
  7. ;; it can be changed.  (And has: changed for RDR
  8. ;; by Chris Walters.
  9. ;;
  10. ;; Author: Kenneth Persson (kenneth@eb.se)
  11. ;;         EB Signal AB, Stockholm, Sweden
  12. ;;
  13. ;; Modified by:
  14. ;;         Douglas Worthington,
  15. ;;         dougw@grebyn.com
  16. ;;
  17. ;; This is version 3.02.
  18. ;;
  19. ;; Put this in your .emacs file if its not in site-init.el:
  20. ;;
  21. ;; (autoload 'objective-C-mode "yourLispCodeDirectory/objective-C-mode"
  22. ;;           "Objective-C mode" t nil)
  23. ;; (setq auto-mode-alist
  24. ;;       (append '(("\\.h$" . objective-C-mode)
  25. ;;            ("\\.m$" . objective-C-mode))
  26. ;;           auto-mode-alist))
  27.  
  28. (provide 'objective-C-mode)
  29.  
  30. (defun objective-C-mode-version ()
  31.   "3.03a")
  32.  
  33. (defun echo-objective-C-mode-version ()
  34.   (interactive)
  35.   (message (concat "Version "
  36.            (objective-C-mode-version)
  37.            " of "
  38.            mode-name
  39.            " mode.")))
  40.  
  41. (defvar objective-C-interface-file-dir nil
  42.   "The directory where to put generated interface files")
  43.  
  44. (defvar objective-C-document-file-dir nil
  45.   "The directory where to put generated document files")
  46.  
  47. (defvar objective-C-mode-map nil
  48.   "*Keymap used in objective-C mode.")
  49. (if objective-C-mode-map
  50.     nil
  51.   (let ((map (make-sparse-keymap))) 
  52.     (define-key map "\C-cc"     'objective-C-mfile-header)
  53.     (define-key map "\C-ch"     'objective-C-hfile-header)   
  54.     (define-key map "\C-cp"     'objective-C-protocol)
  55.     (define-key map "\C-cf"     'objective-C-factory-method)
  56.     (define-key map "\C-cm"     'objective-C-instance-method)
  57.     (define-key map "\C-cl"     'objective-C-codelimit)
  58.     (define-key map "\C-c\C-m"  'objective-C-method-comment)
  59.     (define-key map "\C-c\C-cd" 'generate-Objective-C-documentation)
  60.     (define-key map "\C-c\C-ch" 'generate-Objective-C-hfile)   
  61.     (define-key map "\C-c?"     'describe-objective-C-mode)   
  62.     (define-key map "\C-ci"     'indent-region)
  63.     (define-key map "\C-ca"     'add-user-sign)
  64.     (define-key map "\C-cv"     'echo-objective-C-mode-version)
  65.     (define-key map "{"         'electric-objective-C-brace)
  66.     (define-key map "}"         'electric-objective-C-brace)
  67.     (define-key map ":"         'electric-objective-C-keyword-match)
  68.     (define-key map "\177"      'backward-delete-char-untabify)
  69.     (define-key map "\t"        'objective-C-indent-command)
  70.     (setq objective-C-mode-map map)))
  71.  
  72. (define-abbrev-table 'objective-C-mode-abbrev-table ())
  73. (defvar objective-C-mode-abbrev-table nil
  74.   "abbrevations to use in objective-c")
  75.  
  76. ;;      (append objective-C-mode-abbrev-table
  77. ;;          (list '("ryes" "return YES"      nil)
  78. ;;            '("ry"   "return YES"      nil)
  79. ;;            '("rno"  "return NO"       nil)
  80. ;;            '("rn"   "return NO"       nil)
  81. ;;            '("rs"   "return self"     nil)
  82. ;;            '("rnil" "return nil"      nil)
  83. ;;            '("imp"  "@implementation" nil)
  84. ;;            '("intf" "@interface"      nil)
  85. ;;            '("slef" "self"            nil)
  86. ;;            '("st"   "STR"             nil)
  87. ;;            '("bo"   "BOOL"            nil))))
  88.  
  89. (defvar objective-C-mode-syntax-table nil
  90.   "Syntax table in use in Objective-C-Mode buffers.")
  91. (if objective-C-mode-syntax-table
  92.     nil
  93.   (setq objective-C-mode-syntax-table (make-syntax-table))
  94.   (modify-syntax-entry ?\\ "\\" objective-C-mode-syntax-table)
  95.   (modify-syntax-entry ?/ ". 14" objective-C-mode-syntax-table)
  96.   (modify-syntax-entry ?* ". 23" objective-C-mode-syntax-table)
  97.   (modify-syntax-entry ?+ "." objective-C-mode-syntax-table)
  98.   (modify-syntax-entry ?- "." objective-C-mode-syntax-table)
  99.   (modify-syntax-entry ?= "." objective-C-mode-syntax-table)
  100.   (modify-syntax-entry ?% "." objective-C-mode-syntax-table)
  101.   (modify-syntax-entry ?< "." objective-C-mode-syntax-table)
  102.   (modify-syntax-entry ?> "." objective-C-mode-syntax-table)
  103.   (modify-syntax-entry ?& "." objective-C-mode-syntax-table)
  104.   (modify-syntax-entry ?| "." objective-C-mode-syntax-table)
  105.   (modify-syntax-entry ?\' "\"" objective-C-mode-syntax-table))
  106.  
  107. (defconst objective-C-indent-level 4
  108.   "*Indentation of C statements with respect to containing block.")
  109. (defconst objective-C-brace-imaginary-offset 0
  110.   "*Imagined indentation of a C open brace that actually follows a statement.")
  111. (defconst objective-C-brace-offset -4
  112.   "*Extra indentation for braces, compared with other text in same context.")
  113. (defconst objective-C-argdecl-indent 5
  114.   "*Indentation level of declarations of C function arguments.")
  115. (defconst objective-C-label-offset -4
  116.   "*Offset of C label lines and case statements relative to usual indentation.")
  117. (defconst objective-C-continued-statement-offset 4
  118.   "*Extra indent for lines not starting new statements.")
  119. (defconst objective-C-auto-newline nil
  120.   "*Non-nil means automatically newline before and after braces,
  121. and after colons and semicolons, inserted in C code.")
  122. (defconst objective-C-tab-always-indent t
  123.   "*Non-nil means TAB in C mode should always reindent the current line,
  124. regardless of where in the line point is when the TAB command is used.")
  125.  
  126. (defun objective-C-mode ()
  127.   "  A major mode for the Objective-C language.
  128. Commands:
  129.   Expression and list commands understand all Objective-C brackets.
  130.   Tab anywhere on a line indents it according to Objective-C
  131.   conventions. LF does a CR and then an indentation like above.
  132.   Comments are delimited with /* ... */ or // to cr.
  133.   Paragraphs are separated by blank lines only.
  134.   Delete converts tabs to spaces as it moves back.
  135. \\{objective-C-mode-map}
  136.  
  137. Variables controlling indentation style:
  138.   objective-C-indent-level
  139.     Indentation of C statements within surrounding block.
  140.     The surrounding block's indentation is the indentation
  141.     of the line on which the open-brace appears.
  142.  
  143. Variables controlling directories of generated files:
  144.     objective-C-interface-file-dir
  145.       If non nil generated interface files will be put into
  146.       this directory. The default is current directory.
  147.     objective-C-document-file-dir
  148.       If non nil generated dokument files will be put into
  149.       this directory. The default is current directory.
  150.  
  151. Skeletons of the major Objective-C constructs are inserted with:
  152.   C-c c class header    C-c m instanceMethod     C-c f factoryMethod
  153.   C-c p protocol        C-c l limiter            C-c h header in h file
  154.   C-c <RET> method comment
  155.  
  156. Other useful stuff
  157.   C-c ? Describe objective-C mode
  158.   C-c a Add signature to use in comments
  159.   C-c v Return the version of this mode
  160.   C-c C-c h Generate an interface file from the implementation file
  161.   C-c C-c d Generate an documentation file from the implementation file
  162.  
  163. Abbreviations:
  164.   ry   & ryes  = return YES
  165.   rn   & rno   = return NO
  166.   rs   & rself = return self
  167.   rnil         = return nil
  168.   imp          = @implementation
  169.   intf         = @interface
  170.   st           = STR
  171.   bo           = BOOL
  172.  
  173. Turning on Objective-C mode calls the value of the variable
  174. objective-C-mode-hook with abbrevs, if that value is non-nil."
  175.   (interactive)
  176.   (kill-all-local-variables)
  177.   (use-local-map objective-C-mode-map)
  178.   (setq major-mode 'objective-C-mode)
  179.   (setq mode-name "Objective-C")
  180.   (setq local-abbrev-table objective-C-mode-abbrev-table)
  181.   (set-syntax-table objective-C-mode-syntax-table)
  182.   (make-local-variable 'paragraph-start)
  183.   (setq paragraph-start (concat "^$\\|" page-delimiter))
  184.   (make-local-variable 'paragraph-separate)
  185.   (setq paragraph-separate paragraph-start)
  186.   (make-local-variable 'indent-line-function)
  187.   (setq indent-line-function 'objective-C-indent-line)
  188.   (make-local-variable 'require-final-newline)
  189.   (setq require-final-newline t)
  190.   (make-local-variable 'comment-start)
  191.   (setq comment-start "/* ")
  192.   (make-local-variable 'signatures)
  193.   (setq signatures nil)
  194.   (make-local-variable 'comment-end)
  195.   (setq comment-end " */")
  196.   (make-local-variable 'comment-column)
  197.   (setq comment-column 32)
  198.   (make-local-variable 'comment-start-skip)
  199.   (setq comment-start-skip "/\\*+ *")
  200.   (make-local-variable 'comment-indent-hook)
  201.   (setq comment-indent-hook 'objective-C-comment-indent)
  202.   (make-local-variable 'parse-sexp-ignore-comments)
  203.   (setq parse-sexp-ignore-comments t)
  204.   (setq objective-C-line-length 70)
  205.   (make-local-variable 'super-filename)
  206.   (setq super-filename nil)
  207.   (run-hooks 'objective-C-mode-hook))
  208.  
  209. ;; ------------------------ EB Stuff ---------------------------
  210.  
  211. ;;--------------- site-init.el --------------- START
  212. (defun eb-day (aString)
  213.   (let ((a
  214.      (car (cdr (assoc aString '((" 1"  "01")
  215.                     (" 2"  "02")
  216.                     (" 3"  "03")
  217.                     (" 4"  "04")
  218.                     (" 5"  "05")
  219.                     (" 6"  "06")
  220.                     (" 7"  "07")
  221.                     (" 8"  "08")
  222.                     (" 9"  "09")))))))
  223.     (if (null a) aString a)))
  224.  
  225. (defun eb-month (aString)
  226.   (let ((a
  227.      (car (cdr (assoc aString '(("JAN"  "01")
  228.                     ("FEB"  "02")
  229.                     ("MAR"  "03")
  230.                     ("APR"  "04")
  231.                     ("MAY"  "05")
  232.                     ("JUN"  "06")
  233.                     ("JUL"  "07")
  234.                     ("AUG"  "08")
  235.                     ("SEP"  "09")
  236.                     ("OCT"  "10")
  237.                     ("NOV"  "11")
  238.                     ("DEC"  "12")
  239.                     ))))))
  240.     (if (null a) aString a)))
  241.  
  242. (defun eb-date ()
  243.   "Return the current date in an EB Signal standard form"
  244.   (concat (substring (current-time-string) -4 nil)
  245.       "-"
  246.       (eb-month (substring (current-time-string) 4 7))
  247.       "-"
  248.       (eb-day (substring (current-time-string) 8 10))))
  249. ;;--------------- site-init.el --------------- END
  250.  
  251. ;; ------------------ File and Class name ------------------------
  252.  
  253. ;; return the type ".m" or ".h" kan be improved
  254. (defun file-type (&optional name)
  255.   (substring (if (null name) (m-filename) name) -2 nil))
  256.  
  257. (defun m-filename ()
  258.   (file-name-nondirectory (file-name-sans-versions buffer-file-name)))
  259.  
  260. (defun is-m-file (&optional name)
  261.   (string-equal ".m" (file-type name)))
  262.  
  263. (defun h-filename ()
  264.   (concat (substring (m-filename) 0 -2) ".h"))
  265.  
  266. (defun h-file-dir ()
  267.   (if (null objective-C-interface-file-dir)
  268.       ""
  269.     objective-C-interface-file-dir))
  270.  
  271. (defun is-h-file (&optional name)
  272.   (string-equal ".h" (file-type name)))
  273.  
  274. (defun doc-filename ()
  275.   (concat (substring (m-filename) 0 -2) ".txt"))
  276.  
  277. (defun doc-dir ()
  278.   (if (null objective-C-document-file-dir)
  279.       ""
  280.     objective-C-document-file-dir))
  281.  
  282. (defun class-from-filename (&optional name)
  283.   (substring (if (null name) (m-filename) name)
  284.          0 (string-match "\\.\\([0-9]*\\.\\)?\\(m\\|h\\|txt\\)"
  285.                  (if (null name) (m-filename) name))))
  286.  
  287. (defun number-from-filename (&optional name)
  288.   (let ((m-file (if (null name) (m-filename) name)))
  289.     (substring m-file
  290.            (string-match "\\([0-9]*\\)?\\.\\(m\\|h\\)" m-file)
  291.            (- (length m-file) 2))))
  292.  
  293. ;; Tested and used. Not a very goodlooking
  294. (defun super-class ()
  295.   (let* ((row (concat "@implementation "
  296.               (class-from-filename)
  297.               "\\( \\|\t\\|\n\\)*"
  298.               ":"
  299.               "\\( \\|\t\\|\n\\)*"))
  300.      (row2 (concat row "[a-zA-Z][a-zA-Z0-9$_]*"))
  301.      (a-list (list (string-match row (buffer-string))
  302.                (match-end 0)))
  303.      (b-list (list (string-match row2 (buffer-string))
  304.                (match-end 0))))
  305.     (cond ((null (car a-list)) nil)
  306.       ((null (car b-list)) nil)
  307.       (t (buffer-substring (1+ (cadr a-list))
  308.                    (1+ (cadr b-list)))))))
  309.  
  310. (defun super-class-number ()
  311.   (let ((sc (super-class))
  312.     (no nil))
  313.     (if (null sc) "NO_SUPER_CLASS_FOUND"
  314.       (setq no (read-string (concat "Class number for superclass "
  315.                     (super-class)
  316.                     ": ")))
  317.       (if (string-equal "" no) no
  318.     (concat "." no)))))
  319.  
  320. (defun super-hfilename (&optional number)
  321.   (let ((sc (super-class))
  322.     (no (if (null number) (super-class-number) number)))
  323.     (if (null sc) "NO_SUPER_CLASS_FOUND" (concat sc no ".h"))))
  324.  
  325. ;; ---------------------- AUX ------------------------
  326.  
  327. (defun user-sign ()
  328.   (car (cdr (assoc (user-login-name) signatures))))
  329.  
  330. (defun cadr (l)
  331.   (car (cdr l)))
  332.  
  333. (defun odd (e)
  334.   "True if it's argument is odd."
  335.   (eq (% e 2) 1))
  336.  
  337. (defun e-empty-line-p ()
  338.   "True if current line is empty."
  339.   (save-excursion
  340.     (beginning-of-line)
  341.     (looking-at "^[ \\t]*$")))
  342.  
  343. (defun insert-right (name diff &optional c)
  344.   (let* ((u  (- objective-C-line-length (length name) diff))
  345.      (fillChar (if (char-or-string-p c) c (string-to-char " "))))
  346.     (insert-char fillChar u)
  347.     (insert name)))
  348.  
  349. (defun insert-centered (name diff &optional c)
  350.   "Inserts the name centered in the Objective-C environment
  351. diff is a number that tells how many positions that already
  352. are used on the line (/*     */ = 4) and the optional c
  353. character is used to fill white space with."
  354.   (let* ((toshare  (- objective-C-line-length (length name) diff))
  355.      (u        (/ toshare 2))
  356.      (fillChar (if (char-or-string-p c) c (string-to-char " "))))
  357.     (insert-char fillChar u)
  358.     (insert name)
  359.     (insert-char fillChar (if (odd toshare) (1+ u) u))))
  360.  
  361. (defun add-user-sign ()
  362.   (interactive)
  363.   (let* ((name (user-login-name))
  364.      (sign (read-string (concat "Signature for " name ": "))))
  365.     (setq signatures (cons (list name sign) signatures))))
  366.  
  367. (defun classes-used ()
  368.   "Extract the used classes from the file"
  369.   (save-excursion
  370.     (let ((aString ""))
  371.       (beginning-of-buffer)
  372.       (re-search-forward "Classes used")
  373.       (forward-line 1)
  374.       (while (e-empty-line-p)
  375.     (forward-line 1))
  376.       (beginning-of-line)
  377.       (while (and
  378.           (not (eobp))
  379.           (not (e-empty-line-p))
  380.           (looking-at "#import"))
  381.     (setq aString (concat aString (grep-class-from-line) " "))
  382.     (forward-line 1)
  383.     (beginning-of-line))
  384.       aString)))
  385.  
  386. (defun beginning-of-line-point (&optional aBool)
  387.   (save-excursion
  388.     (beginning-of-line)
  389.     (cond (aBool (skip-chars-forward " \t*/")))
  390.     (point)))
  391.  
  392. (defun end-of-line-point (&optional aBool)
  393.   (save-excursion
  394.     (end-of-line)
  395.     (cond (aBool (skip-chars-backward " \t*/")))
  396.     (point)))
  397.  
  398. (defun grep-class-from-line ()
  399.   (let ((bp (beginning-of-line-point))
  400.     (ep (end-of-line-point)))
  401.     (buffer-substring (+ bp 9) (- ep 3))))
  402.  
  403. (defun start-of-instance-point ()
  404.   (save-excursion
  405.     (beginning-of-buffer)
  406.     (search-forward "@implementation")
  407.     (forward-line 1)
  408.     (while (or (e-empty-line-p)
  409.            (looking-at "{"))
  410.       (forward-line 1)
  411.       (beginning-of-line))
  412.     (point)))
  413.  
  414. (defun end-of-instance-point ()
  415.   (save-excursion
  416.     (beginning-of-buffer)
  417.     (search-forward "@implementation")
  418.     (search-forward "}")
  419.     (forward-line -1)
  420.     (while (e-empty-line-p)
  421.       (forward-line -1))
  422.     (end-of-line)
  423.     (point)))
  424.  
  425. (defun have-instance-variables ()
  426.   (save-excursion
  427.     (beginning-of-buffer)
  428.     (search-forward "@implementation")
  429.     (forward-line 1)
  430.     (while (e-empty-line-p)      
  431.       (forward-line 1))
  432.     (skip-chars-forward " \t")
  433.     (looking-at "{")))
  434.  
  435. (defun instance-variables ()
  436.   (cond ((have-instance-variables)
  437.      (buffer-substring (start-of-instance-point)
  438.                (end-of-instance-point)))
  439.     (t "\t // none")))
  440.  
  441. (defun start-of-intro-point ()
  442.   (save-excursion
  443.     (beginning-of-buffer)
  444.     (cond ((null (search-forward "Introduction"
  445.                  (start-of-instance-point)
  446.                  t))
  447.        1)
  448.       (t (forward-line 1)
  449.          (while (e-empty-line-p)
  450.            (forward-line 1))
  451.          (beginning-of-line)
  452.          (point)))))
  453.  
  454. (defun end-of-intro-point ()
  455.   (save-excursion
  456.     (beginning-of-buffer)
  457.     (cond ((null (search-forward "Revision History"
  458.                  (start-of-instance-point)
  459.                  t))
  460.        1)
  461.       (t (forward-line -1)
  462.          (while (e-empty-line-p)
  463.            (forward-line -1))
  464.          (end-of-line)
  465.          (point)))))
  466.  
  467. (defun class-intro ()
  468.   (let ((si (start-of-intro-point))
  469.     (ei (end-of-intro-point)))
  470.     (if (or (= si ei) (= si 1) (= ei 1))
  471.     "\tCan't extract the class description since the strings\n\tIntroduction and/or Revision History are missing in the source code."
  472.       (buffer-substring si ei))))
  473.  
  474. (defun find-next-protocol-or-method ()
  475.   (beginning-of-line)
  476.   (while (and (not (eobp))
  477.           (not (looking-at "/\\*====="))
  478.           (not (looking-at "+[a-zA-Z( ]"))
  479.           (not (looking-at "-[a-zA-Z( ]")))
  480.     (forward-line 1)
  481.     (beginning-of-line))
  482.   (cond ((looking-at "/\\*=====")
  483.      (forward-line 1)
  484.      (beginning-of-line)))
  485.   (not (eobp)))
  486.  
  487. (defun line-is-method ()
  488.   (save-excursion
  489.     (beginning-of-line)
  490.     (or (looking-at "+[a-zA-Z( ]")
  491.     (looking-at "-[a-zA-Z( ]"))))
  492.  
  493. (defun line-is-protocol ()
  494.   (save-excursion
  495.     (forward-line -1)
  496.     (beginning-of-line)
  497.     (looking-at "/\\*=====")))
  498.  
  499. (defun is-gps-comment ()
  500.   (save-excursion
  501.     (let ((ordinary (is-ordinary-comment)))
  502.       (beginning-of-line)
  503.       (and (looking-at "---------") ordinary))))
  504.  
  505. (defun is-ordinary-comment ()
  506.   (save-excursion
  507.     (and (char-equal ?* (char-after (- (point) 2)))
  508.      (char-equal ?/ (char-after (- (point) 1)))
  509.      (not (char-equal ?= (char-after (beginning-of-line-point)))))))
  510.  
  511. (defun is-date-entry ()
  512.   (< 50 (- (beginning-of-line-point t) (beginning-of-line-point))))
  513.  
  514. (defun is-method-name-entry ()
  515.   (and (char-equal ?| (char-after (beginning-of-line-point t)))
  516.        (char-equal ?| (char-after (- (end-of-line-point t) 1)))))
  517.  
  518. (defun is-empty-line-info ()
  519.   (string-equal "" (buffer-substring (beginning-of-line-point t)
  520.                      (end-of-line-point))))
  521.  
  522. (defun is-not-crap-line ()
  523.     (and (not (is-date-entry))
  524.      (not (is-method-name-entry))
  525.      (not (is-empty-line-info))))
  526.  
  527. (defun look-for-comment-at-previous-line ()
  528.   (save-excursion
  529.     (forward-line -1)
  530.     (beginning-of-line)
  531.     (skip-chars-forward "\t ")
  532.     (and (char-equal ?/ (char-after (point)))
  533.      (char-equal ?* (char-after (+ (point) 1))))))
  534.  
  535. (defun is-still-comment ()
  536.   (save-excursion
  537.     (beginning-of-line)
  538.     (skip-chars-forward "\t ")
  539.     (if (and (char-equal ?/ (char-after (point)))
  540.          (char-equal ?* (char-after (+ (point) 1))))
  541.     (look-for-comment-at-previous-line)
  542.       t)))
  543.  
  544. (defun is-objc-comment ()
  545.   (save-excursion
  546.     (beginning-of-line)
  547.     (looking-at "//")))
  548.  
  549. (defun gps-comment ()
  550.   (ordinary-comment))
  551.  
  552. (defun ordinary-comment ()
  553.   (let ((aStr ""))
  554.     (forward-line -1)
  555.     (while (is-still-comment)
  556.       (beginning-of-line)
  557.       (skip-chars-forward " \t*/")
  558.       (cond ((is-not-crap-line)
  559.          (setq aStr
  560.            (concat (buffer-substring (point) (end-of-line-point t))
  561.                "\n"
  562.                aStr))))
  563.       (forward-line -1))
  564.     aStr))
  565.  
  566. (defun objc-comment ()
  567.   (let ((aStr ""))
  568.     (while (is-objc-comment)
  569.       (beginning-of-line)
  570.       (skip-chars-forward "/ ")
  571.       (cond ((is-not-crap-line)
  572.          (setq aStr
  573.            (concat (buffer-substring (point) (end-of-line-point t))
  574.                "\n"
  575.                aStr))))
  576.       (forward-line -1))
  577.     aStr))
  578.  
  579. (defun no-comment ()
  580.   "This method has not been documented in the source code.")
  581.  
  582. (defun line-as-doc-file-delimiter ()
  583.   (save-excursion
  584.     (beginning-of-line)
  585.     (skip-chars-forward " \t")
  586.     (setq start (point))
  587.     (end-of-line)
  588.     (skip-chars-backward " \t")
  589.     (concat "\n" (buffer-substring start (point)) "\n")))
  590.  
  591. (defun line-as-inteface-file-delimiter ()
  592.   (save-excursion
  593.     (beginning-of-line)
  594.     (skip-chars-forward " \t")
  595.     (setq start (point))
  596.     (end-of-line)
  597.     (skip-chars-backward " \t")
  598.     (setq name     (buffer-substring start (point)))
  599.     (setq toshare  (- objective-C-line-length (length name) 8))
  600.     (concat "\n/* "
  601.         (make-string (/ toshare 2) ?-)
  602.         " "
  603.         (buffer-substring start (point))
  604.         " "
  605.         (make-string (if (odd toshare)
  606.                  (+ (/ toshare 2) 1)
  607.                (/ toshare 2))
  608.              ?-)
  609.         " */")))
  610.  
  611. (defun skip-comment (str)
  612.   (let ((p (string-match "//" str)))
  613.     (cond ((null p) str)
  614.       (t (substring str 0 p)))))
  615.  
  616. (defun line-as-inteface-file-method ()
  617.   (save-excursion
  618.     (beginning-of-line)
  619.     (skip-chars-forward " \t")
  620.     (setq start (point))
  621.     (re-search-forward "{")
  622.     (backward-char 1)
  623.     (skip-chars-backward " \t\n")
  624.     (concat (skip-comment (buffer-substring start (point))) ";")))
  625.  
  626. (defun extract-method-comment ()
  627.   (forward-line -1)
  628.   (while (e-empty-line-p)
  629.     (forward-line -1))
  630.   (end-of-line)
  631.   (skip-chars-backward " \t")
  632.   (cond ((is-gps-comment)      (gps-comment))
  633.     ((is-ordinary-comment) (ordinary-comment))
  634.     ((is-objc-comment)     (objc-comment))
  635.     (t                     (no-comment))))
  636.  
  637. (defun method-description (method-name start-point)
  638.   (save-excursion
  639.     (goto-char start-point)
  640.     (concat method-name "\n" (extract-method-comment))))
  641.  
  642. (defun line-as-doc-file-method ()
  643.   (save-excursion
  644.     (beginning-of-line)
  645.     (skip-chars-forward " \t")
  646.     (setq start (point))
  647.     (re-search-forward "{")
  648.     (backward-char 1)
  649.     (skip-chars-backward " \t\n")
  650.     (method-description
  651.      (concat "|" (buffer-substring start (point)) "|") start)))
  652.  
  653. (defun class-as-short ()
  654.   (save-excursion
  655.     (let ((aString ""))
  656.       (beginning-of-buffer)
  657.       (re-search-forward "@implementation")
  658.       (while (and (not (eobp)) (find-next-protocol-or-method))
  659.     (setq aString
  660.           (concat
  661.            aString
  662.            (cond ((line-is-protocol) (line-as-doc-file-delimiter))
  663.              ((line-is-method)   (line-as-doc-file-method))
  664.              (t ""))
  665.            "\n"))
  666.     (forward-line))
  667.       aString)))
  668.  
  669. (defun class-as-short-no-comments ()
  670.   (save-excursion
  671.     (let ((aString ""))
  672.       (beginning-of-buffer)
  673.       (re-search-forward "@implementation")
  674.       (while (and (not (eobp)) (find-next-protocol-or-method))
  675.     (setq aString
  676.           (concat
  677.            aString
  678.            (cond ((line-is-protocol) (line-as-inteface-file-delimiter))
  679.              ((line-is-method)   (line-as-inteface-file-method))
  680.              (t ""))
  681.            "\n"))
  682.     (forward-line))
  683.       aString)))
  684.  
  685. ;; ------------------ Objective-C mode -------------------
  686.  
  687. (defun describe-objective-C-mode ()
  688.   (interactive)
  689.   (describe-mode))
  690.  
  691. (defun objective-C-mfile-header ()
  692.   "Build a class skeleton prompting for class name."
  693.   (interactive)
  694.   (if (not (is-m-file))
  695.       (message "This is not an implementation file (.m)!")
  696.     (let* ((file  (m-filename))
  697.        (class (class-from-filename))
  698.        (nr    (number-from-filename))
  699.        (cname (read-string "Class: " class))
  700.        (super (read-string "Super: ")))
  701.       (if (not (e-empty-line-p))
  702.       (progn (end-of-line)(newline)))
  703.       (indent-to 0)                
  704.       (insert "/* ")
  705.       (insert-char ?- (- objective-C-line-length 3))
  706.       (insert "\n\n")
  707.       (insert "\tRDR, Inc. \n\n")
  708.       (insert "\tObjective-C source file for the class " cname "\n\n")
  709.       (insert "\tCOPYRIGHT (C), " (substring  (current-time-string) -4 nil)
  710.           ", RDR, Inc.\n")
  711.       (insert "\tALL RIGHTS RESERVED.\n\n")
  712.       (insert "\tResponsible:\t\t\tApproved:\n")
  713.       (insert "\tRDR:" (user-full-name) "\t\t\n\n")
  714.       (insert "\tDate:\t\t\t\tRev:\n")
  715.       (insert "\t" (eb-date)    "\t\t\t___\n\n")
  716. ;      (insert "\tReference:\t\t\tDocument no:\n")
  717. ;      (insert "\tLXA 108 104\t\t\t1/190 55 - CAL 124 1"
  718. ;          (if (string-equal "" nr) "***" nr) "\n\n\n\n\n")
  719.       (insert-centered cname 0)
  720.       (insert "\n\n")
  721.       (insert "\t1. Introduction")
  722.       (insert "\n\n\n")
  723.       (insert "\t2. Revision History")
  724.       (insert "\n\n")
  725.       (insert "\t___\tThe starting point.\t\t\t"
  726.           (user-full-name) "/" (eb-date) "\n\n\n")
  727.       (insert "\t3. Source Code")
  728.       (insert "\n\n")
  729.       (insert-char ?- (- objective-C-line-length 3))
  730.       (insert " */\n\n")
  731.       (comment-line "Import files")
  732.       (insert "#import <appkit/appkit.h>\n\n")
  733.       (comment-line " Classes used ")
  734.       (insert "#import \"foo.h\"\n\n")
  735.       (comment-line " Externals ")
  736.       (insert "\n\n")
  737.       (comment-line " Defines ")
  738.       (insert "\n\n")
  739.       (comment-line " Class variables ")
  740.       (insert "\n\n")
  741.       (comment-box (concat "Implementation of class " cname))
  742.       (insert "#import \"" (concat (substring file 0 -1) "h") "\"\n\n")
  743.       (insert "@implementation " cname " : " super"\n{\n\n}\n\n")
  744.       (comment-box "Instance Creation")
  745.       (insert "\n\n")
  746.       (comment-box "Initialize")
  747.       (insert "\n\n")
  748.       (comment-box "Free")
  749.       (insert "\n\n")
  750.       (insert "@end\n"))
  751.     (re-search-backward "@implementation")
  752.     (next-line 2)
  753.     (objective-C-indent-line)))
  754.  
  755. (defun objective-C-hfile-header (&optional classname super-filename)
  756.   "Gives an interface file sceleton."
  757.   (interactive)
  758.   (if (not (is-h-file))
  759.       (message "This is not an interface file (.h)!")
  760.     (let* ((class (if (null classname) (class-from-filename) classname))
  761.        (cname (read-string "Class: " class))
  762.        (nr    (number-from-filename))
  763.        (super (if (null super-filename)
  764.               (concat (read-string "Super: ") ".h")
  765.             super-filename)))
  766.       (insert "/* ")
  767.       (insert-char ?- (- objective-C-line-length 3))
  768.       (insert "\n\n")
  769.       (insert "\tRDR, Inc. \n\n")
  770.       (insert "\tObjective-C interface file for the class " cname "\n\n")
  771.       (insert "\tCOPYRIGHT (C), " (substring  (current-time-string) -4 nil)
  772.           ", RDR, Inc.\n")
  773.       (insert "\tALL RIGHTS RESERVED.\n\n")
  774.       (insert "\tResponsible:\t\t\tApproved:\n")
  775.       (insert "\tRDR:" (user-full-name) "\t\t\n\n")
  776.       (insert "\tDate:\t\t\t\tRev:\n")
  777.       (insert "\t" (eb-date)    "\t\t\t___\n\n")
  778.       (insert "\tReference:\t\t\tDocument no:\n")
  779. ;      (insert "\tLXA 108 104\t\t\t2/190 55 - CAL 124 1"
  780. ;          (if (string-equal "" nr) "***" nr) "\n\n")
  781. ;      (insert-char ?- (- objective-C-line-length 3))
  782.       (insert " */\n\n")
  783.       (comment-box (concat "Interface of class " cname))
  784.       (insert "#import \"" super "\"\n\n")
  785.       (insert "@interface " cname " : " (class-from-filename super)
  786.           "\n{\n\n}\n\n")
  787.       (insert "@end\n"))
  788.     (re-search-backward "@interface")
  789.     (next-line 2)
  790.     (objective-C-indent-line)))
  791.  
  792. (defun generate-Objective-C-hfile ()
  793.   "Generate the interface file for the current implementation file."
  794.   (interactive)
  795.   (let* ((file-name (read-string "Interface file name: "
  796.                  (concat (h-file-dir) (h-filename))))
  797.      (buf       (create-file-buffer file-name))
  798.      (class     (class-from-filename))
  799.      (no        (number-from-filename))
  800.      (instance  (instance-variables))
  801.      (short     (class-as-short-no-comments))
  802.      (super     (super-hfilename)))
  803.     (set-buffer buf)
  804.     (set-visited-file-name file-name)
  805.     (insert "/* ")
  806.     (insert-char ?- (- objective-C-line-length 3))
  807.     (insert "\n\n")
  808.     (insert "\tRDR, Inc. \n\n")
  809.     (insert "\tObjective-C interface file for the class " class "\n\n")
  810.     (insert "\tCOPYRIGHT (C), " (substring  (current-time-string) -4 nil)
  811.         ", RDR, Inc.\n")
  812.     (insert "\tALL RIGHTS RESERVED.\n\n")
  813.     (insert "\tResponsible:\t\t\tApproved:\n")
  814.     (insert "\tRDR:" (user-full-name) "\t\t\n\n")
  815.     (insert "\tDate:\t\t\t\tRev:\n")
  816.     (insert "\t" (eb-date)    "\t\t\t___\n\n")
  817.     (insert "\tReference:\t\t\tDocument no:\n")
  818. ;    (insert "\tLXA 108 104\t\t\t2/190 55 - CAL 124 1"
  819. ;        (if (string-equal "" no) "***" no) "\n\n")
  820. ;    (insert-char ?- (- objective-C-line-length 3))
  821.     (insert " */\n\n")
  822.     (comment-box (concat "Interface of class " class))
  823.     (insert "#import \"" super "\"\n\n")
  824.     (insert "@interface " class " : " (class-from-filename super) "\n{\n")
  825.     (insert instance)
  826.     (insert "\n}\n")
  827.     (insert short)
  828.     (insert "\n@end\n")
  829.     (beginning-of-buffer)
  830.     (display-buffer buf)))
  831.  
  832. (defun generate-Objective-C-documentation ()
  833.   "Open a new buffer and write the documentation there."
  834.   (interactive)
  835.   (let* ((file-name (read-string "Documentation file name: "
  836.                  (concat (doc-dir) (doc-filename))))
  837.      (buf       (create-file-buffer file-name))
  838.      (used      (classes-used))
  839.      (class     (class-from-filename))
  840.      (super     (super-class))
  841.      (no        (number-from-filename))
  842.      (instance  (instance-variables))
  843.      (short     (class-as-short))
  844.      (intro     (class-intro)))
  845.     (set-buffer buf)
  846.     (set-visited-file-name file-name)
  847.     (indent-to 0)                
  848.     (insert-char ?- objective-C-line-length)
  849.     (insert "\n\n")
  850.     (insert "\tRDR, Inc. \n\n")
  851.     (insert "\tObjective-C documentation file for the class "
  852.         class "\n")
  853.     (insert "\tCOPYRIGHT (C), " (substring  (current-time-string) -4 nil)
  854.         ", RDR, Inc.\n\n")
  855.     (insert "\tResponsible:\t\t\tApproved:\n")
  856.     (insert "\tRDR:" (user-full-name) "\t\t\n\n")
  857.     (insert "\tDate:\t\t\t\tRev:\n")
  858.     (insert "\t" (eb-date)    "\t\t\t___\n\n")
  859.     (insert "\tReference:\t\t\tDocument no:\n")
  860. ;    (insert "\tLXA 108 104\t\t\t1551 - CAL 124 1"
  861. ;            (if (string-equal "" no)
  862. ;        "***"
  863. ;          no) "\n\n")
  864. ;    (insert-char ?- objective-C-line-length)
  865.     (insert "\n\n\n")
  866.     (insert-centered class 0)
  867.     (insert "\n\n\n\tInherits from:\t\t" super "\n\n")
  868.     (insert "\tClasses used:\t\t" used "\n\n")
  869.     (insert "\tInterface file:\t\t" class "." no ".h" "\n\n")
  870.     (insert "\tImplementation file:\t" class "." no ".m" "\n\n\n")
  871.     (insert-centered "Introduction" 0)
  872.     (insert "\n\n")
  873.     (insert intro)
  874.     (insert "\n\n")
  875.     (insert-centered "Instance Variables" 0)
  876.     (insert "\n\n")
  877.     (insert instance)
  878.     (insert "\n\n")
  879.     (insert-centered "Methods" 0)
  880.     (insert "\n")
  881.     (insert short)   
  882.     (insert "\nEnd\n")
  883.     (beginning-of-buffer)
  884.     (display-buffer buf)))
  885.  
  886. (defun comment-box (name)
  887.   "Print name in an comment-box"
  888.   (if (not (e-empty-line-p))
  889.       (progn (end-of-line)(newline)))
  890.   (insert "/*")
  891.   (insert-centered "" 2 ?=)
  892.   (insert "\n")
  893.   (insert-centered name 0 (string-to-char " "))
  894.   (insert "\n")
  895.   (insert-centered "" 2 ?=)
  896.   (insert "*/\n"))
  897.  
  898. (defun comment-line (name)
  899.   "Print name in an comment-line"
  900.   (if (not (e-empty-line-p))
  901.       (progn (end-of-line)(newline)))
  902.   (insert "/* ")
  903.   (insert-centered (concat " " name " ") 6 ?-)
  904.   (insert " */\n"))
  905.  
  906. (defun objective-C-protocol ()
  907.   "Build a protocol skeleton prompting for protocol name."
  908.   (interactive)
  909.   (comment-box (read-string "Protocol name: ")))
  910.  
  911. (defun objective-C-codelimit ()
  912.   "Print name on a centered line."
  913.   (interactive)
  914.   (comment-line (read-string "Centered text: ")))
  915.  
  916. (defun objective-C-method (prefix name)
  917.   (indent-to 0)                
  918.   (insert "/*")
  919.   (insert-centered "" 2 ?-)
  920.   (insert "\n")
  921.   (insert "|" prefix name "| \n" (if (string-equal "-" prefix)
  922.                      "Return self.\n"
  923.                    "\n"))
  924.   (insert-right (concat (user-full-name) "/" (eb-date)) 0)
  925.   (insert "\n")
  926.   (insert-centered "" 2 ?-)
  927.   (insert "*/\n")
  928.   (insert prefix name "\n")
  929.   (insert "{\n")
  930.   (indent-to objective-C-indent-level)
  931.   (if (string-equal "+" prefix)
  932.       (insert "self = [super new];\n")
  933.     (insert "\n"))
  934.   (indent-to objective-C-indent-level)
  935.   (insert "return self;\n")
  936.   (insert "}\n\n")
  937.   (next-line -4))
  938.  
  939. (defun objective-C-method-comment ()
  940.   "Insert a comment according to the style used with methods in GPS"
  941.   (interactive)
  942.   (indent-to 0)                
  943.   (insert "/*")
  944.   (insert-centered "" 2 ?-)
  945.   (insert "\n\n\n")
  946.   (insert-right (concat (user-full-name) "/" (eb-date)) 0)
  947.   (insert "\n")
  948.   (insert-centered "" 2 ?-)
  949.   (insert "*/\n"))
  950.  
  951. (defun objective-C-instance-method ()
  952.   "Build a routine skeleton prompting for method name."
  953.   (interactive)
  954.   (if (not (e-empty-line-p))
  955.       (progn (end-of-line)(newline)))
  956.   (objective-C-method "-" (read-string "Instance method name: ")))
  957.  
  958. (defun objective-C-factory-method ()
  959.   "Build a routine skeleton prompting for method name."
  960.   (interactive)
  961.   (if (not (e-empty-line-p))
  962.       (progn (end-of-line)(newline)))
  963.   (objective-C-method "+" (read-string "Factory method name: ")))
  964.  
  965. ;; ------------------ C- mode fix ---------------------
  966.  
  967. ;; This is used by indent-for-comment
  968. ;; to decide how much to indent a comment in C code
  969. ;; based on its context.
  970. (defun objective-C-comment-indent ()
  971.   (if (looking-at "^/\\*")
  972.       0                ;Existing comment at bol stays there.
  973.     (save-excursion
  974.       (skip-chars-backward " \t")
  975.       (max (1+ (current-column))    ;Else indent at comment column
  976.        comment-column))))    ; except leave at least one space.
  977.  
  978. ;; implement this function later
  979. (defun electric-objective-C-keyword-match ()
  980.   "Match two following lines with keyword arguments"
  981.   (interactive)
  982.   (insert ":"))
  983.  
  984. (defun electric-objective-C-brace (arg)
  985.   "Insert character and correct line's indentation."
  986.   (interactive "P")
  987.   (let (insertpos)
  988.     (if (and (not arg)
  989.          (eolp)
  990.          (or (save-excursion
  991.            (skip-chars-backward " \t")
  992.            (bolp))
  993.          (if objective-C-auto-newline
  994.              (progn (objective-C-indent-line) (newline) t) nil)))
  995.     (progn
  996.       (insert last-command-char)
  997.       (objective-C-indent-line)
  998.       (if objective-C-auto-newline
  999.           (progn
  1000.         (setq insertpos (1- (point)))
  1001.         (newline)
  1002.         (objective-C-indent-line)))
  1003.       (save-excursion
  1004.         (if insertpos (goto-char (1+ insertpos)))
  1005.         (delete-char -1))))
  1006.     (if insertpos
  1007.     (save-excursion
  1008.       (goto-char insertpos)
  1009.       (self-insert-command (prefix-numeric-value arg)))
  1010.       (self-insert-command (prefix-numeric-value arg)))))
  1011.  
  1012. (defun electric-objective-C-semi (arg)
  1013.   "Insert character and correct line's indentation."
  1014.   (interactive "P")
  1015.   (if objective-C-auto-newline
  1016.       (electric-objective-C-terminator arg)
  1017.     (self-insert-command (prefix-numeric-value arg))))
  1018.  
  1019. (defun electric-objective-C-terminator (arg)
  1020.   "Insert character and correct line's indentation."
  1021.   (interactive "P")
  1022.   (let (insertpos (end (point)))
  1023.     (if (and (not arg) (eolp)
  1024.          (not (save-excursion
  1025.             (beginning-of-line)
  1026.             (skip-chars-forward " \t")
  1027.             (or (= (following-char) ?#)
  1028.             ;; Colon is special only after a label, or case ....
  1029.             ;; So quickly rule out most other uses of colon
  1030.             ;; and do no indentation for them.
  1031.             (and (eq last-command-char ?:)
  1032.                  (not (looking-at "case"))
  1033.                  (save-excursion
  1034.                    (forward-word 2)
  1035.                    (<= (point) end)))
  1036.             (progn
  1037.               (beginning-of-defun)
  1038.               (let ((pps (parse-partial-sexp (point) end)))
  1039.                 (or (nth 3 pps) (nth 4 pps) (nth 5 pps))))))))
  1040.     (progn
  1041.       (insert last-command-char)
  1042.       (objective-C-indent-line)
  1043.       (and objective-C-auto-newline
  1044.            (not (objective-C-inside-parens-p))
  1045.            (progn
  1046.          (setq insertpos (1- (point)))
  1047.          (newline)
  1048.          (objective-C-indent-line)))
  1049.       (save-excursion
  1050.         (if insertpos (goto-char (1+ insertpos)))
  1051.         (delete-char -1))))
  1052.     (if insertpos
  1053.     (save-excursion
  1054.       (goto-char insertpos)
  1055.       (self-insert-command (prefix-numeric-value arg)))
  1056.       (self-insert-command (prefix-numeric-value arg)))))
  1057.  
  1058. (defun objective-C-inside-parens-p ()
  1059.   (condition-case ()
  1060.       (save-excursion
  1061.     (save-restriction
  1062.       (narrow-to-region (point)
  1063.                 (progn (beginning-of-defun) (point)))
  1064.       (goto-char (point-max))
  1065.       (= (char-after (or (scan-lists (point) -1 1) (point-min))) ?\()))
  1066.     (error nil)))
  1067.  
  1068. (defun objective-C-indent-command (&optional whole-exp)
  1069.   (interactive "P")
  1070.   "Indent current line as C code, or in some cases insert a tab character.
  1071. If objective-C-tab-always-indent is non-nil (the default), always indent current line.
  1072. Otherwise, indent the current line only if point is at the left margin
  1073. or in the line's indentation; otherwise insert a tab.
  1074.  
  1075. A numeric argument, regardless of its value,
  1076. means indent rigidly all the lines of the expression starting after point
  1077. so that this line becomes properly indented.
  1078. The relative indentation among the lines of the expression are preserved."
  1079.   (if whole-exp
  1080.       ;; If arg, always indent this line as C
  1081.       ;; and shift remaining lines of expression the same amount.
  1082.       (let ((shift-amt (objective-C-indent-line))
  1083.         beg end)
  1084.     (save-excursion
  1085.       (if objective-C-tab-always-indent
  1086.           (beginning-of-line))
  1087.       (setq beg (point))
  1088.       (forward-sexp 1)
  1089.       (setq end (point))
  1090.       (goto-char beg)
  1091.       (forward-line 1)
  1092.       (setq beg (point)))
  1093.     (if (> end beg)
  1094.         (indent-code-rigidly beg end shift-amt "#")))
  1095.     (if (and (not objective-C-tab-always-indent)
  1096.          (save-excursion
  1097.            (skip-chars-backward " \t")
  1098.            (not (bolp))))
  1099.     (insert-tab)
  1100.       (objective-C-indent-line))))
  1101.  
  1102. (defun objective-C-indent-line ()
  1103.   "Indent current line as C code.
  1104. Return the amount the indentation changed by."
  1105.   (let ((indent (calculate-objective-C-indent nil))
  1106.     beg shift-amt
  1107.     (case-fold-search nil)
  1108.     (pos (- (point-max) (point))))
  1109.     (beginning-of-line)
  1110.     (setq beg (point))
  1111.     (cond ((eq indent nil)
  1112.        (setq indent (current-indentation)))
  1113.       ((eq indent t)
  1114.        (setq indent (calculate-objective-C-indent-within-comment)))
  1115.       ((looking-at "[ \t]*#")
  1116.        (setq indent 0))
  1117.       (t
  1118.        (skip-chars-forward " \t")
  1119.        (if (listp indent) (setq indent (car indent)))
  1120.        (cond ((or (looking-at "case\\b")
  1121.               (and (looking-at "[A-Za-z]")
  1122.                (save-excursion
  1123.                  (forward-sexp 1)
  1124.                  (looking-at ":"))))
  1125.           (setq indent (max 1 (+ indent objective-C-label-offset))))
  1126.          ((and (looking-at "else\\b")
  1127.                (not (looking-at "else\\s_")))
  1128.           (setq indent (save-excursion
  1129.                  (objective-C-backward-to-start-of-if)
  1130.                  (current-indentation))))
  1131.          ((= (following-char) ?})
  1132.           (setq indent (- indent objective-C-indent-level)))
  1133.          ((= (following-char) ?{)
  1134.           (setq indent (+ indent objective-C-brace-offset))))))
  1135.     (skip-chars-forward " \t")
  1136.     (setq shift-amt (- indent (current-column)))
  1137.     (if (zerop shift-amt)
  1138.     (if (> (- (point-max) pos) (point))
  1139.         (goto-char (- (point-max) pos)))
  1140.       (delete-region beg (point))
  1141.       (indent-to indent)
  1142.       ;; If initial point was within line's indentation,
  1143.       ;; position after the indentation.  Else stay at same point in text.
  1144.       (if (> (- (point-max) pos) (point))
  1145.       (goto-char (- (point-max) pos))))
  1146.     shift-amt))
  1147.  
  1148. (defun calculate-objective-C-indent (&optional parse-start)
  1149.   "Return appropriate indentation for current line as C code.
  1150. In usual case returns an integer: the column to indent to.
  1151. Returns nil if line starts inside a string, t if in a comment."
  1152.   (save-excursion
  1153.     (beginning-of-line)
  1154.     (let ((indent-point (point))
  1155.       (case-fold-search nil)
  1156.       state
  1157.       containing-sexp)
  1158.       (if parse-start
  1159.       (goto-char parse-start)
  1160.     (beginning-of-defun))
  1161.       (while (< (point) indent-point)
  1162.     (setq parse-start (point))
  1163.     (setq state (parse-partial-sexp (point) indent-point 0))
  1164.     (setq containing-sexp (car (cdr state))))
  1165.       (cond ((or (nth 3 state) (nth 4 state))
  1166.          ;; return nil or t if should not change this line
  1167.          (nth 4 state))
  1168.         ((null containing-sexp)
  1169.          ;; Line is at top level.  May be data or function definition,
  1170.          ;; or may be function argument declaration.
  1171.          ;; Indent like the previous top level line
  1172.          ;; unless that ends in a closeparen without semicolon,
  1173.          ;; in which case this line is the first argument decl.
  1174.          (goto-char indent-point)
  1175.          (skip-chars-forward " \t")
  1176.          (if (= (following-char) ?{)
  1177.          0   ; Unless it starts a function body
  1178.            (objective-C-backward-to-noncomment (or parse-start (point-min)))
  1179.            ;; Look at previous line that's at column 0
  1180.            ;; to determine whether we are in top-level decls
  1181.            ;; or function's arg decls.  Set basic-indent accordinglu.
  1182.            (let ((basic-indent
  1183.               (save-excursion
  1184.             (re-search-backward "^[^ \^L\t\n#]" nil 'move)
  1185.             (if (and (looking-at "\\sw\\|\\s_")
  1186.                  (looking-at ".*(")
  1187.                  (progn
  1188.                    (goto-char (1- (match-end 0)))
  1189.                    (forward-sexp 1)
  1190.                    (and (< (point) indent-point)
  1191.                     (not (memq (following-char)
  1192.                            '(?\, ?\;))))))
  1193.                 objective-C-argdecl-indent 0))))
  1194.         
  1195.            ;; Now add a little if this is a continuation line.
  1196.            (+ basic-indent
  1197.             (if    (or (bobp)
  1198.                 (memq (preceding-char) '(?\) ?\; ?\})))
  1199.             0 0)))))
  1200.           ((/= (char-after containing-sexp) ?{)
  1201.            ;; line is expression, not statement:
  1202.            ;; indent to just after the surrounding open.
  1203.         
  1204.          (goto-char (1+ containing-sexp))
  1205.          (current-column))
  1206.         (t
  1207.          ;; Statement level.  Is it a continuation or a new statement?
  1208.          ;; Find previous non-comment character.
  1209.          (goto-char indent-point)
  1210.          (objective-C-backward-to-noncomment containing-sexp)
  1211.          ;; Back up over label lines, since they don't
  1212.          ;; affect whether our line is a continuation.
  1213.          (while (or (eq (preceding-char) ?\,)
  1214.             (and (eq (preceding-char) ?:)
  1215.                  (or (eq (char-after (- (point) 2)) ?\')
  1216.                  (memq (char-syntax (char-after (- (point) 2)))
  1217.                        '(?w ?_)))))
  1218.            (if (eq (preceding-char) ?\,)
  1219.            (objective-C-backward-to-start-of-continued-exp containing-sexp))
  1220.            (beginning-of-line)
  1221.            (objective-C-backward-to-noncomment containing-sexp))
  1222.          ;; Now we get the answer.
  1223.          (if (not (memq (preceding-char) '(nil ?\, ?\; ?\} ?\{)))
  1224.          ;; This line is continuation of preceding line's statement;
  1225.          ;; indent  objective-C-continued-statement-offset  more than the
  1226.          ;; previous line of the statement.
  1227.          (progn
  1228.            (objective-C-backward-to-start-of-continued-exp containing-sexp)
  1229.            (+ objective-C-continued-statement-offset (current-column)))
  1230.            ;; This line starts a new statement.
  1231.            ;; Position following last unclosed open.
  1232.            (goto-char containing-sexp)
  1233.            ;; Is line first statement after an open-brace?
  1234.            (or
  1235.         ;; If no, find that first statement and indent like it.
  1236.         (save-excursion
  1237.           (forward-char 1)
  1238.           (let ((colon-line-end 0))
  1239.             (while (progn (skip-chars-forward " \t\n")
  1240.                   (looking-at "#\\|/\\*\\|case[ \t\n].*:\\|[a-zA-Z0-9_$]*:"))
  1241.               ;; Skip over comments and labels following openbrace.
  1242.               (cond ((= (following-char) ?\#)
  1243.                  (forward-line 1))
  1244.                 ((= (following-char) ?\/)
  1245.                  (forward-char 2)
  1246.                  (search-forward "*/" nil 'move))
  1247.                 ;; case or label:
  1248.                 (t
  1249.                  (save-excursion (end-of-line)
  1250.                          (setq colon-line-end (point)))
  1251.                  (search-forward ":"))))
  1252.             ;; The first following code counts
  1253.             ;; if it is before the line we want to indent.
  1254.             (and (< (point) indent-point)
  1255.              (if (> colon-line-end (point))
  1256.                  (- (current-indentation) objective-C-label-offset)
  1257.                (current-column)))))
  1258.         ;; If no previous statement,
  1259.         ;; indent it relative to line brace is on.
  1260.         ;; For open brace in column zero, don't let statement
  1261.         ;; start there too.  If objective-C-indent-offset is zero,
  1262.         ;; use objective-C-brace-offset + objective-C-continued-statement-offset instead.
  1263.         ;; For open-braces not the first thing in a line,
  1264.         ;; add in objective-C-brace-imaginary-offset.
  1265.         (+ (if (and (bolp) (zerop objective-C-indent-level))
  1266.                (+ objective-C-brace-offset objective-C-continued-statement-offset)
  1267.              objective-C-indent-level)
  1268.            ;; Move back over whitespace before the openbrace.
  1269.            ;; If openbrace is not first nonwhite thing on the line,
  1270.            ;; add the objective-C-brace-imaginary-offset.
  1271.            (progn (skip-chars-backward " \t")
  1272.               (if (bolp) 0 objective-C-brace-imaginary-offset))
  1273.            ;; If the openbrace is preceded by a parenthesized exp,
  1274.            ;; move to the beginning of that;
  1275.            ;; possibly a different line
  1276.            (progn
  1277.              (if (eq (preceding-char) ?\))
  1278.              (forward-sexp -1))
  1279.              ;; Get initial indentation of the line we are on.
  1280.              (current-indentation))))))))))
  1281.  
  1282. (defun calculate-objective-C-indent-within-comment ()
  1283.   "Return the indentation amount for line, assuming that
  1284. the current line is to be regarded as part of a block comment."
  1285.   (let (end star-start)
  1286.     (save-excursion
  1287.       (beginning-of-line)
  1288.       (skip-chars-forward " \t")
  1289.       (setq star-start (= (following-char) ?\*))
  1290.       (skip-chars-backward " \t\n")
  1291.       (setq end (point))
  1292.       (beginning-of-line)
  1293.       (skip-chars-forward " \t")
  1294.       (and (re-search-forward "/\\*[ \t]*" end t)
  1295.        star-start
  1296.        (goto-char (1+ (match-beginning 0))))
  1297.       (current-column))))
  1298.  
  1299.  
  1300. (defun objective-C-backward-to-noncomment (lim)
  1301.   (let (opoint stop)
  1302.     (while (not stop)
  1303.       (skip-chars-backward " \t\n\f" lim)
  1304.       (setq opoint (point))
  1305.       (if (and (>= (point) (+ 2 lim))
  1306.            (save-excursion
  1307.          (forward-char -2)
  1308.          (looking-at "\\*/")))
  1309.       (search-backward "/*" lim 'move)
  1310.     (beginning-of-line)
  1311.     (skip-chars-forward " \t")
  1312.     (if (looking-at "#")
  1313.         (setq stop (<= (point) lim))
  1314.       (setq stop t)
  1315.       (goto-char opoint))))))  
  1316.  
  1317. (defun objective-C-backward-to-start-of-continued-exp (lim)
  1318.   (if (= (preceding-char) ?\))
  1319.       (forward-sexp -1))
  1320.   (beginning-of-line)
  1321.   (if (<= (point) lim)
  1322.       (goto-char (1+ lim)))
  1323.   (skip-chars-forward " \t"))
  1324.  
  1325. (defun objective-C-backward-to-start-of-if (&optional limit)
  1326.   "Move to the start of the last ``unbalanced'' if."
  1327.   (or limit (setq limit (save-excursion (beginning-of-defun) (point))))
  1328.   (let ((if-level 1)
  1329.     (case-fold-search nil))
  1330.     (while (not (zerop if-level))
  1331.       (backward-sexp 1)
  1332.       (cond ((looking-at "else\\b")
  1333.          (setq if-level (1+ if-level)))
  1334.         ((looking-at "if\\b")
  1335.          (setq if-level (1- if-level)))
  1336.         ((< (point) limit)
  1337.          (setq if-level 0)
  1338.          (goto-char limit))))))
  1339.  
  1340. (defun mark-objective-C-function ()
  1341.   "Put mark at end of C function, point at beginning."
  1342.   (interactive)
  1343.   (push-mark (point))
  1344.   (end-of-defun)
  1345.   (push-mark (point))
  1346.   (beginning-of-defun)
  1347.   (backward-paragraph))
  1348.  
  1349.  
  1350.  
  1351. /* End of text from cm-next-9:next */
  1352.