summaryrefslogtreecommitdiff
path: root/tex/generic
diff options
context:
space:
mode:
Diffstat (limited to 'tex/generic')
-rw-r--r--tex/generic/enigma/enigma.lua1662
1 files changed, 1662 insertions, 0 deletions
diff --git a/tex/generic/enigma/enigma.lua b/tex/generic/enigma/enigma.lua
new file mode 100644
index 0000000..9da4288
--- /dev/null
+++ b/tex/generic/enigma/enigma.lua
@@ -0,0 +1,1662 @@
+#!/usr/bin/env texlua
+-----------------------------------------------------------------------
+-- FILE: enigma.lua
+-- USAGE: Call via interface from within a TeX session.
+-- DESCRIPTION: Enigma logic.
+-- REQUIREMENTS: LuaTeX capable format (Luaplain, ConTeXt).
+-- AUTHOR: Philipp Gesang (Phg), <phg42 dot 2a at gmail dot com>
+-- VERSION: release
+-- CREATED: 2013-03-28 02:12:03+0100
+-----------------------------------------------------------------------
+--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Format Dependent Code]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\startparagraph
+Exported functionality will be collected in the table
+\identifier{enigma}.
+\stopparagraph
+--ichd]]--
+
+local enigma = { machines = { }, callbacks = { } }
+local format_is_context = false
+
+--[[ichd--
+\startparagraph
+Afaict, \LATEX\ for \LUATEX\ still lacks a globally accepted
+namespacing convention. This is more than bad, but we’ll have to cope
+with that. For this reason we brazenly introduce
+\identifier{packagedata} (in analogy to \CONTEXT’s
+\identifier{thirddata}) table as a package namespace proposal. If this
+module is called from a \LATEX\ or plain session, the table
+\identifier{packagedata} will already have been created so we will
+identify the format according to its presence or absence, respectively.
+\stopparagraph
+--ichd]]--
+
+if packagedata then -- latex or plain
+ packagedata.enigma = enigma
+elseif thirddata then -- context
+ format_is_context = true
+ thirddata.enigma = enigma
+else -- external call, mtx-script or whatever
+ _ENV.enigma = enigma
+end
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Prerequisites]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startparagraph
+First of all, we generate local copies of all those library functions
+that are expected to be referenced frequently.
+The format-independent stuff comes first; it consists of functions from
+the
+\identifier{io},
+\identifier{lpeg},
+\identifier{math},
+\identifier{string},
+\identifier{table}, and
+\identifier{unicode}
+libraries.
+\stopparagraph
+--ichd]]--
+
+local get_debug_info = debug.getinfo
+local ioread = io.read
+local iowrite = io.write
+local mathfloor = math.floor
+local mathrandom = math.random
+local next = next
+local nodecopy = node and node.copy
+local nodeid = node and node.id
+local nodeinsert_before = node and node.insert_before
+local nodeinsert_after = node and node.insert_after
+local nodelength = node and node.length
+local nodenew = node and node.new
+local noderemove = node and node.remove
+local nodeslide = node and node.slide
+local nodetraverse = node and node.traverse
+local nodetraverse_id = node and node.traverse_id
+local nodesinstallattributehandler
+local nodestasksappendaction
+local nodestasksdisableaction
+if format_is_context then
+ nodesinstallattributehandler = nodes.installattributehandler
+ nodestasksappendaction = nodes.tasks.appendaction
+ nodestasksdisableaction = nodes.tasks.disableaction
+end
+local stringfind = string.find
+local stringformat = string.format
+local stringlower = string.lower
+local stringsub = string.sub
+local stringupper = string.upper
+local tableconcat = table.concat
+local tonumber = tonumber
+local type = type
+local utf8byte = unicode.utf8.byte
+local utf8char = unicode.utf8.char
+local utf8len = unicode.utf8.len
+local utf8lower = unicode.utf8.lower
+local utf8sub = unicode.utf8.sub
+local utfcharacters = string.utfcharacters
+
+--- debugging tool (careful, this *will* break context!)
+--dofile(kpse.find_file("lualibs-table.lua")) -- archaic version :(
+--table.print = function (...) print(table.serialize(...)) end
+
+local tablecopy
+if format_is_context then
+ tablecopy = table.copy
+else -- could use lualibs instead but not worth the overhead
+ tablecopy = function (t) -- ignores tables as keys
+ local result = { }
+ for k, v in next, t do
+ if type(v) == table then
+ result[k] = tablecopy(v)
+ else
+ result[k] = v
+ end
+ end
+ return result
+ end
+end
+
+local GLYPH_NODE = node and nodeid"glyph"
+local GLUE_NODE = node and nodeid"glue"
+local GLUE_SPEC_NODE = node and nodeid"glue_spec"
+local KERN_NODE = node and nodeid"kern"
+local DISC_NODE = node and nodeid"disc"
+local HLIST_NODE = node and nodeid"hlist"
+local VLIST_NODE = node and nodeid"vlist"
+
+local IGNORE_NODES = node and {
+--[GLUE_NODE] = true,
+ [KERN_NODE] = true,
+--[DISC_NODE] = true,
+} or { }
+
+--[[ichd--
+\startparagraph
+The initialization of the module relies heavily on parsers generated by
+\type{LPEG}.
+\stopparagraph
+--ichd]]--
+
+local lpeg = require "lpeg"
+
+local C, Cb, Cc, Cf, Cg,
+ Cmt, Cp, Cs, Ct
+ = lpeg.C, lpeg.Cb, lpeg.Cc, lpeg.Cf, lpeg.Cg,
+ lpeg.Cmt, lpeg.Cp, lpeg.Cs, lpeg.Ct
+
+local P, R, S, V, lpegmatch
+ = lpeg.P, lpeg.R, lpeg.S, lpeg.V, lpeg.match
+
+--local B = lpeg.version() == "0.10" and lpeg.B or nil
+
+--[[ichd--
+\startparagraph
+By default the output to \type{stdout} will be zero. The verbosity
+level can be adjusted in order to alleviate debugging.
+\stopparagraph
+--ichd]]--
+--local verbose_level = 42
+local verbose_level = 0
+
+--[[ichd--
+\startparagraph
+Historically, Enigma-encoded messages were restricted to a size of 250
+characters. With sufficient verbosity we will indicate whether this
+limit has been exceeded during the \TEX\ run.
+\stopparagraph
+--ichd]]--
+local max_msg_length = 250
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Globals]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startparagraph
+The following mappings are used all over the place as we convert back
+and forth between the characters (unicode) and their numerical
+representation.
+\stopparagraph
+--ichd]]--
+
+local value_to_letter -- { [int] -> chr }
+local letter_to_value -- { [chr] -> int }
+local alpha_sorted -- string, length 26
+local raw_rotor_wiring -- { string0, .. string5, }
+local notches -- { [int] -> int } // rotor num -> notch pos
+local reflector_wiring -- { { [int] -> int }, ... } // symmetrical
+do
+ value_to_letter = {
+ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
+ "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
+ }
+
+ letter_to_value = {
+ a = 01, b = 02, c = 03, d = 04, e = 05, f = 06, g = 07, h = 08,
+ i = 09, j = 10, k = 11, l = 12, m = 13, n = 14, o = 15, p = 16,
+ q = 17, r = 18, s = 19, t = 20, u = 21, v = 22, w = 23, x = 24,
+ y = 25, z = 26,
+ }
+--[[ichd--
+\startparagraph
+The five rotors to simulate.\reference[listing:rotor_wiring]{}
+Their wirings are created from strings at runtime, see below the
+function \luafunction{get_rotors}.
+\stopparagraph
+--ichd]]--
+
+ --[[
+ Nice: http://www.ellsbury.com/ultraenigmawirings.htm
+ ]]--
+ alpha_sorted = "abcdefghijklmnopqrstuvwxyz"
+ raw_rotor_wiring = {
+ [0] = alpha_sorted,
+ "ekmflgdqvzntowyhxuspaibrcj",
+ "ajdksiruxblhwtmcqgznpyfvoe",
+ "bdfhjlcprtxvznyeiwgakmusqo",
+ "esovpzjayquirhxlnftgkdcmwb",
+ "vzbrgityupsdnhlxawmjqofeck",
+ }
+
+--[[ichd--
+\startparagraph
+Notches are assigned to rotors according to the Royal Army
+mnemonic.
+\stopparagraph
+--ichd]]--
+ notches = { }
+ do
+ local raw_notches = "rfwkannnn"
+ --local raw_notches = "qevjz"
+ local n = 1
+ for chr in utfcharacters(raw_notches) do
+ local pos = stringfind(alpha_sorted, chr)
+ notches[n] = pos - 1
+ n = n + 1
+ end
+ end
+
+--[[ichd--
+\placetable[here][listing:reflector]%
+ {The three reflectors and their substitution rules.}{%
+ \starttabulate[|r|l|]
+ \NC UKW a \NC AE BJ CM DZ FL GY HX IV KW NR OQ PU ST \NC \NR
+ \NC UKW b \NC AY BR CU DH EQ FS GL IP JX KN MO TZ VW \NC \NR
+ \NC UKW c \NC AF BV CP DJ EI GO HY KR LZ MX NW QT SU \NC \NR
+ \stoptabulate
+}
+--ichd]]--
+
+ reflector_wiring = { }
+ local raw_ukw = {
+ { a = "e", b = "j", c = "m", d = "z", f = "l", g = "y", h = "x",
+ i = "v", k = "w", n = "r", o = "q", p = "u", s = "t", },
+ { a = "y", b = "r", c = "u", d = "h", e = "q", f = "s", g = "l",
+ i = "p", j = "x", k = "n", m = "o", t = "z", v = "w", },
+ { a = "f", b = "v", c = "p", d = "j", e = "i", g = "o", h = "y",
+ k = "r", l = "z", m = "x", n = "w", q = "t", s = "u", },
+ }
+ for i=1, #raw_ukw do
+ local new_wiring = { }
+ local current_ukw = raw_ukw[i]
+ for from, to in next, current_ukw do
+ from = letter_to_value[from]
+ to = letter_to_value[to]
+ new_wiring[from] = to
+ new_wiring[to] = from
+ end
+ reflector_wiring[i] = new_wiring
+ end
+end
+
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Pretty printing for debug purposes]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startparagraph
+The functions below allow for formatting of the terminal output; they
+have no effect on the workings of the enigma simulator.
+\stopparagraph
+--ichd]]--
+
+local emit
+local pprint_ciphertext
+local pprint_encoding
+local pprint_encoding_scheme
+local pprint_init
+local pprint_machine_step
+local pprint_new_machine
+local pprint_rotor
+local pprint_rotor_scheme
+local pprint_step
+local polite_key_request
+local key_invalid
+do
+ local eol = "\n"
+
+ local colorstring_template = "\027[%d;1m%s\027[0m"
+ local colorize = function (s, color)
+ color = color and color < 38 and color > 29 and color or 31
+ return stringformat(colorstring_template,
+ color,
+ s)
+ end
+
+ local underline = function (s)
+ return stringformat("\027[4;37m%s\027[0m", s)
+ end
+
+ local s_steps = [[Total characters encoded with machine “]]
+ local f_warnsteps = [[ (%d over permitted maximum)]]
+ pprint_machine_step = function (n, name)
+ local sn
+ name = colorize(name, 36)
+ if n > max_msg_length then
+ sn = colorize(n, 31) .. stringformat(f_warnsteps,
+ n - max_msg_length)
+ else
+ sn = colorize(n, 37)
+ end
+ return s_steps .. name .. "”: " .. sn .. "."
+ end
+ local rotorstate = "[s \027[1;37m%s\027[0m n\027[1;37m%2d\027[0m]> "
+ pprint_rotor = function (rotor)
+ local visible = rotor.state % 26 + 1
+ local w, n = rotor.wiring, (rotor.notch - visible) % 26 + 1
+ local tmp = { }
+ for i=1, 26 do
+ local which = (i + rotor.state - 1) % 26 + 1
+ local chr = value_to_letter[rotor.wiring.from[which]]
+ if i == n then -- highlight positions of notches
+ tmp[i] = colorize(stringupper(chr), 32)
+ --elseif chr == value_to_letter[visible] then
+ ---- highlight the character in window
+ -- tmp[i] = colorize(chr, 33)
+ else
+ tmp[i] = chr
+ end
+ end
+ return stringformat(rotorstate,
+ stringupper(value_to_letter[visible]),
+ n)
+ .. tableconcat(tmp)
+ end
+
+ local rotor_scheme = underline"[rot not]"
+ .. " "
+ .. underline(alpha_sorted)
+ pprint_rotor_scheme = function ()
+ return rotor_scheme
+ end
+
+ local s_encoding_scheme = eol
+ .. [[in > 1 => 2 => 3 > UKW > 3 => 2 => 1]]
+ pprint_encoding_scheme = function ()
+ return underline(s_encoding_scheme)
+ end
+ local s_step = " => "
+ local stepcolor = 36
+ local finalcolor = 32
+ pprint_encoding = function (steps)
+ local nsteps, result = #steps, { }
+ for i=0, nsteps-1 do
+ result[i+1] = colorize(value_to_letter[steps[i]], stepcolor)
+ .. s_step
+ end
+ result[nsteps+1] = colorize(value_to_letter[steps[nsteps]],
+ finalcolor)
+ return tableconcat(result)
+ end
+
+ local init_announcement
+ = colorize("\n" .. [[Initial position of rotors: ]],
+ 37)
+ pprint_init = function (init)
+ local result = ""
+ result = value_to_letter[init[1]] .. " "
+ .. value_to_letter[init[2]] .. " "
+ .. value_to_letter[init[3]]
+ return init_announcement .. colorize(stringupper(result), 34)
+ end
+
+ local machine_announcement =
+ [[Enigma machine initialized with the following settings.]] .. eol
+ local s_ukw = colorize(" Reflector:", 37)
+ local s_pb = colorize("Plugboard setting:", 37)
+ local s_ring = colorize(" Ring positions:", 37)
+ local empty_plugboard = colorize(" ——", 34)
+ pprint_new_machine = function (m)
+ local result = { "" }
+ result[#result+1] = underline(machine_announcement)
+ result[#result+1] = s_ukw
+ .. " "
+ .. colorize(
+ stringupper(value_to_letter[m.reflector]),
+ 34
+ )
+ local rings = ""
+ for i=1, 3 do
+ local this = m.ring[i]
+ rings = rings
+ .. " "
+ .. colorize(stringupper(value_to_letter[this + 1]), 34)
+ end
+ result[#result+1] = s_ring .. rings
+ if m.__raw.plugboard then
+ local tpb, pb = m.__raw.plugboard, ""
+ for i=1, #tpb do
+ pb = pb .. " " .. colorize(tpb[i], 34)
+ end
+ result[#result+1] = s_pb .. pb
+ else
+ result[#result+1] = s_pb .. empty_plugboard
+ end
+ result[#result+1] = ""
+ result[#result+1] = pprint_rotor_scheme()
+ for i=1, 3 do
+ result[#result+1] = pprint_rotor(m.rotors[i])
+ end
+ return tableconcat(result, eol) .. eol
+ end
+
+ local step_template = colorize([[Step № ]], 37)
+ local chr_template = colorize([[ —— Input ]], 37)
+ local pbchr_template = colorize([[ → ]], 37)
+ pprint_step = function (n, chr, pb_chr)
+ return eol
+ .. step_template
+ .. colorize(n, 34)
+ .. chr_template
+ .. colorize(stringupper(value_to_letter[chr]), 34)
+ .. pbchr_template
+ .. colorize(stringupper(value_to_letter[pb_chr]), 34)
+ .. eol
+ end
+
+ -- Split the strings into lines, group them in bunches of five etc.
+ local tw = 30
+ local pprint_textblock = function (s)
+ local len = utf8len(s)
+ local position = 1 -- position in string
+ local nline = 5 -- width of current line
+ local out = utf8sub(s, position, position+4)
+ repeat
+ position = position + 5
+ nline = nline + 6
+ if nline > tw then
+ out = out .. eol .. utf8sub(s, position, position+4)
+ nline = 1
+ else
+ out = out .. " " .. utf8sub(s, position, position+4)
+ end
+ until position > len
+ return out
+ end
+
+ local intext = colorize([[Input text:]], 37)
+ local outtext = colorize([[Output text:]], 37)
+ pprint_ciphertext = function (input, output, upper_p)
+ if upper_p then
+ input = stringupper(input)
+ output = stringupper(output)
+ end
+ return eol
+ .. intext
+ .. eol
+ .. pprint_textblock(input)
+ .. eol .. eol
+ .. outtext
+ .. eol
+ .. pprint_textblock(output)
+ end
+
+--[[ichd--
+\startparagraph
+\luafunction{emit} is the main wrapper function for
+\identifier{stdout}. Checks if the global verbosity setting exceeds
+the specified threshold, and only then pushes the output.
+\stopparagraph
+--ichd]]--
+ emit = function (v, f, ...)
+ if f and v and verbose_level >= v then
+ iowrite(f(...) .. eol)
+ end
+ return 0
+ end
+--[[ichd--
+\startparagraph
+The \luafunction{polite_key_request} will be called in case the
+\identifier{day_key} field of the machine setup is empty at the time of
+initialization.
+\stopparagraph
+--ichd]]--
+ local s_request = "\n\n "
+ .. underline"This is an encrypted document." .. [[
+
+
+ Please enter the document key for enigma machine
+ “%s”.
+
+ Key Format:
+
+Ref R1 R2 R3 I1 I2 I3 [P1 ..] Ref: reflector A/B/C
+ Rn: rotor, I through V
+ In: ring position, 01 through 26
+ Pn: optional plugboard wiring, upto 32
+
+>]]
+ polite_key_request = function (name)
+ return stringformat(s_request, colorize(name, 33))
+ end
+
+ local s_invalid_key = colorize"Warning!"
+ .. " The specified key is invalid."
+ key_invalid = function ()
+ return s_invalid_key
+ end
+end
+
+--[[ichd--
+\startparagraph
+The functions \luafunction{new} and \luafunction{ask_for_day_key} are
+used outside their scope, so we declare them beforehand.
+\stopparagraph
+--ichd]]--
+local new
+local ask_for_day_key
+do
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Rotation]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startparagraph
+The following function \luafunction{do_rotate} increments the
+rotational state of a single rotor. There are two tests for notches:
+\startitemize[n]
+ \item whether it’s at the current character, and
+ \item whether it’s at the next character.
+\stopitemize
+The latter is an essential prerequisite for double-stepping.
+\stopparagraph
+--ichd]]--
+ local do_rotate = function (rotor)
+ rotor.state = rotor.state % 26 + 1
+ return rotor,
+ rotor.state == rotor.notch,
+ rotor.state + 1 == rotor.notch
+ end
+
+--[[ichd--
+\startparagraph
+The \luafunction{rotate} function takes care of rotor (\emph{Walze})
+movement. This entails incrementing the next rotor whenever the notch
+has been reached and covers the corner case \emph{double stepping}.
+\stopparagraph
+--ichd]]--
+ local rotate = function (machine)
+ local rotors = machine.rotors
+ local rc, rb, ra = rotors[1], rotors[2], rotors[3]
+
+ ra, nxt = do_rotate(ra)
+ if nxt or machine.double_step then
+ rb, nxt, nxxt = do_rotate(rb)
+ if nxt then
+ rc = do_rotate(rc)
+ end
+ if nxxt then
+ --- weird: home.comcast.net/~dhhamer/downloads/rotors1.pdf
+ machine.double_step = true
+ else
+ machine.double_step = false
+ end
+ end
+ machine.rotors = { rc, rb, ra }
+ end
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Input Preprocessing]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startparagraph
+Internally, we will use lowercase strings as they are a lot more
+readable than uppercase. Lowercasing happens prior to any further
+dealings with input. After the encoding or decoding has been
+accomplished, there will be an optional (re-)uppercasing.
+\stopparagraph
+
+\startparagraph
+Substitutions \reference[listing:preproc]{}are applied onto the
+lowercased input. You might want to avoid some of these, above all the
+rules for numbers, because they translate single digits only. The
+solution is to write out numbers above ten.
+\stopparagraph
+--ichd]]--
+
+ local pp_substitutions = {
+ -- Umlauts are resolved.
+ ["ö"] = "oe",
+ ["ä"] = "ae",
+ ["ü"] = "ue",
+ ["ß"] = "ss",
+ -- WTF?
+ ["ch"] = "q",
+ ["ck"] = "q",
+ -- Punctuation -> “x”
+ [","] = "x",
+ ["."] = "x",
+ [";"] = "x",
+ [":"] = "x",
+ ["/"] = "x",
+ ["’"] = "x",
+ ["‘"] = "x",
+ ["„"] = "x",
+ ["“"] = "x",
+ ["“"] = "x",
+ ["-"] = "x",
+ ["–"] = "x",
+ ["—"] = "x",
+ ["!"] = "x",
+ ["?"] = "x",
+ ["‽"] = "x",
+ ["("] = "x",
+ [")"] = "x",
+ ["["] = "x",
+ ["]"] = "x",
+ ["<"] = "x",
+ [">"] = "x",
+ -- Spaces are omitted.
+ [" "] = "",
+ ["\n"] = "",
+ ["\t"] = "",
+ ["\v"] = "",
+ ["\\"] = "",
+ -- Numbers are resolved.
+ ["0"] = "null",
+ ["1"] = "eins",
+ ["2"] = "zwei",
+ ["3"] = "drei",
+ ["4"] = "vier",
+ ["5"] = "fuenf",
+ ["6"] = "sechs",
+ ["7"] = "sieben",
+ ["8"] = "acht",
+ ["9"] = "neun",
+ }
+
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[
+ title={Main function chain to be applied to single characters},
+]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\startparagraph
+As far as the Enigma is concerned, there is no difference between
+encoding and decoding. Thus, we need only one function
+(\luafunction{encode_char}) to achieve the complete functionality.
+However, within every encoding step, characters will be wired
+differently in at least one of the rotors according to its rotational
+state. Rotation is simulated by adding the \identifier{state} field of
+each rotor to the letter value (its position on the ingoing end).
+\stopparagraph
+\placetable[here][table:dirs]{Directional terminology}{%
+ \starttabulate[|l|r|l|]
+ \NC boolean \NC direction \NC meaning \NC \AR
+ \NC true \NC “from” \NC right to left \NC \AR
+ \NC false \NC “to” \NC left to right \NC \AR
+ \stoptabulate%
+}
+\startparagraph
+The function \luafunction{do_do_encode_char} returns the character
+substitution for one rotor. As a letter passes through each rotor
+twice, the argument \identifier{direction} determines which way the
+substitution is applied.
+\stopparagraph
+--ichd]]--
+ local do_do_encode_char = function (char, rotor, direction)
+ local rw = rotor.wiring
+ local rs = rotor.state
+ local result = char
+ if direction then -- from
+ result = (result + rs - 1) % 26 + 1
+ result = rw.from[result]
+ result = (result - rs - 1) % 26 + 1
+ else -- to
+ result = (result + rs - 1) % 26 + 1
+ result = rw.to[result]
+ result = (result - rs - 1) % 26 + 1
+ end
+ return result
+ end
+
+--[[ichd--
+\startparagraph
+Behind the plugboard, every character undergoes seven substitutions:
+two for each rotor plus the central one through the reflector. The
+function \luafunction{do_encode_char}, although it returns the final
+result only, keeps every intermediary step inside a table for debugging
+purposes. This may look inefficient but is actually a great advantage
+whenever something goes wrong.
+\stopparagraph
+--ichd]]--
+ --- ra -> rb -> rc -> ukw -> rc -> rb -> ra
+ local do_encode_char = function (rotors, reflector, char)
+ local rc, rb, ra = rotors[1], rotors[2], rotors[3]
+ local steps = { [0] = char }
+ --
+ steps[1] = do_do_encode_char(steps[0], ra, true)
+ steps[2] = do_do_encode_char(steps[1], rb, true)
+ steps[3] = do_do_encode_char(steps[2], rc, true)
+ steps[4] = reflector_wiring[reflector][steps[3]]
+ steps[5] = do_do_encode_char(steps[4], rc, false)
+ steps[6] = do_do_encode_char(steps[5], rb, false)
+ steps[7] = do_do_encode_char(steps[6], ra, false)
+ emit(2, pprint_encoding_scheme)
+ emit(2, pprint_encoding, steps)
+ return steps[7]
+ end
+
+--[[ichd--
+\startparagraph
+Before an input character is passed on to the actual encoding routing,
+the function \luafunction{encode_char} matches it agains the latin
+alphabet.
+Characters failing this test are either passed through or ignored,
+depending on the machine option \identifier{other_chars}.
+Also, the counter of encoded characters is incremented at this stage
+and some pretty printer hooks reside here.
+\stopparagraph
+
+\startparagraph
+\luafunction{encode_char} contributes only one element of the encoding
+procedure: the plugboard (\emph{Steckerbrett}).
+Like the rotors described above, a character passed through this
+device twice; the plugboard marks the beginning and end of every step.
+For debugging purposes, the first substitution is stored in a separate
+local variable, \identifier{pb_char}.
+\stopparagraph
+--ichd]]--
+
+ local encode_char = function (machine, char)
+ machine.step = machine.step + 1
+ machine:rotate()
+ local pb = machine.plugboard
+ char = letter_to_value[char]
+ local pb_char = pb[char] -- first plugboard substitution
+ emit(2, pprint_step, machine.step, char, pb_char)
+ emit(3, pprint_rotor_scheme)
+ emit(3, pprint_rotor, machine.rotors[1])
+ emit(3, pprint_rotor, machine.rotors[2])
+ emit(3, pprint_rotor, machine.rotors[3])
+ char = do_encode_char(machine.rotors,
+ machine.reflector,
+ pb_char)
+ return value_to_letter[pb[char]] -- second plugboard substitution
+ end
+
+ local get_random_pattern = function ()
+ local a, b, c
+ = mathrandom(1,26), mathrandom(1,26), mathrandom(1,26)
+ return value_to_letter[a]
+ .. value_to_letter[b]
+ .. value_to_letter[c]
+ end
+
+ local pattern_to_state = function (pat)
+ return {
+ letter_to_value[stringsub(pat, 1, 1)],
+ letter_to_value[stringsub(pat, 2, 2)],
+ letter_to_value[stringsub(pat, 3, 3)],
+ }
+ end
+
+ local set_state = function (machine, state)
+ local rotors = machine.rotors
+ for i=1, 3 do
+ rotors[i].state = state[i] - 1
+ end
+ end
+
+--[[ichd--
+\startparagraph
+When \modulename{Enigma} is called from \TEX, the encoding
+proceeds character by character as we iterate one node at a time.
+\luafunction{encode_string} is a wrapper for use with strings, e.~g. in
+the mtx-script (\at{page}[sec:fun]).
+It handles iteration and extraction of successive characters from the
+sequence.
+\stopparagraph
+--ichd]]--
+ local encode_string = function (machine, str) --, pattern)
+ local result = { }
+ for char in utfcharacters(str) do
+ local tmp = machine:encode(char)
+ if tmp ~= false then
+ if type(tmp) == "table" then
+ for i=1, #tmp do
+ result[#result+1] = tmp[i]
+ end
+ else
+ result[#result+1] = tmp
+ end
+ end
+ end
+ machine:processed_chars()
+ return tableconcat(result)
+ end
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Initialization string parser]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\placetable[here][]{Initialization strings}{%
+ \bTABLE
+ \bTR
+ \bTD Reflector \eTD
+ \bTD[nc=3] Rotor \eTD
+ \bTD[nc=3] Initial \eTD
+ \bTD[nc=10] Plugboard wiring \eTD
+ \eTR
+ \eTR
+ \bTR
+ \bTD in slot \eTD
+ \bTD[nc=3] setting \eTD
+ \bTD[nc=3] rotor \eTD
+ \eTR
+ \bTR
+ \bTD \eTD
+ \bTD 1 \eTD\bTD 2 \eTD\bTD 3 \eTD
+ \bTD 1 \eTD\bTD 2 \eTD\bTD 3 \eTD
+ \bTD 1 \eTD\bTD 2 \eTD\bTD 3 \eTD\bTD 4 \eTD\bTD 5 \eTD
+ \bTD 6 \eTD\bTD 7 \eTD\bTD 8 \eTD\bTD 9 \eTD\bTD 10 \eTD
+ \eTR
+ \bTR
+ \bTD B \eTD
+ \bTD I \eTD\bTD IV \eTD\bTD III \eTD
+ \bTD 16 \eTD\bTD 26 \eTD\bTD 08 \eTD
+ \bTD AD \eTD\bTD CN \eTD\bTD ET \eTD
+ \bTD FL \eTD\bTD GI \eTD\bTD JV \eTD
+ \bTD KZ \eTD\bTD PU \eTD\bTD QY \eTD
+ \bTD WX \eTD
+ \eTR
+ \eTABLE
+}
+--ichd]]--
+ local roman_digits = {
+ i = 1, I = 1,
+ ii = 2, II = 2,
+ iii = 3, III = 3,
+ iv = 4, IV = 4,
+ v = 5, V = 5,
+ }
+
+ local p_init = P{
+ "init",
+ init = V"whitespace"^-1 * Ct(V"do_init"),
+ do_init = (V"reflector" * V"whitespace")^-1
+ * V"rotors" * V"whitespace"
+ * V"ring"
+ * (V"whitespace" * V"plugboard")^-1
+ ,
+ reflector = Cg(C(R("ac","AC")) / stringlower, "reflector")
+ ,
+
+ rotors = Cg(Ct(V"rotor" * V"whitespace"
+ * V"rotor" * V"whitespace"
+ * V"rotor"),
+ "rotors")
+ ,
+ rotor = Cs(V"roman_five" / roman_digits
+ + V"roman_four" / roman_digits
+ + V"roman_three" / roman_digits
+ + V"roman_two" / roman_digits
+ + V"roman_one" / roman_digits)
+ ,
+ roman_one = P"I" + P"i",
+ roman_two = P"II" + P"ii",
+ roman_three = P"III" + P"iii",
+ roman_four = P"IV" + P"iv",
+ roman_five = P"V" + P"v",
+
+ ring = Cg(Ct(V"double_digit" * V"whitespace"
+ * V"double_digit" * V"whitespace"
+ * V"double_digit"),
+ "ring")
+ ,
+ double_digit = C(R"02" * R"09"),
+
+ plugboard = Cg(V"do_plugboard", "plugboard"),
+ --- no need to enforce exactly ten substitutions
+ --do_plugboard = Ct(V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination" * V"whitespace"
+ -- * V"letter_combination")
+ do_plugboard = Ct(V"letter_combination"
+ * (V"whitespace" * V"letter_combination")^0)
+ ,
+ letter_combination = C(R("az", "AZ") * R("az", "AZ")),
+
+ whitespace = S" \n\t\v"^1,
+ }
+
+
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Initialization routines]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+\startparagraph
+The plugboard is implemented as a pair of hash tables.
+\stopparagraph
+--ichd]]--
+ local get_plugboard_substitution = function (p)
+ --- Plugboard wirings are symmetrical, thus we have one table for
+ --- each direction.
+ local tmp, result = { }, { }
+ for _, str in next, p do
+ local one, two = stringlower(stringsub(str, 1, 1)),
+ stringlower(stringsub(str, 2))
+ tmp[one] = two
+ tmp[two] = one
+ end
+ local n_letters = 26
+
+ local lv = letter_to_value
+ for n=1, n_letters do
+ local letter = value_to_letter[n]
+ local sub = tmp[letter] or letter
+ -- Map each char either to the plugboard substitution or itself.
+ result[lv[letter]] = lv[sub or letter]
+ end
+ return result
+ end
+
+--[[ichd--
+\startparagraph
+Initialization of the rotors requires some precautions to be taken.
+The most obvious of which is adjusting the displacement of its wiring
+by the ring setting.
+\stopparagraph
+\startparagraph
+Another important task is to store the notch position in order for it
+to be retrievable by the rotation subroutine at a later point.
+\stopparagraph
+\startparagraph
+The actual bidirectional mapping is implemented as a pair of tables.
+The initial order of letters, before the ring shift is applied, is
+alphabetical on the input (right, “from”) side and, on the output
+(left, “to”) side taken by the hard wired correspondence as specified
+in the rotor wirings above.
+NB the descriptions in terms of “output” and “input” directions is
+misleading in so far as during any encoding step the electricity will
+pass through every rotor in both ways.
+Hence, the “input” (right, from) direction literally applies only to
+the first half of the encoding process between plugboard and reflector.
+\stopparagraph
+\startparagraph
+The function \luafunction{do_get_rotor} creates a single rotor instance
+and populates it with character mappings. The \identifier{from} and
+\identifier{to} subfields of its \identifier{wiring} field represent
+the wiring in the respective directions.
+This initital wiring was specified in the corresponding
+\identifier{raw_rotor_wiring} table; the ringshift is added modulo the
+alphabet size in order to get the correctly initialized rotor.
+\stopparagraph
+--ichd]]--
+ local do_get_rotor = function (raw, notch, ringshift)
+ local rotor = {
+ wiring = {
+ from = { },
+ to = { },
+ },
+ state = 0,
+ notch = notch,
+ }
+ local w = rotor.wiring
+ for from=1, 26 do
+ local to = letter_to_value[stringsub(raw, from, from)]
+ --- The shift needs to be added in both directions.
+ to = (to + ringshift - 1) % 26 + 1
+ from = (from + ringshift - 1) % 26 + 1
+ rotor.wiring.from[from] = to
+ rotor.wiring.to [to ] = from
+ end
+ --table.print(rotor, "rotor")
+ return rotor
+ end
+
+--[[ichd--
+\startparagraph
+Rotors are initialized sequentially accordings to the initialization
+request.
+The function \luafunction{get_rotors} walks over the list of
+initialization instructions and calls \luafunction{do_get_rotor} for
+the actual generation of the rotor table. Each rotor generation request
+consists of three elements:
+\stopparagraph
+\startitemize[n]
+ \item the choice of rotor (one of five),
+ \item the notch position of said rotor, and
+ \item the ring shift.
+\stopitemize
+--ichd]]--
+ local get_rotors = function (rotors, ring)
+ local s, r = { }, { }
+ for n=1, 3 do
+ local nr = tonumber(rotors[n])
+ local ni = tonumber(ring[n]) - 1 -- “1” means shift of zero
+ r[n] = do_get_rotor(raw_rotor_wiring[nr], notches[nr], ni)
+ s[n] = ni
+ end
+ return r, s
+ end
+
+ local decode_char = encode_char -- hooray for involutory ciphers
+
+--[[ichd--
+\startparagraph
+The function \luafunction{encode_general} is an intermediate step for
+the actual single-character encoding / decoding routine
+\luafunction{enchode_char}.
+Its purpose is to ensure encodability of a given character before
+passing it along.
+Characters are first checked against the replacement table
+\identifier{pp_substitutions} (see \at{page}[listing:preproc]).
+For single-character replacements the function returns the encoded
+character (string).
+However, should the replacement turn out to consist of more than one
+character, each one will be encoded successively, yielding a list.
+\stopparagraph
+--ichd]]--
+ local encode_general = function (machine, chr)
+ local chr = utf8lower(chr)
+ local replacement
+ = pp_substitutions[chr] or letter_to_value[chr] and chr
+ if not replacement then
+ if machine.other_chars then
+ return chr
+ else
+ return false
+ end
+ end
+
+ if utf8len(replacement) == 1 then
+ return encode_char(machine, replacement)
+ end
+ local result = { }
+ for new_chr in utfcharacters(replacement) do
+ result[#result+1] = encode_char(machine, new_chr)
+ end
+ return result
+ end
+
+ local process_message_key
+ local alpha = R"az"
+ local alpha_dec = alpha / letter_to_value
+ local whitespace = S" \n\t\v"
+ local mkeypattern = Ct(alpha_dec * alpha_dec * alpha_dec)
+ * whitespace^0
+ * C(alpha * alpha *alpha)
+ process_message_key = function (machine, message_key)
+ message_key = stringlower(message_key)
+ local init, three = lpegmatch(mkeypattern, message_key)
+ -- to be implemented
+ end
+
+ local decode_string = function (machine, str, message_key)
+ machine.kenngruppe, str = stringsub(str, 3, 5), stringsub(str, 6)
+ machine:process_message_key(message_key)
+ local decoded = encode_string(machine, str)
+ return decoded
+ end
+
+ local testoptions = {
+ size = 42,
+
+ }
+ local generate_header = function (options)
+ end
+
+ local processed_chars = function (machine)
+ emit(1, pprint_machine_step, machine.step, machine.name)
+ end
+
+--[[ichd--
+\startparagraph
+The day key is entrusted to the function \luafunction{handle_day_key}.
+If the day key is the empty string or \type{nil}, it will ask for a key
+on the terminal. (Cf. below, \at{page}[listing:ask_for_day_key].)
+Lesson: don’t forget providing day keys in your setups when running in
+batch mode.
+\stopparagraph
+--ichd]]--
+ local handle_day_key handle_day_key = function (dk, name, old)
+ local result
+ if not dk or dk == "" then
+ dk = ask_for_day_key(name, old)
+ end
+ result = lpegmatch(p_init, dk)
+ result.reflector = result.reflector or "b"
+ -- If we don’t like the key we’re going to ask again. And again....
+ return result or handle_day_key(nil, name, dk)
+ end
+
+--[[ichd--
+\startparagraph
+The enigma encoding is restricted to an input -- and, naturally, output
+-- alphabet of exactly twenty-seven characters. Obviously, this would
+severely limit the set of encryptable documents. For this reason the
+plain text would be \emph{preprocessed} prior to encoding, removing
+spaces and substituting a range of characters, e.\,g. punctuation, with
+placeholders (“X”) from the encodable spectrum. See above
+\at{page}[listing:preproc] for a comprehensive list of substitutions.
+\stopparagraph
+
+\startparagraph
+The above mentioned preprocessing, however, does not even nearly extend
+to the whole unicode range that modern day typesetting is expected to
+handle. Thus, sooner or later an Enigma machine will encounter
+non-preprocessable characters and it will have to decide what to do
+with them. The Enigma module offers two ways to handle this kind of
+situation: \emph{drop} those characters, possibly distorting the
+deciphered plain text, or to leave them in, leaving hints behind as to
+the structure of the encrypted text. None of these is optional, so it
+is nevertheless advisable to not include non-latin characters in the
+plain text in the first place. The settings key
+\identifier{other_chars} (type boolean) determines whether we will keep
+or drop offending characters.
+\stopparagraph
+--ichd]]--
+
+ new = function (name, args)
+ local setup_string, pattern = args.day_key, args.rotor_setting
+ local raw_settings = handle_day_key(setup_string, name)
+ local rotors, ring =
+ get_rotors(raw_settings.rotors, raw_settings.ring)
+ local plugboard
+ = raw_settings.plugboard
+ and get_plugboard_substitution(raw_settings.plugboard)
+ or get_plugboard_substitution{ }
+ local machine = {
+ name = name,
+ step = 0, -- n characters encoded
+ init = {
+ rotors = raw_settings.rotors,
+ ring = raw_settings.ring
+ },
+ rotors = rotors,
+ ring = ring,
+ state = init_state,
+ other_chars = args.other_chars,
+ spacing = args.spacing,
+ ---> a>1, b>2, c>3
+ reflector = letter_to_value[raw_settings.reflector],
+ plugboard = plugboard,
+ --- functionality
+ rotate = rotate,
+ --process_message_key = process_message_key,
+ encode_string = encode_string,
+ encode_char = encode_char,
+ encode = encode_general,
+ decode_string = decode_string,
+ decode_char = decode_char,
+ set_state = set_state,
+ processed_chars = processed_chars,
+ --- <badcodingstyle> -- hackish but occasionally useful
+ __raw = raw_settings
+ --- </badcodingstyle>
+ } --- machine
+ local init_state
+ = pattern_to_state(pattern or get_random_pattern())
+ emit(1, pprint_init, init_state)
+ machine:set_state(init_state)
+
+ --table.print(machine.rotors)
+ emit(1, pprint_new_machine, machine)
+ return machine
+ end
+
+end
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+
+--[[ichd--
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\startdocsection[title=Setup Argument Handling]
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+--ichd]]--
+do
+--[[ichd--
+\startparagraph
+As the module is intended to work both with the Plain and \LATEX\
+formats as well as \CONTEXT, we can’t rely on format dependent setups.
+Hence the need for an argument parser. Should be more efficient anyways
+as all the functionality resides in Lua.
+\stopparagraph
+--ichd]]--
+
+ local p_args = P{
+ "args",
+ args = Cf(Ct"" * (V"kv_pair" + V"emptyline")^0, rawset),
+ kv_pair = Cg(V"key"
+ * V"separator"
+ * (V"value" * V"final"
+ + V"empty"))
+ * V"rest_of_line"^-1
+ ,
+ key = V"whitespace"^0 * C(V"key_char"^1),
+ key_char = (1 - V"whitespace" - V"eol" - V"equals")^1,
+ separator = V"whitespace"^0 * V"equals" * V"whitespace"^0,
+ empty = V"whitespace"^0 * V"comma" * V"rest_of_line"^-1
+ * Cc(false)
+ ,
+ value = C((V"balanced" + (1 - V"final"))^1),
+ final = V"whitespace"^0 * V"comma" + V"rest_of_string",
+ rest_of_string = V"whitespace"^0
+ * V"eol_comment"^-1
+ * V"eol"^0
+ * V"eof"
+ ,
+ rest_of_line = V"whitespace"^0 * V"eol_comment"^-1 * V"eol",
+ eol_comment = V"comment_string" * (1 - (V"eol" + V"eof"))^0,
+ comment_string = V"lua_comment" + V"TeX_comment",
+ TeX_comment = V"percent",
+ lua_comment = V"double_dash",
+ emptyline = V"rest_of_line",
+
+ balanced = V"balanced_brk" + V"balanced_brc",
+ balanced_brk = V"lbrk"
+ * (V"balanced" + (1 - V"rbrk"))^0
+ * V"rbrk"
+ ,
+ balanced_brc = V"lbrc"
+ * (V"balanced" + (1 - V"rbrc"))^0
+ * V"rbrc"
+ ,
+ -- Terminals
+ eol = P"\n\r" + P"\r\n" + P"\n" + P"\r",
+ eof = -P(1),
+ whitespace = S" \t\v",
+ equals = P"=",
+ dot = P".",
+ comma = P",",
+ dash = P"-", double_dash = V"dash" * V"dash",
+ percent = P"%",
+ lbrk = P"[", rbrk = P"]",
+ lbrc = P"{", rbrc = P"}",
+ }
+
+
+--[[ichd--
+\startparagraph
+In the next step we process the arguments, check the input for sanity
+etc. The function \luafunction{parse_args} will test whether a value
+has a sanitizer routine and, if so, apply it to its value.
+\stopparagraph
+--ichd]]--
+
+ local boolean_synonyms = {
+ ["1"] = true,
+ doit = true,
+ indeed = true,
+ ok = true,
+ ["⊤"] = true,
+ ["true"] = true,
+ yes = true,
+ }
+ local toboolean
+ = function (value) return boolean_synonyms[value] or false end
+ local alpha = R("az", "AZ")
+ local digit = R"09"
+ local space = S" \t\v"
+ local ans = alpha + digit + space
+ local p_ans = Cs((ans + (1 - ans / ""))^1)
+ local alphanum_or_space = function (str)
+ if type(str) ~= "string" then return nil end
+ return lpegmatch(p_ans, str)
+ end
+ local ensure_int = function (n)
+ n = tonumber(n)
+ if not n then return 0 end
+ return mathfloor(n + 0.5)
+ end
+ p_alpha = Cs((alpha + (1 - alpha / ""))^1)
+ local ensure_alpha = function (s)
+ s = tostring(s)
+ return lpegmatch(p_alpha, s)
+ end
+
+ local sanitizers = {
+ other_chars = toboolean, -- true = keep, false = drop
+ spacing = toboolean,
+ day_key = alphanum_or_space,
+ rotor_setting = ensure_alpha,
+ verbose = ensure_int,
+ }
+ enigma.parse_args = function (raw)
+ local args = lpegmatch(p_args, raw)
+ for k, v in next, args do
+ local f = sanitizers[k]
+ if f then
+ args[k] = f(v)
+ else
+ -- OPTIONAL be fascist and permit only predefined args
+ args[k] = v
+ end
+ end
+ return args
+ end
+--[[ichd--
+\startparagraph
+If the machine setting lacks key settings then we’ll go ahead and ask
+\reference[listing:ask_for_day_key]{}%
+the user directly, hence the function \luafunction{ask_for_day_key}.
+We abort after three misses lest we annoy the user \dots
+\stopparagraph
+--ichd]]--
+ local max_tries = 3
+ ask_for_day_key = function (name, old, try)
+ if try == max_tries then
+ iowrite[[
+Aborting. Entered invalid key three times.
+]]
+ os.exit()
+ end
+ if old then
+ emit(0, key_invalid)
+ end
+ emit(0, polite_key_request, name)
+ local result = ioread()
+ iowrite("\n")
+ return alphanum_or_space(result) or
+ ask_for_day_key(name, (try and try + 1 or 1))
+ end
+end
+
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+--[[ichd--
+\startdocsection[title=Callback]
+\startparagraph
+This is the interface to \TEX. We generate a new callback handler for
+each defined Enigma machine. \CONTEXT\ delivers the head as third
+argument of a callback only (...‽), so we’ll have to do some variable
+shuffling on the function side.
+\stopparagraph
+
+\startparagraph
+When grouping output into the traditional blocks of five letters we
+insert space nodes. As their properties depend on the font we need to
+recreate the space item for every paragraph. Also, as \CONTEXT\ does
+not preload a font we lack access to font metrics before
+\type{\starttext}. Thus creating the space earlier will result in an
+error.
+The function \luafunction{generate_space} will be called inside the
+callback in order to get an appropriate space glue.
+\stopparagraph
+--ichd]]--
+
+local generate_space = function ( )
+ local current_fontparms = font.getfont(font.current()).parameters
+ local space_node = nodenew(GLUE_NODE)
+ space_node.spec = nodenew(GLUE_SPEC_NODE)
+ space_node.spec.width = current_fontparms.space
+ space_node.spec.shrink = current_fontparms.space_shrink
+ space_node.spec.stretch = current_fontparms.space_stretch
+ return space_node
+end
+
+--[[ichd--
+\startparagraph
+\useURL[khaled_hosny_texsx] [http://tex.stackexchange.com/a/11970]
+ [] [tex.sx]
+Registering a callback (“node attribute”?, “node task”?, “task
+action”?) in \CONTEXT\ is not straightforward, let alone documented.
+The trick is to create, install and register a handler first in order
+to use it later on \dots\ many thanks to Khaled Hosny, who posted an
+answer to \from[khaled_hosny_texsx].
+\stopparagraph
+--ichd]]--
+
+local new_callback = function (machine, name)
+ enigma.machines [name] = machine
+ local format_is_context = format_is_context
+ local current_space_node
+ local mod_5 = 0
+
+ --- First we need to choose an insertion method. If autospacing is
+ --- requested, a space will have to be inserted every five
+ --- characters. The rationale behind using differend functions to
+ --- implement each method is that it should be faster than branching
+ --- for each character.
+ local insert_encoded
+
+ if machine.spacing then -- auto-group output
+ insert_encoded = function (head, n, replacement)
+ local insert_glyph = nodecopy(n)
+ if replacement then -- inefficient but bulletproof
+ insert_glyph.char = utf8byte(replacement)
+ --print(utf8char(n.char), "=>", utf8char(insertion.char))
+ end
+ --- if we insert a space we need to return the
+ --- glyph node in order to track positions when
+ --- replacing multiple nodes at once (e.g. ligatures)
+ local insertion = insert_glyph
+ mod_5 = mod_5 + 1
+ if mod_5 > 5 then
+ mod_5 = 1
+ insertion = nodecopy(current_space_node)
+ insertion.next, insert_glyph.prev = insert_glyph, insertion
+ end
+ if head == n then --> replace head
+ local succ = head.next
+ if succ then
+ insert_glyph.next, succ.prev = succ, insert_glyph
+ end
+ head = insertion
+ else --> replace n
+ local pred, succ = n.prev, n.next
+ pred.next, insertion.prev = insertion, pred
+ if succ then
+ insert_glyph.next, succ.prev = succ, insert_glyph
+ end
+ end
+
+ --- insertion becomes the new head
+ return head, insert_glyph -- so we know where to insert
+ end
+ else
+
+ insert_encoded = function (head, n, replacement)
+ local insertion = nodecopy(n)
+ if replacement then
+ insertion.char = utf8byte(replacement)
+ end
+ if head == n then
+ local succ = head.next
+ if succ then
+ insertion.next, succ.prev = succ, insertion
+ end
+ head = insertion
+ else
+ nodeinsert_before(head, n, insertion)
+ noderemove(head, n)
+ end
+ return head, insertion
+ end
+ end
+
+ --- The callback proper starts here.
+ local aux aux = function (head, recurse)
+ if recurse == nil then recurse = 0 end
+ for n in nodetraverse(head) do
+ local nid = n.id
+ --print(utf8char(n.char), n)
+ if nid == GLYPH_NODE then
+ local chr = utf8char(n.char)
+ --print(chr, n)
+ local replacement = machine:encode(chr)
+ --print(chr, replacement, n)
+ local treplacement = replacement and type(replacement)
+ --if replacement == false then
+ if not replacement then
+ noderemove(head, n)
+ elseif treplacement == "string" then
+ --print(head, n, replacement)
+ head, _ = insert_encoded(head, n, replacement)
+ elseif treplacement == "table" then
+ local current = n
+ for i=1, #replacement do
+ head, current = insert_encoded(head, current, replacement[i])
+ end
+ end
+ elseif nid == GLUE_NODE then
+ if n.subtype ~= 15 then -- keeping the parfillskip
+ noderemove(head, n)
+ end
+ elseif IGNORE_NODES[nid] then
+ -- drop spaces and kerns
+ noderemove(head, n)
+ elseif nid == DISC_NODE then
+ --- ligatures need to be resolved if they are characters
+ local npre, npost = n.pre, n.post
+ if nodeid(npre) == GLYPH_NODE and
+ nodeid(npost) == GLYPH_NODE then
+ if npre.char and npost.char then -- ligature between glyphs
+ local replacement_pre = machine:encode(utf8char(npre.char))
+ local replacement_post = machine:encode(utf8char(npost.char))
+ insert_encoded(head, npre, replacement_pre)
+ insert_encoded(head, npost, replacement_post)
+ else -- hlists or whatever
+ -- pass
+ --noderemove(head, npre)
+ --noderemove(head, npost)
+ end
+ end
+ noderemove(head, n)
+ elseif nid == HLIST_NODE or nid == VLIST_NODE then
+ if nodelength(n.list) > 0 then
+ n.list = aux(n.list, recurse + 1)
+ end
+-- else
+-- -- TODO other node types
+-- print(n)
+ end
+ end
+ nodeslide(head)
+ return head
+ end -- callback auxiliary
+
+ --- Context requires
+ --- × argument shuffling; a properly registered “action” gets the
+ --- head passed as its third argument
+ --- × hacking our way around the coupling of pre_linebreak_filter
+ --- and hpack_filter; background:
+ --- http://www.ntg.nl/pipermail/ntg-context/2012/067779.html
+ local cbk = function (a, _, c)
+ local head
+ current_space_node = generate_space ()
+ mod_5 = 0
+ if format_is_context == true then
+ head = c
+ local cbk_env = get_debug_info(4) -- no getenv in lua 5.2
+ --inspect(cbk_env)
+ if cbk_env.func == nodes.processors.pre_linebreak_filter then
+ -- how weird is that?
+ return aux(head)
+ end
+ return head
+ end
+ head = a
+ return aux(head)
+ end
+
+ if format_is_context then
+ local cbk_id = "enigma_" .. name
+ enigma.callbacks[name] = nodesinstallattributehandler{
+ name = cbk_id,
+ namespace = thirddata.enigma,
+ processor = cbk,
+ }
+ local cbk_location = "thirddata.enigma.callbacks." .. name
+ nodestasksappendaction("processors",
+ --"characters",
+ --"finalizers",
+ --- this one is tagged “for users”
+ --- (cf. node-tsk.lua)
+ "before",
+ cbk_location)
+ nodestasksdisableaction("processors", cbk_location)
+ else
+ enigma.callbacks[name] = cbk
+ end
+end
+
+--[[ichd--
+\startparagraph
+Enigma\reference[listing:retrieve]{} machines can be copied and derived
+from one another at will, cf. the \texmacro{defineenigma} on
+\at{page}[listing:define]. Two helper functions residing inside the
+\identifier{thirddata.enigma} namespace take care of these actions:
+\luafunction{save_raw_args} and \luafunction{retrieve_raw_args}. As
+soon as a machine is defined, we store its parsed options inside the
+table \identifier{configurations} for later reference. For further
+details on the machine derivation mechanism see
+\at{page}[listing:inherit].
+\stopparagraph
+--ichd]]--
+local configurations = { }
+
+local save_raw_args = function (conf, name)
+ local current = configurations[name] or { }
+ for k, v in next, conf do
+ current[k] = v
+ end
+ configurations[name] = current
+end
+
+local retrieve_raw_args = function (name)
+ local cn = configurations[name]
+ return cn and tablecopy(cn) or { }
+end
+
+enigma.save_raw_args = save_raw_args
+enigma.retrieve_raw_args = retrieve_raw_args
+
+
+--[[ichd--
+\startparagraph
+The function \luafunction{new_machine} instantiates a table containing
+the complete specification of a workable \emph{Enigma} machine and
+other metadata. The result is intended to be handed over to the
+callback creation mechanism (\luafunction{new_callback}). However, the
+arguments table is usally stored away in the
+\identifier{thirddata.enigma} namespace anyway
+(\luafunction{save_raw_args}), so that the specification of any machine
+can be inherited by some new setup later on.
+\stopparagraph
+--ichd]]--
+local new_machine = function (name)
+ local args = configurations[name]
+ --table.print(configurations)
+ verbose_level = args and args.verbose or verbose_level
+ local machine = new(name, args)
+ return machine
+end
+
+enigma.new_machine = new_machine
+enigma.new_callback = new_callback
+
+--[[ichd--
+\stopdocsection
+--ichd]]--
+
+-- vim:ft=lua:sw=2:ts=2:tw=71:expandtab