Ham4Parser (SiGML Input and Conversion Library)

java.lang.Object
- antlr.Parser
- - antlr.LLkParser
  - - hamparse.Ham4Parser

All Implemented Interfaces:

Ham4ParserTokenTypes
```
public class Ham4Parser
extends antlr.LLkParser
implements Ham4ParserTokenTypes
```
ANTLR-generated parser for a single manual HamNoSys 4 sign, taking input from a custom TokenStream and generating an AST for the sign.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String[]`	`_tokenNames`
`static antlr.collections.impl.BitSet`	`_tokenSet_0`
`static antlr.collections.impl.BitSet`	`_tokenSet_1`
`static antlr.collections.impl.BitSet`	`_tokenSet_10`
`static antlr.collections.impl.BitSet`	`_tokenSet_11`
`static antlr.collections.impl.BitSet`	`_tokenSet_12`
`static antlr.collections.impl.BitSet`	`_tokenSet_13`
`static antlr.collections.impl.BitSet`	`_tokenSet_14`
`static antlr.collections.impl.BitSet`	`_tokenSet_15`
`static antlr.collections.impl.BitSet`	`_tokenSet_16`
`static antlr.collections.impl.BitSet`	`_tokenSet_17`
`static antlr.collections.impl.BitSet`	`_tokenSet_18`
`static antlr.collections.impl.BitSet`	`_tokenSet_19`
`static antlr.collections.impl.BitSet`	`_tokenSet_2`
`static antlr.collections.impl.BitSet`	`_tokenSet_20`
`static antlr.collections.impl.BitSet`	`_tokenSet_21`
`static antlr.collections.impl.BitSet`	`_tokenSet_22`
`static antlr.collections.impl.BitSet`	`_tokenSet_23`
`static antlr.collections.impl.BitSet`	`_tokenSet_24`
`static antlr.collections.impl.BitSet`	`_tokenSet_25`
`static antlr.collections.impl.BitSet`	`_tokenSet_26`
`static antlr.collections.impl.BitSet`	`_tokenSet_27`
`static antlr.collections.impl.BitSet`	`_tokenSet_28`
`static antlr.collections.impl.BitSet`	`_tokenSet_29`
`static antlr.collections.impl.BitSet`	`_tokenSet_3`
`static antlr.collections.impl.BitSet`	`_tokenSet_30`
`static antlr.collections.impl.BitSet`	`_tokenSet_31`
`static antlr.collections.impl.BitSet`	`_tokenSet_32`
`static antlr.collections.impl.BitSet`	`_tokenSet_33`
`static antlr.collections.impl.BitSet`	`_tokenSet_34`
`static antlr.collections.impl.BitSet`	`_tokenSet_35`
`static antlr.collections.impl.BitSet`	`_tokenSet_36`
`static antlr.collections.impl.BitSet`	`_tokenSet_37`
`static antlr.collections.impl.BitSet`	`_tokenSet_38`
`static antlr.collections.impl.BitSet`	`_tokenSet_39`
`static antlr.collections.impl.BitSet`	`_tokenSet_4`
`static antlr.collections.impl.BitSet`	`_tokenSet_40`
`static antlr.collections.impl.BitSet`	`_tokenSet_41`
`static antlr.collections.impl.BitSet`	`_tokenSet_42`
`static antlr.collections.impl.BitSet`	`_tokenSet_43`
`static antlr.collections.impl.BitSet`	`_tokenSet_44`
`static antlr.collections.impl.BitSet`	`_tokenSet_45`
`static antlr.collections.impl.BitSet`	`_tokenSet_46`
`static antlr.collections.impl.BitSet`	`_tokenSet_47`
`static antlr.collections.impl.BitSet`	`_tokenSet_48`
`static antlr.collections.impl.BitSet`	`_tokenSet_49`
`static antlr.collections.impl.BitSet`	`_tokenSet_5`
`static antlr.collections.impl.BitSet`	`_tokenSet_50`
`static antlr.collections.impl.BitSet`	`_tokenSet_51`
`static antlr.collections.impl.BitSet`	`_tokenSet_52`
`static antlr.collections.impl.BitSet`	`_tokenSet_53`
`static antlr.collections.impl.BitSet`	`_tokenSet_54`
`static antlr.collections.impl.BitSet`	`_tokenSet_55`
`static antlr.collections.impl.BitSet`	`_tokenSet_56`
`static antlr.collections.impl.BitSet`	`_tokenSet_57`
`static antlr.collections.impl.BitSet`	`_tokenSet_58`
`static antlr.collections.impl.BitSet`	`_tokenSet_59`
`static antlr.collections.impl.BitSet`	`_tokenSet_6`
`static antlr.collections.impl.BitSet`	`_tokenSet_60`
`static antlr.collections.impl.BitSet`	`_tokenSet_61`
`static antlr.collections.impl.BitSet`	`_tokenSet_62`
`static antlr.collections.impl.BitSet`	`_tokenSet_63`
`static antlr.collections.impl.BitSet`	`_tokenSet_64`
`static antlr.collections.impl.BitSet`	`_tokenSet_65`
`static antlr.collections.impl.BitSet`	`_tokenSet_66`
`static antlr.collections.impl.BitSet`	`_tokenSet_67`
`static antlr.collections.impl.BitSet`	`_tokenSet_68`
`static antlr.collections.impl.BitSet`	`_tokenSet_69`
`static antlr.collections.impl.BitSet`	`_tokenSet_7`
`static antlr.collections.impl.BitSet`	`_tokenSet_8`
`static antlr.collections.impl.BitSet`	`_tokenSet_9`

Fields inherited from interface hamparse.Ham4ParserTokenTypes
A1LIST, A1TLIST, A2TLIST, ACTION1, ACTION1T, ACTION2, ACTION2T, BASICHDSHP, BASICHDSHP1, CNTCTBODY, CNTCTHAND, CNTCTOFHAND, CNTCTOHARM, CNTCTOHHAND, CRCLRMVMT, EOF, EXTFIDIR, EXTFIDIR1, EXTFIDIR2, FCROSSING, FIBENDING, FICRSSLIST, FINGERLIST, FISHPLIST, FSHAPE, HamAltbegin, HamAltend, HamAlternatingmotion, HamArcd, HamArcl, HamArcr, HamArcu, HamArmextended, HamBehind, HamBelowstomach, HamBetween, HamBrushing, HamCee12, HamCee12open, HamCeeall, HamCheek, HamChest, HamChin, HamCircled, HamCircledi, HamCircledl, HamCircledo, HamCircledr, HamCirclei, HamCircleil, HamCircleir, HamCirclel, HamCircleo, HamCircleol, HamCircleor, HamCircler, HamCircleu, HamCircleui, HamCircleul, HamCircleuo, HamCircleur, HamClockd, HamClockdl, HamClockdr, HamClockfull, HamClockl, HamClockr, HamClocku, HamClockul, HamClockur, HamClose, HamComma, HamCorefref, HamCoreftag, HamCross, HamDecreasing, HamDoublebent, HamDoublehooked, HamEar, HamEarlobe, HamElbow, HamElbowinside, HamEllipseh, HamEllipseul, HamEllipseur, HamEllipsev, HamEtc, HamExclaim, HamExtfingerd, HamExtfingerdi, HamExtfingerdl, HamExtfingerdo, HamExtfingerdr, HamExtfingeri, HamExtfingeril, HamExtfingerir, HamExtfingerl, HamExtfingero, HamExtfingerol, HamExtfingeror, HamExtfingerr, HamExtfingeru, HamExtfingerui, HamExtfingerul, HamExtfingeruo, HamExtfingerur, HamEyebrows, HamEyes, HamFast, HamFinger2, HamFinger23, HamFinger2345, HamFinger23spread, HamFingerbase, HamFingerbendmod, HamFingerhookedmod, HamFingermidjoint, HamFingernail, HamFingerpad, HamFingerplay, HamFingerside, HamFingerstraightmod, HamFingertip, HamFist, HamFlathand, HamForehead, HamFullstop, HamFusionbegin, HamFusionend, HamHalt, HamHandback, HamHead, HamHeadtop, HamIncreasing, HamIndexfinger, HamInterlock, HamLargemod, HamLinefeed, HamLips, HamLowerarm, HamLrat, HamLrbeside, HamMetaalt, HamMiddlefinger, HamMime, HamMovecross, HamMoved, HamMovedi, HamMovedl, HamMovedo, HamMovedr, HamMovei, HamMoveil, HamMoveir, HamMovel, HamMoveo, HamMoveol, HamMoveor, HamMover, HamMoveu, HamMoveui, HamMoveul, HamMoveuo, HamMoveur, HamMovex, HamNbs, HamNeck, HamNeutralspace, HamNodding, HamNomotion, HamNondominant, HamNonipsi, HamNose, HamNostrils, HamOrirelative, HamPagebreak, HamPalm, HamPalmd, HamPalmdl, HamPalmdr, HamPalml, HamPalmr, HamPalmu, HamPalmul, HamPalmur, HamParbegin, HamParend, HamPinch12, HamPinch12open, HamPinchall, HamPinky, HamPinkyside, HamPlus, HamQuery, HamRepeatcontinue, HamRepeatcontinueseveral, HamRepeatfromstart, HamRepeatfromstartseveral, HamRepeatreverse, HamReplace, HamRest, HamReturn, HamRingfinger, HamSeqbegin, HamSeqend, HamShoulders, HamShouldertop, HAMSIGNS, HamSlow, HamSmallmod, HamSpace, HamStirccw, HamStircw, HamStomach, HamSwinging, HamSymmlr, HamSymmpar, HamTab, HamTeeth, HamTense, HamThumb, HamThumbacrossmod, HamThumbball, HamThumbopenmod, HamThumboutmod, HamThumbside, HamTongue, HamTouch, HamTwisting, HamUnderchin, HamUpperarm, HamVersion40, HamWavy, HamWristback, HamWristpulse, HamWristtoback, HamWristtopinky, HamWristtopulse, HamWristtothumb, HamZigzag, HCONSTLLN, HDCFGTAIL2, HDCONFIG1, HDCONFIG2, HSCLASS, HSFINGERITEM, HSHAPE1, HSHAPE2, ICFG1, ICFG2, LEVARM, LEVBODY, LEVHAND, LOC1, LOC2, LOCBODY, LOCTNARM, LOCTNBODY, LOCTNBODYARM, LOCTNHAND, MICFG1, MICFG2, MOVINGREPETITION, NMACT1T, NMICLIST, NMICUNIT, NULL_TREE_LOOKAHEAD, PALMOR1, PALMOR2, PARACT1, PARACT1T, PARACT2T, REPETITIONS, REPLACE, REPLACETAIL1, SEQACT1, SEQACT1T, SEQACT2T, SEQFUSEDACT1, SEQFUSEDACT1T, SEQFUSEDACT2T, SIGN1, SIGN2, SIMPLEMVMT, SPLITACT2LOC2, SPLITACT2T, SPLITHDCFG2, SPLITREPLACETL, STRGHTMVMT, THSPECIAL, THUMBPOS, WS

Constructor Summary

Constructors
Constructor and Description
`Ham4Parser(antlr.ParserSharedInputState state)`
`Ham4Parser(antlr.TokenBuffer tokenBuf)`
`Ham4Parser(antlr.TokenStream lexer)`
`Ham4Parser(antlr.TokenStream lexer, boolean erimmed)` Constructs a new HNS-4 sign parser, taking input from the given token stream, and using the given setting of the Immediate Error Reporting flag.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`a1tlist()` a1tlist : ( `action1t` `a1tlist` )? ;
`void`	`a1tstar()` a1tstar : `a1tlist` // { #a1tstar = #([A1TLIST,"a1tstar"], #a1tstar); } ;
`void`	`a2tlist()` a2tlist : ( (`action2t`) => `action2t` `a2tlist` )? ;
`void`	`a2tstar()` a2tstar : `a2tlist` // { #a2tstar = #([A2TLIST,"a2tstar"], #a2tstar); } ;
`void`	`action1()` action1 : ( HamNomotion \| `simplemovement` ( ( `modifier` )+ ( HamLargemod )? )? \| ( HamSeqbegin `digit` ) => `specialfingerplaymovement` \| `paraction1` \| `seqaction1` \| `seqfusedaction1` ) { #action1 = #([ACTION1,"action1"], #action1); } ;
`void`	`action1t()` action1t : ( ( `action1` ) => ( `action1` ( ( `handconstellation` ) => `handconstellation` \| `location1` ( HamLargemod )? )? ) \| `paraction1t` \| ( `nmaction1t` ) //#### 2003-08 => `nmaction1t` \| `seqaction1t` \| `seqfusedaction1t` ) `repetitionsoption` // { #action1t = #([ACTION1T,"action1t"], #action1t); } ;
`void`	`action2t()` action2t : ( ( `action1` `location2not1` ) => `action1` `location2not1` `repetitionsoption` \| ( `action1t` ) => `action1t` \| ( ( HamParbegin ( `action1` )+ HamPlus ( `action1` )+ HamParend `location2` ) => `splitaction2loc2` \| ( HamParbegin ( `action1t` )+ HamPlus ) => `splitaction2t` \| `paraction2t` \| `seqaction2t` \| `seqfusedaction2t` ) `repetitionsoption` ) { #action2t = #([ACTION2T,"action2t"], #action2t); } ;
`void`	`alternations()` alternations : HamAlternatingmotion ( HamAlternatingmotion )? ;
`void`	`arc()` arc : HamArcl \| HamArcu \| HamArcr \| HamArcd ;
`void`	`arckind()` arckind : `arc` ( `arc` )? ( `size` )? ;
`void`	`basichandshape()` basichandshape : ( `handshapeclass` \| HamNondominant ) // 2011-03 // Allow HamEtc for "underspecified"/approximate.
`void`	`basichandshape1()` basichandshape1 : `basichandshape` ( ( HamBetween `handshapeclass` ) //#### 2003-08 => HamBetween ! `basichandshape` )? { #basichandshape1 = #([BASICHDSHP1,"basichandshape1"], #basichandshape1); } ;
`void`	`brushingcontact()` brushingcontact : HamSeqbegin ! HamBrushing `location1` HamSeqend ! ;
`void`	`cautiousfingerlist()` cautiousfingerlist : `reccautiousfingerlist` // { #cautiousfingerlist = #([FINGERLIST,"fingerlist"], #cautiousfingerlist); } ;
`void`	`ccontact()` ccontact : HamInterlock \| HamCross ;
`void`	`checkForParseError()` Does nothing unless parse errors have occurred, in which case a new `RecognitionException` is thrown whose detail message is a complete parsing error log.
`void`	`circularmovement()` circularmovement : `movementcircle` ( HamBetween ! `movementcircle` )? { #circularmovement = #([CRCLRMVMT,"crclrmvmt"], #circularmovement); } ;
`void`	`clock()` clock : HamClocku \| HamClockul \| HamClockl \| HamClockdl \| HamClockd \| HamClockdr \| HamClockr \| HamClockur ;
`void`	`contactbody()` contactbody : ( `pcontact` \| HamArmextended \| `contactofhand` ) { #contactbody = #([CNTCTBODY,"contactbody"], #contactbody); } ;
`void`	`contacthand()` contacthand : ( `pcontact` \| `ccontact` \| `contactofhand` ) { #contacthand = #([CNTCTHAND,"contacthand"], #contacthand); } ;
`void`	`contactofhand()` contactofhand : HamSeqbegin ! ( `pcontact` \| `ccontact` ) ( ( `levelhand` ) => `contactohhand` \| `contactoharm` ) HamSeqend ! // { #contactofhand = #([CNTCTOFHAND,"contactofhand"], #contactofhand); } ;
`void`	`contactoharm()` contactoharm : `levelcomplexarm` // { #contactoharm = #([CNTCTOHARM,"contactoharm"], #contactoharm); } ;
`void`	`contactohhand()` contactohhand : `levelcomplexhand` // { #contactohhand = #([CNTCTOHHAND,"contactohhand"], #contactohhand); } ;
`void`	`digit()` digit : `thumb` \| `finger` ;
`void`	`dorsalorpalmar()` dorsalorpalmar : HamHandback \| HamPalm ;
`void`	`ellipse()` ellipse : `ellipsedirection` ( `size` )? ;
`void`	`ellipsedirection()` ellipsedirection : HamEllipseh \| HamEllipseur \| HamEllipsev \| HamEllipseul ;
`void`	`extfidir()` extfidir : ( HamExtfingeru \| HamExtfingerur \| HamExtfingerr \| HamExtfingerdr \| HamExtfingerd \| HamExtfingerdl \| HamExtfingerl \| HamExtfingerul \| ( HamExtfingerol ( HamExtfingeruo \| HamExtfingerdo )? ) \| HamExtfingero \| ( HamExtfingeror ( HamExtfingeruo \| HamExtfingerdo )? ) \| ( HamExtfingeril ( HamExtfingerui \| HamExtfingerdi )? ) \| HamExtfingeri \| ( HamExtfingerir ( HamExtfingerui \| HamExtfingerdi )? ) \| ( HamExtfingerui ( HamExtfingeril \| HamExtfingerir )? ) \| ( HamExtfingerdi ( HamExtfingeril \| HamExtfingerir )? ) \| ( HamExtfingerdo ( HamExtfingerol \| HamExtfingeror )? ) \| ( HamExtfingeruo ( HamExtfingerol \| HamExtfingeror )? ) ) { #extfidir = #([EXTFIDIR,"extfidir"], #extfidir); } ;
`void`	`extfidir1()` extfidir1 : `extfidir` ( HamBetween ! `extfidir` )? ( HamOrirelative )? { #extfidir1 = #([EXTFIDIR1,"extfidir1"], #extfidir1); } ;
`void`	`extfidir2()` extfidir2 : ( `extfidir1` \| `splitextfidir2` ) { #extfidir2 = #([EXTFIDIR2,"extfidir2"], #extfidir2); } ;
`void`	`finger()` finger : HamIndexfinger \| HamMiddlefinger \| HamRingfinger \| HamPinky ;
`void`	`fingerbending()` fingerbending : ( HamFingerstraightmod \| HamFingerbendmod \| HamFingerhookedmod \| HamDoublebent \| HamDoublehooked ) { #fingerbending = #([FIBENDING,"fingerbending"], #fingerbending); } ;
`void`	`fingercrossing()` fingercrossing : `digit` `fingerpart` `digit` // { #fingercrossing = #([FCROSSING,"fingercrossing"], #fingercrossing); } ;
`void`	`fingercrossinglist()` fingercrossinglist : `recfingercrossinglist` // { #fingercrossinglist = #([FICRSSLIST,"fingercrossinglist"], #fingercrossinglist); } ;
`void`	`fingerlist()` fingerlist : `recfingerlist` // { #fingerlist = #([FINGERLIST,"fingerlist"], #fingerlist); } ;
`void`	`fingerpart()` fingerpart : HamFingertip \| HamFingernail \| HamFingerpad \| HamFingermidjoint \| HamFingerbase \| HamFingerside ;
`void`	`fingershape()` fingershape : `digit` `fingerbending` // { #fingershape = #([FSHAPE,"fingershape"], #fingershape); } ;
`void`	`fingershapelist()` fingershapelist : `recfingershapelist` // { #fingershapelist = #([FISHPLIST,"fingershapelist"], #fingershapelist); } ;
`void`	`hamsignseq()` hamsignseq : ( `sign2or1` ( HamPlus ! `sign2or1` )* )? ;
`void`	`hamsinglesign()` hamsinglesign : `hamsignseq` EOF ! ;
`void`	`handbendandthumb()` handbendandthumb : // empty \| `thumbpos` ( `fingerbending` )? \| `fingerbending` ( `thumbpos` )? ;
`void`	`handconfig1()` handconfig1 : `handshape1` ( `extfidir1` `palmor1` )? // { #handconfig1 = #([HDCONFIG1,"handconfig1"], #handconfig1); } ;
`void`	`handconfig2()` handconfig2 : ( ( `handshape2` ( HamParbegin )? `extfidir1` ) => `handshape2` `handconfigtail2` \| ( `handshape2` ) => `handshape2` \| `splithandconfig2` ) //#### before 2003-08-30: // ( // ( handconfig1 ) // => // handconfig1 // \| // ( HamParbegin handshape1 HamPlus ) // => // handshape2 // handconfigtail2 // \| // ( handshape1 ( HamParbegin )? extfidir1 ) // => // handshape2 // handconfigtail2 // \| // abbrevhandconfig1 // \| // splithandconfig2 // ) // { #handconfig2 = #([HDCONFIG2,"handconfig2"], #handconfig2); } ;
`void`	`handconfigtail2()` handconfigtail2 : ( ( `extfidir2` ) => `extfidir2` `palmor2` \| HamParbegin ! `extfidir1` `palmor1` HamPlus ! `extfidir1` `palmor1` HamParend ! ) { #handconfigtail2 = #([HDCFGTAIL2,"hdcfgtail2"], #handconfigtail2); } ;
`void`	`handconstellation()` handconstellation : ( HamParbegin ! `locationhand` HamPlus ! `locationhand` HamParend ! )? `contacthand` // { #handconstellation = #([HCONSTLLN,"handconstellation"], #handconstellation); } ;
`void`	`handpart()` handpart : HamWristback \| HamWristpulse \| HamThumbball \| HamPalm \| HamHandback \| HamThumbside \| HamPinkyside ;
`void`	`handshape1()` handshape1 : `basichandshape1` ( ( ( `hsfingeritem` )+ HamBetween `finger` ) => `cautiousfingerlist` `fingershapelist` `fingercrossinglist` `thumbbetweenexplicit` \| ( ( `hsdigit` )* ( `fingerbending` \| `fingerpart` ) ) => `cautiousfingerlist` `fingershapelist` `fingercrossinglist` ( ( `thumbspecial` ) => `thumbspecial` )? \| ( ( `hsfingeritem` )* ( `thumbbetweendefault` \| `thumbextra` ) ) => `fingerlist` `fingershapelist` `fingercrossinglist` ( `thumbbetweendefault` \| `thumbextra` ) \| `fingerlist` `fingershapelist` `fingercrossinglist` ) { #handshape1 = #([HSHAPE1,"handshape1"], #handshape1); } ;
`void`	`handshape2()` handshape2 : ( `handshape1` \| HamParbegin ! `handshape1` HamPlus ! `handshape1` HamParend ! ) { #handshape2 = #([HSHAPE2,"handshape2"], #handshape2); } ;
`void`	`handshapeclass()` handshapeclass : ( HamFist \| HamFlathand \| HamFinger2 \| HamFinger23 \| HamFinger23spread \| HamFinger2345 \| HamPinch12 \| HamPinchall \| HamPinch12open \| HamCee12 \| HamCeeall \| HamCee12open ) { #handshapeclass = #([HSCLASS,"handshapeclass"], #handshapeclass); } ;
`void`	`hsdigit()` hsdigit //#### HNS-4 : `thumb` \| `hsfingeritem` ;
`void`	`hsfingeritem()` hsfingeritem //#### HNS-4 : `finger` ( HamLargemod )? // { #hsfingeritem = #([HSFINGERITEM,"hsfingeritem"], #hsfingeritem); } ;
`void`	`initialconfig1()` initialconfig1 : ( `nminitialconfig` )? `minitialconfig1` // { #initialconfig1 = #([ICFG1,"initialconfig1"], #initialconfig1); } ;
`void`	`initialconfig2()` initialconfig2 : ( `nminitialconfig` )? `minitialconfig2` // { #initialconfig2 = #([ICFG2,"initialconfig2"], #initialconfig2); } ;
`void`	`levelarm()` levelarm : ( // 2011-03 // Allow HamEtc for "underspecified"/approximate.
`void`	`levelbody()` levelbody : ( // 2011-03 // Allow HamEtc for "underspecified"/approximate.
`void`	`levelcomplexarm()` levelcomplexarm : `levelarm` ( HamBetween ! `levelarm` )? ;
`void`	`levelcomplexbody()` levelcomplexbody : `levelbody` ( HamBetween ! `levelbody` )? ;
`void`	`levelcomplexhand()` levelcomplexhand : `levelhand` ( HamBetween ! `levelhand` )? ;
`void`	`levelhand()` levelhand : ( `lochand` ( `dorsalorpalmar` )? ( `side` ) => ( `side` )? \| `side` `lochand` ( `dorsalorpalmar` )? ) { #levelhand = #([LEVHAND,"levelhand"], #levelhand); } ;
`void`	`locarm()` locarm : HamUpperarm \| HamElbow \| HamElbowinside \| HamLowerarm ;
`void`	`location1()` location1 : ( ( `locationindexuse` ) //#### 2003-08 => `locationindexuse` \| ( `levelhand` ) => `locationhand` \| `locationbodyarm` ) { #location1 = #([LOC1,"location1"], #location1); } ;
`void`	`location1as2()` location1as2 : `location1` { #location1as2 = #([LOC2,"location1as2"], #location1as2); } ;
`void`	`location2()` location2 : ( `location1as2` \| `location2not1` ) ;
`void`	`location2not1()` location2not1 : ( ( `handconstellation` ) => `handconstellation` ( HamNeutralspace ! ( HamArmextended )? \| ( `locationbody` )? // //2001-07-05 //If we replace the above option with the following, i.e.
`void`	`locationarm()` locationarm : `levelcomplexarm` ( HamBehind )? ( ( `contactbody` ) => `contactbody` )? // { #locationarm = #([LOCTNARM,"locationarm"], #locationarm); } ;
`void`	`locationbody()` locationbody : `levelcomplexbody` ( HamBehind )? ( ( `contactbody` ) => `contactbody` )? // { #locationbody = #([LOCTNBODY,"locationbody"], #locationbody); } ;
`void`	`locationbodyarm()` locationbodyarm : ( HamNeutralspace ! ( HamArmextended )? \| ( `levelbody` ) => `locationbody` \| `locationarm` ) { #locationbodyarm = #([LOCTNBODYARM,"locationbodyarm"], #locationbodyarm); } ;
`void`	`locationhand()` locationhand : `levelcomplexhand` ( (`contacthand`) => `contacthand` )? // { #locationhand = #([LOCTNHAND,"locationhand"], #locationhand); } ;
`void`	`locationindexdefine()` locationindexdefine : `digit` HamCoreftag ! ;
`void`	`locationindexuse()` locationindexuse : `digit` HamCorefref ! ;
`void`	`locbody()` locbody : ( HamHead \| HamHeadtop \| HamForehead \| HamEyebrows // \| HamEyes #### see below \| HamNose \| HamNostrils // \| HamLips #### see below \| HamTongue \| ( ( HamEyes \| HamLips \| HamTeeth ) ( HamDoublebent \| HamDoublehooked )? ) \| HamChin \| HamUnderchin \| HamNeck \| HamShouldertop \| HamShoulders \| HamChest \| HamStomach \| HamBelowstomach ) { #locbody = #([LOCBODY,"locbody"], #locbody); } ;
`void`	`lochand()` lochand : ( `handpart` \| `fingerpart` ( `digit` )* \| ///#### 2003-08 New HNS-4-Orientated version: ( `digit` )+ ( `fingerpart` )? // was: // digit // ( // ( digit )* // \| // fingerpart // ) // ) ;
`void`	`locsided()` locsided : HamEar \| HamEarlobe \| HamCheek ;
`void`	`minitialconfig1()` minitialconfig1 : `handconfig1` ( `location1` )? // { #minitialconfig1 = #([MICFG1,"minitialconfig1"], #minitialconfig1); } ;
`void`	`minitialconfig2()` minitialconfig2 : ( ( `handconfig2` ) => `handconfig2` ( ( `location2` ) => `location2` )? \| HamParbegin ! `handconfig1` ( ( HamPlus ) => HamPlus //?? handconfig1 `location1` HamParend ! \| `location1` HamPlus //?? handconfig1 ( `location1` )? HamParend ! ) ) { #minitialconfig2 = #([MICFG2,"minitialconfig2"], #minitialconfig2); } ;
`void`	`modifier()` modifier : HamFast \| HamSlow \| HamTense \| HamRest \| HamHalt ;
`void`	`movementarrow()` movementarrow : HamMoveu \| HamMoveur \| HamMover \| HamMovedr \| HamMoved \| HamMovedl \| HamMovel \| HamMoveul \| HamMoveol \| HamMoveo \| HamMoveor \| HamMoveil \| HamMovei \| HamMoveir \| HamMoveui \| HamMovedi \| HamMovedo \| HamMoveuo ;
`void`	`movementcircle()` movementcircle : HamCircleo \| HamCirclei \| HamCircled \| HamCircleu \| HamCirclel \| HamCircler \| HamCircleul \| HamCircledr \| HamCircleur \| HamCircledl \| HamCircleol \| HamCircleir \| HamCircleor \| HamCircleil \| HamCircleui \| HamCircledo \| HamCircledi \| HamCircleuo ;
`void`	`movementcross()` movementcross : HamMovecross \| HamMovex ;
`void`	`movingrepetition()` movingrepetition : HamSeqbegin ! `repetition` `movementarrow` ( `size` )? ( `sizechangenonlinear` )? HamSeqend ! // { #movingrepetition = #([MOVINGREPETITION, "movingrepetition"], #movingrepetition); } ;
`void`	`nmaction1t()` nmaction1t : HamSeqbegin ! ( ( `levelbody` ) => `levelbody` \| `levelarm` ) //#### 2007-03: `action1t` HamSeqend ! // { #nmaction1t = #([NMACT1T,"nmact1t"], #nmaction1t); } ;
`void`	`nmicunit()` nmicunit : HamSeqbegin ! ( ( `levelbody` ) => `levelbody` \| `levelarm` ) `action1` HamSeqend ! // { #nmicunit = #([NMICUNIT,"nmicunit"], #nmicunit); } ;
`void`	`nminitialconfig()` nminitialconfig : ( `nmicunit` )+ { #nminitialconfig = #([NMICLIST,"nminitialconfig"], #nminitialconfig); } ;
`void`	`nondomsign1()` nondomsign1 : HamNondominant `initialconfig1` `a1tstar` // { #nondomsign1 = #([SIGN1,"sign1"], #nondomsign1); } ;
`void`	`palmor()` palmor : HamPalmu \| HamPalmur \| HamPalmr \| HamPalmdr \| HamPalmd \| HamPalmdl \| HamPalml \| HamPalmul ;
`void`	`palmor1()` palmor1 : `palmor` ( HamBetween ! `palmor` // 2011-04 // Added HamEtc option for "underspecified"/approximate.
`void`	`palmor2()` palmor2 : ( `palmor1` \| `splitpalmor2` ) { #palmor2 = #([PALMOR2,"palmor2"], #palmor2); } ;
`void`	`paraction1()` paraction1 : HamParbegin ! ( `action1` )+ HamParend ! // { #paraction1 = #([PARACT1,"paract1"], #paraction1); } ;
`void`	`paraction1t()` paraction1t : HamParbegin ! ( `action1t` )+ HamParend ! // { #paraction1t = #([PARACT1T,"paract1t"], #paraction1t); } ;
`void`	`paraction2t()` paraction2t : HamParbegin ! ( `action2t` )+ HamParend ! // { #paraction2t = #([PARACT2T,"paract2t"], #paraction2t); } ;
`void`	`pcontact()` pcontact : HamTouch \| HamClose ;
`void`	`reccautiousfingerlist()` reccautiousfingerlist // recursive cautious finger list : ( ( `hsfingeritem` `digit` ) => `hsfingeritem` `reccautiousfingerlist` )? ;
`void`	`recfingercrossinglist()` recfingercrossinglist // recursive fingercrossinglist : ( ( `fingercrossing` ) => `fingercrossing` `recfingercrossinglist` )? ;
`void`	`recfingerlist()` recfingerlist // recursive finger list : ( ( `hsfingeritem` ) => `hsfingeritem` `recfingerlist` )? ;
`void`	`recfingershapelist()` recfingershapelist // recursive fingershapelist : ( ( `fingershape` ) => `fingershape` `recfingershapelist` )? ;
`void`	`repetition()` repetition : HamRepeatfromstart \| HamRepeatfromstartseveral \| HamRepeatcontinue \| HamRepeatcontinueseveral \| HamRepeatreverse ;
`void`	`repetitions()` repetitions : // 2011-03 // Allow HamEtc after HamRepeatfromstartseveral, for // "underspecified"/approximate repeat locations.
`void`	`repetitionsoption()` repetitionsoption : ( ( ( HamSeqbegin )? `repetition` \| HamAlternatingmotion ) => `repetitions` )? ;
`void`	`replacement()` replacement : HamReplace ! //#### 2011-03: now allow HNS4 sizechange, to control staged order of change.
`void`	`replacetail1()` replacetail1 : ( `extfidir1` ( `palmor1` )? \| `palmor1` ) { #replacetail1 = #([REPLACETAIL1,"replacetail1"], #replacetail1); } ;
`void`	`reportError(antlr.RecognitionException ex)` Reports the parsing error defined by the given exception: an error message is appended to the overall error text for this parse, and a message is also generated immediately on standard output if the parser's Immediate Error Reporting flag is set.
`void`	`revolutions()` revolutions : ( `clock` ( HamClockfull ( HamClockfull )? )? ( `clock` )? \| HamClockfull ( HamClockfull )? ( `clock` )? ) ;
`void`	`seqaction1()` seqaction1 : HamSeqbegin ! ( `action1` )+ HamSeqend ! // { #seqaction1 = #([SEQACT1,"seqact1"], #seqaction1); } ;
`void`	`seqaction1t()` seqaction1t : HamSeqbegin ! ( `action1t` )+ HamSeqend ! // { #seqaction1t = #([SEQACT1T,"seqact1t"], #seqaction1t); } ;
`void`	`seqaction2t()` seqaction2t : HamSeqbegin ! ( `action2t` )+ HamSeqend ! // { #seqaction2t = #([SEQACT2T,"seqact2t"], #seqaction2t); } ;
`void`	`seqfusedaction1()` seqfusedaction1 : HamFusionbegin ! ( `action1` )+ HamFusionend ! // { #seqfusedaction1 = #([SEQFUSEDACT1,"seqfusedaction1"], #seqfusedaction1); } ;
`void`	`seqfusedaction1t()` seqfusedaction1t : HamFusionbegin ! ( `action1t` )+ HamFusionend ! // { #seqfusedaction1t = #([SEQFUSEDACT1T,"seqfusedaction1t"], #seqfusedaction1t); } ;
`void`	`seqfusedaction2t()` seqfusedaction2t : HamFusionbegin ! ( `action2t` )+ HamFusionend ! // { #seqfusedaction2t = #([SEQFUSEDACT2T,"seqfusedaction2t"], #seqfusedaction2t); } ;
`void`	`side()` side : HamLrbeside \| HamLrat ;
`void`	`sign2()` sign2 : ( `symmoperator` `initialconfig2` `a2tstar` \| `initialconfig2` `a1tstar` \| //#### 2004-06 // Extra option to support SiGML 's "holdover" // attribute, specifying that the non-performing hand in an // otherwise single-handed sign is to retain its posture (from // the end of the previous sign or rest position) throughout // this sign.
`void`	`sign2or1()` sign2or1 : ( HamNondominant `initialconfig1` ) => `nondomsign1` \| `sign2` ;
`void`	`simplemovement()` simplemovement : ( `straightmovement` ( `size` )? ( `arckind` \| `zigzag` )? \| `circularmovement` ( `size` )? ( `revolutions` )? ( `ellipse` )? ( `sizechangenonlinear` )? \| `movementcross` ( `size` )? \| `wristmovement` ( `size` )? \| `replacement` \| HamFingerplay // 2011-04 // The more complex form of fingerplay logically goes here, // but to simplify the lookahead in action1 that form is factored // out as a separate nonterminal, specialfingerplaymovement, below.
`void`	`size()` size : HamSmallmod \| HamLargemod ;
`void`	`sizechange()` sizechange : HamIncreasing \| HamDecreasing ;
`void`	`sizechangenonlinear()` sizechangenonlinear : `sizechange` ( `size` )? ;
`void`	`specialfingerplaymovement()` specialfingerplaymovement : // 2011-04 // Logically this is one of the alternatives in simplemovement, but it // is factored out in order to simplify the lookahead in action1.
`void`	`splitaction2loc2()` splitaction2loc2 : HamParbegin ! ( `action1` )+ HamPlus ( `action1` )+ HamParend ! `location2` // { #splitaction2loc2 = #([SPLITACT2LOC2,"splitact2loc2"], #splitaction2loc2); } ;
`void`	`splitaction2t()` splitaction2t : HamParbegin ! ( `action1t` )+ HamPlus ( `action1t` )+ HamParend ! // { #splitaction2t = #([SPLITACT2T,"splitact2t"], #splitaction2t); } ;
`void`	`splitextfidir2()` splitextfidir2 : HamParbegin ! `extfidir1` HamPlus ! `extfidir1` HamParend ! ;
`void`	`splithandconfig2()` splithandconfig2 : HamParbegin ! `handconfig1` HamPlus ! `handconfig1` HamParend ! // { #splithandconfig2 = #([SPLITHDCFG2,"splithdcfg2"], #splithandconfig2); } ;
`void`	`splitpalmor2()` splitpalmor2 : HamParbegin ! `palmor1` HamPlus ! `palmor1` HamParend ! ;
`void`	`splitreplacetail()` splitreplacetail : HamParbegin ! `replacetail1` HamPlus ! ( HamNomotion ! \| `replacetail1` ) HamParend ! // { #splitreplacetail = #([SPLITREPLACETL,"splitreplacetail"], #splitreplacetail); } ;
`void`	`straightmovement()` straightmovement : `movementarrow` ( HamBetween ! `movementarrow` )? { #straightmovement = #([STRGHTMVMT,"strghtmvmt"], #straightmovement); } ;
`void`	`symmoperator()` symmoperator : ( HamSymmpar \| HamSymmlr ) ( HamFingerstraightmod ( HamLargemod )? \| HamLargemod ( HamFingerstraightmod )? )? ( HamAlternatingmotion )? ( HamNonipsi )? ;
`void`	`thumb()` thumb : HamThumb ;
`void`	`thumbbetween()` thumbbetween : `thumbbetweenexplicit` \| `thumbbetweendefault` ;
`void`	`thumbbetweendefault()` thumbbetweendefault : HamBetween // { #thumbbetweendefault = #([THSPECIAL,"thumbspecial"], #thumbbetweendefault); } ;
`void`	`thumbbetweenexplicit()` thumbbetweenexplicit : `finger` HamBetween ^ `finger` // { #thumbbetweenexplicit = #([THSPECIAL,"thumbspecial"], #thumbbetweenexplicit); } ;
`void`	`thumbextra()` thumbextra : ( `thumb` \| `fingerpart` ) { #thumbextra = #([THSPECIAL,"thumbspecial"], #thumbextra); } ;
`void`	`thumbpos()` thumbpos : ( HamThumboutmod \| HamThumbacrossmod \| HamThumbopenmod ) { #thumbpos = #([THUMBPOS,"thumbpos"], #thumbpos); } ;
`void`	`thumbspecial()` thumbspecial : `thumbbetween` \| `thumbextra` ;
`void`	`wristmovement()` wristmovement : HamNodding \| HamSwinging \| HamTwisting \| HamStircw \| HamStirccw ;
`void`	`zigzag()` zigzag : ( HamZigzag \| HamWavy ) ( `size` )? ( `ellipsedirection` )? ( `sizechangenonlinear` )? ;

Methods inherited from class antlr.LLkParser
consume, LA, LT, traceIn, traceOut

Methods inherited from class antlr.Parser
addMessageListener, addParserListener, addParserMatchListener, addParserTokenListener, addSemanticPredicateListener, addSyntacticPredicateListener, addTraceListener, consumeUntil, consumeUntil, getAST, getASTFactory, getFilename, getInputState, getTokenName, getTokenNames, getTokenTypeToASTClassMap, isDebugMode, mark, match, match, matchNot, panic, recover, removeMessageListener, removeParserListener, removeParserMatchListener, removeParserTokenListener, removeSemanticPredicateListener, removeSyntacticPredicateListener, removeTraceListener, reportError, reportWarning, rewind, setASTFactory, setASTNodeClass, setASTNodeType, setDebugMode, setFilename, setIgnoreInvalidDebugCalls, setInputState, setTokenBuffer, traceIndent

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

_tokenNames

public static final java.lang.String[] _tokenNames

_tokenSet_0

public static final antlr.collections.impl.BitSet _tokenSet_0

_tokenSet_1

public static final antlr.collections.impl.BitSet _tokenSet_1

_tokenSet_2

public static final antlr.collections.impl.BitSet _tokenSet_2

_tokenSet_3

public static final antlr.collections.impl.BitSet _tokenSet_3

_tokenSet_4

public static final antlr.collections.impl.BitSet _tokenSet_4

_tokenSet_5

public static final antlr.collections.impl.BitSet _tokenSet_5

_tokenSet_6

public static final antlr.collections.impl.BitSet _tokenSet_6

_tokenSet_7

public static final antlr.collections.impl.BitSet _tokenSet_7

_tokenSet_8

public static final antlr.collections.impl.BitSet _tokenSet_8

_tokenSet_9

public static final antlr.collections.impl.BitSet _tokenSet_9

_tokenSet_10

public static final antlr.collections.impl.BitSet _tokenSet_10

_tokenSet_11

public static final antlr.collections.impl.BitSet _tokenSet_11

_tokenSet_12

public static final antlr.collections.impl.BitSet _tokenSet_12

_tokenSet_13

public static final antlr.collections.impl.BitSet _tokenSet_13

_tokenSet_14

public static final antlr.collections.impl.BitSet _tokenSet_14

_tokenSet_15

public static final antlr.collections.impl.BitSet _tokenSet_15

_tokenSet_16

public static final antlr.collections.impl.BitSet _tokenSet_16

_tokenSet_17

public static final antlr.collections.impl.BitSet _tokenSet_17

_tokenSet_18

public static final antlr.collections.impl.BitSet _tokenSet_18

_tokenSet_19

public static final antlr.collections.impl.BitSet _tokenSet_19

_tokenSet_20

public static final antlr.collections.impl.BitSet _tokenSet_20

_tokenSet_21

public static final antlr.collections.impl.BitSet _tokenSet_21

_tokenSet_22

public static final antlr.collections.impl.BitSet _tokenSet_22

_tokenSet_23

public static final antlr.collections.impl.BitSet _tokenSet_23

_tokenSet_24

public static final antlr.collections.impl.BitSet _tokenSet_24

_tokenSet_25

public static final antlr.collections.impl.BitSet _tokenSet_25

_tokenSet_26

public static final antlr.collections.impl.BitSet _tokenSet_26

_tokenSet_27

public static final antlr.collections.impl.BitSet _tokenSet_27

_tokenSet_28

public static final antlr.collections.impl.BitSet _tokenSet_28

_tokenSet_29

public static final antlr.collections.impl.BitSet _tokenSet_29

_tokenSet_30

public static final antlr.collections.impl.BitSet _tokenSet_30

_tokenSet_31

public static final antlr.collections.impl.BitSet _tokenSet_31

_tokenSet_32

public static final antlr.collections.impl.BitSet _tokenSet_32

_tokenSet_33

public static final antlr.collections.impl.BitSet _tokenSet_33

_tokenSet_34

public static final antlr.collections.impl.BitSet _tokenSet_34

_tokenSet_35

public static final antlr.collections.impl.BitSet _tokenSet_35

_tokenSet_36

public static final antlr.collections.impl.BitSet _tokenSet_36

_tokenSet_37

public static final antlr.collections.impl.BitSet _tokenSet_37

_tokenSet_38

public static final antlr.collections.impl.BitSet _tokenSet_38

_tokenSet_39

public static final antlr.collections.impl.BitSet _tokenSet_39

_tokenSet_40

public static final antlr.collections.impl.BitSet _tokenSet_40

_tokenSet_41

public static final antlr.collections.impl.BitSet _tokenSet_41

_tokenSet_42

public static final antlr.collections.impl.BitSet _tokenSet_42

_tokenSet_43

public static final antlr.collections.impl.BitSet _tokenSet_43

_tokenSet_44

public static final antlr.collections.impl.BitSet _tokenSet_44

_tokenSet_45

public static final antlr.collections.impl.BitSet _tokenSet_45

_tokenSet_46

public static final antlr.collections.impl.BitSet _tokenSet_46

_tokenSet_47

public static final antlr.collections.impl.BitSet _tokenSet_47

_tokenSet_48

public static final antlr.collections.impl.BitSet _tokenSet_48

_tokenSet_49

public static final antlr.collections.impl.BitSet _tokenSet_49

_tokenSet_50

public static final antlr.collections.impl.BitSet _tokenSet_50

_tokenSet_51

public static final antlr.collections.impl.BitSet _tokenSet_51

_tokenSet_52

public static final antlr.collections.impl.BitSet _tokenSet_52

_tokenSet_53

public static final antlr.collections.impl.BitSet _tokenSet_53

_tokenSet_54

public static final antlr.collections.impl.BitSet _tokenSet_54

_tokenSet_55

public static final antlr.collections.impl.BitSet _tokenSet_55

_tokenSet_56

public static final antlr.collections.impl.BitSet _tokenSet_56

_tokenSet_57

public static final antlr.collections.impl.BitSet _tokenSet_57

_tokenSet_58

public static final antlr.collections.impl.BitSet _tokenSet_58

_tokenSet_59

public static final antlr.collections.impl.BitSet _tokenSet_59

_tokenSet_60

public static final antlr.collections.impl.BitSet _tokenSet_60

_tokenSet_61

public static final antlr.collections.impl.BitSet _tokenSet_61

_tokenSet_62

public static final antlr.collections.impl.BitSet _tokenSet_62

_tokenSet_63

public static final antlr.collections.impl.BitSet _tokenSet_63

_tokenSet_64

public static final antlr.collections.impl.BitSet _tokenSet_64

_tokenSet_65

public static final antlr.collections.impl.BitSet _tokenSet_65

_tokenSet_66

public static final antlr.collections.impl.BitSet _tokenSet_66

_tokenSet_67

public static final antlr.collections.impl.BitSet _tokenSet_67

_tokenSet_68

public static final antlr.collections.impl.BitSet _tokenSet_68

_tokenSet_69

public static final antlr.collections.impl.BitSet _tokenSet_69

Constructor Detail

Ham4Parser
```
public Ham4Parser(antlr.TokenStream lexer,
                  boolean erimmed)
```
Constructs a new HNS-4 sign parser, taking input from the given token stream, and using the given setting of the Immediate Error Reporting flag.

Ham4Parser

public Ham4Parser(antlr.TokenBuffer tokenBuf)

Ham4Parser

public Ham4Parser(antlr.TokenStream lexer)

Ham4Parser

public Ham4Parser(antlr.ParserSharedInputState state)

Method Detail

checkForParseError
```
public void checkForParseError()
                        throws antlr.RecognitionException
```
Does nothing unless parse errors have occurred, in which case a new RecognitionException is thrown whose detail message is a complete parsing error log.

Throws:

antlr.RecognitionException

reportError
```
public void reportError(antlr.RecognitionException ex)
```
Reports the parsing error defined by the given exception: an error message is appended to the overall error text for this parse, and a message is also generated immediately on standard output if the parser's Immediate Error Reporting flag is set.

Overrides:

reportError in class antlr.Parser

hamsinglesign

public final void hamsinglesign()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  hamsinglesign
      :   hamsignseq
          EOF !
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

hamsignseq

public final void hamsignseq()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  hamsignseq
      :
          (
              sign2or1
              (
                  HamPlus !
                  sign2or1
              )*
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

sign2or1

public final void sign2or1()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  sign2or1
      :
          ( HamNondominant initialconfig1 )
          =>
          nondomsign1
      |
          sign2
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

initialconfig1

public final void initialconfig1()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  initialconfig1
      :   ( nminitialconfig )?
          minitialconfig1
          //
          { #initialconfig1 =
                  #([ICFG1,"initialconfig1"], #initialconfig1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

nondomsign1

public final void nondomsign1()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  nondomsign1
      :   HamNondominant
          initialconfig1
          a1tstar
          //
          { #nondomsign1 = #([SIGN1,"sign1"], #nondomsign1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

sign2

public final void sign2()
                 throws antlr.RecognitionException,
                        antlr.TokenStreamException

  sign2
      :
      (
          symmoperator
          initialconfig2
          a2tstar
      |
          initialconfig2
          a1tstar
      |
  //####  2004-06
  //      Extra option to support SiGML 's "holdover"
  //      attribute, specifying that the non-performing hand in an
  //      otherwise single-handed sign is to retain its posture (from
  //      the end of the previous sign or rest position) throughout
  //      this sign.
  //
          ( HamNomotion HamNondominant initialconfig1 )
          =>
          HamNomotion
          HamNondominant
          initialconfig1
          a1tstar
      |
          HamNomotion
          initialconfig1
          a1tstar
      )
      { #sign2 = #([SIGN2,"sign2"], #sign2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

symmoperator

public final void symmoperator()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  symmoperator
      :   (
              HamSymmpar
          |
              HamSymmlr
          )
          (
              HamFingerstraightmod
              ( HamLargemod )?
          |
              HamLargemod
              ( HamFingerstraightmod )?
          )?
          ( HamAlternatingmotion )?
          ( HamNonipsi )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

initialconfig2

public final void initialconfig2()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  initialconfig2
      :   ( nminitialconfig )?
          minitialconfig2
          //
          { #initialconfig2 =
                  #([ICFG2,"initialconfig2"], #initialconfig2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

a2tstar

public final void a2tstar()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  a2tstar
      :   a2tlist
          //
          { #a2tstar = #([A2TLIST,"a2tstar"], #a2tstar); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

a1tstar

public final void a1tstar()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  a1tstar
      :   a1tlist
          //
          { #a1tstar = #([A1TLIST,"a1tstar"], #a1tstar); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

nminitialconfig

public final void nminitialconfig()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  nminitialconfig
      :   (
              nmicunit
          )+
          { #nminitialconfig =
                  #([NMICLIST,"nminitialconfig"], #nminitialconfig); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

minitialconfig2

public final void minitialconfig2()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  minitialconfig2
      :
      (   
          ( handconfig2 )
          =>
          handconfig2
          (
              ( location2 )
              =>
              location2
          )?
      |
          HamParbegin !
          handconfig1
          (
              ( HamPlus )
              =>
              HamPlus
  //??        handconfig1
              location1
              HamParend !
          |
              location1
              HamPlus
  //??        handconfig1
              ( location1 )?
              HamParend !
          )
      )
      { #minitialconfig2 =
              #([MICFG2,"minitialconfig2"], #minitialconfig2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

minitialconfig1

public final void minitialconfig1()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  minitialconfig1
      :
          handconfig1
          ( location1 )?
          //
          { #minitialconfig1 =
                  #([MICFG1,"minitialconfig1"], #minitialconfig1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

nmicunit

public final void nmicunit()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  nmicunit
      :
          HamSeqbegin !
          (
              ( levelbody )
              =>
              levelbody
          |
              levelarm
          )
          action1
          HamSeqend !
          //
          { #nmicunit = #([NMICUNIT,"nmicunit"], #nmicunit); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

levelbody

public final void levelbody()
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException

  levelbody
      :
      (
  // 2011-03
  // Allow HamEtc for "underspecified"/approximate.
          locbody
          ( HamEtc )?
          ( side )?
      |
          locsided
          ( HamEtc )?
          ( side )?
      |
          side
          (
              locbody
              ( HamEtc )?
          |
              locsided
              ( HamEtc )?
          )
      )
      { #levelbody = #([LEVBODY,"levelbody"], #levelbody); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

levelarm

public final void levelarm()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  levelarm
      :
      (
  // 2011-03
  // Allow HamEtc for "underspecified"/approximate.
          locarm
          ( HamEtc )?
          ( dorsalorpalmar )?
          ( side )?
      |
          side
          locarm
          ( HamEtc )?
          ( dorsalorpalmar )?
      )
      { #levelarm = #([LEVARM,"levelarm"], #levelarm); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

action1

public final void action1()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  action1
      :
      (
          HamNomotion
      |
          simplemovement
          (
              ( modifier )+
              ( HamLargemod )?
          )?
      |
          ( HamSeqbegin digit )
          =>
          specialfingerplaymovement
      |
          paraction1
      |
          seqaction1
      |
          seqfusedaction1
      )
      { #action1 = #([ACTION1,"action1"], #action1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handconfig2

public final void handconfig2()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  handconfig2
      :
      (
          ( handshape2 ( HamParbegin )? extfidir1 )
          =>
          handshape2
          handconfigtail2
      |
          ( handshape2 )
          =>
          handshape2
      |
          splithandconfig2
      )
  //#### before 2003-08-30:
  //  (
  //      ( handconfig1 )
  //      =>
  //      handconfig1
  //  |
  //      ( HamParbegin handshape1 HamPlus )
  //      =>
  //      handshape2
  //      handconfigtail2
  //  |
  //      ( handshape1 ( HamParbegin )? extfidir1 )
  //      =>
  //      handshape2
  //      handconfigtail2
  //  |
  //      abbrevhandconfig1
  //  |
  //      splithandconfig2
  //  )
  //
      { #handconfig2 = #([HDCONFIG2,"handconfig2"], #handconfig2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

location2

public final void location2()
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException

  location2
      :
      (
          location1as2
      |
          location2not1
      )
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handconfig1

public final void handconfig1()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  handconfig1
      :   handshape1
          (
              extfidir1
              palmor1
          )?
          //
          { #handconfig1 = #([HDCONFIG1,"handconfig1"], #handconfig1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

location1

public final void location1()
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException

  location1
      :
      (
          ( locationindexuse )                    //####  2003-08
          =>
          locationindexuse
      |
          ( levelhand )
          =>
          locationhand
      |
          locationbodyarm
      )
      { #location1 = #([LOC1,"location1"], #location1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handshape2

public final void handshape2()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  handshape2
      :
      (
          handshape1
      |
          HamParbegin !
          handshape1
          HamPlus !
          handshape1
          HamParend !
      )
      { #handshape2 = #([HSHAPE2,"handshape2"], #handshape2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

extfidir1

public final void extfidir1()
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException

  extfidir1
      :   extfidir
          (
              HamBetween !
              extfidir
          )?
          (
              HamOrirelative
          )?
          { #extfidir1 = #([EXTFIDIR1,"extfidir1"], #extfidir1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handconfigtail2

public final void handconfigtail2()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  handconfigtail2
      :
      (
          ( extfidir2 )
          =>
          extfidir2
          palmor2
      |
          HamParbegin !
          extfidir1
          palmor1
          HamPlus !
          extfidir1
          palmor1
          HamParend !
      )
      { #handconfigtail2 =
              #([HDCFGTAIL2,"hdcfgtail2"], #handconfigtail2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

splithandconfig2

public final void splithandconfig2()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  splithandconfig2
      :   HamParbegin !
          handconfig1
          HamPlus !
          handconfig1
          HamParend !
          //
          { #splithandconfig2 =
                  #([SPLITHDCFG2,"splithdcfg2"], #splithandconfig2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handshape1

public final void handshape1()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  handshape1
      :
          basichandshape1
          (
              ( ( hsfingeritem )+ HamBetween finger )
              =>
              cautiousfingerlist
              fingershapelist
              fingercrossinglist
              thumbbetweenexplicit
          |
              ( ( hsdigit )* ( fingerbending | fingerpart ) )
              =>
              cautiousfingerlist
              fingershapelist
              fingercrossinglist
              ( ( thumbspecial ) => thumbspecial )?
          |
              ( ( hsfingeritem )* ( thumbbetweendefault | thumbextra ) )
              =>
              fingerlist
              fingershapelist
              fingercrossinglist
              ( thumbbetweendefault | thumbextra )
          |
              fingerlist
              fingershapelist
              fingercrossinglist
          )
          { #handshape1 = #([HSHAPE1,"handshape1"], #handshape1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

palmor1

public final void palmor1()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  palmor1
      :   palmor
          (
              HamBetween !
              palmor
  // 2011-04
  // Added HamEtc option for "underspecified"/approximate.
          |
                    HamEtc
          )?
          (
              HamOrirelative
          )?
          { #palmor1 = #([PALMOR1,"palmor1"], #palmor1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

extfidir2

public final void extfidir2()
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException

  extfidir2
      :
      (
          extfidir1
      |
          splitextfidir2
      )
      { #extfidir2 = #([EXTFIDIR2,"extfidir2"], #extfidir2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

palmor2

public final void palmor2()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  palmor2
      :
      (
          palmor1
      |
          splitpalmor2
      )
      { #palmor2 = #([PALMOR2,"palmor2"], #palmor2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

basichandshape1

public final void basichandshape1()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  basichandshape1
      :   basichandshape
          (
              ( HamBetween handshapeclass )       //####  2003-08
              =>
              HamBetween !
              basichandshape
          )?
          { #basichandshape1 =
                  #([BASICHDSHP1,"basichandshape1"], #basichandshape1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

hsfingeritem

public final void hsfingeritem()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  hsfingeritem                //#### HNS-4
      :   finger
          ( HamLargemod )?
          //
          { #hsfingeritem =
              #([HSFINGERITEM,"hsfingeritem"], #hsfingeritem); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

finger

public final void finger()
                  throws antlr.RecognitionException,
                         antlr.TokenStreamException

  finger
      :   HamIndexfinger
      |   HamMiddlefinger
      |   HamRingfinger
      |   HamPinky
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

cautiousfingerlist

public final void cautiousfingerlist()
                              throws antlr.RecognitionException,
                                     antlr.TokenStreamException

  cautiousfingerlist
      :   reccautiousfingerlist
          //
          { #cautiousfingerlist =
                  #([FINGERLIST,"fingerlist"], #cautiousfingerlist); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

fingershapelist

public final void fingershapelist()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  fingershapelist
      :   recfingershapelist
          //
          { #fingershapelist =
                  #([FISHPLIST,"fingershapelist"], #fingershapelist); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

fingercrossinglist

public final void fingercrossinglist()
                              throws antlr.RecognitionException,
                                     antlr.TokenStreamException

  fingercrossinglist
      :   recfingercrossinglist
          //
          { #fingercrossinglist =
                  #([FICRSSLIST,"fingercrossinglist"],
                          #fingercrossinglist); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

thumbbetweenexplicit

public final void thumbbetweenexplicit()
                                throws antlr.RecognitionException,
                                       antlr.TokenStreamException

  thumbbetweenexplicit
      :   finger
          HamBetween ^
          finger
          //
          { #thumbbetweenexplicit =
                  #([THSPECIAL,"thumbspecial"], #thumbbetweenexplicit); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

hsdigit

public final void hsdigit()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  hsdigit                     //#### HNS-4
      :   thumb
      |   hsfingeritem
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

fingerbending

public final void fingerbending()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  fingerbending
      :
      (   HamFingerstraightmod
      |   HamFingerbendmod
      |   HamFingerhookedmod
      |   HamDoublebent
      |   HamDoublehooked
      )
      { #fingerbending =
              #([FIBENDING,"fingerbending"], #fingerbending); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

fingerpart

public final void fingerpart()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  fingerpart
      :   HamFingertip
      |   HamFingernail
      |   HamFingerpad
      |   HamFingermidjoint
      |   HamFingerbase
      |   HamFingerside
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

thumbspecial

public final void thumbspecial()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  thumbspecial
      :   thumbbetween
      |   thumbextra
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

thumbbetweendefault

public final void thumbbetweendefault()
                               throws antlr.RecognitionException,
                                      antlr.TokenStreamException

  thumbbetweendefault
      :   HamBetween
          //
          { #thumbbetweendefault =
                  #([THSPECIAL,"thumbspecial"], #thumbbetweendefault); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

thumbextra

public final void thumbextra()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  thumbextra
      :
      (
          thumb
      |
          fingerpart
      )
      { #thumbextra = #([THSPECIAL,"thumbspecial"], #thumbextra); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

fingerlist

public final void fingerlist()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  fingerlist
      :   recfingerlist
          //
          { #fingerlist =
                  #([FINGERLIST,"fingerlist"], #fingerlist); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

basichandshape

public final void basichandshape()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  basichandshape
      :   (
              handshapeclass
          |
              HamNondominant
          )
  // 2011-03
  // Allow HamEtc for "underspecified"/approximate.
          ( HamEtc )?
          handbendandthumb
          //
          { #basichandshape =
                  #([BASICHDSHP,"basichandshape"], #basichandshape); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handshapeclass

public final void handshapeclass()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  handshapeclass
      :
      (   HamFist
      |   HamFlathand
      |   HamFinger2
      |   HamFinger23
      |   HamFinger23spread
      |   HamFinger2345
      |   HamPinch12
      |   HamPinchall
      |   HamPinch12open
      |   HamCee12
      |   HamCeeall
      |   HamCee12open
      )
      { #handshapeclass =
              #([HSCLASS,"handshapeclass"], #handshapeclass); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handbendandthumb

public final void handbendandthumb()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  handbendandthumb
      :
          // empty
      |
          thumbpos
          ( fingerbending )?
      |
          fingerbending
          ( thumbpos )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

thumbpos

public final void thumbpos()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  thumbpos
      :
      (   HamThumboutmod
      |   HamThumbacrossmod
      |   HamThumbopenmod
      )
      { #thumbpos = #([THUMBPOS,"thumbpos"], #thumbpos); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

recfingerlist

public final void recfingerlist()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  recfingerlist               // recursive finger list
      :
          (
              ( hsfingeritem )
              =>
              hsfingeritem
              recfingerlist
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

reccautiousfingerlist

public final void reccautiousfingerlist()
                                 throws antlr.RecognitionException,
                                        antlr.TokenStreamException

  reccautiousfingerlist       // recursive cautious finger list
      :
          (
              ( hsfingeritem digit )
              =>
              hsfingeritem
              reccautiousfingerlist
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

digit

public final void digit()
                 throws antlr.RecognitionException,
                        antlr.TokenStreamException

  digit
      :   thumb
      |   finger
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

recfingershapelist

public final void recfingershapelist()
                              throws antlr.RecognitionException,
                                     antlr.TokenStreamException

  recfingershapelist          // recursive fingershapelist
      :
          (
              ( fingershape )
              =>
              fingershape
              recfingershapelist
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

fingershape

public final void fingershape()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  fingershape
      :   digit
          fingerbending
          //
          { #fingershape = #([FSHAPE,"fingershape"], #fingershape); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

recfingercrossinglist

public final void recfingercrossinglist()
                                 throws antlr.RecognitionException,
                                        antlr.TokenStreamException

  recfingercrossinglist       // recursive fingercrossinglist
      :
          (
              ( fingercrossing )
              =>
              fingercrossing
              recfingercrossinglist
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

fingercrossing

public final void fingercrossing()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  fingercrossing
      :   digit
          fingerpart
          digit
          //
          { #fingercrossing =
                  #([FCROSSING,"fingercrossing"], #fingercrossing); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

thumb

public final void thumb()
                 throws antlr.RecognitionException,
                        antlr.TokenStreamException

  thumb
      :   HamThumb
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

thumbbetween

public final void thumbbetween()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  thumbbetween
      :   thumbbetweenexplicit
      |   thumbbetweendefault
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

splitextfidir2

public final void splitextfidir2()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  splitextfidir2
      :   HamParbegin !
          extfidir1
          HamPlus !
          extfidir1
          HamParend !
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

extfidir

public final void extfidir()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  extfidir
      :
      (   HamExtfingeru
      |   HamExtfingerur
      |   HamExtfingerr
      |   HamExtfingerdr
      |   HamExtfingerd
      |   HamExtfingerdl
      |   HamExtfingerl
      |   HamExtfingerul
      |   (
              HamExtfingerol
              (
                  HamExtfingeruo
              |   HamExtfingerdo
              )?
          )
      |   HamExtfingero
      |   (
              HamExtfingeror
              (
                  HamExtfingeruo
              |   HamExtfingerdo
              )?
          )
      |   (
              HamExtfingeril
              (
                  HamExtfingerui
              |   HamExtfingerdi
              )?
          )
      |   HamExtfingeri
      |   (
              HamExtfingerir
              (
                  HamExtfingerui
              |   HamExtfingerdi
              )?
          )
      |   (
              HamExtfingerui
              (
                  HamExtfingeril
              |   HamExtfingerir
              )?
          )
      |   (
              HamExtfingerdi
              (
                  HamExtfingeril
              |   HamExtfingerir
              )?
          )
      |   (
              HamExtfingerdo
              (
                  HamExtfingerol
              |   HamExtfingeror
              )?
          )
      |   (
              HamExtfingeruo
              (
                  HamExtfingerol
              |   HamExtfingeror
              )?
          )
      )
      { #extfidir = #([EXTFIDIR,"extfidir"], #extfidir); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

splitpalmor2

public final void splitpalmor2()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  splitpalmor2
      :   HamParbegin !
          palmor1
          HamPlus !
          palmor1
          HamParend !
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

palmor

public final void palmor()
                  throws antlr.RecognitionException,
                         antlr.TokenStreamException

  palmor
      :   HamPalmu
      |   HamPalmur
      |   HamPalmr
      |   HamPalmdr
      |   HamPalmd
      |   HamPalmdl
      |   HamPalml
      |   HamPalmul
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

location1as2

public final void location1as2()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  location1as2
      :   location1
          { #location1as2 = #([LOC2,"location1as2"], #location1as2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

location2not1

public final void location2not1()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  location2not1
      :
      (
          ( handconstellation )
          =>
          handconstellation
          (
              HamNeutralspace !
              ( HamArmextended )?
          |
              ( locationbody )?
  //
  //2001-07-05
  //If we replace the above option with the following, i.e. if we
  //allow a split locationbody as well as a single one, we can
  //parse the KOHLE-WALLACH example in the test file
  //          (
  //              ( HamParbegin locationbody )
  //              =>
  //              HamParbegin !
  //              locationbody
  //              HamPlus !
  //              locationbody
  //              HamParend !
  //          |
  //              locationbody
  //          )?
  //
          )
      |
          HamParbegin !
          location1
          HamPlus !
          location1
          HamParend !
      )
      { #location2not1 = #([LOC2,"location2not1"], #location2not1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handconstellation

public final void handconstellation()
                             throws antlr.RecognitionException,
                                    antlr.TokenStreamException

  handconstellation
      :   (
              HamParbegin !
              locationhand
              HamPlus !
              locationhand
              HamParend !
          )?
          contacthand
          //
          { #handconstellation =
                  #([HCONSTLLN,"handconstellation"], #handconstellation); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locationbody

public final void locationbody()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  locationbody
      :   levelcomplexbody
          ( HamBehind )?
          ( ( contactbody ) => contactbody )?
          //
          { #locationbody = #([LOCTNBODY,"locationbody"], #locationbody); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locationindexuse

public final void locationindexuse()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  locationindexuse
      :
          digit
          HamCorefref !
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

levelhand

public final void levelhand()
                     throws antlr.RecognitionException,
                            antlr.TokenStreamException

  levelhand
      :
      (
          lochand
          ( dorsalorpalmar )?
          ( side )
          =>
          ( side )?
      |   
          side
          lochand
          ( dorsalorpalmar )?
      )
      { #levelhand = #([LEVHAND,"levelhand"], #levelhand); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locationhand

public final void locationhand()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  locationhand
      :   levelcomplexhand
          ( (contacthand) => contacthand )?
          //
          { #locationhand = #([LOCTNHAND,"locationhand"], #locationhand); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locationbodyarm

public final void locationbodyarm()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  locationbodyarm
      :
      (
          HamNeutralspace !
          ( HamArmextended )?
      |
          ( levelbody )
          =>
          locationbody
      |
          locationarm
      )
      { #locationbodyarm =
              #([LOCTNBODYARM,"locationbodyarm"], #locationbodyarm); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locationindexdefine

public final void locationindexdefine()
                               throws antlr.RecognitionException,
                                      antlr.TokenStreamException

  locationindexdefine
      :
          digit
          HamCoreftag !
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locationarm

public final void locationarm()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  locationarm
      :   levelcomplexarm
          ( HamBehind )?
          ( ( contactbody ) => contactbody )?
          //
          { #locationarm = #([LOCTNARM,"locationarm"], #locationarm); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

levelcomplexbody

public final void levelcomplexbody()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  levelcomplexbody
      :   levelbody
          (
              HamBetween !
              levelbody
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

contactbody

public final void contactbody()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  contactbody
      :
      (
          pcontact
      |
          HamArmextended
      |
          contactofhand
      )
      { #contactbody = #([CNTCTBODY,"contactbody"], #contactbody); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

levelcomplexhand

public final void levelcomplexhand()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  levelcomplexhand
      :   levelhand
          (
              HamBetween !
              levelhand
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

contacthand

public final void contacthand()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  contacthand
      :
      (
          pcontact
      |
          ccontact
      |
          contactofhand
      )
      { #contacthand = #([CNTCTHAND,"contacthand"], #contacthand); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

levelcomplexarm

public final void levelcomplexarm()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  levelcomplexarm
      :   levelarm
          (
              HamBetween !
              levelarm
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locbody

public final void locbody()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  locbody
      :
      (   HamHead
      |   HamHeadtop
      |   HamForehead
      |   HamEyebrows
  //  |   HamEyes     #### see below
      |   HamNose
      |   HamNostrils
  //  |   HamLips     #### see below
      |   HamTongue
      |   (
              (
                  HamEyes
              |   HamLips
              |   HamTeeth
              )
              (
                  HamDoublebent
              |   HamDoublehooked
              )?
          )
      |   HamChin
      |   HamUnderchin
      |   HamNeck
      |   HamShouldertop
      |   HamShoulders
      |   HamChest
      |   HamStomach
      |   HamBelowstomach
      )
      { #locbody = #([LOCBODY,"locbody"], #locbody); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

side

public final void side()
                throws antlr.RecognitionException,
                       antlr.TokenStreamException

  side
      :   HamLrbeside
      |   HamLrat
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locsided

public final void locsided()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  locsided
      :   HamEar
      |   HamEarlobe
      |   HamCheek
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

lochand

public final void lochand()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  lochand
      :
      (
          handpart
      |
          fingerpart
          ( digit )*
      |
          ///####  2003-08  New HNS-4-Orientated version:
          ( digit )+
          ( fingerpart )?
  // was:
  //      digit
  //      (
  //          ( digit )*
  //      |
  //          fingerpart
  //      )
  //
      )
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

dorsalorpalmar

public final void dorsalorpalmar()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  dorsalorpalmar
      :   HamHandback
      |   HamPalm
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

locarm

public final void locarm()
                  throws antlr.RecognitionException,
                         antlr.TokenStreamException

  locarm
      :   HamUpperarm
      |   HamElbow
      |   HamElbowinside
      |   HamLowerarm
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

pcontact

public final void pcontact()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  pcontact
      :   HamTouch
      |   HamClose
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

contactofhand

public final void contactofhand()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  contactofhand
      :   HamSeqbegin !
          (
              pcontact
          |
              ccontact
          )
          (
              ( levelhand )
              =>
              contactohhand
          |
              contactoharm
          )
          HamSeqend !
          //
          { #contactofhand =
                  #([CNTCTOFHAND,"contactofhand"], #contactofhand); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

ccontact

public final void ccontact()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  ccontact
      :   HamInterlock
      |   HamCross
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

contactohhand

public final void contactohhand()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  contactohhand
      :   levelcomplexhand
          //
          { #contactohhand =
                  #([CNTCTOHHAND,"contactohhand"], #contactohhand); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

contactoharm

public final void contactoharm()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  contactoharm
      :   levelcomplexarm
          //
          { #contactoharm =
                  #([CNTCTOHARM,"contactoharm"], #contactoharm); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

handpart

public final void handpart()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  handpart
      :   HamWristback
      |   HamWristpulse
      |   HamThumbball
      |   HamPalm
      |   HamHandback
      |   HamThumbside
      |   HamPinkyside
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

a2tlist

public final void a2tlist()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  a2tlist
      :
          (
              (action2t)
              =>
              action2t
              a2tlist
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

a1tlist

public final void a1tlist()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  a1tlist
      :
          (
              action1t
              a1tlist
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

action2t

public final void action2t()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  action2t
      :
      (
          ( action1 location2not1 )
          =>
          action1
          location2not1
          repetitionsoption
      |
          ( action1t )
          =>
          action1t
      |
          (
              ( HamParbegin ( action1 )+ HamPlus
                ( action1 )+ HamParend location2 )
              =>
              splitaction2loc2
          |
              ( HamParbegin ( action1t )+ HamPlus )
              =>
              splitaction2t
          |
              paraction2t
          |
              seqaction2t
          |
              seqfusedaction2t
          )
          repetitionsoption
      )
      { #action2t = #([ACTION2T,"action2t"], #action2t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

action1t

public final void action1t()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  action1t
      :
          (
              ( action1 )
              =>
              (
                  action1
                  (
                      ( handconstellation )
                      =>
                      handconstellation
                  |
                      location1
                      ( HamLargemod )?
                  )?
              )
          |
              paraction1t
          |
              ( nmaction1t )                  //####  2003-08
              =>
              nmaction1t
          |
              seqaction1t
          |
              seqfusedaction1t
          )
          repetitionsoption
          //
          { #action1t = #([ACTION1T,"action1t"], #action1t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

repetitionsoption

public final void repetitionsoption()
                             throws antlr.RecognitionException,
                                    antlr.TokenStreamException

  repetitionsoption
      :
          (
              ( ( HamSeqbegin )? repetition | HamAlternatingmotion )
              =>
              repetitions
          )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

splitaction2loc2

public final void splitaction2loc2()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  splitaction2loc2
      :   HamParbegin !
          ( action1 )+
          HamPlus
          ( action1 )+
          HamParend !
          location2
          //
          { #splitaction2loc2 =
                  #([SPLITACT2LOC2,"splitact2loc2"], #splitaction2loc2); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

splitaction2t

public final void splitaction2t()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  splitaction2t
      :   HamParbegin !
          ( action1t )+
          HamPlus
          ( action1t )+
          HamParend !
          //
          { #splitaction2t =
                  #([SPLITACT2T,"splitact2t"], #splitaction2t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

paraction2t

public final void paraction2t()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  paraction2t
      :   HamParbegin !
          ( action2t )+
          HamParend !
          //
          { #paraction2t = #([PARACT2T,"paract2t"], #paraction2t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

seqaction2t

public final void seqaction2t()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  seqaction2t
      :   HamSeqbegin !
          ( action2t )+
          HamSeqend !
          //
          { #seqaction2t = #([SEQACT2T,"seqact2t"], #seqaction2t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

seqfusedaction2t

public final void seqfusedaction2t()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  seqfusedaction2t
      :   HamFusionbegin !
          ( action2t )+
          HamFusionend !
          //
          { #seqfusedaction2t =
                  #([SEQFUSEDACT2T,"seqfusedaction2t"],
                          #seqfusedaction2t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

paraction1t

public final void paraction1t()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  paraction1t
      :
          HamParbegin !
          ( action1t )+
          HamParend !
          //
          { #paraction1t = #([PARACT1T,"paract1t"], #paraction1t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

nmaction1t

public final void nmaction1t()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  nmaction1t
      :
          HamSeqbegin !
          (
              ( levelbody )
              =>
              levelbody
          |
              levelarm
          )
  //#### 2007-03:
          action1t
          HamSeqend !
          //
          { #nmaction1t = #([NMACT1T,"nmact1t"], #nmaction1t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

seqaction1t

public final void seqaction1t()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  seqaction1t
      :
          HamSeqbegin !
          ( action1t )+
          HamSeqend !
          //
          { #seqaction1t = #([SEQACT1T,"seqact1t"], #seqaction1t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

seqfusedaction1t

public final void seqfusedaction1t()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  seqfusedaction1t
      :
          HamFusionbegin !
          ( action1t )+
          HamFusionend !
          //
          { #seqfusedaction1t =
                  #([SEQFUSEDACT1T,"seqfusedaction1t"],
                          #seqfusedaction1t); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

simplemovement

public final void simplemovement()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  simplemovement
      :
          (
              straightmovement
              ( size )?
              (
                  arckind
              |
                  zigzag
              )?
          |
              circularmovement
              ( size )?
              ( revolutions )?
              ( ellipse )?
              ( sizechangenonlinear )?
          |
              movementcross
              ( size )?
          |
              wristmovement
              ( size )?
          |
              replacement
          |
              HamFingerplay
  // 2011-04
  // The more complex form of fingerplay logically goes here,
  // but to simplify the lookahead in action1 that form is factored
  // out as a separate nonterminal, specialfingerplaymovement, below.
          )
          (
            ( HamSeqbegin HamBrushing )
            =>
            brushingcontact
          )?                                  //####  2003-08
          (
            ( locationindexdefine )
            =>
            locationindexdefine
          )?                                  //####  2003-08
          //
          { #simplemovement =
                  #([SIMPLEMVMT,"simplemovement"], #simplemovement); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

modifier

public final void modifier()
                    throws antlr.RecognitionException,
                           antlr.TokenStreamException

  modifier
      :   HamFast
      |   HamSlow
      |   HamTense
      |   HamRest
      |   HamHalt
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

specialfingerplaymovement

public final void specialfingerplaymovement()
                                     throws antlr.RecognitionException,
                                            antlr.TokenStreamException

  specialfingerplaymovement
      :
  // 2011-04
  // Logically this is one of the alternatives in simplemovement, but it
  // is factored out in order to simplify the lookahead in action1.
  // But it therefore returns a SIMPLEMVMT/"simplemovement" AST node,
  // rather than using a distinctive node kind of its own.
          HamSeqbegin !
          ( digit )+
          HamFingerplay
          HamSeqend !
          { #specialfingerplaymovement =
                  #([SIMPLEMVMT,"simplemovement"], #specialfingerplaymovement); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

paraction1

public final void paraction1()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  paraction1
      :
          HamParbegin !
          ( action1 )+
          HamParend !
          //
          { #paraction1 = #([PARACT1,"paract1"], #paraction1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

seqaction1

public final void seqaction1()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  seqaction1
      :
          HamSeqbegin !
          ( action1 )+
          HamSeqend !
          //
          { #seqaction1 = #([SEQACT1,"seqact1"], #seqaction1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

seqfusedaction1

public final void seqfusedaction1()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  seqfusedaction1
      :
          HamFusionbegin !
          ( action1 )+
          HamFusionend !
          //
          { #seqfusedaction1 =
                  #([SEQFUSEDACT1,"seqfusedaction1"], #seqfusedaction1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

repetition

public final void repetition()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  repetition
      :   HamRepeatfromstart
      |   HamRepeatfromstartseveral
      |   HamRepeatcontinue
      |   HamRepeatcontinueseveral
      |   HamRepeatreverse
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

repetitions

public final void repetitions()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  repetitions
      :
  // 2011-03
  // Allow HamEtc after HamRepeatfromstartseveral, for
  // "underspecified"/approximate repeat locations.
      (
          ( HamSeqbegin HamRepeatfromstartseveral HamEtc )
          =>
          HamSeqbegin !
          HamRepeatfromstartseveral
          HamEtc
          ellipsedirection
          HamSeqend !
      |
          (
              repetition
              (
                  HamEtc
              |
                  repetition
              )?
          |
              movingrepetition
          )
          ( sizechangenonlinear )?
          (
              HamAlternatingmotion
              ( HamAlternatingmotion )?
          )?
      |
          HamAlternatingmotion
          ( HamAlternatingmotion )?
      )
      { #repetitions = #([REPETITIONS, "repetitions"], #repetitions); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

ellipsedirection

public final void ellipsedirection()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  ellipsedirection
      :   HamEllipseh
      |   HamEllipseur
      |   HamEllipsev
      |   HamEllipseul
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

movingrepetition

public final void movingrepetition()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  movingrepetition
      :
          HamSeqbegin !
          repetition
          movementarrow
          ( size )?
          ( sizechangenonlinear )?
          HamSeqend !
          //
          { #movingrepetition =
                  #([MOVINGREPETITION, "movingrepetition"],
                          #movingrepetition); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

sizechangenonlinear

public final void sizechangenonlinear()
                               throws antlr.RecognitionException,
                                      antlr.TokenStreamException

  sizechangenonlinear
      :   sizechange
          ( size )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

alternations

public final void alternations()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  alternations
      :   HamAlternatingmotion
          ( HamAlternatingmotion )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

movementarrow

public final void movementarrow()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  movementarrow
      :   HamMoveu
      |   HamMoveur
      |   HamMover
      |   HamMovedr
      |   HamMoved
      |   HamMovedl
      |   HamMovel
      |   HamMoveul
      |   HamMoveol
      |   HamMoveo
      |   HamMoveor
      |   HamMoveil
      |   HamMovei
      |   HamMoveir
      |   HamMoveui
      |   HamMovedi
      |   HamMovedo
      |   HamMoveuo
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

size

public final void size()
                throws antlr.RecognitionException,
                       antlr.TokenStreamException

  size
      :   HamSmallmod
      |   HamLargemod
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

straightmovement

public final void straightmovement()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  straightmovement
      :   movementarrow
          (
              HamBetween !
              movementarrow
          )?
          { #straightmovement =
                  #([STRGHTMVMT,"strghtmvmt"], #straightmovement); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

arckind

public final void arckind()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  arckind
      :   arc
          ( arc )?
          ( size )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

zigzag

public final void zigzag()
                  throws antlr.RecognitionException,
                         antlr.TokenStreamException

  zigzag
      :   (
              HamZigzag
          |
              HamWavy
          )
          ( size )?
          ( ellipsedirection )?
          ( sizechangenonlinear )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

circularmovement

public final void circularmovement()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  circularmovement
      :   movementcircle
          (
              HamBetween !
              movementcircle
          )?
          { #circularmovement =
                  #([CRCLRMVMT,"crclrmvmt"], #circularmovement); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

revolutions

public final void revolutions()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  revolutions
      :
      (
          clock
          (
              HamClockfull
              ( HamClockfull )?
          )?
          ( clock )?
      |
          HamClockfull
          ( HamClockfull )?
          ( clock )?
      )
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

ellipse

public final void ellipse()
                   throws antlr.RecognitionException,
                          antlr.TokenStreamException

  ellipse
      :   ellipsedirection
          ( size )?
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

movementcross

public final void movementcross()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  movementcross
      :   HamMovecross
      |   HamMovex
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

wristmovement

public final void wristmovement()
                         throws antlr.RecognitionException,
                                antlr.TokenStreamException

  wristmovement
      :   HamNodding
      |   HamSwinging
      |   HamTwisting
      |   HamStircw
      |   HamStirccw
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

replacement

public final void replacement()
                       throws antlr.RecognitionException,
                              antlr.TokenStreamException

  replacement
      :   HamReplace !
  //#### 2011-03:  now allow HNS4 sizechange, to control staged order of change.
          ( sizechange )?
          (
              handshape1
              (
                  ( splitreplacetail )
                  =>
                  splitreplacetail
              |
                  ( extfidir1 )?
                  ( palmor1 )?
              )
          |
              splitreplacetail
          |
              extfidir1
              ( palmor1 )?
          |
              palmor1
          )
          { #replacement =
                  #([REPLACE,"replacement"], #replacement); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

brushingcontact

public final void brushingcontact()
                           throws antlr.RecognitionException,
                                  antlr.TokenStreamException

  brushingcontact
      :
          HamSeqbegin !
          HamBrushing
          location1
          HamSeqend !
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

movementcircle

public final void movementcircle()
                          throws antlr.RecognitionException,
                                 antlr.TokenStreamException

  movementcircle
      :   HamCircleo
      |   HamCirclei
      |   HamCircled
      |   HamCircleu
      |   HamCirclel
      |   HamCircler
      |   HamCircleul
      |   HamCircledr
      |   HamCircleur
      |   HamCircledl
      |   HamCircleol
      |   HamCircleir
      |   HamCircleor
      |   HamCircleil
      |   HamCircleui
      |   HamCircledo
      |   HamCircledi
      |   HamCircleuo
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

arc

public final void arc()
               throws antlr.RecognitionException,
                      antlr.TokenStreamException

  arc
      :   HamArcl
      |   HamArcu
      |   HamArcr
      |   HamArcd
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

sizechange

public final void sizechange()
                      throws antlr.RecognitionException,
                             antlr.TokenStreamException

  sizechange
      :   HamIncreasing
      |   HamDecreasing
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

clock

public final void clock()
                 throws antlr.RecognitionException,
                        antlr.TokenStreamException

  clock
      :   HamClocku
      |   HamClockul
      |   HamClockl
      |   HamClockdl
      |   HamClockd
      |   HamClockdr
      |   HamClockr
      |   HamClockur
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

splitreplacetail

public final void splitreplacetail()
                            throws antlr.RecognitionException,
                                   antlr.TokenStreamException

  splitreplacetail
      :   HamParbegin !
          replacetail1
          HamPlus !
          (
              HamNomotion !
          |
              replacetail1
          )
          HamParend !
          //
          { #splitreplacetail =
                  #([SPLITREPLACETL,"splitreplacetail"],
                          #splitreplacetail); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

replacetail1

public final void replacetail1()
                        throws antlr.RecognitionException,
                               antlr.TokenStreamException

  replacetail1
      :
      (
          extfidir1
          ( palmor1 )?
      |
          palmor1
      )
      { #replacetail1 =
              #([REPLACETAIL1,"replacetail1"], #replacetail1); }
      ;

Throws:: antlr.RecognitionException; antlr.TokenStreamException

Class Ham4Parser

Field Summary

Fields inherited from interface hamparse.Ham4ParserTokenTypes

Constructor Summary

Method Summary

Methods inherited from class antlr.LLkParser

Methods inherited from class antlr.Parser

Methods inherited from class java.lang.Object

Field Detail

_tokenNames

_tokenSet_0

_tokenSet_1

_tokenSet_2

_tokenSet_3

_tokenSet_4

_tokenSet_5

_tokenSet_6

_tokenSet_7

_tokenSet_8

_tokenSet_9

_tokenSet_10

_tokenSet_11

_tokenSet_12

_tokenSet_13

_tokenSet_14

_tokenSet_15

_tokenSet_16

_tokenSet_17

_tokenSet_18

_tokenSet_19

_tokenSet_20

_tokenSet_21

_tokenSet_22

_tokenSet_23

_tokenSet_24

_tokenSet_25

_tokenSet_26

_tokenSet_27

_tokenSet_28

_tokenSet_29

_tokenSet_30

_tokenSet_31

_tokenSet_32

_tokenSet_33

_tokenSet_34

_tokenSet_35

_tokenSet_36

_tokenSet_37

_tokenSet_38

_tokenSet_39

_tokenSet_40

_tokenSet_41

_tokenSet_42

_tokenSet_43

_tokenSet_44

_tokenSet_45

_tokenSet_46

_tokenSet_47

_tokenSet_48

_tokenSet_49

_tokenSet_50

_tokenSet_51

_tokenSet_52

_tokenSet_53

_tokenSet_54

_tokenSet_55

_tokenSet_56

_tokenSet_57

_tokenSet_58

_tokenSet_59

_tokenSet_60

_tokenSet_61

_tokenSet_62

_tokenSet_63

_tokenSet_64

_tokenSet_65

_tokenSet_66

_tokenSet_67

_tokenSet_68

_tokenSet_69