Разбор аргументов командной строки из STRING в Clojure

Question

Я нахожусь в ситуации, когда мне нужно проанализировать аргументы из строки таким же образом, как они были бы проанализированы, если предоставлены в командной строке для приложения Java / Clojure.

Например, мне нужно превратить "foo \"bar baz\" 'fooy barish' foo" в ("foo" "bar baz" "fooy barish" "foo").

Мне любопытно, есть ли способ использовать парсер, который Java или Clojure используют для этого. Я не против использования регулярных выражений, но я отстой в регулярных выражениях, и я бы сильно не справился бы, если бы попытался написать один для этого.

Есть идеи?

Answer 1

Обновлено с новой, еще более запутанной версией. Это официально смешно; следующая итерация будет использовать правильный синтаксический анализатор (или c.c.monads и немного парсекоподобной логики поверх этого). См. Историю изменений в этом ответе для оригинала.

Кажется, что этот запутанный набор функций делает свое дело (не в моем DRYest с этим, извините!):

(defn initial-state [input]
  {:expecting nil
   :blocks (mapcat #(str/split % #"(?<=\s)|(?=\s)")
                   (str/split input #"(?<=(?:'|\"|\\))|(?=(?:'|\"|\\))"))
   :arg-blocks []})

(defn arg-parser-step [s]
  (if-let [bs (seq (:blocks s))]
    (if-let [d (:expecting s)]
      (loop [bs bs]
        (cond (= (first bs) d)
              [nil (-> s
                       (assoc-in [:expecting] nil)
                       (update-in [:blocks] next))]
              (= (first bs) "\\")
              [nil (-> s
                       (update-in [:blocks] nnext)
                       (update-in [:arg-blocks]
                                  #(conj (pop %)
                                         (conj (peek %) (second bs)))))]
              :else
              [nil (-> s
                       (update-in [:blocks] next)
                       (update-in [:arg-blocks]
                                  #(conj (pop %) (conj (peek %) (first bs)))))]))
      (cond (#{"\"" "'"} (first bs))
            [nil (-> s
                     (assoc-in [:expecting] (first bs))
                     (update-in [:blocks] next)
                     (update-in [:arg-blocks] conj []))]
            (str/blank? (first bs))
            [nil (-> s (update-in [:blocks] next))]
            :else
            [nil (-> s
                     (update-in [:blocks] next)
                     (update-in [:arg-blocks] conj [(.trim (first bs))]))]))
    [(->> (:arg-blocks s)
          (map (partial apply str)))
     nil]))

(defn split-args [input]
  (loop [s (initial-state input)]
    (let [[result new-s] (arg-parser-step s)]
      (if result result (recur new-s)))))

Отчасти обнадеживает следующее: true:

(= (split-args "asdf 'asdf \" asdf' \"asdf ' asdf\" asdf")
   '("asdf" "asdf \" asdf" "asdf ' asdf" "asdf"))

Так же это:

(= (split-args "asdf asdf '  asdf \" asdf ' \" foo bar ' baz \" \" foo bar \\\" baz \"")
   '("asdf" "asdf" "  asdf \" asdf " " foo bar ' baz " " foo bar \" baz "))

Надеюсь, это должно обрезать обычные аргументы, но не те, которые заключены в кавычки, обрабатывать двойные и одинарные кавычки, включая двойные кавычки в двойных кавычках (обратите внимание, что в настоящее время одинарные кавычки внутри одинарных кавычек обрабатываются таким же образом, очевидно, расходится с * nix shell способом ... аааа) и т. д. Обратите внимание, что это в основном вычисления в специальной монаде состояния, только что написанные особенно уродливо и крайне нуждающиеся в СУШКЕ. : -Р

Answer 2

Это доставило мне неприятности, поэтому я запустил его в ANTLR.Приведенная ниже грамматика должна дать вам представление о том, как это сделать.Он включает элементарную поддержку escape-последовательностей с обратной косой чертой.

Работа с ANTLR в Clojure - это слишком много, чтобы писать в этом текстовом поле.Я написал в блоге запись об этом.

grammar Cmd;

options {
    output=AST;
    ASTLabelType=CommonTree;
}

tokens {
    DQ = '"';
    SQ = '\'';
    BS = '\\';
}

@lexer::members {
    String strip(String s) {
        return s.substring(1, s.length() - 1);
    }
}

args: arg (sep! arg)* ;
arg : BAREARG
    | DQARG 
    | SQARG
    ;
sep :   WS+ ;

DQARG  : DQ (BS . | ~(BS | DQ))+ DQ
        {setText( strip(getText()) );};
SQARG  : SQ (BS . | ~(BS | SQ))+ SQ
        {setText( strip(getText()) );} ;
BAREARG: (BS . | ~(BS | WS | DQ | SQ))+ ;

WS  :   ( ' ' | '\t' | '\r' | '\n');

Answer 3

Я закончил этим:

(filter seq
        (flatten
         (map #(%1 %2)
              (cycle [#(s/split % #" ") identity])
              (s/split (read-line) #"(?<!\\)(?:'|\")"))))