2 @setfilename ../../info/ede
3 @settitle Emacs Development Environment
4 @documentencoding UTF-8
7 This file describes EDE, the Emacs Development Environment.
9 Copyright @copyright{} 1998--2001, 2004--2005, 2008--2014
10 Free Software Foundation, Inc.
13 Permission is granted to copy, distribute and/or modify this document
14 under the terms of the GNU Free Documentation License, Version 1.3 or
15 any later version published by the Free Software Foundation; with no
16 Invariant Sections, with the Front-Cover texts being ``A GNU Manual,''
17 and with the Back-Cover Texts as in (a) below. A copy of the license
18 is included in the section entitled ``GNU Free Documentation License.''
20 (a) The FSF's Back-Cover Text is: ``You have the freedom to copy and
21 modify this GNU manual.''
25 @dircategory Emacs misc features
27 * EDE: (ede). The Emacs Development Environment.
31 @center @titlefont{EDE (The Emacs Development Environment)}
33 @center by Eric Ludlam
35 @vskip 0pt plus 1filll
70 @node Top, EDE Project Concepts, (dir), (dir)
72 @comment node-name, next, previous, up
74 @ede{} is the Emacs Development Environment: an Emacs extension that
75 simplifies building and debugging programs in Emacs. It attempts to
76 emulate a typical IDE (Integrated Development Environment). @ede{}
77 can manage or create your makefiles and other building environment
78 duties, allowing you to concentrate on writing code rather than
79 support files. It aims to make it much easier for new programmers to
80 learn and adopt GNU ways of doing things.
87 * EDE Project Concepts:: @ede{} Project Concepts
88 * EDE Mode:: Turning on @ede{} mode.
89 * Quick Start:: Quick start to building a project.
90 * Creating a project:: Creating a project.
91 * Modifying your project:: Adding and removing files and targets.
92 * Building and Debugging:: Initiating a build or debug session.
93 * Miscellaneous commands:: Other project related commands.
94 * Extending EDE:: Programming and extending @ede{}.
95 * GNU Free Documentation License:: The license for this documentation.
98 @node EDE Project Concepts, EDE Mode, Top, Top
99 @chapter @ede{} Project Concepts
101 @ede{} is a generic interface for managing projects. It specifies a
102 single set of menus and keybindings, while supporting multiple ways to
103 express a project via a build system.
105 In the subsequent chapters, we will describe the different project
106 types (@pxref{Creating a project}), as well as the commands to build
107 and debug projects (@pxref{Building and Debugging}).
109 In @ede{}, a project hierarchy matches a directory hierarchy. The
110 project's topmost directory is called the @dfn{project root}, and its
111 subdirectories are @dfn{subprojects}.
113 Each project can contain multiple @dfn{targets}. A target, at the
114 simplest level, is a named collection of files within a project. A
115 target can specify two different types of information:
119 A collection of files to be added to a distribution (e.g., a tarball
120 that you intend to distribute to others).
123 A collection of files that can be built into something else (e.g., a
124 program or compiled documentation).
127 Lastly, @ede{} provides a way for other tools to easily learn file
128 associations. For example, a program might need to restrict some sort
129 of search to files in a single target, or to discover the location of
130 documentation or interface files. @ede{} can provide this
133 @node EDE Mode, Quick Start, EDE Project Concepts, Top
136 @ede{} is implemented as a minor mode, which augments other modes such
137 as C mode, and Texinfo mode. You can enable @ede{} for all buffers by
138 running the command @code{global-ede-mode}, or by putting this in your
145 Activating @ede{} adds a menu named @samp{Development} to the menu
146 bar. This menu provides several menu items for high-level @ede{}
147 commands. These menu items, and their corresponding keybindings, are
148 independent of the type of project you are actually working on.
150 @node Quick Start, Creating a project, EDE Mode, Top
153 Once you have @ede{} enabled, you can create a project. This chapter
154 provides an example C++ project that will create Automake files for
157 @section Step 1: Create root directory
159 First, lets create a directory for our project. For this example,
160 we'll start with something in @file{/tmp}.
163 C-x C-f /tmp/myproject/README RET
164 M-x make-directory RET RET
167 Now put some plain text in your README file to start.
169 Now, lets create the project:
172 M-x ede-new RET Automake RET myproject RET
176 Nothing visible happened, but if you use @code{dired} to look at the
177 directory, you should see this:
181 total used in directory 32 available 166643476
182 drwxr-xr-x 2 zappo users 4096 2012-02-23 22:10 .
183 drwxrwxrwt 73 root root 20480 2012-02-23 22:10 ..
184 -rw-r--r-- 1 zappo users 195 2012-02-23 22:10 Project.ede
185 -rw-r--r-- 1 zappo users 10 2012-02-23 22:09 README
188 @section Step 2: Create Subdirectories and Files
190 We'll make a more complex project, so use dired to create some more
191 directories using the @kbd{+} key, and typing in new directories:
198 Now I'll short-cut in this tutorial. Create the following files:
200 @file{include/myproj.hh}
208 #define IMPORTANT_MACRO 1
210 int my_lib_function();
228 #ifdef IMPORTANT_MACRO
239 * Shared Library to build
242 int my_lib_function() @{
247 @section Step 3: Create subprojects
249 @ede{} needs subdirectories to also have projects in them. You can
250 now create those projects.
252 With @file{main.cpp} as your current buffer, type:
255 M-x ede-new RET Automake RET src RET
258 and in @file{myproj.hh} as your current buffer, type:
261 M-x ede-new RET Automake RET include RET
264 These steps effectively only create the Project.ede file in which you
265 will start adding targets.
267 @section Step 4: Create targets
269 In order to build a program, you must have targets in your @ede{}
270 Projects. You can create targets either from a buffer, or from a
271 @code{dired} directory buffer.
273 Note: If for some reason a directory list buffer, or file does not have the
274 @samp{Project} menu item, or if @ede{} keybindings don't work, just
275 use @kbd{M-x revert-buffer RET} to force a refresh. Sometimes
276 creating a new project doesn't restart buffers correctly.
278 Lets start with the header file. In @file{include/myproj.hh}, you
279 could use the menu, but we will now start using the @ede{} command prefix
280 which is @kbd{C-c .}.
283 C-c . t includes RET miscellaneous RET y
287 This creates a misc target for holding your includes, and then adds
288 myproj.hh to the target. Automake (the tool) has better ways to do
289 this, but for this project, it is sufficient.
291 Next, visit the @file{src} directory using dired. There should be a
292 @samp{Project} menu. You can create a new target with
295 . t myprogram RET program RET
298 Note that @kbd{. t} is a command for creating a target. This command
299 is also in the menu. This will create a target that will build a
300 program. If you want, visit @file{Project.ede} to see the structure
303 Next, place the cursor on @file{main.cpp}, and use @kbd{. a} to add
304 that file to your target.
310 Note that these prompts often have completion, so you can just press
311 @kbd{TAB} to complete the name @file{myprogram}.
313 If you had many files to add to the same target, you could mark them
314 all in your dired buffer, and add them all at the same time.
316 Next, do the same for the library by placing the cursor on @file{mylib.cpp}.
319 . t mylib RET sharedobject RET
323 @section Step 5: Compile, and fail
325 Next, we'll try to compile the project, but we aren't done yet, so it
326 won't work right away.
328 Visit @file{/tmp/myproject/Project.ede}. We're starting here because
329 we don't have any program files in this directory yet. Now we can use
336 Because this is the very first time, it will create a bunch of files
337 for you that are required by Automake. It will then use automake to
338 build the support infrastructure it needs. This step is skipped if
339 you choose just a @file{Makefile} build system.
341 After the Automake init, it runs compile. You will immediately
342 discover the error in main.cpp can't find @file{myproj.hh}. We need
345 @section Step 6: Customizing your project
347 To fix the failed compile, we need to add
348 @file{/tmp/myproject/include} to the include path.
350 Visit @file{main.cpp}.
353 M-x customize-project RET
356 Select the @samp{[Settings]} subgroup of options. Under
357 @samp{Variable :} click @samp{[INS]}. At this point, you need to be
358 somewhat savvy with Automake. Add a variable named @samp{CPPFLAGS},
359 and set the value to @samp{../include}.
361 You should see something like this:
365 [INS] [DEL] Cons-cell:
369 Variables to set in this Makefile.
372 Click @samp{[Apply]}. Feel free to visit @file{Project.ede} to see
373 how it changed the config file.
375 Compile the whole project again with @kbd{C-c . C} from
376 @file{main.cpp}. It should now compile.
378 @section Step 7: Shared library dependency
380 Note: Supporting shared libraries for Automake in this way is easy,
381 but doing so from a project of type Makefile is a bit tricky. If you
382 are creating shared libraries too, stick to Automake projects.
384 Next, lets add a dependency from @file{main.cpp} on our shared
385 library. To do that, update main like this:
401 where the lower case @kbd{c} compiles just that target. You should
404 This time, we need to add a dependency from @file{main.cpp} on our shared
405 library. To do that, we need to customize our target instead of the
406 project. This is because variables such as the include path are
407 treated globally, whereas dependencies for a target are target specific.
410 M-x customize-target RET
413 On the first page, you will see an Ldlibs-local section. Add mylib to
414 it by first clicking @samp{[INS]}, and they adding the library. It
415 should look like this:
419 [INS] [DEL] Local Library: libmylib.la
421 Libraries that are part of this project. [Hide Rest]
422 The full path to these libraries should be specified, such as:
423 ../lib/libMylib.la or ../ar/myArchive.a
426 You will also see other variables for library related flags and system
427 libraries if you need them. Click @samp{[Accept]}, and from
428 @file{main.cpp}, again compile the whole project to force all
429 dependent elements to compile:
435 @section Step 8: Run your program
437 You can run your program directly from @ede{}.
443 If your program takes command line arguments, you can type them in
444 when it offers the command line you want to use to run your program.
446 @node Creating a project, Modifying your project, Quick Start, Top
447 @chapter Creating a project
449 To create a new project, first visit a file that you want to include
450 in that project. If you have a hierarchy of directories, first visit
451 a file in the topmost directory. From this buffer, type @kbd{M-x
452 ede-new}, or click on the @samp{Create Project} item in the
453 @samp{Development} menu.
455 The @command{ede-new} command prompts for the type of project you
456 would like to create. Each project type has its own benefits or
457 language specific enhancements. Not all projects that @ede{} supports
458 also allow creating a new project. Projects such as @code{emacs}
459 or @code{linux} are designed to recognize existing projects only.
460 Project types such as @samp{Make} and @samp{Automake} do support
461 creating new project types with @command{ede-new}.
465 For the @samp{Make} project type, @ede{} creates a @dfn{project file},
466 called @file{Project.ede}, in each project directory. Information
467 about the project is stored in this file. This project autogenerates
471 For the @samp{Automake} project type, @ede{} creates a
472 @file{Project.ede} project file similar to a @samp{Make} project.
473 Unlike a @samp{Make} project, this project autogenerates a
474 @file{Makefile.am} file. @ede{} handles the Automake bootstrapping
475 routines, which import and maintain a @file{configure.am} script and
476 other required files.
479 A subproject is merely a project in a subdirectory of another project.
480 You can create a subproject by using the @command{ede-new} command (or
481 the @samp{Create Project} menu item), while visiting a buffer in a
482 subdirectory of the project root. This new project is automatically
483 added to the parent project, and will be automatically loaded when
484 @ede{} reads the parent project.
486 When using a project command that involves a makefile, @ede{} uses
487 the top-most project's makefile as a starting place for the build. How
488 the toplevel project handles subprojects in the build process is
489 dependent on that project's type.
491 @node Modifying your project, Building and Debugging, Creating a project, Top
492 @chapter Modifying your project
494 In this chapter, we describe the generic features for manipulating
495 projects, including the targets and files within them. Subsequent
496 chapters, which describe specific project types, will provide more
497 detailed information about exactly what these features do.
500 * Add/Remove target::
502 * Customize Features::
503 * Project Local Variables::
504 * EDE Project Features::
507 @node Add/Remove target, Add/Remove files, Modifying your project, Modifying your project
508 @section Add/Remove target
510 To create a new target, type @kbd{C-c . t} (@code{ede-new-target}) or
511 use the @samp{Add Target} menu item in the @samp{Project Options}
512 submenu. This prompts for a target name, and adds the current buffer
515 The @command{ede-new-target} command also prompts for a @dfn{target
516 type}. Each target type has its own build process and class of files
519 To remove a target from the project, type @kbd{M-x ede-delete-target},
520 or use the @samp{Remove Target} menu item in the @samp{Project
523 @node Add/Remove files, Customize Features, Add/Remove target, Modifying your project
524 @section Add/Remove files
526 To add the current file to an existing target, type @kbd{C-c . a}
527 (@code{ede-add-file}), or use the @samp{Add File} menu item in the
528 @samp{Target Options} submenu.
530 You can add a file to more than one target; this is OK.
532 To remove the current file from a target, type @kbd{C-c . d}
533 (@code{ede-remove-file}), or use the @samp{Remove File} menu item
534 in the @samp{Target Options} submenu. If the file belongs to multiple
535 targets, this command prompts for each target it could be removed
538 While working in a project, if you visit a file that is not part of an
539 existing target, @ede{} automatically prompts for a target. If you do
540 not wish to add the file to any target, you can choose @samp{none}.
541 You can customize this behavior with the variable
542 @command{ede-auto-add-method}.
544 @node Customize Features, Project Local Variables, Add/Remove files, Modifying your project
545 @section Customize Features
547 A project, and its targets, are objects using the @samp{EIEIO} object
548 system. @xref{Top,,,eieio,EIEIO manual}. These objects have data
549 fields containing important information related to your work.
551 If the high-level functions aren't enough, you can tweak all
552 user-customizable fields at any time by running the command
553 @command{customize-project} or @command{customize-target}. This loads
554 the current project or target into a customization buffer, where you
555 can tweak individual slots. This is usually necessary for complex
558 Some project modes do not have a project file, but directly read a
559 Makefile or other existing file. Instead of directly editing the
560 object, you can edit the file by typing @kbd{C-c . e}
561 (@code{ede-edit-file-target}). You should ``rescan'' the project
562 afterwards (@pxref{Miscellaneous commands}).
564 @node Project Local Variables, EDE Project Features, Customize Features, Modifying your project
565 @section Project Local Variables
567 EDE projects can store and manager project local variables. The
568 variables are stored in the project, and will be restored when a
571 Projects which are not stored on disk WILL NOT restore your project
572 local variables later.
574 You can use @ref{Customize Features} to of the project to edit the
575 project local variables. They are under the 'Settings' group as
576 ``Project Local Variables''.
578 You can also use @kbd{M-x ede-set} to set a new variable local in the
581 In multi-level projects such as Automake and Make generating projects,
582 project local variables are installed from both the TOP most project,
583 and the local directory's project. In that way, you can have some
584 variables across your whole project, and some specific to a
587 You can use project local variables to set any Emacs variable so that
588 buffers belonging to different projects can have different settings.
590 NOTE: When you use project-local variables with @ref{ede-cpp-root},
591 the format is an association list. For example:
594 (ede-cpp-root-project "SOMENAME"
595 :file "/dir/to/some/file"
597 '((grep-command . "grep -nHi -e ")
598 (compile-command . "make -f MyCustomMakefile all")))
601 The same is true when you use project-local variables with
602 @ref{ede-java-root}. For example:
605 (ede-java-root-project "SOMENAME"
606 :file "/dir/to/some/file"
608 '((grep-command . "grep -nHi -e ")
609 (compile-command . "ant")))
612 @node EDE Project Features, , Project Local Variables, Modifying your project
613 @section EDE Project Features
615 This section details user facing features of an @ede{} @samp{Make}
616 style project. An @samp{Automake} project has similar options (but a
617 direct Automake project does not).
619 To modify any of the specific features mentioned here, you need to
620 customize the project or target with @command{customize-project} or
621 @command{customize-target}.
623 When you are customizing, you are directly manipulating slot values in
624 @eieio{} objects. @xref{Extending EDE}, if you are interested in
628 * Changing Compilers and Flags::
632 @node Changing Compilers and Flags, Configurations, EDE Project Features, EDE Project Features
633 @subsection Changing Compilers and Flags
635 Targets that build stuff need compilers. To change compilers, you
636 need to customize the desired target.
638 In the @samp{[Make]} section, you can choose a new compiler or linker
639 from the list. If a linker you need is not available, you will need
640 to create a new one. @xref{Compiler and Linker objects}.
642 If an existing compiler or linker is close, but you need to modify
643 some flag set such as adding an include path you will need to add a
644 configuration variable.
646 To start, you should create the basic setup, and construct a makefile
647 with @command{ede-proj-regenerate}. Look in the @file{Makefile} to
648 see what commands are inserted. Once you have determined the variable
649 you need to modify, you can add a configuration for it.
650 @xref{Configurations}.
652 @node Configurations, , Changing Compilers and Flags, EDE Project Features
653 @subsection Configurations
655 Configurations specify different ways to build a project. For
656 example, you may configure a project to be in ``debug'' mode, or
657 perhaps in ``release'' mode.
659 The project, and each target type all have a slot named
660 @code{configuration-variables}. To add new variables to a
661 configuration find this slot in the custom buffer, and insert a new
662 configuration. Name it either ``debug'' or ``release'', then insert
663 some number of name/value pairs to it.
665 You can have any number of valid configurations too. To add a new
666 configuration, customize your project. Work in the @samp{[Settings]}
667 block for ``configurations''. Add a new named configuration here.
669 To switch between different active configurations, modify the
670 ``configuration default'' slot.
672 @node Building and Debugging, Miscellaneous commands, Modifying your project, Top
673 @chapter Building and Debugging
675 @ede{} provides the following ``project-aware'' compilation and
680 Compile the current target (@code{ede-compile-target}).
682 Compile the entire project (@code{ede-compile-project}).
684 Debug the current target (@code{ede-debug-target}).
685 @item M-x ede-make-dist
686 Build a distribution file for your project.
689 These commands are also available from the @samp{Development} menu.
691 @node Miscellaneous commands, Extending EDE, Building and Debugging, Top
692 @chapter Miscellaneous commands
694 If you opt to go in and edit @ede{} project files directly---for
695 instance, by using @kbd{C-c . e} (@pxref{Customize Features})---you
696 must then ``rescan'' the project files to update the internal data
697 structures. To rescan the current project, type @kbd{C-c . g}
698 (@code{ede-rescan-toplevel}).
700 @ede{} can help you find files in your project, via the command
701 @kbd{C-c . f} (@code{ede-find-file}). This prompts for a file name;
702 you need not specify the directory. EDE then tries to visit a file
703 with that name somewhere in your project.
705 @ede{} can use external tools to help with file finding. To do this,
706 customize @code{ede-locate-setup-options}.
708 @defvar ede-locate-setup-options
709 @anchor{ede-locate-setup-options}
710 List of locate objects to try out by default.
711 Listed in order of preference. If the first item cannot be used in
712 a particular project, then the next one is tried.
713 It is always assumed that @dfn{ede-locate-base} is at end of the list.
716 @ede{} also provides a project display mode for the speedbar
717 (@pxref{Speedbar,,,emacs,GNU Emacs Manual}). This allows you to view
718 your source files as they are structured in your project: as a
719 hierarchical tree, grouped according to target.
721 To activate the speedbar in this mode, type @kbd{C-c . s}
722 (@code{ede-speedbar}).
725 * Make and Automake projects:: Project types of @samp{ede-project}
726 * Automake direct projects:: Project interface on hand-written automake files.
727 * Android projects:: Projects for Android development
728 * Arduino projects:: Projects for Arduino sketches
729 * Simple projects:: Projects @ede{} doesn't manage.
732 @node Make and Automake projects
733 @section Make and Automake projects
735 A project of @samp{ede-project} type creates a file called
736 @file{Project.ede} in every project directory. This is used to track
737 your configuration information. If you configure this project to be
738 in @samp{Makefile} mode, then this project will autogenerate a
739 @file{Makefile}. If you configure it in @samp{Automake} mode a
740 @file{Makefile.am} file will be created. The automake bootstrapping
741 routines will also import and maintain a configure.am script and a
742 host of other files required by Automake.
744 @node Automake direct projects
745 @section Automake direct projects
747 The project type that reads @file{Makefile.am} directly is derived
748 from the sources of the original @file{project-am.el} mode that was
749 distributed independently. This mode eventually became @ede{}. The
750 @samp{project-am} project will read existing automake files, but will
751 not generate them automatically, or create new ones. As such, it is
752 useful as a browsing tool, or as maintenance in managing file lists.
754 @node Android projects
755 @section Android projects
757 An Android project of type @samp{ede-android-project} will detect and
758 support development of Android apps. Android projects use an
759 @file{AndroidManifest.xml} file. Always load your Manifest first in a
760 running Emacs to make sure the project is identified correctly.
762 Android projects can be created with @code{ede-new} but depend on a
763 correctly configured Android SDK via @cedet{} support.
765 @defun cedet-android-sdk-root
766 @anchor{cedet-android-sdk-root}
767 The root to the Android @var{SDK}.
770 Android projects support different configurations including compile,
771 and install, which will upload a program to your Android device. It
772 also supports several debugging tools via @file{android.el}.
774 @node Arduino projects
775 @section Arduino projects
777 An arduino project of type @samp{ede-arduino-project} will read your
778 @file{~/.arduino/preferences.txt} file, and identify your sketches.
779 You will still need the Arduino IDE to set up your preferences and
780 locate your arduino. After quitting the IDE, Emacs will be able to
781 find your sketches, compile them, and upload them to your arduino.
783 If you have the @file{arduino} command on your path, @ede{} will be
784 able to find your SDK and compile your programs.
786 @node Simple projects
787 @section Simple Projects
789 There is a wide array of simple projects. In this case a simple
790 project is one that detects, or is directed to identify a directory as
791 belonging to a project, but doesn't provide many features of a typical
792 @ede{} project. Having the project however allows tools such as
793 @semantic{} to find sources and perform project level completions.
797 * ede-cpp-root:: This project marks the root of a C/C++ code project.
798 * ede-java-root:: This project marks the root of a Java project.
799 * ede-emacs:: A project for working with Emacs.
800 * ede-linux:: A project for working with Linux kernels.
801 * ede-generic-project:: A project type for wrapping build systems with EDE.
802 * Custom Locate:: Customizing how to locate files in a simple project
805 @node ede-cpp-root, ede-java-root, Simple projects, Simple projects
806 @subsection ede-cpp-root
808 The @code{ede-cpp-root} project type allows you to create a single
809 object with no save-file in your @file{.emacs} file. It allows @ede{}
810 to provide the @semantic{} package with the ability to find header
813 The @code{ede-cpp-root} class knows a few things about C++ projects,
814 such as the prevalence of "include" directories, and typical
815 file-layout stuff. If this isn't sufficient, you can subclass
816 @code{ede-cpp-root-project} and add your own tweaks in just a few
817 lines. See the end of this file for an example.
819 In the most basic case, add this to your @file{.emacs} file, modifying
820 appropriate bits as needed.
823 (ede-cpp-root-project "SOMENAME" :file "/dir/to/some/file")
826 Replace @var{SOMENAME} with whatever name you want, and the filename
827 to an actual file at the root of your project. It might be a
828 Makefile, a README file. Whatever. It doesn't matter. It's just a
829 key to hang the rest of @ede{} off of.
831 The most likely reason to create this project, is to speed up
832 searching for includes files, or to simplify bootstrapping @semantic{}'s
833 ability to find files without much user interaction. In conjunction
834 with @semantic{} completion, having a short include path is key. You can
835 override the default include path and system include path like this:
838 (ede-cpp-root-project "NAME" :file "FILENAME"
839 :include-path '( "/include" "../include" "/c/include" )
840 :system-include-path '( "/usr/include/c++/3.2.2/" )
841 :spp-table '( ("MOOSE" . "")
842 ("CONST" . "const") ) )
845 In this case each item in the include path list is searched. If the
846 directory starts with "/", then that expands to the project root
847 directory. If a directory does not start with "/", then it is
848 relative to the default-directory of the current buffer when the file
851 The include path only affects C/C++ header files. Use the slot
852 @code{:header-match-regexp} to change it.
854 The @code{:system-include-path} allows you to specify full directory
855 names to include directories where system header files can be found.
856 These will be applied to files in this project only.
858 The @code{:spp-table} provides a list of project specific #define
859 style macros that are unique to this project, passed in to the
860 compiler on the command line, or are in special headers.
861 See the @code{semantic-lex-c-preprocessor-symbol-map} for more
862 on how to format this entry.
864 If there is a single file in your project, you can instead set the
865 @code{:spp-files} to a list of file names relative to the root of your
866 project. Specifying this is like setting the variable
867 @code{semantic-lex-c-preprocessor-symbol-file} in semantic.
869 If you want to override the file-finding tool with your own
870 function you can do this:
873 (ede-cpp-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
876 Where @var{MYFCN} is a symbol for a function. The locate function can
877 be used in place of @code{ede-expand-filename} so you can quickly
878 customize your custom target to use specialized local routines instead
879 of the default @ede{} routines. The function symbol must take two
884 The name of the file to find.
886 The directory root for this cpp-root project.
889 When creating a project with @code{ede-cpp-root}, you can get
890 additional configurations via @ref{Project Local Variables}. Be aware
891 that the format for project local variables is an association list.
892 You cannot use @kbd{M-x ede-set} and have your project local variables
893 persist between sessions.
895 If the cpp-root project style is right for you, but you want a dynamic
896 loader, instead of hard-coding path name values in your @file{.emacs}, you
897 can do that too, but you will need to write some lisp code.
899 To do that, you need to add an entry to the
900 @code{ede-project-class-files} list, and also provide two functions to
901 teach @ede{} how to load your project pattern
903 It would look like this:
906 (defun MY-FILE-FOR-DIR (&optional dir)
907 "Return a full file name to the project file stored in DIR."
908 <write your code here, or return nil>
911 (defun MY-ROOT-FCN ()
912 "Return the root fcn for `default-directory'"
913 ;; You might be able to use `ede-cpp-root-project-root'
914 ;; and not write this at all.
918 "Load a project of type `cpp-root' for the directory DIR.
919 Return nil if there isn't one."
920 ;; Use your preferred construction method here.
921 (ede-cpp-root-project "NAME" :file (expand-file-name "FILE" dir)
925 (add-to-list 'ede-project-class-files
926 (ede-project-autoload "cpp-root"
929 :proj-file 'MY-FILE-FOR-DIR
930 :proj-root 'MY-ROOT-FCN
932 :class-sym 'ede-cpp-root)
936 This example only creates an auto-loader, and does not create a new kind
939 @xref{ede-cpp-root-project}, for details about the class that defines
940 the @code{ede-cpp-root} project type.
942 @node ede-java-root, ede-emacs, ede-cpp-root, Simple projects
943 @subsection ede-java-root
945 Much like the project type @ref{ede-cpp-root}, the java variant is
946 can be setup in your @file{.emacs} file and just marks a directory as
947 the root of a java source tree.
949 The @code{ede-java-root} project class knows a few things about Java
950 projects. In particular, you can use it to control your classpath at
951 both the system level, and for your project. If it is insufficient,
952 you can subclass @code{ede-java-root-project} and add your own tweaks
953 in just a few lines. See @ref{ede-cpp-root} for an example using the
956 In the most basic case, add this to your @file{.emacs} file, modifying
957 appropriate bits as needed.
960 (ede-java-root-project "SOMENAME" :file "/dir/to/some/file" :srcroot '("src"))
963 Replace @var{SOMENAME} with whatever name you want, and the filename
964 to an actual file at the root of your project. It might be a
965 Makefile, a README file. Whatever. It doesn't matter. It's just a
966 key to hang the rest of @ede{} off of.
968 Replace the value of :srcroot with a list of directories under the
969 project root which contains Java sources. For example, if you have:
974 ~/myprojects/P1/src/com/ericsoft/MyCode.java
978 Then @file{src} represents the directory under which all your Java
979 code is. It is important that @file{src} is one step above the
980 directory that is the base of your package name, such as
981 @file{com/ericsoft} in the example above so that new files can be
982 discovered via fully qualified name. You can have multiple such
983 directories in one project, and each will be accessible.
985 You can specify your classpath like this:
988 (ede-java-root-project "NAME" :file "FILENAME"
990 :classpath '("/absolute/path.jar")
991 :localclasspath '( "/relative/path.jar" ))
994 In this example, @code{:classpath} specifies absolute paths somewhere
995 on your system, and the explicit jar or source root directories
996 @semantic{} will search when performing completions.
998 The @code{:localclasspath} is like @code{:classpath}, but it will
999 contain path names relative to the root of your project.
1001 If you want to override the file-finding tool with your own
1002 function you can do this:
1005 (ede-java-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
1008 Where @var{MYFCN} is a symbol for a function. The locate function can
1009 be used in place of @code{ede-expand-filename} so you can quickly
1010 customize your custom target to use specialized local routines instead
1011 of the default @ede{} routines. The function symbol must take two
1016 The name of the file to find.
1018 The directory root for this java-root project.
1021 If you would like to create your Java projects dynamically, instead of
1022 putting them all in your @file{.emacs}, you can do that too. See
1023 @ref{ede-cpp-root} for details that can be applied to this project type.
1025 @node ede-emacs, ede-linux, ede-java-root, Simple projects
1026 @subsection ede-emacs
1028 The @code{ede-emacs} project automatically identifies an Emacs source
1029 tree, and enables EDE project mode for it.
1031 It pre-populates the C Preprocessor symbol map for correct parsing,
1032 and has an optimized include file identification function.
1034 @node ede-linux, ede-generic-project, ede-emacs, Simple projects
1035 @subsection ede-linux
1037 The @code{ede-linux} project will automatically identify a Linux
1038 Kernel source tree, and enable EDE project mode for it.
1040 It pre-populates the C Preprocessor symbol map for reasonable parsing,
1041 and has an optimized include file identification function.
1043 @node ede-generic-project, Custom Locate, ede-linux, Simple projects
1044 @subsection ede-generic-project
1046 The @code{ede-generic-project} is a project system that makes it easy
1047 to wrap up different kinds of build systems as an EDE project.
1048 Projects such as @ref{ede-emacs} require coding skills to create.
1049 Generic projects also require writing Emacs Lisp code, but the
1050 requirements are minimal. You can then use
1051 @command{customize-project} to configure build commands, includes, and
1052 other options for that project. The configuration is saved in
1053 @file{EDEConfig.el}.
1055 Generic projects are disabled by default because they have the
1056 potential to interfere with other projects. To use the generic
1057 project system to start detecting projects, you need to enable it.
1059 @deffn Command ede-enable-generic-projects
1060 Enable generic project loaders.
1062 This enables generic loaders for projects that are detected using
1063 either a @file{Makefile}, @file{SConstruct}, or @file{CMakeLists}.
1065 You do not need to use this command if you create your own generic
1069 If you want to create your own generic project loader, you need to
1070 define your own project and target classes, and create an autoloader.
1071 The example for Makefiles looks like this:
1076 (defclass ede-generic-makefile-project (ede-generic-project)
1077 ((buildfile :initform "Makefile")
1079 "Generic Project for makefiles.")
1081 (defmethod ede-generic-setup-configuration ((proj ede-generic-makefile-project) config)
1082 "Setup a configuration for Make."
1083 (oset config build-command "make -k")
1084 (oset config debug-command "gdb ")
1087 (ede-generic-new-autoloader "generic-makefile" "Make"
1088 "Makefile" 'ede-generic-makefile-project)
1091 This example project will detect any directory with the file
1092 @file{Makefile} in it as belonging to this project type.
1093 Customization of the project will allow you to make build and debug
1094 commands more precise.
1096 @node Custom Locate, , ede-generic-project, Simple projects
1097 @subsection Custom Locate
1099 The various simple project styles all have one major drawback, which
1100 is that the files in the project are not completely known to EDE@.
1101 When the EDE API is used to try and file files by some reference name
1102 in the project, then that could fail.
1104 @ede{} can therefore use some external locate commands, such as the unix
1105 ``locate'' command, or ``GNU Global''.
1107 Configuration of the tool you want to use such as @code{locate}, or
1108 @code{global} will need to be done without the aid of @ede{}. Once
1109 configured, however, @ede{} can use it.
1111 To enable one of these tools, set the variable
1112 @code{ede-locate-setup-options} with the names of different locate
1113 objects. @ref{Miscellaneous commands}.
1115 Configure this in your @file{.emacs} before loading in CEDET or EDE@.
1116 If you want to add support for GNU Global, your configuration would
1120 (setq ede-locate-setup-options '(ede-locate-global ede-locate-base))
1123 That way, when a search needs to be done, it will first try using
1124 GLOBAL@. If global is not available for that directory, then it will
1125 revert to the base locate object. The base object always fails to
1128 You can add your own locate tool but subclassing from
1129 @code{ede-locate-base}. The subclass should also implement two
1130 methods. See the code in @file{ede-locate.el} for GNU Global as a
1133 @@TODO - Add ID Utils and CScope examples
1135 More on idutils and cscope is in the CEDET manual, and they each have
1138 @node Extending EDE, GNU Free Documentation License, Miscellaneous commands, Top
1139 @chapter Extending @ede{}
1141 This chapter is intended for users who want to write new parts or fix
1142 bugs in @ede{}. A knowledge of Emacs Lisp, and some @eieio{}(CLOS) is
1145 @ede{} uses @eieio{}, the CLOS package for Emacs, to define two object
1146 superclasses, specifically the PROJECT and TARGET@. All commands in
1147 @ede{} are usually meant to address the current project, or current
1150 All specific projects in @ede{} derive subclasses of the @ede{}
1151 superclasses. In this way, specific behaviors such as how a project
1152 is saved, or how a target is compiled can be customized by a project
1153 author in detail. @ede{} communicates to these project objects via an
1154 API using methods. The commands you use in @ede{} mode are high-level
1155 functional wrappers over these methods. @xref{Top,,, eieio, EIEIO manual}. For
1156 details on using @eieio{} to extending classes, and writing methods.
1158 If you intend to extend @ede{}, it is most likely that a new target type is
1159 needed in one of the existing project types. The rest of this chapter
1160 will discuss extending the @code{ede-project} class, and it's targets.
1161 See @file{project-am.el} for basic details on adding targets to it.
1163 For the @code{ede-project} type, the core target class is called
1164 @code{ede-proj-target}. Inheriting from this will give you everything
1165 you need to start, including adding your sources into the makefile. If
1166 you also need additional rules in the makefile, you will want to inherit
1167 from @code{ede-proj-target-makefile} instead. You may want to also add
1168 new fields to track important information.
1170 If you are building currently unsupported code into a program or shared
1171 library, it is unlikely you need a new target at all. Instead you
1172 would need to create a new compiler or linker object that compiles
1173 source code of the desired type. @ref{Compiler and Linker objects}.
1175 Once your new class exists, you will want to fill in some basic methods.
1176 See the @file{ede-skel.el} file for examples of these. The files
1177 @file{ede-proj-info.el} and @file{ede-proj-elisp.el} are two interesting
1181 * Development Overview::
1182 * Detecting a Project::
1183 * User interface methods:: Methods associated with keybindings
1184 * Base project methods:: The most basic methods on @ede{} objects.
1185 * Sourcecode objects:: Defining new sourcecode classes.
1186 * Compiler and Linker objects:: Defining new compilers and linkers.
1187 * Project:: Details of project classes.
1188 * Targets:: Details of target classes.
1189 * Sourcecode:: Details of source code classes.
1190 * Compilers:: Details of compiler classes.
1193 @node Development Overview, Detecting a Project, Extending EDE, Extending EDE
1194 @section Development Overview
1196 @ede{} is made up of a series of classes implemented with @eieio{}.
1197 These classes define an interface that can be used to create different
1200 @ede{} defines two superclasses which are @code{ede-project} and
1201 @code{ede-target}. All commands in @ede{} are usually meant to
1202 address the current project, or current target.
1204 All specific projects in @ede{} derive subclasses of the @ede{} superclasses.
1205 In this way, specific behaviors such as how a project is saved, or how a
1206 target is compiled can be customized by a project author in detail. @ede{}
1207 communicates to these project objects via an API using methods. The
1208 commands you use in @ede{} mode are high-level functional wrappers over
1211 Some example project types are:
1215 Automake project which reads existing Automake files.
1216 @item ede-proj-project
1217 This project type will create @file{Makefiles},
1218 or @file{Makefile.am} files to compile your project.
1220 This project type will detect linux source trees.
1222 This project will detect an Emacs source tree.
1225 There are several other project types as well.
1227 The first class you need to know to create a new project type is
1228 @code{ede-project-autoload}. New instances of this class are needed
1229 to define how Emacs associates different files/buffers with different
1230 project types. All the autoloads are kept in the variable
1231 @code{ede-project-class-files}.
1233 The next most important class to know is @code{ede-project}. This is
1234 the baseclass defines how all projects behave. The basic pattern for
1235 a project is that there is one project per directory, and the topmost
1236 project or directory defines the project as a whole.
1238 Key features of @code{ede-project} are things like name and version
1239 number. It also holds a list of @code{ede-target} objects and a list
1240 of sub projects, or more @code{ede-project} objects.
1242 New project types must subclass @code{ede-project} to add special
1243 behavior. New project types also need to subclass @code{ede-target} to
1244 add specialty behavior.
1246 In this way, the common @ede{} interface is designed to work against
1247 @code{ede-project}, and thus all subclasses.
1249 @code{ede-project} subclasses @code{ede-project-placeholder}. This is
1250 the minimum necessary project needed to be cached between runs of
1251 Emacs. This way, Emacs can track all projects ever seen, without
1252 loading those projects into memory.
1254 Here is a high-level UML diagram for the @ede{} system created with @cogre{}..
1257 +-----------------------+ +-----------------------+
1258 | | |ede-project-placeholder|
1259 |ede-project-class-files| +-----------------------+
1260 | | +-----------------------+
1261 +-----------------------+ +-----------------------+
1265 +--------------------+ +-----------+ +----------+
1266 |ede-project-autoload| |ede-project| |ede-target|
1267 +--------------------+<>--------------+-----------+<>-------+----------+
1268 +--------------------+ +-----------+ +----------+
1269 +--------------------+ +-----------+ +----------+
1273 +---------------------+-----------------+
1277 +----------------+ +-------------------+ +---------+
1278 |ede-proj-project| |project-am-makefile| |ede-emacs|
1279 +----------------+ +-------------------+ +---------+
1280 +----------------+ +-------------------+ +---------+
1281 +----------------+ +-------------------+ +---------+
1285 @node Detecting a Project, User interface methods, Development Overview, Extending EDE
1286 @section Detecting a Project
1288 Project detection happens with the list of @code{ede-project-autoload}
1289 instances stored in @code{ede-project-class-files}. The full project
1290 detection scheme works like this:
1294 @code{find-file-hook} calls @code{ede-turn-on-hook} on BUFFER.
1296 @code{ede-turn-on-hook} turns on @code{ede-minor-mode}
1298 @code{ede-minor-mode} looks to see if BUFFER is associated with any
1299 open projects. If not, it calls @code{ede-load-project-file} to find
1300 a project associated with the current directory BUFFER is in.
1302 @code{ede-minor-mode} associates the found project with the current
1303 buffer with a series of variables, such as @code{ede-object}, and
1304 @code{ede-object-project} and @code{ede-object-root-project}.
1307 Once a buffer is associated, @ede{} minor mode commands will operate
1310 The function @code{ede-load-project-file} is at the heart of detecting
1311 projects, and it works by looping over all the known project autoload
1312 types in @code{ede-project-autoload} using the utility
1313 @code{ede-directory-project-p}.
1315 The function @code{ede-directory-project-p} will call
1316 @code{ede-dir-to-projectfile} on every @code{ede-project-autoload}
1317 until one of them returns true. The method
1318 @code{ede-dir-to-projectfile} in turn gets the @code{:proj-file} slot
1319 from the autoload. If it is a string (i.e., a project file name), it
1320 checks to see if that exists in BUFFER's directory. If it is a
1321 function, then it calls that function and expects it to return a file
1322 name or nil. If the file exists, then this directory is assumed to be
1323 part of a project, and @code{ede-directory-project-p} returns the
1324 instance of @code{ede-project-autoload} that matched.
1326 If the current directory contains the file @code{.ede-ignore} then
1327 that directory is automatically assumed to contain no projects, even
1328 if there is a matching pattern. Use this type of file in a directory
1329 that may contain many other sub projects, but still has a Makefile of
1332 If the current directory is a project, then @ede{} scans upwards till
1333 it finds the top of the project. It does this by calling
1334 @code{ede-toplevel-project}. If this hasn't already been discovered,
1335 the directories as scanned upward one at a time until a directory with
1336 no project is found. The last found project becomes the project
1337 root. If the found instance of @code{ede-project-autoload} has a
1338 valid @code{proj-root} slot value, then that function is called instead
1339 of scanning the project by hand. Some project types have a short-cut
1340 for determining the root of a project, so this comes in handy.
1342 Getting back to @code{ede-load-project-file}, this now has an instance
1343 of @code{ede-project-autoload}. It uses the @code{load-type} slot to
1344 both autoload in the project type, and to create a new instance of the
1345 project type found for the root of the project. That project is added
1346 to the global list of all projects. All subprojects are then created
1347 and assembled into the project data structures.
1350 @node User interface methods, Base project methods, Detecting a Project, Extending EDE
1351 @section User interface methods
1353 These methods are core behaviors associated with user commands.
1354 If you do not implement a method, there is a reasonable default that
1355 may do what you need.
1358 @item project-add-file
1359 Add a file to your project. Override this if you want to put new
1360 sources into different fields depending on extension, or other details.
1361 @item project-remove-file
1362 Reverse of project-add-file.
1363 @item project-compile-target
1364 Override this if you want to do something special when the user
1365 "compiles" this target.
1366 @item project-debug-target
1367 What to do when a user wants to debug your target.
1368 @item project-update-version
1369 Easily update the version number of your project.
1370 @item project-edit-file-target
1371 Edit the file the project's information is stored in.
1372 @item project-new-target
1373 Create a new target in a project.
1374 @item project-delete-target
1375 Delete a target from a project.
1376 @item project-make-dist
1377 Make a distribution (tar archive) of the project.
1378 @item project-rescan
1379 Rescan a project file, changing the data in the existing objects.
1382 @node Base project methods, Sourcecode objects, User interface methods, Extending EDE
1383 @section Base project methods
1385 These methods are important for querying base information from project
1390 Return a string that is the name of this target.
1391 @item ede-target-name
1392 Return a string that is the name of the target used by a Make system.
1393 @item ede-description
1394 A brief description of the project or target. This is currently used
1395 by the @samp{ede-speedbar} interface.
1396 @item ede-want-file-p
1397 Return non-nil if a target will accept a given file.
1398 It is generally unnecessary to override this. See the section on source
1400 @item ede-buffer-mine
1401 Return non-nil if a buffer belongs to this target. Used during
1402 association when a file is loaded. It is generally unnecessary to
1403 override this unless you keep auxiliary files.
1406 These methods are used by the semantic package extensions.
1407 @xref{Top,,, semantic, Semantic manual}.
1410 @item ede-buffer-header-file
1411 Return a header file belonging to a given buffer. Prototypes are place
1412 there when appropriate
1413 @item ede-buffer-documentation-files
1414 Return the documentation file information about this file would be
1416 @item ede-documentation
1417 List all documentation a project or target is responsible for.
1420 @node Sourcecode objects, Compiler and Linker objects, Base project methods, Extending EDE
1421 @section Sourcecode objects
1423 @ede{} projects track source file / target associates via source code
1424 objects. The definitions for this is in @file{ede-source.el}. A source
1425 code object contains methods that know how to identify a file as being
1426 of that class, (i.e., a C file ends with @file{.c}). Some targets can
1427 handle many different types of sources which must all be compiled
1428 together. For example, a mixed C and C++ program would have
1429 instantiations of both sourcecode types.
1431 When a target needs to know if it will accept a source file, it
1432 references its list of source code objects. These objects then make
1435 Source code objects are stored in the target objects as a list of
1436 symbols, where the symbol's value is the object. This enables the
1437 project save file mechanism to work.
1439 Here is an example for an instantiation of an Emacs Lisp source code object:
1442 (defvar ede-source-emacs
1443 (ede-sourcecode "ede-emacs-source"
1445 :sourcepattern "\\.el$"
1446 :garbagepattern '("*.elc"))
1447 "Emacs Lisp source code definition.")
1450 If you want to recycle parts of an existing sourcecode object, you can
1451 clone the original, and then just tweak the parts that are different.
1455 (defvar ede-source-emacs-autoload
1456 (clone ede-source-emacs "ede-source-emacs-autoload"
1457 :name "Emacs Lisp Autoload"
1458 :sourcepattern "-loaddefs\\.el")
1459 "Emacs Lisp autoload source code.")
1462 In this case, the garbage pattern is the same.
1466 @node Compiler and Linker objects, Project, Sourcecode objects, Extending EDE
1467 @section Compiler and Linker objects
1469 In order for a target to create a @file{Makefile}, it must know how to
1470 compile the sources into the program or desired data file, and
1471 possibly link them together.
1473 A compiler object instantiation is used to associate a given target
1474 with a given source code type. Some targets can handle many types of
1475 sources, and thus has many compilers available to it. Some targets
1476 may have multiple compilers for a given type of source code.
1478 @ede{} will examine the actual source files in a target, cross reference
1479 that against the compiler list to come up with the final set of
1480 compilers that will be inserted into the Makefile.
1482 Compiler instantiations must also insert variables specifying the
1483 compiler it plans to use, in addition to creating Automake settings for
1484 @file{configure.ac} when appropriate.
1486 Compiler objects are stored in the target objects as a list of
1487 symbols, where the symbols value is the object. This enables the
1488 project output mechanism to work more efficiently.
1490 Targets will also have a special "compiler" slot which lets a user
1491 explicitly choose the compiler they want to use.
1493 Here is an example for texinfo:
1496 (defvar ede-makeinfo-compiler
1498 "ede-makeinfo-compiler"
1500 :variables '(("MAKEINFO" . "makeinfo"))
1501 :commands '("makeinfo -o $@ $<")
1502 :autoconf '(("AC_CHECK_PROG" . "MAKEINFO, makeinfo"))
1503 :sourcetype '(ede-makeinfo-source)
1505 "Compile texinfo files into info files.")
1510 When creating compiler instantiations, it may be useful to @code{clone}
1511 an existing compiler variable. Cloning allows you to only modify
1512 parts of the original, while keeping the rest of the same.
1513 Modification of the original will result in the clone also being
1514 changed for shared value slots.
1516 The second important object is the linker class. The linker is similar
1517 to the compiler, except several compilers might be used to create some
1518 object files, and only one linker is used to link those objects together.
1520 See @file{ede-proj-obj.el} for examples of the combination.
1527 @node Project, Targets, Compiler and Linker objects, Extending EDE
1531 * ede-project-placeholder::
1533 * ede-cpp-root-project::
1534 * ede-simple-project::
1535 * ede-simple-base-project::
1536 * ede-proj-project::
1537 * project-am-makefile::
1538 * ede-step-project::
1541 @node ede-project-placeholder, ede-project, Project, Project
1542 @subsection ede-project-placeholder
1543 @pjindex ede-project-placeholder
1546 @item Inheritance Tree:
1548 @item eieio-speedbar
1550 @item eieio-speedbar-directory-button
1552 @item ede-project-placeholder
1555 @w{@xref{ede-project}.}
1567 Type: @code{string} @*
1568 Default Value: @code{"Untitled"}
1570 The name used when generating distribution files.
1573 Type: @code{string} @*
1574 Default Value: @code{"1.0"}
1576 The version number used when distributing files.
1581 Directory this project is associated with.
1586 File name where this project is stored.
1592 @subsubsection Specialized Methods
1594 @deffn Method ede--project-inode :AFTER proj
1595 Get the inode of the directory project @var{PROJ} is in.
1598 @deffn Method ede-project-root :AFTER this
1599 If a project knows it's root, return it here.
1600 Allows for one-project-object-for-a-tree type systems.
1603 @deffn Method ede-find-subproject-for-directory :AFTER proj dir
1604 Find a subproject of @var{PROJ} that corresponds to @var{DIR}.
1607 @deffn Method ede-project-root-directory :AFTER this &optional file
1608 If a project knows it's root, return it here.
1609 Allows for one-project-object-for-a-tree type systems.
1610 Optional @var{FILE} is the file to test. It is ignored in preference
1611 of the anchor file for the project.
1614 @deffn Method ede-project-force-load :AFTER this
1615 Make sure the placeholder @var{THIS} is replaced with the real thing.
1616 Return the new object created in its place.
1619 @deffn Method project-interactive-select-target :AFTER this prompt
1620 Make sure placeholder @var{THIS} is replaced with the real thing, and pass through.
1623 @deffn Method project-add-file :AFTER this file
1624 Make sure placeholder @var{THIS} is replaced with the real thing, and pass through.
1627 @node ede-project, ede-cpp-root-project, ede-project-placeholder, Project
1628 @subsection ede-project
1629 @pjindex ede-project
1632 @item Inheritance Tree:
1634 @item eieio-speedbar
1636 @item eieio-speedbar-directory-button
1638 @item @w{@xref{ede-project-placeholder}.}
1643 @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}.}
1658 List of top level targets in this project.
1663 List of tool cache configurations in this project.
1664 This allows any tool to create, manage, and persist project-specific settings.
1667 Type: @code{string} @*
1669 URL to this projects web site.
1670 This is a URL to be sent to a web site for documentation.
1672 @item :web-site-directory @*
1674 A directory where web pages can be found by Emacs.
1675 For remote locations use a path compatible with ange-ftp or EFS@.
1676 You can also use TRAMP for use with rcp & scp.
1678 @item :web-site-file @*
1680 A file which contains the home page for this project.
1681 This file can be relative to slot @code{web-site-directory}.
1682 This can be a local file, use ange-ftp, EFS, or TRAMP.
1685 Type: @code{string} @*
1687 FTP site where this project's distribution can be found.
1688 This FTP site should be in Emacs form, as needed by @code{ange-ftp}, but can
1689 also be of a form used by TRAMP for use with scp, or rcp.
1691 @item :ftp-upload-site
1692 Type: @code{string} @*
1694 FTP Site to upload new distributions to.
1695 This FTP site should be in Emacs form as needed by @code{ange-ftp}.
1696 If this slot is @code{nil}, then use @code{ftp-site} instead.
1698 @item :configurations
1699 Type: @code{list} @*
1700 Default Value: @code{("debug" "release")}
1702 List of available configuration types.
1703 Individual target/project types can form associations between a configuration,
1704 and target specific elements such as build variables.
1706 @item :configuration-default @*
1707 Default Value: @code{"debug"}
1709 The default configuration.
1711 @item :local-variables @*
1712 Default Value: @code{nil}
1714 Project local variables
1719 @subsubsection Specialized Methods
1721 @deffn Method ede-preprocessor-map :AFTER this
1722 Get the pre-processor map for project @var{THIS}.
1725 @deffn Method ede-subproject-relative-path :AFTER proj &optional parent-in
1726 Get a path name for @var{PROJ} which is relative to the parent project.
1727 If PARENT is specified, then be relative to the PARENT project.
1728 Specifying PARENT is useful for sub-sub projects relative to the root project.
1731 @deffn Method eieio-speedbar-description :AFTER obj
1732 Provide a speedbar description for @var{OBJ}.
1735 @deffn Method ede-map-any-target-p :AFTER this proc
1736 For project @var{THIS}, map @var{PROC} to all targets and return if any non-nil.
1737 Return the first non-@code{nil} value returned by @var{PROC}.
1740 @deffn Method ede-map-subprojects :AFTER this proc
1741 For object @var{THIS}, execute @var{PROC} on all direct subprojects.
1742 This function does not apply @var{PROC} to sub-sub projects.
1743 See also @dfn{ede-map-all-subprojects}.
1746 @deffn Method ede-convert-path :AFTER this path
1747 Convert path in a standard way for a given project.
1748 Default to making it project relative.
1749 Argument @var{THIS} is the project to convert @var{PATH} to.
1752 @deffn Method ede-name :AFTER this
1753 Return a short-name for @var{THIS} project file.
1754 Do this by extracting the lowest directory name.
1757 @deffn Method ede-set-project-variables :AFTER project &optional buffer
1758 Set variables local to @var{PROJECT} in @var{BUFFER}.
1761 @deffn Method eieio-speedbar-derive-line-path :AFTER obj &optional depth
1762 Return the path to @var{OBJ}.
1763 Optional @var{DEPTH} is the depth we start at.
1766 @deffn Method ede-map-all-subprojects :AFTER this allproc
1767 For object @var{THIS}, execute PROC on @var{THIS} and all subprojects.
1768 This function also applies PROC to sub-sub projects.
1769 See also @dfn{ede-map-subprojects}.
1772 @deffn Method project-update-version :AFTER ot
1773 The @code{:version} of the project @var{OT} has been updated.
1774 Handle saving, or other detail.
1777 @deffn Method ede-buffer-header-file :AFTER this buffer
1778 Return @code{nil}, projects don't have header files.
1781 @deffn Method ede-buffer-documentation-files :AFTER this buffer
1782 Return all documentation in project @var{THIS} based on @var{BUFFER}.
1785 @deffn Method ede-map-targets :AFTER this proc
1786 For object @var{THIS}, execute @var{PROC} on all targets.
1789 @deffn Method ede-buffer-mine :AFTER this buffer
1790 Return non-@code{nil} if object @var{THIS} lays claim to the file in @var{BUFFER}.
1793 @deffn Method ede-object-keybindings :BEFORE this
1794 Retrieves the slot @code{keybindings} from an object of class @code{ede-project}
1797 @deffn Method ede-description :AFTER this
1798 Return a description suitable for the minibuffer about @var{THIS}.
1801 @deffn Method eieio-speedbar-object-children :AFTER this
1802 Return the list of speedbar display children for @var{THIS}.
1805 @deffn Method project-make-dist :AFTER this
1806 Build a distribution for the project based on @var{THIS} project.
1809 @deffn Method ede-system-include-path :AFTER this
1810 Get the system include path used by project @var{THIS}.
1813 @deffn Method project-new-target-custom :AFTER proj
1814 Create a new target. It is up to the project @var{PROJ} to get the name.
1817 @deffn Method ede-subproject-p :AFTER proj
1818 Return non-@code{nil} if @var{PROJ} is a sub project.
1821 @deffn Method ede-expand-filename :AFTER this filename &optional force
1822 Return a fully qualified file name based on project @var{THIS}.
1823 @var{FILENAME} should be just a filename which occurs in a directory controlled
1825 Optional argument @var{FORCE} forces the default filename to be provided even if it
1829 @deffn Method ede-menu-items-build :AFTER obj &optional current
1830 Return a list of menu items for building project @var{OBJ}.
1831 If optional argument @var{CURRENT} is non-@code{nil}, return sub-menu code.
1834 @deffn Method ede-update-version-in-source :AFTER this version
1835 Change occurrences of a version string in sources.
1836 In project @var{THIS}, cycle over all targets to give them a chance to set
1837 their sources to @var{VERSION}.
1840 @deffn Method project-new-target :AFTER proj &rest args
1841 Create a new target. It is up to the project @var{PROJ} to get the name.
1844 @deffn Method project-compile-project :AFTER obj &optional command
1845 Compile the entire current project @var{OBJ}.
1846 Argument @var{COMMAND} is the command to use when compiling.
1849 @deffn Method eieio-speedbar-object-buttonname :AFTER object
1850 Return a string to use as a speedbar button for @var{OBJECT}.
1853 @deffn Method ede-map-project-buffers :AFTER this proc
1854 For @var{THIS}, execute @var{PROC} on all buffers belonging to @var{THIS}.
1857 @deffn Method ede-expand-filename-impl :AFTER this filename &optional force
1858 Return a fully qualified file name based on project @var{THIS}.
1859 @var{FILENAME} should be just a filename which occurs in a directory controlled
1861 Optional argument @var{FORCE} forces the default filename to be provided even if it
1865 @deffn Method eieio-done-customizing :AFTER proj
1866 Call this when a user finishes customizing @var{PROJ}.
1869 @deffn Method ede-html-documentation :AFTER this
1870 Return a list of HTML files provided by project @var{THIS}.
1873 @deffn Method ede-documentation :AFTER this
1874 Return a list of files that provides documentation.
1875 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
1876 files in the project.
1879 @deffn Method project-interactive-select-target :AFTER this prompt
1880 Interactively query for a target that exists in project @var{THIS}.
1881 Argument @var{PROMPT} is the prompt to use when querying the user for a target.
1884 @deffn Method ede-target-in-project-p :AFTER proj target
1885 Is @var{PROJ} the parent of @var{TARGET}?
1886 If @var{TARGET} belongs to a subproject, return that project file.
1889 @deffn Method ede-find-target :AFTER proj buffer
1890 Fetch the target in @var{PROJ} belonging to @var{BUFFER} or nil.
1893 @deffn Method ede-add-subproject :AFTER proj-a proj-b
1894 Add into @var{PROJ-A}, the subproject @var{PROJ-B}.
1897 @deffn Method ede-commit-project :AFTER proj
1898 Commit any change to @var{PROJ} to its file.
1901 @deffn Method project-dist-files :AFTER this
1902 Return a list of files that constitutes a distribution of @var{THIS} project.
1905 @deffn Method ede-object-menu :BEFORE this
1906 Retrieves the slot @code{menu} from an object of class @code{ede-project}
1909 @deffn Method ede-commit-local-variables :AFTER proj
1910 Commit change to local variables in @var{PROJ}.
1913 @node ede-cpp-root-project, ede-simple-project, ede-project, Project
1914 @subsection ede-cpp-root-project
1915 @pjindex ede-cpp-root-project
1918 @item Inheritance Tree:
1920 @item eieio-speedbar
1922 @item eieio-speedbar-directory-button
1924 @item @w{@xref{ede-project-placeholder}.}
1926 @item @w{@xref{ede-project}.}
1928 @item ede-cpp-root-project
1937 This class implements the @code{ede-cpp-root} project type.
1938 @xref{ede-cpp-root}, for information about using this project type.
1945 Type: @code{list} @*
1946 Default Value: @code{(quote ("/include" "../include/"))}
1948 The default locate function expands filenames within a project.
1949 If a header file (.h, .hh, etc.)@: name is expanded, and
1950 the @code{:locate-fcn} slot is @code{nil}, then the include path is checked
1951 first, and other directories are ignored. For very large
1952 projects, this optimization can save a lot of time.
1954 Directory names in the path can be relative to the current
1955 buffer's @code{default-directory} (not starting with a /). Directories
1956 that are relative to the project's root should start with a /, such
1957 as "/include", meaning the directory @code{include} off the project root
1960 @item :system-include-path
1961 Type: @code{list} @*
1962 Default Value: @code{nil}
1964 The system include path for files in this project.
1965 C files initialized in an ede-cpp-root-project have their semantic
1966 system include path set to this value. If this is @code{nil}, then the
1967 semantic path is not modified.
1970 Type: @code{list} @*
1971 Default Value: @code{nil}
1973 C Preprocessor macros for your files.
1974 Preprocessor symbols will be used while parsing your files.
1975 These macros might be passed in through the command line compiler, or
1976 are critical symbols derived from header files. Providing header files
1977 macro values through this slot improves accuracy and performance.
1978 Use `:spp-files' to use these files directly.
1981 Type: @code{list} @*
1982 Default Value: @code{nil}
1984 C header file with Preprocessor macros for your files.
1985 The PreProcessor symbols appearing in these files will be used while
1986 parsing files in this project.
1987 See @code{semantic-lex-c-preprocessor-symbol-map} for more on how this works.
1989 @item :header-match-regexp
1990 Type: @code{string} @*
1991 Default Value: @code{"\\.\\(h\\(h\\|xx\\|pp\\|\\+\\+\\)?\\|H\\)$\\|\\<\\w+$"}
1993 Regexp used to identify C/C++ header files.
1996 Type: @code{(or null function)} @*
1997 Default Value: @code{nil}
1999 The locate function can be used in place of
2000 @dfn{ede-expand-filename} so you can quickly customize your custom target
2001 to use specialized local routines instead of the EDE routines.
2002 The function symbol must take two arguments:
2003 NAME - The name of the file to find.
2004 DIR - The directory root for this cpp-root project.
2006 It should return the fully qualified file name passed in from NAME@. If that file does not
2007 exist, it should return nil.
2012 @subsubsection Specialized Methods
2014 @deffn Method initialize-instance :AFTER this &rest fields
2015 Make sure the @code{:file} is fully expanded.
2018 @deffn Method ede-preprocessor-map :AFTER this
2019 Get the pre-processor map for project @var{THIS}.
2022 @deffn Method ede-cpp-root-header-file-p :AFTER proj name
2023 Non @code{nil} if in @var{PROJ} the filename @var{NAME} is a header.
2026 @deffn Method ede-system-include-path :AFTER this
2027 Get the system include path used by project @var{THIS}.
2030 @deffn Method ede-expand-filename-impl :AFTER proj name
2031 Within this project @var{PROJ}, find the file @var{NAME}.
2032 This knows details about or source tree.
2035 @node ede-simple-project, ede-simple-base-project, ede-cpp-root-project, Project
2036 @subsection ede-simple-project
2037 @pjindex ede-simple-project
2040 @item Inheritance Tree:
2042 @item eieio-speedbar
2044 @item eieio-speedbar-directory-button
2046 @item @w{@xref{ede-project-placeholder}.}
2048 @item @w{@xref{ede-project}.}
2050 @item ede-simple-project
2059 @subsubsection Specialized Methods
2061 @deffn Method ede-commit-project :AFTER proj
2062 Commit any change to @var{PROJ} to its file.
2065 @node ede-simple-base-project, ede-proj-project, ede-simple-project, Project
2066 @subsection ede-simple-base-project
2067 @pjindex ede-simple-base-project
2070 @item Inheritance Tree:
2072 @item eieio-speedbar
2074 @item eieio-speedbar-directory-button
2076 @item @w{@xref{ede-project-placeholder}.}
2078 @item @w{@xref{ede-project}.}
2080 @item ede-simple-base-project
2089 EDE Simple project base class.
2090 This one project could control a tree of subdirectories.
2095 @node ede-proj-project, project-am-makefile, ede-simple-base-project, Project
2096 @subsection ede-proj-project
2097 @pjindex ede-proj-project
2100 @item Inheritance Tree:
2102 @item eieio-speedbar
2104 @item eieio-speedbar-directory-button
2106 @item @w{@xref{ede-project-placeholder}.}
2108 @item @w{@xref{ede-project}.}
2110 @item ede-proj-project
2123 @item :makefile-type
2124 Type: @code{symbol} @*
2125 Default Value: @code{Makefile}
2127 The type of Makefile to generate.
2128 Can be one of @code{'Makefile}, 'Makefile.in, or 'Makefile.am.
2129 If this value is NOT @code{'Makefile}, then that overrides the @code{:makefile} slot
2133 Type: @code{list} @*
2134 Default Value: @code{nil}
2136 Variables to set in this Makefile.
2138 @item :configuration-variables
2139 Type: @code{list} @*
2140 Default Value: @code{("debug" (("DEBUG" . "1")))}
2142 Makefile variables to use in different configurations.
2143 These variables are used in the makefile when a configuration becomes active.
2145 @item :inference-rules @*
2146 Default Value: @code{nil}
2148 Inference rules to add to the makefile.
2150 @item :include-file @*
2151 Default Value: @code{nil}
2153 Additional files to include.
2154 These files can contain additional rules, variables, and customizations.
2156 @item :automatic-dependencies
2157 Type: @code{boolean} @*
2158 Default Value: @code{t}
2160 Non-@code{nil} to do implement automatic dependencies in the Makefile.
2162 @item :metasubproject
2163 Type: @code{boolean} @*
2164 Default Value: @code{nil}
2166 Non-@code{nil} if this is a metasubproject.
2167 Usually, a subproject is determined by a parent project. If multiple top level
2168 projects are grouped into a large project not maintained by EDE, then you need
2169 to set this to non-nil. The only effect is that the @code{dist} rule will then avoid
2175 @subsubsection Specialized Methods
2177 @deffn Method ede-proj-makefile-create :AFTER this mfilename
2178 Create a Makefile for all Makefile targets in @var{THIS}.
2179 @var{MFILENAME} is the makefile to generate.
2182 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2183 Insert rules needed by @var{THIS} target.
2186 @deffn Method ede-proj-makefile-tags :AFTER this targets
2187 Insert into the current location rules to make recursive TAGS files.
2188 Argument @var{THIS} is the project to create tags for.
2189 Argument @var{TARGETS} are the targets we should depend on for TAGS.
2192 @deffn Method ede-proj-makefile-insert-variables :AFTER this
2193 Insert variables needed by target @var{THIS}.
2196 @deffn Method project-make-dist :AFTER this
2197 Build a distribution for the project based on @var{THIS} target.
2200 @deffn Method ede-proj-makefile-insert-dist-rules :AFTER this
2201 Insert distribution rules for @var{THIS} in a Makefile, such as CLEAN and DIST.
2204 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
2205 Insert any symbols that the DIST rule should depend on.
2206 Argument @var{THIS} is the project that should insert stuff.
2209 @deffn Method ede-proj-makefile-insert-subproj-rules :AFTER this
2210 Insert a rule for the project @var{THIS} which should be a subproject.
2213 @deffn Method ede-proj-makefile-create-maybe :AFTER this mfilename
2214 Create a Makefile for all Makefile targets in @var{THIS} if needed.
2215 @var{MFILENAME} is the makefile to generate.
2218 @deffn Method ede-proj-configure-test-required-file :AFTER this file
2219 For project @var{THIS}, test that the file @var{FILE} exists, or create it.
2222 @deffn Method ede-proj-setup-buildenvironment :AFTER this &optional force
2223 Setup the build environment for project @var{THIS}.
2224 Handles the Makefile, or a Makefile.am configure.ac combination.
2225 Optional argument @var{FORCE} will force items to be regenerated.
2228 @deffn Method ede-proj-makefile-garbage-patterns :AFTER this
2229 Return a list of patterns that are considered garbage to @var{THIS}.
2230 These are removed with make clean.
2233 @deffn Method ede-proj-configure-synchronize :AFTER this
2234 Synchronize what we know about project @var{THIS} into configure.ac.
2237 @deffn Method ede-proj-makefile-insert-variables-new :AFTER this
2238 Insert variables needed by target @var{THIS}.
2240 NOTE: Not yet in use! This is part of an SRecode conversion of
2241 EDE that is in progress.
2244 @deffn Method ede-proj-makefile-configuration-variables :AFTER this configuration
2245 Return a list of configuration variables from @var{THIS}.
2246 Use @var{CONFIGURATION} as the current configuration to query.
2249 @deffn Method eieio-done-customizing :AFTER proj
2250 Call this when a user finishes customizing this object.
2251 Argument @var{PROJ} is the project to save.
2254 @deffn Method ede-proj-configure-recreate :AFTER this
2255 Delete project @var{THIS}'s configure script and start over.
2258 @deffn Method ede-proj-makefile-insert-user-rules :AFTER this
2259 Insert user specified rules needed by @var{THIS} target.
2260 This is different from @dfn{ede-proj-makefile-insert-rules} in that this
2261 function won't create the building rules which are auto created with
2265 @deffn Method ede-proj-dist-makefile :AFTER this
2266 Return the name of the Makefile with the DIST target in it for @var{THIS}.
2269 @deffn Method ede-proj-configure-file :AFTER this
2270 The configure.ac script used by project @var{THIS}.
2273 @deffn Method ede-commit-project :AFTER proj
2274 Commit any change to @var{PROJ} to its file.
2277 @deffn Method project-dist-files :AFTER this
2278 Return a list of files that constitutes a distribution of @var{THIS} project.
2281 @deffn Method ede-commit-local-variables :AFTER proj
2282 Commit change to local variables in @var{PROJ}.
2285 @node project-am-makefile, ede-step-project, ede-proj-project, Project
2286 @subsection project-am-makefile
2287 @pjindex project-am-makefile
2290 @item Inheritance Tree:
2292 @item eieio-speedbar
2294 @item eieio-speedbar-directory-button
2296 @item @w{@xref{ede-project-placeholder}.}
2298 @item @w{@xref{ede-project}.}
2300 @item project-am-makefile
2309 @subsubsection Specialized Methods
2311 @deffn Method project-am-subtree :AFTER ampf subdir
2312 Return the sub project in @var{AMPF} specified by @var{SUBDIR}.
2315 @deffn Method project-targets-for-file :AFTER proj
2316 Return a list of targets the project @var{PROJ}.
2319 @deffn Method project-new-target :AFTER proj &optional name type
2320 Create a new target named @var{NAME}.
2321 Argument @var{TYPE} is the type of target to insert. This is a string
2322 matching something in @code{project-am-type-alist} or type class symbol.
2323 Despite the fact that this is a method, it depends on the current
2324 buffer being in order to provide a smart default target type.
2327 @node ede-step-project, , project-am-makefile, Project
2328 @subsection ede-step-project
2329 @pjindex ede-step-project
2332 @item Inheritance Tree:
2334 @item eieio-speedbar
2336 @item eieio-speedbar-directory-button
2338 @item @w{@xref{ede-project-placeholder}.}
2340 @item @w{@xref{ede-project}.}
2342 @item ede-step-project
2355 @item :init-variables
2356 Type: @code{list} @*
2357 Default Value: @code{nil}
2359 Variables to set in this Makefile, at top of file.
2361 @item :additional-variables
2362 Type: @code{(or null list)} @*
2363 Default Value: @code{nil}
2365 Arbitrary variables needed from this project.
2366 It is safe to leave this blank.
2368 @item :additional-rules
2369 Type: @code{(or null list)} @*
2370 Default Value: @code{nil}
2372 Arbitrary rules and dependencies needed to make this target.
2373 It is safe to leave this blank.
2375 @item :installation-domain
2376 Type: @code{symbol} @*
2377 Default Value: @code{user}
2379 Installation domain specification.
2380 The variable GNUSTEP_INSTALLATION_DOMAIN is set at this value.
2383 Type: @code{(or null list)} @*
2384 Default Value: @code{(quote ("GNUmakefile.preamble"))}
2386 The auxiliary makefile for additional variables.
2387 Included just before the specific target files.
2390 Type: @code{(or null list)} @*
2391 Default Value: @code{(quote ("GNUmakefile.postamble"))}
2393 The auxiliary makefile for additional rules.
2394 Included just after the specific target files.
2396 @item :metasubproject
2397 Type: @code{boolean} @*
2398 Default Value: @code{nil}
2400 Non-@code{nil} if this is a metasubproject.
2401 Usually, a subproject is determined by a parent project. If multiple top level
2402 projects are grouped into a large project not maintained by EDE, then you need
2403 to set this to non-nil. The only effect is that the @code{dist} rule will then avoid
2409 @subsubsection Specialized Methods
2411 @deffn Method ede-proj-makefile-create :AFTER this mfilename
2412 Create a GNUmakefile for all Makefile targets in @var{THIS}.
2413 @var{MFILENAME} is the makefile to generate.
2416 @deffn Method project-make-dist :AFTER this
2417 Build a distribution for the project based on @var{THIS} target.
2420 @deffn Method ede-proj-makefile-create-maybe :AFTER this mfilename
2421 Create a Makefile for all Makefile targets in @var{THIS} if needed.
2422 @var{MFILENAME} is the makefile to generate.
2425 @deffn Method ede-proj-setup-buildenvironment :AFTER this &optional force
2426 Setup the build environment for project @var{THIS}.
2427 Handles the Makefile, or a Makefile.am configure.ac combination.
2428 Optional argument @var{FORCE} will force items to be regenerated.
2431 @deffn Method eieio-done-customizing :AFTER proj
2432 Call this when a user finishes customizing this object.
2433 Argument @var{PROJ} is the project to save.
2436 @deffn Method ede-proj-dist-makefile :AFTER this
2437 Return the name of the Makefile with the DIST target in it for @var{THIS}.
2440 @deffn Method ede-commit-project :AFTER proj
2441 Commit any change to @var{PROJ} to its file.
2444 @deffn Method project-dist-files :AFTER this
2445 Return a list of files that constitutes a distribution of @var{THIS} project.
2448 @deffn Method ede-commit-local-variables :AFTER proj
2449 Commit change to local variables in @var{PROJ}.
2452 @node Targets, Sourcecode, Project, Extending EDE
2458 * ede-proj-target-makefile::
2459 * semantic-ede-proj-target-grammar::
2460 * ede-proj-target-makefile-objectcode::
2461 * ede-proj-target-makefile-archive::
2462 * ede-proj-target-makefile-program::
2463 * ede-proj-target-makefile-shared-object::
2464 * ede-proj-target-elisp::
2465 * ede-proj-target-elisp-autoloads::
2466 * ede-proj-target-makefile-miscelaneous::
2467 * ede-proj-target-makefile-info::
2468 * ede-proj-target-scheme::
2469 * project-am-target::
2470 * project-am-objectcode::
2471 * project-am-program::
2472 * project-am-header-noinst::
2473 * project-am-header-inst::
2475 * project-am-texinfo::
2480 @node ede-target, ede-proj-target, Targets, Targets
2481 @subsection ede-target
2485 @item Inheritance Tree:
2487 @item eieio-speedbar
2489 @item eieio-speedbar-directory-button
2494 @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}.}
2508 Name of this target.
2513 The path to the sources of this target.
2514 Relative to the path of the project it belongs to.
2517 Type: @code{list} @*
2518 Default Value: @code{nil}
2520 Source files in this target.
2522 @item :versionsource
2523 Type: @code{list} @*
2524 Default Value: @code{nil}
2526 Source files with a version string in them.
2527 These files are checked for a version string whenever the EDE version
2528 of the master project is changed. When strings are found, the version
2529 previously there is updated.
2534 @subsubsection Specialized Methods
2536 @deffn Method ede-preprocessor-map :AFTER this
2537 Get the pre-processor map for project @var{THIS}.
2540 @deffn Method eieio-speedbar-description :AFTER obj
2541 Provide a speedbar description for @var{OBJ}.
2544 @deffn Method project-compile-target :AFTER obj &optional command
2545 Compile the current target @var{OBJ}.
2546 Argument @var{COMMAND} is the command to use for compiling the target.
2549 @deffn Method project-debug-target :AFTER obj
2550 Run the current project target @var{OBJ} in a debugger.
2553 @deffn Method ede-convert-path :AFTER this path
2554 Convert path in a standard way for a given project.
2555 Default to making it project relative.
2556 Argument @var{THIS} is the project to convert @var{PATH} to.
2559 @deffn Method ede-name :AFTER this
2560 Return the name of @var{THIS} targt.
2563 @deffn Method ede-target-buffer-in-sourcelist :AFTER this buffer source
2564 Return non-@code{nil} if object @var{THIS} is in @var{BUFFER} to a @var{SOURCE} list.
2565 Handles complex path issues.
2568 @deffn Method eieio-speedbar-derive-line-path :AFTER obj &optional depth
2569 Return the path to @var{OBJ}.
2570 Optional @var{DEPTH} is the depth we start at.
2573 @deffn Method ede-buffer-header-file :AFTER this buffer
2574 There are no default header files in EDE@.
2575 Do a quick check to see if there is a Header tag in this buffer.
2578 @deffn Method project-remove-file :AFTER ot fnnd
2579 Remove the current buffer from project target @var{OT}.
2580 Argument @var{FNND} is an argument.
2583 @deffn Method ede-buffer-documentation-files :AFTER this buffer
2584 Check for some documentation files for @var{THIS}.
2585 Also do a quick check to see if there is a Documentation tag in this @var{BUFFER}.
2588 @deffn Method ede-map-target-buffers :AFTER this proc
2589 For @var{THIS}, execute @var{PROC} on all buffers belonging to @var{THIS}.
2592 @deffn Method eieio-speedbar-child-description :AFTER obj
2593 Provide a speedbar description for a plain-child of @var{OBJ}.
2594 A plain child is a child element which is not an EIEIO object.
2597 @deffn Method ede-object-keybindings :BEFORE this
2598 Retrieves the slot @code{keybindings} from an object of class @code{ede-target}
2601 @deffn Method ede-description :AFTER this
2602 Return a description suitable for the minibuffer about @var{THIS}.
2605 @deffn Method eieio-speedbar-object-children :AFTER this
2606 Return the list of speedbar display children for @var{THIS}.
2609 @deffn Method ede-system-include-path :AFTER this
2610 Get the system include path used by project @var{THIS}.
2613 @deffn Method ede-object-sourcecode :BEFORE this
2614 Retrieves the slot @code{sourcetype} from an object of class @code{ede-target}
2617 @deffn Method ede-expand-filename :AFTER this filename &optional force
2618 Return a fully qualified file name based on target @var{THIS}.
2619 @var{FILENAME} should be a filename which occurs in a directory in which @var{THIS} works.
2620 Optional argument @var{FORCE} forces the default filename to be provided even if it
2624 @deffn Method ede-menu-items-build :AFTER obj &optional current
2625 Return a list of menu items for building target @var{OBJ}.
2626 If optional argument @var{CURRENT} is non-@code{nil}, return sub-menu code.
2629 @deffn Method ede-want-file-p :AFTER this file
2630 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2633 @deffn Method ede-update-version-in-source :AFTER this version
2634 In sources for @var{THIS}, change version numbers to @var{VERSION}.
2637 @deffn Method project-delete-target :AFTER ot
2638 Delete the current target @var{OT} from it's parent project.
2641 @deffn Method ede-target-sourcecode :AFTER this
2642 Return the sourcecode objects which @var{THIS} permits.
2645 @deffn Method eieio-speedbar-child-make-tag-lines :AFTER this depth
2646 Create a speedbar tag line for a child of @var{THIS}.
2647 It has depth @var{DEPTH}.
2650 @deffn Method eieio-speedbar-object-buttonname :AFTER object
2651 Return a string to use as a speedbar button for @var{OBJECT}.
2654 @deffn Method eieio-done-customizing :AFTER target
2655 Call this when a user finishes customizing @var{TARGET}.
2658 @deffn Method project-edit-file-target :AFTER ot
2659 Edit the target @var{OT} associated w/ this file.
2662 @deffn Method ede-documentation :AFTER this
2663 Return a list of files that provides documentation.
2664 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
2665 files in the project.
2668 @deffn Method ede-want-file-source-p :AFTER this file
2669 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2672 @deffn Method ede-want-file-auxiliary-p :AFTER this file
2673 Return non-@code{nil} if @var{THIS} target wants @var{FILE}.
2676 @deffn Method project-add-file :AFTER ot file
2677 Add the current buffer into project project target @var{OT}.
2678 Argument @var{FILE} is the file to add.
2681 @deffn Method ede-target-name :AFTER this
2682 Return the name of @var{THIS} target, suitable for make or debug style commands.
2685 @deffn Method ede-object-menu :BEFORE this
2686 Retrieves the slot @code{menu} from an object of class @code{ede-target}
2689 @node ede-proj-target, ede-proj-target-makefile, ede-target, Targets
2690 @subsection ede-proj-target
2691 @tgindex ede-proj-target
2694 @item Inheritance Tree:
2696 @item eieio-speedbar
2698 @item eieio-speedbar-directory-button
2700 @item @w{@xref{ede-target}.}
2702 @item ede-proj-target
2705 @w{@xref{ede-proj-target-makefile},} @w{ede-proj-target-aux,} @w{@xref{ede-proj-target-scheme}.}
2720 Name of this target.
2725 The path to the sources of this target.
2726 Relative to the path of the project it belongs to.
2729 Type: @code{list} @*
2730 Default Value: @code{nil}
2732 Auxiliary source files included in this target.
2733 Each of these is considered equivalent to a source file, but it is not
2734 distributed, and each should have a corresponding rule to build it.
2737 Type: @code{(or null symbol)} @*
2738 Default Value: @code{nil}
2740 The compiler to be used to compile this object.
2741 This should be a symbol, which contains the object defining the compiler.
2742 This enables save/restore to do so by name, permitting the sharing
2743 of these compiler resources, and global customization thereof.
2746 Type: @code{(or null symbol)} @*
2747 Default Value: @code{nil}
2749 The linker to be used to link compiled sources for this object.
2750 This should be a symbol, which contains the object defining the linker.
2751 This enables save/restore to do so by name, permitting the sharing
2752 of these linker resources, and global customization thereof.
2757 @subsubsection Specialized Methods
2759 @deffn Method project-compile-target :AFTER obj &optional command
2760 Compile the current target @var{OBJ}.
2761 Argument @var{COMMAND} is the command to use for compiling the target.
2764 @deffn Method project-debug-target :AFTER obj
2765 Run the current project target @var{OBJ} in a debugger.
2768 @deffn Method ede-proj-configure-add-missing :AFTER this
2769 Query if any files needed by @var{THIS} provided by automake are missing.
2770 Results in --add-missing being passed to automake.
2773 @deffn Method ede-proj-flush-autoconf :AFTER this
2774 Flush the configure file (current buffer) to accommodate @var{THIS}.
2775 By flushing, remove any cruft that may be in the file. Subsequent
2776 calls to @dfn{ede-proj-tweak-autoconf} can restore items removed by flush.
2779 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2780 Insert rules needed by @var{THIS} target.
2783 @deffn Method project-remove-file :AFTER target file
2784 For @var{TARGET}, remove @var{FILE}.
2785 @var{FILE} must be massaged by @dfn{ede-convert-path}.
2788 @deffn Method ede-proj-configure-create-missing :AFTER this
2789 Add any missing files for @var{THIS} by creating them.
2792 @deffn Method ede-proj-makefile-sourcevar :AFTER this
2793 Return the variable name for @var{THIS}'s sources.
2796 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
2797 Insert variables needed by target @var{THIS}.
2798 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2802 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
2803 Insert variables needed by target @var{THIS} in Makefile.am after SOURCES.
2806 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
2807 Insert any symbols that the DIST rule should depend on.
2808 Argument @var{THIS} is the target that should insert stuff.
2811 @deffn Method ede-proj-linkers :AFTER obj
2812 List of linkers being used by @var{OBJ}.
2813 If the @code{linker} slot is empty, concoct one on a first match found
2814 basis for any given type from the @code{availablelinkers} slot.
2815 Otherwise, return the @code{linker} slot.
2816 Converts all symbols into the objects to be used.
2819 @deffn Method ede-proj-makefile-garbage-patterns :AFTER this
2820 Return a list of patterns that are considered garbage to @var{THIS}.
2821 These are removed with make clean.
2824 @deffn Method ede-proj-tweak-autoconf :AFTER this
2825 Tweak the configure file (current buffer) to accommodate @var{THIS}.
2828 @deffn Method ede-proj-compilers :AFTER obj
2829 List of compilers being used by @var{OBJ}.
2830 If the @code{compiler} slot is empty, concoct one on a first match found
2831 basis for any given type from the @code{availablecompilers} slot.
2832 Otherwise, return the @code{compiler} slot.
2833 Converts all symbols into the objects to be used.
2836 @deffn Method project-delete-target :AFTER this
2837 Delete the current target @var{THIS} from it's parent project.
2840 @deffn Method ede-proj-makefile-target-name :AFTER this
2841 Return the name of the main target for @var{THIS} target.
2844 @deffn Method eieio-done-customizing :AFTER target
2845 Call this when a user finishes customizing this object.
2846 Argument @var{TARGET} is the project we are completing customization on.
2849 @deffn Method ede-proj-makefile-insert-user-rules :AFTER this
2850 Insert user specified rules needed by @var{THIS} target.
2853 @deffn Method project-add-file :AFTER this file
2854 Add to target @var{THIS} the current buffer represented as @var{FILE}.
2857 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
2858 Insert variables needed by target @var{THIS} in Makefile.am before SOURCES.
2861 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
2862 Insert any symbols that the DIST rule should depend on.
2863 Argument @var{THIS} is the target that should insert stuff.
2866 @deffn Method ede-proj-makefile-dependency-files :AFTER this
2867 Return a list of source files to convert to dependencies.
2868 Argument @var{THIS} is the target to get sources from.
2871 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
2872 Insert the source variables needed by @var{THIS}.
2873 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2878 @node ede-proj-target-makefile, semantic-ede-proj-target-grammar, ede-proj-target, Targets
2879 @subsection ede-proj-target-makefile
2880 @tgindex ede-proj-target-makefile
2883 @item Inheritance Tree:
2885 @item eieio-speedbar
2887 @item eieio-speedbar-directory-button
2889 @item @w{@xref{ede-target}.}
2891 @item @w{@xref{ede-proj-target}.}
2893 @item ede-proj-target-makefile
2896 @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}.}
2910 Type: @code{string} @*
2911 Default Value: @code{"Makefile"}
2913 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.
2923 @item :configuration-variables
2924 Type: @code{list} @*
2925 Default Value: @code{nil}
2927 Makefile variables appended to use in different configurations.
2928 These variables are used in the makefile when a configuration becomes active.
2929 Target variables are always renamed such as foo_CFLAGS, then included into
2930 commands where the variable would usually appear.
2933 Type: @code{list} @*
2934 Default Value: @code{nil}
2936 Arbitrary rules and dependencies needed to make this target.
2937 It is safe to leave this blank.
2942 @subsubsection Specialized Methods
2944 @deffn Method ede-proj-makefile-dependencies :AFTER this
2945 Return a string representing the dependencies for @var{THIS}.
2946 Some compilers only use the first element in the dependencies, others
2947 have a list of intermediates (object files), and others don't care.
2948 This allows customization of how these elements appear.
2951 @deffn Method project-compile-target :AFTER obj &optional command
2952 Compile the current target program @var{OBJ}.
2953 Optional argument @var{COMMAND} is the s the alternate command to use.
2956 @deffn Method ede-proj-makefile-insert-rules :AFTER this
2957 Insert rules needed by @var{THIS} target.
2960 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
2961 Insert variables needed by target @var{THIS}.
2962 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
2966 @deffn Method ede-proj-makefile-insert-commands :AFTER this
2967 Insert the commands needed by target @var{THIS}.
2968 For targets, insert the commands needed by the chosen compiler.
2971 @deffn Method ede-proj-makefile-configuration-variables :AFTER this configuration
2972 Return a list of configuration variables from @var{THIS}.
2973 Use @var{CONFIGURATION} as the current configuration to query.
2976 @node semantic-ede-proj-target-grammar, ede-proj-target-makefile-objectcode, ede-proj-target-makefile, Targets
2977 @subsection semantic-ede-proj-target-grammar
2978 @tgindex semantic-ede-proj-target-grammar
2981 @item Inheritance Tree:
2983 @item eieio-speedbar
2985 @item eieio-speedbar-directory-button
2987 @item @w{@xref{ede-target}.}
2989 @item @w{@xref{ede-proj-target}.}
2991 @item @w{@xref{ede-proj-target-makefile}.}
2993 @item semantic-ede-proj-target-grammar
3003 @subsubsection Specialized Methods
3005 @deffn Method project-compile-target :AFTER obj
3006 Compile all sources in a Lisp target @var{OBJ}.
3009 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3010 Insert rules needed by @var{THIS} target.
3013 @deffn Method ede-buffer-mine :AFTER this buffer
3014 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3015 Lays claim to all -by.el, and -wy.el files.
3018 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3019 Return the variable name for @var{THIS}'s sources.
3022 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3023 Insert dist dependencies, or intermediate targets.
3024 This makes sure that all grammar lisp files are created before the dist
3025 runs, so they are always up to date.
3026 Argument @var{THIS} is the target that should insert stuff.
3030 @node ede-proj-target-makefile-objectcode, ede-proj-target-makefile-archive, semantic-ede-proj-target-grammar, Targets
3031 @subsection ede-proj-target-makefile-objectcode
3032 @tgindex ede-proj-target-makefile-objectcode
3035 @item Inheritance Tree:
3037 @item eieio-speedbar
3039 @item eieio-speedbar-directory-button
3041 @item @w{@xref{ede-target}.}
3043 @item @w{@xref{ede-proj-target}.}
3045 @item @w{@xref{ede-proj-target-makefile}.}
3047 @item ede-proj-target-makefile-objectcode
3050 @w{@xref{ede-proj-target-makefile-archive},} @w{@xref{ede-proj-target-makefile-program}.}
3064 @item :configuration-variables
3065 Type: @code{list} @*
3066 Default Value: @code{("debug" ("CFLAGS" . "-g") ("LDFLAGS" . "-g"))}
3068 @xref{ede-proj-target-makefile}.
3071 @subsubsection Specialized Methods
3073 @deffn Method ede-buffer-header-file :AFTER this buffer
3074 There are no default header files.
3077 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3078 Return the variable name for @var{THIS}'s sources.
3081 @deffn Method ede-proj-makefile-insert-variables :AFTER this &optional moresource
3082 Insert variables needed by target @var{THIS}.
3083 Optional argument @var{MORESOURCE} is not used.
3086 @deffn Method ede-proj-makefile-dependency-files :AFTER this
3087 Return a list of source files to convert to dependencies.
3088 Argument @var{THIS} is the target to get sources from.
3092 @node ede-proj-target-makefile-archive, ede-proj-target-makefile-program, ede-proj-target-makefile-objectcode, Targets
3093 @subsection ede-proj-target-makefile-archive
3094 @tgindex ede-proj-target-makefile-archive
3097 @item Inheritance Tree:
3099 @item eieio-speedbar
3101 @item eieio-speedbar-directory-button
3103 @item @w{@xref{ede-target}.}
3105 @item @w{@xref{ede-proj-target}.}
3107 @item @w{@xref{ede-proj-target-makefile}.}
3109 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3111 @item ede-proj-target-makefile-archive
3122 @subsubsection Specialized Methods
3124 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3125 Create the make rule needed to create an archive for @var{THIS}.
3128 @deffn Method ede-proj-makefile-insert-source-variables :PRIMARY this
3129 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3130 We aren't actually inserting SOURCE details, but this is used by the
3131 Makefile.am generator, so use it to add this important bin program.
3135 @node ede-proj-target-makefile-program, ede-proj-target-makefile-shared-object, ede-proj-target-makefile-archive, Targets
3136 @subsection ede-proj-target-makefile-program
3137 @tgindex ede-proj-target-makefile-program
3140 @item Inheritance Tree:
3142 @item eieio-speedbar
3144 @item eieio-speedbar-directory-button
3146 @item @w{@xref{ede-target}.}
3148 @item @w{@xref{ede-proj-target}.}
3150 @item @w{@xref{ede-proj-target-makefile}.}
3152 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3154 @item ede-proj-target-makefile-program
3157 @w{@xref{ede-proj-target-makefile-shared-object}.}
3173 Type: @code{list} @*
3174 Default Value: @code{nil}
3176 Libraries, such as "m" or "Xt" which this program depends on.
3177 The linker flag "-l" is automatically prepended. Do not include a "lib"
3178 prefix, or a ".so" suffix.
3180 Note: Currently only used for Automake projects.
3183 Type: @code{list} @*
3184 Default Value: @code{nil}
3186 Additional flags to add when linking this target.
3187 Use ldlibs to add addition libraries. Use this to specify specific
3188 options to the linker.
3190 Note: Not currently used. This bug needs to be fixed.
3195 @subsubsection Specialized Methods
3197 @deffn Method project-debug-target :AFTER obj
3198 Debug a program target @var{OBJ}.
3201 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3202 Insert rules needed by @var{THIS} target.
3205 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
3206 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3209 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
3210 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3214 @node ede-proj-target-makefile-shared-object, ede-proj-target-elisp, ede-proj-target-makefile-program, Targets
3215 @subsection ede-proj-target-makefile-shared-object
3216 @tgindex ede-proj-target-makefile-shared-object
3219 @item Inheritance Tree:
3221 @item eieio-speedbar
3223 @item eieio-speedbar-directory-button
3225 @item @w{@xref{ede-target}.}
3227 @item @w{@xref{ede-proj-target}.}
3229 @item @w{@xref{ede-proj-target-makefile}.}
3231 @item @w{@xref{ede-proj-target-makefile-objectcode}.}
3233 @item @w{@xref{ede-proj-target-makefile-program}.}
3235 @item ede-proj-target-makefile-shared-object
3247 @subsubsection Specialized Methods
3249 @deffn Method ede-proj-configure-add-missing :AFTER this
3250 Query if any files needed by @var{THIS} provided by automake are missing.
3251 Results in --add-missing being passed to automake.
3254 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3255 Return the variable name for @var{THIS}'s sources.
3258 @deffn Method ede-proj-makefile-insert-automake-post-variables :AFTER this
3259 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3260 We need to override -program which has an LDADD element.
3263 @deffn Method ede-proj-makefile-target-name :AFTER this
3264 Return the name of the main target for @var{THIS} target.
3267 @deffn Method ede-proj-makefile-insert-automake-pre-variables :AFTER this
3268 Insert bin_PROGRAMS variables needed by target @var{THIS}.
3269 We aren't actually inserting SOURCE details, but this is used by the
3270 Makefile.am generator, so use it to add this important bin program.
3274 @node ede-proj-target-elisp, ede-proj-target-elisp-autoloads, ede-proj-target-makefile-shared-object, Targets
3275 @subsection ede-proj-target-elisp
3276 @tgindex ede-proj-target-elisp
3279 @item Inheritance Tree:
3281 @item eieio-speedbar
3283 @item eieio-speedbar-directory-button
3285 @item @w{@xref{ede-target}.}
3287 @item @w{@xref{ede-proj-target}.}
3289 @item @w{@xref{ede-proj-target-makefile}.}
3291 @item ede-proj-target-elisp
3294 @w{@xref{ede-proj-target-elisp-autoloads}.}
3309 Type: @code{list} @*
3310 Default Value: @code{nil}
3312 Additional packages needed.
3313 There should only be one toplevel package per auxiliary tool needed.
3314 These packages location is found, and added to the compile time
3320 @subsubsection Specialized Methods
3322 @deffn Method project-compile-target :AFTER obj
3323 Compile all sources in a Lisp target @var{OBJ}.
3324 Bonus: Return a cons cell: (COMPILED . UPTODATE).
3327 @deffn Method ede-proj-flush-autoconf :AFTER this
3328 Flush the configure file (current buffer) to accommodate @var{THIS}.
3331 @deffn Method ede-buffer-mine :AFTER this buffer
3332 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3333 Lays claim to all .elc files that match .el files in this target.
3336 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3337 Return the variable name for @var{THIS}'s sources.
3340 @deffn Method ede-proj-tweak-autoconf :AFTER this
3341 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3344 @deffn Method ede-update-version-in-source :AFTER this version
3345 In a Lisp file, updated a version string for @var{THIS} to @var{VERSION}.
3346 There are standards in Elisp files specifying how the version string
3347 is found, such as a @code{-version} variable, or the standard header.
3350 @node ede-proj-target-elisp-autoloads, ede-proj-target-makefile-miscelaneous, ede-proj-target-elisp, Targets
3351 @subsection ede-proj-target-elisp-autoloads
3352 @tgindex ede-proj-target-elisp-autoloads
3355 @item Inheritance Tree:
3357 @item eieio-speedbar
3359 @item eieio-speedbar-directory-button
3361 @item @w{@xref{ede-target}.}
3363 @item @w{@xref{ede-proj-target}.}
3365 @item @w{@xref{ede-proj-target-makefile}.}
3367 @item @w{@xref{ede-proj-target-elisp}.}
3369 @item ede-proj-target-elisp-autoloads
3385 Type: @code{list} @*
3386 Default Value: @code{("cedet-autogen")}
3388 @xref{ede-proj-target-elisp}.
3389 @item :autoload-file
3390 Type: @code{string} @*
3391 Default Value: @code{"loaddefs.el"}
3393 The file that autoload definitions are placed in.
3394 There should be one load defs file for a given package. The load defs are created
3395 for all Emacs Lisp sources that exist in the directory of the created target.
3397 @item :autoload-dirs
3398 Type: @code{list} @*
3399 Default Value: @code{nil}
3401 The directories to scan for autoload definitions.
3402 If @code{nil} defaults to the current directory.
3407 @subsubsection Specialized Methods
3409 @deffn Method ede-proj-makefile-dependencies :AFTER this
3410 Return a string representing the dependencies for @var{THIS}.
3411 Always return an empty string for an autoloads generator.
3414 @deffn Method project-compile-target :AFTER obj
3415 Create or update the autoload target.
3418 @deffn Method ede-proj-flush-autoconf :AFTER this
3419 Flush the configure file (current buffer) to accommodate @var{THIS}.
3422 @deffn Method ede-buffer-mine :AFTER this buffer
3423 Return @code{t} if object @var{THIS} lays claim to the file in @var{BUFFER}.
3424 Lays claim to all .elc files that match .el files in this target.
3427 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3428 Return the variable name for @var{THIS}'s sources.
3431 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3432 Insert any symbols that the DIST rule should depend on.
3433 Emacs Lisp autoload files ship the generated .el files.
3434 Argument @var{THIS} is the target which needs to insert an info file.
3437 @deffn Method ede-proj-tweak-autoconf :AFTER this
3438 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3441 @deffn Method ede-update-version-in-source :AFTER this version
3442 In a Lisp file, updated a version string for @var{THIS} to @var{VERSION}.
3443 There are standards in Elisp files specifying how the version string
3444 is found, such as a @code{-version} variable, or the standard header.
3447 @deffn Method ede-proj-compilers :AFTER obj
3448 List of compilers being used by @var{OBJ}.
3449 If the @code{compiler} slot is empty, get the car of the compilers list.
3452 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
3453 Insert any symbols that the DIST rule should distribute.
3454 Emacs Lisp autoload files ship the generated .el files.
3455 Argument @var{THIS} is the target which needs to insert an info file.
3458 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
3459 Insert the source variables needed by @var{THIS}.
3460 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
3465 @node ede-proj-target-makefile-miscelaneous, ede-proj-target-makefile-info, ede-proj-target-elisp-autoloads, Targets
3466 @subsection ede-proj-target-makefile-miscelaneous
3467 @tgindex ede-proj-target-makefile-miscelaneous
3470 @item Inheritance Tree:
3472 @item eieio-speedbar
3474 @item eieio-speedbar-directory-button
3476 @item @w{@xref{ede-target}.}
3478 @item @w{@xref{ede-proj-target}.}
3480 @item @w{@xref{ede-proj-target-makefile}.}
3482 @item ede-proj-target-makefile-miscelaneous
3497 Type: @code{string} @*
3498 Default Value: @code{""}
3500 Miscellaneous sources which have a specialized makefile.
3501 The sub-makefile is used to build this target.
3506 @subsubsection Specialized Methods
3508 @deffn Method ede-proj-makefile-insert-rules :AFTER this
3509 Create the make rule needed to create an archive for @var{THIS}.
3512 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3513 Return the variable name for @var{THIS}'s sources.
3516 @deffn Method ede-proj-makefile-dependency-files :AFTER this
3517 Return a list of files which @var{THIS} target depends on.
3521 @node ede-proj-target-makefile-info, ede-proj-target-scheme, ede-proj-target-makefile-miscelaneous, Targets
3522 @subsection ede-proj-target-makefile-info
3523 @tgindex ede-proj-target-makefile-info
3526 @item Inheritance Tree:
3528 @item eieio-speedbar
3530 @item eieio-speedbar-directory-button
3532 @item @w{@xref{ede-target}.}
3534 @item @w{@xref{ede-proj-target}.}
3536 @item @w{@xref{ede-proj-target-makefile}.}
3538 @item ede-proj-target-makefile-info
3553 Type: @code{string} @*
3554 Default Value: @code{""}
3556 The main menu resides in this file.
3557 All other sources should be included independently.
3562 @subsubsection Specialized Methods
3564 @deffn Method ede-proj-configure-add-missing :AFTER this
3565 Query if any files needed by @var{THIS} provided by automake are missing.
3566 Results in --add-missing being passed to automake.
3569 @deffn Method object-write :AFTER this
3570 Before committing any change to @var{THIS}, make sure the mainmenu is first.
3573 @deffn Method ede-proj-makefile-sourcevar :AFTER this
3574 Return the variable name for @var{THIS}'s sources.
3577 @deffn Method ede-proj-makefile-insert-dist-dependencies :AFTER this
3578 Insert any symbols that the DIST rule should depend on.
3579 Texinfo files want to insert generated `.info' files.
3580 Argument @var{THIS} is the target which needs to insert an info file.
3583 @deffn Method ede-proj-makefile-target-name :AFTER this
3584 Return the name of the main target for @var{THIS} target.
3587 @deffn Method ede-documentation :AFTER this
3588 Return a list of files that provides documentation.
3589 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
3590 files in the project.
3593 @deffn Method ede-proj-makefile-insert-dist-filepatterns :AFTER this
3594 Insert any symbols that the DIST rule should depend on.
3595 Texinfo files want to insert generated `.info' files.
3596 Argument @var{THIS} is the target which needs to insert an info file.
3599 @deffn Method ede-proj-makefile-insert-source-variables :AFTER this &optional moresource
3600 Insert the source variables needed by @var{THIS} info target.
3601 Optional argument @var{MORESOURCE} is a list of additional sources to add to the
3603 Does the usual for Makefile mode, but splits source into two variables
3604 when working in Automake mode.
3607 @node ede-proj-target-scheme, project-am-target, ede-proj-target-makefile-info, Targets
3608 @subsection ede-proj-target-scheme
3609 @tgindex ede-proj-target-scheme
3612 @item Inheritance Tree:
3614 @item eieio-speedbar
3616 @item eieio-speedbar-directory-button
3618 @item @w{@xref{ede-target}.}
3620 @item @w{@xref{ede-proj-target}.}
3622 @item ede-proj-target-scheme
3636 Type: @code{string} @*
3637 Default Value: @code{"guile"}
3639 The preferred interpreter for this code.
3644 @subsubsection Specialized Methods
3646 @deffn Method ede-proj-tweak-autoconf :AFTER this
3647 Tweak the configure file (current buffer) to accommodate @var{THIS}.
3651 @node project-am-target, project-am-objectcode, ede-proj-target-scheme, Targets
3652 @subsection project-am-target
3653 @tgindex project-am-target
3656 @item Inheritance Tree:
3658 @item eieio-speedbar
3660 @item eieio-speedbar-directory-button
3662 @item @w{@xref{ede-target}.}
3664 @item project-am-target
3667 @w{@xref{project-am-objectcode},} @w{project-am-header,} @w{@xref{project-am-lisp},} @w{@xref{project-am-texinfo},} @w{@xref{project-am-man}.}
3675 @subsubsection Specialized Methods
3677 @deffn Method project-compile-target-command :AFTER this
3678 Default target to use when compiling a given target.
3681 @deffn Method project-make-dist :AFTER this
3682 Run the current project in the debugger.
3685 @deffn Method project-edit-file-target :AFTER obj
3686 Edit the target associated w/ this file.
3689 @node project-am-objectcode, project-am-program, project-am-target, Targets
3690 @subsection project-am-objectcode
3691 @tgindex project-am-objectcode
3694 @item Inheritance Tree:
3696 @item eieio-speedbar
3698 @item eieio-speedbar-directory-button
3700 @item @w{@xref{ede-target}.}
3702 @item @w{@xref{project-am-target}.}
3704 @item project-am-objectcode
3707 @w{@xref{project-am-program},} @w{project-am-lib.}
3716 @subsubsection Specialized Methods
3718 @deffn Method project-am-macro :AFTER this
3719 Return the default macro to 'edit' for this object type.
3722 @deffn Method project-debug-target :AFTER obj
3723 Run the current project target in a debugger.
3726 @deffn Method project-compile-target-command :AFTER this
3727 Default target to use when compiling an object code target.
3730 @deffn Method ede-buffer-header-file :AFTER this buffer
3731 There are no default header files.
3734 @node project-am-program, project-am-header-noinst, project-am-objectcode, Targets
3735 @subsection project-am-program
3736 @tgindex project-am-program
3739 @item Inheritance Tree:
3741 @item eieio-speedbar
3743 @item eieio-speedbar-directory-button
3745 @item @w{@xref{ede-target}.}
3747 @item @w{@xref{project-am-target}.}
3749 @item @w{@xref{project-am-objectcode}.}
3751 @item project-am-program
3766 Default Value: @code{nil}
3772 @node project-am-header-noinst, project-am-header-inst, project-am-program, Targets
3773 @subsection project-am-header-noinst
3774 @tgindex project-am-header-noinst
3777 @item Inheritance Tree:
3779 @item eieio-speedbar
3781 @item eieio-speedbar-directory-button
3783 @item @w{@xref{ede-target}.}
3785 @item @w{@xref{project-am-target}.}
3787 @item @w{project-am-header.}
3789 @item project-am-header-noinst
3799 @subsubsection Specialized Methods
3801 @deffn Method project-am-macro :AFTER this
3802 Return the default macro to 'edit' for this object.
3805 @node project-am-header-inst, project-am-lisp, project-am-header-noinst, Targets
3806 @subsection project-am-header-inst
3807 @tgindex project-am-header-inst
3810 @item Inheritance Tree:
3812 @item eieio-speedbar
3814 @item eieio-speedbar-directory-button
3816 @item @w{@xref{ede-target}.}
3818 @item @w{@xref{project-am-target}.}
3820 @item @w{project-am-header.}
3822 @item project-am-header-inst
3832 @subsubsection Specialized Methods
3834 @deffn Method project-am-macro :AFTER this
3835 Return the default macro to 'edit' for this object.
3838 @node project-am-lisp, project-am-texinfo, project-am-header-inst, Targets
3839 @subsection project-am-lisp
3840 @tgindex project-am-lisp
3843 @item Inheritance Tree:
3845 @item eieio-speedbar
3847 @item eieio-speedbar-directory-button
3849 @item @w{@xref{ede-target}.}
3851 @item @w{@xref{project-am-target}.}
3853 @item project-am-lisp
3862 @subsubsection Specialized Methods
3864 @deffn Method project-am-macro :AFTER this
3865 Return the default macro to 'edit' for this object.
3868 @node project-am-texinfo, project-am-man, project-am-lisp, Targets
3869 @subsection project-am-texinfo
3870 @tgindex project-am-texinfo
3873 @item Inheritance Tree:
3875 @item eieio-speedbar
3877 @item eieio-speedbar-directory-button
3879 @item @w{@xref{ede-target}.}
3881 @item @w{@xref{project-am-target}.}
3883 @item project-am-texinfo
3897 Default Value: @code{nil}
3899 Additional texinfo included in this one.
3903 @subsubsection Specialized Methods
3905 @deffn Method project-am-macro :AFTER this
3906 Return the default macro to 'edit' for this object type.
3909 @deffn Method project-compile-target-command :AFTER this
3910 Default target to use when compiling a texinfo file.
3913 @deffn Method ede-documentation :AFTER this
3914 Return a list of files that provides documentation.
3915 Documentation is not for object @var{THIS}, but is provided by @var{THIS} for other
3916 files in the project.
3919 @node project-am-man, , project-am-texinfo, Targets
3920 @comment node-name, next, previous, up
3921 @subsection project-am-man
3922 @tgindex project-am-man
3925 @item Inheritance Tree:
3927 @item eieio-speedbar
3929 @item eieio-speedbar-directory-button
3931 @item @w{@xref{ede-target}.}
3933 @item @w{@xref{project-am-target}.}
3935 @item project-am-man
3944 @subsubsection Specialized Methods
3946 @deffn Method project-am-macro :AFTER this
3947 Return the default macro to 'edit' for this object type.
3950 @node Sourcecode, Compilers, Targets, Extending EDE
3953 The source code type is an object designed to associated files with
3961 @node ede-sourcecode, , Sourcecode, Sourcecode
3962 @subsection ede-sourcecode
3963 @scindex ede-sourcecode
3966 @item Inheritance Tree:
3968 @item eieio-instance-inheritor
3970 @item ede-sourcecode
3980 @item :parent-instance
3981 Type: @code{eieio-instance-inheritor-child}
3983 The parent of this instance.
3984 If a slot of this class is reference, and is unbound, then the parent
3985 is checked for a value.
3990 The name of this type of source code.
3991 Such as "C" or "Emacs Lisp"
3993 @item :sourcepattern
3994 Type: @code{string} @*
3995 Default Value: @code{".*"}
3997 Emacs regex matching sourcecode this target accepts.
3999 @item :auxsourcepattern
4000 Type: @code{(or null string)} @*
4001 Default Value: @code{nil}
4003 Emacs regex matching auxiliary source code this target accepts.
4004 Aux source are source code files needed for compilation, which are not compiled
4007 @item :enable-subdirectories
4008 Type: @code{boolean} @*
4009 Default Value: @code{nil}
4011 Non @code{nil} if this sourcecode type uses subdirectores.
4012 If sourcecode always lives near the target creating it, this should be nil.
4013 If sourcecode can, or typically lives in a subdirectory of the owning
4014 target, set this to t.
4016 @item :garbagepattern
4017 Type: @code{list} @*
4018 Default Value: @code{nil}
4020 Shell file regex matching files considered as garbage.
4021 This is a list of items added to an @code{rm} command when executing a @code{clean}
4027 @subsubsection Specialized Methods
4029 @deffn Method ede-want-any-files-p :AFTER this filenames
4030 Return non-@code{nil} if @var{THIS} will accept any files in @var{FILENAMES}.
4033 @deffn Method ede-want-any-source-files-p :AFTER this filenames
4034 Return non-@code{nil} if @var{THIS} will accept any source files in @var{FILENAMES}.
4037 @deffn Method ede-want-any-auxiliary-files-p :AFTER this filenames
4038 Return non-@code{nil} if @var{THIS} will accept any aux files in @var{FILENAMES}.
4041 @deffn Method ede-buffer-header-file :AFTER this filename
4042 Return a list of file names of header files for @var{THIS} with @var{FILENAME}.
4043 Used to guess header files, but uses the auxsource regular expression.
4046 @deffn Method ede-want-file-p :AFTER this filename
4047 Return non-@code{nil} if sourcecode definition @var{THIS} will take @var{FILENAME}.
4050 @deffn Method ede-want-file-source-p :AFTER this filename
4051 Return non-@code{nil} if @var{THIS} will take @var{FILENAME} as an auxiliary .
4054 @deffn Method ede-want-file-auxiliary-p :AFTER this filename
4055 Return non-@code{nil} if @var{THIS} will take @var{FILENAME} as an auxiliary .
4058 @node Compilers, , Sourcecode, Extending EDE
4061 The compiler object is designed to associate source code with
4062 compilers. The target then references the compilers it can use.
4063 When the makefile is created, this object type knows how to create
4067 * ede-compilation-program::
4069 * ede-object-compiler::
4074 @node ede-compilation-program, ede-compiler, Compilers, Compilers
4075 @subsection ede-compilation-program
4076 @cmindex ede-compilation-program
4079 @item Inheritance Tree:
4081 @item eieio-instance-inheritor
4083 @item ede-compilation-program
4086 @w{@xref{ede-compiler},} @w{@xref{ede-linker}.}
4096 @item :parent-instance
4097 Type: @code{eieio-instance-inheritor-child}
4099 The parent of this instance.
4100 If a slot of this class is reference, and is unbound, then the parent
4101 is checked for a value.
4106 Name of this type of compiler.
4111 Variables needed in the Makefile for this compiler.
4112 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4113 is a string, and VALUE is either a string, or a list of strings.
4114 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4119 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4120 This is used to match target objects with the compilers and linkers
4121 they can use, and which files this object is interested in.
4124 Type: @code{list} @*
4125 Default Value: @code{nil}
4127 Auxiliary rules needed for this compiler to run.
4128 For example, yacc/lex files need additional chain rules, or inferences.
4133 The commands used to execute this compiler.
4134 The object which uses this compiler will place these commands after
4135 it's rule definition.
4138 Type: @code{list} @*
4139 Default Value: @code{nil}
4141 Autoconf function to call if this type of compiler is used.
4142 When a project is in Automake mode, this defines the autoconf function to
4143 call to initialize automake to use this compiler.
4144 For example, there may be multiple C compilers, but they all probably
4145 use the same autoconf form.
4147 @item :objectextention
4150 A string which is the extension used for object files.
4151 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4156 @subsubsection Specialized Methods
4158 @deffn Method ede-proj-flush-autoconf :AFTER this
4159 Flush the configure file (current buffer) to accommodate @var{THIS}.
4162 @deffn Method ede-proj-makefile-insert-rules :AFTER this
4163 Insert rules needed for @var{THIS} compiler object.
4166 @deffn Method ede-proj-makefile-insert-variables :AFTER this
4167 Insert variables needed by the compiler @var{THIS}.
4170 @deffn Method ede-proj-makefile-insert-commands :AFTER this
4171 Insert the commands needed to use compiler @var{THIS}.
4172 The object creating makefile rules must call this method for the
4173 compiler it decides to use after inserting in the rule.
4176 @deffn Method ede-object-sourcecode :AFTER this
4177 Retrieves the slot @code{sourcetype} from an object of class @code{ede-compilation-program}
4180 @deffn Method ede-proj-tweak-autoconf :AFTER this
4181 Tweak the configure file (current buffer) to accommodate @var{THIS}.
4185 @node ede-compiler, ede-object-compiler, ede-compilation-program, Compilers
4186 @subsection ede-compiler
4187 @cmindex ede-compiler
4190 @item Inheritance Tree:
4192 @item eieio-instance-inheritor
4194 @item @w{@xref{ede-compilation-program}.}
4199 @w{@xref{ede-object-compiler},} @w{semantic-ede-grammar-compiler-class.}
4209 Create a new object with name NAME of class type ede-compiler
4215 @item :parent-instance
4216 Type: @code{eieio-instance-inheritor-child}
4218 The parent of this instance.
4219 If a slot of this class is reference, and is unbound, then the parent
4220 is checked for a value.
4225 Name of this type of compiler.
4230 Variables needed in the Makefile for this compiler.
4231 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4232 is a string, and VALUE is either a string, or a list of strings.
4233 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4238 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4239 This is used to match target objects with the compilers and linkers
4240 they can use, and which files this object is interested in.
4245 The commands used to execute this compiler.
4246 The object which uses this compiler will place these commands after
4247 it's rule definition.
4249 @item :objectextention
4252 A string which is the extension used for object files.
4253 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4256 Type: @code{boolean} @*
4257 Default Value: @code{nil}
4259 Non-@code{nil} if this compiler can make dependencies.
4262 Type: @code{boolean} @*
4263 Default Value: @code{nil}
4265 Non-@code{nil} if this compiler creates code that can be linked.
4266 This requires that the containing target also define a list of available
4267 linkers that can be used.
4272 @subsubsection Specialized Methods
4274 @deffn Method ede-proj-makefile-insert-object-variables :AFTER this targetname sourcefiles
4275 Insert an OBJ variable to specify object code to be generated for @var{THIS}.
4276 The name of the target is @var{TARGETNAME} as a string. @var{SOURCEFILES} is the list of
4277 files to be objectified.
4278 Not all compilers do this.
4281 @deffn Method ede-compiler-intermediate-objects-p :AFTER this
4282 Return non-@code{nil} if @var{THIS} has intermediate object files.
4283 If this compiler creates code that can be linked together,
4284 then the object files created by the compiler are considered intermediate.
4287 @deffn Method ede-compiler-intermediate-object-variable :AFTER this targetname
4288 Return a string based on @var{THIS} representing a make object variable.
4289 @var{TARGETNAME} is the name of the target that these objects belong to.
4293 @node ede-object-compiler, ede-linker, ede-compiler, Compilers
4294 @subsection ede-object-compiler
4295 @cmindex ede-object-compiler
4298 @item Inheritance Tree:
4300 @item eieio-instance-inheritor
4302 @item @w{@xref{ede-compilation-program}.}
4304 @item @w{@xref{ede-compiler}.}
4306 @item ede-object-compiler
4319 Type: @code{boolean} @*
4320 Default Value: @code{t}
4322 @xref{ede-compiler}.
4323 @item :dependencyvar
4326 A variable dedicated to dependency generation.
4330 @subsubsection Specialized Methods
4332 @deffn Method ede-proj-makefile-insert-variables :AFTER this
4333 Insert variables needed by the compiler @var{THIS}.
4336 @node ede-linker, , ede-object-compiler, Compilers
4337 @subsection ede-linker
4341 @item Inheritance Tree:
4343 @item eieio-instance-inheritor
4345 @item @w{@xref{ede-compilation-program}.}
4356 Create a new object with name NAME of class type ede-linker
4365 Name of this type of compiler.
4370 Variables needed in the Makefile for this compiler.
4371 An assoc list where each element is (VARNAME . VALUE) where VARNAME
4372 is a string, and VALUE is either a string, or a list of strings.
4373 For example, GCC would define CC=gcc, and emacs would define EMACS=emacs.
4378 A list of @code{ede-sourcecode} @xref{ede-sourcecode}. objects this class will handle.
4379 This is used to match target objects with the compilers and linkers
4380 they can use, and which files this object is interested in.
4385 The commands used to execute this compiler.
4386 The object which uses this compiler will place these commands after
4387 it's rule definition.
4389 @item :objectextention
4392 A string which is the extension used for object files.
4393 For example, C code uses .o on unix, and Emacs Lisp uses .elc.
4398 @node GNU Free Documentation License, , Extending EDE, Top
4399 @appendix GNU Free Documentation License
4400 @include doclicense.texi