forked from fgeller/emacs-mac-port
-
Notifications
You must be signed in to change notification settings - Fork 0
/
ede.info
4025 lines (2834 loc) · 132 KB
/
ede.info
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
This is /home/cyd/emacs/doc/misc/../../info/ede.info, produced by
makeinfo version 4.13 from /home/cyd/emacs/doc/misc/ede.texi.
This file describes EDE, the Emacs Development Environment.
Copyright (C) 1998-2001, 2004-2005, 2008-2012 Free Software
Foundation, Inc.
Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License,
Version 1.3 or any later version published by the Free Software
Foundation; with no Invariant Sections, with the Front-Cover texts
being "A GNU Manual," and with the Back-Cover Texts as in (a)
below. A copy of the license is included in the section entitled
"GNU Free Documentation License."
(a) The FSF's Back-Cover Text is: "You have the freedom to copy and
modify this GNU manual. Buying copies from the FSF supports it in
developing GNU and promoting software freedom."
INFO-DIR-SECTION Emacs misc features
START-INFO-DIR-ENTRY
* EDE: (ede). The Emacs Development Environment.
END-INFO-DIR-ENTRY
File: ede.info, Node: Top, Next: EDE Project Concepts, Prev: (dir), Up: (dir)
EDE
***
EDE is the Emacs Development Environment: an Emacs extension that
simplifies building and debugging programs in Emacs. It attempts to
emulate a typical IDE (Integrated Development Environment). EDE can
manage or create your makefiles and other building environment duties,
allowing you to concentrate on writing code rather than support files.
It aims to make it much easier for new programmers to learn and adopt
GNU ways of doing things.
This file describes EDE, the Emacs Development Environment.
Copyright (C) 1998-2001, 2004-2005, 2008-2012 Free Software
Foundation, Inc.
Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License,
Version 1.3 or any later version published by the Free Software
Foundation; with no Invariant Sections, with the Front-Cover texts
being "A GNU Manual," and with the Back-Cover Texts as in (a)
below. A copy of the license is included in the section entitled
"GNU Free Documentation License."
(a) The FSF's Back-Cover Text is: "You have the freedom to copy and
modify this GNU manual. Buying copies from the FSF supports it in
developing GNU and promoting software freedom."
* Menu:
* EDE Project Concepts:: EDE Project Concepts
* EDE Mode:: Turning on EDE mode.
* Quick Start:: Quick start to building a project.
* Creating a project:: Creating a project.
* Modifying your project:: Adding and removing files and targets.
* Building and Debugging:: Initiating a build or debug session.
* Miscellaneous commands:: Other project related commands.
* Extending EDE:: Programming and extending EDE.
File: ede.info, Node: EDE Project Concepts, Next: EDE Mode, Prev: Top, Up: Top
1 EDE Project Concepts
**********************
EDE is a generic interface for managing projects. It specifies a
single set of menus and keybindings, while supporting multiple ways to
express a project via a build system.
In the subsequent chapters, we will describe the different project
types (*note Creating a project::), as well as the commands to build
and debug projects (*note Building and Debugging::).
In EDE, a project hierarchy matches a directory hierarchy. The
project's topmost directory is called the "project root", and its
subdirectories are "subprojects".
Each project can contain multiple "targets". A target, at the
simplest level, is a named collection of files within a project. A
target can specify two different types of information:
1. A collection of files to be added to a distribution (e.g., a
tarball that you intend to distribute to others).
2. A collection of files that can be built into something else (e.g.,
a program or compiled documentation).
Lastly, EDE provides a way for other tools to easily learn file
associations. For example, a program might need to restrict some sort
of search to files in a single target, or to discover the location of
documentation or interface files. EDE can provide this information.
File: ede.info, Node: EDE Mode, Next: Quick Start, Prev: EDE Project Concepts, Up: Top
2 EDE Mode
**********
EDE is implemented as a minor mode, which augments other modes such as
C mode, and Texinfo mode. You can enable EDE for all buffers by
running the command `global-ede-mode', or by putting this in your init
file:
(global-ede-mode t)
Activating EDE adds a menu named `Development' to the menu bar.
This menu provides several menu items for high-level EDE commands.
These menu items, and their corresponding keybindings, are independent
of the type of project you are actually working on.
File: ede.info, Node: Quick Start, Next: Creating a project, Prev: EDE Mode, Up: Top
3 Quick Start
*************
Once you have EDE enabled, you can create a project. This chapter
provides an example C++ project that will create Automake files for
compilation.
3.1 Step 1: Create root directory
=================================
First, lets create a directory for our project. For this example,
we'll start with something in `/tmp'.
C-x C-f /tmp/myproject/README RET
M-x make-directory RET RET
Now put some plain text in your README file to start.
Now, lets create the project:
M-x ede-new RET Automake RET myproject RET
Nothing visible happened, but if you use `dired' to look at the
directory, you should see this:
/tmp/myproject:
total used in directory 32 available 166643476
drwxr-xr-x 2 zappo users 4096 2012-02-23 22:10 .
drwxrwxrwt 73 root root 20480 2012-02-23 22:10 ..
-rw-r--r-- 1 zappo users 195 2012-02-23 22:10 Project.ede
-rw-r--r-- 1 zappo users 10 2012-02-23 22:09 README
3.2 Step 2: Create Subdirectories and Files
===========================================
We'll make a more complex project, so use dired to create some more
directories using the `+' key, and typing in new directories:
+ include RET
+ src RET
Now I'll short-cut in this tutorial. Create the following files:
`include/myproj.hh'
/** myproj.hh ---
*/
#ifndef myproj_hh
#define myproj_hh 1
#define IMPORTANT_MACRO 1
int my_lib_function();
#endif // myproj_hh
`src/main.cpp'
/** main.cpp ---
*/
#include <iostream>
#include "myproj.hh"
int main() {
}
#ifdef IMPORTANT_MACRO
int my_fcn() {
}
#endif
`src/mylib.cpp'
/** mylib.cpp ---
*
* Shared Library to build
*/
int my_lib_function() {
}
3.3 Step 3: Create subprojects
==============================
EDE needs subdirectories to also have projects in them. You can now
create those projects.
With `main.cpp' as your current buffer, type:
M-x ede-new RET Automake RET src RET
and in `myproj.hh' as your current buffer, type:
M-x ede-new RET Automake RET include RET
These steps effectively only create the Project.ede file in which you
will start adding targets.
3.4 Step 4: Create targets
==========================
In order to build a program, you must have targets in your EDE
Projects. You can create targets either from a buffer, or from a
`dired' directory buffer.
Note: If for some reason a directory list buffer, or file does not
have the `Project' menu item, or if EDE keybindings don't work, just
use `M-x revert-buffer RET' to force a refresh. Sometimes creating a
new project doesn't restart buffers correctly.
Lets start with the header file. In `include/myproj.hh', you could
use the menu, but we will now start using the EDE command prefix which
is `C-c .'.
C-c . t includes RET miscellaneous RET y
This creates a misc target for holding your includes, and then adds
myproj.hh to the target. Automake (the tool) has better ways to do
this, but for this project, it is sufficient.
Next, visit the `src' directory using dired. There should be a
`Project' menu. You can create a new target with
. t myprogram RET program RET
Note that `. t' is a command for creating a target. This command is
also in the menu. This will create a target that will build a program.
If you want, visit `Project.ede' to see the structure built so far.
Next, place the cursor on `main.cpp', and use `. a' to add that file
to your target.
. a myprogram RET
Note that these prompts often have completion, so you can just press
`TAB' to complete the name `myprogram'.
If you had many files to add to the same target, you could mark them
all in your dired buffer, and add them all at the same time.
Next, do the same for the library by placing the cursor on
`mylib.cpp'.
. t mylib RET sharedobject RET
. a mylib RET
3.5 Step 5: Compile, and fail
=============================
Next, we'll try to compile the project, but we aren't done yet, so it
won't work right away.
Visit `/tmp/myproject/Project.ede'. We're starting here because we
don't have any program files in this directory yet. Now we can use the
compile command:
C-c . C
Because this is the very first time, it will create a bunch of files
for you that are required by Automake. It will then use automake to
build the support infrastructure it needs. This step is skipped if you
choose just a `Makefile' build system.
After the Automake init, it runs compile. You will immediately
discover the error in main.cpp can't find `myproj.hh'. We need to go
fix this.
3.6 Step 6: Customizing your project
====================================
To fix the failed compile, we need to add `/tmp/myproject/include' to
the include path.
Visit `main.cpp'.
M-x customize-project RET
Select the `[Settings]' subgroup of options. Under `Variable :'
click `[INS]'. At this point, you need to be somewhat savvy with
Automake. Add a variable named `CPPFLAGS', and set the value to
`../include'.
You should see something like this:
Variables :
[INS] [DEL] Cons-cell:
Name: AM_CPPFLAGS
Value: -I../include
[INS]
Variables to set in this Makefile.
Click `[Apply]'. Feel free to visit `Project.ede' to see how it
changed the config file.
Compile the whole project again with `C-c . C' from `main.cpp'. It
should now compile.
3.7 Step 7: Shared library dependency
=====================================
Note: Supporting shared libraries for Automake in this way is easy, but
doing so from a project of type Makefile is a bit tricky. If you are
creating shared libraries too, stick to Automake projects.
Next, lets add a dependency from `main.cpp' on our shared library.
To do that, update main like this:
int main() {
my_lib_function();
}
Now compile with:
C-c . c
where the lower case `c' compiles just that target. You should see
an error.
This time, we need to add a dependency from `main.cpp' on our shared
library. To do that, we need to customize our target instead of the
project. This is because variables such as the include path are
treated globally, whereas dependencies for a target are target specific.
M-x customize-target RET
On the first page, you will see an Ldlibs-local section. Add mylib
to it by first clicking `[INS]', and they adding the library. It
should look like this:
Ldlibs-Local :
[INS] [DEL] Local Library: libmylib.la
[INS]
Libraries that are part of this project. [Hide Rest]
The full path to these libraries should be specified, such as:
../lib/libMylib.la or ../ar/myArchive.a
You will also see other variables for library related flags and
system libraries if you need them. Click `[Accept]', and from
`main.cpp', again compile the whole project to force all dependent
elements to compile:
C-c . C
3.8 Step 8: Run your program
============================
You can run your program directly from EDE.
C-c . R RET RET
If your program takes command line arguments, you can type them in
when it offers the command line you want to use to run your program.
File: ede.info, Node: Creating a project, Next: Modifying your project, Prev: Quick Start, Up: Top
4 Creating a project
********************
To create a new project, first visit a file that you want to include in
that project. If you have a hierarchy of directories, first visit a
file in the topmost directory. From this buffer, type `M-x ede-new',
or click on the `Create Project' item in the `Development' menu.
The `ede-new' command prompts for the type of project you would like
to create. Each project type has its own benefits or language specific
enhancements. EDE supports four different project types: `Make',
`Automake', `direct Automake', and `Simple'.
* For the `Make' project type, EDE creates a "project file", called
`Project.ede', in each project directory. Information about the
project is stored in this file. This project autogenerates a
`Makefile'.
* For the `Automake' project type, EDE creates a `Project.ede'
project file similar to a `Make' project. Unlike a `Make'
project, this project autogenerates a `Makefile.am' file. EDE
handles the Automake bootstrapping routines, which import and
maintain a `configure.am' script and other required files.
* For the `direct Automake' project type, EDE reads directly from
the Automake files.
You cannot create direct Automake projects with the `ede-new'
command. Instead, when you visit a project with existing Automake
files, EDE automatically detects them.
* The `Simple' project type provides light-weight constructs for
identifying a project root and looking up files. If you already
have a non-EDE project infrastructure, you can use a `Simple'
project to provide other Emacs packages, such as Semantic, with
some information about the project. *Note Simple projects::.
A subproject is merely a project in a subdirectory of another
project. You can create a subproject by using the `ede-new' command (or
the `Create Project' menu item), while visiting a buffer in a
subdirectory of the project root. This new project is automatically
added to the parent project, and will be automatically loaded when EDE
reads the parent project.
When using a project command that involves a makefile, EDE uses the
top-most project's makefile as a starting place for the build. How the
toplevel project handles subprojects in the build process is dependent
on that project's type.
File: ede.info, Node: Modifying your project, Next: Building and Debugging, Prev: Creating a project, Up: Top
5 Modifying your project
************************
In this chapter, we describe the generic features for manipulating
projects, including the targets and files within them. Subsequent
chapters, which describe specific project types, will provide more
detailed information about exactly what these features do.
* Menu:
* Add/Remove target::
* Add/Remove files::
* Customize Features::
* Project Local Variables::
* EDE Project Features::
File: ede.info, Node: Add/Remove target, Next: Add/Remove files, Prev: Modifying your project, Up: Modifying your project
5.1 Add/Remove target
=====================
To create a new target, type `C-c . t' (`ede-new-target') or use the
`Add Target' menu item in the `Project Options' submenu. This prompts
for a target name, and adds the current buffer to that target.
The `ede-new-target' command also prompts for a "target type". Each
target type has its own build process and class of files that it will
accept.
To remove a target from the project, type `M-x ede-delete-target',
or use the `Remove Target' menu item in the `Project Options' submenu.
File: ede.info, Node: Add/Remove files, Next: Customize Features, Prev: Add/Remove target, Up: Modifying your project
5.2 Add/Remove files
====================
To add the current file to an existing target, type `C-c . a'
(`ede-add-file'), or use the `Add File' menu item in the `Target
Options' submenu.
You can add a file to more than one target; this is OK.
To remove the current file from a target, type `C-c . d'
(`ede-remove-file'), or use the `Remove File' menu item in the `Target
Options' submenu. If the file belongs to multiple targets, this
command prompts for each target it could be removed from.
While working in a project, if you visit a file that is not part of
an existing target, EDE automatically prompts for a target. If you do
not wish to add the file to any target, you can choose `none'. You can
customize this behavior with the variable `ede-auto-add-method'.
File: ede.info, Node: Customize Features, Next: Project Local Variables, Prev: Add/Remove files, Up: Modifying your project
5.3 Customize Features
======================
A project, and its targets, are objects using the `EIEIO' object
system. *Note Top: (eieio)Top. These objects have data fields
containing important information related to your work.
If the high-level functions aren't enough, you can tweak all
user-customizable fields at any time by running the command
`customize-project' or `customize-target'. This loads the current
project or target into a customization buffer, where you can tweak
individual slots. This is usually necessary for complex projects.
Some project modes do not have a project file, but directly read a
Makefile or other existing file. Instead of directly editing the
object, you can edit the file by typing `C-c . e'
(`ede-edit-file-target'). You should "rescan" the project afterwards
(*note Miscellaneous commands::).
File: ede.info, Node: Project Local Variables, Next: EDE Project Features, Prev: Customize Features, Up: Modifying your project
5.4 Project Local Variables
===========================
EDE projects can store and manager project local variables. The
variables are stored in the project, and will be restored when a
project reloads.
Projects which are not stored on disk WILL NOT restore your project
local variables later.
You can use *note Customize Features:: to of the project to edit the
project local variables. They are under the 'Settings' group as
"Project Local Variables".
You can also use `M-x ede-set' to set a new variable local in the
mini buffer.
In multi-level projects such as Automake and Make generating
projects, project local variables are installed from both the TOP most
project, and the local directory's project. In that way, you can have
some variables across your whole project, and some specific to a
subdirectory.
You can use project local variables to set any Emacs variable so that
buffers belonging to different projects can have different settings.
NOTE: When you use project-local variables with *note ede-cpp-root::,
the format is an association list. For example:
(ede-cpp-root-project "SOMENAME"
:file "/dir/to/some/file"
:local-variables
'((grep-command . "grep -nHi -e ")
(compile-command . "make -f MyCustomMakefile all")))
The same is true when you use project-local variables with *note
ede-java-root::. For example:
(ede-java-root-project "SOMENAME"
:file "/dir/to/some/file"
:local-variables
'((grep-command . "grep -nHi -e ")
(compile-command . "ant")))
File: ede.info, Node: EDE Project Features, Prev: Project Local Variables, Up: Modifying your project
5.5 EDE Project Features
========================
This section details user facing features of an EDE `Make' style
project. An `Automake' project has similar options (but a direct
Automake project does not).
To modify any of the specific features mentioned here, you need to
customize the project or target with `customize-project' or
`customize-target'.
When you are customizing, you are directly manipulating slot values
in EIEIO objects. *Note Extending EDE::, if you are interested in
additional details.
* Menu:
* Changing Compilers and Flags::
* Configurations::
File: ede.info, Node: Changing Compilers and Flags, Next: Configurations, Prev: EDE Project Features, Up: EDE Project Features
5.5.1 Changing Compilers and Flags
----------------------------------
Targets that build stuff need compilers. To change compilers, you need
to customize the desired target.
In the `[Make]' section, you can choose a new compiler or linker
from the list. If a linker you need is not available, you will need to
create a new one. *Note Compiler and Linker objects::.
If an existing compiler or linker is close, but you need to modify
some flag set such as adding an include path you will need to add a
configuration variable.
To start, you should create the basic setup, and construct a makefile
with `ede-proj-regenerate'. Look in the `Makefile' to see what
commands are inserted. Once you have determined the variable you need
to modify, you can add a configuration for it. *Note Configurations::.
File: ede.info, Node: Configurations, Prev: Changing Compilers and Flags, Up: EDE Project Features
5.5.2 Configurations
--------------------
Configurations specify different ways to build a project. For example,
you may configure a project to be in "debug" mode, or perhaps in
"release" mode.
The project, and each target type all have a slot named
`configuration-variables'. To add new variables to a configuration
find this slot in the custom buffer, and insert a new configuration.
Name it either "debug" or "release", then insert some number of
name/value pairs to it.
You can have any number of valid configurations too. To add a new
configuration, customize your project. Work in the `[Settings]' block
for "configurations". Add a new named configuration here.
To switch between different active configurations, modify the
"configuration default" slot.
File: ede.info, Node: Building and Debugging, Next: Miscellaneous commands, Prev: Modifying your project, Up: Top
6 Building and Debugging
************************
EDE provides the following "project-aware" compilation and debugging
commands:
`C-c . c'
Compile the current target (`ede-compile-target').
`C-c . C'
Compile the entire project (`ede-compile-project').
`c-c . D'
Debug the current target (`ede-debug-target').
`M-x ede-make-dist'
Build a distribution file for your project.
These commands are also available from the `Development' menu.
File: ede.info, Node: Miscellaneous commands, Next: Extending EDE, Prev: Building and Debugging, Up: Top
7 Miscellaneous commands
************************
If you opt to go in and edit EDE project files directly--for instance,
by using `C-c . e' (*note Customize Features::)--you must then "rescan"
the project files to update the internal data structures. To rescan
the current project, type `C-c . g' (`ede-rescan-toplevel').
EDE can help you find files in your project, via the command `C-c .
f' (`ede-find-file'). This prompts for a file name; you need not
specify the directory. EDE then tries to visit a file with that name
somewhere in your project.
EDE can use external tools to help with file finding. To do this,
customize `ede-locate-setup-options'.
-- Variable: ede-locate-setup-options
List of locate objects to try out by default. Listed in order of
preference. If the first item cannot be used in a particular
project, then the next one is tried. It is always assumed that
"ede-locate-base" is at end of the list.
EDE also provides a project display mode for the speedbar (*note
Speedbar: (emacs)Speedbar.). This allows you to view your source files
as they are structured in your project: as a hierarchical tree, grouped
according to target.
To activate the speedbar in this mode, type `C-c . s'
(`ede-speedbar').
* Menu:
* Make and Automake projects:: Project types of `ede-project'
* Automake direct projects:: Project interface on hand-written automake files.
* Android projects:: Projects for Android development
* Arduino projects:: Projects for Arduino sketches
* Simple projects:: Projects EDE doesn't manage.
File: ede.info, Node: Make and Automake projects, Next: Automake direct projects, Up: Miscellaneous commands
7.1 Make and Automake projects
==============================
A project of `ede-project' type creates a file called `Project.ede' in
every project directory. This is used to track your configuration
information. If you configure this project to be in `Makefile' mode,
then this project will autogenerate a `Makefile'. If you configure it
in `Automake' mode a `Makefile.am' file will be created. The automake
bootstrapping routines will also import and maintain a configure.am
script and a host of other files required by Automake.
File: ede.info, Node: Automake direct projects, Next: Android projects, Prev: Make and Automake projects, Up: Miscellaneous commands
7.2 Automake direct projects
============================
The project type that reads `Makefile.am' directly is derived from the
sources of the original `project-am.el' mode that was distributed
independently. This mode eventually became EDE. The `project-am'
project will read existing automake files, but will not generate them
automatically, or create new ones. As such, it is useful as a browsing
tool, or as maintenance in managing file lists.
File: ede.info, Node: Android projects, Next: Arduino projects, Prev: Automake direct projects, Up: Miscellaneous commands
7.3 Android projects
====================
An Android project of type `ede-android-project' will detect and
support development of Android apps. Android projects use an
`AndroidManifest.xml' file. Always load your Manifest first in a
running Emacs to make sure the project is identified correctly.
Android projects can be created with `ede-new' but depend on a
correctly configured Android SDK via CEDET support.
-- Function: cedet-android-sdk-root
The root to the android SDK.
Android projects support different configurations including compile,
and install, which will upload a program to your Android device. It
also supports several debugging tools via `android.el'.
File: ede.info, Node: Arduino projects, Next: Simple projects, Prev: Android projects, Up: Miscellaneous commands
7.4 Arduino projects
====================
An arduino project of type `ede-arduino-project' will read your
`~/.arduino/preferences.txt' file, and identify your sketches. You
will still need the Arduino IDE to set up your preferences and locate
your arduino. After quitting the IDE, Emacs will be able to find your
sketches, compile them, and upload them to your arduino.
If you have the `arduino' command on your path, EDE will be able to
find your SDK and compile your programs.
File: ede.info, Node: Simple projects, Prev: Arduino projects, Up: Miscellaneous commands
7.5 Simple Projects
===================
There is a wide array of Simple projects. The root for simple projects
is the class `ede-simple-project'. This handles the infrastructure of
storing a .ede file if needed.
The class `ede-simple-project' is designed to be subclassed. Then
key EDE methods can be overridden to provide a quick wrapper over any
project.
A second project type is `ede-cpp-root'. This project type is
designed to be created for a directory hierarchy full of C/C++ code.
It can be configured with minimal lisp knowledge to do header file
lookup for Semantic, improving code completion performance.
* Menu:
* ede-cpp-root:: This project marks the root of a C/C++ code project.
* ede-java-root:: This project marks the root of a Java project.
* ede-emacs:: A project for working with Emacs.
* ede-linux:: A project for working with Linux kernels.
* Custom Locate:: Customizing how to locate files in a simple project
File: ede.info, Node: ede-cpp-root, Next: ede-java-root, Prev: Simple projects, Up: Simple projects
7.5.1 ede-cpp-root
------------------
The `ede-cpp-root' project type allows you to create a single object
with no save-file in your `.emacs' file. It allows EDE to provide the
Semantic package with the ability to find header files quickly.
The `ede-cpp-root' class knows a few things about C++ projects, such
as the prevalence of "include" directories, and typical file-layout
stuff. If this isn't sufficient, you can subclass
`ede-cpp-root-project' and add your own tweaks in just a few lines.
See the end of this file for an example.
In the most basic case, add this to your `.emacs' file, modifying
appropriate bits as needed.
(ede-cpp-root-project "SOMENAME" :file "/dir/to/some/file")
Replace SOMENAME with whatever name you want, and the filename to an
actual file at the root of your project. It might be a Makefile, a
README file. Whatever. It doesn't matter. It's just a key to hang
the rest of EDE off of.
The most likely reason to create this project, is to speed up
searching for includes files, or to simplify bootstrapping Semantic's
ability to find files without much user interaction. In conjunction
with Semantic completion, having a short include path is key. You can
override the default include path and system include path like this:
(ede-cpp-root-project "NAME" :file "FILENAME"
:include-path '( "/include" "../include" "/c/include" )
:system-include-path '( "/usr/include/c++/3.2.2/" )
:spp-table '( ("MOOSE" . "")
("CONST" . "const") ) )
In this case each item in the include path list is searched. If the
directory starts with "/", then that expands to the project root
directory. If a directory does not start with "/", then it is relative
to the default-directory of the current buffer when the file name is
expanded.
The include path only affects C/C++ header files. Use the slot
`:header-match-regexp' to change it.
The `:system-include-path' allows you to specify full directory
names to include directories where system header files can be found.
These will be applied to files in this project only.
The `:spp-table' provides a list of project specific #define style
macros that are unique to this project, passed in to the compiler on
the command line, or are in special headers. See the
`semantic-lex-c-preprocessor-symbol-map' for more on how to format this
entry.
If there is a single file in your project, you can instead set the
`:spp-files' to a list of file names relative to the root of your
project. Specifying this is like setting the variable
`semantic-lex-c-preprocessor-symbol-file' in semantic.
If you want to override the file-finding tool with your own function
you can do this:
(ede-cpp-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
Where MYFCN is a symbol for a function. The locate function can be
used in place of `ede-expand-filename' so you can quickly customize
your custom target to use specialized local routines instead of the
default EDE routines. The function symbol must take two arguments:
NAME
The name of the file to find.
DIR
The directory root for this cpp-root project.
When creating a project with `ede-cpp-root', you can get additional
configurations via *note Project Local Variables::. Be aware that the
format for project local variables is an association list. You cannot
use `M-x ede-set' and have your project local variables persist between
sessions.
If the cpp-root project style is right for you, but you want a
dynamic loader, instead of hard-coding path name values in your
`.emacs', you can do that too, but you will need to write some lisp
code.
To do that, you need to add an entry to the
`ede-project-class-files' list, and also provide two functions to teach
EDE how to load your project pattern
It would look like this:
(defun MY-FILE-FOR-DIR (&optional dir)
"Return a full file name to the project file stored in DIR."
<write your code here, or return nil>
)
(defun MY-ROOT-FCN ()
"Return the root fcn for `default-directory'"
;; You might be able to use `ede-cpp-root-project-root'
;; and not write this at all.
)
(defun MY-LOAD (dir)
"Load a project of type `cpp-root' for the directory DIR.
Return nil if there isn't one."
;; Use your preferred construction method here.
(ede-cpp-root-project "NAME" :file (expand-file-name "FILE" dir)
:locate-fcn 'MYFCN)
)
(add-to-list 'ede-project-class-files
(ede-project-autoload "cpp-root"
:name "CPP ROOT"
:file 'ede-cpp-root
:proj-file 'MY-FILE-FOR-DIR
:proj-root 'MY-ROOT-FCN
:load-type 'MY-LOAD
:class-sym 'ede-cpp-root)
t)
This example only creates an auto-loader, and does not create a new
kind of project.
*Note ede-cpp-root-project::, for details about the class that
defines the `ede-cpp-root' project type.
File: ede.info, Node: ede-java-root, Next: ede-emacs, Prev: ede-cpp-root, Up: Simple projects
7.5.2 ede-java-root
-------------------
Much like the project type *note ede-cpp-root::, the java variant is
can be setup in your `.emacs' file and just marks a directory as the
root of a java source tree.
The `ede-java-root' project class knows a few things about Java
projects. In particular, you can use it to control your classpath at
both the system level, and for your project. If it is insufficient,
you can subclass `ede-java-root-project' and add your own tweaks in
just a few lines. See *note ede-cpp-root:: for an example using the
C++ variant.
In the most basic case, add this to your `.emacs' file, modifying
appropriate bits as needed.
(ede-java-root-project "SOMENAME" :file "/dir/to/some/file" :srcroot '("src"))
Replace SOMENAME with whatever name you want, and the filename to an
actual file at the root of your project. It might be a Makefile, a
README file. Whatever. It doesn't matter. It's just a key to hang
the rest of EDE off of.
Replace the value of :srcroot with a list of directories under the
project root which contains Java sources. For example, if you have:
~/myprojects/P1/
~/myprojects/P1/src/
~/myprojects/P1/src/com/ericsoft/MyCode.java
~/myprojects/P1/doc/
Then `src' represents the directory under which all your Java code
is. It is important that `src' is one step above the directory that is
the base of your package name, such as `com/ericsoft' in the example
above so that new files can be discovered via fully qualified name.
You can have multiple such directories in one project, and each will be
accessible.
You can specify your classpath like this:
(ede-java-root-project "NAME" :file "FILENAME"
:srcroot '("src")
:classpath '("/absolute/path.jar")
:localclasspath '( "/relative/path.jar" ))
In this example, `:classpath' specifies absolute paths somewhere on
your system, and the explicit jar or source root directories Semantic
will search when performing completions.
The `:localclasspath' is like `:classpath', but it will contain path
names relative to the root of your project.
If you want to override the file-finding tool with your own function
you can do this:
(ede-java-root-project "NAME" :file "FILENAME" :locate-fcn 'MYFCN)
Where MYFCN is a symbol for a function. The locate function can be
used in place of `ede-expand-filename' so you can quickly customize
your custom target to use specialized local routines instead of the
default EDE routines. The function symbol must take two arguments:
NAME
The name of the file to find.
DIR
The directory root for this java-root project.
If you would like to create your Java projects dynamically, instead
of putting them all in your `.emacs', you can do that too. See *note
ede-cpp-root:: for details that can be applied to this project type.
File: ede.info, Node: ede-emacs, Next: ede-linux, Prev: ede-java-root, Up: Simple projects
7.5.3 ede-emacs
---------------
The `ede-emacs' project automatically identifies an Emacs source tree,
and enables EDE project mode for it.
It pre-populates the C Preprocessor symbol map for correct parsing,
and has an optimized include file identification function.
File: ede.info, Node: ede-linux, Next: Custom Locate, Prev: ede-emacs, Up: Simple projects