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
