kU      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTportable to Hugs and GHC experimental,Lennart Kolmodin <kolmodin@dtek.chalmers.se>#UVWA XW# is an efficient way to build lazy Ys. . There are several functions for constructing XWs, but only one G to inspect them: to extract any data, you have to turn them into lazy  Ys using Z. Internally, a XW constructs a lazy  L.Bytestring by filling byte 9 arrays piece by piece. As each buffer is filled, it is 'popped' 2 off, to become a new chunk of the resulting lazy Y. ) All this is hidden from the user of the XW. X[\O(1). The empty Builder, satisfying  Z \ = ]^O(1)., A Builder taking a single byte, satisfying  Z (^ b) = _ b`O(1).= The concatenation of two Builders, an associative operation  with identity \ , satisfying  Z (` x y) = a (Z x) (Z y)bO(1). A Builder taking a c , satisfying  Z (b bs) = d [bs]eO(1). A Builder taking a lazy Y , satisfying  Z (e bs) = bsZO(n). Extract a lazy Y from a XW. D The construction work takes place if and when the relevant part of  the lazy Y is demanded. fO(1). Pop the c% we have constructed so far, if any, ) yielding a new chunk in the result lazy Y. gh'Sequence an IO operation on the buffer iGet the size of the buffer j'Map the resulting list of bytestrings. kEnsure that there are at least n many bytes available. l Ensure that n( many bytes are available, and then use f to write some  bytes into the memory. mno Ensure that n( many bytes are available, and then use f to write some " storable values into the memory. pq$Write a Word16 in big endian format r'Write a Word16 in little endian format s$Write a Word32 in big endian format t'Write a Word32 in little endian format u$Write a Word64 in big endian format v'Write a Word64 in little endian format wO(1).< A Builder taking a single native machine word. The word is = written in host order, host endian form, for the machine you're on. G On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 6 4 bytes. Values written this way are not portable to > different endian or word sized machines, without conversion. x9Write a Word16 in native host order and host endianness. % 2 bytes will be written, unaligned. y9Write a Word32 in native host order and host endianness. % 4 bytes will be written, unaligned. z%Write a Word64 in native host order. J On a 32 bit machine we write two host order Word32s, in big endian form. % 8 bytes will be written, unaligned. {|}W\^`beZfqrstuvwxyzW\^`beZfqrstuvwxyz (portable)(stable)AR~like Maybe type with error msgs  added by KJ added 2/10/ 2003 by PEB ~~portable to Hugs and GHC. experimental,Lennart Kolmodin <kolmodin@dtek.chalmers.se>,IThe Get monad is just a State monad carrying around the input ByteString The parse state Run the Get monad applies a &-based parser on the input ByteString Run the Get monad applies a -based parser on the input F ByteString. Additional to the result of get it returns the number of + consumed bytes and the rest of the input.  Skip ahead n bytes. Fails if fewer than n bytes are available.  Skip ahead n bytes. No error if there isn't enough bytes. Run ga*, but return without consuming its input.  Fails if ga fails. Like , but consume the input if gma returns 'Just _'.  Fails if gma fails. Like , but consume the input if gea returns 'Right _'.  Fails if gea fails. Get the next up to n6 bytes as a lazy ByteString, without consuming them. 2Get the total number of bytes read to this point. ,Get the number of remaining unparsed bytes. : Useful for checking whether all input has been consumed. . Note that this forces the rest of the input. *Test whether all input has been consumed, - i.e. there are no remaining unparsed bytes.  An efficient / method for strict ByteStrings. Fails if fewer  than n bytes are left in the input.  An efficient : method for lazy ByteStrings. Does not fail if fewer than  n bytes are left in the input. @Get a lazy ByteString that is terminated with a NUL byte. Fails 7 if it reaches the end of input without hitting a NUL. -Get the remaining bytes as a lazy ByteString Pull n/ bytes from the input, as a strict ByteString.  important BSplit a ByteString. If the first result is consumed before the -- + second, this runs in constant heap space. 9You must force the returned tuple for that to work, e.g.  case splitAtST n xs of ) (ys,zs) -> consume ys ... consume zs  important "Read a Word8 from the monad state #Read a Word16 in big endian format &Read a Word16 in little endian format #Read a Word32 in big endian format &Read a Word32 in little endian format #Read a Word64 in big endian format &Read a Word64 in little endian format O(1).8 Read a single native machine word. The word is read in 2 host order, host endian form, for the machine you're on. On a 64 bit D machine the Word is an 8 byte value, on a 32 bit machine, 4 bytes. O(1).@ Read a 2 byte Word16 in native host order and host endianness. O(1).9 Read a Word32 in native host order and host endianness. O(1).8 Read a Word64 in native host order and host endianess. (Portable to Hugs and GHC. Requires MPTCsstable,Lennart Kolmodin <kolmodin@dtek.chalmers.se>=Put merely lifts Builder into a Writer monad, applied to (). AThe PutM type. A Writer monad over the efficient Builder monoid. Run the  monad Run the  monad with a serialiser Run the , monad with a serialiser and get its result BPop the ByteString we have constructed so far, if any, yielding a % new chunk in the result ByteString. 0Efficiently write a byte into the output buffer LAn efficient primitive to write a strict ByteString into the output buffer. J It flushes the current buffer, and writes the argument into a new chunk. ?Write a lazy ByteString efficiently, simply appending the lazy ( ByteString chunks to the output buffer $Write a Word16 in big endian format 'Write a Word16 in little endian format $Write a Word32 in big endian format 'Write a Word32 in little endian format $Write a Word64 in big endian format 'Write a Word64 in little endian format O(1).1 Write a single native machine word. The word is = written in host order, host endian form, for the machine you're on. G On a 64 bit machine the Word is an 8 byte value, on a 32 bit machine, 6 4 bytes. Values written this way are not portable to > different endian or word sized machines, without conversion. O(1).: Write a Word16 in native host order and host endianness.  For portability issues see  putWordhost. O(1).: Write a Word32 in native host order and host endianness.  For portability issues see  putWordhost. O(1).% Write a Word64 in native host order J On a 32 bit machine we write two host order Word32s, in big endian form.  For portability issues see  putWordhost.   Fportable to Hugs and GHC. Requires the FFI and some flexible instancesunstable,Lennart Kolmodin <kolmodin@dtek.chalmers.se> The Binary class provides  and , methods to encode and F decode a Haskell value to a lazy ByteString. It mirrors the Read and B Show classes for textual representation of Haskell types, and is D suitable for serialising Haskell values to disk, over the network. BFor parsing and generating simple external binary formats (e.g. C A structures), Binary may be used, but in general is not suitable ? for complex protocols. Instead use the Put and Get primitives  directly. ;Instances of Binary should satisfy the following property:   decode . encode == id  That is, the  and ' methods should be the inverse of each D other. A range of instances are provided for basic Haskell types. !Encode a value in the Put monad.  Decode a value in the Get monad @Encode a value using binary serialisation to a lazy ByteString. NDecode a value from a lazy ByteString, reconstructing the original structure. #Lazily serialise a value to a file 'This is just a convenience function, it's defined simply as:  ' encodeFile f = B.writeFile f . encode ASo for example if you wanted to compress as well, you could use: # B.writeFile f . compress . encode 9Lazily reconstruct a value previously written to a file. 'This is just a convenience function, it's defined simply as:  1 decodeFile f = return . decode =<< B.readFile f CSo for example if you wanted to decompress as well, you could use: / return . decode . decompress =<< B.readFile f  (portable)(stable)PL%Like 6, but returns the empty list when the input is empty. Like 4, but more efficient as it uses sorting internally. Like 4, but more efficient as it uses sorting internally. :Sorts and then groups elements given and ordering of the  elements. #Take the union of a list of lists. Like *, but fails if the argument is not found, ! instead of returning Nothing. Like !, but fails if nothing is found. Set a value in a lookup table. &Group tuples by their first elements. 9Replace all occurences of an element by another element. 3Use an ordering function as an equality predicate. :Return the given value if the boolean is true, els return . 1Returns true if the argument is Nothing or Just [] 5Apply all the functions in the list to the argument. Fixpoint iteration. /Join a number of lists by using the given glue  between the lists. glue lists to join      %     %     portablestablePeter Ljunglf$A sorted map also has unique keys,  i.e. 'map fst m :: SList a', if ' m :: SMap a b' 3The list must be sorted and contain no duplicates. 1Group a set of key-value pairs into a sorted map <Group a set of key-(sets-of-values) pairs into a sorted map )True is the two sets has common elements >True if the first argument is a subset of the second argument Create a set from any list. 5 This function can also be used as an alternative to nub in List.hs #the union of a list of sorted maps merging two sorted maps The union of a list of sets The union of two sets The difference of two sets The intersection of two sets A fixed point iteration The iterator function The initial set The result of the iteration   (portable)(stable)BB$(Keeps both incoming and outgoing edges. 1Creates a relation from a list of related pairs. BCreates a relation from a list pairs of elements and the elements  related to them.  !Add a pair to the relation. "%Add a list of pairs to the relation. #,Checks if an element is related to another. $=Get the set of elements to which a given element is related. %"Get all elements in the relation. &'>Keep only pairs for which both elements are in the given set. (),The set over which the relation is defined. *Uses % +,-.9Get the set of elements which are related to themselves. /8Keep the related pairs for which the predicate is true. 0%Remove keys that map to no elements. 1;Get the equivalence classes from an equivalence relation. 234567Returns 8 if there are cycles, and 9 if there are cycles. :;<=>?$Removes an element from a relation. F Returns the new relation, and the set of incoming and outgoing edges  of the removed element. @A#$()*+,-.1234567#$()*+,-.1234567  (portable)(stable)ARGBCDEFGHIJK analogue of maybe L add msg s to Maybe failures MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvThomas Hallgren' s wrap lines ww is the same as sequence!!!  peb 30/5-04 x+topological sorting with test of cyclicity ythe generic fix point iterator z$chop into separator-separated parts {|}~)if the first check fails try another one J~BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~GBCDECDEFGGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ &An abstract data type that represents 2 identifiers for functions and categories in PGF. Creates a new identifier from  Reads an identifier from . The function returns ( if the string is not valid identifier. Renders the identifier as     P represents a hypothesis in a type i.e. in the type A -> B, A is the hypothesis To read a type from a , use . Reads a  from a . renders type as  . The list 2 of identifiers is the list of all free variables 1 in the expression in order reverse to the order  of binding. 8creates a type from list of hypothesises, category and 4 list of arguments for the category. The operation  mkType [h_1,...,h_n] C [e_1,...,e_m] will create  "h_1 -> ... -> h_n -> C e_1 ... e_m 1creates hypothesis for non-dependent type i.e. A 3creates hypothesis for dependent type i.e. (x : A) Lcreates hypothesis for dependent type with implicit argument i.e. ({x} : A)     ?AAn expression in the abstract syntax of the grammar. It could be C both parameter of a dependent type or an abstract syntax tree for  for some sentence. =The equation is used to define lambda function as a sequence 1 of equations with pattern matching. The list of  represents  the patterns and the second  is the function body for this  equation. OThe pattern is used to define equations in the abstract syntax of the grammar. implicit argument in pattern  wildcard  variable literal Dapplication. The identifier should be constructor i.e. defined with 'data'  implicit argument in expression local type signature variable with de Bruijn index function or data constructor meta variable literal  application lambda abstraction ?Tree is the abstract syntax representation of a given sentence & in some concrete syntax. Technically  is a type synonym  of . floating point constant integer constant string constant parses  as an expression renders expression as  . The list 2 of identifiers is the list of all free variables 1 in the expression in order reverse to the order  of binding. IConstructs an expression by applying a function to a list of expressions 6Decomposes an expression into application of function -Constructs an expression from string literal -Decomposes an expression into string literal .Constructs an expression from integer literal .Decomposes an expression into integer literal 2Constructs an expression from real number literal 2Decomposes an expression into real number literal 0Constructs an expression which is meta variable 0Checks whether an expression is a meta variable %Compute an expression to normal form C>CThis is just a  with the language name. : A language name is the identifier that you write in the 2 top concrete or abstract module in GF after the  concrete/abstract keyword. Example:  abstract Lang = ...  concrete LangEng of Lang = ... value of a flag (type, arrity and definition of function   context of a category C ^ 2. functions of a category. The order in the list is important, I this is the order in which the type singatures are given in the source. D The termination of the exhaustive generation might depend on this. 8An abstract data type representing multilingual grammar  in Portable Grammar Format.  C       +Show the printname of function or category  !"#$$      !"#%&'()*$      !"#$+,-./0,/0,/0 (portable)(stable)Krasimir Angelov7 -If an error occurs in the typechecking phase 9 the type checker returns not a plain text error message  but a  & structure which describes the error. !1Implicit argument was passed where the type doesn' t allow it "RSome metavariables have to be instantiated in order to complete the typechecking. #7It is not possible to infer the type of an expression. $CSomething that is not of function type was applied to an argument. %,The expression is not of the expected type. , The first type is the expected type, while ! the second is the inferred. The [CId] argument is the list 9 of free variables in both the expression and the type.  It should be used for the   and  functions. &5A category was applied to wrong number of arguments. ; The first integer is the number of expected arguments and + the second the number of given arguments.  The [CId]( argument is the list of free variables ( in the type. It should be used for the   function. '!Unknown function name was found. (!Unknown category name was found. 123456789:;<=>?@A=returns the type and the De Bruijn index of a local variable B2returns the type and the name of a local variable CDEFGHIJKLM)3Renders the type checking error to a document. See Text.PrettyPrint. *;Check whether a given type is consistent with the abstract  syntax of the grammar. NOP+/Checks an expression against a specified type. Q,9Tries to infer the type of a given expression. Note that 9 even if the expression is type correct it is not always 3 possible to infer its type in the GF type system. ' In this case the function returns the # error. RSTUVWXYZ !"#$%&'()*+, ('&%$#"!!"#$%&'()*+, -[./012\]-./012\]-./012\]^_`abc^_`abcd^_`abc%e-An abstract data type whose values represent 4 the state in an incremental parser after an error. fghijklmn3-An abstract data type whose values represent - the current state in an incremental parser. opqrstuvwxy4:Creates an initial parsing state for a given language and  startup category. 5*From the current state and the next token  5' computes a new state, where the token 9 is consumed and the current position is shifted by one. : If the new token cannot be accepted then an error state  is returned. 6KIf the next token is not known but only its prefix (possible empty prefix)  then the 60 function can be used to calculate the possible L next words and the consequent states. This is used for word completions in  the GF interpreter. 78=This function extracts the list of all completed parse trees @ that spans the whole input consumed so far. The trees are also 5 limited by the category specified, which is usually # the same as the startup category. z{|}~ e3xy45678 e3xy45678 Cbuild probability tables by filling unspecified funs with prob sum + TODO: check that probabilities sum to 1 (compute the probability of a given tree (rank from highest to lowest probability 999 ;The tree is an evaluated expression in the abstract syntax : of the grammar. The type is especially restricted to not A allow unapplied lambda abstractions. The tree is used directly ? from the linearizer and is produced directly from the parser. meta variable literal function application  variable 7lambda abstraction. The list of variables is non-empty .Converts a tree to expression. The conversion 4 is always total, every tree is a valid expression. @Converts an expression to tree. The conversion is only partial. Q Variables and meta variables of function type and beta redexes are not allowed.    (portable)(stable)AR :Converts a pattern to tree. :: (portable)(stable)AR;<=> ;<=> ;<=>portablestable Aarne Ranta?3Reads file in Portable Grammar Format and produces  / structure. The file is usually produced with:  $ gf -make <grammar file name> @6Linearizes given expression as string in the language A:Tries to parse the given string in the specified language 5 and to produce abstract syntax expression. An empty F list is returned if the parsing is not successful. The list may also < contain more than one element if the grammar is ambiguous. : Throws an exception if the given language cannot be used  for parsing, see canParse. BC The same as D but does not return  the language. D7Linearizes given expression as string in all languages  available in the grammar. EF The same as G but does not return  the language. G>Tries to parse the given string with all available languages. 1 Languages which cannot be used for parsing (see canParse)  are ignored. . The returned list contains pairs of language * and list of abstract syntax expressions 5 (this is a list, since grammars can be ambiguous).  Only those languages 8 for which at least one parsing is possible are listed. HBGenerates an infinite list of random abstract syntax expressions. G This is usefull for tree bank generation which after that can be used  for grammar testing. I The same as J but does not limit ' the depth in the generation, and doesn't give an initial expression. J2Generates an exhaustive possibly infinite list of 7 abstract syntax expressions. A depth can be specified  to limit the search space. K8The abstract language name is the name of the top-level  abstract module L6List of all languages available in the given grammar. M Gets the RFC 4646 language tag = of the language which the given concrete syntax implements, * if this is listed in the source grammar.  Example language tags include "en" for English,  and "en-UK" for British English. N5List of all categories defined in the given grammar. 3 The categories are defined in the abstract syntax  with the 'cat' keyword. O2The start category is defined in the grammar with  the 'startcat'- flag. This is usually the sentence category A but it is not necessary. Despite that there is a start category = defined you can parse with any category. The start category % definition is just for convenience. P5List of all functions defined in the abstract syntax QThe type of a given function R9Complete the last word in the given string. If the input < is empty or ends in whitespace, the last word is considred 9 to be the empty string. This means that the completions " will be all possible next words. Possible completions,  including the given input. S&Converts an expression to normal form TU  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU?LKM  NOPQ@DCEABGFS:*+, ('&%$#"!)R345678HIJ9/.-102;=<>T?@ABCDEFGHIJKLMNOPQRST     ! " # $ % & ' ( )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoppqqrstuvwrxwyrxyzrxz{r|trx}~Oyw                 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?@A@B C D E F G H I J K L M N O O P Q R S T U V W X Y Z [ y \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                               !"#~$%&'()*+,-./01234456789:;;<=>?@ABCDEFGHIJKLMNOPQRSTUHVWXYZ[\]^_`aabcdefghijklmnoo\]pqrstuvwxyz{|}~* gf-3.1.6.2PGFData.Binary.Builder GF.Data.ErrMData.Binary.GetData.Binary.PutGF.Data.TrieMap Data.BinaryGF.Data.UtilitiesGF.Data.SortedListGF.Data.RelationGF.Data.OperationsPGF.CIdPGF.TypePGF.ExprPGF.Data PGF.Macros PGF.Linearize PGF.TypeCheckPGF.Morphology PGF.Binary PGF.ParsePGF.Probabilistic PGF.GeneratePGF.TreePGF.ParaphrasePGF.VisualizeTree PGF.PrinterCIdwildCIdmkCIdreadCIdshowCIdExprHypoTypereadTypeshowTypemkTypemkHypo mkDepHypo mkImplHypoTreereadExprshowExprmkAppunAppmkStrunStrmkIntunIntmkDoubleunDoublemkMetaisMetaLanguage readLanguage showLanguage showPrintNameTcErrorUnexpectedImplArgUnresolvedMetaVarsCannotInferType NotFunType TypeMismatch WrongCatArgs UnknownFun UnknownCat ppTcError checkType checkExpr inferExprMorphoAnalysisLemma buildMorpho lookupMorphofullFormLexicon ParseState initState nextStategetCompletionsrecoveryStates extractTreesgenerateRandomFrom paraphrasegraphvizAbstractTreegraphvizDependencyTreegraphvizParseTreegraphvizAlignmentreadPGF linearizeparseparseWithRecovery linearizeAlllinearizeAllLang groupResultsparseAll parseAllLanggenerateRandom generateAllgenerateAllDepth abstractName languages languageCode categoriesstartCat functions functionTypecompletecomputebrowseBufferBuilderbytestring-0.9.1.8Data.ByteString.Lazy.Internal ByteStringtoLazyByteString runBuilderemptyData.ByteString.Lazy singletonappendfromByteStringData.ByteString.Internal fromChunksfromLazyByteStringflush defaultSize unsafeLiftIOwithSize mapBuilder ensureFreewriteN writeNBuffer newBuffer writeNbyteswriteNBufferBytes putWord16be putWord16le putWord32be putWord32le putWord64be putWord64le putWordhost putWord16host putWord32host putWord64host shiftr_w16 shiftr_w32 shiftr_w64ErrBadOk$fMonadPlusErr $fFunctorErrGetunGetSgetputmkStaterunGet runGetStatefailDescskip uncheckedSkip lookAhead lookAheadM lookAheadEuncheckedLookAhead bytesRead remainingisEmpty getByteStringgetLazyByteStringgetLazyByteStringNulgetRemainingLazyByteStringgetBytesjoin splitAtSTreadNgetPtrgetWord8 getWord16be getWord16le getWord32be getWord32le getWord64be getWord64le getWordhost getWord16host getWord32host getWord64host shiftl_w16 shiftl_w32 shiftl_w64PutPutMunPutPairSsndStell putBuilderexecPutrunPutrunPutMputWord8 putByteStringputLazyByteStringTrieMapTrlookupnull decompose insertWith unionWith unionsWithelemsSmallIntBinaryencodedecode encodeFile decodeFileunrollrollbaseGHC.WordWordWord8Word16Word32Word64 sameLength notLongerThan longerThan lookupListsplitsplitBy foldMergeselect updateNth updateNthMsafeInitGHC.ListinitsortNub Data.Listnub sortNubBynubBy sortGroupByunionAlllookup'find'findtableSet buildMultiMapreplace compareEq compareBybothmapFstmapSndwhenMP Control.Monadmzero nothingOrNullfoldFunsfixnlspwrapconcatSunwordsSunlinesSjoinSSMapSList groupPairs groupUnionhasCommonElementssubsetnubsortunionMapmergeMapunion<++><\\><**>limitRel'RelmkRelmkRel' relToListrelaterelates isRelatedTo allRelateddomain reverseRelintersectSetReltransitiveClosurereflexiveClosure_reflexiveClosuresymmetricClosuresymmetricSubrelationreflexiveSubrelationreflexiveElements filterRel purgeEmptyequivalenceClasses isTransitive isReflexive isSymmetric isEquivalenceisSubRelationOftopologicalSort Data.EitherLeftRighttsort findCyclesisEmpty' relToRel' rel'ToRelremoveincomingoutgoing ErrorMonadraisehandlehandle_STMBinTreeifNullonSnderrmaybeErrtestErrerrValerrIn lookupErr mapPairListM mapPairsMpairM checkUnique emptyBinTree isInBinTreejustLookupTree lookupTreelookupTreeManylookupTreeManyAll updateTree buildTree sorted2treemapTreemapMTree filterBinTree tree2listindent+++++-+++++++++prUpper prReplicateprTListprQuotedString prParenthprCurly prBracket prArgList prSemicList prCurlyListrestoreEscapesnumberedParagraphs prConjList prIfEmpty wrapLines combinationstopoTestiterFixchunks readIntArgappSTMstmstmrreadSTM updateSTMwriteSTMdonemapsErr mapsErrTree checkAgainchecks allChecksdoUntilGHC.BaseString Data.MaybeNothingpCIdpIdentppCIdDTyppTypeppTypeppHypo freshNameppExprpBindsBindTypeImplicitExplicitEnvSigValueVImplArgVClosureVConstVGenVSuspVMetaVLitVAppEquationEquPattPTildePImplArgPWildPAsPVarPLitPAppEImplArgETypedEVarEFunEMetaELitEAppEAbsMetaIdLiteralLFltLIntLStrpExprpLitppPatt pattScopeppMeta normalFormevalapplymatchppParenspArgpMetappLit value2exprToknKPKSTermTMWFVFCVKPR AlternativeAltSeqIdFunIdSequenceCncFunCncCat ProductionPConstPCoercePApplySymbolSymKPSymKSSymLitSymCatDotPosLIndexFIdConcrcflags printnamescncfuns sequences productions pproductions lproductionscnccats totalCatsAbstraflagsfunscatsgflagsabsnameabstract concretesunionPGFemptyPGF fcatStringfcatInt fcatFloatfcatVar isLiteralFCat mapConcreteslookTypelookDefisData lookValCat lookStartCatlookGlobalFlag lookAbsFlag lookConcrlookConcrComplete lookConcrFlagfunctionsToCat missingLinshasLin restrictPGFdepthcftype typeOfHypo catSkeleton typeSkeletonvalCat contextLengthterm0tm0kkslookMap isLiteralCatupdateProductionIndices cidStringcidIntcidFloatcidVar_B_VLinTable linearizeslinTreeuntokntabularLinearizesmarkLinearizesTcResultFailTcMunTcM MetaValueMGuardedMBoundMUnbound MetaStoreScopeTTypeTTyp addScopedVar lookupVargetVarscopeEnv scopeVars scopeSize lookupCatHyps lookupFunTypenewMetanewGuardedMetagetMetasetMetatcError addConstrainttcTypetcHypostcHypotcExprinfExpreqTypecheckResolvedMetaStoreevalType refineExpr refineType morphoMissingmissingWordMsgpgfMajorVersionpgfMinorVersionputArraygetArray putArray2 getArray2 decodingError ErrorStateEStateChartactiveactivespassiveforestnextIdoffsetPState PassiveChart PassiveKeyPK ActiveChart ActiveKeyAKActiveupdateAtemptyAClookupAClookupACByFCatlabelsACinsertACemptyPClookupPCinsertPC foldForest ProbabilitiesProbsfunProbscatProbsprProbabilitiesgetProbsFromFile fillProbsdefaultProbabilitiesprobTreerankTreesByProbsgenerateAllFromgenerateForMetasgenerate genRandom genRandomProb hitRegionMetaLitFunVarAbs tree2expr expr2treeprTreeSubst paraphraseN paraphraseN'fromDefsubstisClosedisLinear patt2treePosTextMTLabels tree2graphtree2mk getDepLabels lin2graphwlins readPosTextppPGFppAbsppFlagppCatppFunppCncppAll