Liblouis Table Specification

(def table (compile-table))

(defn translate [input typeform]
  ""
  {:pre [(= (count input) (count typeform))]}
  (let [;; pass 0
        tmp (make-corrections input)
        ;; pass 1
        syl-info (mark-syllables tmp1)
        cap-info (mark-capitals tmp1)
        tmp (loop [pos 0
                   tmp2 []
                   prev-rules []
                   emph-info []]
              (if (>= pos (count tmp))
                tmp2
                (if-let [[pos tmp2] (maybe-translate-comp-braille tmp typeform pos tmp2)]
                  (recur pos tmp2 prev-rules emph-info)
                  (let [[tmp2 emph-info] (maybe-insert-emph-indicator tmp typeform emph-info pos tmp2)
                        rule (select-rule tmp syl-info cap-info pos prev-rules)]
                    (if (= (rule-type rule) :compbrl)
                      (let [[pos tmp2] (do-compbrl tmp pos tmp2)]
                        (recur pos tmp2 prev-rules emph-info))
                      (let [tmp2 (or (maybe-insert-num-indicator tmp pos rule prev-rules tmp2)
                                     (maybe-insert-let-indicator tmp pos rule tmp2)
                                     (maybe-insert-cap-indicator tmp pos tmp2)
                                     tmp2)
                            tmp2 (if (= (rule-type rule) :largesign)
                                   (trim-trailing-space tmp2)
                                   tmp2)]
                        (let [[pos tmp2] (do-translation tmp pos rule tmp2)
                              prev-rules (conj prev-rules rule)]
                          (recur pos tmp2 prev-rules emph-info))))))))
        ;; pass 2 to 4
        tmp (loop [n 2
                   tmp tmp]
              (if (> n 4)
                tmp
                (recur (+1 n)
                       (loop [pos 0
                              tmp2 []]
                         (if (>= pos (count tmp))
                           tmp2
                           (if-let [rule (select-multipass-rule tmp pos n)]
                             (let [[pos tmp2] (do-translation tmp pos rule tmp2)]
                               (recur pos tmp2))
                             (let [tmp2 (conj tmp2 (tmp pos))
                                   pos (+1 pos)]
                               (recur pos tmp2))))))))]
    tmp))

(defn make-corrections [input]
  "(See opcode correct.)")

(defn mark-syllables [input]
  "(See opcode syllable.)")

(defn mark-capitals [input]
  "(See opcode uplow.)")

(defn maybe-translate-comp-braille [input typeform pos output]
  "Maybe translate part of the `input' starting at position `pos' as
computer braille, based on the `typeform' parameter. (See opcodes
begcomp and endcomp.)"
  {:pre [(= (count input) (count typeform))
         (< pos (count input))]
   :post [(if-let [[new-pos new-output] %]
            (and (> new-pos pos)
                 (only-appended? output new-output)
                 (> (count new-output) (count output)))
            true)]})

(defn maybe-insert-emph-indicator [input typeform emph-info pos output]
  "Maybe insert an emphasis indicator based on the `typeform'
parameter at position `pos' and info `emph-info' from previous
iterations. Maybe mark positions in the input for future insertion of
emphasis indicators. (See opcodes singleletter__, firstletter__,
lastletter__, firstword__, lastword__before, lastword__after and
len__phrase.)"
  {:pre [(= (count input) (count typeform))
         (< pos (count input))]
   :post [(let [[new-output new-emph-info] %]
            (and (only-appended? output new-output)
                 (only-appended? emph-info new-emph-info)))]})

(defn select-rule [input syl-info cap-info pos prev-rules]
  "Select a translation rule that matches the `input' at position
  `pos', based on info about syllable and capital positions, and a
  list of previously applied rules.")

(defn do-compbrl [input pos output]
  "")

(defn maybe-insert-num-indicator [input pos rule prev-rules output]
  ""
  {:post [(if-let [new-output %]
            (and (only-appended? output new-output)
                 (> (count new-output) (count output)))
            true)]})

(defn maybe-insert-let-indicator [input pos rule output]
  ""
  {:post [(if-let [new-output %]
            (and (only-appended? output new-output)
                 (> (count new-output) (count output)))
            true)]})

(defn maybe-insert-cap-indicator [input pos output]
  ""
  {:post [(if-let [new-output %]
            (and (only-appended? output new-output)
                 (> (count new-output) (count output)))
            true)]})

(defn trim-trailing-space [output]
  "Trim trailing space characters from `output'."
  {:post [(= % (take (count %) output))]})

(defn do-translation [input pos rule output]
  "Apply the translation rule on `input' at position `pos'."
  {:post [(let [[new-pos new-output] %]
            (and (> new-pos pos)
                 (only-appended? output new-output)))]})

(defn select-multipass-rule [input pos n]
  "Select a multipass translation rule for pass `n' that matches the
  `input' at position `pos'. (See opcodes pass2, pass3 and pass4)."
  {:pre [(#{2 3 4} n)]
   :post [(if-let [rule %]
            (= (rule-type %) (case n
                               2 :pass2
                               3 :pass3
                               4 :pass4))
            true)]})

(defn only-appended? [old new]
  (= old (take (count old) new)))