CEDET

Hi Dave,

EDE uses a series of classes and method to define behavior.  You can 
tackle the project of getting Build/Debug menus working for the 
ede-cpp-root project type in two ways:

1) subclass ede-cpp-root, and create a new project type with the 
features you want.

or 2) Design a way for ede-cpp-root to support what you like and 
implement that.  To do this, the FSF will need a release for any 
software you write.

As for the specifics, if you use:

C-h v ede-project RET

You will see a bunch of abstract (sort of) methods called "project-*", 
including a project-compile-project.  For:

C-h v ede-target RET

you will see project-compile-target (and debug).

If ede-cpp-root (or a subclass) were to implement these, they would be 
hooked into the menu item, and run that code.

Good Luck
Eric

Dave Milter wrote:
> Hello,
> 
> ordinary to force competitions works I used
> ede-cpp-root-project.
> 
> (ede-cpp-root-project "test1"
>                             :file "/home/dave/projects/test1/Makefile"
>                             :include-path '("/home/dave/projects/test1")
>                             :system-include-path '("/usr/include"
> "/usr/include/qt4"
> "/usr/lib/gcc/i686-pc-linux-gnu/4.3.2/include/g++-v4"))
> 
> 
> that's works, great.
> 
> But I want also build and test application. I thought I already wrote
> full description of my project,
> can I reuse it?
> 
> And I wrote such code:
> 
> (setq test1-prj (ede-cpp-root-project "test1"
>                             :file "/home/dave/projects/test1/Makefile"
>                             :include-path '("/home/dave/projects/test1")
>                             :system-include-path '("/usr/include"
> "/usr/include/qt4"
> "/usr/lib/gcc/i686-pc-linux-gnu/4.3.2/include/g++-v4")))
> 
> (setq path-to-makefiles (make-hash-table :test 'eq))
> (puthash test1-prj "make -k -C /home/dave/projects/test1" path-to-makefiles)
> 
> (defun my-compile ()
> 	"compilation using ede projects"
> 	(interactive)
> 	(setq current-dir (file-name-directory (buffer-file-name (current-buffer))))
> 	(setq prj (ede-current-project current-dir))
> 	(when prj
> 		(setq make-cmd (gethash prj path-to-makefiles))
> 		(save-buffer)
> 		(save-some-buffers)
> 		(compile (format "%s"  make-cmd))
> 		)
> )
> 
> In similar way I implement my-debug.
> 
> But once upon a time I saw the menu items: like build, debug and so on.
> 
> So I wonder, can I reuse this menu items, any hints?
> 
> Also I should say that project types like makefile or something like that not
> for me, because of I want modify Makefile by myself, and not allow to elisp code
> touch it.
> 
> ------------------------------------------------------------------------------
> This SF.Net email is sponsored by the Verizon Developer Community
> Take advantage of Verizon's best-in-class app development support
> A streamlined, 14 day to market process makes app distribution fast and easy
> Join now and get one step closer to millions of Verizon customers
> http://p.sf.net/sfu/verizon-dev2dev 
> _______________________________________________
> cedet-semantic mailing list
> cedet-semantic@...
> https://lists.sourceforge.net/lists/listinfo/cedet-semantic
>

On Sat, Jan 16, 2010 at 6:22 AM, Eric M. Ludlam <eric@...> wrote:
> Hi Dave,
>
> EDE uses a series of classes and method to define behavior.  You can tackle
> the project of getting Build/Debug menus working for the ede-cpp-root
> project type in two ways:
>
> 1) subclass ede-cpp-root, and create a new project type with the features
> you want.
>
> or 2) Design a way for ede-cpp-root to support what you like and implement
> that.  To do this, the FSF will need a release for any software you write.
>
> As for the specifics, if you use:
>
> C-h v ede-project RET
>
> You will see a bunch of abstract (sort of) methods called "project-*",
> including a project-compile-project.  For:
>
> C-h v ede-target RET
>
> you will see project-compile-target (and debug).
>
> If ede-cpp-root (or a subclass) were to implement these, they would be
> hooked into the menu item, and run that code.
>

Thanks, for answer.
So I wrote:
(defclass my-ede-cpp-root-project (ede-cpp-root-project eieio-instance-tracker)
  (
   (custom_build_cmd :initarg :custom_build_cmd
                     :initform ""
                     :type string
                     :custom string
                     :documentation "Set this field to shell command
for build your project")
   )
  "My class for ede projects"
  :method-invocation-order :depth-first
  )

(defmethod project-compile-project ((obj my-ede-cpp-root-project)
&optional command)
  ;;  (message "compile %s cmd %s" (object-name obj) (oref obj
custom_build_cmd))
  (compile (oref obj custom_build_cmd))
  )


and thats works as expected,
now I want to add "debug" ability.
As I see from source code, and your email I need redefine project-debug-target.

(defclass my-ede-target (ede-target)
  ()
  "My class for ede targets"
  )

(defmethod project-debug-target ((obj my-ede-target))
  (message "Implement me")
  )

But, how can I tell ede that from targets of my-ede-cpp-root-project project
it should create objects of my-ede-target?

I mean how I connect my-ede-target and my-ede-cpp-root-project?

On 02/10/2010 07:05 AM, Dave Milter wrote:
> On Sat, Jan 16, 2010 at 6:22 AM, Eric M. Ludlam<eric@...>  wrote:
>> As for the specifics, if you use:
>>
>> C-h v ede-project RET
>>
>> You will see a bunch of abstract (sort of) methods called "project-*",
>> including a project-compile-project.  For:
>>
>> C-h v ede-target RET
>>
>> you will see project-compile-target (and debug).
>>
>> If ede-cpp-root (or a subclass) were to implement these, they would be
>> hooked into the menu item, and run that code.
>>
>
> Thanks, for answer.
> So I wrote:
> (defclass my-ede-cpp-root-project (ede-cpp-root-project eieio-instance-tracker)
>    (
>     (custom_build_cmd :initarg :custom_build_cmd
>                       :initform ""
>                       :type string
>                       :custom string
>                       :documentation "Set this field to shell command
> for build your project")
>     )
>    "My class for ede projects"
>    :method-invocation-order :depth-first
>    )
>
> (defmethod project-compile-project ((obj my-ede-cpp-root-project)
> &optional command)
>    ;;  (message "compile %s cmd %s" (object-name obj) (oref obj
> custom_build_cmd))
>    (compile (oref obj custom_build_cmd))
>    )

Good News.


> and thats works as expected,
> now I want to add "debug" ability.
> As I see from source code, and your email I need redefine project-debug-target.
>
> (defclass my-ede-target (ede-target)
>    ()
>    "My class for ede targets"
>    )
>
> (defmethod project-debug-target ((obj my-ede-target))
>    (message "Implement me")
>    )
>
> But, how can I tell ede that from targets of my-ede-cpp-root-project project
> it should create objects of my-ede-target?
>
> I mean how I connect my-ede-target and my-ede-cpp-root-project?

There is already a ede-cpp-root-target class, so you can create a method 
for that, since there is no default.  The funny thing about 
ede-cpp-root, is it just tries to put a thin wrapper over what is more 
likely a complex bit of code, so the 'target' is just a bit of a guess, 
but it will give you the hook needed to do what you want.


Eric