Question

I have to do a software to identify tokens in C. I have this code:

*main = do
   x <- readFile "progc.c"
   let resultado = lexCmm X
   print resultado
lexCmm :: String -> [Tok]
  lexCmm X = case X of
    c:cs   | isSpace c     -> lexCmm cs
    c:cs   | isAlpha c     -> getId s
    c:cs   | isDigit c     -> getInt s
    c:d:cs | isSymb [c,d]  -> TS [c,d] : lexCmm cs
    c:cs   | isSymb [c]    -> TS [c]   : lexCmm cs
    _                      -> []  
   where
    getId s  = lx i : lexCmm cs where (i,cs) = span isIdChar s
    getInt s = TI (read i) : lexCmm cs where (i,cs) = span isDigit s
    isIdChar c = isAlpha c || isDigit c
    lx i = if isReservedWord i then TS i else TI i

  isSymb s = elem s $ words "++ -- == <= >= ++ { } = , ; + * - ( ) < >"

  isReservedWord w = elem w $ words "else if int main printInt return while"*

The error is:

file:{Hugs}\prog.hs:7 - Syntax error in input (unexpected `=')

Answer 1

In addition to the mentioned error of using an upper case X for a variable name, you have an indentation error, the defining equation of lexCmm is indented, but it ought to start in the leftmost column.

If you unindent that line

lexCmm :: String -> [Tok]
lexCmm x = case x of

and the definitions of isSymb and isReservedWord too, you will get some other errors.

The alternatives of the case expression must be indented further than the case keyword.

In

c:cs   | isAlpha c     -> getId s
c:cs   | isDigit c     -> getInt s

you use an entity s that is not in scope (so you should probably change the argument of lexCmm to s, or these two s to x.

getInt s = TI (read i) : lexCmm cs where (i,cs) = span isDigit s

strongly suggests that the constructor TI of Tok takes an Int argument, but

lx i = if isReservedWord i then TS i else TI i

tries to apply it to a String. You probably want TI (read i) there.

The following code, containing a quick mockup of a Tok type compiles:

module Toks where

import Data.Char

data Tok
    = TS String
    | TI Int
      deriving Show

main = do
   x <- readFile "progc.c"
   let resultado = lexCmm x
   print resultado

lexCmm :: String -> [Tok]
lexCmm s = case s of       -- No indentation for function definition
            c:cs   | isSpace c     -> lexCmm cs    -- alternatives indented further
            c:cs   | isAlpha c     -> getId s      -- than the `case', all to the same level
            c:cs   | isDigit c     -> getInt s
            c:d:cs | isSymb [c,d]  -> TS [c,d] : lexCmm cs
            c:cs   | isSymb [c]    -> TS [c]   : lexCmm cs
            _                      -> []  
      where  -- `where' indented less than the `case', so that it scopes over all alternatives
        getId s  = lx i : lexCmm cs where (i,cs) = span isIdChar s
        getInt s = TI (read i) : lexCmm cs where (i,cs) = span isDigit s
        isIdChar c = isAlpha c || isDigit c
        lx i = if isReservedWord i then TS i else TI (read i)

isSymb s = elem s $ words "++ -- == <= >= ++ { } = , ; + * - ( ) < >"

isReservedWord w = elem w $ words "else if int main printInt return while"