MMORPH(5)							File Formats Manual							 MMORPH(5)

NAME

       mmorph - MULTEXT morphology tool formalism syntax

DESCRIPTION

       A  mmorph  morphology  description  file  is  divided  into  declaration sections.  Each section starts by a section header (`@ Alphabets',
       `@ Attributes', etc.)  followed by a sequence of declarations.  Each declaration starts by a name, followed by a colon (`:') and the  defi-
       nition associated to the name.  Here is a brief description of each section:

@ Alphabets
       In  this section the lexical and surface alphabet are declared.	All symbols forming each alphabet has to be listed.  Symbols may appear in
       both the lexical and surface alphabet definition in which case it is considered a bi-level symbol, otherwise it is a lexical only  or  sur-
       face  only symbol.  Symbols are usually letters (eg.  a, b, c) , but may also consist of longer names (beta, schwa).  Symbol names consist-
       ing of one special character (`:' or `(') may be specified by enclosing them in double quotes (`:' or `(').
       Example:

	      Lexical : a b c d e f g h i j k l m n o p q r s t u v w x y z "-" "." "," "?" "!" """ "'" ":" ";" "(" ")" strong_e

	      Surface : a b c d e f g h i j k l m n o p q r s t u v w x y z "-" "." "," "?" "!" """ "'" ":" ";" "(" ")" " "

       In this example, the symbol strong_e is lexical only, the symbol " " (space) is surface only.  All the other symbols are bi-level.

       All the strings appearing in the rest of the grammar will be made exclusively of symbols declared in this section.

@ Attributes
       In this section, the name of attributes (sometimes called features) and their associated value set.  At most 32	different  values  may	be
       declared for an attribute.
       Examples:

	      Gender : feminine masculine neuter
	      Number : singular plural
	      Person : 1st 2nd 3rd
	      Transitive : yes no
	      Inflection : base intermediate final

       In the current version of the implementation value sets of different attributes are incompatible, even if they are defined identically.	To
       overcome this restriction, in a future version this section will be  split  into  two:	declaration  of  value	sets  and  declaration	of
       attributes.

@ Types
       In this section, the different types of feature structures are declared.  The attributes allowed for each type are listed.  Attributes that
       are only used within the scope of the tool and have no meaning outside can be listed  after  a  bar  (`|').   The  values  of  these  local
       attributes ar not stored in the database or written on the final output of the program.
       Examples:

	      Noun : Gender Number
	      Verb : Tense Person Gender Number Transitive | Inflection

Typed feature structures
       Typed  feature  structures  are used in the grammar and spelling rules.	It is the specification of a type and the value of some associated
       attributes.  The list of attribute specifications is enclosed in square brackets (`[' and `]').
       Example:

	      Noun[ Gender=feminine Number=singular ]

       It is possible to specify a set of values for an attribute by listing the possible valuse separated with a bar (`|'), or the complement	of
       a set (with respect to all possible values of that attribute) indicated with `!=' instead of `='.
       Example:  Assuming the declaration of Gender as above, the following two typed feature structures are equivalent

	      Noun[ Gender=masculine|neuter ]
	      Noun[ Gender!=feminine ]

@ Grammar
       This section contains the rules that specify the structure of words.  It has the general shape of a context free grammar over typed feature
       structures.  There are three basic types of rules:  binary, goal and affixes.

       Binary rules specify the result of the concatenation of two elements. This is written as:

	      Rule_name : Lhs <- Rhs1 Rhs2

       where Lhs is called the left hand side, and Rhs1 and Rhs2 the first and second part of the right hand side.  Lhs, Rhs1 and Rhs2 are  speci-
       fied as typed feature structures.
       Example:

	      Rule_1  : Noun[ Gender=feminine Number=singular ]
		      <- Noun[ Gender=feminine Number=singular ]
			 NounSuffix[ Gender=feminine ]

       Variables can be used to indicate that some attributes have the same value.  A variable is a name starting with a dollar (`$').
       Example:

	      Rule_2  : Noun[ Gender=$A Number=$number ]
		      <- Noun[ Gender=$A Number=$number ]
			 NounSuffix[ Gender=$A ]

       If needed, both a variable and a value specification can be given for an attribute (only once per attribute):
       Example:

	      Rule_3  : Noun[ Gender=$A Number=$number ]
		      <- Noun[ Gender=$A Number=$number ]
			 NounSuffix[ Gender=$A=masculine|neuter ]

       Affix rules define basic elements of the concatenations specified by binary rules (together with lexical entries, see the section @ Lexicon
       below).	An affix rule consists of lexical string associated to a typed feature structure.
       Examples:

	      Plural_s : "s" NounSuffix[ Number=plural ]
	      Feminine_e : "e" NounSuffix[ Gender=feminine ]
	      ing : "ing" VerbSuffix[ Tense=present_participle ]

       Goal rules specify the valid results constructed by the grammar.  They consist of just a typed feature structure.
       Examples:

	      Goal_1  : Noun[]
	      Goal_2  : Verb[ inflection=final ]

       In addition to these three basic rule types, there are prefix or suffix composite rules and unary rules.  A unary rule consist  of  a  left
       hand side and a right hand side.
       Example:

	      Rule_4  : Noun[ gender=$G number=plural ]
		      <- Noun[ gender=$G number=singular invariant=yes]

       Prefix  and suffix composite rules have the same shape as binary rules except that one part of the right hand side is an affix (i.e. has an
       associated string).
       Examples:

	      Append_e	 : Noun[ Gender=feminine Number=$number ]
		      <- Noun[ Gender=feminine Number=$number ]
			 "e" NounSuffix[ Gender=feminine ]

	      anti    : Noun[ Gender=$gender Number=$number ]
		      <- "anti" NounPrefix[]
			 Noun[ Gender=$gender Number=$number ]

@ Classes
       This optional section contains the definition of symbol classes. Each class is defined as a set of symbols, or other classes. If the  class
       contains only bi-level elements it is a bi-level class, otherwise it is a lexical or surface class.
       Examples:

	      Dental : d t
	      Vowel : a e i o u
	      Vowel_y : Vowel y
	      Consonant: b c d f g h j k l m n p q r s t v w x z

@ Pairs
       This optional section contains the definition of pair disjunctions.  Each disjunction is defined as a set of pairs.  Explicit pairs specify
       a sequence of surface symbols and a sequence of zero or one lexical symbol, one of them possibly empty.	A  sequence  is  enclosed  between
       angle  brackets `<' and `>'.  The empty sequence is indicated with `<>'.  In the current implementation only the surface part of a pair can
       be a sequence of more than one element.	The special symbol `?' stands for the class of all possible symbols, including	the  morpheme  and
       word boundary.
       Examples:

	      s_x_z_1 : s/s x/x z/z
	      VowelPair1: a/a e/e i/i o/o u/u
	      VowelPair2: Vowel/Vowel
	      ie.y: <i e>/y
	      Delete_e: <>/e
	      Insert_d: d/<>
	      Surface_Vowel: Vowel/?
	      Lexical_s:  ?/s

	      DoubleConsonant: <b b>/b <d d>/d <f f>/f <g g>/g <k k>/k <m m>/m <p p>/p <s s>/s <t t>/t <v v>/v <z z>/z

       Note that VowelPair1 and VowelPair2 don't specify the same thing: VowelPair2 would match a/o but VowelPair1 would not.

       Implicit pairs are specified by the name of a bi-level symbol or a bi-level class.
       Examples:  the following s_x_z_2 and VowelPair3 are equivalent to the above s_x_z_1 and VowelPair2 (assuming that s, x, z and Vowel are bi-
       level symbols and classes).

	      s_x_z_2 : s x z
	      VowelPair3 : Vowel

       In a pair disjunction all lexical parts should be disjoint. This means you cannot specify for the same pair disjunction a/a and o/a or  a/a
       and Vowel/Vowel.

       In a future version this section will be split in two:  simple pair disjunctions and pair sequences.

@ Spelling
       In  this section are declared the two level spelling rules.  A spelling rule consist of a kind indicator followed by a left context a focus
       and a right context.  The kind indicator is `=>' if the rule is optional, `<=>' if it is obligatory and `<=' if it is  a  surface  coercion
       rule.   The  contexts may be empty.  The focus is surrounded by two `-'.  The contexts and the focus consist of a sequence of pairs or pair
       disjunctions declared in the `@ Pairs section.  A morpheme boundary is indicated by a `+' or a `*', a word boundary is indicated by a `~'.
       Examples:

	      Sibilant_s: <=> s_x_z_1 * - e/<> - s
	      Gemination: <=>
		      Consonant Vowel - DoubleConsonant - * Vowel
	      i_y_optionnel: => a - i/y - * ?/e

       Constraints may be specified in the form of a list of typed feature structures.	They are affix-driven:	the rule is licensed if  at  least
       one  of	them  subsumes	the  closest corresponding affix.  The morpheme boundary indicated by a star (`*') will be used to determine which
       affix it is.  If there is no such indication, then the affix adjacent to the morpheme where the first character	of  the  focus	occurs	is
       used.  In case there is no affix, the typed feature structure of the lexical stem is used.
       Example:

	      Sibilant_s: <=>
		  s_x_z_1 * - e/<> - s NounSuffix[ Number=plural ]

@ Lexicon
       This  section  is  optional and can also be repeated.  This section lists all the lexical entries of the morphological description.  Unlike
       the other sections, definitions do not have a name.  A definition consist of a typed feature strucure followed by a list of  lexical  stems
       that share that feature structure.  A lexical stem consists of the string used in the concatenation specified by the grammar rules followed
       by `=' and a reference string.  The reference string can be anything and usually is used to indicate the canonical form of the word  or	an
       identifier of an external database entry.
       Examples:
	      Noun[ Number=singular ] "table" = "table" "chair" = "chair"
	      Verb[ Transitive=yes|no Inflection=base ] "bow" = "bow1"
	      Noun[ Number=singular ] "bow" = "bow2"

       If the stem string and the reference strings are identical, only one needs to be specified.
       Example:

	      Noun[ Number=singular ] "table" "chair"

FORMAL SYNTAX

       The formal syntax description below is in Backus Naur Form (BNF).  The following conventions apply:

       <id>	 is a non-terminal symbol (within angle brackets).
       ID	 is a token (terminal symbol, all uppercase).
       <id>?	 means zero or one occurrence of <id> (i.e. <id> is optional).
       <id>*	 is zero or more occurrences of <id>.
       <id>+	 is one or more occurrences of <id>.
       ::=	 separates a non-terminal symbol and its expansion.
       |	 indicates an alternative expansion.
       ;	 starts a comment (not part of the definition).

       The start symbol corresponding to a complete description is named <Start>.  Symbols that parse but do nothing are marked with `; not opera-
       tional'.

       <Start>		 ::= <AlphabetDecl> <AttDecl> <TypeDecl> <GramDecl>
			     <ClassDecl>? <PairDecl>? <SpellDecl>? <LexDecl>*

       <AlphabetDecl>	 ::= ALPHABETS <LexicalDef> <SurfaceDef>

       <LexicalDef>	 ::= <LexicalName> COLON <LexicalSymbol>+

       <SurfaceDef>	 ::= <SurfaceName> COLON <SurfaceSymbol>+

       <LexicalSymbol>	 ::= <LexicalSymbolName>    ; lexical only
			 |   <BiLevelSymbolName>    ; both lexical and surface

       <SurfaceSymbol>	 ::= <SurfaceSymbolName>    ; surface only
			 |   <BiLevelSymbolName>    ; both lexical and surface

       <AttDecl>	 ::= ATTRIBUTES <AttDef>+

       <AttDef> 	 ::= <AttName> COLON <ValName>+

       <TypeDecl>	 ::= TYPES <TypeDef>+

       <TypeDef>	 ::= <TypeName> COLON <AttName>+ <NoProjAtt>?

       <NoProjAtt>	 ::= BAR <AttName>+

       <LexDecl>	 ::= LEXICON <LexDef>+

       <LexDef> 	 ::= <Tfs> <Lexical>+

       <Lexical>	 ::= LEXICALSTRING <BaseForm>?

       <BaseForm>	 ::= EQUAL LEXICALSTRING

       <Tfs>		 ::= <TypeName> <AttSpec>?

       <VarTfs> 	 ::= <TypeName> <VarAttSpec>?

       <AttSpec>	 ::= LBRA <AttVal>* RBRA

       <VarAttSpec>	 ::= LBRA <VarAttVal>* RBRA

       <AttVal> 	 ::= <AttName> <ValSpec>

       <VarAttVal>	 ::= <AttName> <VarValSpec>

       <ValSpec>	 ::= EQUAL <ValSet>
			 |   NOTEQUAL <ValSet>

       <VarValSpec>	 ::= <ValSpec>
			 |   EQUAL DOLLAR <VarName>
			 |   EQUAL DOLLAR <VarName> <ValSpec>

       <ValSet> 	 ::= <ValName> <ValSetRest>*

       <ValSetRest>	 ::= BAR <ValName>

       <GramDecl>	 ::= GRAMMAR <Rule>+

       <RuleDef>	 ::= <RuleName> COLON <RuleBody>

       <RuleBody>	 ::= <VarTfs> LARROW <Rhs>
			 |   <Tfs>    ; goal rule
			 |   LEXICALSTRING <Tfs>    ; lexical affix

       <Rhs>		 ::= <VarTfs>	 ; unary rule
			 |   <VarTfs> <VarTfs>	  ; binary rule
			 |   LEXICALSTRING <Tfs> <VarTfs>   ; prefix rule
			 |   <VarTfs> <Tfs> LEXICALSTRING    ; suffix rule

       <ClassDecl>	 ::= CLASSES<ClassDef>+

       <ClassDef>	 ::= <LexicalClassName> COLON <LexicalClass>+
			 |   <SurfaceClassName> COLON <SurfaceClass>+
			 |   <BiLevelClassName> COLON <BiLevelClass>+

       <LexicalClass>	 ::= <LexicalSymbol>
			 |   <LexicalClassName>
			 |   <BiLevelClassName>

       <SurfaceClass>	 ::= <SurfaceSymbol>
			 |   <SurfaceClassName>
			 |   <BiLevelClassName>

       <BiLevelClass>	 ::= <BiLevelSymbolName>
			 |   <BiLevelClassName>

       <PairDecl>	 ::= PAIRS <PairDef>+

       <PairDef>	 ::= <PairName> COLON <PairDef>+

       <PairDef>	 ::= <PairName> COLON <Pair>+

       <Pair>		 ::= <SurfaceSequence> SLASH <LexicalSequence>
			 |   <PairName>
			 |   <BiLevelClassName>
			 |   <BiLevelSymbolName>

       SurfaceSequence	 ::= LANGLE <SurfaceSymbol>* RANGLE
			 |   SURFACESTRING
			 |   <SurfaceClass>
			 |   ANY

       LexicalSequence	 ::= LANGLE <LexicalSymbol>* RANGLE
			 |   LEXICALSTRING
			 |   <LexicalClass>
			 |   ANY

       <SpellDecl>	 ::= SPELLING <SpellDef>+

       <SpellDef>	 ::= <SpellName> COLON <Arrow> <LeftContext> <Focus>
				 <RightContext> <Constraint>*

       <LeftContext>	 ::= <Pattern>*

       <RightContext>	 ::= <Pattern>*

       <Focus>		 ::= CONTEXTBOUNDARY <Pattern>+ CONTEXTBOUNDARY

       <Pattern>	 ::= <Pair>
			 |   MORPHEMEBOUNDARY
			 |   WORDBOUNDARY
			 |   CONCATBOUNDARY

       <Constraint>	 ::= <Tfs>

       <Arrow>		 ::= RARROW
			 |   BIARROW
			 |   COERCEARROW

       <AttName>	   ::= NAME
       <BiLevelClassName>  ::= NAME
       <BiLevelSymbolName> ::= NAME  | SYMBOLSTRING
       <LexicalClassName>  ::= NAME
       <LexicalName>	   ::= NAME
       <LexicalSymbolName> ::= NAME  | SYMBOLSTRING
       <PairName>	   ::= NAME
       <RuleName>	   ::= NAME
       <SpellName>	   ::= NAME
       <SurfaceClassName>  ::= NAME
       <SurfaceName>	   ::= NAME
       <SurfaceSymbolName> ::= NAME  | SYMBOLSTRING
       <TypeName>	   ::= NAME
       <ValName>	   ::= NAME
       <VarName>	   ::= NAME

   Simple tokens
       Simple tokens of the BNF above are defined as follow: The token name on the left correspond to the literal character or characters  on  the
       right:

       ANY		   ?
       BAR		   |
       BIARROW		   <=>
       COERCEARROW	   <=
       COLON		   :
       CONCATBOUNDARY	   *
       CONTEXTBOUNDARY	   -
       DOLLAR		   $
       EQUAL		   =
       LANGLE		   <
       LARROW		   <-
       LBRA		   ]
       MORPHEMEBOUNDARY    +
       NOTEQUAL 	   !=
       RARROW		   =>
       RANGLE		   <
       RBRA		   [
       SLASH		   /
       WORDBOUNDARY	   ~

       ALPHABETS	   @Alphabets
       ATTRIBUTES	   @Attributes
       CLASSES		   @Classes
       GRAMMAR		   @Grammar
       LEXICON		   @Lexicon
       PAIRS		   @Pairs
       SPELLING 	   @Spelling
       TYPES		   @Types

       In the section header tokens above, spaces may separate the `@' from the reserved word.

   Complex tokens
       NAME
	      is any sequence of letter, digit, underline (`_'), period (`.')
	      Examples:
	      category
	      33
	      Rule_9
	      __2__
	      Proper.Noun

       LEXICALSTRING
	      is a string of lexical symbols

       SURFACESTRING
	      is a string of surface symbols

       SYMBOLSTRING
	      is a string of just just one character (used only in alphabet declaration).

       A  string consist of zero or more characters within double quotes (`"').  Characters preceded by a backslash (`') are escaped (the usual C
       escaping convention apply).  Symbols that have a name longer than one character are represented using a SGML entity like  notation:  `&sym-
       bolname;'.  The maximum number of symbols in a string is 127.
       Examples:

	      "table"
	      ","
	      ""
	      "double quote is " and backslash is \"
	      "&strong_e;"
	      "escape like in C : 	 is ASCII tab"
	      "escape with octal code: 11 is ASCII tab"

       Tokens can be separated by one or many blanks or comments.
       A blank separator is space, tab or newline.
       A comment starts with a semicolon and finishes at the next newline (except when the semicolon occurs in a string.

       Inclusion of files can be specified with the usual `#include' directive:
       Example:
	      #include "verb.entries"

       will splice in the content of the file verb.entries at the point where this directive occurs.

       The  `#'  should  be  the first character on the line.  Tabs or spaces may separate `#' and `include'.  The file name must be quoted.  Only
       tabs or spaces may occur on the rest of the line.  Inclusion can be nested up to 10 levels.

SEE ALSO

       mmorph(1).

       G. Russell and D. Petitpierre, MMORPH - The Multext Morphology Program, Version 2.3, October 1995,  MULTEXT  deliverable  report  for  task
	      2.3.1.

AUTHOR

       Dominique Petitpierre, ISSCO, <petitp@divsun.unige.ch>

COMMENTS

       The  parser  for  the  morphology  description  formalims  above was written using yacc (1) and flex (1).  Flex was written by Vern Paxson,
       <vern@ee.lbl.gov>, and is distributed in the framework of the GNU project under the condition of the GNU General Public License

							     Version 2.3, October 1995							 MMORPH(5)