2 @setfilename ../../info/ede
3 @settitle Emacs Development Environment
6 This file describes EDE, the Emacs Development Environment.
8 Copyright @copyright{} 1998--2001, 2004--2005, 2008--2012
9 Free Software Foundation, Inc.
12 Permission is granted to copy, distribute and/or modify this document
13 under the terms of the GNU Free Documentation License, Version 1.3 or
14 any later version published by the Free Software Foundation; with no
15 Invariant Sections, with the Front-Cover texts being ``A GNU Manual,''
16 and with the Back-Cover Texts as in (a) below. A copy of the license
17 is included in the section entitled ``GNU Free Documentation License.''
19 (a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
20 modify this GNU manual.''
24 @dircategory Emacs misc features
26 * EDE: (ede). The Emacs Development Environment.
30 @center @titlefont{EDE (The Emacs Development Environment)}
32 @center by Eric Ludlam
66 @node top, EDE Project Concepts, (dir), (dir)
68 @comment node-name, next, previous, up
70 @ede{} is the Emacs Development Environment: an Emacs extension that
71 simplifies building and debugging programs in Emacs. It attempts to
72 emulate a typical IDE (Integrated Development Environment). @ede{}
73 can manage or create your makefiles and other building environment
74 duties, allowing you to concentrate on writing code rather than
75 support files. It aims to make it much easier for new programmers to
76 learn and adopt GNU ways of doing things.
83 * EDE Project Concepts:: @ede{} Project Concepts
84 * EDE Mode:: Turning on @ede{} mode.
85 * Quick Start:: Quick start to building a project.
86 * Creating a project:: Creating a project.
87 * Modifying your project:: Adding and removing files and targets.
88 * Building and Debugging:: Initiating a build or debug session.
89 * Miscellaneous commands:: Other project related commands.
90 * Extending EDE:: Programming and extending @ede{}.
91 * GNU Free Documentation License:: The license for this documentation.
94 @node EDE Project Concepts, EDE Mode, top, top
95 @chapter @ede{} Project Concepts
97 @ede{} is a generic interface for managing projects. It specifies a
98 single set of menus and keybindings, while supporting multiple ways to
99 express a project via a build system.
101 In the subsequent chapters, we will describe the different project
102 types (@pxref{Creating a project}), as well as the commands to build
103 and debug projects (@pxref{Building and Debugging}).
105 In @ede{}, a project hierarchy matches a directory hierarchy. The
106 project's topmost directory is called the @dfn{project root}, and its
107 subdirectories are @dfn{subprojects}.
109 Each project can contain multiple @dfn{targets}. A target, at the
110 simplest level, is a named collection of files within a project. A
111 target can specify two different types of information:
115 A collection of files to be added to a distribution (e.g., a tarball
116 that you intend to distribute to others).
119 A collection of files that can be built into something else (e.g., a
120 program or compiled documentation).
123 Lastly, @ede{} provides a way for other tools to easily learn file
124 associations. For example, a program might need to restrict some sort
125 of search to files in a single target, or to discover the location of
126 documentation or interface files. @ede{} can provide this
129 @node EDE Mode, Quick Start, EDE Project Concepts, top
132 @ede{} is implemented as a minor mode, which augments other modes such
133 as C mode, and Texinfo mode. You can enable @ede{} for all buffers by
134 running the command @code{global-ede-mode}, or by putting this in your
141 Activating @ede{} adds a menu named @samp{Development} to the menu
142 bar. This menu provides several menu items for high-level @ede{}
143 commands. These menu items, and their corresponding keybindings, are
144 independent of the type of project you are actually working on.
146 @node Quick Start, Creating a project, EDE Mode, top
149 Once you have @ede{} enabled, you can create a project. This chapter
150 provides an example C++ project that will create Automake files for
153 @section Step 1: Create root directory
155 First, lets create a directory for our project. For this example,
156 we'll start with something in @file{/tmp}.
159 C-x C-f /tmp/myproject/README RET
160 M-x make-directory RET RET
163 Now put some plain text in your README file to start.
165 Now, lets create the project:
168 M-x ede-new RET Automake RET myproject RET
172 Nothing visible happened, but if you use @code{dired} to look at the
173 directory, you should see this:
177 total used in directory 32 available 166643476
178 drwxr-xr-x 2 zappo users 4096 2012-02-23 22:10 .
179 drwxrwxrwt 73 root root 20480 2012-02-23 22:10 ..
180 -rw-r--r-- 1 zappo users 195 2012-02-23 22:10 Project.ede
181 -rw-r--r-- 1 zappo users 10 2012-02-23 22:09 README
184 @section Step 2: Create Subdirectories and Files
186 We'll make a more complex project, so use dired to create some more
187 directories using the @kbd{+} key, and typing in new directories:
194 Now I'll short-cut in this tutorial. Create the following files:
196 @file{include/myproj.hh}
204 #define IMPORTANT_MACRO 1
206 int my_lib_function();
224 #ifdef IMPORTANT_MACRO
235 * Shared Library to build
238 int my_lib_function() @{
243 @section Step 3: Create subprojects
245 @ede{} needs subdirectories to also have projects in them. You can
246 now create those projects.
248 With @file{main.cpp} as your current buffer, type:
251 M-x ede-new RET Automake RET src RET
254 and in @file{myproj.hh} as your current buffer, type:
257 M-x ede-new RET Automake RET include RET
260 These steps effectively only create the Project.ede file in which you
261 will start adding targets.
263 @section Step 4: Create targets
265 In order to build a program, you must have targets in your @ede{}
266 Projects. You can create targets either from a buffer, or from a
267 @code{dired} directory buffer.
269 Note: If for some reason a directory list buffer, or file does not have the
270 @samp{Project} menu item, or if @ede{} keybindings don't work, just
271 use @kbd{M-x revert-buffer RET} to force a refresh. Sometimes
272 creating a new project doesn't restart buffers correctly.
274 Lets start with the header file. In @file{include/myproj.hh}, you
275 could use the menu, but we will now start using the @ede{} command prefix
276 which is @kbd{C-c .}.
279 C-c . t includes RET miscellaneous RET y
283 This creates a misc target for holding your includes, and then adds
284 myproj.hh to the target. Automake (the tool) has better ways to do
285 this, but for this project, it is sufficient.
287 Next, visit the @file{src} directory using dired. There should be a
288 @samp{Project} menu. You can create a new target with
291 . t myprogram RET program RET
294 Note that @kbd{. t} is a command for creating a target. This command
295 is also in the menu. This will create a target that will build a
296 program. If you want, visit @file{Project.ede} to see the structure
299 Next, place the cursor on @file{main.cpp}, and use @kbd{. a} to add
300 that file to your target.
306 Note that these prompts often have completion, so you can just press
307 @kbd{TAB} to complete the name @file{myprogram}.
309 If you had many files to add to the same target, you could mark them
310 all in your dired buffer, and add them all at the same time.
312 Next, do the same for the library by placing the cursor on @file{mylib.cpp}.
315 . t mylib RET sharedobject RET
319 @section Step 5: Compile, and fail
321 Next, we'll try to compile the project, but we aren't done yet, so it
322 won't work right away.
324 Visit @file{/tmp/myproject/Project.ede}. We're starting here because
325 we don't have any program files in this directory yet. Now we can use
332 Because this is the very first time, it will create a bunch of files
333 for you that are required by Automake. It will then use automake to
334 build the support infrastructure it needs. This step is skipped if
335 you choose just a @file{Makefile} build system.
337 After the Automake init, it runs compile. You will immediately
338 discover the error in main.cpp can't find @file{myproj.hh}. We need
341 @section Step 6: Customizing your project
343 To fix the failed compile, we need to add
344 @file{/tmp/myproject/include} to the include path.
346 Visit @file{main.cpp}.
349 M-x customize-project RET
352 Select the @samp{[Settings]} subgroup of options. Under
353 @samp{Variable :} click @samp{[INS]}. At this point, you need to be
354 somewhat savvy with Automake. Add a variable named @samp{CPPFLAGS},
355 and set the value to @samp{../include}.
357 You should see something like this:
361 [INS] [DEL] Cons-cell:
365 Variables to set in this Makefile.
368 Click @samp{[Apply]}. Feel free to visit @file{Project.ede} to see
369 how it changed the config file.
371 Compile the whole project again with @kbd{C-c . C} from
372 @file{main.cpp}. It should now compile.
374 @section Step 7: Shared library dependency
376 Note: Supporting shared libraries for Automake in this way is easy,
377 but doing so from a project of type Makefile is a bit tricky. If you
378 are creating shared libraries too, stick to Automake projects.
380 Next, lets add a dependency from @file{main.cpp} on our shared
381 library. To do that, update main like this:
397 where the lower case @kbd{c} compiles just that target. You should
400 This time, we need to add a dependency from @file{main.cpp} on our shared
401 library. To do that, we need to customize our target instead of the
402 project. This is because variables such as the include path are
403 treated globally, whereas dependencies for a target are target specific.
406 M-x customize-target RET
409 On the first page, you will see an Ldlibs-local section. Add mylib to
410 it by first clicking @samp{[INS]}, and they adding the library. It
411 should look like this:
415 [INS] [DEL] Local Library: libmylib.la
417 Libraries that are part of this project. [Hide Rest]
418 The full path to these libraries should be specified, such as:
419 ../lib/libMylib.la or ../ar/myArchive.a
422 You will also see other variables for library related flags and system
423 libraries if you need them. Click @samp{[Accept]}, and from
424 @file{main.cpp}, again compile the whole project to force all
425 dependent elements to compile:
431 @section Step 8: Run your program
433 You can run your program directly from @ede{}.
439 If your program takes command line arguments, you can type them in
440 when it offers the command line you want to use to run your program.
442 @node Creating a project, Modifying your project, Quick Start, top
443 @chapter Creating a project
445 To create a new project, first visit a file that you want to include
446 in that project. If you have a hierarchy of directories, first visit
447 a file in the topmost directory. From this buffer, type @kbd{M-x
448 ede-new}, or click on the @samp{Create Project} item in the
449 @samp{Development} menu.
451 The @command{ede-new} command prompts for the type of project you
452 would like to create. Each project type has its own benefits or
453 language specific enhancements. @ede{} supports four different
454 project types: @samp{Make}, @samp{Automake}, @samp{direct Automake},
459 For the @samp{Make} project type, @ede{} creates a @dfn{project file},
460 called @file{Project.ede}, in each project directory. Information
461 about the project is stored in this file. This project autogenerates
465 For the @samp{Automake} project type, @ede{} creates a
466 @file{Project.ede} project file similar to a @samp{Make} project.
467 Unlike a @samp{Make} project, this project autogenerates a
468 @file{Makefile.am} file. @ede{} handles the Automake bootstrapping
469 routines, which import and maintain a @file{configure.am} script and
470 other required files.
473 For the @samp{direct Automake} project type, @ede{} reads directly
474 from the Automake files.
476 You cannot create direct Automake projects with the @command{ede-new}
477 command. Instead, when you visit a project with existing Automake
478 files, @ede{} automatically detects them.
481 The @samp{Simple} project type provides light-weight constructs for
482 identifying a project root and looking up files. If you already have
483 a non-@ede{} project infrastructure, you can use a @samp{Simple}
484 project to provide other Emacs packages, such as Semantic, with some
485 information about the project. @xref{Simple projects}.
488 A subproject is merely a project in a subdirectory of another project.
489 You can create a subproject by using the @command{ede-new} command (or
490 the @samp{Create Project} menu item), while visiting a buffer in a
491 subdirectory of the project root. This new project is automatically
492 added to the parent project, and will be automatically loaded when
493 @ede{} reads the parent project.
495 When using a project command that involves a makefile, @ede{} uses
496 the top-most project's makefile as a starting place for the build. How
497 the toplevel project handles subprojects in the build process is
498 dependent on that project's type.
500 @node Modifying your project, Building and Debugging, Creating a project, top
501 @chapter Modifying your project
503 In this chapter, we describe the generic features for manipulating
504 projects, including the targets and files within them. Subsequent
505 chapters, which describe specific project types, will provide more
506 detailed information about exactly what these features do.
509 * Add/Remove target::
511 * Customize Features::
512 * Project Local Variables::
513 * EDE Project Features::
516 @node Add/Remove target, Add/Remove files, Modifying your project, Modifying your project
517 @section Add/Remove target
519 To create a new target, type @kbd{C-c . t} (@code{ede-new-target}) or
520 use the @samp{Add Target} menu item in the @samp{Project Options}
521 submenu. This prompts for a target name, and adds the current buffer
524 The @command{ede-new-target} command also prompts for a @dfn{target
525 type}. Each target type has its own build process and class of files
528 To remove a target from the project, type @kbd{M-x ede-delete-target},
529 or use the @samp{Remove Target} menu item in the @samp{Project
532 @node Add/Remove files, Customize Features, Add/Remove target, Modifying your project
533 @section Add/Remove files
535 To add the current file to an existing target, type @kbd{C-c . a}
536 (@code{ede-add-file}), or use the @samp{Add File} menu item in the
537 @samp{Target Options} submenu.
539 You can add a file to more than one target; this is OK.
541 To remove the current file from a target, type @kbd{C-c . d}
542 (@code{ede-remove-file}), or use the @samp{Remove File} menu item
543 in the @samp{Target Options} submenu. If the file belongs to multiple
544 targets, this command prompts for each target it could be removed
547 While working in a project, if you visit a file that is not part of an
548 existing target, @ede{} automatically prompts for a target. If you do
549 not wish to add the file to any target, you can choose @samp{none}.
550 You can customize this behavior with the variable
551 @command{ede-auto-add-method}.
553 @node Customize Features, Project Local Variables, Add/Remove files, Modifying your project
554 @section Customize Features
556 A project, and its targets, are objects using the @samp{EIEIO} object
557 system. @xref{Top,,,eieio,EIEIO manual}. These objects have data
558 fields containing important information related to your work.
560 If the high-level functions aren't enough, you can tweak all
561 user-customizable fields at any time by running the command
562 @command{customize-project} or @command{customize-target}. This loads
563 the current project or target into a customization buffer, where you
564 can tweak individual slots. This is usually necessary for complex
567 Some project modes do not have a project file, but directly read a
568 Makefile or other existing file. Instead of directly editing the
569 object, you can edit the file by typing @kbd{C-c . e}
570 (@code{ede-edit-file-target}). You should ``rescan'' the project
571 afterwards (@pxref{Miscellaneous commands}).
573 @node Project Local Variables, EDE Project Features, Customize Features, Modifying your project
574 @section Project Local Variables
576 EDE projects can store and manager project local variables. The
577 variables are stored in the project, and will be restored when a
580 Projects which are not stored on disk WILL NOT restore your project
581 local variables later.
583 You can use @ref{Customize Features} to of the project to edit the
584 project local variables. They are under the 'Settings' group as
585 ``Project Local Variables''.
587 You can also use @kbd{M-x ede-set} to set a new variable local in the
590 In multi-level projects such as Automake and Make generating projects,
591 project local variables are installed from both the TOP most project,
592 and the local directory's project. In that way, you can have some
593 variables across your whole project, and some specific to a
596 You can use project local variables to set any Emacs variable so that
597 buffers belonging to different projects can have different settings.
599 NOTE: When you use project-local variables with @ref{ede-cpp-root},
600 the format is an association list. For example:
603 (ede-cpp-root-project "SOMENAME"
604 :file "/dir/to/some/file"
606 '((grep-command . "grep -nHi -e ")
607 (compile-command . "make -f MyCustomMakefile all")))
610 The same is true when you use project-local variables with
611 @ref{ede-java-root}. For example:
614 (ede-java-root-project "SOMENAME"
615 :file "/dir/to/some/file"
617 '((grep-command . "grep -nHi -e ")
618 (compile-command . "ant")))
621 @node EDE Project Features, , Project Local Variables, Modifying your project
622 @section EDE Project Features
624 This section details user facing features of an @ede{} @samp{Make}
625 style project. An @samp{Automake} project has similar options (but a
626 direct Automake project does not).
628 To modify any of the specific features mentioned here, you need to
629 customize the project or target with @command{customize-project} or
630 @command{customize-target}.
632 When you are customizing, you are directly manipulating slot values in
633 @eieio{} objects. @xref{Extending EDE}, if you are interested in
637 * Changing Compilers and Flags::
641 @node Changing Compilers and Flags, Configurations, EDE Project Features, EDE Project Features
642 @subsection Changing Compilers and Flags
644 Targets that build stuff need compilers. To change compilers, you
645 need to customize the desired target.
647 In the @samp{[Make]} section, you can choose a new compiler or linker
648 from the list. If a linker you need is not available, you will need
649 to create a new one. @xref{Compiler and Linker objects}.
651 If an existing compiler or linker is close, but you need to modify
652 some flag set such as adding an include path you will need to add a
653 configuration variable.
655 To start, you should create the basic setup, and construct a makefile
656 with @command{ede-proj-regenerate}. Look in the @file{Makefile} to
657 see what commands are inserted. Once you have determined the variable
658 you need to modify, you can add a configuration for it.
659 @xref{Configurations}.
661 @node Configurations, , Changing Compilers and Flags, EDE Project Features
662 @subsection Configurations
664 Configurations specify different ways to build a project. For
665 example, you may configure a project to be in ``debug'' mode, or
666 perhaps in ``release'' mode.
668 The project, and each target type all have a slot named
669 @code{configuration-variables}. To add new variables to a
670 configuration find this slot in the custom buffer, and insert a new
671 configuration. Name it either ``debug'' or ``release'', then insert
672 some number of name/value pairs to it.
674 You can have any number of valid configurations too. To add a new
675 configuration, customize your project. Work in the @samp{[Settings]}
676 block for ``configurations''. Add a new named configuration here.
678 To switch between different active configurations, modify the
679 ``configuration default'' slot.
681 @node Building and Debugging, Miscellaneous commands, Modifying your project, top
682 @chapter Building and Debugging
684 @ede{} provides the following ``project-aware'' compilation and
689 Compile the current target (@code{ede-compile-target}).
691 Compile the entire project (@code{ede-compile-project}).
693 Debug the current target (@code{ede-debug-target}).
694 @item M-x ede-make-dist
695 Build a distribution file for your project.
698 These commands are also available from the @samp{Development} menu.
700 @node Miscellaneous commands, Extending EDE, Building and Debugging, top
701 @chapter Miscellaneous commands
703 If you opt to go in and edit @ede{} project files directly---for
704 instance, by using @kbd{C-c . e} (@pxref{Customize Features})---you
705 must then ``rescan'' the project files to update the internal data
706 structures. To rescan the current project, type @kbd{C-c . g}
707 (@code{ede-rescan-toplevel}).
709 @ede{} can help you find files in your project, via the command
710 @kbd{C-c . f} (@code{ede-find-file}). This prompts for a file name;
711 you need not specify the directory. EDE then tries to visit a file
712 with that name somewhere in your project.
714 @ede{} can use external tools to help with file finding. To do this,
715 customize @code{ede-locate-setup-options}.
717 @defvar ede-locate-setup-options
718 @anchor{ede-locate-setup-options}
719 List of locate objects to try out by default.
720 Listed in order of preference. If the first item cannot be used in
721 a particular project, then the next one is tried.
722 It is always assumed that @dfn{ede-locate-base} is at end of the list.
725 @ede{} also provides a project display mode for the speedbar
726 (@pxref{Speedbar,,,emacs,GNU Emacs Manual}). This allows you to view
727 your source files as they are structured in your project: as a
728 hierarchical tree, grouped according to target.
730 To activate the speedbar in this mode, type @kbd{C-c . s}
731 (@code{ede-speedbar}).
734 * Make and Automake projects:: Project types of @samp{ede-project}
735 * Automake direct projects:: Project interface on hand-written automake files.
736 * Android projects:: Projects for Android development
737 * Arduino projects:: Projects for Arduino sketches
738 * Simple projects:: Projects @ede{} doesn't manage.
741 @node Make and Automake projects
742 @section Make and Automake projects
744 A project of @samp{ede-project} type creates a file called
745 @file{Project.ede} in every project directory. This is used to track
746 your configuration information. If you configure this project to be
747 in @samp{Makefile} mode, then this project will autogenerate a
748 @file{Makefile}. If you configure it in @samp{Automake} mode a
749 @file{Makefile.am} file will be created. The automake bootstrapping
750 routines will also import and maintain a configure.am script and a
751 host of other files required by Automake.
753 @node Automake direct projects
754 @section Automake direct projects
756 The project type that reads @file{Makefile.am} directly is derived
757 from the sources of the original @file{project-am.el} mode that was
758 distributed independently. This mode eventually became @ede{}. The
759 @samp{project-am} project will read existing automake files, but will
760 not generate them automatically, or create new ones. As such, it is
761 useful as a browsing tool, or as maintenance in managing file lists.
763 @node Android projects
764 @section Android projects
766 An Android project of type @samp{ede-android-project} will detect and
767 support development of Android apps. Android projects use an
768 @file{AndroidManifest.xml} file. Always load your Manifest first in a
769 running Emacs to make sure the project is identified correctly.
771 Android projects can be created with @code{ede-new} but depend on a
772 correctly configured Android SDK via @cedet{} support.
774 @defun cedet-android-sdk-root
775 @anchor{cedet-android-sdk-root}
776 The root to the android @var{SDK}.
779 Android projects support different configurations including compile,
780 and install, which will upload a program to your Android device. It
781 also supports several debugging tools via @file{android.el}.
783 @node Arduino projects
784 @section Arduino projects
786 An arduino project of type @samp{ede-arduino-project} will read your
787 @file{~/.arduino/preferences.txt} file, and identify your sketches.
788 You will still need the Arduino IDE to set up your preferences and
789 locate your arduino. After quitting the IDE, Emacs will be able to
790 find your sketches, compile them, and upload them to your arduino.
792 If you have the @file{arduino} command on your path, @ede{} will be
793 able to find your SDK and compile your programs.
795 @node Simple projects
796 @section Simple Projects
798 There is a wide array of Simple projects. The root for simple
799 projects is the class @code{ede-simple-project}. This handles the
800 infrastructure of storing a .ede file if needed.
802 The class @code{ede-simple-project} is designed to be subclassed.
803 Then key @ede{} methods can be overridden to provide a quick wrapper
806 A second project type is @code{ede-cpp-root}. This project type is
807 designed to be created for a directory hierarchy full of C/C++ code.
808 It can be configured with minimal lisp knowledge to do header file
809 lookup for @semantic{}, improving code completion performance.
812 * ede-cpp-root:: This project marks the root of a C/C++ code project.
813 * ede-java-root:: This project marks the root of a Java project.
814 * ede-emacs:: A project for working with Emacs.
815 * ede-linux:: A project for working with Linux kernels.
816 * Custom Locate:: Customizing how to locate files in a simple project
819 @node ede-cpp-root, ede-java-root, Simple projects, Simple projects
820 @subsection ede-cpp-root
822 The @code{ede-cpp-root} project type allows you to create a single
823 object with no save-file in your @file{.emacs} file. It allows @ede{}
824 to provide the @semantic{} package with the ability to find header
827 The @code{ede-cpp-root} class knows a few things about C++ projects,
828 such as the prevalence of "include" directories, and typical
829 file-layout stuff. If this isn't sufficient, you can subclass
830 @code{ede-cpp-root-project} and add your own tweaks in just a few
831 lines. See the end of this file for an example.
833 In the most basic case, add this to your @file{.emacs} file, modifying
834 appropriate bits as needed.
837 (ede-cpp-root-project "SOMENAME" :file "/dir/to/some/file")
840 Replace @var{SOMENAME} with whatever name you want, and the filename
841 to an actual file at the root of your project. It might be a
842 Makefile, a README file. Whatever. It doesn't matter. It's just a
843 key to hang the rest of @ede{} off of.
845 The most likely reason to create this project, is to speed up
846 searching for includes files, or to simplify bootstrapping @semantic{}'s
847 ability to find files without much user interaction. In conjunction
848 with @semantic{} completion, having a short include path is key. You can
849 override the default include path and system include path like this:
852 (ede-cpp-root-project "NAME" :file "FILENAME"
853 :include-path '( "/include" "../include" "/c/include" )
854 :system-include-path '( "/usr/include/c++/3.2.2/" )
855 :spp-table '( ("MOOSE" . "")
856 ("CONST" . "const") ) )
859 In this case each item in the include path list is searched. If the
860 directory starts with "/", then that expands to the project root
861 directory. If a directory does not start with "/", then it is
862 relative to the default-directory of the current buffer when the file
865 The include path only affects C/C++ header files. Use the slot
866 @code{:header-match-regexp} to change it.
868 The @code{:system-include-path} allows you to specify full directory
869 names to include directories where system header files can be found.
870 These will be applied to files in this project only.
872 The @code{:spp-table} provides a list of project specific #define
873 style macros that are unique to this project, passed in to the
874 compiler on the command line, or are in special headers.
875 See the @code{semantic-lex-c-preprocessor-symbol-map} for more
876 on how to format this entry.
878 If there is a single file in your project, you can instead set the
879 @code{:spp-files} to a list of file names relative to the root of your
880 project. Specifying this is like setting the variable
881 @code{semantic-lex-c-preprocessor-symbol-file} in semantic.
883 If you want to override the file-finding tool with your own
884 function you can do this:
887 (ede-cpp-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
890 Where @var{MYFCN} is a symbol for a function. The locate function can
891 be used in place of @code{ede-expand-filename} so you can quickly
892 customize your custom target to use specialized local routines instead
893 of the default @ede{} routines. The function symbol must take two
898 The name of the file to find.
900 The directory root for this cpp-root project.
903 When creating a project with @code{ede-cpp-root}, you can get
904 additional configurations via @ref{Project Local Variables}. Be aware
905 that the format for project local variables is an association list.
906 You cannot use @kbd{M-x ede-set} and have your project local variables
907 persist between sessions.
909 If the cpp-root project style is right for you, but you want a dynamic
910 loader, instead of hard-coding path name values in your @file{.emacs}, you
911 can do that too, but you will need to write some lisp code.
913 To do that, you need to add an entry to the
914 @code{ede-project-class-files} list, and also provide two functions to
915 teach @ede{} how to load your project pattern
917 It would look like this:
920 (defun MY-FILE-FOR-DIR (&optional dir)
921 "Return a full file name to the project file stored in DIR."
922 <write your code here, or return nil>
925 (defun MY-ROOT-FCN ()
926 "Return the root fcn for `default-directory'"
927 ;; You might be able to use `ede-cpp-root-project-root'
928 ;; and not write this at all.
932 "Load a project of type `cpp-root' for the directory DIR.
933 Return nil if there isn't one."
934 ;; Use your preferred construction method here.
935 (ede-cpp-root-project "NAME" :file (expand-file-name "FILE" dir)
939 (add-to-list 'ede-project-class-files
940 (ede-project-autoload "cpp-root"
943 :proj-file 'MY-FILE-FOR-DIR
944 :proj-root 'MY-ROOT-FCN
946 :class-sym 'ede-cpp-root)
950 This example only creates an auto-loader, and does not create a new kind
953 @xref{ede-cpp-root-project}, for details about the class that defines
954 the @code{ede-cpp-root} project type.
956 @node ede-java-root, ede-emacs, ede-cpp-root, Simple projects
957 @subsection ede-java-root
959 Much like the project type @ref{ede-cpp-root}, the java variant is
960 can be setup in your @file{.emacs} file and just marks a directory as
961 the root of a java source tree.
963 The @code{ede-java-root} project class knows a few things about Java
964 projects. In particular, you can use it to control your classpath at
965 both the system level, and for your project. If it is insufficient,
966 you can subclass @code{ede-java-root-project} and add your own tweaks
967 in just a few lines. See @ref{ede-cpp-root} for an example using the
970 In the most basic case, add this to your @file{.emacs} file, modifying
971 appropriate bits as needed.
974 (ede-java-root-project "SOMENAME" :file "/dir/to/some/file" :srcroot '("src"))
977 Replace @var{SOMENAME} with whatever name you want, and the filename
978 to an actual file at the root of your project. It might be a
979 Makefile, a README file. Whatever. It doesn't matter. It's just a
980 key to hang the rest of @ede{} off of.
982 Replace the value of :srcroot with a list of directories under the
983 project root which contains Java sources. For example, if you have:
988 ~/myprojects/P1/src/com/ericsoft/MyCode.java
992 Then @file{src} represents the directory under which all your Java
993 code is. It is important that @file{src} is one step above the
994 directory that is the base of your package name, such as
995 @file{com/ericsoft} in the example above so that new files can be
996 discovered via fully qualified name. You can have multiple such
997 directories in one project, and each will be accessible.
999 You can specify your classpath like this:
1002 (ede-java-root-project "NAME" :file "FILENAME"
1004 :classpath '("/absolute/path.jar")
1005 :localclasspath '( "/relative/path.jar" ))
1008 In this example, @code{:classpath} specifies absolute paths somewhere
1009 on your system, and the explicit jar or source root directories
1010 @semantic{} will search when performing completions.
1012 The @code{:localclasspath} is like @code{:classpath}, but it will
1013 contain path names relative to the root of your project.
1015 If you want to override the file-finding tool with your own
1016 function you can do this:
1019 (ede-java-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
1022 Where @var{MYFCN} is a symbol for a function. The locate function can
1023 be used in place of @code{ede-expand-filename} so you can quickly
1024 customize your custom target to use specialized local routines instead
1025 of the default @ede{} routines. The function symbol must take two
1030 The name of the file to find.
1032 The directory root for this java-root project.
1035 If you would like to create your Java projects dynamically, instead of
1036 putting them all in your @file{.emacs}, you can do that too. See
1037 @ref{ede-cpp-root} for details that can be applied to this project type.
1039 @node ede-emacs, ede-linux, ede-java-root, Simple projects
1040 @subsection ede-emacs
1042 The @code{ede-emacs} project automatically identifies an Emacs source
1043 tree, and enables EDE project mode for it.
1045 It pre-populates the C Preprocessor symbol map for correct parsing,
1046 and has an optimized include file identification function.
1048 @node ede-linux, Custom Locate, ede-emacs, Simple projects
1049 @subsection ede-linux
1051 The @code{ede-linux} project will automatically identify a Linux
1052 Kernel source tree, and enable EDE project mode for it.
1054 It pre-populates the C Preprocessor symbol map for reasonable parsing,
1055 and has an optimized include file identification function.
1057 @node Custom Locate, , ede-linux, Simple projects
1058 @subsection Custom Locate
1060 The various simple project styles all have one major drawback, which
1061 is that the files in the project are not completely known to EDE@.
1062 When the EDE API is used to try and file files by some reference name
1063 in the project, then that could fail.
1065 @@TODO - Add ID Utils and CScope examples
1067 @ede{} can therefore use some external locate commands, such as the unix
1068 ``locate'' command, or ``GNU Global''.
1070 Configuration of the tool you want to use such as @code{locate}, or
1071 @code{global} will need to be done without the aid of @ede{}. Once
1072 configured, however, @ede{} can use it.
1074 To enable one of these tools, set the variable
1075 @code{ede-locate-setup-options} with the names of different locate
1076 objects. @ref{Miscellaneous commands}.
1078 Configure this in your @file{.emacs} before loading in CEDET or EDE@.
1079 If you want to add support for GNU Global, your configuration would
1083 (setq ede-locate-setup-options '(ede-locate-global ede-locate-base))
1086 That way, when a search needs to be done, it will first try using
1087 GLOBAL@. If global is not available for that directory, then it will
1088 revert to the base locate object. The base object always fails to
1091 You can add your own locate tool but subclassing from
1092 @code{ede-locate-base}. The subclass should also implement two
1093 methods. See the code in @file{ede-locate.el} for GNU Global as a
1096 @node Extending EDE, GNU Free Documentation License, Miscellaneous commands, top
1097 @chapter Extending @ede{}
1099 This chapter is intended for users who want to write new parts or fix
1100 bugs in @ede{}. A knowledge of Emacs Lisp, and some @eieio{}(CLOS) is
1103 @ede{} uses @eieio{}, the CLOS package for Emacs, to define two object
1104 superclasses, specifically the PROJECT and TARGET@. All commands in
1105 @ede{} are usually meant to address the current project, or current
1108 All specific projects in @ede{} derive subclasses of the @ede{}
1109 superclasses. In this way, specific behaviors such as how a project
1110 is saved, or how a target is compiled can be customized by a project
1111 author in detail. @ede{} communicates to these project objects via an
1112 API using methods. The commands you use in @ede{} mode are high-level
1113 functional wrappers over these methods. @xref{Top,,, eieio, EIEIO manual}. For
1114 details on using @eieio{} to extending classes, and writing methods.
1116 If you intend to extend @ede{}, it is most likely that a new target type is
1117 needed in one of the existing project types. The rest of this chapter
1118 will discuss extending the @code{ede-project} class, and it's targets.
1119 See @file{project-am.el} for basic details on adding targets to it.
1121 For the @code{ede-project} type, the core target class is called
1122 @code{ede-proj-target}. Inheriting from this will give you everything
1123 you need to start, including adding your sources into the makefile. If
1124 you also need additional rules in the makefile, you will want to inherit
1125 from @code{ede-proj-target-makefile} instead. You may want to also add
1126 new fields to track important information.
1128 If you are building currently unsupported code into a program or shared
1129 library, it is unlikely you need a new target at all. Instead you
1130 would need to create a new compiler or linker object that compiles
1131 source code of the desired type. @ref{Compiler and Linker objects}.
1133 Once your new class exists, you will want to fill in some basic methods.
1134 See the @file{ede-skel.el} file for examples of these. The files
1135 @file{ede-proj-info.el} and @file{ede-proj-elisp.el} are two interesting
1139 * Development Overview::
1140 * Detecting a Project::
1141 * User interface methods:: Methods associated with keybindings
1142 * Base project methods:: The most basic methods on @ede{} objects.
1143 * Sourcecode objects:: Defining new sourcecode classes.
1144 * Compiler and Linker objects:: Defining new compilers and linkers.
1145 * Project:: Details of project classes.
1146 * Targets:: Details of target classes.
1147 * Sourcecode:: Details of source code classes.
1148 * Compilers:: Details of compiler classes.
1151 @node Development Overview, Detecting a Project, Extending EDE, Extending EDE
1152 @section Development Overview
1154 @ede{} is made up of a series of classes implemented with @eieio{}.
1155 These classes define an interface that can be used to create different
1158 @ede{} defines two superclasses which are @code{ede-project} and
1159 @code{ede-target}. All commands in @ede{} are usually meant to
1160 address the current project, or current target.
1162 All specific projects in @ede{} derive subclasses of the @ede{} superclasses.
1163 In this way, specific behaviors such as how a project is saved, or how a
1164 target is compiled can be customized by a project author in detail. @ede{}
1165 communicates to these project objects via an API using methods. The
1166 commands you use in @ede{} mode are high-level functional wrappers over
1169 Some example project types are:
1173 Automake project which reads existing Automake files.
1174 @item ede-proj-project
1175 This project type will create @file{Makefiles},
1176 or @file{Makefile.am} files to compile your project.
1178 This project type will detect linux source trees.
1180 This project will detect an Emacs source tree.
1183 There are several other project types as well.
1185 The first class you need to know to create a new project type is
1186 @code{ede-project-autoload}. New instances of this class are needed
1187 to define how Emacs associates different files/buffers with different
1188 project types. All the autoloads are kept in the variable
1189 @code{ede-project-class-files}.
1191 The next most important class to know is @code{ede-project}. This is
1192 the baseclass defines how all projects behave. The basic pattern for
1193 a project is that there is one project per directory, and the topmost
1194 project or directory defines the project as a whole.
1196 Key features of @code{ede-project} are things like name and version
1197 number. It also holds a list of @code{ede-target} objects and a list
1198 of sub projects, or more @code{ede-project} objects.
1200 New project types must subclass @code{ede-project} to add special
1201 behavior. New project types also need to subclass @code{ede-target} to
1202 add specialty behavior.
1204 In this way, the common @ede{} interface is designed to work against
1205 @code{ede-project}, and thus all subclasses.
1207 @code{ede-project} subclasses @code{ede-project-placeholder}. This is
1208 the minimum necessary project needed to be cached between runs of
1209 Emacs. This way, Emacs can track all projects ever seen, without
1210 loading those projects into memory.
1212 Here is a high-level UML diagram for the @ede{} system created with @cogre{}..
1215 +-----------------------+ +-----------------------+
1216 | | |ede-project-placeholder|
1217 |ede-project-class-files| +-----------------------+
1218 | | +-----------------------+
1219 +-----------------------+ +-----------------------+
1223 +--------------------+ +-----------+ +----------+
1224 |ede-project-autoload| |ede-project| |ede-target|
1225 +--------------------+<>--------------+-----------+<>-------+----------+
1226 +--------------------+ +-----------+ +----------+
1227 +--------------------+ +-----------+ +----------+
1231 +---------------------+-----------------+
1235 +----------------+ +-------------------+ +---------+
1236 |ede-proj-project| |project-am-makefile| |ede-emacs|
1237 +----------------+ +-------------------+ +---------+
1238 +----------------+ +-------------------+ +---------+
1239 +----------------+ +-------------------+ +---------+
1243 @node Detecting a Project, User interface methods, Development Overview, Extending EDE
1244 @section Detecting a Project
1246 Project detection happens with the list of @code{ede-project-autoload}
1247 instances stored in @code{ede-project-class-files}. The full project
1248 detection scheme works like this:
1252 @code{find-file-hook} calls @code{ede-turn-on-hook} on BUFFER.
1254 @code{ede-turn-on-hook} turns on @code{ede-minor-mode}
1256 @code{ede-minor-mode} looks to see if BUFFER is associated with any
1257 open projects. If not, it calls @code{ede-load-project-file} to find
1258 a project associated with the current directory BUFFER is in.
1260 @code{ede-minor-mode} associates the found project with the current
1261 buffer with a series of variables, such as @code{ede-object}, and
1262 @code{ede-object-project} and @code{ede-object-root-project}.
1265 Once a buffer is associated, @ede{} minor mode commands will operate
1268 The function @code{ede-load-project-file} is at the heart of detecting
1269 projects, and it works by looping over all the known project autoload
1270 types in @code{ede-project-autoload} using the utility
1271 @code{ede-directory-project-p}.
1273 The function @code{ede-directory-project-p} will call
1274 @code{ede-dir-to-projectfile} on every @code{ede-project-autoload}
1275 until one of them returns true. The method
1276 @code{ede-dir-to-projectfile} in turn gets the @code{:proj-file} slot
1277 from the autoload. If it is a string (i.e., a project file name), it
1278 checks to see if that exists in BUFFER's directory. If it is a
1279 function, then it calls that function and expects it to return a file
1280 name or nil. If the file exists, then this directory is assumed to be
1281 part of a project, and @code{ede-directory-project-p} returns the
1282 instance of @code{ede-project-autoload} that matched.
1284 If the current directory contains the file @code{.ede-ignore} then
1285 that directory is automatically assumed to contain no projects, even
1286 if there is a matching pattern. Use this type of file in a directory
1287 that may contain many other sub projects, but still has a Makefile of
1290 If the current directory is a project, then @ede{} scans upwards till
1291 it finds the top of the project. It does this by calling
1292 @code{ede-toplevel-project}. If this hasn't already been discovered,
1293 the directories as scanned upward one at a time until a directory with
1294 no project is found. The last found project becomes the project
1295 root. If the found instance of @code{ede-project-autoload} has a
1296 valid @code{proj-root} slot value, then that function is called instead
1297 of scanning the project by hand. Some project types have a short-cut
1298 for determining the root of a project, so this comes in handy.
1300 Getting back to @code{ede-load-project-file}, this now has an instance
1301 of @code{ede-project-autoload}. It uses the @code{load-type} slot to
1302 both autoload in the project type, and to create a new instance of the
1303 project type found for the root of the project. That project is added
1304 to the global list of all projects. All subprojects are then created
1305 and assembled into the project data structures.
1308 @node User interface methods, Base project methods, Detecting a Project, Extending EDE
1309 @section User interface methods
1311 These methods are core behaviors associated with user commands.
1312 If you do not implement a method, there is a reasonable default that
1313 may do what you need.
1316 @item project-add-file
1317 Add a file to your project. Override this if you want to put new
1318 sources into different fields depending on extension, or other details.
1319 @item project-remove-file
1320 Reverse of project-add-file.
1321 @item project-compile-target
1322 Override this if you want to do something special when the user
1323 "compiles" this target.
1324 @item project-debug-target
1325 What to do when a user wants to debug your target.
1326 @item project-update-version
1327 Easily update the version number of your project.
1328 @item project-edit-file-target
1329 Edit the file the project's information is stored in.
1330 @item project-new-target
1331 Create a new target in a project.
1332 @item project-delete-target
1333 Delete a target from a project.
1334 @item project-make-dist
1335 Make a distribution (tar archive) of the project.
1336 @item project-rescan
1337 Rescan a project file, changing the data in the existing objects.
1340 @node Base project methods, Sourcecode objects, User interface methods, Extending EDE
1341 @section Base project methods
1343 These methods are important for querying base information from project
1348 Return a string that is the name of this target.
1349 @item ede-target-name
1350 Return a string that is the name of the target used by a Make system.
1351 @item ede-description
1352 A brief description of the project or target. This is currently used
1353 by the @samp{ede-speedbar} interface.
1354 @item ede-want-file-p
1355 Return non-nil if a target will accept a given file.
1356 It is generally unnecessary to override this. See the section on source
1358 @item ede-buffer-mine
1359 Return non-nil if a buffer belongs to this target. Used during
1360 association when a file is loaded. It is generally unnecessary to
1361 override this unless you keep auxiliary files.
1364 These methods are used by the semantic package extensions.
1365 @xref{Top,,, semantic, Semantic manual}.
1368 @item ede-buffer-header-file
1369 Return a header file belonging to a given buffer. Prototypes are place
1370 there when appropriate
1371 @item ede-buffer-documentation-files
1372 Return the documentation file information about this file would be
1374 @item ede-documentation
1375 List all documentation a project or target is responsible for.
1378 @node Sourcecode objects, Compiler and Linker objects, Base project methods, Extending EDE
1379 @section Sourcecode objects
1381 @ede{} projects track source file / target associates via source code
1382 objects. The definitions for this is in @file{ede-source.el}. A source
1383 code object contains methods that know how to identify a file as being
1384 of that class, (i.e., a C file ends with @file{.c}). Some targets can
1385 handle many different types of sources which must all be compiled
1386 together. For example, a mixed C and C++ program would have
1387 instantiations of both sourcecode types.
1389 When a target needs to know if it will accept a source file, it
1390 references its list of source code objects. These objects then make
1393 Source code objects are stored in the target objects as a list of
1394 symbols, where the symbol's value is the object. This enables the
1395 project save file mechanism to work.
1397 Here is an example for an instantiation of an Emacs Lisp source code object:
1400 (defvar ede-source-emacs
1401 (ede-sourcecode "ede-emacs-source"
1403 :sourcepattern "\\.el$"
1404 :garbagepattern '("*.elc"))
1405 "Emacs Lisp source code definition.")
1408 If you want to recycle parts of an existing sourcecode object, you can
1409 clone the original, and then just tweak the parts that are different.
1413 (defvar ede-source-emacs-autoload
1414 (clone ede-source-emacs "ede-source-emacs-autoload"
1415 :name "Emacs Lisp Autoload"
1416 :sourcepattern "-loaddefs\\.el")
1417 "Emacs Lisp autoload source code.")
1420 In this case, the garbage pattern is the same.
1424 @node Compiler and Linker objects, Project, Sourcecode objects, Extending EDE
1425 @section Compiler and Linker objects
1427 In order for a target to create a @file{Makefile}, it must know how to
1428 compile the sources into the program or desired data file, and
1429 possibly link them together.
1431 A compiler object instantiation is used to associate a given target
1432 with a given source code type. Some targets can handle many types of
1433 sources, and thus has many compilers available to it. Some targets
1434 may have multiple compilers for a given type of source code.
1436 @ede{} will examine the actual source files in a target, cross reference
1437 that against the compiler list to come up with the final set of
1438 compilers that will be inserted into the Makefile.
1440 Compiler instantiations must also insert variables specifying the
1441 compiler it plans to use, in addition to creating Automake settings for
1442 @file{configure.ac} when appropriate.
1444 Compiler objects are stored in the target objects as a list of
1445 symbols, where the symbols value is the object. This enables the
1446 project output mechanism to work more efficiently.
1448 Targets will also have a special "compiler" slot which lets a user
1449 explicitly choose the compiler they want to use.
1451 Here is an example for texinfo:
1454 (defvar ede-makeinfo-compiler
1456 "ede-makeinfo-compiler"
1458 :variables '(("MAKEINFO" . "makeinfo"))
1459 :commands '("makeinfo -o $@ $<")
1460 :autoconf '(("AC_CHECK_PROG" . "MAKEINFO, makeinfo"))
1461 :sourcetype '(ede-makeinfo-source)
1463 "Compile texinfo files into info files.")
1468 When creating compiler instantiations, it may be useful to @code{clone}
1469 an existing compiler variable. Cloning allows you to only modify
1470 parts of the original, while keeping the rest of the same.
1471 Modification of the original will result in the clone also being
1472 changed for shared value slots.
1474 The second important object is the linker class. The linker is similar
1475 to the compiler, except several compilers might be used to create some
1476 object files, and only one linker is used to link those objects together.
1478 See @file{ede-proj-obj.el} for examples of the combination.
1485 @node Project, Targets, Compiler and Linker objects, Extending EDE
1489 * ede-project-placeholder::
1491 * ede-cpp-root-project::
1492 * ede-simple-project::
1493 * ede-simple-base-project::
1494 * ede-proj-project::
1495 * project-am-makefile::
1496 * ede-step-project::
1499 @node ede-project-placeholder, ede-project, Project, Project
1500 @subsection ede-project-placeholder
1501 @pjindex ede-project-placeholder
1504 @item Inheritance Tree:
1506 @item eieio-speedbar
1508 @item eieio-speedbar-directory-button
1510 @item ede-project-placeholder
1513 @w{@xref{ede-project}.}
1525 Type: @code{string} @*
1526 Default Value: @code{"Untitled"}
1528 The name used when generating distribution files.
1532 Type: @code{string} @*
1533 Default Value: @code{"1.0"}
1535 The version number used when distributing files.
1541 Directory this project is associated with.
1547 File name where this project is stored.
1554 @subsubsection Specialized Methods
1556 @deffn Method ede--project-inode :AFTER proj
1557 Get the inode of the directory project @var{PROJ} is in.
1560 @deffn Method ede-project-root :AFTER this
1561 If a project knows it's root, return it here.
1562 Allows for one-project-object-for-a-tree type systems.
1565 @deffn Method ede-find-subproject-for-directory :AFTER proj dir
1566 Find a subproject of @var{PROJ} that corresponds to @var{DIR}.
1569 @deffn Method ede-project-root-directory :AFTER this &optional file
1570 If a project knows it's root, return it here.
1571 Allows for one-project-object-for-a-tree type systems.
1572 Optional @var{FILE} is the file to test. It is ignored in preference
1573 of the anchor file for the project.
1576 @deffn Method ede-project-force-load :AFTER this
1577 Make sure the placeholder @var{THIS} is replaced with the real thing.
1578 Return the new object created in its place.
1581 @deffn Method project-interactive-select-target :AFTER this prompt
1582 Make sure placeholder @var{THIS} is replaced with the real thing, and pass through.
1585 @deffn Method project-add-file :AFTER this file
1586 Make sure placeholder @var{THIS} is replaced with the real thing, and pass through.
1589 @node ede-project, ede-cpp-root-project, ede-project-placeholder, Project
1590 @subsection ede-project
1591 @pjindex ede-project
1594 @item Inheritance Tree:
1596 @item eieio-speedbar
1598 @item eieio-speedbar-directory-button
1600 @item @w{@xref{ede-project-placeholder}.}
1605 @w{@xref{ede-cpp-root-project},} @w{ede-emacs-project,} @w{ede-linux-project,} @w{ede-maven-project,} @w{@xref{ede-simple-project},} @w{@xref{ede-simple-base-project},} @w{@xref{ede-proj-project},} @w{@xref{project-am-makefile},} @w{@xref{ede-step-project}.}
1620 List of top level targets in this project.
1626 List of tool cache configurations in this project.
1627 This allows any tool to create, manage, and persist project-specific settings.
1631 Type: @code{string} @*
1633 URL to this projects web site.
1634 This is a URL to be sent to a web site for documentation.
1637 @item :web-site-directory @*
1639 A directory where web pages can be found by Emacs.
1640 For remote locations use a path compatible with ange-ftp or EFS@.
1641 You can also use TRAMP for use with rcp & scp.
1644 @item :web-site-file @*
1646 A file which contains the home page for this project.
1647 This file can be relative to slot @code{web-site-directory}.
1648 This can be a local file, use ange-ftp, EFS, or TRAMP.
1652 Type: @code{string} @*
1654 FTP site where this project's distribution can be found.
1655 This FTP site should be in Emacs form, as needed by @code{ange-ftp}, but can
1656 also be of a form used by TRAMP for use with scp, or rcp.
1659 @item :ftp-upload-site
1660 Type: @code{string} @*
1662 FTP Site to upload new distributions to.
1663 This FTP site should be in Emacs form as needed by @code{ange-ftp}.
1664 If this slot is @code{nil}, then use @code{ftp-site} instead.
1667 @item :configurations
1668 Type: @code{list} @*
1669 Default Value: @code{("debug" "release")}
1671 List of available configuration types.
1672 Individual target/project types can form associations between a configuration,
1673 and target specific elements such as build variables.
1676 @item :configuration-default @*
1677 Default Value: @code{"debug"}
1679 The default configuration.
1682 @item :local-variables @*
1683 Default Value: @code{nil}
1685 Project local variables
1691 @subsubsection Specialized Methods
1693 @deffn Method ede-preprocessor-map :AFTER this
1694 Get the pre-processor map for project @var{THIS}.
1697 @deffn Method ede-subproject-relative-path :AFTER proj &optional parent-in
1698 Get a path name for @var{PROJ} which is relative to the parent project.
1699 If PARENT is specified, then be relative to the PARENT project.
1700 Specifying PARENT is useful for sub-sub projects relative to the root project.
1703 @deffn Method eieio-speedbar-description :AFTER obj
1704 Provide a speedbar description for @var{OBJ}.
1707 @deffn Method ede-map-any-target-p :AFTER this proc
1708 For project @var{THIS}, map @var{PROC} to all targets and return if any non-nil.
1709 Return the first non-@code{nil} value returned by @var{PROC}.
1712 @deffn Method ede-map-subprojects :AFTER this proc
1713 For object @var{THIS}, execute @var{PROC} on all direct subprojects.
1714 This function does not apply @var{PROC} to sub-sub projects.
1715 See also @dfn{ede-map-all-subprojects}.
1718 @deffn Method ede-convert-path :AFTER this path
1719 Convert path in a standard way for a given project.
1720 Default to making it project relative.
1721 Argument @var{THIS} is the project to convert @var{PATH} to.
1724 @deffn Method ede-name :AFTER this
1725 Return a short-name for @var{THIS} project file.
1726 Do this by extracting the lowest directory name.
1729 @deffn Method ede-set-project-variables :AFTER project &optional buffer
1730 Set variables local to @var{PROJECT} in @var{BUFFER}.
1733 @deffn Method eieio-speedbar-derive-line-path :AFTER obj &optional depth
1734 Return the path to @var{OBJ}.
1735 Optional @var{DEPTH} is the depth we start at.
1738 @deffn Method ede-map-all-subprojects :AFTER this allproc
1739 For object @var{THIS}, execute PROC on @var{THIS} and all subprojects.
1740 This function also applies PROC to sub-sub projects.
1741 See also @dfn{ede-map-subprojects}.
1744 @deffn Method project-update-version :AFTER ot
1745 The @code{:version} of the project @var{OT} has been updated.
1746 Handle saving, or other detail.
1749 @deffn Method ede-buffer-header-file :AFTER this buffer
1750 Return @code{nil}, projects don't have header files.
1753 @deffn Method ede-buffer-documentation-files :AFTER this buffer
1754 Return all documentation in project @var{THIS} based on @var{BUFFER}.
1757 @deffn Method ede-map-targets :AFTER this proc
1758 For object @var{THIS}, execute @var{PROC} on all targets.
1761 @deffn Method ede-buffer-mine :AFTER this buffer
1762 Return non-@code{nil} if object @var{THIS} lays claim to the file in @var{BUFFER}.
1765 @deffn Method ede-object-keybindings :BEFORE this
1766 Retrieves the slot @code{keybindings} from an object of class @code{ede-project}
1769 @deffn Method ede-description :AFTER this
1770 Return a description suitable for the minibuffer about @var{THIS}.
1773 @deffn Method eieio-speedbar-object-children :AFTER this
1774 Return the list of speedbar display children for @var{THIS}.
1777 @deffn Method project-make-dist :AFTER this
1778 Build a distribution for the project based on @var{THIS} project.
1781 @deffn Method ede-system-include-path :AFTER this
1782 Get the system include path used by project @var{THIS}.
1785 @deffn Method project-new-target-custom :AFTER proj
1786 Create a new target. It is up to the project @var{PROJ} to get the name.
1789 @deffn Method ede-subproject-p :AFTER proj
1790 Return non-@code{nil} if @var{PROJ} is a sub project.
1793 @deffn Method ede-expand-filename :AFTER this filename &optional force
1794 Return a fully qualified file name based on project @var{THIS}.
1795 @var{FILENAME} should be just a filename which occurs in a directory controlled
1797 Optional argument @var{FORCE} forces the default filename to be provided even if it
1801 @deffn Method ede-menu-items-build :AFTER obj &optional current
1802 Return a list of menu items for building project @var{OBJ}.
1803 If optional argument @var{CURRENT} is non-@code{nil}, return sub-menu code.
1806 @deffn Method ede-update-version-in-source :AFTER this version
1807 Change occurrences of a version string in sources.
1808 In project @var{THIS}, cycle over all targets to give them a chance to set
1809 their sources to @var{VERSION}.
1812 @deffn Method project-new-target :AFTER proj &rest args
1813 Create a new target. It is up to the project @var{PROJ} to get the name.
1816 @deffn Method project-compile-project :AFTER obj &optional command
1817 Compile the entire current project @var{OBJ}.
1818 Argument @var{COMMAND} is the command to use when compiling.
1821 @deffn Method eieio-speedbar-object-buttonname :AFTER object
1822 Return a string to use as a speedbar button for @var{OBJECT}.
1825 @deffn Method ede-map-project-buffers :AFTER this proc
1826 For @var{THIS}, execute @var{PROC} on all buffers belonging to @var{THIS}.
1829 @deffn Method ede-expand-filename-impl :AFTER this filename &optional force
1830 Return a fully qualified file name based on project @var{THIS}.
1831 @var{FILENAME} should be just a filename which occurs in a directory controlled
1833 Optional argument @var{FORCE} forces the default filename to be provided even if it
1837 @deffn Method eieio-done-customizing :AFTER proj
1838 Call this when a user finishes customizing @var{PROJ}.
1841 @deffn Method ede-html-documentation :AFTER this
1842 Return a list of HTML files provided by project @var{THIS}.
1845 @deffn Method ede-documentation :AFTER this
1846 Return a list of files that provides documentation.
1847 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
1848 files in the project.
1851 @deffn Method project-interactive-select-target :AFTER this prompt
1852 Interactively query for a target that exists in project @var{THIS}.
1853 Argument @var{PROMPT} is the prompt to use when querying the user for a target.
1856 @deffn Method ede-target-in-project-p :AFTER proj target
1857 Is @var{PROJ} the parent of @var{TARGET}?
1858 If @var{TARGET} belongs to a subproject, return that project file.
1861 @deffn Method ede-find-target :AFTER proj buffer
1862 Fetch the target in @var{PROJ} belonging to @var{BUFFER} or nil.
1865 @deffn Method ede-add-subproject :AFTER proj-a proj-b
1866 Add into @var{PROJ-A}, the subproject @var{PROJ-B}.
1869 @deffn Method ede-commit-project :AFTER proj
1870 Commit any change to @var{PROJ} to its file.
1873 @deffn Method project-dist-files :AFTER this
1874 Return a list of files that constitutes a distribution of @var{THIS} project.
1877 @deffn Method ede-object-menu :BEFORE this
1878 Retrieves the slot @code{menu} from an object of class @code{ede-project}
1881 @deffn Method ede-commit-local-variables :AFTER proj
1882 Commit change to local variables in @var{PROJ}.
1885 @node ede-cpp-root-project, ede-simple-project, ede-project, Project
1886 @subsection ede-cpp-root-project
1887 @pjindex ede-cpp-root-project
1890 @item Inheritance Tree:
1892 @item eieio-speedbar
1894 @item eieio-speedbar-directory-button
1896 @item @w{@xref{ede-project-placeholder}.}
1898 @item @w{@xref{ede-project}.}
1900 @item ede-cpp-root-project
1909 This class implements the @code{ede-cpp-root} project type.
1910 @xref{ede-cpp-root}, for information about using this project type.
1917 Type: @code{list} @*
1918 Default Value: @code{(quote ("/include" "../include/"))}
1920 The default locate function expands filenames within a project.
1921 If a header file (.h, .hh, etc) name is expanded, and
1922 the @code{:locate-fcn} slot is @code{nil}, then the include path is checked
1923 first, and other directories are ignored. For very large
1924 projects, this optimization can save a lot of time.
1926 Directory names in the path can be relative to the current
1927 buffer's @code{default-directory} (not starting with a /). Directories
1928 that are relative to the project's root should start with a /, such
1929 as "/include", meaning the directory @code{include} off the project root
1933 @item :system-include-path
1934 Type: @code{list} @*
1935 Default Value: @code{nil}
1937 The system include path for files in this project.
1938 C files initialized in an ede-cpp-root-project have their semantic
1939 system include path set to this value. If this is @code{nil}, then the
1940 semantic path is not modified.
1944 Type: @code{list} @*
1945 Default Value: @code{nil}
1947 C Preprocessor macros for your files.
1948 Preprocessor symbols will be used while parsing your files.
1949 These macros might be passed in through the command line compiler, or
1950 are critical symbols derived from header files. Providing header files
1951 macro values through this slot improves accuracy and performance.
1952 Use `:spp-files' to use these files directly.
1956 Type: @code{list} @*
1957 Default Value: @code{nil}
1959 C header file with Preprocessor macros for your files.
1960 The PreProcessor symbols appearing in these files will be used while
1961 parsing files in this project.
1962 See @code{semantic-lex-c-preprocessor-symbol-map} for more on how this works.
1965 @item :header-match-regexp
1966 Type: @code{string} @*
1967 Default Value: @code{"\\.\\(h\\(h\\|xx\\|pp\\|\\+\\+\\)?\\|H\\)$\\|\\<\\w+$"}
1969 Regexp used to identify C/C++ header files.
1973 Type: @code{(or null function)} @*
1974 Default Value: @code{nil}
1976 The locate function can be used in place of
1977 @dfn{ede-expand-filename} so you can quickly customize your custom target
1978 to use specialized local routines instead of the EDE routines.
1979 The function symbol must take two arguments:
1980 NAME - The name of the file to find.
1981 DIR - The directory root for this cpp-root project.
1983 It should return the fully qualified file name passed in from NAME@. If that file does not
1984 exist, it should return nil.
1990 @subsubsection Specialized Methods
1992 @deffn Method initialize-instance :AFTER this &rest fields
1993 Make sure the @code{:file} is fully expanded.
1996 @deffn Method ede-preprocessor-map :AFTER this
1997 Get the pre-processor map for project @var{THIS}.
2000 @deffn Method ede-cpp-root-header-file-p :AFTER proj name
2001 Non @code{nil} if in @var{PROJ} the filename @var{NAME} is a header.
2004 @deffn Method ede-system-include-path :AFTER this
2005 Get the system include path used by project @var{THIS}.
2008 @deffn Method ede-expand-filename-impl :AFTER proj name
2009 Within this project @var{PROJ}, find the file @var{NAME}.
2010 This knows details about or source tree.
2013 @node ede-simple-project, ede-simple-base-project, ede-cpp-root-project, Project
2014 @subsection ede-simple-project
2015 @pjindex ede-simple-project
2018 @item Inheritance Tree:
2020 @item eieio-speedbar
2022 @item eieio-speedbar-directory-button
2024 @item @w{@xref{ede-project-placeholder}.}
2026 @item @w{@xref{ede-project}.}
2028 @item ede-simple-project
2037 @subsubsection Specialized Methods
2039 @deffn Method ede-commit-project :AFTER proj
2040 Commit any change to @var{PROJ} to its file.
2043 @node ede-simple-base-project, ede-proj-project, ede-simple-project, Project
2044 @subsection ede-simple-base-project
2045 @pjindex ede-simple-base-project
2048 @item Inheritance Tree:
2050 @item eieio-speedbar
2052 @item eieio-speedbar-directory-button
2054 @item @w{@xref{ede-project-placeholder}.}
2056 @item @w{@xref{ede-project}.}
2058 @item ede-simple-base-project
2067 EDE Simple project base class.
2068 This one project could control a tree of subdirectories.
2073 @node ede-proj-project, project-am-makefile, ede-simple-base-project, Project
2074 @subsection ede-proj-project
2075 @pjindex ede-proj-project
2078 @item Inheritance Tree:
2080 @item eieio-speedbar
2082 @item eieio-speedbar-directory-button
2084 @item @w{@xref{ede-project-placeholder}.}
2086 @item @w{@xref{ede-project}.}
2088 @item ede-proj-project
2101 @item :makefile-type
2102 Type: @code{symbol} @*
2103 Default Value: @code{Makefile}
2105 The type of Makefile to generate.
2106 Can be one of @code{'Makefile}, 'Makefile.in, or 'Makefile.am.
2107 If this value is NOT @code{'Makefile}, then that overrides the @code{:makefile} slot
2112 Type: @code{list} @*
2113 Default Value: @code{nil}
2115 Variables to set in this Makefile.
2118 @item :configuration-variables
2119 Type: @code{list} @*
2120 Default Value: @code{("debug" (("DEBUG" . "1")))}
2122 Makefile variables to use in different configurations.
2123 These variables are used in the makefile when a configuration becomes active.
2126 @item :inference-rules @*
2127 Default Value: @code{nil}
2129 Inference rules to add to the makefile.
2132 @item :include-file @*
2133 Default Value: @code{nil}
2135 Additional files to include.
2136 These files can contain additional rules, variables, and customizations.
2139 @item :automatic-dependencies
2140 Type: @code{boolean} @*
2141 Default Value: @code{t}
2143 Non-@code{nil} to do implement automatic dependencies in the Makefile.
2146 @item :metasubproject
2147 Type: @code{boolean} @*
2148 Default Value: @code{nil}
2150 Non-@code{nil} if this is a metasubproject.
2151 Usually, a subproject is determined by a parent project. If multiple top level
2152 projects are grouped into a large project not maintained by EDE, then you need
2153 to set this to non-nil. The only effect is that the @code{dist} rule will then avoid
2160 @subsubsection Specialized Methods
2162 @deffn Method ede-proj-makefile-create :AFTER this mfilename
2163 Create a Makefile for all Makefile targets in @var{THIS}.
2164 @var{MFILENAME} is the makefile to generate.
2167 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2168 Insert rules needed by @var{THIS} target.
2171 @deffn Method ede-proj-makefile-tags :AFTER this targets
2172 Insert into the current location rules to make recursive TAGS files.
2173 Argument @var{THIS} is the project to create tags for.
2174 Argument @var{TARGETS} are the targets we should depend on for TAGS.
2177 @deffn Method ede-proj-makefile-insert-variables :AFTER this
2178 Insert variables needed by target @var{THIS}.
2181 @deffn Method project-make-dist :AFTER this
2182 Build a distribution for the project based on @var{THIS} target.
2185 @deffn Method ede-proj-makefile-insert-dist-rules :AFTER this
2186 Insert distribution rules for @var{THIS} in a Makefile, such as CLEAN and DIST.
2189 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
2190 Insert any symbols that the DIST rule should depend on.
2191 Argument @var{THIS} is the project that should insert stuff.
2194 @deffn Method ede-proj-makefile-insert-subproj-rules :AFTER this
2195 Insert a rule for the project @var{THIS} which should be a subproject.
2198 @deffn Method ede-proj-makefile-create-maybe :AFTER this mfilename
2199 Create a Makefile for all Makefile targets in @var{THIS} if needed.
2200 @var{MFILENAME} is the makefile to generate.
2203 @deffn Method ede-proj-configure-test-required-file :AFTER this file
2204 For project @var{THIS}, test that the file @var{FILE} exists, or create it.
2207 @deffn Method ede-proj-setup-buildenvironment :AFTER this &optional force
2208 Setup the build environment for project @var{THIS}.
2209 Handles the Makefile, or a Makefile.am configure.ac combination.
2210 Optional argument @var{FORCE} will force items to be regenerated.
2213 @deffn Method ede-proj-makefile-garbage-patterns :AFTER this
2214 Return a list of patterns that are considered garbage to @var{THIS}.
2215 These are removed with make clean.
2218 @deffn Method ede-proj-configure-synchronize :AFTER this
2219 Synchronize what we know about project @var{THIS} into configure.ac.
2222 @deffn Method ede-proj-makefile-insert-variables-new :AFTER this
2223 Insert variables needed by target @var{THIS}.
2225 NOTE: Not yet in use! This is part of an SRecode conversion of
2226 EDE that is in progress.
2229 @deffn Method ede-proj-makefile-configuration-variables :AFTER this configuration
2230 Return a list of configuration variables from @var{THIS}.
2231 Use @var{CONFIGURATION} as the current configuration to query.
2234 @deffn Method eieio-done-customizing :AFTER proj
2235 Call this when a user finishes customizing this object.
2236 Argument @var{PROJ} is the project to save.
2239 @deffn Method ede-proj-configure-recreate :AFTER this
2240 Delete project @var{THIS}'s configure script and start over.
2243 @deffn Method ede-proj-makefile-insert-user-rules :AFTER this
2244 Insert user specified rules needed by @var{THIS} target.
2245 This is different from @dfn{ede-proj-makefile-insert-rules} in that this
2246 function won't create the building rules which are auto created with
2250 @deffn Method ede-proj-dist-makefile :AFTER this
2251 Return the name of the Makefile with the DIST target in it for @var{THIS}.
2254 @deffn Method ede-proj-configure-file :AFTER this
2255 The configure.ac script used by project @var{THIS}.
2258 @deffn Method ede-commit-project :AFTER proj
2259 Commit any change to @var{PROJ} to its file.
2262 @deffn Method project-dist-files :AFTER this
2263 Return a list of files that constitutes a distribution of @var{THIS} project.
2266 @deffn Method ede-commit-local-variables :AFTER proj
2267 Commit change to local variables in @var{PROJ}.
2270 @node project-am-makefile, ede-step-project, ede-proj-project, Project
2271 @subsection project-am-makefile
2272 @pjindex project-am-makefile
2275 @item Inheritance Tree:
2277 @item eieio-speedbar
2279 @item eieio-speedbar-directory-button
2281 @item @w{@xref{ede-project-placeholder}.}
2283 @item @w{@xref{ede-project}.}
2285 @item project-am-makefile
2294 @subsubsection Specialized Methods
2296 @deffn Method project-am-subtree :AFTER ampf subdir
2297 Return the sub project in @var{AMPF} specified by @var{SUBDIR}.
2300 @deffn Method project-targets-for-file :AFTER proj
2301 Return a list of targets the project @var{PROJ}.
2304 @deffn Method project-new-target :AFTER proj &optional name type
2305 Create a new target named @var{NAME}.
2306 Argument @var{TYPE} is the type of target to insert. This is a string
2307 matching something in @code{project-am-type-alist} or type class symbol.
2308 Despite the fact that this is a method, it depends on the current
2309 buffer being in order to provide a smart default target type.
2312 @node ede-step-project, , project-am-makefile, Project
2313 @subsection ede-step-project
2314 @pjindex ede-step-project
2317 @item Inheritance Tree:
2319 @item eieio-speedbar
2321 @item eieio-speedbar-directory-button
2323 @item @w{@xref{ede-project-placeholder}.}
2325 @item @w{@xref{ede-project}.}
2327 @item ede-step-project
2340 @item :init-variables
2341 Type: @code{list} @*
2342 Default Value: @code{nil}
2344 Variables to set in this Makefile, at top of file.
2347 @item :additional-variables
2348 Type: @code{(or null list)} @*
2349 Default Value: @code{nil}
2351 Arbitrary variables needed from this project.
2352 It is safe to leave this blank.
2355 @item :additional-rules
2356 Type: @code{(or null list)} @*
2357 Default Value: @code{nil}
2359 Arbitrary rules and dependencies needed to make this target.
2360 It is safe to leave this blank.
2363 @item :installation-domain
2364 Type: @code{symbol} @*
2365 Default Value: @code{user}
2367 Installation domain specification.
2368 The variable GNUSTEP_INSTALLATION_DOMAIN is set at this value.
2372 Type: @code{(or null list)} @*
2373 Default Value: @code{(quote ("GNUmakefile.preamble"))}
2375 The auxiliary makefile for additional variables.
2376 Included just before the specific target files.
2380 Type: @code{(or null list)} @*
2381 Default Value: @code{(quote ("GNUmakefile.postamble"))}
2383 The auxiliary makefile for additional rules.
2384 Included just after the specific target files.
2387 @item :metasubproject
2388 Type: @code{boolean} @*
2389 Default Value: @code{nil}
2391 Non-@code{nil} if this is a metasubproject.
2392 Usually, a subproject is determined by a parent project. If multiple top level
2393 projects are grouped into a large project not maintained by EDE, then you need
2394 to set this to non-nil. The only effect is that the @code{dist} rule will then avoid
2401 @subsubsection Specialized Methods
2403 @deffn Method ede-proj-makefile-create :AFTER this mfilename
2404 Create a GNUmakefile for all Makefile targets in @var{THIS}.
2405 @var{MFILENAME} is the makefile to generate.
2408 @deffn Method project-make-dist :AFTER this
2409 Build a distribution for the project based on @var{THIS} target.
2412 @deffn Method ede-proj-makefile-create-maybe :AFTER this mfilename
2413 Create a Makefile for all Makefile targets in @var{THIS} if needed.
2414 @var{MFILENAME} is the makefile to generate.
2417 @deffn Method ede-proj-setup-buildenvironment :AFTER this &optional force
2418 Setup the build environment for project @var{THIS}.
2419 Handles the Makefile, or a Makefile.am configure.ac combination.
2420 Optional argument @var{FORCE} will force items to be regenerated.
2423 @deffn Method eieio-done-customizing :AFTER proj
2424 Call this when a user finishes customizing this object.
2425 Argument @var{PROJ} is the project to save.
2428 @deffn Method ede-proj-dist-makefile :AFTER this
2429 Return the name of the Makefile with the DIST target in it for @var{THIS}.
2432 @deffn Method ede-commit-project :AFTER proj
2433 Commit any change to @var{PROJ} to its file.
2436 @deffn Method project-dist-files :AFTER this
2437 Return a list of files that constitutes a distribution of @var{THIS} project.
2440 @deffn Method ede-commit-local-variables :AFTER proj
2441 Commit change to local variables in @var{PROJ}.
2444 @node Targets, Sourcecode, Project, Extending EDE
2450 * ede-proj-target-makefile::
2451 * semantic-ede-proj-target-grammar::
2452 * ede-proj-target-makefile-objectcode::
2453 * ede-proj-target-makefile-archive::
2454 * ede-proj-target-makefile-program::
2455 * ede-proj-target-makefile-shared-object::
2456 * ede-proj-target-elisp::
2457 * ede-proj-target-elisp-autoloads::
2458 * ede-proj-target-makefile-miscelaneous::
2459 * ede-proj-target-makefile-info::
2460 * ede-proj-target-scheme::
2461 * project-am-target::
2462 * project-am-objectcode::
2463 * project-am-program::
2464 * project-am-header-noinst::
2465 * project-am-header-inst::
2467 * project-am-texinfo::
2472 @node ede-target, ede-proj-target, Targets, Targets
2473 @subsection ede-target
2477 @item Inheritance Tree:
2479 @item eieio-speedbar
2481 @item eieio-speedbar-directory-button
2486 @w{ede-cpp-root-target,} @w{ede-emacs-target-c,} @w{ede-emacs-target-el,} @w{ede-emacs-target-misc,} @w{ede-linux-target-c,} @w{ede-linux-target-misc,} @w{ede-maven-target-java,} @w{ede-maven-target-c,} @w{ede-maven-target-misc,} @w{ede-simple-target,} @w{@xref{ede-proj-target},} @w{@xref{project-am-target}.}
2500 Name of this target.
2506 The path to the sources of this target.
2507 Relative to the path of the project it belongs to.
2511 Type: @code{list} @*
2512 Default Value: @code{nil}
2514 Source files in this target.
2517 @item :versionsource
2518 Type: @code{list} @*
2519 Default Value: @code{nil}
2521 Source files with a version string in them.
2522 These files are checked for a version string whenever the EDE version
2523 of the master project is changed. When strings are found, the version
2524 previously there is updated.
2530 @subsubsection Specialized Methods
2532 @deffn Method ede-preprocessor-map :AFTER this
2533 Get the pre-processor map for project @var{THIS}.
2536 @deffn Method eieio-speedbar-description :AFTER obj
2537 Provide a speedbar description for @var{OBJ}.
2540 @deffn Method project-compile-target :AFTER obj &optional command
2541 Compile the current target @var{OBJ}.
2542 Argument @var{COMMAND} is the command to use for compiling the target.
2545 @deffn Method project-debug-target :AFTER obj
2546 Run the current project target @var{OBJ} in a debugger.
2549 @deffn Method ede-convert-path :AFTER this path
2550 Convert path in a standard way for a given project.
2551 Default to making it project relative.
2552 Argument @var{THIS} is the project to convert @var{PATH} to.
2555 @deffn Method ede-name :AFTER this
2556 Return the name of @var{THIS} targt.
2559 @deffn Method ede-target-buffer-in-sourcelist :AFTER this buffer source
2560 Return non-@code{nil} if object @var{THIS} is in @var{BUFFER} to a @var{SOURCE} list.
2561 Handles complex path issues.
2564 @deffn Method eieio-speedbar-derive-line-path :AFTER obj &optional depth
2565 Return the path to @var{OBJ}.
2566 Optional @var{DEPTH} is the depth we start at.
2569 @deffn Method ede-buffer-header-file :AFTER this buffer
2570 There are no default header files in EDE@.
2571 Do a quick check to see if there is a Header tag in this buffer.
2574 @deffn Method project-remove-file :AFTER ot fnnd
2575 Remove the current buffer from project target @var{OT}.
2576 Argument @var{FNND} is an argument.
2579 @deffn Method ede-buffer-documentation-files :AFTER this buffer
2580 Check for some documentation files for @var{THIS}.
2581 Also do a quick check to see if there is a Documentation tag in this @var{BUFFER}.
2584 @deffn Method ede-map-target-buffers :AFTER this proc
2585 For @var{THIS}, execute @var{PROC} on all buffers belonging to @var{THIS}.
2588 @deffn Method eieio-speedbar-child-description :AFTER obj
2589 Provide a speedbar description for a plain-child of @var{OBJ}.
2590 A plain child is a child element which is not an EIEIO object.
2593 @deffn Method ede-object-keybindings :BEFORE this
2594 Retrieves the slot @code{keybindings} from an object of class @code{ede-target}
2597 @deffn Method ede-description :AFTER this
2598 Return a description suitable for the minibuffer about @var{THIS}.
2601 @deffn Method eieio-speedbar-object-children :AFTER this
2602 Return the list of speedbar display children for @var{THIS}.
2605 @deffn Method ede-system-include-path :AFTER this
2606 Get the system include path used by project @var{THIS}.
2609 @deffn Method ede-object-sourcecode :BEFORE this
2610 Retrieves the slot @code{sourcetype} from an object of class @code{ede-target}
2613 @deffn Method ede-expand-filename :AFTER this filename &optional force
2614 Return a fully qualified file name based on target @var{THIS}.
2615 @var{FILENAME} should be a filename which occurs in a directory in which @var{THIS} works.
2616 Optional argument @var{FORCE} forces the default filename to be provided even if it
2620 @deffn Method ede-menu-items-build :AFTER obj &optional current
2621 Return a list of menu items for building target @var{OBJ}.
2622 If optional argument @var{CURRENT} is non-@code{nil}, return sub-menu code.
2625 @deffn Method ede-want-file-p :AFTER this file
2626 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2629 @deffn Method ede-update-version-in-source :AFTER this version
2630 In sources for @var{THIS}, change version numbers to @var{VERSION}.
2633 @deffn Method project-delete-target :AFTER ot
2634 Delete the current target @var{OT} from it's parent project.
2637 @deffn Method ede-target-sourcecode :AFTER this
2638 Return the sourcecode objects which @var{THIS} permits.
2641 @deffn Method eieio-speedbar-child-make-tag-lines :AFTER this depth
2642 Create a speedbar tag line for a child of @var{THIS}.
2643 It has depth @var{DEPTH}.
2646 @deffn Method eieio-speedbar-object-buttonname :AFTER object
2647 Return a string to use as a speedbar button for @var{OBJECT}.
2650 @deffn Method eieio-done-customizing :AFTER target
2651 Call this when a user finishes customizing @var{TARGET}.
2654 @deffn Method project-edit-file-target :AFTER ot
2655 Edit the target @var{OT} associated w/ this file.
2658 @deffn Method ede-documentation :AFTER this
2659 Return a list of files that provides documentation.
2660 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
2661 files in the project.
2664 @deffn Method ede-want-file-source-p :AFTER this file
2665 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2668 @deffn Method ede-want-file-auxiliary-p :AFTER this file
2669 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2672 @deffn Method project-add-file :AFTER ot file
2673 Add the current buffer into project project target @var{OT}.
2674 Argument @var{FILE} is the file to add.
2677 @deffn Method ede-target-name :AFTER this
2678 Return the name of @var{THIS} target, suitable for make or debug style commands.
2681 @deffn Method ede-object-menu :BEFORE this
2682 Retrieves the slot @code{menu} from an object of class @code{ede-target}
2685 @node ede-proj-target, ede-proj-target-makefile, ede-target, Targets
2686 @subsection ede-proj-target
2687 @tgindex ede-proj-target
2690 @item Inheritance Tree:
2692 @item eieio-speedbar
2694 @item eieio-speedbar-directory-button
2696 @item @w{@xref{ede-target}.}
2698 @item ede-proj-target
2701 @w{@xref{ede-proj-target-makefile},} @w{ede-proj-target-aux,} @w{@xref{ede-proj-target-scheme}.}
2716 Name of this target.
2722 The path to the sources of this target.
2723 Relative to the path of the project it belongs to.
2727 Type: @code{list} @*
2728 Default Value: @code{nil}
2730 Auxiliary source files included in this target.
2731 Each of these is considered equivalent to a source file, but it is not
2732 distributed, and each should have a corresponding rule to build it.
2736 Type: @code{(or null symbol)} @*
2737 Default Value: @code{nil}
2739 The compiler to be used to compile this object.
2740 This should be a symbol, which contains the object defining the compiler.
2741 This enables save/restore to do so by name, permitting the sharing
2742 of these compiler resources, and global customization thereof.
2746 Type: @code{(or null symbol)} @*
2747 Default Value: @code{nil}
2749 The linker to be used to link compiled sources for this object.
2750 This should be a symbol, which contains the object defining the linker.
2751 This enables save/restore to do so by name, permitting the sharing
2752 of these linker resources, and global customization thereof.
2758 @subsubsection Specialized Methods
2760 @deffn Method project-compile-target :AFTER obj &optional command
2761 Compile the current target @var{OBJ}.
2762 Argument @var{COMMAND} is the command to use for compiling the target.
2765 @deffn Method project-debug-target :AFTER obj
2766 Run the current project target @var{OBJ} in a debugger.
2769 @deffn Method ede-proj-configure-add-missing :AFTER this
2770 Query if any files needed by @var{THIS} provided by automake are missing.
2771 Results in --add-missing being passed to automake.
2774 @deffn Method ede-proj-flush-autoconf :AFTER this
2775 Flush the configure file (current buffer) to accommodate @var{THIS}.
2776 By flushing, remove any cruft that may be in the file. Subsequent
2777 calls to @dfn{ede-proj-tweak-autoconf} can restore items removed by flush.
2780 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2781 Insert rules needed by @var{THIS} target.
2784 @deffn Method project-remove-file :AFTER target file
2785 For @var{TARGET}, remove @var{FILE}.
2786 @var{FILE} must be massaged by @dfn{ede-convert-path}.
2789 @deffn Method ede-proj-configure-create-missing :AFTER this
2790 Add any missing files for @var{THIS} by creating them.
2793 @deffn Method ede-proj-makefile-sourcevar :AFTER this
2794 Return the variable name for @var{THIS}'s sources.
2797 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
2798 Insert variables needed by target @var{THIS}.
2799 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2803 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
2804 Insert variables needed by target @var{THIS} in Makefile.am after SOURCES.
2807 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
2808 Insert any symbols that the DIST rule should depend on.
2809 Argument @var{THIS} is the target that should insert stuff.
2812 @deffn Method ede-proj-linkers :AFTER obj
2813 List of linkers being used by @var{OBJ}.
2814 If the @code{linker} slot is empty, concoct one on a first match found
2815 basis for any given type from the @code{availablelinkers} slot.
2816 Otherwise, return the @code{linker} slot.
2817 Converts all symbols into the objects to be used.
2820 @deffn Method ede-proj-makefile-garbage-patterns :AFTER this
2821 Return a list of patterns that are considered garbage to @var{THIS}.
2822 These are removed with make clean.
2825 @deffn Method ede-proj-tweak-autoconf :AFTER this
2826 Tweak the configure file (current buffer) to accommodate @var{THIS}.
2829 @deffn Method ede-proj-compilers :AFTER obj
2830 List of compilers being used by @var{OBJ}.
2831 If the @code{compiler} slot is empty, concoct one on a first match found
2832 basis for any given type from the @code{availablecompilers} slot.
2833 Otherwise, return the @code{compiler} slot.
2834 Converts all symbols into the objects to be used.
2837 @deffn Method project-delete-target :AFTER this
2838 Delete the current target @var{THIS} from it's parent project.
2841 @deffn Method ede-proj-makefile-target-name :AFTER this
2842 Return the name of the main target for @var{THIS} target.
2845 @deffn Method eieio-done-customizing :AFTER target
2846 Call this when a user finishes customizing this object.
2847 Argument @var{TARGET} is the project we are completing customization on.
2850 @deffn Method ede-proj-makefile-insert-user-rules :AFTER this
2851 Insert user specified rules needed by @var{THIS} target.
2854 @deffn Method project-add-file :AFTER this file
2855 Add to target @var{THIS} the current buffer represented as @var{FILE}.
2858 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
2859 Insert variables needed by target @var{THIS} in Makefile.am before SOURCES.
2862 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
2863 Insert any symbols that the DIST rule should depend on.
2864 Argument @var{THIS} is the target that should insert stuff.
2867 @deffn Method ede-proj-makefile-dependency-files :AFTER this
2868 Return a list of source files to convert to dependencies.
2869 Argument @var{THIS} is the target to get sources from.
2872 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
2873 Insert the source variables needed by @var{THIS}.
2874 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2879 @node ede-proj-target-makefile, semantic-ede-proj-target-grammar, ede-proj-target, Targets
2880 @subsection ede-proj-target-makefile
2881 @tgindex ede-proj-target-makefile
2884 @item Inheritance Tree:
2886 @item eieio-speedbar
2888 @item eieio-speedbar-directory-button
2890 @item @w{@xref{ede-target}.}
2892 @item @w{@xref{ede-proj-target}.}
2894 @item ede-proj-target-makefile
2897 @w{@xref{semantic-ede-proj-target-grammar},} @w{@xref{ede-proj-target-makefile-objectcode},} @w{@xref{ede-proj-target-elisp},} @w{@xref{ede-proj-target-makefile-miscelaneous},} @w{@xref{ede-proj-target-makefile-info}.}
2911 Type: @code{string} @*
2912 Default Value: @code{"Makefile"}
2914 File name of generated Makefile.
2918 Type: @code{boolean} @*
2919 Default Value: @code{t}
2921 Non @code{nil} means the rule created is part of the all target.
2922 Setting this to @code{nil} creates the rule to build this item, but does not
2923 include it in the ALL`all:' rule.
2926 @item :configuration-variables
2927 Type: @code{list} @*
2928 Default Value: @code{nil}
2930 Makefile variables appended to use in different configurations.
2931 These variables are used in the makefile when a configuration becomes active.
2932 Target variables are always renamed such as foo_CFLAGS, then included into
2933 commands where the variable would usually appear.
2937 Type: @code{list} @*
2938 Default Value: @code{nil}
2940 Arbitrary rules and dependencies needed to make this target.
2941 It is safe to leave this blank.
2947 @subsubsection Specialized Methods
2949 @deffn Method ede-proj-makefile-dependencies :AFTER this
2950 Return a string representing the dependencies for @var{THIS}.
2951 Some compilers only use the first element in the dependencies, others
2952 have a list of intermediates (object files), and others don't care.
2953 This allows customization of how these elements appear.
2956 @deffn Method project-compile-target :AFTER obj &optional command
2957 Compile the current target program @var{OBJ}.
2958 Optional argument @var{COMMAND} is the s the alternate command to use.
2961 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2962 Insert rules needed by @var{THIS} target.
2965 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
2966 Insert variables needed by target @var{THIS}.
2967 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2971 @deffn Method ede-proj-makefile-insert-commands :AFTER this
2972 Insert the commands needed by target @var{THIS}.
2973 For targets, insert the commands needed by the chosen compiler.
2976 @deffn Method ede-proj-makefile-configuration-variables :AFTER this configuration
2977 Return a list of configuration variables from @var{THIS}.
2978 Use @var{CONFIGURATION} as the current configuration to query.
2981 @node semantic-ede-proj-target-grammar, ede-proj-target-makefile-objectcode, ede-proj-target-makefile, Targets
2982 @subsection semantic-ede-proj-target-grammar
2983 @tgindex semantic-ede-proj-target-grammar
2986 @item Inheritance Tree:
2988 @item eieio-speedbar
2990 @item eieio-speedbar-directory-button
2992 @item @w{@xref{ede-target}.}
2994 @item @w{@xref{ede-proj-target}.}
2996 @item @w{@xref{ede-proj-target-makefile}.}
2998 @item semantic-ede-proj-target-grammar
3008 @subsubsection Specialized Methods
3010 @deffn Method project-compile-target :AFTER obj
3011 Compile all sources in a Lisp target @var{OBJ}.
3014 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3015 Insert rules needed by @var{THIS} target.
3018 @deffn Method ede-buffer-mine :AFTER this buffer
3019 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3020 Lays claim to all -by.el, and -wy.el files.
3023 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3024 Return the variable name for @var{THIS}'s sources.
3027 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3028 Insert dist dependencies, or intermediate targets.
3029 This makes sure that all grammar lisp files are created before the dist
3030 runs, so they are always up to date.
3031 Argument @var{THIS} is the target that should insert stuff.
3035 @node ede-proj-target-makefile-objectcode, ede-proj-target-makefile-archive, semantic-ede-proj-target-grammar, Targets
3036 @subsection ede-proj-target-makefile-objectcode
3037 @tgindex ede-proj-target-makefile-objectcode
3040 @item Inheritance Tree:
3042 @item eieio-speedbar
3044 @item eieio-speedbar-directory-button
3046 @item @w{@xref{ede-target}.}
3048 @item @w{@xref{ede-proj-target}.}
3050 @item @w{@xref{ede-proj-target-makefile}.}
3052 @item ede-proj-target-makefile-objectcode
3055 @w{@xref{ede-proj-target-makefile-archive},} @w{@xref{ede-proj-target-makefile-program}.}
3069 @item :configuration-variables
3070 Type: @code{list} @*
3071 Default Value: @code{("debug" ("CFLAGS" . "-g") ("LDFLAGS" . "-g"))}
3073 @xref{ede-proj-target-makefile}.
3076 @subsubsection Specialized Methods
3078 @deffn Method ede-buffer-header-file :AFTER this buffer
3079 There are no default header files.
3082 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3083 Return the variable name for @var{THIS}'s sources.
3086 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
3087 Insert variables needed by target @var{THIS}.
3088 Optional argument @var{MORESOURCE} is not used.
3091 @deffn Method ede-proj-makefile-dependency-files :AFTER this
3092 Return a list of source files to convert to dependencies.
3093 Argument @var{THIS} is the target to get sources from.
3097 @node ede-proj-target-makefile-archive, ede-proj-target-makefile-program, ede-proj-target-makefile-objectcode, Targets
3098 @subsection ede-proj-target-makefile-archive
3099 @tgindex ede-proj-target-makefile-archive
3102 @item Inheritance Tree:
3104 @item eieio-speedbar
3106 @item eieio-speedbar-directory-button
3108 @item @w{@xref{ede-target}.}
3110 @item @w{@xref{ede-proj-target}.}
3112 @item @w{@xref{ede-proj-target-makefile}.}
3114 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3116 @item ede-proj-target-makefile-archive
3127 @subsubsection Specialized Methods
3129 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3130 Create the make rule needed to create an archive for @var{THIS}.
3133 @deffn Method ede-proj-makefile-insert-source-variables :PRIMARY this
3134 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3135 We aren't actually inserting SOURCE details, but this is used by the
3136 Makefile.am generator, so use it to add this important bin program.
3140 @node ede-proj-target-makefile-program, ede-proj-target-makefile-shared-object, ede-proj-target-makefile-archive, Targets
3141 @subsection ede-proj-target-makefile-program
3142 @tgindex ede-proj-target-makefile-program
3145 @item Inheritance Tree:
3147 @item eieio-speedbar
3149 @item eieio-speedbar-directory-button
3151 @item @w{@xref{ede-target}.}
3153 @item @w{@xref{ede-proj-target}.}
3155 @item @w{@xref{ede-proj-target-makefile}.}
3157 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3159 @item ede-proj-target-makefile-program
3162 @w{@xref{ede-proj-target-makefile-shared-object}.}
3178 Type: @code{list} @*
3179 Default Value: @code{nil}
3181 Libraries, such as "m" or "Xt" which this program depends on.
3182 The linker flag "-l" is automatically prepended. Do not include a "lib"
3183 prefix, or a ".so" suffix.
3185 Note: Currently only used for Automake projects.
3189 Type: @code{list} @*
3190 Default Value: @code{nil}
3192 Additional flags to add when linking this target.
3193 Use ldlibs to add addition libraries. Use this to specify specific
3194 options to the linker.
3196 Note: Not currently used. This bug needs to be fixed.
3202 @subsubsection Specialized Methods
3204 @deffn Method project-debug-target :AFTER obj
3205 Debug a program target @var{OBJ}.
3208 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3209 Insert rules needed by @var{THIS} target.
3212 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
3213 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3216 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
3217 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3221 @node ede-proj-target-makefile-shared-object, ede-proj-target-elisp, ede-proj-target-makefile-program, Targets
3222 @subsection ede-proj-target-makefile-shared-object
3223 @tgindex ede-proj-target-makefile-shared-object
3226 @item Inheritance Tree:
3228 @item eieio-speedbar
3230 @item eieio-speedbar-directory-button
3232 @item @w{@xref{ede-target}.}
3234 @item @w{@xref{ede-proj-target}.}
3236 @item @w{@xref{ede-proj-target-makefile}.}
3238 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3240 @item @w{@xref{ede-proj-target-makefile-program}.}
3242 @item ede-proj-target-makefile-shared-object
3254 @subsubsection Specialized Methods
3256 @deffn Method ede-proj-configure-add-missing :AFTER this
3257 Query if any files needed by @var{THIS} provided by automake are missing.
3258 Results in --add-missing being passed to automake.
3261 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3262 Return the variable name for @var{THIS}'s sources.
3265 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
3266 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3267 We need to override -program which has an LDADD element.
3270 @deffn Method ede-proj-makefile-target-name :AFTER this
3271 Return the name of the main target for @var{THIS} target.
3274 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
3275 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3276 We aren't actually inserting SOURCE details, but this is used by the
3277 Makefile.am generator, so use it to add this important bin program.
3281 @node ede-proj-target-elisp, ede-proj-target-elisp-autoloads, ede-proj-target-makefile-shared-object, Targets
3282 @subsection ede-proj-target-elisp
3283 @tgindex ede-proj-target-elisp
3286 @item Inheritance Tree:
3288 @item eieio-speedbar
3290 @item eieio-speedbar-directory-button
3292 @item @w{@xref{ede-target}.}
3294 @item @w{@xref{ede-proj-target}.}
3296 @item @w{@xref{ede-proj-target-makefile}.}
3298 @item ede-proj-target-elisp
3301 @w{@xref{ede-proj-target-elisp-autoloads}.}
3316 Type: @code{list} @*
3317 Default Value: @code{nil}
3319 Additional packages needed.
3320 There should only be one toplevel package per auxiliary tool needed.
3321 These packages location is found, and added to the compile time
3328 @subsubsection Specialized Methods
3330 @deffn Method project-compile-target :AFTER obj
3331 Compile all sources in a Lisp target @var{OBJ}.
3332 Bonus: Return a cons cell: (COMPILED . UPTODATE).
3335 @deffn Method ede-proj-flush-autoconf :AFTER this
3336 Flush the configure file (current buffer) to accommodate @var{THIS}.
3339 @deffn Method ede-buffer-mine :AFTER this buffer
3340 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3341 Lays claim to all .elc files that match .el files in this target.
3344 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3345 Return the variable name for @var{THIS}'s sources.
3348 @deffn Method ede-proj-tweak-autoconf :AFTER this
3349 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3352 @deffn Method ede-update-version-in-source :AFTER this version
3353 In a Lisp file, updated a version string for @var{THIS} to @var{VERSION}.
3354 There are standards in Elisp files specifying how the version string
3355 is found, such as a @code{-version} variable, or the standard header.
3358 @node ede-proj-target-elisp-autoloads, ede-proj-target-makefile-miscelaneous, ede-proj-target-elisp, Targets
3359 @subsection ede-proj-target-elisp-autoloads
3360 @tgindex ede-proj-target-elisp-autoloads
3363 @item Inheritance Tree:
3365 @item eieio-speedbar
3367 @item eieio-speedbar-directory-button
3369 @item @w{@xref{ede-target}.}
3371 @item @w{@xref{ede-proj-target}.}
3373 @item @w{@xref{ede-proj-target-makefile}.}
3375 @item @w{@xref{ede-proj-target-elisp}.}
3377 @item ede-proj-target-elisp-autoloads
3393 Type: @code{list} @*
3394 Default Value: @code{("cedet-autogen")}
3396 @xref{ede-proj-target-elisp}.
3397 @item :autoload-file
3398 Type: @code{string} @*
3399 Default Value: @code{"loaddefs.el"}
3401 The file that autoload definitions are placed in.
3402 There should be one load defs file for a given package. The load defs are created
3403 for all Emacs Lisp sources that exist in the directory of the created target.
3406 @item :autoload-dirs
3407 Type: @code{list} @*
3408 Default Value: @code{nil}
3410 The directories to scan for autoload definitions.
3411 If @code{nil} defaults to the current directory.
3417 @subsubsection Specialized Methods
3419 @deffn Method ede-proj-makefile-dependencies :AFTER this
3420 Return a string representing the dependencies for @var{THIS}.
3421 Always return an empty string for an autoloads generator.
3424 @deffn Method project-compile-target :AFTER obj
3425 Create or update the autoload target.
3428 @deffn Method ede-proj-flush-autoconf :AFTER this
3429 Flush the configure file (current buffer) to accommodate @var{THIS}.
3432 @deffn Method ede-buffer-mine :AFTER this buffer
3433 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3434 Lays claim to all .elc files that match .el files in this target.
3437 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3438 Return the variable name for @var{THIS}'s sources.
3441 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3442 Insert any symbols that the DIST rule should depend on.
3443 Emacs Lisp autoload files ship the generated .el files.
3444 Argument @var{THIS} is the target which needs to insert an info file.
3447 @deffn Method ede-proj-tweak-autoconf :AFTER this
3448 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3451 @deffn Method ede-update-version-in-source :AFTER this version
3452 In a Lisp file, updated a version string for @var{THIS} to @var{VERSION}.
3453 There are standards in Elisp files specifying how the version string
3454 is found, such as a @code{-version} variable, or the standard header.
3457 @deffn Method ede-proj-compilers :AFTER obj
3458 List of compilers being used by @var{OBJ}.
3459 If the @code{compiler} slot is empty, get the car of the compilers list.
3462 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
3463 Insert any symbols that the DIST rule should distribute.
3464 Emacs Lisp autoload files ship the generated .el files.
3465 Argument @var{THIS} is the target which needs to insert an info file.
3468 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
3469 Insert the source variables needed by @var{THIS}.
3470 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
3475 @node ede-proj-target-makefile-miscelaneous, ede-proj-target-makefile-info, ede-proj-target-elisp-autoloads, Targets
3476 @subsection ede-proj-target-makefile-miscelaneous
3477 @tgindex ede-proj-target-makefile-miscelaneous
3480 @item Inheritance Tree:
3482 @item eieio-speedbar
3484 @item eieio-speedbar-directory-button
3486 @item @w{@xref{ede-target}.}
3488 @item @w{@xref{ede-proj-target}.}
3490 @item @w{@xref{ede-proj-target-makefile}.}
3492 @item ede-proj-target-makefile-miscelaneous
3507 Type: @code{string} @*
3508 Default Value: @code{""}
3510 Miscellaneous sources which have a specialized makefile.
3511 The sub-makefile is used to build this target.
3517 @subsubsection Specialized Methods
3519 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3520 Create the make rule needed to create an archive for @var{THIS}.
3523 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3524 Return the variable name for @var{THIS}'s sources.
3527 @deffn Method ede-proj-makefile-dependency-files :AFTER this
3528 Return a list of files which @var{THIS} target depends on.
3532 @node ede-proj-target-makefile-info, ede-proj-target-scheme, ede-proj-target-makefile-miscelaneous, Targets
3533 @subsection ede-proj-target-makefile-info
3534 @tgindex ede-proj-target-makefile-info
3537 @item Inheritance Tree:
3539 @item eieio-speedbar
3541 @item eieio-speedbar-directory-button
3543 @item @w{@xref{ede-target}.}
3545 @item @w{@xref{ede-proj-target}.}
3547 @item @w{@xref{ede-proj-target-makefile}.}
3549 @item ede-proj-target-makefile-info
3564 Type: @code{string} @*
3565 Default Value: @code{""}
3567 The main menu resides in this file.
3568 All other sources should be included independently.
3574 @subsubsection Specialized Methods
3576 @deffn Method ede-proj-configure-add-missing :AFTER this
3577 Query if any files needed by @var{THIS} provided by automake are missing.
3578 Results in --add-missing being passed to automake.
3581 @deffn Method object-write :AFTER this
3582 Before committing any change to @var{THIS}, make sure the mainmenu is first.
3585 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3586 Return the variable name for @var{THIS}'s sources.
3589 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3590 Insert any symbols that the DIST rule should depend on.
3591 Texinfo files want to insert generated `.info' files.
3592 Argument @var{THIS} is the target which needs to insert an info file.
3595 @deffn Method ede-proj-makefile-target-name :AFTER this
3596 Return the name of the main target for @var{THIS} target.
3599 @deffn Method ede-documentation :AFTER this
3600 Return a list of files that provides documentation.
3601 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
3602 files in the project.
3605 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
3606 Insert any symbols that the DIST rule should depend on.
3607 Texinfo files want to insert generated `.info' files.
3608 Argument @var{THIS} is the target which needs to insert an info file.
3611 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
3612 Insert the source variables needed by @var{THIS} info target.
3613 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
3615 Does the usual for Makefile mode, but splits source into two variables
3616 when working in Automake mode.
3619 @node ede-proj-target-scheme, project-am-target, ede-proj-target-makefile-info, Targets
3620 @subsection ede-proj-target-scheme
3621 @tgindex ede-proj-target-scheme
3624 @item Inheritance Tree:
3626 @item eieio-speedbar
3628 @item eieio-speedbar-directory-button
3630 @item @w{@xref{ede-target}.}
3632 @item @w{@xref{ede-proj-target}.}
3634 @item ede-proj-target-scheme
3648 Type: @code{string} @*
3649 Default Value: @code{"guile"}
3651 The preferred interpreter for this code.
3657 @subsubsection Specialized Methods
3659 @deffn Method ede-proj-tweak-autoconf :AFTER this
3660 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3664 @node project-am-target, project-am-objectcode, ede-proj-target-scheme, Targets
3665 @subsection project-am-target
3666 @tgindex project-am-target
3669 @item Inheritance Tree:
3671 @item eieio-speedbar
3673 @item eieio-speedbar-directory-button
3675 @item @w{@xref{ede-target}.}
3677 @item project-am-target
3680 @w{@xref{project-am-objectcode},} @w{project-am-header,} @w{@xref{project-am-lisp},} @w{@xref{project-am-texinfo},} @w{@xref{project-am-man}.}
3688 @subsubsection Specialized Methods
3690 @deffn Method project-compile-target-command :AFTER this
3691 Default target to use when compiling a given target.
3694 @deffn Method project-make-dist :AFTER this
3695 Run the current project in the debugger.
3698 @deffn Method project-edit-file-target :AFTER obj
3699 Edit the target associated w/ this file.
3702 @node project-am-objectcode, project-am-program, project-am-target, Targets
3703 @subsection project-am-objectcode
3704 @tgindex project-am-objectcode
3707 @item Inheritance Tree:
3709 @item eieio-speedbar
3711 @item eieio-speedbar-directory-button
3713 @item @w{@xref{ede-target}.}
3715 @item @w{@xref{project-am-target}.}
3717 @item project-am-objectcode
3720 @w{@xref{project-am-program},} @w{project-am-lib.}
3729 @subsubsection Specialized Methods
3731 @deffn Method project-am-macro :AFTER this
3732 Return the default macro to 'edit' for this object type.
3735 @deffn Method project-debug-target :AFTER obj
3736 Run the current project target in a debugger.
3739 @deffn Method project-compile-target-command :AFTER this
3740 Default target to use when compiling an object code target.
3743 @deffn Method ede-buffer-header-file :AFTER this buffer
3744 There are no default header files.
3747 @node project-am-program, project-am-header-noinst, project-am-objectcode, Targets
3748 @subsection project-am-program
3749 @tgindex project-am-program
3752 @item Inheritance Tree:
3754 @item eieio-speedbar
3756 @item eieio-speedbar-directory-button
3758 @item @w{@xref{ede-target}.}
3760 @item @w{@xref{project-am-target}.}
3762 @item @w{@xref{project-am-objectcode}.}
3764 @item project-am-program
3779 Default Value: @code{nil}
3786 @node project-am-header-noinst, project-am-header-inst, project-am-program, Targets
3787 @subsection project-am-header-noinst
3788 @tgindex project-am-header-noinst
3791 @item Inheritance Tree:
3793 @item eieio-speedbar
3795 @item eieio-speedbar-directory-button
3797 @item @w{@xref{ede-target}.}
3799 @item @w{@xref{project-am-target}.}
3801 @item @w{project-am-header.}
3803 @item project-am-header-noinst
3813 @subsubsection Specialized Methods
3815 @deffn Method project-am-macro :AFTER this
3816 Return the default macro to 'edit' for this object.
3819 @node project-am-header-inst, project-am-lisp, project-am-header-noinst, Targets
3820 @subsection project-am-header-inst
3821 @tgindex project-am-header-inst
3824 @item Inheritance Tree:
3826 @item eieio-speedbar
3828 @item eieio-speedbar-directory-button
3830 @item @w{@xref{ede-target}.}
3832 @item @w{@xref{project-am-target}.}
3834 @item @w{project-am-header.}
3836 @item project-am-header-inst
3846 @subsubsection Specialized Methods
3848 @deffn Method project-am-macro :AFTER this
3849 Return the default macro to 'edit' for this object.
3852 @node project-am-lisp, project-am-texinfo, project-am-header-inst, Targets
3853 @subsection project-am-lisp
3854 @tgindex project-am-lisp
3857 @item Inheritance Tree:
3859 @item eieio-speedbar
3861 @item eieio-speedbar-directory-button
3863 @item @w{@xref{ede-target}.}
3865 @item @w{@xref{project-am-target}.}
3867 @item project-am-lisp
3876 @subsubsection Specialized Methods
3878 @deffn Method project-am-macro :AFTER this
3879 Return the default macro to 'edit' for this object.
3882 @node project-am-texinfo, project-am-man, project-am-lisp, Targets
3883 @subsection project-am-texinfo
3884 @tgindex project-am-texinfo
3887 @item Inheritance Tree:
3889 @item eieio-speedbar
3891 @item eieio-speedbar-directory-button
3893 @item @w{@xref{ede-target}.}
3895 @item @w{@xref{project-am-target}.}
3897 @item project-am-texinfo
3911 Default Value: @code{nil}
3913 Additional texinfo included in this one.
3918 @subsubsection Specialized Methods
3920 @deffn Method project-am-macro :AFTER this
3921 Return the default macro to 'edit' for this object type.
3924 @deffn Method project-compile-target-command :AFTER this
3925 Default target to use when compiling a texinfo file.
3928 @deffn Method ede-documentation :AFTER this
3929 Return a list of files that provides documentation.
3930 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
3931 files in the project.
3934 @node project-am-man, , project-am-texinfo, Targets
3935 @comment node-name, next, previous, up
3936 @subsection project-am-man
3937 @tgindex project-am-man
3940 @item Inheritance Tree:
3942 @item eieio-speedbar
3944 @item eieio-speedbar-directory-button
3946 @item @w{@xref{ede-target}.}
3948 @item @w{@xref{project-am-target}.}
3950 @item project-am-man
3959 @subsubsection Specialized Methods
3961 @deffn Method project-am-macro :AFTER this
3962 Return the default macro to 'edit' for this object type.
3965 @node Sourcecode, Compilers, Targets, Extending EDE
3968 The source code type is an object designed to associated files with
3976 @node ede-sourcecode, , Sourcecode, Sourcecode
3977 @subsection ede-sourcecode
3978 @scindex ede-sourcecode
3981 @item Inheritance Tree:
3983 @item eieio-instance-inheritor
3985 @item ede-sourcecode
3995 @item :parent-instance
3996 Type: @code{eieio-instance-inheritor-child}
3998 The parent of this instance.
3999 If a slot of this class is reference, and is unbound, then the parent
4000 is checked for a value.
4006 The name of this type of source code.
4007 Such as "C" or "Emacs Lisp"
4010 @item :sourcepattern
4011 Type: @code{string} @*
4012 Default Value: @code{".*"}
4014 Emacs regex matching sourcecode this target accepts.
4017 @item :auxsourcepattern
4018 Type: @code{(or null string)} @*
4019 Default Value: @code{nil}
4021 Emacs regex matching auxiliary source code this target accepts.
4022 Aux source are source code files needed for compilation, which are not compiled
4026 @item :enable-subdirectories
4027 Type: @code{boolean} @*
4028 Default Value: @code{nil}
4030 Non @code{nil} if this sourcecode type uses subdirectores.
4031 If sourcecode always lives near the target creating it, this should be nil.
4032 If sourcecode can, or typically lives in a subdirectory of the owning
4033 target, set this to t.
4036 @item :garbagepattern
4037 Type: @code{list} @*
4038 Default Value: @code{nil}
4040 Shell file regex matching files considered as garbage.
4041 This is a list of items added to an @code{rm} command when executing a @code{clean}
4048 @subsubsection Specialized Methods
4050 @deffn Method ede-want-any-files-p :AFTER this filenames
4051 Return non-@code{nil} if @var{THIS} will accept any files in @var{FILENAMES}.
4054 @deffn Method ede-want-any-source-files-p :AFTER this filenames
4055 Return non-@code{nil} if @var{THIS} will accept any source files in @var{FILENAMES}.
4058 @deffn Method ede-want-any-auxiliary-files-p :AFTER this filenames
4059 Return non-@code{nil} if @var{THIS} will accept any aux files in @var{FILENAMES}.
4062 @deffn Method ede-buffer-header-file :AFTER this filename
4063 Return a list of file names of header files for @var{THIS} with @var{FILENAME}.
4064 Used to guess header files, but uses the auxsource regular expression.
4067 @deffn Method ede-want-file-p :AFTER this filename
4068 Return non-@code{nil} if sourcecode definition @var{THIS} will take @var{FILENAME}.
4071 @deffn Method ede-want-file-source-p :AFTER this filename
4072 Return non-@code{nil} if @var{THIS} will take @var{FILENAME} as an auxiliary .
4075 @deffn Method ede-want-file-auxiliary-p :AFTER this filename
4076 Return non-@code{nil} if @var{THIS} will take @var{FILENAME} as an auxiliary .
4079 @node Compilers, , Sourcecode, Extending EDE
4082 The compiler object is designed to associate source code with
4083 compilers. The target then references the compilers it can use.
4084 When the makefile is created, this object type knows how to create
4088 * ede-compilation-program::
4090 * ede-object-compiler::
4095 @node ede-compilation-program, ede-compiler, Compilers, Compilers
4096 @subsection ede-compilation-program
4097 @cmindex ede-compilation-program
4100 @item Inheritance Tree:
4102 @item eieio-instance-inheritor
4104 @item ede-compilation-program
4107 @w{@xref{ede-compiler},} @w{@xref{ede-linker}.}
4117 @item :parent-instance
4118 Type: @code{eieio-instance-inheritor-child}
4120 The parent of this instance.
4121 If a slot of this class is reference, and is unbound, then the parent
4122 is checked for a value.
4128 Name of this type of compiler.
4134 Variables needed in the Makefile for this compiler.
4135 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4136 is a string, and VALUE is either a string, or a list of strings.
4137 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4143 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4144 This is used to match target objects with the compilers and linkers
4145 they can use, and which files this object is interested in.
4149 Type: @code{list} @*
4150 Default Value: @code{nil}
4152 Auxiliary rules needed for this compiler to run.
4153 For example, yacc/lex files need additional chain rules, or inferences.
4159 The commands used to execute this compiler.
4160 The object which uses this compiler will place these commands after
4161 it's rule definition.
4165 Type: @code{list} @*
4166 Default Value: @code{nil}
4168 Autoconf function to call if this type of compiler is used.
4169 When a project is in Automake mode, this defines the autoconf function to
4170 call to initialize automake to use this compiler.
4171 For example, there may be multiple C compilers, but they all probably
4172 use the same autoconf form.
4175 @item :objectextention
4178 A string which is the extension used for object files.
4179 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4185 @subsubsection Specialized Methods
4187 @deffn Method ede-proj-flush-autoconf :AFTER this
4188 Flush the configure file (current buffer) to accommodate @var{THIS}.
4191 @deffn Method ede-proj-makefile-insert-rules :AFTER this
4192 Insert rules needed for @var{THIS} compiler object.
4195 @deffn Method ede-proj-makefile-insert-variables :AFTER this
4196 Insert variables needed by the compiler @var{THIS}.
4199 @deffn Method ede-proj-makefile-insert-commands :AFTER this
4200 Insert the commands needed to use compiler @var{THIS}.
4201 The object creating makefile rules must call this method for the
4202 compiler it decides to use after inserting in the rule.
4205 @deffn Method ede-object-sourcecode :AFTER this
4206 Retrieves the slot @code{sourcetype} from an object of class @code{ede-compilation-program}
4209 @deffn Method ede-proj-tweak-autoconf :AFTER this
4210 Tweak the configure file (current buffer) to accommodate @var{THIS}.
4214 @node ede-compiler, ede-object-compiler, ede-compilation-program, Compilers
4215 @subsection ede-compiler
4216 @cmindex ede-compiler
4219 @item Inheritance Tree:
4221 @item eieio-instance-inheritor
4223 @item @w{@xref{ede-compilation-program}.}
4228 @w{@xref{ede-object-compiler},} @w{semantic-ede-grammar-compiler-class.}
4238 Create a new object with name NAME of class type ede-compiler
4244 @item :parent-instance
4245 Type: @code{eieio-instance-inheritor-child}
4247 The parent of this instance.
4248 If a slot of this class is reference, and is unbound, then the parent
4249 is checked for a value.
4255 Name of this type of compiler.
4261 Variables needed in the Makefile for this compiler.
4262 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4263 is a string, and VALUE is either a string, or a list of strings.
4264 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4270 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4271 This is used to match target objects with the compilers and linkers
4272 they can use, and which files this object is interested in.
4278 The commands used to execute this compiler.
4279 The object which uses this compiler will place these commands after
4280 it's rule definition.
4283 @item :objectextention
4286 A string which is the extension used for object files.
4287 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4291 Type: @code{boolean} @*
4292 Default Value: @code{nil}
4294 Non-@code{nil} if this compiler can make dependencies.
4298 Type: @code{boolean} @*
4299 Default Value: @code{nil}
4301 Non-@code{nil} if this compiler creates code that can be linked.
4302 This requires that the containing target also define a list of available
4303 linkers that can be used.
4309 @subsubsection Specialized Methods
4311 @deffn Method ede-proj-makefile-insert-object-variables :AFTER this targetname sourcefiles
4312 Insert an OBJ variable to specify object code to be generated for @var{THIS}.
4313 The name of the target is @var{TARGETNAME} as a string. @var{SOURCEFILES} is the list of
4314 files to be objectified.
4315 Not all compilers do this.
4318 @deffn Method ede-compiler-intermediate-objects-p :AFTER this
4319 Return non-@code{nil} if @var{THIS} has intermediate object files.
4320 If this compiler creates code that can be linked together,
4321 then the object files created by the compiler are considered intermediate.
4324 @deffn Method ede-compiler-intermediate-object-variable :AFTER this targetname
4325 Return a string based on @var{THIS} representing a make object variable.
4326 @var{TARGETNAME} is the name of the target that these objects belong to.
4330 @node ede-object-compiler, ede-linker, ede-compiler, Compilers
4331 @subsection ede-object-compiler
4332 @cmindex ede-object-compiler
4335 @item Inheritance Tree:
4337 @item eieio-instance-inheritor
4339 @item @w{@xref{ede-compilation-program}.}
4341 @item @w{@xref{ede-compiler}.}
4343 @item ede-object-compiler
4356 Type: @code{boolean} @*
4357 Default Value: @code{t}
4359 @xref{ede-compiler}.
4360 @item :dependencyvar
4363 A variable dedicated to dependency generation.
4368 @subsubsection Specialized Methods
4370 @deffn Method ede-proj-makefile-insert-variables :AFTER this
4371 Insert variables needed by the compiler @var{THIS}.
4374 @node ede-linker, , ede-object-compiler, Compilers
4375 @subsection ede-linker
4379 @item Inheritance Tree:
4381 @item eieio-instance-inheritor
4383 @item @w{@xref{ede-compilation-program}.}
4394 Create a new object with name NAME of class type ede-linker
4403 Name of this type of compiler.
4409 Variables needed in the Makefile for this compiler.
4410 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4411 is a string, and VALUE is either a string, or a list of strings.
4412 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4418 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4419 This is used to match target objects with the compilers and linkers
4420 they can use, and which files this object is interested in.
4426 The commands used to execute this compiler.
4427 The object which uses this compiler will place these commands after
4428 it's rule definition.
4431 @item :objectextention
4434 A string which is the extension used for object files.
4435 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4441 @node GNU Free Documentation License, , Extending EDE, Top
4442 @appendix GNU Free Documentation License
4443 @include doclicense.texi