Package eu.bandm.tools.d2d2.base

package eu.bandm.tools.d2d2.base

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 service provider 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 further service provider class is Batch for more efficient processing of more than one input file and output format.
Approximately, the calling graphs are

         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
  

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.
BatchOptions.traceflag	This enum type indicates: Switch on/off different trace outputs individually.
BatchOptionsGui	Generated source of a graphical user interface (GUI) for command line processing.
BatchProcessor	Batch processing of d2d sources into different back-ends, using BandMs' own "txsl" implementation of xslt 1_0.
BatchProcessor.Job	Represents one transformation job, with all its parameters, to be applied to multiple d2d source file inputs.
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
CharParserPrepare.Split	Represents a RegExp as a collection of segments: g=non-recursive termation case, p=prefix before the first recursive call, s=suffix after the last recursive call, i=inbetween two recursive calls.
Classifier
Classifier.DifferenceFound
Constants	Utility class holding ubiquituously used constants.
Def2Dtd	Implements the translation of a d2d definition module (imported from .ddf/.umod/.dtd/ad lib) into a Dtd object.
Def2Xslt3	Collects XSLT rules (and the necessary namespace declarations) in d2d format 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 or null in case of error.
FirstCalculator	Sets up constants in each Expression, which cache structural properties of the syntax for later parsing.
Main	D2d comand line tool, by static method Main.main(java.lang.String[]).
MemScanner<D>	Basic scanner for d2d text recognition, working on and returning MemString objects.
MemScanner.OpenTagModifier	Categories of the character data immediately follwoing an open tag.
MemScanner.TokenType	Non-overlapping Categories of the recognized tokens.
Meta2Pi
ModuleRegistry	Resolves module names to Module objects.
Navigate	Auxiliary static methods for model navigation and inquiry.
Navigate.AttributeCollector	Worker for updating the local attribute cache.
Navigate.CharSetCalc	Expand all character set expressions from the d2d definition language to an extensional representation as CharSet.
Navigate.LocalReferenceNormalizer	Replaces hard every referring identifier which is local to some declared object by the normalized identifier, as valid on module level.
Navigate.VisitReachable<T>	Visits all definitions and their defined expressions which are reachable from given start points.
Options	Generated source for command line processing.
Options.modes	This enum type indicates: Select very different operation modes of this tool.
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).
Reducer.manglingMode
Resolver4
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	Single-use tool to find all sub-expressions of the current content model which are allowed to enter as next input in the current parsing situation.
SyntaxGraph	Calculates and paints an extended regex as graphic.
SyntaxGraph.LayoutParameters	Intended to be overwritten in anonymous subclasses.
SyntaxGraph.RectMap	Maps exprssion objects to graphic araes.
SyntaxGraph.RefPainter	An instance of this must be plugged into a SyntaxGraph.Painter for customized representation of references.
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	Parse a d2d text input into xml nodes.
Text2Udom.ErrorStrategy	Configuration object for the different ways of reacting to input errors.
Text2Udom.modes	Kind of the text to parse.
Text2Udom.parsingState	Realizes the parsing state on lower=character level.
TextFileHeader	Parser for the header of a d2d text input file.
Translations	Multi-lingual translations catalog, generated from XML source.
TypeCheck	ATTENTION: Typecheck itself NOT YET used, BUT collectAttributes.
TypeCheck.AttributeCollector
TypeCheck.Type
Udom2Sax	Generates SAX events in name-space mode.
UdomClient	Adapter to use bandm xpath (and thus txsl) with internal d2d udom objects.
UMod2Def	Generate a d2d definition module from a umod model definition.
Userdoc	Common superclass for user documentation, instantiated or uninstantiated.
UserdocInstantiated	Create Xhtml documentation of a ResolvedModule, as produced by Resolver4
UserdocUninstantiated	Create Xhtml documentation of an unresolved "raw" Module.
XsltInstance	Instantiates the generic d2d xslt module definition for some particular target doctype.