Cplusplus.x

-- -*- haskell -*- 
--  Simple lexer for c/c++ files

{
{-# OPTIONS -w  #-}
module Yi.Lexer.Cplusplus ( initState, alexScanToken ) where
{- Standard Library Modules Imported -}
import Yi.Lexer.Alex
{- External Library Modules Imported -}
{- Local Modules Imported -}
import qualified Yi.Syntax
import Yi.Style
  ( Style             ( .. )
  , defaultStyle
  , commentStyle
  , lineCommentStyle
  , keywordStyle
  , operatorStyle
  , upperIdStyle
  , stringStyle
  , numberStyle
  )
{- End of Module Imports -}

}

$whitechar = [\ \t\n\r\f\v]
$special   = [\(\)\,\;\[\]\`\{\}]

$ascdigit  = 0-9
$unidigit  = [] -- TODO
$digit     = [$ascdigit $unidigit]

$ascsymbol = [\!\#\$\%\&\*\+\.\/\<\=\>\?\@\\\^\|\-\~]
$unisymbol = [] -- TODO
$symbol    = [$ascsymbol $unisymbol] # [$special \_\:\"\']

$large     = [A-Z \xc0-\xd6 \xd8-\xde]
$small     = [a-z \xdf-\xf6 \xf8-\xff \_]
$alpha     = [$small $large]

$graphic   = [$small $large $symbol $digit $special \:\"\']

$octit     = 0-7
$hexit     = [0-9 A-F a-f]
$idchar    = [$alpha $digit \']
$symchar   = [$symbol \:]
$nl        = [\n\r]

@reservedid = 
  asm
  |break
  |case
  |continue
  |default
  |do
  |else
  |enum
  |for
  |fortran
  |goto
  |if
  |return
  |sizeof
  |struct
  |switch
  |typedef
  |union
  |while
  |_Bool
  |_Complex
  |_Imaginary
  |bool
  |char
  |double
  |float
  |int
  |long
  |short
  |signed
  |size_t
  |unsigned
  |void
  |auto
  |const
  |extern
  |inline
  |register
  |restrict
  |static
  |volatile
  |NULL
  |MAX
  |MIN
  |TRUE
  |FALSE
  |__LINE__
  |__DATA__
  |__FILE__
  |__func__
  |__TIME__
  |__STDC__
  |and
  |and_eq
  |bitand
  |bitor
  |catch
  |compl
  |const_cast
  |delete
  |dynamic_cast
  |false
  |for
  |friend
  |new
  |not
  |not_eq
  |operator
  |or
  |or_eq
  |private
  |protected
  |public
  |reinterpret_cast
  |static_cast
  |this
  |throw
  |true
  |try
  |typeid
  |using
  |xor
  |xor_eq
  |class
  |namespace
  |typename
  |template
  |virtual
  |bool
  |explicit
  |export
  |inline
  |mutable
  |wchar_t


@reservedop = 
  "->" | "*" | "+" | "-" | "%" | \\ | "||" | "&&" | "?" | ":"

@varid  = $small $idchar*
@conid  = $large $idchar*
@varsym = $symbol $symchar*
@consym = \: $symchar*

@decimal     = $digit+
@octal       = $octit+
@hexadecimal = $hexit+
@exponent    = [eE] [\-\+] @decimal

$cntrl   = [$large \@\[\\\]\^\_]
@ascii   = \^ $cntrl | NUL | SOH | STX | ETX | EOT | ENQ | ACK
         | BEL | BS | HT | LF | VT | FF | CR | SO | SI | DLE
         | DC1 | DC2 | DC3 | DC4 | NAK | SYN | ETB | CAN | EM
         | SUB | ESC | FS | GS | RS | US | SP | DEL
$charesc = [abfnrtv\\\"\'\&]
@escape  = \\ ($charesc | @ascii | @decimal | o @octal | x @hexadecimal)
@gap     = \\ $whitechar+ \\
@string  = $graphic # [\"\\] | " " | @escape | @gap

haskell :-

<0> $white+                                     { c defaultStyle } -- whitespace

<nestcomm> {
  -- We could do nested comments like this
  -- "/*"                                       { m (subtract 1) commentStyle }
  "*/"                                          { m (+1) commentStyle }
  $white+                                       { c defaultStyle } -- whitespace
  .                                             { c commentStyle }
}

<0> {
  "//"[^\n]*                                    { c commentStyle }

 "/*"                                           { m (subtract 1) commentStyle }

 $special                                       { c defaultStyle }

 @reservedid                                    { c keywordStyle }
 @varid                                         { c defaultStyle }
 @conid                                         { c upperIdStyle }

 @reservedop                                    { c operatorStyle }
 @varsym                                        { c operatorStyle }
 @consym                                        { c upperIdStyle }

 @decimal 
  | 0[oO] @octal
  | 0[xX] @hexadecimal                          { c defaultStyle }

 @decimal \. @decimal @exponent?
  | @decimal @exponent                          { c defaultStyle }

 \' ($graphic # [\'\\] | " " | @escape) \'      { c stringStyle }
 \" @string* \"                                 { c stringStyle }
 .                                              { c operatorStyle }
}


{

type HlState = Int
type Token = Style

stateToInit x | x < 0     = nestcomm
              | otherwise = 0

initState :: HlState
initState = 0

#include "alex.hsinc"
}