Package eu.bandm.tools.d2d2.base

Class CharParserPrepare

java.lang.Object

eu.bandm.tools.d2d2.base.CharParserPrepare

public class CharParserPrepare
extends Object

Collects all parser particles from character parsers and joins them to a content model which is DTD compatible. There are two situations: without and with an explicit element definition. In both cases the definitions of the parse particles (e.g. "p") must be collected from the different character parser definitions, which may be recursive. All variants must be joined into one disjunction, and this must be normalized into a content model for later DTD generation. (For mere write-out = SAX event generation, this is not necessary.)
Case without element definition:

     chars a = ..... [p ..... [q..][q..] [p ..... ] .... ]
     chars b = ..... [p ..... ] ...
  

In this case NO definition in the module may have the name "p".

or

     chars a = ..... [p ..... [q..][q..] [p ..... ] .... ]
     chars b = ..... [p ..... ] ...
     chars p = #distributed with xmlrep el = "x:y", postprocessor "a.b"
  

In this case a char parser is defined as "#distributed" and will be assigned the collected content model of the parse particles in the same module with the name. Then additional features can be specified, like xml tag and namespace, Java class as postprocessor, etc.

     chars p = #distributed with xmlrep data ...
  

The keyword "data" means that the sequential order of the input is not significant and will be re-ordered. The top-level expression will be a permutation "..&.." of the contained elements (coming from character parsers or parse particles in the collected regexps).

Usage: create one instance (anew for each instantiated module) and call resolve(eu.bandm.tools.d2d2.model.ResolvedModule).

(Please note that there is a general problem with more than one instantiations of the same module, which will result in more than one parser definitions bound to the same XML tag !)

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	CharParserPrepare.EliminateRecursion
static class	CharParserPrepare.ReduceToCardinalities
(package private) static class	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.

Field Summary

Fields

Modifier and Type	Field	Description
(package private) final Set<CharsRegExp>	allCharsRegExp
(package private) final Multimap<String,ParseParticle>	allParseParticles
(package private) static final Alt	EMPTY
(package private) static final Seq	EPS
protected final MessageReceiver<SimpleMessage<XMLDocumentIdentifier>>	msg
(package private) static final Location<XMLDocumentIdentifier>	NOLOC
(package private) final Map<String,Module>	ppName2rawModule
(package private) final Map<Module,String>	reprKey
(package private) ResolvedModule	resolvedModule

Constructor Summary

Constructors

Constructor	Description
CharParserPrepare(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg)

Method Summary

Modifier and Type	Method	Description
(package private) static Alt	ALT(Expression... exp)
protected void	error(@Opt Location<XMLDocumentIdentifier> loc, String txt, Object... obj)
(package private) static boolean	isEmptyAlt(Expression exp)
static void	main(String[] cmd)
(package private) static Expression	PLUS(Expression exp)
protected Definition	rawDef(Definition def)
protected Module	rawMod(Definition def)
(package private) final String	representingKey(DefInstance defI, Module rawMod)	ATTENTION ParseParticles are unified w.r.t.
void	resolve(ResolvedModule resolvedModule)	MAIN OPERATIVE ENTRY METHOD: Collect all ParseParticles in resolvedModule and link together all those from the same raw module, with the same name.
protected void	resolveOnePpName(String ppName)	ppName is built from one (arbitrarily chosen) module expansion of the raw original module, plus the name of a ParseParticle.
(package private) static Expression	SEQ(Expression... exp)
static void	testE(String data)
static void	testF(String data)
static Expression	testParse(String data)
static Expression	toRegExp(String s, Expression exp)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

msg

protected final MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg

NOLOC

static final Location<XMLDocumentIdentifier> NOLOC

EPS

static final Seq EPS

EMPTY

static final Alt EMPTY

resolvedModule

ResolvedModule resolvedModule

allCharsRegExp

final Set<CharsRegExp> allCharsRegExp

allParseParticles

final Multimap<String,ParseParticle> allParseParticles

ppName2rawModule

final Map<String,Module> ppName2rawModule

reprKey

final Map<Module,String> reprKey

Constructor Details

CharParserPrepare

public CharParserPrepare(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg)

Method Details

error

protected void error(@Opt
 @Opt Location<XMLDocumentIdentifier> loc,
 String txt,
 Object... obj)

SEQ

static Expression SEQ(Expression... exp)

ALT

static Alt ALT(Expression... exp)

isEmptyAlt

static boolean isEmptyAlt(Expression exp)

PLUS

static Expression PLUS(Expression exp)

rawDef

protected Definition rawDef(Definition def)

rawMod

protected Module rawMod(Definition def)

representingKey

final String representingKey(DefInstance defI,
 Module rawMod)

ATTENTION ParseParticles are unified w.r.t. the UN-instatiated, raw modules. Therefore one instantiated module is chosen arbitrarily, and the "collector" is instantiated/created with that import prefix in its name.

resolve

public void resolve(ResolvedModule resolvedModule)

MAIN OPERATIVE ENTRY METHOD:

1. Collect all ParseParticles in resolvedModule and link together all those from the same raw module, with the same name.
2. Link these to a "Collector", either a fresh CharsRegExp, or one in the same module with the with the same name, declared as "#distributed".
3. Collect the "linear content models" (as an Expression) of all CharParsers and all ParseParticles, thereby reducing "flattened recursion" = "x=..@x.." to repetition.
4. Construct the unified expr (for DTD-generation and writing-out) either as a conjunction of the distributed expressions (may crash due to violation of (1)unambigueness.) or as a permutation expression, reflecting cardinalities only, iff the Collector has been declared as xmlrep data.

resolveOnePpName

protected void resolveOnePpName(String ppName)

ppName is built from one (arbitrarily chosen) module expansion of the raw original module, plus the name of a ParseParticle. This call triggers the unification of all ParseParticle with this name in ALL instantiated definitions coming from this raw module, as already stored in allParseParticles.

testParse

public static Expression testParse(String data)

toRegExp

public static Expression toRegExp(String s,
 Expression exp)

testE

public static void testE(String data)

testF

public static void testF(String data)

main

public static void main(String[] cmd)