Como faço para iterate através de um diretório em Common Lisp?

StackOverflow https://stackoverflow.com/questions/1403717

Pergunta

Eu estou usando OpenMCL em Darwin, e eu gostaria de fazer algo como: 

(loop for f in (directory "somedir")
  collect (some-per-file-processing f))

Mas eu não consigo directory para retorno outra coisa senão NIL, e eu não consigo encontrar qualquer boa explicação em linha (diferente de "sua diferente para cada sistema").

Os ponteiros?

Foi útil?

Solução

A sua especificação caminho contêm um curinga? material caminho do Common Lisp é um pouco difícil de entender no início - pelo menos para mim foi ... Como o CLHS membros sobre a função directory:

Se o pathspec não é selvagem, o lista resultante irá conter elementos zero ou um.

A fim de ter o seu caminho incluem um curinga, você pode tentar a função make-caminho, como 

(directory (make-pathname :directory '(:absolute "srv" "hunchentoot") :name :wild :type "lisp"))

Ou mesmo 

(directory (make-pathname :directory '(:absolute "srv" "hunchentoot") :name :wild :type :wild))

Eu encontrei o CL-FAD biblioteca de uma grande ajuda para lidar com caminhos eo sistema de arquivos . Em particular, a sua list-directory função pode ser mais fácil de usar do que a função directory padrão simples.

Outras dicas

Existem basicamente duas formas de especificar caminhos:

  • usando cordas

Strings são, obviamente, dependendo da plataforma:. Sintaxe Unix sintaxe vs. Windows, por exemplo 

"/Users/foo/bar.text"  is a valid pathname
"/Users/foo/*/foo.*"   is a valid pathname with two wildcards

Você pode criar um objeto de caminho a partir de uma string: 

? (pathname "/Users/bar/foo.text")
#P"/Users/bar/foo.text"

O #p acima assegura que um objeto caminho (e não uma string) é criado, quando você lê-lo de volta. 

? #P"/Users/bar/foo.text"
#P"/Users/bar/foo.text"

Assim, internamente Common Lisp funciona com objetos nome de caminho, mas permite usar strings normais e faz objetos pathname a partir deles, se necessário.

Quando Lisp comum vê um caminho que tem nem todos os componentes especificados (por exemplo, o diretório está faltando), então ele preenche os componentes do objeto de caminho que é o valor da variabel * default-nome de caminho-defaults *.

Com a função DESCREVER você pode olhar para os componentes de um caminho (aqui Clozure CL): 

? (describe (pathname "/Users/bar/*.text"))
#P"/Users/bar/*.text"
Type: PATHNAME
Class: #<BUILT-IN-CLASS PATHNAME>
TYPE: (PATHNAME . #<CCL::CLASS-WRAPPER PATHNAME #x3000401D03BD>)
%PATHNAME-DIRECTORY: (:ABSOLUTE "Users" "bar")
%PATHNAME-NAME: :WILD
%PATHNAME-TYPE: "text"
%PHYSICAL-PATHNAME-VERSION: :NEWEST
%PHYSICAL-PATHNAME-DEVICE: NIL
  • usando o nome de caminho funções Lisp criando objetos

Faça-PATHNAME é a função e leva alguns argumentos de palavra-chave para especificar os componentes.

Às vezes, ele também é útil para criar um novo caminho baseado em um já existente: 

(make-pathname :name "foo" :defaults (pathname "/Users/bar/baz.text"))

Se você usar o diretório é útil para usar um caminho com curingas. DIRETÓRIO seguida, irá retornar uma lista de caminhos correspondentes. O nome 'Diretório' é um pouco enganador, uma vez diretório não listar o conteúdo de um diretório, mas lista os caminhos que combinam para (geralmente) um caminho com curingas. Os curingas podem corresponder a uma sequência de caracteres em componentes como /foo/s*c/list*.l*". Há também o wild card **, que é usado para combinar partes de uma hierarquia de diretório como / foo / ** /test.lisp, o que corresponde a todos os arquivos test.lisp sob o foo diretório e seus subdiretórios. 

(directory "/Users/foo/Lisp/**/*.lisp")

Acima deve retornar uma lista de todos os arquivos 'lisp' em '/ Users / foo / Lisp /' e todos os seus subdiretórios.

Para retornar os arquivos .c em uma única utilização diretório: 

(directory "/Users/foo/c/src/*.c")

Note que o diretório retorna uma lista de objetos Pathname (não uma lista de strings). 

? (directory (make-pathname
               :name "md5"
               :type :wild
               :directory '(:absolute "Lisp" "cl-http" "cl-http-342" "server")))
(#P"/Lisp/cl-http/cl-http-342/server/md5.lisp"
 #P"/Lisp/cl-http/cl-http-342/server/md5.xfasl")

Acima usa um objeto de caminho que é criado por MAKE-PATHNAME. Ele retorna todos os arquivos que correspondem /Lisp/cl-http/cl-http-342/server/md5.*.

Este é o mesmo que: 

(directory "/Lisp/cl-http/cl-http-342/server/md5.*")

que é mais curto, mas depende da sintaxe caminho Unix.

A biblioteca Lisp Comum diretório implementação moderna listando é IOLIB .

Ele funciona assim: 

CL-USER> (iolib.os:list-directory "/etc/apt")
(#/p/"trusted.gpg~" #/p/"secring.gpg" #/p/"trustdb.gpg" #/p/"sources.list"
 #/p/"sources.list~" #/p/"apt-file.conf" #/p/"apt.conf.d" #/p/"trusted.gpg"
 #/p/"sources.list.d")

Note que nenhuma barra à direita ou curingas são obrigatórios. Ele é muito robusto e pode até mesmo nomes de arquivo processo com caracteres Unicode codificados incorretamente.

As diferenças em relação ao CL-FAD:

  • Os objetos que você tem são caminhos de arquivo IOLIB, um substituto para caminhos do CL que é mais perto que o sistema operacional subjacente faz.
  • IOLIB implementa suas rotinas usando CFFI, por isso funciona da mesma em todas as implementações Lisp (desde IOLIB tem um backend para o sistema operacional), em contraste com CL-FAD, que tenta abstrato sobre função DIRECTORY da implementação com toda a sua peculiaridades.
  • Em contraste com CL-FAD, iolib lida corretamente com links simbólicos (uma questão importante com CL-FAD que torna praticamente inutilizável em diferentes do Windows IMHO plataformas).

Vou acrescentar um exemplo que funciona para mim, por causa de um trecho de código. Eu uso osicat (semelhante ao CL-fad) e str .

Editar : também com uiop:directory-files. str: contém? poderia ser feito com search. 

;; searching for "ref".
(setf *data-directory* "~/books/lisp")
(remove-if-not (lambda (it)
                   (str:contains? "ref" (namestring it)))
                (osicat:list-directory *data-directory*))

volta 

(#P"~/books/lisp/common-lisp-quick-reference-clqr-a4-booklet-all.pdf"
 #P"~/books/lisp/common-lisp-quick-reference-clqr-a4-consec.pdf"
 #P"~/books/lisp/commonLisp-interactive-approach-reference-buffalo.pdf")

Ele certamente pode ser melhorado o meu um uso adequado dos wildcards. No entanto, que é um trecho que você pode usar agora:)

Referências:

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top