h$@:^      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                     Safe-Inferred2>hpp6A fully-populated configuration for the pre-processor.hppPre-processor configuration parameterized over a functor. This is used to normalize partial configurations,  ConfigF Maybe<, and configurations suitable for the pre-processor logic, ConfigF Identity. Specifically, the source file name of the file being processed must be set.hppName of the file being preprocessed. Hpp will update this as new files are included. The user must set it manually for the starting input file.hpp(Paths to be searched for included files.hppA backslash as the last character of a line causes the next line to be appended to the current one eliding the newline character present in the source input.hpp#Erase line comments (starting with //$) and block comments (delimited by /* and */).hpp Do not emit #line directives.hppReplace trigraph sequences (each of which starts with two consecutive question marks ("??"") with the characters they encode. hppFormat string for __DATE__. hppFormat string for __TIME__. hppA  representing a date.hppA  representing a time.hpp7Ensure that required configuration fields are supplied.hpp3Extract the current file name from a configuration.hpp4Extract the include paths name from a configuration.hpp4Determine if continued long lines should be spliced.hpp/Determine if C-style comments should be erased.hpp;Determine if generation of linemarkers should be inhibited.hpp3Determine if trigraph sequences should be replaced.hpp&The date the pre-processor was run on.hpp0The time of the active pre-processor invocation.hppA default configuration with no current file name set. Note that long line splicing is enabled, C++-style comments are erased, #line markers are inhibited, and trigraph replacement is disabled.hpp&Format a date according to the C spec.hpp&Format a time according to the C spec.hppA default preprocessor configuration with date and time stamps taken from the current system time.hppLens for the "splice long lines" option (prepend a line ending with a backslash to the next line).hppLens for the "erase C-style comments" option (comments delimited by /* and */). hppLens for the "inhibit line markers" option. Option to disable the emission of #line pragmas in the output.!hpp(Lens for the "replace trigraphs" option."   !"   ! Safe-Inferred)*+,)*+, Safe-Inferred-hppStringification puts double quotes around a string and backslashes before existing double quote characters and backslash characters..hpp9Remove double quote characters from the ends of a string./hpp0Remove angle brackets from the ends of a string.0hppTrim trailing spaces from a 1hpp0Similar to the function of the same name in the text package.breakOn needles haystack, finds the first instance of an element of needles in haystack. The first component of the result is the needle tag, the second component is the prefix of haystack before the matched needle, the third component is the remainder of the haystack after the needle..2hppUsed to make switching to the text package easier.-./012-./012 Safe-Inferred &>3hpp?A collection of operations relating to sequences of characters.4hppStringification puts double quotes around a string and backslashes before existing double quote characters and backslash characters.5hpp9Remove double quote characters from the ends of a string.6hppTrim trailing spaces from a 7hpp0Similar to the function of the same name in the text package.breakOn needles haystack, finds the first instance of an element of needles in haystack. The first component of the result is the needle tag, the second component is the prefix of haystack before the matched needle, the third component is the remainder of the haystack after the needle..8hppA special case of 7 in which we are looking for either a special character or a particular substring.EhppAn opportunity to copy a string to its own storage to help with GC3@?>=864D5CB7=864D5CB7%hpp6There are object-like macros and function-like macros.hpp4An object-like macro is replaced with its definitionhppA function-like macro of some arity taks macro-expanded and raw versions of its arguments, then substitutes them into a body producing a new set of tokens.hppMacro expansion involves treating tokens differently if they appear in the original source or as the result of a previous macro expansion. This distinction is used to prevent divergence by masking out definitions that could be used recursively.Things are made somewhat more complicated than one might expect due to the fact that the scope of this masking is not structurally recursive. A object-like macro can expand into a fragment of a macro function application, one of whose arguments is a token matching the original object-like macro. That argument should not be expanded.hpp=An interpreter capability of threading a binding environment.hpp2An interpreter capability to modify dynamic state.hppA free monad transformer specialized to HppF as the base functor.hpp is a monad with  as its base functor.hppA free monad construction to strictly delimit what capabilities we need to perform pre-processing.hpp)Dynamic state of the preprocessor engine.hppInitial configurationhppDirectory of input filehpp!Current line number of input filehpp Preprocessor binding environmenthpp)Base functor for a free monad transformerhpp%Hpp can raise various parsing errors.hpp"Error conditions we may encounter.hppA macro binding environment.hpp Line numbers are represented as shpphppReadFile lineNumber fileName introduces an  #include fileName at the given line number.hpphppReadNext lineNumber fileName introduces an #include_next fileName at the given line number.hpp Looks up a $ in the current environment. If the  is found, the environment is juggled so that subsequent lookups of the same  may evaluate more quickly.44 Safe-Inferred 'hppIf a line ends with a backslash, it is prepended to the following the line.hpp(Remove C-style comments bracketed by @@.hppRemove C-style comments bracked by @@ and perform trigraph replacement.  Safe-Inferred5-U hppA  is a bit of state that carries a source of input consisting of a list of values which are either actions in an underlying monad or sequences of inputs. Thus we have chunks of input values with interspersed effects.hppA 2 is a bit of state that carries a source of input.hpp)Push a value back into a parser's source.hpp4Push a stream of values back into a parser's source.hpp Evaluate a  with a given input stream.hpp that throws an error with the given message if no more input is available. This may be used to locate where in a processing pipeline input was unexpectedly exhausted.hppDiscard all values until one fails to satisfy a predicate. At that point, the failing value is  d, and the  stream stops.hppEcho all values until one fails to satisfy a predicate. At that point, the failing value is  d, and the  stream stops.hppA parser on lists of things can embed a parser on things. For example, if we have a parser on lists of words, we can embed a parser on individual words.hppGiven a function with type a -> b, and a partial inverse,  b -> Maybe a*, we can embed a parser on values of type b in a parser on values of type a.    Safe-Inferred &-hpp9Parse the definition of an object-like or function macro.  Safe-Inferred .)  Safe-Inferred /,hppTake everything up to the end of this branch, drop all remaining branches (if any).hppDrop the rest of a conditional expression incrementing the given  by the number of lines skipped.  Safe-Inferred &/hppHandle preprocessor directives (commands prefixed with an octothorpe).hpp9Expands an input line producing a stream of output lines. Safe-Inferred &-2hppInterpret the IO components of the preprocessor. This implementation relies on IO for the purpose of checking search paths for included files.hppLike @runHpp@, but any #include directives are skipped. These ignored inclusions are tracked in the returned list of files, but note that since extra source files are not opened, any files they might wish to include are not discovered.hpp/Run a stream of lines through the preprocessor.hppGeneral hpp runner against input source file lines. Output lines are fed to the caller-supplied sink function. Any errors encountered are thrown with .hpp%hpp runner that returns output lines.  None9 hppThe result of running hpphpp/The type of preprocessor actions. Created with  and executed with  or .hppPreprocess lines of input.hppRun a preprocessor action with some initial state. Returns the result of preprocessing as well as an updated preprocessor state representation.hppstreamHpp state sink action runs a preprocessor action with some initial state4. Output is streamed to the caller-provided output sink as it is generated. The list of files read during preprocessing is returned along with an updated preprocessor state representation.hppLike , but does not access the filesystem. Run a preprocessor action with some initial state. Returns the result of preprocessing as well as an updated preprocessor state representation. Since this operation performs no IO, #include directives are ignored in terms of the generated output lines, but the files named in those directive are available in the  value returned.hppAn  containing no macro definitions, and default values for the starting configuration: the name of the current file is "NoFile", there are no paths to be searched for included files, etc. See 2 for more information on available configuration.hpp Create a  with the given  and .hppaddDefinition name expression adds a binding of name to  expression& in the preprocessor@s internal state.hppLower level parsing of macro definitions. Will typically be used with * for manual construction of a  binding environment.None :Vhpp-Run Hpp with the given commandline arguments. !"#$%&'()*+,-./0123456789:;<=>?@A;<>?B@CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                     hpp-0.6.5-24hk5iZDc1gDtGirvpBRvv Hpp.ConfigHpp.Env Hpp.String Hpp.StringSig Hpp.TokensHpp.Expr Hpp.TypesHpp.Preprocessing Hpp.Parser Hpp.Macro Hpp.ExpansionHpp.Conditional Hpp.Directive Hpp.RunHppHpp Hpp.CmdLineConfigConfigF curFileNameF includePathsFspliceLongLinesFeraseCCommentsFinhibitLinemarkersFreplaceTrigraphsF prepDateF prepTimeF DateString getDateString TimeString getTimeString realizeConfig curFileName includePathsspliceLongLineseraseCCommentsinhibitLinemarkersreplaceTrigraphsprepDateprepTimedefaultConfigFformatPrepDateformatPrepTimedefaultConfigFNowspliceLongLinesLeraseCCommentsLinhibitLinemarkersLreplaceTrigraphsL$fEqDateString$fOrdDateString$fShowDateString$fEqTimeString$fOrdTimeString$fShowTimeString $fShowConfigFemptyEnv insertPair deleteKey lookupKey stringifyunquotestripAngleBrackets trimSpacesbreakOnconsStringybreakCharOrSubunconssnocunsnocsdropsbreaksall sIsPrefixOfisEmpty readLines putStringytoCharscopy CharOrSub CharMatchSubMatchNoMatchNil:.boolJust predicateJust sdropWhilestripR$fStringyByteString $fStringy[]Token ImportantOtherdetok isImportant notImportant importantstrimUnimportantnewLine skipLiteraltokenize detokenize$fFunctorToken $fEqToken $fOrdToken $fShowTokenExprELitEBinOpEUnaryOp readLitInt parseExpr renderExprevalExpr $fNumCppInt $fOrdCppInt $fEqCppInt$fEqExpr $fOrdExpr $fShowExpr $fEqFunLike $fOrdFunLike $fShowFunLike $fEqAssoc $fOrdAssoc $fShowAssoc $fEqParsed $fOrdParsed $fShowParsed$fEqLit$fOrdLit $fShowLit $fEqUnaryOp $fOrdUnaryOp $fShowUnaryOp $fEqBinOp $fOrdBinOp $fShowBinOpLensMacroObjectFunctionScanUnmaskMaskRescanHasEnvgetEnvsetEnv HasHppStategetStatesetStateHppTrunHppTHppFReadFileReadNext WriteOutputHppState hppConfig hppCurDir hppLineNumhppEnvFreeFPureFHasError throwErrorErrorUnterminatedBranchBadMacroDefinitionBadIfPredicateBadLineArgumentIncludeDoesNotExist FailedInclude UserErrorUnknownCommandTooFewArgumentsToMacroBadMacroArguments NoInputFileBadCommandLine RanOutOfInputTOKENStringEnvLineNum hppReadFile hppReadNexthppWriteOutput lookupMacrosetLgetLover emptyHppStateconfigdirlineNumenvuse.=%=$fExceptionError$fHasErrorStateT$fHasErrorExceptT$fFunctorFreeF $fFunctorHppF $fMonadIOHppT$fMonadTransHppT $fMonadHppT$fApplicativeHppT $fFunctorHppT$fHasErrorHppT $fShowMacro$fHasEnvExceptT$fHasEnvStateT$fHasEnvStateT0 $fHasEnvHppT$fHasHppStateHppT$fHasHppStateStateT$fHasHppStateStateT0$fHasHppStateExceptT$fShowHppState$fEqScan $fShowScan $fEqError $fOrdError $fShowErrortrigraphReplacement lineSplicingcCommentRemovalcCommentAndTrigraph prepareInputParserParserTawaitreplaceprecede evalParse awaitJust droppingWhile takingWhileinsertInputSegmentonInputSegment onElements onIsomorphism$fFunctorInputItemparseDefinitionexpandLineState takeBranch dropBranch directivemacroExpansion HppResult hppFilesRead hppResultrunHpp expandHpp preprocess hppIOSinkhppIO HppOutput hppOutput streamHppexpand initHppState addDefinition runWithArgsbaseGHC.Base Data.OldListwordsghc-prim GHC.TypesTrueFalseIntGHC.Errerror