Package eu.bandm.tools.d2d2.base

D2d allows to write valid XML documents directly in the creative flow of authoring, with minimum typographic noise.

See: Description

Interface Summary

Interface	Description
SyntaxGraph.RefPainter	Plugged into a painter for customized representation of references.

Class Summary

Class	Description
Batch	Batch processing of d2d sources into different back-ends, using BandMs' own "txsl" implementation of xslt 1_0.
BatchOptions	Generated source for command line processing.
BatchOptionsGui	Generated source of a graphical user interface (GUI) for command line processing.
CharacterParser	Realizes the fine granular d2d character level parsing.
CharacterParser.ParseResult	A simple wrapper for one (of the many parallel) parsing situations; wraps MemScanner as the next input situation and ResultingStructures as collected so far.
CharParserPrepare	Collects all parser particles from character parsers and joins them to a content model which is DTD compatible.
CharParserPrepare.EliminateRecursion
CharParserPrepare.ReduceToCardinalities
Def2Doc	Create Xhtml documentation of an (instantiated or un-instantiated) d2d module. (1) Create fresh instance (alwas anew, no re-usage) (2) call main entry method Def2Doc.makeHtmlDoc(ModuleRegistry,Module,boolean,String,String,NamespaceName2String) (3) Then the directory (specified in (1), already existing) will be filled with main "index.html" and many "*.png", etc.
Def2Doc.RefPainter_custom
Def2Doc3	Create Xhtml documentation of a ResolvedModule, as produced by eu.bandm.tools.d2d2.base.Resover3 (new at 201060823).
Def2Doc3.RefPainter_custom
Def2Dtd	Implements the translation of a d2d definition module (imported from .ddf/.umod/.dtd/ad lib) into a Dtd object.
Def2Xslt	Implements the extraction of all xslt rules for all definitions in a given module into the given target format.
Def2Xslt3	KOMMENTAR UEBERARBEITEN : FIXME Collects XSLT rules (and the necessary namespce declarations) from a set of resolved modules, for one particular transformation target key.
DocOnly	A source file which only adds comments to existing modules.
DocTexts	Multi-lingual translations catalog, generated from XML source.
Dtd2Def	Simple dtd to d2d2 module converter, returns an instantiated Module (FIXME change to ResolvedModule !!) or null in case of error.
Main	This class implements the d2d2 comand line tool by Main.main(String[]) and contains global static constants for d2d processing and for the d2d basic gp libraries.
MemScanner	Basic scanner for d2d text recognition, working on and returning MemString objects.
Meta2Pi
ModuleRegistry	Normally only one central instance exists which resolves module names to Module objects, searching ModuleRegistry.sourceHabitats, like a "ClassLoader" does for Java classes.
Navigate	Auxiliary static methods for model navigation and inquiry.
Navigate.CharSetCalc	Under a CharBinary all refs and defs and operators MUST be of character type.
Navigate.LocalReferenceNormalizer	Replaces hard every refering id which is local to some declared object by the normalized identifier, as valid on module level.
Navigate.VisitReachable<T>
Options	Generated source for command line processing.
OptionsGui	Generated source of a graphical user interface (GUI) for command line processing.
PostProcessor	The class from which all post processing classes must be derived.
Reducer	Reduces a d2d definition text file ("ddf") given as a tdom Document_module into an umod Module and its sub-structures (= contained sub-modules and definitions).
Resolver	Changes an unresolved module into a resolved one.
Resolver2	Changes an unresolved module into a resolved one, new strategy which allows recursive module imports etc., since it has a finer granularity.
Resolver3	Transforms a "raw" module into an "instantiated" one.
Resolver3.Formatter_showingResolution
Resolver4	Executes instantiation of a d2d definition module.
RewriteCompare
StackPrinter	Prints the current stack state to a terminal, highlighting current position and possible continuations, for error diagnosis in interactive use cases.
StackPrinter.ExpressionPrinter	Simply prints expressions, inserting parentheses by priority.
StackPrinter.FollowSet	find all sub-expressions of the current content model which can be entered immediately in the current parsing situation.
SyntaxGraph	Calculates and paints an extended regex as graphic.
SyntaxGraph.LayoutParameters	all distances/offsets measured in pixels, font sizes in "points = 1/72 inch"
SyntaxGraph.RectMap
SyntaxGraph.SizeInfo	Represents the result of a layout sub-process as a TeX-like box model with three length values.
Tasks	Collection of static methods which realize the different d2d conversion tasks.
Text2Udom
Text2Udom.ErrorStrategy	Configuration object for the different ways of reacting to input errors.
TypeCheck	ATTENTION: Typecheck itself NOT YET used, BUT collectAttributes.
TypeCheck.AttributeCollector
Udom2Sax	Generates SAX events in name-space mode.
UdomClient	FIXME abstraktion mit w3cClient, gemeinsame superklasse?
UMod2Def
XsltSpecialized	NOT YET USED! This class prepares the d2d definitions of xslt code for one certain back-end/targetmodule.

Enum Summary

Enum	Description
BatchOptions.traceflag	This enum type indicates: Enabling of very different trace outputs of bandm tXsl separately.
MemScanner.OpenTagModifier
MemScanner.TokenType
Options.modes	This enum type indicates: Select very different operation modes of this tool.
Reducer.manglingMode
Text2Udom.parsingState	Realizes the parsing state on lower/character level.
TypeCheck.Type

Exception Summary

Exception	Description

Package eu.bandm.tools.d2d2.base Description

D2d allows to write valid XML documents directly in the creative flow of authoring, with minimum typographic noise. This is the main package of the d2d version 2.0 implementation, as described in the dedicated user documentation. Its prerequisites are the packages ../infra, which contains hand coded low level auxiliary routines, and the packages ../parser, ../absy, ../model and ../rt, which contain sources generated from one xantlr grammar file and two umod model definition files.
../postproc contains some standard post processing code, activated by explicit reflection.

The user entry class is Main, which implements the command line interface. The entry class for programmatic usage is Tasks. See there for more documentation about the use cases.
A new user entry class (NOT YET READY) is in Batch for more efficient processing of more than one input file and output format, without module caching.
Approximatly, the calling graphs are these:

         Main.main()
           +-------------------------------+--+--+-----+
           |  Batch.main()                 |  |  |     |   
           V  |     |                      V  |  V     |
         Tasks.text2texts()           Def2Doc V Def2Dtd|
           |  |  |  |                /     | Def2Xslt  |
           |  |  V  V        Callgraph     |  |  |     |
           |  | Udom2Sax     DocTexts      |  |  |     |
           V  V              SyntaxGraph   |  | /      |
       Text2Udom.fromFile()                |  /        |
        |  |  |  |   V      |              |/          |
        |  |  |  V  PostProcessor          |           |
        |  |  | CharacterParser.parse()    |           |
        |  |  V  V          V              |           |
        |  |  MemScanner  StackPrinter     |           |
        |  |   V                           |           |
        |  |  MemString                   /|           |
        |  V                            /  |           |
        |  rt.ResultingStructure      /    |           |
        V                           V      |           |
       ModuleReg.loadInstantiated()        |           |
         | |  |       V                    V           |
         | |  V       ModuleReg.loadUnInstantiated()   / 
         | V  Dtd2Def <------ | ---------------------/
         V UMod2Def           |
       Resolver,Navigate      V
       (,TypeCheck)         Reducer
                              V
                            ../absy
                              V
                            ../parser