package xtc.parser; header { import xtc.util.Utilities; import xtc.tree.Attribute; } class PParser; body { public static String makeString (Object value) { if( value != null ) { if( value instanceof Pair ) { return " " + ((Pair)value).list().toString() + " "; } else { return " " + value.toString() + " "; } } else { return " null "; } } } option location,debug,mainMethod; top text; // This is a Parsing Expression Grammar for Lojban. // See http://www.pdos.lcs.mit.edu/~baford/packrat/ // // All rules have the form: // // name <- peg-expression // // which means that the grammatical construct "name" is parsed using // "peg-expression". // // 1) Names in lower case are grammatical constructs. // 2) Names in UPPER CASE are selma'o (lexeme) names, and are terminals. // 3) Concatenation is expressed by juxtaposition with no operator symbol. // 4) / represents *ORDERED* alternation (choice). If the first // option succeeds, the others will never be checked. // 5) ? indicates that the element to the left is optional. // 6) * represents optional repetition of the construct to the left. // 7) + represents one-or-more repetition of the construct to the left. // 8) () serves to indicate the grouping of the other operators. // // Longest match wins. // --- GRAMMAR --- // This mess here is to allow the following preference relation: // 1. no joik-jek, text-1 // 2. joik-jek, text-1 optional // 3. neither //String text = (spacesNotY* suClause* spacesNotY* (Y !BU)? siClause NAI* ((CMENE !ZEI !BU)+ free* / (indicators free+ / indicators / free+))? text1 (FAhO dotStar)?) / (spacesNotY* suClause* spacesNotY* (Y !BU)? siClause NAI* ((CMENE !ZEI !BU)+ free* / (indicators free+ / indicators / free+))? joikJek text1? (FAhO dotStar)?) / (spacesNotY* suClause* spacesNotY* (Y !BU)? siClause NAI* ((CMENE !ZEI !BU)+ free* / (indicators free+ / indicators / free+))? (FAhO dotStar)?); //String text = a:spacesNotY* b:suClause* c:spacesNotY* d:(Y !BU)? e:siClause f:NAI* g:(yyValue:(CMENE !ZEI !BU)+ free* / (yyValue:indicators free+ / yyValue:indicators / yyValue:free+))? h:text1 i:(FAhO Anything)? { yyValue = "text=(" + a.toString() + b.toString() + c.toString() + d.toString() + e.toString() + f.toString() + g.toString() + h.toString() + makeString(i) + ")"; }; //String text = (a:spacesNotY* b:suClause* c:spacesNotY* d:(Y !BU)? e:siClause f:NAI* g:(a:(CMENE !ZEI !BU)+ b:free* { yyValue = "g=(" + makeString(a) + makeString(b) + ")"; } / (a:indicators b:free+ { yyValue = makeString(a) + makeString(b); } / a:indicators { yyValue = makeString(a); } / a:free+ { yyValue = makeString(a); }))? h:text1 i:(FAhO Anything)? { yyValue = "text=(" + makeString(a) + makeString(b) + makeString(c) + makeString(d) + makeString(e) + makeString(f) + makeString(g) + makeString(h) + makeString(i) + ")"; }) / (a:spacesNotY* b:suClause* c:spacesNotY* d:(Y !BU )? e:siClause f:NAI* g:(a:(CMENE !ZEI !BU)+ b:free* { yyValue = "g=(" + makeString(a) + makeString(b) + ")"; } / (a:indicators b:free+ { yyValue = makeString(a) + makeString(b); } / a:indicators { yyValue = makeString(a); } / a:free+ { yyValue = makeString(a); }))? g2:joikJek h:text1? i:(FAhO Anything)? { yyValue = "text=(" + makeString(a) + makeString(b) + makeString(c) + makeString(d) + makeString(e) + makeString(f) + makeString(g) + makeString(g2) + makeString(h) + makeString(i) + ")"; }) ; void Anything = .*; String text = (spacesNotYSEP1:spacesNotY* suClauseSEP2:suClause* spacesNotYSEP3:spacesNotY* PARSERparen4:(Y !BU)? siClauseSEP5:siClause NAISEP6:NAI* PARSERparen7:(PARSERparen1:(CMENE !ZEI !BU)+ freeSEP2:free* { yyValue = "PARSERparen1=(" + makeString(PARSERparen1) + ")" + "free=(" + makeString(freeSEP2) + ")" + "" ; }/ (indicatorsSEP1:indicators freeSEP2:free+ { yyValue = "indicators=(" + makeString(indicatorsSEP1) + ")" + "free=(" + makeString(freeSEP2) + ")" + "" ; }/ indicators / free+))? text1SEP8:text1 PARSERparen9:(FAhOSEP1:FAhO dotStarSEP2:dotStar{ yyValue = "FAhO=(" + makeString(FAhOSEP1) + ")" + "dotStar=(" + makeString(dotStarSEP2) + ")" + "" ; })?{ yyValue = "spacesNotY=(" + makeString(spacesNotYSEP1) + ")" + "suClause=(" + makeString(suClauseSEP2) + ")" +"spacesNotY=(" + makeString(spacesNotYSEP3) + ")" + "PARSERparen4=(" + makeString(PARSERparen4) + ")" + "siClause=(" + makeString(siClauseSEP5) + ")" + "NAI=(" + makeString(NAISEP6) + ")" + "PARSERparen7=(" + makeString(PARSERparen7) + ")" + "text1=(" + makeString(text1SEP8) + ")" + "PARSERparen9=(" + makeString(PARSERparen9) + ")" + "" ; }) / (spacesNotYSEP1:spacesNotY* suClauseSEP2:suClause* spacesNotYSEP3:spacesNotY* PARSERparen4:(Y !BU)? siClauseSEP5:siClause NAISEP6:NAI* PARSERparen7:(PARSERparen1:(CMENE !ZEI !BU)+ freeSEP2:free* { yyValue = "PARSERparen1=(" + makeString(PARSERparen1) + ")" + "free=(" + makeString(freeSEP2) + ")" + "" ; }/ (indicatorsSEP1:indicators freeSEP2:free+ { yyValue = "indicators=(" + makeString(indicatorsSEP1) + ")" + "free=(" + makeString(freeSEP2) + ")" + "" ; }/ indicators / free+))? joikJekSEP8:joikJek text1SEP9:text1? PARSERparen10:(FAhOSEP1:FAhO dotStarSEP2:dotStar{ yyValue = "FAhO=(" + makeString(FAhOSEP1) + ")" + "dotStar=(" + makeString(dotStarSEP2) + ")" + "" ; })?{ yyValue = "spacesNotY=(" + makeString(spacesNotYSEP1) + ")" + "suClause=(" + makeString(suClauseSEP2) + ")" + "spacesNotY=(" + makeString(spacesNotYSEP3) + ")" + "PARSERparen4=(" + makeString(PARSERparen4) + ")" + "siClause=(" + makeString(siClauseSEP5) + ")" + "NAI=(" + makeString(NAISEP6) + ")" + "PARSERparen7=(" + makeString(PARSERparen7) + ")" + "joikJek=(" + makeString(joikJekSEP8) + ")" + "text1=(" + makeString(text1SEP9) + ")" + "PARSERparen10=(" + makeString(PARSERparen10) + ")" + "" ; }) / (spacesNotYSEP1:spacesNotY* suClauseSEP2:suClause* spacesNotYSEP3:spacesNotY* PARSERparen4:(Y !BU)? siClauseSEP5:siClause NAISEP6:NAI* PARSERparen7:(PARSERparen1:(CMENE !ZEI !BU)+ freeSEP2:free* { yyValue = "PARSERparen1=(" + makeString(PARSERparen1) + ")" + "free=(" + makeString(freeSEP2) + ")" + "" ; }/ (indicatorsSEP1:indicators freeSEP2:free+ { yyValue = "indicators=(" + makeString(indicatorsSEP1) + ")" + "free=(" + makeString(freeSEP2) + ")" + "" ; }/ indicators / free+))? PARSERparen8:(FAhOSEP1:FAhO dotStarSEP2:dotStar{ yyValue = "FAhO=(" + makeString(FAhOSEP1) + ")" + "dotStar=(" + makeString(dotStarSEP2) + ")" + "" ; })?{ yyValue = "spacesNotY=(" + makeString(spacesNotYSEP1) + ")" + "suClause=(" + makeString(suClauseSEP2) + ")" + "spacesNotY=(" + makeString(spacesNotYSEP3) + ")" + "PARSERparen4=(" + makeString(PARSERparen4) + ")" + "siClause=(" + makeString(siClauseSEP5) + ")" + "NAI=(" + makeString(NAISEP6) + ")" + "PARSERparen7=(" + makeString(PARSERparen7) + ")" + "PARSERparen8=(" + makeString(PARSERparen8) + ")" + "" ; }); String dotStar = .*; // Please note that the "text-1" item in the text-1 production does // *not* match the BNF. This is due to a bug in the BNF. The change // here was made to match grammar.300 String text1 = I (jek / joik)? (stag? BO)? free* text1? / NIhO+ free* suClause* spacesNotY* paragraphs? / paragraphs; String paragraphs = paragraph (NIhO+ free* suClause* spacesNotY* paragraphs)?; String paragraph = (statement / fragment) (I !jek !joik !joikJek free* (statement / fragment)?)*; String statement = statement1 / prenex statement; String statement1 = statement2 (I joikJek statement2)* / statement2 (I joikJek statement2?)*; String statement2 = statement3 (I (jek / joik)? stag? BO free* statement2)? / statement3 (I (jek / joik)? stag? BO free*)?; String statement3 = sentence / tag? TUhE free* text1 (TUhU free*)?; String fragment = terms (VAU free*)? / ek free* / gihek free* / quantifier / NA free* / prenex / relativeClauses / links / linkargs; String prenex = terms ZOhU free*; String sentence = (terms (CU free*)?)? bridiTail / bridiTail; String subsentence = sentence / prenex subsentence; String bridiTail = bridiTail1 (gihek stag? KE free* bridiTail (KEhE free*)? tailTerms)?; String bridiTail1 = bridiTail2 (gihek !(stag? BO) !(stag? KE) free* bridiTail2 tailTerms)*; String bridiTail2 = bridiTail3 (gihek stag? BO free* bridiTail2 tailTerms)?; String bridiTail3 = selbri tailTerms / gekSentence; String gekSentence = gek subsentence gik subsentence tailTerms / tag? KE free* gekSentence (KEhE free*)? / NA free* gekSentence; String tailTerms = terms? (VAU free*)?; String terms = terms1+; String terms1 = terms2 (PEhE free* joikJek terms2)*; String terms2 = term (CEhE free* term)*; String term = sumti / ( !gek (tag / FA free*) (sumti / (KU free*)?) ) / termset / NA KU free*; String termset = NUhI free* gek terms (NUhU free*)? gik terms (NUhU free*)? / NUhI free* terms (NUhU free*)?; String sumti = sumti1 (VUhO free* relativeClauses)?; String sumti1 = sumti2 ((ek / joik) stag? KE free* sumti (KEhE free*)?)?; String sumti2 = sumti3 (joikEk sumti3)*; String sumti3 = sumti4 ((ek / joik) stag? BO free* sumti3)?; String sumti4 = sumti5 / gek sumti gik sumti4; String sumti5 = quantifier? sumti6 relativeClauses? / quantifier selbri (KU free*)? relativeClauses?; String sumti6 = zoClause / LOhU lohuTail free* / lerfuStringNoMOI (BOI free*)? / (LAhE free* / NAhE BO free*) relativeClauses? sumti (LUhU free*)? / KOhA free* / LA free* relativeClauses? CMENE+ free* / (LA / LE) free* sumtiTail (KU free*)? / LI free* mex (LOhO free*)? ; // / ZOI any-word anything any-word free* String zoClause = ZO zoSiClause? Y free* / ZO zoSiClause? anyWord free*; String zoSiClause = (Y / anyWordNoSIHandling) SI / (Y / anyWordNoSIHandling) zoSiClause SI; String lohuTail = lehuSiClause lohuTail / LEhU / anyWordNoSIHandling lohuTail; String lehuSiClause = LEhU SI / anyWordNoSIHandling SI / LEhU lehuSiClause SI / anyWordNoSIHandling lehuSiClause SI ; String sumtiTail = (sumti6 relativeClauses?)? sumtiTail1 / relativeClauses sumtiTail1; String sumtiTail1 = selbri relativeClauses? / quantifier selbri relativeClauses? / quantifier sumti; String relativeClauses = relativeClause (ZIhE free* relativeClause)*; String relativeClause = GOI free* term (GEhU free*)? / NOI free* subsentence (KUhO free*)?; String selbri = tag? selbri1; String selbri1 = selbri2 / NA free* selbri; String selbri2 = selbri3 (CO free* selbri2)?; String selbri3 = selbri4+; String selbri4 = selbri5 (joikJek selbri5 / joik stag? KE free* selbri3 (KEhE free*)?)*; String selbri5 = selbri6 ((jek / joik) stag? BO free* selbri5)?; String selbri6 = tanruUnit (BO free* selbri6)? / (NAhE free*)? guhek selbri gik selbri6; String tanruUnit = tanruUnit1 (CEI free* tanruUnit1)*; String tanruUnit1 = tanruUnit2 linkargs?; String tanruUnit2 = anyWord (ZEI anyWord)+ / BRIVLA free* / GOhA RAhO? free* / KE free* selbri3 (KEhE free*)? / ME free* sumti (MEhU free*)? (MOI free*)? / (number / lerfuString) MOI free* / NUhA free* mexOperator / SE free* tanruUnit2 / JAI free* tag? tanruUnit2 / NAhE free* tanruUnit2 / NU NAI? free* (joikJek NU NAI? free*)* subsentence (KEI free*)?; String linkargs = BE free* term links? (BEhO free*)?; String links = BEI free* term links?; String quantifier = number !MOI (BOI free*)? / VEI free* mex (VEhO free*)?; String mex = mex1 (operator mex1)* / FUhA free* rpExpression; String mex1 = mex2 (BIhE free* operator mex1)?; String mex2 = operand / (PEhO free*)? operator mex2+ (KUhE free*)?; //li fu'a reboi ci pi'i voboi mu pi'i su'i reboi ci vu'u su'i du li rexa //rp-expression <- rp-operand rp-operand operator //rp-operand <- operand / rp-expression String rpExpression = operand rpExpressionTail; String rpExpressionTail = rpExpression operator rpExpressionTail / (); String operator = operator1 (joikJek operator1 / joik stag? KE free* operator (KEhE free*)?)*; String operator1 = operator2 / guhek operator1 gik operator2 / operator2 (jek / joik) stag? BO free* operator1; String operator2 = mexOperator / KE free* operator (KEhE free*)?; String mexOperator = SE free* mexOperator / NAhE free* mexOperator / MAhO free* mex (TEhU free*)? / NAhU free* selbri (TEhU free*)? / VUhU free*; String operand = operand1 ((ek / joik) stag? KE free* operand (KEhE free*)?)?; String operand1 = operand2 (joikEk operand2)*; String operand2 = operand3 ((ek / joik) stag? BO free* operand2)?; String operand3 = quantifier / lerfuStringNoMOI (BOI free*)? / NIhE free* selbri (TEhU free*)? / MOhE free* sumti (TEhU free*)? / JOhI free* mex2+ (TEhU free*)? / gek operand gik operand3 / (LAhE free* / NAhE BO free*) operand (LUhU free*)?; String number = PA (PA / lerfuWord)*; String lerfuStringNoMOI = lerfuWord !MOI (PA !MOI / lerfuWord !MOI)*; String lerfuString = lerfuWord (PA / lerfuWord)*; String lerfuWord = buClause / BY / LAU lerfuWord / TEI lerfuString FOI; String buClause = BAhE BU+ / Y BU+ / !BUBare anyWordNoBUHandling BU+; String ek = NA? SE? A NAI?; String gihek = NA? SE? GIhA NAI?; String jek = NA? SE? JA NAI?; String joik = SE? JOI NAI? / interval / GAhO interval GAhO; String interval = SE? BIhI NAI?; String joikEk = joik free* / ek free*; String joikJek = joik free* / jek free*; String gek = SE? GA NAI? free* / joik GI free* / stag gik; String guhek = SE? GUhA NAI? free*; String gik = GI NAI? free*; String tag = tenseModal (joikJek tenseModal)*; String stag = simpleTenseModal ((jek / joik) simpleTenseModal)*; String tenseModal = simpleTenseModal free* / FIhO free* selbri (FEhU free*)?; String simpleTenseModal = NAhE? SE? BAI NAI? KI? / NAhE? ( ((time space? / space time?) CAhA) / (time space? / space time?) / CAhA ) KI? / KI / CUhE; String time = ZI timeOffset* (ZEhA (PU NAI?)?)? intervalProperty* / ZI? timeOffset+ (ZEhA (PU NAI?)?)? intervalProperty* / ZI? timeOffset* ZEhA (PU NAI?)? intervalProperty* / ZI? timeOffset* (ZEhA (PU NAI?)?)? intervalProperty+; String timeOffset = PU NAI? ZI?; String space = VA spaceOffset* spaceInterval? (MOhI spaceOffset)? / VA? spaceOffset+ spaceInterval? (MOhI spaceOffset)? / VA? spaceOffset* spaceInterval (MOhI spaceOffset)? / VA? spaceOffset* spaceInterval? MOhI spaceOffset; String spaceOffset = FAhA NAI? VA?; String spaceInterval = (VEhA / VIhA / VEhA VIhA) (FAhA NAI?)? spaceIntProps / (VEhA / VIhA / VEhA VIhA) (FAhA NAI?)? / spaceIntProps; String spaceIntProps = (FEhE intervalProperty)+; String intervalProperty = number ROI NAI? / TAhE NAI? / ZAhO NAI?; String free = SEI free* (terms (CU free*)?)? selbri SEhU? / SOI free* sumti sumti? SEhU? / vocative relativeClauses? selbri relativeClauses? DOhU? / vocative relativeClauses? CMENE+ free* relativeClauses? DOhU? / vocative sumti? DOhU? / (number / lerfuString) MAI / XI free* (number / lerfuString) BOI? / XI free* VEI free* mex VEhO?; String vocative = (COI NAI?)+ DOI / (COI NAI?)+ / DOI; String indicators = FUhE? indicator+; String indicator = ((UI / CAI) NAI? / Y / DAhO / FUhO) !BUBare; // The following rules are non-formal: // // word<1100> <- [BAhE] any-word [indicators] // // null<1101> <- any-word SI / utterance SA / text SU // any single lexable Lojban words String anyWord = CMAVO / BRIVLA / CMENE; String anyWordNoSIHandling = CMAVONoSIHandling / BRIVLANoSIHandling / CMENENoSIHandling; String anyWordNoSAHandling = CMAVONoSAHandling / BRIVLANoSIHandling / CMENENoSIHandling; String anyWordNoBUHandling = CMAVONoBUHandling / BRIVLANoBUHandling / CMENENoBUHandling; // a possibly unlexable phoneme string // anything <- "AnyThing" // --- MORPHOLOGY --- //; -- General Morphology Issues // // 1. Spaces (including '.y') and UI are eaten *after* a word. // // 2. Morphology is checked *before* a word. // // 3. BAhE is eaten *before* a word. // // 4. -words should be used only in those situations where // we are Really Sure that we don't need to worry about morphology. In other words, basically never. //; -- Letter Groups String consonant = [bcdfgjklmnprstvxz]; String initialPair = "bl" / "br" / "cf" / "ck" / "cl" / "cm" / "cn" / "cp" / "cr" / "ct" / "dj" / "dr" / "dz" / "fl" / "fr" / "gl" / "gr" / "jb" / "jd" / "jg" / "jm" / "jv" / "kl" / "kr" / "ml" / "mr" / "pl" / "pr" / "sf" / "sk" / "sl" / "sm" / "sn" / "sp" / "sr" / "st" / "tc" / "tr" / "ts" / "vl" / "vr" / "xl" / "xr" / "zb" / "zd" / "zg" / "zm" / "zv"; String cmeneConsonant = [bcdfgjklmnprstvxz] / [BCDFGJKLMNPRSTVXZ]; String vowel = [aeiouy]; String vowelNotY = [aeiou]; String otherLetter = [',]; String lojbanLetter = consonant / vowel / otherLetter; String cmeneLetter = lojbanLetter / [BCDFGJKLMNPRSTVXZ] / [AEIOU] / [hY]; String anyLetter = cmeneLetter / [09]; // Indicator absorbtion; grammar.300 4d and 4e String absorbIndicators = UI NAI? / CAI NAI? / Y / DAhO / FUhO / FUhE; // Handling of spaces String spacing = !. / spaces+ siClause absorbIndicators*; String spacingOpt = !. / spaces+ siClause absorbIndicators* / siClause absorbIndicators*; String spaceChars = '.' / ' ' / '\n' / '\t' / '\r' / '?' / '!'; String spaces = spaceChars+ 'y'+ !['] !vowel / '.' / ' ' / '\n' / '\t' / '\r' / '?' / '!'; String spacesNotY = '.' / ' ' / '\n' / '\t' / '\r' / '?' / '!'; // SU clauses String suClause = (!SU !NIhO !LU !TUhE !TO anyWord)+ SU / SU; // Handling of SI and interactions with zo and lo'u...le'u String siClause = (LOhU lohuTailSiClause SI / !LOhU !SI !ZO anyWordNoSIHandling SI / !LOhU !SI !ZO anyWordNoSIHandling siClause SI )* ENDSICLAUSE; //; This is just to make reading the parser output easier. String ENDSICLAUSE = (); String lohuTailSiClause = LEhUNoSIHandling siClause SI / !SI anyWordNoSIHandling lohuTailSiClause SI; // For handling things of higher priority than SI (i.e. lo'u...le'u, zo) String spacingNoSIHandling = spaces+; String spacingNoSIHandlingOpt = spaces*; String siSpacing = spaces+; // For handling BU issues String spacingNoBUHandling = spaces+ absorbIndicators*; String spacingNoBUHandlingOpt = spaces* absorbIndicators*; // any brivla // For now: gismu pattern. // BRIVLA : /[bcdfgjklmnprstvxz]{2}['a-z]{2,}[aeiou]/ // / /[bcdfgjklmnprstvxz][aeiou][bcdfgjklmnprstvxz]y?[bcdfgjklmnprstvxz]['a-z]*[aeiou]/ // / /[bcdfgjklmnprstvxz][aeiou]'?[aeiou][bcdfgjklmnprstvxz]{2}['a-z]*[aeiou]/ // / /[aeiou]('?[aeiou]){,2}[bcdfgjklmnprstvxz]{2}['a-z]*[aeiou]/ String BRIVLA = BAhE? initialPair lojbanLetter lojbanLetter brivlaTail / BAhE? consonant !"y" vowel consonant 'y'? consonant brivlaTail / BAhE? consonant !"y" vowel [']? !"y" vowel consonant consonant brivlaTail; /// FUHIVLA // FUHIVLA <- !['] consonant consonant brivla-tail / !CMAVO cmene-letter consonant consonant brivla-tail / !CMAVO cmene-letter cmene-letter consonant consonant brivla-tail / cmene-letter cmene-letter consonant "y" consonant (consonant / vowel-not-y) brivla-tail / cmene-letter cmene-letter cmene-letter consonant consonant brivla-tail String brivlaTail = vowelNotY spacing / lojbanLetter brivlaTail; String BRIVLANoSIHandling = initialPair lojbanLetter lojbanLetter brivlaTailNoSIHandling / consonant !"y" vowel consonant 'y'? consonant brivlaTailNoSIHandling / consonant !"y" vowel [']? !"y" vowel consonant consonant brivlaTailNoSIHandling; String brivlaTailNoSIHandling = vowelNotY spacingNoSIHandling / lojbanLetter brivlaTailNoSIHandling; String BRIVLANoBUHandling = initialPair lojbanLetter lojbanLetter brivlaTailNoBUHandling / consonant !"y" vowel consonant 'y'? consonant brivlaTailNoBUHandling / consonant !"y" vowel [']? !"y" vowel consonant consonant brivlaTailNoBUHandling; String brivlaTailNoBUHandling = vowelNotY spacingNoBUHandling / lojbanLetter brivlaTailNoBUHandling; // CMENE <- /\.?[,'a-pr-z]+[bcdfgjklmnprstvxz]/ String CMENE = BAhE? cmeneLetter cmeneTail; String cmeneTail = cmeneConsonant !"y" spacing / cmeneLetter cmeneTail; String CMENENoSIHandling = cmeneLetter cmeneTailNoSIHandling; String cmeneTailNoSIHandling = cmeneConsonant !"y" spacingNoSIHandling / cmeneLetter cmeneTailNoSIHandling; String CMENENoBUHandling = cmeneLetter cmeneTailNoBUHandling; String cmeneTailNoBUHandling = cmeneConsonant !"y" spacingNoBUHandling / cmeneLetter cmeneTailNoBUHandling; //; CMAVO morphology String CMAVOPostMorphology = &spaces+ / CMAVOCmeneCheck (CMAVOBrivlaCheck / CMAVOConsonantCheck); String CMAVOBrivlaCheck = &(consonant? vowel (['] vowel / vowel)* initialPair vowel lojbanLetter lojbanLetter) ; String CMAVOCmeneCheck = !( cmeneLetter CMAVOCmeneCheckTail ); String CMAVOCmeneCheckTail = consonant &spaces+ / cmeneLetter CMAVOCmeneCheckTail; String CMAVOConsonantCheck = !['] !( consonant consonant / cmeneLetter consonant consonant / cmeneLetter cmeneLetter consonant consonant / cmeneLetter cmeneLetter consonant "y" consonant (consonant / vowelNotY) / cmeneLetter cmeneLetter cmeneLetter consonant consonant ); // The "CMAVO-post" productions only occur after another cmavo as a // test for whether another cmavo immediately follows, with no // intervening spaces; hence must start with consonant. String CMAVOPost = !. / (spaces+ / !vowel) CMAVOPostMorphology knownCmavo / !vowel CMAVOPostMorphology consonant vowel (['] vowel / vowel)+; String CMAVOPostNoSIHandling = !. / !vowel CMAVOPostMorphology consonant vowel (['] vowel / vowel)*; String CMAVOPostNoBUHandling = !. / !vowel CMAVOPostMorphology consonant vowel (['] vowel / vowel)*; String CMAVO = preCmavoCheck knownCmavo / preCmavoCheck consonant? vowel (['] vowel / vowel)+ spacing !BUBare; String CMAVONoSIHandling = preCmavoCheck consonant? vowel (['] vowel / vowel)* postCmavoNoSIHandling; String CMAVONoSAHandling = preCmavoCheck consonant? vowel (['] vowel / vowel)* postCmavo; String CMAVONoBUHandling = preCmavoCheck consonant? vowel (['] vowel / vowel)* postCmavoNoBUHandling; String knownCmavo = A / BAI / BAhE / BE / BEI / BEhO / BIhE / BIhI / BO / BOI / BU / BY / CAI / CAhA / CEI / CEhE / CO / COI / CU / CUhE / DAhO / DOI / DOhU / FA / FAhA / FAhO / FEhE / FEhU / FIhO / FOI / FUhA / FUhE / FUhO / GA / GAhO / GEhU / GI / GIhA / GOI / GOhA / GUhA / I / JA / JAI / JOI / JOhI / KE / KEI / KEhE / KI / KOhA / KU / KUhE / KUhO / LA / LAU / LAhE / LE / LEhU / LI / LIhU / LOhO / LOhU / LU / LUhU / MAI / MAhO / ME / MEhU / MOI / MOhE / MOhI / NA / NAI / NAhE / NAhU / NIhE / NIhO / NOI / NU / NUhA / NUhI / NUhU / PA / PEhE / PEhO / PU / RAhO / ROI / SA / SE / SEI / SEhU / SI / SOI / SU / TAhE / TEI / TEhU / TO / TOI / TUhE / TUhU / UI / VA / VAU / VEI / VEhA / VEhO / VIhA / VUhO / VUhU / XI / Y / ZAhO / ZEI / ZEhA / ZI / ZIhE / ZO / ZOI / ZOhU; // Handling of what can go after a cmavo String postCmavo = !BUBare !['] !vowel spacingOpt; String preCmavoCheck = !BRIVLA !CMENE; String postCmavoNoSIHandling = !['] !vowel ( !. / spaces+ / &SI); String postCmavoNoBUHandling = !['] !vowel ( spacingNoBUHandlingOpt / &BU ); String preCmavo = BAhE? preCmavoCheck; // --- SELMAHO --- // eks; basic afterthought logical connectives String A = preCmavo ASaClause? AWords postCmavo; String ANoSAHandling = preCmavo AWords postCmavo; String ASaClause = AWords spaces* ASaTail; String ASaTail = SA &(preCmavo AWords) / !AWords anyWordNoSAHandling ASaTail; String AWords = "a" / "e" / "ji" / "o" / "u"; // modal operators String BAI = preCmavo BAISaClause? BAIWords postCmavo; String BAINoSAHandling = preCmavo BAIWords postCmavo; String BAISaClause = BAIWords spaces* BAISaTail; String BAISaTail = SA &(preCmavo BAIWords) / !BAIWords anyWordNoSAHandling BAISaTail; String BAIWords = "du'o" / "si'u" / "zau" / "ki'i" / "du'i" / "cu'u" / "tu'i" / "ti'u" / "di'o" / "ji'u" / "ri'a" / "ni'i" / "mu'i" / "ki'u" / "va'u" / "koi" / "ca'i" / "ta'i" / "pu'e" / "ja'i" / "kai" / "bai" / "fi'e" / "de'i" / "ci'o" / "mau" / "mu'u" / "ri'i" / "ra'i" / "ka'a" / "pa'u" / "pa'a" / "le'a" / "ku'u" / "tai" / "bau" / "ma'i" / "ci'e" / "fau" / "po'i" / "cau" / "ma'e" / "ci'u" / "ra'a" / "pu'a" / "li'e" / "la'u" / "ba'i" / "ka'i" / "sau" / "fa'e" / "be'i" / "ti'i" / "ja'e" / "ga'a" / "va'o" / "ji'o" / "me'a" / "do'e" / "ji'e" / "pi'o" / "gau" / "zu'e" / "me'e" / "rai"; // next word intensifier String BAhE = (BAhEWords postCmavo)+; String BAhEWords = "ba'e" / "za'e"; // sumti link to attach sumti to a selbri String BE = preCmavo BESaClause? BEWords postCmavo; String BENoSAHandling = preCmavo BEWords postCmavo; String BESaClause = BEWords spaces* BESaTail; String BESaTail = SA &(preCmavo BEWords) / !BEWords anyWordNoSAHandling BESaTail; String BEWords = "be"; // multiple sumti separator between BE, BEI String BEI = preCmavo BEISaClause? BEIWords postCmavo; String BEINoSAHandling = preCmavo BEIWords postCmavo; String BEISaClause = BEIWords spaces* BEISaTail; String BEISaTail = SA &(preCmavo BEIWords) / !BEIWords anyWordNoSAHandling BEISaTail; String BEIWords = "bei"; // terminates BEBEI specified descriptors String BEhO = preCmavo BEhOSaClause? BEhOWords postCmavo; String BEhONoSAHandling = preCmavo BEhOWords postCmavo; String BEhOSaClause = BEhOWords spaces* BEhOSaTail; String BEhOSaTail = SA &(preCmavo BEhOWords) / !BEhOWords anyWordNoSAHandling BEhOSaTail; String BEhOWords = "be'o"; // prefix for high-priority MEX operator String BIhE = preCmavo BIhESaClause? BIhEWords postCmavo; String BIhENoSAHandling = preCmavo BIhEWords postCmavo; String BIhESaClause = BIhEWords spaces* BIhESaTail; String BIhESaTail = SA &(preCmavo BIhEWords) / !BIhEWords anyWordNoSAHandling BIhESaTail; String BIhEWords = "bi'e"; // interval component of JOI String BIhI = preCmavo BIhISaClause? BIhIWords postCmavo; String BIhINoSAHandling = preCmavo BIhIWords postCmavo; String BIhISaClause = BIhIWords spaces* BIhISaTail; String BIhISaTail = SA &(preCmavo BIhIWords) / !BIhIWords anyWordNoSAHandling BIhISaTail; String BIhIWords = "mi'i" / "bi'o" / "bi'i"; // joins two units with shortest scope String BO = preCmavo BOSaClause? BOWords postCmavo; String BONoSAHandling = preCmavo BOWords postCmavo; String BOSaClause = BOWords spaces* BOSaTail; String BOSaTail = SA &(preCmavo BOWords) / !BOWords anyWordNoSAHandling BOSaTail; String BOWords = "bo"; // number or lerfu-string terminator String BOI = preCmavo BOISaClause? BOIWords postCmavo; String BOINoSAHandling = preCmavo BOIWords postCmavo; String BOISaClause = BOIWords spaces* BOISaTail; String BOISaTail = SA &(preCmavo BOIWords) / !BOIWords anyWordNoSAHandling BOISaTail; String BOIWords = "boi"; // turns any word into a BY lerfu word String BU = preCmavoCheck BUWords postCmavoNoBUHandling; String BUWords = "bu"; String BUBare = preCmavoCheck "bu" !['] !vowel spacingOpt; // individual lerfu words String BY = preCmavo BYSaClause? BYWords postCmavo; String BYNoSAHandling = preCmavo BYWords postCmavo; String BYSaClause = BYWords spaces* BYSaTail; String BYSaTail = SA &(preCmavo BYWords) / !BYWords anyWordNoSAHandling BYSaTail; String BYWords = "jo'o" / "ru'o" / "ge'o" / "je'o" / "lo'a" / "na'a" / "se'e" / "to'a" / "ga'e" / "y'y" / "by" / "cy" / "dy" / "fy" / "gy" / "jy" / "ky" / "ly" / "my" / "ny" / "py" / "ry" / "sy" / "ty" / "vy" / "xy" / "zy"; // specifies actualitypotentiality of tense String CAhA = preCmavo CAhASaClause? CAhAWords postCmavo; String CAhANoSAHandling = preCmavo CAhAWords postCmavo; String CAhASaClause = CAhAWords spaces* CAhASaTail; String CAhASaTail = SA &(preCmavo CAhAWords) / !CAhAWords anyWordNoSAHandling CAhASaTail; String CAhAWords = "ca'a" / "pu'i" / "nu'o" / "ka'e"; // afterthought intensity marker String CAI = preCmavo CAISaClause? CAIWords postCmavo; String CAINoSAHandling = preCmavo CAIWords postCmavo; String CAISaClause = CAIWords spaces* CAISaTail; String CAISaTail = SA &(preCmavo CAIWords) / !CAIWords anyWordNoSAHandling CAISaTail; String CAIWords = "pei" / "cai" / "cu'i" / "sai" / "ru'e"; // pro-bridi assignment operator String CEI = preCmavo CEISaClause? CEIWords postCmavo; String CEINoSAHandling = preCmavo CEIWords postCmavo; String CEISaClause = CEIWords spaces* CEISaTail; String CEISaTail = SA &(preCmavo CEIWords) / !CEIWords anyWordNoSAHandling CEISaTail; String CEIWords = "cei"; // afterthought term list connective String CEhE = preCmavo CEhESaClause? CEhEWords postCmavo; String CEhENoSAHandling = preCmavo CEhEWords postCmavo; String CEhESaClause = CEhEWords spaces* CEhESaTail; String CEhESaTail = SA &(preCmavo CEhEWords) / !CEhEWords anyWordNoSAHandling CEhESaTail; String CEhEWords = "ce'e"; // names; require consonant end, then pause no // LA or DOI selma'o embedded, pause before if // vowel initial and preceded by a vowel // tanru inversion String CO = preCmavo COSaClause? COWords postCmavo; String CONoSAHandling = preCmavo COWords postCmavo; String COSaClause = COWords spaces* COSaTail; String COSaTail = SA &(preCmavo COWords) / !COWords anyWordNoSAHandling COSaTail; String COWords = "co"; String COI = preCmavo COISaClause? COIWords postCmavo; String COINoSAHandling = preCmavo COIWords postCmavo; String COISaClause = COIWords spaces* COISaTail; String COISaTail = SA &(preCmavo COIWords) / !COIWords anyWordNoSAHandling COISaTail; String COIWords = "ju'i" / "coi" / "fi'i" / "ta'a" / "mu'o" / "fe'o" / "co'o" / "pe'u" / "ke'o" / "nu'e" / "re'i" / "be'e" / "je'e" / "mi'e" / "ki'e" / "vi'o"; // vocative marker permitted inside names; must // always be followed by pause or DOI // separator between head sumti and selbri String CU = preCmavo CUSaClause? CUWords postCmavo; String CUNoSAHandling = preCmavo CUWords postCmavo; String CUSaClause = CUWords spaces* CUSaTail; String CUSaTail = SA &(preCmavo CUWords) / !CUWords anyWordNoSAHandling CUSaTail; String CUWords = "cu"; // tensemodal question String CUhE = preCmavo CUhESaClause? CUhEWords postCmavo; String CUhENoSAHandling = preCmavo CUhEWords postCmavo; String CUhESaClause = CUhEWords spaces* CUhESaTail; String CUhESaTail = SA &(preCmavo CUhEWords) / !CUhEWords anyWordNoSAHandling CUhESaTail; String CUhEWords = "cu'e" / "nau"; // cancel anaphoracataphora assignments String DAhO = preCmavo DAhOSaClause? DAhOWords postCmavo; String DAhONoSAHandling = preCmavo DAhOWords postCmavo; String DAhOSaClause = DAhOWords spaces* DAhOSaTail; String DAhOSaTail = SA &(preCmavo DAhOWords) / !DAhOWords anyWordNoSAHandling DAhOSaTail; String DAhOWords = "da'o"; // vocative marker String DOI = preCmavo DOISaClause? DOIWords postCmavo; String DOINoSAHandling = preCmavo DOIWords postCmavo; String DOISaClause = DOIWords spaces* DOISaTail; String DOISaTail = SA &(preCmavo DOIWords) / !DOIWords anyWordNoSAHandling DOISaTail; String DOIWords = "doi"; // terminator for DOI-marked vocatives String DOhU = preCmavo DOhUSaClause? DOhUWords postCmavo; String DOhUNoSAHandling = preCmavo DOhUWords postCmavo; String DOhUSaClause = DOhUWords spaces* DOhUSaTail; String DOhUSaTail = SA &(preCmavo DOhUWords) / !DOhUWords anyWordNoSAHandling DOhUSaTail; String DOhUWords = "do'u"; // modifier head generic case tag String FA = preCmavo FASaClause? FAWords postCmavo; String FANoSAHandling = preCmavo FAWords postCmavo; String FASaClause = FAWords spaces* FASaTail; String FASaTail = SA &(preCmavo FAWords) / !FAWords anyWordNoSAHandling FASaTail; String FAWords = "fai" / "fa" / "fe" / "fo" / "fu" / "fi'a" / "fi"; // superdirections in space String FAhA = preCmavo FAhASaClause? FAhAWords postCmavo; String FAhANoSAHandling = preCmavo FAhAWords postCmavo; String FAhASaClause = FAhAWords spaces* FAhASaTail; String FAhASaTail = SA &(preCmavo FAhAWords) / !FAhAWords anyWordNoSAHandling FAhASaTail; String FAhAWords = "du'a" / "be'a" / "ne'u" / "vu'a" / "ga'u" / "ti'a" / "ni'a" / "ca'u" / "zu'a" / "ri'u" / "ru'u" / "re'o" / "te'e" / "bu'u" / "ne'a" / "pa'o" / "ne'i" / "to'o" / "zo'i" / "ze'o" / "zo'a" / "fa'a"; String FAhO = preCmavo FAhOSaClause? FAhOWords postCmavo; String FAhONoSAHandling = preCmavo FAhOWords postCmavo; String FAhOSaClause = FAhOWords spaces* FAhOSaTail; String FAhOSaTail = SA &(preCmavo FAhOWords) / !FAhOWords anyWordNoSAHandling FAhOSaTail; String FAhOWords = "fa'o"; // normally elided 'done pause' to indicate end // of utterance string // space interval mod flag String FEhE = preCmavo FEhESaClause? FEhEWords postCmavo; String FEhENoSAHandling = preCmavo FEhEWords postCmavo; String FEhESaClause = FEhEWords spaces* FEhESaTail; String FEhESaTail = SA &(preCmavo FEhEWords) / !FEhEWords anyWordNoSAHandling FEhESaTail; String FEhEWords = "fe'e"; // ends bridi to modal conversion String FEhU = preCmavo FEhUSaClause? FEhUWords postCmavo; String FEhUNoSAHandling = preCmavo FEhUWords postCmavo; String FEhUSaClause = FEhUWords spaces* FEhUSaTail; String FEhUSaTail = SA &(preCmavo FEhUWords) / !FEhUWords anyWordNoSAHandling FEhUSaTail; String FEhUWords = "fe'u"; // marks bridi to modal conversion String FIhO = preCmavo FIhOSaClause? FIhOWords postCmavo; String FIhONoSAHandling = preCmavo FIhOWords postCmavo; String FIhOSaClause = FIhOWords spaces* FIhOSaTail; String FIhOSaTail = SA &(preCmavo FIhOWords) / !FIhOWords anyWordNoSAHandling FIhOSaTail; String FIhOWords = "fi'o"; // end compound lerfu String FOI = preCmavo FOISaClause? FOIWords postCmavo; String FOINoSAHandling = preCmavo FOIWords postCmavo; String FOISaClause = FOIWords spaces* FOISaTail; String FOISaTail = SA &(preCmavo FOIWords) / !FOIWords anyWordNoSAHandling FOISaTail; String FOIWords = "foi"; // reverse Polish flag String FUhA = preCmavo FUhASaClause? FUhAWords postCmavo; String FUhANoSAHandling = preCmavo FUhAWords postCmavo; String FUhASaClause = FUhAWords spaces* FUhASaTail; String FUhASaTail = SA &(preCmavo FUhAWords) / !FUhAWords anyWordNoSAHandling FUhASaTail; String FUhAWords = "fu'a"; // open long scope for indicator String FUhE = preCmavo FUhESaClause? FUhEWords postCmavo; String FUhENoSAHandling = preCmavo FUhEWords postCmavo; String FUhESaClause = FUhEWords spaces* FUhESaTail; String FUhESaTail = SA &(preCmavo FUhEWords) / !FUhEWords anyWordNoSAHandling FUhESaTail; String FUhEWords = "fu'e"; // close long scope for indicator String FUhO = preCmavo FUhOSaClause? FUhOWords postCmavo; String FUhONoSAHandling = preCmavo FUhOWords postCmavo; String FUhOSaClause = FUhOWords spaces* FUhOSaTail; String FUhOSaTail = SA &(preCmavo FUhOWords) / !FUhOWords anyWordNoSAHandling FUhOSaTail; String FUhOWords = "fu'o"; // geks; forethought logical connectives String GA = preCmavo GASaClause? GAWords postCmavo; String GANoSAHandling = preCmavo GAWords postCmavo; String GASaClause = GAWords spaces* GASaTail; String GASaTail = SA &(preCmavo GAWords) / !GAWords anyWordNoSAHandling GASaTail; String GAWords = "ge'i" / "ge" / "go" / "ga" / "gu"; // openclosed interval markers for BIhI String GAhO = preCmavo GAhOSaClause? GAhOWords postCmavo; String GAhONoSAHandling = preCmavo GAhOWords postCmavo; String GAhOSaClause = GAhOWords spaces* GAhOSaTail; String GAhOSaTail = SA &(preCmavo GAhOWords) / !GAhOWords anyWordNoSAHandling GAhOSaTail; String GAhOWords = "ke'i" / "ga'o"; // marker ending GOI relative clauses String GEhU = preCmavo GEhUSaClause? GEhUWords postCmavo; String GEhUNoSAHandling = preCmavo GEhUWords postCmavo; String GEhUSaClause = GEhUWords spaces* GEhUSaTail; String GEhUSaTail = SA &(preCmavo GEhUWords) / !GEhUWords anyWordNoSAHandling GEhUSaTail; String GEhUWords = "ge'u"; // forethought medial marker String GI = preCmavo GISaClause? GIWords postCmavo; String GINoSAHandling = preCmavo GIWords postCmavo; String GISaClause = GIWords spaces* GISaTail; String GISaTail = SA &(preCmavo GIWords) / !GIWords anyWordNoSAHandling GISaTail; String GIWords = "gi"; // logical connectives for bridi-tails String GIhA = preCmavo GIhASaClause? GIhAWords postCmavo; String GIhANoSAHandling = preCmavo GIhAWords postCmavo; String GIhASaClause = GIhAWords spaces* GIhASaTail; String GIhASaTail = SA &(preCmavo GIhAWords) / !GIhAWords anyWordNoSAHandling GIhASaTail; String GIhAWords = "gi'e" / "gi'i" / "gi'o" / "gi'a" / "gi'u"; // attaches a sumti modifier to a sumti String GOI = preCmavo GOISaClause? GOIWords postCmavo; String GOINoSAHandling = preCmavo GOIWords postCmavo; String GOISaClause = GOIWords spaces* GOISaTail; String GOISaTail = SA &(preCmavo GOIWords) / !GOIWords anyWordNoSAHandling GOISaTail; String GOIWords = "no'u" / "ne" / "goi" / "po'u" / "pe" / "po'e" / "po"; // pro-bridi String GOhA = preCmavo GOhASaClause? GOhAWords postCmavo; String GOhANoSAHandling = preCmavo GOhAWords postCmavo; String GOhASaClause = GOhAWords spaces* GOhASaTail; String GOhASaTail = SA &(preCmavo GOhAWords) / !GOhAWords anyWordNoSAHandling GOhASaTail; String GOhAWords = "mo" / "nei" / "go'u" / "go'o" / "go'i" / "no'a" / "go'e" / "go'a" / "du" / "bu'a" / "bu'e" / "bu'i" / "co'e"; // GEK for tanru units, corresponds to JEKs String GUhA = preCmavo GUhASaClause? GUhAWords postCmavo; String GUhANoSAHandling = preCmavo GUhAWords postCmavo; String GUhASaClause = GUhAWords spaces* GUhASaTail; String GUhASaTail = SA &(preCmavo GUhAWords) / !GUhAWords anyWordNoSAHandling GUhASaTail; String GUhAWords = "gu'e" / "gu'i" / "gu'o" / "gu'a" / "gu'u"; // sentence link String I = preCmavo ISaClause? IWords postCmavo; String INoSAHandling = preCmavo IWords postCmavo; String ISaClause = IWords spaces* ISaTail; String ISaTail = SA &(preCmavo IWords) / !IWords anyWordNoSAHandling ISaTail; String IWords = "i"; // jeks; logical connectives within tanru String JA = preCmavo JASaClause? JAWords postCmavo; String JANoSAHandling = preCmavo JAWords postCmavo; String JASaClause = JAWords spaces* JASaTail; String JASaTail = SA &(preCmavo JAWords) / !JAWords anyWordNoSAHandling JASaTail; String JAWords = "je'i" / "je" / "jo" / "ja" / "ju"; // modal conversion flag String JAI = preCmavo JAISaClause? JAIWords postCmavo; String JAINoSAHandling = preCmavo JAIWords postCmavo; String JAISaClause = JAIWords spaces* JAISaTail; String JAISaTail = SA &(preCmavo JAIWords) / !JAIWords anyWordNoSAHandling JAISaTail; String JAIWords = "jai"; // flags an array operand String JOhI = preCmavo JOhISaClause? JOhIWords postCmavo; String JOhINoSAHandling = preCmavo JOhIWords postCmavo; String JOhISaClause = JOhIWords spaces* JOhISaTail; String JOhISaTail = SA &(preCmavo JOhIWords) / !JOhIWords anyWordNoSAHandling JOhISaTail; String JOhIWords = "jo'i"; // non-logical connectives String JOI = preCmavo JOISaClause? JOIWords postCmavo; String JOINoSAHandling = preCmavo JOIWords postCmavo; String JOISaClause = JOIWords spaces* JOISaTail; String JOISaTail = SA &(preCmavo JOIWords) / !JOIWords anyWordNoSAHandling JOISaTail; String JOIWords = "fa'u" / "pi'u" / "joi" / "ce'o" / "ce" / "jo'u" / "ku'a" / "jo'e" / "ju'e"; // left long scope marker String KE = preCmavo KESaClause? KEWords postCmavo; String KENoSAHandling = preCmavo KEWords postCmavo; String KESaClause = KEWords spaces* KESaTail; String KESaTail = SA &(preCmavo KEWords) / !KEWords anyWordNoSAHandling KESaTail; String KEWords = "ke"; // right terminator for KE groups String KEhE = preCmavo KEhESaClause? KEhEWords postCmavo; String KEhENoSAHandling = preCmavo KEhEWords postCmavo; String KEhESaClause = KEhEWords spaces* KEhESaTail; String KEhESaTail = SA &(preCmavo KEhEWords) / !KEhEWords anyWordNoSAHandling KEhESaTail; String KEhEWords = "ke'e"; // right terminator, NU abstractions String KEI = preCmavo KEISaClause? KEIWords postCmavo; String KEINoSAHandling = preCmavo KEIWords postCmavo; String KEISaClause = KEIWords spaces* KEISaTail; String KEISaTail = SA &(preCmavo KEIWords) / !KEIWords anyWordNoSAHandling KEISaTail; String KEIWords = "kei"; // multiple utterance scope for tenses String KI = preCmavo KISaClause? KIWords postCmavo; String KINoSAHandling = preCmavo KIWords postCmavo; String KISaClause = KIWords spaces* KISaTail; String KISaTail = SA &(preCmavo KIWords) / !KIWords anyWordNoSAHandling KISaTail; String KIWords = "ki"; // sumti anaphora String KOhA = preCmavo KOhASaClause? KOhAWords postCmavo; String KOhANoSAHandling = preCmavo KOhAWords postCmavo; String KOhASaClause = KOhAWords spaces* KOhASaTail; String KOhASaTail = SA &(preCmavo KOhAWords) / !KOhAWords anyWordNoSAHandling KOhASaTail; String KOhAWords = "da'u" / "da'e" / "di'u" / "di'e" / "de'u" / "de'e" / "dei" / "do'i" / "mi'o" / "ma'a" / "mi'a" / "do'o" / "ko'a" / "fo'u" / "ko'e" / "ko'i" / "ko'o" / "ko'u" / "fo'a" / "fo'e" / "fo'i" / "fo'o" / "vo'a" / "vo'e" / "vo'i" / "vo'o" / "vo'u" / "ru" / "ri" / "ra" / "ta" / "tu" / "ti" / "zi'o" / "ke'a" / "ma" / "zu'i" / "zo'e" / "ce'u" / "da" / "de" / "di" / "ko" / "mi" / "do"; // right terminator for descriptions, etc. String KU = preCmavo KUSaClause? KUWords postCmavo; String KUNoSAHandling = preCmavo KUWords postCmavo; String KUSaClause = KUWords spaces* KUSaTail; String KUSaTail = SA &(preCmavo KUWords) / !KUWords anyWordNoSAHandling KUSaTail; String KUWords = "ku"; // MEX forethought delimiter String KUhE = preCmavo KUhESaClause? KUhEWords postCmavo; String KUhENoSAHandling = preCmavo KUhEWords postCmavo; String KUhESaClause = KUhEWords spaces* KUhESaTail; String KUhESaTail = SA &(preCmavo KUhEWords) / !KUhEWords anyWordNoSAHandling KUhESaTail; String KUhEWords = "ku'e"; // right terminator, NOI relative clauses String KUhO = preCmavo KUhOSaClause? KUhOWords postCmavo; String KUhONoSAHandling = preCmavo KUhOWords postCmavo; String KUhOSaClause = KUhOWords spaces* KUhOSaTail; String KUhOSaTail = SA &(preCmavo KUhOWords) / !KUhOWords anyWordNoSAHandling KUhOSaTail; String KUhOWords = "ku'o"; // name descriptors String LA = preCmavo LASaClause? LAWords postCmavo; String LANoSAHandling = preCmavo LAWords postCmavo; String LASaClause = LAWords spaces* LASaTail; String LASaTail = SA &(preCmavo LAWords) / !LAWords anyWordNoSAHandling LASaTail; String LAWords = "lai" / "la'i" / "la"; // lerfu prefixes String LAU = preCmavo LAUSaClause? LAUWords postCmavo; String LAUNoSAHandling = preCmavo LAUWords postCmavo; String LAUSaClause = LAUWords spaces* LAUSaTail; String LAUSaTail = SA &(preCmavo LAUWords) / !LAUWords anyWordNoSAHandling LAUSaTail; String LAUWords = "ce'a" / "lau" / "zai" / "tau"; // sumti qualifiers String LAhE = preCmavo LAhESaClause? LAhEWords postCmavo; String LAhENoSAHandling = preCmavo LAhEWords postCmavo; String LAhESaClause = LAhEWords spaces* LAhESaTail; String LAhESaTail = SA &(preCmavo LAhEWords) / !LAhEWords anyWordNoSAHandling LAhESaTail; String LAhEWords = "tu'a" / "lu'a" / "lu'o" / "la'e" / "vu'i" / "lu'i" / "lu'e"; // sumti descriptors String LE = preCmavo LESaClause? LEWords postCmavo; String LENoSAHandling = preCmavo LEWords postCmavo; String LESaClause = LEWords spaces* LESaTail; String LESaTail = SA &(preCmavo LEWords) / !LEWords anyWordNoSAHandling LESaTail; String LEWords = "lei" / "loi" / "le'i" / "lo'i" / "le'e" / "lo'e" / "lo" / "le"; // possibly ungrammatical text right quote String LEhU = preCmavo LEhUSaClause? LEhUWords postCmavo; String LEhUNoSAHandling = preCmavo LEhUWords postCmavo; String LEhUSaClause = LEhUWords spaces* LEhUSaTail; String LEhUSaTail = SA &(preCmavo LEhUWords) / !LEhUWords anyWordNoSAHandling LEhUSaTail; String LEhUNoSIHandling = preCmavo LEhUWords postCmavoNoSIHandling; String LEhUWords = "le'u"; // convert number to sumti String LI = preCmavo LISaClause? LIWords postCmavo; String LINoSAHandling = preCmavo LIWords postCmavo; String LISaClause = LIWords spaces* LISaTail; String LISaTail = SA &(preCmavo LIWords) / !LIWords anyWordNoSAHandling LISaTail; String LIWords = "me'o" / "li"; // grammatical text right quote String LIhU = preCmavo LIhUSaClause? LIhUWords postCmavo; String LIhUNoSAHandling = preCmavo LIhUWords postCmavo; String LIhUSaClause = LIhUWords spaces* LIhUSaTail; String LIhUSaTail = SA &(preCmavo LIhUWords) / !LIhUWords anyWordNoSAHandling LIhUSaTail; String LIhUWords = "li'u"; // elidable terminator for LI String LOhO = preCmavo LOhOSaClause? LOhOWords postCmavo; String LOhONoSAHandling = preCmavo LOhOWords postCmavo; String LOhOSaClause = LOhOWords spaces* LOhOSaTail; String LOhOSaTail = SA &(preCmavo LOhOWords) / !LOhOWords anyWordNoSAHandling LOhOSaTail; String LOhOWords = "lo'o"; // possibly ungrammatical text left quote String LOhU = preCmavo LOhUWords postCmavoNoSIHandling; String LOhUWords = "lo'u"; // grammatical text left quote String LU = preCmavo LUSaClause? LUWords postCmavo; String LUNoSAHandling = preCmavo LUWords postCmavo; String LUSaClause = LUWords spaces* LUSaTail; String LUSaTail = SA &(preCmavo LUWords) / !LUWords anyWordNoSAHandling LUSaTail; String LUWords = "lu"; // LAhE close delimiter String LUhU = preCmavo LUhUSaClause? LUhUWords postCmavo; String LUhUNoSAHandling = preCmavo LUhUWords postCmavo; String LUhUSaClause = LUhUWords spaces* LUhUSaTail; String LUhUSaTail = SA &(preCmavo LUhUWords) / !LUhUWords anyWordNoSAHandling LUhUSaTail; String LUhUWords = "lu'u"; // change MEX expressions to MEX operators String MAhO = preCmavo MAhOSaClause? MAhOWords postCmavo; String MAhONoSAHandling = preCmavo MAhOWords postCmavo; String MAhOSaClause = MAhOWords spaces* MAhOSaTail; String MAhOSaTail = SA &(preCmavo MAhOWords) / !MAhOWords anyWordNoSAHandling MAhOSaTail; String MAhOWords = "ma'o"; // change numbers to utterance ordinals String MAI = preCmavo MAISaClause? MAIWords postCmavo; String MAINoSAHandling = preCmavo MAIWords postCmavo; String MAISaClause = MAIWords spaces* MAISaTail; String MAISaTail = SA &(preCmavo MAIWords) / !MAIWords anyWordNoSAHandling MAISaTail; String MAIWords = "mo'o" / "mai"; // converts a sumti into a tanru_unit String ME = preCmavo MESaClause? MEWords postCmavo; String MENoSAHandling = preCmavo MEWords postCmavo; String MESaClause = MEWords spaces* MESaTail; String MESaTail = SA &(preCmavo MEWords) / !MEWords anyWordNoSAHandling MESaTail; String MEWords = "me"; // terminator for ME String MEhU = preCmavo MEhUSaClause? MEhUWords postCmavo; String MEhUNoSAHandling = preCmavo MEhUWords postCmavo; String MEhUSaClause = MEhUWords spaces* MEhUSaTail; String MEhUSaTail = SA &(preCmavo MEhUWords) / !MEhUWords anyWordNoSAHandling MEhUSaTail; String MEhUWords = "me'u"; // change sumti to operand, inverse of LI String MOhE = preCmavo MOhESaClause? MOhEWords postCmavo; String MOhENoSAHandling = preCmavo MOhEWords postCmavo; String MOhESaClause = MOhEWords spaces* MOhESaTail; String MOhESaTail = SA &(preCmavo MOhEWords) / !MOhEWords anyWordNoSAHandling MOhESaTail; String MOhEWords = "mo'e"; // motion tense marker String MOhI = preCmavo MOhISaClause? MOhIWords postCmavo; String MOhINoSAHandling = preCmavo MOhIWords postCmavo; String MOhISaClause = MOhIWords spaces* MOhISaTail; String MOhISaTail = SA &(preCmavo MOhIWords) / !MOhIWords anyWordNoSAHandling MOhISaTail; String MOhIWords = "mo'i"; // change number to selbri String MOI = preCmavo MOISaClause? MOIWords postCmavo; String MOINoSAHandling = preCmavo MOIWords postCmavo; String MOISaClause = MOIWords spaces* MOISaTail; String MOISaTail = SA &(preCmavo MOIWords) / !MOIWords anyWordNoSAHandling MOISaTail; String MOIWords = "mei" / "moi" / "si'e" / "cu'o" / "va'e"; // bridi negation String NA = preCmavo NASaClause? NAWords postCmavo; String NANoSAHandling = preCmavo NAWords postCmavo; String NASaClause = NAWords spaces* NASaTail; String NASaTail = SA &(preCmavo NAWords) / !NAWords anyWordNoSAHandling NASaTail; String NAWords = "ja'a" / "na"; // attached to words to negate them String NAI = preCmavo NAISaClause? NAIWords postCmavo; String NAINoSAHandling = preCmavo NAIWords postCmavo; String NAISaClause = NAIWords spaces* NAISaTail; String NAISaTail = SA &(preCmavo NAIWords) / !NAIWords anyWordNoSAHandling NAISaTail; String NAIWords = "nai"; // scalar negation String NAhE = preCmavo NAhESaClause? NAhEWords postCmavo; String NAhENoSAHandling = preCmavo NAhEWords postCmavo; String NAhESaClause = NAhEWords spaces* NAhESaTail; String NAhESaTail = SA &(preCmavo NAhEWords) / !NAhEWords anyWordNoSAHandling NAhESaTail; String NAhEWords = "to'e" / "je'a" / "na'e" / "no'e"; // change a selbri into an operator String NAhU = preCmavo NAhUSaClause? NAhUWords postCmavo; String NAhUNoSAHandling = preCmavo NAhUWords postCmavo; String NAhUSaClause = NAhUWords spaces* NAhUSaTail; String NAhUSaTail = SA &(preCmavo NAhUWords) / !NAhUWords anyWordNoSAHandling NAhUSaTail; String NAhUWords = "na'u"; // change selbri to operand; inverse of MOI String NIhE = preCmavo NIhESaClause? NIhEWords postCmavo; String NIhENoSAHandling = preCmavo NIhEWords postCmavo; String NIhESaClause = NIhEWords spaces* NIhESaTail; String NIhESaTail = SA &(preCmavo NIhEWords) / !NIhEWords anyWordNoSAHandling NIhESaTail; String NIhEWords = "ni'e"; // new paragraph; change of subject String NIhO = preCmavo NIhOSaClause? NIhOWords suClause* postCmavo; String NIhONoSAHandling = preCmavo NIhOWords suClause* postCmavo; String NIhOSaClause = NIhOWords spaces* NIhOSaTail; String NIhOSaTail = SA &(preCmavo NIhOWords) / !NIhOWords anyWordNoSAHandling NIhOSaTail; String NIhOWords = "ni'o" / "no'i"; // attaches a subordinate clause to a sumti String NOI = preCmavo NOISaClause? NOIWords postCmavo; String NOINoSAHandling = preCmavo NOIWords postCmavo; String NOISaClause = NOIWords spaces* NOISaTail; String NOISaTail = SA &(preCmavo NOIWords) / !NOIWords anyWordNoSAHandling NOISaTail; String NOIWords = "voi" / "noi" / "poi"; // abstraction String NU = preCmavo NUSaClause? NUWords postCmavo; String NUNoSAHandling = preCmavo NUWords postCmavo; String NUSaClause = NUWords spaces* NUSaTail; String NUSaTail = SA &(preCmavo NUWords) / !NUWords anyWordNoSAHandling NUSaTail; String NUWords = "ni" / "du'u" / "si'o" / "nu" / "li'i" / "ka" / "jei" / "su'u" / "zu'o" / "mu'e" / "pu'u" / "za'i"; // change operator to selbri; inverse of MOhE String NUhA = preCmavo NUhASaClause? NUhAWords postCmavo; String NUhANoSAHandling = preCmavo NUhAWords postCmavo; String NUhASaClause = NUhAWords spaces* NUhASaTail; String NUhASaTail = SA &(preCmavo NUhAWords) / !NUhAWords anyWordNoSAHandling NUhASaTail; String NUhAWords = "nu'a"; // marks the start of a termset String NUhI = preCmavo NUhISaClause? NUhIWords postCmavo; String NUhINoSAHandling = preCmavo NUhIWords postCmavo; String NUhISaClause = NUhIWords spaces* NUhISaTail; String NUhISaTail = SA &(preCmavo NUhIWords) / !NUhIWords anyWordNoSAHandling NUhISaTail; String NUhIWords = "nu'i"; // marks the middle and end of a termset String NUhU = preCmavo NUhUSaClause? NUhUWords postCmavo; String NUhUNoSAHandling = preCmavo NUhUWords postCmavo; String NUhUSaClause = NUhUWords spaces* NUhUSaTail; String NUhUSaTail = SA &(preCmavo NUhUWords) / !NUhUWords anyWordNoSAHandling NUhUSaTail; String NUhUWords = "nu'u"; // numbers and numeric punctuation String PA = preCmavo PASaClause? PAWords postCmavo; String PANoSAHandling = preCmavo PAWords postCmavo; String PASaClause = PAWords spaces* PASaTail; String PASaTail = SA &(preCmavo PAWords) / !PAWords anyWordNoSAHandling PASaTail; String PAWords = "dau" / "fei" / "gai" / "jau" / "rei" / "vai" / "pi'e" / "pi" / "fi'u" / "za'u" / "me'i" / "ni'u" / "ki'o" / "ce'i" / "ma'u" / "ra'e" / "da'a" / "so'a" / "ji'i" / "su'o" / "su'e" / "ro" / "rau" / "so'u" / "so'i" / "so'e" / "so'o" / "mo'a" / "du'e" / "te'o" / "ka'o" / "ci'i" / "tu'o" / "xo" / "pai" / "no'o" / "no" / "pa" / "re" / "ci" / "vo" / "mu" / "xa" / "ze" / "bi" / "so" / "0" / "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9"; // afterthought termset connective prefix String PEhE = preCmavo PEhESaClause? PEhEWords postCmavo; String PEhENoSAHandling = preCmavo PEhEWords postCmavo; String PEhESaClause = PEhEWords spaces* PEhESaTail; String PEhESaTail = SA &(preCmavo PEhEWords) / !PEhEWords anyWordNoSAHandling PEhESaTail; String PEhEWords = "pe'e"; // forethought (Polish) flag String PEhO = preCmavo PEhOSaClause? PEhOWords postCmavo; String PEhONoSAHandling = preCmavo PEhOWords postCmavo; String PEhOSaClause = PEhOWords spaces* PEhOSaTail; String PEhOSaTail = SA &(preCmavo PEhOWords) / !PEhOWords anyWordNoSAHandling PEhOSaTail; String PEhOWords = "pe'o"; // directions in time String PU = preCmavo PUSaClause? PUWords postCmavo; String PUNoSAHandling = preCmavo PUWords postCmavo; String PUSaClause = PUWords spaces* PUSaTail; String PUSaTail = SA &(preCmavo PUWords) / !PUWords anyWordNoSAHandling PUSaTail; String PUWords = "ba" / "pu" / "ca"; // flag for modified interpretation of GOhI String RAhO = preCmavo RAhOSaClause? RAhOWords postCmavo; String RAhONoSAHandling = preCmavo RAhOWords postCmavo; String RAhOSaClause = RAhOWords spaces* RAhOSaTail; String RAhOSaTail = SA &(preCmavo RAhOWords) / !RAhOWords anyWordNoSAHandling RAhOSaTail; String RAhOWords = "ra'o"; // converts number to extensional tense String ROI = preCmavo ROISaClause? ROIWords postCmavo; String ROINoSAHandling = preCmavo ROIWords postCmavo; String ROISaClause = ROIWords spaces* ROISaTail; String ROISaTail = SA &(preCmavo ROIWords) / !ROIWords anyWordNoSAHandling ROISaTail; String ROIWords = "re'u" / "roi"; String SA = preCmavo SAWords postCmavo; String SAWords = "sa"; // metalinguistic eraser to the beginning of // the current utterance // conversions String SE = preCmavo SESaClause? SEWords postCmavo; String SENoSAHandling = preCmavo SEWords postCmavo; String SESaClause = SEWords spaces* SESaTail; String SESaTail = SA &(preCmavo SEWords) / !SEWords anyWordNoSAHandling SESaTail; String SEWords = "se" / "te" / "ve" / "xe"; // metalinguistic bridi insert marker String SEI = preCmavo SEISaClause? SEIWords postCmavo; String SEINoSAHandling = preCmavo SEIWords postCmavo; String SEISaClause = SEIWords spaces* SEISaTail; String SEISaTail = SA &(preCmavo SEIWords) / !SEIWords anyWordNoSAHandling SEISaTail; String SEIWords = "sei" / "ti'o"; // metalinguistic bridi end marker String SEhU = preCmavo SEhUSaClause? SEhUWords postCmavo; String SEhUNoSAHandling = preCmavo SEhUWords postCmavo; String SEhUSaClause = SEhUWords spaces* SEhUSaTail; String SEhUSaTail = SA &(preCmavo SEhUWords) / !SEhUWords anyWordNoSAHandling SEhUSaTail; String SEhUWords = "se'u"; // metalinguistic single word eraser String SI = SIWords postCmavoNoSIHandling; String SIWords = "si"; // reciprocal sumti marker String SOI = preCmavo SOISaClause? SOIWords postCmavo; String SOINoSAHandling = preCmavo SOIWords postCmavo; String SOISaClause = SOIWords spaces* SOISaTail; String SOISaTail = SA &(preCmavo SOIWords) / !SOIWords anyWordNoSAHandling SOISaTail; String SOIWords = "soi"; // metalinguistic eraser of the entire text String SU = preCmavo SUSaClause? SUWords postCmavo; String SUNoSAHandling = preCmavo SUWords postCmavo; String SUSaClause = SUWords spaces* SUSaTail; String SUSaTail = SA &(preCmavo SUWords) / !SUWords anyWordNoSAHandling SUSaTail; String SUWords = "su"; // tense interval properties String TAhE = preCmavo TAhESaClause? TAhEWords postCmavo; String TAhENoSAHandling = preCmavo TAhEWords postCmavo; String TAhESaClause = TAhEWords spaces* TAhESaTail; String TAhESaTail = SA &(preCmavo TAhEWords) / !TAhEWords anyWordNoSAHandling TAhESaTail; String TAhEWords = "ru'i" / "ta'e" / "di'i" / "na'o"; // closing gap for MEX constructs String TEhU = preCmavo TEhUSaClause? TEhUWords postCmavo; String TEhUNoSAHandling = preCmavo TEhUWords postCmavo; String TEhUSaClause = TEhUWords spaces* TEhUSaTail; String TEhUSaTail = SA &(preCmavo TEhUWords) / !TEhUWords anyWordNoSAHandling TEhUSaTail; String TEhUWords = "te'u"; // start compound lerfu String TEI = preCmavo TEISaClause? TEIWords postCmavo; String TEINoSAHandling = preCmavo TEIWords postCmavo; String TEISaClause = TEIWords spaces* TEISaTail; String TEISaTail = SA &(preCmavo TEIWords) / !TEIWords anyWordNoSAHandling TEISaTail; String TEIWords = "tei"; // left discursive parenthesis String TO = preCmavo TOSaClause? TOWords postCmavo; String TONoSAHandling = preCmavo TOWords postCmavo; String TOSaClause = TOWords spaces* TOSaTail; String TOSaTail = SA &(preCmavo TOWords) / !TOWords anyWordNoSAHandling TOSaTail; String TOWords = "to'i" / "to"; // right discursive parenthesis String TOI = preCmavo TOISaClause? TOIWords postCmavo; String TOINoSAHandling = preCmavo TOIWords postCmavo; String TOISaClause = TOIWords spaces* TOISaTail; String TOISaTail = SA &(preCmavo TOIWords) / !TOIWords anyWordNoSAHandling TOISaTail; String TOIWords = "toi"; // multiple utterance scope mark String TUhE = preCmavo TUhESaClause? TUhEWords suClause* postCmavo; String TUhENoSAHandling = preCmavo TUhEWords suClause* postCmavo; String TUhESaClause = TUhEWords spaces* TUhESaTail; String TUhESaTail = SA &(preCmavo TUhEWords) / !TUhEWords anyWordNoSAHandling TUhESaTail; String TUhEWords = "tu'e"; // multiple utterance end scope mark String TUhU = preCmavo TUhUSaClause? TUhUWords postCmavo; String TUhUNoSAHandling = preCmavo TUhUWords postCmavo; String TUhUSaClause = TUhUWords spaces* TUhUSaTail; String TUhUSaTail = SA &(preCmavo TUhUWords) / !TUhUWords anyWordNoSAHandling TUhUSaTail; String TUhUWords = "tu'u"; // attitudinals, observationals, discursives String UI = preCmavo UISaClause? UIWords postCmavo; String UINoSAHandling = preCmavo UIWords postCmavo; String UISaClause = UIWords spaces* UISaTail; String UISaTail = SA &(preCmavo UIWords) / !UIWords anyWordNoSAHandling UISaTail; String UIWords = "i'a" / "ie" / "a'e" / "u'i" / "i'o" / "i'e" / "a'a" / "ia" / "o'i" / "o'e" / "e'e" / "oi" / "uo" / "e'i" / "u'o" / "au" / "ua" / "a'i" / "i'u" / "ii" / "u'a" / "ui" / "a'o" / "ai" / "a'u" / "iu" / "ei" / "o'o" / "e'a" / "uu" / "o'a" / "o'u" / "u'u" / "e'o" / "io" / "e'u" / "ue" / "i'i" / "u'e" / "ba'a" / "ja'o" / "ca'e" / "su'a" / "ti'e" / "ka'u" / "se'o" / "za'a" / "pe'i" / "ru'a" / "ju'a" / "ta'o" / "ra'u" / "li'a" / "ba'u" / "mu'a" / "do'a" / "to'u" / "va'i" / "pa'e" / "zu'u" / "sa'e" / "la'a" / "ke'u" / "sa'u" / "da'i" / "je'u" / "sa'a" / "kau" / "ta'u" / "na'i" / "jo'a" / "bi'u" / "li'o" / "pau" / "mi'u" / "ku'i" / "ji'a" / "si'a" / "po'o" / "pe'a" / "ro'i" / "ro'e" / "ro'o" / "ro'u" / "ro'a" / "re'e" / "le'o" / "ju'o" / "fu'i" / "dai" / "ga'i" / "zo'o" / "be'u" / "ri'e" / "se'i" / "se'a" / "vu'e" / "ki'a" / "xu" / "ge'e" / "bu'o"; // distance in space-time String VA = preCmavo VASaClause? VAWords postCmavo; String VANoSAHandling = preCmavo VAWords postCmavo; String VASaClause = VAWords spaces* VASaTail; String VASaTail = SA &(preCmavo VAWords) / !VAWords anyWordNoSAHandling VASaTail; String VAWords = "vi" / "va" / "vu"; // end simple bridi or bridi-tail String VAU = preCmavo VAUSaClause? VAUWords postCmavo; String VAUNoSAHandling = preCmavo VAUWords postCmavo; String VAUSaClause = VAUWords spaces* VAUSaTail; String VAUSaTail = SA &(preCmavo VAUWords) / !VAUWords anyWordNoSAHandling VAUSaTail; String VAUWords = "vau"; // left MEX bracket String VEI = preCmavo VEISaClause? VEIWords postCmavo; String VEINoSAHandling = preCmavo VEIWords postCmavo; String VEISaClause = VEIWords spaces* VEISaTail; String VEISaTail = SA &(preCmavo VEIWords) / !VEIWords anyWordNoSAHandling VEISaTail; String VEIWords = "vei"; // right MEX bracket String VEhO = preCmavo VEhOSaClause? VEhOWords postCmavo; String VEhONoSAHandling = preCmavo VEhOWords postCmavo; String VEhOSaClause = VEhOWords spaces* VEhOSaTail; String VEhOSaTail = SA &(preCmavo VEhOWords) / !VEhOWords anyWordNoSAHandling VEhOSaTail; String VEhOWords = "ve'o"; // MEX operator String VUhU = preCmavo VUhUSaClause? VUhUWords postCmavo; String VUhUNoSAHandling = preCmavo VUhUWords postCmavo; String VUhUSaClause = VUhUWords spaces* VUhUSaTail; String VUhUSaTail = SA &(preCmavo VUhUWords) / !VUhUWords anyWordNoSAHandling VUhUSaTail; String VUhUWords = "ge'a" / "fu'u" / "pi'i" / "fe'i" / "vu'u" / "su'i" / "ju'u" / "gei" / "pa'i" / "fa'i" / "te'a" / "cu'a" / "va'a" / "ne'o" / "de'o" / "fe'a" / "sa'o" / "re'a" / "ri'o" / "sa'i" / "pi'a" / "si'i"; // space-time interval size String VEhA = preCmavo VEhASaClause? VEhAWords postCmavo; String VEhANoSAHandling = preCmavo VEhAWords postCmavo; String VEhASaClause = VEhAWords spaces* VEhASaTail; String VEhASaTail = SA &(preCmavo VEhAWords) / !VEhAWords anyWordNoSAHandling VEhASaTail; String VEhAWords = "ve'u" / "ve'a" / "ve'i" / "ve'e"; // space-time dimensionality marker String VIhA = preCmavo VIhASaClause? VIhAWords postCmavo; String VIhANoSAHandling = preCmavo VIhAWords postCmavo; String VIhASaClause = VIhAWords spaces* VIhASaTail; String VIhASaTail = SA &(preCmavo VIhAWords) / !VIhAWords anyWordNoSAHandling VIhASaTail; String VIhAWords = "vi'i" / "vi'a" / "vi'u" / "vi'e"; String VUhO = preCmavo VUhOSaClause? VUhOWords postCmavo; String VUhONoSAHandling = preCmavo VUhOWords postCmavo; String VUhOSaClause = VUhOWords spaces* VUhOSaTail; String VUhOSaTail = SA &(preCmavo VUhOWords) / !VUhOWords anyWordNoSAHandling VUhOSaTail; String VUhOWords = "vu'o"; // glue between logically connected sumti // and relative clauses // subscripting operator String XI = preCmavo XISaClause? XIWords postCmavo; String XINoSAHandling = preCmavo XIWords postCmavo; String XISaClause = XIWords spaces* XISaTail; String XISaTail = SA &(preCmavo XIWords) / !XIWords anyWordNoSAHandling XISaTail; String XIWords = "xi"; // hesitation String Y = preCmavo YSaClause? YWords spaces*; String YNoSAHandling = preCmavo YWords spaces*; String YSaClause = YWords spaces* YSaTail; String YSaTail = SA &(preCmavo YWords) / !YWords anyWordNoSAHandling YSaTail; String YWords = "y"+; // event properties - inchoative, etc. String ZAhO = preCmavo ZAhOSaClause? ZAhOWords postCmavo; String ZAhONoSAHandling = preCmavo ZAhOWords postCmavo; String ZAhOSaClause = ZAhOWords spaces* ZAhOSaTail; String ZAhOSaTail = SA &(preCmavo ZAhOWords) / !ZAhOWords anyWordNoSAHandling ZAhOSaTail; String ZAhOWords = "co'i" / "pu'o" / "co'u" / "mo'u" / "ca'o" / "co'a" / "de'a" / "ba'o" / "di'a" / "za'o"; // time interval size tense String ZEhA = preCmavo ZEhASaClause? ZEhAWords postCmavo; String ZEhANoSAHandling = preCmavo ZEhAWords postCmavo; String ZEhASaClause = ZEhAWords spaces* ZEhASaTail; String ZEhASaTail = SA &(preCmavo ZEhAWords) / !ZEhAWords anyWordNoSAHandling ZEhASaTail; String ZEhAWords = "ze'u" / "ze'a" / "ze'i" / "ze'e"; // lujvo glue String ZEI = preCmavo ZEISaClause? ZEIWords postCmavo; String ZEINoSAHandling = preCmavo ZEIWords postCmavo; String ZEISaClause = ZEIWords spaces* ZEISaTail; String ZEISaTail = SA &(preCmavo ZEIWords) / !ZEIWords anyWordNoSAHandling ZEISaTail; String ZEIWords = "zei"; // time distance tense String ZI = preCmavo ZISaClause? ZIWords postCmavo; String ZINoSAHandling = preCmavo ZIWords postCmavo; String ZISaClause = ZIWords spaces* ZISaTail; String ZISaTail = SA &(preCmavo ZIWords) / !ZIWords anyWordNoSAHandling ZISaTail; String ZIWords = "zu" / "za" / "zi"; // conjoins relative clauses String ZIhE = preCmavo ZIhESaClause? ZIhEWords postCmavo; String ZIhENoSAHandling = preCmavo ZIhEWords postCmavo; String ZIhESaClause = ZIhEWords spaces* ZIhESaTail; String ZIhESaTail = SA &(preCmavo ZIhEWords) / !ZIhEWords anyWordNoSAHandling ZIhESaTail; String ZIhEWords = "zi'e"; // single word metalinguistic quote marker String ZO = preCmavo ZOWords zoPostCmavo; String ZOWords = "zo"; String zoPostCmavo = spacesNotY+ / &CMAVOPostNoSIHandling / SI / &BRIVLA; // delimited quote marker String ZOI = preCmavo ZOISaClause? ZOIWords postCmavo; String ZOINoSAHandling = preCmavo ZOIWords postCmavo; String ZOISaClause = ZOIWords spaces* ZOISaTail; String ZOISaTail = SA &(preCmavo ZOIWords) / !ZOIWords anyWordNoSAHandling ZOISaTail; String ZOIWords = "zoi" / "la'o"; // prenex terminator (not elidable) String ZOhU = preCmavo ZOhUSaClause? ZOhUWords postCmavo; String ZOhUNoSAHandling = preCmavo ZOhUWords postCmavo; String ZOhUSaClause = ZOhUWords spaces* ZOhUSaTail; String ZOhUSaTail = SA &(preCmavo ZOhUWords) / !ZOhUWords anyWordNoSAHandling ZOhUSaTail; String ZOhUWords = "zo'u";