• The development environment is organized like a database. Scripts with definitions for tokens, productions and class methods can be inserted, deleted or changed. The IDE contains different pages for these kinds of scripts. So the structure of a parser class, as the TextTransformer can produce it, is preformed.
  • Syntax highlighting of the scripts
  • Semantic code can be collapsed to better overview the structure of the real parser.
  • Source files can be viewed in binary or hexadecimal form too
  • Semantic code can be cleared automatically from an individual script or from all scripts.
  • Several wizards are helping to construct new projects or to expand existing projects. E.g. a kind of parser generator generator creates productions from token sequences, which are extracted from example texts.
  • By the regex test dialog single regular expressions, which are used for the definitions of tokens, can be tested.
  • A character class calculator helps to construct regular expressions
  • The very detailed context sensitive help shows the syntax of single interpreter instructions, explains messages, which might be shown in the error window and explains the function of dialog elements.
Parser generator
  • Generator for recursively descending parsers
  • Arbitrary look-ahead makes possible to resolve conflicts
  • Semantic predicates can resolve conflicts too.
  • Automatic grammar tests are detecting possible conflicts
  • SKIP-symbol: sections of text with unspecified composition can be skipped automatically.
  • Family concept: the classes of tokens and rules are open. The required definitions of the symbols for a start rule are put together automatically.
  • Tokens are defined by regular expressions (extended POSIX style with Kleene star)
  • Productions are defined by the same syntactical elements. Here they have a Meta meaning: productions are quasi-regular expressions of regular expressions.
  • Dynamic placeholder tokens can be extended by literal expressions - e.g. type identifiers - during parsing and then will recognize these expressions in the following text.
  • Also whole dictionaries can be assigned to placeholder tokens with thousands of literal tokens.
  • Global and local options are allowing a fine tuning of the parser.
  • The integrated interpreter can execute parsers and translators immediately.
  • A subset of c++ instructions can be executed in the interpreter. (This code can be compiled in the generated parser class without restrictions - see below.)
  • The creation of parse trees is possible. They can be made by means of wizards for the whole project. This approach is more flexible than a fully automatic creation of parse trees.
  • Function tables, which can be created by means of a wizard, allow the processing of parse trees. Each label of a node represents its type and an evaluating function is assigned to this type by the table.
  • Sub-expressions of the tokens can be accessed.
  • The testing step-by-step of a generated parser is possible, since version 1.4.0 for look-ahead productions too.
  • You can step backwards in the debugger, from a breakpoint or error condition.
  • Breakpoints can be set, both in the source text and in the grammar
  • Each production can be tested individually, by choosing it as start rule.
  • The current token and the expected token is highlighted in the input
  • A stack of the called productions is shown
  • In a variable-inspector you can see the values of local variables, class variables and the parse state. A complete parse tree can be represented.
Test suite

Productions can be tested automatically

  • Individual texts can be transformed inside of the TextTransformer environment.
  • It is possible to interactively treat different parts of the text differently.
  • Whole directories or other specified groups of text files can be transformed by means of the integrated Transformation-Manager.
  • A command line tool permits the transformation of file groups independently of the TextTransformer IDE.
C++ code generation (in the professional version only)
  • A c++ parser class is produced for a start rule.
  • Individual productions are implemented as class methods
  • Interfaces can be produced for every subordinate production.
  • Code frames can enlarge the parser class by additional class elements or methods.
  • All interpreter code yields compiling ANSI/ISO c++ code. Additional code, which is not meant for the interpreter, is taken as a copy from the productions. By according bracketing it is also possible, to restrict code parts to the interpreter.
  • The source code for the base classes of the scanners and the parsers is part of the package of the professional version of the TextTransformer. An installation of the free boost library for regular expressions is required for compiling the code. No further precompiled components like dll's etc. are needed.
  • Multithread safe reentrant parsers and translators can be created (without use of function tables).
  • The TextTransformer is bootstrapping itself. Essential projects, by which the program is made, are part of the installation package.

   deutsch Deutsch


Latest News
Aurora2Cpp: Delphi 7 translator [more...]

Delphi2Cpp 2.3: Conversion of DFM files [more...]


... You have exceeded my expectations and I love your product. We will get a lot of use out of it in the future for other projects."

Charles Finley
xformix 23-02-07


I was extremely impressed with your components and tools. Not only extremely powerful but very professionally done and well documented, etc. Really quality work, congratulations

mouser (First Author, Administrator)

  This website is generated from plain text with [Minimal Website ]

Minimal Website Minimal Website is made with TextTransformer

TextTransformer TextTransformer is made with Borland CBuilder