Lex.x

{
module Bindings.Bfd.Disasm.I386.Lex (
     Token(..)
   , lexer
) where

import System.IO
}

%wrapper "basic"

$whitestuff = [\ \f\v\r]
$decdigit   = [0-9]
$hexdigit   = [0-9 a-f]
$scale      = [1 2 4 8]
$alphanum   = [a-z 0-9]

tokens :-
   $whitestuff+                                             ;
   "data32 "                                                ;
   "-"{0,1}"0x"$hexdigit+                                   { offset           }
   $scale                                                   { offset           }
   "$0x"$hexdigit+                                          { constant         }
   ">0x"$hexdigit+                                          { address          }
   "lock "$alphanum+                                        { prefixedMnemonic }
   "rep "$alphanum+                                         { prefixedMnemonic }
   "repz "$alphanum+                                        { prefixedMnemonic }
   "repnz "$alphanum+                                       { prefixedMnemonic }
   "rex"".X"{0,1}" "$alphanum+                              { prefixedMnemonic }
   "rex (bad)"                                              { prefixedMnemonic }
   "%"$alphanum+"("$decdigit")"                             { register         }
   "%"$alphanum+                                            { register         }
   $alphanum+".s"{0,1}                                      { mnemonic         }
   $alphanum+",pt"{0,1}                                     { mnemonic         }
   $alphanum+",pn"{0,1}                                     { mnemonic         }
   "(bad)"                                                  { mnemonic         }
   "("                                                      { parensL          }
   ")"                                                      { parensR          }
   ","                                                      { comma            }
   ":"                                                      { colon            }
   "#"                                                      { hash             }
   "*"                                                      { star             }

{
data Token = Offset           Int
           | Constant         Int
           | Address          Int
           | PrefixedMnemonic [String]
           | Register         String
           | Mnemonic         String
           | ParensL
           | ParensR
           | Comma
           | Colon
           | Hash
           | Star
     deriving (Eq, Show)

offset   s = Offset   $ read s
constant s = Constant $ read $ tail s
address  s = Address  $ read $ tail s 

prefixedMnemonic s = PrefixedMnemonic $ words s
mnemonic         s = Mnemonic s

register s = Register $ tail s

parensL _ = ParensL
parensR _ = ParensR

comma   _ = Comma
colon   _ = Colon
hash    _ = Hash
star    _ = Star

lexer = alexScanTokens
}