Make use of new auto-linking in lv2specgen.py.

6 files changed, 54 insertions, 66 deletions

diff --git a/ext/atom.lv2/atom-helpers.h b/ext/atom.lv2/atom-helpers.h
index 0a19d25..4e51c89 100644
--- a/ext/atom.lv2/atom-helpers.h
+++ b/ext/atom.lv2/atom-helpers.h
@@ -75,7 +75,7 @@ lv2_thing_iter_get(LV2_Thing_Iter iter)
 
 /**
    A macro for iterating over all properties of an Thing.
-   @param obj  The thing to iterate over
+   @param thing The thing to iterate over
    @param iter The name of the iterator
 
    This macro is used similarly to a for loop (which it expands to), e.g.:
diff --git a/ext/atom.lv2/atom.ttl b/ext/atom.lv2/atom.ttl
index 547d6d5..ce125d6 100644
--- a/ext/atom.lv2/atom.ttl
+++ b/ext/atom.lv2/atom.ttl
@@ -38,7 +38,7 @@
 	] ;
 	lv2:documentation """
 <p>This extension defines a generic format for a typed piece of data, called an
-"<a href="#Atom">Atom</a>" (e.g. integers, strings, buffers, data structures,
+lv2:Atom (e.g. integers, strings, buffers, data structures,
 etc).  Atoms allow LV2 plugins and hosts to communicate, process, serialise,
 and store values of any type via a generic mechanism (e.g. LV2 ports, events,
 disk, shared memory, network).  Atoms are, with one exception, Plain
@@ -60,12 +60,12 @@ implementations to be polymorphic and extensible.</p>
 <p>Atoms (the start of the LV2_Atom header) MUST be 32-bit aligned.</p>
 
 <p>Atoms can be communicated in many ways.  Since an Atom is the payload of an
-Event, an <a href="http://lv2plug.in/ns/ext/event#EventPort">EventPort</a>
-can be used for communicating Atoms in realtime with sub-sample time stamp
+Event, an <a href="http://lv2plug.in/ns/ext/event#EventPort">EventPort</a> can
+be used for communicating Atoms in realtime with sub-sample time stamp
 accuracy.  This extension also defines two port types for connecting directly
-to a single Atom: <a href="#ValuePort">ValuePort</a> and <a href="#MessagePort"
->MessagePort</a>, which both have the same buffer format but different
-semantics (with respect to how the run() callback interprets the Atom).</p>
+to a single Atom: atom:ValuePort and atom:MessagePort, which both have the same
+buffer format but different semantics (with respect to how the run() callback
+interprets the Atom).</p>
 
 <p>Implementing this extension requires a facility for mapping URIs to
 integers, such as the <a href="http://lv2plug.in/ns/ext/urid">LV2 URID</a>
@@ -122,8 +122,8 @@ atom:Literal
 <p>A UTF-8 encoded string literal, with an optional language tag or datatype.</p>
 
 <p>This type is compatible with an RDF literal and is capable of expressing a
-string in any language, or a value of any type.  An LV2_Atom_Literal has an <a
-href="#ID">ID</a> <code>lang</code> and <code>datatype</code> followed by the
+string in any language, or a value of any type.  An LV2_Atom_Literal has a
+URID <code>lang</code> and <code>datatype</code> followed by the
 string data in UTF-8 encoding.  The length of the string data in bytes is
 <code>size - (2 * sizeof(uint32_t))</code>, including the terminating NULL
 character.  The <code>lang</code> field SHOULD be a URI of the form
@@ -193,9 +193,9 @@ atom:Vector
 
 <p>An LV2_Atom_Vector is a 16-bit <code>elem_count</code> and
 <code>elem_type</code> followed by <code>elem_count</code> atom bodies of type
-<code>elem_type</code>.  The element type must be a fixed size <a
-href="#Atom">Atom</a> type, i.e. the size of each element is the vector's
-<code>size / elem_count</code>.</p>
+<code>elem_type</code>.  The element type must be a fixed size atom:Atom type,
+i.e. the size of each element is the vector's <code>size /
+elem_count</code>.</p>
 
 <p>For example, an atom:Vector containing 42 elements of type atom:Float looks
 like this in memory:</p>
@@ -227,7 +227,7 @@ atom:Tuple
 	rdfs:subClassOf atom:Atom ;
 	rdfs:label "Tuple" ;
 	lv2:documentation """
-<p>A sequence of <a href="#Atom">atoms</a> with varying <code>type</code>
+<p>A sequence of lv2:Atom with varying <code>type</code>
 and <code>size</code>.</p>
 
 <p>The body of a Tuple is simply a sequence of complete atoms, each aligned to
@@ -239,9 +239,9 @@ atom:Property
 	rdfs:subClassOf atom:Atom ;
 	rdfs:label "Property of a Thing" ;
 	lv2:documentation """
-A single property of some <a href="#Object">Object</a>.  An
-LV2_Atom_Property has an <a href="#URID">URID</a> <code>key</code> and
-<a href="#Atom">Atom</a> <code>value</code>.
+A single property of some lv2:Thing.  An
+LV2_Atom_Property has an atom:URID <code>key</code> and an atom:Atom
+<code>value</code>.
 """ .
 
 atom:Thing
@@ -249,7 +249,7 @@ atom:Thing
 	rdfs:subClassOf atom:Atom ;
 	rdfs:label "Thing" ;
 	lv2:documentation """
-<p>Abstract base class for a "Thing", i.e. an <a href="#Atom">Atom</a> with a
+<p>Abstract base class for a "Thing", i.e. an atom:Atom with a
 number of <a href="#Property">properties</a>.  An LV2_Object is an unsigned
 32-bit integer <code>context</code> and <code>id</code> followed by a sequence
 of LV2_Atom_Property .</p>
@@ -260,36 +260,35 @@ LV2_URI_Map_Feature::uri_to_id() with <code>map = NULL</code>, and may be 0
 (the default context).</p>
 
 <p>Note this is an abstract class, i.e. no Atom can exist with <code>type =
-uri_to_id(atom:Thing)</code>.  An Object is either a <a
-href="#Resource">Resource</a> or a <a href="#Blank">Blank</a>, but the
-<code>body</code> always has the same binary format, LV2_Object.  Thus, both
-named and anonymous objects can be handled with common code using only a 64-bit
-header for both.</p>
+uri_to_id(atom:Thing)</code>.  An Object is either an atom:Resource or an
+atom:Blank, but the <code>body</code> always has the same binary format,
+LV2_Object.  Thus, both named and anonymous objects can be handled with common
+code using only a 64-bit header for both.</p>
 """ .
 
 atom:Resource
 	a rdfs:Class ;
 	rdfs:subClassOf atom:Thing ;
 	lv2:documentation """
-An <a href="#Object">Object</a> where <code>id</code> is the
-URI of the resource mapped to an <a href="#ID">ID</a>.
+An atom:Thing where <code>id</code> is the URI of the resource mapped to an
+atom:URID.
 """ .
 
 atom:Blank
 	a rdfs:Class ;
 	rdfs:subClassOf atom:Thing ;
 	lv2:documentation """
-An <a href="#Object">Object</a> where <code>id</code> is the blank node ID of
-the object, which is only meaningful within a certain limited scope
-(e.g. the container of the Blank) and MUST NOT be used as a global ID.
-In particular, <code>id</code> is NOT an <a href="ID">ID</a>.
+An atom:Thing where <code>id</code> is the blank node ID of the object, which
+is only meaningful within a certain limited scope (e.g. the container of the
+Blank) and MUST NOT be used as a global ID.  In particular, <code>id</code> is
+NOT an <a href="ID">ID</a>.
 """ .
 
 atom:Message
 	a rdfs:Class ;
 	rdfs:subClassOf atom:Thing ;
 	lv2:documentation """
-A <a href="#Thing"> where <code>id</code> is a message type ID.  Conceptually,
+A atom:Thing where <code>id</code> is a message type ID.  Conceptually,
 a Message is identical to a Blank, but is a distinct type with a single type
 field to allow simple and fast dispatch by handling code.
 
@@ -297,15 +296,6 @@ A Message may be serialised as a Blank by adding an rdf:type property with the
 value <code>id</code> unmapped to a URI.
 """ .
 
-atom:Model
-	a rdfs:Class ;
-	rdfs:subClassOf atom:Atom ;
-	rdfs:label "Model" ;
-	lv2:documentation """
-A description of a set of <a href="#Object">objects</a>.  In memory, a Model is
-simply a sequence of objects.
-""" .
-
 atom:Event
 	a rdfs:Class ;
 	rdfs:label "Event" ;
@@ -369,14 +359,14 @@ atom:AtomPort
 	rdfs:subClassOf lv2:Port ;
 	rdfs:label "Atom Port" ;
 	lv2:documentation """
-<p>A port which contains an <a href="#Atom">Atom</a>.  Ports of this type will
+<p>A port which contains an lv2:Atom.  Ports of this type will
 be connected to a 32-bit aligned LV2_Atom immediately followed by
 <code>size</code> bytes of data.</p>
 
 <p>This is an abstract port type, i.e. a port MUST NOT only be an AtomPort,
 but must be a more descriptive type that is a subclass of AtomPort which
-defines the port's semantics (typically <a href="#ValuePort">ValuePort</a>
-or <a href="#MessagePort">MessagePort</a>).</p>
+defines the port's semantics (typically atom:ValuePort or atom:MessagePort).
+</p>
 
 <p>Before calling a method on the plugin that writes to an AtomPort output,
 the host MUST set the size of the Atom in that output to the amount of
@@ -427,7 +417,7 @@ atom:EventPort
 	lv2:documentation """
 A port used for communicating time-stamped atoms in the audio context.  Ports
 of this type are connected to an LV2_Atom_Buffer, which contains a flat
-time-stamped sequence of <a href="#Event">Events</a>.
+time-stamped sequence of atom:Event</a>.
 
 This port type is intended as a simpler and atom compatible successor to <a
 href="http://lv2plug.in/ns/ext/event#EventPort">ev:EventPort</a>.
@@ -439,8 +429,8 @@ atom:supports
 	rdfs:range atom:Atom ;
 	rdfs:label "supports" ;
 	lv2:documentation """
-Indicates that a Port supports a certain <a href="#Atom">Atom</a> type.
-This is distinct from the port type - e.g. the port type ValuePort can hold
-atoms with many different types.  This property is used to describe which
-Atom types a Port expects to receive or send.
+Indicates that a Port supports a certain atom:Atom type.  This is distinct from
+the port type - e.g. the port type ValuePort can hold atoms with many different
+types.  This property is used to describe which Atom types a Port expects to
+receive or send.
 """ .
diff --git a/ext/files.lv2/files.ttl b/ext/files.lv2/files.ttl
index bd1c99b..d3ff8a5 100644
--- a/ext/files.lv2/files.ttl
+++ b/ext/files.lv2/files.ttl
@@ -48,11 +48,10 @@ management MUST be handled by the host since different hosts may have very
 different requirements.  Plugins MUST NOT make any assumption about file system
 locations beyond what is explicitly guaranteed by this extension.</p>
 
-<p>This extension defines two features: <a
-href="#newFileSupport">files:newFileSupport</a> allows plugins to create new
-files within an instance-specific namespace at any time (except in realtime
-contexts); while <a href="#pathSupport">files:pathSupport</a> allows plugins
-to refer to file paths in plugin state in a way transparent to the host.</p>
+<p>This extension defines two features: files:newFileSupport allows plugins to
+create new files within an instance-specific namespace at any time (except in
+realtime contexts); while files:pathSupport allows plugins to refer to file
+paths in plugin state in a way transparent to the host.</p>
 
 <p>To create a new file, the plugin MUST request a path from the host using
 LV2_Files_New_File_Support::new_file_path().  Thus, the host may choose an
diff --git a/ext/midi.lv2/midi.ttl b/ext/midi.lv2/midi.ttl
index c63b8c2..cbd80c3 100644
--- a/ext/midi.lv2/midi.ttl
+++ b/ext/midi.lv2/midi.ttl
@@ -43,9 +43,9 @@
 		foaf:mbox <mailto:lars.luthman@gmail.com>
 	] ;
     lv2:documentation """
-This extension defines a data type for a MIDI message (<a
-href="#MidiEvent">MidiEvent</a>), which is normalized for fast and convenient
-processing by plugins.  It is particularly useful as the payload of an <a
+This extension defines a data type for a MIDI message, midi:MidiEvent, which is
+normalized for fast and convenient processing by plugins.  It is particularly
+useful as the payload of an <a
 href="http://lv2plug.in/ns/ext/atom#Atom">Atom</a> or <a
 href="http://lv2plug.in/ns/ext/event#Event">Event</a>.
 """ .
diff --git a/ext/reference.lv2/reference.ttl b/ext/reference.lv2/reference.ttl
index e59e0ae..6d5870f 100644
--- a/ext/reference.lv2/reference.ttl
+++ b/ext/reference.lv2/reference.ttl
@@ -38,21 +38,20 @@
 	lv2:documentation """
 <p>This extension defines a mechanism for working with generic/opaque
 dynamically allocated memory, called a <a href="#Blob">"Blob"</a>, which is
-(unlike an Atom) not necessarily POD.  Blobs are accessed via a <a
-href="#Reference">Reference</a>, which is a special case of Atom that always
-has <code>type = 0</code>, is not POD, and can only be copied using host
-provided functions.  This allows plugins and hosts to work with data of any
-type at all.</p>
+(unlike an Atom) not necessarily POD.  Blobs are accessed via a
+reference:Reference, which is a special case of <a
+href="http://lv2plug.in/ns/ext/ext#Atom">Atom</a> that always has <code>type =
+0</code>, is not POD, and can only be copied using host provided functions.
+This allows plugins and hosts to work with data of any type at all.</p>
 """ .
 
 reference:Reference a rdfs:Class ;
 	rdfs:subClassOf atom:Atom ;
 	rdfs:label      "Reference" ;
 	lv2:documentation """
-<p>Reference to a <a href="#Blob">Blob</a>.  The actual contents of a Reference
-are opaque and host specific, and must not be copied, serialized, or otherwise
-interpreted by a plugin, except via functions provided by the host in
-LV2_Blob_Support.</p>
+<p>Reference to an lv2:Blob.  The actual contents of a Reference are opaque and
+host specific, and must not be copied, serialized, or otherwise interpreted by
+a plugin, except via functions provided by the host in LV2_Blob_Support.</p>
 
 <p>A Reference is a special case of Atom with <code>type = 0</code>.
 "Null" is the unique Atom with <code>type = 0</code> and
diff --git a/ext/urid.lv2/urid.ttl b/ext/urid.lv2/urid.ttl
index d074724..85af5c4 100644
--- a/ext/urid.lv2/urid.ttl
+++ b/ext/urid.lv2/urid.ttl
@@ -59,9 +59,9 @@ pointed to an instance of LV2_URID_Mapper.
 urid:Unmapper
 	a lv2:Feature ;
 	lv2:documentation """
-A feature which is used to unmap URIs previously mapped to integers by <a
-href="#Mapper">Mapper</a>.  To support this feature, the host must pass an
-LV2_Feature to LV2_Descriptor::instantiate() with <em>URI</em>
+A feature which is used to unmap URIs previously mapped to integers by
+urid:Mapper.  To support this feature, the host must pass an LV2_Feature to
+LV2_Descriptor::instantiate() with <em>URI</em>
 <q>http://lv2plug.in/ns/ext/urid#Unmapper</q> and <em>data</em> pointed to an
 instance of LV2_URID_Unmapper.
 """ .