The TextTransformer is a visual development environment, which combines a parser generator with a simple c++ interpreter and a debugger.
The TextTransformer has a comfortable user interface with syntax highlighting, immediate finding of errors and an integrated debugger, which allows the testing of a program without previous compilation to binary code. The background of this concept is examined now.

What is a parser

A parser is a program that analyzes the syntactic structure of texts. For example a so-called CSV file (Character Separated Values) consists of lines in which data are separated by commas or other separating character from each other. Many database applications can read and write such files.
If the data consist of words and numbers, the structure would be described as follows in the TextTransformer:

CSV ::= Line*
Line ::= ID ( "," ID )* EOL

"ID" and "EOL" are predefined, so-called tokens in the TextTransformer which recognize sequences of letters/numbers and the end of line in the text. The star '*' describes an arbitrary number of repeats of the expression standing in front of the star. From the description of the CSV file the TextTransformer already produces a complete parser, which recognizes all single data in the text, one after the other.

How it works in detail

What is the use of a parser

CSV ::= ( Line {{ m_i++; }} )*
Line ::= ID ( "," ID )* EOL

Here "m_i" is a variable, in which the respective line number is stored. Every time a line was recognized, the value of m_i is increased by one.
From this example you can see, that the words "translator" and "transformation" are used in a very broad meaning here. In the example a text: the CSV file, is transformed in a number: the number of data sets.

Complex transformation programs

The example above is a very simple transformation program. The other extreme would be a translator in the narrow meaning of the word, which could translate texts of a natural language into another language. Large companies and universities worldwide are biting on granite to solve this task. However, the principle is the same: at first a parser is designed, which then is enlarged for a transformation program. The difference lies in the complexity of the grammars of the source and the target text.
Transformation programs can be handled considerably better for texts, whose grammar isn't of natural origin but whose syntax did man create. The translation of programming languages into binary code or into an interpreter and converting programs of different document formats in each other are a typical examples. These tasks often are very complex, too: Experienced software developers spend many months with expensive software tools to make it. So a lot of software was developed, to change text formats, like MS Word, Excel, HTML or PDF documents, into each other or to extract parts, e.g. tables or picture, from them. One has already to look intensively for programs on the Internet that can analyze less popular document formats. Such a search is hopelessly, when one has to do with special formats, which were designed by smaller software houses, insurance companies, financial entrprises or other enterprises for their specific tasks. How can nested records in a text file be imported in a database? And what can a private user do, if he has scanned a long text and the characters are mixed up everywhere and the same syllables are written wrongly again and again?

The TextTransformer and its alternatives

The TextTransformer is developed especially for the solution of such tasks. It can replace the usual expensive development tools and simplifies the development of parsers in a measure, that people who don't devote themselves to the software development professionally can solve their special problems with it either.
A professional developer will like the TextTransformer because he can completely concentrate on the development of the grammar, without having to struggle with the details of the construction of the parser and the scanner.
The advantage of the TextTransformers gets clearer, when it is opposed to the alternatives:

Advantage of a parser generator IDE

The TextTransformer and few similar competing products offer the way out here. Example texts simply can be loaded by a selection dialog in the TextTransformer. The parser is generated within the TextTransformer itself and can immediately be executed and tested there. Debugging has all comfort here: you can step into a production or pass over it. It is possible too, to jump to the point at which the next token will be consumed. Or breakpoints can be set both in the grammar and in the input. Recognized text sections are marked ion the source text, the token recognized last and the token expected are shown and in a window the stack of the called productions can be examined.
So the development of a parser becomes a game and even people, who aren't software developers, will enjoy it.
A problem nevertheless remains: a parser alone is useless. Something shall be done with the parsed text. Therefore so-called semantic actions, which process the recognized text pieces, are inserted in the code of the parser. The above problem of the double error correction arises once more with that, however.

Outstanding of the TextTransformer

The TextTransformer is worldwide the only parser generator, which integrates an interpreter. The TextTransformer isn't only suitable for the development of parsers, but also for the development of complete translators.
Already at the pure parser development the integrated interpreter can be of advantage since it is excellently suitable for the logging of information that can document the progress and state of the parser.
But the advantage of the TextTransformer is most obvious, if it is all about to develop a complete transformation program. The interpreter is rich enough to handle many practical tasks that daily arise for an ambitious computer user. Even the construction of a parse tree and its evaluation is possible.
For specific, professional tasks it is furthermore possible to embed an arbitrary C++ code in the productions. Interpreter code can be combined with other code arbitrarily.

Versions

Technical details