Changeset 2009

Show
Ignore:
Timestamp:
04/16/05 00:52:37 (4 years ago)
Author:
theorbtwo
svk:copy_cache_prev:
3535
Message:

The Great Renaming. * becomes Pugs.*, except for stuff designed to be externable.

Location:
src
Files:
1 added
31 modified
29 moved

Legend:

Unmodified
Added
Removed

  • src/IMC.hs

    r1458 r2009  
    1010-} 
    1111 
    12 module IMC ( 
     12module Pugs.IMC ( 
    1313    module IMC.Compile, 
    1414    yow, 

  • src/IMC/AST.hs

    r1427 r2009  
    11{-# OPTIONS_GHC -fglasgow-exts -fth #-} 
    22 
    3 module IMC.AST where 
     3module Pugs.IMC.AST where 
    44import Language.Haskell.TH 
    55import Language.Haskell.TH.Ppr 

  • src/IMC/Compile.hs

    r1427 r2009  
    11{-# OPTIONS_GHC -fglasgow-exts -fth #-} 
    22 
    3 module IMC.Compile where 
     3module Pugs.IMC.Compile where 
    44 
    55import Rule 

  • src/IMC/Lexer.hs

    r1458 r2009  
    11{-# OPTIONS_GHC -fglasgow-exts #-} 
    22 
    3 module IMC.Lexer where 
     3module Pugs.IMC.Lexer where 
    44import Internals 
    55import Rule hiding (letter) 

  • src/Main.hs

    r1845 r2009  
    1515 
    1616module Main where 
    17 import Internals 
    18 import Config 
    19 import Run 
    20 import AST 
    21 import Types 
    22 import Eval 
    23 import External 
    24 import Shell 
    25 import Parser 
    26 import Help 
    27 import Pretty 
    28 import Compile 
     17import Pugs.Internals 
     18import Pugs.Config 
     19import Pugs.Run 
     20import Pugs.AST 
     21import Pugs.Types 
     22import Pugs.Eval 
     23import Pugs.External 
     24import Pugs.Shell 
     25import Pugs.Parser 
     26import Pugs.Help 
     27import Pugs.Pretty 
     28import Pugs.Compile 
    2929import IO 
    3030import qualified Data.Map as Map 
    … …  
    134134    writeFile "dump.ast" str 
    135135 
    136 doParseWith :: (AST.Exp -> FilePath -> IO a) -> FilePath -> String -> IO a 
     136doParseWith :: (Pugs.AST.Exp -> FilePath -> IO a) -> FilePath -> String -> IO a 
    137137doParseWith f name prog = do 
    138138    env <- emptyEnv [] 

  • src/Pugs/AST.hs

    r1987 r2009  
    1313-} 
    1414 
    15 module AST where 
    16 import Internals 
    17 import Context 
    18 import Rule 
     15module Pugs.AST where 
     16import Pugs.Internals 
     17import Pugs.Context 
     18import Pugs.Rule 
    1919import List 
    20 import Types 
    21 import qualified Types.Array  as Array 
    22 import qualified Types.Handle as Handle 
    23 import qualified Types.Hash   as Hash 
    24 import qualified Types.Scalar as Scalar 
    25 import qualified Types.Code   as Code 
    26 import qualified Types.Rule   as Rule 
     20import Pugs.Types 
     21import qualified Pugs.Types.Array  as Array 
     22import qualified Pugs.Types.Handle as Handle 
     23import qualified Pugs.Types.Hash   as Hash 
     24import qualified Pugs.Types.Scalar as Scalar 
     25import qualified Pugs.Types.Code   as Code 
     26import qualified Pugs.Types.Rule   as Rule 
    2727import qualified Data.Set       as Set 
    2828import qualified Data.HashTable as HTable 

  • src/Pugs/Bind.hs

    r1902 r2009  
    1010-} 
    1111 
    12 module Bind where 
    13 import Internals 
    14 import AST 
    15 import Types 
     12module Pugs.Bind where 
     13import Pugs.Internals 
     14import Pugs.AST 
     15import Pugs.Types 
    1616 
    1717type MaybeError a = Either String a 

  • src/Pugs/Class.hs

    r1464 r2009  
    1212-} 
    1313 
    14 module Class where 
     14module Pugs.Class where 
    1515import AST 
    1616import Internals 

  • src/Pugs/Compat.hs

    r1848 r2009  
    1515#include "pugs_config.h" 
    1616 
    17 module Compat ( 
     17module Pugs.Compat ( 
    1818    createLink, 
    1919    createSymbolicLink, 

  • src/Pugs/Compile.hs

    r1545 r2009  
    1010-} 
    1111 
    12 module Compile where 
    13 import Compile.Pugs (genPugs) 
    14 import Compile.Parrot (genPIR) 
    15 import Compile.Haskell (genGHC) 
     12module Pugs.Compile where 
     13import Pugs.Compile.Pugs (genPugs) 
     14import Pugs.Compile.Parrot (genPIR) 
     15import Pugs.Compile.Haskell (genGHC) 
    1616 
    1717compile "Haskell" = genGHC 

  • src/Pugs/Compile/Haskell.hs

    r1544 r2009  
    11{-# OPTIONS_GHC -fglasgow-exts -fth -cpp #-} 
    22 
    3 module Compile.Haskell where 
     3module Pugs.Compile.Haskell where 
    44 
    55#undef PUGS_HAVE_TH 
    … …  
    99#else 
    1010 
    11 import Internals 
     11import Pugs.Internals 
    1212import Language.Haskell.TH as TH 
    13 import AST 
    14 import Run 
    15 import Prim 
     13import Pugs.AST 
     14import Pugs.Run 
     15import Pugs.Prim 
    1616 
    1717genGHC exp = runQ [d| mainCC = runComp $(compile exp) |] >>= \str -> return . unlines $ 

  • src/Pugs/Compile/Parrot.hs

    r1765 r2009  
    11{-# OPTIONS_GHC -fglasgow-exts #-} 
    22 
    3 module Compile.Parrot where 
    4 import Internals 
    5 import Pretty 
    6 import AST 
     3module Pugs.Compile.Parrot where 
     4import Pugs.Internals 
     5import Pugs.Pretty 
     6import Pugs.AST 
    77import Data.HashTable 
    88import Text.PrettyPrint 
    … …  
    1111-- XXX and maybe TH-based AST combinators 
    1212 
    13 genPIR :: (Compile.Parrot.Compile x, Monad m) => x -> m String 
     13genPIR :: (Pugs.Compile.Parrot.Compile x, Monad m) => x -> m String 
    1414genPIR exp = return . unlines $ 
    1515    [ "#!/usr/bin/env parrot" 

  • src/Pugs/Compile/Parrot/AST.hs

    r1458 r2009  
    11{-# OPTIONS_GHC -cpp -fglasgow-exts #-} 
    22 
    3 module Compile.Parrot where 
     3module Pugs.Compile.Parrot where 
    44 
    55data ParrotContext 

  • src/Pugs/Compile/Pugs.hs

    r1458 r2009  
    11{-# OPTIONS_GHC -fglasgow-exts #-} 
    22 
    3 module Compile.Pugs where 
    4 import Internals 
     3module Pugs.Compile.Pugs where 
     4import Pugs.Internals 
    55 
    66genPugs :: (Show a, Monad m) => a -> m String 
    … …  
    88    [ "{-# OPTIONS_GHC -fglasgow-exts -fno-warn-unused-imports -fno-warn-unused-binds -O #-}" 
    99    , "module MainCC where" 
    10     , "import Run" 
    11     , "import AST" 
    12     , "import Internals" 
     10    , "import Pugs.Run" 
     11    , "import Pugs.AST" 
     12    , "import Pugs.Internals" 
    1313    , "" 
    1414    , "mainCC = runAST $ " ++ show exp 

  • src/Pugs/Cont.hs

    r1458 r2009  
    1010-} 
    1111 
    12 module Cont ( 
     12module Pugs.Cont ( 
    1313    callCC, shift, reset, shiftT, resetT, 
    1414    module Control.Monad.Cont, 

  • src/Pugs/Context.hs

    r1875 r2009  
    1010-} 
    1111 
    12 module Context where 
    13 import Internals 
     12module Pugs.Context where 
     13import Pugs.Internals 
    1414 
    1515type Cxt = String 

  • src/Pugs/Embed.hs

    r1458 r2009  
    1010-} 
    1111 
    12 module Embed ( 
    13     module Embed.Perl5, 
     12module Pugs.Embed ( 
     13    module Pugs.Embed.Perl5, 
     14    -- module Pugs.Embed.Haskell 
     15    -- module Pugs.Embed.Parrot 
     16    -- module Pugs.Embed.Ponie 
    1417) where 
    15 import Embed.Perl5 
    16 -- import Embed.Haskell 
    17 -- import Embed.Parrot 
    18 -- import Embed.Ponie 
     18import Pugs.Embed.Perl5 
     19-- import Pugs.Embed.Haskell 
     20-- import Pugs.Embed.Parrot 
     21-- import Pugs.Embed.Ponie 
    1922 

  • src/Pugs/Embed/Perl5.hs

    r1458 r2009  
    55 
    66#ifndef PUGS_EMBED_PERL5 
    7 module Embed.Perl5 where 
     7module Pugs.Embed.Perl5 where 
    88 
    99type PerlInterpreter = () 

  • src/Pugs/Eval.hs

    r1996 r2009  
    1313-} 
    1414 
    15 module Eval where 
    16 import Internals 
     15module Pugs.Eval where 
     16import Pugs.Internals 
    1717import Prelude hiding ( exp ) 
    1818import qualified Data.Map as Map 
    1919 
    20 import AST 
    21 import Junc 
    22 import Bind 
    23 import Prim 
    24 import Context 
    25 import Monads 
    26 import Pretty 
    27 import Types 
    28 import qualified Types.Hash as Hash 
    29 import qualified Types.Array as Array 
     20import Pugs.AST 
     21import Pugs.Junc 
     22import Pugs.Bind 
     23import Pugs.Prim 
     24import Pugs.Context 
     25import Pugs.Monads 
     26import Pugs.Pretty 
     27import Pugs.Types 
     28import qualified Pugs.Types.Hash as Hash 
     29import qualified Pugs.Types.Array as Array 
    3030 
    3131emptyEnv :: (MonadIO m) => Pad -> m Env 

  • src/Pugs/External.hs

    r1885 r2009  
    1010-} 
    1111 
    12 module External where 
    13 import Internals 
    14 import AST 
    15 import External.Haskell (externalizeHaskell, loadHaskell) 
     12module Pugs.External where 
     13import Pugs.Internals 
     14import Pugs.AST 
     15import Pugs.External.Haskell (externalizeHaskell, loadHaskell) 
    1616 
    1717externalize :: String -> Exp -> IO String 

  • src/Pugs/External/C.hs

    r1427 r2009  
    11{-# OPTIONS_GHC -fglasgow-exts -cpp -O #-} 
    22 
    3 module External.C where 
    4 import Internals 
    5 import Internals.RuntimeLoader 
     3module Pugs.External.C where 
     4import Pugs.Internals 
     5import Pugs.Internals.RuntimeLoader 
    66 

  • src/Pugs/External/Haskell.hs

    r1885 r2009  
    1 {-# OPTIONS_GHC -fglasgow-exts -fth -cpp -package plugins -package hi #-} 
     1{-# OPTIONS_GHC -fglasgow-exts -fth -cpp -package plugins #-} 
    22 
    3 module External.Haskell where 
    4 import AST 
     3module Pugs.External.Haskell where 
     4import Pugs.AST 
     5import Pugs.Internals 
    56 
    67#undef PUGS_HAVE_TH 
    … …  
    1314#else 
    1415 
    15 import Internals 
    1616import Language.Haskell.TH as TH 
    1717import Language.Haskell.Parser 

  • src/Pugs/External/Haskell/DynamicLoader.hs

    r1458 r2009  
    1414-- 
    1515---------------------------------------------------------------------------- 
    16 module External.Haskell.DynamicLoader (DynamicModule, 
     16module Pugs.External.Haskell.DynamicLoader (DynamicModule, 
    1717                                    dm_path, 
    1818                                    DynamicPackage, 

  • src/Pugs/External/Haskell/NameLoader.hs

    r1458 r2009  
    1414-- 
    1515---------------------------------------------------------------------------- 
    16 module External.Haskell.NameLoader (Module, LoadedModule, 
     16module Pugs.External.Haskell.NameLoader (Module, LoadedModule, 
    1717                                 ModuleType(..), 
    1818                                 setEnvironment, 

  • src/Pugs/External/Haskell/PathLoader.hs

    r1458 r2009  
    1414-- 
    1515---------------------------------------------------------------------------- 
    16 module External.Haskell.PathLoader (LoadedModule, 
     16module Pugs.External.Haskell.PathLoader (LoadedModule, 
    1717                                 ModuleType (..), 
    1818                                 setBasePath, 

  • src/Pugs/Help.hs

    r1978 r2009  
    1616#include "pugs_version.h" 
    1717 
    18 module Help (printInteractiveHelp, printCommandLineHelp, 
     18module Pugs.Help (printInteractiveHelp, printCommandLineHelp, 
    1919             banner, versnum, version, revnum, 
    2020             copyright, disclaimer, intro) where 

  • src/Pugs/Internals.hs

    r1734 r2009  
    1414-} 
    1515 
    16 module Internals ( 
     16module Pugs.Internals ( 
    1717    module UTF8, 
    1818    module Unicode, 
    19     module Cont, 
    20     module Embed, 
    21     module Compat, 
     19    module Pugs.Cont, 
     20    module Pugs.Embed, 
     21    module Pugs.Compat, 
    2222    module RRegex, 
    2323    module RRegex.Syntax, 
    24     module Rule.Pos, 
     24    module Pugs.Rule.Pos, 
    2525    module Data.Dynamic, 
    2626    module Data.Unique, 
    … …  
    6666import UTF8 
    6767import Unicode 
    68 import Cont 
    69 import Embed 
    70 import Compat 
     68import Pugs.Cont 
     69import Pugs.Embed 
     70import Pugs.Compat 
    7171import RRegex 
    7272import RRegex.Syntax 
    … …  
    110110import Data.Map (Map) 
    111111import Debug.Trace 
    112 import Rule.Pos 
     112import Pugs.Rule.Pos 
    113113 
    114114-- Instances. 

  • src/Pugs/Junc.hs

    r1588 r2009  
    1010-} 
    1111 
    12 module Junc where 
    13 import Internals 
    14 import AST 
     12module Pugs.Junc where 
     13import Pugs.Internals 
     14import Pugs.AST 
    1515import qualified Data.Set as Set 
    1616 

  • src/Pugs/Lexer.hs

    r1878 r2009  
    1111-} 
    1212 
    13 module Lexer where 
    14 import Internals 
    15 import AST 
    16 import Rule 
    17 import Rule.Language 
    18 import qualified Rule.Token as P 
     13module Pugs.Lexer where 
     14import Pugs.Internals 
     15import Pugs.AST 
     16import Pugs.Rule 
     17import Pugs.Rule.Language 
     18import qualified Pugs.Rule.Token as P 
    1919 
    2020type RuleParser a = GenParser Char Env a 

  • src/Pugs/Monads.hs

    r1896 r2009  
    1010-} 
    1111 
    12 module Monads where 
    13 import Internals 
    14 import AST 
    15 import Context 
     12module Pugs.Monads where 
     13import Pugs.Internals 
     14import Pugs.AST 
     15import Pugs.Context 
    1616 
    1717enterLex :: Pad -> Eval a -> Eval a 

  • src/Pugs/Parser.hs

    r2005 r2009  
    1111-} 
    1212 
    13 module Parser where 
    14 import Internals 
    15 import AST 
    16 import Types.Code as Code 
    17 import Help 
    18 import Lexer 
    19 import Rule 
    20 import Rule.Expr 
    21 import Rule.Error 
     13module Pugs.Parser where 
     14import Pugs.Internals 
     15import Pugs.AST 
     16import Pugs.Types.Code as Code 
     17import Pugs.Help 
     18import Pugs.Lexer 
     19import Pugs.Rule 
     20import Pugs.Rule.Expr