March 2014 - Haskell-Cafe

parsec problem: infinite loop (possibly connected to try(lookahead ...)) but how?)
by keydana＠gmx.de 01 Mar '14

01 Mar '14

Hi, I want to parse a rather unstructured log file, skipping blocks I'm not interested in but keeping others. For that purpose, I define "markers" that flag the beginning of interesting chunks. The "skip parser" reads anything until such a marker (using manyTill parseAny (try (lookAhead parseMarker)) and then the relative content parser starts by really consuming this marker string. I have a test case demonstrating this principle which works fine, but when I execute the (seemingly!) equivalent "real" code on a piece of a (seemingly!) equivalent "real log file", ghci enters an infinite loop - and I have no idea why... I'd be very grateful for any help, as I'm completely stuck here ;-) Following are: - the test input file - the piece of "real logfile" - the complete code in one piece (Main.hs), with the test case code in the bottom These are the results when I run 1) the test case: *Main> readFile "testfile.txt" >>= parseTest parseAll ["aaa\naaa\n","aaa\naaa\n","aaa\naaa\n"] 2) the main code (endless loop interrupted, with output from debug.trace): parseUntilChunkWFG: "" parseMaybeChunk: Nothing parseWFGMarker: Global Wait-For-Graph(WFG) at ddTS[0.3] : parseUntilChunkWFG: "" parseMaybeChunk: Nothing ^CparseWFGMarker: Global Wait-For-Graph(WFG) at ddTS[0.3] : parseUntilChunkWFG: "" parseMaybeChunk: Nothing Interrupted. This is the test input file, with vi newline symbols: ########################################################################## this is just some stuff$ I wanna skip$ $ this is, too$ 12[] $ $ BEGIN_MARKER$ aaa$ aaa$ $ this here again I can skip$ $ BEGIN_MARKER$ aaa$ aaa$ $ and then it goes on till the end of the file$ ########################################################################## ... and this is the real piece (part of, what is important I have 2 chunks of "interesting content"): ########################################################################## client details:$ O/S info: user: oracle, term: pts/2, ospid: 5820$ machine: node1.skyrac.com program: sqlplus(a)node1.skyrac.com (TNS V1-V3)$ application name: sqlplus(a)node1.skyrac.com (TNS V1-V3), hash value=10026263$ current SQL:$ insert into test values(2)$ DUMP LOCAL BLOCKER: initiate state dump for DEADLOCK$ possible owner[39.5827] on resource TX-00080011-00000545$ $ *** 2014-02-22 08:43:55.554$ Submitting asynchronized dump request [28]. summary=[ges process stack dump (kjdglblkrdm1)].$ Global blockers dump end:-----------------------------------$ Global Wait-For-Graph(WFG) at ddTS[0.3] :$ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0xc0006.0x1c5(ext 0x4,0x0)[27000-0001-00000001] inst 1 $ BLOCKER 0x83b196a8 3 wq 1 cvtops x28 TX 0xc0006.0x1c5(ext 0x4,0x0)[36000-0002-00000005] inst 2 $ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0x80011.0x545(ext 0x2,0x0)[36000-0002-00000005] inst 2 $ BLOCKER 0x83b35b10 3 wq 1 cvtops x28 TX 0x80011.0x545(ext 0x2,0x0)[27000-0001-00000001] inst 1 $ $ *** 2014-02-22 08:43:56.292$ * Cancel deadlock victim lockp 0x83437238 $ DUMP LOCAL BLOCKER: initiate state dump for DEADLOCK$ possible owner[39.5827] on resource TX-00080011-00000545$ $ *** 2014-02-22 08:43:55.554$ Submitting asynchronized dump request [28]. summary=[ges process stack dump (kjdglblkrdm1)].$ Global blockers dump end:-----------------------------------$ Global Wait-For-Graph(WFG) at ddTS[0.3] :$ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0xc0006.0x1c5(ext 0x4,0x0)[27000-0001-00000001] inst 1$ BLOCKER 0x83b196a8 3 wq 1 cvtops x28 TX 0xc0006.0x1c5(ext 0x4,0x0)[36000-0002-00000005] inst 2$ BLOCKED 0x83437238 3 wq 2 cvtops x1 TX 0x80011.0x545(ext 0x2,0x0)[36000-0002-00000005] inst 2$ BLOCKER 0x83b35b10 3 wq 1 cvtops x28 TX 0x80011.0x545(ext 0x2,0x0)[27000-0001-00000001] inst 1$ $ *** 2014-02-22 08:43:56.292$ ########################################################################## ... and this is the code: ########################################################################## module Main ( main ) where import System.Environment import System.Directory import Text.ParserCombinators.Parsec import Debug.Trace import Numeric import Data.Maybe import Data.Char main = do --files <- getArgs currDir <- getCurrentDirectory --let filepaths = map ((currDir ++ "/") ++) ["munip1_lmd0_5702.trc", "munip2_lmd0_5966.trc"] let filepaths = map ((currDir ++ "/") ++) ["munip1_lmd0_5702.trc"] wfgs <- mapM (\p -> parseFromFile parseChunks p) filepaths print wfgs parseChunks :: Parser [Chunk] parseChunks = do chunks <- many1 parseMaybeChunk -- trace ("parseChunks: " ++ (show chunks)) return (catMaybes chunks) return (catMaybes chunks) parseMaybeChunk :: Parser (Maybe Chunk) parseMaybeChunk = do chunk <- try (parseChunkWFG >>= return . Just) <|> try (parseUntilChunkWFG >> return Nothing) <|> (parseTillEOF >> return Nothing) trace ("parseMaybeChunk: " ++ show chunk) return chunk --return chunk parseUntilChunkWFG :: Parser [Char] parseUntilChunkWFG = do skip <- manyTill parseAny (try (lookAhead parseWFGMarker) ) trace ("parseUntilChunkWFG: " ++ show skip) return skip --return skip parseAny :: Parser Char parseAny = do anyC <- oneOf (['a'..'z'] ++ ['A'..'Z'] ++ ['0'..'9'] ++ "()[]* -:.,/_?@='\n\\") --trace ("parseAny: " ++ (show anyC)) return anyC return anyC parseWFGMarker :: Parser [Char] parseWFGMarker = do marker <- string "Global Wait-For-Graph(WFG) at ddTS[0.3] :\n" trace ("parseWFGMarker: " ++ marker) return marker --return marker parseTillEOF :: Parser [Char] parseTillEOF = do anyCs <- many1 anyChar eof --trace ("parseTillEOF: " ++ anyCs) return anyCs return anyCs parseChunkWFG :: Parser Chunk parseChunkWFG = do marker <- string "Global Wait-For-Graph(WFG) at ddTS[0.3] :\n" wfg <- manyTill parseWFGEntry newline --trace ("parseChunkWFG: " ++ (show wfg)) return $ ChunkWFG wfg return $ ChunkWFG wfg parseWFGEntry :: Parser WFGEntry parseWFGEntry = do role <- try (string "BLOCKER") <|> string "BLOCKED" skipMany1 (space >> string "0x") lockaddr <- many1 hexDigit skipMany1 (space >> (many1 digit) >> space >> string "wq" >> space >> (many1 digit) >> space >> string "cvtops" >> space >> char 'x' >> (many1 digit) >> space) restype <- manyTill upper space skipMany1 (string "0x") id1 <- manyTill hexDigit (string ".0x") id2 <- manyTill hexDigit (string "(ext ") manyTill (digit <|> oneOf ")[]x,-") (string " inst ") instid <- manyTill digit (space >> newline) let wfgEntry = WFGEntry (read role :: Role) lockaddr (ResourceId id1 id2 restype) (read instid) --trace ("parseWFGEntry: " ++ show wfgEntry) return $ wfgEntry {- trace ("parseWFGEntry: " ++ role ++ " " ++ lockaddr ++ " " ++ restype ++ " " ++ id1 ++ " " ++ id2 ++ " " ++ instid) return $ wfgEntry -} return $ wfgEntry data Chunk = ChunkWFG WFG deriving (Show, Read) data ResourceId = ResourceId { id1 :: String, id2 :: String, restype :: String } deriving (Show, Read) data WFGEntry = WFGEntry { role :: Role, lockaddr :: String, resource :: ResourceId, instid :: Int } deriving (Show, Read) type WFG = [WFGEntry] data Role = BLOCKED | BLOCKER deriving (Show, Read) ------------------- testcase code --------------------------- parseAll :: Parser [String] parseAll = do chunks <- many1 parseChunk return (catMaybes chunks) parseChunk :: Parser (Maybe [Char]) parseChunk = do chunk <- try (parseContent >>= return . Just) <|> try (parseUntilMarker >> return Nothing) <|> (parseTillEOF >> return Nothing) --trace ("parseChunk: " ++ show chunk) return chunk return chunk parseUntilMarker :: Parser [Char] parseUntilMarker = do skip <- manyTill parseAny (try (lookAhead parseMarker) ) --trace ("parseUntilMarker: " ++ show skip) return skip return skip parseMarker :: Parser [Char] parseMarker = do marker <- string "BEGIN_MARKER\n" --trace ("parseWFGMarker: " ++ marker) return marker return marker parseContent :: Parser [Char] parseContent = do marker <- string "BEGIN_MARKER\n" items <- manyTill parseItem newline --trace ("parseContent: " ++ (show items)) return $ concat items return $ concat items parseItem :: Parser [Char] parseItem = string "aaa\n" ########################################################################## Many thanks in advance for any hints what might be going on :-)! Sigrid

1 0

Safe Haskell design question - package trust
by Omari Norman 01 Mar '14

01 Mar '14

Safe Haskell has three levels of safety: Safe - pure functions won't launch missiles. Well, sort of. They might launch missiles if they apply functions from other Trustworthy modules that do launch missiles, though one can use -fpackage-trust to mitigate this issue. Unsafe - pure functions might launch missiles, watch out. Trustworthy - module author raises her hand and says "My pure functions won't launch missiles, I promise." I can use the package trust feature to say "only trust a Trustworthy package if I say so." My issue is this: why is there no easy way to trust *any* package, not just packages that are Trustworthy? I should be able to say "I trust this package." It is immaterial whether the package author has raised her hand and said "my pure functions don't launch missiles" when I can examine the code for myself and determine whether the code launches missiles. Indeed, if I use package trust, I need to either examine the code or trust the author--the author's pledge isn't determinative. I see what "Trustworthy" adds when you're not using package trust, but it's just an informational flag if you are using package trust. Despite this Safe Haskell will not recognize the trustworthiness of packages that I have deliberately marked as trusted--merely because the author has not made a pledge. I ask because Safe Haskell has been around for over two years now yet the time package, which ships with GHC, has modules that are unsafe. I have examined them; they don't launch missiles. Yet the only easy way to get them working with Safe Haskell is to get the modules marked Trustworthy. I have emailed the maintainer and the libraries mailing list and so far have heard nothing. I have seen at least one package author get annoyed because people asked him to mark his modules Trustworthy, and I think he's right. He shouldn't need to say they're Trustworthy; rather, the Safe Haskell user should be able to do this himself. (True, the Safe Haskell user can do this by recompiling--come on, it shouldn't be that hard, and I don't want to recompile a package like time, that ships with GHC.)

1 0

Re: [Haskell-cafe] [Haskell] Can Haskell use short floats; i.e. 16 bit floats to save space?
by Henning Thielemann 01 Mar '14

01 Mar '14

moving to Haskell-Cafe ... Am 01.03.2014 07:09, schrieb KC: > Can Haskell use short floats; i.e. 16 bit floats to save space? You could wrap an Int16 in a newtype and implement your own floating point arithmetic with some bit manipulation and make that instances of Num, Fractional or numeric-prelude or yap classes.

3 2