Sammelsurium

Contents 2008-01

About Programming Languages and Converters

There exists so much source code, but unfortunately not always in a really usable language. That's why I'm trying to write code converters and other tools for lowering the language boundaries. Currently my favorite language is Object Pascal Language (Delphi...), and I'm working on a C to Pascal converter. In former times I've been writing much code in GFA Basic, and a converter to OPL is already available.

C to Pascal

Since some time I'm trying to port GNU and other open source projects to Windows, with many problems and little success. That's why I started to write an really useful C to Pascal converter, which shall allow not only for a literal code translation (think C, write Pascal), but which also shall support the reengineering of poorly structured and auto-bloated C projects.

After some investigations and experiments now I can present an working scanner and simple parser for C source and header files, written in Pascal. Sample applications for the CScan library include an C preprocessor and an converter for C header files into Pascal (OPL). While I'm concentrating on the extension of the core library into an cross compiler, everybody is invited to write and contribute further applications and tools around that library. You can download the source code and documentation of the WinToPas library and sample applications and use it in your own non-commercial projects. Some documentation is also available, sorry for the complicated download.

Cross Compiler

A cross compiler translates code from a source language into another target language. Consequently a general cross compiler uses an synthetic meta language to describe the given code, and any number of input and output modules which transform from and to language specific code. For most languages a mix of Basic, C and Pascal gives a usable meta language, with a common set of data types and control structures. Most incompatibilities between real programming languages exist in the runtime and I/O system (standard libraries), so that also a general library for the translation of such services has to be implemented. For such a library I found classes quite useful, which implement the functionality in a base class and the interface to specific languages in derived classes. Only the basic functionality has to be implemented explicitly for every target language (runtime system), the remaining functions are wrappers around these functions which can be translated easily into the target languages. The target languages must not necessarily include classes, an automatic translation of the methods into ordinary functions is possible without major complications.

In the first step a number of input modules shall be implemented, which convert a given source into the internal representation. Such modules exist already, but mostly for binary sources (objects, libraries, executables) which have a simple common structure. Input modules for source code are harder to implement, depending on the syntax and semantics of the specific programming language. Much code can be taken from open source compilers, but unfortunately many of these compilers are written in the source language, so that no automatic translation of that code is possible in this step.

In further steps output modules will be added, with a source code generator for OPL in the first place. At the same time the cross compiler machine will be continuously improved, with analyzation and transformation capabilities, and with more support for the input and output modules.

Currently I have to merge several existing decompiler and cross compiler projects, in order to create a commonly usable cross compiler machine. That's why no source code is available yet, but feel free to tell me your urgent needs, perhaps one of my older projects will be helpful to you.

Für Freunde von GFA- und anderen -Basics

Warnung: Diese Seite wurde schon einmal behackt! Heruntergeladene Programme möglichst auf Viren prüfen, und keinesfalls irgendwelche Setup-Programme ausführen, die stammen sicher nicht von mir.

Latest News 2003/5

Lonny Pursell and I could decode the format of the source files from the MS-DOS and Win3.x GFA Basic. We just have documented the general format and the binary tokens.

Worum geht es hier?

Ich bin gerade (war: letztes Jahr) dabei, einen Konverter für GFA-Basic in andere Programmiersprachen zu schreiben. In dieser Seite möchte ich alle möglichen Schnipsel hierzu veröffentlichen, deshalb der Titel. Die Dokumente und Programme sind alle noch in Arbeit, teilweise schon überholt, aber vielleicht sind sie doch für den einen oder anderen interessant. Updates aller Art sind willkommen.

Beim Schreiben dieses Programms ist mir eine Ähnlichkeit mit meinen alten Discompilern aufgefallen, die alle in GFA-Basic geschrieben sind. Das ist auch der Anlaß für die Entwicklung eines Konverters, ich brauche diese Quellen in einer neueren Programmiersprache. Momentan verwende ich Delphi (Pascal), und das soll daher auch die erste Ziel-Sprache für den Konverter sein. Später kann dann eine ganze Menge von Tools herauskommen, die entweder compilierte Programme oder Quelltexte einlesen, in eine allgemeine Darstellung (Baum) umwandeln, und dann in irgendeiner anderen Programmiersprache wieder ausgeben. Quelltexte, Maschinencode und auch Token-Code sind dabei nur unterschiedlicher Input, die Weiterbehandlung ist weitgehend identisch!

Im Einzelnen

Zunächst haben wir da Tabellen für die Tokens von GFA-Basic, einmal in Rohform, und in der daraus erzeugten Delphi Form, sowie eine Beschreibung der Tokens, die momentan eigentlich nur aus Lücken besteht.
Hinzu kommt eine Beschreibung der verwendeten Attribute und das entsprechende Delphi-Modul, die weder Anspruch auf Vollständigkeit noch auf Aktualität erhebt.
Auch die Beschreibung eines universellen Token-Formats ist nur ein (nicht weiter verfolgter) Ansatz.

Dazu kommt ein erster Ansatz für ein Konvertierungsprogramm, das ein Basic-Programm in eine Baumstruktur konvertieren und anschließend in einer anderen Programmiersprache wieder ausgeben soll. Das Einlesen von *.GFA Dateien funktioniert halbwegs, die meisten Fehler dürften sich durch Ändern der Tabellen beheben lassen. Gleitkommazahlen funktionieren noch nicht, das sollte aber leicht zu korrigieren sein. Der Baum und die Ausgabe ist permanent in Arbeit, daher zunächst keine weiteren Kommentare hierzu.
Die Bedienung ist etwas erklärungsbedürftig. Vor allem benötigt man eine DOSe mit Windows/32, um das Programm laufen zu lassen, auf ST und Windows/16 kann ich derzeit keine Rücksicht nehmen.
Dann kann man eine Datei (*.GFA) vom Explorer in die linke Hälfte des Fensters herüberziehen, um diese zu öffnen. GFA-Basic 2.0 mit *.BAS Dateien ist vorgesehen, der zugehörige Code muß aber noch angepaßt werden.
Im linken Teil des Fensters erscheint dann eine Liste aller Symbole (Variablen, Unterprogramme...), die später zum Navigieren im Code verwendet werden soll.
Im rechten Teil des Fensters erscheint ein etwas entarteter Baum des eingelesenen Programms. Die Breite der einzelnen Knoten kann man mit dem Schieber im oberen Teil des Fensters einstellen. Die Navigation im Baum erfolgt mit den Cursor-Tasten, relativ zu dem in der linken oberen Ecke angezeigten Knoten.
Der Token-Zweig enthält von links nach rechts das Hauptprogramm und alle Unterprogramme, darunter alle zugehörigen Statements, die (später) noch weiter verzästelt werden sollen.
Beim Bewegen der Maus werden in der unten liegenden Statuszeile Einzelheiten zu dem jeweiligen Knoten angezeigt.
Weitere Funktionen sollen laufend dazukommen, wie das Navigieren zu einem doppelt angeklickten Knoten, und ein Kontext-Menü (rechte Maustaste) für jeden Knoten.

Das wars bis jetzt, viel Spaß wünscht

DoDi

(Dr. Hans-Peter Diettrich)