Text2Udom (BandM metatools API doc)

java.lang.Object
- eu.bandm.tools.d2d2.base.Text2Udom

```
public class Text2Udom
extends Object
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`Text2Udom.CannotContinue`
`protected class`	`Text2Udom.CollectAllElements` Collect all elements which can appear in an xslt template "spontanuously" on top level of a template content.
`static class`	`Text2Udom.ErrorStrategy` Configuration object for the different ways of reacting to input errors.
`static class`	`Text2Udom.parsingState` Realizes the parsing state on lower/character level.
`protected class`	`Text2Udom.PrematureEndOfFile` Explicit end of input sources is modelled as follows: the pseudo-token `Chars.STRING_TAGNAME_eof` is defined to "eof" this is specially tested for in `process_open_tag(String, boolean)`.
`protected class`	`Text2Udom.Starter` Opens all "`State`"-frames needed for later continuations, directed by an Expression and the recognized tag.

Field Summary

Fields
Modifier and Type	Field and Description
`protected static Map<Enumeration,String[]>`	`allSortedKeys`
`protected Location<String>`	`bicLoc`
`protected Navigate.CharSetCalc`	`charSetCalc`
`protected static Function<Definition,Reference>`	`co_resolve`
`protected Text2Udom.parsingState`	`currentState` Current micro-state, values from `#parsingState`.
`static Text2Udom.ErrorStrategy`	`default_ErrorStrategy`
`protected boolean`	`doTrace`
`protected Text2Udom.ErrorStrategy`	`errorStrategy`
`protected boolean`	`found_eof_parsed`
`static Function<SourceItem,String>`	`getFullPath`
`static Text2Udom.ErrorStrategy`	`interactive_ErrorStrategy`
`protected Text2Udom.parsingState`	`interruptedState` Needed to treat `setcommand`, `setcomment` and numeric input (i.e.
`protected boolean`	`lastCloseWasXslt` An EXPLICITLY closed xslt element is no longer in the stack, but a subsequent target-language element must nevertheless be treated as coming from "inxslt"!
`protected List<ResultingChars>`	`leading_ws` Accumulator for ws, not yet clear whether to deliver or to ignore.
`static Location<XMLDocumentIdentifier>`	`locnull`
`protected static Function<String,Reference>`	`makeRef`
`static String`	`MEMSTRING_ID_SYNTHETIC` Aux function to insert synthesized character data in the output, which is NOT contained in the source, e.g.
`protected Definition`	`meta_assumedXsltOutput`
`protected Definition`	`meta_expected`
`protected Definition`	`meta_kind`
`protected Definition`	`meta_location`
`protected Definition`	`meta_messageText`
`protected Module`	`meta_module` Attention, only initialized and used iff xslt or "partial" documents are created.
`protected Definition`	`meta_parsingError`
`protected Definition`	`meta_skipped`
`protected Definition`	`meta_tag`
`protected Definition`	`meta_warning`
`protected String`	`modulename` Maybe == null iff xsltmode.
`protected ModuleRegistry`	`moduleRegistry`
`protected MessageReceiver<SimpleMessage<String>>`	`msg`
`protected MemScanner`	`scanner`
`protected ResultingStructure`	`skipContainer` For reporting skipped input
`protected static boolean`	`sloppyHeaderSyntax`
`protected State`	`state` The crurently growing stackframe, see `State`.
`static Location<String>`	`synthLocation`
`protected ResultingStructure`	`top_result` Toplevel result of parsing the input text.
`protected String`	`toplevel_fileLocation`
`protected @Opt String`	`toplevelelementname` Maybe == null iff xsltmode.
`protected Module`	`toplevelModule`
`protected XRegExp`	`toplevelXRegExp`
`protected int`	`verbatimSuppress`
`protected boolean`	`version_2_0_selected`
`protected MessageReceiver<SimpleMessage<XMLDocumentIdentifier>>`	`xml_msg`
`protected Expression`	`xslt_alt_ubiquituous`
`protected Expression`	`xslt_alt_ubiquituous_repeated`
`static String`	`xslt_generic_tag_for_backend_elements`
`protected Module`	`xslt_module`
`static String`	`xslt_modulename`
`static String[]`	`xslt_prefices`
`static String`	`xslt_tag_toplevel`
`static String`	`xslt_tag_ubiquituous`
`protected Map<String,String>`	`xsltInputNamespaces` Is a map from URI TO prefix.
`protected boolean`	`xsltmode`

Constructor Summary

Constructors
Constructor and Description
`Text2Udom(MessageReceiver<SimpleMessage<String>> msg, ModuleRegistry moduleRegistry, Text2Udom.ErrorStrategy errorStrategy)`
`Text2Udom(MessageReceiver<SimpleMessage<String>> msg, ModuleRegistry moduleRegistry, Text2Udom.ErrorStrategy errorStrategy, boolean doTrace)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`accept_superfluous_end_tag(String tag, boolean defIsEmpty, Definition def, Location<String> startLoc)` Lets the scanner accept and discard an end tag, either normal or forced or by a parenthesis character.
`protected void`	`addRestPerm(State_perm permstate, CheckedList<Expression> misslist)` Add obligate members of a "perm" expression to the term which describes the missing input.
`protected void`	`bicERROR(String text, boolean isCommand)`
`protected boolean`	`builtInMetaCommands(String tag)`
`protected static @Opt ResultingStructure`	`consume_enumeration(MemScanner scan, Enumeration etype)` Used by tag parsers AND character parsers (with multiple parallel scanners !)
`protected void`	`deliver_last()` Deliver the last scanned character data, and set the "is whitespace" flag according to the token type returned by scanner.
`protected void`	`deliver_numeric(int val)` Append the unicode character to the top-most resulting structure.
`protected void`	`deliver_spontanuous(ResultingStructure res)` Append the argument to the top-most resulting structure which is not encoded as xml attribute.
`protected void`	`deliver_to_singletonstate(ResultingStructure res, State_singleton tss)`
`protected void`	`deliver(ResultingChars chars)`
`protected void`	`deliver(ResultingStructure res)` Append the argument to the top-most resulting structure.
`protected void`	`deliver(Udom res)`
`protected void`	`digest_consume_characters()` When an element may receive character data, and some non-ws character data has been recognized at the reading position.
`protected void`	`digest_look_for_tag()` After a command char has been read.
`protected void`	`digest_nothing_open()` Initial (micro-)state, or after an explicit close.
`protected void`	`digest_skip_for_command()` Micro-state for error recovery: skip until command char and then goto tag-reading mode again.
`protected void`	`digest_verbatim()` Parses "verbatim input" mode, which (a) requires an explicit `#/tag` end tag, and (b) accepts only tags of sub-elements immediatly contained in its definition.
`protected void`	`digest()` Main loop, consumes input data according to current "micro"-state `currentState`.
`protected void`	`error(Location<String> loc, String text)`
`protected void`	`error(Location<String> loc, String text, Object... args)`
`protected void`	`error(String text)`
`protected void`	`errorcheck_xsltprepare(MessageCounter<SimpleMessage<XMLDocumentIdentifier>> cnt)`
`protected void`	`failure(Location<String> loc, String text)`
`protected void`	`failureDEF(Location<XMLDocumentIdentifier> loc, String text)`
`protected State_singleton`	`find_top_singleton()` Called from `return_to_upper_input_mode()`.
`protected State_singleton`	`find_top_singleton(boolean mustBeNonAtt)`
`@Opt ResultingStructure`	`fromFile(File f)`
`@Opt ResultingStructure`	`fromFile(String s)` The calling graph of the main scanner functions is :
`protected @Opt ResultingStructure`	`fromMemString(MemString text)`
`@Opt ResultingStructure`	`fromMemString(String locationText, MemString text)`
`Map<String,String>`	`getXsltInputNamespaces()`
`protected void`	`hint_xml(Location<XMLDocumentIdentifier> loc, String text)`
`protected void`	`hint(Location<String> loc, String text)`
`protected void`	`ignore_superfluous_end_tag(String tag, boolean defIsEmpty, Definition def, Location<String> startLoc)` Called after an empty tag, a parser or an enum have been consumed.
`static void`	`insertPlainChars(ResultingStructure host, Definition tag, String chars)`
`protected boolean`	`isXsltDef(Definition def)`
`protected Definition`	`loadMetaDefinition(Map<String,Definition> defs, String name)`
`protected void`	`loadMetaModule()`
`protected void`	`logEnd(String text)`
`protected void`	`logStart(String text)`
`protected Alt`	`makealt(CheckedList<Expression> subs)`
`protected Alt`	`makealt(Collection<Reference> subs)`
`protected void`	`makeGlobalSkipContainer(ResultingStructure errormsg)`
`static Text2Udom.ErrorStrategy`	`non_interactive_ErrorStrategy()` Used for situations when basic data is required by the "programmer" and not by a user.
`static void`	`P(String s)`
`protected boolean`	`parseVerbatimSuppres()`
`protected void`	`prepareXsltMode_text()` For text mode the xslt module can be used directly, no rewriting is necessary but eliminating "xslt:RESULT_ELEMENTS"
`protected void`	`prepareXsltMode()` The insertion of the target language classes into the content-containing xslt elements is done by once modifying the (copy of the) xslt declaration.
`protected void`	`process_char_parser_error(String tag, MemString charsStart)` Is called after a non-acceptions by char parser or by an enumeration has been detected.
`protected void`	`process_close_char()` Called from digest_nothing_open/look_for_tag/consume_chars, in case that closing parenthesis character has been recognized.
`protected void`	`process_close_tag_inner(@Opt String tag, boolean force, Location<String> closeTagDefLoc)` Search the state space for "nexttag" as possible close tag.
`protected void`	`process_close_tag(String tag, boolean force)` Called by digest_look_for_tag, process_open_tag (in case of empty element declarations), process_close_char.
`protected void`	`process_open_tag(String tag, boolean isCharData)` Only method for processing an "open" tag.
`protected void`	`report_assumed_xslt_output(State_singleton ss, CheckedList<Expression> misslist)` Is called when an target-language open/close tag has been found after an xslt template call, to report the necessary expansion.
`protected void`	`report_missing_elements(boolean isOpen, String tag, boolean frameFound, CheckedList<Expression> misslist, List<SimpleMessage<String>> messlist, Location<String> closeTagDefLoc)` this proc can be called from `process_open_tag(String, boolean)` or `process_close_tag(String, boolean)`. Basically, there are two classes of error recovery: framefound = true ==> the tag is KNOWN, but tags before are missing, --- then continue with a shrunk stack state. framefound = false ==> the tag is NOT KNOWN, then discard all input up to the next tag and try again.
`protected void`	`return_to_upper_input_mode()` Called to re-enter the input mode (verbatim or nothing_open) after an explicit close (tags had been openend and closed) or an implicit close (enum or character parser have consumed enough) has happened. Assume the stack frame of the parser/enum/closed tag is already popped from the stack. Assume that "inputmode verbatim" is only allowed with "content = (#PCDATA\|..)*".
`protected void`	`scanForHeader()` Sets modname==null and toplevelelementname==null => xsltmode=true Generates warnings/errors
`protected static String[]`	`sortKeys(Enumeration e)`
`protected void`	`warning(Location<String> loc, String text)`
`protected void`	`warning(String text)`
`protected void`	`warnOrError_incompleteHeader(Location<String> loc, String missing)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - default_ErrorStrategy
```
public static final Text2Udom.ErrorStrategy default_ErrorStrategy
```
  - interactive_ErrorStrategy
```
public static final Text2Udom.ErrorStrategy interactive_ErrorStrategy
```
  - moduleRegistry
```
protected final ModuleRegistry moduleRegistry
```
  - scanner
```
protected MemScanner scanner
```
  - msg
```
protected final MessageReceiver<SimpleMessage<String>> msg
```
  - xml_msg
```
protected final MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> xml_msg
```
  - errorStrategy
```
protected final Text2Udom.ErrorStrategy errorStrategy
```
  - charSetCalc
```
protected final Navigate.CharSetCalc charSetCalc
```
  - doTrace
```
protected final boolean doTrace
```
  - meta_module
```
protected Module meta_module
```
    Attention, only initialized and used iff xslt or "partial" documents are created.
  - meta_warning
```
protected Definition meta_warning
```
  - meta_location
```
protected Definition meta_location
```
  - meta_messageText
```
protected Definition meta_messageText
```
  - meta_kind
```
protected Definition meta_kind
```
  - meta_tag
```
protected Definition meta_tag
```
  - meta_parsingError
```
protected Definition meta_parsingError
```
  - meta_expected
```
protected Definition meta_expected
```
  - meta_skipped
```
protected Definition meta_skipped
```
  - meta_assumedXsltOutput
```
protected Definition meta_assumedXsltOutput
```
  - toplevel_fileLocation
```
protected String toplevel_fileLocation
```
  - modulename
```
protected String modulename
```
    Maybe == null iff xsltmode.
  - toplevelModule
```
protected Module toplevelModule
```
  - toplevelelementname
```
@Opt
protected @Opt String toplevelelementname
```
    Maybe == null iff xsltmode.
  - toplevelXRegExp
```
protected XRegExp toplevelXRegExp
```
  - version_2_0_selected
```
protected boolean version_2_0_selected
```
  - xsltInputNamespaces
```
protected Map<String,String> xsltInputNamespaces
```
    Is a map from URI TO prefix. Collects all xslt namespace mappings (uri,pref) which are EXPLICITY declared in the header of a d2d xslt mode source, normally related to the INPUT to the xslt code. (Any XML OUTPUT format must be a module anyhow, and its namespaces must of course also be added, but can be retrieved from there.) Is read by Main, Tasks, ModuleRegistry, etc., when writing out such a file als XML.
  - top_result
```
protected ResultingStructure top_result
```
    Toplevel result of parsing the input text.
    Set once when opening the State for the first tag:
  - xsltmode
```
protected boolean xsltmode
```
  - xslt_alt_ubiquituous
```
protected Expression xslt_alt_ubiquituous
```
  - xslt_alt_ubiquituous_repeated
```
protected Expression xslt_alt_ubiquituous_repeated
```
  - xslt_module
```
protected Module xslt_module
```
  - state
```
protected State state
```
    The crurently growing stackframe, see State.
  - found_eof_parsed
```
protected boolean found_eof_parsed
```
  - leading_ws
```
protected List<ResultingChars> leading_ws
```
    Accumulator for ws, not yet clear whether to deliver or to ignore.
  - currentState
```
protected Text2Udom.parsingState currentState
```
    Current micro-state, values from #parsingState.
  - verbatimSuppress
```
protected int verbatimSuppress
```
  - interruptedState
```
protected Text2Udom.parsingState interruptedState
```
    Needed to treat setcommand, setcomment and numeric input (i.e. pseudo-tags, which look like a tag, but do not behave so) like whitespace.
  - skipContainer
```
protected ResultingStructure skipContainer
```
    For reporting skipped input
  - lastCloseWasXslt
```
protected boolean lastCloseWasXslt
```
    An EXPLICITLY closed xslt element is no longer in the stack, but a subsequent target-language element must nevertheless be treated as coming from "inxslt"!
  - sloppyHeaderSyntax
```
protected static final boolean sloppyHeaderSyntax
```
    See Also:
    
    Constant Field Values
  - xslt_modulename
```
public static final String xslt_modulename
```
    See Also:
    
    Constant Field Values
  - xslt_generic_tag_for_backend_elements
```
public static final String xslt_generic_tag_for_backend_elements
```
    See Also:
    
    Constant Field Values
  - xslt_tag_toplevel
```
public static final String xslt_tag_toplevel
```
    See Also:
    
    Constant Field Values
  - xslt_tag_ubiquituous
```
public static final String xslt_tag_ubiquituous
```
    See Also:
    
    Constant Field Values
  - xslt_prefices
```
public static final String[] xslt_prefices
```
  - locnull
```
public static final Location<XMLDocumentIdentifier> locnull
```
  - co_resolve
```
protected static final Function<Definition,Reference> co_resolve
```
  - makeRef
```
protected static final Function<String,Reference> makeRef
```
  - getFullPath
```
public static final Function<SourceItem,String> getFullPath
```
  - allSortedKeys
```
protected static final Map<Enumeration,String[]> allSortedKeys
```
  - MEMSTRING_ID_SYNTHETIC
```
public static final String MEMSTRING_ID_SYNTHETIC
```
    Aux function to insert synthesized character data in the output, which is NOT contained in the source, e.g. error messages. DISLOC FIXME
    
    See Also:
    
    Constant Field Values
  - synthLocation
```
public static final Location<String> synthLocation
```
  - bicLoc
```
protected Location<String> bicLoc
```
- Constructor Detail
  - Text2Udom
```
public Text2Udom(MessageReceiver<SimpleMessage<String>> msg,
                 ModuleRegistry moduleRegistry,
                 Text2Udom.ErrorStrategy errorStrategy)
```
  - Text2Udom
```
public Text2Udom(MessageReceiver<SimpleMessage<String>> msg,
                 ModuleRegistry moduleRegistry,
                 Text2Udom.ErrorStrategy errorStrategy,
                 boolean doTrace)
```
- Method Detail
  - non_interactive_ErrorStrategy
```
public static final Text2Udom.ErrorStrategy non_interactive_ErrorStrategy()
```
    Used for situations when basic data is required by the "programmer" and not by a user.
  - P
```
public static void P(String s)
```
  - getXsltInputNamespaces
```
public Map<String,String> getXsltInputNamespaces()
```
  - fromFile
```
@Opt
public @Opt ResultingStructure fromFile(String s)
```
    The calling graph of the main scanner functions is :
```
  fromFile(String filename) 
    -> fromFile(File)
       -> fromMemString(MemString)
          -> scanForHeader
          -> Starter.install
          -> digest() 
              // Starting in "nothing open" mode, no verbatim/charparser
                     top-level supported FIXME
   
```
  - fromFile
```
@Opt
public @Opt ResultingStructure fromFile(File f)
```
  - fromMemString
```
@Opt
public @Opt ResultingStructure fromMemString(String locationText,
                                                  MemString text)
```
  - fromMemString
```
@Opt
protected @Opt ResultingStructure fromMemString(MemString text)
```
  - warning
```
protected void warning(Location<String> loc,
                       String text)
```
  - warning
```
protected void warning(String text)
```
  - hint
```
protected void hint(Location<String> loc,
                    String text)
```
  - logStart
```
protected void logStart(String text)
```
  - logEnd
```
protected void logEnd(String text)
```
  - hint_xml
```
protected void hint_xml(Location<XMLDocumentIdentifier> loc,
                        String text)
```
  - error
```
protected void error(Location<String> loc,
                     String text)
```
  - error
```
protected void error(Location<String> loc,
                     String text,
                     Object... args)
```
  - error
```
protected void error(String text)
```
  - failure
```
protected void failure(Location<String> loc,
                       String text)
```
  - failureDEF
```
protected void failureDEF(Location<XMLDocumentIdentifier> loc,
                          String text)
```
  - loadMetaDefinition
```
protected Definition loadMetaDefinition(Map<String,Definition> defs,
                                        String name)
```
  - loadMetaModule
```
protected void loadMetaModule()
```
  - warnOrError_incompleteHeader
```
protected void warnOrError_incompleteHeader(Location<String> loc,
                                            String missing)
```
  - scanForHeader
```
protected void scanForHeader()
```
    Sets modname==null and toplevelelementname==null => xsltmode=true Generates warnings/errors
  - isXsltDef
```
protected boolean isXsltDef(Definition def)
```
  - makealt
```
protected Alt makealt(CheckedList<Expression> subs)
```
  - makealt
```
protected Alt makealt(Collection<Reference> subs)
```
  - prepareXsltMode
```
protected void prepareXsltMode()
```
    The insertion of the target language classes into the content-containing xslt elements is done by once modifying the (copy of the) xslt declaration.
    Each reference to "xslt_generic_tag_for_backend_elements" = "RESULT_ELEMENTS" is hard rewritten to "(#chars|A|B|C)*", with "A", "B", etc. being the reachable target model element tags.
    The other side, i.e. the callability of ubiquituous content-producing xslt elements out of user content is done DYNAMICALLY, by special look-up code. Cf. the local "boolean inxslt" in function process_open_tag(String, boolean).
  - prepareXsltMode_text
```
protected void prepareXsltMode_text()
```
    For text mode the xslt module can be used directly, no rewriting is necessary but eliminating "xslt:RESULT_ELEMENTS"
  - errorcheck_xsltprepare
```
protected void errorcheck_xsltprepare(MessageCounter<SimpleMessage<XMLDocumentIdentifier>> cnt)
```
  - digest
```
protected void digest()
```
    Main loop, consumes input data according to current "micro"-state currentState. Only called once, from fromMemString(MemString). Calls the digest_<> delegate functions according to currentState. These are only called from here and could be in-lined. They mostly do not change micro-state themselves, but call #process_open_tag(String.boolean), #process_close_tag(String.boolean) or process_close_char().
    Each loop pass (and each delegate function) ends with calling scanner .accept().
    So when each loop pass (and each delegate function) starts, the next-to-consume token is already lexically recognized and ready for consumption.
  - digest_nothing_open
```
protected void digest_nothing_open()
```
    Initial (micro-)state, or after an explicit close. Switches currentState on command-char and on non-whitespace character data, which implies the invisible "char-data-tag". If the current top expression does NOT accept characters, then non-Whitespace is implicitly tagged as such, and that tag is searched up-ward, as usual. Whitespace however is accumulated and delayed for possible deliverance, until this happens. If the current top expression DOES accept characters, then whitespace is immediately treated as valid character data and delivered.
  - digest_look_for_tag
```
protected void digest_look_for_tag()
```
    After a command char has been read. An open tag or (two kinds of) close tag may follow. Whitespace, comments and further command chars are discarded, other chars lead to an error.
  - process_open_tag
```
protected void process_open_tag(String tag,
                                boolean isCharData)
```
    Only method for processing an "open" tag. Is called from digest_nothing_open() for character data, from digest_look_for_tag() for an explicit tag, and from digest_verbatim().
    ATTENTION: must be called in an "un-accepted" state of MemScanner, because next may come an "open tag modifier", which has to be decoded explicty, not by MemScanner.accept(). This may be followed by characters which are consumed by a "chars parser" or an "enum" definition, again not by the MemScanner! In these cases the outer state machine in not altered, but returned to.
    In case of a non-empty "tags parser", the state stack is extended accordingly by one level (or two levels in case of "#implicit".)
    In case of xslt-mode, the state machine is
```
      startInXslt=startXslt // whether current frame is an xslt
         | 
         | ascend into non-xslt, and NO xslt components are missing
         |    // if xslt itself is incomplete (CANNOT HAPPEN currently!), 
         |    //   then treat ALL missings as ERROR.
         V
      found_weakMode=true   // use "weak_firsts" modified director map
         |                  //   interpret all missing as "assumed"
         | 
         | cross open element boundary 
         V 
      all false, normal parsing // report "assumed" and collect all FURTHER
                                //   missings as errors
   
```
  - process_char_parser_error
```
protected void process_char_parser_error(String tag,
                                         MemString charsStart)
```
    Is called after a non-acceptions by char parser or by an enumeration has been detected. If no "partial doc output" is enabled: throw exception and abort parsing. Otherweise add Add diagnostic outputs with tags from "d2d-meta" into the result udom, set up skip container and switch parser state to parsingState.skip_for_command.
  - sortKeys
```
protected static String[] sortKeys(Enumeration e)
```
  - consume_enumeration
```
@Opt
protected static @Opt ResultingStructure consume_enumeration(MemScanner scan,
                                                                  Enumeration etype)
```
    Used by tag parsers AND character parsers (with multiple parallel scanners !)
  - process_close_char
```
protected void process_close_char()
```
    Called from digest_nothing_open/look_for_tag/consume_chars, in case that closing parenthesis character has been recognized. resets scanner and simulates the reaction to a "complete" close tag.
  - process_close_tag
```
protected void process_close_tag(String tag,
                                 boolean force)
```
    Called by digest_look_for_tag, process_open_tag (in case of empty element declarations), process_close_char. Tag may be =null for an unspecified "close lowest element"
  - process_close_tag_inner
```
protected void process_close_tag_inner(@Opt
                                       @Opt String tag,
                                       boolean force,
                                       Location<String> closeTagDefLoc)
```
    Search the state space for "nexttag" as possible close tag. Then adjust the stack accordingly. Whenever obligate entries are missing in between, then store them to "found_missing" and execute the error diagnosis.
    
    Parameters:
    
    nexttag - the tag of the element to close, or null to close the last opened element.
  - return_to_upper_input_mode
```
protected void return_to_upper_input_mode()
```
    Called to re-enter the input mode (verbatim or nothing_open) after an explicit close (tags had been openend and closed) or an implicit close (enum or character parser have consumed enough) has happened.
    Assume the stack frame of the parser/enum/closed tag is already popped from the stack.
    Assume that "inputmode verbatim" is only allowed with "content = (#PCDATA|..)*". TYPCHECKER MISSING FIXME.
  - insertPlainChars
```
public static void insertPlainChars(ResultingStructure host,
                                    Definition tag,
                                    String chars)
```
  - makeGlobalSkipContainer
```
protected void makeGlobalSkipContainer(ResultingStructure errormsg)
```
  - report_assumed_xslt_output
```
protected void report_assumed_xslt_output(State_singleton ss,
                                          CheckedList<Expression> misslist)
```
    Is called when an target-language open/close tag has been found after an xslt template call, to report the necessary expansion. Or as soon as the possible range of the template's output (one content model) is left, so that all further missing elements will be treated as normal "missing errors".
  - report_missing_elements
```
protected void report_missing_elements(boolean isOpen,
                                       String tag,
                                       boolean frameFound,
                                       CheckedList<Expression> misslist,
                                       List<SimpleMessage<String>> messlist,
                                       Location<String> closeTagDefLoc)
```
    this proc can be called from process_open_tag(String, boolean) or process_close_tag(String, boolean).
    Basically, there are two classes of error recovery:
    framefound = true ==> the tag is KNOWN, but tags before are missing, --- then continue with a shrunk stack state.
    
    framefound = false ==> the tag is NOT KNOWN, then discard all input up to the next tag and try again.
    
    General issue: these "Errors" behave like "Warnings" in case of "partialDocs==true".
    
    FIXME DocumentError should have TYPED fields like expression ,etc.
    FIXME parameter for controlling the kind of reaction MISSING FIXME
  - digest_consume_characters
```
protected void digest_consume_characters()
```
    When an element may receive character data, and some non-ws character data has been recognized at the reading position. Discards comments, delivers text, whitespace and other chars, and switches state on a command char.
  - ignore_superfluous_end_tag
```
protected void ignore_superfluous_end_tag(String tag,
                                          boolean defIsEmpty,
                                          Definition def,
                                          Location<String> startLoc)
```
    Called after an empty tag, a parser or an enum have been consumed. Called with scanner in the "un-accepted" state, but leaves after calling "accept()" (so the next token to digest == scanner.current)
    After a character parser there MAY appear an explicit closing tag:
    #tag 12[345]!!! #/tag or
    #tag 12[345]!!! #///tag or
    #tag 12[345]!!! #/ <-ws! or
    #tag$ 12[345]!!! $
    All these are to be IGNORED, since the application of the character parser must be finished (= it must have reached a final state OR an error stste!) anyhow.
    For empty content the situation is similar:
    #tag continue text do NOT consume anything.
    #tag#/tag continue text DO consume end-tag, but nothing more (esp. not the following blank!)
    #tag# /tag continue text this is ok, and treated the same way
    . #tag #/tag continue text this is NOT OK, and should be rejected
    #tag-continue word do NOT consume anything.
    #tag!! continue do consume the parentheses (has been done by lexer).
    #tag#///tag should possibly NOT be supported. If, then treat like simple end tag!
    
    Operation starts with an accept(), meaning "decode at current point of reading".
    On return, also an accept() has been performed, meaning "next lexer token to digest by the top level "digest" loop (=what follows after the ended element) is now reflected by the scanner output fields".
  - accept_superfluous_end_tag
```
protected boolean accept_superfluous_end_tag(String tag,
                                             boolean defIsEmpty,
                                             Definition def,
                                             Location<String> startLoc)
```
    Lets the scanner accept and discard an end tag, either normal or forced or by a parenthesis character. Only caller is #ignore_superfluous_end_tag(String,boolean)
  - digest_verbatim
```
protected void digest_verbatim()
```
    Parses "verbatim input" mode, which (a) requires an explicit #/tag end tag, and (b) accepts only tags of sub-elements immediatly contained in its definition.
  - digest_skip_for_command
```
protected void digest_skip_for_command()
```
    Micro-state for error recovery: skip until command char and then goto tag-reading mode again. Store the skipped input chars into skipContainer for meta-error-elements.
  - bicERROR
```
protected void bicERROR(String text,
                        boolean isCommand)
```
  - builtInMetaCommands
```
protected boolean builtInMetaCommands(String tag)
```
  - parseVerbatimSuppres
```
protected boolean parseVerbatimSuppres()
```
  - deliver_to_singletonstate
```
protected void deliver_to_singletonstate(ResultingStructure res,
                                         State_singleton tss)
```
  - deliver_numeric
```
protected void deliver_numeric(int val)
```
    Append the unicode character to the top-most resulting structure. A java string must contain two(2) "code units", what are 16bit "chars" for representing a code point > 0x0ffff, (int=32 bit char=16bit)
  - deliver
```
protected void deliver(ResultingStructure res)
```
    Append the argument to the top-most resulting structure.
  - deliver_spontanuous
```
protected void deliver_spontanuous(ResultingStructure res)
```
    Append the argument to the top-most resulting structure which is not encoded as xml attribute.
  - deliver
```
protected void deliver(ResultingChars chars)
```
  - deliver
```
protected void deliver(Udom res)
```
  - deliver_last
```
protected void deliver_last()
```
    Deliver the last scanned character data, and set the "is whitespace" flag according to the token type returned by scanner.
  - addRestPerm
```
protected void addRestPerm(State_perm permstate,
                           CheckedList<Expression> misslist)
```
    Add obligate members of a "perm" expression to the term which describes the missing input.
  - find_top_singleton
```
protected State_singleton find_top_singleton()
```
    Called from return_to_upper_input_mode(). and .... DELIVER()??? AND OPEN XSLTMODE ??
  - find_top_singleton
```
protected State_singleton find_top_singleton(boolean mustBeNonAtt)
```

Class Text2Udom

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

default_ErrorStrategy

interactive_ErrorStrategy

moduleRegistry

scanner

msg

xml_msg

errorStrategy

charSetCalc

doTrace

meta_module

meta_warning

meta_location

meta_messageText

meta_kind

meta_tag

meta_parsingError

meta_expected

meta_skipped

meta_assumedXsltOutput

toplevel_fileLocation

modulename

toplevelModule

toplevelelementname

toplevelXRegExp

version_2_0_selected

xsltInputNamespaces

top_result

xsltmode

xslt_alt_ubiquituous

xslt_alt_ubiquituous_repeated

xslt_module

state

found_eof_parsed

leading_ws

currentState

verbatimSuppress

interruptedState

skipContainer

lastCloseWasXslt

sloppyHeaderSyntax

xslt_modulename

xslt_generic_tag_for_backend_elements

xslt_tag_toplevel

xslt_tag_ubiquituous

xslt_prefices

locnull

co_resolve

makeRef

getFullPath

allSortedKeys

MEMSTRING_ID_SYNTHETIC

synthLocation

bicLoc

Constructor Detail

Text2Udom

Text2Udom

Method Detail

non_interactive_ErrorStrategy

P

getXsltInputNamespaces

fromFile

fromFile

fromMemString

fromMemString

warning

warning

hint

logStart

logEnd

hint_xml

error

error

error