% language=us runpath=texruns:manuals/luametatex \environment luametatex-style \startcomponent luametatex-callbacks \startchapter[reference=callbacks,title={\LUA\ callbacks}] \startsection[title={Registering callbacks}][library=callback] \topicindex{callbacks} \libindex{register} \libindex{list} \libindex{find} \libindex{known} {\em The callbacks are a moving target. Don't bother me with questions about them. Some are new and/or experimental and therefore not yet documented. In \CONTEXT\ we can easily adapt interfaces so changes in these have no real effect on users. Of course in due time all will be official and documented.} This library has functions that register, find and list callbacks. Callbacks are \LUA\ functions that are called in well defined places. There are two kinds of callbacks: those that mix with existing functionality, and those that (when enabled) replace functionality. In most cases the second category is expected to behave similar to the built in functionality because in a next step specific data is expected. For instance, you can replace the hyphenation routine. The function gets a list that can be hyphenated (or not). The final list should be valid and is (normally) used for constructing a paragraph. Another function can replace the ligature builder and|/|or kern routine. Doing something else is possible but in the end might not give the user the expected outcome. The first thing you need to do is registering a callback: \startfunctioncall id = callback.register( callback_name, func) id = callback.register( callback_name, nil) id = callback.register( callback_name, false) \stopfunctioncall Here the \syntax {callback_name} is a predefined callback name, see below. The function returns the internal \type {id} of the callback or \type {nil}, if the callback could not be registered. \LUATEX\ internalizes the callback function in such a way that it does not matter if you redefine a function accidentally. Callback assignments are always global. You can use the special value \type {nil} instead of a function for clearing the callback. For some minor speed gain, you can assign the boolean \type {false} to the non|-|file related callbacks, doing so will prevent \LUATEX\ from executing whatever it would execute by default (when no callback function is registered at all). Be warned: this may cause all sorts of grief unless you know \notabene {exactly} what you are doing! \startfunctioncall info = callback.list() \stopfunctioncall The keys in the table are the known callback names, the value is a boolean where \type {true} means that the callback is currently set (active). \startfunctioncall f = callback.find(callback_name) \stopfunctioncall If the callback is not set, \type {find} returns \type {nil}. The \type {known} function can be used to check if a callback is supported. \startfunctioncall if callback.known("foo") then ... end \stopfunctioncall \stopsection \startsection[title={File related callbacks},reference=iocallback][library=callback] \startsubsection[title={\cbk {find_format_file} and \cbk {find_log_file}}] \topicindex{callbacks+format file} \topicindex{callbacks+log file} These callbacks are called as: \startfunctioncall actualname = function ( askedname) \stopfunctioncall The \type {askedname} is a format file for reading (the format file for writing is always opened in the current directory) or a log file for writing. \stopsubsection \startsubsection[title={\cbk {open_data_file}}] \topicindex{callbacks+opening files} This callback function gets a filename passed: \startfunctioncall
env = function ( filename) \stopfunctioncall The return value is either the boolean value false or a table with two functions. A mandate \type {reader} function fill be called once for each new line to be read, the optional \type {close} function will be called once \LUATEX\ is done with the file. \LUATEX\ never looks at the rest of the table, so you can use it to store your private per|-|file data. Both the callback functions will receive the table as their only argument. % No longer needed anyway. % % \subsection{\cbk {if_end_of_file}} % % \topicindex{callbacks+checking files} % % This callback has no arguments and your function should return true or false. The % callback is triggered by \type {\ifeof}. It's up to the macro package to come up % with a reasonable implementation. By default the test is always true. % % \startfunctioncall % eof = % function () % \stopfunctioncall \stopsubsection \stopsection \startsection[title={Data processing callbacks}][library=callback] \startsubsection[title={\cbk {process_jobname}}] \topicindex{callbacks+jobname} This callback allows you to change the jobname given by \prm {jobname} in \TEX\ and \type {tex.jobname} in Lua. It does not affect the internal job name or the name of the output or log files. \startfunctioncall function( jobname) return adjusted_jobname end \stopfunctioncall The only argument is the actual job name; you should not use \type {tex.jobname} inside this function or infinite recursion may occur. If you return \type {nil}, \LUATEX\ will pretend your callback never happened. This callback does not replace any internal code. \stopsubsection \stopsection \startsection[title={Node list processing callbacks}][library=callback] The description of nodes and node lists is in~\in{chapter}[nodes]. \startsubsection[title={\cbk {contribute_filter}}] \topicindex{callbacks+contributions} This callback is called when \LUATEX\ adds contents to list: \startfunctioncall function( extrainfo) end \stopfunctioncall The string reports the group code. From this you can deduce from what list you can give a treat. \starttabulate[|l|p|] \DB value \BC explanation \NC \NR \TB \NC \type{pre_box} \NC interline material is being added \NC \NR \NC \type{pre_adjust} \NC \prm {vadjust} material is being added \NC \NR \NC \type{box} \NC a typeset box is being added (always called) \NC \NR \NC \type{adjust} \NC \prm {vadjust} material is being added \NC \NR \LL \stoptabulate \stopsubsection \startsubsection[title={\cbk {buildpage_filter}}] \topicindex{callbacks+building pages} This callback is called whenever \LUATEX\ is ready to move stuff to the main vertical list. You can use this callback to do specialized manipulation of the page building stage like imposition or column balancing. \startfunctioncall function( extrainfo) end \stopfunctioncall The string \type {extrainfo} gives some additional information about what \TEX's state is with respect to the \quote {current page}. The possible values for the \cbk {buildpage_filter} callback are: \starttabulate[|l|p|] \DB value \BC explanation \NC \NR \TB \NC \type{alignment} \NC a (partial) alignment is being added \NC \NR \NC \type{after_output} \NC an output routine has just finished \NC \NR \NC \type{new_graf} \NC the beginning of a new paragraph \NC \NR \NC \type{vmode_par} \NC \prm {par} was found in vertical mode \NC \NR \NC \type{hmode_par} \NC \prm {par} was found in horizontal mode \NC \NR \NC \type{insert} \NC an insert is added \NC \NR \NC \type{penalty} \NC a penalty (in vertical mode) \NC \NR \NC \type{before_display} \NC immediately before a display starts \NC \NR \NC \type{after_display} \NC a display is finished \NC \NR \NC \type{end} \NC \LUATEX\ is terminating (it's all over) \NC \NR \LL \stoptabulate \stopsubsection \startsubsection[title={\cbk {insert_distance}}] \topicindex{callbacks+inserts} This callback is called when the page builder adds an insert. There is not much control over this mechanism but this callback permits some last minute manipulations of the spacing before an insert, something that might be handy when for instance multiple inserts (types) are appended in a row. \startfunctioncall function( n, i) return register end \stopfunctioncall with \starttabulate[|l|p|] \DB value \BC explanation \NC \NR \TB \NC \type{n} \NC the insert class \NC \NR \NC \type{i} \NC the order of the insert \NC \NR \LL \stoptabulate The return value is a number indicating the skip register to use for the prepended spacing. This permits for instance a different top space (when \type {i} equals one) and intermediate space (when \type {i} is larger than one). Of course you can mess with the insert box but you need to make sure that \LUATEX\ is happy afterwards. \stopsubsection \startsubsection[title={\cbk {pre_linebreak_filter}}] \topicindex{callbacks+linebreaks} This callback is called just before \LUATEX\ starts converting a list of nodes into a stack of \prm {hbox}es, after the addition of \prm {parfillskip}. \startfunctioncall function( head, groupcode) return newhead end \stopfunctioncall The string called \type {groupcode} identifies the nodelist's context within \TEX's processing. The range of possibilities is given in the table below, but not all of those can actually appear in \cbk {pre_linebreak_filter}, some are for the \cbk {hpack_filter} and \cbk {vpack_filter} callbacks that will be explained in the next two paragraphs. \starttabulate[|l|p|] \DB value \BC explanation \NC \NR \TB \NC \type{} \NC main vertical list \NC \NR \NC \type{hbox} \NC \prm {hbox} in horizontal mode \NC \NR \NC \type{adjusted_hbox} \NC \prm {hbox} in vertical mode \NC \NR \NC \type{vbox} \NC \prm {vbox} \NC \NR \NC \type{vtop} \NC \prm {vtop} \NC \NR \NC \type{align} \NC \prm {halign} or \prm {valign} \NC \NR \NC \type{disc} \NC discretionaries \NC \NR \NC \type{insert} \NC packaging an insert \NC \NR \NC \type{vcenter} \NC \prm {vcenter} \NC \NR \NC \type{local_box} \NC \prm {localleftbox} or \prm {localrightbox} \NC \NR \NC \type{split_off} \NC top of a \prm {vsplit} \NC \NR \NC \type{split_keep} \NC remainder of a \prm {vsplit} \NC \NR \NC \type{align_set} \NC alignment cell \NC \NR \NC \type{fin_row} \NC alignment row \NC \NR \LL \stoptabulate As for all the callbacks that deal with nodes, the return value can be one of three things: \startitemize \startitem boolean \type {true} signals successful processing \stopitem \startitem \type {} signals that the \quote {head} node should be replaced by the returned node \stopitem \startitem boolean \type {false} signals that the \quote {head} node list should be ignored and flushed from memory \stopitem \stopitemize This callback does not replace any internal code. \stopsubsection \startsubsection[title={\cbk {linebreak_filter}}] \topicindex{callbacks+linebreaks} This callback replaces \LUATEX's line breaking algorithm. \startfunctioncall function( head, is_display) return newhead end \stopfunctioncall The returned node is the head of the list that will be added to the main vertical list, the boolean argument is true if this paragraph is interrupted by a following math display. If you return something that is not a \type {}, \LUATEX\ will apply the internal linebreak algorithm on the list that starts at \type {}. Otherwise, the \type {} you return is supposed to be the head of a list of nodes that are all allowed in vertical mode, and at least one of those has to represent an \prm {hbox}. Failure to do so will result in a fatal error. Setting this callback to \type {false} is possible, but dangerous, because it is possible you will end up in an unfixable \quote {deadcycles loop}. \stopsubsection \startsubsection[title={\type {append_to_vlist_filter}}] \topicindex{callbacks+contributions} This callback is called whenever \LUATEX\ adds a box to a vertical list (the \type {mirrored} argument is obsolete): \startfunctioncall function( box, locationcode, prevdepth) return list [, prevdepth [, checkdepth ] ] end \stopfunctioncall It is ok to return nothing or \type {nil} in which case you also need to flush the box or deal with it yourself. The prevdepth is also optional. Locations are \type {box}, \type {alignment}, \type {equation}, \type {equation_number} and \type {post_linebreak}. When the third argument returned is \type {true} the normal prevdepth correction will be applied, based on the first node. \stopsubsection \startsubsection[title={\cbk {post_linebreak_filter}}] \topicindex{callbacks+linebreaks} This callback is called just after \LUATEX\ has converted a list of nodes into a stack of \prm {hbox}es. \startfunctioncall function( head, groupcode) return newhead end \stopfunctioncall This callback does not replace any internal code. \stopsubsection \startsubsection[title={\cbk {glyph_run}}] \topicindex{callbacks+fonts} \topicindex{callbacks+hyphenation} \topicindex{callbacks+kerning} \topicindex{callbacks+ligature building} When set this callback is triggered when \TEX\ normally handles the ligaturing and kerning. In \LUATEX\ you use the \typ {hpack_filter} and \typ {per_linebreak_filter} callbacks for that (where each passes different arguments). This callback doesn't get triggered when there are no glyphs (in \LUATEX\ this optimization is controlled by a a variable). \startfunctioncall function( head, groupcode, direction]) return newhead end \stopfunctioncall The traditional \TEX\ font processing is bypassed so you need to take care of that with the helpers. (For the moment we keep the ligaturing and kerning callbacks but they are kind of obsolete.) \stopsubsection \startsubsection[title={\cbk {hpack_filter}}] \topicindex{callbacks+packing} This callback is called when \TEX\ is ready to start boxing some horizontal mode material. Math items and line boxes are ignored at the moment. \startfunctioncall function( head, groupcode, size, packtype [, direction] [, attributelist]) return newhead end \stopfunctioncall The \type {packtype} is either \type {additional} or \type {exactly}. If \type {additional}, then the \type {size} is a \type {\hbox spread ...} argument. If \type {exactly}, then the \type {size} is a \type {\hbox to ...}. In both cases, the number is in scaled points. This callback does not replace any internal code. \stopsubsection \startsubsection[title={\cbk {vpack_filter}}] \topicindex{callbacks+packing} This callback is called when \TEX\ is ready to start boxing some vertical mode material. Math displays are ignored at the moment. This function is very similar to the \cbk {hpack_filter}. Besides the fact that it is called at different moments, there is an extra variable that matches \TEX's \prm {maxdepth} setting. \startfunctioncall function( head, groupcode, size, packtype, maxdepth [, direction] [, attributelist])) return newhead end \stopfunctioncall This callback does not replace any internal code. \stopsubsection \startsubsection[title={\cbk {packed_vbox_filter}}] \topicindex{callbacks+packing} After the \cbk {vpack_filter} callback (see previous section) is triggered the box get packed and after that this callback can be configured to kick in. \startfunctioncall function( head, groupcode) return newhead end \stopfunctioncall This callback does not replace any internal code. \stopsubsection \startsubsection[title={\cbk {alignment_filter}}] \topicindex{callbacks+alignments} This is an experimental callback that when set is called several times during the construction of an alignment. The context values are available in \typ {tex.getalignmentcontextvalues()}. \startfunctioncall function( head, context, attributes, preamble) -- no return values end \stopfunctioncall There are no sanity checks so if a user messes up the passed node lists the results can be unpredictable and, as with other node related callbacks, crash the engine. \stopsubsection \startsubsection[title={\cbk {localbox_filter}}] \topicindex{callbacks+local boxes} Local boxes are a somewhat tricky and error prone feature so use this callback with care because the paragraph is easily messed up. A line can have a left, right and middle box where the middle one has no width. The callback gets quite some parameters passed: \startfunctioncall function( linebox, leftbox, rightbox, middlebox, linenumber, leftskip, rightskip, lefthang, righthang, indentation, parinitleftskip, parinitrightskip, parfillleftskip, parfillrightskip, overshoot) -- no return values end \stopfunctioncall This is an experimental callback that will be tested in different \CONTEXT\ mechanisms before it will be declared stable. \stopsubsection \startsubsection[title={\cbk {process_rule}}] \topicindex{callbacks+rules} This is an experimental callback. It can be used with rules of subtype~4 (user). The callback gets three arguments: the node, the width and the height. The callback can use \type {pdf.print} to write code to the \PDF\ file but beware of not messing up the final result. No checking is done. \stopsubsection \startsubsection[title={\type {pre_output_filter}}] \topicindex{callbacks+output} This callback is called when \TEX\ is ready to start boxing the box 255 for \prm {output}. \startfunctioncall function( head, groupcode, size, packtype, maxdepth [, direction]) return newhead end \stopfunctioncall This callback does not replace any internal code. \stopsubsection \startsubsection[title={\cbk {hyphenate}}] \topicindex{callbacks+hyphenation} This callback is supposed to insert discretionary nodes in the node list it receives. \startfunctioncall function( head, tail) -- no return values end \stopfunctioncall Setting this callback to \type {false} will prevent the internal discretionary insertion pass. \stopsubsection \startsubsection[title={\cbk {ligaturing}}] \topicindex{callbacks+ligature building} This callback, which expects no return values, has to apply ligaturing to the node list it receives. \startfunctioncall function( head, tail) -- no return values end \stopfunctioncall You don't have to worry about return values because the \type {head} node that is passed on to the callback is guaranteed not to be a glyph_node (if need be, a temporary node will be prepended), and therefore it cannot be affected by the mutations that take place. After the callback, the internal value of the \quote {tail of the list} will be recalculated. The \type {next} of \type {head} is guaranteed to be non-nil. The \type {next} of \type {tail} is guaranteed to be nil, and therefore the second callback argument can often be ignored. It is provided for orthogonality, and because it can sometimes be handy when special processing has to take place. Setting this callback to \type {false} will prevent the internal ligature creation pass. You must not ruin the node list. For instance, the head normally is a local par node, and the tail a glue. Messing too much can push \LUATEX\ into panic mode. \stopsubsection \startsubsection[title={\cbk {kerning}}] \topicindex{callbacks+kerning} This callback has to apply kerning between the nodes in the node list it receives. See \cbk {ligaturing} for calling conventions. \startfunctioncall function( head, tail) -- no return values end \stopfunctioncall Setting this callback to \type {false} will prevent the internal kern insertion pass. You must not ruin the node list. For instance, the head normally is a local par node, and the tail a glue. Messing too much can push \LUATEX\ into panic mode. \stopsubsection \startsubsection[title={\cbk {append_line_filter}}] \topicindex{callbacks+lines} Every time a line is added this callback is triggered, when set. migrated material and adjusts also qualify as such and the detail relates to the adjust index. \startfunctioncall function( head, tail, context, detail) return newhead end \stopfunctioncall A list of possible context values can be queried with \typ {tex.getappendlinecontextvalues()}. \stopsubsection \stopsection \startsection[title={Paragraph callbacks}] \startsubsection[title={\type {insert_par}}] \topicindex{callbacks+paragraphs} Each paragraph starts with a local par node that keeps track of for instance the direction. You can hook a callback into the creator: \startfunctioncall function( par, location) -- no return values end \stopfunctioncall There is no return value and you should make sure that the node stays valid as otherwise \TEX\ can get confused. \stopsubsection \startsubsection[title={\cbk {begin_paragraph}}] \topicindex{callbacks+paragraphs} {\em todo} \stopsubsection \startsubsection[title={\cbk {paragraph_context}}] \topicindex{callbacks+paragraphs} {\em todo} \stopsubsection \startsection[title={Math related callbacks}] \startsubsection[title={\cbk {mlist_to_hlist}}] \topicindex{callbacks+math} This callback replaces \LUATEX's math list to node list conversion algorithm. \startfunctioncall function( head, display_type, need_penalties) return newhead end \stopfunctioncall The returned node is the head of the list that will be added to the vertical or horizontal list, the string argument is either \quote {text} or \quote {display} depending on the current math mode, the boolean argument is \type {true} if penalties have to be inserted in this list, \type {false} otherwise. Setting this callback to \type {false} is bad, it will almost certainly result in an endless loop. \stopsubsection \startsubsection[title={\cbk {math_rule}}] \topicindex{callbacks+math} \topicindex{callbacks+ruled} {\em todo} \stopsubsection \startsubsection[title={\cbk {make_extensible}}] \topicindex{callbacks+math} \topicindex{callbacks+fonts} {\em todo} \stopsubsection \startsubsection[title={\cbk {register_extensible}}] \topicindex{callbacks+math} \topicindex{callbacks+fonts} {\em todo} \stopsubsection \stopsection \startsection[title={Information reporting callbacks}][library=callback] \startsubsection[title={\cbk {pre_dump}}] \topicindex{callbacks+dump} \startfunctioncall function() -- no return values end \stopfunctioncall This function is called just before dumping to a format file starts. It does not replace any code and there are neither arguments nor return values. \stopsubsection \startsubsection[title={\cbk {start_run}}] \topicindex{callbacks+job run} \startfunctioncall function() -- no return values end \stopfunctioncall This callback replaces the code that prints \LUATEX's banner. Note that for successful use, this callback has to be set in the \LUA\ initialization script, otherwise it will be seen only after the run has already started. \stopsubsection \startsubsection[title={\cbk {stop_run}}] \topicindex{callbacks+job run} \startfunctioncall function() end \stopfunctioncall This callback replaces the code that prints \LUATEX's statistics and \quote {output written to} messages. The engine can still do housekeeping and therefore you should not rely on this hook for postprocessing the \PDF\ or log file. \stopsubsection \startsubsection[title={\cbk {intercept_tex_error}, \cbk {intercept_lua_error}}] \topicindex{callbacks+errors} \startfunctioncall function() -- no return values end \stopfunctioncall This callback is run from inside the \TEX\ error function, and the idea is to allow you to do some extra reporting on top of what \TEX\ already does (none of the normal actions are removed). You may find some of the values in the \type {status} table useful. The \TEX\ related callback gets two arguments: the current processing mode and a boolean indicating if there was a runaway. \stopsubsection \startsubsection[title={\cbk {show_error_message} and \cbk {show_warning_message}}] \topicindex{callbacks+errors} \topicindex{callbacks+warnings} \startfunctioncall function() -- no return values end \stopfunctioncall These callback replaces the code that prints the error message. The usual interaction after the message is not affected. \stopsubsection \startsubsection[title={\cbk {start_file}}] \topicindex{callbacks+files} \startfunctioncall function(category,filename) -- no return values end \stopfunctioncall This callback replaces the code that \LUATEX\ prints when a file is opened like \type {(filename} for regular files. The category is a number: \starttabulate[|c|l|] \DB value \BC meaning \NC \NR \TB \NC 1 \NC a normal data file, like a \TEX\ source \NC \NR \NC 2 \NC a font map coupling font names to resources \NC \NR \NC 3 \NC an image file (\type {png}, \type {pdf}, etc) \NC \NR \NC 4 \NC an embedded font subset \NC \NR \NC 5 \NC a fully embedded font \NC \NR \LL \stoptabulate \stopsubsection \startsubsection[title={\cbk {stop_file}}] \topicindex{callbacks+files} \startfunctioncall function(category) -- no return values end \stopfunctioncall This callback replaces the code that \LUATEX\ prints when a file is closed like the \type {)} for regular files. \stopsubsection \startsubsection[title={\cbk {wrapup_run}}] \topicindex{callbacks+wrapping up} This callback is called after the \PDF\ and log files are closed. Use it at your own risk. \stopsubsection \stopsection \startsection[title={Font-related callbacks}][library=callback] \startsubsection[title={\cbk {define_font}}] \topicindex{callbacks+fonts} \startfunctioncall function( name, size) return id end \stopfunctioncall The string \type {name} is the filename part of the font specification, as given by the user. The number \type {size} is a bit special: \startitemize[packed] \startitem If it is positive, it specifies an \quote{at size} in scaled points. \stopitem \startitem If it is negative, its absolute value represents a \quote {scaled} setting relative to the design size of the font. \stopitem \stopitemize The font can be defined with \type {font.define} which returns a font identifier that can be returned in the callback. So, contrary to \LUATEX, in \LUAMETATEX\ we only accept a number. The internal structure of the \type {font} table that is passed to \type {font.define} is explained in \in {chapter} [fonts]. That table is saved internally, so you can put extra fields in the table for your later \LUA\ code to use. In alternative, \type {retval} can be a previously defined fontid. This is useful if a previous definition can be reused instead of creating a whole new font structure. Setting this callback to \type {false} is pointless as it will prevent font loading completely but will nevertheless generate errors. \stopsubsection \startsubsection[title={\cbk {missing_character} and \cbk {process_character}}] \topicindex{callbacks+fonts} \topicindex{callbacks+characters} This callback is triggered when a character node is created and the font doesn't have the requested character. \startfunctioncall function( glyph, font, character) -- no return value end \stopfunctioncall The \type {process_character} callback is experimental and gets called when a glyph node is created and the callback field in a character is set. \startfunctioncall function( font, character) -- no return value end \stopfunctioncall \stopsubsection \stopsection \startsection[title=Reporting] \startsubsection[title={\cbk {show_whatsit}}] \topicindex{callbacks+whatsits} Because we only have a generic whatsit it is up to the macro package to provide details when tracing them. \startfunctioncall function( whatsit, indentation, tracinglevel, currentlevel, inputlevel) -- no return value end \stopfunctioncall The indentation tells how many periods are to be typeset if you want to be compatible with the rest of tracing. The tracinglevels indicates if the current level and\|/or input level are shown cf. \prm {tracinglevels}. Of course one is free to show whatever in whatever way suits the whatsit best. \stopsubsection \startsubsection[title={\cbk {get_attribute}}] \topicindex{callbacks+attributes} Because attributes are abstract pairs of indices and values the reported properties makes not much sense and are very macro package (and user) dependent. This callback permits more verbose reporting by the engine when tracing is enabled. \startfunctioncall function( index, value) return , end \stopfunctioncall \stopsubsection \startsubsection[title={\cbk {get_noad_class}}] \topicindex{callbacks+classes} We have built|-|in math classes but there can also be user defined ones. This callback can be used to report more meaningful strings instead of numbers when tracing. \startfunctioncall function( class) return end \stopfunctioncall \stopsubsection \startsubsection[title={\cbk {trace_memory}}] When the engine starts all kind of memory is pre|-|allocated> depending on the configuration more gets allocated when a category runs out of memory. The \LUAMETATEX\ engine is more dynamic than \LUATEX. If this callback is set it will get called as follows: \startfunctioncall function( category, success) -- no return value end \stopfunctioncall The boolean indicates if the allocation has been successful. One can best quit the run when this one is \type {false}, if the engine doesn't already do that. \stopsubsection \startsubsection[title={\type {hpack_quality}}] \topicindex{callbacks+packing} This callback can be used to intercept the overfull messages that can result from packing a horizontal list (as happens in the par builder). The function takes a few arguments: \startfunctioncall function( incident, detail, head, first, last) return whatever end \stopfunctioncall The incident is one of \type {overfull}, \type {underfull}, \type {loose} or \type {tight}. The detail is either the amount of overflow in case of \type {overfull}, or the badness otherwise. The head is the list that is constructed (when protrusion or expansion is enabled, this is an intermediate list). Optionally you can return a node, for instance an overfull rule indicator. That node will be appended to the list (just like \TEX's own rule would). \stopsubsection \startsubsection[title={\type {vpack_quality}}] \topicindex{callbacks+packing} This callback can be used to intercept the overfull messages that can result from packing a vertical list (as happens in the page builder). The function takes a few arguments: \startfunctioncall function( incident, detail, head, first, last) end \stopfunctioncall The incident is one of \type {overfull}, \type {underfull}, \type {loose} or \type {tight}. The detail is either the amount of overflow in case of \type {overfull}, or the badness otherwise. The head is the list that is constructed. \stopsubsection \startsubsection[title={\type {show_lua_call}}] \topicindex{callbacks+lua} This one can be used to help reporting definitions that relate to \LUA\ calls to be more meaningful when tracing. \startfunctioncall function( name, index) return end \stopfunctioncall \stopsubsection \startsubsection[title={\type {handle_overload}}] \topicindex{callbacks+overload} This is one of the few callbacks that is aimed at \CONTEXT: it relates to overload protection of macros and other variables. \startfunctioncall function( error, overload, csname, flags) -- no return values end \stopfunctioncall The overload is determined by: \starttabulate[|c|l|c|c|c|c|c|] \DB \BC \BC immutable \BC permanent \BC primitive \BC frozen \BC instance \NC \NR \TB \NC 1 \NC warning \NC \star \NC \star \NC \star \NC \NC \NC \NR \NC 2 \NC error \NC \star \NC \star \NC \star \NC \NC \NC \NR \NC 3 \NC warning \NC \star \NC \star \NC \star \NC \star \NC \NC \NR \NC 4 \NC error \NC \star \NC \star \NC \star \NC \star \NC \NC \NR \NC 5 \NC warning \NC \star \NC \star \NC \star \NC \star \NC \star \NC \NR \NC 6 \NC error \NC \star \NC \star \NC \star \NC \star \NC \star \NC \NR \LL \stoptabulate This relates to the optional prefixed that can be used when defining and setting quantities and is therefore also a bit of a playground. All macros and aliases in \CONTEXT\ are classified this way. \stopsection \stopchapter \stopcomponent