Best Compiler Destination

Question

I've got a few languages I've been building as interpreters. When I'm ready to take "that next step", what options are best for non-native compiled formats... what are the pros and cons of each?

I've been looking at compiling to CLR or LLVM, and contemplated C-midcompile a few times, but I'm not completely certain.

A few features I'm hoping to be able to port are as follows:

1. REPL - One of the languages I'm building supports block-level evaluation during runtime.
2. Robust Macros - One of the languages I'm building requires the ability to filter through code seperately before tokenizing, and in the midstep between tokenizing and parsing.

Ok, not really "a few", just two. I like to think I can port any other features my languages support to "anything".

What are my best options, and their pros/cons?

Answer 1

Code generation is my business :-)

Comments on a few options:

• CLR:

  • Pro: industrial support
  • Con: you have to buy into their type system pretty much completely; depending on what you want to do with types, this may not matter
  • Con: Only Windows platform is really prime-time quality

• LLVM:

  • Pro: enthusiastic user community with charismatic leader
  • Pro: serious backing from Apple
  • Pro: many interesting performance improvements
  • Con: somewhat complex interface
  • Con: history of holes in the engineering; as LLVM matures expect the holes in the engineering to be plugged by adding to the complexity of the interface

• C--

  • Pro: target is an actual written language, not an API; you can easily inspect, debug, and edit your C-- code
  • Pro: design is reasonably mature and reasonably clean
  • Pro: supports accurate garbage collection
  • Pro: most users report it is very easy to use
  • Con: very small development team
  • Con: as of early 2009, supports only three hardware platforms (x86, PPC, ARM)
  • Con: does not ship with a garbage collector
  • Con: project has no future

• C as target language

  • Pro: looks easy
  • Con: nearly impossible to get decent performance
  • Con: will drive you nuts in the long run; ask the long line of people who have tried to compile Haskell, ML, Modula-3, Scheme and more using this technique. At some point every one of these people gave up and built their own native code generator.

Summary: anything except C is a reasonable choice. For the best combination of flexibility, quality, and expected longevity, I'd probably recommend LLVM.

Full disclosure: I am affiliated with the C-- project.