{-# OPTIONS_GHC -Wunused-imports #-}

{-| The code to lex string and character literals. Basically the same code
    as in GHC.
-}
module Agda.Syntax.Parser.StringLiterals
    ( litString, litChar
    ) where

import Data.Bifunctor
import Data.Char
import qualified Data.Text as T

import Agda.Syntax.Common (pattern Ranged)
import Agda.Syntax.Parser.Alex
import Agda.Syntax.Parser.Monad
import Agda.Syntax.Parser.Tokens
import Agda.Syntax.Parser.LookAhead
import Agda.Syntax.Position
import Agda.Syntax.Literal

{--------------------------------------------------------------------------
    Exported actions
 --------------------------------------------------------------------------}

-- | Lex a string literal. Assumes that a double quote has been lexed.
litString :: LexAction Token
litString :: LexAction Token
litString = Char -> (Interval -> String -> Parser Token) -> LexAction Token
forall tok.
Char -> (Interval -> String -> Parser tok) -> LexAction tok
stringToken Char
'"' ((Interval -> String -> Parser Token) -> LexAction Token)
-> (Interval -> String -> Parser Token) -> LexAction Token
forall a b. (a -> b) -> a -> b
$ \ Interval
i String
s ->
  Token -> Parser Token
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> Parser Token) -> Token -> Parser Token
forall a b. (a -> b) -> a -> b
$ RLiteral -> Token
TokLiteral (RLiteral -> Token) -> RLiteral -> Token
forall a b. (a -> b) -> a -> b
$ Range -> Literal -> RLiteral
forall a. Range -> a -> Ranged a
Ranged (Interval -> Range
forall a. HasRange a => a -> Range
getRange Interval
i) (Literal -> RLiteral) -> Literal -> RLiteral
forall a b. (a -> b) -> a -> b
$ Text -> Literal
LitString (Text -> Literal) -> Text -> Literal
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
s

{-| Lex a character literal. Assumes that a single quote has been lexed.  A
    character literal is lexed in exactly the same way as a string literal.
    Only before returning the token do we check that the lexed string is of
    length 1. This is maybe not the most efficient way of doing things, but on
    the other hand it will only be inefficient if there is a lexical error.
-}
litChar :: LexAction Token
litChar :: LexAction Token
litChar = Char -> (Interval -> String -> Parser Token) -> LexAction Token
forall tok.
Char -> (Interval -> String -> Parser tok) -> LexAction tok
stringToken Char
'\'' ((Interval -> String -> Parser Token) -> LexAction Token)
-> (Interval -> String -> Parser Token) -> LexAction Token
forall a b. (a -> b) -> a -> b
$ \ Interval
i -> \case
  [Char
c] -> Token -> Parser Token
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> Parser Token) -> Token -> Parser Token
forall a b. (a -> b) -> a -> b
$ RLiteral -> Token
TokLiteral (RLiteral -> Token) -> RLiteral -> Token
forall a b. (a -> b) -> a -> b
$ Range -> Literal -> RLiteral
forall a. Range -> a -> Ranged a
Ranged (Interval -> Range
forall a. HasRange a => a -> Range
getRange Interval
i) (Literal -> RLiteral) -> Literal -> RLiteral
forall a b. (a -> b) -> a -> b
$ Char -> Literal
LitChar Char
c
  String
_   -> String -> Parser Token
forall a. String -> Parser a
lexError String
"character literal must contain a single character"


{--------------------------------------------------------------------------
    Errors
 --------------------------------------------------------------------------}

-- | Custom error function.
litError :: String -> LookAhead a
litError :: forall a. String -> LookAhead a
litError String
msg =
    do  LookAhead ()
sync
        Parser a -> LookAhead a
forall a. Parser a -> LookAhead a
liftP (Parser a -> LookAhead a) -> Parser a -> LookAhead a
forall a b. (a -> b) -> a -> b
$ String -> Parser a
forall a. String -> Parser a
lexError (String -> Parser a) -> String -> Parser a
forall a b. (a -> b) -> a -> b
$
            String
"Lexical error in string or character literal: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
msg


{--------------------------------------------------------------------------
    The meat
 --------------------------------------------------------------------------}

-- | The general function to lex a string or character literal token. The
--   character argument is the delimiter (@\"@ for strings and @\'@ for
--   characters).
stringToken :: Char -> (Interval -> String -> Parser tok) -> LexAction tok
stringToken :: forall tok.
Char -> (Interval -> String -> Parser tok) -> LexAction tok
stringToken Char
del Interval -> String -> Parser tok
mkTok = (PreviousInput -> PreviousInput -> Int -> Parser tok)
-> LexAction tok
forall r.
(PreviousInput -> PreviousInput -> Int -> Parser r) -> LexAction r
LexAction ((PreviousInput -> PreviousInput -> Int -> Parser tok)
 -> LexAction tok)
-> (PreviousInput -> PreviousInput -> Int -> Parser tok)
-> LexAction tok
forall a b. (a -> b) -> a -> b
$ \ PreviousInput
inp PreviousInput
inp' Int
n ->
    do  PositionWithoutFile -> Parser ()
setLastPos (PositionWithoutFile -> PositionWithoutFile
forall a. Position' a -> Position' a
backupPos (PositionWithoutFile -> PositionWithoutFile)
-> PositionWithoutFile -> PositionWithoutFile
forall a b. (a -> b) -> a -> b
$ PreviousInput -> PositionWithoutFile
lexPos PreviousInput
inp')
        PreviousInput -> Parser ()
setLexInput PreviousInput
inp'
        -- TODO: Should setPrevToken be run here? Compare with
        -- Agda.Syntax.Parser.LexActions.token.
        tok <- (forall a. String -> LookAhead a)
-> LookAhead String -> Parser String
forall a.
(forall a. String -> LookAhead a) -> LookAhead a -> Parser a
runLookAhead String -> LookAhead b
forall a. String -> LookAhead a
litError (LookAhead String -> Parser String)
-> LookAhead String -> Parser String
forall a b. (a -> b) -> a -> b
$ Char -> String -> LookAhead String
lexString Char
del String
""
        i   <- getParseInterval
        mkTok i tok


-- | This is where the work happens. The string argument is an accumulating
--   parameter for the string being lexed.
lexString :: Char -> String -> LookAhead String
lexString :: Char -> String -> LookAhead String
lexString Char
del String
s =

    do  c <- LookAhead Char
nextChar
        case c of

            Char
c | Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
del  -> LookAhead ()
sync LookAhead () -> LookAhead String -> LookAhead String
forall a b. LookAhead a -> LookAhead b -> LookAhead b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> LookAhead String
forall a. a -> LookAhead a
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> String
forall a. [a] -> [a]
reverse String
s)

            Char
'\\' ->
                do  c' <- LookAhead Char
nextChar
                    case c' of
                        Char
'&'             -> LookAhead ()
sync LookAhead () -> LookAhead String -> LookAhead String
forall a b. LookAhead a -> LookAhead b -> LookAhead b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> String -> LookAhead String
lexString Char
del String
s
                        Char
c | Char -> Bool
isSpace Char
c   -> LookAhead ()
sync LookAhead () -> LookAhead String -> LookAhead String
forall a b. LookAhead a -> LookAhead b -> LookAhead b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> String -> LookAhead String
lexStringGap Char
del String
s
                        Char
_               -> LookAhead String
normalChar

            Char
_ -> LookAhead String
normalChar
    where
        normalChar :: LookAhead String
normalChar =
            do  LookAhead ()
rollback
                c <- LookAhead Char
lexChar
                lexString del (c:s)


-- | A string gap consists of whitespace (possibly including line breaks)
--   enclosed in backslashes. The gap is not part of the resulting string.
lexStringGap :: Char -> String -> LookAhead String
lexStringGap :: Char -> String -> LookAhead String
lexStringGap Char
del String
s =
    do  c <- LookAhead Char
eatNextChar
        case c of
            Char
'\\'            -> Char -> String -> LookAhead String
lexString Char
del String
s
            Char
c | Char -> Bool
isSpace Char
c   -> Char -> String -> LookAhead String
lexStringGap Char
del String
s
            Char
_               -> String -> LookAhead String
forall a. String -> LookAhead a
lookAheadError String
"non-space in string gap"

-- | Lex a single character.
lexChar :: LookAhead Char
lexChar :: LookAhead Char
lexChar =
    do  c <- LookAhead Char
eatNextChar
        case c of
            Char
'\\'    -> LookAhead Char
lexEscape
            Char
_       -> Char -> LookAhead Char
forall a. a -> LookAhead a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
c

-- | Lex an escaped character. Assumes the backslash has been lexed.
lexEscape :: LookAhead Char
lexEscape :: LookAhead Char
lexEscape =
    do  c <- LookAhead Char
eatNextChar
        case c of
            Char
'^'     -> do c <- LookAhead Char
eatNextChar
                          if c >= '@' && c <= '_'
                            then return (chr (ord c - ord '@'))
                            else lookAheadError "invalid control character"

            Char
'x'     -> (Char -> Bool) -> Int -> (Char -> Int) -> LookAhead Char
readNum Char -> Bool
isHexDigit Int
16 Char -> Int
digitToInt
            Char
'o'     -> (Char -> Bool) -> Int -> (Char -> Int) -> LookAhead Char
readNum Char -> Bool
isOctDigit  Int
8 Char -> Int
digitToInt
            Char
x | Char -> Bool
isDigit Char
x
                    -> (Char -> Bool) -> Int -> (Char -> Int) -> Int -> LookAhead Char
readNumAcc Char -> Bool
isDigit Int
10 Char -> Int
digitToInt (Char -> Int
digitToInt Char
x)

            Char
c ->
                -- Try to match the input (starting with c) against the
                -- silly escape codes.
                do  esc <- Char
-> [(String, LookAhead Char)] -> LookAhead Char -> LookAhead Char
forall a.
Char -> [(String, LookAhead a)] -> LookAhead a -> LookAhead a
match' Char
c (((String, Char) -> (String, LookAhead Char))
-> [(String, Char)] -> [(String, LookAhead Char)]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> LookAhead Char)
-> (String, Char) -> (String, LookAhead Char)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second Char -> LookAhead Char
forall a. a -> LookAhead a
forall (m :: * -> *) a. Monad m => a -> m a
return) [(String, Char)]
sillyEscapeChars)
                                    (String -> LookAhead Char
forall a. String -> LookAhead a
lookAheadError String
"bad escape code")
                    sync
                    return esc

-- | Read a number in the specified base.
readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> LookAhead Char
readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> LookAhead Char
readNum Char -> Bool
isDigit Int
base Char -> Int
conv =
    do  c <- LookAhead Char
eatNextChar
        if isDigit c
            then readNumAcc isDigit base conv (conv c)
            else lookAheadError "non-digit in numeral"

-- | Same as 'readNum' but with an accumulating parameter.
readNumAcc :: (Char -> Bool) -> Int -> (Char -> Int) -> Int -> LookAhead Char
readNumAcc :: (Char -> Bool) -> Int -> (Char -> Int) -> Int -> LookAhead Char
readNumAcc Char -> Bool
isDigit Int
base Char -> Int
conv Int
i = Int -> LookAhead Char
scan Int
i
    where
        scan :: Int -> LookAhead Char
scan Int
i =
            do  inp <- LookAhead PreviousInput
getInput
                c   <- nextChar
                case c of
                    Char
c | Char -> Bool
isDigit Char
c -> Int -> LookAhead Char
scan (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
base Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Char -> Int
conv Char
c)
                    Char
_             ->
                        do  PreviousInput -> LookAhead ()
setInput PreviousInput
inp
                            LookAhead ()
sync
                            if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Char -> Int
ord Char
forall a. Bounded a => a
minBound Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Char -> Int
ord Char
forall a. Bounded a => a
maxBound
                                then Char -> LookAhead Char
forall a. a -> LookAhead a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Char
chr Int
i)
                                else String -> LookAhead Char
forall a. String -> LookAhead a
lookAheadError String
"character literal out of bounds"

-- | The escape codes.
sillyEscapeChars :: [(String, Char)]
sillyEscapeChars :: [(String, Char)]
sillyEscapeChars =
    [ (String
"a", Char
'\a')
    , (String
"b", Char
'\b')
    , (String
"f", Char
'\f')
    , (String
"n", Char
'\n')
    , (String
"r", Char
'\r')
    , (String
"t", Char
'\t')
    , (String
"v", Char
'\v')
    , (String
"\\", Char
'\\')
    , (String
"\"", Char
'\"')
    , (String
"'", Char
'\'')
    , (String
"NUL", Char
'\NUL')
    , (String
"SOH", Char
'\SOH')
    , (String
"STX", Char
'\STX')
    , (String
"ETX", Char
'\ETX')
    , (String
"EOT", Char
'\EOT')
    , (String
"ENQ", Char
'\ENQ')
    , (String
"ACK", Char
'\ACK')
    , (String
"BEL", Char
'\BEL')
    , (String
"BS", Char
'\BS')
    , (String
"HT", Char
'\HT')
    , (String
"LF", Char
'\LF')
    , (String
"VT", Char
'\VT')
    , (String
"FF", Char
'\FF')
    , (String
"CR", Char
'\CR')
    , (String
"SO", Char
'\SO')
    , (String
"SI", Char
'\SI')
    , (String
"DLE", Char
'\DLE')
    , (String
"DC1", Char
'\DC1')
    , (String
"DC2", Char
'\DC2')
    , (String
"DC3", Char
'\DC3')
    , (String
"DC4", Char
'\DC4')
    , (String
"NAK", Char
'\NAK')
    , (String
"SYN", Char
'\SYN')
    , (String
"ETB", Char
'\ETB')
    , (String
"CAN", Char
'\CAN')
    , (String
"EM", Char
'\EM')
    , (String
"SUB", Char
'\SUB')
    , (String
"ESC", Char
'\ESC')
    , (String
"FS", Char
'\FS')
    , (String
"GS", Char
'\GS')
    , (String
"RS", Char
'\RS')
    , (String
"US", Char
'\US')
    , (String
"SP", Char
'\SP')
    , (String
"DEL", Char
'\DEL')
    ]