Add Swift Back-End

.vscode/tasks.json

@@ -0,0 +1,50 @@
+
+{
+  // Automatically created by phoityne-vscode extension.
+
+  "version": "2.0.0",
+  "presentation": {
+    "reveal": "always",
+    "panel": "new"
+  },
+  "tasks": [
+    {
+      // F7
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "label": "haskell build",
+      "type": "shell",
+      //"command": "cabal configure && cabal build"
+      "command": "stack build"
+    },
+    {
+      // F6
+      "group": "build",
+      "type": "shell",
+      "label": "haskell clean & build",
+      //"command": "cabal clean && cabal configure && cabal build"
+      "command": "stack clean && stack build"
+      //"command": "stack clean ; stack build"  // for powershell
+    },
+    {
+      // F8
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "type": "shell",
+      "label": "haskell test",
+      //"command": "cabal test"
+      "command": "stack test"
+    },
+    {
+      // F6
+      "isBackground": true,
+      "type": "shell",
+      "label": "haskell watch",
+      "command": "stack build --test --no-run-tests --file-watch"
+    }
+  ]
+}

source/BNFC.cabal

@@ -264,6 +264,29 @@ library
     BNFC.Backend.Java.RegToAntlrLexer
     BNFC.Backend.Java.Utils
 
+    -- Dart backend
+    BNFC.Backend.Dart
+    BNFC.Backend.Dart.CFtoDartAST
+    BNFC.Backend.Dart.CFtoDartBuilder
+    BNFC.Backend.Dart.Common
+    BNFC.Backend.Dart.CFtoDartPrinter
+    BNFC.Backend.Dart.CFtoDartSkeleton
+
+    -- Swift backend
+    BNFC.Backend.Swift
+    BNFC.Backend.Swift.CFtoSwiftAST
+    BNFC.Backend.Swift.CFtoSwiftBuilder
+    BNFC.Backend.Swift.Common
+    BNFC.Backend.Swift.CFtoSwiftPrinter
+    BNFC.Backend.Swift.CFtoSwiftSkeleton
+
+    -- Antlr4 backend
+    BNFC.Backend.Antlr
+    BNFC.Backend.Antlr.CFtoAntlr4Lexer
+    BNFC.Backend.Antlr.CFtoAntlr4Parser
+    BNFC.Backend.Antlr.RegToAntlrLexer
+    BNFC.Backend.Antlr.Utils
+
     -- XML backend
     BNFC.Backend.XML
 

source/main/Main.hs

@@ -25,6 +25,9 @@ import BNFC.Backend.Java
 import BNFC.Backend.Latex
 import BNFC.Backend.OCaml
 import BNFC.Backend.Pygments
+import BNFC.Backend.Dart (makeDart)
+import BNFC.Backend.Swift (makeSwift)
+import BNFC.Backend.Antlr
 import BNFC.Backend.TreeSitter
 import BNFC.CF (CF)
 import BNFC.GetCF
@@ -81,5 +84,8 @@ maketarget = \case
     TargetJava         -> makeJava
     TargetOCaml        -> makeOCaml
     TargetPygments     -> makePygments
+    TargetDart         -> makeDart
+    TargetSwift        -> makeSwift
+    TargetAntlr        -> makeAntlr
     TargetCheck        -> error "impossible"
     TargetTreeSitter   -> makeTreeSitter

source/src/BNFC/Backend/Antlr.hs

@@ -0,0 +1,101 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module BNFC.Backend.Antlr ( makeAntlr, makeAntlr', DirectoryOptions(..) ) where
+
+import Prelude hiding ((<>))
+import System.FilePath ((</>), pathSeparator, (<.>))
+import Text.PrettyPrint.HughesPJ (vcat)
+import Data.Maybe (fromMaybe)
+
+import BNFC.Utils
+    ( NameStyle(CamelCase),
+      mkName,
+      replace,
+      (+.+),
+      (+++) )
+import BNFC.CF
+import BNFC.Options as Options
+import BNFC.Backend.Base
+import BNFC.Backend.Antlr.CFtoAntlr4Lexer
+import BNFC.Backend.Antlr.CFtoAntlr4Parser
+import BNFC.Backend.Antlr.Utils (dotG4, getAntlrOptions)
+import BNFC.Backend.Common.Makefile as MakeFile
+    ( mkMakefile, mkVar, mkRule, refVar )
+
+data DirectoryOptions = DirectoryOptions
+  { baseDirectory :: Maybe String
+  , nameStyle :: Maybe NameStyle }
+
+makeAntlr :: SharedOptions -> CF -> MkFiles ()
+makeAntlr opts cf = makeAntlr' opts cf DirectoryOptions {
+    baseDirectory=Nothing
+  , nameStyle=Nothing }
+
+makeAntlr' :: SharedOptions -> CF -> DirectoryOptions -> MkFiles ()
+makeAntlr' opts@Options{..} cf DirectoryOptions{..} = do
+  let packageBase = maybe id (+.+) inPackage pkg
+      dirBase = fromMaybe (pkgToDir packageBase) baseDirectory
+
+  let lexerName = mkFilename "Lexer"
+      lexerFile = dotG4 lexerName
+      (lex, env) = cf2AntlrLex lexerName cf
+    -- Where the lexer file is created. lex is the content!
+  mkfile (dirBase </> lexerFile) mkAntlrComment lex
+
+  let parserName = mkFilename "Parser"
+      parserFile = dotG4 parserName
+      parserContent = cf2AntlrParse lexerName parserName cf linenumbers env
+  mkfile (dirBase </> parserFile) mkAntlrComment parserContent
+
+  MakeFile.mkMakefile optMake makefileContent
+    where
+      pkg = mkName [] (fromMaybe CamelCase nameStyle) lang
+      pkgToDir = replace '.' pathSeparator
+      mkFilename ending = mkName [] (fromMaybe CamelCase nameStyle) (pkg ++ ending)
+
+      makeVars x = [MakeFile.mkVar n v | (n,v) <- x]
+      makeRules x = [MakeFile.mkRule tar dep recipe  | (tar, dep, recipe) <- x]
+
+      langRef = MakeFile.refVar "LANG"
+
+      lexerVarName = "LEXER_GRAMMAR_FILENAME"
+      lexerGrammarFile = (langRef </>) . dotG4 $ langRef ++ "Lexer"
+
+      parserVarName = "PARSER_GRAMMAR_FILENAME"
+      parserGrammarFile = (langRef </>) . dotG4 $ langRef ++ "Parser"
+
+      makefileVars = vcat $ makeVars 
+        [ ("LANG", pkg)
+        , (lexerVarName, lexerGrammarFile)
+        , (parserVarName, parserGrammarFile)
+        , ("ANTLR4", "java org.antlr.v4.Tool")
+        , ("ANTLR_OPTIONS", getAntlrOptions opts)
+        , ("DIRECT_OPTIONS", antlrOpts)
+        ]
+
+      genAntlrRecipe = ((MakeFile.refVar "ANTLR4" +++ MakeFile.refVar "ANTLR_OPTIONS" +++ MakeFile.refVar "DIRECT_OPTIONS") +++) . MakeFile.refVar
+
+      antlrFiles = 
+        let ns = fromMaybe CamelCase nameStyle 
+        in map (langRef </>)
+          [ mkName [] ns (pkg +++ "Lexer") <.> "interp"
+          , mkName [] ns (pkg +++ "Parser") <.> "interp"
+          , mkName [] ns (pkg +++ "Lexer") <.> "tokens"
+          , mkName [] ns (pkg +++ "Parser") <.> "tokens"
+          ]
+
+      makefileRules =  vcat $ makeRules
+        [ (".PHONY", ["all", "clean-antlr", "remove"], [])
+        , ("all", [langRef], [])
+        , ("lexer", [MakeFile.refVar lexerVarName], [genAntlrRecipe lexerVarName])
+        , ("parser", [MakeFile.refVar parserVarName], [genAntlrRecipe parserVarName])
+        , (langRef, ["lexer", "parser"], [])
+        , ("clean-antlr", [],
+          map ("rm -f" +++) antlrFiles )
+        , ("remove", [], ["rm -rf" +++ langRef])
+        ]
+
+      makefileContent _ = vcat [makefileVars, "", makefileRules]
+
+mkAntlrComment :: String -> String
+mkAntlrComment = ("// ANTLRv4 " ++)

source/src/BNFC/Backend/Antlr/CFtoAntlr4Lexer.hs

@@ -0,0 +1,173 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+{-
+    BNF Converter: Java Antlr4 Lexer generator
+    Copyright (C) 2015  Author:  Gabriele Paganelli
+
+    Description   : This module generates the Antlr4 input file.
+                    Based on CFtoJLex15.hs
+
+    Author        : Gabriele Paganelli ([email protected])
+    Created       : 15 Oct, 2015
+
+-}
+
+module BNFC.Backend.Antlr.CFtoAntlr4Lexer ( cf2AntlrLex ) where
+
+import Prelude hiding ((<>))
+
+import Text.PrettyPrint
+import BNFC.CF
+import BNFC.Backend.Antlr.RegToAntlrLexer
+import BNFC.Backend.Common.NamedVariables
+
+-- | Creates a lexer grammar.
+-- Since antlr token identifiers must start with an uppercase symbol,
+-- I prepend "Surrogate_id_SYMB_" to the identifier.
+-- This introduces risks of clashes if somebody uses the same identifier for
+-- user defined tokens. This is not handled.
+-- returns the environment because the parser uses it.
+cf2AntlrLex :: String -> CF -> (Doc, KeywordEnv)
+cf2AntlrLex lexerName cf = (,env) $ vcat
+    [ prelude lexerName
+    , cMacros
+    -- unnamed symbols (those in quotes, not in token definitions)
+    , lexSymbols env
+    , restOfLexerGrammar cf
+    ]
+  where
+    env = zip (cfgSymbols cf ++ reservedWords cf) $ map (("Surrogate_id_SYMB_" ++) . show) [0 :: Int ..]
+
+
+-- | File prelude
+prelude :: String -> Doc
+prelude lexerName = vcat
+    [ "// Lexer definition for use with Antlr4"
+    , "lexer grammar" <+> text lexerName <> ";"
+    ]
+
+--For now all categories are included.
+--Optimally only the ones that are used should be generated.
+cMacros :: Doc
+cMacros = vcat
+    [ "// Predefined regular expressions in BNFC"
+    , frg "LETTER  : CAPITAL | SMALL"
+    , frg "CAPITAL : [A-Z\\u00C0-\\u00D6\\u00D8-\\u00DE]"
+    , frg "SMALL   : [a-z\\u00DF-\\u00F6\\u00F8-\\u00FF]"
+    , frg "DIGIT   : [0-9]"
+    ]
+  where frg a = "fragment" <+> a <+> ";"
+
+escapeChars :: String -> String
+escapeChars = concatMap escapeCharInSingleQuotes
+
+-- |
+-- >>> lexSymbols [("foo","bar")]
+-- bar : 'foo' ;
+-- >>> lexSymbols [("\\","bar")]
+-- bar : '\\' ;
+-- >>> lexSymbols [("/","bar")]
+-- bar : '/' ;
+-- >>> lexSymbols [("~","bar")]
+-- bar : '~' ;
+lexSymbols :: KeywordEnv -> Doc
+lexSymbols ss = vcat $  map transSym ss
+  where
+    transSym (s,r) = text r <>  " : '" <> text (escapeChars s) <> "' ;"
+
+-- | Writes rules for user defined tokens, and, if used, the predefined BNFC tokens.
+restOfLexerGrammar :: CF -> Doc
+restOfLexerGrammar cf = vcat
+    [ lexComments (comments cf)
+    , ""
+    , userDefTokens
+    , ifString strdec
+    , ifChar chardec
+    , ifC catDouble [
+        "// Double predefined token type",
+        "DOUBLE : DIGIT+ '.' DIGIT+ ('e' '-'? DIGIT+)?;"
+        ]
+    , ifC catInteger [
+        "//Integer predefined token type",
+        "INTEGER : DIGIT+;"
+        ]
+    , ifC catIdent [
+        "// Identifier token type" ,
+        "fragment" ,
+        "IDENTIFIER_FIRST : LETTER | '_';",
+        "IDENT : IDENTIFIER_FIRST (IDENTIFIER_FIRST | DIGIT)*;"
+        ]
+    , "// Whitespace"
+    , "WS : (' ' | '\\r' | '\\t' | '\\n' | '\\f')+ ->  skip;"
+    , "// Escapable sequences"
+    , "fragment"
+    , "Escapable : ('\"' | '\\\\' | 'n' | 't' | 'r' | 'f');"
+    , "ErrorToken : . ;"
+    , ifString stringmodes
+    , ifChar charmodes
+    ]
+  where
+    ifC cat s     = if isUsedCat cf (TokenCat cat) then vcat s else ""
+    ifString      = ifC catString
+    ifChar        = ifC catChar
+    strdec        = [ "// String token type"
+                    , "STRING : '\"' -> more, mode(STRINGMODE);"
+                    ]
+    chardec       = ["CHAR : '\\''   -> more, mode(CHARMODE);"]
+    userDefTokens = vcat
+        [ text name <> " : " <> text (printRegJLex exp) <> ";"
+        | (name, exp) <- tokenPragmas cf ]
+    stringmodes   = [ "mode STRESCAPE;"
+        , "STRESCAPED : Escapable  -> more, popMode ;"
+        , "mode STRINGMODE;"
+        , "STRINGESC : '\\\\' -> more , pushMode(STRESCAPE);"
+        , "STRINGEND : '\"' ->  type(STRING), mode(DEFAULT_MODE);"
+        , "STRINGTEXT : ~[\"\\\\] -> more;"
+        ]
+    charmodes     = [ "mode CHARMODE;"
+        , "CHARANY     :  ~['\\\\] -> more, mode(CHAREND);"
+        , "CHARESC     :  '\\\\'  -> more, pushMode(CHAREND),pushMode(ESCAPE);"
+        , "mode ESCAPE;"
+        , "ESCAPED : (Escapable | '\\'')  -> more, popMode ;"
+        , "mode CHAREND;"
+        , "CHARENDC     :  '\\''  -> type(CHAR), mode(DEFAULT_MODE);"
+        ]
+
+lexComments :: ([(String, String)], [String]) -> Doc
+lexComments ([],[]) = ""
+lexComments (m,s) = vcat
+    (prod "COMMENT_antlr_builtin" lexSingleComment s ++
+         prod "MULTICOMMENT_antlr_builtin" lexMultiComment m )
+
+  where
+    prod bg lc ty = [bg, ": ("] ++ punctuate "|" (map lc ty) ++ skiplex
+    skiplex       = [") -> skip;"]
+
+-- | Create lexer rule for single-line comments.
+--
+-- >>> lexSingleComment "--"
+-- '--' ~[\r\n]* (('\r'? '\n')|EOF)
+--
+-- >>> lexSingleComment "\""
+-- '"' ~[\r\n]* (('\r'? '\n')|EOF)
+lexSingleComment :: String -> Doc
+lexSingleComment c =
+    "'" <>text (escapeChars c) <>  "' ~[\\r\\n]* (('\\r'? '\\n')|EOF)"
+
+-- | Create lexer rule for multi-lines comments.
+--
+-- There might be a possible bug here if a language includes 2 multi-line
+-- comments. They could possibly start a comment with one character and end it
+-- with another. However this seems rare.
+--
+-- >>> lexMultiComment ("{-", "-}")
+-- '{-' (.)*? '-}'
+--
+-- >>> lexMultiComment ("\"'", "'\"")
+-- '"\'' (.)*? '\'"'
+lexMultiComment :: (String, String) -> Doc
+lexMultiComment (b,e) =
+         "'" <> text (escapeChars b)
+        <>"' (.)*? '"<> text (escapeChars e)
+        <> "'"