Introduction

Grapheme Description Language for embedding in higher-order document types such as text editions and signlists. A formal definition with RNC schema is given interwoven with the ATF conventions for representing each element in the schema.

Grapheme

The term "grapheme" as used in this document refers to a string of letters, numbers, modifiers and operators used to specify a Sumero-Akkadian cuneiform sign by name or to render one of the values of such a sign. While sign names are often glyph-descriptive (e.g., KA×A meaning sign A written inside sign KA), this document does not provide a glyph description language. Rather, we define a Grapheme Description Language.

GDL & ATF

GDL is not intended to be generated manually; rather, it is the XML result of processing ASCII Transliteration Format (ATF) with the ATF processor. This document includes implementor notes on ATF interwoven with the technical documentation. Unless you are an implementor, or are pathologically curious (or both), you don't need to read this document! Read the tutorial instead. If you are a developer who is new to GDL and ATF it is recommended that you first read the tutorial, and then this document.

An XSL script to convert from GDL back to ATF can be found in the resources section below. The script does not convert the character set from Unicode to ASCII.

charset.rnc

In this section we provide a model for constraining the lexical representation of graphemic atoms. This aspect of grapheme description does not constrain the validity of values within a given signiary; that is handled elsewhere.

Atoms are tightly constrained sequences of characters separated into distinct lowercase and uppercase sets to permit finer-grained constraints.

Characters

GDL does not support any of the common ASCII approximations of the various non-ASCII characters used in cuneiform transliteration; GDL uses only the specific Unicode codepoints listed below for the representation of these characters. Details and images of the Unicode characters can be found at http://www.unicode.org/charts.

Characters are combined into atom specifications by grouping them in classes which are used to place lexical constraints on the atoms.

lV = Permitted lowercase vowels

a e i u

uV = Permitted uppercase vowels

A E I U

lC = Permitted lowercase consonants

b d g h k l m n p q r s u w y z
U+014B LATIN SMALL LETTER ENG
U+1E2B LATIN SMALL LETTER H WITH BREVE BELOW
U+015B LATIN SMALL LETTER S WITH ACUTE
U+0161 LATIN SMALL LETTER S WITH CARON
U+1E63 LATIN SMALL LETTER S WITH DOT BELOW
U+1E6D LATIN SMALL LETTER T WITH DOT BELOW
U+02BE MODIFIER LETTER RIGHT HALF RING

uC = Permitted uppercase consonants

B D G H K L M N P Q R S U W Y Z
U+014A LATIN CAPITAL LETTER ENG
U+1E2A LATIN CAPITAL LETTER H WITH BREVE BELOW
U+015A LATIN CAPITAL LETTER S WITH ACUTE
U+0160 LATIN CAPITAL LETTER S WITH CARON
U+1E62 LATIN CAPITAL LETTER S WITH DOT BELOW
U+1E6C LATIN CAPITAL LETTER T WITH DOT BELOW
U+02BE MODIFIER LETTER RIGHT HALF RING

Si = Subscript initial characters

U+2081-U+2089 (Unicode subscript 1 through 9)

Sc = Subscript continuation characters

U+2080-U+2089 (Unicode subscript 0 through 9)

Sx = Subscript x character

U+208A SUBSCRIPT PLUS SIGN

This yields the following base character sets and definitions (dollar-variables are expanded by a preprocessor to generate the actual RNC schema):

$lV = [aeiu]
$lC = [\x{2BE}bdegh\x{1E2B}i\x{14B}klmnpqrs\x{161}\x{1E63}\x{15B}t\x{1E6D}uwyz]
$uV = [AEIU]
$uC = [\x{2BE}BDEGH\x{1E2A}I\x{14A}KLMNPQRS\x{160}\x{1E62}\x{15A}T\x{1E6C}UWYZ]
$Si = [\x{2081}\x{2082}\x{2083}\x{2084}\x{2085}\x{2086}\x{2087}\x{2088}\x{2089}]
$Sc = [\x{2080}\x{2081}\x{2082}\x{2083}\x{2084}\x{2085}\x{2086}\x{2087}\x{2088}\x{2089}]

$subscript = (${Si}${Sc}?|\x{208A})?

lV = xsd:string {
   pattern = "${lV}${subscript}"
}

lVCv = xsd:string {
  pattern = "(${lV}${lC})+${lV}?${subscript}"
}

lCVc = xsd:string {
  pattern = "(${lC}${lV})+${lC}?${subscript}"
}

lVCCvc = xsd:string {
  pattern = "(${lV}${lC}{1,2})+(${lV}${lC}?)${subscript}"
}

lCVCCvc = xsd:string {
  pattern = "(suen|kuara|${lC}(${lV}${lC}{1,2})+(${lV}${lC}?))${subscript}"
}

uV = xsd:string {
   pattern = "${uV}${subscript}"
}

uVCv = xsd:string {
  pattern = "(${uV}${uC})+${uV}?${subscript}"
}

uCVc = xsd:string {
  pattern = "(${uC}${uV})+${uC}?${subscript}"
}

uVCCvc = xsd:string {
  pattern = "(${uV}${uC}{1,2})+(${uV}${uC}?)${subscript}"
}

uCVCCvc = xsd:string {
  pattern = "${uC}(${uV}${uC}{1,2})+(${uV}${uC}?)${subscript}"
}

grapheme.rnc

namespace g = "http://oracc.org/ns/gdl/1.0"

grapheme = v | q | s | n | c | gloss | g | nongrapheme | punct | gsurro
form     = attribute form { text }
sb       = element g:b { s.model }
vb       = element g:b { v.model }
punct    = element g:p { p.model }
lang     = attribute xml:lang { xsd:language }
gsurro   = 
  element g:surro {
    delim? , (s|c|n|punct|group) , groupgroup
  }

# Values
#v.model  = "x" | lV | lVCv | lCVc | lVCCvc | lCVCCvc
v.model = text
v        = element g:v { form? , g.meta , lang? , (v.model | (vb , mods+)) }
#dingir   = element g:v { g.meta , lang? , ("d") }
#mister   = element g:v { g.meta , lang? , ("m") }

# Names
#s.model  =  "N" | "X" | uV | uVCv | uCVc | uVCCvc | uCVCCvc | lst | num
s.model  = text

lst    = xsd:string {
  pattern="(..?SL|ABZ|BAU|HZL|KWU|LAK|M|MEA|MZL|REC|RSP|ZATU)\d+[a-z]*"
}

#[ABCD] is a stop-gap until lateuruk numbers are fixed
num      = xsd:string { pattern = "N|N\d+[ABCD]?" }

s        = element g:s { form? , g.meta , (s.model | (sb , mods+)) }

# Qualified graphemes
q        = element g:q { form? , g.meta , (v|s|c) , (s|c|n) }

# Numbers
n.model  = r , (v|s|c|q)?

r        = element g:r {
             xsd:string {
	       pattern = "[nN]\+[0-9]+|[nN]|[0-9]+|[n1-9]+/[n1-9]" } }

n        = element g:n { form? , g.meta , sexified?, n.model , mods* }
sexified = attribute sexified { text }

# Modifiers
mods     = modifier | allograph | formvar

modifier = element g:m { xsd:string { pattern = "[a-z]|[0-9]{1,3}" } }

allograph= element g:a { xsd:string { pattern = "[a-wyz0-9]+" } 
			| xsd:string { pattern = "[\+\-]" } }

formvar = element g:f { xsd:string { pattern = "[a-z0-9]+" } }

# Compounds
c.model  = (compound , (o.join , compound)+) | unary | binary | ternary | (g , mods+)

c        = element g:c { form? , g.meta , c.model , mods* }

g        = element g:g { g.meta , c.model , mods* }

compound = single | unary | binary

single   = n | s | c | (g,mods*) | q

unary    = o.unary , single

binary   = single , o.binary , single

ternary   = single , o.binary , single , o.binary , single

o.join   = element g:o { attribute g:type { "beside" | "joining" | "reordered" } }

o.unary  = element g:o { attribute g:type { "repeated" } , xsd:integer }

o.binary =
  element g:o {
    attribute g:type {
      "containing" | "above" | "crossing" | "opposing"
    }
  }

# Punctuation
p.model =
    attribute g:type { "*"|":"|":'"|':"'|":."|"::"|"|"|"/"|":r:"|"·" } , 
    g.meta , 
    (v|q|s|n|c)?

Preamble

As a design principle, all of the most common GDL elements have single character names. In order to minimize possible confusion with similar names in other vocabularies, it is recommended that GDL elements always be namespace-qualified. To reinforce this point, the definition of the GDL schema does not use a default namespace.

The examples in this document all assume that the prefix g is bound to the namespace of the GDL schema.

namespace g = "http://oracc.org/ns/gdl/1.0"

grapheme = v | q | s | n | c | gloss | g | nongrapheme | punct | gsurro
form     = attribute form { text }
sb       = element g:b { s.model }
vb       = element g:b { v.model }
punct    = element g:p { p.model }
lang     = attribute xml:lang { xsd:language }
gsurro   = 
  element g:surro {
    delim? , (s|c|n|punct|group) , groupgroup
  }

Signs

We call the core alphanumeric portion of a sign an atom. This is a single grapheme component which for the purposes of this grapheme description instance is not susceptible to further sub-description.

All sign values are by definition atoms.

Sign names consist of one or more atoms. In the grapheme A there is a single atom; in the grapheme KA×A there are two atoms, KA and A. In another context, that same grapheme might be named as NAG; this version of the name contains a single atom, despite the fact that a sign list might describe the sign as KA×A. In other words, atomicity in grapheme names is determined by the naming scheme rather than the underlying construction of the glyph.

Two simple elements are defined for atoms: g:v, for sign values, and g:s for sign names.

Values

# Values
#v.model  = "x" | lV | lVCv | lCVc | lVCCvc | lCVCCvc
v.model = text
v        = element g:v { form? , g.meta , lang? , (v.model | (vb , mods+)) }
#dingir   = element g:v { g.meta , lang? , ("d") }
#mister   = element g:v { g.meta , lang? , ("m") }

a      a₂    babbar      dug₄      ṣe₂    ša₁₃

Names

# Names
#s.model  =  "N" | "X" | uV | uVCv | uCVc | uVCCvc | uCVCCvc | lst | num
s.model  = text

lst    = xsd:string {
  pattern="(..?SL|ABZ|BAU|HZL|KWU|LAK|M|MEA|MZL|REC|RSP|ZATU)\d+[a-z]*"
}

#[ABCD] is a stop-gap until lateuruk numbers are fixed
num      = xsd:string { pattern = "N|N\d+[ABCD]?" }

s        = element g:s { form? , g.meta , (s.model | (sb , mods+)) }

A      BA     ŠA₃    GILIM

ša AN

N01       N34       LAK37        ZATU777

Qualified

Qualifed graphemes consist of a sign value followed by a sign name in parentheses, e.g., pu(BU). (In normalized text the superficially similar construct is used to indicate the logograms used for the normalized form, e.g., %akk/n bēlu(EN).)

# Qualified graphemes
q        = element g:q { form? , g.meta , (v|s|c) , (s|c|n) }

baₓ(PI)         ZAX(LAK384)

Number

Numerical graphemes have a special form. Each numerical grapheme consists of at least two parts: the repetition count and the sign value, sign name or compound sign. A special case is made for numerical graphemes by allowing them to have modifiers even if the graphemic base is a sign value.

The repetition count must have one of the following forms:

digits

This is the normal case.

n

This is a special case for circumstances where the repetition is completely uncertain.

n+digits

This is a special case for circumstances where the repetition is partly uncertain.

While it would in principle be possible to constrain the value space of GRAPHEME in the schema we do not do so; instead, as with non-numerical graphemes, we constrain the lexical space and require the values of numerical graphemes to be validated elsewhere. This allows the schema to be open-ended with respect to the identification of new numerical systems.

# Numbers
n.model  = r , (v|s|c|q)?

r        = element g:r {
             xsd:string {
	       pattern = "[nN]\+[0-9]+|[nN]|[0-9]+|[n1-9]+/[n1-9]" } }

n        = element g:n { form? , g.meta , sexified?, n.model , mods* }
sexified = attribute sexified { text }

REPETITION '(' GRAPHEME ')'

1(N₀₁)      4(ban₂)     1(aš@c)    n(geš₂)      n+1(aš)

Modifier

Sign names and numerical sign value atoms may be described by reference to modifications of the base sign, as summarized in the table below. The lexical representation of modifiers is restricted to either a single lower case letter or a sequence of one, two or three ASCII digits. The semantics of these modifiers is indicated in the table, but is irrelevant from the point of view of the schema. A single GDL element, g:m, contains the modifier.

Modifiers may not follow a compound sign's terminating pipe character; if an entire compound is to be modified, the compound's content must be grouped and the modifiers suffixed between the closing parenthesis and the closing pipe.

# Modifiers
mods     = modifier | allograph | formvar

modifier = element g:m { xsd:string { pattern = "[a-z]|[0-9]{1,3}" } }

In ATF the at-sign (@) precedes each modifier; multiple modifiers may be given in which case each modifier requires its own at-sign. The entire sequence of modifiers (and allographs, described below) belongs to the immediately preceding sign or group. Sign names and values with modifiers and/or allographs following them should not be be treated as compounds.

ATF Modifier Overview

Modifier	ATF	Example	Sign
curved	@c	AŠ@c
flat	@f	1(N01@f)
gunu (4 extra wedges)	@g	DU@g
sheshig (added še-sign)	@s	DU@s
tenu (slanting)	@t	GAN₂@t
nutillu (unfinished)	@n	SAG@n
zidatenu (slanting right)	@z	AŠ@z
kabatenu (slanting left)	@k	AŠ@k
vertically reflected	@r	U@r
horizontally reflected	@h	N07~a@h
rotated	@<DIGITS>	NAGA@180
variant	@v	4(ban₂)@v

Modifiers on numerical graphemes may go inside or outside the closing parenthesis depending on the naming schema for values and sign names used by the style manual or sign list for an individual project.

Allograph

It is sometimes desirable to distinguish between grapheme instances which have otherwise been considered the same sign, or which actually are the same sign, for semantic or glyph-analytic reasons. This is expressed in GDL by the g:a element whose content is a sequence of one or more lowercase letters, excluding x, and ASCII digits. Sign list creators are free to assign whatever meanings they like to any combinations of these characters; in PCSL, for example, sequences such as a1a versus a1b and a2a versus a2b are used to implement multi-level distinctions between variants of a sign. An allograph may follow the closing parenthesis of a group within a compound sign, but may not follow the final vertical bar of the compound.

The reason for the exclusion of x in the allowable set of lowercase letters in an allograph is that allowing it in ASCII transliterations would introduce an ambiguity at the ATF level between x in allographs and x as a compound operator.

allograph= element g:a { xsd:string { pattern = "[a-wyz0-9]+" } 
			| xsd:string { pattern = "[\+\-]" } }

|EN~a|  |EN~b|  |GA₂~a1|  |GA₂~a2|  |GEŠTU~axŠE~a@t|

Formvars

formvar = element g:f { xsd:string { pattern = "[a-z0-9]+" } }

Form variants is the GDL name for minor differences in the construction of signs which may be of interest in analysis of a corpus for handwritings, but which are not important enough to be displayed or included in the version of the writing used for linguistic analysis.

Compound

Compound graphemes are combinations of sign names and operators; the definition is recursive meaning that compound grapheme atoms may be grouped and the group treated as a compound in its own right. Atoms and compounds may both have associated modifier and/or allograph qualifications. We call a single combination of a sign or compound sign and its qualifiers a constituent.

The possible operator types are:

beside

Constituents are written sequentially beside each other.

joining

Constituents are written such that they share at least one common wedge.

containing

The constituent preceding the operator contains the constituent following the operator; the containment may be partial.

above

The constituent preceding the operator is written in the upper part of the line, with the following constituent written beneath it in the lower part of the line.

crossing

The constituents cross one another similarly to the diagonals of an X.

opposing

The constituent preceding the operator is opposite the following constituent, which is turned upside down.

repeated

The following constituent is repeated N times

The beside and joining operators are in fact joiners which mark boundaries; any number of joiner/compound pairs may be siblings.

The inside, above, crossing and opposing operators all have binary scope: a compound which contains an operator is constrained to having exactly two compound children, one before and one after the operator.

The repeated operator is a unary prefix with the content of the operator giving the repetition count. Compounds containing this operator may have only one compound child.

The repeated operator is a unary postfix with the content of the operator giving the number of degrees the sign is rotated in a clockwise direction. Compounds containing this operator may have only one compound child.

# Compounds
c.model  = (compound , (o.join , compound)+) | unary | binary | ternary | (g , mods+)

c        = element g:c { form? , g.meta , c.model , mods* }

g        = element g:g { g.meta , c.model , mods* }

compound = single | unary | binary

single   = n | s | c | (g,mods*) | q

unary    = o.unary , single

binary   = single , o.binary , single

ternary   = single , o.binary , single , o.binary , single

o.join   = element g:o { attribute g:type { "beside" | "joining" | "reordered" } }

o.unary  = element g:o { attribute g:type { "repeated" } , xsd:integer }

o.binary =
  element g:o {
    attribute g:type {
      "containing" | "above" | "crossing" | "opposing"
    }
  }

The difference between a simple sign and a compound sign is that a a compound sign is a sequence of sign names which contains at least one operator, i.e., a character which represents a relationship between multiple graphemes. In ATF the set of characters used for operators is: × % @ & . : +.

In ATF compound graphemes are enclosed at the outer level in vertical bars ("pipes", |...|):

|KA×A|

Signs are frequently modified or operated on as a group; parentheses are used to group multi-part constituents:

|GA₂×(ME.EN)|      |(GI&GI)׊E₃|

Note that modifiers and allographs must not be placed after the closing pipe; instead, they must be put inside the pipe adding grouping characters if necessary:

|GA₂~a×EN|       |GA₂×EN~a|          |(GA₂×EN)~a|  

Th examples above all mean different things. The first, |GA₂~a×EN|, means: "the a-allograph of the sign GA₂ containing sign EN". The second, |GA₂×EN~a|, means: "GA₂ containing the a-allograph of sign EN". The third, |(GA₂×EN)~a|, means: "the a-allograph of the group consisting of sign GA₂ containing sign EN". In example three the bad form *|GA₂×EN|~a would result in a parse error.

Each of the compound operations has its own ATF notation as summarized in the table below:

Summary of Compound Grapheme Operators in ATF/GDL

GDL	ATF	Example	Sign
beside	.	|DU.DU|
joining	+	|LAGAB+LAGAB|
containing	×	|GA₂×AN|
containing/group	×	|GA₂×(ME.EN)|
above	&	|DU&DU|
crossing	%	|GI%GI|
opposing	@	|LU₂@LU₂|
repeated	3×	|3×AN|
repeated	4×	|4xLU2|

# Punctuation
p.model =
    attribute g:type { "*"|":"|":'"|':"'|":."|"::"|"|"|"/"|":r:"|"·" } , 
    g.meta , 
    (v|q|s|n|c)?

graphmeta.rnc

namespace g = "http://oracc.org/ns/gdl/1.0"
g.meta = 
  break? , status.flags? , status.spans? , 
  paleography.attr? , linguistic.attr? , proximity.attr? ,
  opener? , closer? , hsqb_o?, hsqb_c? , emhyph? ,
  varnum? , sign_attr? , utf8? , delim? ,
  attribute xml:id { xsd:ID }? ,
  breakStart? , breakEnd? ,
  damageStart? , damageEnd? ,
  surroStart? , surroEnd? ,
  statusStart? , statusEnd? ,
  accented? , a_oid? , a_spoid? , a_spform?

accented = attribute g:accented { text }
breakStart = attribute g:breakStart { "1" }
breakEnd = attribute g:breakEnd { xsd:IDREF }
damageStart = attribute g:damageStart { "1" }
damageEnd = attribute g:damageEnd { xsd:IDREF }
surroStart = attribute g:surroStart { "1" }
surroEnd = attribute g:surroEnd { xsd:IDREF }
statusStart = attribute g:statusStart { "1" }
statusEnd = attribute g:statusEnd { xsd:IDREF }

a_oid = attribute oid { text }
a_spoid = attribute spoid { text }
a_spform = attribute spform { text }

break = attribute g:break  { "damaged" | "missing" }
opener = attribute g:o     { text }
closer = attribute g:c     { text }
hsqb_o = attribute g:ho    { "1" }
hsqb_c = attribute g:hc    { "1" }
emhyph = attribute g:em    { "1" }
sign_attr = attribute g:sign  { text }
utf8   = attribute g:utf8  { text }
oid    = attribute oid  { text }
delim  = attribute g:delim { text }
varnum = (
  attribute g:varo { text }? , 
  attribute g:vari { text }? ,  
  attribute g:varc { text }?
)

status.flags =
  attribute g:collated { xsd:boolean } ? ,
  attribute g:queried  { xsd:boolean } ? ,
  attribute g:remarked { xsd:boolean } ? ,
  attribute g:uflag1 { xsd:boolean } ? ,
  attribute g:uflag2 { xsd:boolean } ? ,
  attribute g:uflag3 { xsd:boolean } ? ,
  attribute g:uflag4 { xsd:boolean } ? 

gloss = det | glo
pos = attribute g:pos { "pre" | "post" | "free" }
#det = element g:d { pos , dtyp , delim? , emhyph? , notemark? , surroStart? , g.meta ,
#                    (dingir | mister | word.content*)}
det = element g:d { pos , dtyp , delim? , emhyph? , surroStart? , g.meta ,
                    (word.content*)}
dtyp= attribute g:role { "phonetic" | "semantic" }
glo = element g:gloss { attribute g:type { "lang" | "text" } , surroEnd? , delim? , pos , words }

status.spans =
  attribute g:status {
    "ok" | "erased" | "excised" | "implied" | "maybe" | "supplied" | "some"
  }

paleography.attr =
  attribute g:script      { xsd:NCName }

linguistic.attr =
  attribute xml:lang      { xsd:language } ? ,
#  attribute g:rws         { "emegir" | "emesal" | "udgalnun" }? ,
  (attribute g:role       { "sign" | "ideo" | "num" | "syll" }
  | (attribute g:role     { "logo" } ,
     attribute g:logolang { xsd:language }))

proximity.attr = 
  attribute g:prox { xsd:integer }

nongrapheme = 
  element g:x {
    ( attribute g:type { "disambig" | "empty" | "linebreak" | "newline" | "user" | "dollar" | "comment" }
    | ( attribute g:type { "ellipsis" | "word-absent" | "word-broken" | "word-linecont" | "word-linefrom" } 
        , status.spans , opener? , closer? , break? )),
    delim? , text? , varnum? ,
    attribute xml:id { xsd:ID }? ,
    breakStart? , breakEnd? ,
    damageStart? , damageEnd? , emhyph? ,
    surroStart? , surroEnd? ,
    statusStart? , statusEnd? ,
    status.flags?
    }

Preamble

This module defines attributes which are essentially graphemic metadata supplied by the editor of the text. They fall into several groups: properties of the grapheme imputed to derive from the scribe; properties assigned by the editor; physical preservation properties; paleographic properties; and linguistic properties. We describe these principally in the form of the tutorial aimed at end-users and allow the sequence of definitions in the schema to follow the tutorial.

namespace g = "http://oracc.org/ns/gdl/1.0"
g.meta = 
  break? , status.flags? , status.spans? , 
  paleography.attr? , linguistic.attr? , proximity.attr? ,
  opener? , closer? , hsqb_o?, hsqb_c? , emhyph? ,
  varnum? , sign_attr? , utf8? , delim? ,
  attribute xml:id { xsd:ID }? ,
  breakStart? , breakEnd? ,
  damageStart? , damageEnd? ,
  surroStart? , surroEnd? ,
  statusStart? , statusEnd? ,
  accented? , a_oid? , a_spoid? , a_spform?

accented = attribute g:accented { text }
breakStart = attribute g:breakStart { "1" }
breakEnd = attribute g:breakEnd { xsd:IDREF }
damageStart = attribute g:damageStart { "1" }
damageEnd = attribute g:damageEnd { xsd:IDREF }
surroStart = attribute g:surroStart { "1" }
surroEnd = attribute g:surroEnd { xsd:IDREF }
statusStart = attribute g:statusStart { "1" }
statusEnd = attribute g:statusEnd { xsd:IDREF }

a_oid = attribute oid { text }
a_spoid = attribute spoid { text }
a_spform = attribute spform { text }

Breakage

ba#       [a]-ba     mudₓ(|ZI&ZI.A|)#

break = attribute g:break  { "damaged" | "missing" }
opener = attribute g:o     { text }
closer = attribute g:c     { text }
hsqb_o = attribute g:ho    { "1" }
hsqb_c = attribute g:hc    { "1" }
emhyph = attribute g:em    { "1" }
sign_attr = attribute g:sign  { text }
utf8   = attribute g:utf8  { text }
oid    = attribute oid  { text }
delim  = attribute g:delim { text }
varnum = (
  attribute g:varo { text }? , 
  attribute g:vari { text }? ,  
  attribute g:varc { text }?
)

Other flags

a*               ki?            šum!              ki!?*(DI)

status.flags =
  attribute g:collated { xsd:boolean } ? ,
  attribute g:queried  { xsd:boolean } ? ,
  attribute g:remarked { xsd:boolean } ? ,
  attribute g:uflag1 { xsd:boolean } ? ,
  attribute g:uflag2 { xsd:boolean } ? ,
  attribute g:uflag3 { xsd:boolean } ? ,
  attribute g:uflag4 { xsd:boolean } ?

Glosses

{d}utu   larsa{ki}   {+u₃-mu₂}u₂-mu₁₁    AN{+e}

du₃-am₃{{mu-un-<(du₃)>}}

{(1(u))}    {(%a he-pi₂ eš-šu₂)}

gloss = det | glo
pos = attribute g:pos { "pre" | "post" | "free" }
#det = element g:d { pos , dtyp , delim? , emhyph? , notemark? , surroStart? , g.meta ,
#                    (dingir | mister | word.content*)}
det = element g:d { pos , dtyp , delim? , emhyph? , surroStart? , g.meta ,
                    (word.content*)}
dtyp= attribute g:role { "phonetic" | "semantic" }
glo = element g:gloss { attribute g:type { "lang" | "text" } , surroEnd? , delim? , pos , words }

status.spans =
  attribute g:status {
    "ok" | "erased" | "excised" | "implied" | "maybe" | "supplied" | "some"
  }

mu-un-šum₂{%1 szu}

paleography.attr =
  attribute g:script      { xsd:NCName }

#atf: lang nb

8. %e še-eb %s e₂-kur-ra ba-du₃-a-bi

Roles

The role of a grapheme may be annotated on the grapheme element, but there is no ATF syntax for specifying it: the ideo, num or syll values of the role attribute should be determined by linguistic services processors and added directly to the XTF version of the text.

Logograms

The surface syntax for logograms is described under Sign Names above.

The notation _%LANG LOGOGRAMS_ can be used to specify the logogram language, e.g., in Urartean context, _%akk DAN-NU_

A normalization may be given after a word containing at least one logogram by following the word immediately with (=...), e.g., SAL(=mimma).

linguistic.attr =
  attribute xml:lang      { xsd:language } ? ,
#  attribute g:rws         { "emegir" | "emesal" | "udgalnun" }? ,
  (attribute g:role       { "sign" | "ideo" | "num" | "syll" }
  | (attribute g:role     { "logo" } ,
     attribute g:logolang { xsd:language }))

Scripts

Proximity

proximity.attr = 
  attribute g:prox { xsd:integer }

Intrusions

mu-un-;e₃          [...]         [(...)]

#note: @akk{-ir}*: copy has @akk{NI}.

nongrapheme = 
  element g:x {
    ( attribute g:type { "disambig" | "empty" | "linebreak" | "newline" | "user" | "dollar" | "comment" }
    | ( attribute g:type { "ellipsis" | "word-absent" | "word-broken" | "word-linecont" | "word-linefrom" } 
        , status.spans , opener? , closer? , break? )),
    delim? , text? , varnum? ,
    attribute xml:id { xsd:ID }? ,
    breakStart? , breakEnd? ,
    damageStart? , damageEnd? , emhyph? ,
    surroStart? , surroEnd? ,
    statusStart? , statusEnd? ,
    status.flags?
    }

namespace g = "http://oracc.org/ns/gdl/1.0"
namespace n = "http://oracc.org/ns/norm/1.0"
namespace note = "http://oracc.org/ns/note/1.0"
namespace syn = "http://oracc.org/ns/syntax/1.0"

word.content = text | group | grapheme | nongrapheme

words = (word | sword.head | sword.cont | nonword | nongrapheme | normword)*

word = 
  element g:w {
    word.attributes,
    word.content*
  }

sword.head = 
  element g:w {
    attribute headform { text },
    attribute contrefs { xsd:IDREFS },
    word.attributes,
    word.content*
  }

sword.cont = 
  element g:swc {
    attribute xml:id { xsd:ID } ,
    attribute xml:lang { xsd:language } ,
    attribute form  { text }? ,
    attribute headref { xsd:IDREF },
    attribute swc-final { "1" | "0" },
    delim? ,
    word.content*
  }

word.attributes = 
    attribute xml:id { xsd:ID } ,
    attribute xml:lang { xsd:language } ,
    attribute fwhost { xsd:language }? ,
    attribute form  { text }? ,
    attribute lemma { text }? ,
    attribute guide { text }? ,
    attribute sense { text }? ,
    attribute pos   { text }? ,
    attribute morph { text }? ,
    attribute base  { text }? ,
    attribute norm  { text }? ,
    delim? ,
    syntax.attributes*

nonword = 
  element g:nonw {
    (
    attribute xml:id { xsd:ID }? ,
    attribute xml:lang { xsd:language }? ,
    attribute type { "comment" | "dollar" | "excised" | "punct" | "surro" | "vari" }? ,
    attribute form { text }? ,
    attribute lemma { text }? ,
    syntax.attributes* ,
    break? , status.flags? , status.spans? , opener? , closer? , delim? , g.meta , 
    word.content*
    )
    |
    (
    attribute type { "notelink" },
    noteref,
    noteauto?,
    text
    )
  }

group = 
  element g:gg {
    attribute g:type { 
      "correction" | "alternation" | "group" | "reordering" | "ligature" | "implicit-ligature" | "logo" | "numword"
    } ,
    g.meta ,
    (group | grapheme | normseg)+
  }

groupgroup = 
  element g:gg {
    attribute g:type { "group" } ,
    g.meta ,
    (group | grapheme | normword | normseg)+
  }

syntax.attributes = 
  (attribute syn:brk-before { text } |
   attribute syn:brk-after  { text } |
   attribute syn:ub-before  { text } |
   attribute syn:ub-after   { text } )

normword = 
  element n:w { 
    word.attributes , 
    break? , status.flags? , status.spans? , opener? , closer? , 
    hsqb_o? , hsqb_c? ,
    (gsurro | normwordword | normwordgroup | gloss | nongrapheme | group)* ,
    syntax.attributes*,
    breakStart? , breakEnd? ,
    damageStart? , damageEnd? ,
    statusStart? , statusEnd?
  }

normwordgroup = 
  element n:word-group {
     attribute g:type { "alternation" } ,
     attribute g:delim { "-" }? ,
     element n:grouped-word { normwordword }+
  }

normwordword = ( text | (normseg | normgroup)+)

normseg =
  element n:s {
    n.meta ,
    g.meta ,
    text
  }

n.meta = normnum?

normnum = attribute n:num { "yes" }

normgroup = 
  element n:g {
    attribute g:type {
      "correction" | "alternation" | "group" | "reordering" | "ligature" | "numword"
    } ,
    g.meta ,
    (normgroup | normseg)+
  }

Words

For the purposes of transliteration, a "word" is anything between spaces, including isolated and uninterpretable signs.

In GDL, words are sequences of graphemes or grapheme-groups. The following kinds of grapheme-groups are defined:

alternation

Simple alternation of the common transliterational form KI/DI. An alternation may contain more than one choice, but always applies to a sequence of single graphemes.

reordering

Reordering of graphemes within a word commonly expressed by use of the colon (:) as a grapheme joiner in transliterations. The original order of the signs on the tablet is not indicated within a word; the structural mechanism Multiplexing must be used instead.

a-ba mu-un-ba-al-e     KI/DI-bi     LAGAB-DUL₃      mu:un-du₃

Foreign Words

To mark foreign words use the %fw shift. This must be used before the language of the foreign word itself, and results in an fwhost attribute being placed on the word's XML node. The fwhost attribute gives the host language, i.e., the language of the environment within which the foreign word is an intrusion. The %fw is cancelled the next time the host language is reverted to. So, to give an Akkadian word in Hittite context use %hit bu %fw %akk šar-ru %hit ba.

namespace g = "http://oracc.org/ns/gdl/1.0"
namespace n = "http://oracc.org/ns/norm/1.0"
namespace note = "http://oracc.org/ns/note/1.0"
namespace syn = "http://oracc.org/ns/syntax/1.0"

word.content = text | group | grapheme | nongrapheme

words = (word | sword.head | sword.cont | nonword | nongrapheme | normword)*

word = 
  element g:w {
    word.attributes,
    word.content*
  }

sword.head = 
  element g:w {
    attribute headform { text },
    attribute contrefs { xsd:IDREFS },
    word.attributes,
    word.content*
  }

sword.cont = 
  element g:swc {
    attribute xml:id { xsd:ID } ,
    attribute xml:lang { xsd:language } ,
    attribute form  { text }? ,
    attribute headref { xsd:IDREF },
    attribute swc-final { "1" | "0" },
    delim? ,
    word.content*
  }

word.attributes = 
    attribute xml:id { xsd:ID } ,
    attribute xml:lang { xsd:language } ,
    attribute fwhost { xsd:language }? ,
    attribute form  { text }? ,
    attribute lemma { text }? ,
    attribute guide { text }? ,
    attribute sense { text }? ,
    attribute pos   { text }? ,
    attribute morph { text }? ,
    attribute base  { text }? ,
    attribute norm  { text }? ,
    delim? ,
    syntax.attributes*

nonword = 
  element g:nonw {
    (
    attribute xml:id { xsd:ID }? ,
    attribute xml:lang { xsd:language }? ,
    attribute type { "comment" | "dollar" | "excised" | "punct" | "surro" | "vari" }? ,
    attribute form { text }? ,
    attribute lemma { text }? ,
    syntax.attributes* ,
    break? , status.flags? , status.spans? , opener? , closer? , delim? , g.meta , 
    word.content*
    )
    |
    (
    attribute type { "notelink" },
    noteref,
    noteauto?,
    text
    )
  }

group = 
  element g:gg {
    attribute g:type { 
      "correction" | "alternation" | "group" | "reordering" | "ligature" | "implicit-ligature" | "logo" | "numword"
    } ,
    g.meta ,
    (group | grapheme | normseg)+
  }

groupgroup = 
  element g:gg {
    attribute g:type { "group" } ,
    g.meta ,
    (group | grapheme | normword | normseg)+
  }

syntax.attributes = 
  (attribute syn:brk-before { text } |
   attribute syn:brk-after  { text } |
   attribute syn:ub-before  { text } |
   attribute syn:ub-after   { text } )

Normalization

In normalization, sequences like mû/pû generate an outer n:w containing a n:word-group which in turn contains a sequence of n:grouped-word elements.

normword = 
  element n:w { 
    word.attributes , 
    break? , status.flags? , status.spans? , opener? , closer? , 
    hsqb_o? , hsqb_c? ,
    (gsurro | normwordword | normwordgroup | gloss | nongrapheme | group)* ,
    syntax.attributes*,
    breakStart? , breakEnd? ,
    damageStart? , damageEnd? ,
    statusStart? , statusEnd?
  }

normwordgroup = 
  element n:word-group {
     attribute g:type { "alternation" } ,
     attribute g:delim { "-" }? ,
     element n:grouped-word { normwordword }+
  }

normwordword = ( text | (normseg | normgroup)+)

normseg =
  element n:s {
    n.meta ,
    g.meta ,
    text
  }

n.meta = normnum?

normnum = attribute n:num { "yes" }

normgroup = 
  element n:g {
    attribute g:type {
      "correction" | "alternation" | "group" | "reordering" | "ligature" | "numword"
    } ,
    g.meta ,
    (normgroup | normseg)+
  }

gdl.rnc

A simple entry point so that users don't have to include several separate schemas.

include "charset.rnc"
include "grapheme.rnc"
include "graphmeta.rnc"
include "words.rnc"

Links

Top

Tutorial

Questions about this document may be directed to the Oracc Steering Committee (osc at oracc dot org).