feat: add specialized number literals

madlib-lang · Mar 27, 2024 · f22cb0f · f22cb0f
1 parent 35ecb41
commit f22cb0f
Show file tree

Hide file tree

Showing 6 changed files with 52 additions and 1 deletion.
diff --git a/compiler/common/AST/Canonical.hs b/compiler/common/AST/Canonical.hs
@@ -137,6 +137,9 @@ data ListItem_
 
 type Exp = Canonical Exp_
 data Exp_ = LNum String
+          | LByte String
+          | LShort String
+          | LInt String
           | LFloat String
           | LStr String
           | LChar Char

diff --git a/compiler/common/AST/Source.hs b/compiler/common/AST/Source.hs
@@ -149,6 +149,9 @@ data DictItem_
 type Exp = Source Exp_
 data Exp_
   = LNum String
+  | LByte String
+  | LShort String
+  | LInt String
   | LFloat String
   | LStr String
   | LChar String

diff --git a/compiler/main/Canonicalize/Canonicalize.hs b/compiler/main/Canonicalize/Canonicalize.hs
@@ -89,6 +89,21 @@ instance Canonicalizable Src.Exp Can.Exp where
     Src.LNum  x ->
       return $ Can.Canonical area (Can.LNum x)
 
+    Src.LByte  x -> do
+      -- when ((read x :: Int) > 255) $
+      --   throwError $ CompilationError InvalidLhs (Context (Env.envCurrentPath env) area)
+      return $ Can.Canonical area (Can.LByte x)
+
+    Src.LShort  x -> do
+      -- when ((read x :: Int) > 255) $
+      --   throwError $ CompilationError InvalidLhs (Context (Env.envCurrentPath env) area)
+      return $ Can.Canonical area (Can.LShort x)
+
+    Src.LInt  x -> do
+      -- when ((read x :: Int) > 255) $
+      --   throwError $ CompilationError InvalidLhs (Context (Env.envCurrentPath env) area)
+      return $ Can.Canonical area (Can.LInt x)
+
     Src.LFloat x ->
       return $ Can.Canonical area (Can.LFloat x)
 

diff --git a/compiler/main/Infer/Exp.hs b/compiler/main/Infer/Exp.hs
@@ -66,6 +66,9 @@ infer options env lexp = do
       let ps = [IsIn "Number" [t] Nothing]
       return (M.empty, ps, t, applyLitSolve lexp (ps :=> t))
 
+    Can.LByte _               -> return (M.empty, [], tByte, applyLitSolve lexp ([] :=> tByte))
+    Can.LShort _              -> return (M.empty, [], tShort, applyLitSolve lexp ([] :=> tShort))
+    Can.LInt _                -> return (M.empty, [], tInteger, applyLitSolve lexp ([] :=> tInteger))
     Can.LFloat _              -> return (M.empty, [], tFloat, applyLitSolve lexp ([] :=> tFloat))
     Can.LStr  _               -> return (M.empty, [], tStr, applyLitSolve lexp ([] :=> tStr))
     Can.LChar  _              -> return (M.empty, [], tChar, applyLitSolve lexp ([] :=> tChar))
@@ -103,6 +106,9 @@ infer options env lexp = do
 applyLitSolve :: Can.Exp -> Qual Type -> Slv.Exp
 applyLitSolve (Can.Canonical area exp) qt = case exp of
   Can.LNum  v  -> Slv.Typed qt area $ Slv.LNum v
+  Can.LByte  v -> Slv.Typed qt area $ Slv.LNum v
+  Can.LShort v -> Slv.Typed qt area $ Slv.LNum v
+  Can.LInt  v  -> Slv.Typed qt area $ Slv.LNum v
   Can.LFloat v -> Slv.Typed qt area $ Slv.LFloat v
   Can.LStr  v  -> Slv.Typed qt area $ Slv.LStr v
   Can.LChar  v -> Slv.Typed qt area $ Slv.LChar v

diff --git a/compiler/main/Parse/Madlib/Grammar.y b/compiler/main/Parse/Madlib/Grammar.y
@@ -22,6 +22,9 @@ import Text.Show.Pretty
 %lexer { lexerWrap } { Token _ _ TokenEOF }
 
 %token
+  byte        { Token _ _ (TokenByte _) }
+  short       { Token _ _ (TokenShort _) }
+  int         { Token _ _ (TokenInt _) }
   number      { Token _ _ (TokenNumber _) }
   float       { Token _ _ (TokenFloat _) }
   str         { Token _ _ (TokenStr _) }
@@ -666,6 +669,9 @@ tupleItems :: { [Src.Exp] }
 
 literal :: { Src.Exp }
   : number  %shift { Src.Source (tokenArea $1) (tokenTarget $1) (Src.LNum $ strV $1) }
+  | byte    %shift { Src.Source (tokenArea $1) (tokenTarget $1) (Src.LByte $ init $ init (strV $1)) }
+  | short   %shift { Src.Source (tokenArea $1) (tokenTarget $1) (Src.LShort $ init $ init (strV $1)) }
+  | int     %shift { Src.Source (tokenArea $1) (tokenTarget $1) (Src.LInt $ init $ init (strV $1)) }
   | float   %shift { Src.Source (tokenArea $1) (tokenTarget $1) (Src.LFloat $ strV $1) }
   | str     %shift { Src.Source (tokenArea $1) (tokenTarget $1) (Src.LStr $ strV $1) }
   | char    %shift { Src.Source (tokenArea $1) (tokenTarget $1) (Src.LChar $ charData $1) }

diff --git a/compiler/main/Parse/Madlib/Lexer.x b/compiler/main/Parse/Madlib/Lexer.x
@@ -107,9 +107,15 @@ tokens :-
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed, jsxOpeningTag> :\=$tail?            { mapToken (\_ -> TokenMutateEq) }
   -- <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> \n[\ ]*\-Infinity                   { mapToken (\s -> TokenNumber s) }
   -- <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> Infinity                            { mapToken (\s -> TokenNumber s) }
+  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> @decimal\_b                         { mapToken (\s -> TokenByte s) }
+  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> @decimal\_s                         { mapToken (\s -> TokenShort s) }
+  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> @decimal\_i                         { mapToken (\s -> TokenInt s) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> @decimal                            { mapToken (\s -> TokenNumber s) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> @floating                           { mapToken (\s -> TokenFloat s) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> 0x[0-9a-fA-F]*                      { mapToken (\s -> TokenNumber s) }
+  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> 0x[0-9a-fA-F]*\_b                   { mapToken (\s -> TokenByte s) }
+  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> 0x[0-9a-fA-F]*\_s                   { mapToken (\s -> TokenShort s) }
+  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> 0x[0-9a-fA-F]*\_i                   { mapToken (\s -> TokenInt s) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> "true"                              { mapToken (\_ -> (TokenBool "true")) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> "false"                             { mapToken (\_ -> (TokenBool "false")) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> $head*"=="                          { mapToken (\_ -> TokenDoubleEq) }
@@ -141,7 +147,7 @@ tokens :-
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed, instanceHeader> $head*\>\>\>        { mapToken (\_ -> TokenTripleRightChevron) }
   <0> \;                                                                                      { mapToken (\_ -> TokenSemiColon) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed, instanceHeader> [\n]                { mapToken (\_ -> TokenReturn) }
-  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed, jsxClosingTag, instanceHeader> [$alpha \_] [$alpha $digit \_ \']* { decideTokenName }
+  <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed, jsxClosingTag, instanceHeader>      [$alpha \_] [$alpha $digit \_ \']* { decideTokenName }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> $head*\+                                      { mapToken (\_ -> TokenPlus) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> $head*\+\+                                    { mapToken (\_ -> TokenDoublePlus) }
   <0, stringTemplateMadlib, jsxOpeningTag, jsxAutoClosed> \-[\t\ \n]+                                   { mapToken (\_ -> TokenDash) }
@@ -727,6 +733,9 @@ data Token = Token Area SourceTarget TokenClass deriving (Eq, Show)
 
 data TokenClass
  = TokenConst
+ | TokenByte String
+ | TokenShort String
+ | TokenInt String
  | TokenNumber String
  | TokenFloat String
  | TokenStr String
@@ -827,6 +836,15 @@ strV (Token _ _ (TokenTemplateStringEnd x)) =
 strV (Token _ _ (TokenNumber x)) =
   x
 
+strV (Token _ _ (TokenByte x)) =
+  x
+
+strV (Token _ _ (TokenShort x)) =
+  x
+
+strV (Token _ _ (TokenInt x)) =
+  x
+
 strV (Token _ _ (TokenFloat x)) =
   x