GF shell: fix a parsing problem with the cc command

This patch fixes a problem introduced last year when the GF shell was
refactored to allow more commands to be treated uniformly and be part
of pipes. The cc command was one of those commands, but unfortunately this
introduced a parsing problem, e.g.

	> cc "last"
	constant not found: last

	> cc "last"++"year"
	command not parsed: cc "last"++"year"

This happened because the generic command line parser in
GF.Command.{Abstract,Parse} assumes that all commands have an argument of
type PGF.Expr. Commands that expect other types of arguments have to
use PGF.showExpr combined with other conversion to the argument type they
expect. The cc command excpets a GF.Grammar.Term, and unfortunately not 
all terms survice the roundtrip through PGF.Expr, in part because of
an additional hack to allow strings to be roundtripped through PGF.Expr
without adding superfluous double quotes.

To solve the problem, this patch

 + makes room for arguments of type Term in the Argument type in
   GF.Command.Abstract.
   
 + makes a special case for the cc command in GF.Command.Parse, by
   calling the partial parser 'runPartial pTerm' recently added in
   GF.Grammar.Lexer and GF.Grammar.Parser. Care was taken so that
   that "|" and ";" can be used both inside terms and as separators between
   commands in the shell, e.g. things like the following now work:

       > cc ("a"|"b") | ps -lexcode
       variants { "a" ; "b" }

 + introduces a type CommandArgument that replaces [Expr] as the
   type of values passed between commands in pipes. It has room for
   values of type [Expr], [String] and Term, thus eliminating the need
   to roundtrip through the Expr type all the time.
   The hack to avoid adding superfluous quotes when strings are
   roundtripped through Expr has been left in place for now,
   but can probably be removed.

src/compiler/GF/Command/Interpreter.hs

@@ -33,29 +33,31 @@ interpretPipe env cs = do
      putStrLnE s
      return ()
   where
-   intercs [] treess = return treess
-   intercs (c:cs) (Piped (trees,_)) = interc c trees >>= intercs cs
+   intercs [] args = return args
+   intercs (c:cs) (Piped (args,_)) = interc c args >>= intercs cs
 
-   interc comm@(Command co opts arg) es =
+   interc comm@(Command co opts arg) args =
      case co of
        '%':f -> case Map.lookup f (commandmacros env) of
          Just css ->
-           do es <- getCommandTrees env False arg es
-              mapM_ (interpretPipe env) (appLine es css)
+           do args <- getCommandTrees env False arg args
+              mapM_ (interpretPipe env) (appLine args css)
               return void
          Nothing  -> do
            putStrLnE $ "command macro " ++ co ++ " not interpreted"
            return void
-       _ -> interpret env es comm
+       _ -> interpret env args comm
 
    appLine = map . map . appCommand
 
 -- | macro definition applications: replace ?i by (exps !! i)
-appCommand :: [Expr] -> Command -> Command
-appCommand xs c@(Command i os arg) = case arg of
+appCommand :: CommandArguments -> Command -> Command
+appCommand args c@(Command i os arg) = case arg of
   AExpr e -> Command i os (AExpr (app e))
   _       -> c
  where
+  xs = toExprs args
+
   app e = case e of
     EAbs b x e -> EAbs b x (app e)
     EApp e1 e2 -> EApp (app e1) (app e2)
@@ -97,14 +99,15 @@ checkOpts info opts =
     os  -> fail $ "options not interpreted: " ++ unwords os
 
 --getCommandTrees :: CommandEnv -> Bool -> Argument -> [Expr] -> Either String [Expr]
-getCommandTrees env needsTypeCheck a es =
+getCommandTrees env needsTypeCheck a args =
   case a of
     AMacro m -> case Map.lookup m (expmacros env) of
                   Just e -> one e
-                  _      -> return [] -- report error?
+                  _      -> return (Exprs []) -- report error?
     AExpr e -> if needsTypeCheck
                then one =<< typeCheckArg e
                else one e
-    ANoArg  -> return es  -- use piped
+    ATerm t -> return (Term t)
+    ANoArg  -> return args  -- use piped
   where
-    one e = return [e] -- ignore piped
+    one e = return (Exprs [e]) -- ignore piped