D2d -- XML for Authors
aa r X i v : . [ c s . P L ] M a y D2d — XML for Authors (Technical Report – Bad Honnef 2013)
Markus Lepper and Baltasar Tranc´on y Widemann < semantics /> GmbH, Berlin [email protected] d2d
XML is a de facto standard for the encoding of semi-structured text corpora. Itspractical application ranges from mere technical configuration data to web siteswith entertaining contents.Both notions, “XML” and “text”, stand here for very different things: On oneside the organization of the internal computable text model as a tree structurewith its standardized update and retrieval methods (“W3C DOM”), and thefamily of tools operating on these (implementing “XSLT”, “XQuery”, etc.). Onthe other side its external representations: unicode text files containing a lot of“angled braces”, their decoding ruled by a historically grown collection of hardlyunderstandable, non-compositional quoting rules.All this hinders the creation of XML encoded texts in the creative flow ofauthoring . Neither are syntax controlled editors, which support tagging by menudriven selections, auto completion, automated coloring and indenting, a solutionfor all those authors which are used to “writing” as a creative, flowing, intuitiveand intimate process, in direct contact with that mysterious thing called text.So far XML appears inappropriate for this kind of authoring situation. Nev-ertheless often its use is highly desirable: Technical documentations, cookbooks,screen plays, song lyrics, scientific analyses, even multi-volume fantasy novelscan profit extraordinarily by only little interspersed mark-up.This is the starting point of the “ d2d ” project. It stands for “directly todocument” or “direct document denotation”, hence pronounced “triple dee”,and it tries to close this gap. It is both, a text format which realizes XML mark-up in a very unobtrusive way, and it is a software system which implementsparsing, translating, parser definitions, documentation, user guidance, etc.It is based on a simple idea, the realization of which turned out to be sur-prisingly complex, and has been driven on by the authors for now more than tenyears. The main characteristics are: – Simple way of writing and good readability by humans (without the needfor any dedicated tool) as well as by machines. – All tags marked with one single, user-defined character. – Inference of (nearly all) closing tags. A rather early version is described in [4]; full documentation can be found at [6].
Lepper, Tranc´on: D2d – XML for authors – Inference also of opening tags by a second, character-based level of parsers,used for small, highly structured data entities, interspersed in flow text. – Support of standard text format definition formats (e.g. W3C DTD). – Own language for text format definition (required at least for the characterlevel parser definition). It employs free rewriting for parametrization andre-use of modules, and multi-lingual user documentation.So d2d is a concept, a format and a software system which addresses domainexperts and enables them to write XML compatible texts and potentially opensto them the whole world of XML based processing.
D2d has been sucessfullyemployed in the very diverse fields of technical documentation, book keeping,web content creation, interactive music theory, etc. d2d
Parsing Process d2d
Parsing Process
The process of reading a text file, interpreting it as conforming to particular textformat definition in the d2d format, and constructing the corresponding internalmodel, is called “
D2d parsing”. This model can be written out as an externalrepresentation according to the XML standard [1]. The implementation of the d2d tool also allows to process this model directly, e.g. using a collection of XSLTrules to derive other models to be written out. The parsing process is controlledby the chosen root element. Element definitions can have tagged or charactercontent models:In the tagged case, the resulting sub-tree of the model is constructed ac-cording to the tags appearing in the input text. Tags are marked by a singleuser-defined lead-in character, which defaults to “ ”. Closing tags can in mostcases be omitted, because the parser uses simply LL(1) strategy: Whenever anopening tag can be accepted on some currently open higher level in the resulttree, all intervening closing tags are supplied automatically. Nevertheless explicitclosing tags may be added to resolve ambiguities, to close more than one stacklevel, or to increase the readability of the source.
Character based parsers accept plain character data. All tagging is addedautomatically as defined in the applicable parser rules. The basic strategy is anon-deterministic longest match. Thus this mechanism performs well for shortinput data, e.g. some ten lines of MathML. In practice this covers most instancesof structured entities, interspersed in flow text. Besides, non-deterministic rulesare much easier definable by computer language laymen.
Every file to be processed by the d2d tool may start with sections containinglocal definitions. These have the form α d2d 2 . µ C = // allowed input characters I = // allowed identifiers D ::= chars ( C ⋆ ) | comment ( C ⋆ ) | eof | error ( C ⋆ ) | warning ( C ⋆ ) | OPEN i : I | CLOSE i : I | CLOSE Fi :( I ∪{ } ) | EMPTY i : I | EMPTY Fi : I tokenize : C ⋆ → D ⋆ : ( D ⋆ × C ⋆ × ( C × I ) ⋆ ) → ( D ⋆ × C ⋆ × ( C × I ) ⋆ )( hi , α, hi ) ( δ, hi , hi ) tokenize ( α ) = δ Parenths : C → C Parenths = { ’ ( ’ ’ ) ’ , ’ < ’ ’ > ’ , ’ [ ’ ’ ] ’ , ’ { ’ ’ } ’ , ’ . ’ ’ . ’’ ! ’ ’ ! ’ , ’ \ ’ ’ \ ’ , ’ : ’ ’ : ’ , ’ $ ’ ’ $ ’ , ’ ↑ ’ ’ ↑ ’ } α, α ′′ ∈ C ⋆ α ′′ = hi δ ∈ D ⋆ γ ∈ ( C \ { NL } ) ⋆ γ ′ = a ∗ ( a κ ∈ dom Parenths ∧ κ ′ = Parenths ( κ ) ζ ∈ ( | | . . . | ) , ( | | . . . | | a | . . . | f ) ⋆ ∧ ζ ′ = char ( parseInt ( ζ )) α ′ ∈ ( C \ { , κ ′ } ) + ∧ α ′ = a (( a ∧ α ′ = a ( ∗ a ( δ, | | NL ) + a α, π ) ( δ, ◮ α, π )( δ, ( ( γ NL ◮ α, π ) ( δ ◭ comment ( γ ) , NL ◮ α, π )( δ, ( ∗ γ ′ ∗ ( ◮ α, π ) ( δ ◭ comment ( γ ′ ) , α, π )( δ, someTag ( | NL ) ◮ α, π ) ( δ ◭ OPEN someTag , α, π )( δ, someTag κ ◮ α, π ) ( δ ◭ OPEN someTag , α, ( κ ′ , someTag ) ◮ π )( δ, κ ′ ◮ α, ( κ ′ , someTag ) ◮ π ) ( δ ◭ CLOSE someTag , α, π )( δ, someTag/ ◮ α, π ) ( δ ◭ EMPTY someTag , α, π )( δ, someTag/// ◮ α, π ) ( δ ◭ EMPTY F someTag , α, π )( δ, someTag ◮ α, π ) ( δ ◭ OPEN someTag , α, π )( δ, ζ / ◮ α, π ) ( δ ◭ chars ( ζ ′ ) , α, π )( δ, ζ ◮ α, π ) ( δ ◭ chars ( ζ ′ ) , α, π )( δ, /someTag ( | NL ) ◮ α, π ) ( δ ◭ CLOSE someTag , α, π )( δ, ///someTag ( | NL ) ◮ α, π ) ( δ ◭ CLOSE F someTag , α, π )( δ, / ( | NL ) ◮ α, π ) ( δ ◭ CLOSE , α, π )( δ, /someTag ◮ α, π ) ( δ ◭ CLOSE someTag , α, π )( δ, ///someTag ◮ α, π ) ( δ ◭ CLOSE F someTag , α, π )( δ, / ◮ α, π ) ( δ ◭ CLOSE , α, π )( δ, α ′ ◮ α, ( κ ′ , ) ◮ π ) ( δ ◭ chars ( α ′ ) , α, ( κ ′ , ) ◮ π )( δ, eof ◮ α, π = hi ) ( δ ◭ warning (“pending parentheses”) , eof ◮ α, hi )( δ, eof ◮ α ′′ , hi ) ( δ ◭ warning (“discarding trailing characters”) , eof , hi )( δ, eof , hi ) ( δ ◭ eof , hi , hi )( δ, hi , π ) ( δ ◭ error (“premature end of file”) , hi , hi ) Table 1.
Basic Data and Tokenization α is a prefix not containing such a section, and will be discarded totally.This allows d2d input to be contained in arbitrary documents, like e-mails etc. µ must be a valid module definition in the ddf format (see Section 3). It willbe parsed and the contained definitions can be used immediately in the followingtext corpus.Zero to many such local definition sections can be contained in an input file.Finally it has to follow either α d2d 2 . m : t In this case m is the name of a module, and t is the name of a tag parser definitionfrom m . This is used as the topmost element for the document structure tobe parsed and thus defines the initial state of the parsing process. The otherpossibility is α d2d 2 . m : t In this case an XSLT source will be parsed, and the module and tag do identifythe top-level element of the output to be generated by the XSLT code.In both cases, the rest of the file immediately after the “ t ” is the text corpusinput, fed to the d2d parser, up to a final explicit “ ”. The function tokenize in Table 1 defines the next step for processing the textcorpus data (not the local module definitions), namely converting the streamof characters into a stream of tokens. The comment lead-in character “ ( ” andthe command character “ / ”and “ ”, resp. The tokenization process is defined by applying a longest prefixmatch discipline to the transformation rules given for “ ”. The closing andempty tags with three slashes mark those elements which are intentionally leftincomplete by the user. The reaction of the tools in these cases is configurable.The tokenization level supports a limited set of one character parentheses, asknown from sed’s “ s%...%...% ” and L A TEX’s “ \ verb%...% ” syntax. It is unre-lated to the parser level, which can cause funny effects, but which neverthelesshas turned out to be the cleanest way to define. The second step, parsing, is to convert a sequences of tokens from D ⋆ to a singlenode from N , as defined by the function text2tree () in Tables 2 and 3. Thisnode represents the top-most element of the resulting document model, whichcan later be shipped out to standard XML file format, or further processed byXSLT, as soon as completed.Parsing always starts in tag mode, i.e. looking for explicit tags “
OPEN i ” inthe token stream. Character data is treated as if tagged with an implicit pseudo-tag “ chars ”. The tag parsing process is a stack-controlled recursive descent The formulas in this tables have been published in [3]. F is possibly addedand the corresponding content model is made the new accepting state machine.This is performed by the function descend (), which delivers a new stack prefix.Its definition is comparably simple, since (a) it is only called when the next tag i is contained in first ( t ), and (b) all first sets in all alternatives are disjoint.The stack levels represent the choice points at which the parsing process canlater be continued. Whenever a tag (opening or closing tag) is reached whichcannot be consumed in the current state, the stack is unwound in search for thefirst possibility by functions ascend O () and ascend C (). Only if such is found, allintermediate stack frames are closed, and all material collected there is packedinto node objects. (The third parameter of the functions is an accumulator forthese; finally their sequence is wrapped in the highest closed node and appendedto the contents of the parent element’s node ). If some non-optional content ismissing in the closed frames, an error message element “ missing() ” is synthe-sized and inserted into the resulting model. If no such frame is found, the input isignored, the stack left unchanged, and a “ skipped() ” error message is inserted,instead.Due to this feature, the translate function is always total , an important fea-ture when addressing domain experts, who are not language experts. An inter-esting philosophical question is the definition of the content model reported by missing (): E.g. when the original syntax requires something like “ (a|b)?, x,d+ ”, which is not matched by the input, then minimally only “ x,d ” is required(in the strict sense of the word) to make the input complete. Nevertheless wedecided to report the subexpression from the original structure definition as awhole, to make the error more easily locatable by the user. The algorithm is slightly enhanced to parse XSLT sources. In these, elements(and attributes) of the XSLT language and those of the target language appearintermingled. Again, we want to write with least noise, and both categories thusmust be recognized automatically, as far as possible. These measures are taken: – Basically, the XSLT language and the target language must be providedas text structure definitions. They will be parsed by switching between thecorresponding state machines, in the style of “co-routines”. – All reachable elements of the target language are collected, and all XSLTelements which are allowed to contain target language elements. – Whenever parsing the contents of an element from the latter set, an openingtag of the former set may appear, additionally to the normal parsing ascontrolled by the XSLT grammar state machine. – Vice versa, dedicated (“productive”) XSLT elements can contain anywhere ina target element. Whenever this happens, the parsing process is switched to“weak mode”, a variant, in which every target content expression is allowedto additionally match the empty string, as if decorated with a “ ? ”.A more promising approach will be the integration of Fragmented Validation(FV) . This is a technique of parsing the result fragments in an XSLT source5 Lepper, Tranc´on: D2d – XML for authors N ::= node ( I, N ∗ ) | chars ( C ⋆ ) | perm ( T × ( T N ⋆ )) | missing ( T ) | skipped ( D ) T ::= ’ . . . ’ | " . . . " | . . . | T .. T | T U T | T A T | T - T | T ~ T | T ~+ | T ~* | > T | [ id T ] | | T , T | T + | T * | T ? | T & T | T | T | T ˆ ( T / id ) | id | @ id | ( T ) | | X R // many additional attributes: representation, docu, XSLT, etc.Definition ∧ = [ tag : I ; kind : { tags , chars } ; regExp : T ; repr : X R ] defs : I Definition text2tree : D ⋆ × I → NF = T × N ⋆ translate : D ⋆ × F ⋆ → D ⋆ × F ⋆ translate ( d, h ( defs ( i ) . regExp , hi ) i ) = ( h eof i , h ( , n ) i ) text2tree ( d, i ) = nI C = I ∪ { chars } skip , skip C : D ⋆ × F ⋆ → D ⋆ × F ⋆ first : T → F I C // the “first” set of the regexp potEps : T → boolean // whether regexp matches empty input ascend O : I C × F ⋆ × F ⋆ → F ⋆ ascend C : I × F ⋆ × F ⋆ → F ⋆ descend : T × I C → F ∗ e = chars ( ) skip C ( chars ( x ) ◮ δ, ( t, τ ) ◮ φ ) = skip C ( δ, ( t, τ ◭ skipped ( chars ( x ))) ◮ φ ) skip C ( e ◮ δ, φ ) = e ◮ δ, φ skip ( d ◮ δ, ( t, τ ) ◮ φ ) = skip C ( δ, ( t, τ ◭ skipped ( d )) ◮ φ ) φ ′ = ascend C , ( j, φ, hi ) translate ( CLOSE j ◮ δ, φ ) = ( translate ( δ, φ ′ ) if φ ′ = hi translate ( skip ( CLOSE j ◮ δ, φ )) otherwise φ = ( t, ) ◮ φ ′ = ascend O ( j, φ, hi ) translate ( OPEN j ◮ δ, φ ) = translate ( δ, descend ( t, j ) a φ ) if j ∈ first ( t ) translate ( δ, descend ( t, j ) a φ ′ ) if j first ( t ) ∧ φ ′ = hi translate ( skip ( OPEN j ◮ δ, φ )) otherwise f = ( t, ν ) φ ′ = ascend O ( chars , f ◮ φ, hi ) ∆ = chars ( x ) ◮ δ translate ( ∆, f ◮ φ )= translate ( δ, ( t, ν ◭ chars ( x )) ◮ φ ) if chars ∈ first ( t ) translate ( ∆, φ ′ ) if chars first ( t ) ∧ φ ′ = hi translate ( skip C ( ∆, f ◮ φ )) otherwise translate ( EMPTY j ◮ δ, φ ) = translate ( OPEN j ◮ CLOSE j ◮ δ, φ ) Table 2.
Tag Parsing t, t ′ , t n ∈ T i ∈ I C i ′ ∈ Ii ∈ first ( t ) i first ( t ′ ) (cid:3) ∈ { + , * } p = t & . . . & t & . . . & t n descend (( t , t , . . . , t n ) , i ) = descend ( t, i ) ◭ (( t , . . . , t n ) , hi ) descend (( t ′ , t , . . . , t n ) , i ) = descend (( t , . . . , t n ) , i ) descend (( t | . . . | t | . . . | t n ) , i ) = descend ( t, i ) descend ( p, i ) = descend ( t, i ) ◭ ( t, perm ( p, {} )) descend ( t (cid:3) , i ) = descend ( t, i ) ◭ ( t (cid:3) , hi ) descend ( t ? , i ) = descend ( t, i ) descend ( i ′ , i ′ ) = h ( defs ( i ′ ) . regExp , hi ) i descend ( chars , chars ) = hi i, j ∈ I i = j t ∈ T (cid:3) ∈ { + , * } S = ( t , t , . . . , t n ) ∈ T ascend C ( i, ( j, ν ) ◮ φ, τ ) = ascend C ( i, φ, h node ( j, ν a τ ) i ascend C ( i, ( i, ν ) ◮ ( t, µ ) ◮ φ, τ ) = ( t, µ ◭ node ( j, ν a τ )) ◮ φ ascend C ( i, ( t (cid:3) , ν ) ◮ φ, τ ) = ascend C ( i, φ, ν a τ ) ascend C ( i, ( S, ν ) ◮ φ, τ ) = ( ascend C ( i, φ, ν a τ ◭ missing ( S )) if ¬ potEps ( S ) ascend C ( i, φ, ν a τ ) otherwise i ∈ I t = ( t & . . . & t n ) M = { t k v k , . . . , t k m v k m } M ′ = M ∪ { t x τ } matches ( t y ) = t y ∈ { t , . . . , t } ∧ i ∈ first ( t y ) ∧ t y dom M ′ R = { t k ∈ { t . . . t n }| t k dom M ′ ∧ ¬ potEps ( t k ) } R ′ = & ( | R | ) ascend C ( i, ( t x , perm ( t, M )) ◮ φ, τ )= ( ascend C ( i, φ, h perm ( t, M ∪ { t x τ ◭ missing ( R ′ ) } ) i ) if R = {} ascend C ( i, φ, h perm ( t, M ′ ) i ) otherwise ascend O ( i, ( t x , perm ( t, M )) ◮ φ, τ )= ( t y , perm ( t, M ′ )) ◮ φ if ∃ t y • matches ( t y ) ascend O ( i, φ, h perm ( t, M ∪ { t x τ ◭ missing ( R ′ ) } ) i ) otherwise , if R = {} ascend O ( i, φ, h perm ( t, M ′ ) i ) otherwise i, j ∈ I t, t ′ ∈ T (cid:3) ∈ { + , * } i ∈ first ( t ) i first ( t ) S = ( t , t , . . . , t n ) ∈ T ascend O ( i, ( j, ν ) ◮ φ, τ ) = ascend O ( i, φ, h node ( j, ν a τ ) i ascend O ( i, ( t (cid:3) , ν ) ◮ φ, τ ) = ( t (cid:3) , ν a τ ) ◮ φ ascend O ( i, ( t ′ (cid:3) , ν ) ◮ φ, τ ) = ascend O ( i, φ, ν a τ ) ascend O ( i, ( S, ν ) ◮ φ, τ )= (( t , . . . , t n ) , ν a τ ) ◮ φ ) if i ∈ first ( t ) ascend O ( i, (( t , . . . , t n ) , ν ) ◮ φ, τ ◭ missing ( t )) otherwise , if ¬ potEps ( t ) ascend O ( i, (( t , . . . , t n ) , ν ) ◮ φ, τ ) otherwise , if n ≥ ascend O ( i, φ, ν a τ ) otherwiseTable 3. Tag Parsing, continued d2d tool. – The tags of the target language have priority over the same tags from XSLT.For these prefixed aliases are generated automatically, whenever necessary.In practice it turned out that this format for writing down XSLT sourcesallows a work-flow nearly as with a dedicated programming language front-end.
Whenever the opening tag of an element has been consumed which is declared asa character parser, the text input is redirected to the parsing process as definedin Table 4. Character based parsers have non-deterministic semantics: A set ofhypotheses is maintained in parallel, and at the end the longest matched prefixis delivered.The first operator special for the character level is “ ~ ”, which is a sequentialcomposition without intervening whitespace. This hold also for the repetitionoperators “ ~* ” and “ ~+ ” The operator “ , ” is taken over from the tag level,for convenience, and means sequential composition with arbitrary interveningwhitespace. The operator “ & ” for permutation is currently not supported oncharacter level. The operator “ > ” defines a greedy sub-expression, where non-determinism is overruled by longest prefix matching. The operators “ ~* ” and“ ~* ” are greedy anyhow, when they are applied to plain character sets.The generated and output XML expression will be one single element, withthe parser’s identifier as its tag, if no structure is defined. This is done by nestingthe constructs “ [ i T ] ”, which generate an element with i as its tag and theparsed contents. This again is simply the parsed character data, if no such con-structs are contained recursively, or the sequence of the resulting XML elements,otherwise.Immediately after the character parser cannot be continued, control returnsto the tag parsing level. Now an explicit closing tag for the parser may follow,but is never required. The genuine d2d text structure definition language “ddf” supports (a) the defini-tion of the element content models, as tag or character parsers, plus (b) variousadditional parameters.The content models follow basically the same design principles as knownfrom W3C DTD [1] or relaxNG [2]. Differences are the “ & ” operator, whichdoes not stand for interleaving (as in relaxNG), but only for permutation. Newis the “ @ ” operator, which inserts the content model of the referred definitioninto any expression, allowing a definition to act as element specification and asmere internal constant (with an expression as its value).Each definition may carry attributes related to very different layers: TheXML tag can be set, overriding the identifier of the definition, which is the8epper, Tranc´on: D2d – XML for authors 9 S = N × N ⋆ parseM : T × F S → F S parse : T × S → F S parseM ( t, s ) = [ s ′ ∈ s • parse ( s ′ ) parse ( t, {} ) = {} parse ( t ? , s ) = parse ( t, s ) ∪ { s } parse ( t ~* , s ) = parseM ( t ~* , parse ( t, s )) ∪ { s } parse ( t ~+ , s ) = parseM ( t ~* , parse ( t, s )) parse ( t | t , s ) = parse ( t , s ) ∪ parse ( t , s ) parse ( " α " , ( p, n )) = ( { ( p + len ( α ) , n ) } if α is prefix of data at pos p {} otherwise parse ( ’ α ’ , ( p, n )) = ( { ( p + 1 , n ) } if character at pos p is contained in α {} otherwise parse ( t | t , s ) = parse ( t , s ) ∪ parse ( t , s ) parse ( t , t , s ) = parse ( t ~ " "* ~ t , s ) parse ( t , s ) = S parse ( t ~ t , s ) = parseM ( t , S ) parse ( > t , s ) = µ { ( p, r ) ∈ S | ( ∀ ( p ′ , ) ∈ S • p ′ ≤ p ) } parse ( t , ( p, r )) = S pack ( p ′ , r ′ ) = ( p ′ , r ◭ node ( i, packRes ( p ′ , r ′ )) packRes ( p ′ , r ′ ) = ( chars ( data . substring [ p, p ′ ]) if r ′ == hi r ′ otherwise parse ( [ i t ] , ( p, r )) = pack ( | S | ) Table 4.
Character Based Parsing
90 Lepper, Tranc´on: D2d – XML for authorsdefault; an XML namespace URI can be defined; different formats for editingand parsing can be specified; definitions can open a local scope for tags; etc.More importantly: User documentation in different languages can be attachedto every definition, and XSLT rules for transformation into different back-ends.Both features employ d2d recursively to document or process itself: The formeremploys some standard format for technical documentation, readable by humans;the latter employs the XSLT source format, as described above, instantiated withthe text structure definition of the target format.All definitions are organized in a hierarchy of modules; each top module mustbe locatable by some rules matching the module name to a file location, or sim.Modules can be imported into other modules. Thereby an “import key” isdefined, which used as a prefix makes the definitions in the imported moduleaccessible in all expressions in the importing module. This includes “automaticre-export”: the imports in the imported module are accessible by concatenatingthese import keys, etc.Additionally, substitutions can be defined which apply to all expressions inthe imported module (or only the expression of one particular definition). Eachsuch substitution replaces a particular reference, i.e. a sequence of identifiersmeant as a reference to a definition, by a given expression, evaluated in thecontext of the importing module. Furthermore, a particular module import inthe imported module can be replaced by a different one, defined in the importingmodule, as a whole. This selection of mechanisms for parametrization has turnedout to be very powerful and adequate when maintaining and developing mid-scale text structure architectures, like the examples listed at the beginning.
References
1. Tim Bray, Jean Paoli, C.M. Sperberg-McQueen, Eve Maler, Fran cois Yergeau, andJohn Cowan.
Extensible Markup Language (XML) 1.1 (Second Edition) . W3C, , 2006.2. Clark and Murata.
Document Schema Definition Language (DSDL) –Part 2: Regular-grammar-based validation – RELAX NG . ISO/IEC, http://standards.iso.org/ittf/PubliclyAvailableStandards/c052348_ISO_IEC_19757-2_2008(E).zip ,2008.3. Markus Lepper and Baltasar Tranc´on y Widemann. d2d — a robust front-endfor prototyping, authoring and maintaining XML encoded documents by domainexperts. In Joaquim Filipe and J.G.Dietz, editors,
Proceedings of the InternationalConference on Knowledge Engineering and Ontology Delelopgment, KEOD 2011 ,pages 449–456, Lisboa, 2011. SciTePress.4. Markus Lepper, Baltasar Tranc´on y Widemann, and Jacob Wieland. Minimze mark-up ! – Natural writing should guide the design of textual modeling frontends. In
Conceptual Modeling — ER2001 , volume 2224 of
LNCS . Springer, November 2001.5. Markus Lepper and Baltasar Tranc´on y Widemann. Fragmented validation — asimple and efficient contribution to xslt checking (extended abstract). In
Proc.ICMT 2013, Int. Conference on Theory and Practice of Model Transformations ,volume 7909 of
LNCS . Springer, 2013.6. Baltasar Tranc´on y Widemann and Markus Lepper.
The BandM Meta-Tools UserDocumentation . http://bandm.eu/metatools/docs/usage/index.html , 2010., 2010.