Re: How-to evaluate Java-snippets in org-mode/org-babel?

[Torsten Wagner <torsten.wagner@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 6754 bytes --]

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...

#+begin_src java classname packagename/classname

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

[-- Attachment #2: Type: text/html, Size: 9406 bytes --]