pygments.rb-jruby 0.5.4

data/vendor/pygments-main/tests/examplefiles/Sudoku.lhs

@@ -0,0 +1,382 @@
+% Copyright 2005 Brian Alliet
+
+\documentclass[11pt]{article}
+\usepackage{palatino}
+\usepackage{fullpage}
+\usepackage{parskip}
+\usepackage{lhs}
+
+\begin{document}
+
+\title{Sudoku Solver}
+\author{Brian Alliet}
+\maketitle
+
+\ignore{
+\begin{code}
+module Sudoku (
+    Sudoku,
+    makeSudoku, solve, eliminate, analyze, backtrack,
+    main
+    ) where
+
+import Array
+import Monad
+import List (union,intersperse,transpose,(\\),nub,nubBy)
+\end{code}
+}
+
+\section{Introduction}
+
+This Haskell module implements a solver for Sudoku~\footnote{http://en.wikipedia.org/wiki/Sudoku} puzzles. It can solve
+any Sudoku puzzle, even those that require backtracking.
+
+\section{Data Types}
+
+\begin{code}
+data CellState a = Known a | Unknown [a] | Impossible deriving Eq
+\end{code}
+
+Each cell in a Sudoku grid can be in one of three states: ``Known'' if it has a known correct value~\footnote{Actually
+this doesn't always means it is correct. While we are in the backtracking stage we make our guesses ``Known''.},
+``Unknown'' if there is still more than one possible correct value, or ``Impossible'' if there is no value that can
+possibly fit the cell. Sudoku grids with ``Impossible'' cells are quickly discarded by the {\tt solve} function.
+
+\begin{code}
+type Coords = (Int,Int)
+type Grid a = Array Coords (CellState a)
+newtype Sudoku a = Sudoku { unSudoku :: Grid a } deriving Eq
+\end{code}
+
+We represent a Sudoku grid as an Array indexed by integer coordinates. We additionally define a newtype wrapper for the
+grid. The smart constructor, {\tt makeSudoku} verifies some invariants before creating the Sudoku value. All the public
+API functions operate on the Sudoku type.
+
+\begin{code}
+instance Show a => Show (Sudoku a) where showsPrec p = showParen (p>0) . showsGrid . unSudoku
+instance Show a => Show (CellState a) where showsPrec _ = showsCell
+\end{code}
+
+We define {\tt Show} instances for the above types.
+
+\section{Internal Functions}
+
+\begin{code}
+size :: Grid a -> Int
+size = (+1).fst.snd.bounds
+\end{code}
+
+{\tt size} returns the size (the width, height, and number of subboxes) for a Sudoku grid. We ensure Grid's are always
+square and indexed starting at $(0,0)$ so simply incrementing either of the array's upper bounds is correct.
+
+\begin{code}
+getRow,getCol,getBox :: Grid a -> Int -> [(Coords,CellState a)]
+getRow grid r = [let l = (r,c) in (l,grid!l)|c <- [0..size grid - 1]]
+getCol grid c = [let l = (r,c) in (l,grid!l)|r <- [0..size grid - 1]]
+getBox grid b = [let l = (r,c) in (l,grid!l)|r <- [boxR..boxR+boxN-1],c <- [boxC..boxC+boxN-1]]
+    where
+        boxN = intSqrt (size grid); boxR = b `quot` boxN * boxN; boxC = b `rem`  boxN * boxN
+
+getBoxOf :: Grid a -> Coords -> [(Coords,CellState a)]
+getBoxOf grid (r,c) = grid `getBox` ((r `quot` boxN * boxN) + (c `quot` boxN))
+    where boxN = intSqrt (size grid)
+\end{code}
+
+{\tt getRow}, {\tt getCol}, and {\tt getBox} return the coordinates and values of the cell in row, column, or box
+number {\tt n}, {\tt r}, or {\tt b}.
+
+\begin{code}
+getNeighbors :: Eq a => Grid a -> Coords -> [(Coords,CellState a)]
+getNeighbors grid l@(r,c) = filter ((/=l).fst) 
+                          $ foldr (union.($grid)) [] 
+                          [(`getRow`r),(`getCol`c),(`getBoxOf`l)]
+\end{code}
+
+{\tt getNeighbors} returns the coordinates and values of all the neighbors of this cell.
+
+\begin{code}
+impossible :: Eq a => Grid a -> Coords -> [a]
+impossible grid l = map snd $ justKnowns $ grid `getNeighbors` l
+\end{code}
+
+{\tt impossible} returns a list of impossible values for a given cell. The impossible values consist of the values any
+``Known'' neighbors.
+
+\begin{code}
+justUnknowns :: [(Coords,CellState a)] -> [(Coords,[a])]
+justUnknowns = foldr (\c -> case c of (p,Unknown xs) -> ((p,xs):); _ -> id) []
+
+justKnowns :: [(Coords,CellState a)] -> [(Coords,a)]
+justKnowns = foldr (\c -> case c of (p,Known x) -> ((p,x):); _ -> id) []
+\end{code}
+
+{\tt justUnknowns} and {\tt justKnowns} return only the Known or Unknown values (with the constructor stripped off)
+from a list of cells.
+
+\begin{code}
+updateGrid :: Grid a -> [(Coords,CellState a)] -> Maybe (Grid a)
+updateGrid _ [] = Nothing
+updateGrid grid xs = Just $ grid // nubBy (\(x,_) (y,_) -> x==y) xs
+\end{code}
+
+{\tt updateGrid} applies a set of updates to a grid and returns the new grid only if it was updated.
+
+\section{Public API}
+
+\begin{code}
+makeSudoku :: (Num a, Ord a, Enum a) => [[a]] -> Sudoku a
+makeSudoku xs
+    | not (all ((==size).length) xs) = error "error not a square"
+    | (intSqrt size)^(2::Int) /= size = error "error dims aren't perfect squares"
+    | any (\x -> x < 0 || x > fromIntegral size) (concat xs) = error "value out of range"
+    | otherwise = Sudoku (listArray ((0,0),(size-1,size-1)) states)
+    where
+        size = length xs
+        states = map f (concat xs)
+        f 0 = Unknown [1..fromIntegral size]
+        f x = Known x
+\end{code}
+
+{\tt makeSudoku} makes a {\tt Sudoku} value from a list of numbers. The given matrix must be square and have dimensions
+that are a perfect square. The possible values for each cell range from 1 to the dimension of the square with ``0''
+representing unknown values.\footnote{The rest of the code doesn't depend on any of this weird ``0'' is unknown
+representation. In fact, it doesn't depend on numeric values at all. ``0'' is just used here because it makes
+representing grids in Haskell source code easier.}
+
+\begin{code}
+eliminate :: Eq a => Sudoku a -> Maybe (Sudoku a)
+eliminate (Sudoku grid) = fmap Sudoku $ updateGrid grid changes >>= sanitize
+    where
+        changes = concatMap findChange $ assocs grid
+        findChange (l,Unknown xs) 
+            = map ((,) l) 
+            $ case filter (not.(`elem`impossible grid l)) xs of
+                [] -> return Impossible
+                [x] -> return $ Known x
+                xs'
+                    | xs' /= xs -> return $ Unknown xs'
+                    | otherwise -> mzero
+        findChange _ = mzero
+        sanitize grid = return $ grid // [(l,Impossible) | 
+            (l,x) <- justKnowns changes, x `elem` impossible grid l]
+\end{code}
+
+The {\tt eliminate} phase tries to remove possible choices for ``Unknowns'' based on ``Known'' values in the same row,
+column, or box as the ``Unknown'' value. For each cell on the grid we find its ``neighbors'', that is, cells in the
+same row, column, or box. Out of those neighbors we get a list of all the ``Known'' values. We can eliminate all of
+these from our list of candidates for this cell. If we're lucky enough to eliminate all the candidates but one we have
+a new ``Known'' value. If we're unlucky enough to have eliminates {\bf all} the possible candidates we have a new
+``Impossible'' value.
+
+After iterating though every cell we make one more pass looking for conflicting changes. {\tt sanitize} marks cells as
+``Impossible'' if we have conflicting ``Known'' values.
+
+\begin{code}
+analyze :: Eq a => Sudoku a -> Maybe (Sudoku a)
+analyze (Sudoku grid) = fmap Sudoku $ updateGrid grid $ nub [u |
+            f <- map ($grid) [getRow,getCol,getBox],
+            n <- [0..size grid - 1],
+            u <- unique (f n)]
+    where
+        unique xs = foldr f [] $ foldr (union.snd) [] unknowns \\ map snd (justKnowns xs)
+            where
+                unknowns = justUnknowns xs
+                f c = case filter ((c`elem`).snd) unknowns of
+                    [(p,_)] -> ((p,Known c):)
+                    _ -> id
+\end{code}
+
+The {\tt analyze} phase tries to turn ``Unknowns'' into ``Knowns'' when a certain ``Unknown'' is the only cell that
+contains a value needed in a given row, column, or box. We apply each of the functions {\tt getRow}, {\tt getCol}, and
+{\tt getBox} to all the indices on the grid, apply {\tt unique} to each group, and update the array with the
+results. {\tt unique}  gets a list of all  the unknown cells in the group and finds all the unknown values in each of
+those cells. Each of these values are iterated though looking for a value that is only contained in one cell. If such a
+value is found the cell containing it must be that value.
+
+\begin{code}
+backtrack :: (MonadPlus m, Eq a) => Sudoku a -> m (Sudoku a)
+backtrack (Sudoku grid) = case (justUnknowns (assocs grid)) of
+    [] -> return $ Sudoku grid
+    ((p,xs):_) -> msum $ map (\x -> solve $ Sudoku $ grid // [(p,Known x)]) xs
+\end{code}
+
+Sometimes the above two phases still aren't enough to solve a puzzle. For these rare puzzles backtracking is required.
+We attempt to solve the puzzle by replacing the first ``Unknown'' value with each of the candidate values and solving
+the resulting puzzles. Hopefully at least one of our choices will result in a solvable puzzle.
+
+We could actually solve any puzzle using backtracking alone, although this would be very inefficient. The above
+functions simplify most puzzles enough that the backtracking phase has to do hardly any work.
+
+\begin{code}
+solve :: (MonadPlus m, Eq a) => Sudoku a -> m (Sudoku a)
+solve sudoku = 
+    case eliminate sudoku of
+        Just new 
+            | any (==Impossible) (elems (unSudoku new))-> mzero
+            | otherwise -> solve new
+        Nothing -> case analyze sudoku of
+            Just new -> solve new
+            Nothing -> backtrack sudoku
+\end{code}
+
+{\tt solve} glues all the above phases together. First we run the {\tt eliminate} phase. If that found the puzzle  to
+be unsolvable we abort immediately. If {\tt eliminate} changed the grid we go though the {\tt eliminate} phase again
+hoping to eliminate more. Once {\tt eliminate} can do no more work we move on to the {\tt analyze} phase. If this
+succeeds in doing some work we start over again with the {\tt eliminate} phase. Once {\tt analyze} can do no more work
+we have no choice but to resort to backtracking. (However in most cases backtracking won't actually do anything because
+the puzzle is already solved.)
+
+\begin{code}
+showsCell :: Show a => CellState a -> ShowS
+showsCell (Known x) = shows x
+showsCell (Impossible) = showChar 'X'
+showsCell (Unknown xs) = \rest -> ('(':) 
+                       $ foldr id (')':rest)
+                       $ intersperse (showChar ' ')
+                       $ map shows xs
+\end{code}
+
+{\tt showCell} shows a cell.
+
+\begin{code}
+showsGrid :: Show a => Grid a -> ShowS
+showsGrid grid = showsTable [[grid!(r,c) | c <- [0..size grid-1]] | r <- [0..size grid-1]]
+\end{code}
+
+{\tt showGrid} show a grid.
+
+\begin{code}
+-- FEATURE: This is pretty inefficient
+showsTable :: Show a => [[a]] -> ShowS
+showsTable xs = (showChar '\n' .) $ showString $ unlines $ map (concat . intersperse " ") xs''
+    where
+        xs' = (map.map) show xs
+        colWidths = map (max 2 . maximum . map length) (transpose xs')
+        xs'' = map (zipWith (\n s -> s ++ (replicate (n - length s) ' ')) colWidths) xs'
+\end{code}
+
+{\tt showsTable} shows a table (or matrix). Every column has the same width so things line up.
+
+\begin{code}
+intSqrt :: Integral a => a -> a
+intSqrt n
+    | n < 0 = error "intSqrt: negative n"
+    | otherwise = f n
+    where
+        f x = if y < x then f y else x
+            where y = (x + (n `quot` x)) `quot` 2
+\end{code}
+
+{\tt intSqrt} is Newton`s Iteration for finding integral square roots.
+
+\ignore{
+\begin{code}
+test :: Sudoku Int
+test = makeSudoku [
+    [0,6,0,1,0,4,0,5,0],
+    [0,0,8,3,0,5,6,0,0],
+    [2,0,0,0,0,0,0,0,1],
+    [8,0,0,4,0,7,0,0,6],
+    [0,0,6,0,0,0,3,0,0],
+    [7,0,0,9,0,1,0,0,4],
+    [5,0,0,0,0,0,0,0,2],
+    [0,0,7,2,0,6,9,0,0],
+    [0,4,0,5,0,8,0,7,0]]
+
+test2 :: Sudoku Int
+test2 = makeSudoku [
+    [0,7,0,0,0,0,8,0,0],
+    [0,0,0,2,0,4,0,0,0],
+    [0,0,6,0,0,0,0,3,0],
+    [0,0,0,5,0,0,0,0,6],
+    [9,0,8,0,0,2,0,4,0],
+    [0,5,0,0,3,0,9,0,0],
+    [0,0,2,0,8,0,0,6,0],
+    [0,6,0,9,0,0,7,0,1],
+    [4,0,0,0,0,3,0,0,0]]
+
+testSmall :: Sudoku Int
+testSmall = makeSudoku [
+    [1,0,0,0,0,0,0,0,0],
+    [0,0,2,7,4,0,0,0,0],
+    [0,0,0,5,0,0,0,0,4],
+    [0,3,0,0,0,0,0,0,0],
+    [7,5,0,0,0,0,0,0,0],
+    [0,0,0,0,0,9,6,0,0],
+    [0,4,0,0,0,6,0,0,0],
+    [0,0,0,0,0,0,0,7,1],
+    [0,0,0,0,0,1,0,3,0]]
+
+testHard :: Sudoku Int
+testHard = makeSudoku [
+    [0,0,0,8,0,2,0,0,0],
+    [5,0,0,0,0,0,0,0,1],
+    [0,0,6,0,5,0,3,0,0],
+    [0,0,9,0,1,0,8,0,0],
+    [1,0,0,0,0,0,0,0,2],
+    [0,0,0,9,0,7,0,0,0],
+    [0,6,1,0,3,0,7,8,0],
+    [0,5,0,0,0,0,0,4,0],
+    [0,7,2,0,4,0,1,5,0]]
+
+testHard2 :: Sudoku Int
+testHard2 = makeSudoku [
+    [3,0,0,2,0,0,9,0,0],
+    [0,0,0,0,0,0,0,0,5],
+    [0,7,0,1,0,4,0,0,0],
+    [0,0,9,0,0,0,8,0,0],
+    [5,0,0,0,7,0,0,0,6],
+    [0,0,1,0,0,0,2,0,0],
+    [0,0,0,3,0,9,0,4,0],
+    [8,0,0,0,0,0,0,0,0],
+    [0,0,6,0,0,5,0,0,7]]
+
+testHW :: Sudoku Int
+testHW = makeSudoku [
+    [0,0,0,1,0,0,7,0,2],    
+    [0,3,0,9,5,0,0,0,0],
+    [0,0,1,0,0,2,0,0,3],
+    [5,9,0,0,0,0,3,0,1],
+    [0,2,0,0,0,0,0,7,0],
+    [7,0,3,0,0,0,0,9,8],
+    [8,0,0,2,0,0,1,0,0],
+    [0,0,0,0,8,5,0,6,0],
+    [6,0,5,0,0,9,0,0,0]]
+
+testTough :: Sudoku Int
+testTough = makeSudoku $ map (map read . words) $ lines $
+ "8 3 0  0 0 0  0 4 6\n"++
+ "0 2 0  1 0 4  0 3 0\n"++
+ "0 0 0  0 0 0  0 0 0\n"++
+ "0 0 2  9 0 6  5 0 0\n"++
+ "1 4 0  0 0 0  0 2 3\n"++
+ "0 0 5  4 0 3  1 0 0\n"++
+ "0 0 0  0 0 0  0 0 0\n"++
+ "0 6 0  3 0 8  0 7 0\n"++
+ "9 5 0  0 0 0  0 6 2\n"
+
+testDiabolical :: Sudoku Int 
+testDiabolical = makeSudoku $ map (map read . words) $ lines $
+  "8 0 0  7 0 1  0 0 2\n"++
+  "0 0 6  0 0 0  7 0 0\n"++
+  "0 1 7  0 0 0  8 9 0\n"++
+  "0 0 0  1 7 3  0 0 0\n"++
+  "7 0 0  0 0 0  0 0 6\n"++
+  "0 0 0  9 5 6  0 0 0\n"++
+  "0 9 5  0 0 0  4 1 0\n"++
+  "0 0 8  0 0 0  5 0 0\n"++
+  "3 0 0  6 0 5  0 0 7\n"
+
+main :: IO ()
+main = do
+    let
+        solve' p = case solve p of
+            [] -> fail $ "couldn't solve: " ++ show p
+            sols -> return sols
+    mapM_ (\p -> solve' p >>= putStrLn.show) [test,test2,testSmall,testHard,testHard2,testHW,testTough,testDiabolical]
+    return ()
+
+\end{code}
+}
+
+\end{document}

data/vendor/pygments-main/tests/examplefiles/addressbook.proto

@@ -0,0 +1,30 @@
+// See README.txt for information and build instructions.
+
+package tutorial;
+
+option java_package = "com.example.tutorial";
+option java_outer_classname = "AddressBookProtos";
+
+message Person {
+  required string name = 1;
+  required int32 id = 2;        // Unique ID number for this person.
+  optional string email = 3;
+
+  enum PhoneType {
+    MOBILE = 0;
+    HOME = 1;
+    WORK = 2;
+  }
+
+  message PhoneNumber {
+    required string number = 1;
+    optional PhoneType type = 2 [default = HOME];
+  }
+
+  repeated PhoneNumber phone = 4;
+}
+
+// Our address book file is just one of these.
+message AddressBook {
+  repeated Person person = 1;
+}

data/vendor/pygments-main/tests/examplefiles/antlr_throws

@@ -0,0 +1 @@
+public f throws a, b, c : x ;

data/vendor/pygments-main/tests/examplefiles/apache2.conf

@@ -0,0 +1,393 @@
+# Based upon the NCSA server configuration files originally by Rob McCool.
+# Changed extensively for the Debian package by Daniel Stone <daniel@sfarc.net>
+# and also by Thom May <thom@debian.org>.
+
+# ServerRoot: The top of the directory tree under which the server's
+# configuration, error, and log files are kept.
+#
+# NOTE!  If you intend to place this on an NFS (or otherwise network)
+# mounted filesystem then please read the LockFile documentation
+# (available at <URL:http://www.apache.org/docs/mod/core.html#lockfile>);
+# you will save yourself a lot of trouble.
+
+ServerRoot "/etc/apache2"
+
+# The LockFile directive sets the path to the lockfile used when Apache
+# is compiled with either USE_FCNTL_SERIALIZED_ACCEPT or
+# USE_FLOCK_SERIALIZED_ACCEPT. This directive should normally be left at
+# its default value. The main reason for changing it is if the logs
+# directory is NFS mounted, since the lockfile MUST BE STORED ON A LOCAL
+# DISK. The PID of the main server process is automatically appended to
+# the filename. 
+
+LockFile /var/lock/apache2/accept.lock
+
+# PidFile: The file in which the server should record its process
+# identification number when it starts.
+
+PidFile /var/run/apache2.pid
+
+# Timeout: The number of seconds before receives and sends time out.
+
+Timeout 300
+
+# KeepAlive: Whether or not to allow persistent connections (more than
+# one request per connection). Set to "Off" to deactivate.
+
+KeepAlive On
+
+# MaxKeepAliveRequests: The maximum number of requests to allow
+# during a persistent connection. Set to 0 to allow an unlimited amount.
+# We recommend you leave this number high, for maximum performance.
+
+MaxKeepAliveRequests 100
+
+# KeepAliveTimeout: Number of seconds to wait for the next request from the
+# same client on the same connection.
+
+KeepAliveTimeout 15
+
+##
+## Server-Pool Size Regulation (MPM specific)
+## 
+
+# prefork MPM
+# StartServers ......... number of server processes to start
+# MinSpareServers ...... minimum number of server processes which are kept spare
+# MaxSpareServers ...... maximum number of server processes which are kept spare
+# MaxClients ........... maximum number of server processes allowed to start
+# MaxRequestsPerChild .. maximum number of requests a server process serves
+<IfModule prefork.c>
+StartServers         5
+MinSpareServers      5
+MaxSpareServers     10
+MaxClients          20
+MaxRequestsPerChild  0
+</IfModule>
+
+# pthread MPM
+# StartServers ......... initial  number of server processes to start
+# MaxClients ........... maximum  number of server processes allowed to start
+# MinSpareThreads ...... minimum  number of worker threads which are kept spare
+# MaxSpareThreads ...... maximum  number of worker threads which are kept spare
+# ThreadsPerChild ...... constant number of worker threads in each server process
+# MaxRequestsPerChild .. maximum  number of requests a server process serves
+<IfModule worker.c>
+StartServers         2
+MaxClients         150 
+MinSpareThreads     25
+MaxSpareThreads     75
+ThreadsPerChild     25
+MaxRequestsPerChild  0
+</IfModule>
+
+# perchild MPM
+# NumServers ........... constant number of server processes
+# StartThreads ......... initial  number of worker threads in each server process
+# MinSpareThreads ...... minimum  number of worker threads which are kept spare
+# MaxSpareThreads ...... maximum  number of worker threads which are kept spare
+# MaxThreadsPerChild ... maximum  number of worker threads in each server process
+# MaxRequestsPerChild .. maximum  number of connections per server process (then it dies)
+<IfModule perchild.c>
+NumServers           5
+StartThreads         5
+MinSpareThreads      5
+MaxSpareThreads     10
+MaxThreadsPerChild  20
+MaxRequestsPerChild  0
+AcceptMutex fcntl
+</IfModule>
+
+User www-data
+Group www-data
+
+# The following directives define some format nicknames for use with
+# a CustomLog directive (see below).
+LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
+LogFormat "%h %l %u %t \"%r\" %>s %b" common
+LogFormat "%{Referer}i -> %U" referer
+LogFormat "%{User-agent}i" agent
+
+
+# Global error log.
+ErrorLog /var/log/apache2/error.log
+
+# Include module configuration:
+Include /etc/apache2/mods-enabled/*.load
+Include /etc/apache2/mods-enabled/*.conf
+
+# Include all the user configurations:
+Include /etc/apache2/httpd.conf
+
+# Include ports listing
+Include /etc/apache2/ports.conf
+
+# Include generic snippets of statements
+Include /etc/apache2/conf.d/[^.#]*
+
+#Let's have some Icons, shall we?
+Alias /icons/ "/usr/share/apache2/icons/"
+<Directory "/usr/share/apache2/icons">
+    Options Indexes MultiViews
+    AllowOverride None
+    Order allow,deny
+    Allow from all
+</Directory>
+
+# Set up the default error docs.
+#
+# Customizable error responses come in three flavors:
+# 1) plain text 2) local redirects 3) external redirects
+#
+# Some examples:
+#ErrorDocument 500 "The server made a boo boo."
+#ErrorDocument 404 /missing.html
+#ErrorDocument 404 "/cgi-bin/missing_handler.pl"
+#ErrorDocument 402 http://www.example.com/subscription_info.html
+#
+
+#
+# Putting this all together, we can Internationalize error responses.
+#
+# We use Alias to redirect any /error/HTTP_<error>.html.var response to
+# our collection of by-error message multi-language collections.  We use 
+# includes to substitute the appropriate text.
+#
+# You can modify the messages' appearance without changing any of the
+# default HTTP_<error>.html.var files by adding the line;
+#
+#   Alias /error/include/ "/your/include/path/"
+#
+# which allows you to create your own set of files by starting with the
+# /usr/local/apache2/error/include/ files and
+# copying them to /your/include/path/, even on a per-VirtualHost basis.
+#
+
+<IfModule mod_negotiation.c>
+<IfModule mod_include.c>
+    Alias /error/ "/usr/share/apache2/error/"
+
+    <Directory "/usr/share/apache2/error">
+        AllowOverride None
+        Options IncludesNoExec
+        AddOutputFilter Includes html
+        AddHandler type-map var
+        Order allow,deny
+        Allow from all
+        LanguagePriority en es de fr
+        ForceLanguagePriority Prefer Fallback
+    </Directory>
+
+    ErrorDocument 400 /error/HTTP_BAD_REQUEST.html.var
+    ErrorDocument 401 /error/HTTP_UNAUTHORIZED.html.var
+    ErrorDocument 403 /error/HTTP_FORBIDDEN.html.var
+    ErrorDocument 404 /error/HTTP_NOT_FOUND.html.var
+    ErrorDocument 405 /error/HTTP_METHOD_NOT_ALLOWED.html.var
+    ErrorDocument 408 /error/HTTP_REQUEST_TIME_OUT.html.var
+    ErrorDocument 410 /error/HTTP_GONE.html.var
+    ErrorDocument 411 /error/HTTP_LENGTH_REQUIRED.html.var
+    ErrorDocument 412 /error/HTTP_PRECONDITION_FAILED.html.var
+    ErrorDocument 413 /error/HTTP_REQUEST_ENTITY_TOO_LARGE.html.var
+    ErrorDocument 414 /error/HTTP_REQUEST_URI_TOO_LARGE.html.var
+    ErrorDocument 415 /error/HTTP_SERVICE_UNAVAILABLE.html.var
+    ErrorDocument 500 /error/HTTP_INTERNAL_SERVER_ERROR.html.var
+    ErrorDocument 501 /error/HTTP_NOT_IMPLEMENTED.html.var
+    ErrorDocument 502 /error/HTTP_BAD_GATEWAY.html.var
+    ErrorDocument 503 /error/HTTP_SERVICE_UNAVAILABLE.html.var
+    ErrorDocument 506 /error/HTTP_VARIANT_ALSO_VARIES.html.var
+
+</IfModule>
+</IfModule>
+
+DirectoryIndex index.html index.cgi index.pl index.php index.xhtml
+
+# UserDir is now a module
+#UserDir public_html
+#UserDir disabled root
+
+#<Directory /home/*/public_html>
+#	AllowOverride FileInfo AuthConfig Limit
+#	Options Indexes SymLinksIfOwnerMatch IncludesNoExec
+#</Directory>
+
+AccessFileName .htaccess
+
+<Files ~ "^\.ht">
+    Order allow,deny
+    Deny from all
+</Files>
+
+UseCanonicalName Off
+
+TypesConfig /etc/mime.types
+DefaultType text/plain
+
+HostnameLookups Off
+
+IndexOptions FancyIndexing VersionSort
+
+AddIconByEncoding (CMP,/icons/compressed.gif) x-compress x-gzip
+
+AddIconByType (TXT,/icons/text.gif) text/*
+AddIconByType (IMG,/icons/image2.gif) image/*
+AddIconByType (SND,/icons/sound2.gif) audio/*
+AddIconByType (VID,/icons/movie.gif) video/*
+
+# This really should be .jpg.
+
+AddIcon /icons/binary.gif .bin .exe
+AddIcon /icons/binhex.gif .hqx
+AddIcon /icons/tar.gif .tar
+AddIcon /icons/world2.gif .wrl .wrl.gz .vrml .vrm .iv
+AddIcon /icons/compressed.gif .Z .z .tgz .gz .zip
+AddIcon /icons/a.gif .ps .ai .eps
+AddIcon /icons/layout.gif .html .shtml .htm .pdf
+AddIcon /icons/text.gif .txt
+AddIcon /icons/c.gif .c
+AddIcon /icons/p.gif .pl .py
+AddIcon /icons/f.gif .for
+AddIcon /icons/dvi.gif .dvi
+AddIcon /icons/uuencoded.gif .uu
+AddIcon /icons/script.gif .conf .sh .shar .csh .ksh .tcl
+AddIcon /icons/tex.gif .tex
+AddIcon /icons/bomb.gif core
+
+AddIcon /icons/back.gif ..
+AddIcon /icons/hand.right.gif README
+AddIcon /icons/folder.gif ^^DIRECTORY^^
+AddIcon /icons/blank.gif ^^BLANKICON^^
+
+
+# This is from Matty J's patch. Anyone want to make the icons?
+#AddIcon /icons/dirsymlink.jpg ^^SYMDIR^^
+#AddIcon /icons/symlink.jpg ^^SYMLINK^^
+
+DefaultIcon /icons/unknown.gif
+
+ReadmeName README.html
+HeaderName HEADER.html
+
+IndexIgnore .??* *~ *# HEADER* RCS CVS *,t
+
+AddEncoding x-compress Z
+AddEncoding x-gzip gz tgz
+
+AddLanguage da .dk
+AddLanguage nl .nl
+AddLanguage en .en
+AddLanguage et .et
+AddLanguage fr .fr
+AddLanguage de .de
+AddLanguage el .el
+AddLanguage it .it
+AddLanguage ja .ja
+AddLanguage pl .po
+AddLanguage ko .ko
+AddLanguage pt .pt
+AddLanguage no .no
+AddLanguage pt-br .pt-br
+AddLanguage ltz .ltz
+AddLanguage ca .ca
+AddLanguage es .es
+AddLanguage sv .se
+AddLanguage cz .cz
+AddLanguage ru .ru
+AddLanguage tw .tw
+AddLanguage zh-tw .tw
+
+LanguagePriority en da nl et fr de el it ja ko no pl pt pt-br ltz ca es sv tw
+
+
+#AddDefaultCharset	ISO-8859-1
+
+AddCharset ISO-8859-1  .iso8859-1  .latin1
+AddCharset ISO-8859-2  .iso8859-2  .latin2 .cen
+AddCharset ISO-8859-3  .iso8859-3  .latin3
+AddCharset ISO-8859-4  .iso8859-4  .latin4
+AddCharset ISO-8859-5  .iso8859-5  .latin5 .cyr .iso-ru
+AddCharset ISO-8859-6  .iso8859-6  .latin6 .arb
+AddCharset ISO-8859-7  .iso8859-7  .latin7 .grk
+AddCharset ISO-8859-8  .iso8859-8  .latin8 .heb	
+AddCharset ISO-8859-9  .iso8859-9  .latin9 .trk
+AddCharset ISO-2022-JP .iso2022-jp .jis
+AddCharset ISO-2022-KR .iso2022-kr .kis
+AddCharset ISO-2022-CN .iso2022-cn .cis
+AddCharset Big5        .Big5       .big5
+# For russian, more than one charset is used (depends on client, mostly):
+AddCharset WINDOWS-1251 .cp-1251   .win-1251
+AddCharset CP866       .cp866
+AddCharset KOI8-r      .koi8-r .koi8-ru
+AddCharset KOI8-ru     .koi8-uk .ua
+AddCharset ISO-10646-UCS-2 .ucs2
+AddCharset ISO-10646-UCS-4 .ucs4
+AddCharset UTF-8       .utf8
+
+AddCharset GB2312      .gb2312 .gb 
+AddCharset utf-7       .utf7
+AddCharset utf-8       .utf8
+AddCharset big5	       .big5 .b5
+AddCharset EUC-TW      .euc-tw	
+AddCharset EUC-JP      .euc-jp
+AddCharset EUC-KR      .euc-kr
+AddCharset shift_jis   .sjis
+
+#AddType application/x-httpd-php .php
+#AddType application/x-httpd-php-source .phps
+
+AddType application/x-tar .tgz
+
+# To use CGI scripts outside /cgi-bin/:
+#
+#AddHandler cgi-script .cgi
+
+# To use server-parsed HTML files
+#
+<FilesMatch "\.shtml(\..+)?$">
+    SetOutputFilter INCLUDES
+</FilesMatch>
+
+# If you wish to use server-parsed imagemap files, use
+#
+#AddHandler imap-file map
+
+BrowserMatch "Mozilla/2" nokeepalive
+BrowserMatch "MSIE 4\.0b2;" nokeepalive downgrade-1.0 force-response-1.0
+BrowserMatch "RealPlayer 4\.0" force-response-1.0
+BrowserMatch "Java/1\.0" force-response-1.0
+BrowserMatch "JDK/1\.0" force-response-1.0
+
+#
+# The following directive disables redirects on non-GET requests for
+# a directory that does not include the trailing slash.  This fixes a 
+# problem with Microsoft WebFolders which does not appropriately handle 
+# redirects for folders with DAV methods.
+#
+
+BrowserMatch "Microsoft Data Access Internet Publishing Provider" redirect-carefully
+BrowserMatch "^WebDrive" redirect-carefully
+BrowserMatch "^gnome-vfs" redirect-carefully 
+BrowserMatch "^WebDAVFS/1.[012]" redirect-carefully
+
+# Allow server status reports, with the URL of http://servername/server-status
+# Change the ".your_domain.com" to match your domain to enable.
+#
+#<Location /server-status>
+#    SetHandler server-status
+#    Order deny,allow
+#    Deny from all
+#    Allow from .your_domain.com
+#</Location>
+
+# Allow remote server configuration reports, with the URL of
+#  http://servername/server-info (requires that mod_info.c be loaded).
+# Change the ".your_domain.com" to match your domain to enable.
+#
+#<Location /server-info>
+#    SetHandler server-info
+#    Order deny,allow
+#    Deny from all
+#    Allow from .your_domain.com
+#</Location>
+
+# Include the virtual host configurations:
+Include /etc/apache2/sites-enabled/[^.#]*