1 / 20

Integration of BETA with Eclipse

This presentation explores the integration of BETA programming language with the Eclipse IDE, focusing on why Eclipse is increasingly popular among developers working with multiple languages. It discusses the advantages of a multi-language IDE, including reusability of existing tools and infrastructure across platforms. Key topics include interoperability requirements, BETA's adaptation to Eclipse through Java plug-ins, auto-indentation strategies, and the challenges of compiling BETA code to JVM bytecode. This session aims to demonstrate how BETA and Java can effectively coexist within the Eclipse environment.

geordi
Télécharger la présentation

Integration of BETA with Eclipse

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Integration of BETA with Eclipse eTX presentation Barcelona 2004 Peter Andersen Mads Brøgger Enevoldsen Ole Lehrmann Madsen mbe/pa/olm

  2. Powerful BETA IDE already available. - So why Eclipse? • Eclipse is gaining more and more users • Programmers use several languages • Easier if the same IDE • With language interoperability then a multi language IDE is a must • Use of existing infrastructure • Multiple platforms • Reuse of tools produced for other languages • Easier to maintain mbe/pa/olm

  3. Requirements • Plug-ins for BETA should be implemented in BETA • To reuse code from BETA IDE • BETA programmers use BETA • Eclipse plug-ins must be Java classes • Interoperability between BETA and Java is necessary mbe/pa/olm

  4. DefaultAutoIndentStrategy BetaAutoIndentStrategy Example: Add indent strategy • Implement class BetaAutoIndentStrategy inheriting from DefaultAutoIndentStrategy from the Eclipse library • Existing BETA code exists for analysing BETA source line and returning indentation level • Two different approaches: • Java Native Interface (JNI) interoperability • Compiling BETA to Java bytecodes in .class files mbe/pa/olm

  5. Java class: public class BetaAutoIndentStrategy extends DefaultAutoIndentStrategy { ... value = indentLine(lineNo); } CwrappedBETALibrary: int indentLineCB(int lineNo) { return indentLine(lineNo); } ? BETAIndentationLibrary: (# indentLine: (# lineNo: @integer; enter lineNo do ... #) #) JNIIndentWrapper: JNIEXPORT int JNICALL Java_BetaAutoIndentStrategy_indentLine (JNIEnv *env, jobject obj, int lineNo) { indentLineCB(lineNo); } JNI based BETA plug-in (complex!) native int indentLine(int lineNo); System.loadLibrary("JniIndentWrapper") Java code BETA code C code mbe/pa/olm

  6. JVM Based BETA Plugin • Alternative: Compile existing BETA code to Java bytecode • Write BetaAutoIndentStrategy in BETA, inheriting directly from Java DefaultAutoIndentStrategy • Requires mapping of BETA language to JVM using dedicated BETA compiler mbe/pa/olm

  7. BETA vs. Java • Class and method unified in pattern • General nesting of patterns, i.e. also of methods • INNER instead of super • Enter-Do-Exit semantics • Genericity in the form of virtual patterns • Multiple return values • Active objects in the form of Coroutines • No constructors • No dynamic exceptions mbe/pa/olm

  8. The mapping • Generating bytecode for JVM corresponds to making a BETA source mapping into Java source code • Challenges for the mapping: • Must be complete • Must be semantically correct • Must be “nice”, i.e. classes generated from BETA must be understandable for Java programmers. mbe/pa/olm

  9. Naive mapping into Java . Calculator: (# R: @integer; set: (# V: @integer enter V do V  R #); add: (# V: @integer enter V do R+V  R exit R #); #); Class Calculator extends Object { int R; void set(int V) { R = V; }; int add(int V) { R = R + V; return R;} } mbe/pa/olm

  10. Naive mapping into Java .. C: @Calculator; X: @integer; 12  C.set; 5  C.add  X Calculator C = new Calculator(); int X; C.set(12); X = C.add(5); mbe/pa/olm

  11. Instances of add • More complex mapping needed • Possible to create instances of pattern add Calculator: (# R: @integer; … add: (# V: @integer enter V do R+V  R exit R #); #); C: @Calculator; X: @integer; A: ^C.add; &C.add[]  A[]; 6  A  X Creation of an instance of C.add Execution of the C.add instance mbe/pa/olm

  12. Inner class add Class Calculator extends Object { int R; class add extends Object{ … } … } Class Calculator extends Object { int R; class add extends Object{ int V; void Enter(int a) { V = a; } void Do() { R = R + V }; int Exit() { return R; } } … } Class Calculator extends Object { int R; class add extends Object{ int V; void Enter(int a) { V = a; } void Do() { R = R + V }; int Exit() { return R; } } int add(int V){ … } … } Class Calculator extends Object { int R; class add extends Object{ int V; void Enter(int a) { V = a; } void Do() { R = R + V }; int Exit() { return R; } } int add(int V){ add A = new add(); A.Enter(V); A.Do(); return A.Exit(); } … } Calculator: (# R: @integer; … add: (# V: @integer enter V do R+V  R exit R #); #); mbe/pa/olm

  13. Use of add as a class: C: @Calculator; X: @integer; A: ^C.add; &C.add[]  A[]; 5  A  X Calculator C = new Calculator() int X; Calculator.add A; A = C.new add(); A.Enter(5); A.Do() X = A.Exit(); mbe/pa/olm

  14. Use of add as a method C: @Calculator; X: @integer; 5  C.add  X Calculator C = new Calculator() int X; X = C.add(5); mbe/pa/olm

  15. Not described here… • Innercall mechanism – implemented by declaring new methods at each inheritance level • Virtual classes – corresponding to generics (Java 1.5) – implemented with virtual instantiation methods and a lot of casting • Coroutines and concurrency – implemented with threads • Pattern variables: Classes and methods as first-class values – implemented with reflection • Leave/restartout of nested method activations – implemented with exceptions • Multiple return values– implemented with extra fields • Use of external classes and interfaces • Numerous minor details! mbe/pa/olm

  16. BETA pattern: BetaAutoIndentStrategy: DefaultAutoIndentStrategy (# do … lineNo -> indentLine -> value; #) BETAIndentationLibrary: (# indentLine: (# lineNo: @integer; enter lineNo do ... #) #) JVM Based Structure Eclipse plug-in code now written directly in BETA mbe/pa/olm

  17. Debugger Integration • Existing BETA debugger hard to port to Eclipse • Since we compile to JVM, perhaps use Eclipse JDT debugger for Java? • Turns out to work!  • After some pain…  mbe/pa/olm

  18. Demo mbe/pa/olm

  19. Evaluation • Two approaches for Eclipse plug-in writing using non-Java language: • JNI: possible, but complex and error-prone • JVM: Elegant, but hard work to compile your language to JVM. Allows for JDT reuse. • Problems with our JVM solution: • JVM code is slow, we have not yet looked at optimizations • BETA developers want to build native applications, but have to debug via JVM target. mbe/pa/olm

  20. Questions? Contacts: • Mads Brøgger Enevoldsen mailto:brogger@daimi.au.dk • Peter Andersen mailto:datpete@daimi.au.dk • Ole Lehrmann Madsen mailto:olm@daimi.au.dk • Download: http://www.daimi.au.dk/~beta/eclipse http://www.daimi.au.dk/~beta/ooli mbe/pa/olm

More Related