allow spaces between command options; option -treebank in linearize

src-3.0/GF/Command/Commands.hs

@@ -133,16 +133,12 @@ allCommands pgf = Map.fromList [
   ("l", emptyCommandInfo {
      longname = "linearize",
      synopsis = "convert an abstract syntax expression to string",
-     explanation = "Shows all linearization forms of Tree by the actual grammar\n"++
+     explanation = unlines [
-                   "(which is overridden by the -lang flag).\n"++
+       "Shows the linearization of a Tree by the actual grammar",
-                   "The pattern list has the form [P, ... ,Q] where P,...,Q follow GF\n"++
+       "(which is overridden by the -lang flag)."
-                   "syntax for patterns. All those forms are generated that match with the\n"++
+       ],
-                   "pattern list. Too short lists are filled with variables in the end.\n"++
-                   "Only the -table flag is available if a pattern list is specified.\n"++
-                   "HINT: see GF language specification for the syntax of Pattern and Term.\n"++
-                   "You can also copy and past parsing results.",
      exec = \opts -> return . fromStrings . map (optLin opts),
-     options = ["all","record","table","term"],
+     options = ["all","record","table","term", "treebank"],
      flags = ["lang"]
      }),
 
@@ -207,7 +203,11 @@ allCommands pgf = Map.fromList [
    lin opts t = unlines [linearize pgf lang t    | lang <- optLangs opts]
    par opts s = concat  [parse pgf lang (optCat opts) s | lang <- optLangs opts]
  
-   optLin opts t = unlines [linea lang t | lang <- optLangs opts] where
+   optLin opts t = case opts of 
+     _ | isOpt "treebank" opts -> unlines $ (abstractName pgf ++ ": " ++ showExp t) :
+          [lang ++ ": " ++ linea lang t | lang <- optLangs opts]
+     _ -> unlines [linea lang t | lang <- optLangs opts] 
+    where
      linea lang = case opts of
        _ | isOpt "all"    opts -> allLinearize pgf (mkCId lang)
        _ | isOpt "table"  opts -> tableLinearize pgf (mkCId lang)

src-3.0/GF/Command/Interpreter.hs

@@ -61,7 +61,7 @@ interpret env trees0 comm = case lookCommand co comms of
    comms = commands env
    checkOpts info = 
      case
-       [o | OOpt  o   <- opts, notElem o (options info)] ++
+       [o | OOpt  o   <- opts, notElem o ("tr" : options info)] ++
        [o | OFlag o _ <- opts, notElem o (flags info)]
       of
         []  -> return () 

src-3.0/GF/Command/Parse.hs

@@ -20,7 +20,8 @@ pPipe = RP.sepBy (RP.skipSpaces >> pCommand) (RP.skipSpaces >> RP.char '|')
 pCommand = do
   cmd  <- pIdent
   RP.skipSpaces
-  opts <- RP.many pOption
+  opts <- RP.sepBy pOption RP.skipSpaces
+--  opts <- RP.many pOption
   arg  <- RP.option ANoArg (fmap AExp (pExp False))
   return (Command cmd opts arg)
 

src-3.0/PGF/Morphology.hs

@@ -1,6 +1,6 @@
 module PGF.Morphology where
 
-import PGF.ShowLinearize
+import PGF.ShowLinearize (collectWords)
 import PGF.Data
 import PGF.CId
 
@@ -30,17 +30,3 @@ type Analysis = String
 noAnalysis :: [(Lemma,Analysis)]
 noAnalysis = []
 
-collectWords :: PGF -> CId -> [(String, [(Lemma,Analysis)])]
-collectWords pgf lang = 
-    concatMap collOne 
-      [(f,c,0) | (f,(DTyp [] c _,_)) <- Map.toList $ funs $ abstract pgf] 
-  where
-    collOne (f,c,i) = 
-      fromRec f [prCId c] (recLinearize pgf lang (EApp f (replicate i (EMeta 888))))
-    fromRec f v r = case r of
-      RR  rs -> concat [fromRec f v t | (_,t) <- rs] 
-      RT  rs -> concat [fromRec f (p:v) t | (p,t) <- rs]
-      RFV rs -> concatMap (fromRec f v) rs
-      RS  s  -> [(s,[(prCId f,unwords (reverse v))])]
-      RCon c -> [] ---- inherent
-

src-3.0/PGF/ShowLinearize.hs

@@ -1,5 +1,5 @@
 module PGF.ShowLinearize (
-  Record (..), recLinearize, --- used in PGF.Morphology
+  collectWords,
   tableLinearize,
   recordLinearize,
   termLinearize,
@@ -13,6 +13,7 @@ import PGF.Linearize
 
 import GF.Data.Operations
 import Data.List
+import qualified Data.Map as Map
 
 -- printing linearizations in different ways with source parameters
 
@@ -85,3 +86,18 @@ termLinearize :: PGF -> CId -> Exp -> String
 termLinearize pgf lang = show . linExp pgf lang
 
 
+-- for Morphology: word, lemma, tags
+collectWords :: PGF -> CId -> [(String, [(String,String)])]
+collectWords pgf lang = 
+    concatMap collOne 
+      [(f,c,0) | (f,(DTyp [] c _,_)) <- Map.toList $ funs $ abstract pgf] 
+  where
+    collOne (f,c,i) = 
+      fromRec f [prCId c] (recLinearize pgf lang (EApp f (replicate i (EMeta 888))))
+    fromRec f v r = case r of
+      RR  rs -> concat [fromRec f v t | (_,t) <- rs] 
+      RT  rs -> concat [fromRec f (p:v) t | (p,t) <- rs]
+      RFV rs -> concatMap (fromRec f v) rs
+      RS  s  -> [(s,[(prCId f,unwords (reverse v))])]
+      RCon c -> [] ---- inherent
+