I have spent a considerqable amount of time doing research on the web 
looking for a suitable OS Editor for OSIS Markup. Unfortunately I 
couldn't find any that would help in providing the tags in an 
appropriate context.
Quanta Plus has support for DTDs but no XSDs, Kate would accept 
osisCore.dtd if one would exist. And here is my question:
why OSIS Initiative folks have not yet made available an osisCore.dtd?
We would be able to use so many editors to make modules.

Does anyone know anything about that?

regards,
Benedict

Benedict,

Here are a couple of reasons:
1) You cannot express with a DTD the validation structures we are able
to express with XML Schema.
2) XML Schema is the next step in technology/standards and follows after
DTD, so it make sense to use XML Schema rather than a DTD.  If we were
to publish both a DTD and an XML Schema then we would have two standards
and what is valid with respect to the DTD would not necessarily be valid
with respect to the XML Schema.

For your own personal use you can generate a DTD that closely mirrors
the standard OSIS Schema for use with software tools you may find
useful, but you should always validate with the proper OSIS Schema.

Additionally, just because a document is valid with respect to the OSIS
Schema, does not necessarily mean that it is "OSIS valid" because there
are validity constraints that can not be expressed with XML Schema..

Todd
[...]

Todd Tillinghast wrote:[...]

Hi Todd,
thanks for clarification. I just found out that quanta plus has the 
capability to help in writing xml files providing the features I was 
looking so ardently for the last couple of days. I tried ThML1.0.dtd and 
it performs great. It gives me the ability to insert tags contextually.
How can I generate a DTD from osisCore.xsd?


I am just a user and have no expertise in XML...

Thanks
Benedict

The easiest way I have found is to use the XML Spy Convert DTD/Schema
feature.  You can download the software at www.altova.com.

Todd
[...]
able[...]
and[...]
contextually.[...]

As another would be simple user, I've been playing with the Word add-in, 
which does most of what I want. I am a bit puzzled why MSWord was chosen 
rather than Open Office but I assume there were technical issues. A 
freely available editor that non-techies can use would really help those 
who want to produce OSIS content...

Tim
[...]

Anyone checked into using this one? It says it is schema aware.
http://www.xmlmind.com/xmleditor/

Jim Albright
704 843-0582
Wycliffe Bible Translators

Hi -

While Todd is completely right, Benedict's point is well taken too:
Why not make it easier for your users by providing non-normative
versions in different schema languages, in addition to the normative
W3C Schema version? This is what the DocBook community does, for
example.

To edit XML files, I personnally recommend emacs with James Clark's
excellent nxml mode (http://www.thaiopensource.com/download/).
It does
auto-completion, on-the-fly validation, syntax highlighting, and much
more.

It requires the schema to be expressed in RELAX NG Compact
Syntax. Details and conversion tools are freely available
(http://www.thaiopensource.com/relaxng/).
For your convenience, I
include a suitable (non-normative) RELAX NG version of OSIS 2.0 with
this message. I generated it by converting the W3C Schema version to
RELAX NG XML Syntax using Sun's rngconv (https://msv.dev.java.net/),
and then converting the result to Compact Syntax using James Clark's
Trang (http://www.thaiopensource.com/relaxng/trang.html).

Justus


Save the following, up to but not including my .signature, into a file
osisCore.2.0.rnc:

default namespace =
  "http://www.bibletechnologies.net/2003/OSIS/namespace"

start =
  notAllowed
  | element osis {
      attribute TEIform { "TEI.2" }?,
      (element osisCorpus {
         attribute TEIform { "teiCorpus.2" }?,
         (element header { headerCT }?,
          element titlePage { titlePageCT }?,
          element osisText { osisTextCT })+
       }
       | empty
       | element osisText { osisTextCT })
    }
headerCT =
  (attribute canonical { xsd:boolean }?,
   attribute TEIform { "teiHeader" }?,
   (notAllowed
    | element revisionDesc {
        attribute TEIform { "revisionDesc" }?,
        globalWithType,
        attribute canonical { xsd:boolean }?,
        element date { dateCT },
        element p { pCT }+
      })*,
   (notAllowed
    | element work {
        globalWithType,
        attribute osisWork {
          xsd:string {
            pattern = "((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?"
          }
        },
        element title { titleCT }?,
        element contributor { contributorCT }*,
        element creator { creatorCT }*,
        element subject { subjectCT }*,
        element date { dateCT }*,
        element description { descriptionCT }*,
        element publisher { publisherCT }*,
        element type { typeCT }*,
        element format { formatCT }*,
        element identifier { identifierCT }*,
        element source { sourceCT }*,
        element language { languageCT }*,
        element relation { relationCT }*,
        element coverage { coverageCT }*,
        element rights {
          globalWithType,
          attribute canonical { xsd:boolean }?,
          xsd:string
        }*,
        element scope {
          attribute canonical { xsd:boolean }?,
          globalWithType,
          list {
            xsd:string {
              pattern =
               
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
            }*
          }
        }*,
        element castList {
          attribute TEIform { "castList" }?,
          globalWithType,
          attribute canonical { xsd:boolean }?,
          element castGroup {
            attribute TEIform { "castGroup" }?,
            globalWithType,
            attribute canonical { xsd:boolean }?,
            (element head { headCT }
             | element castItem {
                 attribute TEIform { "castItem" }?,
                 globalWithType,
                 attribute canonical { xsd:boolean }?,
                 (element actor {
                    attribute TEIform { "actor" }?,
                    globalWithType,
                    attribute who { xsd:string }?,
                    attribute canonical { xsd:boolean }?,
                    (element a { aCT }
                     | element abbr { abbrCT }
                     | element foreign { foreignCT }
                     | element index { indexCT }
                     | element note { noteCT }
                     | element reference { referenceCT }
                     | element seg { segCT }
                     | element w { wCT })*
                  }
                  | element role {
                      attribute TEIform { "role" }?,
                      globalWithType,
                      attribute canonical { xsd:boolean }?,
                      (element a { aCT }
                       | element abbr { abbrCT }
                       | element foreign { foreignCT }
                       | element index { indexCT }
                       | element note { noteCT }
                       | element reference { referenceCT }
                       | element seg { segCT }
                       | element w { wCT })*
                    }
                  | element roleDesc {
                      attribute TEIform { "roleDesc" }?,
                      globalWithType,
                      attribute canonical { xsd:boolean }?,
                      (element a { aCT }
                       | element abbr { abbrCT }
                       | element foreign { foreignCT }
                       | element index { indexCT }
                       | element note { noteCT }
                       | element reference { referenceCT }
                       | element seg { segCT }
                       | element w { wCT })*
                    })*
               })*
          }*
        }*,
        element teiHeader {
          mixed {
            attribute TEIform { "teiHeader" }?,
            element0+
          }
        }?,
        element refSystem {
          globalWithType,
          attribute canonical { xsd:boolean }?,
          xsd:string
        }*
      })+),
  empty
sourceCT =
  (attribute canonical { xsd:boolean }?,
   globalWithType,
   xsd:string),
  empty
indexCT =
  (attribute TEIform { "index" }?,
   globalWithType,
   attribute see { xsd:string }?,
   attribute level4 { xsd:string }?,
   attribute level3 { xsd:string }?,
   attribute level2 { xsd:string }?,
   attribute level1 { xsd:string },
   attribute index { xsd:string },
   attribute canonical { xsd:boolean }?),
  empty
relationCT =
  (globalWithType,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
pCT =
  mixed {
    attribute TEIform { "p" }?,
    globalWithType,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element catchWord { catchWordCT })
     | (notAllowed
        | element chapter { chapterCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element figure { figureCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element rdg { rdgCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element salute { saluteCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element signed { signedCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element speech { speechCT })
     | (notAllowed
        | element table { tableCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element verse { verseCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
figureCT =
  (attribute TEIform { "figure" }?,
   globalWithType,
   attribute src { xsd:string }?,
   attribute osisRef {
     list {
       xsd:string {
         pattern =
          
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
       }*
     }
   }?,
   attribute canonical { xsd:boolean }?,
   attribute alt { xsd:string }?,
   ((notAllowed
     | element caption {
         mixed {
           attribute TEIform { "figDesc" }?,
           attribute canonical { xsd:boolean }?,
           globalWithType,
           (element a { aCT }
            | element abbr { abbrCT }
            | element date { dateCT }
            | element divineName { divineNameCT }
            | element foreign { foreignCT }
            | element hi { hiCT }
            | element index { indexCT }
            | element lb { lbCT }
            | element milestone { milestoneCT }
            | element name { nameCT }
            | element note { noteCT }
            | element q { qCT }
            | element reference { referenceCT }
            | element seg { segCT }
            | element w { wCT })*
         }
       })
    | (notAllowed
       | element index { indexCT })
    | (notAllowed
       | element note { noteCT }))*),
  empty
globalWithType =
  attribute script {
    xsd:string { pattern = "([A-Z][a-z]{3}|x-[A-Za-z0-9]+)" }
  }?,
  space?,
  lang?,
  attribute n { xsd:string }?,
  attribute subType {
    xsd:string { pattern = "x-([^\s])+" }
  }?,
  attribute type {
    xsd:string { pattern = "x-([^\s])+" }
  }?,
  attribute resp { xsd:string }?,
  attribute osisID {
    list {
      xsd:string {
        pattern =
         
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?"
      }*
    }
  }?,
  attribute ID { xsd:ID }?,
  attribute annotateType {
    (xsd:string "studyGuide"
     | xsd:string "translation"
     | xsd:string "rebuttal"
     | xsd:string "exposition"
     | xsd:string "commentary"
     | xsd:string "sermon"
     | xsd:string "outline"
     | xsd:string "meditation")
    | xsd:string { pattern = "x-([^\s])+" }
  }?,
  attribute annotateWork { xsd:string }?,
  attribute annotateRef {
    list {
      (xsd:string {
         pattern =
          
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
       }
       | xsd:string {
           pattern =
            
"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)((((\p{L})|(\p{N})|_)+)(((\.(\p{L}|\p{N}|_)+)*))?))"
         })*
    }
  }?
chapterCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element div { divCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element figure { figureCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element p { pCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element salute { saluteCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element signed { signedCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element speech { speechCT })
     | (notAllowed
        | element table { tableCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element verse { verseCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute chapterTitle { xsd:string }?,
    attribute canonical { xsd:boolean }?,
    attribute osisRef {
      list {
        xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }*
      }
    }?,
    globalWithType,
    attribute TEIform { "div" }?
  },
  empty
languageCT =
  (attribute type {
     (xsd:string "other"
      | xsd:string "IANA"
      | xsd:string "ISO-639-2-B"
      | xsd:string "SIL"
      | xsd:string "ISO-639-1"
      | xsd:string "IETF"
      | xsd:string "LINGUIST"
      | xsd:string "ISO-639-2-T"
      | xsd:string "ISO-639-2")
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   attribute use {
     (xsd:string "quotation"
      | xsd:string "base"
      | xsd:string "translation"
      | xsd:string "didactic"
      | xsd:string "target"
      | xsd:string "original"
      | xsd:string "interlinear"
      | xsd:string "source")
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   globalWithoutType,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
globalWithoutType =
  attribute script {
    xsd:string { pattern = "([A-Z][a-z]{3}|x-[A-Za-z0-9]+)" }
  }?,
  space?,
  lang?,
  attribute n { xsd:string }?,
  attribute subType {
    xsd:string { pattern = "x-([^\s])+" }
  }?,
  attribute resp { xsd:string }?,
  attribute osisID {
    list {
      xsd:string {
        pattern =
         
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?"
      }*
    }
  }?,
  attribute ID { xsd:ID }?,
  attribute annotateType {
    (xsd:string "studyGuide"
     | xsd:string "translation"
     | xsd:string "rebuttal"
     | xsd:string "exposition"
     | xsd:string "commentary"
     | xsd:string "sermon"
     | xsd:string "outline"
     | xsd:string "meditation")
    | xsd:string { pattern = "x-([^\s])+" }
  }?,
  attribute annotateWork { xsd:string }?,
  attribute annotateRef {
    list {
      (xsd:string {
         pattern =
          
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
       }
       | xsd:string {
           pattern =
            
"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)((((\p{L})|(\p{N})|_)+)(((\.(\p{L}|\p{N}|_)+)*))?))"
         })*
    }
  }?
transChangeCT =
  mixed {
    globalWithoutType,
    attribute type {
      (xsd:string "deleted"
       | xsd:string "tenseChange"
       | xsd:string "changed"
       | xsd:string "moved"
       | xsd:string "amplified"
       | xsd:string "added")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
wCT =
  mixed {
    attribute TEIform { "w" }?,
    globalWithType,
    attribute xlit { xsd:string }?,
    attribute src { xsd:string }?,
    attribute POS {
      list {
        xsd:string {
          pattern =
           
"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)((((\p{L})|(\p{N})|_)+)(((\.(\p{L}|\p{N}|_)+)*))?))"
        }*
      }
    }?,
    attribute morph {
      list {
        xsd:string {
          pattern =
           
"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)((((\p{L})|(\p{N})|_)+)(((\.(\p{L}|\p{N}|_)+)*))?))"
        }*
      }
    }?,
    attribute lemma {
      list {
        xsd:string {
          pattern =
           
"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)((((\p{L})|(\p{N})|_)+)(((\.(\p{L}|\p{N}|_)+)*))?))"
        }*
      }
    }?,
    attribute gloss { xsd:string }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element seg { segCT }))*
  },
  empty
creatorCT =
  (attribute role {
     (xsd:string "cwt"
      | xsd:string "ilu"
      | xsd:string "bnd"
      | xsd:string "ill"
      | xsd:string "bdd"
      | xsd:string "encoder"
      | xsd:string "aut"
      | xsd:string "cmm"
      | xsd:string "aqt"
      | xsd:string "pbl"
      | xsd:string "trl"
      | xsd:string "cre"
      | xsd:string "ctg"
      | xsd:string "com"
      | xsd:string "bkp"
      | xsd:string "clb"
      | xsd:string "bjd"
      | xsd:string "ann"
      | xsd:string "bkd"
      | xsd:string "aui"
      | xsd:string "adp"
      | xsd:string "edt"
      | xsd:string "aft"
      | xsd:string "bpd"
      | xsd:string "ctb"
      | xsd:string "art")
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   globalWithType,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
divCT =
  mixed {
    anonymous0,
    (notAllowed
     | element titlePage { titlePageCT })?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element chapter { chapterCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element div { divCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element figure { figureCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element p { pCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element salute { saluteCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element signed { signedCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element speech { speechCT })
     | (notAllowed
        | element table { tableCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element verse { verseCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    attribute osisRef {
      list {
        xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }*
      }
    }?,
    attribute scope {
      list {
        xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }*
      }
    }?,
    attribute type {
      (xsd:string "index"
       | xsd:string "annotant"
       | xsd:string "part"
       | xsd:string "dedication"
       | xsd:string "afterword"
       | xsd:string "appendix"
       | xsd:string "acknowledgement"
       | xsd:string "section"
       | xsd:string "article"
       | xsd:string "entry"
       | xsd:string "gazetteer"
       | xsd:string "front"
       | xsd:string "commentary"
       | xsd:string "imprimatur"
       | xsd:string "outline"
       | xsd:string "majorSection"
       | xsd:string "introduction"
       | xsd:string "body"
       | xsd:string "summary"
       | xsd:string "titlePage"
       | xsd:string "coverPage"
       | xsd:string "subSection"
       | xsd:string "back"
       | xsd:string "paragraph"
       | xsd:string "chapter"
       | xsd:string "concordance"
       | xsd:string "book"
       | xsd:string "preface"
       | xsd:string "map"
       | xsd:string "glossary"
       | xsd:string "colophon"
       | xsd:string "bookGroup"
       | xsd:string "devotional")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    globalWithoutType,
    attribute TEIform { "div" }?
  },
  empty
typeCT =
  (attribute canonical { xsd:boolean }?,
   attribute type {
     xsd:string "OSIS"
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   globalWithoutType,
   xsd:string),
  empty
publisherCT =
  (globalWithType,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
catchWordCT =
  mixed {
    globalWithType,
    attribute osisRef {
      list {
        xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }*
      }
    }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
qCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element p { pCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element salute { saluteCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element signed { signedCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element verse { verseCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    attribute level { xsd:string }?,
    attribute osisRef {
      list {
        xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }*
      }
    }?,
    attribute type {
      xsd:string "block"
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute who { xsd:string }?,
    globalWithoutType,
    attribute TEIform { "q" }?
  },
  empty
aCT =
  mixed {
    globalWithType,
    attribute href { xsd:string },
    attribute canonical { xsd:boolean }?,
    (notAllowed
     | element index { indexCT })*
  },
  empty
coverageCT =
  (globalWithType,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
hiCT =
  mixed {
    attribute TEIform { "hi" }?,
    globalWithoutType,
    attribute type {
      (xsd:string "small-caps"
       | xsd:string "illuminated"
       | xsd:string "line-through"
       | xsd:string "italic"
       | xsd:string "bold"
       | xsd:string "normal"
       | xsd:string "underline")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
foreignCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    globalWithType,
    attribute TEIform { "foreign" }?
  },
  empty
lgCT =
  (anonymous0,
   ((notAllowed
     | element chapter { chapterCT })
    | (notAllowed
       | element index { indexCT })
    | (notAllowed
       | element l {
           mixed {
             anonymous0,
             (element a { aCT }
              | element abbr { abbrCT }
              | element chapter { chapterCT }
              | element date { dateCT }
              | element divineName { divineNameCT }
              | element foreign { foreignCT }
              | element hi { hiCT }
              | element index { indexCT }
              | element lb { lbCT }
              | element mentioned { mentionedCT }
              | element milestone { milestoneCT }
              | element milestoneEnd { milestoneEndCT }
              | element milestoneStart { milestoneStartCT }
              | element name { nameCT }
              | element note { noteCT }
              | element q { qCT }
              | element reference { referenceCT }
              | element seg { segCT }
              | element speaker { speakerCT }
              | element transChange { transChangeCT }
              | element verse { verseCT }
              | element w { wCT })*,
             attribute canonical { xsd:boolean }?,
             attribute level { xsd:positiveInteger }?,
             globalWithType,
             attribute TEIform { "l" }?
           }
         })
    | (notAllowed
       | element lb { lbCT })
    | (notAllowed
       | element lg { lgCT })
    | (notAllowed
       | element milestone { milestoneCT })
    | (notAllowed
       | element milestoneEnd { milestoneEndCT })
    | (notAllowed
       | element milestoneStart { milestoneStartCT })
    | (notAllowed
       | element q { qCT })
    | (notAllowed
       | element verse { verseCT }))*,
   attribute canonical { xsd:boolean }?,
   globalWithType,
   attribute TEIform { "lg" }?),
  empty
noteCT =
  mixed {
    attribute TEIform { "note" }?,
    globalWithoutType,
    attribute type {
      (xsd:string "study"
       | xsd:string "translation"
       | xsd:string "explanation"
       | xsd:string "encoder"
       | xsd:string "exegesis"
       | xsd:string "alternative"
       | xsd:string "citation"
       | xsd:string "variant"
       | xsd:string "background"
       | xsd:string "crossReference"
       | xsd:string "allusion"
       | xsd:string "devotional"
       | xsd:string "speaker")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute osisRef {
      list {
        xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }*
      }
    }?,
    attribute canonical { xsd:boolean }?,
    (notAllowed
     | element note { noteCT })*,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element catchWord { catchWordCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element figure { figureCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element p { pCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element rdg { rdgCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element table { tableCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element verse { verseCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
lang = attribute xml:lang { xsd:language }
speechCT =
  mixed {
    anonymous0,
    (notAllowed
     | element speech { speechCT })*,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element chapter { chapterCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element p { pCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element salute { saluteCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element signed { signedCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element table { tableCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element verse { verseCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    globalWithType,
    attribute TEIform { "speech" }?
  },
  empty
divineNameCT =
  mixed {
    globalWithType,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
mentionedCT =
  mixed {
    attribute TEIform { "mentioned" }?,
    globalWithType,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
titleCT =
  mixed {
    attribute TEIform { "title" }?,
    globalWithoutType,
    attribute type {
      (xsd:string "parallel"
       | xsd:string "main"
       | xsd:string "continued"
       | xsd:string "acrostic"
       | xsd:string "sub"
       | xsd:string "psalm")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute short { xsd:string }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element figure { figureCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
osisTextCT =
  (attribute TEIform { "text" }?,
   space?,
   lang,
   attribute subType {
     xsd:string { pattern = "x-([^\s])+" }
   }?,
   attribute type {
     xsd:string { pattern = "x-([^\s])+" }
   }?,
   attribute osisRefWork {
     xsd:string {
       pattern = "((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?"
     }
   }?,
   attribute osisIDWork {
     xsd:string {
       pattern = "((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?"
     }
   },
   attribute osisID {
     list {
       xsd:string {
         pattern =
          
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?"
       }*
     }
   }?,
   attribute ID { xsd:ID }?,
   attribute canonical { xsd:boolean }?,
   attribute annotateRef {
     list {
       (xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }
        | xsd:string {
            pattern =
             
"((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_))*:)((((\p{L})|(\p{N})|_)+)(((\.(\p{L}|\p{N}|_)+)*))?))"
          })*
     }
   }?,
   (notAllowed
    | element header { headerCT }),
   (notAllowed
    | element titlePage { titlePageCT })?,
   (notAllowed
    | element div { divCT })*),
  empty
listCT =
  mixed {
    attribute TEIform { "list" }?,
    globalWithType,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element chapter { chapterCT })
     | (notAllowed
        | element head { headCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element item {
            mixed {
              attribute TEIform { "item" }?,
              globalWithType,
              attribute role { xsd:string }?,
              attribute canonical { xsd:boolean }?,
              (element label {
                 mixed {
                   attribute TEIform { "label" }?,
                   globalWithType,
                   attribute role { xsd:string }?,
                   attribute canonical { xsd:boolean }?,
                   (element a { aCT }
                    | element abbr { abbrCT }
                    | element date { dateCT }
                    | element divineName { divineNameCT }
                    | element foreign { foreignCT }
                    | element hi { hiCT }
                    | element index { indexCT }
                    | element lb { lbCT }
                    | element milestone { milestoneCT }
                    | element milestoneEnd { milestoneEndCT }
                    | element milestoneStart { milestoneStartCT }
                    | element name { nameCT }
                    | element note { noteCT }
                    | element q { qCT }
                    | element reference { referenceCT }
                    | element seg { segCT }
                    | element transChange { transChangeCT }
                    | element w { wCT })*
                 }
               }?,
               (element a { aCT }
                | element abbr { abbrCT }
                | element date { dateCT }
                | element divineName { divineNameCT }
                | element foreign { foreignCT }
                | element hi { hiCT }
                | element index { indexCT }
                | element lg { lgCT }
                | element list { listCT }
                | element lb { lbCT }
                | element milestone { milestoneCT }
                | element milestoneEnd { milestoneEndCT }
                | element milestoneStart { milestoneStartCT }
                | element name { nameCT }
                | element note { noteCT }
                | element p { pCT }
                | element q { qCT }
                | element reference { referenceCT }
                | element seg { segCT }
                | element title { titleCT }
                | element transChange { transChangeCT }
                | element verse { verseCT }
                | element w { wCT })*)+
            }
          })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element verse { verseCT }))*
  },
  empty
headCT =
  mixed {
    attribute TEIform { "head" }?,
    globalWithType,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element head { headCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
milestoneCT =
  (attribute TEIform { "milestone" }?,
   globalWithoutType,
   attribute type {
     (xsd:string "pb"
      | xsd:string "footer"
      | xsd:string "column"
      | xsd:string "header"
      | xsd:string "line"
      | xsd:string "screen"
      | xsd:string "cQuote"
      | xsd:string "halfLine")
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   attribute canonical { xsd:boolean }?),
  empty
space = attribute space { xsd:NCName "preserve" | xsd:NCName "default" }
dateCT =
  mixed {
    attribute TEIform { "date" }?,
    globalWithoutType,
    attribute type {
      xsd:string "ISO"
      | xsd:string "Jewish"
      | xsd:string "Islamic"
      | xsd:string "Julian"
      | xsd:string "Gregorian"
      | xsd:string "Chinese"
    }?,
    attribute event {
      (xsd:string "edition"
       | xsd:string "imprint"
       | xsd:string "original"
       | xsd:string "eversion")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
tableCT =
  (attribute TEIform { "table" }?,
   globalWithType,
   attribute rows { xsd:positiveInteger }?,
   attribute cols { xsd:positiveInteger }?,
   attribute canonical { xsd:boolean }?,
   (notAllowed
    | element head { headCT })?,
   (notAllowed
    | element row {
        attribute TEIform { "row" }?,
        globalWithType,
        attribute role { xsd:string "label" | xsd:string "data" }?,
        attribute canonical { xsd:boolean }?,
        element cell {
          mixed {
            attribute TEIform { "cell" }?,
            globalWithType,
            attribute role { xsd:string "label" | xsd:string "data" }?,
            attribute canonical { xsd:boolean }?,
            (element a { aCT }
             | element abbr { abbrCT }
             | element date { dateCT }
             | element divineName { divineNameCT }
             | element figure { figureCT }
             | element foreign { foreignCT }
             | element hi { hiCT }
             | element index { indexCT }
             | element inscription { inscriptionCT }
             | element lb { lbCT }
             | element lg { lgCT }
             | element list { listCT }
             | element milestone { milestoneCT }
             | element milestoneEnd { milestoneEndCT }
             | element milestoneStart { milestoneStartCT }
             | element name { nameCT }
             | element note { noteCT }
             | element p { pCT }
             | element q { qCT }
             | element reference { referenceCT }
             | element salute { saluteCT }
             | element seq { segCT }
             | element signed { signedCT }
             | element speaker { speakerCT }
             | element speech { speechCT }
             | element table { tableCT }
             | element title { titleCT }
             | element transChange { transChangeCT }
             | element verse { verseCT }
             | element w { wCT })*
          }
        }+
      })*),
  empty
verseCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element inscription { inscriptionCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    globalWithType
  },
  empty
element0 =
  element * {
    mixed {
      (element0
       | attribute * { text })*
    }
  }
lbCT =
  (attribute TEIform { "milestone" }?,
   globalWithType,
   attribute canonical { xsd:boolean }?),
  empty
anonymous0 =
  attribute eID { xsd:string }?,
  attribute sID { xsd:string }?
milestoneEndCT =
  (attribute TEIform { "milestone" }?,
   globalWithoutType,
   attribute start { xsd:string },
   attribute type {
     xsd:string "speech"
     | xsd:string "verse"
     | xsd:string "foreign"
     | xsd:string "lg"
     | xsd:string "l"
     | xsd:string "q"
     | xsd:string "chapter"
     | xsd:string "signed"
     | xsd:string "salute"
     | xsd:string "div"
     | xsd:string "closer"
     | xsd:string "seg"
     | xsd:string "abbr"
   }?,
   attribute canonical { xsd:boolean }?),
  empty
descriptionCT =
  (globalWithType,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
nameCT =
  mixed {
    attribute TEIform { "name" }?,
    globalWithoutType,
    attribute type {
      (xsd:string "geographic"
       | xsd:string "ritual"
       | xsd:string "nonhuman"
       | xsd:string "person"
       | xsd:string "holiday")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute regular { xsd:string }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
contributorCT =
  (attribute canonical { xsd:boolean }?,
   attribute file-as { xsd:string }?,
   attribute role {
     (xsd:string "cwt"
      | xsd:string "ilu"
      | xsd:string "bnd"
      | xsd:string "ill"
      | xsd:string "bdd"
      | xsd:string "encoder"
      | xsd:string "aut"
      | xsd:string "cmm"
      | xsd:string "aqt"
      | xsd:string "pbl"
      | xsd:string "trl"
      | xsd:string "cre"
      | xsd:string "ctg"
      | xsd:string "com"
      | xsd:string "bkp"
      | xsd:string "clb"
      | xsd:string "bjd"
      | xsd:string "ann"
      | xsd:string "bkd"
      | xsd:string "aui"
      | xsd:string "adp"
      | xsd:string "edt"
      | xsd:string "aft"
      | xsd:string "bpd"
      | xsd:string "ctb"
      | xsd:string "art")
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   globalWithType,
   xsd:string),
  empty
inscriptionCT =
  mixed {
    globalWithType,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element speech { speechCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
abbrCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    attribute expansion { xsd:string }?,
    globalWithType,
    attribute TEIform { "abbr" }?
  },
  empty
referenceCT =
  mixed {
    globalWithoutType,
    attribute type {
      (xsd:string "parallel" | xsd:string "annotateRef")
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    attribute osisRef {
      list {
        xsd:string {
          pattern =
           
"(((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?:)?((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?(\-((((\p{L}|\p{N}|_)+)(\.(\p{L}|\p{N}|_)*)*)+)(!((\p{L}|\p{N}|_)+)((\.(\p{L}|\p{N}|_)+)*)?)?((at)(cp\[(\p{Nd})*\]|s\[(\p{L}|\p{N})+\](\[(\p{N})+\])?))?)?"
        }*
      }
    }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element title { titleCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
speakerCT =
  mixed {
    attribute TEIform { "sp" }?,
    globalWithType,
    attribute who { xsd:string }?,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
milestoneStartCT =
  (attribute TEIform { "milestone" }?,
   globalWithoutType,
   attribute type {
     xsd:string "speech"
     | xsd:string "verse"
     | xsd:string "foreign"
     | xsd:string "lg"
     | xsd:string "l"
     | xsd:string "q"
     | xsd:string "chapter"
     | xsd:string "signed"
     | xsd:string "salute"
     | xsd:string "div"
     | xsd:string "closer"
     | xsd:string "seg"
     | xsd:string "abbr"
   }?,
   attribute end { xsd:string },
   attribute canonical { xsd:boolean }?),
  empty
signedCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    globalWithType,
    attribute TEIform { "signed" }?
  },
  empty
rdgCT =
  mixed {
    attribute TEIform { "rdg" }?,
    globalWithType,
    attribute canonical { xsd:boolean }?,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element p { pCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element w { wCT }))*
  },
  empty
subjectCT =
  (attribute canonical { xsd:boolean }?,
   attribute type {
     (xsd:string "RSWK"
      | xsd:string "LCSH"
      | xsd:string "DBC"
      | xsd:string "DDC"
      | xsd:string "MeSH"
      | xsd:string "UDC"
      | xsd:string "NLSH"
      | xsd:string "SEARS"
      | xsd:string "BILDI"
      | xsd:string "ATLA"
      | xsd:string "FGT"
      | xsd:string "SWD_RSWK"
      | xsd:string "SOG"
      | xsd:string "VAT"
      | xsd:string "EUT"
      | xsd:string "LCC")
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   globalWithoutType,
   xsd:string),
  empty
titlePageCT =
  (globalWithType,
   ((notAllowed
     | element title { titleCT })
    | (notAllowed
       | element contributor { contributorCT })
    | (notAllowed
       | element creator { creatorCT })
    | (notAllowed
       | element subject { subjectCT })
    | (notAllowed
       | element date { dateCT })
    | (notAllowed
       | element description { descriptionCT })
    | (notAllowed
       | element publisher { publisherCT })
    | (notAllowed
       | element type { typeCT })
    | (notAllowed
       | element format { formatCT })
    | (notAllowed
       | element identifier { identifierCT })
    | (notAllowed
       | element source { sourceCT })
    | (notAllowed
       | element language { languageCT })
    | (notAllowed
       | element relation { relationCT })
    | (notAllowed
       | element coverage { coverageCT })
    | (notAllowed
       | element p { pCT })
    | (notAllowed
       | element figure { figureCT })
    | (notAllowed
       | element milestone { milestoneCT }))*),
  empty
saluteCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element lg { lgCT })
     | (notAllowed
        | element list { listCT })
     | (notAllowed
        | element mentioned { mentionedCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element p { pCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element speaker { speakerCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element verse { verseCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    globalWithType,
    attribute TEIform { "salute" }?
  },
  empty
identifierCT =
  (globalWithoutType,
   attribute type {
     (xsd:string "ISSN"
      | xsd:string "DOI"
      | xsd:string "ISBN"
      | xsd:string "Dewey"
      | xsd:string "URN"
      | xsd:string "URL"
      | xsd:string "LCCN"
      | xsd:string "URI"
      | xsd:string "SICI"
      | xsd:string "OSIS")
     | xsd:string { pattern = "x-([^\s])+" }
   }?,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
formatCT =
  (globalWithType,
   attribute canonical { xsd:boolean }?,
   xsd:string),
  empty
segCT =
  mixed {
    anonymous0,
    ((notAllowed
      | element a { aCT })
     | (notAllowed
        | element abbr { abbrCT })
     | (notAllowed
        | element date { dateCT })
     | (notAllowed
        | element divineName { divineNameCT })
     | (notAllowed
        | element foreign { foreignCT })
     | (notAllowed
        | element hi { hiCT })
     | (notAllowed
        | element index { indexCT })
     | (notAllowed
        | element lb { lbCT })
     | (notAllowed
        | element milestone { milestoneCT })
     | (notAllowed
        | element milestoneEnd { milestoneEndCT })
     | (notAllowed
        | element milestoneStart { milestoneStartCT })
     | (notAllowed
        | element name { nameCT })
     | (notAllowed
        | element note { noteCT })
     | (notAllowed
        | element q { qCT })
     | (notAllowed
        | element reference { referenceCT })
     | (notAllowed
        | element seg { segCT })
     | (notAllowed
        | element transChange { transChangeCT })
     | (notAllowed
        | element w { wCT }))*,
    attribute canonical { xsd:boolean }?,
    attribute type {
      xsd:string "otPassage"
      | xsd:string { pattern = "x-([^\s])+" }
    }?,
    globalWithoutType,
    attribute TEIform { "seg" }?
  },
  empty

[...]

Justus H. Piater wrote:[...]
[...][...]

Hi Justus,
Thank you for providing the osisCore.2.0.nsc file. While emacs is a 
powerful choice for many, personally I find it very difficult to use. I 
tried Xemacs about three times to get used to it and always failed...
Quanta or Kate would be my preferred choice at the moment.
It is possible to edit files in Quanta using ThML-1.0.dtd. There is a 
function where you can select a DTD document and import it into quanta's 
available dtds. From then on a document in a project can use ThML 
syntax. Do you think you would be able to provide osisCore-2.0.1.dtd?
Are there conversion tools for that?

I have another question: what are files of this extension: *.dtd.xml ?
They are used in kate editor. Is anyone familiar how to convert an 
existing dtd into dtd.xml?

Thanks,
Benedict

Is this question about Open Source or about availability? If the latter 
there is an add-in for MSWord that makes producing OSIS documents 
relatively easy for the average biblical scholar.

If the question is really about open source, and if we really are 
reduced to Emacs, we leave the production of OSIS something for geeks only!

Tim

"Benedykt P. Barszcz" <kb2qzv(at)poczta.wp.pl> wrote on Sat, 29 May 2004
15:53:17 +0200:
[...]

Yes, emacs unfolds its power if you use it all the time and for
everything. It is not intended for a casual user.
[...]

I've given it a try (RELAX NG -> DTD using trang), but it does not
work. The RELAX NG version produced by rngconv contains constructs
that trang cannot express in DTD form, and that I don't know how to
fix by simple scripting, at least not without investing some
significant time. In any case, at first glance it seems that the
resulting DTD would be significantly less stringent than the W3C
Schema version because the latter expresses constraints that cannot be
expressed by a DTD.

If there's a demand, I can try a harder, but it may take a few days or
weeks until I get around to it.
[...]

The only ones I've found are XML Spy and TurboXML, both commercial
software.
[...]

After a quick look-around on the Web: These files are XML
representations of DTD content. Kate's XML plugin uses them to support
DTD-conformant editing of XML files. You can create them from DTDs
using dtdparse (http://dtdparse.sourceforge.net/).


Tim Bulkeley <tim(at)carey.ac.nz> wrote on Sun, 30 May 2004 07:54:09
+1200:
[...]

:-) No, that's obviously not the way to go. So, if I can help reducing
any barriers to using OSIS by converting the Schema to something else,
I'll see what I can do.

While we're at it: Are there any strong reasons to prefer W3C Schema
over RELAX NG as the format of the normative OSIS schema, or is there
a possibility that this will change at some point in the future?

Justus
[...]

If you are simply looking for a good XML editor for a technically
oriented person (read don't mind pointy brackets) and you don't have a
philosophical problem with commercial software both XML Spy and oXygen
are $49(US) for a version that includes a full XML editor.  

I tried the oXygen editor and it seems to work well (and should run on
any OS because it is Java based).  The advantage of oXygen is that it
will report all errors at one time, while XML Spy only does one at a
time.

Personally, I use XML Spy and you will appreciate the XSLT debugger if
you write any XSLT transformations (the XSLT debugger is not included in
the $49 version).

You may also find XML Spy useful for generating DTDs from the OSIS
schema as well as readable "documentation" views of the schema.

Todd
[...]
?[...]
http://www.montefiore.ulg.ac.be/~piater/[...]