hpastetwo

New Revision

import List                                                                                                                                                                                                                                  
import Data.List                                                                                                                                                                                                                             
import Numeric                                                                                                                                                                                                                               
import Control.Concurrent                                                                                                                                                                                                                    
import System.IO                                                                                                                                                                                                                             
import System.Environment                                                                                                                                                                                                                    
import System.Posix.Process                                                                                                                                                                                                                  
                                                                                                                                                                                                                                             
data ParsedEntity = ParsedEntity {                                                                                                                                                                                                           
    delay   :: Int,                                                                                                                                                                                                                          
    binary  :: String,                                                                                                                                                                                                                       
    args    :: [String]                                                                                                                                                                                                                      
} deriving (Show, Eq)                                                                                                                                                                                                                        
                                                                                                                                                                                                                                             
instance Ord ParsedEntity where                                                                                                                                                                                                              
    compare x y                                                                                                                                                                                                                              
        | delay x == delay y    = EQ                                                                                                                                                                                                         
        | delay x < delay y     = LT                                                                                                                                                                                                         
        | otherwise             = GT                                                                                                                                                                                                         
                                                                                                                                                                                                                                             
main =                                                                                                                                                                                                                                       
    getArgs >>= handleArgs                                                                                                                                                                                                                   
    where handleArgs (name:_) = do                                                                                                                                                                                                           
            inh <- openFile name ReadMode                                                                                                                                                                                                    
            contents <- hGetContents inh                                                                                                                                                                                                     
            let entities = parseContents contents                                                                                                                                                                                            
            print entities                                                                                                                                                                                                                   
            processEntities entities                                                                                                                                                                                                         
            hClose inh                                                                                                                                                                                                                       
          handleArgs _ = putStrLn "Incorrect args format"                                                                                                                                                                                    
                                                                                                                                                                                                                                             
processEntities = mapM processEntity                                                                                                                                                                                                         
    where processEntity e = do                                                                                                                                                                                                               
            threadDelay $ 1000000 * delay e                                                                                                                                                                                                  
            putStrLn $ "Running " ++ binary e ++ " with arguments " ++ show (args e)                                                                                                                                                         
            forkProcess $ executeFile (binary e) False (args e) Nothing                                                                                                                                                                      
                                                                                                                                                                                                                                             
parseContents = snd . sequenize . buildSorted                                                                                                                                                                                                
    where sequenize = foldl' f (0, [])                                                                                                                                                                                                       
            where f (acc, xs) e = (delay e, xs ++ [(ParsedEntity (delay e - acc) (binary e) (args e))])                                                                                                                                      
          buildSorted = sort . map parseLine . lines                                                                                                                                                                                         
            where parseLine line = ParsedEntity (fst rd) (head (words (snd rd))) (tail (words (snd rd)))                                                                                                                                     
                    where rd = head $ readDec line

author title

language channel