deliverable n°: d3.3 (extended) tools for translating

Deliverable N°: D3.3 (Extended) tools for translating existing other formats into

new format Version: Final version – V2.0

Due date of Deliverable: May 2007

Actual submission date: 31 January 2008

Start date of Project: 1 January 2006

Duration: 30 months

Project Coordinator: Universiteit van Amsterdam (NL)

Lead contractor deliverable: Corvinus University Budapest

Participating contractors: Alma Mater Studiorum - Universita di Bologna (IT), University of Liverpool (UK), Fraunhofer Gesellschaft zur foerderung der angewandten forschung e.v. (DE), RuleWise b.v. (NL), RuleBurst (EUROPE) Ltd. (UK), knowledgeTools International GmbH (DE), Interaction Design Ltd. (UK), SOGEI - Societa Generale d'Informatica S.P.A. (IT), Ministro per le Riforme e le Innivazioni nella Publica Amministrazione (IT), Hungarian Tax and Financial Control Administration (HU), Budapesti Corvinus Egyetem (HU), Ministero dell'Economia e delle Finanze (IT), Consorzio Pisa Ricerche SCARL (IT)

Project funded by the European Community under the 6th Framework Programme

Dissemination Level

PU Public PP Restricted to other programme participants (including the Commission Services) RE Restricted to a group specified by the consortium (including the Commission Services) CO Confidential, only for members of the consortium (including the Commission Services) X

ESTRELL@

IST-2004-027655

European project for Standardized Transparent Representations in order to Extend LegaL Accessibility

Specific Targeted Research or Innovation Project

Specific Targeted Research Project Information Society Technologies

ESTRELLA Deliverable 3.3

2

EXECUTIVE SUMMARY

Scope and objective of the deliverable

This document presents the Estrella translation methods and tools creating the MetaLex/CEN representation of an existing national standard.

The Dutch pilot case is based on their national standard MetaLex 1.3.1. They are able to create both the generic MetaLex/CEN and the MetaLex/LS of their national representation. In addition their tools can transform the MetaLex/LS to the generic one.

The Hungarian pilot explains an automatic conversion from a HTML tagged plain text to MetaLex/CEN. First of all a specific application creates their XML based representation then an XSL transformation produces the MetaLex/CEN.

The Italian pilot is about the bidirectional translation between their national standard NIR and MetaLex/CEN. They introduce the NIR specific elements and the connection to LKIF-Core.

Organization of the deliverable

The deliverable is organized in five main chapters that describe the details of the pilot cases respectively beside the theoretical issues behind.

Chapter 2 describes the general concepts used in legal source translation, especially to MetaLex/CEN format.

Chapter 3 gives an overview of the standard translation methods and the related topics such as the reference mechanism between LKIF model and Metalex/CEN.

Chapter 4 introduces the Dutch pilot that contains tools of translation to produce generic MetaLex/CEN and MetaLex/LS representation of their national standard.

Chapter 5 presents the Hungarian translator that explains how they can create the MetaLex/CEN representation of a legal document given in HTML format.

Chapter 6 describes how the Italian tools can realize the translation between NIR and MetaLex/CEN in both directions. Furthermore it shows how to connect MetaLex/Cen and LKIF.

The remaining chapters are Annexes that contain source code and the related examples of the Dutch, Hungarian and Italian translator tools.


3

Deliverable 3.3, Translators

(Extended) tools for translating existing other formats into new format Emile de Maat, Saskia van de Ven Leibniz Center for Law University of Amsterdam Monica Palmirani, Luca Cervone, Federica Benigni Alma Mater Studiorum - Universita di Bologna Krisztián Mácsár, Gábor Kőrösi, György Strausz Corvinus University Budapest


4

Contents 1 INTRODUCTION ...................................................................................................................... 6

2 GENERAL TRANSLATION CONCEPTS ........................................................................................ 7

2.1 GENERAL CONSIDERATIONS ............................................................................................................... 7 2.2 NEW PATTERNS IN THE METALEX/CEN STANDARD ................................................................................ 8 2.3 FORKING FROM THE METALEX/CEN FOR ESTRELLA ........................................................................... 10

3 STANDARD TRANSLATION APPROACHES ............................................................................... 13

3.1 PREVIOUS EXISTING FORMAT TRANSLATION ........................................................................................ 13 3.2 PREVIOUS EXISTING STANDARD WRAPPING ......................................................................................... 13 3.3 REFERENCES TO LKIF‐CORE AND LKIF‐RULES ................................................................................... 13

3.3.1 Proposed new classes into LKIF‐core ............................................................................. 14 3.3.2 The reference mechanism between MetaLex/CEN and LKIF‐core ................................ 16

3.4 RDFA INTEGRATION INTO THE TRANSFORMATION: AN ABSTRACT MAPPING WITH LMIF LEVEL ...................... 19 3.5 SUMMARY ................................................................................................................................... 21

4 DUTCH TRANSLATOR ............................................................................................................ 23

4.1 OVERVIEW ................................................................................................................................... 23 4.2 METALEX 1.3.1 TO GENERIC METALEX/CEN ..................................................................................... 23

4.2.1 Elements ......................................................................................................................... 23 4.2.2 Attributes ....................................................................................................................... 27

4.3 METALEX 1.3.1 TO METALEX/LS 1.0............................................................................................... 28 4.3.1 Elements ......................................................................................................................... 28

4.4 METALEX/LS TO GENERIC METALEX/CEN ......................................................................................... 31

5 HUNGARIAN TRANSLATOR ................................................................................................... 33

5.1 OVERVIEW ................................................................................................................................... 33 5.2 SOURCE SPECIFIC PROBLEMS ............................................................................................................ 33 5.3 ARCHITECTURE ............................................................................................................................. 33 5.4 INTERMEDIATE FORMAT .................................................................................................................. 34

5.4.1 Common attributes ........................................................................................................ 34 5.4.2 Element types ................................................................................................................. 35

5.5 TRANSLATION ............................................................................................................................... 37 5.5.1 Translation concept........................................................................................................ 37 5.5.2 Creating Intermediate XML ........................................................................................... 38 5.5.3 Creating MetaLex/CEN .................................................................................................. 40 5.5.4 Metadata ....................................................................................................................... 42

5.6 SUMMARY ................................................................................................................................... 42

6 ITALIAN TRANSLATOR ........................................................................................................... 44

6.1 OVERVIEW ................................................................................................................................... 44 6.2 NIR SPECIFIC ELEMENTS ................................................................................................................. 44 6.3 WRAPPER VS CONVERSION TOOLS ..................................................................................................... 46 6.4 NIR2METALEX CONVERSION TOOL ................................................................................................... 48 6.5 ADDING RDFA INTO METALEX/CEN XML ........................................................................................ 55 6.6 RDF EXTRACTOR ........................................................................................................................... 57 6.7 METALEX2NIR CONVERSION TOOL .................................................................................................. 58 6.8 NORMA‐EDITOR ........................................................................................................................... 59

7 ANNEX A .............................................................................................................................. 61

7.1 XSL DEFINITION OF THE METALEX 1.3.1 TO METALEX/CEN TRANSLATION .............................................. 61 7.2 XSL DEFINITION OF THE METALEX 1.3.1 TO METALEX/LS 1.0 TRANSLATION ........................................... 68 7.3 METALEX/LS 1.0 WRAPPER ........................................................................................................... 76

8 ANNEX B .............................................................................................................................. 81

8.1 XSL DEFINITION OF THE HUNGARIAN TRANSLATOR ............................................................................... 81


5

9 ANNEX C ‐ ITALIAN TRANSLATORS ........................................................................................ 84

9.1 FORKING OF METALEX/CEN FOR NIR TRANSLATION ............................................................................ 84 9.2 WRAPPER .................................................................................................................................... 92 9.3 NIR2META_3‐2.XSLT .................................................................................................................. 103 9.4 META2NIR_2‐0.XSLT .................................................................................................................. 196 9.5 LMIF_1‐1‐CURIE.RDF ............................................................................................................... 197 9.6 RDF EXTRACTOR COMPLIANT WITH GRDDL SPECIFICATIONS ............................................................... 198 9.7 SAMPLES OF DOCUMENT ITALIAN SAVING TAX D.LGS 84/2005 .......................................................... 199

9.7.1 Original document in NIR ............................................................................................. 199 9.7.2 MetaLex/CEN document translated ............................................................................ 204 9.7.3 RDF Extraction .............................................................................................................. 213 9.7.4 Back to NIR from MetaLex/CEN ................................................................................... 216


6

1 Introduction

The aim of this deliverable is to present techniques and tools for producing a translation from existing mark-up format to MetaLex/CEN.

Three main pilots are presented: a) conversion from MetaLex 1.3.1 into MetaLex/CEN, performed by UvA; b) conversion from Hungarian HTML documents into MetaLex/CEN, performed

by CUB; c) conversion from NIR, Italian national standard for legal resources, into

MetaLex/CEN and back, performed by UNIBO-Italy.

New elements where introduced for permitting the compatibility with other existing standard, but moreover for enhancing and adapting MetaLex/CEN to the purposes of ESTRELLA project. In particular several elements are added for representing better the ontological par of a legal resource [CWA2007].

A second goal is also to demonstrate how it is possible to link MetaLex/CEN to LKIF-core and to the LKIF logic layer using the attributes of MetaLex/CEN and some other techniques such as RDFa syntax or RDF (see § 3.3).

Two approaches are possible for facing the translation into MetaLex/CEN: a) translate the national standard schema or DTD in a MetaLex/CEN elements. In

case a national standard doesn’t exist, a HTML template is considered the input for the translation. The mechanism maps all the original elements into the MetaLex/CEN elements through a corresponding table, tool or an XSLT.

b) produce an extension of the MetaLex/CEN schema for validating the existing document as an extension MetaLex/CEN standard.

Before to enter into detail of these two approaches and in the three concrete pilots, we intend to present the general concepts of this translation to MetaLex/CEN.


7

2 General translation concepts

2.1 General considerations

The main issue in the translation tools is to convert the existing standard sources in MetaLex/CEN documents that are used for interchange activities. This means that the main goal is to preserve a correspondence with the existing standard elements and the MetaLex/CEN ones in order to use the common definition with the similar meaning. This normalisation process should be applied to the existing standard (national standard, HTML template, exchange formats in XML, etc.) in order to preserve the expressiveness of the source format and the document metadata. On the other hand MetaLex/CEN is a general standard for interchanging, therefore the challenge is to convert the source, previously marked up, and minimise the lost of descriptiveness, semantic, information.

In general the XML national standards for legal resources, or in general an existing mark up schema, are conditioned by different factors:

a) legal system configuration (civil law, common law); b) government form (constitutional monarchy, republic, etc.); c) organisation of the parliament (bicameralism, unicameralism, etc.); d) legacy information system (public administration information system,

databases, etc.); e) application layers. Specific purposes sometime lead the XML standard such as

Publication process, consolidation, presentation, search, interoperability between systems, etc.

Therefore the translation should concentrate the attention only on the content of the legal source (document content) and on the metadata of the legal source (document metadata). Not on the metadata that represent particular processes, workflow, applications, and local particularities.

The translation should pay attention primarily to produce an output with the following characteristics:

DOCUMENT MODELLING. The translation should mostly concentrate the effort to preserve the structure of the original document in the conversion to MetaLex/CEN. (e.g. the granularity of the original mark-up in the structure should be preserved: commas, lines, etc.)

METADATA PRESERVING. it is preserve the document metadata. Some metadata concern issues more oriented to the application layer: such as publication process, web searching, local classification vocabulary or thesaurus. Other metadata express information about the legal content of the document or the document itself. We are interested to find a mechanism that is able to preserve these metadata not only as information (literal) but also


8

semantically in order to make possible to compare the same abstract concept between different sources. (e.g. the metadata concerning the typographic processes should be externalised).

DESCRIPTIVENESS. The translation should preserve the original descriptiveness of the mark up in order to avoid in the normalisation process to pass to an excessive generalisation of the elements. (e.g. do not use in a trivial way the element metadata or block just for making the document valid). For doing that a semantic and structural analysis of the original standard is necessary for understanding the meaning of each tag, attribute and it function in the description of the document. One other point is to maintain all the naming of the original elements and attributes inside of the converted document for permitting to the reader to understand better the transformation product.

PATTERN ORIENTED. The translation process should preserve the pattern division of MetaLex/CEN. So an analysis of the content model definition used in the original standard is necessary in order to making a mapping with the MetaLex/CEN patters.

INVERSE TRANSLATION. The translation should preserve the descriptiveness of the element in a way that it is always possible, with and invert process, to obtain again the original document.

In order to preserve the above characteristics it was necessary to integrate elements and attributes to those already existing in the MetaLex/CEN standard. For the same reason, the structure of certain other elements has been changed. Some of these changes have been included in the original version of the standard. Instead, other elements were considered of aid for the translation of some specific national standard (such as NIR) and therefore were included in a forking.

2.2 New patterns in the MetaLex/CEN standard

ROOT: the root element must contain a container element. This because some existing standards do not have mContainer block as child of the root. Indeed before this modification we had:

Old

<xsd:complexType name="absRootType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urType"> <xsd:sequence> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absContainer" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="e:typeroot"/> </xsd:restriction> </xsd:complexContent>

Now we have the following that permits to have asbContainer only.

<xsd:complexType name="absRootType" abstract="true"> <xsd:complexContent>


9

<xsd:restriction base="e:urType"> <xsd:sequence> <xsd:element ref="e:absContainer" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="e:typeroot"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

MCONTAINER: The Mcontainer element may be included in Hcontainer, Container and Mcontainer elements. This modification is a consequence of requirement of the previous point (root).

Old

<xsd:complexType name="absMcontainerType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urType"> <xsd:choice> <xsd:element ref="e:absMeta" maxOccurs="unbounded"/> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> </xsd:choice> <xsd:attributeGroup ref="e:typemcontainer"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

New

<xsd:complexType name="absMcontainerType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absMeta" maxOccurs="unbounded"/> <xsd:element ref="e:absGenericMeta" maxOccurs="unbounded"/> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> </xsd:choice> <xsd:attributeGroup ref="e:typemcontainer"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

ANY ATTRIBUTE: Any elements may contain any attribute from any namespace. The reasons for this modification are many: i) this permits more flexibility in order to maintain the descriptiveness of the original attributes; ii) this permits to a more compensable and compact reading to the end-user confident with the national standard; iii) it permits the inverse translation in order to reproduce the original standard format.

Old element of Hcontainer

<xsd:complexType name="absHcontainerType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urContentType"> <xsd:sequence>


10

<xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> </xsd:choice> </xsd:sequence> <xsd:attributeGroup ref="e:typehcontainer"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

New element of Hcontainer with any as attribute:

<xsd:complexType name="absHcontainerType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urContentType"> <xsd:choice maxOccurs="unbounded"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> </xsd:choice> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absBasic"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> </xsd:choice> </xsd:choice> <xsd:attributeGroup ref="e:typehcontainer"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent>

2.3 Forking from the MetaLex/CEN for ESTRELLA

New elements where introduced in MetaLex/CEN for representing specific parts of legal resource. The main elements introduced are:

QUOTEDCONTENT: any part of the text that doesn’t belong to the current document but it is part of a other document under the semantic point of view. It is usually encapsulated inside of quoted symbol such as << - >> or “ …” or "…".

Example Property

“Articolo 1a For the purposes of this Directive: 1. 'depositary' shall mean any institution entrusted with the duties mentioned in Articles 7 and 14 and subject to the other provisions laid down in Sections IIIa and IVa; 2. 'management company' shall mean any company, the regular business of which is the management of UCITS in the form of unit trusts/common funds and/or of investment companies (collective portfolio management of UCITS); this includes the functions mentioned in Annex II.”

QuotedStrcture

“Council Directive 77/799/EEC of 19 December 1977

QuotedText


11

concerning mutual assistance by the competent authorities of the Member States in the field of direct taxation, certain excise duties and taxation of insurance premiums”.

CITATION: citation was introduced for modelling any normative cross-reference embedded in the text to other legal resources or to internal part of the same text. Some examples are produced with a taxonomy of normative cross-references:

Example Property Art. 3 of the Law n. 48 of 12 January 2005

Art. 5, 15, 16 of the Law n. 48 of 12 January 2005 Art. 5 to 19 of the Law n. 48 of 12 January 2005

Simple List

Interval

Art. 5 of the Law n. 48 of 12 January 2005 Art. 5 of the Law n. 48 of 2005

Art. 5 of Budgetary Law

Incomplete Complete

Abbreviate

Art. 5 of the Law n. 48 of 2005 Law n. 48 of 2005, Art. 15 and 32

Art. 56 of the Law n. 48 of 2005, section 1-5 and section 7-9

Ascendant Descendent

Hybrid

the Art. 5 of the present document Art. 5 of the Law n. 48 of 2005

Internal External

The Table A of the Budgetary Law 2001 The Table A of the Digital Signature Law n. 45, 2005

Static Dynamic

The first paragraph The last paragraph

Relative

QUOTEDCONTENT: the quetedContent element is a mixed content model and can contain meta container, hierarchical containers and basic elements.

QuotedType

<xsd:complexType name="absQuotedType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:urType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

QuotedContent

<xsd:element name="absQuotedContent" type="e:absQuotedType" abstract="true"/>

CITATION: An inline element used to indicate a normative reference to another legal resource.

CitationType

<xsd:complexType name="absCitationType" abstract="true" mixed="true">


12

<xsd:complexContent mixed="true"> <xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absMeta"/> <xsd:element ref="e:absMilestone"/> </xsd:choice> <xsd:attributeGroup ref="e:typeinline"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

Citation Element

<xsd:element name="citation" type="e:genCitationType" substitutionGroup="e:absCitation"/>


13

3 Standard translation approaches

Two main approaches are possible to solve the problem: a) mapping each existing element and attribute into the MetaLex/CEN standard; b) extending the MetaLex/CEN standard with a wrapper for making the original

documents valid in MetaLex/CEN [D3.2].

The following paragraphs intends to present the pros and cons of each approach.

3.1 Previous existing format translation

For achieving the goal to perform a mapping between existing marked-up format (national standards, existing local standards, HTML templates, etc.) we can use different tools:

i) when an XML schema or DTD already exist, it is suggested to use XSLT (CWA20071);

ii) when an HTML template exist, it is possible to develop an application layer for translating it;

iii) when a DBMS or CMS contain the original documents, an export module should be implemented.

3.2 Previous existing standard wrapping

The second approach for translating existing standard format into MetaLex/CEN is to use a wrapper that makes valid the existing marked-up documents. This is possible only if we have an XML mark-up format.

The technique was already presented in the D3.2. It consist to map with an XSD file all the elements and attributes of the existing standard on the MetaLex/CEN abstract elements and abstract type, with respect of the pattern architecture imposed by MetaLex/CEN.

After this mapping, that should be done manually from a designer of the XML schema, the instruction substitutiongroup of XML-schema language:

<xsd:element name="articolo" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/>

3.3 References to LKIF-CORE and LKIF-Rules

MetaLex/CEN is an interchange standard and for this reason can not model elements or attributes with semantic meaning. This is for maintaining a meta-level of descriptiveness independently to the single national or pre-existing mark-up format, design or vocabulary. 1 svn.metalex.eu/svn/MetaLexWS/documentation/2007proposal/CWA2007.pdf


14

For these reason elements such as “article” or “preamble”, that are a semantic interpretation of a particular part of the text, is demanded to LKIF-core ontology. The abstract concepts of several important parts of the legal resource were evaluated and analysed. Therefore an improvement of LKIF-core was suggested for the next WP4 period in order to make possible the complete annotation of the legal resource document

3.3.1 Proposed new classes into LKIF-core

The classes proposed in LKIF-core are divided in three main categories: a) legal public actions (such as publication); b) legal temporal events (such as the transposition date included in the EU

directive); c) structure of the legal resource (such as articles, etc.); d) semantic structure of the legal document organisation (preamble, preface,

etc.).

LEGAL PUBLIC ACTIONS

Class Definition Axioms Part of the ontology LKIF-core

Act_of_Publication Act of Publication: a public act by a legislative body which publishes or gives a delegation to third body to publish a manifestation of the act with legal value on the Official Journal.

It is > of the Delivery_Date It is > of the Enter_in_Force_Date

legal_action.owl

Act_of_Commencement Legal Act of the enter of the Act into the legal system.

LEGAL TEMPORAL EVENTS

Class Definition Axioms Proposed modification in LKIF-core

Transposition_Date Deadline within the member states must implement/transpose the EU Directives into national Law.

It is > of the Delivery_Date It is > of the Enter_in_Force_Date

time-modification.owl

STRUCTURE OF THE LEGAL RESOURCE

Class Definition Axioms Proposed modification in LKIF-core

Higher_Division Higher division of the legal resource

It is part_of Higher_Division

merology.owl

Basic_Unit It is the basic normative element with a unique numbering in all the document. It is the basic of the normative citations.

It is part_of Higher_Division

merology.owl


15

Sub_Division It is the basic normative element with a unique numbering in all the document. It is the basic of the normative citations.

It is part_of Basic_Element

merology.owl

SEMANTIC ORGANISATION OF THE LEGAL RESOURCE

Class Definition Axioms Part of the ontology LKIF-core

Modifier Legal resource document expression that affect others legal resource(s) document expression

expression.owl

Modified Legal resource document expression affected by others legal resource(s) document expression

expression.owl

Preface Header of the Legal Resource

It is strictly_part_of Legal Document Structure

expression.owl

Preamble Motivation and justification part of the Legal Resource

It is strictly_part_of Preface

expression.owl

Enacting_Section Normative and binding part of the Legal Resource

It is strictly_part_of Legal Document Structure It is after Preface

expression.owl

Conclusion Final sentence of the Legal Resource that demonstrate and statue the legal validity and power of the body organisation.

It is strictly_part_of Legal Document Structure It is after Enacting_ Section

expression.owl

Signature Part where are present the signature of the people empowered to make valid the legal resource.

It is strictly_part_of Conclusion

expression.owl

Independent _Annex Independent Annex to the Legal Recouces. (e.g. International Treaty, contract, Deontological Code, etc.)

It is part_of Legal Document Structure It is independent Legal Resource

expression.owl

Dependent _Annex

Dendent Annex to the Legal Recouces.

It is strictly_part_of Legal Document Structure

New_Text Type of quotedContent: it means a new part of the text.

It is part_of Sub_Division It is part_of Basic_Element

expression.owl

Old_Text Type of quotedContent: it means a old part of the text.

It is part_of Sub_Division It is part_of Basic_Element

expression.owl

Position_Text Type of quotedContent: it means an anchor to the text.

It is part_of Sub_Division It is part_of

expression.owl


16

Basic_Element

Publication_Type Type of publication It is a part of the Act_of_Publication

expression.owl

Publication_Numebr Serial Number of the publication

It is a part of the Act_of_Publication

expression.owl

3.3.2 The reference mechanism between MetaLex/CEN and LKIF-core

The reference mechanism for linking MetaLex/CEN to LKIF-core uses the RDFa2 syntax for expressing RDF3 statement.

The objective is to use RDFa syntax for classify the structural part of the MetaLex/CEN text with the LKIF-core semantic meaning. The RDFa was chosen as syntax because permits to embed the assertions and because the XML file can alternatively be used in a proficiency way by several web engine and spider for classifying the document through the metadata.

Furthermore the RDFa was selected because it is possible, with an RDFa process, extract in automatic way RDF statements, also by reification. For understanding how RDFa is working we start with the RDF statement that is the final goal where we would like to arrive.

An RDF statement has the following architecture for providing semantic to the metadata:

SUBJECT: the thing the statement describes; PREDICATE: a specific property; OBJECT: the thing the statement says is the value of the property, for the thing the statement describes.

The subject and the property value are always URIs (including CURIE syntax4). The object is either a URI or a (optionally datatyped) literal.

Example:

<rdf:Statement> <rdf:subject rdf:resource="Document.xml"/> <rdf:predicate rdf:resource="lkif-legal-action:Act_of_Publication"/> <rdf:object rdf:resource="nir:pubblicazione"/> </rdf:Statement>

2 http://www.w3.org/TR/xhtml-rdfa-primer/ 3 http://www.w3.org/TR/rdf-primer/ 4 http://www.w3.org/2001/sw/BestPractices/HTML/2005-10-27-CURIE, http://www.w3.org/TR/2007/WD-curie-20070307/


17

Figure 1 - RDF statement

The final goal is to produce a list of such statements starting from the MetaLex/CEN enriched with RDFa.

On the other side an important predicate can help this mechanism: rdf:type predicate, typically property of the RDF syntax5, specifies that a particularly subject is a member of the class in the object. Therefore the following statement says that the element nir:pubblicazione is_an_instance of the class of LKIF-core Act_of_Publication.

Example:

<rdf:Description rdf:about=”nir:publicazione”> <rdf:type rdf.resource=”http://www.estrellaproject.org/lkif-core/legal-action.owl#Act_of_Publication”> </rdf:Description>

Using this predicate (rdf:type) we are able to exploit the RDFa syntax and permits an embedded annotation of the metadata inside of the XML document, therefore we can use RDFa syntax for enriching the MetaLex/CEN with statement concerning the semantic meaning of the structure.

5 http://www.w3.org/2001/sw/RDFCore/


18

Figure 2 – RDFa statement

RDFa uses the following syntax for making statements6:

A) ANNOTATION OF THE LITTERAL rdfa:about defines the subject. URI rdfa:property defines the predicate. URI rdfa:content defines the object as literal. <rdf:about=”” rdfa:property=”lkif:publication_date” rdfa:content=”19990517”>

this statement says that the document has a publication_date with content = 19990517 B) ANNOTATION OF THE URI rdfa:about defines the subject. URI rdfa:rel defines the property where about is the subject. URI rdfa:rev defines the property where about is the object (inverse property) rdfa:href defines the object. URI <rdf:about=”” rdfa:rel=”lkif:publication_date” rdfa:href=”http://www.estrella.org/it/act/20041010/11/ita@/main.xml#span12”>

this statement says that the document has a publication date in the span12

Because in our case we need to make a connection between the LKIF-core classes and the document values, we are using in MetaLex/CEN the above annotation rispectively: for the elements the annotation B) with REL predicate; for the attributes the annotation A) with CONTENT.

The result inside of the MetaLex/CEN using RDFa syntax embedded is the following:

<mcontainer name="pubblicazione" id="metalex_idpubblicazione115252432" xmlns:rdfa="http://www.w3.org/ns/rdfa/" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-legal_action:Act_of_Pubblication]" tipo="GU" num="113" norm="19990517"> <meta id="metalex_idtipo115252488" name="pubblicazione-tipo" rdfa:about="#pubblicazione" rdfa:property="[lkif-expression:Pubblication_Type]" rdfa:content="GU"/>

6 http://www.w3.org/2006/07/SWD/RDFa/syntax/


19

<meta id="metalex_idnum115252592" name="pubblicazione-num" rdfa:about="#pubblicazione" rdfa:property="[lkif- expression:Pubblication_Number]" rdfa:content="113"/> <meta id="metalex_idnorm115252672" name="pubblicazione-norm" rdfa:about="#pubblicazione" rdfa:property="[lkif-time_modification:Pubblication_Date]" rdfa:content="19990517"/> </mcontainer>

That means to say the following assertion: i) the current document has a publication_act in the current metadata; ii) pubblicazione has a Type with value GU; iii) pubblicazione has a number with value 113; iv) pubblicazione has Publication_date with value 19990517.

Finally using an RDFa process (XSLT extractor) we can obtain five statements in RDF.

<rdf:Description rdf:about="metalex_idpubblicazione115252432"> <rdf:type rdf:resource="[lkif-legal_action:Act_of_Pubblication]"/> </rdf:Description> <rdf:Description rdf:about="metalex_idtipo115252488"> <rdf:type rdf:resource="[lkif- expression:Pubblication_Type]"/> </rdf:Description> <rdf:Description rdf:about="metalex_idnum115252592"> <rdf:type rdf:resource="[lkif- expression:Pubblication_Number]"/> </rdf:Description> <rdf:Description rdf:about="metalex_idnorm115252672"> <rdf:type rdf:resource="[lkif-time_modification:Pubblication_Date]"/> </rdf:Description>

3.4 RDFa integration into the transformation: an abstract mapping with LMIF level

The RDFa assertion are embedded to the MetaLex/CEN therefore the translator to MetaLex/CEN should be able to map the semantic meaning of the national metadata into the LKIF-core classes and to provide the correct syntax expressiveness inside of the XML document. The XSLT devoted to the translation, for this purpose, should embed all the mapping between the national matadata and the LKIF-core classes and in this approach the XSLT is not independent to the LKIF-core evolution.

A more reasonable approach is to externalise this mapping and use a vocabulary correspondence approach. So we define LMIF (Legal metadata interchange framework) layer that is able to make assertions not on the metadata of the document but on the elements and the attributes of the national standard.

It is a meta-level for making statements on the existing standard.


20

Figure 3 – Vocabulary mapping

This approach is clean and permits to the XSLT translator to not include in the code (embedded) the names of the LKIF-core classes. As it is evident this approach has different advantages:

a) make assertions on the elements (tag) and attributes of a standard (reification); b) maintain the semantic mapping outside to the XSLT code; c) independent division of the levels of the standard design MetaLex/CEN

standards and LKIF-core design can proceed to be evolved without any interdependences.

d) produce a translator able to produce on the fly the RDFa sentences; e) better extensibility and maintainability; f) possibility to map/integrate/compare several vocabularies coming from

different national standards and make query such as: give me all the metadata in Europe used for the publication.

LMIF fragment mapping the NIR publication metadata into LKIF-core (see the § Error! Reference source not found. of the ANNEX )

<?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:nir="http://www.nir.it/2.0" xmlns:dsp="http://www.normeinrete.it/nir/disposizioni/2.0" xmlns:lkif-legal_action="http://www.estrellaproject.org/lkif-core/legal_action" xmlns:lkif-time_modification="http://www.estrellaproject.org/lkif-core/time-modification" xmlns:lkif-expression="http://www.estrellaproject.org/lkif-core/expression" xmlns:lkif-merology="http://www.estrellaproject.org/lkif-core/merology"> <rdf:Description rdf:about="nir:pubblicazione"> <rdf:type rdf:resource="[lkif-legal_action:Act_of_Publication]" /> </rdf:Description> <rdf:Description rdf:about="nir:pubblicazione-tipo"> <rdf:type rdf:resource="[lkif-expression:Publication_Type]" /> </rdf:Description> <rdf:Description rdf:about="nir:pubblicazione-num"> <rdf:type rdf:resource="[lkif-expression:Publication_Number]" /> </rdf:Description>


21

<rdf:Description rdf:about="nir:pubblicazione-norm"> <rdf:type rdf:resource="[lkif-time_modification:Publication_date]" rdf:datatype="xsd:date" /> </rdf:Description>

3.5 Summary

The Estrella project provides at least four standard levels of the Semantic Web layers7:

a) MetaLex/CEN for structuring the Legal Resources in XML; b) RDF for making assertion on the metadata; c) LKIF-core for modelling the legal knowledge; d) LKIF-rule, LKIF-argument for modelling the logic.

Figure 4 – Semantic Web layers

In particular we have the following mapping of the four levels and the interconnection through CURIE naming convention (CURIE -Compact URI annotation).

The MetaLex/CEN include also RDFa statement on the semantic meaningful, a parser extract RDF statements, the RDF statements point out to the LKIF-core classes by CURIE annotation, and in the same way the LKIF-rules and LKIF-argument graph syntax point out to the MetaLex/CEN resources by URI annotation [D3.2.]

Figure 5 – Layers in ESTRELLA

The translator task is based on three meta-transformations: 7 http://www.w3.org/2001/12/semweb-fin/w3csw


22

i) XSLT that takes in input the NIR and the MetaLex/CEN standards. Manually the document designer and the knowledge engineer produce the XSLT;

ii) LMIF that takes in input the NIR schema and LKIF-core ontology. Manually it is made a mapping of the vocabulary;

iii) finally the XSLT of the point a) uses also LMIF during the transformation for producing embedded the RDFa statements.

The following picture shows the subdivision of the three layers (XML, meta and ontology) and how the meta-tools (in green) are used during the meta-modelling for the transformation. We can see four phases:

i) National Standard is mapped into MetaLex/CEN and it produces an XSLT;

ii) National Standard vocabulary is mapped into LKIF-core and it produces the LMIF.rdf;

iii) the conversion layer uses both the meta-tools (XSLT and LMIF) for implementing the transformation. Finally a MetaLex/CEN + RDFa statements is produced;

iv) in addition it is possible, using the GRDDL8 mechanism to parser the XML document and extract the RDF statements separately to the MetaLex/CEN text.

Figure 6 – Workflow of the translation through XSLT, RDFa and RDF

8 http://www.w3.org/2004/01/rdxh/spec


23

4 Dutch translator

4.1 Overview

This chapter describes how documents that have been tagged using the MetaLex 1.3.1 standard can be converted to the new MetaLex/CEN standard. Two conversions have been described. The first one translates MetaLex 1.3.1 to generic MetaLex/CEN, which means that it uses the generic elements that are defined in the MetaLex/CEN XML schema. This schema, being generic, contains less specific information than the MetaLex 1.3.1 schema. This is compensated by adding metadata denoting the original MetaLex 1.3.1 type to each of the elements.

A second translation is described for translating MetaLex 1.3.1 documents to MetaLex/LS. This is a subschema of MetaLex/CEN, which contains all functionality and information that was included in MetaLex 1.3.1 (with one exception, see below). Translating documents to this schema will not lead to loss of information, but does require the use of the subschema in addition to the main MetaLex/CEN schema.

A major difference between MetaLex 1.3.1 and MetaLex/CEN is that MetaLex 1.3.1 allows for multiple versions of a document within the same XML document. MetaLex/CEN does not allow this. The translations in this document assume that the input is a MetaLex 1.3.1 document that contains only one version9. In other words, a single MetaLex 1.3.1 document may be translated to multiple MetaLex/CEN documents, one for each version contained in the original MetaLex 1.3.1 document.

4.2 MetaLex 1.3.1 to generic MetaLex/CEN

When translating from MetaLex 1.3.1 to generic MetaLex/CEN, all MetaLex 1.3.1 elements are replaced by one (or sometimes several) generic MetaLex/CEN elements. This is described in section 4.2.1. Attributes are likewise mapped on the generic elements and their attributes. Some attributes will stay as an attribute on the element, while others will be transformed to a meta element (which is subsequently added to the mcontainer at the start of the document. This is described in 4.2.2.

4.2.1 Elements

This section describes the translation of the elements. Each MetaLex 1.3.1 element is replaced by one or more generic MetaLex/CEN elements. The exact mapping is detailed below.

Attributes will be added to the new elements to indicate what their original MetaLex 1.3.1.1 counterpart was, so that no information is lost. This is done by using the RDFa attribute instanceof, which refers to the MetaLex 1.3.1.1 type. For a (former) Article tag, this would lead to the attribute:


24

instanceof=”http://www.metalex.eu/legacy/metalex/1.3.1.1/Article”.

For every element, the instanceof is added to its translation. If an element is translated to more than one generic MetaLex/CEN element, these attributes will be added to only one of them, as will become clear from the examples shown.

To shorten the examples, the namespace is not included there. Thus, if an example shows instanceof=”Article”, then this ought to be read as:

instanceof=”http://www.metalex.eu/legacy/metalex/1.3.1/Article”

in the actual document.

Furthermore it is important to note that the examples in this section only show the translation of the elements; the translation of any attributes is not shown in these examples.

Regulation and CitationDesignation

Regulation, the root element of a MetaLex 1.3.1 document is mapped to root. The CitationDesignation is mapped to htitle.

As a htitle can appear only in a hcontainer, the translation of the regulation is different depending on whether or not a CitationDesignation is present.

<Regulation metadata10> <CitationDesignation>citation designation<CitationDesignation> content </Regulation>

becomes:

<root instanceof =”Regulation”> <mcontainer> metadata </mcontainer> <container> <hcontainer> <htitle instanceof=”CitationDesignation”> citation designation </htitle> content </hcontainer> </container> </root>

Without a CititationDesignation, the result is:

<root instanceof=”Regulation”> <mcontainer> metadata

9 The MetaLex 1.3 distributions inclused an XSLT transformation to extract the different versions from a MetaLex 1.3 document. 10 See section 4.2.2 for a description on how metadata in attributes is handled.


25

</mcontainer> <container> <container> content </container> </container> </root>

Part, Article, Subpart, IndexDesignation, Category, Index, Title

Part, Article and Subpart are all mapped to an hcontainer. Title becomes an htitle.

IndexDesignation, Category and Index become inline elements. The (former) IndexDesignation element will be enclosed in a htitle element.

<Part> <IndexDesignation> <Category>category</Category><Index>index</Index> </IndexDesignation> <Title>title</Title> content </Part>

becomes:

<hcontainer instanceof=”Part”> <htitle> <inline instanceof=”IndexDesignation”> <inline instanceof=”Category”> category </inline> <inline instanceof=”Index”> index </inline> </inline> </htitle> <htitle>title</htitle> content </hcontainer>

Annotation, Sentence, List, SentenceFragment, SentenceFragmentSubpart

Annotation, Sentence, List, SentenceFragment and SentenceFragmentSubpart elements are all replaced by inline elements. IndexDesignations that appear within lists are also replaced by inlines (as described above). However, the IndexDesignations are not enclosed in htitles.

A (former) Sentence is enclosed in a block element. A (former) List is enclosed in a block element, unless it is already enclosed in an inline. If multiple Sentences or Lists follow each other, they will be concatenated into a single block.

A (former) Annotation element will be enclosed with a block element if it is not enclosed by an inline element (a former Sentence or SentenceFragment) or a htitle element (such as a former Title).


26

The block element is encapsulated within a container element. If multiple blocks follow each other, they will be concatenated into a single container.

So,

<Sentence>first sentence.</Sentence> <Sentence>second sentence.</Sentence> <Sentence>third sentence.</Sentence>

becomes:

<container> <block> <inline instanceof=”Sentence”> first sentence. </inline> <inline instanceof=”Sentence”> second sentence. </inline> <inline instanceof=”Sentence”> third sentence. </inline> </block> </container>

And

<List> <SentenceFragment>introduction</SentenceFragment> <SentenceFragmentSubpart> <IndexDesignation> <Index>first index</Index> </IndexDesignation> <SentenceFragment> first list item </SentenceFragment> </SentenceFragmentSubpart> <SentenceFragmentSubpart> <IndexDesignation> <Index>second index</Index> </IndexDesignation> <SentenceFragment> second list item </SentenceFragment> </SentenceFragmentSubpart> </List>

becomes:

<container> <block> <inline instanceof="List"> <inline instanceof="SentenceFragment"> introduction </inline> <inline instanceof="SentenceFragmentSubpart"> <inline instanceof="IndexDesignation"> <inline instanceof="Index"> first index


27

</inline> </inline> <inline instanceof="SentenceFragment"> first list item </inline> </inline> <inline instanceof="SentenceFragmentSubpart"> <inline instanceof="IndexDesignation"> <inline instanceof="Index"> second index </inline> </inline> <inline instanceof="SentenceFragment"> second list item </inline> </inline> </inline> </block> </container>

Introduction, Conclusion and Appendix

Introduction, Conclusion and Appendix become containers with a block enclosed.

<Introduction>introduction</Introduction>

becomes:

<container instanceof=”Introduction”> <block> introduction </block> </container>

CitationTitle, Cite, CiteRange, CiteGroup, CiteFrom, CiteTo, Quote, Reference

These are all inline elements and are mapped to inline elements.

TextVersion

All TextVersion elements are removed. Their contents (text and inline elements) remain, however.

MetaData

This element will disappear when translating. Its contents are deleted, and will not be present in the translated document.

4.2.2 Attributes

Any non-MetaLex attributes on an element (such as xml:lang) can simply remain on the (translated) element. If the element maps to several new elements, the attributes are added to the element that contains the instanceof attribute, as explained above.


28

The MetaLex 1.3.1 id attribute is mapped to the new id attribute (and as such, can remain).

Any other MetaLex 1.3.1 attributes represent metadata, and are converted to a new meta element. This meta element has three attributes: about, property and content. Their values will be as follows:

• about: the id of the (original) element the meta data belongs to. • property: the name of the MetaLex 1.3.1 attribute that is represented. • content: the value of the MetaLex 1.3.1 attribute that is represented.

If the MetaLex 1.3.1 attribute has an URI as value, than instead of property and content the attributes rel and href are used.

This meta element will be added to the mcontainer at the beginning of the regulation.

Thus,

<article id=id date-enacted=date1 date-repealed=date2> content </article>

becomes:

<article id=id> content </article>

And

<meta about=id property=”date-enacted” content=date1/> <meta about=id property=”date-repealed” content=date2/>

with those meta elements included in the document’s main mcontainer.

4.3 MetaLex 1.3.1 to MetaLex/LS 1.0

The translation from MetaLex 1.3.1 to the Leibniz Center’s version of MetaLex/CEN is more or less the same as the translation to generic MetaLex/CEN. The main difference is that in MetaLex/LS several specific elements have been added that are used instead of the generic elements. The result is that usually, the element names will stay the same (as MetaLex/LS uses the same element names as MetaLex 1.3.1).

The mapping of the elements is described below. Attributes are translated as described in section 4.2.2, but using Meta instead of meta.

4.3.1 Elements

Regulation and CitationDesignation

Regulation and CitationDesignation are mapped to elements with the same name. However, some additional elements are added.


29

The Regulation element will contain two containers, RegulationMetaData and RegulationContent. If no CitationDesignation is present, the content of the document will be added under the RegulationContent element. Otherwise, a TitledRegulation element is inserted, which will include the CitationDesignation and the content.

<Regulation metadata> <CitationDesignation>citation designation<CitationDesignation> content </Regulation>

becomes:

<Regulation> <RegulationMetadata> metadata </RegulationMetadata> <RegulationContent> <TitledRegulation> <CitationDesignation> citation designation </CitationDesignation> content </TitledRegulation> </RegulationContent> </Regulation>

Without a CititationDesignation, the result is:

<Regulation> <RegulationMetadata> metadata </RegulationMetadata> <RegulationContent> <UntitledRegulation> content </UntitledRegulation> </RegulationContent> </Regulation>

Part, Article, Subpart, IndexDesignation, Category, Index, Title

These elements are all mapped on elements with the same name. The IndexDesignation is enclosed in an IndexDesignationTitle element.

<Part> <IndexDesignation> <Category>category</Category> <Index>index</Index> </IndexDesignation> <Title>title</Title> content </Part>

Becomes:

<Part> <IndexDesignationTitle> <IndexDesignation>


30

<Category>category</Category> <Index>index</Index> </IndexDesignation> </IndexDesignationTitle> <Title>title</Title> content </Part>

In case of an Article or Subpart: if the content consists of Sentences and/or Lists, it is enclosed by an ArticleText or SubpartText element. Thus content becomes:

<ArticleText>content</ArticleText>

Sentence, List, SentenceFragment, SentenceFragmentSubpart

Sentence, List, SentenceFragment and SentenceFragmentSubpart elements all remain the same. As explained above, IndexDesignation, Category and Index also remain the same. However, unlike when it appears in a Part, Article or Subpart, and IndexDesignation that appears in a List is not enclosed in an IndexDesignationTitle element.

A Sentence is enclosed in a Block element. A List is enclosed in a Block element, unless it is already enclosed in a SentenceFragmentSubPart.

An Annotation element is enclosed in a AnnotationBlock element if it is not already enclosed within Block (at any level).

The AnnotationBlock element is enclosed in a AnnotationText element if it is not already enclosed within an ArticleText or SubpartText element.

So,

<Sentence>first sentence.</Sentence> <Sentence>second sentence.</Sentence> <Sentence>third sentence.</Sentence>

becomes:

<Block> <Sentence>first sentence.</Sentence> <Sentence>second sentence.</Sentence> <Sentence>third sentence.</Sentence> </Block>

And:

<Sentence>first sentence.</Sentence> <Sentence>second sentence.</Sentence> <Annotation>first annotation.</Annotation> <Sentence> third sentence. <Annotation>second annotation.</Annotation> </Sentence>

Becomes:


31

<Block> <Sentence>first sentence.</Sentence> <Sentence>second sentence.</Sentence> </Block> <AnnotationBlock> <Annotation>first annotation.</Annotation> </AnnotationBlock> <Block> <Sentence> third sentence. <Annotation>second annotation.</Annotation> </Sentence> </Block>

Introduction, Conclusion and Appendix

Introduction, Conclusion and Appendix all remain the same. The contents are enclosed in a Block.

<Introduction>introduction</Introduction>

becomes:

<Introduction> <Block> introduction </Block> </Introduction>

CitationTitle, Cite, CiteRange, CiteGroup, CiteFrom, CiteTo, Quote, Reference

These elements remain the same.

TextVersion

All TextVersion elements are removed. Their contents (text and inline elements) remain, however.

MetaData

This element will disappear when translating. Its contents are deleted, and will not be present in the translated document.

4.4 MetaLex/LS to generic MetaLex/CEN

A MetaLex/LS document can easily be transformed to a generic MetaLex/CEN document by replacing the specific MetaLex/LS elements by the corresponding generic MetaLex/CEN elements. The attributes are unaffected.

Element Replace with Regulation root RegulationMetadata mcontainer RegulationContent container TitledRegulation hcontainer CitationDesignation htitle


32

Part hcontainer Article hcontainer Subpart hcontainer ArticleText container SubpartText container Introduction container Conclusion container Appendix container Title htitle IndexDesignation htitle Block block Annotation meta Meta meta All other elements inline


33

5 Hungarian translator

5.1 Overview

Hungarian regulations are published on the government’s website in order to every citizen could easily access them. Hungarian legislation doesn’t have a standard to represent legal content in a standardized way, they are in HTML format and it means a loose structure and the lack of syntactical consistency. Solving this problem we have defined a general format based on international standards such as XML to represent legal documents in a uniform way. Actually it is in a refinement stage to increase its efficiency.

There are several vendors in Hungary offering software solutions. These products store the officially published law contents in a database. Users are able to search a specific regulation, they can see how the different documents are related and these products can display the status of the stored content at a concrete date.

Nevertheless these vendors have processed all the published legal documents and they store the information in their application specific formats (mostly in relational databases or in their own file based formats). This makes difficult the interchange of the legal sources. It is a problem, because nowadays not these legal databases represents the value of a software solution rather the additional services (e.g. text search, version management, translations) make easier the work of the users.

5.2 Source specific problems

Hungarian legislation doesn’t have strict rules with regard to the format of their documents. For this reason they differ from each other more or less. They are published on the official website of the government but their HTML representation inherits the looseness of the original format. The inconsistent usage of HTML elements and CSS classes causes lots of additional problems during the conversion procedure.

However it is very easy to get the latest version of a legislative document via internet. Beside the disadvantages of the HTML its tags provide a lot of additional information of the structure of the source document. These extras increase the accuracy of the conversion and this is the reason why the result needs lesser manual correction afterwards.

The translator tool must be flexible enough to handle the differences of the input document even if they are downloaded from the same website. This can be handled easily if the source specific information is not hard-coded into the transformation algorithm and this is why there is a configuration module that contains the characteristic of the source.

5.3 Architecture


34

The translator has a modularized architecture as you can see on Figure 7. It produces the MetaLex/CEN representation of a HTML based Hungarian legal content in two steps.

First of all an application builds up the hierarchical structure of the source based on configuration files that contains syntactical information beside heuristics helping the identification of the structural elements.

The final step is an XSL transformation of our “intermediate XML representation”. This is the reason why we can easily translate the HTML based source to various national or international standards. Actually we created XSLs to produce the MetaLex 1.3.1 and MetaLex/CEN format of an HTML legal source.

Figure 7

5.4 Intermediate format

The main design principle was to find the optimal balance between simplicity, generality and expressiveness.

The most important requirement is that it must be able to represent the structure of a legislative document which is given in natural format. This is why the intermediate format is not complete at the moment and needs further refinements.

These refinements will provide language independence and it must handle several translations of the legal source beside the different versions of a given part. Some of these versions express different validity or they can be derived from modification processes.

5.4.1 Common attributes

Usage of attributes is necessary because they give additional information to XML tags explaining the role of their content. General XML tags cannot express semantic


35

meaning of a given part such as article or paragraph they are represented by the same container element.

Let’s see the list of these common attributes:

id

Identifier is an important and required attribute if the element can be referenced. It must be permanent and unique in the scope of the document. This means every time the tool translates a given document or its extension, the same structural parts must get the same identifier. This can be solved if the identifiers derive from its hierarchical position.

For instance id=”a1_s3” is the identifier of the third subpart in the first article. Thanks to this method a given part of the source will always get the same identifier. They can be more user friendly using full element names instead of their first letter (id=”article1_subpart1”).

name

Name attribute is required for elements because it adds semantic meanings to the given part of the source. It comes from the configuration file where users can add semantic information to the definitions of structural parts. Name attribute can also be used at the final transformation step to create general XSL templates.

level

The level attribute automatically get value during the translation and it shows the element’s position in the hierarchy. The XML tree of the source includes this information implicitly therefore historical issues give reasons for its presence. It could also be useful to handle exceptions in case of XSL templates.

5.4.2 Element types

In this section you can see an overview of the fundamental elements of this XML format.

Container

Container elements are fundamental parts of this intermediate format, they represent the hierarchy of a legislative document.

• Container: It contains important parts of the source for instance parts, articles and this is why beside other container elements it must contain title, index and category of the index. These additional elements constitute the “header” of a container.

• Block:


36

This can contain other container elements excluding “Container” and text based elements storing sentences of the source document. It is also represent major parts of the source that is why title, index and category of index element are needed.

• List: It has only one function: grouping the contained ListItem elements because Lists can be nested. Actually the level attribute can be used as well to specify self containing but it is possible this attribute won’t be part of the later versions of this XML format.

• ListItem: List and the related ListItem elements represent enumerations of the legislative document. It consists of an index and several text elements or a nested List.

Text

Elements of this group contain sentences or paragraph of the given legislative document.

• Text: It contains sentences and paragraphs of the source document and it cannot contain others excluding inline elements.

<Text>warehousing services provided in free zones</Text>

• Title: Articles and parts of legislative documents usually have title that is marked with this element.

<Title>Personal Scope</Title>

• Index: Part of sources can be numbered and index element provides a structured way to store this information.

<Index>14/A</Index>

• Category: Categories belong to indexes defining types of given parts of the source document. Its value can be for instance: article, §, Section, Part, etc…

<Category>Section</Category>

Inline

Inline elements can be children of text-based parents they cannot take place in container elements.

• Reference: This element makes possible to reference a resource or mark a citation.


37

<Reference type=”” URI=””>Act LXXIV of 1992 on Value Added Tax</Reference>

5.5 Translation

Because of the loosely defined nature of the input format there are a lot of problems reducing the precision (correctness) of the translation process and the result. Additionally the usage of CSS classes and source’s structure can be different. This is the reason why we had to provide an easy way to configure the identification mechanism of the translator in order to produce an accurate result that needs minimal corrections afterwards.

The translation procedure is consists of two steps, first of all we produce the hierarchy of the source based on configuration files. This is also an XML tagged file so it can be validated against an XML schema. Thereafter it can be easily transformed to any (inter)national XML standard by the usage of XSL transformation.

In the next chapters we can see different representations of the following legal text:

Figure 8

5.5.1 Translation concept


38

There are two different approaches translating a legal document given in XML to MetaLex/CEN as you can see in chapter 3.

Schema wrapping

The basic concept of creating a wrapper that is derived from the schema of MetaLex/CEN and contains the element definitions of the source is explained is chapter 3.2.

In our case the usage of this method is not appropriate because our intermediate format is not as expressive as other existing national standards. This is why a wrapper could make a correct MetaLex/CEN document from the intermediate format but it wouldn’t be able to benefit from the advantages of MetaLex/CEN.

XSL transformation

Our implementation is based on XSL transformation which fundamentals are explained in chapter 3.1. You also can find further details in chapter 5.5.3.

5.5.2 Creating Intermediate XML

Creating our XML representation is mainly a text processing task, because HTML is a free text with mark-ups. Browser engines are generous with HTML pages in point of their syntax and that is why we had to create a general algorithm which can be manipulated dynamically. In other words the text processing algorithm is using pre-defined mapping instructions stored in configuration files which help to produce the hierarchy of the source document. This makes possible the automated output generation.

Configuration:

Element definitions represent mappings between parts of the source text and the elements of the intermediate format. The quality of the output can be highly improved by extending element definitions.

They contains: − name:

name is an additional information it is preserved in the intermediate format as an attribute of elements. This information can be used in XSL transformation definitions.

− type: type determines the representing intermediate element

− need-id: in case of a true value the processing algorithm automatically creates an unique and permanent identifier.

− index pattern:


39

index pattern is a regular expression that helps to determine the number of the given part

− index category: sometimes the category cannot be determined based on the text source

− style condition: style condition means special text patterns in a text source (HTML tags). They provide additional information that can help recognize structural elements beside plain text

− text condition in some cases the plain text source contains enough information to its identification

References:

In the body of a legislative document there are lots of references to other parts or any related document. References and citations have great variety in point of appearance which makes their automatic recognition very difficult.

Naturally the basic conception is using the defined reference patterns in a descending order by their length. A longer pattern means the connection of more hierarchical element, for instance “Paragraph f) of Subsection (1) of Section 32” is the relation of three different structural levels.

Therefore reference handling is the weakest point in the translation procedure.

Replaces:

Replaces are very powerful tools formatting the source text. We can filter or modify the input without changing the program code and this makes the application flexible enough to handle different input formats (for instance HTML, or any other text based format with their specific style mark up language).

We can categorize them into “before” and “after” replaces according to where we would like to use them. Some replaces are filtering the HTML tags or HTML character escapes and this is the reason why the intermediate representation is missing those input specific style definitions.

The intermediate representation of the law text given on Figure 8 can be seen:

<Container id="p1_p2" name="Part" level="1"> <Title name="Title" level="3"> DEFINITIONS </Title> <Index>II</Index> <Category>CHAPTER</Category> <Container id="p1_p2_a1" name="Article" level="2"> <Title name="Title" level="2"> Taxable Person </Title> <Index>4.</Index> <Category>Section</Category> <Block id="p1_p2_a1_s1" name="SubPart" level="3"> <Index>(1)</Index> <Text>'Taxable person' shall mean any natural or legal person or unincorporated organization


40

who (which) may, in its own name, obtain rights, assume obligations, sue, and perform economic activities on its own behalf, regardless of the purpose and results thereof. </Text> </Block> <Block id="p1_p2_a1_s2" name="SubPart" level="3"> <Index>(2)</Index> <Text>In respect of jointly owned and jointly used movable and immovable property, the co-owners jointly shall be liable for the tax payable under this Act. The group of co-owners shall exercise the obligations and rights stemming from their taxable status through their appointed representative. If no representative has been appointed, the co-owner holding the largest share shall be considered the representative, or the person designated by the tax authority if all co-owners hold equal shares. </Text> </Block> <Block id="p1_p2_a1_s3" name="SubPart" level="3"> <Index>(3)</Index> <Text>The occasional sale of new means of transport shall also be subject to taxation, if exported to another Member State in direct consequence of the sale. The sale of any new means of transport by a taxable person not as part of his taxable business operations shall be treated as if it was subject to taxation. </Text> </Block> <Block id="p1_p2_a1_s4" name="SubPart" level="3"> <Index>(4)</Index> <Text> </Text> </Block> </Container> </Container>

5.5.3 Creating MetaLex/CEN

The MetaLex/CEN format is based on the intermediate format. It contains all the structural and general information that is needed to produce the required output. The application could also create the MetaLex/CEN representation (maybe in a single step) but in that case we would loose the benefits provided by the XSL transformation:

− easy to modify − based on open standard − it needs minimal development time − re-usable (it can be built into applications) − easy to create another XSL’s in order to provide further national standard

output

These are the motivations why we decided to use XSL transformation producing the MetaLex/CEN output.

The XSL defines mappings between the different schemas. It contains of several templates that are matching parts of the XML tree given in the intermediate representation.

We are using the functions of the XSL 2.0 recommendation because some kind of problems cannot be solved without them. Some XML parser doesn’t support XSL 2.0 but fortunately most of them implement its instructions.


41

The source of the transformation definition can be found in Error! Reference source not found..

The MetaLex/CEN representation of the law text given on Figure 8 can be seen:

<container name="PartWrapper"> <hcontainer name="Part" id="p1_p2"> <htitle name="Title"> DEFINITIONS </htitle> <container name="IndexDesignation"> <container name="Category"> <block name="TextVersion" xml:lang="en">CHAPTER</block> </container> <block name="Index">II</block> </container> <hcontainer name="Article" id="p1_p2_a1"> <htitle name="Title"> Taxable Person </htitle> <container name="IndexDesignation"> <container name="Category"> <block name="TextVersion" xml:lang="en">Section</block> </container> <block name="Index">4.</block> </container> <container name="Body"> <hcontainer name="SubPart" id="p1_p2_a1_s1"> <htitle name="Title"/> <container name="IndexDesignation"> <block name="Index">(1)</block> </container> <container name="Body"> <block name="TextVersion" xml:lang="en">'Taxable person' shall mean any natural or legal person or unincorporated organization who (which) may, in its own name, obtain rights, assume obligations, sue, and perform economic activities on its own behalf, regardless of the purpose and results thereof. </block> </container> </hcontainer> <hcontainer name="SubPart" id="p1_p2_a1_s2"> <htitle name="Title"/> <container name="IndexDesignation"> <block name="Index">(2)</block> </container> <container name="Body"> <block name="TextVersion" xml:lang="en"> In respect of jointly owned and jointly used movable and immovable property, the co-owners jointly shall be liable for the tax payable under this Act. The group of co-owners shall exercise the obligations and rights stemming from their taxable status through their appointed representative. If no representative has been appointed, the co-owner holding the largest share shall be considered the representative, or the person designated by the tax authority if all co-owners hold equal shares. </block> </container> </hcontainer> <hcontainer name="SubPart" id="p1_p2_a1_s3"> <htitle name="Title"/> <container name="IndexDesignation"> <block name="Index">(3)</block> </container> <container name="Body"> <block name="TextVersion" xml:lang="en"> The occasional sale of new means of transport shall also be subject to taxation, if exported to another Member State in direct consequence of the sale. The sale of any new means of transport by a taxable person not as part of his taxable business operations shall be treated as if it was subject to taxation.


42

</block> </container> </hcontainer> <hcontainer name="SubPart" id="p1_p2_a1_s4"> <htitle name="Title"/> <container name="IndexDesignation"> <block name="Index">(4)</block> </container> <container name="Body"> <block name="TextVersion" xml:lang="en"> </block> </container> </hcontainer> </container> </hcontainer> </hcontainer> </container>

5.5.4 Metadata

In general meta information contains semantic meaning which is hard to recognize in a HTML source. Therefore the automatic translation process is not able to produce it in the result. It needs user interaction to manually extend the result with meta information and the RDFa based references to the LKIF-Core.

5.6 Summary

Aim of the Hungarian translator was to produce the MetaLex/CEN representation of a legislative document given in HTML format.

First of all we create the hierarchical model of the source. It means an XML tree that is called “intermediate representation”. Its expressiveness at the moment is far from other existing national or international standards because in the beginning its main purpose was to express and store a legislative document in a hierarchical and uniform way. Actually it is under a refinement procedure that will highly increase its capabilities.

The second step is an XSL transformation that produces the expected output format. This is the easiest method when the input and output is given in XML and it provides lots of benefits for instance: easy modification and the usage of open standards.

This modularized architecture of the translator makes it possible to create different representations of the legislative source effortlessly. For instance beside MetaLex/CEN we defined an XSL transformation to produce the MetaLex 1.3.1 version of the source document too.

The whole translation procedure is fully automatic it doesn’t require user interaction except the configuration file at the first time. Further documents with the same style can be translated without the need of interaction. This could be very useful if we have a lot of documents to translate.

With the use of precise configuration settings the result will be very accurate and needs minimal manual correction afterwards. Of course meta information and other


43

extra information are exceptions because they are whether hard to recognize or the source doesn’t contain them directly.

The result is accurate enough it doesn’t need a lot of correction, but meta information and the related LKIF connection must be added manually. It can be edited in a single text editor or an XML editor, but this is not a convenient way of modifications and this is the reason why we would like to develop a comfortable editor to make easier the users work.


44

6 Italian translator

6.1 Overview

The Italian Translator aims to convert the existing Italian national standard called NormeInRete [D3.1] into MetaLex/CEN [D3.2]. Three different tools are designed and implemented:

a) wrapper for making valid existing NIR document in MetaLex/CEN; b) Nir2Meta XSLT for transforming NIR document into MetaLex/CEN

document; c) Meta2Nir XSLT for transforming MetaLex/CEN document into loosely-

couple NIR document.

NIR contains two types of elements that can not be translated into MetaLex even with the latest changes to the MetaLex standard.

NIR defines a particular type of metadata called “disposizioni”. These metadata can contain text, content elements and other metadata. For the translation of these elements we created an element called gMeta (generic meta).

Another NIR specific issue is the translation of the content elements that mix text with other elements of various kinds. Later in this document we will se that the inclusion of an element called “basic” solve this problem.

6.2 NIR Specific Elements

The elements that was inserted in the MetaLex/CEN forking created in order to permit the translation of the NormaInRete documents without the lost of data.

GMETA. Generic meta data. This element is necessary for translating all the elements which the mixed content model and in particular composed by meta, mContainer, text. Some example of that is the block in NIR defined in the disposizioni.dtd.

GenericMetaType

<xsd:complexType name="absGenericMetaType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="xsd:anyType"> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:extension> </xsd:complexContent> </xsd:complexType>

gmeta

<xsd:element name="gmeta" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/>

BASICTYPE. This type was added for managing which elements that are not in line with the 9 patterns of MetaLex/CEN. Inside of NIR we are plenty of those elements


45

coming from an original design of the DTD. In the next version of NIR we will dedicate a special task for reengineering the standard in order to be complaint with the new approach of MetaLex/CEN.

BasicType

<xsd:complexType name="absBasicType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absBasic"/> <xsd:element ref="e:absHtitle"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absBlock"/> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absQuotedContent"/> </xsd:choice> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

BASIC. The basic element allows us to map all those elements that are not compliant whit the patterns. These elements are residues of the older version of NormaInRete. We are working on a new NIR standard that will be full compliant with the MetaLex patterns.

<xsd:element name="basic" type="e:genBasicType" substitutionGroup="e:absBasic"/>

In order to make basic elements effectively useful we give the possibility to (optionally) add basic elements in block, container and htitle. The content model of these elements now appears as the follow:

Blocks:

<xsd:complexType name="absBlockType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:attributeGroup ref="e:typeblock"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

CONTAINER:

<xsd:complexType name="absContainerType" abstract="true">


46

<xsd:complexContent> <xsd:restriction base="e:urContentType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> <xsd:element ref="e:absContainer"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absBlock"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:attributeGroup ref="e:typecontainer"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

HTITLE:

<xsd:complexType name="absBlockType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:attributeGroup ref="e:typeblock"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

6.3 Wrapper vs conversion tools

We know that there are two very effective ways to use Metalex/CEN. The first one is using a Wrapper. Whit a wrapper we can redefine the NIR elements and attributes using the abstract elements of the MetaLex/CEN. The second way is to develop an appropriate XSLT for converting in automatic way the NIR documents.

Even though these two ways are both efficient we strongly believe that a conversion tool is better than a wrapper. This because it is easier to integrate RDFa attributes that we will use to give a semantic meaning to the elements in the documents. On the other and the wrapper can provide some prescriptive rules of the original standard for some application such as publication, searching, indexing. It is the case of the article.

The article in NormeinRete is defined as:

<!ENTITY % Tarticolatoart "(inlinemeta?, (num | rubrica | decorazione)+)"> <!ENTITY % CMarticolo "%Tarticolatoart;, (comma*)"> <!ELEMENT articolo (%CMarticolo;)>

Therefore it is a candidate for the Hcontainer

<xsd:element name="articolo" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/>


47

But if we would like to provide also the prescriptiveness (some constraint rules) included in the original standard schema/DTD, we should perform a restriction as following:

<xsd:complexType name="articleType"> <xsd:complexContent> <xsd:restriction base="e:hcontainerType"> <xsd:sequence> <xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> <xsd:choice> <xsd:element ref="e:absHcontainer" maxOccurs="unbounded"/> <xsd:element ref="e:absContainer" maxOccurs="unbounded"/> </xsd:choice> </xsd:sequence> <xsd:attributeGroup ref="e:globnumb"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>

This restriction provides a rule of composition and in particular that the article should have a title (nir:rubrica) and a body (nir:corpo). This is more restricted respect to map simply articolo in Hcontainer.

These are simple examples of the wrapper mapping.

<xsd:element name="originale" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="modificheattive" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/>

In this way the document is valid both for the NIR standard and for the MetaLex/CEN as well (see § 9.2 of the ANNEX ).

The wrapper was divided in three main files: • N2MWrapper_2-0.xsd - the main; • N2MWh_2.0.xsd - the wrapper of the generic elements; • N2MWdsp_2.0.xsd - the wrapper of the dsp NIR elements.

In additional we have produced the documentation in HTML of the wrapper that is able to show how each element in the NIR stanadard is mapped in the MetaLex/CEN pattern (see the documentation available on the web site wrapper.html).


48

Figure 9

6.4 NIR2Metalex conversion tool

The NormeInRete is composed of 6 dtd and three different levels of translation are possible: Nirloose.dtd, Nirstrict.dtd, Nirlight.dtd. The NIR standard is very rich as descriptive standard for legal document as metadata representation on the semantic level. For this reason during the transformation several metadata and semantic meaningfully expressiveness risk to lost in favour of the interchange standardisation. The main issue of the translator NIR2Metalex is to avoid as much as possible this risk. This doesn’t mean in any case to lost the richness: the self-explanatory of the markup of NIR standard is maintained through four principle mechanisms:

a) the original naming of the elements is stored in the “name” attribute; b) any attribute is admitted in the element definition of the MetaLex/CEN

schema in order to preserve the original granularity and expressiveness of the NIR attributes;

c) the RDFa mechanism for linking the Metalex/CEN structure with the LKIF-core ontology permits to assign;

d) the LMIF document was produced for demonstrating the complete scenario described in the § Error! Reference source not found. of the ANNEX .

NIR2Metalex conversion tool is an XSLT that translate in an automatic way a NIR document in a MetaLex/CEN compliant document. The XSLT processes all NIR elements and for each one produce the appropriate MetaLex elements.

Fragment of XSLT for the publication element and attributes, note as in the translation there is also the RDFa statement embedded:


49

<xsl:template match="nir:pubblicazione"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-legal_action:Act_of_Publication]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="$attname='tipo' "> <xsl:element name="meta"> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="name">pubblicazione-tipo</xsl:attribute> <xsl:attribute name="rdfa:about">#pubblicazione</xsl:attribute> <xsl:attribute name="rdfa:property">[lkif-expression:Publication_Type]</xsl:attribute> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> <xsl:if test="$attname='num' "> <xsl:element name="meta"> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="name">pubblicazione-num</xsl:attribute> <xsl:attribute name="rdfa:about">#pubblicazione</xsl:attribute> <xsl:attribute name="rdfa:property">[lkif-expression:Publication_Number]</xsl:attribute> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> <xsl:if test="$attname='norm' "> <xsl:element name="meta"> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="name">pubblicazione-norm</xsl:attribute> <xsl:attribute name="rdfa:about">#pubblicazione</xsl:attribute> <xsl:attribute name="rdfa:property">[lkif-time_modification:Publication_Date]</xsl:attribute> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>

This means that an element like this:


50

<originale id="ro1" xlink:href="urn:nir:stato:decreto.legislativo:1999-05-11;135" />

Will be translated to:

<meta name="originale" id="ro1" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="urn:nir:stato:decreto.legislativo:1999-05-11;135">

ELEMENT MAPPING

Following this mechanism and using the previous new elements and types we have the following correspondences between the NIR elements and MetaLex/CEN ones, without loose in representetiveness and decorativeness.

In NIR we have in total 273 elements.

We have divided the existing elements in NIR for pattern and content model and we have assigned to the correspondent element in MetaLex/CEN.

We can identify six mains patterns in NIR: 1. Meta 2. Milestone 3. Inline 4. Container 5. Hierarchical container 6. Block

Therefore we have assigned all the elements belonging to a determinated patter to the similar one in MetaLex/CEN.

ELEMENT REPLACE WITH NIR Root vuoto milestone br milestone hr milestone img milestone input milestone col milestone pubblicazione Meta entratainvigore Meta redazione Meta alias Meta allegatodi Meta attiva Meta attivita Meta errata Meta evento Meta giurisprudenza Meta haallegato Meta materia Meta originale Meta passiva Meta proponente Meta rettifica Meta ripubblicazione Meta


51

altrepubblicazioni Mcontainer ciclodivita Mcontainer comunicazioni Mcontainer descrittori Mcontainer disposizioni Mcontainer eventi Mcontainer inlinemeta Mcontainer materie Mcontainer modificheattive Mcontainer modifichepassive Mcontainer motivazioni Mcontainer oggetto Mcontainer proponenti Mcontainer regole Mcontainer relazioni Mcontainer considerato Mcontainer dataDoc inline dataeluogo inline mNumdoc inline mTipodoc inline mDatadoc inline mEmanante inline mTitolodoc inline inlinea inline ndr inline atto inline data inline numDoc inline def inline emanante inline ente inline importo inline irif inline luogo inline mrif inline rif inline rifesterno inline rango inline b inline i inline u inline sub inline sup inline span inline a inline tipoDoc Htitle rubrica Htitle tit Htitle titoloDoc Htitle num Htitle gerarchia Hcontainer l1 Hcontainer l2 Hcontainer l3 Hcontainer l4 Hcontainer l5 Hcontainer l6 Hcontainer l7 Hcontainer l8 Hcontainer l9 Hcontainer


52

capo Hcontainer libro Hcontainer partizione Hcontainer el Hcontainer en Hcontainer ep Hcontainer articolato Hcontainer object Hcontainer table Hcontainer thead Hcontainer tfoot Hcontainer tbody Hcontainer tr Hcontainer th Hcontainer td Hcontainer Sezione Hcontaine titolo Hcontaine paragrafo Hcontaine parte Hcontaine articolo Hcontaine comma Hcontaine proprietario gmeta urn gmeta testo gmeta pos gmeta termine gmeta condizione gmeta visto gmeta sentito gmeta considerato gmeta suproposta gmeta basegiuridica gmeta proposta gmeta parere gmeta richiesta gmeta procedura gmeta considerando gmeta motivazione gmeta finalita gmeta finanziaria gmeta ambito gmeta metaregola gmeta definitoria gmeta istitutiva gmeta organizzativa gmeta status gmeta competenza gmeta delega gmeta revoca gmeta diritto gmeta dovere gmeta pretesa gmeta obbligo gmeta divieto gmeta permesso gmeta procedimento gmeta sanzione gmeta riparazione gmeta informazione gmeta regola gmeta


53

abrogazione gmeta sostituzione gmeta integrazione gmeta ricollocazione gmeta intautentica gmeta variazione gmeta modtermini gmeta vigenza gmeta annullamento gmeta proroga gmeta reviviscenza gmeta posticipo gmeta sospensione gmeta retroattivita gmeta ultrattivita gmeta inapplicazione gmeta deroga gmeta estensione gmeta recepisce gmeta attua gmeta ratifica gmeta attuadelega gmeta attuadelegifica gmeta converte gmeta reitera gmeta modifica gmeta decadimento gmeta comunicazione gmeta norma gmeta soggetto gmeta effetto gmeta partizione gmeta tiporegola gmeta fatto gmeta organo gmeta destinatario gmeta territorio gmeta attivita gmeta definiendum gmeta definiens gmeta qualifica gmeta delegante gmeta controparte gmeta azione gmeta pena gmeta novella gmeta novellando gmeta dominio gmeta altradata gmeta argomento gmeta meta container redazionale container altro container avvertenza container annessi container destinatario container inquadramento container lavoripreparatori container note container nota container


54

AttoDiAuthority container Comunicato container DecretoLegge container DecretoLegislativo container DecretoMinisteriale container DecretoNN container DocArticolato container DocumentoNIR container Dpcm container DpcmNN container Legge container LeggeCostituzionale container LeggeRegionale container RegioDecreto container Semiarticolato container contenitore container elencoAnnessi container finalita container firma container lista container form container dl container dt container dd container caption container colgroup container blocco block infodoc block infomancanti block preambolo block testata block coda block ul block ol block intestazione basic conclusione basic corpo basic formulainiziale basic formulafinale basic cell basic deflist basic list basic rows basic decorazione basic denAnnesso basic preAnnesso basic sottoscrivente basic sottoscrizioni basic annesso basic mod basic virgolette basic alinea basic titAnnesso basic p basic div basic li basic

NIR METADATA MAPPING IN LKIF-CORE CLASSES


55

Abstract metadata

NIR element Attributes LKIF-core class

Publication metadata

pubblicazione tipo="GU" num="113" norm="19990517"

legal_action.owl:Act_of_Publication expression.owl:Publication_Type expression.owl:Publication_Number time-modification.owl:Publication_Date

Enter into force date

entratainvigore norm="19990518

legal_action.owl:Act_of_Commencement time-modification.owl:Enter_in_Force_Date

URI of the document

urn urn="urn:nir:stato:decreto.legislativo:1999-05-11;135@1999-05-11;1999-05-18"

naming=”URI"

Modification passiva xlink expression.owl:Modified Modification attiva xlink expression.owl:Modifier Event evento data="19990518"

time-modification.owl:Enter_in_Force_Date if the type=original time-modification.owl:Application_Date if the type=version

Header intestazione Preface Preamble

expression.owl:Preface expression.owl:Preamble

Modification modificheattive expression.owl:Modifier modifichepassive expression.owl:Modified Modification dsp:abrogazione time-modification.owl:Repeal Modification dsp:sostituzione time_modification.owl:Substitution Modification dsp:integrazione time-modification.owl:Integration Body articolato Enacting_Section expression.owl:Enacting_Section Higher partitions

titolo, capo, parte, sessione, etc.

Higher_Division merology..owl:Higher_Division

Basic element articolo Basic_Element merology.owl:Basic_Unit Sub partitions comma Sub_DIvision merology.owl:Sub_Division References rif Citation citation Conclusion conclusione Conclusion expression.owl:Conclusion Signature sottoscrivente

visto Signature expression.owl:Signature

New Text Novella New_Text expression.owl:New_Text Old Text Novellando Old_Text expression.owl:Old_Text Ancor Position expression.owl:Position_Text

6.5 Adding RDFa into MetaLex/CEN XML

With NIR2MetaLex translation tool it is possible to add RDFa attributes to the element in order to give semantic meaning to the elements, assuming we have the element:

<pubblicazione tipo="GU" num="113" norm="19990517" />

translated to:

<meta name="pubblicazione" tipo="GU" num="113" norm="19990517" />

As we can see, we have three relevant metadata in this element: Tipo: this means that the document was published in the Italian “Gazzetta

Ufficiale”. The value is GU.


56

Num: this is the publication number. The value is 113. Norm: this is the date of the publication. The value is 19990517

Initially the translation tool splits the element in three elements that have as common ancestor the element in its original form:

<mcontainer name="pubblicazione" id="metalex_idpubblicazione115252432" xmlns:rdfa="http://www.w3.org/ns/rdfa/" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-legal_action:Act_of_Pubblication]" tipo="GU" num="113" norm="19990517"> <meta id="metalex_idtipo115252488" name="pubblicazione-tipo" rdfa:about="#pubblicazione" rdfa:property="[lkif- expression:Pubblication_Type]" rdfa:content="GU"/> <meta id="metalex_idnum115252592" name="pubblicazione-num" rdfa:about="#pubblicazione" rdfa:property="[lkif-expression:Pubblication_Number]" rdfa:content="113"/> <meta id="metalex_idnorm115252672" name="pubblicazione-norm" rdfa:about="#pubblicazione" rdfa:property="[lkif-time_modification:Pubblication_Date]" rdfa:content="19990517"/> </mcontainer>

The same we have for all the other metadata, such as the date of entry into force:

<mcontainer name="entratainvigore" id="metalex_ECDGAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-time_modification:Enter_in_Force_Date]" norm="20050523" xmlns:rdfa="http://www.w3.org/ns/rdfa/">

Other example of fragment of MetaLex/CEN document with RDFa annotation is on the lifecycle of the document metadata.

The history of the document is tracked by the element ciclodivita that contains all the events occurred to the document or to activate from the document.

<mcontainer name="ciclodivita" id="metalex_idciclodivita126377976"> <mcontainer name="eventi" id="metalex_ideventi126378032"> <mcontainer name="evento" xmlns:rdfa="http://www.w3.org/ns/rdfa/" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-time_modification:Enter_in_Force_Date]" id="e1" data="19990518" fonte="ro1" tipo="originale"> <meta id="metalex_iddata126378200" name="evento-data" rdfa:about="" rdfa:content="19990518"/> </mcontainer> <mcontainer name="evento" xmlns:rdfa="http://www.w3.org/ns/rdfa/" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-time_modification:Application_Date]" id="e2" data="19990518" fonte="rp1" tipo="versione"> <meta id="metalex_iddata127655576" name="evento-data" rdfa:about="" rdfa:content="19990518"/> </mcontainer> </mcontainer>

The relationships are defined in the block relazioni and it makes in evidence the relationship between the modifier and the modified documents inside of the legal system.

Another example is the attiva metadata of NIR. It means that the current document modifies the URI = urn:nir:stato:legge:1996-12-31;676.

The RDFa statement says that: i) current document (about) ii) modifies (rel)


57

iii) urn:nir:stato:legge:1996-12-31;676 (href)

<mcontainer name="relazioni" id="metalex_idrelazioni127655792"> <meta name="attiva" xmlns:rdfa="http://www.w3.org/ns/rdfa/" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Modifier]" id="ra1" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="urn:nir:stato:legge:1996-12-31;676"/> </mcontainer>

It is also possible to use rev predicates so the same should be also expressed in such way:

i) urn:nir:stato:legge:1996-12-31;676 (href) ii) is modified by (rev) iii) current document (about)

<mcontainer name="relazioni" id="metalex_idrelazioni127655792"> <meta name="attiva" xmlns:rdfa="http://www.w3.org/ns/rdfa/" rdfa:about="" rdfa:rev="rdf:type" rdfa:href="[lkif-espression:Modified]" id="ra1" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="urn:nir:stato:legge:1996-12-31;676"/> </mcontainer>

In of passiva case the RDFa statement says: iv) current document (about) v) has modfier (rel) vi) 1999_05_11_DLGS_135 (href)

<mcontainer name="relazioni" id="metalex_idrelazioni127655792"> <meta name="passiva" xmlns:rdfa="http://www.w3.org/ns/rdfa/" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Modifier]" id="rp1" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="#1999_05_11_DLGS_135"/> </mcontainer> </mcontainer>

For now this task is performed by the XSLT Nir2Meta but in an advanced version of the same XSLT is possible to take the information concerning the metadata mapping directly from the LMIF.rdf file in order to separate the mapping of the semantic layer to the mapping of the structural one.

6.6 RDF extractor

An RDF extractor is implemented for extracting the RDFa statement from the MetaLex/CEN and separate in this way the structural content to the semantic content.

The GDRRL - Gleaning Resource Descriptions from Dialects of Languages - is a set of specification for declaring that some metadata, compliant with RDF standard, are included in an XML file. It is possible to define the processing instruction in an external XSLT performed following the GDRRL specification11 and make interoperable the extraction.

Using this mechanism we have developed an XSLT extractor of the RDF statements from the XML MetaLex/CEN files, using the RDFa definitions.

11 http://www.w3.org/TR/2006/WD-grddl-primer-20061002/


58

Considering this part of text that declares a substitution, marked up in NIR markup is:

<dsp:sostituzione> <dsp:pos xlink:href="#art5-com2"/> <dsp:norma xlink:href="urn:nir:stato:legge:1996-12-31;675"> <dsp:pos xlink:href="#rif30"/> <dsp:sub xlink:href="urn:nir:stato:legge:1996-12-31;675#art22-com3"/> </dsp:norma> <dsp:novella> <dsp:pos xlink:href="#mod4-vir1"/> </dsp:novella> </dsp:sostituzione>

The MetaLex/CEN enriched with RDFa is the following:

<gmeta name="dsp:sostituzione" id="metalex_iddsp:sostituzione128525632" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-time_modification:Substitution]"> <meta name="dsp:pos" id="metalex_iddsp:pos128525688" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="#art5-com2"/> <gmeta name="dsp:norma" id="metalex_iddsp:norma128525848" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="urn:nir:stato:legge:1996-12-31;675"> <meta name="dsp:pos" id="metalex_iddsp:pos128526008" xlink:href="#rif30"/> </gmeta> <gmeta name="dsp:novella" id="metalex_iddsp:novella111947456" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:New_Text]"> <meta name="dsp:pos" id="metalex_iddsp:pos111947512" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="#mod4-vir1"/> </gmeta> </gmeta>

The same statement should be extracted by the XSL extractor (see § 9.6) and transformed in RDF statement as following:

<rdf:Description rdf:about="metalex_iddsp:sostituzione128525632"> <rdf:type rdf:resource="[lkif-time_modification:Substitution]"/> </rdf:Description> <rdf:Description rdf:about="metalex_iddsp:novella111947456"> <rdf:type rdf:resource="[lkif-expression:New_Text]"/> </rdf:Description>

Obtained the RDF statement it is possible to apply any other the RDF technologies for implementing semantic web services (query, searching, indexing, classification, inference, reasoning, etc.)

6.7 MetaLex2NIR Conversion tool

Metalex2NIR (see the § 9.4) works only with documents previously converted with NIR2MetaLex tool. This conversion tool is the simplest one. It simply read the name attribute of the MetaLex/CEN element and creates a NIR element having the same tag name of the name attribute content. It needs simply to remove the RDFa syntax previously and to work on a pure MetaLex/CEN document. In this way we have demonstrated the possibility to respect the inverse property of the conversion.

So, using the same example of the above paragraph, the element:

<meta name="originale" id="ro1" xmlns:xlink="http://www.w3.org/1999/xlink"


59

xlink:href="urn:nir:stato:decreto.legislativo:1999-05-11;135" />

Will be translated to:

<originale id="ro1" xlink:href="urn:nir:stato:decreto.legislativo:1999-05-11;135" />

6.8 Norma-Editor

The previous two tools developed (NIR2Meta and Meta2NIR) and presented previously were integrate in Norma-Editor. Norma-Editor is an editor developed by the CIRSFID-UNIBO which enables to mark-up with a user-friendly interface the legal resources. It is based on Microsoft Word, but the implementation in released with a like-GPL licence.

It permits to the end-user to mark-up the structure parts of the document in a easy way and without to know any XML syntax, as well as some metadata and some LKIF-core classes (modifications, publication, time of enter into force, etc.) are modelled.

This editor is used for permitting a rapid translation in MetaLex/CENof the documents concerning the Italian Pilot case (Saving Tax domain consists of about 26 documents: 8 from Italian Law and 18 from the EU regulations). The set of documents was also useful for permitting to tune the XSTL translator and the Wrapper as well (see in the e-groupware).

The integration was very easy because was used the Microsoft library. The transformation phase from XmlNiR to XmlMetalex/CEN and vice versa is controlled from a class named TraduciXML that use two XSLT file (NIR2Metalex.xslt and Metalex2NIR.xslt) and a .Net class, XslTransform class. A new variable XslTranform must be set. Then must be use the Load method to load the xslt file to make the transformation. And then the Transform method must be called specifying which is the path of xml input file and xml output file.

More information is available in Microsoft documentation. For details see http://msdn2.microsoft.com/en-us/library/system.xml.xsl.xsltransform(VS.71).aspx.


60

Figure 10 - Converter inside of Norma-Editor

Figure 11- Norma-Editor translation phase

61

7 ANNEX A

7.1 XSL definition of the MetaLex 1.3.1 to MetaLex/CEN Translation

<?xml version="1.0" encoding="UTF-8"?>   <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:metalex="http://www.metalex.nl/latest" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/1999/xhtml"> <xsl:output method="xml" version="1.0" encoding="UTF-8" omit-xml-declaration="no" media-type="text/html" indent="yes"/> <xsl:preserve-space elements="text"/> <xsl:strip-space elements="*"/>  <xsl:template match="metalex:Regulation"> <xsl:element name="root"> <xsl:if test="boolean(@id)"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:if test="boolean(@xml:lang)"> <xsl:attribute name="xml:lang"><xsl:value-of select="@xml:lang"/></xsl:attribute> </xsl:if> <xsl:if test="boolean(@xml:base)"> <xsl:attribute name="base" namespace="http://www.w3.org/XML/1998/namespace"><xsl:value-

62

of select="@xml:base"/></xsl:attribute> </xsl:if> <xsl:if test="boolean(@schemaLocation)"> <xsl:attribute name="schemaLocation" namespace="http://www.w3.org/2001/XMLSchema-instance"><xsl:value-of select="@schemaLocation"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:element name="mcontainer">  </xsl:element> <xsl:choose>  <xsl:when test="metalex:CitationDesignation"> <xsl:element name="container"> <xsl:element name="hcontainer"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:when> <xsl:otherwise> <xsl:element name="container"> <xsl:element name="container"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:otherwise> </xsl:choose> </xsl:element> </xsl:template>  <xsl:template match="metalex:CitationDesignation"> <xsl:element name="htitle"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:Part"> <xsl:element name="hcontainer"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:Article"> <xsl:element name="hcontainer">

63

<xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates select="metalex:IndexDesignation"/> <xsl:if test="metalex:Title"> <xsl:apply-templates select="metalex:Title"/> </xsl:if> <xsl:choose> <xsl:when test="not(metalex:SubPart)"> <xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="container"> <xsl:element name="block"> <xsl:apply-templates select="metalex:List|metalex:Sentence"/> </xsl:element> </xsl:element> </xsl:if> </xsl:when> <xsl:when test="metalex:SubPart and metalex:Sentence"> <xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="container"> <xsl:element name="block"> <xsl:apply-templates select="metalex:Sentence"/> </xsl:element> </xsl:element> <xsl:apply-templates select="metalex:SubPart"/> </xsl:if> </xsl:when> <xsl:otherwise> <xsl:apply-templates select="metalex:SubPart"/> </xsl:otherwise> </xsl:choose> <xsl:apply-templates select="metalex:Annotation|metalex:MetaData"></xsl:apply-templates> </xsl:element> </xsl:template>  <xsl:template match="metalex:SubPart"> <xsl:element name="hcontainer"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates select="metalex:IndexDesignation"/> <xsl:if test="metalex:Title"> <xsl:apply-templates select="metalex:Title"/> </xsl:if> <xsl:choose> <xsl:when test="not(metalex:SubPart)"> <xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="container"> <xsl:element name="block"> <xsl:apply-templates select="metalex:List|metalex:Sentence"/> </xsl:element> </xsl:element> </xsl:if> </xsl:when> <xsl:when test="metalex:SubPart and metalex:Sentence">

64

<xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="container"> <xsl:element name="block"> <xsl:apply-templates select="metalex:Sentence"/> </xsl:element> </xsl:element> <xsl:apply-templates select="metalex:SubPart"/> </xsl:if> </xsl:when> <xsl:when test="metalex:SubPart"> <xsl:apply-templates select="metalex:SubPart"/> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> <xsl:apply-templates select="metalex:Annotation|metalex:MetaData"></xsl:apply-templates> </xsl:element> </xsl:template>  <xsl:template match="metalex:Title"> <xsl:element name="htitle"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:IndexDesignation"> <xsl:choose> <xsl:when test="parent::metalex:SentenceFragmentSubPart"> <xsl:element name="inline"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:when> <xsl:otherwise> <xsl:element name="htitle"> <xsl:element name="inline"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element>

65

</xsl:element> </xsl:otherwise> </xsl:choose> </xsl:template>  <xsl:template match="metalex:Category"> <xsl:element name="inline"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:template> <xsl:template match="metalex:Index"> <xsl:element name="inline"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:SentenceFragment|metalex:SentenceFragmentSubPart"> <xsl:element name="inline"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:Sentence|metalex:List"> <xsl:element name="inline"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute

66

name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:TextVersion"> <xsl:apply-templates/> <xsl:text> </xsl:text> </xsl:template>  <xsl:template match="metalex:Introduction|metalex:Conclusion|metalex:Appendix"> <xsl:element name="container"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:element name="block"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:template> <xsl:template match="metalex:Annotation">  </xsl:template>  <xsl:template match="metalex:CitationTitle|metalex:Cite|metalex:CiteRange|metalex:CiteGroup|metalex:CiteFrom|metalex:CiteTo|metalex:Quote|metalex:Reference"> <xsl:element name="inline"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:attribute name="instanceOf"><xsl:text>http://www.metalex.eu/legacy/metalex/1.3.1/</xsl:text><xsl:value-of select="name(.)"/></xsl:attribute> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:MetaData">  </xsl:template>

67

<xsl:template name="attributes"> <xsl:apply-templates select="@author|@region|@region-resolver|@editor|@editor-resolver|@authority|@procedure"/> <xsl:apply-templates select="@date-version|@date-enacted|@date-repealed|@date-publication"/> <xsl:apply-templates select="@date-start-efficacy|@date-end-efficacy|@date-start-effect|@date-end-effect|@duration-to-enactment|@duration-active|@duration-efficacy"/> </xsl:template> <!-- <xsl:template match="@author|@region|@region-resolver|@editor|@editor-resolver|@authority|@procedure"> <xsl:choose> <xsl:when test="$copyDescriptorAttrs='true'"> <div class="descriptor"> <div class="aname"><xsl:text> </xsl:text><xsl:value-of select="local-name(parent::node())"/>.<xsl:value-of select="local-name()"/></div><xsl:text> = </xsl:text><div class="aval"><xsl:value-of select="."/></div> </div> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="@date-version|@date-enacted|@date-repealed|@date-publication"> <xsl:choose> <xsl:when test="$copyTemporalAttrs='true'"> <div class="temporal"> <div class="aname"><xsl:text> </xsl:text><xsl:value-of select="local-name(parent::node())"/>.<xsl:value-of select="local-name()"/></div><xsl:text> = </xsl:text><div class="aval"><xsl:value-of select="."/></div> </div> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="@date-start-efficacy|@date-end-efficacy|@date-start-effect|@date-end-effect|@duration-to-enactment|@duration-active|@duration-efficacy"> <xsl:choose> <xsl:when test="$copyExtTemporalAttrs='true'"> <div class="extTemporal"> <div class="aname"><xsl:text> </xsl:text><xsl:value-of select="local-name(parent::node())"/>.<xsl:value-of select="local-name()"/></div><xsl:text> = </xsl:text><div class="aval"><xsl:value-of select="."/></div> </div> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="*"> <xsl:choose> <xsl:when test="$copyThirdParty='true'"> <xsl:copy> <xsl:apply-templates/> </xsl:copy>

68

</xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template>--> </xsl:stylesheet>

7.2 XSL definition of the MetaLex 1.3.1 to MetaLex/LS 1.0 Translation

<?xml version="1.0" encoding="UTF-8"?>   <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:metalex="http://www.metalex.nl/latest" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/1999/xhtml"> <xsl:output method="xml" version="1.0" encoding="UTF-8" omit-xml-declaration="no" media-type="text/html" indent="yes"/> <xsl:preserve-space elements="text"/> <xsl:strip-space elements="*"/>  <xsl:template match="metalex:Regulation"> <xsl:element name="Regulation"> <xsl:if test="boolean(@id)"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:if test="boolean(@xml:lang)"> <xsl:attribute name="xml:lang"><xsl:value-of select="@xml:lang"/></xsl:attribute> </xsl:if> <xsl:if test="boolean(@xml:base)"> <xsl:attribute name="base" namespace="http://www.w3.org/XML/1998/namespace"><xsl:value-of select="@xml:base"/></xsl:attribute> </xsl:if> <xsl:if test="boolean(@schemaLocation)"> <xsl:attribute name="schemaLocation" namespace="http://www.w3.org/2001/XMLSchema-

69

instance"><xsl:value-of select="@schemaLocation"/></xsl:attribute> </xsl:if> <xsl:element name="RegulationMetadata">  </xsl:element> <xsl:choose>  <xsl:when test="metalex:CitationDesignation"> <xsl:element name="RegulationContent"> <xsl:element name="TitledRegulation"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:when> <xsl:otherwise> <xsl:element name="RegulationContent"> <xsl:element name="UntitledRegulation"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:otherwise> </xsl:choose> </xsl:element> </xsl:template>  <xsl:template match="metalex:CitationDesignation"> <xsl:element name="CitationDesignation"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:Part"> <xsl:element name="Part"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:Article"> <xsl:element name="Article"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates select="metalex:IndexDesignation"/> <xsl:if test="metalex:Title"> <xsl:apply-templates select="metalex:Title"/> </xsl:if> <xsl:choose> <xsl:when test="not(metalex:SubPart)"> <xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="ArticleText"> <xsl:element name="Block">

70

<xsl:apply-templates select="metalex:List|metalex:Sentence"/> </xsl:element> </xsl:element> </xsl:if> </xsl:when> <xsl:when test="metalex:SubPart and metalex:Sentence"> <xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="ArticleText"> <xsl:element name="Block"> <xsl:apply-templates select="metalex:Sentence"/> </xsl:element> </xsl:element> <xsl:apply-templates select="SubPart"/> </xsl:if> </xsl:when> <xsl:otherwise> <xsl:apply-templates select="metalex:SubPart"/> </xsl:otherwise> </xsl:choose> <xsl:apply-templates select="metalex:Annotation|metalex:MetaData"></xsl:apply-templates> </xsl:element> </xsl:template>  <xsl:template match="metalex:SubPart"> <xsl:element name="SubPart"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates select="metalex:IndexDesignation"/> <xsl:if test="metalex:Title"> <xsl:apply-templates select="metalex:Title"/> </xsl:if> <xsl:choose> <xsl:when test="not(metalex:SubPart)"> <xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="SubPartText"> <xsl:element name="Block"> <xsl:apply-templates select="metalex:List|metalex:Sentence"/> </xsl:element> </xsl:element> </xsl:if> </xsl:when> <xsl:when test="metalex:SubPart and metalex:Sentence"> <xsl:if test="metalex:List|metalex:Sentence"> <xsl:element name="SubPartText"> <xsl:element name="Block"> <xsl:apply-templates select="metalex:Sentence"/> </xsl:element> </xsl:element> <xsl:apply-templates select="metalex:SubPart"/> </xsl:if> </xsl:when> <xsl:when test="metalex:SubPart"> <xsl:apply-templates select="metalex:SubPart"/> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> <xsl:apply-templates select="metalex:Annotation|metalex:MetaData"></xsl:apply-templates>

71

</xsl:element> </xsl:template>  <xsl:template match="metalex:Title"> <xsl:element name="Title"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:IndexDesignation"> <xsl:choose> <xsl:when test="parent::metalex:SentenceFragmentSubPart"> <xsl:element name="IndexDesignation"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:when> <xsl:otherwise> <xsl:element name="IndexDesignationTitle"> <xsl:element name="IndexDesignation"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:otherwise> </xsl:choose> </xsl:template>  <xsl:template match="metalex:Category"> <xsl:element name="Category"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template> <xsl:template match="metalex:Index"> <xsl:element name="Index"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template> <!--

72

SentenceFragment and SentenceFragmentSubpart remain the same elements. --> <xsl:template match="metalex:SentenceFragment"> <xsl:element name="SentenceFragment"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template> <xsl:template match="metalex:SentenceFragmentSubPart"> <xsl:element name="SentenceFragmentSubPart"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template>  <xsl:template match="metalex:Sentence"> <xsl:element name="Sentence"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template> <xsl:template match="metalex:List"> <xsl:element name="List"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:apply-templates/> </xsl:element> </xsl:template> <xsl:template match="metalex:TextVersion"> <xsl:apply-templates/> <xsl:text> </xsl:text> </xsl:template>  <xsl:template match="metalex:Introduction"> <xsl:element name="Introduction"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:element name="Block"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:template>  <xsl:template match="metalex:Conclusion"> <xsl:element name="Conclusion">

73

<xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:element name="Block"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:template>  <xsl:template match="metalex:Appendix"> <xsl:element name="Appendix"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:element name="Block"> <xsl:apply-templates/> </xsl:element> </xsl:element> </xsl:template> <xsl:template match="metalex:Annotation">  </xsl:template>  <xsl:template match="metalex:CitationTitle"> <xsl:element name="CitationTitle"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:Cite"> <xsl:element name="Cite"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:CiteRange"> <xsl:element name="CiteRange"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:CiteGroup"> <xsl:element name="CiteGroup"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element>

74

</xsl:template> <xsl:template match="metalex:CiteFrom"> <xsl:element name="CiteFrom"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:CiteTo"> <xsl:element name="CiteTo"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:Quote"> <xsl:element name="Quote"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:Reference"> <xsl:element name="Reference"> <xsl:if test="@id"> <xsl:attribute name="id"><xsl:value-of select="@id"/></xsl:attribute> </xsl:if> <xsl:copy-of select="text()"/> </xsl:element> </xsl:template> <xsl:template match="metalex:MetaData">  </xsl:template>   <xsl:template name="attributes"> <xsl:apply-templates select="@author|@region|@region-resolver|@editor|@editor-resolver|@authority|@procedure"/> <xsl:apply-templates select="@date-version|@date-enacted|@date-repealed|@date-publication"/> <xsl:apply-templates select="@date-start-efficacy|@date-end-efficacy|@date-start-effect|@date-end-effect|@duration-to-enactment|@duration-active|@duration-efficacy"/> </xsl:template> <!--


75

<xsl:template match="@author|@region|@region-resolver|@editor|@editor-resolver|@authority|@procedure"> <xsl:choose> <xsl:when test="$copyDescriptorAttrs='true'"> <div class="descriptor"> <div class="aname"><xsl:text> </xsl:text><xsl:value-of select="local-name(parent::node())"/>.<xsl:value-of select="local-name()"/></div><xsl:text> = </xsl:text><div class="aval"><xsl:value-of select="."/></div> </div> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="@date-version|@date-enacted|@date-repealed|@date-publication"> <xsl:choose> <xsl:when test="$copyTemporalAttrs='true'"> <div class="temporal"> <div class="aname"><xsl:text> </xsl:text><xsl:value-of select="local-name(parent::node())"/>.<xsl:value-of select="local-name()"/></div><xsl:text> = </xsl:text><div class="aval"><xsl:value-of select="."/></div> </div> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="@date-start-efficacy|@date-end-efficacy|@date-start-effect|@date-end-effect|@duration-to-enactment|@duration-active|@duration-efficacy"> <xsl:choose> <xsl:when test="$copyExtTemporalAttrs='true'"> <div class="extTemporal"> <div class="aname"><xsl:text> </xsl:text><xsl:value-of select="local-name(parent::node())"/>.<xsl:value-of select="local-name()"/></div><xsl:text> = </xsl:text><div class="aval"><xsl:value-of select="."/></div> </div> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="*"> <xsl:choose> <xsl:when test="$copyThirdParty='true'"> <xsl:copy> <xsl:apply-templates/> </xsl:copy> </xsl:when> <xsl:otherwise> <xsl:apply-templates/> </xsl:otherwise> </xsl:choose> </xsl:template>--> </xsl:stylesheet>

76

7.3 MetaLex/LS 1.0 Wrapper

<?xml version="1.0" encoding="UTF-8"?>  <xsd:schema xmlns="http://www.metalex.eu/metalex" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.metalex.eu/metalex" elementFormDefault="qualified"> <xsd:include schemaLocation="http://www.metalex.eu/MetaLex"/> <xsd:import namespace="http://www.w3.org/1999/xlink" schemaLocation="http://svn.leibnizcenter.org/svn/MetaLex/trunk/schema/res/Xlink-Schema.xsd"/> <xsd:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="http://www.w3.org/2001/xml.xsd"> <xsd:annotation> <xsd:documentation xml:lang="en">Access to xml:lang and xml:base</xsd:documentation> </xsd:annotation> </xsd:import>   <xsd:complexType name="lsTregulation"> <xsd:complexContent> <xsd:restriction base="urTroot"> <xsd:sequence> <xsd:element ref="MetaData"/> <xsd:element ref="RegulationContent"/> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="Publication" type="lsTpublication" substitutionGroup="ur-root"/>  <xsd:complexType name="lsTregulationMetadata"> <xsd:complexContent> <xsd:restriction base="urTmcontainer"> <xsd:choice> <xsd:element ref="Meta" maxOccurs="unbounded"/> </xsd:choice> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="RegulationMetadata" type="lsTmetadata" substitutionGroup="ur-mcontainer"/>  <xsd:complexType name="lsTregulationContent"> <xsd:complexContent> <xsd:restriction base="urTcontainer"> <xsd:choice> <xsd:element ref="UntitledRegulation"/> <xsd:element ref="TitledRegulation"/> </xsd:choice> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="RegulationContent" type="lsTpublicationcontent" substitutionGroup="ur-container"/>

77

<xsd:complexType name="lsUntitledRegulation"> <xsd:complexContent> <xsd:restriction base="urTcontainer"> <xsd:choice> <xsd:element ref="Part" maxOccurs="unbounded"/> <xsd:element ref="Article" maxOccurs="unbounded"/> </xsd:choice> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="UntitledRegulation" type="lsUntitledRegulationt" substitutionGroup="ur-container"/> <xsd:complexType name="lsTtextContainer"> <xsd:complexContent> <xsd:restriction base="urTcontainer"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="Block"/> </xsd:choice> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="Introduction" type="lsTtextContainer" substitutionGroup="ur-container"/> <xsd:element name="Conclusion" type="lsTtextContainer" substitutionGroup="ur-container"/> <xsd:element name="Appendix" type="lsTtextContainer" substitutionGroup="ur-container"/> <xsd:element name="ArticleText" type="lsTtextContainer" substitutionGroup="ur-container"/> <xsd:element name="SubpartText" type="lsTtextContainer" substitutionGroup="ur-container"/>  <xsd:complexType name="lsTtitledRegulation"> <xsd:complexContent> <xsd:restriction base="urThcontainer"> <xsd:sequence> <xsd:element ref="CitationDesignation"/> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="Article"/> <xsd:element ref="Part"/> </xsd:choice> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="TitledRegulation" type="lsTtitledRegulation" substitutionGroup="ur-hcontainer"/> <xsd:complexType name="lsTpart"> <xsd:complexContent> <xsd:restriction base="urThcontainer"> <xsd:sequence> <xsd:element ref="IndexDesignationTitle"/> <xsd:element ref="Title" minOccurs="0"/> <xsd:choice> <xsd:element ref="Article" maxOccurs="unbounded"/> <xsd:element ref="Part" maxOccurs="unbounded"/> </xsd:choice> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="Part" type="lsTpart" substitutionGroup="ur-hcontainer"/> <xsd:complexType name="lsTarticle"> <xsd:complexContent> <xsd:restriction base="urThcontainer"> <xsd:sequence> <xsd:element ref="IndexDesignationTitle"/>

78

<xsd:element ref="Title" minOccurs="0"/> <xsd:choice> <xsd:element ref="Subpart" maxOccurs="unbounded"/> <xsd:sequence> <xsd:element ref="List"/> <xsd:element ref="Sentence" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> <xsd:sequence> <xsd:element ref="Sentence" maxOccurs="unbounded"/> <xsd:choice> <xsd:element ref="Subpart" maxOccurs="unbounded"/> <xsd:sequence> <xsd:element ref="List"/> <xsd:element ref="Sentence" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:choice> </xsd:sequence> </xsd:choice> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="Article" type="lsTarticle" substitutionGroup="ur-hcontainer"/> <xsd:complexType name="cTsubpart"> <xsd:complexContent> <xsd:restriction base="urThcontainer"> <xsd:sequence> <xsd:element ref="IndexDesignationTitle"/> <xsd:element ref="Title" minOccurs="0"/> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="Subpart"/> <xsd:element ref="SubpartText"/> </xsd:choice> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="SubPart" type="cTsubpart" substitutionGroup="ur-hcontainer"/>  <xsd:complexType name="lsTcitationDesignation" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTblock"/>  </xsd:complexContent> </xsd:complexType> <xsd:element name="CitationDesignation" type="lsTcitationDesignation" substitutionGroup="ur-htitle"/> <xsd:complexType name="lsTtitle" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTblock"/>  </xsd:complexContent> </xsd:complexType> <xsd:element name="Title" type="lsTtitle" substitutionGroup="ur-htitle"/> <xsd:complexType name="lsTindexDesignationTitle" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTblock"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="IndexDesignation"/> </xsd:choice> </xsd:restriction> </xsd:complexContent>

79

</xsd:complexType> <xsd:element name="IndexDesignationTitle" type="lsTindexDesignationTitle" substitutionGroup="ur-htitle"/>  <xsd:complexType name="lsBlock" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTblock"> <xsd:choice minOccurs="0" maxOccurs="unbounded">  <xsd:element ref="ur-inline"/> <xsd:element ref="Milestone"/> </xsd:choice> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="Block" type="lsBlock" substitutionGroup="ur-block"/>  <xsd:complexType name="lsTinline" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTinline"/>  </xsd:complexContent> </xsd:complexType> <xsd:element name="Index" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:element name="Category" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:element name="Cite" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:element name="CiteFrom" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:element name="CiteTo" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:element name="Quote" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:element name="Reference" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:element name="Sentence" type="lsTinline" substitutionGroup="ur-inline"/> <xsd:complexType name="lsTciteGroup" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTinline"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="Cite"/> <xsd:element ref="CiteGroup"/> </xsd:choice> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="CiteGroup" type="lsTciteGroup" substitutionGroup="ur-inline"/> <xsd:complexType name="lsTciteRange" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTinline"> <xsd:sequence> <xsd:element ref="CiteFrom"/> <xsd:element ref="CiteTo"/> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="CiteRange" type="lsTciteRange" substitutionGroup="ur-inline"/> <xsd:complexType name="lsTindexDesignation" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTinline"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="Category"/> <xsd:element ref="Index"/> </xsd:choice> </xsd:restriction> </xsd:complexContent>

80

</xsd:complexType> <xsd:element name="IndexDesignation" type="lsTindexDesignation" substitutionGroup="ur-inline"/> <xsd:complexType name="lsTlist" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTinline"> <xsd:sequence> <xsd:element ref="SentenceFragment"/> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="SentenceFragmentSubPart"/> </xsd:choice> <xsd:element ref="SentenceFragment" minOccurs="0" maxOccurs="unbounded"/> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="List" type="lsTlist" substitutionGroup="ur-inline"/> <xsd:complexType name="lsTsentenceFragmentSubPart" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTinline"> <xsd:sequence> <xsd:element ref="IndexDesignation"/> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="SentenceFragment"/> <xsd:element ref="List"/> </xsd:choice> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="SentenceFragmentSubPart" type="lsTsentenceFragmentSubPart" substitutionGroup="ur-inline"/>  <xsd:complexType name="lsTdate" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="urTdate"/>  </xsd:complexContent> </xsd:complexType> <xsd:element name="Date" type="lsTdate" substitutionGroup="ur-inline"/>  <xsd:complexType name="lsTmeta"> <xsd:complexContent> <xsd:restriction base="urTmeta"/>  </xsd:complexContent> </xsd:complexType> <xsd:element name="Meta" type="cTmeta" substitutionGroup="ur-meta"/> <xsd:element name="Annotation" type="cTmeta" substitutionGroup="ur-meta"/> </xsd:schema>


81

8 ANNEX B

8.1 XSL definition of the Hungarian translator

<?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:fn="http://www.w3.org/2005/xpath-functions"> <xsl:output method="xml" encoding="UTF-8" indent="yes"/> <xsl:variable name="xsl_lang">hu</xsl:variable> <xsl:template match="Intermediate_Document"> <xsl:element name="root"> <xsl:attribute name="name">Regulation</xsl:attribute> <xsl:call-template name="metainfo"/> <xsl:apply-templates/> </xsl:element> </xsl:template> <xsl:template match="Container[@name='Introduction']"> <xsl:element name="container"> <xsl:attribute name="name" select="@name"/> <xsl:call-template name="textversion"> <xsl:with-param name="textvalue" select="./Text"/> </xsl:call-template> </xsl:element> </xsl:template> <xsl:template match="Container"> <xsl:choose> <xsl:when test="@name = 'Article'"> <xsl:element name="hcontainer"> <xsl:attribute name="name" select="@name"/> <xsl:call-template name="applyctemplates"/> </xsl:element> </xsl:when> <xsl:when test="@name = 'Part' or @name = 'Appendix'"> <xsl:element name="container"> <xsl:attribute name="name">PartWrapper</xsl:attribute> <xsl:element name="hcontainer"> <xsl:attribute name="name" select="@name"/> <xsl:call-template name="applyctemplates"/> </xsl:element> </xsl:element> </xsl:when> <xsl:otherwise> <xsl:element name="container"> <xsl:attribute name="name" select="@name"/> <xsl:call-template name="applyctemplates"/> </xsl:element> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template match="Block"> <xsl:element name="hcontainer"> <xsl:attribute name="name" select="@name"/>

82

<xsl:call-template name="preserve_id"/> <xsl:call-template name="createhtitle"/> <xsl:call-template name="indexdesignation"/> <xsl:element name="container"> <xsl:attribute name="name">Body</xsl:attribute> <xsl:call-template name="sentence"/> <xsl:apply-templates select="Block"/> <xsl:apply-templates select="List"/> </xsl:element> </xsl:element> </xsl:template> <xsl:template match="List"> <xsl:param name="nestedtext"/> <xsl:element name="container"> <xsl:attribute name="name">List</xsl:attribute> <xsl:call-template name="preserve_id"/> <xsl:call-template name="textversion"> <xsl:with-param name="textvalue" select="$nestedtext"/> </xsl:call-template> <xsl:for-each select="./ListItem"> <xsl:element name="hcontainer"> <xsl:attribute name="name">ListItem</xsl:attribute> <xsl:call-template name="preserve_id"/> <xsl:call-template name="createhtitle"/> <xsl:call-template name="indexdesignation"/> <xsl:element name="container"> <xsl:attribute name="name">Body</xsl:attribute> <xsl:if test="exists(./List)"> <xsl:apply-templates select="List"> <xsl:with-param name="nestedtext" select="./Text"/> </xsl:apply-templates> </xsl:if> <xsl:if test="not(exists(./List))"> <xsl:call-template name="textversion"> <xsl:with-param name="textvalue" select="./Text"/> </xsl:call-template> </xsl:if> </xsl:element> </xsl:element> </xsl:for-each> </xsl:element> </xsl:template>   <xsl:template name="preserve_id"> <xsl:if test="exists(@id) and string-length(@id)>0"> <xsl:attribute name="id"> <xsl:value-of select="@id"/> </xsl:attribute> </xsl:if> </xsl:template>  <xsl:template name="applyctemplates"> <xsl:call-template name="preserve_id"/> <xsl:call-template name="createhtitle"/> <xsl:call-template name="indexdesignation"/> <xsl:apply-templates select="Container"/> <xsl:element name="container">

83

<xsl:attribute name="name">Body</xsl:attribute> <xsl:apply-templates select="Block"/> <xsl:call-template name="sentence"/> <xsl:apply-templates select="List"/> </xsl:element> </xsl:template>  <xsl:template name="createhtitle"> <xsl:element name="htitle"> <xsl:attribute name="name">Title</xsl:attribute> <xsl:value-of select="./Title"/> </xsl:element> </xsl:template>  <xsl:template name="indexdesignation"> <xsl:element name="container"> <xsl:attribute name="name">IndexDesignation</xsl:attribute> <xsl:if test="exists(./Category) and string-length(./Category)>0"> <xsl:element name="container"> <xsl:attribute name="name">Category</xsl:attribute> <xsl:call-template name="textversion"> <xsl:with-param name="textvalue" select="./Category"/> </xsl:call-template> </xsl:element> </xsl:if> <xsl:element name="block"> <xsl:attribute name="name">Index</xsl:attribute> <xsl:value-of select="./Index"/> </xsl:element> </xsl:element> </xsl:template>  <xsl:template name="textversion"> <xsl:param name="textvalue"/> <xsl:element name="block"> <xsl:attribute name="name">TextVersion</xsl:attribute> <xsl:attribute name="xml:lang" select="$xsl_lang"/> <xsl:value-of select="$textvalue"/> </xsl:element> </xsl:template>  <xsl:template name="sentence"> <xsl:call-template name="textversion"> <xsl:with-param name="textvalue" select="./Text"/> </xsl:call-template> </xsl:template> </xsl:stylesheet>

84

9 ANNEX C - Italian translators

9.1 Forking of MetaLex/CEN for NIR translation <?xml version="1.0" encoding="UTF-8"?>  <xsd:schema xmlns:e="metalex" xmlns:xsd="http://www.w3.org/2001/XMLSchema" targetNamespace="metalex" elementFormDefault="qualified"> <xsd:simpleType name="CMtype"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="root"/> <xsd:enumeration value="hcontainer"/> <xsd:enumeration value="container"/> <xsd:enumeration value="block"/> <xsd:enumeration value="basic"/> <xsd:enumeration value="inline"/> <xsd:enumeration value="milestone"/> <xsd:enumeration value="mcontainer"/> <xsd:enumeration value="meta"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="numberingType"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="locunq"/> <xsd:enumeration value="globunq"/> <xsd:enumeration value="locnumb"/> <xsd:enumeration value="globnumb"/> <xsd:enumeration value="locnn"/> <xsd:enumeration value="globnn"/> </xsd:restriction> </xsd:simpleType> <xsd:attributeGroup name="nameopt"> <xsd:attribute name="name" type="xsd:NMTOKEN"/> </xsd:attributeGroup> <xsd:attributeGroup name="namereq"> <xsd:attribute name="name" type="xsd:NMTOKEN" use="required"/> </xsd:attributeGroup> <xsd:attributeGroup name="typeopt"> <xsd:attribute name="type" type="e:CMtype"/> </xsd:attributeGroup> <xsd:attributeGroup name="typereq"> <xsd:attribute name="type" type="e:CMtype" use="required"/> </xsd:attributeGroup> <xsd:attributeGroup name="typeroot"> <xsd:attribute name="type" type="e:CMtype" fixed="root"/> </xsd:attributeGroup> <xsd:attributeGroup name="typehcontainer"> <xsd:attribute name="type" type="e:CMtype" fixed="hcontainer"/> </xsd:attributeGroup> <xsd:attributeGroup name="typecontainer"> <xsd:attribute name="type" type="e:CMtype" fixed="container"/> </xsd:attributeGroup> <xsd:attributeGroup name="typeblock"> <xsd:attribute name="type" type="e:CMtype" fixed="block"/> </xsd:attributeGroup> <xsd:attributeGroup name="typeinline"> <xsd:attribute name="type" type="e:CMtype" fixed="inline"/> </xsd:attributeGroup> <xsd:attributeGroup name="typemilestone">


85

<xsd:attribute name="type" type="e:CMtype" fixed="milestone"/> </xsd:attributeGroup> <xsd:attributeGroup name="typemcontainer"> <xsd:attribute name="type" type="e:CMtype" fixed="mcontainer"/> </xsd:attributeGroup> <xsd:attributeGroup name="typemeta"> <xsd:attribute name="type" type="e:CMtype" fixed="meta"/> </xsd:attributeGroup> <xsd:attributeGroup name="idopt"> <xsd:attribute name="id" type="xsd:NMTOKEN"/> </xsd:attributeGroup> <xsd:attributeGroup name="idreq"> <xsd:attribute name="id" type="xsd:NMTOKEN" use="required"/> </xsd:attributeGroup> <xsd:attributeGroup name="numbatt"> <xsd:attribute name="numbering" type="e:numberingType"/> </xsd:attributeGroup> <xsd:attributeGroup name="locunq"> <xsd:attribute name="numbering" type="e:numberingType" fixed="locunq"/> </xsd:attributeGroup> <xsd:attributeGroup name="globunq"> <xsd:attribute name="numbering" type="e:numberingType" fixed="globunq"/> </xsd:attributeGroup> <xsd:attributeGroup name="locnumb"> <xsd:attribute name="numbering" type="e:numberingType" fixed="locnumb"/> </xsd:attributeGroup> <xsd:attributeGroup name="globnumb"> <xsd:attribute name="numbering" type="e:numberingType" fixed="globnumb"/> </xsd:attributeGroup> <xsd:attributeGroup name="locnn"> <xsd:attribute name="numbering" type="e:numberingType" fixed="locnn"/> </xsd:attributeGroup> <xsd:attributeGroup name="globnn"> <xsd:attribute name="numbering" type="e:numberingType" fixed="globnn"/> </xsd:attributeGroup> <xsd:attributeGroup name="classatt"> <xsd:attribute name="class" type="xsd:NMTOKEN"/> </xsd:attributeGroup> <xsd:attributeGroup name="styleatt"> <xsd:attribute name="style" type="xsd:string"/> </xsd:attributeGroup> <xsd:attributeGroup name="dateatt"> <xsd:attribute name="date" type="xsd:date"/> </xsd:attributeGroup> <xsd:attributeGroup name="hrefatt"> <xsd:attribute name="href" type="xsd:anyURI" default="null"/> </xsd:attributeGroup> <xsd:attributeGroup name="appliestoatt"> <xsd:attribute name="appliesto" type="xsd:anyURI"/> </xsd:attributeGroup> <xsd:attributeGroup name="valueatt"> <xsd:attribute name="value" type="xsd:string"/> </xsd:attributeGroup> <xsd:attributeGroup name="showasatt"> <xsd:attribute name="showas" type="xsd:string"/> </xsd:attributeGroup> <xsd:complexType name="urType" abstract="true"> <xsd:complexContent> <xsd:extension base="xsd:anyType"> <xsd:attributeGroup ref="e:nameopt"/> <xsd:attributeGroup ref="e:typeopt"/> <xsd:anyAttribute namespace="##any" processContents="skip"/>


86

</xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="urContentType" abstract="true"> <xsd:complexContent> <xsd:extension base="e:urType"> <xsd:attributeGroup ref="e:idopt"/> <xsd:attributeGroup ref="e:numbatt"/> <xsd:attributeGroup ref="e:classatt"/> <xsd:attributeGroup ref="e:styleatt"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="urMetaType" abstract="true"> <xsd:complexContent> <xsd:extension base="e:urType"> <xsd:attributeGroup ref="e:idopt"/> <xsd:attributeGroup ref="e:numbatt"/> <xsd:attributeGroup ref="e:hrefatt"/> <xsd:attributeGroup ref="e:appliestoatt"/> <xsd:attributeGroup ref="e:showasatt"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absContainerType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urContentType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> <xsd:element ref="e:absContainer"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absBlock"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:attributeGroup ref="e:typecontainer"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absHcontainerType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urContentType"> <xsd:choice maxOccurs="unbounded"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> </xsd:choice> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absBasic"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> </xsd:choice> </xsd:choice> <xsd:attributeGroup ref="e:typehcontainer"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absBasicType" abstract="true" mixed="true"> <xsd:complexContent mixed="true">


87

<xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absBasic"/> <xsd:element ref="e:absHtitle"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absBlock"/> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absQuotedContent"/> </xsd:choice> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absBlockType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:attributeGroup ref="e:typeblock"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absInlineType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> </xsd:choice> <xsd:attributeGroup ref="e:typeinline"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absMilestoneType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urContentType"> <xsd:attributeGroup ref="e:typemilestone"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absRootType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urType"> <xsd:sequence> <xsd:element ref="e:absContainer" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="e:typeroot"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent>


88

</xsd:complexType> <xsd:complexType name="absMcontainerType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absMeta" maxOccurs="unbounded"/> <xsd:element ref="e:absGenericMeta" maxOccurs="unbounded"/> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> </xsd:choice> <xsd:attributeGroup ref="e:typemcontainer"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absGenericMetaType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="xsd:anyType"> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absMetaType" abstract="true"> <xsd:complexContent> <xsd:restriction base="e:urMetaType"> <xsd:attributeGroup ref="e:typemeta"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absAnchorType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="e:absInlineType"> <xsd:attributeGroup ref="e:hrefatt"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absDateType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="e:absInlineType"> <xsd:attributeGroup ref="e:dateatt"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absQuotedType" abstract="true" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:urType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="absCitationType" abstract="true" mixed="true"> <xsd:complexContent mixed="true">


89

<xsd:restriction base="e:urContentType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absMilestone"/> </xsd:choice> <xsd:attributeGroup ref="e:typeinline"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="absRoot" type="e:absRootType" abstract="true"/> <xsd:element name="absContainer" type="e:absContainerType" abstract="true"/> <xsd:element name="absHcontainer" type="e:absHcontainerType" abstract="true"/> <xsd:element name="absBlock" type="e:absBlockType" abstract="true"/> <xsd:element name="absBasic" type="e:absBasicType" abstract="true"/> <xsd:element name="absHtitle" type="e:absBlockType" abstract="true"/> <xsd:element name="absInline" type="e:absInlineType" abstract="true"/> <xsd:element name="absMilestone" type="e:absMilestoneType" abstract="true"/> <xsd:element name="absMcontainer" type="e:absMcontainerType" abstract="true"/> <xsd:element name="absGenericMeta" type="e:absGenericMetaType" abstract="true"/> <xsd:element name="absMeta" type="e:absMetaType" abstract="true"/> <xsd:element name="absQuotedContent" type="e:absQuotedType" abstract="true"/> <xsd:element name="absCitation" type="e:absCitationType" abstract="true"/> <xsd:complexType name="genRootType"> <xsd:complexContent> <xsd:restriction base="e:absRootType"> <xsd:sequence> <xsd:element ref="e:absContainer" maxOccurs="unbounded"/> </xsd:sequence> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genContainerType"> <xsd:complexContent> <xsd:restriction base="e:absContainerType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> <xsd:element ref="e:absContainer"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absBlock"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genHcontainerType"> <xsd:complexContent> <xsd:restriction base="e:absHcontainerType"> <xsd:choice maxOccurs="unbounded"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> </xsd:choice> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absBasic"/> <xsd:element ref="e:absHcontainer"/>


90

<xsd:element ref="e:absContainer"/> </xsd:choice> </xsd:choice> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genBasicType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:absBasicType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absBasic"/> <xsd:element ref="e:absHtitle"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absBlock"/> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absQuotedContent"/> </xsd:choice> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genBlockType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:absBlockType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> <xsd:element ref="e:absBasic"/> </xsd:choice> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genInlineType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:absInlineType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absMilestone"/> </xsd:choice> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genMilestoneType"> <xsd:complexContent> <xsd:restriction base="e:absMilestoneType"> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType>


91

<xsd:complexType name="genMcontainerType"> <xsd:complexContent> <xsd:restriction base="e:absMcontainerType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absMeta" maxOccurs="unbounded"/> <xsd:element ref="e:absGenericMeta" maxOccurs="unbounded"/> <xsd:element ref="e:absMcontainer" maxOccurs="unbounded"/> </xsd:choice> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genGenericMetaType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="e:absGenericMetaType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genMetaType"> <xsd:complexContent> <xsd:restriction base="e:absMetaType"> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genQuotedType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="e:absQuotedType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="genCitationType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:restriction base="e:absCitationType"> <xsd:choice minOccurs="0" maxOccurs="unbounded"> <xsd:element ref="e:absInline"/> <xsd:element ref="e:absCitation"/> <xsd:element ref="e:absMcontainer"/> <xsd:element ref="e:absMilestone"/> </xsd:choice> <xsd:attributeGroup ref="e:namereq"/> <xsd:anyAttribute namespace="##any" processContents="skip"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:element name="root" type="e:genRootType" substitutionGroup="e:absRoot"/> <xsd:element name="container" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="hcontainer" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="block" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="basic" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="htitle" type="e:genBlockType" substitutionGroup="e:absHtitle"/> <xsd:element name="inline" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="milestone" type="e:genMilestoneType" substitutionGroup="e:absMilestone"/> <xsd:element name="mcontainer" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="meta" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="gmeta" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="quotedcontent" type="e:genQuotedType" substitutionGroup="e:absQuotedContent"/> <xsd:element name="citation" type="e:genCitationType" substitutionGroup="e:absCitation"/>

92

<xsd:complexType name="rootType"> <xsd:complexContent> <xsd:extension base="e:absRootType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="containerType"> <xsd:complexContent> <xsd:extension base="e:absContainerType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="hcontainerType"> <xsd:complexContent> <xsd:extension base="e:absHcontainerType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="blockType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="e:absBlockType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="inlineType" mixed="true"> <xsd:complexContent mixed="true"> <xsd:extension base="e:absInlineType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="milestoneType"> <xsd:complexContent> <xsd:extension base="e:absMilestoneType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="mcontainerType"> <xsd:complexContent> <xsd:extension base="e:absMcontainerType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="metaType"> <xsd:complexContent> <xsd:extension base="e:absMetaType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="anchorType"> <xsd:complexContent> <xsd:extension base="e:absAnchorType"/> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="dateType"> <xsd:complexContent> <xsd:extension base="e:absDateType"/> </xsd:complexContent> </xsd:complexType> </xsd:schema>

9.2 Wrapper

N2MWrapper_2-0.xsd

<?xml version="1.0" encoding="UTF-8"?>  <xsd:schema xmlns="http://www.nir.it/2.0" xmlns:e="metalex"


93

xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:h="http://www.w3.org/HTML/1998/html4" xmlns:dsp="http://www.normeinrete.it/nir/disposizioni/2.0" targetNamespace="http://www.nir.it/2.0" elementFormDefault="qualified"> <xsd:import namespace="metalex" schemaLocation="./e_fork_four.xsd"/> <xsd:import namespace="http://www.w3.org/HTML/1998/html4" schemaLocation="./N2MWh_2.0.xsd"/> <xsd:import namespace="http://www.normeinrete.it/nir/disposizioni/2.0" schemaLocation="./N2MWdsp_2.0.xsd"/> <xsd:annotation> <xsd:documentation> ===================================================================== NEW TYPES ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:simpleType name="elencoValoridiTipo"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="originale"/> <xsd:enumeration value="monovigente"/> <xsd:enumeration value="multivigente"/> </xsd:restriction> </xsd:simpleType> <xsd:simpleType name="elencoValoriPubblicazione"> <xsd:restriction base="xsd:string"> <xsd:enumeration value="GU"/> <xsd:enumeration value="BR"/> <xsd:enumeration value="AlboPretorio"/> </xsd:restriction> </xsd:simpleType> <xsd:complexType name="hierarchyType"> <xsd:complexContent> <xsd:restriction base="e:hcontainerType"> <xsd:sequence> <xsd:choice> <xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> </xsd:choice> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absBasic"/> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> </xsd:choice> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="articleType"> <xsd:complexContent> <xsd:restriction base="e:hcontainerType"> <xsd:sequence> <xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> <xsd:choice> <xsd:element ref="e:absHcontainer" maxOccurs="unbounded"/> <xsd:element ref="e:absContainer" maxOccurs="unbounded"/> </xsd:choice> </xsd:sequence> <xsd:attributeGroup ref="e:globnumb"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="clauseType">


94

<xsd:complexContent> <xsd:restriction base="e:hcontainerType"> <xsd:sequence> <xsd:element ref="e:absHtitle" maxOccurs="unbounded"/> <xsd:choice> <xsd:element ref="e:absHcontainer"/> <xsd:element ref="e:absContainer"/> </xsd:choice> </xsd:sequence> <xsd:attributeGroup ref="e:locnumb"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="contentType"> <xsd:complexContent> <xsd:restriction base="e:containerType"> <xsd:choice maxOccurs="unbounded"> <xsd:element ref="e:absHcontainer"/> </xsd:choice> <xsd:attributeGroup ref="e:locnumb"/> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="prefaceType"> <xsd:complexContent> <xsd:restriction base="e:blockType"> <xsd:sequence> <xsd:element ref="e:absBasic"/> </xsd:sequence> </xsd:restriction> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="mdateType"> <xsd:complexContent> <xsd:extension base="e:metaType"> <xsd:attribute name="norm" type="xsd:date" use="required"/> <xsd:attribute name="num" type="xsd:integer"/> <xsd:attribute name="nome" type="xsd:string"/> <xsd:attribute name="tipo" type="elencoValoriPubblicazione"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="inLineDateType"> <xsd:complexContent> <xsd:extension base="e:inlineType"> <xsd:attribute name="norm" type="xsd:date" use="required"/> <xsd:attribute name="codice" type="xsd:string"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:complexType name="mLegalInfoType"> <xsd:complexContent> <xsd:extension base="e:metaType"> <xsd:attribute name="natura" type="xsd:string" use="required"/> <xsd:attribute name="normativa" type="xsd:string" use="required"/> <xsd:attribute name="funzione" type="xsd:string" use="required"/> <xsd:attribute name="fonte" type="xsd:string" use="required"/> </xsd:extension> </xsd:complexContent> </xsd:complexType> <xsd:annotation> <xsd:documentation>


95

===================================================================== HIERARCHY TYPES ELEMENT (OLD e:genHcontainerType) ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="sezione" type="hierarchyType" substitutionGroup="e:absHcontainer"/> <xsd:element name="titolo" type="hierarchyType" substitutionGroup="e:absHcontainer"/> <xsd:element name="paragrafo" type="hierarchyType" substitutionGroup="e:absHcontainer"/> <xsd:element name="parte" type="hierarchyType" substitutionGroup="e:absHcontainer"/> <xsd:annotation> <xsd:documentation> ===================================================================== ARTICLETYPE ELEMENT (OLD e:genHcontainerType) ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="articolo" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:annotation> <xsd:documentation> ===================================================================== CLAUSE TYPE ELEMENT (OLD e:genHcontainerType) ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="comma" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:annotation> <xsd:documentation> ===================================================================== MDATE TYPE ELEMENTS (OLD e:genMetaType) ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="pubblicazione" type="mdateType" substitutionGroup="e:absMeta"/> <xsd:element name="entratainvigore" type="mdateType" substitutionGroup="e:absMeta"/> <xsd:element name="redazione" type="mdateType" substitutionGroup="e:absMeta"/> <xsd:annotation> <xsd:documentation> ===================================================================== INLINE DATE TYPE ELEMENT (OLD e:genInline) ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="dataDoc" type="inLineDateType" substitutionGroup="e:absInline"/> <xsd:element name="dataeluogo" type="inLineDateType" substitutionGroup="e:absInline"/> <xsd:annotation> <xsd:documentation> ===================================================================== ROOT ELEMENT ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="NIR" type="e:rootType" substitutionGroup="e:absRoot"/> <xsd:annotation> <xsd:documentation> =====================================================================


96

META ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="alias" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="allegatodi" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="attiva" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="attivita" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="errata" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="evento" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="giurisprudenza" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="haallegato" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="materia" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="originale" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="passiva" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="proponente" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="rettifica" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:element name="ripubblicazione" type="e:genMetaType" substitutionGroup="e:absMeta"/> <xsd:annotation> <xsd:documentation> ===================================================================== GENERIC META ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="proprietario" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="urn" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:annotation> <xsd:documentation> ===================================================================== META CONTAINER ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="altrepubblicazioni" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="ciclodivita" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="comunicazioni" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="descrittori" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="disposizioni" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="eventi" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="inlinemeta" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="materie" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="modificheattive" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="modifichepassive" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="motivazioni" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="oggetto" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="proponenti" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="regole" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:element name="relazioni" type="e:genMcontainerType"


97

substitutionGroup="e:absMcontainer"/> <xsd:element name="considerato" type="e:genMcontainerType" substitutionGroup="e:absMcontainer"/> <xsd:annotation> <xsd:documentation> ===================================================================== BASIC ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="intestazione" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="conclusione" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="corpo" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="formulainiziale" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="formulafinale" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="cell" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="deflist" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="list" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="rows" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="decorazione" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="denAnnesso" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="preAnnesso" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="sottoscrivente" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="sottoscrizioni" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="annesso" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="mod" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="virgolette" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="alinea" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="titAnnesso" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:annotation> <xsd:documentation> ===================================================================== CONTAINER ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="meta" type="e:genContainerType" abstract="false" substitutionGroup="e:absContainer"/> <xsd:element name="redazionale" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="altro" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="avvertenza" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="annessi" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="destinatario" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="inquadramento" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="lavoripreparatori" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="note" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="nota" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="AttoDiAuthority" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="Comunicato" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="DecretoLegge" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="DecretoLegislativo" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="DecretoMinisteriale" type="e:genContainerType"


98

substitutionGroup="e:absContainer"/> <xsd:element name="DecretoNN" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="DocArticolato" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="DocumentoNIR" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="Dpcm" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="DpcmNN" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="Legge" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="LeggeCostituzionale" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="LeggeRegionale" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="RegioDecreto" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="Semiarticolato" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="contenitore" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="elencoAnnessi" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="finalita" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="firma" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="lista" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:annotation> <xsd:documentation> ===================================================================== HCONTAINER ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="gerarchia" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l1" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l2" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l3" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l4" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l5" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l6" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l7" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l8" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="l9" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="capo" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="libro" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="partizione" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="el" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="en" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="ep" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="articolato" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="object" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:annotation> <xsd:documentation> ===================================================================== BLOCK ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation>


99

<xsd:element name="blocco" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="infodoc" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="infomancanti" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="preambolo" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="testata" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="coda" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:annotation> <xsd:documentation> ===================================================================== INLINE ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="mNumdoc" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="mTipodoc" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="mDatadoc" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="mEmanante" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="mTitolodoc" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="inlinea" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="ndr" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="atto" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="data" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="numDoc" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="def" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="emanante" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="ente" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="importo" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="irif" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="luogo" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="mrif" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="rif" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="rifesterno" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="rango" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:annotation> <xsd:documentation> ===================================================================== HTITLE ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="tipoDoc" type="e:genBlockType" substitutionGroup="e:absHtitle"/> <xsd:element name="rubrica" type="e:genBlockType" substitutionGroup="e:absHtitle"/> <xsd:element name="tit" type="e:genBlockType" substitutionGroup="e:absHtitle"/> <xsd:element name="titoloDoc" type="e:genBlockType" substitutionGroup="e:absHtitle"/> <xsd:element name="num" type="e:genBlockType" substitutionGroup="e:absHtitle"/> <xsd:annotation> <xsd:documentation> ===================================================================== MILESTONE ELEMENTS ===================================================================== </xsd:documentation> </xsd:annotation> <xsd:element name="vuoto" type="e:genMilestoneType" substitutionGroup="e:absMilestone"/> </xsd:schema>

N2MWh_2.0.xsd

<xsd:schema xmlns="http://www.normeinrete.it/nir/2.1/" xmlns:e="metalex"


100

xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:h="http://www.w3.org/HTML/1998/html4" targetNamespace="http://www.w3.org/HTML/1998/html4" elementFormDefault="qualified"> <xsd:import namespace="metalex" schemaLocation="./e_fork_four.xsd"/> <xsd:element name="br" type="e:genMilestoneType" substitutionGroup="e:absMilestone"/> <xsd:element name="hr" type="e:genMilestoneType" substitutionGroup="e:absMilestone"/> <xsd:element name="img" type="e:genMilestoneType" substitutionGroup="e:absMilestone"/> <xsd:element name="input" type="e:genMilestoneType" substitutionGroup="e:absMilestone"/> <xsd:element name="b" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="i" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="u" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="sub" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="sup" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="span" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="a" type="e:genInlineType" substitutionGroup="e:absInline"/> <xsd:element name="p" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="div" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="form" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="ul" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="ol" type="e:genBlockType" substitutionGroup="e:absBlock"/> <xsd:element name="li" type="e:genBasicType" substitutionGroup="e:absBasic"/> <xsd:element name="dl" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="dt" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="dd" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="table" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="caption" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="thead" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="tfoot" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="tbody" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="colgroup" type="e:genContainerType" substitutionGroup="e:absContainer"/> <xsd:element name="col" type="e:genMilestoneType" substitutionGroup="e:absMilestone"/> <xsd:element name="tr" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="th" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> <xsd:element name="td" type="e:genHcontainerType" substitutionGroup="e:absHcontainer"/> </xsd:schema>

N2MWdsp_2.0.xsd

<xsd:schema xmlns="http://www.normeinrete.it/nir/2.1/" xmlns:e="metalex" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:h="http://www.w3.org/HTML/1998/html4" xmlns:dsp="http://www.nir.it/disposizioni/2.0" targetNamespace="http://www.normeinrete.it/nir/disposizioni/2.0" elementFormDefault="qualified"> <xsd:import namespace="metalex" schemaLocation="./e_fork_four.xsd"/> <xsd:element name="testo" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="pos" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="termine" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="condizione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="visto" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="sentito" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="considerato" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="suproposta" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="basegiuridica" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="proposta" type="e:genGenericMetaType"


101

substitutionGroup="e:absGenericMeta"/> <xsd:element name="parere" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="richiesta" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="procedura" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="considerando" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="motivazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="finalita" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="finanziaria" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="ambito" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="metaregola" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="definitoria" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="istitutiva" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="organizzativa" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="status" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="competenza" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="delega" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="revoca" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="diritto" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="dovere" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="pretesa" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="obbligo" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="divieto" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="permesso" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="procedimento" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="sanzione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="riparazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="informazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="regola" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="abrogazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="sostituzione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="integrazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="ricollocazione" type="e:genGenericMetaType"


102

substitutionGroup="e:absGenericMeta"/> <xsd:element name="intautentica" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="variazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="modtermini" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="vigenza" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="annullamento" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="proroga" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="reviviscenza" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="posticipo" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="sospensione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="retroattivita" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="ultrattivita" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="inapplicazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="deroga" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="estensione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="recepisce" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="attua" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="ratifica" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="attuadelega" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="attuadelegifica" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="converte" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="reitera" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="modifica" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="decadimento" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="comunicazione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="norma" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="soggetto" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="effetto" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="partizione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="tiporegola" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="fatto" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="organo" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/>

103

<xsd:element name="fine" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="destinatario" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="territorio" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="attivita" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="definiendum" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="definiens" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="qualifica" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="delegante" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="controparte" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="azione" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="pena" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="novella" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="novellando" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="dominio" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="altradata" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> <xsd:element name="argomento" type="e:genGenericMetaType" substitutionGroup="e:absGenericMeta"/> </xsd:schema>

9.3 Nir2Meta_3-2.xslt <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns="metalex" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:nir="http://www.normeinrete.it/nir/2.0" xmlns:h="http://www.w3.org/HTML/1998/html4" xmlns:dsp="http://www.normeinrete.it/nir/disposizioni/2.0" xmlns:rdfa="http://www.w3.org/ns/rdfa/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:lkif-legal_action="http://www.estrellaproject.org/lkif-core/legal_action" xmlns:lkif-time_modification="http://www.estrellaproject.org/lkif-core/time-modification" xmlns:lkif-expression="http://www.estrellaproject.org/lkif-core/expression" xmlns:lkif-merology="http://www.estrellaproject.org/lkif-core/merology" exclude-result-prefixes="rdfa"> <xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>  <xsl:template match="nir:NIR"> <xsl:element name="root"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute>


104

</xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:for-each select="./*"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:for-each> </xsl:element> </xsl:template> <xsl:template match="nir:alias"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:allegatodi"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." />


105

<xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:altrepubblicazioni"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:altro"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:attiva"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute>


106

<xsl:attribute name="rdfa:href">[lkif-espression:Modifier]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:attivita"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:avvertenza"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:ciclodivita"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)">


107

<xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:comunicazioni"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:descrittori"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:destinatario"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute>


108

<xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:disposizioni"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:entratainvigore"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-legal_action:Act_of_Commencement]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="$attname='norm' "> <xsl:element name="meta">


109

<xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="name">entratainvigore-norm</xsl:attribute> <xsl:attribute name="rdfa:about">#entratainvigore</xsl:attribute> <xsl:attribute name="rdfa:property">[lkif-time_modification:Enter_in_Force_Date]</xsl:attribute> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:errata"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:eventi"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:evento"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute>


110

<xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:variable name="event_type" select="@tipo" /> <xsl:choose> <xsl:when test="$event_type = 'originale'"> <xsl:attribute name="rdfa:href">[lkif-time_modification:Enter_in_Force_Date]</xsl:attribute> </xsl:when> <xsl:otherwise> <xsl:attribute name="rdfa:href">[lkif-time_modification:Application_Date]</xsl:attribute> </xsl:otherwise> </xsl:choose> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="$attname='data' "> <xsl:element name="meta"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> <xsl:attribute name="name">evento-data</xsl:attribute> <xsl:attribute name="rdfa:about"></xsl:attribute> <xsl:choose> <xsl:when test="$event_type = 'originale'"> <xsl:attribute name="rdfa:content">[lkif-time_modification:Enter_in_Force_Date]</xsl:attribute> </xsl:when> <xsl:otherwise> <xsl:attribute name="rdfa:content">[lkif-time_modification:Application_Date]</xsl:attribute> </xsl:otherwise> </xsl:choose> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:finalita"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." />


111

</xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:giurisprudenza"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:haallegato"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:infodoc"> <xsl:element name="block"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}">


112

<xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:infomancanti"> <xsl:element name="block"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:inlinemeta"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:inquadramento"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')">


113

<xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:lavoripreparatori"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:materia"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:materie"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." />


114

<xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:mDatadoc"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:mEmanante"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:meta"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" />


115

<xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:mNumdoc"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:modificheattive"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-expression:Modifier]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:modifichepassive"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)">


116

<xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-expression:Modified]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:motivazioni"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:mTipodoc"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:mTitolodoc"> <xsl:element name="inline">


117

<xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:nota"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:oggetto"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:originale">


118

<xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> <xsl:if test="$attname = 'id'"> <xsl:attribute name="about"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:passiva"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-expression:Modified]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:proponente"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}">


119

<xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:proponenti"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:proprietario"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:pubblicazione"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-legal_action:Act_of_Publication]</xsl:attribute> <xsl:for-each select="@*">


120

<xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="$attname='tipo' "> <xsl:element name="meta"> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="name">pubblicazione-tipo</xsl:attribute> <xsl:attribute name="rdfa:about">#pubblicazione</xsl:attribute> <xsl:attribute name="rdfa:property">[lkif-expression:Publication_Type]</xsl:attribute> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> <xsl:if test="$attname='num' "> <xsl:element name="meta"> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="name">pubblicazione-num</xsl:attribute> <xsl:attribute name="rdfa:about">#pubblicazione</xsl:attribute> <xsl:attribute name="rdfa:property">[lkif-expression:Publication_Number]</xsl:attribute> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> <xsl:if test="$attname='norm' "> <xsl:element name="meta"> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="name">pubblicazione-norm</xsl:attribute> <xsl:attribute name="rdfa:about">#pubblicazione</xsl:attribute> <xsl:attribute name="rdfa:property">[lkif-time_modification:Publication_Date]</xsl:attribute> <xsl:attribute name="rdfa:content"><xsl:value-of select="$attvalue" /></xsl:attribute> </xsl:element> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:redazione"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" />


121

<xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:redazionale"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:regole"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:relazioni"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*">


122

<xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:rettifica"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:ripubblicazione"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:territorio"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if>


123

<xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:urn"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="urn"> <xsl:value-of select="." /> </xsl:attribute> <xsl:attribute name="naming">Akoma Ntoso Name</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> </xsl:element> </xsl:template> <xsl:template match="dsp:abrogazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-time_modification:Repeal]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:altradata">


124

<xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:ambito"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:argomento"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


125

<xsl:template match="dsp:attivita"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:annullamento"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:attua"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


126

<xsl:template match="dsp:attuadelega"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:attuadelegifica"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:azione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element>


127

</xsl:template> <xsl:template match="dsp:basegiuridica"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:competenza"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:comunicazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates />


128

</xsl:element> </xsl:template> <xsl:template match="dsp:considerando"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:considerato"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:condizione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each>


129

<xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:controparte"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:converte"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:decadimento"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if>


130

</xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:definiendum"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:definiens"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:definitoria"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute>


131

</xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:delega"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:delegante"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:deroga"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." />


132

</xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:destinatario"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:diritto"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:divieto"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}">


133

<xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:dominio"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:dovere"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:effetto"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')">


134

<xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:estensione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:fatto"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:finalita"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." />


135

<xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:finanziaria"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:fine"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:inapplicazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" />


136

<xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:informazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:intautentica"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:integrazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute>


137

<xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-time_modification:Integration]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:istitutiva"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:metaregola"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:modifica"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute>


138

<xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:modtermini"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:motivazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:norma"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" />


139

</xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:novella"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-expression:New_Text]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:novellando"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-expression:Old_Text]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates />


140

</xsl:element> </xsl:template> <xsl:template match="dsp:obbligo"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:organizzativa"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:organo"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each>


141

<xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:parere"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:partizione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:pena"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if>


142

</xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:permesso"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:pos"> <xsl:element name="meta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:posticipo"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute>


143

</xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:pretesa"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:procedimento"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:procedura"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." />


144

</xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:proposta"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:proroga"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:qualifica"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}">


145

<xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:ratifica"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:recepisce"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:regola"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')">


146

<xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:reitera"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:retroattivita"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:reviviscenza"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." />


147

<xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:revoca"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:richiesta"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:ricolocazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" />


148

<xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:riparazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:sanzione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:sentito"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*">


149

<xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:soggetto"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:sospensione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:sostituzione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if>


150

<xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-time_modification:Substitution]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:status"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:suproposta"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:termine"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" />


151

</xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:territorio"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:testo"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:tiporegola"> <xsl:element name="gmeta"> <xsl:attribute name="name">


152

<xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:ultrattivita"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:variazione"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:vigenza"> <xsl:element name="gmeta">


153

<xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="dsp:visto"> <xsl:element name="gmeta"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:intestazione"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-espression:Preface]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element>


154

</xsl:template> <xsl:template match="nir:altro"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:avvertenza"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:annessi"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')">


155

<xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:conclusione"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-expression:Conclusion]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:corpo"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:finalita"> <xsl:element name="container"> <xsl:attribute name="name">


156

<xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:firma"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:formulafinale"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." />


157

</xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:formulainiziale"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:cell"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:deflist"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute>


158

</xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:list"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:rows"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:decorazione">


159

<xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:def"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:denAnnesso"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


160

<xsl:template match="nir:el"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:elencoAnnessi"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:emanante"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


161

<xsl:template match="nir:en"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:articolato"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-espression:Enacting_Section]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:articolo"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-merology:Basic_Unit]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}">


162

<xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:caption"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:colgroup"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:dd"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')">


163

<xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:dl"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:dt"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="@id"> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:form"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" />


164

</xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:li"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:lista"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:lavoripreparatori"> <xsl:element name="container"> <xsl:attribute name="name">


165

<xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:preambolo"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-espression:Preamble]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:preAnnesso"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


166

<xsl:template match="nir:rango"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:sottoscrivente"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-expression:Signature]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:sottoscrizioni"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if>


167

</xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:visto"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:testata"> <xsl:element name="block"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:annesso"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-espression:Dependent_Annex]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')">


168

<xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:capo"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-merology:Higher_Division]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:contenitore"> <xsl:element name="container"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:coda"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute>


169

<xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="id"> <xsl:value-of select="@id" /> </xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:comma"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-merology:Sub_Division]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:gerarchia"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element>


170

</xsl:template> <xsl:template match="h:object"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:table"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:tbody"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates />


171

</xsl:element> </xsl:template> <xsl:template match="h:td"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:tfoot"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:th"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each>


172

<xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:thead"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:tr"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:li"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if>


173

</xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l1"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l2"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l2"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute>


174

</xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l3"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l4"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l5"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." />


175

</xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l6"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l7"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:libro"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}">


176

<xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:l8"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:mod"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:paragrafo"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')">


177

<xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:parte"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-merology:Higher_Division]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:partizione"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:sezione"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if>


178

<xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-merology:Higher_Division]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:titolo"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:attribute name="rdfa:about"> </xsl:attribute> <xsl:attribute name="rdfa:rel">rdf:type</xsl:attribute> <xsl:attribute name="rdfa:href">[lkif-merology:Higher_Division]</xsl:attribute> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:virgolette"> <xsl:element name="quotedcontent"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:alias">


179

<xsl:element name="milestone"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:br"> <xsl:element name="milestone"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:apply-templates /> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> </xsl:element> </xsl:template> <xsl:template match="h:col"> <xsl:element name="milestone"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


180

<xsl:template match="h:hr"> <xsl:element name="milestone"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:input"> <xsl:element name="milestone"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:rif"> <xsl:element name="citation"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


181

<xsl:template match="nir:mrif"> <xsl:element name="citation"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:rifesterno"> <xsl:element name="citation"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:vuoto"> <xsl:element name="milestone"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element>


182

</xsl:template> <xsl:template match="nir:alinea"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:atto"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:coda"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates />


183

</xsl:element> </xsl:template> <xsl:template match="nir:data"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:datadoc"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:dataeluogo"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each>


184

<xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:def"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:ente"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:ep"> <xsl:element name="hcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if>


185

</xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:a"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:b"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:i"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute>


186

</xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:img"> <xsl:element name="milestone"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:span"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:sub"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." />


187

</xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:sup"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:u"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:importo"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}">


188

<xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:luogo"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:tipoDoc"> <xsl:element name="htitle"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:inlinea"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute>


189

</xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:irif"> <xsl:element name="citation"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute> </xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:mirif"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute>


190

</xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:ndr"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute> </xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:rubrica"> <xsl:element name="htitle"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute>


191

</xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:soggetto"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute> </xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:tit"> <xsl:element name="htitle"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute>


192

</xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:titAnnesso"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute> </xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:titoloDoc"> <xsl:element name="htitle"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:if test="@style"> <xsl:attribute name="style"> <xsl:value-of select="@style" /> </xsl:attribute>


193

</xsl:if> <xsl:if test="@class"> <xsl:attribute name="class"> <xsl:value-of select="@class" /> </xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:num"> <xsl:element name="htitle"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:numDoc"> <xsl:element name="inline"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:blocco">


194

<xsl:element name="block"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:div"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:ol"> <xsl:element name="block"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


195

<xsl:template match="h:p"> <xsl:element name="basic"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="h:ul"> <xsl:element name="block"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template> <xsl:template match="nir:ciclodivita"> <xsl:element name="mcontainer"> <xsl:attribute name="name"> <xsl:value-of select="name()" /> </xsl:attribute> <xsl:if test="not(@id)"> <xsl:attribute name="id">metalex_<xsl:value-of select="generate-id()" /></xsl:attribute> </xsl:if> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '')"> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:template>


196

</xsl:stylesheet>

9.4 Meta2Nir_2-0.xslt <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h="http://www.w3.org/HTML/1998/html4" xmlns="http://www.normeinrete.it/nir/2.0" xmlns:dsp="http://www.normeinrete.it/nir/disposizioni/2.0" xmlns:rdfa="http://www.w3.org/ns/rdfa/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:lkif-legal_action="http://www.estrellaproject.org/lkif-core/legal_action" xmlns:lkif-time_modification="http://www.estrellaproject.org/lkif-core/time-modification" xmlns:lkif-expression="http://www.estrellaproject.org/lkif-core/expression" xmlns:lkif-merology="http://www.estrellaproject.org/lkif-core/merology" xmlns:xml="http://www.w3.org/XML/1998/namespace" exclude-result-prefixes="xs"> <xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/> <xsl:template match="*"> <xsl:choose> <xsl:when test="not(@name = 'NIR')"> <xsl:if test="not(contains(@name, '-'))"> <xsl:element name="{@name}"> <xsl:for-each select="@*"> <xsl:variable name="attname" select="name(.)" /> <xsl:variable name="attvalue" select="." /> <xsl:if test="not($attname = 'name') and not($attvalue = '') and not($attname = 'type') and not($attname = 'xmlns:xs') and not($attname = 'xs:schemaLocation') and not($attvalue = 'null') and not(contains($attname, 'rdfa')) and not(contains($attvalue, 'metalex_'))"> <xsl:choose> <xsl:when test="$attname = 'urn' "> <xsl:value-of select="$attvalue" /> </xsl:when> <xsl:otherwise> <xsl:attribute name="{$attname}"> <xsl:value-of select="." /> </xsl:attribute> </xsl:otherwise> </xsl:choose> </xsl:if> </xsl:for-each> <xsl:apply-templates /> </xsl:element> </xsl:if> </xsl:when> <xsl:otherwise> <NIR> <xsl:variable name="typeatt" select="@tipo" /> <xsl:if test="$typeatt = 'originale' or $typeatt = 'monovigente' or $typeatt = 'multivigente'"> <xsl:attribute name="tipo"> <xsl:value-of select="$typeatt" /> </xsl:attribute> </xsl:if> <xsl:apply-templates /> </NIR> </xsl:otherwise> </xsl:choose> </xsl:template> </xsl:stylesheet>


197

9.5 LMIF_1-1-CURIE.rdf <?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:nir="http://www.nir.it/2.0" xmlns:dsp="http://www.normeinrete.it/nir/disposizioni/2.0" xmlns:lkif-legal_action="http://www.estrellaproject.org/lkif-core/legal_action" xmlns:lkif-time_modification="http://www.estrellaproject.org/lkif-core/time-modification" xmlns:lkif-expression="http://www.estrellaproject.org/lkif-core/expression" xmlns:lkif-merology="http://www.estrellaproject.org/lkif-core/merology"> <rdf:Description rdf:about="nir:pubblicazione"> <rdf:type rdf:resource="[lkif-legal_action:Act_of_Publication]" /> </rdf:Description> <rdf:Description rdf:about="nir:pubblicazione-tipo"> <rdf:type rdf:resource="[lkif-expression:Publication_Type]" /> </rdf:Description> <rdf:Description rdf:about="nir:pubblicazione-num"> <rdf:type rdf:resource="[lkif-expression:Publication_Number]" /> </rdf:Description> <rdf:Description rdf:about="nir:pubblicazione-norm"> <rdf:type rdf:resource="[lkif-time_modification:Publication_Date]" rdf:datatype="xsd:date" /> </rdf:Description> <rdf:Description rdf:about="nir:entratainvigore"> <rdf:type rdf:resource="[lkif-legal_action:Act_of_Commencement]"/> </rdf:Description> <rdf:Description rdf:about="nir:entratainvigore-norm"> <rdf:type rdf:resource="[lkif-time_modification:Enter_in_Force_Date]" rdf:datatype="xsd:date" /> </rdf:Description> <rdf:Description rdf:about="nir:passiva"> <rdf:type rdf:resource="[lkif-expression:Modified]"/> </rdf:Description> <rdf:Description rdf:about="nir:attiva"> <rdf:type rdf:resource="[lkif-expression:Modifier]"/> </rdf:Description> <rdf:Description rdf:about="nir:evento"> <rdf:type rdf:resource="[lkif-time_modification:Application_Date]"/> </rdf:Description> <rdf:Description rdf:about="nir:evento-data"> <rdf:type rdf:resource="[lkif-time_modification:Application_Date]" rdf:datatype="xsd:date"/> </rdf:Description> <rdf:Description rdf:about="nir:intestazione"> <rdf:type rdf:resource="[lkif-expression:Preface]"/> </rdf:Description> <rdf:Description rdf:about="nir:preambolo"> <rdf:type rdf:resource="[lkif-expression:Preamble]"/> </rdf:Description> <rdf:Description rdf:about="nir:modificheattive"> <rdf:type rdf:resource="[lkif-expression:Modifier]"/> </rdf:Description> <rdf:Description rdf:about="nir:modifichepassive"> <rdf:type rdf:resource="[lkif-expression:Modified]"/> </rdf:Description> <rdf:Description rdf:about="dsp:abrogazione"> <rdf:type rdf:resource="[lkif-time_modification:Repeal]"/> </rdf:Description> <rdf:Description rdf:about="dsp:sostituzione"> <rdf:type rdf:resource="[lkif-time_modification:Substitution]"/> </rdf:Description> <rdf:Description rdf:about="dsp:integrazione"> <rdf:type rdf:resource="[lkif-time_modification:Integration]"/>


198

</rdf:Description> <rdf:Description rdf:about="nir:articolato"> <rdf:type rdf:resource="[lkif-expression:Enacting_Section]"/> </rdf:Description> <rdf:Description rdf:about="nir:titolo"> <rdf:type rdf:resource="[lkif-merology:Higher_Division]"/> </rdf:Description> <rdf:Description rdf:about="nir:capo"> <rdf:type rdf:resource="[lkif-merology:Higher_Division]"/> </rdf:Description> <rdf:Description rdf:about="nir:parte"> <rdf:type rdf:resource="[lkif-merology:Higher_Division]"/> </rdf:Description> <rdf:Description rdf:about="nir:sezione"> <rdf:type rdf:resource="[lkif-merology:Higher_Division]"/> </rdf:Description> <rdf:Description rdf:about="nir:articolo"> <rdf:type rdf:resource="[lkif-merology:Basic_Unit]"/> </rdf:Description> <rdf:Description rdf:about="nir:comma"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="nir:conclusione"> <rdf:type rdf:resource="[lkif-expression:Conclusion]"/> </rdf:Description> <rdf:Description rdf:about="nir:sottoscrivente"> <rdf:type rdf:resource="[lkif-expression:Signature]"/> </rdf:Description> <rdf:Description rdf:about="nir:novella"> <rdf:type rdf:resource="[lkif-expression:New_Text]"/> </rdf:Description> <rdf:Description rdf:about="nir:novellando"> <rdf:type rdf:resource="[lkif-expression:Old_Text]"/> </rdf:Description> </rdf:RDF>

9.6 RDF extractor compliant with GRDDL specifications <?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h="http://www.w3.org/HTML/1998/html4" xmlns:dsp="http://www.normeinrete.it/nir/disposizioni/2.0" xmlns:rdfa="http://www.w3.org/ns/rdfa/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dataview="http://www.w3.org/2003/g/data-view#" xmlns:lkif-legal_action="http://www.estrellaproject.org/lkif-core/legal_action" xmlns:lkif-time_modification="http://www.estrellaproject.org/lkif-core/time-modification" xmlns:lkif-expression="http://www.estrellaproject.org/lkif-core/expression" xmlns:lkif-merology="http://www.estrellaproject.org/lkif-core/merology"> <xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/> <xsl:template match="/"> <rdf:RDF> <rdf:Description rdf:about="http://www.metalex.org/1.0"> <dataview:namespaceTransformation rdf:resource="\\normaxml\metalex\LkifExtractor.xslt"/> </rdf:Description> <xsl:for-each select="*"> <xsl:call-template name="rdfa_extract" /> </xsl:for-each> </rdf:RDF>


199

</xsl:template> <xsl:template name="rdfa_extract"> <xsl:if test="@rel"> <rdf:Description rdf:about="{@id}"> <xsl:element name="{@rel}"> <xsl:attribute name="rdf:resource"><xsl:value-of select="@href" /></xsl:attribute> </xsl:element> </rdf:Description> </xsl:if> <xsl:if test="@rev"> <rdf:Description rdf:about="{@id}"> <xsl:element name="{@rev}"> <xsl:attribute name="rdf:resource"><xsl:value-of select="@href" /></xsl:attribute> </xsl:element> </rdf:Description> </xsl:if> <xsl:if test="@property"> <rdf:Description rdf:about="{@id}"> <xsl:element name="rdf:type"> <xsl:attribute name="rdf:resource"><xsl:value-of select="@property" /></xsl:attribute> </xsl:element> </rdf:Description> </xsl:if> <xsl:if test="@rdfa:rel"> <rdf:Description rdf:about="{@id}"> <xsl:element name="{@rdfa:rel}"> <xsl:attribute name="rdf:resource"><xsl:value-of select="@rdfa:href" /></xsl:attribute> </xsl:element> </rdf:Description> </xsl:if> <xsl:if test="@rdfa:rev"> <rdf:Description rdf:about="{@id}"> <xsl:element name="{@rdfa:rev}"> <xsl:attribute name="rdf:resource"><xsl:value-of select="@rdfa:href" /></xsl:attribute> </xsl:element> </rdf:Description> </xsl:if> <xsl:if test="@rdfa:property"> <rdf:Description rdf:about="{@id}"> <xsl:element name="rdf:type"> <xsl:attribute name="rdf:resource"><xsl:value-of select="@rdfa:property" /></xsl:attribute> </xsl:element> </rdf:Description> </xsl:if> <xsl:for-each select="*"> <xsl:call-template name="rdfa_extract" /> </xsl:for-each> </xsl:template> </xsl:stylesheet>

9.7 Samples of document Italian Saving Tax D.lgs 84/2005

9.7.1 Original document in NIR <?xml version="1.0" encoding="utf-8" standalone="no"?> <?xml-stylesheet type="text/xsl" href="../../../../DTD/norma.xsl"?> <!DOCTYPE NIR SYSTEM "../../../../DTD/nirloose.dtd"> <NIR tipo="originale" xmlns="http://www.normeinrete.it/nir/2.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h="http://www.w3.org/HTML/1998/html4"> <DecretoLegislativo id="2005_04_18_dlgs_84">


200

<meta> <descrittori> <pubblicazione tipo="GU" num="118" norm="20050523" /> <entratainvigore norm="20050523" /> <redazione id="rd1" norm="20080131" nome="CIRSFID" url="http://www.cirsfid.unibo.it" /> <urn>urn:nir:stato:decreto.legislativo:2005-04-18;84</urn> </descrittori> <inquadramento> <infodoc natura="decreto legislativo" normativa="si" funzione="regolativa" fonte="primario" /> <infomancanti> <mTipodoc>decreto legislativo</mTipodoc> <mEmanante>stato</mEmanante> </infomancanti> </inquadramento> <ciclodivita> <eventi> <evento id="e1" data="20050523" fonte="ro1" tipo="originale" /> <evento id="e2" data="20050701" fonte="ro1" /> </eventi> <relazioni> <originale id="ro1" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84" /> <attiva id="ra1" xlink:href="urn:nir:stato:legge:2003-10-31;306" /> <attiva id="ra2" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2003-06-03;2003-48-ce" /> <attiva id="ra3" xlink:href="#2005_04_18_dlgs_84" /> <attiva id="ra4" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:1977-12-19;1977-799-cee" /> <haallegato id="ran1" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a" tipo="allegatointegrante" /> <haallegato id="ran2" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.b" tipo="allegatointegrante" /> </relazioni> </ciclodivita> </meta> <intestazione><tipoDoc>LEGISLATIVE DECREE</tipoDoc>, of <dataDoc norm="20050418">18 April 2005</dataDoc>, n. <numDoc>84</numDoc> <h:br/><h:br/><titoloDoc id="titolo">Implementation of <rif id="rif6" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2003-06-03;2003-48-ce">Directive 2003/48/EC</rif> on taxation of savings income in the form of interest payments</titoloDoc></intestazione> <formulainiziale>THE PRESIDENT OF THE REPUBLIC<h:br/><h:br/><preambolo id="preambolo">Having regard to <rif id="rif7" xlink:href="urn:nir:stato:costituzione:1947-12-27;nir-s9473953#sec76">Articles 76 and 87 of the Constitution</rif>;<h:br/><h:br/>Having regard to the <mod id="mod3"><rif id="rif8" xlink:href="urn:nir:stato:legge:2003-10-31;306">Law No 306 of 31 October 2003</rif></mod>, concerning "Provisions for implementing obligations related to the italian partnership to the European Communities. Communitarian Law 2003", and in particular <rif id="rif9" xlink:href="urn:nir:stato:legge:2003-10-31;306#sec1-sub1">Article 1, paragraph 1 and 2</rif>, and <rif id="rif10" xlink:href="urn:nir:stato:legge:2003-10-31;306:allegato.a">Annex A</rif>;<h:br/><h:br/>Having regard to <mod id="mod1"><rif id="rif11" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2003-06-03;2003-48-ce">Council Directive 2003/48/EC</rif></mod> of 3 June 2003, on taxation of savings income in the form of interest payments, as well as modified by <rif id="rif1" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2004-04-26;2004-66-ce">Council Directive 2004/66/CE</rif> of 26 April 2004;<h:br/><h:br/>Having regard to <rif id="rif12" xlink:href="urn:nir:unione.europea;consiglio:decisione:2004-07-19;2004-587-ce">Council Decision 2004/587/EC</rif> of 19 July 2004, on the date of application of mentioned <rif id="rif2" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2003-06-03;2003-48-ce">Directive 2003/48/CE</rif>;<h:br/><h:br/>Having regard to <rif id="rif3" xlink:href="urn:nir:stato:decreto.legislativo:1999-07-30;300#sec23">Article 23 of the Legislative Decree n. 300</rif> of 30 July 1999;<h:br/><h:br/>Having regard to the Cabinet Deliberation, adopted in the meeting of 24 March 2005;<h:br/><h:br/>On proposal of Minister for Comunitary Policies and Minister of Economics and Finance, together with Minister of Foreing Affairs and


201

Justice;</preambolo><h:br/><h:br/>HAS ADOPTED THIS LEGISLATIVE DECREE:</formulainiziale> <articolato> <articolo id="sec1"> <num>Art. 1.</num> <rubrica>Subjects held to the communication</rubrica> <comma id="sec1-sub1"> <num>1.</num> <corpo> Banks, investment firms, Poste italiane S.p.a., security investment fund management companies, financial companies and trust companies, resident in Italy, shall comunicate to the Revenue Agency the information concerning the paid interest or the interest for which the immediate payment is secured for the immediate benefit of individuals, that are beneficial owners, resident in another Member State; for this purpose the individuals shall be considered beneficial owners of interest if they received the payment as final recipient. The above mentioned communication shall, also, be made by any other subject, also individuals, resident in the State, who, for professional or commercial purposes, pay or secure the payment of interest to individuals referred to in the first period. The same obligations shall be applied to the permanent organizations in Italy of non-residents.</corpo> </comma> <comma id="sec1-sub2"> <num>2.</num> <corpo> The subject referred to in <rif id="rif13" xlink:href="#sec1-sub1">paragraph 1</rif> shall made the communication when they operate as debtor of the debt claim producing the interest, or as operator charged by the debtor or the beneficial owner with paying interest or securing the payment of interest.</corpo> </comma> <comma id="sec1-sub3"> <num>3.</num> <alinea> The communication referred to in <rif id="rif14" xlink:href="#sec1-sub1">paragraph 1</rif> shall make, at the moment of collection, also by the entity to which interest is paid or for which interest is secured for the benefit of the beneficial owner, if resident in the State and different from: </alinea> <el id="sec1-sub3-itm1"> <num>a)</num> <corpo> a legal person;</corpo> </el> <el id="sec1-sub3-itm2"> <num>b)</num> <corpo> a subject the whose profits are taxed under the determination arrangements of business taxation;</corpo> </el> <el id="sec1-sub3-itm3"> <num>c)</num> <corpo> an undertakings for collective investment in transferable securities (UCITS) authorised in accordance with <rif id="rif15" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:1985-12-20;1985-611-cee">Council Directive 85/611/EEC</rif>, of 20 December 1985.</corpo> </el> </comma> <comma id="sec1-sub4"> <num>4.</num> <corpo> The entity referred to in <rif id="rif16" xlink:href="#sec1-sub3">paragraph 3</rif>, shall be able to choose to be treated, for the purposes of this legislative decree, as an undertakings for collective investment in transferable securities (UCITS) authorised in accordance with <rif id="rif17" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:1985-12-20;1985-611-cee">Council Directive 85/611/EEC</rif>, by means the presentation of an application to the Revenue Agency, that in case of positive reception, shall issue a certificate that become operative from the date of issue. The certificate could be revoked by the Revenue Agency or by request of the entity .With provision of the Revenue Agency Director, to be published in the Italian Republic Official Journal within sixty days of the date of entrance into force of this Decree, shall set out the terms for the certificate issue and the revocation.</corpo> </comma>


202

</articolo> <articolo id="sec2"> <num>Art. 2.</num> <rubrica>Interest payments.</rubrica> <comma id="sec2-sub1"> <num>1.</num> <alinea> For the purposes of this legislative decree, are object of communication the following interest payments: </alinea> <el id="sec2-sub1-itm1"> <num>a)</num> <corpo> interest paid or credited to an account, relating to debt claims of every kind, whether or not secured by mortgage and whether or not carrying a right to participate in the debtor's profits, and, in particular, income from government securities and income from bonds or debentures, including other proceeds incoming form such securities, bonds or debentures; penalty charges for late payments shall not be regarded as interest payments;</corpo> </el> <el id="sec2-sub1-itm2"> <num>b)</num> <corpo> interest accrued at the sale, refund or redemption of the debt claims referred to in <rif id="rif18" xlink:href="#sec2-sub1-itm1">letter a);</rif></corpo> </el> <el id="sec2-sub1-itm3"> <num>c)</num> <alinea> income deriving from interest payments either directly or through an entity referred to in <rif id="rif19" xlink:href="#sec1-sub3">Article 1, paragraph 3</rif>, also situated in another Member State, distributed by:</alinea> <en id="sec2-sub1-itm3-itm1"> <num>1)</num> <corpo> an undertakings for collective investment in transferable securities (UCITS) authorised in accordance with <rif id="rif20" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:1985-12-20;1985-611-cee">Directive 85/611/EEC</rif>,</corpo> </en> <en id="sec2-sub1-itm3-itm2"> <num>2)</num> <corpo> entities which qualify for the option to be treated as an UCITS authorised in accordance with <rif id="rif21" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:1985-12-20;1985-611-cee">Directive 85/611/EEC</rif>,</corpo> </en> <en id="sec2-sub1-itm3-itm3"> <num>3)</num> <corpo> undertakings for collective investment established outside the territory where is applicable the <rif id="rif23" xlink:href="urn:nir:stato:legge:1957-10-14;1203">Treaty establishing the European Community</rif>, in accordance with <rif id="rif22" xlink:href="urn:nir:stato:legge:1957-10-14;1203#sec299">Article 299</rif> of the same Treaty;</corpo> </en> </el> <el id="sec2-sub1-itm4"> <num>d)</num> <corpo> income realised upon the sale, refund or redemption of shares or units in the undertakings and entities referred to in <rif id="rif24" xlink:href="#sec2-sub1-itm3-itm1">number 1), 2) and 3) of letter c)</rif>, if they invest directly or indirectly, via other undertakings for collective investment or entities referred to letter c), more than 40 % of their assets in debt claims as referred to in <rif id="rif25" xlink:href="#sec2-sub1-itm1">letter a)</rif>. From 1 January 2011, the percentage of 40% shall be reduced to 25%.</corpo> </el> </comma> <comma id="sec2-sub2"> <num>2.</num> <corpo> It's also considered interest payment the payment or crediting an account, held by an entity referred to in <rif id="rif26" xlink:href="#sec1-sub3">Article 1, paragraph 3</rif>, of proceeds


203

referred to in <rif id="rif27" xlink:href="#sec2-sub1">paragraph 1</rif>, irrespective of their effective secured for the beneficial owner. <mod id="mod7"><rif id="rif94" xlink:href="#sec2-sub2">This provision</rif></mod> shall not apply, in case it's been issued the certificate referred to in <rif id="rif28" xlink:href="#sec1-sub4">Article 1, paragraph 4</rif>, to the entity to which the above mentioned proceeds are paid or credited.</corpo> </comma> <comma id="sec2-sub3"> <num>3.</num> <corpo> Shall not be considered interest payments the income referred to <mrif id="rif29">letter <rif id="rif29-1" xlink:href="#sec2-sub1-itm3">c</rif>) and <rif id="rif29-2" xlink:href="#sec2-sub1-itm4">d</rif>) of paragraph 1</mrif>, deriving from undertakings or entity situated in the territory of Member States that have been exercised the option referred to in <rif id="rif30" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2003-06-03;2003-48-ce#sec6-sub6">Article 6, paragraph 6</rif>, first period, of the <rif id="rif31" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2003-06-03;2003-48-ce">Directive 2003/48/EC</rif>, and the whose investment in debt claims referred to in paragraph 1(a) is not more than 15 % of their assets.</corpo> </comma> <comma id="sec2-sub4"> <num>4.</num> <corpo> The percentage referred to in <rif id="rif32" xlink:href="#sec2-sub1-itm4">letter d) of paragraph 1</rif>, shall be determined by reference to the rules or instruments of incorporation of undertaking for collective investment or of entities concerned or, failing which, by reference to the actual composition of the assets of the above mentioned undertakings or entities, taking care to the last statements of accounts or adopted balance-sheet.</corpo> </comma> <comma id="sec2-sub5"> <num>5.</num> <corpo> During the transitional period referred to in <rif id="rif33" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2003-06-03;2003-48-ce#sec10">Article 10 of Directive 2003/48/EC</rif>, in any case not later than 31 December 2010, shall not be considered as credit referred to in <rif id="rif34" xlink:href="#sec2-sub1-itm1">letter a) of paragraph 1</rif>, domestic and international bonds and other negotiable debt securities which have been first issued before 1 March 2001 or for which the original issuing prospectuses have been approved before that date by the competent authorities within the meaning of Council <rif id="rif35" xlink:href="urn:nir:unione.europea;consiglio:direttiva:2001-03-28;2001-34-ce">Directive 2001/34/EC</rif> of 28 March, 2001, or by the responsible authorities in third countries, provided that no further issues of such negotiable debt securities are made on or after 1 March 2002.</corpo> </comma> <comma id="sec2-sub6"> <num>6.</num> <alinea> If the subscription of securities referred to in <rif id="rif36" xlink:href="#sec2-sub5">paragraph 5</rif> has been object of a further issue from 1 May 2002, shall be considered as a debt claim referred to in <rif id="rif37" xlink:href="#sec2-sub1-itm1">letter a), paragraph 1</rif>: </alinea> <el id="sec2-sub6-itm1"> <num>a)</num> <corpo> the entiry issue, consisting of the original issue and any further issue, for the securities issued by a Government or a related entity acting as a public authority or whose role is recognised by an international treaty, as defined in the <rif id="rif38" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a">Annex A</rif>;</corpo> </el> <el id="sec2-sub6-itm2"> <num>b)</num> <corpo> the issues made in occasion of further issue of securities referred to in <rif id="rif39" xlink:href="#sec2-sub5">paragraph 5</rif>, for securities issued by any other issuer.</corpo> </el> </comma> <comma id="sec2-sub7"> <num>7.</num> <corpo> Where the subjects, obliged to communicate, have not the disposal of the informative elements necessary in order to verify the subsistence of the conditions referred to in <rif id="rif40"


204

xlink:href="#sec2-sub5">paragraph 5 and 6</rif>, the entiry issue of the security shall be considered as a debt referred to in <rif id="rif41" xlink:href="#sec2-sub1-itm1">letter a), paragraph 1</rif>.</corpo> </comma> <comma id="sec2-sub8"> <num>8.</num> <corpo> A decree of the Ministry of economics and finance shall make the amendments to <rif id="rif42" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a">Annex A</rif>, in accordance with the establishment laid down in the comunitary level.</corpo> </comma> </articolo> omissis <num>Art. 13.</num> <rubrica>Entry into force</rubrica> <comma id="sec13-sub1"> <num /> <corpo>This Legislative Decree shall enter into force on the same day of its publication in the Italian Republic Official Journal.</corpo> </comma> </articolo> </articolato> <formulafinale>This decree, in possession of the seal of the State, will be inserted in the Italian Republic Official Journal. It is obliged to observe any of it and do it observe.</formulafinale> <conclusione><dataeluogo norm="20050418" codice="Rome">Done at Rome, 18 April 2005</dataeluogo><h:br/><h:br/><sottoscrivente>CIAMPI</sottoscrivente><h:br/><h:br/><sottoscrivente>Berlusconi, Presidente del Consiglio dei Ministri</sottoscrivente><h:br/><sottoscrivente>Buttiglione, Ministro per le politiche comunitarie</sottoscrivente><h:br/><sottoscrivente>Siniscalco, Ministro dell'economia e delle finanze</sottoscrivente><h:br/><sottoscrivente>Fini, Ministro degli affari esteri</sottoscrivente><h:br/><sottoscrivente>Castelli, Ministro della giustizia</sottoscrivente><h:br/><h:br/><visto>Visto, il Guardasigilli: Castelli</visto></conclusione> <annessi> <elencoAnnessi> <h:div>Annex A (referred to in Article 2, paragraph 6, letter a) LIST OF RELATED ENTITIES</h:div> <h:div>Annex B (referred to in Article 11, paragraph 1) LIST OF INDIPENDENT OR ASSOCIATED TERITORY:</h:div> </elencoAnnessi> <annesso id="ann1-2005_04_18_dlgs_84"> <testata> <denAnnesso>Annex A (referred to in Article 2, paragraph 6, letter a) LIST OF RELATED ENTITIES</denAnnesso> </testata> <rifesterno xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a" /> </annesso> <annesso id="ann2-2005_04_18_dlgs_84"> <testata> <denAnnesso>Annex B (referred to in Article 11, paragraph 1) LIST OF INDIPENDENT OR ASSOCIATED TERITORY:</denAnnesso> </testata> <rifesterno xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.b" /> </annesso> </annessi> </DecretoLegislativo> </NIR>

9.7.2 MetaLex/CEN document translated <?xml version="1.0" encoding="utf-8"?> <root name="NIR" id="metalex_EA" tipo="originale" xmlns="metalex" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance" xs:schemaLocation="metalex


205

../../../../DTD/e_fork_four.xsd"> <container name="DecretoLegislativo" id="2005_04_18_dlgs_84" xml:lang="it"> <container name="meta" id="metalex_EGAA"> <mcontainer name="descrittori" id="metalex_EDGAA"> <mcontainer name="pubblicazione" id="metalex_EDDGAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-legal_action:Act_of_Publication]" tipo="GU" num="118" norm="20050523" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <meta id="metalex_ACDDGAA" name="pubblicazione-tipo" rdfa:about="#pubblicazione" rdfa:property="[lkif-expression:Publication_Type]" rdfa:content="GU"/> <meta id="metalex_ABDDGAA" name="pubblicazione-num" rdfa:about="#pubblicazione" rdfa:property="[lkif-expression:Publication_Number]" rdfa:content="118"/> <meta id="metalex_AADDGAA" name="pubblicazione-norm" rdfa:about="#pubblicazione" rdfa:property="[lkif-time_modification:Publication_Date]" rdfa:content="20050523"/> </mcontainer> <mcontainer name="entratainvigore" id="metalex_ECDGAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-legal_action:Act_of_Commencement]" norm="20050523" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <meta id="metalex_AACDGAA" name="entratainvigore-norm" rdfa:about="#entratainvigore" rdfa:property="[lkif-time_modification:Enter_in_Force_Date]" rdfa:content="20050523"/> </mcontainer> <meta name="redazione" id="rd1" norm="20080131" nome="CIRSFID" url="http://www.cirsfid.unibo.it"/> <meta name="urn" id="metalex_EADGAA" urn="urn:nir:stato:decreto.legislativo:2005-04-18;84" naming="Akoma Ntoso Name"/> </mcontainer> <container name="inquadramento" id="metalex_ECGAA"> <block name="infodoc" id="metalex_EBCGAA" natura="decreto legislativo" normativa="si" funzione="regolativa" fonte="primario"/> <block name="infomancanti" id="metalex_EACGAA"> <inline name="mTipodoc" id="metalex_EBACGAA">decreto legislativo</inline> <inline name="mEmanante" id="metalex_EAACGAA">stato</inline> </block> </container> <mcontainer name="ciclodivita" id="metalex_EBGAA"> <mcontainer name="eventi" id="metalex_EBBGAA"> <mcontainer name="evento" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-time_modification:Enter_in_Force_Date]" id="e1" data="20050523" fonte="ro1" tipo="originale" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <meta id="metalex_ACBBBGAA" name="evento-data" rdfa:about="" rdfa:content="20050523"/> </mcontainer> <mcontainer name="evento" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-time_modification:Application_Date]" id="e2" data="20050701" fonte="ro1" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <meta id="metalex_ABABBGAA" name="evento-data" rdfa:about="" rdfa:content="20050701"/> </mcontainer> </mcontainer> <mcontainer name="relazioni" id="metalex_EABGAA"> <meta name="originale" id="ro1" about="ro1" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"/> <meta name="attiva" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Modifier]" id="ra1" xlink:href="urn:nir:stato:legge:2003-10-31;306" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:rdfa="http://www.w3.org/ns/rdfa/"/> <meta name="attiva" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Modifier]" id="ra2" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2003-06-03;2003-48-ce" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:rdfa="http://www.w3.org/ns/rdfa/"/> <meta name="attiva" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Modifier]" id="ra3" xlink:href="#2005_04_18_dlgs_84" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:rdfa="http://www.w3.org/ns/rdfa/"/> <meta name="attiva" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Modifier]" id="ra4" xlink:href="urn:nir:consiglio.comunita.europee:direttiva:1977-12-19;1977-799-cee" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"


206

xmlns:rdfa="http://www.w3.org/ns/rdfa/"/> <meta name="haallegato" id="ran1" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a" tipo="allegatointegrante" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"/> <meta name="haallegato" id="ran2" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.b" tipo="allegatointegrante" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"/> </mcontainer> </mcontainer> </container> </container> <basic name="intestazione" id="metalex_EFAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Preface]" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <htitle name="tipoDoc" id="metalex_EFFAA"> <inline name="ndr" id="metalex_EBFFAA" num="n1" value="1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink"/> DECRETO LEGISLATIVO</htitle>18 aprile 2005, n. <inline name="numDoc" id="metalex_ECFAA">84</inline> <milestone name="h:br" id="metalex_EBFAA" xml:lang="it"/> <htitle name="titoloDoc" id="titolo" xml:lang="it">Attuazione della <citation name="rif" id="rif1" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2003-06-03;2003-48-ce" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 2003/48/CE</citation> in materia di tassazione dei redditi da risparmio sotto forma di pagamenti di interessi.</htitle> </basic> <basic name="formulainiziale" xml:lang="it">IL PRESIDENTE DELLA REPUBBLICA<milestone name="h:br" id="metalex_EGEAA" xml:lang="it"/> <milestone name="h:br" id="metalex_EFEAA" xml:lang="it"/> <basic name="preambolo" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Preamble]" id="preambolo" xml:lang="it" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <mcontainer name="inlinemeta" id="metalex_E6EEAA"> <mcontainer name="disposizioni" id="metalex_EA6EEAA" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"> <mcontainer name="modificheattive" id="metalex_EAA6EEAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Modifier]"> <gmeta name="dsp:attuadelega" id="metalex_EBAA6EEAA" implicita="no"> <meta name="dsp:pos" id="metalex_EBBAA6EEAA" xlink:href="#preambolo" xlink:type="simple"/> <gmeta name="dsp:norma" id="metalex_EABAA6EEAA" xlink:href="urn:nir:stato:legge:2003-10-31;306" xlink:type="simple"> <meta name="dsp:pos" id="metalex_EAABAA6EEAA" xlink:href="#rif3" xlink:type="simple"/> </gmeta> </gmeta> <gmeta name="dsp:attua" id="metalex_EAAA6EEAA" implicita="no"> <meta name="dsp:pos" id="metalex_EBAAA6EEAA" xlink:href="#preambolo" xlink:type="simple"/> <gmeta name="dsp:norma" id="metalex_EAAAA6EEAA" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2003-06-03;2003-48-ce" xlink:type="simple"> <meta name="dsp:pos" id="metalex_EAAAAA6EEAA" xlink:href="#rif5" xlink:type="simple"/> </gmeta> </gmeta> </mcontainer> </mcontainer> </mcontainer>Visti gli <citation name="mrif" id="rif2" xml:lang="it">articoli <citation name="rif" id="rif2-1" xlink:href="urn:nir:stato:costituzione:1947-12-27;nir-s9473953#art76" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">76</citation> e <citation name="rif" id="rif2-2" xlink:href="urn:nir:stato:costituzione:1947-12-27;nir-s9473953#art87" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">87</citation> della Costituzione</citation>;<milestone name="h:br" id="metalex_E2EEAA" xml:lang="it"/>Vista la <basic name="mod" id="mod2" xml:lang="it">


207

<citation name="rif" id="rif3" xlink:href="urn:nir:stato:legge:2003-10-31;306" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">legge 31 ottobre 2003, n. 306</citation> </basic>, recante "Disposizioni per l'adempimento degli obblighi derivanti dall'appartenenza dell'Italia alle Comunità europee. Legge comunitaria 2003", ed in particolare l'<citation name="mrif" id="rif4" xml:lang="it">articolo 1, commi <citation name="rif" id="rif4-1" xlink:href="urn:nir:stato:legge:2003-10-31;306#art1-com1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">1</citation> e <citation name="rif" id="rif4-2" xlink:href="urn:nir:stato:legge:2003-10-31;306#art1-com2" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">2</citation> </citation>, e l'<citation name="rif" id="rif94" xlink:href="urn:nir:stato:legge:2003-10-31;306:allegato.a" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">allegato A</citation>;<milestone name="h:br" id="metalex_ETEEAA" xml:lang="it"/>Vista la <basic name="mod" id="mod4" xml:lang="it"> <citation name="rif" id="rif5" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2003-06-03;2003-48-ce" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 2003/48/CE del Consiglio, del 3 giugno 2003</citation> </basic>, in materia di tassazione dei redditi da risparmio sotto forma di pagamenti di interessi, così come modificata dalla <citation name="rif" id="rif6" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2004-04-26;2004-66-ce" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 2004/66/CE del Consiglio, del 26 aprile 2004</citation>;<milestone name="h:br" id="metalex_ENEEAA" xml:lang="it"/>Vista la <citation name="rif" id="rif7" xlink:href="urn:nir:comunita.europea;consiglio:decisione:2004-07-19;2004-587-ce" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">decisione 2004/587/CE del Consiglio, del 19 luglio 2004</citation>, relativa alla data di applicazione della citata <citation name="rif" id="rif8" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2003-06-03;2003-48-ce" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 2003/48/CE</citation>; <milestone name="h:br" id="metalex_EHEEAA" xml:lang="it"/>Visto l'<citation name="rif" id="rif9" xlink:href="urn:nir:stato:decreto.legislativo:1999-07-30;300#art23" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">articolo 23 del decreto legislativo 30 luglio 1999, n. 300</citation>; <milestone name="h:br" id="metalex_EDEEAA" xml:lang="it"/>Vista la deliberazione del Consiglio dei Ministri, adottata nella riunione del 24 marzo 2005;<milestone name="h:br" id="metalex_EBEEAA" xml:lang="it"/>Sulla proposta del Ministro per le politiche comunitarie e del Ministro dell'economia e delle finanze, di concerto con i Ministri degli affari esteri e della giustizia;</basic> <milestone name="h:br" id="metalex_EDEAA" xml:lang="it"/>EMANA<milestone name="h:br" id="metalex_EBEAA" xml:lang="it"/>il seguente decreto legislativo:</basic> <basic name="articolato" id="metalex_EDAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Enacting_Section]" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <hcontainer name="articolo" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Basic_Unit]" id="art1" xml:lang="it"> <htitle name="num" id="metalex_EFMDAA">Art. 1.<inline name="ndr" id="metalex_EAFMDAA" num="n2" value="2" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink"/> </htitle> <htitle name="rubrica" id="metalex_EEMDAA" xml:lang="it">Soggetti tenuti alle comunicazioni</htitle> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art1-com1" xml:lang="it"> <htitle name="num" id="metalex_EBDMDAA">1.</htitle> <basic name="corpo" id="metalex_EADMDAA"> Le banche, le società di intermediazione mobiliare, le Poste italiane S.p.a., le società di gestione del risparmio, le società finanziarie e le società fiduciarie, residenti nel territorio dello Stato, comunicano all'Agenzia delle entrate le informazioni relative agli interessi pagati o il cui pagamento e attribuito direttamente a persone fisiche residenti in un altro Stato membro, che ne siano beneficiarie effettive; a tale fine le persone fisiche sono considerate beneficiarie effettive degli interessi se ricevono i pagamenti in qualità di beneficiario finale. Le suddette comunicazioni sono, altresì, effettuate da ogni altro soggetto, anche persona fisica, residente nel territorio dello Stato, che per ragioni professionali o commerciali paga o attribuisce il pagamento di interessi alle persone fisiche indicate nel primo periodo. Gli stessi obblighi si applicano alle stabili organizzazioni in Italia di soggetti non residenti.</basic> </hcontainer>


208

<hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art1-com2" xml:lang="it"> <htitle name="num" id="metalex_EBCMDAA">2.</htitle> <basic name="corpo" id="metalex_EACMDAA"> I soggetti di cui al <citation name="rif" id="rif10" xlink:href="#art1-com1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">comma 1</citation> effettuano le comunicazioni quando agiscono sia come debitori del credito che produce gli interessi, sia come incaricati dal debitore o dal beneficiario effettivo di pagare o di attribuire il pagamento di interessi.</basic> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art1-com3" xml:lang="it"> <htitle name="num" id="metalex_EEBMDAA">3.</htitle> <basic name="alinea" id="metalex_EDBMDAA"> Le comunicazioni di cui al <citation name="rif" id="rif11" xlink:href="#art1-com1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">comma 1</citation> sono effettuate, all'atto della riscossione, anche dalle entità alle quali sono pagati o è attribuito un pagamento di interessi a vantaggio del beneficiario effettivo, se residenti nel territorio dello Stato e diverse da:</basic> <hcontainer name="el" id="art1-com3-let1" xml:lang="it"> <htitle name="num" id="metalex_EBCBMDAA">a)</htitle> <basic name="corpo" id="metalex_EACBMDAA"> una persona giuridica;</basic> </hcontainer> <hcontainer name="el" id="art1-com3-let2" xml:lang="it"> <htitle name="num" id="metalex_EBBBMDAA">b)</htitle> <basic name="corpo" id="metalex_EABBMDAA"> un soggetto i cui redditi sono tassati secondo i criteri di determinazione del reddito di impresa;</basic> </hcontainer> <hcontainer name="el" id="art1-com3-let3" xml:lang="it"> <htitle name="num" id="metalex_EBABMDAA">c)</htitle> <basic name="corpo" id="metalex_EAABMDAA"> un organismo di investimento collettivo in valori mobiliari autorizzato ai sensi della <citation name="rif" id="rif12" xlink:href="urn:nir:consiglio.comunita.europee:direttiva:1985-12-20;1985-611-cee" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 85/611/CEE del Consiglio, del 20 dicembre 1985</citation>.</basic> </hcontainer> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art1-com4" xml:lang="it"> <htitle name="num" id="metalex_EBAMDAA">4.</htitle> <basic name="corpo" id="metalex_EAAMDAA"> Le entità di cui al <citation name="rif" id="rif13" xlink:href="#art1-com3" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">comma 3</citation> possono scegliere di essere trattate, ai fini del presente decreto legislativo, come un organismo di investimento collettivo in valori mobiliari autorizzato ai sensi della citata <citation name="rif" id="rif14" xlink:href="urn:nir:consiglio.comunita.europee:direttiva:1985-12-20;1985-611-cee" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 85/611/CEE</citation>, mediante presentazione di un'istanza all'Agenzia delle entrate, che, in caso di accoglimento, rilascerà un certificato produttivo di effetti dalla data di rilascio. Il certificato può essere revocato dall'Agenzia delle entrate o a richiesta dell'entità. Con provvedimento del Direttore dell'Agenzia delle entrate, da pubblicare nella Gazzetta Ufficiale della Repubblica italiana entro sessanta giorni dalla data di entrata in vigore del presente decreto, sono stabilite le modalità per il rilascio e la revoca del certificato.</basic> </hcontainer> </hcontainer> <hcontainer name="articolo" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Basic_Unit]" id="art2" xml:lang="it"> <mcontainer name="inlinemeta" id="metalex_EKLDAA"> <mcontainer name="disposizioni" id="metalex_EAKLDAA" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"> <mcontainer name="modificheattive" id="metalex_EAAKLDAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Modifier]"> <gmeta name="dsp:deroga" id="metalex_EAAAKLDAA" implicita="no"> <meta name="dsp:pos" id="metalex_ECAAAKLDAA" xlink:href="#art2-com2"


209

xlink:type="simple"/> <gmeta name="dsp:norma" id="metalex_EBAAAKLDAA" xlink:href="#2005_04_18_dlgs_84" xlink:type="simple"> <meta name="dsp:pos" id="metalex_EBBAAAKLDAA" xlink:href="#rif101" xlink:type="simple"/> </gmeta> <gmeta name="dsp:dominio" id="metalex_EAAAAKLDAA">La presente disposizione non si applica, qualora sia stato rilasciato il certificato di cui all'articolo 1, comma 4, all'entità cui sono pagati o accreditati i predetti proventi.</gmeta> </gmeta> </mcontainer> </mcontainer> </mcontainer> <htitle name="num" id="metalex_EJLDAA">Art. 2.<inline name="ndr" id="metalex_EAJLDAA" num="n3" value="3" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink"/> </htitle> <htitle name="rubrica" id="metalex_EILDAA" xml:lang="it">Pagamenti di interessi</htitle> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com1" xml:lang="it"> <htitle name="num" id="metalex_EFHLDAA">1.</htitle> <basic name="alinea" id="metalex_EEHLDAA"> Ai fini del presente decreto legislativo, costituiscono oggetto di comunicazione i seguenti pagamenti di interessi:</basic> <hcontainer name="el" id="art2-com1-let1" xml:lang="it"> <htitle name="num" id="metalex_EBDHLDAA">a)</htitle> <basic name="corpo" id="metalex_EADHLDAA"> gli interessi pagati o accreditati su un conto, relativi a crediti di qualsivoglia natura, assistiti o meno da garanzie ipotecarie e corredati o meno di una clausola di partecipazione agli utili del debitore, in particolare quelli derivanti da titoli di debito pubblico e quelli prodotti da obbligazioni, compresi gli altri proventi derivanti dai suddetti titoli o obbligazioni; gli interessi moratori non costituiscono pagamenti di interessi;</basic> </hcontainer> <hcontainer name="el" id="art2-com1-let2" xml:lang="it"> <htitle name="num" id="metalex_EBCHLDAA">b)</htitle> <basic name="corpo" id="metalex_EACHLDAA"> gli interessi maturati alla cessione, al rimborso o al riscatto dei crediti di cui alla <citation name="rif" id="rif15" xlink:href="#art2-com1-let1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettera a)</citation>;</basic> </hcontainer> <hcontainer name="el" id="art2-com1-let3" xml:lang="it"> <htitle name="num" id="metalex_EEBHLDAA">c)</htitle> <basic name="alinea" id="metalex_EDBHLDAA"> i redditi derivanti da pagamenti di interessi, direttamente o tramite un'entità di cui all'<citation name="rif" id="rif16" xlink:href="#art1-com3" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">articolo 1, comma 3</citation>, anche situata in un altro Stato membro, distribuiti da:</basic> <hcontainer name="en" id="art2-com1-let3-num1" xml:lang="it"> <htitle name="num" id="metalex_EBCBHLDAA">1)</htitle> <basic name="corpo" id="metalex_EACBHLDAA"> organismi di investimento collettivo in valori mobiliari autorizzati ai sensi della <citation name="rif" id="rif17" xlink:href="urn:nir:consiglio.comunita.europee:direttiva:1985-12-20;1985-611-cee" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 85/611/CEE</citation>;</basic> </hcontainer> <hcontainer name="en" id="art2-com1-let3-num2" xml:lang="it"> <htitle name="num" id="metalex_EBBBHLDAA">2)</htitle> <basic name="corpo" id="metalex_EABBHLDAA"> entità che beneficiano dell'opzione per essere trattate come un organismo di investimento collettivo in valori mobiliari autorizzato ai sensi della <citation name="rif" id="rif18" xlink:href="urn:nir:consiglio.comunita.europee:direttiva:1985-12-20;1985-611-cee" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 85/611/CEE</citation>;</basic> </hcontainer> <hcontainer name="en" id="art2-com1-let3-num3" xml:lang="it"> <htitle name="num" id="metalex_EBABHLDAA">3)</htitle>


210

<basic name="corpo" id="metalex_EAABHLDAA"> organismi di investimento collettivo stabiliti al di fuori del territorio in cui si applica il <citation name="rif" id="rif95" xlink:href="urn:nir:stato:legge:1992-11-03;454:trattato" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">Trattato dell'Unione europea</citation>, in conformità all'<citation name="rif" id="rif19" xlink:href="urn:nir:stato:legge:1992-11-03;454:trattato#art299" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">articolo 299 del Trattato</citation> medesimo;</basic> </hcontainer> </hcontainer> <hcontainer name="el" id="art2-com1-let4" xml:lang="it"> <htitle name="num" id="metalex_EBAHLDAA">d)</htitle> <basic name="corpo" id="metalex_EAAHLDAA"> i redditi realizzati alla cessione, al rimborso o al riscatto di partecipazioni o quote negli organismi ed entità indicati ai <citation name="rif" id="rif20" xlink:href="#art2-com1-let3-num1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">numeri 1), 2) e 3) della lettera c)</citation>, se questi investono direttamente o indirettamente, tramite altri organismi di investimento collettivo o entità di cui alla <citation name="rif" id="rif21" xlink:href="#art2-com1-let3" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettera c)</citation>, oltre il 40 per cento del loro attivo in crediti di cui alla <citation name="rif" id="rif22" xlink:href="#art2-com1-let1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettera a)</citation>. A decorrere dal 1° gennaio 2011 la percentuale del 40 per cento è ridotta al 25 per cento.</basic> </hcontainer> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com2" xml:lang="it"> <htitle name="num" id="metalex_EBGLDAA">2.</htitle> <basic name="corpo" id="metalex_EAGLDAA"> È altresì considerato pagamento di interessi il pagamento o l'accredito su un conto intestato ad un entità di cui all'<citation name="rif" id="rif23" xlink:href="#art1-com3" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">articolo 1, comma 3</citation>, dei proventi di cui al <citation name="rif" id="rif24" xlink:href="#art2-com1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">comma 1</citation>, a prescindere dall'effettiva attribuzione degli stessi al beneficiario effettivo. Tale <basic name="mod" id="mod1" xml:lang="it"> <citation name="rif" id="rif101" xlink:href="#art1-com3" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">disposizione</citation> </basic> non si applica, qualora sia stato rilasciato il certificato di cui all'<citation name="rif" id="rif25" xlink:href="#art1-com4" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">articolo 1, comma 4</citation>, all'entità cui sono pagati o accreditati i predetti proventi.</basic> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com3" xml:lang="it"> <htitle name="num" id="metalex_EBFLDAA">3.</htitle> <basic name="corpo" id="metalex_EAFLDAA"> Non sono, tuttavia, considerati pagamenti di interessi i redditi di cui alle <citation name="rif" id="rif26" xlink:href="#art2-com2-let3" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettere c) e d) del comma 1</citation>, derivanti da organismi ed entità situati nel territorio di quegli Stati membri che abbiano esercitato l'opzione di cui all'<citation name="rif" id="rif28" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2003-06-03;2003-48-ce#art6-com6" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">articolo 6, paragrafo 6, primo periodo, della direttiva 2003/48/CE</citation>, ed il cui investimento nei crediti di cui al <citation name="rif" id="rif29" xlink:href="#art2-com1-let1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">comma 1, lettera a)</citation>, non sia stato superiore al 15 per cento del loro attivo.</basic> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com4" xml:lang="it"> <htitle name="num" id="metalex_EBELDAA">4.</htitle> <basic name="corpo" id="metalex_EAELDAA"> La percentuale di cui alla <citation name="rif" id="rif30" xlink:href="#art2-com1-let4" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettera d) del comma 1</citation>, è determinata in base al regolamento o ai documenti costitutivi degli organismi di investimento collettivo in valori mobiliari


211

o delle entità interessate ovvero, in mancanza di tale riferimento, in base all'effettiva composizione dell'attivo dei suddetti organismi o entità, avendo riguardo all'ultimo rendiconto o bilancio di esercizio approvato.</basic> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com5" xml:lang="it"> <htitle name="num" id="metalex_EBDLDAA">5.</htitle> <basic name="corpo" id="metalex_EADLDAA"> Durante il periodo transitorio di cui all'<citation name="rif" id="rif31" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2003-06-03;2003-48-ce#art10" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">articolo 10 della direttiva 2003/48/CE</citation>, e comunque non oltre il 31 dicembre 2010, non sono ricompresi tra i crediti di cui alla <citation name="rif" id="rif32" xlink:href="#art2-com1-let1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettera a) del comma 1</citation>, le obbligazioni nazionali e internazionali e gli altri titoli di credito negoziabili che siano stati emessi per la prima volta anteriormente al 1° marzo 2001 o il cui prospetto originario delle condizioni di emissione sia stato approvato prima di tale data dalle autorità competenti, ai sensi della <citation name="rif" id="rif33" xlink:href="urn:nir:comunita.europea;consiglio:direttiva:2001-05-28;2001-34-ce" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">direttiva 2001/34/CE del Consiglio, del 28 maggio 2001</citation>, o dalle autorità responsabili di Stati terzi, a condizione che la sottoscrizione di tali titoli non abbia costituito oggetto di riapertura a decorrere dal 1° marzo 2002.</basic> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com6" xml:lang="it"> <htitle name="num" id="metalex_EDCLDAA">6.</htitle> <basic name="alinea" id="metalex_ECCLDAA"> Qualora la sottoscrizione dei titoli di cui al <citation name="rif" id="rif34" xlink:href="#art2-com5" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">comma 5</citation> abbia costituito oggetto di riapertura a decorrere dal 1° marzo 2002, rientrano tra i crediti di cui alla <citation name="rif" id="rif35" xlink:href="#art2-com1-let1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettera a) del comma 1</citation>:</basic> <hcontainer name="el" id="art2-com6-let1" xml:lang="it"> <htitle name="num" id="metalex_EBBCLDAA">a)</htitle> <basic name="corpo" id="metalex_EABCLDAA"> l'intera emissione, costituita dalla prima emissione e da quelle successive, per i titoli emessi da Governi o dagli enti collegati, che agiscono in qualità di autorità pubblica o il cui ruolo è riconosciuto da un trattato internazionale, indicati nell'<citation name="rif" id="rif99" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">allegato A</citation>;</basic> </hcontainer> <hcontainer name="el" id="art2-com6-let2" xml:lang="it"> <htitle name="num" id="metalex_EBACLDAA">b)</htitle> <basic name="corpo" id="metalex_EAACLDAA"> le emissioni effettuate in occasione della riapertura di emissione dei titoli di cui al <citation name="rif" id="rif36" xlink:href="#art2-com5" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">comma 5</citation> per i titoli emessi da qualsiasi altro emittente.</basic> </hcontainer> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com7" xml:lang="it"> <htitle name="num" id="metalex_EBBLDAA">7.</htitle> <basic name="corpo" id="metalex_EABLDAA"> Qualora i soggetti tenuti alle comunicazioni non siano in possesso degli elementi informativi necessari per verificare la sussistenza delle condizioni previste dai <citation name="rif" id="rif37" xlink:href="#art2-com5" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">commi 5 e 6</citation>, l'intera emissione del titolo è considerata un credito di cui alla <citation name="rif" id="rif38" xlink:href="#art2-com1-let1" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">lettera a) del comma 1</citation>.</basic> </hcontainer> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art2-com8" xml:lang="it"> <htitle name="num" id="metalex_EBALDAA">8.</htitle>


212

<basic name="corpo" id="metalex_EAALDAA"> Con decreto del Ministro dell'economia e delle finanze sono apportate modifiche all'<citation name="rif" id="rif100" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a" xlink:type="simple" xml:lang="it" xmlns:xlink="http://www.w3.org/1999/xlink">allegato A</citation>, conformemente a quanto stabilito in sede comunitaria.</basic> </hcontainer> </hcontainer> omissis <hcontainer name="articolo" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Basic_Unit]" id="art13" xml:lang="it"> <htitle name="num" id="metalex_ECADAA">Art. 13.</htitle> <htitle name="rubrica" id="metalex_EBADAA" xml:lang="it">Entrata in vigore</htitle> <hcontainer name="comma" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-merology:Sub_Division]" id="art13-com1" xml:lang="it"> <htitle name="num" id="metalex_EBAADAA">1.</htitle> <basic name="corpo" id="metalex_EAAADAA"> Il presente decreto entra in vigore il giorno stesso della sua pubblicazione nella Gazzetta Ufficiale della Repubblica italiana.</basic> </hcontainer> </hcontainer> </basic> <basic name="formulafinale" xml:lang="it">Il presente decreto, munito del sigillo dello Stato, sarà inserito nella Raccolta ufficiale degli atti normativi della Repubblica italiana. È fatto obbligo a chiunque spetti di osservarlo e di farlo osservare.</basic> <basic name="conclusione" id="metalex_EBAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Conclusion]" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <inline name="dataeluogo" id="metalex_EQBAA" norm="20050418" codice="roma">Dato a Roma, addì 18 aprile 2005</inline> <milestone name="h:br" id="metalex_EPBAA" xml:lang="it"/> <milestone name="h:br" id="metalex_EOBAA" xml:lang="it"/> <basic name="sottoscrivente" id="metalex_ENBAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Signature]">CIAMPI</basic> <milestone name="h:br" id="metalex_EMBAA" xml:lang="it"/> <milestone name="h:br" id="metalex_ELBAA" xml:lang="it"/> <basic name="sottoscrivente" id="metalex_EKBAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Signature]">Berlusconi, Presidente del Consiglio dei Ministri</basic> <milestone name="h:br" id="metalex_EJBAA" xml:lang="it"/> <basic name="sottoscrivente" id="metalex_EIBAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Signature]">Buttiglione, Ministro per le politiche comunitarie</basic> <milestone name="h:br" id="metalex_EHBAA" xml:lang="it"/> <basic name="sottoscrivente" id="metalex_EGBAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Signature]">Siniscalco, Ministro del-l'economia e delle finanze</basic> <milestone name="h:br" id="metalex_EFBAA" xml:lang="it"/> <basic name="sottoscrivente" id="metalex_EEBAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Signature]">Fini, Ministro degli affari esteri</basic> <milestone name="h:br" id="metalex_EDBAA" xml:lang="it"/> <basic name="sottoscrivente" id="metalex_ECBAA" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-expression:Signature]">Castelli, Ministro della giustizia</basic> <milestone name="h:br" id="metalex_EBBAA" xml:lang="it"/> <basic name="visto" id="metalex_EABAA">Visto, il Guardasigilli: Castelli</basic> </basic> <container name="annessi" id="metalex_EAAA"> <container name="elencoAnnessi" id="metalex_ECAAA"> <basic name="h:div" id="metalex_EBCAAA" xml:lang="it">Allegato A (previsto dall'art. 2, comma 6, lettera a) ELENCO DEGLI ENTI COLLEGATI</basic> <basic name="h:div" id="metalex_EACAAA" xml:lang="it">Allegato B (previsto dall'art. 11, comma 1) ELENCO DEI TERRITORI DIPENDENTI O ASSOCIATI</basic> </container> <basic name="annesso" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Dependent_Annex]" id="ann1-2005_04_18_dlgs_84" xml:lang="it" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <block name="testata" id="metalex_EBBAAA"> <basic name="denAnnesso" id="metalex_EABBAAA">Allegato A (previsto dall'art. 2, comma 6,


213

lettera a) ELENCO DEGLI ENTI COLLEGATI</basic> </block> <citation name="rifesterno" id="metalex_EABAAA" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.a" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"/> </basic> <basic name="annesso" rdfa:about="" rdfa:rel="rdf:type" rdfa:href="[lkif-espression:Dependent_Annex]" id="ann2-2005_04_18_dlgs_84" xml:lang="it" xmlns:rdfa="http://www.w3.org/ns/rdfa/"> <block name="testata" id="metalex_EBAAAA"> <basic name="denAnnesso" id="metalex_EABAAAA">Allegato B (previsto dall'art. 11, comma 1) ELENCO DEI TERRITORI DIPENDENTI O ASSOCIATI</basic> </block> <citation name="rifesterno" id="metalex_EAAAAA" xlink:href="urn:nir:stato:decreto.legislativo:2005-04-18;84:allegato.b" xlink:type="simple" xmlns:xlink="http://www.w3.org/1999/xlink"/> </basic> </container> </container> </root>

9.7.3 RDF Extraction <?xml version="1.0" encoding="UTF-8"?> <rdf:RDF xmlns:dataview="http://www.w3.org/2003/g/data-view#" xmlns:dsp="http://www.normeinrete.it/nir/disposizioni/2.0" xmlns:h="http://www.w3.org/HTML/1998/html4" xmlns:lkif-expression="http://www.estrellaproject.org/lkif-core/expression" xmlns:lkif-legal_action="http://www.estrellaproject.org/lkif-core/legal_action" xmlns:lkif-merology="http://www.estrellaproject.org/lkif-core/merology" xmlns:lkif-time_modification="http://www.estrellaproject.org/lkif-core/time-modification" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfa="http://www.w3.org/ns/rdfa/" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xs="http://www.w3.org/2001/XMLSchema"> <rdf:Description rdf:about="http://www.metalex.org/1.0"> <dataview:namespaceTransformation rdf:resource="\\normaxml\metalex\LkifExtractor.xslt"/> </rdf:Description> <rdf:Description rdf:about="metalex_EDDGAA"> <rdf:type rdf:resource="[lkif-legal_action:Act_of_Publication]"/> </rdf:Description> <rdf:Description rdf:about="metalex_ACDDGAA"> <rdf:type rdf:resource="[lkif-expression:Publication_Type]"/> </rdf:Description> <rdf:Description rdf:about="metalex_ABDDGAA"> <rdf:type rdf:resource="[lkif-expression:Publication_Number]"/> </rdf:Description> <rdf:Description rdf:about="metalex_AADDGAA"> <rdf:type rdf:resource="[lkif-time_modification:Publication_Date]"/> </rdf:Description> <rdf:Description rdf:about="metalex_ECDGAA"> <rdf:type rdf:resource="[lkif-legal_action:Act_of_Commencement]"/> </rdf:Description> <rdf:Description rdf:about="metalex_AACDGAA"> <rdf:type rdf:resource="[lkif-time_modification:Enter_in_Force_Date]"/> </rdf:Description> <rdf:Description rdf:about="e1"> <rdf:type rdf:resource="[lkif-time_modification:Enter_in_Force_Date]"/> </rdf:Description> <rdf:Description rdf:about="e2"> <rdf:type rdf:resource="[lkif-time_modification:Application_Date]"/> </rdf:Description> <rdf:Description rdf:about="ra1"> <rdf:type rdf:resource="[lkif-espression:Modifier]"/>


214

</rdf:Description> <rdf:Description rdf:about="ra2"> <rdf:type rdf:resource="[lkif-espression:Modifier]"/> </rdf:Description> <rdf:Description rdf:about="ra3"> <rdf:type rdf:resource="[lkif-espression:Modifier]"/> </rdf:Description> <rdf:Description rdf:about="ra4"> <rdf:type rdf:resource="[lkif-espression:Modifier]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EFAA"> <rdf:type rdf:resource="[lkif-espression:Preface]"/> </rdf:Description> <rdf:Description rdf:about="preambolo"> <rdf:type rdf:resource="[lkif-espression:Preamble]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EAA6EEAA"> <rdf:type rdf:resource="[lkif-expression:Modifier]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EDAA"> <rdf:type rdf:resource="[lkif-espression:Enacting_Section]"/> </rdf:Description> <rdf:Description rdf:about="art1"> <rdf:type rdf:resource="[lkif-merology:Basic_Unit]"/> </rdf:Description> <rdf:Description rdf:about="art1-com1"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art1-com2"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art1-com3"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art1-com4"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2"> <rdf:type rdf:resource="[lkif-merology:Basic_Unit]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EAAKLDAA"> <rdf:type rdf:resource="[lkif-expression:Modifier]"/> </rdf:Description> <rdf:Description rdf:about="art2-com1"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2-com2"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2-com3"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2-com4"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2-com5"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2-com6"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2-com7">


215

<rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="art2-com8"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> omissis <rdf:Description rdf:about="art13"> <rdf:type rdf:resource="[lkif-merology:Basic_Unit]"/> </rdf:Description> <rdf:Description rdf:about="art13-com1"> <rdf:type rdf:resource="[lkif-merology:Sub_Division]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EBAA"> <rdf:type rdf:resource="[lkif-expression:Conclusion]"/> </rdf:Description> <rdf:Description rdf:about="metalex_ENBAA"> <rdf:type rdf:resource="[lkif-expression:Signature]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EKBAA"> <rdf:type rdf:resource="[lkif-expression:Signature]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EIBAA"> <rdf:type rdf:resource="[lkif-expression:Signature]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EGBAA"> <rdf:type rdf:resource="[lkif-expression:Signature]"/> </rdf:Description> <rdf:Description rdf:about="metalex_EEBAA"> <rdf:type rdf:resource="[lkif-expression:Signature]"/> </rdf:Description> <rdf:Description rdf:about="metalex_ECBAA"> <rdf:type rdf:resource="[lkif-expression:Signature]"/> </rdf:Description> <rdf:Description rdf:about="ann1-2005_04_18_dlgs_84"> <rdf:type rdf:resource="[lkif-espression:Dependent_Annex]"/> </rdf:Description> <rdf:Description rdf:about="ann2-2005_04_18_dlgs_84"> <rdf:type rdf:resource="[lkif-espression:Dependent_Annex]"/> </rdf:Description> </rdf:RDF>


216

9.7.4 Back to NIR from MetaLex/CEN

deliverable n°: d3.3 (extended) tools for translating

Documents