Парсинг параметров командной строки от СТРОКИ в Clojure
Я нахожусь в ситуации, где я должен проанализировать аргументы от строки таким же образом, что они были бы проанализированы, если обеспечено на командной строке к приложению Java/Clojure.
Например, я должен повернуться "foo \"bar baz\" 'fooy barish' foo" в ("foo" "bar baz" "fooy barish" "foo").
Мне любопытно, если существует способ использовать синтаксический анализатор что Java или использование Clojure, чтобы сделать это. Я не настроен против использования regex, но я сосу в regexes, и я перестал бы работать трудно, если бы я пытался записать один для этого.
Какие-либо идеи?
2 ответа
Обновлено с добавлением новой, еще более запутанной версии. Официально это смешно; следующая итерация будет использовать правильный синтаксический анализатор (или c.c.monads и немного логики, подобной Parsec). См. Историю изменений этого ответа для оригинала.
Эта запутанная связка функций, кажется, помогает (не в моем 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 ... argh) и т. д. Обратите внимание, что это в основном вычисление в монаде ad-hoc состояния, только что написанное особенно уродливым способом и остро нуждающееся в СУШКЕ. :-P
Это меня беспокоило, поэтому я заставил его работать в ANTLR. Приведенная ниже грамматика должна дать вам представление о том, как это сделать. Она включает рудиментарную поддержку последовательности обратного слеша.
Заставить 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');