;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Skeleton code for A10Q1. Replace this with your own header, and
;; fill in the relevant fragments of code and functions below.
;;
(define-struct stag (name attrs))
(define-struct etag (name))
;; An attribute is of the form (list n t), where n and t are strings.
;; A start-tag is (make-stag n a), where n in a string and a is a
;; (listof attribute).
;; An end-tag is (make-etag n), where n is a string.
;; A tag is a start-tag or an end-tag.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Basic helper functions to extract tokens from a list of characters,
;; inspired by the code on Slides 35 and 36 of Module 10.
;;
;; get-token-until: (char -> boolean) (listof char) -> (listof char)
;; Produce the prefix of the passed-in list of characters consisting
;; of all characters up to but not including the first one which
;; satisfies the predicate break?. Assume that we will find a
;; character that satisfies the predicate before we run out of list.
;; Examples:
(check-expect (get-token-until char-alphabetic? '(#\a #\1 #\2)) empty)
(check-expect (get-token-until char-alphabetic? '(#\1 #\a #\b #\2 #\3 #\4)) '(#\1))
(define (get-token-until break? a-chl)
(cond
[(break? (first a-chl)) empty]
[else (cons (first a-chl) (get-token-until break? (rest a-chl)))]))
;; Tests:
(check-expect (get-token-until char-alphabetic? '(#\1 #\2 #\a #\b #\3 #\4 #\c)) '(#\1 #\2))
;; remove-token-while: (char -> boolean) (listof char) -> (listof char)
;; Produce the suffix of the passed-in list consisting of all
;; characters beginning with the first one which does not satisfy
;; the predicate while?. (This is slightly different from
;; remove-token in the notes, which produces the suffix starting
;; *after* the first character that satisfies the predicate.)
;; Examples:
(check-expect (remove-token-while char-alphabetic? '(#\a #\1 #\2)) '(#\1 #\2))
(check-expect (remove-token-while char-alphabetic? '(#\1 #\a)) '(#\1 #\a))
(define (remove-token-while while? a-chl)
(cond
[(empty? a-chl) empty]
[(while? (first a-chl)) (remove-token-while while? (rest a-chl))]
[else a-chl]))
; Tests:
(check-expect (remove-token-while char-alphabetic? '(#\a #\b #\c #\1 #\d #\2)) '(#\1 #\d #\2))
(check-expect (remove-token-while char-alphabetic? '(#\a #\b #\c)) empty)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Here's the code you need to write for Part (a).
;;
;; parse-tag-loc: [contract here]
;; [purpose here]
;; Examples:
;; [examples here]
(define (parse-tag-loc loc)
;; [function body here]
...)
;; parse-tag: string -> tag
;; Consume the first XML tag found in the input string and return it
;; as a tag according to the data definition above.
;; Examples:
(check-expect (parse-tag " <a b = \"c\" d=\"e\" >") (make-stag "a" '(("b" "c") ("d" "e"))))
(check-expect (parse-tag "</xml>") (make-etag "xml"))
(define (parse-tag s)
(parse-tag-loc (string->list s)))
;; Tests:
;; Examples suffice for this wrapper function. You'll need more in-depth
;; tests for parse-tag-loc.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; There's no specific work for you to do with these next two functions.
;; These functions serve two purposes. The function get-all-tags calls
;; parse-tag-loc above, and you should ensure that your implementation
;; of parse-tag-loc is compatible with get-all-tags (that is, the tests
;; for get-all-tags should work). The function parse-xml is mainly useful
;; to you in the solution to 1(b), since it makes it easy to generate
;; interested test cases for balanced-tags?.
;;
;; get-all-tags: (listof char) -> (listof tag)
;; Given a full XML document represented as a list of characters,
;; produce the associated list of XML tags. You must make sure
;; that your parse-tag-loc function above is compatible with this
;; function in the sense that these tests pass.
;; Examples:
(check-expect (get-all-tags empty) empty)
(check-expect (get-all-tags (string->list "<a><b></b><c></c><d>"))
(list (make-stag "a" empty)
(make-stag "b" empty)
(make-etag "b")
(make-stag "c" empty)
(make-etag "c")
(make-stag "d" empty)))
(define (get-all-tags loc)
(local
[(define start
(remove-token-while
(lambda © (not (char=? c #\<))) loc))]
(cond
[(empty? start) empty]
[else (cons (parse-tag-loc start)
(get-all-tags
(rest (remove-token-while
(lambda © (not (char=? c #\>))) start))))])))
;; Tests:
(check-expect (get-all-tags (string->list " < a > < /a > "))
(list (make-stag "a" empty)
(make-etag "a")))
(check-expect (get-all-tags (string->list "</a></a></a><bbb><cccccc>"))
(list (make-etag "a") (make-etag "a") (make-etag "a")
(make-stag "bbb" empty) (make-stag "cccccc" empty)))
;; parse-xml: string -> (listof tag)
;; Given a full XML document represented as a string,
;; produce the associated list of XML tags.
;; Examples:
(check-expect (parse-xml "") empty)
(check-expect (parse-xml "<a><b></b><c></c><d>")
(list (make-stag "a" empty)
(make-stag "b" empty)
(make-etag "b")
(make-stag "c" empty)
(make-etag "c")
(make-stag "d" empty)))
(define (parse-xml s)
(get-all-tags (string->list s)))
;; Tests:
;; Examples are adequate here. The main testing will be done in
;; get-all-tags.
;; balanced-tags?: [contract here]
;; [purpose here]
;; Examples:
;; [examples here]
(define (balanced-tags? lot) ...)
;; Tests:
;; [tests here]
