CTAN Comprehensive TeX Archive Network

Macro sup­port

This topic con­tains pack­ages with sup­port for de­vel­op­ment of macros.

Add com­mands to pack­age af­ter it's loaded.
Ex­e­cute com­mand af­ter the next page break.
Alias coun­ters.
Ar­ray data struc­tures for .
Ar­ray data struc­tures for .
Sort ar­rays (or por­tions of them).
As­so­ciate coun­ters, mak­ing them step when a mas­ter steps.
Short com­mands start­ing '@'.
Make au­thor, etc., avail­able af­ter \maketi­tle.
Code bal­anced quotes ac­cord­ing to doc­u­ment lan­guage.
Split list, in ’s mouth.
Pro­duc­ing 'blind' text for test­ing.
A boolean ex­pres­sion eval­u­a­tor and a switch com­mand.
BX bun­dle base com­po­nents.
En­close the doc­u­ment body with some pieces of code.
Dummy text in Ja­panese.
Ad­just the po­si­tion of paren­the­ses at para­graph head.
Catch an ex­ter­nal file into a macro.
Catch text de­lim­ited by doc­strip tags.
Generic han­dling of cat­e­gory codes.
Pre­serv­ing and re­call­ing stan­dard cat­codes.
Ex­tend “im­prop­erly closed en­vi­ron­ment” mes­sages.
A patch for the la­bel-check­ing code.
Change the re­set­ting of coun­ters.
Record classes used in a doc­u­ment.
Get com­mand name re­li­ably.
Store counter val­ues per chap­ter.
Col­lect text for later re-use.
Ex­pand­able it­er­a­tion on comma-sep­a­rated and file­name lists.
Com­pare two strings.
Create new key-value syn­tax.
Make use of count1 to count9.
Sup­port dy­namic coun­ters.
De­clare reg­is­ter names lo­cally.
Ex­pand pri­vate macros in a doc­u­ment.
Macros for con­struct­ing in­ter­ac­tive scripts.
Do things af­ter a group.
Ap­ply a com­mand to a list of items.
De­clare ac­tive char­ac­ter sub­sti­tu­tion, ro­bustly.
Create duck­i­fied dummy con­tent.
Lo­cal al­lo­ca­tion macros for 2015.
A new in­ter­face for en­vi­ron­ments in .
Catch ar­gu­ments de­lim­ited by end of line.
Avoid name clashes with e- com­mands.
E- sup­port pack­age.
e- tools for users and pack­age writ­ers.
e- tools for .
Ger­man trans­la­tion of doc­u­men­ta­tion of etool­box.
Hooks for stan­dard to­ken lists.
Wrap­per pack­age for ex­per­i­men­tal 3.
Im­port and ex­port val­ues of reg­is­ters.
Ex­pand­able \@testopt (and re­lated) macros.
A mis­cel­lany of sup­port macros.
One-shot changes to to­ken reg­is­ters such as \ev­ery­par.
Fetch the cur­rent class name.
FIFO and stack im­ple­men­ta­tion for pack­age writ­ers.
Hooks for in­put files.
Ad­just be­haviour of the ends of foot­notes.
Fix mis­cel­la­neous two col­umn mode fea­tures.
Fix JFM (for *p).
Set­ting and clear­ing of flags in bit fields.
Im­prove on 's foot­note han­dling.
hy­per­ref aware foot­note.sty.
Us­ing ar­ray struc­tures in .
Iter­a­tion in .
Sup­port for writ­ing mod­u­lar and cus­tomis­able code.
Gather­ing items from a list-like en­vi­ron­ment.
Clean up ti­tle ref­er­ences.
Sup­port macros for other pack­ages.
More gob­ble macros for Plain and .
Ma­nip­u­lat­ing gen­er­al­ized to­ken lists.
Make al­lo­ca­tions lo­cal.
Con­struct pack­age bun­dles.
Load patches for pack­ages.
Hun­gar­ian dummy text (Lórum ipse).
Func­tion­al­ity from IEEE­tran for use with other classes.
If-then-else com­mand for pro­cess­ing po­ten­tially empty ar­gu­ments.
Util­ity macro: peek ahead with­out ig­nor­ing spaces.
Deter­mine if the cur­rent page is odd or even.
Con­di­tional com­mands in doc­u­ments.
Ex­tra tests for \ifthenelse.
De­tect p and its deriva­tives.
Trans­late in­put files on the fly.
Cal­cu­late in­verse file paths.
Gen­er­ate sen­tences in Kant's style.
A ‘lip­sum’ pack­age for the Kur­dish lan­guage.
3 back­end drivers.
A test­ing and build­ing sys­tem for .
Ex­per­i­men­tal 3 con­cepts.
op­tion pro­cess­ing us­ing 3 keys.
High-level 3 con­cepts.
Reg­u­lar ex­pres­sion fa­cil­i­ties for .
Check the ex­is­tence of la­bels, and fork ac­cord­ingly.
Lists in 's mouth.
Zero-width boxes for an­no­ta­tions, etc.
Mis­cel­la­neous helper pack­ages.
Easy ac­cess to the Lorem Ip­sum dummy text.
A sim­ple pack­age for in­clud­ing sup­port files.
Pro­cess lists to do repet­i­tive ac­tions.
Var­i­ous macros for keep­ing things lo­cal.
Macros for lo­cal­iz­ing reg­is­ter al­lo­ca­tions.
e- show­box fa­cil­i­ties for ex­plo­ration pur­poses.
Gen­eral loop­ing macros for use with .
Pro­vide a graph datas­truc­ture for ex­per­i­men­tal 3.
Some ker­nel com­mands for gen­eral use.
A col­lec­tion of API macros.
util­ity macros.
Swap the def­i­ni­tions of two macros.
The new \makecom­mand com­mand al­ways (re)de­fines a com­mand.
Mak­ing a macro ro­bust.
Make an ex­ist­ing com­mand ro­bust.
Mis­cel­la­neous list-re­lated com­mands.
Mis­cel­la­neous tools by Mark Wood­ing.
Con­tain­ers for data in .
Up­per­case the first let­ter of a word.
A set of use­ful macro tools.
An ab­stract of fa­cil­i­ties for use with Plain .
defin­ing, ex­pan­sion, and de­bug­ging com­mands.
Quickly de­fine sev­eral sim­i­lar macros.
A loop fa­cil­ity for Generic .
Mul­ti­ple en­vi­ron­ments us­ing a "key=value" syn­tax.
Vari­a­tions on the prim­i­tive com­mand \ex­pandafter.
Write in­for­ma­tion to files.
Gen­er­ate new com­mand def­i­ni­tions.
Pro­cess­ing an en­vi­ron­ment’s body.
Gen­er­al­i­sa­tions of the page ad­vance com­mands.
Re­solve macro name con­flict be­tween pack­ages.
Tool to pre­vent para­graph in­den­ta­tion af­ter en­vi­ron­ments/macros.
Avoid the need for pro­tec­tion.
Flex­i­ble and con­fig­urable page range type­set­ting.
Ap­ply a macro to each line of an en­vi­ron­ment.
Patch loaded pack­ages, etc.
Change the def­i­ni­tion of an ex­ist­ing com­mand.
Im­ple­ments pdf's es­cape fea­tures us­ing or e-.
Lua sup­port for pdf util­ity func­tions.
Make a counter re­set at ev­ery page bound­ary.
A patched ver­sion of PiCTeX us­ing fewer reg­is­ters.
Di­mens for pic­ture macros.
A min­i­mal method for mak­ing generic pack­ages.
'Lorem ip­sum' for Plain de­vel­op­ers.
Pro­cess key-value pairs.
Load prop­er­ties from a file.
De­fine pro­tected com­mands.
A ‘lip­sum’ for Per­sian.
An easy way to type­set any part of The Holy Qu­ran.
Ger­man trans­la­tions to the quran pack­age.
Urdu trans­la­tions to the quran pack­age.
Ran­domise to­ken strings.
Re­cy­cle top mat­ter.
Con­di­tional macro, etc., def­i­ni­tions.
High level patch­ing of com­mands.
Set the font size rel­a­tive to the cur­rent font size.
Re­move from counter-re­set lists.
Re­move coun­ters from re­set list.
Re­peat ex­e­cu­tion of macros.
De­clare ro­bust com­mand, with \new­com­mand checks.
In­crease the num­ber of avail­able out­put streams in .
Rede­fine sym­bols where names con­flict.
Trans­fig patch sup­port­ing shapepar.
Show la­bel, ref, cite and bib keys.
Show la­bel com­mands in the mar­gin.
Create com­mands us­ing pa­ram­e­ters and key­val in par­al­lel.
Save load­ing all of an­other pack­age.
Patch ker­nel spac­ing macros.
Tools to de­fine and use stacks.
Highly cus­tomised stack­ing of ob­jects, in­sets, base­line changes, etc.
Pro­vide sec­tion­ing in­for­ma­tion for pack­age writ­ers.
Stor­ing in­for­ma­tion for reuse.
Store the name of a de­fined com­mand in a con­tainer.
Deal with sub­strings in strings.
De­fine com­mands with suf­fixes.
Tab­bing with ac­cented let­ters.
“Tab­bing” front-end to stack­engine.
Macros to write for­mat-in­de­pen­dent pack­ages.
Case con­ver­sion ig­nor­ing math­e­mat­ics, etc.
A sin­gle TikZ node for the whole page.
Tool macros.
Find the last value of a counter.
Make sen­si­ble use of trac­ing in .
Trim spaces around an ar­gu­ment or within a macro.
Def­i­ni­tions with two op­tional ar­gu­ments.
Sup­press \outer flags in Plain .
Watch­ing di­gest to­kens.
Mis­cel­la­neous macros by Peter Wil­liams.
Ephe­meral macro use.
De­fine com­mands with op­tional ar­gu­ments.
De­fine com­mands with many op­tional ar­gu­ments.
As­so­ci­ated coun­ters step­ping si­mul­ta­ne­ously.
Track the num­ber of sub­sec­tions etc. that oc­cur in a spec­i­fied track­level.
A reim­ple­men­ta­tion of the for-loop macro.
Con­trol text feed­ing onto the page.
Ex­tended con­di­tional com­mands.
Pro­vi­sion for ex­pand­able macros in pack­age op­tions.
Xkey­val viewer.
Ex­tend­ing etool­box patch­ing com­mands.
De­fine com­mands that peek ahead in the in­put stream.
Pro­cess trail­ing punc­tu­a­tion which may be re­dun­dant.
De­fine com­mands that ap­pear not to eat spaces.
Chi­nese dummy text.
Guest Book Sitemap Contact Contact Author