Sorry took me a while to test it.
It works great !!!!
Many many thanks for your help.
I found two minor things.
My snippets contain the definition of a package, which in turn end to be a folder. The tangle function could create folders on demand. Would be useful for your code too. It works already by creating the folder manually and simply write...
in the next step, people might use sessions as equivalent to a package. This would allow to define multiple classes and the usage of them within a single execution.
However for now its perfect already. Why not putting it into ob-java.el and see how its develope.
Totti
On Jul 16, 2011 12:37 AM, "Eric Schulte" <
schulte.eric@gmail.com> wrote:
> Hi Torsten,
>
> I've just written the included emacs-lisp function [1], which when added
> to your config should provide for minimal evaluation functionality for
> java code blocks.
>
> This function drops the body of a code block to a file named after the
> value of the :classname header argument (since java cares about file
> names), it then compiles the file with javac, and executes the resulting
> executable returning the results. See the attached Org-mode file [2]
> which evaluates successfully on my system (after I installed javac).
>
> I copied the code example and compilation process from [3].
>
> Please let me know how this works for you, hopefully once we iron out
> the kinks in this function it can serve as the seed for a full java
> mode.
>
> Cheers -- Eric
>
> Torsten Wagner <
torsten.wagner@gmail.com> writes:
>
>> Hi Eric,
>>
>>> You probably don't want to pass the body of a code block to a lisp
>>> function as quoting will become a nightmare, however passing the name to
>>> a lisp block may be reasonable.
>>>
>>> I would suggest that rather than implementing this behavior in a code
>>> block you take a look at starting a ob-java.el file. A partial
>>> implementation (e.g., only external evaluation, no session evaluation)
>>> would be a useful contribution, and given the many helper functions and
>>> examples present in the other ob-* files this would most likely be
>>> easier than a custom lisp-block implementation.
>>
>> o.k. the first round of evaluations is over and it worked out
>> o.k. However, there was still rather much handwork to do.
>> I tried to get a ob-java.el file together using the template and
>> mainly by looking at ob-c.el which I guess comes close what would have
>> to be done for java.
>> However, my lisp-skills (which are close to zero) are not enough to
>> get it working. The main problem was that ob-c.el is working for both
>> C and C++ and all this if then else troubles me a bit.
>>
>> Basically, I want only tangle the actual code block into a temp
>> file. Well temp is not really right, since java demand its file
>> structure and file naming. Finally execute it externally by your
>> proposed code
>>
>> javac -cp . mypackage/myclass.java
>> java -cp . mypackage.myclass
>>
>> and return the results
>>
>> Hmm maybe better to give a real world example (stripped down to make
>> it shorter)
>> I use now the following way
>> /-----------------------------------------------/
>> #+BABEL: :mkdirp t
>>
>> * Coursework 1
>> ** StudentID1
>> #+BEGIN_SRC java
>> package foo;
>> public class Bar
>> {
>> private double ans = 0
>> public void set(double d){
>> ans = d;
>> }
>> public void print(){
>> System.out.println(ans);
>> }
>> public static void main(String[] argv){
>> Bar c = new Bar();
>> c.set(100);
>> c.print();
>> }
>> }
>> #+end_src
>>
>> ** StudentID2
>> #+BEGIN_SRC java
>> package foo;
>> public class Bar
>> {
>> private double x = 0
>> public void set(double in){
>> x = in;
>> }
>> public void print(){
>> System.out.println(x);
>> }
>> public static void main(String[] argv){
>> Bar myclass = new Bar();
>> myclass.set(100);
>> myclass.print();
>> }
>> }
>> #+end_src
>>
>> ** Result
>> #+srcname: result
>> #+begin_src sh :results output
>> javac -cp . foo/Bar.java
>> java -cp . foo.Bar
>> #+end_src
>>
>> /----------------------------------------------------/
>>
>>
>> For now I only added the tangle command to a single code block and
>> created the file via C-c C-v t.
>>
>> #+BEGIN_SRC java tangle: foo/Bar.java
>>
>> Then I rushed down to a shell block "result" which executed the the
>> above commands. I checked the results and started to remove the tangle
>> object from one block and added it to the next block. Kind of tiring
>> if you have several dozen of blocks.
>> Guess you can see from the above example the trouble of having several
>> dozen of them and then tangeling them one by one and execute the
>> result block ;)
>>
>> I tried to make it more easy by giving the shell block a name and call
>> it under each java code block. This would save me the time going up
>> and down in my file.
>>
>> #+call: result()
>>
>> However, I noticed that the result update was always done at the first
>> appearances of the call , like under the first java code block but not
>> at the desired code block?!
>> if you fold all together it would look like
>>
>> /-----------------------------------------------/
>> #+BABEL: :mkdirp t
>>
>> * Coursework 1
>> ** StudentID1
>> #+BEGIN_SRC java
>> #+call: result()
>>
>> #+results: result
>> : 100.0
>>
>> ** StudentID2
>> #+BEGIN_SRC java :tangle foo/Bar.java
>> #+call: result()
>>
>> ** Result
>> #+srcname: result
>> /-----------------------------------------------/
>>
>> Calling the second call function updates the result on the first!
>>
>> Anyhow, I guess having it working with a ob-java.el minimal system
>> would be the most easiest. Simply type C-c C-c and it would be done.
>>
>> Would be very glad if you could help me to get this somehow working.
>>
>> Totti
>>
>>
>
>
> Footnotes:
> [1]
> #+begin_src emacs-lisp
> (defun org-babel-execute:java (body params)
> (let* ((classname (or (cdr (assoc :classname params))
> (error
> "Can't compile a java block without a classname")))
> (src-file (concat classname ".java"))
> (full-body (org-babel-expand-body:generic body params))
> (compile
> (progn (with-temp-file src-file (insert full-body))
> (org-babel-eval (concat "javac " src-file) ""))))
> ((lambda (results)
> (org-babel-reassemble-table
> (if (member "vector" (cdr (assoc :result-params params)))
> (let ((tmp-file (org-babel-temp-file "c-")))
> (with-temp-file tmp-file (insert results))
> (org-babel-import-elisp-from-file tmp-file))
> (org-babel-read results))
> (org-babel-pick-name
> (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
> (org-babel-pick-name
> (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
> (org-babel-eval (concat "java " classname) ""))))
> #+end_src
>
> [2]
hello-java.org