conlang-layer/funcs.el

;;; funcs.el --- Conlanging Layer functions File for Spacemacs
;;
;; Copyright (c) 2018-2020 Lucien Cartier-Tilet
;;
;; Author: Lucien Cartier-Tilet <lucien@phundrak.com>
;; URL: https://labs.phundrak.com/phundrak/conlang-layer
;;
;; This file is not part of GNU Emacs.
;;
;;; License: GPLv3

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                        ;                 Tree                ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun conlanging//declare-node (t-node-text t-node-generation)
  "Declares a node in the graphviz source code. The node’s identifier will be
`node-generation', and it will bear the label `node-text'."
  (format "%d[label=\"%s\"];" t-node-generation
          t-node-text))

(defun conlanging/tree-to-dot (t-tree &optional t-current-generation t-previous-generation)
  "Translates an Elisp t-tree with any number of children per node
to a corresponding graphviz file that can be executed from dot.
Arguments:
- `t-tree': t-tree to convert
- `t-current-generation': generation number, incremented when
  changing from a node to another node from the same generation,
  multiplied by 10 when going from a node to one of its children.
- `t-previous-generation': generation number from previous named
  node"
  (cond
   ((null t-previous-generation) ;; first call
    (concat "graph{graph[dpi=300];node[shape=plaintext];graph[bgcolor=\"transparent\"];"
            (conlanging//declare-node (car t-tree) 0)
            (conlanging/tree-to-dot (cdr t-tree) 1 0)
            "}"))
   ((null t-tree) "") ;; last call in this branch
   ((atom (car t-tree)) ;; '("text" () () ()) manage the label
    (concat (conlanging//declare-node (car t-tree)
                                      t-current-generation)
            ;; make link
            (concat (number-to-string t-previous-generation) " -- "
                    (number-to-string t-current-generation) ";")
            (conlanging/tree-to-dot (cdr t-tree)
                                    (+ 1
                                       (* 10 t-current-generation))
                                    t-current-generation)))
   ((listp (car t-tree)) ;; '(() () ()) manage the branches
    (concat (conlanging/tree-to-dot (car t-tree) ;; child of current node
                                    t-current-generation
                                    t-previous-generation)
            (conlanging/tree-to-dot (cdr t-tree)
                                    (+ 1 t-current-generation)
                                    t-previous-generation)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                        ;                Common               ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun conlanging//replace-string-by-char (t-string t-correspondance-table)
  "Return a copy of t-string converted with the correspondance
table"
  (interactive)
  (while t-correspondance-table
    (let ((cur-from-char (car (car t-correspondance-table)))
          (cur-to-char (cdr (car t-correspondance-table))))
      (setq t-string (replace-regexp-in-string cur-from-char cur-to-char
                                               t-string))
      (setq t-correspondance-table (cdr t-correspondance-table))))
  t-string)

(defun conlanging//get-boundary ()
  "Get the boundary of either the selected region, or if there is
none the word the cursor is over"
  (interactive)
  (let* ((beg (region-beginning))
         (end (region-end)))
    (if (= beg end)
        (bounds-of-thing-at-point 'word)
      (cons beg end))))

(defun conlanging//replace-char-by-table (t-correspondance-table)
  "Replaces selected text’s strings according to the table passed
as argument. The table is a list of pairs, the first element of
the pair is a regex to be searched in the selected text and the
second element of the pair the string it has to be replaced
with."
  (let* ((cur-boundary (conlanging//get-boundary))
         (beg (car cur-boundary))
         (end (cdr cur-boundary))
         (regionp (buffer-substring-no-properties beg end))
         (new-regionp (conlanging//replace-string-by-char regionp
                                                          t-correspondance-table)))
    (delete-region beg end)
    (goto-char beg)
    (insert new-regionp)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                        ;                Mattér               ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar conlanging//matter-latin-to-runes '((", *" . "᛬")
                                            ("\\. *" . "᛭")
                                            (" +" . "᛫")
                                            ("ċ" . "ᛇ")
                                            ("ch" . "ᛇ")
                                            ("ae" . "ᚫ")
                                            ("æ" . "ᚫ")
                                            ("dh" . "ᛋ")
                                            ("z" . "ᛋ")
                                            ("ð" . "ᛋ")
                                            ("th" . "ᚦ")
                                            ("s" . "ᚦ")
                                            ("þ" . "ᚦ")
                                            ("w" . "ᚹ")
                                            ("ƿ" . "ᚹ")
                                            ("g" . "ᚷ")
                                            ("ᵹ" . "ᚷ")
                                            ("ea" . "ᛠ")
                                            ("f" . "ᚠ")
                                            ("u" . "ᚢ")
                                            ("o" . "ᚩ")
                                            ("r" . "ᚱ")
                                            ("c" . "ᚳ")
                                            ("h" . "ᚻ")
                                            ("n" . "ᚾ")
                                            ("i" . "ᛁ")
                                            ("j" . "ᛄ")
                                            ("p" . "ᛈ")
                                            ("v" . "ᛝ")
                                            ("t" . "ᛏ")
                                            ("b" . "ᛒ")
                                            ("e" . "ᛖ")
                                            ("m" . "ᛗ")
                                            ("l" . "ᛚ")
                                            ("d" . "ᛞ")
                                            ("é" . "ᛟ")
                                            ("a" . "ᚪ")
                                            ("y" . "ᚣ"))
  "Equivalence between the Mattér orthography in the Latin script
and the Runic script. The first element of a pair is the Latin
script orthography, the second is the Runic equivalent.")

(defvar conlanging//matter-latin-to-native '((" +" . " ")
                                             ("ch" . "ċ")
                                             ("ae" . "æ")
                                             ("th" . "þ")
                                             ("s" . "þ")
                                             ("dh" . "ð")
                                             ("z" . "ð")
                                             ("w" . "ƿ")
                                             ("j" . "i"))
  "Equivalence between the Mattér orthography in its native Latin
script and the transliterated Mattér Latin script. The first
element of a pair is the transliterated Latin script orthography,
the second is the native Latin script equivalent.")

(defvar conlanging//matter-latin-to-latex '((", *" . ":")
                                            ("\\. *" . "*")
                                            (" +" . ".")
                                            ("ch" . "I")
                                            ("ċ" . "I")
                                            ("ae" . "æ")
                                            ("ea" . "\\\\ea")
                                            ("ƿ" . "w")
                                            ("dh" . "s")
                                            ("z" . "s")
                                            ("ð" . "s")
                                            ("th" . "þ")
                                            ("s" . "þ")
                                            ("v" . "\\\\ng")
                                            ("é " . "\\\\oe"))
  "Equivalence between the Mattér orthography in the Latin script
and the LaTeX code for the Runic script. The first element of a
pair is the Latin script orthography, the second is the Runic
LaTeX code equivalent.")

(defun conlanging/matter-to-runes ()
  "Replaces transliterated Mattér with its runic writing system"
  (interactive)
  (conlanging//replace-char-by-table conlanging//matter-latin-to-runes))

(defun conlanging/matter-to-native-latin ()
  "Replaces transliterated Mattér with its corresponding native
latin writing system"
  (interactive)
  (conlanging//replace-char-by-table conlanging//matter-latin-to-native))

(defun conlanging/matter-to-latex ()
  "Replaces transliterated Mattér with its corresponding runes"
  (interactive)
  (conlanging//replace-char-by-table conlanging//matter-latin-to-latex))

(defun conlanging/matter-org-export-runes (t-text)
  "Replaces the transliterated Mattér `t-text' with its
corresponding runes during org-mode export"
  (interactive)
  (if (org-export-derived-backend-p org-export-current-backend
                                    'latex)
      (concat "\\textarm{"
              (conlanging//replace-string-by-char t-text conlanging//matter-latin-to-latex)
              "}")
    (conlanging//replace-string-by-char t-text conlanging//matter-latin-to-runes)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                        ;              Eittlandic              ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar conlanging//eittlandic-latin-to-latex '((", *\\|\\. *" . "\\\\tripledot")
                                                (" +"          . ":")
                                                ("hv"          . "x")
                                                ("í"           . "i")
                                                ("é"           . "\\\\e")
                                                ("ę\\|æ"       . "æ")
                                                ("ý"           . "y")
                                                ("œ"           . "ø")
                                                ("ú"           . "u")
                                                ("ó"           . "o")
                                                ("á\\|ǫ"       . "a")
                                                ("j"           . "i"))
  "Equivalence between the Eittlandic orthography in the Latin
script and the LaTeX code for the Runic script. The first element
of a pair is the Latin script orthography, the second is the
Runic LaTeX code equivalent.")

(defvar conlanging//eittlandic-latin-to-runes '((", *\\|\\. *"   . "⁝")
                                                (" +\\|:"        . "᛬")
                                                ("hv"            . "ᛪ")
                                                ("i\\|í\\|j"     . "ᛁ")
                                                ("é"             . "ᛂ")
                                                ("e\\|ę\\|æ"     . "ᛅ")
                                                ("y\\|ý"         . "ᛦ")
                                                ("ø\\|œ"         . "ᚯ")
                                                ("u\\|ú\\|v\\|w" . "ᚢ")
                                                ("o\\|ó"         . "ᚮ")
                                                ("a\\|á\\|ǫ"     . "ᛆ")
                                                ("p"             . "ᛔ")
                                                ("b"             . "ᛒ")
                                                ("f"             . "ᚠ")
                                                ("t"             . "ᛐ")
                                                ("d"             . "ᛑ")
                                                ("þ"             . "ᚦ")
                                                ("ð"             . "ᚧ")
                                                ("s"             . "ᛋ")
                                                ("k"             . "ᚴ")
                                                ("g"             . "ᚵ")
                                                ("h"             . "ᚼ")
                                                ("m"             . "ᛘ")
                                                ("n"             . "ᚿ")
                                                ("r"             . "ᚱ")
                                                ("l"             . "ᛚ"))
  "Equivalence between the Eittlandic orthography in the Latin
 script and the Runic script. The first element of a pair is the
 Latin script orthography, the second is the Runic equivalent.")

(defun conlanging/eittlandic-to-runes ()
  "Replaces transliterated Eittlandic with its runic writing system"
  (interactive)
  (conlanging//replace-char-by-table conlanging//eittlandic-latin-to-runes))

(defun conlanging/eittlandic-to-latex ()
  "Replaces transliterated Eittlandic with its corresponding runes"
  (interactive)
  (conlanging//replace-char-by-table conlanging//eittlandic-latin-to-latex))

(defun conlanging/eittlandic-org-export-runes (t-text)
  "Replaces  transliterated  Eittlandic  with  its  corresponding
runes during org-mode export"
  (interactive)
  (if (org-export-derived-backend-p org-export-current-backend
                                    'latex)
      (concat "\\textarm{"
              (conlanging//replace-string-by-char t-text conlanging//eittlandic-latin-to-latex)
              "}")
    (conlanging//replace-string-by-char t-text conlanging//eittlandic-latin-to-runes)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                        ;                    Ñyqy             ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar conlanging//nyqy-phonetics '(("q" t   t   "q" "ħ")
                                     ("g" t   t   "ɢ" "ʢ")
                                     ("ñ" t   t   "ɴ" "m")
                                     ("c" t   t   "c" "ɬ")
                                     ("j" t   t   "ɟ" "ɮ")
                                     ("w" t   t   "w" "l")
                                     ("p" t   nil "χ" "p")
                                     ("b" t   nil "ʁ" "b")
                                     ("m" t   nil "ʀ" "m")
                                     ("n" t   nil "j" "n")
                                     ("s" t   nil "x" "s")
                                     ("z" t   nil "ɣ" "z")
                                     ("y" nil "y")
                                     ("ú" nil "u")
                                     ("i" nil "ɪ")
                                     ("u" nil "ʊ")
                                     ("ø" nil "ø")
                                     ("œ" nil "ɤ")
                                     ("e" nil "ɛ")
                                     ("o" nil "ɔ")
                                     (" " nil " ")
                                     ("," nil " ")
                                     (";" nil " ")
                                     ("." nil " "))
  "List of Ñyqy characters and their phonetics equivalent.

The first value is the translitteration of a sound in Ñyqy. The
second is whether or not it represents a consonant.

If it is a consonant, then the third value is whether it is a
dorsal consonant by default or not. Then we have the consonant's
dorsal prononciation and its non-dorsal pronunciation.

If it is not a consonant, then the third value is its
pronunciation already.")

(defun conlanging//nyqy-is-consonant (t-elem)
  (nth 1 t-elem))

(defun conlanging//nyqy-is-dorsal (t-elem)
  (nth 2 t-elem))

(defun conlanging//nyqy-get-phoneme (t-phoneme &optional t-is-consonant t-is-dorsal)
  "Extracts a phoneme from `t-phoneme'.

Arguments:
- `t-phoneme': array from `conlanging//nyqy-phonetics'
- `t-is-consonant': whether `t-phoneme' represents a
  consonant (default: `nil')
- `t-is-dorsal': whether `t-phoneme' should be a dorsal
  consonant (default: `nil')"
  (if t-is-consonant
      (if t-is-dorsal
          (nth 3 t-phoneme)
        (nth 4 t-phoneme))
    (nth 2 t-phoneme)))

(defun conlanging/nyqy-to-phonetics (t-text &optional t-nyqy t-phonetics t-met-consonant
                                            t-dorsal)
  "Returns the phonetics equivalent of the Ñyqy `t-text'.

Arguments:
- `t-text': text to convert to phonetics
- `t-nyqy': for internal use only, `t-text' argument but as a
  list of characters
- `t-phonetics': for internal use only, result phonetics, array
- `t-met-consonant': for internal use only, `t' if a consonant
  has been met previously, `nil' otherwise
- `t-dorsal': for internal use only, `t' if the current consonant
  is required to be dorsal, `nil' otherwise"
  (interactive)
  (cond

   ;; first call to the function
   ((eq nil t-phonetics)
    (conlanging/nyqy-to-phonetics t-text
                                  (split-string (downcase t-text) "" t)
                                  ""))

   ;; no more to convert
   ((eq nil t-nyqy)
    t-phonetics)

   ;; default option
   (t (let* ((cur-char (car t-nyqy)) ;; default option
             (cur-phon (seq-find (lambda (elt)
                                   (string= (car elt)
                                            cur-char))
                                 conlanging//nyqy-phonetics))
             (is-consonant (conlanging//nyqy-is-consonant cur-phon))
             (t-dorsal (if (or t-met-consonant
                               (not is-consonant))
                           t-dorsal
                         (conlanging//nyqy-is-dorsal cur-phon))))
        (if is-consonant
            (conlanging/nyqy-to-phonetics t-text
                                          (cdr t-nyqy)
                                          (concat t-phonetics
                                                  (conlanging//nyqy-get-phoneme cur-phon t t-dorsal))
                                          t
                                          (not t-dorsal))
          (conlanging/nyqy-to-phonetics t-text
                                        (cdr t-nyqy)
                                        (concat t-phonetics
                                                (conlanging//nyqy-get-phoneme cur-phon nil))
                                        t-met-consonant
                                        t-dorsal))))))

(defun conlanging/nyqy-to-org (t-text)
  "Returns the phonetics equivalent of the Ñygy `t-text' properly
formatted for org so it gets exported as a tooltip in HTML or as
LaTeX code for LaTeX exports.

Arguments:
- `t-text': text to convert to phonetics"
  (let ((phonetics (conlanging/nyqy-to-phonetics t-text))
        (text t-text))
    (format (concat "@@html:<span class=\"tooltip\"><i>%s</i><span class=\"tooltiptext\">/%s/</span></span>@@"
                    "@@latex:\\textit{%s} (/%s/)@@")
            text
            phonetics
            text
            phonetics)))