Proparse directions

I imagine that the first priority is to add support for 10.1C syntax. I don't know if any Proparse users are adding 10.1C syntax to their applications anytime soon... this would be a good place for discussion.

Beyond that, there are a number of changes that I would like to make in terms of making Proparse easier to use, adding more features, and making it easier to maintain.

  1. Repackage the core secondary parser and library bits out of prorefactor.jar to create a proparse.jar.
  2. Make proparse.jar launchable as a background process listening on a tcp socket.
  3. Add scripting support on that socket, for accessing those libraries (accept a script, return results).
  4. Add a service on that socket which returns a BLOB for a compile unit.
  5. Create a new OO-ABL front-end to the parser, which uses the BLOB.

The last two are items that Jurjen and I have discussed offline. We believe that it should be possible to make a BLOB-based OO-ABL parser API which is easier to use (much easier to use!) and as fast or faster than the existing API.

Beyond that, another task I think is important is a conversion of Proparse from C++ (DLL) to Java. I believe that:

  • the conversion would not be a huge task
  • the parser in Java would be comparable in speed to the parser in C++
  • the parser in Java would be much easier to maintain and enhance
  • the parser in Java would remove a lot of existing overhead (time and trouble) in terms of porting the parser to various hardware and OS platforms

As with everything else, getting these tasks done are a matter of resources and priorities.

Any thoughts?

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.
john's picture

Proparse translation

I made a few points in my initial post about translation of Proparse from C++ to Java...

A few weeks ago I ran into a few issues with proparse.dll on different platforms, compiler issues, and a weird Java Native Interface bug. (A customer discovered an issue after compiling on Linux-64 as well.) Enough was enough! I started the translation to Java.

The translation was not a huge task. My estimate for the translation part of this task was six days, and that's about what it took. (Much of the syntax and semantics between C++ and Java are very close.)

It is already a dream to test, debug, and maintain in Java compared to the frustration of the C++ DLL.

Now I'll get to the interesting piece. I had predicted that the performance would be comparable. My first timed test runs seem to be indicating that in Java, Proparse is only about 15% slower than it was in C++! This is an excellent result, and I'm very happy with it. Fingers crossed that it's not just fast because it's missing something. :)

I'm still working on rewriting all my unit and regression tests to interface with Java Proparse rather than the old DLL API.

I also have to finish the integration with ProRefactor and Analyst (hooray! no more separate downloads of Proparse for Analyst!), and I'll also work on that proparse.jar idea to generate compile unit BLOBs.