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 Free Software Foundation, Inc.
11 Permission is granted to copy, distribute and/or modify this document
12 under the terms of the GNU Free Documentation License, Version 1.3 or
13 any later version published by the Free Software Foundation; with no
14 Invariant Sections, with the Front-Cover texts being ``A GNU Manual,''
15 and with the Back-Cover Texts as in (a) below. A copy of the license
16 is included in the section entitled ``GNU Free Documentation License.''
18 (a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
19 modify this GNU manual. Buying copies from the FSF supports it in
20 developing GNU and promoting software freedom.''
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{}.
93 @node EDE Project Concepts, EDE Mode, top, top
94 @chapter @ede{} Project Concepts
96 @ede{} is a generic interface for managing projects. It specifies a
97 single set of menus and keybindings, while supporting multiple ways to
98 express a project via a build system.
100 In the subsequent chapters, we will describe the different project
101 types (@pxref{Creating a project}), as well as the commands to build
102 and debug projects (@pxref{Building and Debugging}).
104 In @ede{}, a project hierarchy matches a directory hierarchy. The
105 project's topmost directory is called the @dfn{project root}, and its
106 subdirectories are @dfn{subprojects}.
108 Each project can contain multiple @dfn{targets}. A target, at the
109 simplest level, is a named collection of files within a project. A
110 target can specify two different types of information:
114 A collection of files to be added to a distribution (e.g., a tarball
115 that you intend to distribute to others).
118 A collection of files that can be built into something else (e.g., a
119 program or compiled documentation).
122 Lastly, @ede{} provides a way for other tools to easily learn file
123 associations. For example, a program might need to restrict some sort
124 of search to files in a single target, or to discover the location of
125 documentation or interface files. @ede{} can provide this
128 @node EDE Mode, Quick Start, EDE Project Concepts, top
131 @ede{} is implemented as a minor mode, which augments other modes such
132 as C mode, and Texinfo mode. You can enable @ede{} for all buffers by
133 running the command @code{global-ede-mode}, or by putting this in your
140 Activating @ede{} adds a menu named @samp{Development} to the menu
141 bar. This menu provides several menu items for high-level @ede{}
142 commands. These menu items, and their corresponding keybindings, are
143 independent of the type of project you are actually working on.
145 @node Quick Start, Creating a project, EDE Mode, top
148 Once you have @ede{} enabled, you can create a project. This chapter
149 provides an example C++ project that will create Automake files for
152 @section Step 1: Create root directory
154 First, lets create a directory for our project. For this example,
155 we'll start with something in @file{/tmp}.
158 C-x C-f /tmp/myproject/README RET
159 M-x make-directory RET RET
162 Now put some plain text in your README file to start.
164 Now, lets create the project:
167 M-x ede-new RET Automake RET myproject RET
171 Nothing visible happened, but if you use @code{dired} to look at the
172 directory, you should see this:
176 total used in directory 32 available 166643476
177 drwxr-xr-x 2 zappo users 4096 2012-02-23 22:10 .
178 drwxrwxrwt 73 root root 20480 2012-02-23 22:10 ..
179 -rw-r--r-- 1 zappo users 195 2012-02-23 22:10 Project.ede
180 -rw-r--r-- 1 zappo users 10 2012-02-23 22:09 README
183 @section Step 2: Create Subdirectories and Files
185 We'll make a more complex project, so use dired to create some more
186 directories using the @kbd{+} key, and typing in new directories:
193 Now I'll short-cut in this tutorial. Create the following files:
195 @file{include/myproj.hh}
203 #define IMPORTANT_MACRO 1
205 int my_lib_function();
223 #ifdef IMPORTANT_MACRO
234 * Shared Library to build
237 int my_lib_function() @{
242 @section Step 3: Create subprojects
244 @ede{} needs subdirectories to also have projects in them. You can
245 now create those projects.
247 With @file{main.cpp} as your current buffer, type:
250 M-x ede-new RET Automake RET src RET
253 and in @file{myproj.hh} as your current buffer, type:
256 M-x ede-new RET Automake RET include RET
259 These steps effectively only create the Project.ede file in which you
260 will start adding targets.
262 @section Step 4: Create targets
264 In order to build a program, you must have targets in your @ede{}
265 Projects. You can create targets either from a buffer, or from a
266 @code{dired} directory buffer.
268 Note: If for some reason a directory list buffer, or file does not have the
269 @samp{Project} menu item, or if @ede{} keybindings don't work, just
270 use @kbd{M-x revert-buffer RET} to force a refresh. Sometimes
271 creating a new project doesn't restart buffers correctly.
273 Lets start with the header file. In @file{include/myproj.hh}, you
274 could use the menu, but we will now start using the @ede{} command prefix
275 which is @kbd{C-c .}.
278 C-c . t includes RET miscellaneous RET y
282 This creates a misc target for holding your includes, and then adds
283 myproj.hh to the target. Automake (the tool) has better ways to do
284 this, but for this project, it is sufficient.
286 Next, visit the @file{src} directory using dired. There should be a
287 @samp{Project} menu. You can create a new target with
290 . t myprogram RET program RET
293 Note that @kbd{. t} is a command for creating a target. This command
294 is also in the menu. This will create a target that will build a
295 program. If you want, visit @file{Project.ede} to see the structure
298 Next, place the cursor on @file{main.cpp}, and use @kbd{. a} to add
299 that file to your target.
305 Note that these prompts often have completion, so you can just press
306 @kbd{TAB} to complete the name @file{myprogram}.
308 If you had many files to add to the same target, you could mark them
309 all in your dired buffer, and add them all at the same time.
311 Next, do the same for the library by placing the cursor on @file{mylib.cpp}.
314 . t mylib RET sharedobject RET
318 @section Step 5: Compile, and fail
320 Next, we'll try to compile the project, but we aren't done yet, so it
321 won't work right away.
323 Visit @file{/tmp/myproject/Project.ede}. We're starting here because
324 we don't have any program files in this directory yet. Now we can use
331 Because this is the very first time, it will create a bunch of files
332 for you that are required by Automake. It will then use automake to
333 build the support infrastructure it needs. This step is skipped if
334 you choose just a @file{Makefile} build system.
336 After the Automake init, it runs compile. You will immediately
337 discover the error in main.cpp can't find @file{myproj.hh}. We need
340 @section Step 6: Customizing your project
342 To fix the failed compile, we need to add
343 @file{/tmp/myproject/include} to the include path.
345 Visit @file{main.cpp}.
348 M-x customize-project RET
351 Select the @samp{[Settings]} subgroup of options. Under
352 @samp{Variable :} click @samp{[INS]}. At this point, you need to be
353 somewhat savvy with Automake. Add a variable named @samp{CPPFLAGS},
354 and set the value to @samp{../include}.
356 You should see something like this:
360 [INS] [DEL] Cons-cell:
364 Variables to set in this Makefile.
367 Click @samp{[Apply]}. Feel free to visit @file{Project.ede} to see
368 how it changed the config file.
370 Compile the whole project again with @kbd{C-c . C} from
371 @file{main.cpp}. It should now compile.
373 @section Step 7: Shared library dependency
375 Note: Supporting shared libraries for Automake in this way is easy,
376 but doing so from a project of type Makefile is a bit tricky. If you
377 are creating shared libraries too, stick to Automake projects.
379 Next, lets add a dependency from @file{main.cpp} on our shared
380 library. To do that, update main like this:
396 where the lower case @kbd{c} compiles just that target. You should
399 This time, we need to add a dependency from @file{main.cpp} on our shared
400 library. To do that, we need to customize our target instead of the
401 project. This is because variables such as the include path are
402 treated globally, whereas dependencies for a target are target specific.
405 M-x customize-target RET
408 On the first page, you will see an Ldlibs-local section. Add mylib to
409 it by first clicking @samp{[INS]}, and they adding the library. It
410 should look like this:
414 [INS] [DEL] Local Library: libmylib.la
416 Libraries that are part of this project. [Hide Rest]
417 The full path to these libraries should be specified, such as:
418 ../lib/libMylib.la or ../ar/myArchive.a
421 You will also see other variables for library related flags and system
422 libraries if you need them. Click @samp{[Accept]}, and from
423 @file{main.cpp}, again compile the whole project to force all
424 dependent elements to compile:
430 @section Step 8: Run your program
432 You can run your program directly from @ede{}.
438 If your program takes command line arguments, you can type them in
439 when it offers the command line you want to use to run your program.
441 @node Creating a project, Modifying your project, Quick Start, top
442 @chapter Creating a project
444 To create a new project, first visit a file that you want to include
445 in that project. If you have a hierarchy of directories, first visit
446 a file in the topmost directory. From this buffer, type @kbd{M-x
447 ede-new}, or click on the @samp{Create Project} item in the
448 @samp{Development} menu.
450 The @command{ede-new} command prompts for the type of project you
451 would like to create. Each project type has its own benefits or
452 language specific enhancements. @ede{} supports four different
453 project types: @samp{Make}, @samp{Automake}, @samp{direct Automake},
458 For the @samp{Make} project type, @ede{} creates a @dfn{project file},
459 called @file{Project.ede}, in each project directory. Information
460 about the project is stored in this file. This project autogenerates
464 For the @samp{Automake} project type, @ede{} creates a
465 @file{Project.ede} project file similar to a @samp{Make} project.
466 Unlike a @samp{Make} project, this project autogenerates a
467 @file{Makefile.am} file. @ede{} handles the Automake bootstrapping
468 routines, which import and maintain a @file{configure.am} script and
469 other required files.
472 For the @samp{direct Automake} project type, @ede{} reads directly
473 from the Automake files.
475 You cannot create direct Automake projects with the @command{ede-new}
476 command. Instead, when you visit a project with existing Automake
477 files, @ede{} automatically detects them.
480 The @samp{Simple} project type provides light-weight constructs for
481 identifying a project root and looking up files. If you already have
482 a non-@ede{} project infrastructure, you can use a @samp{Simple}
483 project to provide other Emacs packages, such as Semantic, with some
484 information about the project. @xref{Simple projects}.
487 A subproject is merely a project in a subdirectory of another project.
488 You can create a subproject by using the @command{ede-new} command (or
489 the @samp{Create Project} menu item), while visiting a buffer in a
490 subdirectory of the project root. This new project is automatically
491 added to the parent project, and will be automatically loaded when
492 @ede{} reads the parent project.
494 When using a project command that involves a makefile, @ede{} uses
495 the top-most project's makefile as a starting place for the build. How
496 the toplevel project handles subprojects in the build process is
497 dependent on that project's type.
499 @node Modifying your project, Building and Debugging, Creating a project, top
500 @chapter Modifying your project
502 In this chapter, we describe the generic features for manipulating
503 projects, including the targets and files within them. Subsequent
504 chapters, which describe specific project types, will provide more
505 detailed information about exactly what these features do.
508 * Add/Remove target::
510 * Customize Features::
511 * Project Local Variables::
512 * EDE Project Features::
515 @node Add/Remove target, Add/Remove files, Modifying your project, Modifying your project
516 @section Add/Remove target
518 To create a new target, type @kbd{C-c . t} (@code{ede-new-target}) or
519 use the @samp{Add Target} menu item in the @samp{Project Options}
520 submenu. This prompts for a target name, and adds the current buffer
523 The @command{ede-new-target} command also prompts for a @dfn{target
524 type}. Each target type has its own build process and class of files
527 To remove a target from the project, type @kbd{M-x ede-delete-target},
528 or use the @samp{Remove Target} menu item in the @samp{Project
531 @node Add/Remove files, Customize Features, Add/Remove target, Modifying your project
532 @section Add/Remove files
534 To add the current file to an existing target, type @kbd{C-c . a}
535 (@code{ede-add-file}), or use the @samp{Add File} menu item in the
536 @samp{Target Options} submenu.
538 You can add a file to more than one target; this is OK.
540 To remove the current file from a target, type @kbd{C-c . d}
541 (@code{ede-remove-file}), or use the @samp{Remove File} menu item
542 in the @samp{Target Options} submenu. If the file belongs to multiple
543 targets, this command prompts for each target it could be removed
546 While working in a project, if you visit a file that is not part of an
547 existing target, @ede{} automatically prompts for a target. If you do
548 not wish to add the file to any target, you can choose @samp{none}.
549 You can customize this behavior with the variable
550 @command{ede-auto-add-method}.
552 @node Customize Features, Project Local Variables, Add/Remove files, Modifying your project
553 @section Customize Features
555 A project, and its targets, are objects using the @samp{EIEIO} object
556 system. @xref{Top,,,eieio,EIEIO manual}. These objects have data
557 fields containing important information related to your work.
559 If the high-level functions aren't enough, you can tweak all
560 user-customizable fields at any time by running the command
561 @command{customize-project} or @command{customize-target}. This loads
562 the current project or target into a customization buffer, where you
563 can tweak individual slots. This is usually necessary for complex
566 Some project modes do not have a project file, but directly read a
567 Makefile or other existing file. Instead of directly editing the
568 object, you can edit the file by typing @kbd{C-c . e}
569 (@code{ede-edit-file-target}). You should ``rescan'' the project
570 afterwards (@pxref{Miscellaneous commands}).
572 @node Project Local Variables, EDE Project Features, Customize Features, Modifying your project
573 @section Project Local Variables
575 EDE projects can store and manager project local variables. The
576 variables are stored in the project, and will be restored when a
579 Projects which are not stored on disk WILL NOT restore your project
580 local variables later.
582 You can use @ref{Customize Features} to of the project to edit the
583 project local variables. They are under the 'Settings' group as
584 ``Project Local Variables''.
586 You can also use @kbd{M-x ede-set} to set a new variable local in the
589 In multi-level projects such as Automake and Make generating projects,
590 project local variables are installed from both the TOP most project,
591 and the local directory's project. In that way, you can have some
592 variables across your whole project, and some specific to a
595 You can use project local variables to set any Emacs variable so that
596 buffers belonging to different projects can have different settings.
598 NOTE: When you use project-local variables with @ref{ede-cpp-root},
599 the format is an association list. For example:
602 (ede-cpp-root-project "SOMENAME"
603 :file "/dir/to/some/file"
605 '((grep-command . "grep -nHi -e ")
606 (compile-command . "make -f MyCustomMakefile all")))
609 The same is true when you use project-local variables with
610 @ref{ede-java-root}. For example:
613 (ede-java-root-project "SOMENAME"
614 :file "/dir/to/some/file"
616 '((grep-command . "grep -nHi -e ")
617 (compile-command . "ant")))
620 @node EDE Project Features, , Project Local Variables, Modifying your project
621 @section EDE Project Features
623 This section details user facing features of an @ede{} @samp{Make}
624 style project. An @samp{Automake} project has similar options (but a
625 direct Automake project does not).
627 To modify any of the specific features mentioned here, you need to
628 customize the project or target with @command{customize-project} or
629 @command{customize-target}.
631 When you are customizing, you are directly manipulating slot values in
632 @eieio{} objects. @xref{Extending EDE}, if you are interested in
636 * Changing Compilers and Flags::
640 @node Changing Compilers and Flags, Configurations, EDE Project Features, EDE Project Features
641 @subsection Changing Compilers and Flags
643 Targets that build stuff need compilers. To change compilers, you
644 need to customize the desired target.
646 In the @samp{[Make]} section, you can choose a new compiler or linker
647 from the list. If a linker you need is not available, you will need
648 to create a new one. @xref{Compiler and Linker objects}.
650 If an existing compiler or linker is close, but you need to modify
651 some flag set such as adding an include path you will need to add a
652 configuration variable.
654 To start, you should create the basic setup, and construct a makefile
655 with @command{ede-proj-regenerate}. Look in the @file{Makefile} to
656 see what commands are inserted. Once you have determined the variable
657 you need to modify, you can add a configuration for it.
658 @xref{Configurations}.
660 @node Configurations, , Changing Compilers and Flags, EDE Project Features
661 @subsection Configurations
663 Configurations specify different ways to build a project. For
664 example, you may configure a project to be in ``debug'' mode, or
665 perhaps in ``release'' mode.
667 The project, and each target type all have a slot named
668 @code{configuration-variables}. To add new variables to a
669 configuration find this slot in the custom buffer, and insert a new
670 configuration. Name it either ``debug'' or ``release'', then insert
671 some number of name/value pairs to it.
673 You can have any number of valid configurations too. To add a new
674 configuration, customize your project. Work in the @samp{[Settings]}
675 block for ``configurations''. Add a new named configuration here.
677 To switch between different active configurations, modify the
678 ``configuration default'' slot.
680 @node Building and Debugging, Miscellaneous commands, Modifying your project, top
681 @chapter Building and Debugging
683 @ede{} provides the following ``project-aware'' compilation and
688 Compile the current target (@code{ede-compile-target}).
690 Compile the entire project (@code{ede-compile-project}).
692 Debug the current target (@code{ede-debug-target}).
693 @item M-x ede-make-dist
694 Build a distribution file for your project.
697 These commands are also available from the @samp{Development} menu.
699 @node Miscellaneous commands, Extending EDE, Building and Debugging, top
700 @chapter Miscellaneous commands
702 If you opt to go in and edit @ede{} project files directly---for
703 instance, by using @kbd{C-c . e} (@pxref{Customize Features})---you
704 must then ``rescan'' the project files to update the internal data
705 structures. To rescan the current project, type @kbd{C-c . g}
706 (@code{ede-rescan-toplevel}).
708 @ede{} can help you find files in your project, via the command
709 @kbd{C-c . f} (@code{ede-find-file}). This prompts for a file name;
710 you need not specify the directory. EDE then tries to visit a file
711 with that name somewhere in your project.
713 @ede{} can use external tools to help with file finding. To do this,
714 customize @code{ede-locate-setup-options}.
716 @defvar ede-locate-setup-options
717 @anchor{ede-locate-setup-options}
718 List of locate objects to try out by default.
719 Listed in order of preference. If the first item cannot be used in
720 a particular project, then the next one is tried.
721 It is always assumed that @dfn{ede-locate-base} is at end of the list.
724 @ede{} also provides a project display mode for the speedbar
725 (@pxref{Speedbar,,,emacs,GNU Emacs Manual}). This allows you to view
726 your source files as they are structured in your project: as a
727 hierarchical tree, grouped according to target.
729 To activate the speedbar in this mode, type @kbd{C-c . s}
730 (@code{ede-speedbar}).
733 * Make and Automake projects:: Project types of @samp{ede-project}
734 * Automake direct projects:: Project interface on hand-written automake files.
735 * Android projects:: Projects for Android development
736 * Arduino projects:: Projects for Arduino sketches
737 * Simple projects:: Projects @ede{} doesn't manage.
740 @node Make and Automake projects
741 @section Make and Automake projects
743 A project of @samp{ede-project} type creates a file called
744 @file{Project.ede} in every project directory. This is used to track
745 your configuration information. If you configure this project to be
746 in @samp{Makefile} mode, then this project will autogenerate a
747 @file{Makefile}. If you configure it in @samp{Automake} mode a
748 @file{Makefile.am} file will be created. The automake bootstrapping
749 routines will also import and maintain a configure.am script and a
750 host of other files required by Automake.
752 @node Automake direct projects
753 @section Automake direct projects
755 The project type that reads @file{Makefile.am} directly is derived
756 from the sources of the original @file{project-am.el} mode that was
757 distributed independently. This mode eventually became @ede{}. The
758 @samp{project-am} project will read existing automake files, but will
759 not generate them automatically, or create new ones. As such, it is
760 useful as a browsing tool, or as maintenance in managing file lists.
762 @node Android projects
763 @section Android projects
765 An Android project of type @samp{ede-android-project} will detect and
766 support development of Android apps. Android projects use an
767 @file{AndroidManifest.xml} file. Always load your Manifest first in a
768 running Emacs to make sure the project is identified correctly.
770 Android projects can be created with @code{ede-new} but depend on a
771 correctly configured Android SDK via @cedet{} support.
773 @defun cedet-android-sdk-root
774 @anchor{cedet-android-sdk-root}
775 The root to the android @var{SDK}.
778 Android projects support different configurations including compile,
779 and install, which will upload a program to your Android device. It
780 also supports several debugging tools via @file{android.el}.
782 @node Arduino projects
783 @section Arduino projects
785 An arduino project of type @samp{ede-arduino-project} will read your
786 @file{~/.arduino/preferences.txt} file, and identify your sketches.
787 You will still need the Arduino IDE to set up your preferences and
788 locate your arduino. After quitting the IDE, Emacs will be able to
789 find your sketches, compile them, and upload them to your arduino.
791 If you have the @file{arduino} command on your path, @ede{} will be
792 able to find your SDK and compile your programs.
794 @node Simple projects
795 @section Simple Projects
797 There is a wide array of Simple projects. The root for simple
798 projects is the class @code{ede-simple-project}. This handles the
799 infrastructure of storing a .ede file if needed.
801 The class @code{ede-simple-project} is designed to be subclassed.
802 Then key @ede{} methods can be overridden to provide a quick wrapper
805 A second project type is @code{ede-cpp-root}. This project type is
806 designed to be created for a directory hierarchy full of C/C++ code.
807 It can be configured with minimal lisp knowledge to do header file
808 lookup for @semantic{}, improving code completion performance.
811 * ede-cpp-root:: This project marks the root of a C/C++ code project.
812 * ede-java-root:: This project marks the root of a Java project.
813 * ede-emacs:: A project for working with Emacs.
814 * ede-linux:: A project for working with Linux kernels.
815 * Custom Locate:: Customizing how to locate files in a simple project
818 @node ede-cpp-root, ede-java-root, Simple projects, Simple projects
819 @subsection ede-cpp-root
821 The @code{ede-cpp-root} project type allows you to create a single
822 object with no save-file in your @file{.emacs} file. It allows @ede{}
823 to provide the @semantic{} package with the ability to find header
826 The @code{ede-cpp-root} class knows a few things about C++ projects,
827 such as the prevalence of "include" directories, and typical
828 file-layout stuff. If this isn't sufficient, you can subclass
829 @code{ede-cpp-root-project} and add your own tweaks in just a few
830 lines. See the end of this file for an example.
832 In the most basic case, add this to your @file{.emacs} file, modifying
833 appropriate bits as needed.
836 (ede-cpp-root-project "SOMENAME" :file "/dir/to/some/file")
839 Replace @var{SOMENAME} with whatever name you want, and the filename
840 to an actual file at the root of your project. It might be a
841 Makefile, a README file. Whatever. It doesn't matter. It's just a
842 key to hang the rest of @ede{} off of.
844 The most likely reason to create this project, is to speed up
845 searching for includes files, or to simplify bootstrapping @semantic{}'s
846 ability to find files without much user interaction. In conjunction
847 with @semantic{} completion, having a short include path is key. You can
848 override the default include path and system include path like this:
851 (ede-cpp-root-project "NAME" :file "FILENAME"
852 :include-path '( "/include" "../include" "/c/include" )
853 :system-include-path '( "/usr/include/c++/3.2.2/" )
854 :spp-table '( ("MOOSE" . "")
855 ("CONST" . "const") ) )
858 In this case each item in the include path list is searched. If the
859 directory starts with "/", then that expands to the project root
860 directory. If a directory does not start with "/", then it is
861 relative to the default-directory of the current buffer when the file
864 The include path only affects C/C++ header files. Use the slot
865 @code{:header-match-regexp} to change it.
867 The @code{:system-include-path} allows you to specify full directory
868 names to include directories where system header files can be found.
869 These will be applied to files in this project only.
871 The @code{:spp-table} provides a list of project specific #define
872 style macros that are unique to this project, passed in to the
873 compiler on the command line, or are in special headers.
874 See the @code{semantic-lex-c-preprocessor-symbol-map} for more
875 on how to format this entry.
877 If there is a single file in your project, you can instead set the
878 @code{:spp-files} to a list of file names relative to the root of your
879 project. Specifying this is like setting the variable
880 @code{semantic-lex-c-preprocessor-symbol-file} in semantic.
882 If you want to override the file-finding tool with your own
883 function you can do this:
886 (ede-cpp-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
889 Where @var{MYFCN} is a symbol for a function. The locate function can
890 be used in place of @code{ede-expand-filename} so you can quickly
891 customize your custom target to use specialized local routines instead
892 of the default @ede{} routines. The function symbol must take two
897 The name of the file to find.
899 The directory root for this cpp-root project.
902 When creating a project with @code{ede-cpp-root}, you can get
903 additional configurations via @ref{Project Local Variables}. Be aware
904 that the format for project local variables is an association list.
905 You cannot use @kbd{M-x ede-set} and have your project local variables
906 persist between sessions.
908 If the cpp-root project style is right for you, but you want a dynamic
909 loader, instead of hard-coding path name values in your @file{.emacs}, you
910 can do that too, but you will need to write some lisp code.
912 To do that, you need to add an entry to the
913 @code{ede-project-class-files} list, and also provide two functions to
914 teach @ede{} how to load your project pattern
916 It would look like this:
919 (defun MY-FILE-FOR-DIR (&optional dir)
920 "Return a full file name to the project file stored in DIR."
921 <write your code here, or return nil>
924 (defun MY-ROOT-FCN ()
925 "Return the root fcn for `default-directory'"
926 ;; You might be able to use `ede-cpp-root-project-root'
927 ;; and not write this at all.
931 "Load a project of type `cpp-root' for the directory DIR.
932 Return nil if there isn't one."
933 ;; Use your preferred construction method here.
934 (ede-cpp-root-project "NAME" :file (expand-file-name "FILE" dir)
938 (add-to-list 'ede-project-class-files
939 (ede-project-autoload "cpp-root"
942 :proj-file 'MY-FILE-FOR-DIR
943 :proj-root 'MY-ROOT-FCN
945 :class-sym 'ede-cpp-root)
949 This example only creates an auto-loader, and does not create a new kind
952 @xref{ede-cpp-root-project}, for details about the class that defines
953 the @code{ede-cpp-root} project type.
955 @node ede-java-root, ede-emacs, ede-cpp-root, Simple projects
956 @subsection ede-java-root
958 Much like the project type @ref{ede-cpp-root}, the java variant is
959 can be setup in your @file{.emacs} file and just marks a directory as
960 the root of a java source tree.
962 The @code{ede-java-root} project class knows a few things about Java
963 projects. In particular, you can use it to control your classpath at
964 both the system level, and for your project. If it is insufficient,
965 you can subclass @code{ede-java-root-project} and add your own tweaks
966 in just a few lines. See @ref{ede-cpp-root} for an example using the
969 In the most basic case, add this to your @file{.emacs} file, modifying
970 appropriate bits as needed.
973 (ede-java-root-project "SOMENAME" :file "/dir/to/some/file" :srcroot '("src"))
976 Replace @var{SOMENAME} with whatever name you want, and the filename
977 to an actual file at the root of your project. It might be a
978 Makefile, a README file. Whatever. It doesn't matter. It's just a
979 key to hang the rest of @ede{} off of.
981 Replace the value of :srcroot with a list of directories under the
982 project root which contains Java sources. For example, if you have:
987 ~/myprojects/P1/src/com/ericsoft/MyCode.java
991 Then @file{src} represents the directory under which all your Java
992 code is. It is important that @file{src} is one step above the
993 directory that is the base of your package name, such as
994 @file{com/ericsoft} in the example above so that new files can be
995 discovered via fully qualified name. You can have multiple such
996 directories in one project, and each will be accessible.
998 You can specify your classpath like this:
1001 (ede-java-root-project "NAME" :file "FILENAME"
1003 :classpath '("/absolute/path.jar")
1004 :localclasspath '( "/relative/path.jar" ))
1007 In this example, @code{:classpath} specifies absolute paths somewhere
1008 on your system, and the explicit jar or source root directories
1009 @semantic{} will search when performing completions.
1011 The @code{:localclasspath} is like @code{:classpath}, but it will
1012 contain path names relative to the root of your project.
1014 If you want to override the file-finding tool with your own
1015 function you can do this:
1018 (ede-java-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
1021 Where @var{MYFCN} is a symbol for a function. The locate function can
1022 be used in place of @code{ede-expand-filename} so you can quickly
1023 customize your custom target to use specialized local routines instead
1024 of the default @ede{} routines. The function symbol must take two
1029 The name of the file to find.
1031 The directory root for this java-root project.
1034 If you would like to create your Java projects dynamically, instead of
1035 putting them all in your @file{.emacs}, you can do that too. See
1036 @ref{ede-cpp-root} for details that can be applied to this project type.
1038 @node ede-emacs, ede-linux, ede-java-root, Simple projects
1039 @subsection ede-emacs
1041 The @code{ede-emacs} project automatically identifies an Emacs source
1042 tree, and enables EDE project mode for it.
1044 It pre-populates the C Preprocessor symbol map for correct parsing,
1045 and has an optimized include file identification function.
1047 @node ede-linux, Custom Locate, ede-emacs, Simple projects
1048 @subsection ede-linux
1050 The @code{ede-linux} project will automatically identify a Linux
1051 Kernel source tree, and enable EDE project mode for it.
1053 It pre-populates the C Preprocessor symbol map for reasonable parsing,
1054 and has an optimized include file identification function.
1056 @node Custom Locate, , ede-linux, Simple projects
1057 @subsection Custom Locate
1059 The various simple project styles all have one major drawback, which
1060 is that the files in the project are not completely known to EDE.
1061 When the EDE API is used to try and file files by some reference name
1062 in the project, then that could fail.
1064 @@TODO - Add ID Utils and CScope examples
1066 @ede{} can therefore use some external locate commands, such as the unix
1067 ``locate'' command, or ``GNU Global''.
1069 Configuration of the tool you want to use such as @code{locate}, or
1070 @code{global} will need to be done without the aid of @ede{}. Once
1071 configured, however, @ede{} can use it.
1073 To enable one of these tools, set the variable
1074 @code{ede-locate-setup-options} with the names of different locate
1075 objects. @ref{Miscellaneous commands}.
1077 Configure this in your @file{.emacs} before loading in CEDET or EDE.
1078 If you want to add support for GNU Global, your configuration would
1082 (setq ede-locate-setup-options '(ede-locate-global ede-locate-base))
1085 That way, when a search needs to be done, it will first try using
1086 GLOBAL. If global is not available for that directory, then it will
1087 revert to the base locate object. The base object always fails to
1090 You can add your own locate tool but subclassing from
1091 @code{ede-locate-base}. The subclass should also implement two
1092 methods. See the code in @file{ede-locate.el} for GNU Global as a
1095 @node Extending EDE, , Miscellaneous commands, top
1096 @chapter Extending @ede{}
1098 This chapter is intended for users who want to write new parts or fix
1099 bugs in @ede{}. A knowledge of Emacs Lisp, and some @eieio{}(CLOS) is
1102 @ede{} uses @eieio{}, the CLOS package for Emacs, to define two object
1103 superclasses, specifically the PROJECT and TARGET. All commands in
1104 @ede{} are usually meant to address the current project, or current
1107 All specific projects in @ede{} derive subclasses of the @ede{}
1108 superclasses. In this way, specific behaviors such as how a project
1109 is saved, or how a target is compiled can be customized by a project
1110 author in detail. @ede{} communicates to these project objects via an
1111 API using methods. The commands you use in @ede{} mode are high-level
1112 functional wrappers over these methods. @xref{(eieio)Top}. For
1113 details on using @eieio{} to extending classes, and writing methods.
1115 If you intend to extend @ede{}, it is most likely that a new target type is
1116 needed in one of the existing project types. The rest of this chapter
1117 will discuss extending the @code{ede-project} class, and it's targets.
1118 See @file{project-am.el} for basic details on adding targets to it.
1120 For the @code{ede-project} type, the core target class is called
1121 @code{ede-proj-target}. Inheriting from this will give you everything
1122 you need to start, including adding your sources into the makefile. If
1123 you also need additional rules in the makefile, you will want to inherit
1124 from @code{ede-proj-target-makefile} instead. You may want to also add
1125 new fields to track important information.
1127 If you are building currently unsupported code into a program or shared
1128 library, it is unlikely you need a new target at all. Instead you
1129 would need to create a new compiler or linker object that compiles
1130 source code of the desired type. @ref{Compiler and Linker objects}.
1132 Once your new class exists, you will want to fill in some basic methods.
1133 See the @file{ede-skel.el} file for examples of these. The files
1134 @file{ede-proj-info.el} and @file{ede-proj-elisp.el} are two interesting
1138 * Development Overview::
1139 * Detecting a Project::
1140 * User interface methods:: Methods associated with keybindings
1141 * Base project methods:: The most basic methods on @ede{} objects.
1142 * Sourcecode objects:: Defining new sourcecode classes.
1143 * Compiler and Linker objects:: Defining new compilers and linkers.
1144 * Project:: Details of project classes.
1145 * Targets:: Details of target classes.
1146 * Sourcecode:: Details of source code classes.
1147 * Compilers:: Details of compiler classes.
1150 @node Development Overview, Detecting a Project, Extending EDE, Extending EDE
1151 @section Development Overview
1153 @ede{} is made up of a series of classes implemented with @eieio{}.
1154 These classes define an interface that can be used to create different
1157 @ede{} defines two superclasses which are @code{ede-project} and
1158 @code{ede-target}. All commands in @ede{} are usually meant to
1159 address the current project, or current target.
1161 All specific projects in @ede{} derive subclasses of the @ede{} superclasses.
1162 In this way, specific behaviors such as how a project is saved, or how a
1163 target is compiled can be customized by a project author in detail. @ede{}
1164 communicates to these project objects via an API using methods. The
1165 commands you use in @ede{} mode are high-level functional wrappers over
1168 Some example project types are:
1172 Automake project which reads existing Automake files.
1173 @item ede-proj-project
1174 This project type will create @file{Makefiles},
1175 or @file{Makefile.am} files to compile your project.
1177 This project type will detect linux source trees.
1179 This project will detect an Emacs source tree.
1182 There are several other project types as well.
1184 The first class you need to know to create a new project type is
1185 @code{ede-project-autoload}. New instances of this class are needed
1186 to define how Emacs associates different files/buffers with different
1187 project types. All the autoloads are kept in the variable
1188 @code{ede-project-class-files}.
1190 The next most important class to know is @code{ede-project}. This is
1191 the baseclass defines how all projects behave. The basic pattern for
1192 a project is that there is one project per directory, and the topmost
1193 project or directory defines the project as a whole.
1195 Key features of @code{ede-project} are things like name and version
1196 number. It also holds a list of @code{ede-target} objects and a list
1197 of sub projects, or more @code{ede-project} objects.
1199 New project types must subclass @code{ede-project} to add special
1200 behavior. New project types also need to subclass @code{ede-target} to
1201 add specialty behavior.
1203 In this way, the common @ede{} interface is designed to work against
1204 @code{ede-project}, and thus all subclasses.
1206 @code{ede-project} subclasses @code{ede-project-placeholder}. This is
1207 the minimum necessary project needed to be cached between runs of
1208 Emacs. This way, Emacs can track all projects ever seen, without
1209 loading those projects into memory.
1211 Here is a high-level UML diagram for the @ede{} system created with @cogre{}..
1214 +-----------------------+ +-----------------------+
1215 | | |ede-project-placeholder|
1216 |ede-project-class-files| +-----------------------+
1217 | | +-----------------------+
1218 +-----------------------+ +-----------------------+
1222 +--------------------+ +-----------+ +----------+
1223 |ede-project-autoload| |ede-project| |ede-target|
1224 +--------------------+<>--------------+-----------+<>-------+----------+
1225 +--------------------+ +-----------+ +----------+
1226 +--------------------+ +-----------+ +----------+
1230 +---------------------+-----------------+
1234 +----------------+ +-------------------+ +---------+
1235 |ede-proj-project| |project-am-makefile| |ede-emacs|
1236 +----------------+ +-------------------+ +---------+
1237 +----------------+ +-------------------+ +---------+
1238 +----------------+ +-------------------+ +---------+
1242 @node Detecting a Project, User interface methods, Development Overview, Extending EDE
1243 @section Detecting a Project
1245 Project detection happens with the list of @code{ede-project-autoload}
1246 instances stored in @code{ede-project-class-files}. The full project
1247 detection scheme works like this:
1251 @code{find-file-hooks} calls @code{ede-turn-on-hook} on BUFFER.
1253 @code{ede-turn-on-hook} turns on @code{ede-minor-mode}
1255 @code{ede-minor-mode} looks to see if BUFFER is associated with any
1256 open projects. If not, it calls @code{ede-load-project-file} to find
1257 a project associated with the current directory BUFFER is in.
1259 @code{ede-minor-mode} associates the found project with the current
1260 buffer with a series of variables, such as @code{ede-object}, and
1261 @code{ede-object-project} and @code{ede-object-root-project}.
1264 Once a buffer is associated, @ede{} minor mode commands will operate
1267 The function @code{ede-load-project-file} is at the heart of detecting
1268 projects, and it works by looping over all the known project autoload
1269 types in @code{ede-project-autoload} using the utility
1270 @code{ede-directory-project-p}.
1272 The function @code{ede-directory-project-p} will call
1273 @code{ede-dir-to-projectfile} on every @code{ede-project-autoload}
1274 until one of them returns true. The method
1275 @code{ede-dir-to-projectfile} in turn gets the @code{:proj-file} slot
1276 from the autoload. If it is a string (ie, a project file name), it
1277 checks to see if that exists in BUFFER's directory. If it is a
1278 function, then it calls that function and expects it to return a file
1279 name or nil. If the file exists, then this directory is assumed to be
1280 part of a project, and @code{ede-directory-project-p} returns the
1281 instance of @code{ede-project-autoload} that matched.
1283 If the current directory contains the file @code{.ede-ignore} then
1284 that directory is automatically assumed to contain no projects, even
1285 if there is a matching pattern. Use this type of file in a directory
1286 that may contain many other sub projects, but still has a Makefile of
1289 If the current directory is a project, then @ede{} scans upwards till
1290 it finds the top of the project. It does this by calling
1291 @code{ede-toplevel-project}. If this hasn't already been discovered,
1292 the directories as scanned upward one at a time until a directory with
1293 no project is found. The last found project becomes the project
1294 root. If the found instance of @code{ede-project-autoload} has a
1295 valid @code{proj-root} slot value, then that function is called instead
1296 of scanning the project by hand. Some project types have a short-cut
1297 for determining the root of a project, so this comes in handy.
1299 Getting back to @code{ede-load-project-file}, this now has an instance
1300 of @code{ede-project-autoload}. It uses the @code{load-type} slot to
1301 both autoload in the project type, and to create a new instance of the
1302 project type found for the root of the project. That project is added
1303 to the global list of all projects. All subprojects are then created
1304 and assembled into the project data structures.
1307 @node User interface methods, Base project methods, Detecting a Project, Extending EDE
1308 @section User interface methods
1310 These methods are core behaviors associated with user commands.
1311 If you do not implement a method, there is a reasonable default that
1312 may do what you need.
1315 @item project-add-file
1316 Add a file to your project. Override this if you want to put new
1317 sources into different fields depending on extension, or other details.
1318 @item project-remove-file
1319 Reverse of project-add-file.
1320 @item project-compile-target
1321 Override this if you want to do something special when the user
1322 "compiles" this target.
1323 @item project-debug-target
1324 What to do when a user wants to debug your target.
1325 @item project-update-version
1326 Easily update the version number of your project.
1327 @item project-edit-file-target
1328 Edit the file the project's information is stored in.
1329 @item project-new-target
1330 Create a new target in a project.
1331 @item project-delete-target
1332 Delete a target from a project.
1333 @item project-make-dist
1334 Make a distribution (tar archive) of the project.
1335 @item project-rescan
1336 Rescan a project file, changing the data in the existing objects.
1339 @node Base project methods, Sourcecode objects, User interface methods, Extending EDE
1340 @section Base project methods
1342 These methods are important for querying base information from project
1347 Return a string that is the name of this target.
1348 @item ede-target-name
1349 Return a string that is the name of the target used by a Make system.
1350 @item ede-description
1351 A brief description of the project or target. This is currently used
1352 by the @samp{ede-speedbar} interface.
1353 @item ede-want-file-p
1354 Return non-nil if a target will accept a given file.
1355 It is generally unnecessary to override this. See the section on source
1357 @item ede-buffer-mine
1358 Return non-nil if a buffer belongs to this target. Used during
1359 association when a file is loaded. It is generally unnecessary to
1360 override this unless you keep auxiliary files.
1363 These methods are used by the semantic package extensions @xref{(semantic)Top}.
1366 @item ede-buffer-header-file
1367 Return a header file belonging to a given buffer. Prototypes are place
1368 there when appropriate
1369 @item ede-buffer-documentation-files
1370 Return the documentation file information about this file would be
1372 @item ede-documentation
1373 List all documentation a project or target is responsible for.
1376 @node Sourcecode objects, Compiler and Linker objects, Base project methods, Extending EDE
1377 @section Sourcecode objects
1379 @ede{} projects track source file / target associates via source code
1380 objects. The definitions for this is in @file{ede-source.el}. A source
1381 code object contains methods that know how to identify a file as being
1382 of that class, (ie, a C file ends with @file{.c}). Some targets can
1383 handle many different types of sources which must all be compiled
1384 together. For example, a mixed C and C++ program would have
1385 instantiations of both sourcecode types.
1387 When a target needs to know if it will accept a source file, it
1388 references its list of source code objects. These objects then make
1391 Source code objects are stored in the target objects as a list of
1392 symbols, where the symbol's value is the object. This enables the
1393 project save file mechanism to work.
1395 Here is an example for an instantiation of an Emacs Lisp source code object:
1398 (defvar ede-source-emacs
1399 (ede-sourcecode "ede-emacs-source"
1401 :sourcepattern "\\.el$"
1402 :garbagepattern '("*.elc"))
1403 "Emacs Lisp source code definition.")
1406 If you want to recycle parts of an existing sourcecode object, you can
1407 clone the original, and then just tweak the parts that are different.
1411 (defvar ede-source-emacs-autoload
1412 (clone ede-source-emacs "ede-source-emacs-autoload"
1413 :name "Emacs Lisp Autoload"
1414 :sourcepattern "-loaddefs\\.el")
1415 "Emacs Lisp autoload source code.")
1418 In this case, the garbage pattern is the same.
1422 @node Compiler and Linker objects, Project, Sourcecode objects, Extending EDE
1423 @section Compiler and Linker objects
1425 In order for a target to create a @file{Makefile}, it must know how to
1426 compile the sources into the program or desired data file, and
1427 possibly link them together.
1429 A compiler object instantiation is used to associate a given target
1430 with a given source code type. Some targets can handle many types of
1431 sources, and thus has many compilers available to it. Some targets
1432 may have multiple compilers for a given type of source code.
1434 @ede{} will examine the actual source files in a target, cross reference
1435 that against the compiler list to come up with the final set of
1436 compilers that will be inserted into the Makefile.
1438 Compiler instantiations must also insert variables specifying the
1439 compiler it plans to use, in addition to creating Automake settings for
1440 @file{configure.ac} when appropriate.
1442 Compiler objects are stored in the target objects as a list of
1443 symbols, where the symbols value is the object. This enables the
1444 project output mechanism to work more efficiently.
1446 Targets will also have a special "compiler" slot which lets a user
1447 explicitly choose the compiler they want to use.
1449 Here is an example for texinfo:
1452 (defvar ede-makeinfo-compiler
1454 "ede-makeinfo-compiler"
1456 :variables '(("MAKEINFO" . "makeinfo"))
1457 :commands '("makeinfo -o $@ $<")
1458 :autoconf '(("AC_CHECK_PROG" . "MAKEINFO, makeinfo"))
1459 :sourcetype '(ede-makeinfo-source)
1461 "Compile texinfo files into info files.")
1466 When creating compiler instantiations, it may be useful to @code{clone}
1467 an existing compiler variable. Cloning allows you to only modify
1468 parts of the original, while keeping the rest of the same.
1469 Modification of the original will result in the clone also being
1470 changed for shared value slots.
1472 The second important object is the linker class. The linker is similar
1473 to the compiler, except several compilers might be used to create some
1474 object files, and only one linker is used to link those objects together.
1476 See @file{ede-proj-obj.el} for examples of the combination.
1483 @node Project, Targets, Compiler and Linker objects, Extending EDE
1487 * ede-project-placeholder::
1489 * ede-cpp-root-project::
1490 * ede-simple-project::
1491 * ede-simple-base-project::
1492 * ede-proj-project::
1493 * project-am-makefile::
1494 * ede-step-project::
1497 @node ede-project-placeholder, ede-project, Project, Project
1498 @subsection ede-project-placeholder
1499 @pjindex ede-project-placeholder
1502 @item Inheritance Tree:
1504 @item eieio-speedbar
1506 @item eieio-speedbar-directory-button
1508 @item ede-project-placeholder
1511 @w{@xref{ede-project}.}
1523 Type: @code{string} @*
1524 Default Value: @code{"Untitled"}
1526 The name used when generating distribution files.
1530 Type: @code{string} @*
1531 Default Value: @code{"1.0"}
1533 The version number used when distributing files.
1539 Directory this project is associated with.
1545 File name where this project is stored.
1552 @subsubsection Specialized Methods
1554 @deffn Method ede--project-inode :AFTER proj
1555 Get the inode of the directory project @var{PROJ} is in.
1558 @deffn Method ede-project-root :AFTER this
1559 If a project knows it's root, return it here.
1560 Allows for one-project-object-for-a-tree type systems.
1563 @deffn Method ede-find-subproject-for-directory :AFTER proj dir
1564 Find a subproject of @var{PROJ} that corresponds to @var{DIR}.
1567 @deffn Method ede-project-root-directory :AFTER this &optional file
1568 If a project knows it's root, return it here.
1569 Allows for one-project-object-for-a-tree type systems.
1570 Optional @var{FILE} is the file to test. It is ignored in preference
1571 of the anchor file for the project.
1574 @deffn Method ede-project-force-load :AFTER this
1575 Make sure the placeholder @var{THIS} is replaced with the real thing.
1576 Return the new object created in its place.
1579 @deffn Method project-interactive-select-target :AFTER this prompt
1580 Make sure placeholder @var{THIS} is replaced with the real thing, and pass through.
1583 @deffn Method project-add-file :AFTER this file
1584 Make sure placeholder @var{THIS} is replaced with the real thing, and pass through.
1587 @node ede-project, ede-cpp-root-project, ede-project-placeholder, Project
1588 @subsection ede-project
1589 @pjindex ede-project
1592 @item Inheritance Tree:
1594 @item eieio-speedbar
1596 @item eieio-speedbar-directory-button
1598 @item @w{@xref{ede-project-placeholder}.}
1603 @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}.}
1618 List of top level targets in this project.
1624 List of tool cache configurations in this project.
1625 This allows any tool to create, manage, and persist project-specific settings.
1629 Type: @code{string} @*
1631 URL to this projects web site.
1632 This is a URL to be sent to a web site for documentation.
1635 @item :web-site-directory @*
1637 A directory where web pages can be found by Emacs.
1638 For remote locations use a path compatible with ange-ftp or EFS.
1639 You can also use TRAMP for use with rcp & scp.
1642 @item :web-site-file @*
1644 A file which contains the home page for this project.
1645 This file can be relative to slot @code{web-site-directory}.
1646 This can be a local file, use ange-ftp, EFS, or TRAMP.
1650 Type: @code{string} @*
1652 FTP site where this project's distribution can be found.
1653 This FTP site should be in Emacs form, as needed by @code{ange-ftp}, but can
1654 also be of a form used by TRAMP for use with scp, or rcp.
1657 @item :ftp-upload-site
1658 Type: @code{string} @*
1660 FTP Site to upload new distributions to.
1661 This FTP site should be in Emacs form as needed by @code{ange-ftp}.
1662 If this slot is @code{nil}, then use @code{ftp-site} instead.
1665 @item :configurations
1666 Type: @code{list} @*
1667 Default Value: @code{("debug" "release")}
1669 List of available configuration types.
1670 Individual target/project types can form associations between a configuration,
1671 and target specific elements such as build variables.
1674 @item :configuration-default @*
1675 Default Value: @code{"debug"}
1677 The default configuration.
1680 @item :local-variables @*
1681 Default Value: @code{nil}
1683 Project local variables
1689 @subsubsection Specialized Methods
1691 @deffn Method ede-preprocessor-map :AFTER this
1692 Get the pre-processor map for project @var{THIS}.
1695 @deffn Method ede-subproject-relative-path :AFTER proj &optional parent-in
1696 Get a path name for @var{PROJ} which is relative to the parent project.
1697 If PARENT is specified, then be relative to the PARENT project.
1698 Specifying PARENT is useful for sub-sub projects relative to the root project.
1701 @deffn Method eieio-speedbar-description :AFTER obj
1702 Provide a speedbar description for @var{OBJ}.
1705 @deffn Method ede-map-any-target-p :AFTER this proc
1706 For project @var{THIS}, map @var{PROC} to all targets and return if any non-nil.
1707 Return the first non-@code{nil} value returned by @var{PROC}.
1710 @deffn Method ede-map-subprojects :AFTER this proc
1711 For object @var{THIS}, execute @var{PROC} on all direct subprojects.
1712 This function does not apply @var{PROC} to sub-sub projects.
1713 See also @dfn{ede-map-all-subprojects}.
1716 @deffn Method ede-convert-path :AFTER this path
1717 Convert path in a standard way for a given project.
1718 Default to making it project relative.
1719 Argument @var{THIS} is the project to convert @var{PATH} to.
1722 @deffn Method ede-name :AFTER this
1723 Return a short-name for @var{THIS} project file.
1724 Do this by extracting the lowest directory name.
1727 @deffn Method ede-set-project-variables :AFTER project &optional buffer
1728 Set variables local to @var{PROJECT} in @var{BUFFER}.
1731 @deffn Method eieio-speedbar-derive-line-path :AFTER obj &optional depth
1732 Return the path to @var{OBJ}.
1733 Optional @var{DEPTH} is the depth we start at.
1736 @deffn Method ede-map-all-subprojects :AFTER this allproc
1737 For object @var{THIS}, execute PROC on @var{THIS} and all subprojects.
1738 This function also applies PROC to sub-sub projects.
1739 See also @dfn{ede-map-subprojects}.
1742 @deffn Method project-update-version :AFTER ot
1743 The @code{:version} of the project @var{OT} has been updated.
1744 Handle saving, or other detail.
1747 @deffn Method ede-buffer-header-file :AFTER this buffer
1748 Return @code{nil}, projects don't have header files.
1751 @deffn Method ede-buffer-documentation-files :AFTER this buffer
1752 Return all documentation in project @var{THIS} based on @var{BUFFER}.
1755 @deffn Method ede-map-targets :AFTER this proc
1756 For object @var{THIS}, execute @var{PROC} on all targets.
1759 @deffn Method ede-buffer-mine :AFTER this buffer
1760 Return non-@code{nil} if object @var{THIS} lays claim to the file in @var{BUFFER}.
1763 @deffn Method ede-object-keybindings :BEFORE this
1764 Retrieves the slot @code{keybindings} from an object of class @code{ede-project}
1767 @deffn Method ede-description :AFTER this
1768 Return a description suitable for the minibuffer about @var{THIS}.
1771 @deffn Method eieio-speedbar-object-children :AFTER this
1772 Return the list of speedbar display children for @var{THIS}.
1775 @deffn Method project-make-dist :AFTER this
1776 Build a distribution for the project based on @var{THIS} project.
1779 @deffn Method ede-system-include-path :AFTER this
1780 Get the system include path used by project @var{THIS}.
1783 @deffn Method project-new-target-custom :AFTER proj
1784 Create a new target. It is up to the project @var{PROJ} to get the name.
1787 @deffn Method ede-subproject-p :AFTER proj
1788 Return non-@code{nil} if @var{PROJ} is a sub project.
1791 @deffn Method ede-expand-filename :AFTER this filename &optional force
1792 Return a fully qualified file name based on project @var{THIS}.
1793 @var{FILENAME} should be just a filename which occurs in a directory controlled
1795 Optional argument @var{FORCE} forces the default filename to be provided even if it
1799 @deffn Method ede-menu-items-build :AFTER obj &optional current
1800 Return a list of menu items for building project @var{OBJ}.
1801 If optional argument @var{CURRENT} is non-@code{nil}, return sub-menu code.
1804 @deffn Method ede-update-version-in-source :AFTER this version
1805 Change occurrences of a version string in sources.
1806 In project @var{THIS}, cycle over all targets to give them a chance to set
1807 their sources to @var{VERSION}.
1810 @deffn Method project-new-target :AFTER proj &rest args
1811 Create a new target. It is up to the project @var{PROJ} to get the name.
1814 @deffn Method project-compile-project :AFTER obj &optional command
1815 Compile the entire current project @var{OBJ}.
1816 Argument @var{COMMAND} is the command to use when compiling.
1819 @deffn Method eieio-speedbar-object-buttonname :AFTER object
1820 Return a string to use as a speedbar button for @var{OBJECT}.
1823 @deffn Method ede-map-project-buffers :AFTER this proc
1824 For @var{THIS}, execute @var{PROC} on all buffers belonging to @var{THIS}.
1827 @deffn Method ede-expand-filename-impl :AFTER this filename &optional force
1828 Return a fully qualified file name based on project @var{THIS}.
1829 @var{FILENAME} should be just a filename which occurs in a directory controlled
1831 Optional argument @var{FORCE} forces the default filename to be provided even if it
1835 @deffn Method eieio-done-customizing :AFTER proj
1836 Call this when a user finishes customizing @var{PROJ}.
1839 @deffn Method ede-html-documentation :AFTER this
1840 Return a list of HTML files provided by project @var{THIS}.
1843 @deffn Method ede-documentation :AFTER this
1844 Return a list of files that provides documentation.
1845 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
1846 files in the project.
1849 @deffn Method project-interactive-select-target :AFTER this prompt
1850 Interactively query for a target that exists in project @var{THIS}.
1851 Argument @var{PROMPT} is the prompt to use when querying the user for a target.
1854 @deffn Method ede-target-in-project-p :AFTER proj target
1855 Is @var{PROJ} the parent of @var{TARGET}?
1856 If @var{TARGET} belongs to a subproject, return that project file.
1859 @deffn Method ede-find-target :AFTER proj buffer
1860 Fetch the target in @var{PROJ} belonging to @var{BUFFER} or nil.
1863 @deffn Method ede-add-subproject :AFTER proj-a proj-b
1864 Add into @var{PROJ-A}, the subproject @var{PROJ-B}.
1867 @deffn Method ede-commit-project :AFTER proj
1868 Commit any change to @var{PROJ} to its file.
1871 @deffn Method project-dist-files :AFTER this
1872 Return a list of files that constitutes a distribution of @var{THIS} project.
1875 @deffn Method ede-object-menu :BEFORE this
1876 Retrieves the slot @code{menu} from an object of class @code{ede-project}
1879 @deffn Method ede-commit-local-variables :AFTER proj
1880 Commit change to local variables in @var{PROJ}.
1883 @node ede-cpp-root-project, ede-simple-project, ede-project, Project
1884 @subsection ede-cpp-root-project
1885 @pjindex ede-cpp-root-project
1888 @item Inheritance Tree:
1890 @item eieio-speedbar
1892 @item eieio-speedbar-directory-button
1894 @item @w{@xref{ede-project-placeholder}.}
1896 @item @w{@xref{ede-project}.}
1898 @item ede-cpp-root-project
1907 This class implements the @code{ede-cpp-root} project type.
1908 @xref{ede-cpp-root}, for information about using this project type.
1915 Type: @code{list} @*
1916 Default Value: @code{(quote ("/include" "../include/"))}
1918 The default locate function expands filenames within a project.
1919 If a header file (.h, .hh, etc) name is expanded, and
1920 the @code{:locate-fcn} slot is @code{nil}, then the include path is checked
1921 first, and other directories are ignored. For very large
1922 projects, this optimization can save a lot of time.
1924 Directory names in the path can be relative to the current
1925 buffer's @code{default-directory} (not starting with a /). Directories
1926 that are relative to the project's root should start with a /, such
1927 as "/include", meaning the directory @code{include} off the project root
1931 @item :system-include-path
1932 Type: @code{list} @*
1933 Default Value: @code{nil}
1935 The system include path for files in this project.
1936 C files initialized in an ede-cpp-root-project have their semantic
1937 system include path set to this value. If this is @code{nil}, then the
1938 semantic path is not modified.
1942 Type: @code{list} @*
1943 Default Value: @code{nil}
1945 C Preprocessor macros for your files.
1946 Preprocessor symbols will be used while parsing your files.
1947 These macros might be passed in through the command line compiler, or
1948 are critical symbols derived from header files. Providing header files
1949 macro values through this slot improves accuracy and performance.
1950 Use `:spp-files' to use these files directly.
1954 Type: @code{list} @*
1955 Default Value: @code{nil}
1957 C header file with Preprocessor macros for your files.
1958 The PreProcessor symbols appearing in these files will be used while
1959 parsing files in this project.
1960 See @code{semantic-lex-c-preprocessor-symbol-map} for more on how this works.
1963 @item :header-match-regexp
1964 Type: @code{string} @*
1965 Default Value: @code{"\\.\\(h\\(h\\|xx\\|pp\\|\\+\\+\\)?\\|H\\)$\\|\\<\\w+$"}
1967 Regexp used to identify C/C++ header files.
1971 Type: @code{(or null function)} @*
1972 Default Value: @code{nil}
1974 The locate function can be used in place of
1975 @dfn{ede-expand-filename} so you can quickly customize your custom target
1976 to use specialized local routines instead of the EDE routines.
1977 The function symbol must take two arguments:
1978 NAME - The name of the file to find.
1979 DIR - The directory root for this cpp-root project.
1981 It should return the fully qualified file name passed in from NAME. If that file does not
1982 exist, it should return nil.
1988 @subsubsection Specialized Methods
1990 @deffn Method initialize-instance :AFTER this &rest fields
1991 Make sure the @code{:file} is fully expanded.
1994 @deffn Method ede-preprocessor-map :AFTER this
1995 Get the pre-processor map for project @var{THIS}.
1998 @deffn Method ede-cpp-root-header-file-p :AFTER proj name
1999 Non @code{nil} if in @var{PROJ} the filename @var{NAME} is a header.
2002 @deffn Method ede-system-include-path :AFTER this
2003 Get the system include path used by project @var{THIS}.
2006 @deffn Method ede-expand-filename-impl :AFTER proj name
2007 Within this project @var{PROJ}, find the file @var{NAME}.
2008 This knows details about or source tree.
2011 @node ede-simple-project, ede-simple-base-project, ede-cpp-root-project, Project
2012 @subsection ede-simple-project
2013 @pjindex ede-simple-project
2016 @item Inheritance Tree:
2018 @item eieio-speedbar
2020 @item eieio-speedbar-directory-button
2022 @item @w{@xref{ede-project-placeholder}.}
2024 @item @w{@xref{ede-project}.}
2026 @item ede-simple-project
2035 @subsubsection Specialized Methods
2037 @deffn Method ede-commit-project :AFTER proj
2038 Commit any change to @var{PROJ} to its file.
2041 @node ede-simple-base-project, ede-proj-project, ede-simple-project, Project
2042 @subsection ede-simple-base-project
2043 @pjindex ede-simple-base-project
2046 @item Inheritance Tree:
2048 @item eieio-speedbar
2050 @item eieio-speedbar-directory-button
2052 @item @w{@xref{ede-project-placeholder}.}
2054 @item @w{@xref{ede-project}.}
2056 @item ede-simple-base-project
2065 EDE Simple project base class.
2066 This one project could control a tree of subdirectories.
2071 @node ede-proj-project, project-am-makefile, ede-simple-base-project, Project
2072 @subsection ede-proj-project
2073 @pjindex ede-proj-project
2076 @item Inheritance Tree:
2078 @item eieio-speedbar
2080 @item eieio-speedbar-directory-button
2082 @item @w{@xref{ede-project-placeholder}.}
2084 @item @w{@xref{ede-project}.}
2086 @item ede-proj-project
2099 @item :makefile-type
2100 Type: @code{symbol} @*
2101 Default Value: @code{Makefile}
2103 The type of Makefile to generate.
2104 Can be one of @code{'Makefile}, 'Makefile.in, or 'Makefile.am.
2105 If this value is NOT @code{'Makefile}, then that overrides the @code{:makefile} slot
2110 Type: @code{list} @*
2111 Default Value: @code{nil}
2113 Variables to set in this Makefile.
2116 @item :configuration-variables
2117 Type: @code{list} @*
2118 Default Value: @code{("debug" (("DEBUG" . "1")))}
2120 Makefile variables to use in different configurations.
2121 These variables are used in the makefile when a configuration becomes active.
2124 @item :inference-rules @*
2125 Default Value: @code{nil}
2127 Inference rules to add to the makefile.
2130 @item :include-file @*
2131 Default Value: @code{nil}
2133 Additional files to include.
2134 These files can contain additional rules, variables, and customizations.
2137 @item :automatic-dependencies
2138 Type: @code{boolean} @*
2139 Default Value: @code{t}
2141 Non-@code{nil} to do implement automatic dependencies in the Makefile.
2144 @item :metasubproject
2145 Type: @code{boolean} @*
2146 Default Value: @code{nil}
2148 Non-@code{nil} if this is a metasubproject.
2149 Usually, a subproject is determined by a parent project. If multiple top level
2150 projects are grouped into a large project not maintained by EDE, then you need
2151 to set this to non-nil. The only effect is that the @code{dist} rule will then avoid
2158 @subsubsection Specialized Methods
2160 @deffn Method ede-proj-makefile-create :AFTER this mfilename
2161 Create a Makefile for all Makefile targets in @var{THIS}.
2162 @var{MFILENAME} is the makefile to generate.
2165 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2166 Insert rules needed by @var{THIS} target.
2169 @deffn Method ede-proj-makefile-tags :AFTER this targets
2170 Insert into the current location rules to make recursive TAGS files.
2171 Argument @var{THIS} is the project to create tags for.
2172 Argument @var{TARGETS} are the targets we should depend on for TAGS.
2175 @deffn Method ede-proj-makefile-insert-variables :AFTER this
2176 Insert variables needed by target @var{THIS}.
2179 @deffn Method project-make-dist :AFTER this
2180 Build a distribution for the project based on @var{THIS} target.
2183 @deffn Method ede-proj-makefile-insert-dist-rules :AFTER this
2184 Insert distribution rules for @var{THIS} in a Makefile, such as CLEAN and DIST.
2187 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
2188 Insert any symbols that the DIST rule should depend on.
2189 Argument @var{THIS} is the project that should insert stuff.
2192 @deffn Method ede-proj-makefile-insert-subproj-rules :AFTER this
2193 Insert a rule for the project @var{THIS} which should be a subproject.
2196 @deffn Method ede-proj-makefile-create-maybe :AFTER this mfilename
2197 Create a Makefile for all Makefile targets in @var{THIS} if needed.
2198 @var{MFILENAME} is the makefile to generate.
2201 @deffn Method ede-proj-configure-test-required-file :AFTER this file
2202 For project @var{THIS}, test that the file @var{FILE} exists, or create it.
2205 @deffn Method ede-proj-setup-buildenvironment :AFTER this &optional force
2206 Setup the build environment for project @var{THIS}.
2207 Handles the Makefile, or a Makefile.am configure.ac combination.
2208 Optional argument @var{FORCE} will force items to be regenerated.
2211 @deffn Method ede-proj-makefile-garbage-patterns :AFTER this
2212 Return a list of patterns that are considered garbage to @var{THIS}.
2213 These are removed with make clean.
2216 @deffn Method ede-proj-configure-synchronize :AFTER this
2217 Synchronize what we know about project @var{THIS} into configure.ac.
2220 @deffn Method ede-proj-makefile-insert-variables-new :AFTER this
2221 Insert variables needed by target @var{THIS}.
2223 NOTE: Not yet in use! This is part of an SRecode conversion of
2224 EDE that is in progress.
2227 @deffn Method ede-proj-makefile-configuration-variables :AFTER this configuration
2228 Return a list of configuration variables from @var{THIS}.
2229 Use @var{CONFIGURATION} as the current configuration to query.
2232 @deffn Method eieio-done-customizing :AFTER proj
2233 Call this when a user finishes customizing this object.
2234 Argument @var{PROJ} is the project to save.
2237 @deffn Method ede-proj-configure-recreate :AFTER this
2238 Delete project @var{THIS}'s configure script and start over.
2241 @deffn Method ede-proj-makefile-insert-user-rules :AFTER this
2242 Insert user specified rules needed by @var{THIS} target.
2243 This is different from @dfn{ede-proj-makefile-insert-rules} in that this
2244 function won't create the building rules which are auto created with
2248 @deffn Method ede-proj-dist-makefile :AFTER this
2249 Return the name of the Makefile with the DIST target in it for @var{THIS}.
2252 @deffn Method ede-proj-configure-file :AFTER this
2253 The configure.ac script used by project @var{THIS}.
2256 @deffn Method ede-commit-project :AFTER proj
2257 Commit any change to @var{PROJ} to its file.
2260 @deffn Method project-dist-files :AFTER this
2261 Return a list of files that constitutes a distribution of @var{THIS} project.
2264 @deffn Method ede-commit-local-variables :AFTER proj
2265 Commit change to local variables in @var{PROJ}.
2268 @node project-am-makefile, ede-step-project, ede-proj-project, Project
2269 @subsection project-am-makefile
2270 @pjindex project-am-makefile
2273 @item Inheritance Tree:
2275 @item eieio-speedbar
2277 @item eieio-speedbar-directory-button
2279 @item @w{@xref{ede-project-placeholder}.}
2281 @item @w{@xref{ede-project}.}
2283 @item project-am-makefile
2292 @subsubsection Specialized Methods
2294 @deffn Method project-am-subtree :AFTER ampf subdir
2295 Return the sub project in @var{AMPF} specified by @var{SUBDIR}.
2298 @deffn Method project-targets-for-file :AFTER proj
2299 Return a list of targets the project @var{PROJ}.
2302 @deffn Method project-new-target :AFTER proj &optional name type
2303 Create a new target named @var{NAME}.
2304 Argument @var{TYPE} is the type of target to insert. This is a string
2305 matching something in @code{project-am-type-alist} or type class symbol.
2306 Despite the fact that this is a method, it depends on the current
2307 buffer being in order to provide a smart default target type.
2310 @node ede-step-project, , project-am-makefile, Project
2311 @subsection ede-step-project
2312 @pjindex ede-step-project
2315 @item Inheritance Tree:
2317 @item eieio-speedbar
2319 @item eieio-speedbar-directory-button
2321 @item @w{@xref{ede-project-placeholder}.}
2323 @item @w{@xref{ede-project}.}
2325 @item ede-step-project
2338 @item :init-variables
2339 Type: @code{list} @*
2340 Default Value: @code{nil}
2342 Variables to set in this Makefile, at top of file.
2345 @item :additional-variables
2346 Type: @code{(or null list)} @*
2347 Default Value: @code{nil}
2349 Arbitrary variables needed from this project.
2350 It is safe to leave this blank.
2353 @item :additional-rules
2354 Type: @code{(or null list)} @*
2355 Default Value: @code{nil}
2357 Arbitrary rules and dependencies needed to make this target.
2358 It is safe to leave this blank.
2361 @item :installation-domain
2362 Type: @code{symbol} @*
2363 Default Value: @code{user}
2365 Installation domain specification.
2366 The variable GNUSTEP_INSTALLATION_DOMAIN is set at this value.
2370 Type: @code{(or null list)} @*
2371 Default Value: @code{(quote ("GNUmakefile.preamble"))}
2373 The auxiliary makefile for additional variables.
2374 Included just before the specific target files.
2378 Type: @code{(or null list)} @*
2379 Default Value: @code{(quote ("GNUmakefile.postamble"))}
2381 The auxiliary makefile for additional rules.
2382 Included just after the specific target files.
2385 @item :metasubproject
2386 Type: @code{boolean} @*
2387 Default Value: @code{nil}
2389 Non-@code{nil} if this is a metasubproject.
2390 Usually, a subproject is determined by a parent project. If multiple top level
2391 projects are grouped into a large project not maintained by EDE, then you need
2392 to set this to non-nil. The only effect is that the @code{dist} rule will then avoid
2399 @subsubsection Specialized Methods
2401 @deffn Method ede-proj-makefile-create :AFTER this mfilename
2402 Create a GNUmakefile for all Makefile targets in @var{THIS}.
2403 @var{MFILENAME} is the makefile to generate.
2406 @deffn Method project-make-dist :AFTER this
2407 Build a distribution for the project based on @var{THIS} target.
2410 @deffn Method ede-proj-makefile-create-maybe :AFTER this mfilename
2411 Create a Makefile for all Makefile targets in @var{THIS} if needed.
2412 @var{MFILENAME} is the makefile to generate.
2415 @deffn Method ede-proj-setup-buildenvironment :AFTER this &optional force
2416 Setup the build environment for project @var{THIS}.
2417 Handles the Makefile, or a Makefile.am configure.ac combination.
2418 Optional argument @var{FORCE} will force items to be regenerated.
2421 @deffn Method eieio-done-customizing :AFTER proj
2422 Call this when a user finishes customizing this object.
2423 Argument @var{PROJ} is the project to save.
2426 @deffn Method ede-proj-dist-makefile :AFTER this
2427 Return the name of the Makefile with the DIST target in it for @var{THIS}.
2430 @deffn Method ede-commit-project :AFTER proj
2431 Commit any change to @var{PROJ} to its file.
2434 @deffn Method project-dist-files :AFTER this
2435 Return a list of files that constitutes a distribution of @var{THIS} project.
2438 @deffn Method ede-commit-local-variables :AFTER proj
2439 Commit change to local variables in @var{PROJ}.
2442 @node Targets, Sourcecode, Project, Extending EDE
2448 * ede-proj-target-makefile::
2449 * semantic-ede-proj-target-grammar::
2450 * ede-proj-target-makefile-objectcode::
2451 * ede-proj-target-makefile-archive::
2452 * ede-proj-target-makefile-program::
2453 * ede-proj-target-makefile-shared-object::
2454 * ede-proj-target-elisp::
2455 * ede-proj-target-elisp-autoloads::
2456 * ede-proj-target-makefile-miscelaneous::
2457 * ede-proj-target-makefile-info::
2458 * ede-proj-target-scheme::
2459 * project-am-target::
2460 * project-am-objectcode::
2461 * project-am-program::
2462 * project-am-header-noinst::
2463 * project-am-header-inst::
2465 * project-am-texinfo::
2470 @node ede-target, ede-proj-target, Targets, Targets
2471 @subsection ede-target
2475 @item Inheritance Tree:
2477 @item eieio-speedbar
2479 @item eieio-speedbar-directory-button
2484 @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}.}
2498 Name of this target.
2504 The path to the sources of this target.
2505 Relative to the path of the project it belongs to.
2509 Type: @code{list} @*
2510 Default Value: @code{nil}
2512 Source files in this target.
2515 @item :versionsource
2516 Type: @code{list} @*
2517 Default Value: @code{nil}
2519 Source files with a version string in them.
2520 These files are checked for a version string whenever the EDE version
2521 of the master project is changed. When strings are found, the version
2522 previously there is updated.
2528 @subsubsection Specialized Methods
2530 @deffn Method ede-preprocessor-map :AFTER this
2531 Get the pre-processor map for project @var{THIS}.
2534 @deffn Method eieio-speedbar-description :AFTER obj
2535 Provide a speedbar description for @var{OBJ}.
2538 @deffn Method project-compile-target :AFTER obj &optional command
2539 Compile the current target @var{OBJ}.
2540 Argument @var{COMMAND} is the command to use for compiling the target.
2543 @deffn Method project-debug-target :AFTER obj
2544 Run the current project target @var{OBJ} in a debugger.
2547 @deffn Method ede-convert-path :AFTER this path
2548 Convert path in a standard way for a given project.
2549 Default to making it project relative.
2550 Argument @var{THIS} is the project to convert @var{PATH} to.
2553 @deffn Method ede-name :AFTER this
2554 Return the name of @var{THIS} targt.
2557 @deffn Method ede-target-buffer-in-sourcelist :AFTER this buffer source
2558 Return non-@code{nil} if object @var{THIS} is in @var{BUFFER} to a @var{SOURCE} list.
2559 Handles complex path issues.
2562 @deffn Method eieio-speedbar-derive-line-path :AFTER obj &optional depth
2563 Return the path to @var{OBJ}.
2564 Optional @var{DEPTH} is the depth we start at.
2567 @deffn Method ede-buffer-header-file :AFTER this buffer
2568 There are no default header files in EDE.
2569 Do a quick check to see if there is a Header tag in this buffer.
2572 @deffn Method project-remove-file :AFTER ot fnnd
2573 Remove the current buffer from project target @var{OT}.
2574 Argument @var{FNND} is an argument.
2577 @deffn Method ede-buffer-documentation-files :AFTER this buffer
2578 Check for some documentation files for @var{THIS}.
2579 Also do a quick check to see if there is a Documentation tag in this @var{BUFFER}.
2582 @deffn Method ede-map-target-buffers :AFTER this proc
2583 For @var{THIS}, execute @var{PROC} on all buffers belonging to @var{THIS}.
2586 @deffn Method eieio-speedbar-child-description :AFTER obj
2587 Provide a speedbar description for a plain-child of @var{OBJ}.
2588 A plain child is a child element which is not an EIEIO object.
2591 @deffn Method ede-object-keybindings :BEFORE this
2592 Retrieves the slot @code{keybindings} from an object of class @code{ede-target}
2595 @deffn Method ede-description :AFTER this
2596 Return a description suitable for the minibuffer about @var{THIS}.
2599 @deffn Method eieio-speedbar-object-children :AFTER this
2600 Return the list of speedbar display children for @var{THIS}.
2603 @deffn Method ede-system-include-path :AFTER this
2604 Get the system include path used by project @var{THIS}.
2607 @deffn Method ede-object-sourcecode :BEFORE this
2608 Retrieves the slot @code{sourcetype} from an object of class @code{ede-target}
2611 @deffn Method ede-expand-filename :AFTER this filename &optional force
2612 Return a fully qualified file name based on target @var{THIS}.
2613 @var{FILENAME} should be a filename which occurs in a directory in which @var{THIS} works.
2614 Optional argument @var{FORCE} forces the default filename to be provided even if it
2618 @deffn Method ede-menu-items-build :AFTER obj &optional current
2619 Return a list of menu items for building target @var{OBJ}.
2620 If optional argument @var{CURRENT} is non-@code{nil}, return sub-menu code.
2623 @deffn Method ede-want-file-p :AFTER this file
2624 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2627 @deffn Method ede-update-version-in-source :AFTER this version
2628 In sources for @var{THIS}, change version numbers to @var{VERSION}.
2631 @deffn Method project-delete-target :AFTER ot
2632 Delete the current target @var{OT} from it's parent project.
2635 @deffn Method ede-target-sourcecode :AFTER this
2636 Return the sourcecode objects which @var{THIS} permits.
2639 @deffn Method eieio-speedbar-child-make-tag-lines :AFTER this depth
2640 Create a speedbar tag line for a child of @var{THIS}.
2641 It has depth @var{DEPTH}.
2644 @deffn Method eieio-speedbar-object-buttonname :AFTER object
2645 Return a string to use as a speedbar button for @var{OBJECT}.
2648 @deffn Method eieio-done-customizing :AFTER target
2649 Call this when a user finishes customizing @var{TARGET}.
2652 @deffn Method project-edit-file-target :AFTER ot
2653 Edit the target @var{OT} associated w/ this file.
2656 @deffn Method ede-documentation :AFTER this
2657 Return a list of files that provides documentation.
2658 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
2659 files in the project.
2662 @deffn Method ede-want-file-source-p :AFTER this file
2663 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2666 @deffn Method ede-want-file-auxiliary-p :AFTER this file
2667 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2670 @deffn Method project-add-file :AFTER ot file
2671 Add the current buffer into project project target @var{OT}.
2672 Argument @var{FILE} is the file to add.
2675 @deffn Method ede-target-name :AFTER this
2676 Return the name of @var{THIS} target, suitable for make or debug style commands.
2679 @deffn Method ede-object-menu :BEFORE this
2680 Retrieves the slot @code{menu} from an object of class @code{ede-target}
2683 @node ede-proj-target, ede-proj-target-makefile, ede-target, Targets
2684 @subsection ede-proj-target
2685 @tgindex ede-proj-target
2688 @item Inheritance Tree:
2690 @item eieio-speedbar
2692 @item eieio-speedbar-directory-button
2694 @item @w{@xref{ede-target}.}
2696 @item ede-proj-target
2699 @w{@xref{ede-proj-target-makefile},} @w{ede-proj-target-aux,} @w{@xref{ede-proj-target-scheme}.}
2714 Name of this target.
2720 The path to the sources of this target.
2721 Relative to the path of the project it belongs to.
2725 Type: @code{list} @*
2726 Default Value: @code{nil}
2728 Auxiliary source files included in this target.
2729 Each of these is considered equivalent to a source file, but it is not
2730 distributed, and each should have a corresponding rule to build it.
2734 Type: @code{(or null symbol)} @*
2735 Default Value: @code{nil}
2737 The compiler to be used to compile this object.
2738 This should be a symbol, which contains the object defining the compiler.
2739 This enables save/restore to do so by name, permitting the sharing
2740 of these compiler resources, and global customization thereof.
2744 Type: @code{(or null symbol)} @*
2745 Default Value: @code{nil}
2747 The linker to be used to link compiled sources for this object.
2748 This should be a symbol, which contains the object defining the linker.
2749 This enables save/restore to do so by name, permitting the sharing
2750 of these linker resources, and global customization thereof.
2756 @subsubsection Specialized Methods
2758 @deffn Method project-compile-target :AFTER obj &optional command
2759 Compile the current target @var{OBJ}.
2760 Argument @var{COMMAND} is the command to use for compiling the target.
2763 @deffn Method project-debug-target :AFTER obj
2764 Run the current project target @var{OBJ} in a debugger.
2767 @deffn Method ede-proj-configure-add-missing :AFTER this
2768 Query if any files needed by @var{THIS} provided by automake are missing.
2769 Results in --add-missing being passed to automake.
2772 @deffn Method ede-proj-flush-autoconf :AFTER this
2773 Flush the configure file (current buffer) to accommodate @var{THIS}.
2774 By flushing, remove any cruft that may be in the file. Subsequent
2775 calls to @dfn{ede-proj-tweak-autoconf} can restore items removed by flush.
2778 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2779 Insert rules needed by @var{THIS} target.
2782 @deffn Method project-remove-file :AFTER target file
2783 For @var{TARGET}, remove @var{FILE}.
2784 @var{FILE} must be massaged by @dfn{ede-convert-path}.
2787 @deffn Method ede-proj-configure-create-missing :AFTER this
2788 Add any missing files for @var{THIS} by creating them.
2791 @deffn Method ede-proj-makefile-sourcevar :AFTER this
2792 Return the variable name for @var{THIS}'s sources.
2795 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
2796 Insert variables needed by target @var{THIS}.
2797 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2801 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
2802 Insert variables needed by target @var{THIS} in Makefile.am after SOURCES.
2805 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
2806 Insert any symbols that the DIST rule should depend on.
2807 Argument @var{THIS} is the target that should insert stuff.
2810 @deffn Method ede-proj-linkers :AFTER obj
2811 List of linkers being used by @var{OBJ}.
2812 If the @code{linker} slot is empty, concoct one on a first match found
2813 basis for any given type from the @code{availablelinkers} slot.
2814 Otherwise, return the @code{linker} slot.
2815 Converts all symbols into the objects to be used.
2818 @deffn Method ede-proj-makefile-garbage-patterns :AFTER this
2819 Return a list of patterns that are considered garbage to @var{THIS}.
2820 These are removed with make clean.
2823 @deffn Method ede-proj-tweak-autoconf :AFTER this
2824 Tweak the configure file (current buffer) to accommodate @var{THIS}.
2827 @deffn Method ede-proj-compilers :AFTER obj
2828 List of compilers being used by @var{OBJ}.
2829 If the @code{compiler} slot is empty, concoct one on a first match found
2830 basis for any given type from the @code{availablecompilers} slot.
2831 Otherwise, return the @code{compiler} slot.
2832 Converts all symbols into the objects to be used.
2835 @deffn Method project-delete-target :AFTER this
2836 Delete the current target @var{THIS} from it's parent project.
2839 @deffn Method ede-proj-makefile-target-name :AFTER this
2840 Return the name of the main target for @var{THIS} target.
2843 @deffn Method eieio-done-customizing :AFTER target
2844 Call this when a user finishes customizing this object.
2845 Argument @var{TARGET} is the project we are completing customization on.
2848 @deffn Method ede-proj-makefile-insert-user-rules :AFTER this
2849 Insert user specified rules needed by @var{THIS} target.
2852 @deffn Method project-add-file :AFTER this file
2853 Add to target @var{THIS} the current buffer represented as @var{FILE}.
2856 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
2857 Insert variables needed by target @var{THIS} in Makefile.am before SOURCES.
2860 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
2861 Insert any symbols that the DIST rule should depend on.
2862 Argument @var{THIS} is the target that should insert stuff.
2865 @deffn Method ede-proj-makefile-dependency-files :AFTER this
2866 Return a list of source files to convert to dependencies.
2867 Argument @var{THIS} is the target to get sources from.
2870 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
2871 Insert the source variables needed by @var{THIS}.
2872 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2877 @node ede-proj-target-makefile, semantic-ede-proj-target-grammar, ede-proj-target, Targets
2878 @subsection ede-proj-target-makefile
2879 @tgindex ede-proj-target-makefile
2882 @item Inheritance Tree:
2884 @item eieio-speedbar
2886 @item eieio-speedbar-directory-button
2888 @item @w{@xref{ede-target}.}
2890 @item @w{@xref{ede-proj-target}.}
2892 @item ede-proj-target-makefile
2895 @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}.}
2909 Type: @code{string} @*
2910 Default Value: @code{"Makefile"}
2912 File name of generated Makefile.
2916 Type: @code{boolean} @*
2917 Default Value: @code{t}
2919 Non @code{nil} means the rule created is part of the all target.
2920 Setting this to @code{nil} creates the rule to build this item, but does not
2921 include it in the ALL`all:' rule.
2924 @item :configuration-variables
2925 Type: @code{list} @*
2926 Default Value: @code{nil}
2928 Makefile variables appended to use in different configurations.
2929 These variables are used in the makefile when a configuration becomes active.
2930 Target variables are always renamed such as foo_CFLAGS, then included into
2931 commands where the variable would usually appear.
2935 Type: @code{list} @*
2936 Default Value: @code{nil}
2938 Arbitrary rules and dependencies needed to make this target.
2939 It is safe to leave this blank.
2945 @subsubsection Specialized Methods
2947 @deffn Method ede-proj-makefile-dependencies :AFTER this
2948 Return a string representing the dependencies for @var{THIS}.
2949 Some compilers only use the first element in the dependencies, others
2950 have a list of intermediates (object files), and others don't care.
2951 This allows customization of how these elements appear.
2954 @deffn Method project-compile-target :AFTER obj &optional command
2955 Compile the current target program @var{OBJ}.
2956 Optional argument @var{COMMAND} is the s the alternate command to use.
2959 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2960 Insert rules needed by @var{THIS} target.
2963 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
2964 Insert variables needed by target @var{THIS}.
2965 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2969 @deffn Method ede-proj-makefile-insert-commands :AFTER this
2970 Insert the commands needed by target @var{THIS}.
2971 For targets, insert the commands needed by the chosen compiler.
2974 @deffn Method ede-proj-makefile-configuration-variables :AFTER this configuration
2975 Return a list of configuration variables from @var{THIS}.
2976 Use @var{CONFIGURATION} as the current configuration to query.
2979 @node semantic-ede-proj-target-grammar, ede-proj-target-makefile-objectcode, ede-proj-target-makefile, Targets
2980 @subsection semantic-ede-proj-target-grammar
2981 @tgindex semantic-ede-proj-target-grammar
2984 @item Inheritance Tree:
2986 @item eieio-speedbar
2988 @item eieio-speedbar-directory-button
2990 @item @w{@xref{ede-target}.}
2992 @item @w{@xref{ede-proj-target}.}
2994 @item @w{@xref{ede-proj-target-makefile}.}
2996 @item semantic-ede-proj-target-grammar
3006 @subsubsection Specialized Methods
3008 @deffn Method project-compile-target :AFTER obj
3009 Compile all sources in a Lisp target @var{OBJ}.
3012 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3013 Insert rules needed by @var{THIS} target.
3016 @deffn Method ede-buffer-mine :AFTER this buffer
3017 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3018 Lays claim to all -by.el, and -wy.el files.
3021 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3022 Return the variable name for @var{THIS}'s sources.
3025 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3026 Insert dist dependencies, or intermediate targets.
3027 This makes sure that all grammar lisp files are created before the dist
3028 runs, so they are always up to date.
3029 Argument @var{THIS} is the target that should insert stuff.
3033 @node ede-proj-target-makefile-objectcode, ede-proj-target-makefile-archive, semantic-ede-proj-target-grammar, Targets
3034 @subsection ede-proj-target-makefile-objectcode
3035 @tgindex ede-proj-target-makefile-objectcode
3038 @item Inheritance Tree:
3040 @item eieio-speedbar
3042 @item eieio-speedbar-directory-button
3044 @item @w{@xref{ede-target}.}
3046 @item @w{@xref{ede-proj-target}.}
3048 @item @w{@xref{ede-proj-target-makefile}.}
3050 @item ede-proj-target-makefile-objectcode
3053 @w{@xref{ede-proj-target-makefile-archive},} @w{@xref{ede-proj-target-makefile-program}.}
3067 @item :configuration-variables
3068 Type: @code{list} @*
3069 Default Value: @code{("debug" ("CFLAGS" . "-g") ("LDFLAGS" . "-g"))}
3071 @xref{ede-proj-target-makefile}.
3074 @subsubsection Specialized Methods
3076 @deffn Method ede-buffer-header-file :AFTER this buffer
3077 There are no default header files.
3080 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3081 Return the variable name for @var{THIS}'s sources.
3084 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
3085 Insert variables needed by target @var{THIS}.
3086 Optional argument @var{MORESOURCE} is not used.
3089 @deffn Method ede-proj-makefile-dependency-files :AFTER this
3090 Return a list of source files to convert to dependencies.
3091 Argument @var{THIS} is the target to get sources from.
3095 @node ede-proj-target-makefile-archive, ede-proj-target-makefile-program, ede-proj-target-makefile-objectcode, Targets
3096 @subsection ede-proj-target-makefile-archive
3097 @tgindex ede-proj-target-makefile-archive
3100 @item Inheritance Tree:
3102 @item eieio-speedbar
3104 @item eieio-speedbar-directory-button
3106 @item @w{@xref{ede-target}.}
3108 @item @w{@xref{ede-proj-target}.}
3110 @item @w{@xref{ede-proj-target-makefile}.}
3112 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3114 @item ede-proj-target-makefile-archive
3125 @subsubsection Specialized Methods
3127 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3128 Create the make rule needed to create an archive for @var{THIS}.
3131 @deffn Method ede-proj-makefile-insert-source-variables :PRIMARY this
3132 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3133 We aren't actually inserting SOURCE details, but this is used by the
3134 Makefile.am generator, so use it to add this important bin program.
3138 @node ede-proj-target-makefile-program, ede-proj-target-makefile-shared-object, ede-proj-target-makefile-archive, Targets
3139 @subsection ede-proj-target-makefile-program
3140 @tgindex ede-proj-target-makefile-program
3143 @item Inheritance Tree:
3145 @item eieio-speedbar
3147 @item eieio-speedbar-directory-button
3149 @item @w{@xref{ede-target}.}
3151 @item @w{@xref{ede-proj-target}.}
3153 @item @w{@xref{ede-proj-target-makefile}.}
3155 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3157 @item ede-proj-target-makefile-program
3160 @w{@xref{ede-proj-target-makefile-shared-object}.}
3176 Type: @code{list} @*
3177 Default Value: @code{nil}
3179 Libraries, such as "m" or "Xt" which this program depends on.
3180 The linker flag "-l" is automatically prepended. Do not include a "lib"
3181 prefix, or a ".so" suffix.
3183 Note: Currently only used for Automake projects.
3187 Type: @code{list} @*
3188 Default Value: @code{nil}
3190 Additional flags to add when linking this target.
3191 Use ldlibs to add addition libraries. Use this to specify specific
3192 options to the linker.
3194 Note: Not currently used. This bug needs to be fixed.
3200 @subsubsection Specialized Methods
3202 @deffn Method project-debug-target :AFTER obj
3203 Debug a program target @var{OBJ}.
3206 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3207 Insert rules needed by @var{THIS} target.
3210 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
3211 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3214 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
3215 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3219 @node ede-proj-target-makefile-shared-object, ede-proj-target-elisp, ede-proj-target-makefile-program, Targets
3220 @subsection ede-proj-target-makefile-shared-object
3221 @tgindex ede-proj-target-makefile-shared-object
3224 @item Inheritance Tree:
3226 @item eieio-speedbar
3228 @item eieio-speedbar-directory-button
3230 @item @w{@xref{ede-target}.}
3232 @item @w{@xref{ede-proj-target}.}
3234 @item @w{@xref{ede-proj-target-makefile}.}
3236 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3238 @item @w{@xref{ede-proj-target-makefile-program}.}
3240 @item ede-proj-target-makefile-shared-object
3252 @subsubsection Specialized Methods
3254 @deffn Method ede-proj-configure-add-missing :AFTER this
3255 Query if any files needed by @var{THIS} provided by automake are missing.
3256 Results in --add-missing being passed to automake.
3259 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3260 Return the variable name for @var{THIS}'s sources.
3263 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
3264 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3265 We need to override -program which has an LDADD element.
3268 @deffn Method ede-proj-makefile-target-name :AFTER this
3269 Return the name of the main target for @var{THIS} target.
3272 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
3273 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3274 We aren't actually inserting SOURCE details, but this is used by the
3275 Makefile.am generator, so use it to add this important bin program.
3279 @node ede-proj-target-elisp, ede-proj-target-elisp-autoloads, ede-proj-target-makefile-shared-object, Targets
3280 @subsection ede-proj-target-elisp
3281 @tgindex ede-proj-target-elisp
3284 @item Inheritance Tree:
3286 @item eieio-speedbar
3288 @item eieio-speedbar-directory-button
3290 @item @w{@xref{ede-target}.}
3292 @item @w{@xref{ede-proj-target}.}
3294 @item @w{@xref{ede-proj-target-makefile}.}
3296 @item ede-proj-target-elisp
3299 @w{@xref{ede-proj-target-elisp-autoloads}.}
3314 Type: @code{list} @*
3315 Default Value: @code{nil}
3317 Additional packages needed.
3318 There should only be one toplevel package per auxiliary tool needed.
3319 These packages location is found, and added to the compile time
3326 @subsubsection Specialized Methods
3328 @deffn Method project-compile-target :AFTER obj
3329 Compile all sources in a Lisp target @var{OBJ}.
3330 Bonus: Return a cons cell: (COMPILED . UPTODATE).
3333 @deffn Method ede-proj-flush-autoconf :AFTER this
3334 Flush the configure file (current buffer) to accommodate @var{THIS}.
3337 @deffn Method ede-buffer-mine :AFTER this buffer
3338 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3339 Lays claim to all .elc files that match .el files in this target.
3342 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3343 Return the variable name for @var{THIS}'s sources.
3346 @deffn Method ede-proj-tweak-autoconf :AFTER this
3347 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3350 @deffn Method ede-update-version-in-source :AFTER this version
3351 In a Lisp file, updated a version string for @var{THIS} to @var{VERSION}.
3352 There are standards in Elisp files specifying how the version string
3353 is found, such as a @code{-version} variable, or the standard header.
3356 @node ede-proj-target-elisp-autoloads, ede-proj-target-makefile-miscelaneous, ede-proj-target-elisp, Targets
3357 @subsection ede-proj-target-elisp-autoloads
3358 @tgindex ede-proj-target-elisp-autoloads
3361 @item Inheritance Tree:
3363 @item eieio-speedbar
3365 @item eieio-speedbar-directory-button
3367 @item @w{@xref{ede-target}.}
3369 @item @w{@xref{ede-proj-target}.}
3371 @item @w{@xref{ede-proj-target-makefile}.}
3373 @item @w{@xref{ede-proj-target-elisp}.}
3375 @item ede-proj-target-elisp-autoloads
3391 Type: @code{list} @*
3392 Default Value: @code{("cedet-autogen")}
3394 @xref{ede-proj-target-elisp}.
3395 @item :autoload-file
3396 Type: @code{string} @*
3397 Default Value: @code{"loaddefs.el"}
3399 The file that autoload definitions are placed in.
3400 There should be one load defs file for a given package. The load defs are created
3401 for all Emacs Lisp sources that exist in the directory of the created target.
3404 @item :autoload-dirs
3405 Type: @code{list} @*
3406 Default Value: @code{nil}
3408 The directories to scan for autoload definitions.
3409 If @code{nil} defaults to the current directory.
3415 @subsubsection Specialized Methods
3417 @deffn Method ede-proj-makefile-dependencies :AFTER this
3418 Return a string representing the dependencies for @var{THIS}.
3419 Always return an empty string for an autoloads generator.
3422 @deffn Method project-compile-target :AFTER obj
3423 Create or update the autoload target.
3426 @deffn Method ede-proj-flush-autoconf :AFTER this
3427 Flush the configure file (current buffer) to accommodate @var{THIS}.
3430 @deffn Method ede-buffer-mine :AFTER this buffer
3431 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3432 Lays claim to all .elc files that match .el files in this target.
3435 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3436 Return the variable name for @var{THIS}'s sources.
3439 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3440 Insert any symbols that the DIST rule should depend on.
3441 Emacs Lisp autoload files ship the generated .el files.
3442 Argument @var{THIS} is the target which needs to insert an info file.
3445 @deffn Method ede-proj-tweak-autoconf :AFTER this
3446 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3449 @deffn Method ede-update-version-in-source :AFTER this version
3450 In a Lisp file, updated a version string for @var{THIS} to @var{VERSION}.
3451 There are standards in Elisp files specifying how the version string
3452 is found, such as a @code{-version} variable, or the standard header.
3455 @deffn Method ede-proj-compilers :AFTER obj
3456 List of compilers being used by @var{OBJ}.
3457 If the @code{compiler} slot is empty, get the car of the compilers list.
3460 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
3461 Insert any symbols that the DIST rule should distribute.
3462 Emacs Lisp autoload files ship the generated .el files.
3463 Argument @var{THIS} is the target which needs to insert an info file.
3466 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
3467 Insert the source variables needed by @var{THIS}.
3468 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
3473 @node ede-proj-target-makefile-miscelaneous, ede-proj-target-makefile-info, ede-proj-target-elisp-autoloads, Targets
3474 @subsection ede-proj-target-makefile-miscelaneous
3475 @tgindex ede-proj-target-makefile-miscelaneous
3478 @item Inheritance Tree:
3480 @item eieio-speedbar
3482 @item eieio-speedbar-directory-button
3484 @item @w{@xref{ede-target}.}
3486 @item @w{@xref{ede-proj-target}.}
3488 @item @w{@xref{ede-proj-target-makefile}.}
3490 @item ede-proj-target-makefile-miscelaneous
3505 Type: @code{string} @*
3506 Default Value: @code{""}
3508 Miscellaneous sources which have a specialized makefile.
3509 The sub-makefile is used to build this target.
3515 @subsubsection Specialized Methods
3517 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3518 Create the make rule needed to create an archive for @var{THIS}.
3521 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3522 Return the variable name for @var{THIS}'s sources.
3525 @deffn Method ede-proj-makefile-dependency-files :AFTER this
3526 Return a list of files which @var{THIS} target depends on.
3530 @node ede-proj-target-makefile-info, ede-proj-target-scheme, ede-proj-target-makefile-miscelaneous, Targets
3531 @subsection ede-proj-target-makefile-info
3532 @tgindex ede-proj-target-makefile-info
3535 @item Inheritance Tree:
3537 @item eieio-speedbar
3539 @item eieio-speedbar-directory-button
3541 @item @w{@xref{ede-target}.}
3543 @item @w{@xref{ede-proj-target}.}
3545 @item @w{@xref{ede-proj-target-makefile}.}
3547 @item ede-proj-target-makefile-info
3562 Type: @code{string} @*
3563 Default Value: @code{""}
3565 The main menu resides in this file.
3566 All other sources should be included independently.
3572 @subsubsection Specialized Methods
3574 @deffn Method ede-proj-configure-add-missing :AFTER this
3575 Query if any files needed by @var{THIS} provided by automake are missing.
3576 Results in --add-missing being passed to automake.
3579 @deffn Method object-write :AFTER this
3580 Before committing any change to @var{THIS}, make sure the mainmenu is first.
3583 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3584 Return the variable name for @var{THIS}'s sources.
3587 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3588 Insert any symbols that the DIST rule should depend on.
3589 Texinfo files want to insert generated `.info' files.
3590 Argument @var{THIS} is the target which needs to insert an info file.
3593 @deffn Method ede-proj-makefile-target-name :AFTER this
3594 Return the name of the main target for @var{THIS} target.
3597 @deffn Method ede-documentation :AFTER this
3598 Return a list of files that provides documentation.
3599 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
3600 files in the project.
3603 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
3604 Insert any symbols that the DIST rule should depend on.
3605 Texinfo files want to insert generated `.info' files.
3606 Argument @var{THIS} is the target which needs to insert an info file.
3609 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
3610 Insert the source variables needed by @var{THIS} info target.
3611 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
3613 Does the usual for Makefile mode, but splits source into two variables
3614 when working in Automake mode.
3617 @node ede-proj-target-scheme, project-am-target, ede-proj-target-makefile-info, Targets
3618 @subsection ede-proj-target-scheme
3619 @tgindex ede-proj-target-scheme
3622 @item Inheritance Tree:
3624 @item eieio-speedbar
3626 @item eieio-speedbar-directory-button
3628 @item @w{@xref{ede-target}.}
3630 @item @w{@xref{ede-proj-target}.}
3632 @item ede-proj-target-scheme
3646 Type: @code{string} @*
3647 Default Value: @code{"guile"}
3649 The preferred interpreter for this code.
3655 @subsubsection Specialized Methods
3657 @deffn Method ede-proj-tweak-autoconf :AFTER this
3658 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3662 @node project-am-target, project-am-objectcode, ede-proj-target-scheme, Targets
3663 @subsection project-am-target
3664 @tgindex project-am-target
3667 @item Inheritance Tree:
3669 @item eieio-speedbar
3671 @item eieio-speedbar-directory-button
3673 @item @w{@xref{ede-target}.}
3675 @item project-am-target
3678 @w{@xref{project-am-objectcode},} @w{project-am-header,} @w{@xref{project-am-lisp},} @w{@xref{project-am-texinfo},} @w{@xref{project-am-man}.}
3686 @subsubsection Specialized Methods
3688 @deffn Method project-compile-target-command :AFTER this
3689 Default target to use when compiling a given target.
3692 @deffn Method project-make-dist :AFTER this
3693 Run the current project in the debugger.
3696 @deffn Method project-edit-file-target :AFTER obj
3697 Edit the target associated w/ this file.
3700 @node project-am-objectcode, project-am-program, project-am-target, Targets
3701 @subsection project-am-objectcode
3702 @tgindex project-am-objectcode
3705 @item Inheritance Tree:
3707 @item eieio-speedbar
3709 @item eieio-speedbar-directory-button
3711 @item @w{@xref{ede-target}.}
3713 @item @w{@xref{project-am-target}.}
3715 @item project-am-objectcode
3718 @w{@xref{project-am-program},} @w{project-am-lib.}
3727 @subsubsection Specialized Methods
3729 @deffn Method project-am-macro :AFTER this
3730 Return the default macro to 'edit' for this object type.
3733 @deffn Method project-debug-target :AFTER obj
3734 Run the current project target in a debugger.
3737 @deffn Method project-compile-target-command :AFTER this
3738 Default target to use when compiling an object code target.
3741 @deffn Method ede-buffer-header-file :AFTER this buffer
3742 There are no default header files.
3745 @node project-am-program, project-am-header-noinst, project-am-objectcode, Targets
3746 @subsection project-am-program
3747 @tgindex project-am-program
3750 @item Inheritance Tree:
3752 @item eieio-speedbar
3754 @item eieio-speedbar-directory-button
3756 @item @w{@xref{ede-target}.}
3758 @item @w{@xref{project-am-target}.}
3760 @item @w{@xref{project-am-objectcode}.}
3762 @item project-am-program
3777 Default Value: @code{nil}
3784 @node project-am-header-noinst, project-am-header-inst, project-am-program, Targets
3785 @subsection project-am-header-noinst
3786 @tgindex project-am-header-noinst
3789 @item Inheritance Tree:
3791 @item eieio-speedbar
3793 @item eieio-speedbar-directory-button
3795 @item @w{@xref{ede-target}.}
3797 @item @w{@xref{project-am-target}.}
3799 @item @w{project-am-header.}
3801 @item project-am-header-noinst
3811 @subsubsection Specialized Methods
3813 @deffn Method project-am-macro :AFTER this
3814 Return the default macro to 'edit' for this object.
3817 @node project-am-header-inst, project-am-lisp, project-am-header-noinst, Targets
3818 @subsection project-am-header-inst
3819 @tgindex project-am-header-inst
3822 @item Inheritance Tree:
3824 @item eieio-speedbar
3826 @item eieio-speedbar-directory-button
3828 @item @w{@xref{ede-target}.}
3830 @item @w{@xref{project-am-target}.}
3832 @item @w{project-am-header.}
3834 @item project-am-header-inst
3844 @subsubsection Specialized Methods
3846 @deffn Method project-am-macro :AFTER this
3847 Return the default macro to 'edit' for this object.
3850 @node project-am-lisp, project-am-texinfo, project-am-header-inst, Targets
3851 @subsection project-am-lisp
3852 @tgindex project-am-lisp
3855 @item Inheritance Tree:
3857 @item eieio-speedbar
3859 @item eieio-speedbar-directory-button
3861 @item @w{@xref{ede-target}.}
3863 @item @w{@xref{project-am-target}.}
3865 @item project-am-lisp
3874 @subsubsection Specialized Methods
3876 @deffn Method project-am-macro :AFTER this
3877 Return the default macro to 'edit' for this object.
3880 @node project-am-texinfo, project-am-man, project-am-lisp, Targets
3881 @subsection project-am-texinfo
3882 @tgindex project-am-texinfo
3885 @item Inheritance Tree:
3887 @item eieio-speedbar
3889 @item eieio-speedbar-directory-button
3891 @item @w{@xref{ede-target}.}
3893 @item @w{@xref{project-am-target}.}
3895 @item project-am-texinfo
3909 Default Value: @code{nil}
3911 Additional texinfo included in this one.
3916 @subsubsection Specialized Methods
3918 @deffn Method project-am-macro :AFTER this
3919 Return the default macro to 'edit' for this object type.
3922 @deffn Method project-compile-target-command :AFTER this
3923 Default target to use when compiling a texinfo file.
3926 @deffn Method ede-documentation :AFTER this
3927 Return a list of files that provides documentation.
3928 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
3929 files in the project.
3932 @node project-am-man, , project-am-texinfo, Targets
3933 @comment node-name, next, previous, up
3934 @subsection project-am-man
3935 @tgindex project-am-man
3938 @item Inheritance Tree:
3940 @item eieio-speedbar
3942 @item eieio-speedbar-directory-button
3944 @item @w{@xref{ede-target}.}
3946 @item @w{@xref{project-am-target}.}
3948 @item project-am-man
3957 @subsubsection Specialized Methods
3959 @deffn Method project-am-macro :AFTER this
3960 Return the default macro to 'edit' for this object type.
3963 @node Sourcecode, Compilers, Targets, Extending EDE
3966 The source code type is an object designed to associated files with
3974 @node ede-sourcecode, , Sourcecode, Sourcecode
3975 @subsection ede-sourcecode
3976 @scindex ede-sourcecode
3979 @item Inheritance Tree:
3981 @item eieio-instance-inheritor
3983 @item ede-sourcecode
3993 @item :parent-instance
3994 Type: @code{eieio-instance-inheritor-child}
3996 The parent of this instance.
3997 If a slot of this class is reference, and is unbound, then the parent
3998 is checked for a value.
4004 The name of this type of source code.
4005 Such as "C" or "Emacs Lisp"
4008 @item :sourcepattern
4009 Type: @code{string} @*
4010 Default Value: @code{".*"}
4012 Emacs regex matching sourcecode this target accepts.
4015 @item :auxsourcepattern
4016 Type: @code{(or null string)} @*
4017 Default Value: @code{nil}
4019 Emacs regex matching auxiliary source code this target accepts.
4020 Aux source are source code files needed for compilation, which are not compiled
4024 @item :enable-subdirectories
4025 Type: @code{boolean} @*
4026 Default Value: @code{nil}
4028 Non @code{nil} if this sourcecode type uses subdirectores.
4029 If sourcecode always lives near the target creating it, this should be nil.
4030 If sourcecode can, or typically lives in a subdirectory of the owning
4031 target, set this to t.
4034 @item :garbagepattern
4035 Type: @code{list} @*
4036 Default Value: @code{nil}
4038 Shell file regex matching files considered as garbage.
4039 This is a list of items added to an @code{rm} command when executing a @code{clean}
4046 @subsubsection Specialized Methods
4048 @deffn Method ede-want-any-files-p :AFTER this filenames
4049 Return non-@code{nil} if @var{THIS} will accept any files in @var{FILENAMES}.
4052 @deffn Method ede-want-any-source-files-p :AFTER this filenames
4053 Return non-@code{nil} if @var{THIS} will accept any source files in @var{FILENAMES}.
4056 @deffn Method ede-want-any-auxiliary-files-p :AFTER this filenames
4057 Return non-@code{nil} if @var{THIS} will accept any aux files in @var{FILENAMES}.
4060 @deffn Method ede-buffer-header-file :AFTER this filename
4061 Return a list of file names of header files for @var{THIS} with @var{FILENAME}.
4062 Used to guess header files, but uses the auxsource regular expression.
4065 @deffn Method ede-want-file-p :AFTER this filename
4066 Return non-@code{nil} if sourcecode definition @var{THIS} will take @var{FILENAME}.
4069 @deffn Method ede-want-file-source-p :AFTER this filename
4070 Return non-@code{nil} if @var{THIS} will take @var{FILENAME} as an auxiliary .
4073 @deffn Method ede-want-file-auxiliary-p :AFTER this filename
4074 Return non-@code{nil} if @var{THIS} will take @var{FILENAME} as an auxiliary .
4077 @node Compilers, , Sourcecode, Extending EDE
4080 The compiler object is designed to associate source code with
4081 compilers. The target then references the compilers it can use.
4082 When the makefile is created, this object type knows how to create
4086 * ede-compilation-program::
4088 * ede-object-compiler::
4093 @node ede-compilation-program, ede-compiler, Compilers, Compilers
4094 @subsection ede-compilation-program
4095 @cmindex ede-compilation-program
4098 @item Inheritance Tree:
4100 @item eieio-instance-inheritor
4102 @item ede-compilation-program
4105 @w{@xref{ede-compiler},} @w{@xref{ede-linker}.}
4115 @item :parent-instance
4116 Type: @code{eieio-instance-inheritor-child}
4118 The parent of this instance.
4119 If a slot of this class is reference, and is unbound, then the parent
4120 is checked for a value.
4126 Name of this type of compiler.
4132 Variables needed in the Makefile for this compiler.
4133 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4134 is a string, and VALUE is either a string, or a list of strings.
4135 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4141 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4142 This is used to match target objects with the compilers and linkers
4143 they can use, and which files this object is interested in.
4147 Type: @code{list} @*
4148 Default Value: @code{nil}
4150 Auxiliary rules needed for this compiler to run.
4151 For example, yacc/lex files need additional chain rules, or inferences.
4157 The commands used to execute this compiler.
4158 The object which uses this compiler will place these commands after
4159 it's rule definition.
4163 Type: @code{list} @*
4164 Default Value: @code{nil}
4166 Autoconf function to call if this type of compiler is used.
4167 When a project is in Automake mode, this defines the autoconf function to
4168 call to initialize automake to use this compiler.
4169 For example, there may be multiple C compilers, but they all probably
4170 use the same autoconf form.
4173 @item :objectextention
4176 A string which is the extension used for object files.
4177 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4183 @subsubsection Specialized Methods
4185 @deffn Method ede-proj-flush-autoconf :AFTER this
4186 Flush the configure file (current buffer) to accommodate @var{THIS}.
4189 @deffn Method ede-proj-makefile-insert-rules :AFTER this
4190 Insert rules needed for @var{THIS} compiler object.
4193 @deffn Method ede-proj-makefile-insert-variables :AFTER this
4194 Insert variables needed by the compiler @var{THIS}.
4197 @deffn Method ede-proj-makefile-insert-commands :AFTER this
4198 Insert the commands needed to use compiler @var{THIS}.
4199 The object creating makefile rules must call this method for the
4200 compiler it decides to use after inserting in the rule.
4203 @deffn Method ede-object-sourcecode :AFTER this
4204 Retrieves the slot @code{sourcetype} from an object of class @code{ede-compilation-program}
4207 @deffn Method ede-proj-tweak-autoconf :AFTER this
4208 Tweak the configure file (current buffer) to accommodate @var{THIS}.
4212 @node ede-compiler, ede-object-compiler, ede-compilation-program, Compilers
4213 @subsection ede-compiler
4214 @cmindex ede-compiler
4217 @item Inheritance Tree:
4219 @item eieio-instance-inheritor
4221 @item @w{@xref{ede-compilation-program}.}
4226 @w{@xref{ede-object-compiler},} @w{semantic-ede-grammar-compiler-class.}
4236 Create a new object with name NAME of class type ede-compiler
4242 @item :parent-instance
4243 Type: @code{eieio-instance-inheritor-child}
4245 The parent of this instance.
4246 If a slot of this class is reference, and is unbound, then the parent
4247 is checked for a value.
4253 Name of this type of compiler.
4259 Variables needed in the Makefile for this compiler.
4260 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4261 is a string, and VALUE is either a string, or a list of strings.
4262 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4268 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4269 This is used to match target objects with the compilers and linkers
4270 they can use, and which files this object is interested in.
4276 The commands used to execute this compiler.
4277 The object which uses this compiler will place these commands after
4278 it's rule definition.
4281 @item :objectextention
4284 A string which is the extension used for object files.
4285 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4289 Type: @code{boolean} @*
4290 Default Value: @code{nil}
4292 Non-@code{nil} if this compiler can make dependencies.
4296 Type: @code{boolean} @*
4297 Default Value: @code{nil}
4299 Non-@code{nil} if this compiler creates code that can be linked.
4300 This requires that the containing target also define a list of available
4301 linkers that can be used.
4307 @subsubsection Specialized Methods
4309 @deffn Method ede-proj-makefile-insert-object-variables :AFTER this targetname sourcefiles
4310 Insert an OBJ variable to specify object code to be generated for @var{THIS}.
4311 The name of the target is @var{TARGETNAME} as a string. @var{SOURCEFILES} is the list of
4312 files to be objectified.
4313 Not all compilers do this.
4316 @deffn Method ede-compiler-intermediate-objects-p :AFTER this
4317 Return non-@code{nil} if @var{THIS} has intermediate object files.
4318 If this compiler creates code that can be linked together,
4319 then the object files created by the compiler are considered intermediate.
4322 @deffn Method ede-compiler-intermediate-object-variable :AFTER this targetname
4323 Return a string based on @var{THIS} representing a make object variable.
4324 @var{TARGETNAME} is the name of the target that these objects belong to.
4328 @node ede-object-compiler, ede-linker, ede-compiler, Compilers
4329 @subsection ede-object-compiler
4330 @cmindex ede-object-compiler
4333 @item Inheritance Tree:
4335 @item eieio-instance-inheritor
4337 @item @w{@xref{ede-compilation-program}.}
4339 @item @w{@xref{ede-compiler}.}
4341 @item ede-object-compiler
4354 Type: @code{boolean} @*
4355 Default Value: @code{t}
4357 @xref{ede-compiler}.
4358 @item :dependencyvar
4361 A variable dedicated to dependency generation.
4366 @subsubsection Specialized Methods
4368 @deffn Method ede-proj-makefile-insert-variables :AFTER this
4369 Insert variables needed by the compiler @var{THIS}.
4372 @node ede-linker, , ede-object-compiler, Compilers
4373 @subsection ede-linker
4377 @item Inheritance Tree:
4379 @item eieio-instance-inheritor
4381 @item @w{@xref{ede-compilation-program}.}
4392 Create a new object with name NAME of class type ede-linker
4401 Name of this type of compiler.
4407 Variables needed in the Makefile for this compiler.
4408 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4409 is a string, and VALUE is either a string, or a list of strings.
4410 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4416 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4417 This is used to match target objects with the compilers and linkers
4418 they can use, and which files this object is interested in.
4424 The commands used to execute this compiler.
4425 The object which uses this compiler will place these commands after
4426 it's rule definition.
4429 @item :objectextention
4432 A string which is the extension used for object files.
4433 For example, C code uses .o on unix, and Emacs Lisp uses .elc.