Stefan Matthias Aust sma

Ein Twitter-Clone mit Redis

Angenommen, wir wollen ein System modellieren, bei dem User kurze Informationsschnipsel (Posts) an einen Server schicken können, der diese an alle User verteilt, die vorher angegeben haben, besagten Users zu folgen.

Der Redis-Treiber über Python heißt redis und wird so importiert und initialisiert. In der globalen Variable r halte ich eine persistente Datenbank-Verbindung, die ich in allen weiteren Funktionen benutzen werde:

import redis
r = redis.Redis(db=1)

Ein Python-Interpreter

Dieser Text beschreibt theoretische Überlegungen, Python-Programme in Java zu präsentieren, um sie dann auszuführen. Auf welche Weise der Python-Quelltext übersetzt wird, ist nicht wichtig, nur das man zu jedem Python-Teilprogramm eindeutig ein Exemplar einer Java-Klasse zuordnen kann. Um den syntaktischen Ballast von Java zu reduzieren, lasse ich, wo nicht weiter wichtig, alle Sichtbarkeitsmodifikatoren und die offensichtlichen Konstruktoren zur Initialisierung der aufgeführten Exemplarvariablen weg.

Ich übersetze ein Python-Programm in zwei Arten von AST-Knoten:

abstract class Stmt {
    abstract void exec(Frame f);
}

Neulich habe ich gezeigt, wie ein Python-Interpreter in Java aussehen könnte, der entweder als rekursiver AST-Interpreter für einen als Java-Objekte vorliegenden abstrakten Syntaxbaum (AST) oder als virtuelle Maschine für einen aus dem abstrakten Syntaxbaum abgeleiteten Maschinencode realisiert ist.

Heute möchte ich zeigen, wie man ein Python-Programm in einen AST übersetzen kann. Dies mache ich in Python. Dann kann sich das Programm selbst in einen AST übersetzen und wenn ich aus dem AST -- ebenfalls in Python -- einen Maschinencode erzeuge, brauche ich "nur noch" einen Interpreter für die virtuelle Maschine in der Zielsprache (z.B. Java) und habe dann einen vollständigen Python-Interpreter.

So der Plan.

Zerlegen in Wörter

Der Übersetzer, der aus einem Python-Programm einen AST erzeugt, geht in zwei Schnitten vor. Zuerst soll das als String vorliegende Programm in Wörter (sogenannte Token) erlegt werden. Dann analysiere ich die Liste der Token von links nach rechts mit Hilfe eines reku

[Factor][http://factorcode.org/] ist eine Forth-artige Programmiersprache, die konkatenativ ist, d.h. man reiht Befehlswörter aneinander, die Daten auf einem Stack verarbeiten. Im Gegensatz zum klassischen sehr maschinennahen Forth unterstützt Factor (wie das Vorbild Joy) funktionale Programmierung und bietet außerdem objektorientierte Programmierung (die von CLOS, dem CommonLisp-Objektsystem, abgeschaut ist).

Das Beispiel

Factor-Programme bestehen aus Wörtern, die durch Leerzeichen getrennt sind:

3 4  + .

Dies addiert (+) die Zahlen 3 und 4 und gibt das Ergebnis mittels (.) aus. Zahlen werden nacheinander auf einen Daten-Stack geschrieben, von dem sich das + seine beiden Operanden holt und auf den es wieder das Ergebnis schreibt. Auch das . holt sich von dort ein Argument.

	#!/usr/bin/env python2.6

	"""
	Convert JSON data to human-readable form.

	Usage:
	prettyjson [inputFile [outputFile]]
	"""

	import json, sys

	import re

	def parse(s):
	next = iter(re.findall(ur'-?\d+\|"(?:\\["\\/bfnrt]\|\\u[0-9a-fA-F]{4}\|[^"])*"\|[{}\[\]:,]\|true\|false\|null', s)).next

	def parse_value(t):
	if t[0] in "-0123456789":
	return int(t)
	if t[0] == '"':
	return t[1:-1].decode("unicode-escape")

	from operator import add, sub, mul, truediv as div

	operations = {"+": add, "-": sub, "*": mul, "/": div}

	stack = []

	def upn(line):
	for token in line.split():
	if token in operations:
	b, a = stack.pop(), stack.pop()

	package ingwer;

	import org.springframework.expression.*;
	import org.springframework.expression.spel.standard.SpelExpressionParser;
	import org.springframework.expression.spel.support.StandardEvaluationContext;
	import java.io.*;
	import java.util.*;
	import java.util.regex.*;

	public class Ingwer {

	<!DOCTYPE html>
	<html>
	<head>
	<script src="jquery-1.4.js" type="text/javascript" charset="utf-8"></script>
	</head>
	<body>
	<h1>Template Engine</h1>
	<div id="text"></div>

	<script type="text/tmpl" name="t" charset="utf-8">

	# need UTF-8 mode for active support
	$KCODE = "utf8"

	require 'active_support/multibyte'

	# monkey patch class to strip diacritics from IDs
	module MaRuKu
	class MDElement
	def generate_id
	name = children_to_s.strip