This file is indexed.

/usr/share/doc/frown-doc/examples/other/Var2Expr.g is in frown-doc 0.6.2.3-4.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
{-

Illustrates the use of abbreviations.

	frown Var2Expr.g

-}

module Var2Expr
where
import Char

data AddOp                    =  Plus  | Minus
                                 deriving (Show)
data MulOp                    =  Times | Divide
                                 deriving (Show)

data Expr                     =  Add Expr AddOp Expr
                              |  Mul Expr MulOp Expr
                              |  Id String
                                 deriving (Show)

type Result                   =  []

%{

Terminal                      =        IDENT {String}
                              |        ADDOP {AddOp}
                              |        MULOP {MulOp}
                              |  "(" = Special '('
                              |  ")" = Special ')';

Nonterminal                   =  expr {Expr} | term {Expr} | factor {Expr};

expr {Add e1 op e2}           :  expr {e1}, ADDOP {op}, term {e2};
     {e}                      |  term {e};
term {Mul e1 op e2}           :  term {e1}, MULOP {op}, factor {e2};
     {e}                      |  factor {e};
factor {e}                    :  "(", expr {e}, ")";
       {Id s}                 |  IDENT {s};

}%

frown _                       =  fail "syntax error"

data Terminal                 =  IDENT String | ADDOP AddOp | MULOP MulOp | Special Char

lexer                         :: String -> [Terminal]
lexer []                      =  []
lexer ('+' : cs)              =  ADDOP Plus   : lexer cs
lexer ('-' : cs)              =  ADDOP Minus  : lexer cs
lexer ('*' : cs)              =  MULOP Times  : lexer cs
lexer ('/' : cs)              =  MULOP Divide : lexer cs
lexer ('(' : cs)              =  Special '(' : lexer cs
lexer (')' : cs)              =  Special ')' : lexer cs
lexer (c : cs)
    | isAlpha c               =  let (n, cs') = span isAlphaNum cs
                                 in  IDENT (c : n) : lexer cs'
    | otherwise               =  lexer cs