Add Scala backend

.gitignore

@@ -172,3 +172,9 @@ cabal.sandbox.config
 /testing/regression-tests/266_define/nostl-2.9.0/
 
 /testing/regression-tests/comments/ocaml/
+
+ignore-dir/
+
+.DS_Store
+.vscode
+.metals

source/BNFC.cabal

@@ -272,6 +272,14 @@ library
     -- Pygments backend
     BNFC.Backend.Pygments
 
+    -- Scala backend
+    BNFC.Backend.Scala
+    BNFC.Backend.Scala.Utils
+    BNFC.Backend.Scala.CFtoScalaLex
+    BNFC.Backend.Scala.CFtoScalaLexToken
+    BNFC.Backend.Scala.CFtoScalaParser
+    BNFC.Backend.Scala.CFtoScalaParserAST
+
     -- Agda backend
     BNFC.Backend.Agda
 

source/main/Main.hs

@@ -26,6 +26,7 @@ import BNFC.Backend.Latex
 import BNFC.Backend.OCaml
 import BNFC.Backend.Pygments
 import BNFC.Backend.TreeSitter
+import BNFC.Backend.Scala
 import BNFC.CF (CF)
 import BNFC.GetCF
 import BNFC.Options hiding (make, Backend)
@@ -83,3 +84,4 @@ maketarget = \case
     TargetPygments     -> makePygments
     TargetCheck        -> error "impossible"
     TargetTreeSitter   -> makeTreeSitter
+    TargetScala        -> makeScala

source/src/BNFC/Backend/Scala.hs

@@ -0,0 +1,26 @@
+module BNFC.Backend.Scala where
+
+import Prelude hiding ((<>))
+
+import BNFC.Backend.Base (mkfile, Backend)
+import BNFC.CF
+import BNFC.Options hiding (Backend)
+-- import BNFC.Backend.Scala.CFtoScalaAbs (cf2ScalaAbs)
+import BNFC.Backend.Scala.CFtoScalaLex (cf2ScalaLex)
+import BNFC.Backend.Scala.CFtoScalaLexToken (cf2ScalaLexToken)
+import BNFC.Backend.Scala.CFtoScalaParser (cf2ScalaParser)
+import BNFC.Backend.Scala.CFtoScalaParserAST (cf2ScalaParserAST)
+
+-- | Entrypoint for the Scala backend.
+
+makeScala :: SharedOptions -> CF -> Backend
+makeScala opts cf = do 
+    -- mkfile (name ++ ".scala") comment $ cf2ScalaAbs opts cf
+    mkfile (name ++ "LexToken.scala") comment $ cf2ScalaLexToken opts cf
+    mkfile (name ++ "Lex.scala") comment $ cf2ScalaLex opts cf
+    mkfile (name ++ "Parser.scala") comment $ cf2ScalaParser opts cf
+    mkfile (name ++ "ParserAST.scala") comment $ cf2ScalaParserAST opts cf
+    where name = lang opts
+
+comment :: String -> String
+comment = ("// " ++)

source/src/BNFC/Backend/Scala/CFtoScalaLex.hs

@@ -0,0 +1,204 @@
+{-# LANGUAGE LambdaCase        #-}
+{-# LANGUAGE PatternGuards     #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+{-
+    BNF Converter: Scala Lextract syntax
+    Copyright (Scala) 2024  Author:  Juan Pablo Poittevin, Guillermo Poladura
+
+    Description   : This module generates the Scala Lextract Syntax
+                    tree classes. Using Scala Parser Combinator
+
+    Author        : Juan Pablo Poittevin, Guillermo Poladura
+    Created       : 30 September, 2024
+-}
+
+module BNFC.Backend.Scala.CFtoScalaLex (cf2ScalaLex) where
+
+import Prelude hiding ((<>))
+
+import BNFC.Utils (symbolToName)
+import BNFC.CF
+import BNFC.PrettyPrint
+import BNFC.Options
+import BNFC.Backend.Common (unicodeAndSymbols)
+import Data.List (intercalate)
+import Data.Char (toLower)
+import GHC.OldList (nub)
+import GHC.Unicode (toUpper)
+import BNFC.Backend.Scala.Utils (scalaReserverWords, mapManualTypeMap, scalaBNFCReserverWords, applyToRepeated)
+import Data.Maybe (fromMaybe)
+
+-- | Converts a string to lowercase
+toLowerString :: String -> String
+toLowerString s = map toLower s
+
+-- | Main function that generates the Scala lexer code
+cf2ScalaLex :: SharedOptions -> CF -> Doc
+cf2ScalaLex Options{ lang } cf = vcat $
+  -- Generate header and imports
+  imports lang ++
+  -- Generate error and location classes
+  addExtraClasses ++
+  -- Start the WorkflowLexer object
+  initWorkflowClass ++
+  -- Indent the class contents
+  [nest 4 $ vcat $ 
+    -- Add apply function
+    getApplyFunction ++
+    -- Add tokens function
+    getTokensFunction (keyWords ++ symbs ++ liters) ++
+    -- Add parser functions for literals
+    map addParserFunction liters ++
+    -- Add keyword parsers
+    map getBaseLexs (keyWords ++ symbs)
+  ] ++
+  -- End the WorkflowLexer object
+  endWorkflowClass
+  where
+    keyWords = reservedWords cf
+    symbs  = unicodeAndSymbols cf
+    liters = nub $ literals cf
+
+-- | Generate a parser function for a specific literal type
+addParserFunction :: String -> Doc
+addParserFunction liter 
+  | liter == catInteger = getIntegerFunction
+  | liter == catDouble  = getDoubleFunction
+  | liter == catIdent   = getIdentifiersFunction
+  | liter == catString  = getLiteralsFunction
+  | liter == catChar    = getLiteralFunction
+  | otherwise = empty
+
+-- | Generate the imports section
+imports :: String -> [Doc]
+imports name = [
+  text $ "package " ++ name ++ ".workflowtoken." ++ name ++ "Lex",
+  text "",
+  text "import scala.util.parsing.combinator.RegexParsers"
+  ]
+
+-- | Generate error and location classes
+addExtraClasses :: [Doc]
+addExtraClasses = [
+  text "",
+  text "sealed trait WorkflowCompilationError",
+  text "case class WorkflowLexerError(location: Location, msg: String) extends WorkflowCompilationError",
+  text "case class WorkflowParserError(location: Location, msg: String) extends WorkflowCompilationError",
+  text "",
+  text "case class Location(line: Int, column: Int) {",
+  nest 4 $ text "override def toString = s\"$line:$column\"",
+  text "}"
+  ]
+
+-- | Start the WorkflowLexer object
+initWorkflowClass :: [Doc]
+initWorkflowClass = [
+  text "",
+  text "object WorkflowLexer extends RegexParsers {"
+  ]
+
+-- | End the WorkflowLexer object
+endWorkflowClass :: [Doc]
+endWorkflowClass = [
+  text "}"
+  ]
+
+-- | Generate the apply function
+getApplyFunction :: [Doc]
+getApplyFunction = [
+  text "def apply(code: String): Either[WorkflowLexerError, List[WorkflowToken]] = {",
+  nest 4 $ text "parse(tokens, code) match {",
+  nest 8 $ text "case NoSuccess(msg, next) => Left(WorkflowLexerError(Location(next.pos.line, next.pos.column), msg))",
+  nest 8 $ text "case Success(result, next) => Right(result)",
+  nest 4 $ text "}",
+  text "}"
+  ]
+
+-- | Generate the function for parsing identifiers
+getIdentifiersFunction :: Doc
+getIdentifiersFunction = vcat [
+  text "",
+  text "def ident: Parser[IDENT] = {",
+  nest 4 $ text "\"[a-zA-Z_][a-zA-Z0-9_]*\".r ^^ { str => IDENT(str) }",
+  text "}"
+  ]
+
+-- | Generate the function for parsing integers
+getIntegerFunction :: Doc
+getIntegerFunction = vcat [
+  text "",
+  text "def integer: Parser[INTEGER] = {",
+  nest 4 $ text "\"[0-9]+\".r ^^ {i => INTEGER(i)}",
+  text "}"
+  ]
+
+-- | Generate the function for parsing double values
+getDoubleFunction :: Doc
+getDoubleFunction = vcat [
+  text "",
+  text "def double: Parser[DOUBLE] = {",
+  nest 4 $ text "\"[0-9]+.[0-9]+\".r ^^ {i => DOUBLE(i)}",
+  text "}"
+  ]
+
+-- | Generate the function for parsing string literals
+getLiteralsFunction :: Doc
+getLiteralsFunction = vcat [
+  text "",
+  text "def string: Parser[STRING] = {",
+  nest 4 $ text "\"\\\"[^\\\"]*\\\"\".r ^^ { str =>",
+  nest 8 $ text "val content = str.substring(1, str.length - 1)",
+  nest 8 $ text "STRING(content)",
+  nest 4 $ text "}",
+  text "}"
+  ]
+
+-- | Generate the function for parsing character literals
+getLiteralFunction :: Doc
+getLiteralFunction = vcat [
+  text "",
+  text "def char: Parser[CHAR] = {",
+  nest 4 $ text "\"\\\'[^\\\']*\\\'\".r ^^ { str =>",
+  nest 8 $ text "val content = str.substring(1, str.length - 1)",
+  nest 8 $ text "CHAR(content)",
+  nest 4 $ text "}",
+  text "}"
+  ]
+
+-- | Get a symbol name from a string
+getSymbFromName :: String -> String
+getSymbFromName s = 
+  case symbolToName s of
+    Just s -> s
+    _ -> map toUpper s
+
+-- | Generate the tokens function
+getTokensFunction :: [String] -> [Doc]
+getTokensFunction tokens = [
+  text "",
+  text "def tokens: Parser[List[WorkflowToken]] = {",
+  nest 4 $ text $ "phrase(rep1( " ++ intercalate " | " proccesedRepetedSymbs ++ "))",
+  text "}"
+  ]
+  where 
+    proccesedRepetedSymbs = reverse $ applyToRepeated ("p" ++) $ reverse $ getListTokensNames tokens
+
+-- | Get the lowercase symbol name
+getTokenName :: String -> String
+getTokenName s = fromMaybe (toLowerString $ getSymbFromName s) $ scalaReserverWords $ toLowerString $ getSymbFromName s
+
+-- | Get a list of symbol names
+getListTokensNames :: [String] -> [String]
+getListTokensNames = map getTokenName
+
+-- | Generate a keyword parser for a symbol
+getBaseLexs :: String -> Doc
+getBaseLexs symb = 
+  text "" $+$
+  text ("def " ++ defName ++ " = positioned { \"" ++ toLowerString symb ++ "\" ^^ (_ => " ++ param' ++ "()) }")
+    where
+        param = map toUpper $ getSymbFromName symb 
+        param' = fromMaybe param $ mapManualTypeMap param
+        defName = fromMaybe (getTokenName symb) $ scalaBNFCReserverWords $ getTokenName symb
+

source/src/BNFC/Backend/Scala/CFtoScalaLexToken.hs

@@ -0,0 +1,81 @@
+
+{-# LANGUAGE LambdaCase        #-}
+{-# LANGUAGE PatternGuards     #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+{-
+    BNF Converter: Scala Lextract syntax
+    Copyright (Scala) 2024  Author:  Juan Pablo Poittevin
+
+    Description   : This module generates the Scala Lextract Syntax
+                    tree classes. It generates both a Header file
+                    and an Implementation file
+
+    Author        : Juan Pablo Poittevin
+    Created       : 30 September, 2024
+-}
+
+module BNFC.Backend.Scala.CFtoScalaLexToken (cf2ScalaLexToken) where
+
+import Prelude hiding ((<>))
+
+import BNFC.CF
+import BNFC.PrettyPrint
+import BNFC.Options
+import BNFC.Backend.Common (unicodeAndSymbols)
+import BNFC.Utils (symbolToName)
+import Data.Char (toUpper)
+import Data.List (nub)
+import BNFC.Backend.Scala.Utils (scalaReserverWords, mapManualTypeMap)
+import Data.Maybe (fromMaybe)
+
+cf2ScalaLexToken
+  :: SharedOptions     
+  -> CF
+  -> Doc
+cf2ScalaLexToken Options{ lang } cf = vsep . concat $
+  [ 
+    headers lang
+    , [text $ concat $ map generateSymbClass (symbs)]
+    , [generateStringClasses liters]
+    , [generateKeyWordClasses (keyWords ++ ["empty"])]
+    -- , [text $ "Symbols: " ++ show symbs]
+    -- , [text $ "Literals: " ++ show liters]
+    -- , [text $ "Keywords: " ++ show keyWords] 
+  ]
+  where
+    liters = nub $ literals cf
+    symbs = unicodeAndSymbols cf
+    keyWords = reservedWords cf
+
+
+generateSymbClass :: String -> String
+generateSymbClass symb = case symbolToName symb of 
+  Just s -> "case class " ++ fromMaybe s (scalaReserverWords s) ++ "() extends WorkflowToken \n"
+  Nothing -> mempty
+
+
+generateKeyWordClasses :: [String] -> Doc
+generateKeyWordClasses params = text $ concat $ map generateKeyWordClass params
+
+generateKeyWordClass :: String -> String
+generateKeyWordClass key = "case class " ++ param' ++ "() extends WorkflowToken \n"
+        where
+          param = map toUpper key
+          param' = fromMaybe param $ mapManualTypeMap param
+
+
+generateStringClasses :: [String] -> Doc
+generateStringClasses params = text $ concat $ map generateStringClass params
+
+generateStringClass :: String -> String
+generateStringClass param = "case class " ++ (map toUpper param) ++ "(str: String) extends WorkflowToken \n"
+
+headers :: String -> [Doc]
+headers name = [
+  text $ "package " ++ name ++ ".workflowtoken." ++ name ++ "Lex"
+  , "import scala.util.parsing.input.Positional"
+  , "sealed trait WorkflowToken extends Positional"
+  ]
+
+