More precisely stated, the problem is to write a source program that, when compiled and executed, will produce as output an exact copy of its source. If you have never done this, I urge you to try it on your own. The discovery of how to do it is a revelation that far surpasses any benefit obtained by being told how to do it.

I’ve never tried to code such a thing, so I put my shoulder to the wheel and try this exercise in python. After a few minutes, I got this solution. It’s not the shortest (especially considering it reproduces the shebang and the coding lines), but it works. As Mr. Thomson says, it’s a very interesting exercise. Here’s the code:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
data = ['#!/usr/bin/env python', '# -*- coding: utf-8 -*-',
        "for x in data[:2]:", "    print x",
        "print 'data = ', data", "for x in data[2:]:", "    print x"]
for x in data[:2]:
    print x
print 'data = ', data
for x in data[2:]:
    print x

Save it as prog1.py, and then execute python prog1.py.
Even better, try python prog1.py > prog2.py and then python prog2.py > prog3.py and so on.

I, on my behalf, have something else to celebrate: I’ve eventually released 1.0 version of the ZX Spectrum BASIC compiler. You can download it and give it a try, if interested.

If you’re having troubles either installing or using it, or suspect of a bug, please ask for help at the forum.

My favorite subjects are, yes, you guess it, Parallel computing and Computer languages (Compilers, Language processors, etc…)

I’m currently programming a ZX Spectrum BASIC cross compiler in my (little) spare time. It’s entirely written in python, and almost finished (hope to release V1.0 this month). It’s a three stage retargeable compiler. The backend outputs Z80 code, so it should be easily portable to other Z80 micros such as AMSTRAD or MSX. Porting to other architectures, or even to .NET or Java it’s also possible by changing the backend module could also be implemented.

Regarding to the language, It’s not the ZX Spectrum original BASIC but a dialect very close to FreeBasic which allows function definitions and more complex control-flow structures. The URL contains an almost complete specification, although not all of them has been implemented in the ZX for obvious reasons.

Some features:

• Function definitions with local variable scopes and parameters by reference or value
• Multidimensional arrays of any data type
• Strings passed by value or reference
• Dynamic memory heap
• Inline ASM code
• Completely extensible with your own functions

You can download current alpha builds or visit the forum for suggestions, comments, etc.

Update: I’ve just finished it! Visit the compiler page for more information.

Previously, OpenMP support was done in GCC though the use of GOMP (an OpenMP library), but it has been finally merged into the developing mainline of this compiler collection (yes, Fortran have it too).

The specification implemented is OpenMP 2.5 (there’s a 3.0 draft on the way), and it seems to be completely supported, as you might read at the GCC Open MP features document.

I’ve put it in my wiki, just in case anybody want to give it a glance.

My tool is better than the LEX & YACC couple in the sense it can parse LR(n) grammars whilst LEX/Yacc only parses LALR ones. It uses a Lookahead and mangle-likes estructures to take some decisions when choosing which grammar rule to use for reduction.

If it eventually cannot decide which rule should be used, it will start to backtrack to find out the rule to apply.

This tool allows ambiguos grammars, so it is very similar to a GLR parser. BISON (GNU’s YACC) can also use the GLR algorithm, but it is less efficient and can take exponential space/time to parse some entries depending on the given grammar.

The calculator example

The calculator example is the “Hello World” of parsers generators. Below there is an calculator definition for mathematical expresions. Simply run the program and enter a mathematic expression like 1+3.2*5^2 and the program will output the result to the screen (with some explanation about rules used). The program will finish when you enter an empty input.

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys

from bparser import Token
from bparser import Symbol
from bparser import Bparser

class Calc(Bparser):
	def minus_factor(self, symbol, l):
		symbol.value = -l[1].value
		return symbol
	
	def term_mul_term(self, symbol, l):
		symbol.value = l[0].value * l[2].value
		return symbol
	
	def term_div_term(self, symbol, l):
		symbol.value = l[0].value / l[2].value
		return symbol
	
	def term_plus_term(self, symbol, l):
		symbol.value = l[0].value + l[2].value
		return symbol
	
	def term_minus_term(self, symbol, l):
		symbol.value = l[0].value - l[2].value	
		return symbol
	
	def term_pow_term(self, symbol, l):
		symbol.value = l[0].value ** l[2].value
		return symbol
	
	def print_result(self, symbol, l):
		print 'Result is', l[0].value
		return symbol
	
	def lprp_action(self, symbol, l):
		symbol.value = l[1].value
		return symbol

	def default_hook(self, symbol, l):
		symbol.value = l[0].value
	
		print symbol.name, '-->', [x.name for x in l]
		print 'ValueOf(%s) = ' % symbol.name, symbol.value 
	
		return symbol

calc = Calc()

calc.add_token(r'[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?', 'NUMBER')
calc.add_tokens({r'\+': 'PLUS', r'\-': 'MINUS', r'\*': 'MUL', '/': 'DIV', '%': 'MOD', r'\^':'POW'})
calc.add_tokens({r'\(': 'LP', r'\)': 'RP'}) # Escape PARENTHESIS in Regular Expressions
calc.add_token('[ \t\n]+', ('SEPARATOR', Token.skip))

calc.parse_rule('%LEFT (PLUS, MINUS)')
calc.parse_rule('%LEFT (MUL, DIV)')
calc.parse_rule('%RIGHT (POW)')
calc.parse_rule('Program --> expr .print_result')

calc.parse_rule('expr --> term')

calc.parse_rule('term --> term PLUS term .term_plus_term')
calc.parse_rule('term --> term MINUS term .term_minus_term')
calc.parse_rule('term --> term MUL term .term_mul_term')
calc.parse_rule('term --> term DIV term .term_minus_term')
calc.parse_rule('term --> term POW term .term_pow_term')

calc.parse_rule('term --> value')
calc.parse_rule('value --> LP expr RP .lprp_action')
calc.parse_rule('value --> NUMBER')
calc.parse_rule('value --> MINUS NUMBER .minus_factor')


if __name__ == '__main__':
	while True:
		input = sys.stdin.readline().strip()
		if input == '': break
	
		calc.set_buffer(input)
		calc.verbose = False
		calc.start()
		calc.storage.pow_level = []
	
		if calc.parse():
			calc.verbose = True
			calc.mimic()
		else:
			print "Syntax Error."

I’m using this tool in the ZX Spectrum BASIC Compiler, that will serve as a test-language for this tool.