%D \module
%D   [      file=s-system-macros.mkxl,
%D        version=2020.06.02,
%D          title=\CONTEXT\ Style File,
%D       subtitle=System Macros Checking,
%D         author=Hans Hagen,
%D           date=\currentdate,
%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
%C
%C This module is part of the \CONTEXT\ macro||package and is
%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
%C details.

%D This file is for Wolfgang and Hans and it's used in the transition from \MKIV\
%D to the more robust \LMTX.

% todo:  \permanent\protected\let\select\directselect : same value (add ref)
%
% todo: when mutable, remove immutable, decide on how immutable it really is
%
% todo: just for the fun of it we can compare the table generated here to mkiv but it
% needs the same hash exposure as we use in luametatex so i'll do that after all lmtx
% macros are checked (maybe i need to backport some more but it has a low priority)
%
% todo: do we need something similar for lua functions etc (problem: performance hit)
%
% todo: and how about metapost ... I need a mp.hashtokens in order to do that and I also
% need to think about protection there (tricky as we use an avl hash there)
%
% todo:  when possible replace \p_whatever_key by \p_key
%
% public undefined : SmallCaps scitebuffer sciteinlinebuffer
% single todos     : \ \- \\ \_

\enablemode[texmacros]
\enablemode[metapostmacros]
% \enablemode[notmarked]
\enablemode[everything]

\startmodule[system-macros]

\continueifinputfile{s-system-macros.mkxl}

% \usemodule[article-basic] \setuplayout[tight] \setupbodyfont[7pt,tt]
\usemodule[article-basic] \setuplayout[tight] \setupbodyfont[5pt,tt]

\setupbackgrounds[page][background=color,backgroundcolor=darkgray] \setupcolors[textcolor=white]

\setuppapersize
  [A4,landscape]
  [A4,landscape]

\bitwiseflip \normalizelinemode \discardzerotabskipsnormalizecode

\pushoverloadmode
    \aliased\let\\=\letterbackslash
\popoverloadmode

\starttext

\startluacode

    if tex.modes.texmacros then

        local context     = context
        local ctx_NC      = context.NC
        local ctx_NR      = context.NR
        local ctx_bold    = context.bold
        local ctx_verb    = context.verbatim
        local ctx_escaped = context.escaped

        local find     = string.find
        local gsub     = string.gsub
        local gmatch   = string.gmatch
        local create   = tokens.create

        local crap     = "[$>%|%&%#" .. string.char(0xEF) .. "]"

        local basefile  = resolvers.findfile("context.mkxl")
        local swapnames = { }

        local pattern   = file.join(file.pathpart(basefile),"/*.mk*")
        local filenames = dir.glob(pattern)
        for i=1,#filenames do
            swapnames[file.basename(filenames[i])] = true
        end

        local pattern   = file.join(file.pathpart(basefile),"/*.l**")
        local filenames = dir.glob(pattern)
        for i=1,#filenames do
            swapnames[file.basename(filenames[i])] = true
        end

        local hashnames = table.setmetatableindex(function(t,k)
            local s = file.suffix(k)
            local v = k
            if s == "mkiv" then
                local n = file.replacesuffix(k,"mkxl")
                if swapnames[n] then
                    v = n
                end
            elseif s == "mkvi" then
                local n = file.replacesuffix(k,"mklx")
                if swapnames[n] then
                    v = n
                end
            elseif s == "lua" then
                local n = file.replacesuffix(k,"lmt")
                if swapnames[n] then
                    v = n
                end
            end
            t[k] = v
            return v
        end)

        require("mtx-interface")

        local data       = scripts.interface.editor("data")
        local files      = data and data.common and data.common.filenames or { }
        local macros     = { }
        local registers  = { }
        local implements = { }
        local flagged    = 0
        local total      = 0
        local list       = tex.hashtokens()
        local all        = not tex.modes.notmarked
        local everything = tex.modes.everything
        local getmacro   = token.getmacro

        local fmtname = resolvers.locateformat("cont-en.fmt")
        if fmtname then
            local logname = file.replacesuffix(fmtname,"log")
            for filename in gmatch(io.loaddata(logname),"fullname=(%S+)") do
                local s = file.suffix(filename)
                local b = file.basename(filename)
                if s ~= "lua" and s ~= "lmt" then
-- todo: newfloat etc
                    local d = io.loaddata(filename)
                    -- we could make a nice lpeg
                    for m in gmatch(d,"\n[\\a-z]*[exg]*def\\([a-zA-Z_]+)") do
                        macros[m] = b
                    end
                    for m in gmatch(d,"\n[\\a-z]*[g]*let\\([a-zA-Z_]+)") do
                        macros[m] = b
                    end
                    for m in gmatch(d,"\n\\lettonothing\\([a-zA-Z_]+)") do
                        macros[m] = b
                    end
                    for m in gmatch(d,"\n\\integerdef\\([a-zA-Z_]+)") do
                        macros[m] = b
                    end
                    for m in gmatch(d,"\n\\dimensiondef\\([a-zA-Z_]+)") do
                        macros[m] = b
                    end
                    for m in gmatch(d,"\n\\gluespecdef\\([a-zA-Z_]+)") do
                        macros[m] = b
                    end
                    for m in gmatch(d,"\n\\mugluespecdef\\([a-zA-Z_]+)") do
                        macros[m] = b
                    end
                    for m in gmatch(d,"\n\\newinteger\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newdimension\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newgluespec\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newmugluespec\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newconditional\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newtoks\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newcount\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newdimen\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newskip\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                    for m in gmatch(d,"\n\\newmuskip\\([a-zA-Z_]+)") do
                        registers[m] = b
                    end
                elseif b ~= "char-def.lua" then
                    local d = io.loaddata(filename)
                    -- maybe inside implement { }
                    -- maybe get file from debug interface
                    for m in gmatch(d,'\n +name += +"([a-zA-Z_]+)",') do
                        implements[m] = b
                    end
                end
            end
        end

        table.sort(list)

        local function show(visible, check)
            context.starttabulate { "|l|l|r|r|lj2|l|l|l|l|l|l|l|l|l|l|l|" }
            for i=1,#list do
                local k = list[i]
                if check(k) then
                    local v = create(k)
                    local mutable    = v.mutable    and "mutable"
                    local immutable  = v.immutable  and "immutable"
                    local frozen     = v.frozen     and "frozen"
                    local permanent  = v.permanent  and "permanent"
                    local primitive  = v.primitive  and "primitive"
                    local instance   = v.instance   and "instance"
                    local constant   = v.constant   and "constant"
                    local untraced   = v.untraced   and "untraced"
                    local dealtwith  = mutable or immutable or mutable or frozen or permanent or primitive -- beware: we can have combinations
                    local whatever   = find(k,"^[a-z][a-z][a-z]+_")
                    local cscommand  = gsub(v.cmdname or "","_"," ")
                    local undefined  = cscommand == "undefined cs"
                    local marked     = (dealtwith and "+") or (whatever and "-") or (instance and "!")
                    if everything or ((all or not marked) and not find(k,"^[pvm]_") and not find(k,"^![tT]")) then
                        local parameters = v.parameters
                        local noaligned  = v.noaligned  and "noaligned"
                        local filename   = files[k] or macros[k] or implements[k] or registers[k] or implements[gsub(k,"^clf_","")]
                        local csname     = context.escape(k)
                        local size       = v.size or 0
                        if undefined then
                            marked = "?"
                        end
                        ctx_NC() if marked then
                                    context(marked)
                                 end
                        ctx_NC() if primitive then
                                    ctx_bold(csname)
                                 else
                                    ctx_verb(csname)
                                 end
                        ctx_NC() if size > 0 then
                                    context(size)
                                 end
                        ctx_NC() if parameters then
                                    context(parameters > 0 and parameters or "-")
                                 end
                        ctx_NC() if undefined then
                                    context.red(false)
                                 end
                                 context(cscommand)
                        ctx_NC() if primitive then
                                    context(primitive)
                                 end
                        ctx_NC() if permanent then
                                    context(permanent)
                                 end
                        ctx_NC() if immutable then
                                    context(immutable)
                                 end
                        ctx_NC() if frozen then
                                    context(frozen)
                                 end
                        ctx_NC() if mutable then
                                    context(mutable)
                                 end
                        ctx_NC() if instance then
                                    context(instance)
                                 end
                        ctx_NC() if noaligned then
                                    context(noaligned)
                                 end
                        ctx_NC() if constant then
                                    context(constant)
                                 end
                        ctx_NC() if untraced then
                                    context(untraced)
                                 end
                        ctx_NC() if filename then
                                    context(hashnames[filename])
                                 end
                        ctx_NC() if parameters then
                                    if parameters > 0 then
                                     -- context("\\let\\\\=\\letterbackslash")
                                        ctx_escaped(getmacro(csname,false,true))
                                    end
                                 end
                        ctx_NC() ctx_NR()
                    end
                    if visible then
                        total = total + 1
                        if dealtwith then
                            flagged = flagged + 1
                        end
                    end
                end
            end
            context.stoptabulate()
        end

        context.starttitle { title = "Public \\TEX\\ commands" }
            show(true, function(k) return find(k,"^[a-zA-Z]+$") end)
        context.stoptitle()

        context.starttitle { title = "Private \\TEX\\ commands" }
            show(false, function(k) return not find(k,"^[a-zA-Z]+$") and not find(k,crap) end)
        context.stoptitle()

        tokens.setters.macro("NumberOfVisible", total)
        tokens.setters.macro("NumberOfFlagged", flagged)

    end

\stopluacode

\startmode[texmacros]

    \page

    \starttabulate[|c|l|]
    \HL
    \NC \type {+}   \NC mutable, immutable, frozen, permanent, primitive \NC \NR
    \NC \type {-}   \NC protected by obscurity (underscores) \NC \NR
    \NC \type {!}   \NC instance (can be frozen) \NC \NR
    \NC \type {0-9} \NC the number of arguments (argument grabbing can be delegated) \NC \NR
    \HL
    \stoptabulate

    \start \hsize 15cm \veryraggedright
    Often frozen commands are redefined on demand and they can be overloaded. Mutable
    doesn't mean that a user can change it without consequences, for instance the
    \type {\current...} ones. Primitives come with the engine, permanent macros are
    the core of \CONTEXT. Noaligned macros are special and dealt deep down when
    scanning for alignment specific primitives.
    \par \stop

    \starttabulate[||r|]
    \BC number of visible macros  \NC \NumberOfVisible \NC \NR
    \BC number of flagged macros  \NC \NumberOfFlagged \NC \NR
    \stoptabulate

\stopmode

\page

\startluacode

    if tex.modes.metapostmacros then

        local context  = context
     -- local ctx_NC   = context.NC
     -- local ctx_NR   = context.NR
     -- local ctx_bold = context.bold

        local find     = string.find
        local gsub     = string.gsub
        local create   = tokens.create

        context.starttitle { title = "\\METAFUN\\ commands" }

            metapost.simple("prestine")

            local mptotal    = 0
            local codes      = metapost.codes
            local types      = metapost.types
            local parameters = metapost.knownparameters
            local procodes   = mplib.propertycodes
            local everything = tex.modes.everything

            context.startcolumns { n = 5, distance = "1em" }
                context.nohyphens(false)
                context.obeyspaces(false)
                local t = metapost.gethashentries("prestine",true) -- prestine:1
                if t then
                    table.sort(t,function(a,b) return a[3] < b[3] end)
                    mptotal = #t
                    for i=1,mptotal do
                        local ti       = t[i]
                        local code     = codes[ti[1]]
                        local property = procodes[ti[2]]
                        local name     = ti[3]
                        local vtype    = ti[4]
                        local vardef   = vtype and types[vtype] == "unsuffixedmacro"
                        context.bgroup()
                     -- context("%-15s\\quad",vardef and "(vardef) tag" or code)
                        context("%s %-15s\\quad",parameters[name] and "+" or "\\nbsp",vardef and "(vardef) tag" or code)
                        if property == "primitive" then
                            context.bf(false)
                            context.blue(false)
                        elseif property == "permanent"  then
                            context.bf(false)
                            context.lightgreen(false)
                        elseif property == "immutable"  then
                            context.bf(false)
                            context.lightcyan(false)
                        elseif property == "mutable"  then
                            context.bf(false)
                            context.lightmagenta(false)
                        elseif everything or not find(name,"^%a+_") then
                            -- todo:
                            if vardef then
                                context.bf(false)
                                context.lightred(false)
                            end
                        end
                        context.verbatim(name)
                        context.egroup()
                        context.par()
                    end
                end
            context.stopcolumns()

        context.stoptitle()

        tokens.setters.macro("NumberOfMetafun", mptotal)

    end
\stopluacode

\startmode [metapostmacros]

    \page

    \starttabulate[|c|l|]
    \HL
    \NC \type {-3} \NC \bf \lightmagenta mutable   \NC \NR
    \NC \type  {1} \NC \bf \blue         primitive \NC \NR
    \NC \type  {2} \NC \bf \lightgreen   permanent \NC \NR
    \NC \type  {3} \NC \bf \lightcyan    immutable \NC \NR
    \NC \type  {+} \NC \bf (also) used as key      \NC \NR
    \HL
    \stoptabulate

    \starttabulate[||r|]
    \BC number of metafun entries \NC \NumberOfMetafun \NC \NR
    \stoptabulate

\stopmode

\stopmodule
