Statistics
| Revision:

root / tmp / org.txm.core / res / org / txm / xml / xsl / tei / odds2 / odd2dtd.xsl @ 187

History | View | Annotate | Download (66 kB)

1
<?xml version="1.0" encoding="utf-8"?>
2
<xsl:stylesheet xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0"
3
                xmlns:fo="http://www.w3.org/1999/XSL/Format"
4
                xmlns:rng="http://relaxng.org/ns/structure/1.0"
5
                xmlns:t="http://www.thaiopensource.com/ns/annotations"
6
                xmlns:tei="http://www.tei-c.org/ns/1.0"
7
                
8
                xmlns:xs="http://www.w3.org/2001/XMLSchema"
9
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
10
                exclude-result-prefixes="a t tei fo rng xs"
11
                version="2.0">
12
  <xsl:import href="teiodds.xsl"/>
13
  <xsl:import href="../common2/i18n.xsl"/>
14
  <xsl:import href="../common2/tei-param.xsl"/>
15

    
16
  <doc xmlns="http://www.oxygenxml.com/ns/doc/xsl" scope="stylesheet" type="stylesheet">
17
      <desc>
18
         <p> TEI stylesheet for making DTD from ODD </p>
19
         <p>This software is dual-licensed:
20

    
21
1. Distributed under a Creative Commons Attribution-ShareAlike 3.0
22
Unported License http://creativecommons.org/licenses/by-sa/3.0/ 
23

    
24
2. http://www.opensource.org/licenses/BSD-2-Clause
25
		
26
All rights reserved.
27

    
28
Redistribution and use in source and binary forms, with or without
29
modification, are permitted provided that the following conditions are
30
met:
31

    
32
* Redistributions of source code must retain the above copyright
33
notice, this list of conditions and the following disclaimer.
34

    
35
* Redistributions in binary form must reproduce the above copyright
36
notice, this list of conditions and the following disclaimer in the
37
documentation and/or other materials provided with the distribution.
38

    
39
This software is provided by the copyright holders and contributors
40
"as is" and any express or implied warranties, including, but not
41
limited to, the implied warranties of merchantability and fitness for
42
a particular purpose are disclaimed. In no event shall the copyright
43
holder or contributors be liable for any direct, indirect, incidental,
44
special, exemplary, or consequential damages (including, but not
45
limited to, procurement of substitute goods or services; loss of use,
46
data, or profits; or business interruption) however caused and on any
47
theory of liability, whether in contract, strict liability, or tort
48
(including negligence or otherwise) arising in any way out of the use
49
of this software, even if advised of the possibility of such damage.
50
</p>
51
         <p>Author: See AUTHORS</p>
52
         <p>Id: $Id: odd2dtd.xsl 9669 2011-11-07 19:17:54Z rahtz $</p>
53
         <p>Copyright: 2011, TEI Consortium</p>
54
      </desc>
55
   </doc>
56
  <xsl:output method="text"/>
57
  <xsl:param name="autoGlobal">false</xsl:param>
58
  <xsl:param name="verbose"/>
59
  <xsl:param name="outputDir"/>
60
  <xsl:param name="appendixWords"> </xsl:param>
61
  <xsl:param name="filesuffix"/>
62
  <xsl:template name="headingNumberSuffix">
63
      <xsl:text> </xsl:text>
64
  </xsl:template>
65
  <xsl:param name="numberBackHeadings"> </xsl:param>
66
  <xsl:param name="numberFrontHeadings"> </xsl:param>
67
  <xsl:param name="numberHeadings"> </xsl:param>
68
  <xsl:param name="numberHeadingsDepth"> </xsl:param>
69
  <xsl:param name="oddmode">dtd</xsl:param>
70
  <xsl:param name="prenumberedHeadings">false</xsl:param>
71
  <xsl:param name="splitLevel">-1</xsl:param>
72
  <xsl:param name="generateNamespacePrefix">false</xsl:param>
73
  <xsl:param name="namespacePrefix"/>
74
  <xsl:key match="tei:moduleSpec" name="Modules" use="1"/>
75
  <xsl:variable name="nsPrefix">
76
      <xsl:choose>
77
         <xsl:when test="generateNamespacePrefix='false'"/>
78
         <xsl:when test="not($namespacePrefix='')">
79
            <xsl:value-of select="$namespacePrefix"/>
80
         </xsl:when>
81
         <xsl:when test="key('LISTSCHEMASPECS',$whichSchemaSpec)/@ns">
82
            <xsl:variable name="n" select="key('LISTSCHEMASPECS',whichSchemaSpec)/@ns"/>
83
            <xsl:choose>
84
               <xsl:when test="$n='http://www.w3.org/2005/11/its'">its:</xsl:when>
85
               <xsl:when test="$n='http://www.tei-c.org/ns/1.0'">tei:</xsl:when>
86
            </xsl:choose>
87
         </xsl:when>
88
      </xsl:choose>
89
  </xsl:variable>
90
  <xsl:key name="NSELEMENTS" match="tei:elementSpec[@ns]|tei:attDef[@ns]" use="1"/>
91
  <xsl:key match="tei:moduleSpec[@ident]" name="FILES" use="@ident"/>
92
  <xsl:template match="/">
93
      <xsl:choose>
94
         <xsl:when test="key('SCHEMASPECS',1)">
95
            <xsl:apply-templates select="key('LISTSCHEMASPECS',$whichSchemaSpec)"/>
96
         </xsl:when>
97
         <xsl:otherwise>
98
            <xsl:call-template name="byModule"/>
99
         </xsl:otherwise>
100
      </xsl:choose>
101
  </xsl:template>
102
  <xsl:template name="byModule">
103
      <xsl:for-each select="key('Modules',1)">
104
         <xsl:sort order="descending" select="@ident"/>
105
         <xsl:if test="$verbose='true'">
106
            <xsl:message> File [<xsl:value-of select="@ident"/>] </xsl:message>
107
         </xsl:if>
108
         <xsl:call-template name="generateOutput">
109
            <xsl:with-param name="suffix">.dtd</xsl:with-param>
110
            <xsl:with-param name="method">text</xsl:with-param>
111
            <xsl:with-param name="body">
112
               <xsl:call-template name="dtdComment">
113
                  <xsl:with-param name="text"> 
114
	                    <xsl:text>DTD module </xsl:text>
115
	                    <xsl:value-of select="@ident"/>
116
	                    <xsl:text>. Generated </xsl:text>
117
	                    <xsl:call-template name="showDate"/>
118
	                    <xsl:text>. </xsl:text>
119
			    <xsl:call-template name="copyright"/>
120
	                    <xsl:call-template name="makeTEIVersion"/>
121
	                    <xsl:call-template name="makeDescription"/>
122
	                 </xsl:with-param>
123
               </xsl:call-template>
124
               <xsl:choose>
125
                  <xsl:when test="@type='core'">
126
		    <xsl:text>&lt;!ENTITY % TEI.extensions.ent '' &gt;&#10;</xsl:text>
127
		    <xsl:text>%TEI.extensions.ent;&#10;</xsl:text>
128
		    <xsl:call-template name="dtdComment">
129
		      <xsl:with-param name="text">
130
			<xsl:text>list of element names</xsl:text>
131
                        </xsl:with-param>
132
		    </xsl:call-template>
133
		    <xsl:if test="$parameterize='true' and count(key('NSELEMENTS',1))&gt;0">
134
		      <xsl:text>&lt;!ENTITY % NS '</xsl:text>
135
		      <xsl:value-of select="$nsPrefix"/>
136
		      <xsl:text>' &gt;&#10;</xsl:text>
137
		    </xsl:if>
138
		    <xsl:if test="$parameterize='true'">
139
		      <xsl:call-template name="NameList"/>
140
		    </xsl:if>
141
		    <xsl:call-template name="datatypeMacros"/>
142
		    <xsl:call-template name="omissability"/>
143
		    <xsl:call-template name="entityModules"/>
144
		    <xsl:call-template name="predeclaredClasses"/>
145
		    <xsl:call-template name="predeclaredMacros"/>
146
		    <xsl:call-template name="normalClasses"/>
147
		    <xsl:call-template name="normalMacros"/>
148
		    <xsl:text>&#10;&lt;!ENTITY % TEI.extensions.dtd '' &gt;&#10;</xsl:text>
149
		    <xsl:text>%TEI.extensions.dtd;&#10;</xsl:text>
150
		    <xsl:apply-templates mode="tangle" select="key('ElementModule',@ident)">
151
		      <xsl:sort select="@ident"/>
152
		    </xsl:apply-templates>
153
		    <xsl:call-template name="elementModules"/>
154
                  </xsl:when>
155
                  <xsl:otherwise>
156
                     <xsl:apply-templates mode="tangle" select="key('ElementModule',@ident)">
157
                        <xsl:sort select="@ident"/>
158
                     </xsl:apply-templates>
159
                  </xsl:otherwise>
160
               </xsl:choose>
161
            </xsl:with-param>
162
         </xsl:call-template>
163
         <xsl:if test="not(@type='core')">
164
            <xsl:call-template name="generateOutput">
165
               <xsl:with-param name="suffix">-decl.dtd</xsl:with-param>
166
               <xsl:with-param name="method">text</xsl:with-param>
167
               <xsl:with-param name="body">
168
                  <xsl:call-template name="dtdComment">
169
                     <xsl:with-param name="text">
170
		                      <xsl:text>TEI P5 entity declaration module for </xsl:text>
171
		                      <xsl:value-of select="@ident"/>
172
		                      <xsl:text>. Generated </xsl:text>
173
		                      <xsl:call-template name="showDate"/>
174
		                      <xsl:text>.&#10;</xsl:text>
175
				      <xsl:call-template name="copyright"/>
176
		                      <xsl:call-template name="makeTEIVersion"/>
177
		                      <xsl:call-template name="makeDescription"/>
178
	                    </xsl:with-param>
179
                  </xsl:call-template>
180
                  <xsl:call-template name="datatypeMacros"/>
181
                  <xsl:call-template name="normalClasses"/>
182
                  <xsl:call-template name="normalMacros"/>
183
                  <xsl:call-template name="predeclaredMacros"/>
184
               </xsl:with-param>
185
            </xsl:call-template>
186
         </xsl:if>
187
      </xsl:for-each>
188
  </xsl:template>
189
  <xsl:template name="elementModules">
190
      <xsl:for-each select="key('Modules',1)">
191
         <xsl:sort order="descending" select="@ident"/>
192
         <xsl:if test="not(@type='core')">
193
            <xsl:text>&#10;&lt;![%TEI.</xsl:text>
194
            <xsl:value-of select="@ident"/>
195
            <xsl:text>;[
196
	&lt;!ENTITY % file.</xsl:text>
197
            <xsl:value-of select="@ident"/>
198
            <xsl:text> PUBLIC '-//TEI P5//ELEMENTS </xsl:text>
199
            <xsl:value-of select="tei:altIdent[@type='FPI']"/>
200
            <xsl:text>//EN' '</xsl:text>
201
            <xsl:value-of select="@ident"/>
202
            <xsl:text>.dtd' &gt;
203
	%file.</xsl:text>
204
            <xsl:value-of select="@ident"/>
205
            <xsl:text>;
206
	]]&gt;&#10;</xsl:text>
207
         </xsl:if>
208
      </xsl:for-each>
209
  </xsl:template>
210
  <xsl:template name="entityModules">
211
      <xsl:call-template name="dtdComment">
212
         <xsl:with-param name="text">
213
            <xsl:text>Module declarations</xsl:text>
214
         </xsl:with-param>
215
      </xsl:call-template>
216
      <xsl:for-each select="key('Modules',1)">
217
         <xsl:sort order="descending" select="@ident"/>
218
         <xsl:if test="not(@type='core')">
219
            <xsl:text>&lt;!ENTITY % TEI.</xsl:text>
220
            <xsl:value-of select="@ident"/>
221
            <xsl:text> 'IGNORE' &gt;&#10;</xsl:text>
222
            <xsl:text>&lt;![%TEI.</xsl:text>
223
            <xsl:value-of select="@ident"/>
224
            <xsl:text>;[
225
	&lt;!ENTITY % file.</xsl:text>
226
            <xsl:value-of select="@ident"/>
227
            <xsl:text>-decl PUBLIC '-//TEI P5//ENTITIES </xsl:text>
228
            <xsl:value-of select="tei:altIdent[@type='FPI']"/>
229
            <xsl:text>//EN' '</xsl:text>
230
            <xsl:value-of select="@ident"/>
231
            <xsl:text>-decl.dtd' &gt;
232
	%file.</xsl:text>
233
            <xsl:value-of select="@ident"/>
234
            <xsl:text>-decl;
235
	]]&gt;&#10;</xsl:text>
236
         </xsl:if>
237
      </xsl:for-each>
238
  </xsl:template>
239
  <xsl:template name="omissability">
240
      <xsl:call-template name="dtdComment">
241
         <xsl:with-param name="text">
242
            <xsl:text>legacy declaration of omissability indicators</xsl:text>
243
         </xsl:with-param>
244
      </xsl:call-template>
245
      <xsl:text>&lt;!ENTITY % TEI.XML 'INCLUDE' &gt;&#10;</xsl:text>
246
      <xsl:text>&lt;![%TEI.XML;[&#10;</xsl:text>
247
      <xsl:text>&lt;!ENTITY % om.RO '' &gt;&#10;</xsl:text>
248
      <xsl:text>&lt;!ENTITY % om.RR '' &gt;&#10;</xsl:text>
249
      <xsl:text>]]&gt;&#10;</xsl:text>
250
      <xsl:text>&lt;!ENTITY % om.RO '- o' &gt;&#10;</xsl:text>
251
      <xsl:text>&lt;!ENTITY % om.RR '- -' &gt;&#10;</xsl:text>
252
  </xsl:template>
253
  <xsl:template name="datatypeMacros">
254
      <xsl:call-template name="dtdComment">
255
         <xsl:with-param name="text">
256
            <xsl:text>Start datatype macro declarations</xsl:text>
257
         </xsl:with-param>
258
      </xsl:call-template>
259
      <xsl:for-each select="key('MacroModule',@ident)">
260
         <xsl:if test="@type='dt'">
261
            <xsl:apply-templates mode="tangle" select="."/>
262
         </xsl:if>
263
      </xsl:for-each>
264
      <xsl:call-template name="dtdComment">
265
         <xsl:with-param name="text">
266
            <xsl:text>End of datatype macro declarations</xsl:text>
267
         </xsl:with-param>
268
      </xsl:call-template>
269
  </xsl:template>
270
  <xsl:template name="predeclaredMacros">
271
      <xsl:call-template name="dtdComment">
272
         <xsl:with-param name="text">
273
            <xsl:text>Start of pre-declared macros</xsl:text>
274
         </xsl:with-param>
275
      </xsl:call-template>
276
      <xsl:for-each select="key('PredeclareMacrosModule',@ident)">
277
         <xsl:apply-templates mode="tangle" select="."/>
278
      </xsl:for-each>
279
      <xsl:call-template name="dtdComment">
280
         <xsl:with-param name="text">
281
            <xsl:text>End of pre-declared macros</xsl:text>
282
         </xsl:with-param>
283
      </xsl:call-template>
284
  </xsl:template>
285
  <xsl:template name="normalClasses">
286
      <xsl:call-template name="dtdComment">
287
         <xsl:with-param name="text">
288
            <xsl:text>Start of classes</xsl:text>
289
         </xsl:with-param>
290
      </xsl:call-template>
291
      <xsl:apply-templates mode="tangle" select="key('ClassModule',@ident)"/>
292
      <xsl:call-template name="dtdComment">
293
         <xsl:with-param name="text">
294
            <xsl:text>End of classes</xsl:text>
295
         </xsl:with-param>
296
      </xsl:call-template>
297
  </xsl:template>
298
  <xsl:template name="predeclaredClasses">
299
      <xsl:call-template name="dtdComment">
300
         <xsl:with-param name="text">
301
            <xsl:text>Start of pre-declared classes</xsl:text>
302
         </xsl:with-param>
303
      </xsl:call-template>
304
      <xsl:for-each select="key('predeclaredClasses',1)">
305
         <xsl:choose>
306
            <xsl:when test="@type='atts'">
307
               <xsl:call-template name="classAtt">
308
                  <xsl:with-param name="declare">false</xsl:with-param>
309
               </xsl:call-template>
310
            </xsl:when>
311
            <xsl:when test="@type='model'">
312
               <xsl:call-template name="classModel"/>
313
            </xsl:when>
314
         </xsl:choose>
315
      </xsl:for-each>
316
      <xsl:call-template name="dtdComment">
317
         <xsl:with-param name="text">
318
            <xsl:text>End of pre-declared classes</xsl:text>
319
         </xsl:with-param>
320
      </xsl:call-template>
321
  </xsl:template>
322
  <xsl:template name="normalMacros">
323
      <xsl:if test="@type='core'">
324
         <xsl:call-template name="dtdComment">
325
            <xsl:with-param name="text">
326
               <xsl:text>Global pre-declared macros</xsl:text>
327
            </xsl:with-param>
328
         </xsl:call-template>
329
         <xsl:for-each select="key('PredeclareAllMacros',1)">
330
            <xsl:text>&#10;&lt;!ENTITY % </xsl:text>
331
            <xsl:value-of select="@ident"/>
332
            <xsl:text> ''</xsl:text>
333
            <xsl:text>&gt;&#10;</xsl:text>
334
         </xsl:for-each>
335
      </xsl:if>
336
      <xsl:call-template name="dtdComment">
337
         <xsl:with-param name="text">
338
            <xsl:text>Start rest of  macro declarations</xsl:text>
339
         </xsl:with-param>
340
      </xsl:call-template>
341
      <xsl:for-each select="key('MacroModule',@ident)">
342
         <xsl:if test="not(@type='dt')">
343
            <xsl:choose>
344
               <xsl:when test="@predeclare='true'"/>
345
               <!--	    <xsl:when test="key('PredeclareMacros',@ident)"/>-->
346
	       <xsl:otherwise>
347
		 <xsl:apply-templates mode="tangle" select="."/>
348
               </xsl:otherwise>
349
            </xsl:choose>
350
         </xsl:if>
351
      </xsl:for-each>
352
      <xsl:call-template name="dtdComment">
353
         <xsl:with-param name="text">
354
            <xsl:text>End macros</xsl:text>
355
         </xsl:with-param>
356
      </xsl:call-template>
357
  </xsl:template>
358
  <xsl:template match="tei:schemaSpec">
359
      <xsl:if test="$verbose='true'">
360
         <xsl:message>schemaSpec <xsl:value-of select="@ident"/>
361
			      </xsl:message>
362
      </xsl:if>
363
      <xsl:choose>
364
         <xsl:when test="$outputDir='' or $outputDir='-'">
365
            <xsl:call-template name="schemaOut"/>
366
         </xsl:when>
367
         <xsl:otherwise>
368
            <xsl:call-template name="generateOutput">
369
               <xsl:with-param name="suffix">.dtd</xsl:with-param>
370
               <xsl:with-param name="method">text</xsl:with-param>
371
               <xsl:with-param name="body">
372
                  <xsl:call-template name="schemaOut"/>
373
               </xsl:with-param>
374
            </xsl:call-template>
375
         </xsl:otherwise>
376
      </xsl:choose>
377
  </xsl:template>
378
  <xsl:template name="schemaOut">
379
      <xsl:call-template name="dtdComment">
380
         <xsl:with-param name="text">
381
            <xsl:text>DTD Generated </xsl:text>
382
            <xsl:call-template name="showDate"/>
383
            <xsl:text>. </xsl:text>
384
	    <xsl:call-template name="copyright"/>
385
            <xsl:call-template name="makeTEIVersion"/>
386
            <xsl:call-template name="makeDescription"/>
387
         </xsl:with-param>
388
      </xsl:call-template>
389
      <xsl:choose>
390
         <xsl:when test="tei:specGrpRef">
391
            <xsl:variable name="SPECS">
392
               <tei:schemaSpec>
393
                  <xsl:copy-of select="@*"/>
394
                  <xsl:apply-templates mode="expandSpecs"/>
395
               </tei:schemaSpec>
396
            </xsl:variable>
397
            <xsl:for-each select="$SPECS/tei:schemaSpec">
398
               <xsl:call-template name="schemaSpecBody"/>
399
            </xsl:for-each>
400
         </xsl:when>
401
         <xsl:otherwise>
402
            <xsl:call-template name="schemaSpecBody"/>
403
         </xsl:otherwise>
404
      </xsl:choose>
405
  </xsl:template>
406
  <xsl:template name="schemaSpecBody">
407
      <xsl:if test="$parameterize='true' and      count(key('NSELEMENTS',1))&gt;0">
408
         <xsl:text>&lt;!ENTITY % NS '</xsl:text>
409
         <xsl:value-of select="$nsPrefix"/>
410
         <xsl:text>' &gt;&#10;</xsl:text>
411
      </xsl:if>
412
      <xsl:if test="$parameterize='true'">
413
         <xsl:call-template name="NameList"/>
414
      </xsl:if>
415
      <xsl:text>&#10;&lt;!-- start datatypes --&gt;&#10;</xsl:text>
416
      <xsl:apply-templates mode="tangle" select="tei:macroSpec[@type='dt']"/>
417
      <xsl:text>&#10;&lt;!-- end datatypes --&gt;&#10;</xsl:text>
418
      <xsl:if test="tei:classSpec[@predeclare='true']">
419
         <xsl:text>&#10;&lt;!--predeclared classes --&gt;&#10;</xsl:text>
420
         <xsl:for-each select="tei:classSpec[@predeclare='true']">
421
	   <xsl:choose>
422
	     <xsl:when test="@type='atts'">
423
	       <xsl:call-template name="classAtt">
424
		 <xsl:with-param name="declare">true</xsl:with-param>
425
	       </xsl:call-template>
426
	     </xsl:when>
427
	     <xsl:when test="@type='model' and $parameterize='false'">
428
	       <xsl:call-template name="classModel">
429
		 <xsl:with-param name="declare">true</xsl:with-param>
430
	       </xsl:call-template>
431
	     </xsl:when>
432
	   </xsl:choose>
433
         </xsl:for-each>
434
         <xsl:text>&#10;&lt;!--end of predeclared classes --&gt;&#10;</xsl:text>
435
         <xsl:apply-templates mode="tangle" select="tei:classSpec"/>
436
      </xsl:if>
437
      <xsl:text>&#10;&lt;!-- start predeclared patterns --&gt;&#10;</xsl:text>
438
      <xsl:for-each select="tei:macroSpec">
439
	<xsl:if test="@predeclare='true'">
440
	  <xsl:apply-templates mode="tangle" select="."/>
441
	</xsl:if>
442
      </xsl:for-each>
443
      <xsl:text>&#10;&lt;!-- end predeclared patterns --&gt;&#10;</xsl:text>
444
      <xsl:text>&#10;&lt;!-- start rest of patterns --&gt;&#10;</xsl:text>
445
      <xsl:for-each select="tei:macroSpec">
446
	<xsl:choose>
447
	  <xsl:when test="@predeclare='true'"/>
448
	  <xsl:when test="@type='dt'"/>
449
	  <xsl:otherwise>
450
	    <xsl:apply-templates mode="tangle" select="."/>
451
	  </xsl:otherwise>
452
	</xsl:choose>
453
      </xsl:for-each>
454
      <xsl:text>&#10;&lt;!-- end patterns --&gt;&#10;</xsl:text>
455
      <xsl:if test="not(tei:classSpec[@predeclare='true'])">
456
         <xsl:text>&#10;&lt;!-- start classes --&gt;&#10;</xsl:text>
457
         <xsl:apply-templates mode="tangle" select="tei:classSpec[@type='atts']"/>
458
         <xsl:apply-templates mode="tangle" select="tei:classSpec[@type='model']"/>
459
         <xsl:text>&#10;&lt;!-- stop classes --&gt;&#10;</xsl:text>
460
      </xsl:if>
461
      <xsl:text>&#10;&lt;!-- start elements --&gt;&#10;</xsl:text>
462
      <xsl:apply-templates mode="tangle" select="tei:elementSpec">
463
         <xsl:sort select="@ident"/>
464
      </xsl:apply-templates>
465
      <xsl:text>&#10;&lt;!-- end elements --&gt;&#10;</xsl:text>
466
  </xsl:template>
467
  <xsl:template match="tei:macroSpec[@xml:id='TEIGIS']" mode="tangle"/>
468
  <xsl:template name="NameList">
469
      <xsl:choose>
470
         <xsl:when test="self::tei:schemaSpec">
471
            <xsl:for-each select="tei:elementSpec">
472
               <xsl:sort select="@ident"/>
473
               <xsl:call-template name="declareAnElement"/>
474
            </xsl:for-each>
475
         </xsl:when>
476
         <xsl:otherwise>
477
            <xsl:for-each select="key('ELEMENTDOCS',1)">
478
               <xsl:sort select="@ident"/>
479
               <xsl:call-template name="declareAnElement"/>
480
            </xsl:for-each>
481
         </xsl:otherwise>
482
      </xsl:choose>
483
      <!-- walk over all the elementSpec elements and make list of 
484
	 elements -->
485
  </xsl:template>
486
  <xsl:template name="declareAnElement">
487
      <xsl:if test="not(starts-with(@ident,'%'))">
488
         <xsl:text>&lt;!ENTITY % n.</xsl:text>
489
         <xsl:value-of select="@ident"/>
490
         <xsl:text> "</xsl:text>
491
         <xsl:if test="$parameterize='true' and (@ns)">
492
            <xsl:text>%NS;</xsl:text>
493
         </xsl:if>
494
         <xsl:choose>
495
            <xsl:when test="tei:altIdent=@ident">
496
               <xsl:value-of select="@ident"/>
497
            </xsl:when>
498
            <xsl:when test="tei:altIdent">
499
               <xsl:value-of select="tei:altIdent"/>
500
            </xsl:when>
501
            <xsl:otherwise>
502
               <xsl:value-of select="@ident"/>
503
            </xsl:otherwise>
504
         </xsl:choose>
505
         <xsl:text>"&gt;&#10;</xsl:text>
506
      </xsl:if>
507
  </xsl:template>
508
  <xsl:template name="linkStyle"/>
509
  <xsl:template name="makeAnchor">
510
      <xsl:param name="name"/>
511
  </xsl:template>
512
  <xsl:template match="rng:element[rng:anyName]">
513
      <xsl:text>#PCDATA</xsl:text>
514
  </xsl:template>
515
  <xsl:template match="rng:zeroOrMore">
516
      <xsl:variable name="body">
517
         <xsl:call-template name="content">
518
            <xsl:with-param name="sep" select="','"/>
519
         </xsl:call-template>
520
      </xsl:variable>
521
      <xsl:if test="not($body='')">
522
         <xsl:call-template name="checkStart"/>
523
         <xsl:value-of select="$body"/>
524
         <xsl:text>*</xsl:text>
525
         <xsl:call-template name="checkEnd"/>
526
      </xsl:if>
527
  </xsl:template>
528
  <xsl:template match="rng:oneOrMore">
529
      <xsl:variable name="body">
530
         <xsl:call-template name="content">
531
            <xsl:with-param name="sep" select="','"/>
532
         </xsl:call-template>
533
      </xsl:variable>
534
      <xsl:if test="not($body='')">
535
         <xsl:call-template name="checkStart"/>
536
         <xsl:value-of select="$body"/>
537
         <xsl:text>+</xsl:text>
538
         <xsl:call-template name="checkEnd"/>
539
      </xsl:if>
540
  </xsl:template>
541
  <xsl:template match="rng:optional">
542
      <xsl:variable name="body">
543
         <xsl:call-template name="content">
544
            <xsl:with-param name="sep" select="','"/>
545
         </xsl:call-template>
546
      </xsl:variable>
547
      <xsl:choose>
548
         <xsl:when test="$body=''"> </xsl:when>
549
         <xsl:otherwise>
550
            <xsl:call-template name="checkStart"/>
551
            <xsl:value-of select="$body"/>
552
            <xsl:text>?</xsl:text>
553
            <xsl:call-template name="checkEnd"/>
554
         </xsl:otherwise>
555
      </xsl:choose>
556
  </xsl:template>
557
  <xsl:template match="rng:choice">
558
      <xsl:call-template name="checkStart"/>
559
      <xsl:choose>
560
         <xsl:when test="rng:value and ancestor::tei:elementSpec">
561
            <xsl:text>(#PCDATA)</xsl:text>
562
         </xsl:when>
563
         <xsl:when test="rng:value">
564
            <xsl:text> (</xsl:text>
565
            <xsl:for-each select="rng:value">
566
               <xsl:value-of select="."/>
567
               <xsl:if test="following-sibling::rng:value">
568
                  <xsl:text>|&#10;</xsl:text>
569
               </xsl:if>
570
            </xsl:for-each>) </xsl:when>
571
         <xsl:otherwise>
572
            <xsl:call-template name="content">
573
               <xsl:with-param name="sep" select="' |&#xA; '"/>
574
            </xsl:call-template>
575
         </xsl:otherwise>
576
      </xsl:choose>
577
      <xsl:call-template name="checkEnd"/>
578
  </xsl:template>
579
  <xsl:template match="rng:group|rng:mixed">
580
      <xsl:call-template name="content">
581
         <xsl:with-param name="sep" select="','"/>
582
      </xsl:call-template>
583
  </xsl:template>
584
  <xsl:template match="rng:interleave">
585
      <xsl:call-template name="content">
586
         <xsl:with-param name="sep" select="','"/>
587
      </xsl:call-template>
588
  </xsl:template>
589
  <xsl:template name="content">
590
      <xsl:param name="sep"/>
591
        <xsl:variable name="parent" select="local-name(..)"/>
592
        <xsl:variable name="contentbody">
593
          <xsl:variable name="members">
594
            <M>
595
              <xsl:for-each select="rng:*|processing-instruction()">
596
                  <xsl:variable name="F">
597
                     <xsl:choose>
598
                        <xsl:when test="self::processing-instruction()">
599
                           <xsl:apply-templates select="."/>
600
                        </xsl:when>
601
                        <xsl:when test="self::rng:ref and $parameterize='false'">
602
                           <xsl:choose>
603
                              <xsl:when test="key('CLASSES',@name)">
604
                                 <xsl:variable name="exists">
605
                                    <xsl:call-template name="checkClass">
606
                                       <xsl:with-param name="id" select="@name"/>
607
                                    </xsl:call-template>
608
                                 </xsl:variable>
609
                                 <xsl:choose>
610
                                    <xsl:when test="$exists=''">
611
                                       <xsl:text>_DUMMY_</xsl:text>
612
                                       <xsl:value-of select="@name"/>
613
                                    </xsl:when>
614
                                    <xsl:otherwise>
615
                                       <xsl:apply-templates select="."/>
616
                                    </xsl:otherwise>
617
                                 </xsl:choose>
618
                              </xsl:when>
619
                              <xsl:when test="key('CLASSES',substring-before(@name,'_'))">
620
                                 <xsl:variable name="exists">
621
                                    <xsl:call-template name="checkClass">
622
                                       <xsl:with-param name="id" select="substring-before(@name,'_')"/>
623
                                    </xsl:call-template>
624
                                 </xsl:variable>
625
                                 <xsl:choose>
626
                                    <xsl:when test="$exists=''">
627
                                       <xsl:text>_DUMMY_</xsl:text>
628
                                       <xsl:value-of select="@name"/>
629
                                    </xsl:when>
630
                                    <xsl:otherwise>
631
                                       <xsl:apply-templates select="."/>
632
                                    </xsl:otherwise>
633
                                 </xsl:choose>
634
                              </xsl:when>
635
                              <xsl:when test="key('MACROS',@name)">
636
                                 <xsl:apply-templates select="."/>
637
                              </xsl:when>
638
                              <xsl:when test="key('ELEMENTS',@name)">
639
                                 <xsl:apply-templates select="."/>
640
                              </xsl:when>
641
                           </xsl:choose>
642
                        </xsl:when>
643
                        <xsl:otherwise>
644
                           <xsl:apply-templates select="."/>
645
                        </xsl:otherwise>
646
                     </xsl:choose>
647
                  </xsl:variable>
648
                  <xsl:if test="not($F='')">
649
                     <N>
650
                        <xsl:value-of select="$F"/>
651
                     </N>
652
                  </xsl:if>
653
              </xsl:for-each>
654
            </M>
655
          </xsl:variable>
656
          <xsl:for-each select="$members/M">
657
            <xsl:choose>
658
              <xsl:when test="starts-with(N[1],'(') and count(N)=1"/>
659
              <xsl:when test="$parent='content' and count(N)=1 and starts-with(N[1],'%macro.')"/>
660
              <xsl:when test="$parent='content' and count(N)=1">
661
                  <xsl:text>(</xsl:text>
662
              </xsl:when>
663
              <xsl:when test="count(N)=1 and starts-with(N,'%')">
664
                  <xsl:text>(</xsl:text>
665
              </xsl:when>
666
              <xsl:when test="count(N)&gt;1">
667
                  <xsl:text>(</xsl:text>
668
              </xsl:when>
669
            </xsl:choose>
670
            <xsl:for-each select="N">
671
              <xsl:choose>
672
                  <xsl:when test="starts-with(.,'_DUMMY_') and .=preceding-sibling::N[1]"/>
673
                  <xsl:otherwise>
674
                     <xsl:value-of select="."/>
675
                     <xsl:choose>
676
                        <xsl:when test="self::N[1]='|&#xA;'"/>
677
                        <xsl:when test="self::N[1]='('"/>
678
                        <xsl:when test="self::N[1]=')' and position() &lt; last()">
679
                           <xsl:value-of select="$sep"/>
680
                        </xsl:when>
681
                        <xsl:when test="following-sibling::N[1]='('"/>
682
                        <xsl:when test="following-sibling::N[1]=')'"/>
683
                        <xsl:when test="following-sibling::N[1]='|&#xA;'"/>
684
                        <xsl:when test="position() &lt; last()">
685
                           <xsl:value-of select="$sep"/>
686
                        </xsl:when>
687
                     </xsl:choose>
688
                  </xsl:otherwise>
689
              </xsl:choose>
690
            </xsl:for-each>
691
            <xsl:choose>
692
              <xsl:when test="starts-with(N[1],'(') and count(N)=1"/>
693
              <xsl:when test="$parent='content' and count(N)=1 and starts-with(N[1],'%macro.')"/>
694
              <xsl:when test="$parent='content' and count(N)=1">
695
                  <xsl:text>)</xsl:text>
696
              </xsl:when>
697
              <xsl:when test="count(N)=1 and starts-with(N,'%')">
698
                  <xsl:text>)</xsl:text>
699
              </xsl:when>
700
              <xsl:when test="count(N)&gt;1">
701
                  <xsl:text>)</xsl:text>
702
              </xsl:when>
703
            </xsl:choose>
704
          </xsl:for-each>
705
        </xsl:variable>
706
        <xsl:choose>
707
          <xsl:when test="$contentbody=''"/>
708
          <xsl:when test="$contentbody='()'"/>
709
	        <!-- some special cases of known evil -->
710
          <xsl:when test="$contentbody='(#PCDATA |  #PCDATA)'">
711
            <xsl:text>(#PCDATA)</xsl:text>
712
          </xsl:when>
713
          <xsl:when test="contains($contentbody,'#PCDATA') and contains($contentbody,'%macro.anyXML;')">
714
            <xsl:text>(#PCDATA)</xsl:text>
715
          </xsl:when>
716
          <xsl:when test="contains($contentbody, '| ()')">
717
            <xsl:value-of select="substring-before($contentbody,'| ()')"/>
718
            <xsl:value-of select="substring-after($contentbody,'| ()')"/>
719
          </xsl:when>
720
          <xsl:when test="contains($contentbody, ',)')">
721
            <xsl:value-of select="substring-before($contentbody,',)')"/>
722
	           <xsl:text>)</xsl:text>
723
            <xsl:value-of select="substring-after($contentbody,',)')"/>
724
          </xsl:when>
725
          <xsl:otherwise>
726
            <xsl:value-of select="$contentbody"/>
727
          </xsl:otherwise>
728
        </xsl:choose>
729
  </xsl:template>
730
  <xsl:template match="tei:datatype">
731
      <xsl:choose>
732
         <xsl:when test="rng:data/@type='ID'">
733
            <xsl:text> ID</xsl:text>
734
         </xsl:when>
735
         <xsl:when test="rng:data/@type='IDREF'">
736
            <xsl:text> IDREF</xsl:text>
737
         </xsl:when>
738
         <xsl:when test="rng:data/@type='IDREFS'">
739
            <xsl:text> IDREFS</xsl:text>
740
         </xsl:when>
741
         <xsl:when test="rng:data/@type='NMTOKEN'">
742
            <xsl:text> NMTOKEN</xsl:text>
743
         </xsl:when>
744
         <xsl:when test="rng:data/@type='NMTOKENS'">
745
            <xsl:text> NMTOKENS</xsl:text>
746
         </xsl:when>
747
         <xsl:when test="rng:data/@type='boolean'">
748
            <xsl:text> (true | false) </xsl:text>
749
         </xsl:when>
750
         <xsl:when test="rng:ref">
751
            <xsl:text> %</xsl:text>
752
            <xsl:value-of select="rng:ref/@name"/>
753
            <xsl:text>; </xsl:text>
754
         </xsl:when>
755
         <xsl:otherwise>
756
            <xsl:text> CDATA</xsl:text>
757
         </xsl:otherwise>
758
      </xsl:choose>
759
  </xsl:template>
760
  <xsl:template match="rng:element">
761
      <xsl:choose>
762
         <xsl:when test="parent::tei:content/parent::tei:macroSpec">
763
            <xsl:call-template name="topLevel"/>
764
         </xsl:when>
765
         <xsl:otherwise>
766
            <xsl:value-of select="@name"/>
767
         </xsl:otherwise>
768
      </xsl:choose>
769
  </xsl:template>
770
   <!--  
771
       <xsl:template match="tei:text()"/>-->
772
  <xsl:template match="rng:empty">
773
      <xsl:text>EMPTY</xsl:text>
774
  </xsl:template>
775
  <xsl:template match="rng:data">
776
      <xsl:choose>
777
         <xsl:when test="parent::tei:content/parent::tei:macroSpec[@type='dt']">
778
            <xsl:text> CDATA </xsl:text>
779
         </xsl:when>
780
         <xsl:when test="parent::tei:content">
781
            <xsl:text> (#PCDATA)</xsl:text>
782
         </xsl:when>
783
         <xsl:when test="@type='ID'"> ID </xsl:when>
784
         <xsl:when test="@type='IDREF'"> IDREF </xsl:when>
785
         <xsl:when test="@type='IDREFS'"> IDREFS </xsl:when>
786
         <xsl:otherwise> CDATA </xsl:otherwise>
787
      </xsl:choose>
788
  </xsl:template>
789
  <xsl:template match="rng:text">
790
      <xsl:choose>
791
         <xsl:when test="parent::tei:content/parent::tei:macroSpec">
792
            <xsl:call-template name="topLevel"/>
793
         </xsl:when>
794
         <xsl:when test="parent::tei:content">
795
            <xsl:text> (#PCDATA)</xsl:text>
796
         </xsl:when>
797
         <xsl:otherwise>
798
            <xsl:text> #PCDATA</xsl:text>
799
         </xsl:otherwise>
800
      </xsl:choose>
801
  </xsl:template>
802
  <xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:text">
803
      <xsl:text> CDATA</xsl:text>
804
  </xsl:template>
805
  <xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:data">
806
      <xsl:text> CDATA</xsl:text>
807
  </xsl:template>
808
  <xsl:template match="tei:macroSpec[@type='epe']/tei:content/rng:text">
809
      <xsl:text>CDATA</xsl:text>
810
  </xsl:template>
811
  <xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:list">
812
      <xsl:text> CDATA</xsl:text>
813
  </xsl:template>
814
  <xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:choice">
815
      <xsl:choose>
816
         <xsl:when test="rng:value">
817
            <xsl:text>(</xsl:text>
818
            <xsl:for-each select="rng:value">
819
               <xsl:value-of select="."/>
820
               <xsl:if test="following-sibling::rng:value">|
821
</xsl:if>
822
            </xsl:for-each>
823
            <xsl:if test="rng:data/@type='boolean'">
824
               <xsl:text> | true | false</xsl:text>
825
            </xsl:if>
826
            <xsl:text>)</xsl:text>
827
         </xsl:when>
828
         <xsl:otherwise>
829
            <xsl:text> CDATA</xsl:text>
830
         </xsl:otherwise>
831
      </xsl:choose>
832
  </xsl:template>
833
  <xsl:template match="rng:text" mode="simple">
834
      <xsl:choose>
835
         <xsl:when test="parent::tei:content/parent::tei:macroSpec[@type='dt']">
836
            <xsl:text> CDATA</xsl:text>
837
         </xsl:when>
838
         <xsl:when test="parent::tei:content/parent::tei:macroSpec[@type='pe']">
839
            <xsl:text>#PCDATA</xsl:text>
840
         </xsl:when>
841
         <xsl:when test="parent::tei:content and not(following-sibling::rng:*) and not (preceding-sibling::rng:*)">
842
            <xsl:text>(#PCDATA)</xsl:text>
843
         </xsl:when>
844
         <xsl:when test="parent::tei:content and not(following-sibling::rng:*) and not (preceding-sibling::rng:*)">
845
            <xsl:text>(#PCDATA)</xsl:text>
846
         </xsl:when>
847
         <xsl:otherwise>
848
            <xsl:text>#PCDATA</xsl:text>
849
         </xsl:otherwise>
850
      </xsl:choose>
851
  </xsl:template>
852
  <xsl:template match="processing-instruction()[name(.)='teidtd']">
853
      <xsl:value-of select="."/>
854
  </xsl:template>
855
  <xsl:template match="processing-instruction()[name(.)='teidtd']" mode="tangle">
856
      <xsl:value-of select="."/>
857
  </xsl:template>
858
  <xsl:template match="rng:ref">
859
      <xsl:choose>
860
         <xsl:when test="parent::tei:content/parent::tei:macroSpec">
861
            <xsl:call-template name="topLevel"/>
862
         </xsl:when>
863
         <xsl:when test="count(parent::tei:content/rng:*)&gt;1">
864
            <xsl:choose>
865
               <xsl:when test="not(preceding-sibling::rng:*)">
866
                  <xsl:text>(</xsl:text>
867
               </xsl:when>
868
               <xsl:otherwise>
869
                  <xsl:text>,</xsl:text>
870
               </xsl:otherwise>
871
            </xsl:choose>
872
            <xsl:call-template name="refbody"/>
873
            <xsl:if test="not(following-sibling::rng:*)">
874
               <xsl:text>)</xsl:text>
875
            </xsl:if>
876
         </xsl:when>
877
         <xsl:when test="key('MACROS',@name)">
878
            <xsl:call-template name="refbody"/>
879
         </xsl:when>
880
         <xsl:otherwise>
881
            <xsl:if test="parent::tei:content">(</xsl:if>
882
            <xsl:call-template name="refbody"/>
883
            <xsl:if test="parent::tei:content">)</xsl:if>
884
         </xsl:otherwise>
885
      </xsl:choose>
886
  </xsl:template>
887
  <xsl:template match="rng:ref" mode="simple">
888
      <xsl:call-template name="refbody"/>
889
  </xsl:template>
890
  <xsl:template name="refbody">
891
      <xsl:variable name="R">
892
         <xsl:choose>
893
            <xsl:when test="$parameterize='false'">
894
               <xsl:choose>
895
                  <xsl:when test="key('CLASSES',@name)">
896
                     <xsl:variable name="exists">
897
                        <xsl:call-template name="checkClass">
898
                           <xsl:with-param name="id" select="@name"/>
899
                        </xsl:call-template>
900
                     </xsl:variable>
901
                     <xsl:choose>
902
                        <xsl:when test="$exists=''">
903
                           <xsl:text>_DUMMY_</xsl:text>
904
                           <xsl:value-of select="@name"/>
905
                        </xsl:when>
906
                        <xsl:otherwise>
907
                           <xsl:text>%</xsl:text>
908
                           <xsl:value-of select="@name"/>
909
                           <xsl:text>;</xsl:text>
910
                        </xsl:otherwise>
911
                     </xsl:choose>
912
                  </xsl:when>
913
                  <xsl:when test="key('CLASSES',substring-before(@name,'_'))">
914
                     <xsl:variable name="exists">
915
                        <xsl:call-template name="checkClass">
916
                           <xsl:with-param name="id" select="substring-before(@name,'_')"/>
917
                        </xsl:call-template>
918
                     </xsl:variable>
919
                     <xsl:choose>
920
                        <xsl:when test="$exists=''">
921
                           <xsl:text>_DUMMY_</xsl:text>
922
                           <xsl:value-of select="@name"/>
923
                        </xsl:when>
924
                        <xsl:otherwise>
925
                           <xsl:text>%</xsl:text>
926
                           <xsl:value-of select="@name"/>
927
                           <xsl:text>;</xsl:text>
928
                        </xsl:otherwise>
929
                     </xsl:choose>
930
                  </xsl:when>
931
                  <xsl:when test="key('MACROS',@name)">
932
                     <xsl:text>%</xsl:text>
933
                     <xsl:value-of select="@name"/>
934
                     <xsl:text>;</xsl:text>
935
                  </xsl:when>
936
                  <xsl:when test="key('ELEMENTS',@name)">
937
                     <xsl:for-each select="key('ELEMENTS',@name)">
938
                        <xsl:choose>
939
                           <xsl:when test="tei:altIdent=@ident">
940
                              <xsl:value-of select="@ident"/>
941
                           </xsl:when>
942
                           <xsl:when test="tei:altIdent">
943
                              <xsl:value-of select="normalize-space(tei:altIdent)"/>
944
                           </xsl:when>
945
                           <xsl:otherwise>
946
                              <xsl:value-of select="@ident"/>
947
                           </xsl:otherwise>
948
                        </xsl:choose>
949
                     </xsl:for-each>
950
                  </xsl:when>
951
               </xsl:choose>
952
            </xsl:when>
953
            <xsl:when test="@name='IGNORE' or @name='INCLUDE'">
954
               <xsl:value-of select="@name"/>
955
            </xsl:when>
956
            <xsl:when test="contains(@name, '.')">
957
               <xsl:text>%</xsl:text>
958
               <xsl:value-of select="@name"/>
959
               <xsl:text>;</xsl:text>
960
            </xsl:when>
961
            <xsl:otherwise>
962
               <xsl:text>%n.</xsl:text>
963
               <xsl:value-of select="@name"/>
964
               <xsl:text>;</xsl:text>
965
            </xsl:otherwise>
966
         </xsl:choose>
967
      </xsl:variable>
968
      <xsl:value-of select="$R"/>
969
  </xsl:template>
970
  <xsl:template name="topLevel">
971
      <xsl:variable name="unit">
972
         <xsl:apply-templates mode="simple" select="."/>
973
      </xsl:variable>
974
      <xsl:if test="not($unit='')">
975
         <xsl:if test="preceding-sibling::rng:*">
976
            <xsl:choose>
977
               <xsl:when test="preceding-sibling::processing-instruction()"/>
978
               <xsl:otherwise>
979
                  <xsl:text>|&#10;</xsl:text>
980
               </xsl:otherwise>
981
            </xsl:choose>
982
         </xsl:if>
983
         <xsl:value-of select="$unit"/>
984
      </xsl:if>
985
  </xsl:template>
986
  <xsl:template match="rng:element" mode="simple">
987
      <xsl:choose>
988
         <xsl:when test="@name">
989
            <xsl:value-of select="@name"/>
990
         </xsl:when>
991
         <xsl:otherwise>
992
            <xsl:text>ANY</xsl:text>
993
         </xsl:otherwise>
994
      </xsl:choose>
995
  </xsl:template>
996
  <xsl:template match="tei:macroSpec" mode="tangle">
997
      <xsl:choose>
998
         <xsl:when test="@depend and $parameterize='true'">
999
            <xsl:if test="$verbose='true'">
1000
               <xsl:message>Dependency on <xsl:value-of select="@depend"/> for <xsl:value-of select="@ident"/>
1001
               </xsl:message>
1002
            </xsl:if>
1003
            <xsl:text>&#10; &lt;![%TEI.</xsl:text>
1004
            <xsl:value-of select="@depend"/>;[ <xsl:call-template name="macroBody"/>
1005
            <xsl:text>&#10;]]&gt;</xsl:text>
1006
         </xsl:when>
1007
         <xsl:when test="@depend and count(key('ElementModule',@depend))=0">
1008
            <xsl:if test="$verbose='true'">
1009
               <xsl:message>Dependency on <xsl:value-of select="@depend"/>, but not used in
1010
						this schema </xsl:message>
1011
            </xsl:if>
1012
         </xsl:when>
1013
         <xsl:otherwise>
1014
            <xsl:call-template name="macroBody"/>
1015
         </xsl:otherwise>
1016
      </xsl:choose>
1017
  </xsl:template>
1018
  <xsl:template name="macroBody">
1019
      <xsl:text>&#10;&lt;!ENTITY </xsl:text>
1020
      <xsl:if test="not(@type) or @type='defaultpe' or @type='pe' or @type='epe' or @type='dt'">
1021
         <xsl:text>%</xsl:text>
1022
      </xsl:if>
1023
      <xsl:text> </xsl:text>
1024
      <xsl:value-of select="@ident"/>
1025
      <xsl:text> '</xsl:text>
1026
      <xsl:for-each select="tei:content">
1027
	<xsl:choose>
1028
	  <xsl:when test=".//rng:anyName">
1029
	    <xsl:text> ANY</xsl:text>
1030
	  </xsl:when>
1031
	  <xsl:otherwise>
1032
	    <xsl:apply-templates
1033
		select="tei:*|rng:*|processing-instruction()"/>
1034
	  </xsl:otherwise>
1035
	</xsl:choose>
1036
      </xsl:for-each>
1037
      <xsl:text>' &gt;&#10;</xsl:text>
1038
  </xsl:template>
1039
  <xsl:template match="tei:elementSpec" mode="tangle">
1040
      <xsl:if test="$verbose='true'">
1041
         <xsl:message> .... elementSpec <xsl:value-of select="@ident"/>
1042
         </xsl:message>
1043
      </xsl:if>
1044
      <xsl:choose>
1045
         <xsl:when test="starts-with(@ident,'%')">
1046
            <xsl:call-template name="elementBody"/>
1047
         </xsl:when>
1048
         <xsl:when test="$parameterize='false'">
1049
            <xsl:call-template name="elementBody"/>
1050
         </xsl:when>
1051
         <xsl:otherwise>
1052
            <xsl:text>&#10;&lt;!ENTITY % </xsl:text>
1053
            <xsl:value-of select="@ident"/>
1054
            <xsl:text> 'INCLUDE' &gt;&#10;&lt;![ %</xsl:text>
1055
            <xsl:value-of select="@ident"/>
1056
            <xsl:text>; [&#10;</xsl:text>
1057
            <xsl:call-template name="elementBody"/>
1058
            <xsl:text>&#10;]]&gt;&#10;</xsl:text>
1059
         </xsl:otherwise>
1060
      </xsl:choose>
1061
  </xsl:template>
1062
  <xsl:template name="elementBody">
1063
      <xsl:variable name="ename">
1064
         <xsl:choose>
1065
            <xsl:when test="$parameterize='false'">
1066
               <xsl:choose>
1067
                  <xsl:when test="@ns='http://www.w3.org/1999/xhtml'">
1068
                     <xsl:text>html:</xsl:text>
1069
                     <xsl:value-of select="@ident"/>
1070
                  </xsl:when>
1071
                  <xsl:when test="tei:altIdent=@ident">
1072
                     <xsl:value-of select="@ident"/>
1073
                  </xsl:when>
1074
                  <xsl:when test="tei:altIdent">
1075
                     <xsl:value-of select="normalize-space(tei:altIdent)"/>
1076
                  </xsl:when>
1077
                  <xsl:otherwise>
1078
                     <xsl:value-of select="@ident"/>
1079
                  </xsl:otherwise>
1080
               </xsl:choose>
1081
            </xsl:when>
1082
            <xsl:when test="starts-with(@ident,'%')">
1083
               <xsl:value-of select="@ident"/>
1084
            </xsl:when>
1085
            <xsl:otherwise>
1086
               <xsl:text>%n.</xsl:text>
1087
               <xsl:value-of select="@ident"/>
1088
               <xsl:text>;</xsl:text>
1089
            </xsl:otherwise>
1090
         </xsl:choose>
1091
      </xsl:variable>
1092
      <xsl:text>&#10;&lt;!--doc:</xsl:text>
1093
      <xsl:call-template name="makeDescription">
1094
         <xsl:with-param name="includeValList">true</xsl:with-param>
1095
         <xsl:with-param name="coded">false</xsl:with-param>
1096
      </xsl:call-template>
1097
      <xsl:text> --&gt;&#10;</xsl:text>
1098
      <xsl:text>&lt;!ELEMENT </xsl:text>
1099
      <xsl:value-of select="$ename"/>
1100
      <xsl:if test="$parameterize='true'">
1101
         <xsl:text> %om.RR;</xsl:text>
1102
      </xsl:if>
1103
      <xsl:text> </xsl:text>
1104
      <xsl:variable name="Contents">
1105
         <BLAH>
1106
            <xsl:choose>
1107
	      <xsl:when test="tei:content/rng:element[rng:anyName]">
1108
		<xsl:text> (#PCDATA)</xsl:text>
1109
	      </xsl:when>
1110
	      <xsl:when test="tei:content/rng:element">
1111
                  <xsl:text> ANY</xsl:text>
1112
	      </xsl:when>
1113
	      <xsl:when test="tei:valList[@type='closed']">
1114
		<xsl:text> (#PCDATA)</xsl:text>
1115
	      </xsl:when>
1116
	      <xsl:when test="tei:content">
1117
		<xsl:apply-templates select="tei:content/*"/>
1118
	      </xsl:when>
1119
	      <xsl:otherwise>
1120
		<xsl:text/>
1121
	      </xsl:otherwise>
1122
            </xsl:choose>
1123
         </BLAH>
1124
      </xsl:variable>
1125
      <xsl:choose>
1126
         <xsl:when test="$Contents=''">
1127
            <xsl:text> EMPTY</xsl:text>
1128
         </xsl:when>
1129
         <xsl:otherwise>
1130
            <xsl:value-of select="$Contents"/>
1131
         </xsl:otherwise>
1132
      </xsl:choose>
1133
      <xsl:text>&gt;</xsl:text>
1134
      <xsl:choose>
1135
         <xsl:when test="@ns and @ns=''"> </xsl:when>
1136
         <xsl:when test="key('LISTSCHEMASPECS',$whichSchemaSpec)/@ns=''"> </xsl:when>
1137
         <xsl:when test="@ns">
1138
            <xsl:text>&#10;&lt;!ATTLIST </xsl:text>
1139
            <xsl:value-of select="$ename"/>
1140
            <xsl:text> xmlns CDATA "</xsl:text>
1141
            <xsl:value-of select="@ns"/>
1142
            <xsl:text>"</xsl:text>
1143
            <xsl:text>&gt;</xsl:text>
1144
         </xsl:when>
1145
         <xsl:when test="key('LISTSCHEMASPECS',$whichSchemaSpec)/@ns">
1146
            <xsl:text>&#10;&lt;!ATTLIST </xsl:text>
1147
            <xsl:value-of select="$ename"/>
1148
            <xsl:text> xmlns CDATA "</xsl:text>
1149
            <xsl:value-of select="ancestor::tei:schemaSpec/@ns"/>
1150
            <xsl:text>"</xsl:text>
1151
            <xsl:text>&gt;</xsl:text>
1152
         </xsl:when>
1153
         <xsl:otherwise>
1154
            <xsl:text>&#10;&lt;!ATTLIST </xsl:text>
1155
            <xsl:value-of select="$ename"/>
1156
            <xsl:text> xmlns CDATA "http://www.tei-c.org/ns/1.0"</xsl:text>
1157
            <xsl:text>&gt;</xsl:text>
1158
         </xsl:otherwise>
1159
      </xsl:choose>
1160
      <xsl:variable name="maybeatts">
1161
         <xsl:if test="$parameterize='true' and $autoGlobal='true'">
1162
            <xsl:text>&#10; %att.global.attributes;</xsl:text>
1163
         </xsl:if>
1164
         <xsl:if test="$parameterize='true'">
1165
            <xsl:apply-templates mode="tangleAtts" select="tei:classes/tei:memberOf"/>
1166
         </xsl:if>
1167
         <xsl:call-template name="attributeList"/>
1168
    </xsl:variable>
1169
      <xsl:if test="string-length($maybeatts) &gt;0">
1170
         <xsl:text>&#10;&lt;!ATTLIST </xsl:text>
1171
         <xsl:value-of select="$ename"/>
1172
         <xsl:value-of select="$maybeatts"/>
1173
         <xsl:text> &gt;</xsl:text>
1174
      </xsl:if>
1175
      <xsl:if test="@ident='TEI' or @ident='teiCorpus'">
1176
         <xsl:text>&#10;&lt;!ATTLIST </xsl:text>
1177
         <xsl:value-of select="$ename"/>
1178
         <xsl:text> xsi:schemaLocation CDATA #IMPLIED&#10;</xsl:text>
1179
         <xsl:text> xmlns:xsi CDATA #FIXED 'http://www.w3.org/2001/XMLSchema-instance'&#10;</xsl:text>
1180
         <xsl:text> &gt;</xsl:text>
1181
      </xsl:if>
1182
  </xsl:template>
1183
  <xsl:template name="attclasses">
1184
      <xsl:for-each select="tei:classes/tei:memberOf">
1185
         <xsl:for-each select="key('IDENTS',@key)[1]">
1186
            <xsl:if test="@type='atts'"> %<xsl:value-of select="@ident"/>
1187
					          <xsl:text>.attributes;</xsl:text>
1188
				        </xsl:if>
1189
         </xsl:for-each>
1190
      </xsl:for-each>
1191
  </xsl:template>
1192
  <xsl:template name="classAtt">
1193
      <xsl:param name="declare">true</xsl:param>
1194
      <xsl:if test="$verbose='true'">
1195
         <xsl:message> .... <xsl:value-of select="@ident"/>.attributes</xsl:message>
1196
      </xsl:if>
1197
      <xsl:variable name="thisclass">
1198
         <xsl:value-of select="@ident"/>
1199
      </xsl:variable>
1200
      <xsl:choose>
1201
         <xsl:when test="$declare='false'">
1202
            <xsl:text>&#10;&lt;!ENTITY % </xsl:text>
1203
            <xsl:value-of select="$thisclass"/>
1204
            <xsl:text>.attributes</xsl:text>
1205
            <xsl:text> ''&gt;</xsl:text>
1206
         </xsl:when>
1207
         <xsl:otherwise>
1208
            <xsl:choose>
1209
               <xsl:when test="$parameterize='true'">
1210
                  <xsl:text>&#10;&lt;!ENTITY % </xsl:text>
1211
                  <xsl:value-of select="$thisclass"/>
1212
                  <xsl:text>.attributes '</xsl:text>
1213
                  <xsl:call-template name="attclasses"/>
1214
                  <xsl:call-template name="attributeList"/>
1215
                  <xsl:text>'&gt; </xsl:text>
1216
               </xsl:when>
1217
               <xsl:otherwise>
1218
                  <xsl:text>&lt;!ENTITY % </xsl:text>
1219
                  <xsl:value-of select="$thisclass"/>
1220
                  <xsl:text>.attributes '</xsl:text>
1221
                  <xsl:call-template name="attclasses"/>
1222
                  <xsl:call-template name="attributeList"/>
1223
                  <xsl:text>'&gt; </xsl:text>
1224
                  <xsl:for-each select="tei:attList/tei:attDef">
1225
                     <xsl:text>&#10;&lt;!ENTITY % </xsl:text>
1226
                     <xsl:value-of select="$thisclass"/>
1227
                     <xsl:text>.attribute.</xsl:text>
1228
                     <xsl:value-of select="translate(@ident,':','')"/>
1229
                     <xsl:text> '</xsl:text>
1230
                     <xsl:apply-templates mode="tangle" select="."/>
1231
                     <xsl:text>'&gt;&#10;</xsl:text>
1232
                  </xsl:for-each>
1233
               </xsl:otherwise>
1234
            </xsl:choose>
1235
         </xsl:otherwise>
1236
      </xsl:choose>
1237
  </xsl:template>
1238
  <xsl:template match="tei:classSpec" mode="tagatts">
1239
      <xsl:if test="@type='atts'">
1240
         <xsl:if test="$verbose='true'">
1241
            <xsl:message> .... added contents of [%<xsl:value-of select="@ident"/>.attributes;]</xsl:message>
1242
         </xsl:if>
1243
         <xsl:text>&#10; %</xsl:text>
1244
         <xsl:value-of select="@ident"/>
1245
         <xsl:text>.attributes;</xsl:text>
1246
      </xsl:if>
1247
  </xsl:template>
1248
  <xsl:template match="tei:moduleRef[@key]" mode="tangle">
1249
      <xsl:if test="$verbose='true'">
1250
         <xsl:message> moduleRef to <xsl:value-of select="@key"/>
1251
			      </xsl:message>
1252
      </xsl:if>
1253
      <xsl:text>&#10;&lt;!ENTITY %</xsl:text>
1254
      <xsl:text> file.</xsl:text>
1255
      <xsl:value-of select="@key"/>
1256
      <xsl:text> </xsl:text>
1257
      <xsl:text>PUBLIC</xsl:text>
1258
      <xsl:text> '-//TEI P5//</xsl:text>
1259
      <xsl:value-of select="key('FILES',@key)/tei:altIdent[@type='FPI']"/>
1260
      <xsl:text>//EN' '</xsl:text>
1261
      <xsl:value-of select="@key"/>
1262
      <xsl:text>.dtd'</xsl:text>
1263
      <xsl:text> &gt;&#10;</xsl:text>
1264
      <xsl:text>%file.</xsl:text>
1265
      <xsl:value-of select="@key"/>
1266
      <xsl:text>;&#10;</xsl:text>
1267
  </xsl:template>
1268
  <xsl:template match="tei:classSpec" mode="tangle">
1269
      <xsl:if test="$verbose='true'">
1270
         <xsl:message> .. classSpec <xsl:value-of select="@ident"/>,<xsl:value-of select="@type"/></xsl:message>
1271
      </xsl:if>
1272
      <xsl:choose>
1273
         <xsl:when test="@type='atts'">
1274
            <xsl:call-template name="classAtt"/>
1275
         </xsl:when>
1276
         <xsl:when test="@type='model'">
1277
            <xsl:call-template name="classModel"/>
1278
         </xsl:when>
1279
      </xsl:choose>
1280
  </xsl:template>
1281
  <xsl:template match="tei:classSpec" mode="process">
1282
      <xsl:choose>
1283
         <xsl:when test="@type='atts'">
1284
            <xsl:call-template name="classAtt"/>
1285
         </xsl:when>
1286
         <xsl:when test="@type='model'">
1287
            <xsl:call-template name="classModel"/>
1288
         </xsl:when>
1289
      </xsl:choose>
1290
  </xsl:template>
1291
  <xsl:template name="classModel">
1292
      <xsl:param name="declare">false</xsl:param>
1293
      <xsl:call-template name="processClassDefinition">
1294
         <xsl:with-param name="type">
1295
            <xsl:choose>
1296
               <xsl:when test="@generate">
1297
                  <xsl:value-of select="@generate"/>
1298
               </xsl:when>
1299
               <xsl:otherwise>
1300
                  <xsl:text>alternation
1301
	    sequence
1302
	    sequenceOptional
1303
	    sequenceOptionalRepeatable
1304
	    sequenceRepeatable</xsl:text>
1305
               </xsl:otherwise>
1306
            </xsl:choose>
1307
         </xsl:with-param>
1308
         <xsl:with-param name="declare" select="$declare"/>
1309
      </xsl:call-template>
1310
  </xsl:template>
1311
  <xsl:template name="makeClassDefinition">
1312
      <xsl:param name="type">alternation</xsl:param>
1313
      <xsl:param name="declare"/>
1314
      <xsl:variable name="IDENT">
1315
         <xsl:value-of select="@ident"/>
1316
         <xsl:choose>
1317
            <xsl:when test="$type='alternation'"/>
1318
            <xsl:otherwise>
1319
               <xsl:text>_</xsl:text>
1320
               <xsl:value-of select="$type"/>
1321
            </xsl:otherwise>
1322
         </xsl:choose>
1323
      </xsl:variable>
1324
      <xsl:if test="$verbose='true'">
1325
         <xsl:message> .... ... generate model <xsl:value-of select="$type"/> for <xsl:value-of select="@ident"/>
1326
			      </xsl:message>
1327
      </xsl:if>
1328
      <xsl:if test="$parameterize='true'">
1329
         <xsl:text>&#10;&lt;!ENTITY % x.</xsl:text>
1330
         <xsl:value-of select="$IDENT"/>
1331
         <xsl:text> "" &gt;</xsl:text>
1332
      </xsl:if>
1333
      <xsl:text>&#10;&lt;!ENTITY % </xsl:text>
1334
      <xsl:value-of select="$IDENT"/>
1335
      <xsl:text> "</xsl:text>
1336
      <xsl:if test="$parameterize='true'">
1337
         <xsl:text>%x.</xsl:text>
1338
         <xsl:value-of select="$IDENT"/>
1339
         <xsl:text>; </xsl:text>
1340
      </xsl:if>
1341
      <xsl:variable name="generate" select="@generate"/>
1342
      <xsl:variable name="members">
1343
         <M>
1344
            <xsl:for-each select="key('CLASSMEMBERS',@ident)">
1345
               <xsl:variable name="N">
1346
                  <xsl:choose>
1347
                     <xsl:when test="$parameterize='false'">
1348
                        <xsl:choose>
1349
                           <xsl:when test="key('CLASSES',@ident)">
1350
                              <xsl:variable name="exists">
1351
                                 <xsl:call-template name="checkClass">
1352
                                    <xsl:with-param name="id" select="@ident"/>
1353
                                 </xsl:call-template>
1354
                              </xsl:variable>
1355
                              <xsl:if test="not($exists='')">
1356
                                 <xsl:text>%</xsl:text>
1357
                                 <xsl:value-of select="@ident"/>
1358
                                 <xsl:text>;</xsl:text>
1359
                              </xsl:if>
1360
                           </xsl:when>
1361
                           <xsl:when test="key('MACROS',@ident)">
1362
                              <xsl:text>%</xsl:text>
1363
                              <xsl:value-of select="@ident"/>
1364
                              <xsl:text>;</xsl:text>
1365
                           </xsl:when>
1366
                           <xsl:when test="key('ELEMENTS',@ident)">
1367
                              <xsl:choose>
1368
                                 <xsl:when test="tei:altIdent=@ident">
1369
                                    <xsl:value-of select="@ident"/>
1370
                                 </xsl:when>
1371
                                 <xsl:when test="tei:altIdent">
1372
                                    <xsl:value-of select="normalize-space(tei:altIdent)"/>
1373
                                 </xsl:when>
1374
                                 <xsl:otherwise>
1375
                                    <xsl:value-of select="@ident"/>
1376
                                 </xsl:otherwise>
1377
                              </xsl:choose>
1378
                           </xsl:when>
1379
                        </xsl:choose>
1380
                     </xsl:when>
1381
                     <xsl:when test="self::tei:elementSpec">
1382
                        <xsl:if test="$parameterize='true'">
1383
                           <xsl:text>%n.</xsl:text>
1384
                        </xsl:if>
1385
                        <xsl:value-of select="@ident"/>
1386
                        <xsl:if test="$parameterize='true'">
1387
                           <xsl:text>;</xsl:text>
1388
                        </xsl:if>
1389
                     </xsl:when>
1390
                     <xsl:when test="self::tei:classSpec">
1391
                        <xsl:text>%</xsl:text>
1392
                        <xsl:value-of select="@ident"/>
1393
                        <xsl:text>;</xsl:text>
1394
                     </xsl:when>
1395
                     <xsl:otherwise>
1396
                        <xsl:value-of select="@ident"/>
1397
                     </xsl:otherwise>
1398
                  </xsl:choose>
1399
               </xsl:variable>
1400
               <xsl:if test="not($N='')">
1401
                  <N>
1402
                     <xsl:if test="starts-with($N,'%tei.')">
1403
                        <xsl:attribute name="type">class</xsl:attribute>
1404
                     </xsl:if>
1405
                     <xsl:if test="starts-with($N,'%model.')">
1406
                        <xsl:attribute name="type">class</xsl:attribute>
1407
                     </xsl:if>
1408
                     <xsl:value-of select="$N"/>
1409
                  </N>
1410
               </xsl:if>
1411
            </xsl:for-each>
1412
         </M>
1413
      </xsl:variable>
1414
      <xsl:for-each select="$members/M">
1415
         <xsl:call-template name="memberOfClassDefinition">
1416
            <xsl:with-param name="type" select="$type"/>
1417
         </xsl:call-template>
1418
      </xsl:for-each>
1419
      <xsl:text>"&gt; </xsl:text>
1420
  </xsl:template>
1421
  <xsl:template name="memberOfClassDefinition">
1422
      <xsl:param name="type"/>
1423
      <!-- does a class model need bracketing if all its members are also classes?
1424
	 <xsl:if test="count(N[@type='class'])=count(N) and count(N) &gt; 2">
1425
	 <xsl:text>(</xsl:text>
1426
	 </xsl:if>
1427
    -->
1428
    <xsl:for-each select="N">
1429
         <xsl:value-of select="."/>
1430
         <xsl:choose>
1431
            <xsl:when test="$type='sequence'">
1432
               <xsl:if test="position() &lt; last()">, </xsl:if>
1433
            </xsl:when>
1434
            <xsl:when test="$type='sequenceOptional'">
1435
               <xsl:text>?</xsl:text>
1436
               <xsl:if test="position() &lt; last()">, </xsl:if>
1437
            </xsl:when>
1438
            <xsl:when test="$type='sequenceRepeatable'">
1439
               <xsl:text>+</xsl:text>
1440
               <xsl:if test="position() &lt; last()">, </xsl:if>
1441
            </xsl:when>
1442
            <xsl:when test="$type='sequenceOptionalRepeatable'">
1443
               <xsl:text>*</xsl:text>
1444
               <xsl:if test="position() &lt; last()">, </xsl:if>
1445
            </xsl:when>
1446
            <xsl:otherwise>
1447
               <xsl:if test="position() &lt; last()"> |
1448
 </xsl:if>
1449
            </xsl:otherwise>
1450
         </xsl:choose>
1451
      </xsl:for-each>
1452
      <!-- see above
1453
	 <xsl:if test="count(N[@type='class'])=count(N) and count(N) &gt; 2">
1454
	 <xsl:text>)</xsl:text>
1455
	 </xsl:if>
1456
    -->
1457
  </xsl:template>
1458
  <xsl:template match="tei:commDecl" mode="tangle">
1459
      <xsl:text>&#10;  &lt;!--</xsl:text>
1460
      <xsl:apply-templates/>
1461
      <xsl:text>--&gt;</xsl:text>
1462
  </xsl:template>
1463
  <xsl:template name="attributeList">
1464
      <xsl:apply-templates mode="tangle" select="tei:attList/tei:*"/>
1465
  </xsl:template>
1466
  <xsl:template match="tei:attDef" mode="tangle">
1467
      <xsl:text>&#10;</xsl:text>
1468
      <xsl:choose>
1469
         <xsl:when test="@ns='http://www.w3.org/XML/1998/namespace'">
1470
            <xsl:text>xml:</xsl:text>
1471
         </xsl:when>
1472
         <xsl:when test="@ns='http://www.w3.org/1999/xlink'">
1473
            <xsl:text>xlink:</xsl:text>
1474
         </xsl:when>
1475
         <xsl:when test="$parameterize='true' and (@ns) and not($nsPrefix='') and not(starts-with(@ident,'xmlns'))">
1476
            <xsl:text>%NS;</xsl:text>
1477
         </xsl:when>
1478
      </xsl:choose>
1479
      <xsl:choose>
1480
         <xsl:when test="tei:altIdent=@ident">
1481
            <xsl:value-of select="@ident"/>
1482
         </xsl:when>
1483
         <xsl:when test="tei:altIdent">
1484
            <xsl:value-of select="normalize-space(tei:altIdent)"/>
1485
         </xsl:when>
1486
         <xsl:otherwise>
1487
            <xsl:value-of select="@ident"/>
1488
         </xsl:otherwise>
1489
      </xsl:choose>
1490
      <xsl:choose>
1491
         <xsl:when test="(number(tei:datatype/@maxOccurs) &gt; 1 or tei:datatype/@maxOccurs='unbounded') and tei:datatype/rng:ref[@name='data.enumerated']">
1492
            <xsl:text> NMTOKENS </xsl:text>
1493
         </xsl:when>
1494
         <xsl:when test="(number(tei:datatype/@maxOccurs) &gt; 1 or  tei:datatype/@maxOccurs='unbounded') and tei:datatype/rng:ref[@name='data.name']">
1495
            <xsl:text> NMTOKENS </xsl:text>
1496
         </xsl:when>
1497
         <xsl:when test="(number(tei:datatype/@maxOccurs) &gt; 1 or  tei:datatype/@maxOccurs='unbounded') and tei:datatype/rng:data[@type='Name']">
1498
            <xsl:text> NMTOKENS </xsl:text>
1499
         </xsl:when>
1500
         <xsl:when test="tei:valList[@type='closed']">
1501
            <xsl:text> (</xsl:text>
1502
            <xsl:for-each select="tei:valList/tei:valItem">
1503
               <xsl:value-of select="@ident"/>
1504
               <xsl:if test="following-sibling::tei:valItem">
1505
		 <xsl:text>|</xsl:text>
1506
	       </xsl:if>
1507
            </xsl:for-each>
1508
            <xsl:text>)</xsl:text>
1509
         </xsl:when>
1510
         <xsl:when test="tei:datatype/rng:data[@type='Name']">
1511
            <xsl:text> NMTOKEN </xsl:text>
1512
         </xsl:when>
1513
         <xsl:when test="tei:datatype/@minOccurs or tei:datatype/@maxOccurs">
1514
            <xsl:text> CDATA </xsl:text>
1515
         </xsl:when>
1516
         <xsl:when test="tei:datatype/rng:*">
1517
            <xsl:apply-templates select="tei:datatype"/>
1518
         </xsl:when>
1519
         <xsl:otherwise>
1520
            <xsl:text> CDATA </xsl:text>
1521
         </xsl:otherwise>
1522
      </xsl:choose>
1523
      <xsl:choose>
1524
         <xsl:when test="string-length(tei:defaultVal) &gt;0">
1525
            <xsl:text> "</xsl:text>
1526
            <xsl:value-of select="tei:defaultVal"/>
1527
            <xsl:text>" </xsl:text>
1528
         </xsl:when>
1529
         <xsl:when test="parent::tei:attList[@org='choice']">
1530
            <xsl:text> #IMPLIED</xsl:text>
1531
         </xsl:when>
1532
         <xsl:when test="@usage='req'">
1533
            <xsl:text> #REQUIRED</xsl:text>
1534
         </xsl:when>
1535
         <xsl:otherwise>
1536
            <xsl:text> #IMPLIED</xsl:text>
1537
         </xsl:otherwise>
1538
      </xsl:choose>
1539
  </xsl:template>
1540
  <xsl:template name="bitOut">
1541
      <xsl:param name="grammar"/>
1542
      <xsl:param name="element"/>
1543
      <xsl:param name="content"/>
1544
      <xsl:copy-of select="$content"/>
1545
  </xsl:template>
1546
  <xsl:template name="CR">
1547
      <xsl:text>&#10;</xsl:text>
1548
  </xsl:template>
1549
  <xsl:template match="tei:memberOf" mode="tangleAtts">
1550
      <xsl:variable name="ident">
1551
         <xsl:value-of select="ancestor::tei:elementSpec/@ident|ancestor::tei:classSpec/@ident"/>
1552
      </xsl:variable>
1553
      <xsl:variable name="K" select="@key"/>
1554
      <xsl:choose>
1555
         <xsl:when test="key('IDENTS',$K)">
1556
            <xsl:for-each select="key('IDENTS',@key)[1]">
1557
               <xsl:apply-templates mode="tagatts" select="."/>
1558
            </xsl:for-each>
1559
         </xsl:when>
1560
         <xsl:otherwise>
1561
	   <xsl:for-each select="document($localsource)/tei:TEI">
1562
	     <xsl:apply-templates mode="tagatts" select="key('LOCALIDENTS',$K)"/>
1563
	   </xsl:for-each>
1564
	 </xsl:otherwise>
1565
      </xsl:choose>
1566
  </xsl:template>
1567
  <xsl:template match="tei:attRef" mode="tangle">
1568
      <xsl:text>&#10; %</xsl:text>
1569
      <xsl:value-of select="@name"/>
1570
      <xsl:text>;</xsl:text>
1571
  </xsl:template>
1572
  <xsl:template name="checkClass">
1573
      <xsl:param name="id"/>
1574
      <!-- should a class be included?
1575
	 * it must exist in the ODD spec
1576
	 * it must have other classes which point to it
1577
	 * whatever it points to must have members which are in the ODD
1578
    -->
1579
    <xsl:for-each select="key('CLASSMEMBERS',$id)">
1580
         <xsl:choose>
1581
            <xsl:when test="self::tei:elementSpec and key('ELEMENTS',@ident)">
1582
               <xsl:text>true</xsl:text>
1583
            </xsl:when>
1584
            <xsl:when test="self::tei:macroSpec and key('MACROS',@ident)">
1585
               <xsl:text>true</xsl:text>
1586
            </xsl:when>
1587
            <xsl:when test="self::tei:classSpec and key('CLASSES',@ident)">
1588
               <xsl:call-template name="checkClass">
1589
                  <xsl:with-param name="id" select="@ident"/>
1590
               </xsl:call-template>
1591
            </xsl:when>
1592
         </xsl:choose>
1593
      </xsl:for-each>
1594
  </xsl:template>
1595
  <xsl:template name="dtdComment">
1596
      <xsl:param name="text"/>
1597
      <xsl:text>&#10;&lt;!--&#10;</xsl:text>
1598
      <xsl:value-of select="$text"/>
1599
      <xsl:text>&#10;--&gt;&#10;</xsl:text>
1600
  </xsl:template>
1601
  <xsl:template name="checkEnd">
1602
      <xsl:if test="count(parent::tei:content[parent::tei:elementSpec]/rng:*)&gt;1 and     not(following-sibling::rng:*)">
1603
         <xsl:text>)</xsl:text>
1604
      </xsl:if>
1605
  </xsl:template>
1606
  <xsl:template name="checkStart">
1607
      <xsl:if test="count(parent::tei:content[parent::tei:elementSpec]/rng:*)&gt;1">
1608
         <xsl:choose>
1609
            <xsl:when test="preceding-sibling::rng:*">
1610
               <xsl:text>,</xsl:text>
1611
            </xsl:when>
1612
            <xsl:otherwise>
1613
               <xsl:text>(</xsl:text>
1614
            </xsl:otherwise>
1615
         </xsl:choose>
1616
      </xsl:if>
1617
  </xsl:template>
1618

    
1619

    
1620
  <xsl:template name="copyright">
1621
    <xsl:for-each
1622
	select="/tei:TEI/tei:teiHeader/tei:fileDesc/tei:publicationStmt/tei:availability">
1623
      <xsl:if test="count(tei:licence)&gt;1">
1624
	<xsl:text>This material is dual-licensed.&#10;</xsl:text>
1625
      </xsl:if>
1626
      <xsl:apply-templates/>
1627
    </xsl:for-each>
1628
  </xsl:template>
1629

    
1630
  <xsl:template match="tei:licence">
1631
    <xsl:if test="@target">
1632
      <xsl:text>[</xsl:text>
1633
      <xsl:value-of select="@target"/>
1634
      <xsl:text>] </xsl:text>
1635
    </xsl:if>
1636
    <xsl:apply-templates/>
1637
  </xsl:template>
1638

    
1639
  <xsl:template name="typewriter">
1640
    <xsl:param name="text"/>
1641
  </xsl:template>
1642

    
1643

    
1644
</xsl:stylesheet>