diff --git a/Hidden/ParseRegexStr.hs b/Hidden/ParseRegexStr.hs
--- a/Hidden/ParseRegexStr.hs
+++ b/Hidden/ParseRegexStr.hs
@@ -10,15 +10,17 @@
 
 import Hidden.RegexPRTypes  ( RegexSrcParser, RegexAction(..),
                               reverseRegexAction,
-			      getBR, modifyBR, isModeI, setModeI,
+			      getBR, modifyBR,
+			      isModeI, isModeM, isModeX, setMode,
 			      runRegexSrcParser )
 import Hidden.ParseLib( runParse, spot, token, mplus, mzero, tokens,
                         list, greedyList, optional, endOfInput )
 import Control.Monad.State( liftM )
-import Hidden.Tools		( isSymbol )
-import Data.Char		( isAlphaNum, isAlpha, isDigit, toUpper, toLower )
+import Hidden.Tools		( isSymbol, (|||) )
+import Data.Char		( isAlphaNum, isAlpha, isDigit, isSpace,
+                                  toUpper, toLower )
 import Hidden.SrcRegActList
-  ( plusesList, oneCharList, backSlashesList, parensesList )
+  ( plusesList, oneCharList, backSlashesList, parensesList, charClassList )
 
 parseRegexStr :: String -> [RegexAction]
 parseRegexStr
@@ -68,17 +70,28 @@
     `mplus`
     do { token '['; isNotNot <- optional (token '^') >>= return . null;
          cl <- parseCharList; token ']';
-         return $ Select $ flip (if isNotNot then elem else notElem) cl }
+         return $ Select $ (if isNotNot then id else (not.)) cl }
     `mplus`
     do { i <- getBR; token '('; modifyBR (+1); ras <- parseTokensOr; token ')';
          return $ Note i ras }
     `mplus`
-    do { tokens "(?"; token 'i'; token ')'; setModeI True; return NopRegex }
+    do { tokens "(?"; list parseMode >>= mapM_ (uncurry setMode); token ')';
+	 return NopRegex }
     `mplus`
-    do { tokens "(?"; token 'i'; token ':';
-         setModeI True; ras <- parseTokensOr; setModeI False;
-         token ')'; return $ Parens ras }
+    do { tokens "(?";
+         modes <- list parseMode;
+	 mapM_ (uncurry setMode) modes;
+	 token ':';
+         ras <- parseTokensOr;
+	 mapM_ (\(m,b) -> setMode m $ not b) modes;
+	 token ')';
+	 return $ Parens ras }
     `mplus`
+    do { m <- isModeM;
+         if m then token '.' >> return (Select $ const True) else mzero }
+    `mplus`
+    do { x <- isModeX; if x then parseTokenX else mzero }
+    `mplus`
     parseOneChar oneCharList
     `mplus`
     parseBackSlashes backSlashesList
@@ -93,6 +106,16 @@
                                                 $ [toUpper c, toLower c] }
 	    else do { c <- spot isAlpha; return $ Select (==c) }
 
+parseMode :: RegexSrcParser (Char, Bool)
+parseMode = do b <- optional (token '-') >>= return . null
+               spot (flip elem "imx") >>= return . flip (,) b
+
+parseTokenX :: RegexSrcParser RegexAction
+parseTokenX = do { spot isSpace; return NopRegex }
+              `mplus`
+	      do { token '#'; c <- list $ spot (/='\n'); token '\n';
+	           return $ Comment c }
+
 parsePluses ::
   [ (String, RegexAction -> RegexAction) ] ->
 				RegexSrcParser (RegexAction -> RegexAction)
@@ -114,10 +137,14 @@
 					     token ')'
 					     return $ act ras)
 
-parseCharList :: RegexSrcParser String
-parseCharList =
-  liftM concat $ greedyList
-    ((parseChar >>= return . (:[])) `mplus` parseCharArea)
-  where parseChar = spot isAlphaNum `mplus` ( token '\\' >> spot isSymbol )
-        parseCharArea = do { b <- parseChar; token '-'; e <- parseChar;
-			     return [b..e] }
+parseCharList :: RegexSrcParser (Char -> Bool)
+parseCharList = do
+  cl <- greedyList (parseChar `mplus` parseCharArea `mplus` parseCharClass)
+  return $ \c -> or $ zipWith ($) cl (repeat c)
+  where parseChar = (spot isAlphaNum `mplus` (token '\\' >> spot isSymbol))
+                                              >>= return . (==)
+        parseCharArea = do { b <- spot isAlphaNum; token '-'; e <- spot isAlphaNum;
+			     return $ flip elem [b..e] }
+	parseCharClass = foldr mplus mzero $
+	                   map (\(s, p) -> tokens ("[:"++s++":]") >> return p) charClassList
+	-- tokens "[:alnum:]" >> return isAlphaNum
diff --git a/Hidden/RegexPRTypes.hs b/Hidden/RegexPRTypes.hs
--- a/Hidden/RegexPRTypes.hs
+++ b/Hidden/RegexPRTypes.hs
@@ -9,7 +9,9 @@
 , getBR
 , modifyBR
 , isModeI
-, setModeI
+, isModeM
+, isModeX
+, setMode
 , runRegexSrcParser
 , RegexAction(..)
 
@@ -22,7 +24,9 @@
 import Hidden.ParseLib( Parse, runParse )
 import Control.Monad.State( StateT, runStateT, gets, modify )
 import Control.Monad.Reader( ReaderT(runReaderT) )
-import Hidden.Tools( modifySnd, modifyFst, first, modifyFirst )
+import Hidden.Tools( modifySnd, modifyFst,
+                     first, second, third,
+		     modifyFirst, modifySecond, modifyThird )
 
 type RegexResult = ( String, (String, String) )
 type MatchList   = [ (Int, String) ]
@@ -37,10 +41,14 @@
 getBR    = gets fst
 modifyBR :: (Int -> Int) -> RegexSrcParser ()
 modifyBR = modify . modifyFst
-setModeI :: Bool -> RegexSrcParser ()
-setModeI = modify . modifySnd . modifyFirst . const
-isModeI :: RegexSrcParser Bool
-isModeI = gets $ first . snd
+setMode :: Char -> Bool -> RegexSrcParser ()
+setMode 'i' = modify . modifySnd . modifyFirst  . const
+setMode 'm' = modify . modifySnd . modifySecond . const
+setMode 'x' = modify . modifySnd . modifyThird  . const
+isModeI, isModeM, isModeX :: RegexSrcParser Bool
+isModeI = gets $ first  . snd
+isModeM = gets $ second . snd
+isModeX = gets $ third  . snd
 runRegexSrcParser :: RegexSrcParser a -> Parse Char (a, (Int,(Bool,Bool,Bool)))
 runRegexSrcParser = flip runStateT (1, (False, False, False))
 
diff --git a/Hidden/SrcRegActList.hs b/Hidden/SrcRegActList.hs
--- a/Hidden/SrcRegActList.hs
+++ b/Hidden/SrcRegActList.hs
@@ -8,10 +8,13 @@
 , oneCharList
 , backSlashesList
 , parensesList
+, charClassList
 ) where
 
 import Hidden.RegexPRTypes( RegexAction(..), reverseRegexAction )
-import Data.Char( isAlphaNum, isDigit )
+import Hidden.Tools( (&&&), isSymbol )
+import Data.Char( isAlphaNum, isAlpha, isUpper, isLower,
+                  isDigit, isHexDigit, isSpace, isPrint, isControl )
 
 plusesList :: [ (String, RegexAction -> RegexAction) ]
 plusesList = [
@@ -65,6 +68,21 @@
  , ( "?=",  Still                                                       )
  , ( "?!",  Still . (:[]) . RegActNot                                   )
  , ( "?:",  Parens                                                      )
+ ]
+
+charClassList :: [ (String, Char -> Bool) ]
+charClassList = [
+   ( "alnum", isAlphaNum                 )
+ , ( "alpha", isAlpha                    )
+ , ( "cntrl", isControl                  )
+ , ( "digit", isDigit                    )
+ , ( "graph", isPrint &&& (not.) isSpace )
+ , ( "lower", isLower                    )
+ , ( "print", isPrint                    )
+ , ( "punct", isSymbol                   )
+ , ( "space", isSpace                    )
+ , ( "upper", isUpper                    )
+ , ( "xdigit", isHexDigit                )
  ]
 
 regexOr :: [[RegexAction]] -> RegexAction
diff --git a/Hidden/TestMain.hs b/Hidden/TestMain.hs
--- a/Hidden/TestMain.hs
+++ b/Hidden/TestMain.hs
@@ -140,4 +140,14 @@
  , Just ( ("abCde", ("d", "fg")), [] )  ~=? matchRegexPR "ab(?i)cDe" "dabCdefg"
  , Just ( ("aBcdE", ("", "")), [] )     ~=? matchRegexPR "a(?i:bC)dE" "aBcdE"
  , Nothing                              ~=? matchRegexPR "a(?i:bC)dE" "aBcde"
+ , Just ( ("abcDe", ("", "")), [] )     ~=?
+     matchRegexPR "a(?i)bC(?-i)De" "abcDe"
+ , Nothing                              ~=?
+     matchRegexPR "a(?i)bC(?-i)De" "abcdE"
+ , Just ( ("abc\nde", ("", "")), [] )   ~=? matchRegexPR "(?m).+" "abc\nde"
+ , Just ( ("Abc", ("", "\nde")), [] )   ~=? matchRegexPR "(?im-m)a.+" "Abc\nde"
+ , Just ( ("bcd", ("a", "e")), [] )     ~=?
+     matchRegexPR "(?x)# hello\n# goodbye\n\t\tbcd\n\n" "abcde"
+ , Just ( ("bcd", ("a", "e")), [] )     ~=? matchRegexPR "b[[:alnum:]]d" "abcde"
+ , Just ( ("90af", ("", "g")), [] )    ~=? matchRegexPR "[[:xdigit:]]+" "90afg"
  ]
diff --git a/Hidden/Tools.hs b/Hidden/Tools.hs
--- a/Hidden/Tools.hs
+++ b/Hidden/Tools.hs
@@ -8,8 +8,14 @@
 , modifyFst
 , modifySnd
 , first
+, second
+, third
 , modifyFirst
+, modifySecond
+, modifyThird
 , guardEqual
+, (|||)
+, (&&&)
 ) where
 
 import Control.Monad.State( StateT(StateT, runStateT), lift, MonadTrans )
@@ -19,9 +25,6 @@
 isSymbol :: Char -> Bool
 isSymbol = (not . isAlphaNum) &&& (not . isSpace) &&& isPrint
 
-(&&&) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
-(p1 &&& p2) x = p1 x && p2 x
-
 modifyFst :: (a -> c) -> (a, b) -> (c, b)
 modifyFst f (x, y) = (f x, y)
 modifySnd :: (b -> c) -> (a, b) -> (a, c)
@@ -30,8 +33,21 @@
 guardEqual :: (MonadPlus m, Eq a) => m a -> m a -> m ()
 guardEqual m1 m2 = do { x <- m1; y <- m2; guard (x == y) }
 
-first :: (a,b,c) -> a
-first (x,_,_) = x
+first  :: (a, b, c) -> a
+first  (x, _, _) = x
+second :: (a, b, c) -> b
+second (_, y, _) = y
+third  :: (a, b, c) -> c
+third  (_, _, z) = z
 
-modifyFirst :: (a -> d) -> (a, b, c) -> (d, b, c)
-modifyFirst f (x, y, z) = (f x, y, z)
+modifyFirst  :: (a -> d) -> (a, b, c) -> (d, b, c)
+modifyFirst  f (x, y, z) = (f x, y, z)
+modifySecond :: (b -> d) -> (a, b, c) -> (a, d, c)
+modifySecond f (x, y, z) = (x, f y, z)
+modifyThird  :: (c -> d) -> (a, b, c) -> (a, b, d)
+modifyThird  f (x, y, z) = (x, y, f z)
+
+(|||),(&&&) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
+(p1 ||| p2) x = p1 x || p2 x
+(p1 &&& p2) x = p1 x && p2 x
+
diff --git a/regexpr.cabal b/regexpr.cabal
--- a/regexpr.cabal
+++ b/regexpr.cabal
@@ -1,5 +1,5 @@
 Name:		regexpr
-Version:	0.1.5
+Version:	0.1.6
 License:	GPL
 License-File:	LICENSE
 Author:		Yoshikuni Jujo <PAF01143@nifty.ne.jp>
@@ -18,7 +18,6 @@
   Regular expression library like Perl/Ruby's regular expression.
   This package has a module RegexPR.
   And RegexPR export function matchRegexPR and gsubRegexPR.
-  | some
   matchRegexPR :: String -> Maybe ((String, (String, String)), [(Int, String)]),
   gsubRegexPR :: String -> String -> String.
   Examples: matchRegexPR "ab(cde)f\\1" "kkkabcdefcdefgh" =>