You might also be interested in HTML::Template::JIT. It's a just-in-time compiler that generates C code from HTML::Template templates. It uses Inline::C to compile the C code on the fly. The result is the fastest templating system known to (this) man.

-sam

It is a dream, and a wonderful challenge. Back in the early days (I am 50 now) in mid-1974 I heard about the Intel 8080 and set about acquiring a chip. In the meantime, from the early Intel documents I wrote a cross assembler to produce code for it on an Interdata 70 mini.

Go and find some books on compiler design and get into it!

My current favourite hobby project is replicating the Interdata using an Altera EPF10K250A EPLD device. It is about 95% functional, we are just finishing the interface to an original 8k word core memory plane. Using static memory with battery keep-alive we have been able to run our 1974 8080 cross-assembler and produce runnable code that executed on an 8080 emulator.

It may not be efficient, but projects like this are great learning tools. Good luck and have lots of fun!

jdtoronto

I'm currently embarking on a similar twisted path, by creating a parser/compiler for Javascript. It is actually easy to do with the tools that Perl provides, as long as you're not afraid to use Parse::Yapp, a yacc for Perl.

A yacc grammar for C should be found in every corner, the rest is where the fun is...

perl -MHTTP::Daemon -MHTTP::Response -MLWP::Simple -e ' ;    # The  
$d = new HTTP::Daemon and fork and getprint $d->url and exit;#spider
($c = $d->accept())->get_request(); $c->send_response( new   #in the
HTTP::Response(200,$_,$_,qq(Just another Perl hacker\n))); ' #  web
[download]

But since you can eval C-code at runtime, that shouldn't be too hard a feat to do yourself.

Liz

Take a class in compiler construction.

If you want to do this the insane twisted way, start by writing a C => Perl translator and running gcc through it. The result will be a horrific mess (though if your translator is right it should actually work, albeit quite inefficiently), which you can then proceed to attempt to clean up by hand, a little at a time. The disadvantages of this approach should be obvious; the advantage is that, although your compiler will be slow, its output will be just fine.

Doing a project like this will not only teach you a lot, it will also get you a lot of strange looks when you tell people about it.

$;=sub{$/};@;=map{my($a,$b)=($_,$;);$;=sub{$a.$b->()}}
split//,".rekcah lreP rehtona tsuJ";$\=$ ;->();print$/
[download]

No, sick and twisted would be if he wanted to implement a C interpreter in Unlambda or PostScript. Implementing it in Perl is actually fairly sensible.

---

$;=sub{$/};@;=map{my($a,$b)=($_,$;);$;=sub{$a.$b->()}}
split//,".rekcah lreP rehtona tsuJ";$\=$ ;->();print$/
[download]

(Maybe someone should translate TeX to PostScript, then you could just send TeX input to a PostScript printer, and it would do all the work of typesetting.)

Abigail

The knowledge that comes with writing a compiler seems to be a very useful result. Having a compiler written in a very high level language that allows more people to understand how compilers work seems like a very useful result. Starting a possibly successful large-scale project in Perl seems like a very useful result.

Discouraging someone from doing something useful doesn't seem like a very useful result. So what's the point of your comment?

So why not write a Java compiler? Or a brainfuck compiler? There are easier ways to learn about writing compilers. Writing yet another C compiler doesn't seem that useful even if you learn something about writing compilers. You want to see a compiler written in a high level language take a look at D.

I agree completely. I've been toying off and on (lately on) with my own language that has a syntax between Perl and Lisp. It has scalars, lists and hashes.

Writing the parser has been quite challenging. Figuring out how to create the parse tree, optimize it (constant folding, etc) has been good for keeping my skills sharp and looking at problems in a different light.

Sure I could have started with a book on compilers and read up on lex and yacc, but solving it from the ground up, in my mind, has taught me a lot more than just following some book. Not to say there is anything wrong with that. When I get it to a more stable state, I'll probably do exactly that. Go back and see what was done right and what things I didn' figure out.

-Lee

"To be civilized is to deny one's nature."

A potential benefit could be that a C-compiler isn't necessary to compile Perl's C modules (kind of Escherlike, eh?). But of course there are freely available C compilers for most platforms (I had temporarily forgotten about the beauty of Cygwin), so oh well...

How come? Parrot seems to be a runtime environment targeted at dynamic languages. C is a lot, but it's not dynamic, it's quite static.

Abigail

well, you're right, but parrot already have a BASICcompiler/interpreter, so why not C.
--
dominix

But I'm thinking, how you will handle alredy compiled codes, specially libraries? C is used not only because it can be compiled in any OS, but because we can use a lot of libraries/includes that are already done and because it can work directly with the OS, soo we can do anything with it. (and you will need to rewrite a lot of code... Argh!)

But I understand that for now your idea has an educational purpose, and I give you the best luck with it. Maybe we will have the 1st real C interpreted (not a fake C ok!). ;-P

About Parrot, take a look, we can do anything with it (or will), since it has an great architecture and it's a really good VM.

http://www.parrotcode.org/ (Get involved!)

And don't forget that one of the plans of Parrot is to can convert a code to another through Parrot Assembly Code. Soo, from a C code I can automatically convert it to Perl, Java, etc... Or from Perl to C!

Thinking now, adding a C interpreted to Parrot will open an option to can automatically convert Perl codes to C and then use this to compile it as a normal C code. But this will only be possible if you keep your C interpreter compatible with gcc definitions!

Did you have a look at them? They have nothing to do with building a C compiler!

-sam

Yes I have not only looked at but also used them.