Please enter the details of your bug report here
Hi,
I'm having difficulties debugging an app with JDEBug. After clicking on
"Debug App" I get the following error message.
Thanks,
Daniel
Signaling: (error "Unknown host \"DEFAULT\"")
open-network-stream("rand(1) CLI" #<buffer *rand(1) CLI*> "DEFAULT" 1031)
comint-exec(#<buffer *rand(1) CLI*> "rand(1) CLI" ("DEFAULT" . 1031) nil
nil)
make-comint("rand(1) CLI" ("DEFAULT" . 1031))
(oset-engine (oref this process) (quote cli-buf) (make-comint
cli-buffer-name (cons jde-bug-debugger-host-address cli-socket)))
(oset (oref this process) cli-buf (make-comint cli-buffer-name (cons
jde-bug-debugger-host-address cli-socket)))
(let* ((source-buffer ...) (cli-socket ...) (cli-buffer-name ...)) (oset
(oref this process) cli-socket cli-socket) (oset (oref this process) cli-buf
(make-comint cli-buffer-name ...)) (oset this msg (format "%s\nEmacs
connected to standard IO port %d for process %s." ... cli-socket ...))
(pop-to-buffer (oref process msg-buf)) (pop-to-buffer source-buffer)
(split-window-vertically) (pop-to-buffer (oref process locals-buf))
(pop-to-buffer source-buffer) (oset process win-cfg
(current-window-configuration)))
jde-dbs-launch-process([object jde-dbs-launch-process "Launch rand"
[object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process
rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil
nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
apply(jde-dbs-launch-process [object jde-dbs-launch-process "Launch rand"
[object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process
rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil
nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(setq rval (apply (car ...) newargs))
(let ((scoped-class ...)) (setq found t) (setq rval (apply ... newargs)))
(if (car lambdas) (let (...) (setq found t) (setq rval ...)))
(while lambdas (if (car lambdas) (let ... ... ...)) (setq lambdas (cdr
lambdas)))
(let ((rval nil) (found nil)) (while lambdas (if ... ...) (setq lambdas
...)) (if (not found) (signal ... ...)) rval)
(let ((newargs nil) (mclass nil) (lambdas nil)
(eieio-generic-call-methodname method) (eieio-generic-call-arglst args))
(setq newargs args) (if (object-p ...) (setq mclass ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (let (...
...) (while lambdas ... ...) (if ... ...) rval))
eieio-generic-call(jde-dbs-cmd-success-action ([object
jde-dbs-launch-process "Launch rand" [object jde-dbs-proc "process1" 1
"rand" 1031 unbound #<buffer Process rand(1)> #<buffer rand(1) Threads>
#<buffer rand(1) Local Variables> nil nil nil [object
jde-dbs-proc-state-info "State Info 1" unbound unbound unbound unbound]
unbound 0 unbound unbound nil unbound #1 unbound nil] 1 "launch" (1 normal
...) 1031 "Launch command line:\n javaw rand \n" "rand" unbound "javaw"
" " " "]))
jde-dbs-cmd-success-action([object jde-dbs-launch-process "Launch rand"
[object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process
rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil
nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(if (jde-dbo-command-succeeded-p result) (jde-dbs-cmd-success-action this)
(jde-dbs-cmd-failure-action this))
(let ((result ...)) (oset this :result result) (oset this :data (car ...))
(if (jde-dbo-command-succeeded-p result) (jde-dbs-cmd-success-action this)
(jde-dbs-cmd-failure-action this)) (jde-dbs-cmd-display-response this)
(jde-dbs-cmd-execute-pending-events this) (oref this :result))
(if jde-dbs-command-reply (let (...) (oset this :result result) (oset this
:data ...) (if ... ... ...) (jde-dbs-cmd-display-response this)
(jde-dbs-cmd-execute-pending-events this) (oref this :result)))
(let* ((debugger-process ...) (previous-listener ...) (target-process ...)
(command-line ...)) (setq jde-dbs-debugger-output "") (setq
jde-dbs-command-reply "") (setq jde-dbs-pending-events nil) (setq
jde-dbs-pending-command (oref this id)) (if target-process (oset
target-process last-cmd this)) (jde-dbs-debugger-display-message
jde-dbs-the-debugger (concat "JDE> " command-line)) (set-process-filter
debugger-process (quote jde-dbs-command-reply-listener))
(process-send-string debugger-process command-line) (process-send-string
debugger-process "\n") (when (not ...) (message "Error: debugger didn't
respond to command:\n%s" command-line) (setq jde-dbs-command-reply nil))
(set-process-filter debugger-process previous-listener) (if
jde-dbs-command-reply (let ... ... ... ... ... ... ...)))
jde-dbs-cmd([object jde-dbs-launch-process "Launch rand" [object
jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process rand(1)>
#<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil nil
[object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
apply(jde-dbs-cmd [object jde-dbs-launch-process "Launch rand" [object
jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process rand(1)>
#<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil nil
[object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(setq rval (apply (car ...) newargs))
(let ((scoped-class ...)) (setq found t) (setq rval (apply ... newargs)))
(if (car lambdas) (let (...) (setq found t) (setq rval ...)))
(while lambdas (if (car lambdas) (let ... ... ...)) (setq lambdas (cdr
lambdas)))
(let ((rval nil) (found nil)) (while lambdas (if ... ...) (setq lambdas
...)) (if (not found) (signal ... ...)) rval)
(let ((newargs nil) (mclass nil) (lambdas nil)
(eieio-generic-call-methodname method) (eieio-generic-call-arglst args))
(setq newargs args) (if (object-p ...) (setq mclass ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (let (...
...) (while lambdas ... ...) (if ... ...) rval))
eieio-generic-call(jde-dbs-cmd-exec ([object jde-dbs-launch-process
"Launch rand" [object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer
Process rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables>
nil nil nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound
unbound unbound] unbound 0 unbound unbound nil unbound #1 unbound nil] 1
"launch" (1 normal ...) 1031 "Launch command line:\n javaw rand \n"
"rand" unbound "javaw" " " " "]))
jde-dbs-cmd-exec([object jde-dbs-launch-process "Launch rand" [object
jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process rand(1)>
#<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil nil
[object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(not (jde-dbs-cmd-exec launch))
(if (not (jde-dbs-cmd-exec launch)) (progn (jde-dbs-proc-move-to-morgue
process) (if old-target ...) (jde-dbs-proc-set-state process "unknown")
(jde-dbs-proc-set-state-reason process "Error launching process.")
(jde-dbs-proc-set-add jde-dbs-the-process-morgue process) (setq succeededp
nil)))
(when (not (jde-dbs-cmd-exec launch)) (jde-dbs-proc-move-to-morgue
process) (if old-target (oset jde-dbs-the-process-registry :target-process
old-target)) (jde-dbs-proc-set-state process "unknown")
(jde-dbs-proc-set-state-reason process "Error launching process.")
(jde-dbs-proc-set-add jde-dbs-the-process-morgue process) (setq succeededp
nil))
(let* ((process ...) (old-target ...) (launch ...) (succeededp t))
(jde-dbs-proc-set-add jde-dbs-the-process-registry process) (if (not ...)
(oset launch :jre-home jde-bug-jre-home)) (oset jde-dbs-the-process-registry
:target-process process) (when (not ...) (jde-dbs-proc-move-to-morgue
process) (if old-target ...) (jde-dbs-proc-set-state process "unknown")
(jde-dbs-proc-set-state-reason process "Error launching process.")
(jde-dbs-proc-set-add jde-dbs-the-process-morgue process) (setq succeededp
nil)) succeededp)
(if (and (jde-dbs-proc-set-find jde-dbs-the-process-registry :main-class
main-class) (not ...)) nil (let* (... ... ... ...) (jde-dbs-proc-set-add
jde-dbs-the-process-registry process) (if ... ...) (oset
jde-dbs-the-process-registry :target-process process) (when ... ... ... ...
... ... ...) succeededp))
(unless (and (jde-dbs-proc-set-find jde-dbs-the-process-registry
:main-class main-class) (not ...)) (let* (... ... ... ...)
(jde-dbs-proc-set-add jde-dbs-the-process-registry process) (if ... ...)
(oset jde-dbs-the-process-registry :target-process process) (when ... ...
... ... ... ... ...) succeededp))
(let* ((main-class ...)) (unless (and ... ...) (let* ... ... ... ... ...
succeededp)))
jde-bug-launch-process()
(let ((result ...)) (if result (let ... ... ...)))
(if (jde-dbs-debugger-running-p) (let (...) (if result ...)))
jde-bug-debug-app()
(if (string= (car jde-db-debugger) "JDEbug") (jde-bug-debug-app) (jde-db))
jde-debug()
call-interactively(jde-debug)
Emacs : GNU Emacs 20.7.1 (i386-*-windows98.1998)
of Tue Jun 13 2000 on buffy
Package: JDE version 2.2.2
current state:
==============
(setq
jde-gen-session-bean-template '("(jde-wiz-insert-imports-into-buffer (list
\"javax.ejb.*\"\n\"java.rmi.RemoteException\"))"
"(jde-wiz-update-implements-clause \"SessionBean\")" "'> \"public void
ejbActivate() throws RemoteException {\"'>'n \"}\"'>'n\n'>'n" "'> \"public
void ejbPassivate() throws RemoteException {\"'>'n \"}\"'>'n\n'>'n" "'>
\"public void ejbRemove() throws RemoteException {\"'>'n \"}\"'>'n '>'n" "'>
\"public void setSessionContext(SessionContext ctx) throws\nRemoteException
{\"" "'>'n \"}\"'>'n '>'n" "'> \"public void unsetSessionContext() throws
RemoteException {\"'>'n\n\"}\"'>'n '>'n'>")
jde-gen-beep '("(end-of-line) '&"
"\"Toolkit.getDefaultToolkit().beep();\"'>'n'>")
jde-run-classic-mode-vm nil
jde-javadoc-gen-nodeprecatedlist nil
jde-imenu-include-classdef t
jde-javadoc-gen-link-online nil
jde-gen-code-templates '(("Get Set Pair" . jde-gen-get-set)
("toString method"
. jde-gen-to-string-method)
("Action Listener"
. jde-gen-action-listener)
("Window Listener"
. jde-gen-window-listener)
("Mouse Listener" .
jde-gen-mouse-listener)
("Mouse Motion Listener" .
jde-gen-mouse-motion-listener)
("Inner Class" . jde-gen-inner-class)
("println" . jde-gen-println)
("beep" . jde-gen-beep)
("property change support" .
jde-gen-property-change-support)
("EJB Entity Bean" .
jde-gen-entity-bean)
("EJB Session Bean" .
jde-gen-session-bean))
jde-gen-cflow-else '("(if (jde-parse-comment-or-quoted-p)" "'(l
\"else\")"
"'(l '> \"else \"" "(if jde-gen-k&r " "()"
"'>'n)"
"\"{\"'>'n'>'r'n" "\"} // end of
else\"'>'n'>)" ")")
jde-make-args ""
jde-javadoc-gen-destination-directory "JavaDoc"
jde-mode-abbreviations '(("ab" . "abstract") ("bo" . "boolean")
("br" . "break") ("by" . "byte")
("byv" . "byvalue") ("cas" . "cast")
("ca" . "catch") ("ch" . "char")
("cl"
. "class")
("co" . "const") ("con" . "continue")
("de" . "default") ("dou" . "double")
("el" . "else") ("ex" . "extends")
("fa" . "false") ("fi" . "final")
("fin" . "finally") ("fl" . "float")
("fo" . "for") ("fu" . "future")
("ge" . "generic") ("go" . "goto")
("impl" . "implements") ("impo" .
"import")
("ins" . "instanceof") ("in" . "int")
("inte" . "interface") ("lo" .
"long")
("na" . "native") ("ne" . "new")
("nu"
. "null")
("pa" . "package") ("pri" .
"private")
("pro" . "protected") ("pu" .
"public")
("re" . "return") ("sh" . "short")
("st" . "static") ("su" . "super")
("sw" . "switch") ("sy" .
"synchronized")
("th" . "this") ("thr" . "throw")
("throw" . "throws") ("tra" .
"transient")
("tr" . "true") ("vo" . "void")
("vol" . "volatile") ("wh" .
"while"))
jde-imenu-enable t
jde-compile-option-verbose nil
jde-db-option-heap-size '((1 . "megabytes") (16 . "megabytes"))
jde-bug-debugger-host-address "DEFAULT"
jde-make-working-directory ""
jde-bug-breakpoint-marker-colors '("red" . "yellow")
jde-javadoc-gen-use nil
jde-gen-buffer-boilerplate nil
jde-bug-raise-frame-p t
jde-db-option-application-args nil
jde-javadoc-gen-nonavbar nil
jde-javadoc-gen-nohelp nil
jde-bug-vm-includes-jpda-p t
jde-gen-jfc-app-buffer-template '("(funcall jde-gen-boilerplate-function)
'>'n" "\"import java.awt.Dimension;\" '>'n" "\"import java.awt.Graphics;\"
'>'n" "\"import java.awt.Graphics2D;\" '>'n" "\"import java.awt.Color;\"
'>'n" "\"import java.awt.geom.Ellipse2D;\" '>'n" "\"import
java.awt.event.WindowAdapter;\" '>'n" "\"import
java.awt.event.WindowEvent;\" '>'n" "\"import javax.swing.JFrame;\" '>'n"
"\"import javax.swing.JPanel;\" '>'n" "\"import javax.swing.JScrollPane;\"
'>'n" "\"import javax.swing.JMenuBar;\" '>'n" "\"import javax.swing.JMenu;\"
'>'n" "\"import java.awt.event.ActionEvent;\" '>'n" "\"import
javax.swing.AbstractAction;\" '>'n '>'n" "\"/**\" '>'n" "\" * \""
"(file-name-nondirectory buffer-file-name) '>'n" "\" *\" '>'n" "\" *\" '>'n"
"\" * Created: \" (current-time-string) '>'n" "\" *\" '>'n" "\" * @author <a
href=\\\"mailto: \\\"\" (user-full-name) \"</a>\"'>'n" "\" * @version\"
'>'n" "\" */\" '>'n" "'>'n" "\"public class \"" "(file-name-sans-extension
(file-name-nondirectory buffer-file-name))" "\" extends JFrame\"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"class Canvas extends JPanel\""
"(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"public Canvas () \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"setSize(getPreferredSize());\"
'>'n" "\"Canvas.this.setBackground(Color.white);\" '>'n" "\"}\"'>'n '>'n"
"\"public Dimension getPreferredSize() \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "\"return new Dimension(600, 600);\" '>'n" "\"}\"'>'n '>'n"
"\"public void paintComponent(Graphics g) \"" "(if jde-gen-k&r " "()"
"'>'n)" "\"{\"'>'n" "\"super.paintComponent(g);\" '>'n" "\"Graphics2D g2d =
(Graphics2D) g;\" '>'n" "\"Ellipse2D circle = new Ellipse2D.Double(0d, 0d,
100d, 100d);\" '>'n" "\"g2d.setColor(Color.red);\" '>'n"
"\"g2d.translate(10, 10);\" '>'n" "\"g2d.draw(circle);\" '>'n"
"\"g2d.fill(circle);\" '>'n" "\"}\"'>'n " "\"}\"'>'n '>'n" "\"public \""
"(file-name-sans-extension (file-name-nondirectory buffer-file-name))"
"\"()\"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"super(\\\"\" (P
\"Enter app title: \") \"\\\");\" '>'n" "\"setSize(300, 300);\" '>'n"
"\"addWindowListener(new WindowAdapter() \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "\"public void windowClosing(WindowEvent e) {System.exit(0);}\"
'>'n" "\"public void windowOpened(WindowEvent e) {}\" '>'n" "\"});\"'>'n"
"\"setJMenuBar(createMenu());\" '>'n" "\"getContentPane().add(new
JScrollPane(new Canvas()));\" '>'n" "\"}\"'>'n" "'>'n" "\"public static void
main(String[] args) \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "'>'n"
"(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\" f
= new \"" "(file-name-sans-extension (file-name-nondirectory
buffer-file-name))" "\"();\" '>'n" "\"f.show();\" '>'n" "\"}\"'>'n '>'n"
"\"protected JMenuBar createMenu() \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "\"JMenuBar mb = new JMenuBar();\" '>'n" "\"JMenu menu = new
JMenu(\\\"File\\\");\" '>'n" "\"menu.add(new AbstractAction(\\\"Exit\\\")
\"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"public void
actionPerformed(ActionEvent e) \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "\"System.exit(0);\" '>'n" "\"}\" '>'n" "\"});\" '>'n"
"\"mb.add(menu);\" '>'n" "\"return mb;\" '>'n" "\"}\"'>'n " "\"} // \"'>"
"(file-name-sans-extension (file-name-nondirectory buffer-file-name))"
"'>'n")
jde-bug-key-bindings '(("[? ? ?]" . jde-bug-step-over)
("[? ? ?]" . jde-bug-step-into)
("[? ? ?]" . jde-bug-step-into-all)
("[? ? ?]" . jde-bug-step-out)
("[? ? ?]" . jde-bug-continue)
("[? ? ?]" .
jde-bug-set-breakpoint))
jde-compile-finish-hook nil
jde-compile-option-nowarn nil
jde-setnu-mode-threshold 20000
jde-run-java-vm-w "javaw"
jde-compile-option-encoding nil
jde-run-option-java-profile '(nil . "./java.prof")
bsh-startup-timeout 10
jde-bug-jpda-directory ""
jde-read-compile-args nil
jde-run-java-vm "java"
jde-db-option-verbose '(nil nil nil)
jde-db-read-app-args nil
jde-javadoc-gen-nodeprecated nil
jde-run-option-heap-profile '(nil "./java.hprof" 5 20 "Allocation objects")
jde-gen-println '("(end-of-line) '&"
"\"System.out.println(\" (P \"Print out: \") \");\"
'>'n'>")
jde-enable-abbrev-mode t
bsh-vm-args nil
jde-gen-cflow-main '("(if (jde-parse-comment-or-quoted-p)" "'(l
\"main\")"
"'(l '> \"public static void main (String[]
args) \""
"(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n'>'r'n"
"\"} // end of main ()\"'>'n'>)" ")")
jde-javadoc-exception-tag-template '("* @exception " type
" if an
error occurs")
jde-global-classpath nil
jde-gen-window-listener-template '("(end-of-line) '& (P \"Window
name: \")"
"\".addWindowListener(new WindowAdapter() \"" "(if jde-gen-k&r "
"()" "'>'n)" "\"{\"'>'n" "'> \"public void windowActivated(WindowEvent e)
\"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"" "'>'n \"public void
windowClosed(WindowEvent e)\"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n"
"'>'n \"}\"" "'>'n \"public void windowClosing(WindowEvent e) \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "'>'n \"System.exit(0);\" '>'n \"}\""
"'>'n \"public void windowDeactivated(WindowEvent e) \"" "(if jde-gen-k&r "
"()" "'>'n)" "\"{\"'>'n" "'>'n \"}\"" "'>'n \"public void
windowDeiconified(WindowEvent e) \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "'>'n \"}\"" "'>'n \"public void windowIconified(WindowEvent e)
\"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "'>'n \"}\"" "'>'n \"public
void windowOpened(WindowEvent e) \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "'>'n \"}\"" "'>'n \"});\" '>'n'>")
jde-run-working-directory ""
jde-gen-property-change-support '("(end-of-line) '&"
"\"protected
PropertyChangeSupport pcs = new
PropertyChangeSupport(this);\" '>'n '>'n" "\"/**\" '>'n" "\"* Adds a
PropertyChangeListener to the listener list.\" '>'n" "\"* The listener is
registered for all properties.\" '>'n" "\"*\" '>'n" "\"* @param listener The
PropertyChangeListener to be added\" '>'n" "\"*/\" '>'n" "\"public void
addPropertyChangeListener(PropertyChangeListener listener) \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n"
"\"pcs.addPropertyChangeListener(listener);\" '>'n \"}\" '>'n '>'n" "\"/**\"
'>'n" "\"* Removes a PropertyChangeListener from the listener list.\" '>'n"
"\"* This removes a PropertyChangeListener that was registered for all
properties.\" '>'n" "\"*\" '>'n " "\"* @param listener The
PropertyChangeListener to be removed\" '>'n" "\"*/\" '>'n" "\"public void
removePropertyChangeListener(PropertyChangeListener listener) \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n"
"'>\"pcs.removePropertyChangeListener(listener);\" '>'n \"}\" '>'n '>'n"
"\"/**\" '>'n\"* Adds a PropertyChangeListener for a specific property.\"
'>'n" "\"* The listener will be invoked only when a call on
firePropertyChange\" '>'n" "\"* names that specific property.\" '>'n" "\"*\"
'>'n \"* @param propertyName The name of the property to listen on\" '>'n"
"\"* @param listener The PropertyChangeListener to be added\" '>'n \"*/\"
'>'n" "\"public void addPropertyChangeListener(String propertyName,\" '>'n"
"\"PropertyChangeListener listener) \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "'> \"pcs.addPropertyChangeListener(propertyName, listener);\"
'>'n \"}\" '>'n '>'n" "\"/**\" '>'n\"* Removes a PropertyChangeListener for
a specific property.\" '>'n" "\"*\" '>'n \"* @param propertyName The name of
the property that was listened on\" '>'n" "\"* @param listener The
PropertyChangeListener to be removed\" '>'n \"*/\" '>'n" "\"public void
removePropertyChangeListener(String propertyName,\" '>'n"
"\"PropertyChangeListener listener) \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "'> \"pcs.removePropertyChangeListener(propertyName,
listener);\" '>'n \"}\" '>'n '>'n" "\"/**\" '>'n\"* Reports a bound property
update to any registered listeners. \" '>'n" "\"* No event is fired if old
and new are equal and non-null.\" '>'n" "\"*\" '>'n \"* @param propertyName
The programmatic name of the property that was changed\" '>'n" "\"* @param
oldValue The old value of the property\" '>'n" "\"* @param newValue The new
value of the property.\" '>'n \"*/\" '>'n" "\"public void
firePropertyChange(String propertyName, Object oldValue, Object newValue)
\"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "'>
\"pcs.firePropertyChange(propertyName, oldValue, newValue);\" '>'n \"}\"
'>'n '>'n" "\"/**\" '>'n\"* Reports a bound property update to any
registered listeners. \" '>'n" "\"* No event is fired if old and new are
equal and non-null.\" '>'n" "\"* This is merely a convenience wrapper around
the more general\" '>'n" "\"* firePropertyChange method that takes Object
values.\" '>'n" "\"* No event is fired if old and new are equal and
non-null.\" '>'n" "\"*\" '>'n \"* @param propertyName The programmatic name
of the property that was changed\" '>'n" "\"* @param oldValue The old value
of the property\" '>'n" "\"* @param newValue The new value of the
property.\" '>'n \"*/\" '>'n" "\"public void firePropertyChange(String
propertyName, int oldValue, int newValue) \"" "(if jde-gen-k&r " "()"
"'>'n)" "\"{\"'>'n" "'> \"pcs.firePropertyChange(propertyName, oldValue,
newValue);\" '>'n \"}\" '>'n '>'n" "\"/**\" '>'n\"* Reports a bound property
update to any registered listeners. \" '>'n" "\"* No event is fired if old
and new are equal and non-null.\" '>'n" "\"* This is merely a convenience
wrapper around the more general\" '>'n" "\"* firePropertyChange method that
takes Object values.\" '>'n" "\"* No event is fired if old and new are equal
and non-null.\" '>'n" "\"*\" '>'n \"* @param propertyName The programmatic
name of the property that was changed\" '>'n" "\"* @param oldValue The old
value of the property\" '>'n" "\"* @param newValue The new value of the
property.\" '>'n \"*/\" '>'n" "\"public void firePropertyChange(String
propertyName, boolean oldValue, boolean newValue) \"" "(if jde-gen-k&r "
"()" "'>'n)" "\"{\"'>'n" "'> \"pcs.firePropertyChange(propertyName,
oldValue, newValue);\" '>'n \"}\" '>'n '>'n" "\"/**\" '>'n\"* Fires an
existing PropertyChangeEvent to any registered listeners.\" '>'n" "\"* No
event is fired if the given event's old and new values are equal and
non-null. \" '>'n" "\"*\" '>'n \"* @param evt The PropertyChangeEvent
object.\" '>'n\"*/\" '>'n" "\"public void
firePropertyChange(PropertyChangeEvent evt) \"" "(if jde-gen-k&r " "()"
"'>'n)" "\"{\"'>'n" "'> \"pcs.firePropertyChange(evt);\" '>'n \"}\" '>'n
'>'n" "\"/**\" '>'n\"* Checks if there are any listeners for a specific
property.\" '>'n" "\"*\" '>'n \"* @param evt The PropertyChangeEvent
object.\" '>'n" "\"* @return <code>true</code>if there are one or more
listeners for the given property\" '>'n" "\"*/\" '>'n" "\"public boolean
hasListeners(String propertyName) \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "'> \"return pcs.hasListeners(propertyName);\" '>'n \"}\" '>'n
'>'n'>")
jde-javadoc-describe-interface-template '("* Describe interface "
(jde-javadoc-code name) " here.")
jde-javadoc-see-tag-template '("* @see " ref)
jde-imenu-include-signature t
jde-db-marker-regexp "^Breakpoint hit: .*(\\([^$]*\\).*:\\([0-9]*\\))"
jde-gen-mouse-motion-listener-template '("(end-of-line) '& (P \"Component
name: \")" "\".addMouseMotionListener(new MouseMotionAdapter() \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>" "'>'n \"public void
mouseDragged(MouseEvent e) \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n"
"\"}\"'>" "'>'n \"public void mouseMoved(MouseEvent e) \"" "(if jde-gen-k&r
" "()" "'>'n)" "\"{\"'>'n" "\"}\"'>" "'>'n \"});\"'>'n'>")
jde-key-bindings '(("[? ? ?]" . jde-run-menu-run-applet)
("[? ? ?]" . jde-build)
("[? ? ?]" . jde-compile)
("[? ? ?]" . jde-debug)
("[? ? ?]" . jde-wiz-implement-interface)
("[? ? ?j]"
. jde-javadoc-generate-javadoc-template)
("[? ? ? ]" . bsh)
("[? ? ?\f]" . jde-gen-println)
("[? ? ?]" . jde-browse-jdk-doc)
("[? ? ?]" . jde-save-project)
("[? ? ?]" . jde-wiz-update-class-list)
("[? ? ?]" . jde-run)
("[? ? ?]" . speedbar-frame-mode)
("[? ? ?]" . jde-db-menu-debug-applet)
("[? ? ?]" . jde-help-symbol)
("[? ? ?]" . jde-show-class-source)
("[? ? ?]" . jde-wiz-find-and-import)
("[(control c) (control v) (control ?.)]" .
jde-complete-at-point-menu)
("[(control c) (control v) ?.]" .
jde-complete-at-point))
jde-gen-cflow-for-i '("(if (jde-parse-comment-or-quoted-p)" "'(l
\"fori\")"
"'(l '> \"for (int \" (p \"variable: \"
var) \" = 0; \"" "(s var)"
"\" < \"(p \"upper bound: \" ub)\"; \" (s var) \"++) \"" "(if jde-gen-k&r "
"()" "'>'n)" "\"{\"'>'n'>'r'n" "\"} // end of for (int \" (s var) \" = 0;
\"" "(s var) \" < \" (s ub) \"; \" (s var) \"++)\"'>'n'>)" ")")
jde-run-option-classpath nil
jde-javadoc-gen-detail-switch '("-protected")
jde-javadoc-param-tag-template '("* @param " name " " (jde-javadoc-a
type)
" "
(jde-javadoc-code type) " value")
jde-compile-option-verbose-path nil
jde-db-debugger '("JDEbug" "jdb" . "Executable")
jde-jdk-doc-url "http://www.javasoft.com/products/jdk/1.1/docs/index.html"
jde-compiler "javac"
jde-javadoc-gen-verbose nil
jde-javadoc-describe-method-template '("* Describe "
(jde-javadoc-code name)
"
method here.")
jde-gen-class-buffer-template '("(funcall jde-gen-boilerplate-function)
'>'n" "\"/**\" '>'n" "\" * \"" "(file-name-nondirectory buffer-file-name)
'>'n" "\" *\" '>'n" "\" *\" '>'n" "\" * Created: \" (current-time-string)
'>'n" "\" *\" '>'n" "\" * @author <a href=\\\"mailto: \\\"\"
(user-full-name) \"</a>\"'>'n" "\" * @version\" '>'n" "\" */\" '>'n'" "'>'n"
"\"public class \"" "(file-name-sans-extension (file-name-nondirectory
buffer-file-name))" "\" \" (jde-gen-get-super-class)" "(if jde-gen-k&r "
"()" "'>'n)" "\"{\"'>'n" "\"public \"" "(file-name-sans-extension
(file-name-nondirectory buffer-file-name))" "\" ()\"" "(if jde-gen-k&r "
"()" "'>'n)" "\"{\"'>'n" "'>'p'n" "\"}\">" "'>'n" "\"}\">" "\"// \""
"(file-name-sans-extension (file-name-nondirectory buffer-file-name))"
"'>'n")
jde-appletviewer-option-vm-args nil
jde-run-executable-args nil
jde-db-option-garbage-collection '(t t)
jde-javadoc-gen-stylesheetfile ""
jde-use-font-lock t
jde-compile-option-bootclasspath nil
jde-make-program "make"
jde-javadoc-gen-group nil
jde-javadoc-gen-link-offline nil
jde-javadoc-gen-doc-title ""
jde-javadoc-gen-header ""
jde-run-option-vm-args nil
jde-javadoc-gen-window-title ""
jde-compile-option-directory ""
jde-gen-console-buffer-template '("(funcall jde-gen-boilerplate-function)
'>'n" "\"/**\" '>'n" "\" * \"" "(file-name-nondirectory buffer-file-name)
'>'n" "\" *\" '>'n" "\" *\" '>'n" "\" * Created: \" (current-time-string)
'>'n" "\" *\" '>'n" "\" * @author <a href=\\\"mailto: \\\"\"
(user-full-name) \"</a>\"'>'n" "\" * @version\" '>'n" "\" */\" '>'n" "'>'n"
"\"public class \"" "(file-name-sans-extension (file-name-nondirectory
buffer-file-name))" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"public
\"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))"
"\" ()\"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "'>'n" "\"}\"'>'n"
"'>'n" "\"public static void main(String[] args)\"" "(if jde-gen-k&r " "()"
"'>'n)" "\"{\"'>'n" "'>'p'n" "\"}\"'>'n" "\"} // \"'>"
"(file-name-sans-extension (file-name-nondirectory buffer-file-name))"
"'>'n")
jde-read-make-args nil
jde-javadoc-gen-noindex nil
jde-gen-mouse-listener-template '("(end-of-line) '& (P \"Component name:
\")" "\".addMouseListener(new MouseAdapter() \"" "(if jde-gen-k&r " "()"
"'>'n)" "\"{\"'> " "'>'n \"public void mouseClicked(MouseEvent e) \" " "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\" '>" "'>'n \"public void
mouseEntered(MouseEvent e) \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n"
"\"}\" '>" "'>'n \"public void mouseExited(MouseEvent e) \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>" "'>'n \"public void
mousePressed(MouseEvent e) \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n"
"\"}\" '>" "'>'n \"public void mouseReleased(MouseEvent e) \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>" "'>'n \"});\"'>'n'>")
jde-run-option-application-args nil
jde-bug-vm-executable '("javaw")
jde-db-set-initial-breakpoint t
jde-bug-debugger-command-timeout 10
jde-db-option-stack-size '((128 . "kilobytes") (400 . "kilobytes"))
jde-db-option-properties nil
jde-db-source-directories '("c:/Dokumentumok/dani/my-java/")
jde-run-read-app-args nil
jde-gen-to-string-method-template '("(end-of-line) '&"
"\"public
String toString() \""
"(if
jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n"
"\"}\"'>'n'>")
jde-quote-classpath t
jde-bug-window-message nil
jde-build-use-make nil
jde-javadoc-author-tag-template '("* @author <a href=\"mailto:"
user-mail-address
"\">"
user-full-name
"</a>")
jde-javadoc-describe-field-template '("* Describe "
(jde-javadoc-field-type
modifiers)
" "
(jde-javadoc-code name) " here.")
jde-javadoc-gen-link-URL nil
jde-compile-option-classpath nil
jde-bug-jdk-directory "c:/jdk1.3/"
jde-gen-boilerplate-function 'jde-gen-create-buffer-boilerplate
jde-gen-entity-bean-template '("(jde-wiz-insert-imports-into-buffer (list
\"javax.ejb.*\"\n\"java.rmi.RemoteException\"))" "'> \"public void
ejbActivate() throws RemoteException \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "\"}\"'>'n '>'n" "'> \"public void ejbPassivate() throws
RemoteException \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>'n
'>'n" "'> \"public void ejbLoad() throws RemoteException \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>'n '>'n" "'> \"public void
ejbStore() throws RemoteException \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n" "\"}\"'>'n '>'n" "'> \"public void ejbRemove() throws
RemoteException \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>'n
'>'n" "'> \"public void setEntityContext(EntityContext ctx) throws
RemoteException \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>'n
'>'n" "'> \"public void unsetEntityContext() throws RemoteException \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>'n '>'n'>")
jde-javadoc-version-tag-template '("* @version 1.0")
jde-javadoc-describe-constructor-template '("* Creates a new "
(jde-javadoc-code name)
" instance.")
jde-bug-server-shmem-name '(t . "JDEbug")
jde-db-startup-commands nil
jde-javadoc-gen-docletpath nil
jde-javadoc-gen-split-index nil
jde-compile-option-deprecation nil
jde-gen-k&r t
jde-javadoc-gen-bottom ""
jde-javadoc-gen-footer ""
jde-db-option-classpath nil
jde-gen-cflow-for '("(if (jde-parse-comment-or-quoted-p)" "'(l
\"for\")"
"'(l '> \"for (\" (p \"for-clause: \" clause)
\")
\""
"(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n'>'r'n"
"\"} // end of for (\" (s clause)
\")\"'>'n'>)" ")")
jde-run-mode-hook nil
jde-db-option-verify '(nil t)
jde-compile-option-extdirs nil
jde-imenu-sort nil
jde-gen-get-set-var-template '("(end-of-line) '&"
"(P \"Variable type:
\" type) \" \""
"(P \"Variable name:
\" name) \";\" '>'n '>'n" "\"/**\" '>'n" "\"*
Get the value of \" (s name) \".\" '>'n" "\"* @return value of \" (s name)
\".\" '>'n" "\"*/\" '>'n" " \"public \" (s type)" "(if (string= \"boolean\"
(jde-gen-lookup-named 'type) ) " "\" is\" " "\" get\" ) " "(jde-gen-init-cap
(jde-gen-lookup-named 'name))" "\"() \"" "(if jde-gen-k&r " "()" "'>'n)"
"\"{\" '>'n" "\"return \" (s name) \";\" '>'n \"}\"" "'>'n '>'n" "\"/**\"
'>'n" "\"* Set the value of \" (s name) \".\" '>'n" "\"* @param v Value to
assign to \" (s name) \".\" '>'n" "\"*/\" '>'n" "\"public void set\"
(jde-gen-init-cap (jde-gen-lookup-named 'name))" "\"(\" (s type) \" v) \" "
"(if jde-gen-k&r " "()" "'>'n)" "\"{\" '>'n" "'>'n \"this.\" (s name) \" =
v;\" '>'n \"}\" '>'n'>")
jde-bug-saved-breakpoints nil
jde-compile-option-sourcepath nil
jde-gen-cflow-if '("(if (jde-parse-comment-or-quoted-p)" "'(l
\"if\")"
"'(l '> \"if (\" (p \"if-clause: \" clause) \")
\""
"(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n'>'r'n"
"\"} // end of if (\" (s clause) \")\"'>'n'>)"
")")
jde-db-option-java-profile '(nil . "./java.prof")
jde-javadoc-gen-author t
jde-compile-option-depend-switch '("-Xdepend")
jde-setnu-mode-enable nil
jde-run-applet-doc ""
jde-compile-option-vm-args nil
jde-javadoc-gen-overview ""
jde-javadoc-gen-notree nil
jde-run-option-garbage-collection '(t t)
jde-db-mode-hook nil
jde-db-option-heap-profile '(nil "./java.hprof" 5 20 "Allocation objects")
bsh-eval-timeout 20
jde-db-read-vm-args nil
jde-bug-debug nil
jde-javadoc-end-block-template nil
jde-javadoc-gen-packages nil
jde-gen-cflow-if-else '("(if (jde-parse-comment-or-quoted-p)"
"'(l \"ife\")"
"'(l '> \"if (\" (p \"if-clause: \"
clause)
\") \""
"(if jde-gen-k&r " "()" "'>'n)"
"\"{\"'>'n'>'r'n"
"\"} // end of if (\" (s clause)
\")\"'> n"
"'> \"else \"" "(if jde-gen-k&r " "()"
"'>'n)"
"\"{\"'>'n'>'r'n"
"\"} // end of if (\" (s clause)
\")else\"'>'n'>)"
")")
jde-gen-cflow-while '("(if (jde-parse-comment-or-quoted-p)"
"'(l \"while\")"
"'(l '> \"while (\" (p \"while-clause: \"
clause) \") \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n'>'r'n" "\"} // end of while (\" (s
clause) \")\"'>'n'>)" ")")
jde-bug-server-socket '(t . "2112")
jde-appletviewer-option-encoding ""
jde-bug-breakpoint-cursor-colors '("cyan" . "brown")
jde-compile-option-target '("1.1")
jde-run-executable ""
jde-run-option-heap-size '((1 . "megabytes") (16 . "megabytes"))
jde-gen-cflow-switch '("(if (jde-parse-comment-or-quoted-p)"
"'(l \"switch\")"
"'(l '> \"switch (\" (p
\"switch-condition: \" clause) \") \"" "(if
jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n'" "\"case \" (p \"first value: \")
\":\"'>'n'>'p'n" "\"break;\"'>'n'>'p'n" "\"default:\"'>'n'>'p'n"
"\"break;\"'>'n" "\"} // end of switch (\" (s clause) \")\"'>'n'>)" ")")
jde-db-option-vm-args nil
jde-run-application-class ""
jde-javadoc-gen-doclet ""
jde-run-option-verbose '(nil nil nil)
jde-project-file-name "prj.el"
jde-wiz-import-excluded-packages '("bsh.*")
jde-compile-option-debug '("selected" (t nil nil))
jde-bug-jre-home ""
jde-run-applet-viewer ""
jde-entering-java-buffer-hooks '(jde-reload-project-file)
jde-javadoc-return-tag-template '("* @return " (jde-javadoc-a type) "
"
(jde-javadoc-code
type) " value")
jde-javadoc-gen-version t
jde-javadoc-gen-helpfile ""
jde-run-read-vm-args nil
jde-help-docsets nil
jde-javadoc-since-tag-template '("* @since 1.0")
jde-gen-inner-class-template '("(end-of-line) '& \"class \" (P \"Class name:
\" class)" "(P \"Superclass: \" super t)" "(let ((parent
(jde-gen-lookup-named 'super)))" "(if (not (string= parent \"\"))" "(concat
\" extends \" parent ))) " "(if jde-gen-k&r " "()" "'>'n)" "\"{\" '>'n"
"\"public \" (s class) \"() \"" "(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n"
"\"}\"'>'n" "\"}\" '>'n'>")
jde-run-option-verify '(nil t)
jde-compile-option-optimize nil
jde-gen-cflow-case '("(if (jde-parse-comment-or-quoted-p)" "'(l
\"case\")"
"'(l 'n \"case \" (p \"value: \")
\":\"'>'n'>'p'n"
"\"break;\"'>'n'>'p)" ")")
jde-compile-option-depend nil
jde-javadoc-describe-class-template '("* Describe class "
(jde-javadoc-code name) " here.")
jde-javadoc-gen-serialwarn nil
jde-gen-action-listener-template '("'& (P \"Component name: \")"
"\".addActionListener(new ActionListener() \"" "(if jde-gen-k&r "
"()" "'>'n)" "\"{\"'>'n" "\"public void actionPerformed(ActionEvent e) \""
"(if jde-gen-k&r " "()" "'>'n)" "\"{\"'>'n" "\"}\"'>'n \"});\"'>'n'>")
jde-compile-option-command-line-args ""
jde-gen-buffer-templates '(("Class" . jde-gen-class)
("Console" . jde-gen-console)
("Swing App" .
jde-gen-jfc-app))
jde-project-context-switching-enabled-p t
jde-javadoc-gen-args nil
jde-run-option-stack-size '((128 . "kilobytes") (400 . "kilobytes"))
jde-run-option-properties nil
)
The contents of the *JDEBug* buffer were
cd c:/Dokumentumok/dani/my-java/
javaw -classpath
c:/fsf/elisp/jde-2.2.2/java/lib/jde.jar;c:/jdk1.3/lib/tools.jar
jde.debugger.Main
(jde-dbo-init-debug-session)
JDE> -1 1 launch 1 -vmexec javaw rand
(jde-dbo-message
1 "Launched VM Java Debug Interface (Reference Implementation) version 1.3
Java Debug Wire Protocol (Reference Implementation) version 1.0
JVM Debug Interface version 1.0
JVM version 1.3.0 (Java HotSpot(TM) Client VM, interpreted mode)")
(jde-dbo-command-result 1 1031)
(jde-dbo-message
1 "Debugger waiting for Emacs to connect to app SIO port 1031.")
(jde-dbo-event-set
1 "all"
(list "Thread" 1 "main" "unknown" "suspended by debugger"
(list)
"VM has no information"
"VM has no information")
(list 'jde-dbo-vm-start-event))
End Insert *JDEbug* buffer
There is no CLI buffer
The contents of the locals buffer are
End Insert locals buffer
The contents of the *Backtrace* buffer were
Signaling: (error "Unknown host \"DEFAULT\"")
open-network-stream("rand(1) CLI" #<buffer *rand(1) CLI*> "DEFAULT" 1031)
comint-exec(#<buffer *rand(1) CLI*> "rand(1) CLI" ("DEFAULT" . 1031) nil
nil)
make-comint("rand(1) CLI" ("DEFAULT" . 1031))
(oset-engine (oref this process) (quote cli-buf) (make-comint
cli-buffer-name (cons jde-bug-debugger-host-address cli-socket)))
(oset (oref this process) cli-buf (make-comint cli-buffer-name (cons
jde-bug-debugger-host-address cli-socket)))
(let* ((source-buffer ...) (cli-socket ...) (cli-buffer-name ...)) (oset
(oref this process) cli-socket cli-socket) (oset (oref this process) cli-buf
(make-comint cli-buffer-name ...)) (oset this msg (format "%s\nEmacs
connected to standard IO port %d for process %s." ... cli-socket ...))
(pop-to-buffer (oref process msg-buf)) (pop-to-buffer source-buffer)
(split-window-vertically) (pop-to-buffer (oref process locals-buf))
(pop-to-buffer source-buffer) (oset process win-cfg
(current-window-configuration)))
jde-dbs-launch-process([object jde-dbs-launch-process "Launch rand"
[object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process
rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil
nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
apply(jde-dbs-launch-process [object jde-dbs-launch-process "Launch rand"
[object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process
rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil
nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(setq rval (apply (car ...) newargs))
(let ((scoped-class ...)) (setq found t) (setq rval (apply ... newargs)))
(if (car lambdas) (let (...) (setq found t) (setq rval ...)))
(while lambdas (if (car lambdas) (let ... ... ...)) (setq lambdas (cdr
lambdas)))
(let ((rval nil) (found nil)) (while lambdas (if ... ...) (setq lambdas
...)) (if (not found) (signal ... ...)) rval)
(let ((newargs nil) (mclass nil) (lambdas nil)
(eieio-generic-call-methodname method) (eieio-generic-call-arglst args))
(setq newargs args) (if (object-p ...) (setq mclass ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (let (...
...) (while lambdas ... ...) (if ... ...) rval))
eieio-generic-call(jde-dbs-cmd-success-action ([object
jde-dbs-launch-process "Launch rand" [object jde-dbs-proc "process1" 1
"rand" 1031 unbound #<buffer Process rand(1)> #<buffer rand(1) Threads>
#<buffer rand(1) Local Variables> nil nil nil [object
jde-dbs-proc-state-info "State Info 1" unbound unbound unbound unbound]
unbound 0 unbound unbound nil unbound #1 unbound nil] 1 "launch" (1 normal
...) 1031 "Launch command line:\n javaw rand \n" "rand" unbound "javaw"
" " " "]))
jde-dbs-cmd-success-action([object jde-dbs-launch-process "Launch rand"
[object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process
rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil
nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(if (jde-dbo-command-succeeded-p result) (jde-dbs-cmd-success-action this)
(jde-dbs-cmd-failure-action this))
(let ((result ...)) (oset this :result result) (oset this :data (car ...))
(if (jde-dbo-command-succeeded-p result) (jde-dbs-cmd-success-action this)
(jde-dbs-cmd-failure-action this)) (jde-dbs-cmd-display-response this)
(jde-dbs-cmd-execute-pending-events this) (oref this :result))
(if jde-dbs-command-reply (let (...) (oset this :result result) (oset this
:data ...) (if ... ... ...) (jde-dbs-cmd-display-response this)
(jde-dbs-cmd-execute-pending-events this) (oref this :result)))
(let* ((debugger-process ...) (previous-listener ...) (target-process ...)
(command-line ...)) (setq jde-dbs-debugger-output "") (setq
jde-dbs-command-reply "") (setq jde-dbs-pending-events nil) (setq
jde-dbs-pending-command (oref this id)) (if target-process (oset
target-process last-cmd this)) (jde-dbs-debugger-display-message
jde-dbs-the-debugger (concat "JDE> " command-line)) (set-process-filter
debugger-process (quote jde-dbs-command-reply-listener))
(process-send-string debugger-process command-line) (process-send-string
debugger-process "\n") (when (not ...) (message "Error: debugger didn't
respond to command:\n%s" command-line) (setq jde-dbs-command-reply nil))
(set-process-filter debugger-process previous-listener) (if
jde-dbs-command-reply (let ... ... ... ... ... ... ...)))
jde-dbs-cmd([object jde-dbs-launch-process "Launch rand" [object
jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process rand(1)>
#<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil nil
[object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
apply(jde-dbs-cmd [object jde-dbs-launch-process "Launch rand" [object
jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process rand(1)>
#<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil nil
[object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(setq rval (apply (car ...) newargs))
(let ((scoped-class ...)) (setq found t) (setq rval (apply ... newargs)))
(if (car lambdas) (let (...) (setq found t) (setq rval ...)))
(while lambdas (if (car lambdas) (let ... ... ...)) (setq lambdas (cdr
lambdas)))
(let ((rval nil) (found nil)) (while lambdas (if ... ...) (setq lambdas
...)) (if (not found) (signal ... ...)) rval)
(let ((newargs nil) (mclass nil) (lambdas nil)
(eieio-generic-call-methodname method) (eieio-generic-call-arglst args))
(setq newargs args) (if (object-p ...) (setq mclass ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (if (not
scoped-class) (setq lambdas ...)) (if mclass (setq lambdas ...)) (let (...
...) (while lambdas ... ...) (if ... ...) rval))
eieio-generic-call(jde-dbs-cmd-exec ([object jde-dbs-launch-process
"Launch rand" [object jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer
Process rand(1)> #<buffer rand(1) Threads> #<buffer rand(1) Local Variables>
nil nil nil [object jde-dbs-proc-state-info "State Info 1" unbound unbound
unbound unbound] unbound 0 unbound unbound nil unbound #1 unbound nil] 1
"launch" (1 normal ...) 1031 "Launch command line:\n javaw rand \n"
"rand" unbound "javaw" " " " "]))
jde-dbs-cmd-exec([object jde-dbs-launch-process "Launch rand" [object
jde-dbs-proc "process1" 1 "rand" 1031 unbound #<buffer Process rand(1)>
#<buffer rand(1) Threads> #<buffer rand(1) Local Variables> nil nil nil
[object jde-dbs-proc-state-info "State Info 1" unbound unbound unbound
unbound] unbound 0 unbound unbound nil unbound #0 unbound nil] 1 "launch" (1
normal (1031)) 1031 "Launch command line:\n javaw rand \n" "rand"
unbound "javaw" " " " "])
(not (jde-dbs-cmd-exec launch))
(if (not (jde-dbs-cmd-exec launch)) (progn (jde-dbs-proc-move-to-morgue
process) (if old-target ...) (jde-dbs-proc-set-state process "unknown")
(jde-dbs-proc-set-state-reason process "Error launching process.")
(jde-dbs-proc-set-add jde-dbs-the-process-morgue process) (setq succeededp
nil)))
(when (not (jde-dbs-cmd-exec launch)) (jde-dbs-proc-move-to-morgue
process) (if old-target (oset jde-dbs-the-process-registry :target-process
old-target)) (jde-dbs-proc-set-state process "unknown")
(jde-dbs-proc-set-state-reason process "Error launching process.")
(jde-dbs-proc-set-add jde-dbs-the-process-morgue process) (setq succeededp
nil))
(let* ((process ...) (old-target ...) (launch ...) (succeededp t))
(jde-dbs-proc-set-add jde-dbs-the-process-registry process) (if (not ...)
(oset launch :jre-home jde-bug-jre-home)) (oset jde-dbs-the-process-registry
:target-process process) (when (not ...) (jde-dbs-proc-move-to-morgue
process) (if old-target ...) (jde-dbs-proc-set-state process "unknown")
(jde-dbs-proc-set-state-reason process "Error launching process.")
(jde-dbs-proc-set-add jde-dbs-the-process-morgue process) (setq succeededp
nil)) succeededp)
(if (and (jde-dbs-proc-set-find jde-dbs-the-process-registry :main-class
main-class) (not ...)) nil (let* (... ... ... ...) (jde-dbs-proc-set-add
jde-dbs-the-process-registry process) (if ... ...) (oset
jde-dbs-the-process-registry :target-process process) (when ... ... ... ...
... ... ...) succeededp))
(unless (and (jde-dbs-proc-set-find jde-dbs-the-process-registry
:main-class main-class) (not ...)) (let* (... ... ... ...)
(jde-dbs-proc-set-add jde-dbs-the-process-registry process) (if ... ...)
(oset jde-dbs-the-process-registry :target-process process) (when ... ...
... ... ... ... ...) succeededp))
(let* ((main-class ...)) (unless (and ... ...) (let* ... ... ... ... ...
succeededp)))
jde-bug-launch-process()
(let ((result ...)) (if result (let ... ... ...)))
(if (jde-dbs-debugger-running-p) (let (...) (if result ...)))
jde-bug-debug-app()
(if (string= (car jde-db-debugger) "JDEbug") (jde-bug-debug-app) (jde-db))
jde-debug()
call-interactively(jde-debug)
End Insert *Backtrace* buffer
The contents of the *Messages* buffer were
Loading bytecomp...done
Loading byte-opt...
Loading byte-opt...done
Loading pc-select...
Loading pc-select...done
Loading delsel...
Loading delsel...done
Loading iswitchb...
Loading iswitchb...done
Loading edmacro...
Loading edmacro...done
Loading rsz-mini...
Loading rsz-mini...done
Loading which-func...
Loading which-func...done
Loading cl-seq...
Loading cl-seq...done
Loading desktop...
Loading desktop...done
Setting JDE variables to startup values...
Fontifying rand.java...
Fontifying rand.java... (regexps.............)
Setting JDE variables to startup values...
Desktop loaded.
Loading Daniel's .emacs file... Done.
For information about the GNU Project and its goals, type C-h C-p.
(New file)
lev <rand.java> *scratch* *Messages*
Loading debug...
Loading debug...done
Entering debugger...
[2 times]
*Backtrace* <rand.java> lev *scratch* *Messages* *JDEbug*
*Backtrace* rand.java <lev> *scratch* *Messages* *JDEbug*
lev <*Backtrace*> rand.java *scratch* *Messages* *JDEbug*
Mark set [2 times]
Region saved
*Backtrace* <lev> rand.java *scratch* *Messages* *JDEbug*
Mark set
End of buffer [3 times]
Beginning of buffer [3 times]
Auto-saving...
Auto-saving...done
Wrote c:/Dokumentumok/dani/my-java/lev
Preparing problem report...
Loading sendmail...
Loading sendmail...done
Formatting bug report buffer...
Formatting bug report
buffer..............................................................................
Mark set [4 times]
End Insert *Messages* buffer
Process environment:
TERM=cmd
EMACSDOC=C:/FSF/EMACS/etc
EMACSLOCKDIR=C:/FSF/EMACS/lock
EMACSPATH=C:/FSF/EMACS/bin
EMACSDATA=C:/FSF/EMACS/etc
SHELL=C:/FSF/EMACS/bin/cmdproxy.exe
EMACSLOADPATH=C:/FSF/EMACS/site-lisp;C:/FSF/EMACS/lisp;C:/FSF/EMACS/leim
TMPDIR=C:\temp
emacs_dir=C:/FSF/EMACS
BLASTER=A220 I5 D1 H5 T5
windir=C:\WINDOWS
CMDLINE=WIN
TEMP=C:\temp
PATH=C:\WINDOWS;C:\WINDOWS\COMMAND;C:;C:\FSF\EMACS\BIN;C:\FSF\ELISP\GNUSERV;C:\FSF\ELISP\OO-BROWSER;C:\JDK1.3\BIN
HOME=c:/fsf
PROMPT=$p$g
COMSPEC=C:\WINDOWS\COMMAND.COM
winbootdir=C:\WINDOWS
TMP=C:\WINDOWS\TEMP
The contents of the .emacs file was
;;AUTHOR : Daniel Hegyi
;;EMAIL : [EMAIL PROTECTED]
;;SPECIAL THANKS to the following people. I used a lot of their stuff :
;; Benjamin Rutt, Igor Boukanov, Xavier Colmant, and
;; prof. JONATHAN AMSTERDAM of NYU.
(setq debug-on-error t)
;; optional packages you have to install first. Default is not to use them.
(defvar have-jde t "Set to non-nil if you have jde")
(defvar have-html-helper-mode t "Set to non-nil if you have
HTML-Helper-Mode")
(defvar have-oo-browser nil "Set to non-nil if you have oo-browser")
(defvar have-gnuserv t "Set to non-nil if you have gnuserv")
(defvar have-calculator t "Set to non-nil if you have calculator")
(defvar have-pc-bufsw t "Set to non-nil if you have pc-bufsw")
(defvar have-paren-face t "Set to non-nil if you have paren-face")
(defvar have-redo t "Set to non-nil if you have redo")
(defvar have-filladapt nil "Set to non-nil if you have Filladapt")
(defvar have-backup t "Set to non-nil if you have backup")
(defvar have-folding nil "Set to non-nil if you have Folding")
(defvar have-whitespace nil "Set to non-nil if you have whitespace")
(defvar have-ishl t "Set to non-nil if you have Ishl")
(defvar have-eol-conversion-modified nil "Set to non-nil if you have
eol-conversion-modified")
(defvar have-unscroll t "Set to non-nil if you have unscroll")
(message "Loading Daniel's .emacs file... ")
;; SET THIS FIRST!! EVERYTHING ELSE DEPENDS ON THIS VARIABLE!
(setenv "HOME" "c:/fsf")
;; If you get an elisp file from the Internet, you will need to put it
;; in a place where Emacs can find it. This is therefore the first
;; thing I have in my .emacs file.
;; This will add the ~/elisp directory to my load-path. The variable
;; load-path is a list of directories which Emacs will search when it
;; tries to load a library. Any elisp file you get from the Internet or
;; from friends can be copied into the ~/elisp directory and loaded from
;; there.
(add-to-list 'load-path "~/elisp")
;; Common Settings
(setq user-full-name "Daniel Hegyi")
(setq user-mail-address "[EMAIL PROTECTED]" )
;;=====================================================================
;; OPTIONAL PACKAGES.
;;=====================================================================
;; JDE: The Java Development Environment.
;;
;; The semantic bovinator is used to parse the Java source. Various
;; features of the JDE, e.g., the classes menu, need to parse the code
;; in the current Java source buffer. The JDE used to use regular
;; expressions. The semantic package enables use of a BNF grammar (see
;; java.bnf in the JDE lisp directory) to parse your Java code. The
;; grammar-based parser is much faster and more accurate than regular
;; expressions.
(if have-jde
(progn
(add-to-list 'load-path (expand-file-name "~/elisp/jde-2.2.2/lisp"))
(add-to-list 'load-path (expand-file-name "~/elisp/semantic-1.2.1"))
(add-to-list 'load-path (expand-file-name "~/elisp/speedbar-0.12"))
(require 'jde)))
;;=====================================================================
;; HTML-Helper-Mode
;; http://www4.smart.net/~jcovey//html-helper-mode/html-helper-mode.html
;;
;; Insertion philosophy
;; html-mode frequently prompts the user in the minibuffer for the data
;; to fill in fields like titles or headers. In html-helper-mode,
;; prompting is a user-controlled option.
;; Modifying regions
;; In html-helper-mode, every command will instead modify the region if
;; it is called with a prefix argument.
;; Automatic text insertion
;; html-helper-mode can automatically insert skeletons for new
;; documents and also maintain timestamps.
;; Minimal syntax support
;; html-helper-mode does its best to tell emacs about the syntax of
;; HTML documents.
;; Indentation
;; html-helper-mode indents nested lists
;; Highlighting
;; HTML cookies are coloured nicely with hilit19 or font-lock-mode.
;; Keymap
;; A few obsolete cookies have been removed, a few new cookies have
;; been added, and the keybindings have been completely rearranged to
;; be compliant with emacs standards.
;; Completion
;; HTML cookies can be completed in the buffer with M-TAB.
;; Missing features
;; Some features of html-mode are not included. These include the
;; ability to quotify old-style HREFs and automatic naming of anchors
(if have-html-helper-mode
(progn
(autoload 'html-helper-mode "html-helper-mode" "Yay HTML" t)
(setq auto-mode-alist (cons '("\\.html$" . html-helper-mode)
auto-mode-alist))
(setq auto-mode-alist (cons '("\\.htm$" . html-helper-mode)
auto-mode-alist))
;; I suggest you turn on both html-helper-do-write-file-hooks and
;; html-helper-build-new-buffer, and set html-helper-address-string to
;; the appropriate value for you. I use this configuration:
; html-helper-mode will try to update a timestamp in the
; document, and warn the user if it can't.
(setq html-helper-do-write-file-hooks t)
; html-helper-mode will insert a skeleton for new documents.
(setq html-helper-build-new-buffer t)
; html-helper-mode always presents you with a full menu of
; everything it can do.
(setq html-helper-use-expert-menu t)
(setq html-helper-address-string
"<a href=\"http://dhegyi.homepage.com/\">Daniel Hegyi
<[EMAIL PROTECTED]></a>")))
;;=====================================================================
;; OO-Browser: Fantastic tool available at
;; http://www.beopen.com. Formerly known as Altrasoft.
(if have-oo-browser
(progn
(setq load-path (append
'("~/elisp/oo-browser"
"~/elisp/oo-browser/hypb/")
load-path))
(load "br-start")
(global-set-key "\C-c\C-o" 'oo-browser)))
;;=====================================================================
;; Gnuserv: requires optional gnuserv package. This should be done as
;; early as possible to make sure gnuserv starts up before gnuclient
;; times out.
(if have-gnuserv
(progn
(require 'gnuserv)
(gnuserv-start)
;; Reuse an existing frame when loading files externally
(setq gnuserv-frame (car (frame-list)))))
;;=====================================================================
;; calculator: A simple pocket calculator for Emacs.
(if have-calculator
(progn
(autoload 'calculator "calculator"
"A simple pocket calculator for Emacs." t)
(global-set-key "\C-cc" 'calculator)))
;;=====================================================================
;; Pc-bufsw: A fast way to do a buffer switch in Emacs is to use
;; pc-bufsw.el code that I initially created in an attempt to model a
;; Ctrl-Tab like switch that you can find in Windows applications.
;;
;; Note: if you're using XEmacs, use the following lines:
;; (require 'pc-bufsw)
;; (pc-bufsw::bind-keys [(control tab)] [ (control shift tab) ])
(if have-pc-bufsw
(progn
(require 'pc-bufsw)
(pc-bufsw::bind-keys [C-tab] [C-S-tab])))
;;=====================================================================
;; mic-paren: Load this file and Emacs will display highlighting on
;; whatever parenthesis matches the one before or after point. This is
;; an extension to the paren.el file distributed with Emacs. The
;; default behaviour is similar to paren.el but try the authors
;; favourite options:
;; (setq paren-face 'bold)
;; (setq paren-sexp-mode t)
;;
;; To list the possible customisation enter `C-h f paren-activate'
;;
;; Note: XEmacs has this pretty much built-in. Try this in Xemacs:
;; (load "paren")
;; (show-paren-mode t)
;; (setq paren-face 'bold)
;; (setq paren-sexp-mode t)
;; (setq paren-delay 5)
(if have-paren-face
(progn
(if window-system
(require 'mic-paren))
(setq paren-face 'bold)
(setq paren-sexp-mode t)))
;;=====================================================================
;; Redo: The redo/undo system is different from the built-in undo in
;; two ways:
;; 1. The undo/redo command chain is only broken by a buffer
;; modification. You can move around the buffer or switch buffers
;; and still come back and do more undos or redos.
;; 2. The `redo' command rescinds the most recent undo without
;; recording the change as a _new_ buffer change. It completely
;; reverses the effect of the undo, which includes making the
;; chain of buffer modification records shorter by one, to
;; counteract the effect of the undo command making the record
;; list longer by one.
;;
;; Note: if you're using XEmacs, rename the "redo.el.xemacs" file to
;; "redo.el" and use that one.
(if have-redo
(require 'redo))
;;=====================================================================
;; filladapt: Note that in this release Filladapt mode is a minor mode
;; and it is _off_ by default. If you want it to be on by default, use
;; (setq-default filladapt-mode t)
(if have-filladapt
(progn
(require 'filladapt)
(setq-default filladapt-mode t)
;(add-hook 'text-mode-hook 'turn-on-filladapt-mode)
))
;;=====================================================================
;; backup: Tell emacs where central backup directory is, and turn it on
;;
;; Note: XEmacs has this built-in. Just uncomment these lines.
;; (setq auto-save-directory (expand-file-name "~/autosave/")
;; auto-save-directory-fallback auto-save-directory)
(if have-backup
(progn
(setq backup-directory "~/backups")
(require 'backups)
(move-backups t)))
;;=====================================================================
;; folding: Folding mode handles a document as a tree, where each
;; branch is bounded by special markers `{{{' and `}}}'. A branch can
;; be placed inside another branch, creating a complete hierarchical
;; structure.
;;
;; Folding mode can CLOSE a fold, leaving only the initial `{{{' and
;; possibly a comment visible.
;;
;; It can also ENTER a fold, which means that only the current fold
;; will be visible, all text above `{{{' and below `}}}' will be
;; invisible.
;;
;; The best way to install folding is the autolaod installation, so
;; that folding is loaded into your emacs only when you turn on
;; `folding-mode'. This statement speeds up loading your .emacs
(if have-folding
(progn
; (setq folding-default-keys-function
; 'folding-bind-backward-compatible-keys)
(load "folding" 'nomessage 'noerror)
(folding-mode-add-find-file-hook)
(folding-add-to-marks-list 'jde-mode "// {{{ " "// }}}" nil t)))
;;=====================================================================
;; Whitespace: Nukes trailing whitespace from the ends of lines, and
;; deletes excess newlines from the ends of buffers, every time you
;; save.
;; Author: Noah Friedman <[EMAIL PROTECTED]>
(if have-whitespace
(progn
(autoload 'nuke-trailing-whitespace "whitespace" nil t)
(add-hook 'mail-send-hook 'nuke-trailing-whitespace)
(add-hook 'write-file-hooks 'nuke-trailing-whitespace)))
;;=====================================================================
;; Ishl: Highlight searchs.
;;
;; Alert! Ishl has been approved for inclusion in an upcoming release
;; of Emacs, under the name `isearch-lazy-highlight'.
;;
;; This is the general form for loading a package and having it turned
;; on.
(if have-ishl
(progn
(require 'ishl)
(ishl-mode 1)
))
; (ishl-mode)) ;This may be another way of
;turning it on.
; Keep the text highlighted until the next search.
; (setq-default ishl-cleanup nil)
;;;;;;;;;;;;;;;;;;;;;;;;;;; eol-conversion ;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Add Functions to convert between file formats (Unix, Dos, Mac) Add
;; an entry in the Edit Menu (End of line conversion). Warning: This
;; is a modified version of eol-conversion.el. The original was
;; putting an entry in the 'Mule' Menu, which is not allways visible.
;; The one included here puts it in the 'Edit' menu. Be carefull when
;; you get a new version of emacs, it might overwrite the modified
;; eol-conversion.el.
;;
;; Place file eol-conversion.el into c:/fsf/emacs/lisp and
;; byte-compile it.
;;
;; To byte-compile in emacs, use dired (C-x d), find and select the
;; file to compile and press B (capital b).
(if have-eol-conversion-modified
(require 'eol-conversion-modified))
;;=====================================================================
;; unscroll: This file uses "advice" to modify the scrolling commands
;; such that the screen appearance is preserved at the start of each
;; series of scrolls. Ever press C-v C-v C-v when you meant C-b C-b
;; C-b? That's what this is meant to remedy.
;;
;; After scrolling (intentionally or otherwise), you can restore the
;; display with M-x unscroll RET, which I like to bind to C-M-v using
;; (define-key global-map "\C-\M-v" 'unscroll).
(if have-unscroll
(require 'unscroll))
; ;; =====================================================================
; ;; JARI AALTO'S TINY LIBRARY
; ;; =====================================================================
; ;; Defines everything, publishes interface for tiny library. This
; ;; library has a LOT of useful things and is available at
; ;; ftp://cs.uta.fi/pub/ssjaaa/ema-tiny.html
; (require 'tinylibm)
; ;; search fwd or bkwd for word under cursor
; (autoload 'tisw-search-word-forward "tinysword" t t)
; (autoload 'tisw-search-word-backward "tinysword" t t)
; (global-set-key [f2] 'tisw-search-word-forward)
; (global-set-key [S-f2] 'tisw-search-word-backward)
;;ABBREVIATION SECTION
;; abbreviation mode
(setq-default abbrev-mode t)
(if (file-exists-p "~/.abbrev")
(read-abbrev-file "~/.abbrev"))
(setq save-abbrevs t)
;;dynamic abbreviation customizations
(setq dabbrev-case-replace nil)
;;=====================================================================
;; BEHAVIOUR
;; This makes Emacs keybindings a little bit more Windows like. You
;; still can't use C-c, C-v and C-x to copy, paste and delete the
;; selection (luckily. C-c and C-x are pretty important in Emacs), but
;; you can at least use C-INS, S-INS, and S-DEL to do it. Also, you can
;; mark the region using cursor keys and the shift key and other stuff,
;; such as binding [home], [end], [\C-home], [\C-end], [\C-backspace].
(pc-selection-mode)
;; The following function changes the way you switch buffers. You are
;; presented with a list of buffers that shrinks as you type the name,
;; only the matching buffers are shown, making buffer switching much
;; easier.
;(require 'iswitchb)
(iswitchb-default-keybindings)
;; When you scroll down with the cursor, emacs will move down the
;; buffer one line at a time, instead of in larger amounts.
(setq scroll-step 1)
;;make all yes/no prompts into y/n prompts
(fset 'yes-or-no-p 'y-or-n-p)
;; don't automatically add new lines when scrolling down at the bottom
;; of a buffer
(setq next-line-add-newlines nil)
;; Pgup/dn will return exactly to the starting point.
(setq scroll-preserve-screen-position 1)
;;be able to do Ctrl-X, u/l to upper/lowercase regions without confirm
(put 'downcase-region 'disabled nil)
(put 'upcase-region 'disabled nil)
;; Override the unfamiliar yank on button-2 with the more specific
;; context sensitive menu.
(define-key global-map [mouse-2] 'mouse-major-mode-menu)
;; Reorder the mouse buttons if there are only two buttons, as mouse-2
;; is bound to more useful things by default.
(if (equal w32-num-mouse-buttons 2)
(setq w32-swap-mouse-buttons t))
(defvar running-xemacs
(string-match "XEmacs\\|Lucid" emacs-version))
(cond ((and (not running-xemacs)
(>= emacs-major-version 19))
;; Checks to see if you're running xemacs
;; or GNU emacs. I usually use GNU emacs, but am set up to use both.
;; These tell emacs to associate certain filename extensions with
;; certain modes. I use cc-mode.el (c++-mode) for C as well as C++
;; code. It is fairly all-encompassing, also working with other
C-like
;; languages, such as Objective C and Java.
(setq auto-mode-alist (cons '("\\.text$" . text-mode)
auto-mode-alist))
; (setq auto-mode-alist (cons '("\\.txt$" . text-mode)
auto-mode-alist))
(setq auto-mode-alist (cons '("\\.doc$" . text-mode)
auto-mode-alist))
(setq auto-mode-alist (cons '("\\.awk$" . awk-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.perl$" . perl-mode)
auto-mode-alist))
(setq auto-mode-alist (cons '("\\.plx$" . perl-mode)
auto-mode-alist))
(setq auto-mode-alist (cons '("\\.pl$" . perl-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.C$" . c++-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.cc$" . c++-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.c$" . c++-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.h$" . c++-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.cpp$" . c++-mode) auto-mode-alist))
(setq auto-mode-alist (cons '("\\.cxx$" . c++-mode) auto-mode-alist))
; (setq auto-mode-alist (cons '("\\.tcl$" . tcl-mode)
auto-mode-alist))
(setq auto-mode-alist (cons (cons "\\.tk\\'" 'tcl-mode)
auto-mode-alist))
(setq auto-mode-alist (cons '("\\.sh$" . shell-script-mode)
auto-mode-alist))
(setq auto-mode-alist (cons '("\\.zsh$" . shell-script-mode)
auto-mode-alist))
(setq completion-ignored-extensions;; Filename completion ignores
these.
(append completion-ignored-extensions
'(".CKP" ".u" ".press" ".imp" ".BAK")))))
;; Shut off message buffer. Note - if you need to debug emacs,
;; comment these out so you can see what's going on.
;(setq message-log-max nil)
;(kill-buffer "*Messages*")
;; NEW
(setq default-major-mode 'text-mode)
;;=====================================================================
;; APPERANCE
;; If you want to have comments displayed in italics, uncomment the
;; following lines. Note that this must be done before font settings!
(setq w32-enable-italics t)
(make-face-italic 'font-lock-comment-face)
;; Favorite colours and icon/frame naming
(if window-system
(progn
(setq default-frame-alist
(append
'((top . 5) (left . 350)
(width . 78) (height . 31)
(background-color . "floral white")
(cursor-color . "grey")
(cursor-type . box)
(vertical-scroll-bars . 'right)
(horizontal-scroll-bars . nil)
(scroll-bar-width . 10))
default-frame-alist))
(set-face-background 'modeline "red")
(set-face-foreground 'modeline "yellow")
(set-face-background 'region "yellow")))
;; Show more info in taskbar/icon than just "Emacs"
;(setq-default frame-title-format (list "%55b %f"))
(setq-default
frame-title-format
(list '((buffer-file-name "%50b %f" (dired-directory
dired-directory
(revert-buffer-function " %b"
("%b - Dir: "
default-directory)))))))
(setq-default icon-title-format (list "%b"))
;; Make the minibuffer resize to fit all of its contents.
(resize-minibuffer-mode)
;; The space below the modeline is either the echo area (if messages
;; are displayed) or the minibuffer (if you ought to type something
;; after a prompt). The minibuffer can grow if you need more than one
;; line for prompt and answer. Very usefull. This little function
;; allows the minibuffer to grow when required.
;; Make minibuffer larger if there is more to see
(resize-minibuffer-mode 1)
;; Use lazy lock for syntax coloring, otherwise large files will not
;; be colored. Also allows large files to load faster. Thanks Andrew
;; Innes
; (setq font-lock-support-mode 'lazy-lock-mode)
; (setq lazy-lock-defer-on-scrolling nil)
; (setq lazy-lock-defer-time 1)
; (setq lazy-lock-stealth-time 20)
; (setq lazy-lock-stealth-lines 25)
; (setq lazy-lock-stealth-verbose nil)
; (require 'font-lock)
; (require 'lazy-lock)
;;syntax hilite
(global-font-lock-mode 1)
(setq font-lock-maximum-decoration t)
(custom-set-faces)
;; Toggle Which Function mode, globally.
;; When Which Function mode is enabled, the current function name is
;; continuously displayed in the mode line, in certain major modes.
;;
;; which-func-mode ( From gnu emacs FAQ ) If you set
;; which-func-mode-global via customize, which-func-mode will not turn
;; on automatically. You need to add the following to your startup
;; file BEFORE the call to custom-set-variables:
(which-func-mode 1)
;; Custom Variables.
(custom-set-variables
'(inhibit-startup-message t)
'(which-func-mode-global t nil (which-func))
'(tab-width 4)
'(jde-bug-jdk-directory "c:/jdk1.3/")
'(jde-db-source-directories (quote ("c:/Dokumentumok/dani/my-java")))
'(jde-db-debugger (quote ("JDEbug" "jdb" . "Executable")))
'(jde-enable-abbrev-mode t)
'(tempo-interactive t t)
'(jde-bug-vm-includes-jpda-p t)
'(line-number-display-limit 35000000))
;; Stop ^M's from displaying in system shell window
(add-hook 'comint-output-filter-functions 'shell-strip-ctrl-m nil t)
;; This prevents shell commands from being echoed
(defun my-comint-init ()
(setq comint-process-echoes t))
(add-hook 'comint-mode-hook 'my-comint-init)
(setq speedbar-frame-parameters (quote
((minibuffer)
(width . 24)
(border-width . 0)
(menu-bar-lines . 0)
(unsplittable . t))))
(setq window-min-height 3)
;;=====================================================================
;; MY ASSORTED LITTLE FUNCTIONS
(require 'my-funcs)
;;=====================================================================
;; MODES
;; DIRED MODE
(add-hook 'dired-mode-hook
'(lambda()
(define-key dired-mode-map [delete] 'dired-flag-file-deletion)
; (define-key dired-mode-map [return] 'dired-find-file-other-window)
(define-key dired-mode-map [C-down-mouse-1]
'dired-mouse-find-file-other-window)
(local-set-key [f5] 'revert-buffer)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; C/C++ Mode. The Superclass of the Java (and JDE) Mode.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun my-c-mode-hook ()
(sep-line-setup "/" "*" "/")
(local-set-key "\C-c\C-c" 'compile)
(local-set-key "\M-f" 'c-forward-into-nomenclature)
(local-set-key "\M-b" 'c-backward-into-nomenclature)
;;set up the tab stop list so I can do manual Ctrl-I tabs to specific
points
(setq tab-stop-list (create-tab-list 60))
(setq indent-tabs-mode t)
(setq tab-width (get-my-tab-length))
(setq c-basic-offset (get-my-tab-length))
(setq standard-indent (get-my-tab-length))
(setq c-style-variables-are-local-p nil)
;;don't give me newline automatically after electric expressions are
entered
(setq c-auto-newline nil)
;;if (0) becomes if (0)
;; { {
;; ; ;
;; } }
(c-set-offset 'substatement-open 0)
;;first arg of arglist to functions: tabbed in once
;;(default was c-lineup-arglist-intro-after-paren)
(c-set-offset 'arglist-intro '+)
;;second line of arglist to functions: tabbed in once
;;(default was c-lineup-arglist)
(c-set-offset 'arglist-cont-nonempty '+)
;;switch/case: make each case line indent from switch
(c-set-offset 'case-label '+)
;;make the ENTER key indent next line properly
(local-set-key "\C-m" 'newline-and-indent)
;;syntax-highlight aggressively
(setq font-lock-support-mode 'lazy-lock-mode)
(setq lazy-lock-defer-contextually t)
(setq lazy-lock-defer-time 0)
;;make DEL take all previous whitespace with it
(c-toggle-hungry-state 1)
;;make open-braces after a case: statement indent to 0 (default was '+)
(c-set-offset 'statement-case-open 0)
;;make a #define be left-aligned
(setq c-electric-pound-behavior (quote (alignleft)))
;;do not impose restriction that all lines not top-level be indented at
least
;;1 (was imposed by gnu style by default)
(setq c-label-minimum-indentation 0)
)
(add-hook 'c++-mode-hook 'my-c-mode-hook)
(add-hook 'c-mode-hook 'my-c-mode-hook)
;;WINDOWS section
(if (or (eq system-type 'windows-nt)
(eq system-type 'ms-dos))
;;progn is like (begin e1 e2 ...) on scheme. i.e. execute one or more
;;statements in sequential order
(progn
;;get around inadequacies of WIN9x/NT's window manager, which
;;always places new application windows in the same place in
;;some cases. I want random placement of new windows so I can
;;Alt-TAB easier, and know where I'm going. The following code
;;places the top left corner of the initial frame at a random
;;horizontal location on screen and a fixed vertical location.
(setq initial-frame-alist
`((top . 0)
;;Parse out milliseconds field, and scale it down.
;;The current-time function is random enough for purposes here.
(left . ,(/ (car (cdr (cdr (current-time)))) 8000))))
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; JDE Mode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; (defun jde-execute* ()
; "Compile and run the code."
; (interactive)
; (if (buffer-modified-p)
; jde-compile)
; (jde-run))
(defun my-jde-mode-hook ()
(turn-on-auto-fill)
(sep-line-setup "/" "*" "/")
(local-set-key "\C-c\C-c" 'jde-compile)
(local-set-key "\C-c\C-r" 'jde-run)
(local-set-key "\C-c\C-1" 'jde-execute)
; (local-set-key "\C-c\C-c" 'compile-and-run*)
; The key to getting non-space indentation (i.e., tabs) is to set
; c-indent-level and tab-width to the same size.
(setq c-basic-offset 4)
(setq c-indent-level 4)
; (setq tab-width 4))
;;;;;;;;;;;;;;;;;;;;;;;;; My Compile-and-Run ;;;;;;;;;;;;;;;;;;;;;;;;;
; (defun compile-and-run* ()
; "If buffer is modified compile and run, else just run the code."
; (interactive)
; ; (let ((buf (current-buffer)))
; ; (setq is-compile-and-run t)
; (if (buffer-modified-p)
; (jde-compile) ;then
; (jde-run))) ;else
; ;; To be used as a hook at the end of a java compilation
; (defun end-of-java-compile (bufname msg)
; "To be used as a hook at the end of a java compilation"
; (if (not (eq (string-match "finished" msg) nil))
; (progn
; (other-window 1 t)
; (other-window 1 t) ;Switch back to java buffer.
; (jde-run))))
; ;; Set function to be called at end of java compilation
; (setq jde-compile-finish-hook 'end-of-java-compile)
;;;;;;;;;;;;;;;;;;;;;;; End of Compile-and-Run ;;;;;;;;;;;;;;;;;;;;;;;
)
(add-hook 'jde-mode-hook 'my-jde-mode-hook)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Tcl mode.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq tcl-mode-hook
'(lambda ()
; (setq tcl-indent-level 2)
(sep-line-setup "" "#" "")
(define-key tcl-mode-map "\C-c\C-h" 'insert-heading-comment)
; (define-key tcl-mode-map "\C-c\C-;" 'comment-region)
; (font-lock-mode 1)
; (set-face-foreground font-lock-comment-face "blue")
; (set-face-foreground font-lock-keyword-face "black")
; (set-face-foreground font-lock-builtin-face "black")
; (set-face-underline-p font-lock-string-face nil)
; (set-face-foreground font-lock-string-face "black")
(setq font-lock-keywords '(
("#.*" . font-lock-comment-face)
))
))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; HTML Mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; (setq html-mode-hook
; '(lambda ()
; (define-key html-mode-map "\C-j"
; '(lambda () (interactive) (insert "<BR>\n")))
; (define-key html-mode-map "\C-c\C-h"
; '(lambda () (interactive) (wrap-line-in-tags "<H1>" "</H1>")))
; (define-key html-mode-map "\C-c\C-j"
; '(lambda () (interactive) (wrap-line-in-tags "<H2>" "</H2>")))
; (define-key html-mode-map "\C-c\C-v"
; '(lambda () (interactive) (wrap-region-in-tags
; (region-beginning) (region-end)
; "<BLOCKQUOTE><PRE>\n" "</PRE></BLOCKQUOTE>")))
; (auto-fill-mode 1)
; ))
; (defun wrap-line-in-tags (pretag posttag)
; (interactive)
; (wrap-region-in-tags (save-excursion (beginning-of-line) (point))
; (save-excursion (end-of-line) (point))
; pretag
; posttag))
; (defun wrap-region-in-tags (beg end pretag posttag)
; (save-excursion
; (setq endm (make-marker))
; (set-marker endm end)
; (goto-char beg)
; (insert pretag)
; (goto-char endm)
; (insert posttag)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; HTML-Helper Mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Stop ^M's from displaying in system shell window
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Text Mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun my-text-mode-hook ()
(turn-on-auto-fill)
(setq fill-column 75)
(abbrev-mode 1)
;(setq indent-line-function 'text-indent-line)
(define-key text-mode-map "\t"
'(lambda () (interactive) (insert-tab)))
(sep-line-setup "" "-" "")
)
(add-hook 'text-mode-hook 'my-text-mode-hook)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Emacs-Lisp Mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun my-emacs-lisp-mode-hook ()
(turn-on-auto-fill)
(sep-line-setup "" ";" ""))
(add-hook 'emacs-lisp-mode-hook 'my-emacs-lisp-mode-hook)
;; PYTHON
;; If the function python-mode is called, Emacs will load the file
;; python-mode.elc or python-mode.el in your load-path.
;;
;; The variable auto-mode-alist associates filename patterns with
;; functions to call. The entry we are adding lets Emacs call the
;; function python-mode whenever a file ending in .py is edited.
;;
;; The variable interpreter-mode-alist associates interpreters with
;; functions to call. The interpreter is guessed from the first line of
;; a file if it starts with #!. The entry we are adding lets Emacs call
;; the function python-mode whenever a file for the python interpreter
;; is edited.
;;
;; (autoload 'python-mode "python-mode" "Python editing mode." t)
;; (add-to-list 'auto-mode-alist '("\\.py$" . python-mode))
;; (add-to-list 'interpreter-mode-alist '("python" . python-mode))
; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;;; Minibuffer
; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; (defun my-minibuffer-setup-hook ()
; (local-set-key [tab] 'forward-char))
; (add-hook 'minibuffer-setup-hook 'my-minibuffer-setup-hook)
;;LOCAL HOOKS SECTION - note this section should be last to allow an
;;.emacs_local file to override the .emacs. The .emacs_local file should
;;contain anything specific to a particular environment/platform/machine.
(if (file-exists-p "~/.emacs_local")
(load-file "~/.emacs_local"))
;;=====================================================================
;;KEYBOARD SECTION
;;Function keys
(global-set-key [f1] 'help)
(global-set-key [S-f1] 'man)
(global-set-key [f3] 'find-file)
(global-set-key [f4] 'speedbar-get-focus) ;Speedbar URL is
http://www.ultranet.com/~zappo/speedbar.shtml
;(global-set-key [\C-f4] 'kill-current-buffer) ;kill-current-buffer is
defined.
(global-set-key [\C-f4] 'save-buffer-kill-buffer)
(global-set-key [f5] 'compile)
;; C-c bindings.
(global-set-key "\C-c;" 'comment-region) ;have to force it for some reason
(global-set-key (kbd "C-c a") 'auto-fill-mode)
(global-set-key [\S-tab] 'dabbrev-expand) ;dynamic expansion. S-TAB cycles
through words in buffer starting with the same fragment.
;; Control (other than C-c), Meta, Shift keys
(global-set-key "\C-z" 'undo)
(global-set-key "\C-q" 'redo) ;Requires redo.el
(global-set-key [?\C-/] 'void)
(global-set-key "\C-s" 'isearch-forward-regexp)
(global-set-key [\C-delete] 'kill-word)
(global-set-key "\C-\M-s" 'tags-search)
(define-key global-map "\C-\M-v" 'unscroll) ;Requires unscroll.el
(global-set-key "\C-x\C-n" 'find-file-other-frame) ;open new frame with a
file
(global-set-key "\C-xk" 'kill-current-buffer) ;kill current buffer without
confirmation.
(global-set-key "\C-x\C-c" 'intelligent-close)
(global-set-key (kbd "C-c o") 'occur) ;List lines matching regexp.
(global-set-key "\C-x55" 'split-window-fork)
(global-set-key "\M-g" 'goto-line)
(global-set-key "\M-s" 'shell)
(global-set-key "\M-n" 'scroll-n-lines-ahead)
(global-set-key "\M-p" 'scroll-n-lines-behind)
(global-set-key "\M-u" 'void) ;don't bind upcase word
(global-set-key "\M-l" 'void) ;don't bind downcase word
(global-set-key "\M-:" 'insert-heading-comment) ;Think of it as
Meta-shift-;. Separator-line is a defined function.
(global-set-key [\M-backspace] 'backward-kill-word) ;Remap this.
(pc-selection-mode maps this to "undo").
(global-set-key [(meta f4)] 'intelligent-close) ;forward reference
;;Misc.
(global-set-key "%" 'match-paren) ; Make the % key jump to the matching
{}[]() if on another, like in VI. match-paren is a defined function.
;(global-set-key [escape] 'keyboard-quit) ; Same as C-g.
;; TAKE THIS OUT AFTER CHANGES TO ISHL. HERE THE CLARIFICATIONS FROM
;; ISHL's AUTHOR:
; Ishl uses a facility of Emacs Lisp called "advice," which is where
; extra functionality can be attached to pre-existing Emacs functions.
; For performance reasons, it's sometimes desirable for the extra
; functionality to be "compiled" when it's attached.
;
; The process of compiling the extra functionality can cause the
; *Compile-Log* buffer to come into existence.
;
; If you look through ishl.el for the word "compile," you'll find this
; line:
;
; (defadvice isearch-update (after ishl-start-loop compile)
;
; If you prefer, you can remove the word "compile," changing the line to
; this:
;
; (defadvice isearch-update (after ishl-start-loop)
;
; Doing so may have a small effect on performance, or it may not even be
; noticeable.
;
; Note that having an empty buffer named *Compile-Log* lying around in
; your Emacs is totally harmless.
(kill-buffer "*Compile-Log*")
;;=====================================================================
; Desktop works to save your current emacs session -- your buffers,
; positions within them, etc, and to reload your old emacs session
; when you start emacs up again. The first time you want to do this,
; you also need to do "M-x desktop-save".
;
; The reason that I have this down here towards the end of the file is
; that all the nice font-locking stuff is otherwise ignored -- you'd
; need to do "M-x font-lock-mode" by hand, for each buffer, every
; time. That's no good.
;
; Note: I think XEmacs does this automatically. Emacs has this
; package, but the following lines are necessary to activate it.
(load "desktop")
(desktop-load-default)
(desktop-read)
(message "Loading Daniel's .emacs file... Done.")
; ;;; load the JDE
; ;;(setq load-path
; ;; (nconc '( "C:/emacssite/jde-2.1.5" ) load-path)
; ;;)
; (setq load-path
; (nconc '( "C:/emacssite/jde-2.1.6beta21/lisp" ) load-path)
; )
; (require 'jde)
; ;;; load JPack, JDok, JDE CFlow, JSee
; (setq load-path
; (nconc '( "C:/emacssite" ) load-path)
; )
; (require 'jpack)
; (require 'jdok)
; (require 'jsee)
; (load "C:/emacssite/jde-cflow.el")
; (cond ((fboundp 'global-font-lock-mode)
; (require 'extra-java-font-lock)
; (setq font-lock-maximum-decoration t)
; (global-font-lock-mode t)
; ))
;; =====================================================================
;; =====================================================================
;; USEFUL NOTES AND OTHER STUFF
;; =====================================================================
;; How to record and display a keyboard macro
;;
;; Just open a buffer and type C-x ( Then start typing in your macro.
;; Once you are finished defining your macro type C-x ) Then type M-x
;; name-last-kbd-macro. This will allow you to call your macro
;; whatever you want. Next open up your .emacs file and position your
;; cursor where you want the code for the macro to appear. Type M-x
;; insert-kbd-macro and type in the name. The code will automatically
;; be generated.
; There is M-x enriched-mode RET which allows you to use italic and
; underline and bold and suchlike. And store these attributes in a
; file!
; Q: Is it possible to relate two or more actions with global-set-key
;instead of only one action?
;
; A: Record a macro which combines the actions. Then name the macro
; ("name-last-kbd-macro"). Then save the macro in your .emacs file
; ("insert-kbd-macro") Then assign the key to that macro.
; In the project I'm working on the package name in a java file is often
; wrong (don't ask why!) so I wrote a little function to check the
; package name and fix it if it is wrong. I've added this to my
; jde-mode-hooks and it seems to work fine. I'm posting it to share and
; to solicit comments. Two "problems" with it are:
;
; 1. When I visit a file using tags the message is lost amongst other
; minibuffer verbage.
;
; 2. My domain name is hardwired in. I realize I can make this a
; defconst/defvar, but is there something better?
;
; 3. I'm not an elisp wizard, improvements welcome.
;
;
; ;; Check the package of the current buffer. If it is wrong update it.
; (defun check-java-package ()
; (interactive)
; (save-excursion
; (let* ((used-package (jde-parse-get-package-name))
; (cwd (file-name-directory (buffer-file-name)))
; (dots (substring (subst-char-in-string ?/ ?. cwd) 0 -1))
; (tail (second (split-string dots "com.cimsoft")))
; (actual-package (concat "com.cimsoft" tail)))
; (beginning-of-buffer)
; (if (and (not (string-equal used-package actual-package))
; (re-search-forward "package[ \t]+\\(.*\\)[ \t]*;" nil t))
; (progn
; (replace-match actual-package t nil nil 1)
; (message "Warning: Package name updated."))))))
;
; (add-hook 'jde-mode-hook '(check-java-package))
; `<TAB>'
; Complete the text in the minibuffer as much as possible
; (`minibuffer-complete').
; the hook `suspend-hook' runs just before Emacs suspends itself
;; =====================================================================
;; =====================================================================
;;; .emacs ends here
=====end inserted .emacs file
________________________________________________________________________
Get Your Private, Free E-mail from MSN Hotmail at http://www.hotmail.com
