This repository has been archived on 2020-12-27. You can view files and clone it, but cannot push or open issues or pull requests.
conlang-layer/funcs.el

403 lines
19 KiB
EmacsLisp
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

;;; funcs.el --- Conlanging Layer functions File for Spacemacs
;;
;; Copyright (c) 2019-2020 Lucien Cartier-Tilet
;;
;; Author: Lucien Cartier-Tilet <phundrak@phundrak.fr>
;; URL: https://github.com/syl20bnr/spacemacs
;;
;; 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 nodes 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 texts 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)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Eittlanda ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar conlanging//eittlanda-latin-to-latex '((", *" . "\\\\tripledot")
("\\. *" . "\\\\tripledot")
(" +" . ":")
("hv" . "x")
("ø" . "\\\\o")
("œ" . "\\\\oO")
("v" . "w")
("ó" . "v")
("ń" . "\\\\ndot"))
"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//eittlanda-latin-to-runes '((", *" . "")
("\\. *" . "")
(" +" . "")
(":" . "")
("hv" . "")
("i" . "")
("y" . "")
("u" . "")
("e" . "")
("ø" . "")
("o" . "")
("œ" . "")
("ó" . "")
("æ" . "")
("a" . "")
("m" . "")
("n" . "")
("ń" . "")
("p" . "")
("b" . "")
("t" . "")
("d" . "")
("k" . "")
("g" . "")
("f" . "")
("þ" . "")
("ð" . "")
("s" . "")
("h" . "")
("v" . "")
("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/eittlanda-to-runes ()
"Replaces transliterated Eittlandic with its runic writing system"
(interactive)
(conlanging//replace-char-by-table conlanging//eittlanda-latin-to-runes))
(defun conlanging/eittlanda-to-latex ()
"Replaces transliterated Eittlandic with its corresponding runes"
(interactive)
(conlanging//replace-char-by-table conlanging//eittlanda-latin-to-latex))
(defun conlanging/eittlanda-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//eittlanda-latin-to-latex)
"}")
(conlanging//replace-string-by-char t-text conlanging//eittlanda-latin-to-runes)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Ñyqy ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar conlanging//nyqy-phonetics '(("q" t t "q" "ħ")
("g" t t "ɢ" "ʢ")
("ñ" t t "ɴ" "m")
("c" t t "t͡ʃ" "ɬ")
("j" t t "d͡ʒ" "ɮ")
("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)))