Question

I have a problem with common lisp.

I want to pass a string to a function
and want that this strings become a structure.
I can’t use external library.

For example with this input:

(testfu "ftp/http.ok:3345")

This is the struct:

(defstruct test-struct
    scheme 
    part
    ans     
port)

I want this result:

scheme: “ftp” part: “http” ans “ok” port “3345”

How can I do the testfu ?

here my bad try 🙁

(defun testfu (x) 
(setq ur1 (make-test-struct :scheme frist x :host second x)))

Answer 1

You will have to parse the data out of the string in order that you might use it for your strut. Lisp won’t do that magically.

Split Sequence is a good library for doing that

If you don’t want a library, then some code to get you on the correct track. This will tokenize string based on a predicate function fn ( which returns true when a character is a delimiter and false otherwise )

(defun split-by-fn (fn string)
  (let* ((STARTING 0)
         (TOKEN 1)
         (DELIM 2)
         (state STARTING)
         (a-token "")
         (the-list '())
         (str-length (length string)))
    (dotimes (i str-length)
      (if (funcall fn (char string i))
          (progn
            (if (eq state TOKEN)
                (progn
                  (setq the-list (cons a-token the-list))
                  (setq a-token "")))
            (setq state DELIM))
        (progn
          (setq a-token
                (concatenate 'string a-token (string (char string i))))
          (setq state TOKEN))))
    (if (eq state TOKEN)
        (setq the-list (cons a-token the-list)))
    (setq the-list (reverse the-list))))

I don’t usually write code for people but here is an example parser, it’s not the most lisp-y, there are better ways of doing this, but it works.

(defun parser ( string )
  (labels ((set-field (state struct token)
            (let ((SCHEME 0)
                  (PART   1)
                  (ANS    2)
                  (PORT   3))
            (cond ((= state SCHEME) 
                    (setf (example-struct-SCHEME struct) token))
                  ((= state PART)  
                    (setf (example-struct-PART struct) token))
                  ((= state ANS)  
                    (setf (example-struct-ANS struct) token))
                  ((= state PORT)  
                    (setf (example-struct-PORT struct) token))))))
    (let ((state  0)
          (token "")
          (check 0)
          (a-list '())
          (struct (make-example-struct)))
      (loop for char across string do
        (progn
          (setq check (position char "/.:"))
          (if check
            (progn
              (set-field state struct token)
              (setq token "")
              (setq state (+ check 1)))
            (setq token (concatenate 'string token (string char))))))
      (progn
        (if (/= 0 (length token))
          (set-field state struct token))
          struct))))