Added support for some intrinsic (time-related) functions in Rain

common/Intrinsics.hs

@@ -33,3 +33,15 @@ intrinsicProcs =
     , ("RESCHEDULE", [])
     ]
 
+rainIntrinsicFunctions :: [(String, ([A.Type], [(A.Type, String)]))]
+rainIntrinsicFunctions =
+    -- Time functions:
+    [ ("toSeconds", ([A.Real64], [(A.Time, "time")]))
+    , ("toMillis", ([A.Int64], [(A.Time, "time")]))
+    , ("toMicros", ([A.Int64], [(A.Time, "time")]))
+    , ("toNanos", ([A.Int64], [(A.Time, "time")]))
+    , ("fromSeconds", ([A.Time], [(A.Real64, "value")]))
+    , ("fromMillis", ([A.Time], [(A.Int64, "value")]))
+    , ("fromMicros", ([A.Time], [(A.Int64, "value")]))
+    , ("fromNanos", ([A.Time], [(A.Int64, "value")]))
+    ]

common/Types.hs

@@ -242,7 +242,11 @@ returnTypesOfFunction n
 
 returnTypesOfIntrinsic :: (CSMR m, Die m) => Meta -> String -> m [A.Type]
 returnTypesOfIntrinsic m s
-    = case lookup s intrinsicFunctions of
+ = do frontend <- getCompState >>* csFrontend
+      let intrinsicList = case frontend of
+            FrontendOccam -> intrinsicFunctions
+            FrontendRain -> rainIntrinsicFunctions
+      case lookup s intrinsicList of
         Just (rts, _) -> return rts
         Nothing -> dieP m $ "unknown intrinsic function " ++ s
 

frontends/ParseRain.hs

@@ -30,6 +30,7 @@ import Text.ParserCombinators.Parsec
 import qualified AST as A
 import CompState
 import Errors
+import Intrinsics
 import qualified LexRain as L
 import Metadata
 import ParseUtils
@@ -277,17 +278,24 @@ expression
     foldOps lhs (m,op,rhs) = A.Dyadic m op lhs rhs
 
     subExpr' :: RainParser A.Expression
-    subExpr' = try ( do funcName <- name
-                        sLeftR
-                        es <- sepBy expression sComma
-                        sRightR
-                        return $ A.FunctionCall (A.nameMeta funcName) funcName es)
+    subExpr' = try functionCall
                <|> do {id <- variable ; return $ A.ExprVariable (findMeta id) id}
                <|> literal
                <|> range
                <|> do {(m,op) <- monadicArithOp ; rhs <- subExpr' ; return $ A.Monadic m op rhs}
                <|> do {sLeftR ; e <- expression ; sRightR ; return e}
 
+functionCall :: RainParser A.Expression
+functionCall =  do funcName <- name
+                   sLeftR
+                   es <- sepBy expression sComma
+                   sRightR
+                   case lookup (A.nameName funcName) rainIntrinsicFunctions of
+                     Just _ -> return $ A.IntrinsicFunctionCall (A.nameMeta
+                       funcName) (A.nameName funcName) es
+                     Nothing -> return $
+                       A.FunctionCall (A.nameMeta funcName) funcName es
+
 data InnerBlockLineState = Decls | NoMoreDecls | Mixed deriving (Eq)