{-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE DuplicateRecordFields #-} {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE OverloadedLists #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Main where -- import Data.Reflection (reify, Reifies(..)) -- import qualified Data.Text.IO as Text import Control.Applicative (pure) import Control.Monad (Monad(..), when) import Data.Bool import Data.Default.Class (Default(..)) import Data.Either (Either(..)) import Data.Eq (Eq(..)) import Data.Foldable (Foldable(..)) import Data.Function (($), (.)) import Data.Functor ((<$>)) import Data.Locale import Data.Maybe (Maybe(..), fromMaybe, maybe) import Data.Monoid (Monoid(..)) import Data.Ord (Ord(..)) import Data.Semigroup (Semigroup(..)) import Data.String (String, IsString(..)) import Data.Void (Void) import GHC.Exts (IsList(..)) import Prelude (error) import System.FilePath as FilePath import System.IO (IO, FilePath) import Text.Show (Show(..)) import qualified Data.ByteString as BS import qualified Data.Char as Char import qualified Data.List as List import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Text as Text import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.IO as TL import qualified Data.TreeSeq.Strict as Tree import qualified Data.Version as Version import qualified Language.Symantic.RNC.Write as RNC import qualified Paths_hdoc as Hdoc import qualified System.Directory as IO import qualified System.Environment as Env import qualified System.IO as IO import qualified Text.Blaze.Renderer.Utf8 as Blaze import qualified Text.Blaze.Utils as Blaze import qualified Text.Megaparsec as P import qualified Hdoc.Utils as FS import qualified Hdoc.TCT as TCT import qualified Hdoc.TCT.Write.HTML5 as TCT import qualified Hdoc.TCT.Write.Plain as TCT import qualified Hdoc.TCT.Write.XML as TCT import qualified Hdoc.DTC.Read.TCT as DTC import qualified Hdoc.DTC.Sym as DTC import qualified Hdoc.DTC.Write.HTML5 as DTC import qualified Hdoc.DTC.Write.XML as DTC import qualified Text.Blaze.DTC as Blaze.DTC import qualified Text.Blaze.HTML5 as Blaze.HTML5 import Language.Symantic.CLI hiding (main) import qualified Language.Symantic.CLI as CLI import qualified Language.Symantic.Document.Term.IO as Doc import qualified Language.Symantic.CLI.Plain as Plain import qualified Language.Symantic.CLI.Help as Help import qualified Language.Symantic.CLI.Read as Read version :: TL.Text version = "hdoc-" <> TL.pack (Version.showVersion Hdoc.version) main :: IO () main = do lang <- getLang args <- Env.getArgs readArgs lang args >>= \case Nothing -> return () Just (Left err) -> onExit err Just (Right cmd) -> onCommand cmd readArgs :: forall d. Plain.Doc d => Lang -> [String] -> IO.IO (Maybe (Either (Exit (Doc d)) Command)) readArgs lang args = case Read.readArgs (cli (loqualize lang) lang) $ Read.Args $ Read.Arg <$> ("hdoc":args) of Right a -> return $ Just $ Right a Left err -> case err of P.FancyError pos es -> case Set.toList es of [P.ErrorCustom (Read.ErrorRead e)] -> case e of Exit_Error ee -> do IO.hPutStr IO.stderr $ P.parseErrorPretty @Read.Arg @(Read.ErrorRead Error) $ P.FancyError pos $ Set.singleton $ P.ErrorCustom $ Read.ErrorRead ee return Nothing _ -> return $ Just $ Left e _ -> return Nothing P.TrivialError pos e es -> do IO.hPutStr IO.stderr $ P.parseErrorPretty @_ @Void $ P.TrivialError pos e es return Nothing -- * Type 'Exit' data Exit d = Exit_Help d | Exit_Version | Exit_License (Loq d) | Exit_Error Error deriving Show instance Show (Loqualization q) where show _ = "Loqualization" onExit :: Exit (Doc Doc.TermIO) -> IO () onExit (Exit_Help d) = Doc.runTermIO IO.stdout $ Doc.withBreakable (Just 80) (runDoc d) <> Doc.newline onExit Exit_Version = TL.putStrLn version onExit (Exit_License (Loqualization l)) = Doc.runTermIO IO.stdout $ runDoc $ l10n_license l onExit Exit_Error{} = return () -- ** Type 'Error' newtype Error = Error_Locale String deriving Show -- * Type 'Command' data Command = Command_Source CommandSource | Command_Compile CommandCompile | Command_Schema CommandSchema deriving (Show) onCommand :: Command -> IO () onCommand cmd@(Command_Source CommandSource{..}) = do IO.hPrint IO.stderr cmd TCT.readTCT source_input >>= \case Left err -> error $ show err Right tct -> do when source_dump_tct $ FS.writeFile (source_output-<.>"tct.dump") $ TL.pack $ Tree.prettyTrees tct case source_format of CommandSourceFormat_Plain -> FS.writeFile source_output $ TCT.writePlain tct CommandSourceFormat_HTML5 -> FS.withFile source_output IO.WriteMode $ \h -> Blaze.renderMarkupToByteStringIO (BS.hPutStr h) $ TCT.writeHTML5 tct onCommand cmd@(Command_Compile cmdComp@CommandCompile{..}) = do IO.hPrint IO.stderr cmd TCT.readTCT compile_input >>= \case Left err -> error $ show err Right tct -> do when compile_dump_tct $ do FS.writeFile (compile_output-<.>"tct.dump") $ TL.pack $ Tree.prettyTrees tct let xml = TCT.writeXML tct when compile_dump_xml $ do FS.writeFile (compile_output-<.>"xml.dump") $ TL.pack $ Tree.prettyTrees xml case DTC.readDTC xml of Left err -> do FS.removeFile $ compile_output-<.>"deps" error $ P.parseErrorPretty err Right dtc -> do when compile_dump_deps $ do writeDependencies cmdComp tct when compile_dump_xml $ do FS.writeFile (compile_output-<.>"dtc.dump") $ TL.pack $ show dtc case compile_format of CommandCompileFormat_XML -> FS.withFile compile_output IO.WriteMode $ \h -> Blaze.prettyMarkupIO Blaze.DTC.isInlinedElement (BS.hPutStr h) $ DTC.writeXML compile_locale dtc CommandCompileFormat_HTML5{..} -> do config_css <- installFile compile_html5_output_css $ "style""dtc-html5.css" config_js <- installFile compile_html5_output_js $ "style""dtc-html5.js" let conf = DTC.Config { DTC.config_css , DTC.config_js , DTC.config_locale = compile_locale , DTC.config_generator = version } FS.withFile compile_output IO.WriteMode $ \h -> do html <- DTC.writeHTML5 conf dtc Blaze.prettyMarkupIO Blaze.HTML5.isInlinedElement (BS.hPutStr h) html where installFile out name = do dataDir <- Hdoc.getDataDir let src = dataDirname case out of Nothing -> Right <$> FS.readFile src Just "" -> return $ Left "" Just dst -> do IO.createDirectoryIfMissing True $ FilePath.takeDirectory dst IO.copyFile src dst return $ Left dst onCommand Command_Schema{} = TL.hPutStrLn IO.stdout $ RNC.writeRNC DTC.schema DTC.schema writeDependencies :: CommandCompile -> TCT.Roots -> IO () writeDependencies CommandCompile{..} tct = let dir = FilePath.takeDirectory compile_input in FS.writeFile (compile_input-<.>"deps") $ foldMap (TL.pack . (("\n" <>) . FilePath.normalise)) ((dir ) <$> TCT.dependencies tct) <> "\n" -- ** Type 'CommandSource' data CommandSource = CommandSource { source_output :: FilePath , source_dump_tct :: Bool , source_format :: CommandSourceFormat , source_input :: FilePath } deriving (Show) -- *** Type 'CommandSourceFormat' data CommandSourceFormat = CommandSourceFormat_Plain | CommandSourceFormat_HTML5 deriving (Show) instance Default CommandSourceFormat where def = CommandSourceFormat_Plain -- *** Type 'CommandSourceDump' data CommandSourceDump = CommandSourceDump_TCT | CommandSourceDump_XML deriving (Eq, Ord, Show) -- ** Type 'CommandCompile' data CommandCompile = CommandCompile { compile_output :: FilePath , compile_locale :: Lang , compile_dump_tct :: Bool , compile_dump_xml :: Bool , compile_dump_deps :: Bool , compile_format :: CommandCompileFormat , compile_input :: FilePath -- , compile_dump :: Set CommandCompileDump } deriving (Show) -- *** Type 'CommandCompileFormat' data CommandCompileFormat = CommandCompileFormat_HTML5 { compile_html5_output_css :: Maybe FilePath , compile_html5_output_js :: Maybe FilePath , compile_html5_dump_dtc :: Bool } | CommandCompileFormat_XML { } deriving (Show) instance Default CommandCompileFormat where def = CommandCompileFormat_HTML5 { compile_html5_output_css = def , compile_html5_output_js = def , compile_html5_dump_dtc = False } -- *** Type 'CommandCompileDump' data CommandCompileDump = CommandCompileDump_TCT | CommandCompileDump_XML | CommandCompileDump_DTC | CommandCompileDump_Deps deriving (Eq, Ord, Show) -- ** Type 'CommandSchema' data CommandSchema = CommandSchema deriving (Show) -- * Class 'CLI' class ( Sym_Fun repr , Sym_App repr , Sym_Alt repr , Sym_AltApp repr , Sym_Help d repr , Sym_Rule repr , Sym_Interleaved repr , Sym_Command repr , Sym_Option repr , Sym_Exit repr , Plain.Doc d -- , Reifies lang ) => CLI d repr where cli :: Loq d -> Lang -> repr (Exit d) ArgCommand Command cli loq@(Loqualization l) lang = help @d (l10n_cli l) $ CLI.main "hdoc" $ opts **> cmds where opts = interleaved $ (\_ _ -> ()) <<$? option_help loq (help_usage $ cli loq lang) <<|?>> option_version loq <<|?>> option_license loq cmds = Command_Source <$$> command_source loq <||> Command_Compile <$$> command_compile loq lang <||> Command_Schema <$$> command_schema loq option_help :: Loq d -> d -> ((), repr (Exit d) ArgOption ()) option_help (Loqualization l) d = ((),) $ help @d (l10n_help_opt_help l) $ opt (OptionName 'h' "help") $ exit $ Exit_Help d option_version :: Loq d -> ((), repr (Exit d) ArgOption ()) option_version (Loqualization l) = ((),) $ help @d (l10n_help_version l) $ long "version" $ exit $ Exit_Version option_license :: Loq d -> ((), repr (Exit d) ArgOption ()) option_license loq@(Loqualization l) = ((),) $ help @d (l10n_help_license l) $ long "license" $ exit $ Exit_License loq {- option_input :: Loq d -> (FilePath, repr (Exit d) ArgOption FilePath) option_input (Loqualization l) = (mempty,) $ help @d (l10n_help_opt_input l) $ opt (OptionName 'i' "input") $ string $ l10n_var_file l -} option_output :: Loq d -> (FilePath, repr (Exit d) ArgOption FilePath) option_output (Loqualization l) = (mempty,) $ help @d (l10n_help_opt_output l) $ opt (OptionName 'o' "output") $ string $ l10n_var_file l option_lang :: Loq d -> Lang -> (Lang, repr (Exit d) ArgOption Lang) option_lang (Loqualization l) lang = (lang,) $ help @d (l10n_help_opt_lang l) $ long "lang" $ var (l10n_var_locale l) $ \s -> maybe (Left $ Exit_Error $ Error_Locale s) Right $ Map.lookup (Text.pack s) $ locales @Langs option_dump_tct :: Loq d -> (Bool, repr (Exit d) ArgOption Bool) option_dump_tct (Loqualization l) = help @d (l10n_help_opt_dump_tct l) <$> flag (OptionNameLong "dump-tct") option_dump_xml :: Loq d -> (Bool, repr (Exit d) ArgOption Bool) option_dump_xml (Loqualization l) = help @d (l10n_help_opt_dump_xml l) <$> flag (OptionNameLong "dump-xml") option_dump_deps :: Loq d -> (Bool, repr (Exit d) ArgOption Bool) option_dump_deps (Loqualization l) = help @d (l10n_help_opt_dump_deps l) <$> flag (OptionNameLong "dump-deps") option_dump_dtc :: Loq d -> (Bool, repr (Exit d) ArgOption Bool) option_dump_dtc (Loqualization l) = help @d (l10n_help_opt_dump_dtc l) <$> flag (OptionNameLong "dump-dtc") command_source :: Loq d -> repr (Exit d) ArgCommand CommandSource command_source loq@(Loqualization l) = help @d (l10n_help_command_source l) $ command "source" $ (interleaved $ CommandSource <<$? option_help loq (help_usage $ command_source loq) <<|?>> option_output loq <<|?>> option_dump_tct loq) <**> (command_source_plain loq <||> command_source_html5 loq) <**> string (l10n_var_file l) command_source_plain :: Loq d -> repr (Exit d) ArgCommand CommandSourceFormat command_source_plain loq@(Loqualization l) = help @d (l10n_help_format_plain l) $ command "plain" $ interleaved $ CommandSourceFormat_Plain <<$? option_help loq (help_usage $ command_source_plain loq) command_source_html5 :: Loq d -> repr (Exit d) ArgCommand CommandSourceFormat command_source_html5 loq@(Loqualization l) = help @d (l10n_help_format_html5 l) $ command "html" $ interleaved $ CommandSourceFormat_HTML5 <<$? option_help loq (help_usage $ command_source_html5 loq) command_compile :: Loq d -> Lang -> repr (Exit d) ArgCommand CommandCompile command_compile loq@(Loqualization l) lang = help @d (l10n_help_command_compile l) $ command "compile" $ (setDefault <$$>) $ (interleaved $ CommandCompile <<$? option_help loq (help_usage $ command_compile loq lang) <<|?>> option_output loq <<|?>> option_lang loq lang <<|?>> option_dump_tct loq <<|?>> option_dump_xml loq <<|?>> option_dump_deps loq) <**> (command_compile_html5 loq <||> command_compile_xml loq) <**> string (l10n_var_file l) where setDefault a@CommandCompile{..} | null compile_output = (a::CommandCompile){compile_output=compile_input-<.>fmt compile_format} | otherwise = a fmt = \case CommandCompileFormat_XML{} -> "xml" CommandCompileFormat_HTML5{} -> "html" command_compile_html5 :: Loq d -> repr (Exit d) ArgCommand CommandCompileFormat command_compile_html5 loq@(Loqualization l) = help @d (l10n_help_format_html5 l) $ command "html" $ interleaved $ CommandCompileFormat_HTML5 <<$? option_help loq (help_usage $ command_compile_html5 loq) <<|?>> option_html5_output_css <<|?>> option_html5_output_js <<|?>> option_dump_dtc loq where option_html5_output_css = (Nothing,) $ (Just <$$>) $ help @d (l10n_help_opt_output_css l) $ opt (OptionNameLong "output-css") $ string $ l10n_var_file l option_html5_output_js = (Nothing,) $ (Just <$$>) $ help @d (l10n_help_opt_output_js l) $ opt (OptionNameLong "output-js") $ string $ l10n_var_file l command_compile_xml :: Loq d -> repr (Exit d) ArgCommand CommandCompileFormat command_compile_xml loq@(Loqualization l) = help @d (l10n_help_format_xml l) $ command "xml" $ interleaved $ CommandCompileFormat_XML <<$? option_help loq (help_usage $ command_compile_xml loq) command_schema :: Loq d -> repr (Exit d) ArgCommand CommandSchema command_schema loq@(Loqualization l) = help @d (l10n_help_command_schema l) $ command "schema" $ interleaved $ CommandSchema <<$? option_help loq (help_usage $ command_schema loq) instance Plain.Doc d => CLI d (Plain.Plain d) instance Plain.Doc d => CLI d Read.Parser instance Plain.Doc d => CLI d (Help.Help d) help_usage :: Plain.Doc d => Help.Help d (Exit d) t a -> d help_usage = Help.textHelp Help.defReader { Help.reader_command_indent = 2 , Help.reader_option_indent = 12 } -- * Type 'Lang' -- | Supported locales type Langs = '[FR, EN] type Lang = LocaleIn Langs getLang :: IO Lang getLang = (\v -> Map.findWithDefault (LocaleIn @Langs en_US) (Text.pack $ List.takeWhile (\c -> Char.isAlphaNum c || c == '_') v) (locales @Langs)) . fromMaybe "" <$> Env.lookupEnv "LANG" -- ** Class 'L10n' type Loq d = Loqualization (L10n d) -- | Localization class L10n_Var lang => L10n d lang where l10n_cli :: FullLocale lang -> d l10n_license :: FullLocale lang -> d l10n_help_version :: FullLocale lang -> d l10n_help_license :: FullLocale lang -> d l10n_help_command_source :: FullLocale lang -> d l10n_help_command_compile :: FullLocale lang -> d l10n_help_command_schema :: FullLocale lang -> d l10n_help_opt_lang :: FullLocale lang -> d l10n_help_opt_output :: FullLocale lang -> d l10n_help_opt_output_css :: FullLocale lang -> d l10n_help_opt_output_js :: FullLocale lang -> d l10n_help_opt_dump_tct :: FullLocale lang -> d l10n_help_opt_dump_xml :: FullLocale lang -> d l10n_help_opt_dump_deps :: FullLocale lang -> d l10n_help_opt_dump_dtc :: FullLocale lang -> d l10n_help_format :: FullLocale lang -> d l10n_help_format_plain :: FullLocale lang -> d l10n_help_format_html5 :: FullLocale lang -> d l10n_help_format_xml :: FullLocale lang -> d l10n_help_opt_input :: FullLocale lang -> d l10n_help_opt_help :: FullLocale lang -> d class L10n_Var lang where l10n_var_file :: FullLocale lang -> Name l10n_var_locale :: FullLocale lang -> Name -- * Type 'Doc' data Doc d = Doc d | Var Name deriving Show instance (Semigroup d, IsString d) => Semigroup (Doc d) where Doc x <> Doc y = Doc (x<>y) x <> y = Doc $ runDoc x <> runDoc y instance (Semigroup d, Monoid d, IsString d) => Monoid (Doc d) where mempty = Doc mempty mappend = (<>) instance Doc.Breakable d => IsString (Doc d) where fromString = Doc . Plain.words instance (IsString d, Semigroup d, Monoid d) => IsList (Doc d) where type Item (Doc d) = Doc d toList = pure fromList = Doc . foldMap runDoc instance (IsString d, Semigroup d) => Doc.Trans (Doc d) where type ReprOf (Doc d) = d trans = Doc unTrans = runDoc instance Doc.Breakable d => Doc.Textable (Doc d) instance (Doc.Breakable d, Doc.Indentable d) => Doc.Indentable (Doc d) instance Doc.Breakable d => Doc.Breakable (Doc d) instance (IsString d, Semigroup d, Doc.Decorable d) => Doc.Decorable (Doc d) instance (IsString d, Semigroup d, Doc.Colorable d) => Doc.Colorable (Doc d) instance Plain.Doc d => Plain.Doc (Doc d) runDoc :: (IsString d, Semigroup d) => Doc d -> d runDoc = \case Doc d -> d Var n -> "<"<>fromString n<>">" instance (IsString d, Semigroup d, Monoid d, Doc.Breakable d) => L10n (Doc d) EN where l10n_cli _ = "Compiler of Convivial Technical Document (DTC)." l10n_license _ = fromString $ List.intercalate "\n" [ "License: GNU GPLv3+" , "Copyright: Julien Moutinho " , "" , "hdoc is free software: you can redistribute it and/or modify it" , "under the terms of the GNU General Public License (GPL)" , "as published by the Free Software Foundation;" , "either in version 3, or (at your option) any later version." , "" , "hdoc is distributed in the hope that it will be useful," , "but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY" , "or FITNESS FOR A PARTICULAR PURPOSE." , "" , "See the GNU GPL for more details." , "You should have received a copy of the GNU GPL along with hdoc." , "If not, see: http://www.gnu.org/licenses/" ] l10n_help_version _ = "Show the version of this program." l10n_help_license _ = "Inform about the license of this program." l10n_help_command_source _ = "Format the source code of a TCT document." l10n_help_command_compile _ = "Compile a TCT document into a format optimized for reading." l10n_help_command_schema _ = "Show in RNC (RelaxNG Compact) format the XML schema of the DTC format." l10n_help_opt_lang l = ["Use the language given by ", Var $ l10n_var_locale l, "."] l10n_help_opt_output l = ["Output document into ", Var $ l10n_var_file l] l10n_help_opt_output_css l = [ "Output CSS stylesheet into " , Var $ l10n_var_file l , " (if any), instead of incorporating it into the HTML." ] l10n_help_opt_output_js l = [ "Output JavaScript script into " , Var $ l10n_var_file l , " (if any), instead of incorporating it into the HTML." ] l10n_help_opt_dump_tct l = [ "Dump internal TCT representation of " , Var $ l10n_var_file l,".tct file," , " in a" , Var $ l10n_var_file l,".tct.dump file." ] l10n_help_opt_dump_xml l = [ "Dump internal XML representation of " , Var $ l10n_var_file l,".tct file," , " in a" , Var $ l10n_var_file l,".xml.dump file." ] l10n_help_opt_dump_deps l = [ "Dump dependencies of ", Var $ l10n_var_file l,".tct file" , " in ", Var $ l10n_var_file l,".deps file," , " separated by newlines." ] l10n_help_opt_dump_dtc _ = "Dump internal representation of DTC." l10n_help_opt_help _ = "Show this help." l10n_help_format _ = "Output format." l10n_help_format_plain _ = "Output as plain text." l10n_help_format_html5 _ = "Output as HTML5." l10n_help_format_xml _ = "Output as XML." l10n_help_opt_input l = ["Read input from ", Var $ l10n_var_file l, "."] instance (IsString d , Semigroup d, Monoid d, Doc.Breakable d) => L10n (Doc d) FR where l10n_cli _ = "Compilateur de Document Technique Convivial (DTC)." l10n_license _ = fromString $ List.intercalate "\n" [ "Licence : GPLv3+ GNU" , "Droit d’auteur : Julien Moutinho " , "" , "hdoc est un logiciel libre : vous pouvez le redistribuer et/ou le modifier" , "selon les termes de la Licence Publique Générale (GPL) GNU" , "telle que publiée par la Free Software Foundation ;" , "en version 3, ou (à votre choix) n’importe quelle version ultérieure." , "" , "hdoc est distribué dans l’espoir qu’il sera utile," , "mais SANS AUCUNE GARANTIE ; sans même la garantie implicite de COMMERCIALISATION" , "ou de CONVENANCE À UN BUT PARTICULIER." , "" , "Voyez la GPL pour davantage de détails." , "Vous devriez avoir reçu une copie de la GPL avec hdoc." , "Si non, voyez : http://www.gnu.org/licenses/" ] l10n_help_version _ = "Affiche la version de ce logiciel." l10n_help_license _ = "Informe sur la licence de ce logiciel." l10n_help_command_source _ = "Lit un document TCT et écrit un rendu préservant sa syntaxe." l10n_help_command_compile _ = "Compile un document TCT vers un format optimisé pour la lecture." l10n_help_command_schema _ = "Affiche au format RNC (RelaxNG Compact) le schéma XML du format DTC." l10n_help_opt_lang l = ["Utilise le langage indiqué par ", Var $ l10n_var_locale l, "."] l10n_help_opt_output l = ["Écrit dans ", Var $ l10n_var_file l, "."] l10n_help_opt_output_css l = [ "Écrit la feuille de style CSS dans " , Var $ l10n_var_file l , ", au lieu de l’incorporer dans le HTML." ] l10n_help_opt_output_js l = [ "Écrit le script JavaScript dans " , Var $ l10n_var_file l , ", au lieu de l’incorporer dans le HTML." ] l10n_help_opt_dump_tct l = [ "Écrit la représentation TCT interne de " , Var $ l10n_var_file l,".tct," , " dans " , Var $ l10n_var_file l,".tct.dump." ] l10n_help_opt_dump_xml l = [ "Écrit la représentation XML interne de " , Var $ l10n_var_file l,".tct," , " dans " , Var $ l10n_var_file l,".xml.dump." ] l10n_help_opt_dump_deps l = [ "Écrit les dépendences de ", Var $ l10n_var_file l,".tct" , " dans ", Var $ l10n_var_file l,".deps," , " séparées par des retours à la ligne." ] l10n_help_opt_dump_dtc _ = "Écrit la représentation interne du DTC." l10n_help_opt_help _ = "Affiche cette aide." l10n_help_format _ = "Format de sortie." l10n_help_format_plain _ = "Produit du texte brut." l10n_help_format_html5 _ = "Produit du HTML5." l10n_help_format_xml _ = "Produit du XML." l10n_help_opt_input l = ["Lit depuis ", Var $ l10n_var_file l, "."] instance L10n_Var EN where l10n_var_file _ = "file" l10n_var_locale _ = "locale" instance L10n_Var FR where l10n_var_file _ = "fichier" l10n_var_locale _ = "locale"