module Language.Fortran.Lexer.FixedForm.Utils where

import           Language.Fortran.Lexer.FixedForm
import           Language.Fortran.AST
import           Language.Fortran.AST.RealLit
import           Language.Fortran.Util.Position

makeReal :: Maybe Token -> Maybe Token -> Maybe Token -> Maybe (SrcSpan, String) -> Expression A0
makeReal :: Maybe Token
-> Maybe Token
-> Maybe Token
-> Maybe (SrcSpan, String)
-> Expression A0
makeReal Maybe Token
i1 Maybe Token
dot Maybe Token
i2 Maybe (SrcSpan, String)
expr =
  let span1 :: SrcSpan
span1   = (Maybe Token, Maybe Token, Maybe Token) -> SrcSpan
forall a. Spanned a => a -> SrcSpan
getSpan (Maybe Token
i1, Maybe Token
dot, Maybe Token
i2)
      span2 :: SrcSpan
span2   = case Maybe (SrcSpan, String)
expr of
                  Just (SrcSpan, String)
e -> SrcSpan -> SrcSpan -> SrcSpan
forall a b. SpannedPair a b => a -> b -> SrcSpan
getTransSpan SrcSpan
span1 ((SrcSpan, String) -> SrcSpan
forall a b. (a, b) -> a
fst (SrcSpan, String)
e)
                  Maybe (SrcSpan, String)
Nothing -> SrcSpan
span1
      i1Str :: String
i1Str   = case Maybe Token
i1 of { Just (TInt SrcSpan
_ String
s) -> String
s ; Maybe Token
_ -> String
"" }
      dotStr :: String
dotStr  = case Maybe Token
dot of { Just (TDot SrcSpan
_) -> String
"." ; Maybe Token
_ -> String
"" }
      i2Str :: String
i2Str   = case Maybe Token
i2 of { Just (TInt SrcSpan
_ String
s) -> String
s ; Maybe Token
_ -> String
"" }
      exprStr :: String
exprStr  = case Maybe (SrcSpan, String)
expr of { Just (SrcSpan
_, String
s) -> String
s ; Maybe (SrcSpan, String)
_ -> String
"" }
      litStr :: String
litStr  = String
i1Str String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
dotStr String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
i2Str String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
exprStr
   in A0 -> SrcSpan -> Value A0 -> Expression A0
forall a. a -> SrcSpan -> Value a -> Expression a
ExpValue () SrcSpan
span2 (Value A0 -> Expression A0) -> Value A0 -> Expression A0
forall a b. (a -> b) -> a -> b
$ RealLit -> Maybe (Expression A0) -> Value A0
forall a. RealLit -> Maybe (Expression a) -> Value a
ValReal (String -> RealLit
parseRealLit String
litStr) Maybe (Expression A0)
forall a. Maybe a
Nothing