{
    "content": [
        {
            "type": "text",
            "text": "# roff(7) (man)\n\n**Summary:** roff - concepts and history of roff typesetting\n\n## See Also\n\n- groff(1)\n- troff(1)\n\n## Section Outline\n\n- **NAME** (2 lines)\n- **DESCRIPTION** (26 lines)\n- **HISTORY** (4 lines) — 4 subsections\n  - The Predecessor RUNOFF (26 lines)\n  - The Classical nroff/troff System (39 lines)\n  - Availability (13 lines)\n  - Free Heirloom roff (9 lines)\n- **USING ROFF** (11 lines) — 4 subsections\n  - The roff Pipe (20 lines)\n  - Preprocessors (25 lines)\n  - Formatter Programs (17 lines)\n  - Devices and Postprocessors (22 lines)\n- **ROFF PROGRAMMING** (7 lines) — 2 subsections\n  - Macro Packages (14 lines)\n  - The roff Formatting Language (20 lines)\n- **FILE NAME EXTENSIONS** (20 lines)\n- **EDITING ROFF** (31 lines) — 2 subsections\n  - Editing with Emacs (28 lines)\n  - Editing with Vim (13 lines)\n- **AUTHORS** (2 lines)\n- **SEE ALSO** (3 lines) — 3 subsections\n  - Internet sites (38 lines)\n  - Historical roff Documentation (30 lines)\n  - Manual Pages (11 lines)\n\n## Full Content\n\n### NAME\n\nroff - concepts and history of roff typesetting\n\n### DESCRIPTION\n\nroff is the general name for a set of text formatting programs, known under names like troff,\nnroff, ditroff, groff, etc.  A roff system consists of an extensible text formatting language\nand a set of programs for printing and converting to other text formats.  Unix-like operating\nsystems distribute a roff system as a core package.\n\nThe most common roff system today is the free software  implementation  GNU  roff,  groff(1).\ngroff implements the look-and-feel and functionality of its ancestors, with many extensions.\n\nThe  ancestry  of  roff  is described in section “History” below.  In this document, the term\nroff always refers to the general class of roff programs, not to the roff command provided in\nearly Unix systems.\n\nIn spite of its age, roff is in wide use today, for example, the manual pages on Unix systems\n(man pages), many software books, system documentation, standards,  and  corporate  documents\nare  written in roff.  The roff output for text devices is still unmatched, and its graphical\noutput has the same quality as other free type-setting programs and is better  than  some  of\nthe commercial systems.\n\nroff  is  used to format Unix manual pages, (or man pages), the standard documentation system\non many Unix-derived operating systems.\n\nThis document describes the history of the development of the roff system; some usage aspects\ncommon  to  all  roff  versions, details on the roff pipeline, which is usually hidden behind\nfront-ends like groff(1); a general overview of the formatting language; some tips for  edit‐\ning roff files; and many pointers to further readings.\n\n### HISTORY\n\nDocument  formatting  by  computer  dates back to the 1960s.  The roff system itself is inti‐\nmately connected to the Unix operating system, but its roots go back to the earlier operating\nsystems CTSS and Multics.\n\n#### The Predecessor RUNOFF\n\nroff's  ancestor  RUNOFF  was written in the MAD language by Jerry Saltzer for the Compatible\nTime Sharing System (CTSS), a project of the Massachusetts Institute of Technology (MIT),  in\n1963 and 1964—note that CTSS commands were all uppercase.\n\nIn 1965, MIT's Project MAC teamed with Bell Telephone Laboratories (BTL) and General Electric\nto begin the Multics system ⟨http://www.multicians.org⟩.  A command called runoff was written\nfor Multics in the late 60s in the BCPL language, by Bob Morris, Doug McIlroy, and other mem‐\nbers of the Multics team.\n\nLike its CTSS ancestor, Multics runoff formatted an input file consisting of text and command\nlines;  commands began with a period and were two letters.  Output from these commands was to\nterminal devices such as IBM Selectric terminals.  Multics  runoff  had  additional  features\nadded,  such  as the ability to do two-pass formatting; it became the main format for Multics\ndocumentation and text processing.\n\nBCPL and runoff were ported to the GCOS system at Bell Labs when BTL left the development  of\nMultics.\n\nThere is a free archive about historical RUNOFF documents.  You can get it anonymously by the\nshell command\n$git clone https://github.com/bwarken/RUNOFFhistorical.git\n\nAs well, there is a new project for writing a program that can read RUNOFF  files  ,  but  it\ndoes not yet work so far.  You can get an early version anonymously by the shell command\n$git clone https://github.com/bwarken/runoff.git\n\n#### The Classical nroff/troff System\n\nAt  BTL, there was a need to drive the Graphic Systems CAT typesetter, a graphical output de‐\nvice from a PDP-11 computer running Unix.  As runoff was too limited for  this  task  it  was\nfurther  developed  into a more powerful text formatting system by Joseph F. Ossanna, who al‐\nready programmed several runoff ports.\n\nThe name runoff was shortened to roff.  The greatly enlarged language  of  Ossanna's  version\nalready  included  all elements of a full roff system.  All modern roff systems try to imple‐\nment compatibility to this system.  So Joe Ossanna can be called the father of all roff  sys‐\ntems.\n\nThis first roff system had three formatter programs.\n\ntroff  (typesetter  roff) generated a graphical output for the CAT typesetter as its only de‐\nvice.\n\nnroff  produced text output suitable for terminals and line printers.\n\nroff   was the reimplementation of the former runoff program with its limited features;  this\nprogram  was  abandoned in later versions.  Today, the name roff is used to refer to a\ntroff/nroff system as a whole.\n\nOssanna's first version was written in the PDP-11 assembly language  and  released  in  1973.\nBrian  Kernighan  joined  the roff development by rewriting it in the C programming language.\nThe C version was released in 1975.\n\nThe syntax of the formatting language of the nroff/troff programs was documented in  the  fa‐\nmous  Troff  User's  Manual [CSTR #54], first published in 1976, with further revisions up to\n1992 by Brian Kernighan.  This document is the specification of  the  classical  troff.   All\nlater roff systems tried to establish compatibility with this specification.\n\nAfter  Ossanna's  death in 1977, Kernighan went on with developing troff.  In the late 1970s,\nKernighan equipped troff with a general interface to support more devices,  the  intermediate\noutput  format,  and the postprocessor system.  This completed the structure of a roff system\nas it is still in use today; see section “Using Roff” below.  In 1979, these  novelties  were\ndescribed  in  the  paper  [CSTR  #97].  This new troff version is the basis for all existing\nnewer troff systems, including groff.  On some systems, this device independent troff  got  a\nbinary  of  its  own,  called ditroff(7).  All modern troff programs already provide the full\nditroff capabilities automatically.\n\n#### Availability\n\nThe source code of both the ancient Unix  and  classical  troff  weren't  available  for  two\ndecades.   Nowadays,  it  is accessible again (on-line) for non-commercial use; see SEE ALSO,\nbelow.\n\ngroff —— free GNU roff\nThe most important free roff project was  the  GNU  implementation  of  troff,  written  from\nscratch  by  James  Clark and put under the GNU Public License ⟨http://www.gnu.org/copyleft⟩.\nIt was called groff (GNU roff).  See groff(1) for an overview.\n\nThe groff system is still actively developed.  It is compatible to the classical  troff,  but\nmany  extensions were added.  It is the first roff system that is available on almost all op‐\nerating systems — and it is free.  This makes groff the de facto roff standard today.\n\n#### Free Heirloom roff\n\nAn  alternative  is  Gunnar  Ritter's  Heirloom  roff  project  ⟨https://github.com/n-t-roff/\nheirloom-doctools⟩  project, started in 2005, which provides enhanced versions of the various\nroff tools found in the OpenSolaris and Plan 9 operating systems, now  available  under  free\nlicenses.  You can get this package with the shell command:\n$ git clone https://github.com/n-t-roff/heirloom-doctools\n\nMoreover,  one  finds  there  the  Original  Documenter's  Workbench  Release  3.3  ⟨https://\ngithub.com/n-t-roff/DWB3.3⟩.\n\n### USING ROFF\n\nMost people won't even notice that they are actually using roff.  When you read a system man‐\nual  page (man page) roff is working in the background.  But using roff explicitly isn't dif‐\nficult either.\n\nSome roff implementations provide wrapper programs that make it easy to use the  roff  system\non  the  shell command line.  For example, the GNU roff implementation groff(1) provides com‐\nmand-line options to avoid the long command pipes of classical troff; a program grog(1) tries\nto  guess  from the document which arguments should be used for a run of groff; people who do\nnot like specifying command-line options should try the groffer(1)  program  for  graphically\ndisplaying groff files and man pages.\n\n#### The roff Pipe\n\nEach  roff  system  consists  of  preprocessors, roff formatter programs, and a set of device\npostprocessors.  This concept makes heavy use of the piping mechanism, that is, a  series  of\nprograms  is  called  one  after  the other, where the output of each program in the queue is\ntaken as the input for the next program.\n\ncat file | ... | preproc | ... | troff options | postproc\n\nThe preprocessors generate roff code that is fed into a roff formatter (e.g. troff), which in\nturn generates intermediate output that is fed into a device postprocessor program for print‐\ning or final output.\n\nAll of these parts use programming languages of their own; each language is totally unrelated\nto  the  other  parts.  Moreover, roff macro packages that were tailored for special purposes\ncan be included.\n\nMost roff documents use the macros of some package, intermixed with code for one or more pre‐\nprocessors,  spiced  with  some elements from the plain roff language.  The full power of the\nroff formatting language is seldom needed by users; only programmers of macro  packages  need\nto know about the gory details.\n\n#### Preprocessors\n\nA  roff  preprocessor is any program that generates output that syntactically obeys the rules\nof the roff formatting language.  Each preprocessor defines a language of  its  own  that  is\ntranslated  into roff code when run through the preprocessor program.  Parts written in these\nlanguages may be included within a roff document; they are identified  by  special  roff  re‐\nquests  or  macros.   Each document that is enhanced by preprocessor code must be run through\nall corresponding preprocessors before it is fed into the actual roff formatter program,  for\nthe  formatter  just ignores all alien code.  The preprocessor programs extract and transform\nonly the document parts that are determined for them.\n\nThere are a lot of free and commercial roff preprocessors.  Some of them aren't available  on\neach  system,  but  there  is a small set of preprocessors that are considered as an integral\npart of each roff system.  The classical preprocessors are\n\ntbl      for tables.\neqn      for mathematical formulae.\npic      for drawing diagrams.\nrefer    for bibliographic references.\nsoelim   for including macro files from standard locations.\nchem     for drawing chemical formulæ.\n\nOther known preprocessors that are not available on all systems include\n\ngrap   for constructing graphical elements.\ngrn    for including gremlin(1) pictures.\n\n#### Formatter Programs\n\nA roff formatter is a program that parses documents written in the roff  formatting  language\nor uses some of the roff macro packages.  It generates intermediate output, which is intended\nto be fed into a single device postprocessor that must be specified by a command-line  option\nto  the formatter program.  The documents must have been run through all necessary preproces‐\nsors before.\n\nThe output produced by a roff formatter is represented in yet another language, the  interme‐\ndiate  output  format  or troff output.  This language was first specified in [CSTR #97]; its\nGNU extension is documented in groffout(5).  The intermediate output language is a  kind  of\nassembly  language compared to the high-level roff language.  The generated intermediate out‐\nput is optimized for a special device, but the language is the same for every device.\n\nThe roff formatter is the heart of the roff system.  The traditional roff had two formatters,\nnroff for text devices and troff for graphical devices.\n\nOften, the name troff is used as a general term to refer to both formatters.\n\n#### Devices and Postprocessors\n\nDevices are hardware interfaces like printers, text or graphical terminals, etc., or software\ninterfaces such as a conversion into a different text or graphical format.\n\nA roff postprocessor is a program that transforms troff output into a  form  suitable  for  a\nspecial device.  The roff postprocessors are like device drivers for the output target.\n\nFor  each  device there is a postprocessor program that fits the device optimally.  The post‐\nprocessor parses the generated intermediate output and generates device-specific code that is\nsent directly to the device.\n\nThe  names  of  the devices and the postprocessor programs are not fixed because they greatly\ndepend on the software and hardware abilities of the actual computer.  For example, the clas‐\nsical  devices  mentioned  in [CSTR #54] have greatly changed since the classical times.  The\nold hardware doesn't exist any longer and the old graphical conversions were quite  imprecise\nwhen compared to their modern counterparts.\n\nFor  example, the PostScript device post in classical troff had a resolution of 720 units per\ninch, while groff's ps device has 72000, a refinement of factor 100.\n\nToday the operating systems provide device drivers for  most  printer-like  hardware,  so  it\nisn't necessary to write a special hardware postprocessor for each printer.\n\n### ROFF PROGRAMMING\n\nDocuments  using  roff are normal text files decorated by roff formatting elements.  The roff\nformatting language is quite powerful; it is almost a full programming language and  provides\nelements  to  enlarge the language.  With these, it became possible to develop macro packages\nthat are tailored for special applications.  Such macro packages are much handier than  plain\nroff.  So most people will choose a macro package without worrying about the internals of the\nroff language.\n\n#### Macro Packages\n\nMacro packages are collections of macros that are suitable to format a special kind of  docu‐\nments in a convenient way.  This greatly eases the usage of roff.  The macro definitions of a\npackage are kept in a file called name.tmac (classically  tmac.name).   All  tmac  files  are\nstored  in one or more directories at standardized positions.  Details on the naming of macro\npackages and their placement is found in grofftmac(5).\n\nA macro package that is to be used in a document can be announced to  the  formatter  by  the\ncommand-line option -m, see troff(1), or it can be specified within a document using the file\ninclusion requests of the roff language, see groff(7).\n\nFamous classical macro packages are man for traditional man pages, mdoc for BSD-style  manual\npages;  the  macro sets for books, articles, and letters are me (probably from the first name\nof its creator Eric Allman), ms (from Manuscript Macros), and mm (from Memorandum Macros).\n\n#### The roff Formatting Language\n\nThe classical roff formatting language is documented in the Troff User's Manual  [CSTR  #54].\nThe  roff  language  is a full programming language providing requests, definition of macros,\nescape sequences, string variables, number or size registers, and flow controls.\n\nRequests are the predefined basic formatting commands similar to the commands  at  the  shell\nprompt.  The user can define request-like elements using predefined roff elements.  These are\nthen called macros.  A document writer will not note any difference in usage for requests  or\nmacros; both are written on a line on their own starting with a dot.\n\nEscape  sequences are roff elements starting with a backslash ‘\\’.  They can be inserted any‐\nwhere, also in the midst of text in a line.  They are used to implement various features, in‐\ncluding the insertion of non-ASCII characters with \\(, font changes with \\f, in-line comments\nwith \\\", the escaping of special control characters like \\\\, and many other features.\n\nStrings are variables that can store a string.  A string is stored by the .ds  request.   The\nstored string can be retrieved later by the \\* escape sequence.\n\nRegisters  store numbers and sizes.  A register can be set with the request .nr and its value\ncan be retrieved by the escape sequence \\n.\n\n### FILE NAME EXTENSIONS\n\nManual pages (man pages) take the section number as a file name extension, e.g., the filename\nfor this document is roff.7, i.e., it is kept in section 7 of the man pages.\n\nThe  classical macro packages take the package name as an extension, e.g. file.me for a docu‐\nment using the me macro package, file.mm for mm, file.ms for ms, file.pic for pic files, etc.\n\nBut there is no general naming scheme for roff documents, though file.tr for  troff  file  is\nseen  now  and  then.  Maybe there should be a standardization for the filename extensions of\nroff files.\n\nFile name extensions can be very handy in conjunction with the less(1)  pager.   It  provides\nthe possibility to feed all input into a command-line pipe that is specified in the shell en‐\nvironment variable LESSOPEN.  This process is not well documented, so here an example:\n\nLESSOPEN='|lesspipe %s'\n\nwhere lesspipe is either a system supplied command or a shell script of your own.\n\nMore details for file name extensions can be found at grofffilenames(5).\n\n### EDITING ROFF\n\nAll roff formatters provide automated line breaks and horizontal and  vertical  spacing.   In\norder to not disturb this, the following tips can be helpful.\n\n•      Never include empty or blank lines in a roff document.  Instead, use the empty request\n(a line consisting of a dot only) or a line comment .\\\" if a  structuring  element  is\nneeded.\n\n•      Never  start a line with whitespace because this can lead to unexpected behavior.  In‐\ndented paragraphs can be constructed in a controlled way by roff requests.\n\n•      Start each sentence on a line of its own, for the spacing after a dot is handled  dif‐\nferently depending on whether it terminates an abbreviation or a sentence.  To distin‐\nguish both cases, do a line break after each sentence.\n\n•      To additionally use the auto-fill mode in Emacs, it is best to insert  an  empty  roff\nrequest (a line consisting of a dot only) after each sentence.\n\nThe following example shows judicious line breaking in a roff input file.\n\nThis is an example of a\n.I roff\ndocument that you can type into your text editor.\n.\nThis is the next sentence in the same paragraph.\n.\nThis is a longer sentence stretching over several input lines;\nabbreviations like cf. are easily identified because the dot is\nnot followed by a line break.\n.\nIn the output, this sentence continues the same paragraph.\n\n#### Editing with Emacs\n\nThe best program for editing a roff document is Emacs (or XEmacs); see emacs(1).  It provides\nan nroff mode that is suitable for all kinds of roff dialects.  This mode can be activated by\nthe following methods.\n\nWhen editing a file within Emacs the mode can be changed by typing ‘M-x nroff-mode’, where M-\nx means to hold down the Meta key (or Alt) and press the x key at the same time.\n\nBut it is also possible to have the mode automatically selected when the file is loaded  into\nthe editor.\n\n•      The  most general method is to include the following 3 comment lines at the end of the\nfile.\n\n.\\\" Local Variables:\n.\\\" mode: nroff\n.\\\" End:\n\n•      There is a set of file name extensions, e.g. the man pages that trigger the  automatic\nactivation of the nroff mode.\n\n•      Theoretically, it is possible to write the sequence\n\n.\\\" -*- nroff -*-\n\nas  the  first  line of a file to have it started in nroff mode when loaded.  Unfortu‐\nnately, some applications such as the man program are confused by  this;  so  this  is\ndeprecated.\n\n#### Editing with Vim\n\nBesides Emacs, some other editors provide nroff style files too, e.g. vim(1), an extension of\nthe vi(1) program.  Vim's highlighting can be made to recognize roff  files  by  setting  the\nfiletype  option in a Vim modeline.  For this feature to work, your copy of vim must be built\nwith support for, and configured to enable, several features;  consult  the  editor's  online\nhelp  topics  “auto-setting”, “filetype”, and “syntax”.  Then put the following at the end of\nyour roff files, after any Emacs configuration:\n\n.\\\" vim: set filetype=groff:\n\nReplace “groff” in the above with “nroff” if you want highlighing  that  does  not  recognize\nmany  of  the GNU extensions to roff, such as request, register, and string names longer than\ntwo characters.\n\n### AUTHORS\n\nThis document was written by Bernd Warken ⟨groff-bernd.warken-72@web.de⟩.\n\n### SEE ALSO\n\nThere is a lot of documentation on roff.  The original papers on classical  troff  are  still\navailable, and all aspects of groff are documented in great detail.\n\n#### Internet sites\n\nHistory of Unix Manpages\nThe  history page ⟨http://manpages.bsd.lv/history.html⟩ of the mdocml project provides\nan overview of roff development up to date, with links to original  documentation  and\ncomments of the original authors.\n\ntroff.org\nThe  historical troff site ⟨http://www.troff.org⟩ provides an overview and pointers to\nthe historical aspects of roff.\n\nMultics\nThe Multics site ⟨http://www.multicians.org⟩ contains a lot of information on the  MIT\nprojects,  CTSS,  Multics, early Unix, including runoff; especially useful are a glos‐\nsary and the many links to ancient documents.\n\nUnix Archive\nThe Ancient Unixes Archive ⟨http://www.tuhs.org/Archive/⟩ provides the source code and\nsome  binaries of the ancient Unixes (including the source code of troff and its docu‐\nmentation) that were made public by Caldera since 2001, e.g. of the famous  Unix  ver‐\nsion 7 for PDP-11 at the Unix V7 site ⟨http://www.tuhs.org/Archive/PDP-11/Trees/V7⟩.\n\nDevelopers at AT&T Bell Labs\nBell  Labs  Computing  and  Mathematical Sciences Research ⟨http://www.bell-labs.com/⟩\nprovides a search facility for tracking information on the early developers.\n\nPlan 9 The Plan 9 operating system ⟨http://plan9.bell-labs.com⟩ by AT&T Bell Labs.\n\nrunoff Jerry  Saltzer's  home  page   ⟨http://web.mit.edu/Saltzer/www/publications/pubs.html⟩\nstores some documents using the ancient RUNOFF formatting language.\n\nCSTR Papers\nThe    Bell    Labs   (now   Alcatel)   CSTR   site   ⟨https://www.alcatel-lucent.com/\nbell-labs-journals⟩ stores the original troff manuals  (CSTR  #54,  #97,  #114,  #116,\n#122) and famous historical documents on programming.\n\nGNU roff\nThe  groff  web site ⟨http://www.gnu.org/software/groff⟩ provides the free roff imple‐\nmentation groff, the actual standard roff.\n\n#### Historical roff Documentation\n\nMany classical troff documents are still available on-line.  The  two  main  manuals  of  the\ntroff language are\n\n[CSTR #54]\nJ.  F.  Ossanna,  Nroff/Troff  User's Manual ⟨http://www.troff.org/54.pdf⟩; Bell Labs,\n1976; revised by Brian Kernighan, 1992.\n\n[CSTR #97]\nBrian Kernighan, A Typesetter-independent  TROFF  ⟨http://cm.bell-labs.com/cm/cs/cstr/\n97.ps.gz⟩, Bell Labs, 1981, revised March 1982.\n\nThe “little language” roff papers are\n\n[CSTR #114]\nJon  L.  Bentley  and  Brian  W.  Kernighan,  GRAP – A Language for Typesetting Graphs\n⟨http://cm.bell-labs.com/cm/cs/cstr/114.ps.gz⟩; Bell Labs, August 1984.\n\n[CSTR #116]\nBrian  W.  Kernighan,  PIC  –   A   Graphics   Language   for   Typesetting   ⟨http://\ncm.bell-labs.com/cm/cs/cstr/116.ps.gz⟩; Bell Labs, December 1984.\n\n[CSTR #122]\nJ.  L.  Bentley, L. W. Jelinski, and B. W. Kernighan, CHEM – A Program for Typesetting\nChemical Structure Diagrams, Computers and  Chemistry  ⟨http://cm.bell-labs.com/cm/cs/\ncstr/122.ps.gz⟩; Bell Labs, April 1986.\n\nYou  can  get  an  archive  with most classical roff documentation as reasonable PDF files at\ngithub using the shell command\n$ git clone https://github.com/bwarken/roffclassical.git\n\n#### Manual Pages\n\nDue to its complex structure, a full roff system has many man pages, each describing a single\naspect of roff.  Unfortunately, there is no general naming scheme for the documentation among\nthe different roff implementations.\n\nIn groff, the man page groff(1) contains a survey of all documentation available in groff.\n\nOn other systems, you are on your own, but troff(1) might be a good starting point.\n\n\n\ngroff 1.22.4                                23 March 2022                                    ROFF(7)\n\n"
        }
    ],
    "structuredContent": {
        "command": "roff",
        "section": "7",
        "mode": "man",
        "summary": "roff - concepts and history of roff typesetting",
        "synopsis": null,
        "flags": [],
        "examples": [],
        "see_also": [
            {
                "name": "groff",
                "section": "1",
                "url": "https://www.chedong.com/phpMan.php/man/groff/1/json"
            },
            {
                "name": "troff",
                "section": "1",
                "url": "https://www.chedong.com/phpMan.php/man/troff/1/json"
            }
        ],
        "section_outline": [
            {
                "name": "NAME",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "DESCRIPTION",
                "lines": 26,
                "subsections": []
            },
            {
                "name": "HISTORY",
                "lines": 4,
                "subsections": [
                    {
                        "name": "The Predecessor RUNOFF",
                        "lines": 26
                    },
                    {
                        "name": "The Classical nroff/troff System",
                        "lines": 39
                    },
                    {
                        "name": "Availability",
                        "lines": 13
                    },
                    {
                        "name": "Free Heirloom roff",
                        "lines": 9
                    }
                ]
            },
            {
                "name": "USING ROFF",
                "lines": 11,
                "subsections": [
                    {
                        "name": "The roff Pipe",
                        "lines": 20
                    },
                    {
                        "name": "Preprocessors",
                        "lines": 25
                    },
                    {
                        "name": "Formatter Programs",
                        "lines": 17
                    },
                    {
                        "name": "Devices and Postprocessors",
                        "lines": 22
                    }
                ]
            },
            {
                "name": "ROFF PROGRAMMING",
                "lines": 7,
                "subsections": [
                    {
                        "name": "Macro Packages",
                        "lines": 14
                    },
                    {
                        "name": "The roff Formatting Language",
                        "lines": 20
                    }
                ]
            },
            {
                "name": "FILE NAME EXTENSIONS",
                "lines": 20,
                "subsections": []
            },
            {
                "name": "EDITING ROFF",
                "lines": 31,
                "subsections": [
                    {
                        "name": "Editing with Emacs",
                        "lines": 28
                    },
                    {
                        "name": "Editing with Vim",
                        "lines": 13
                    }
                ]
            },
            {
                "name": "AUTHORS",
                "lines": 2,
                "subsections": []
            },
            {
                "name": "SEE ALSO",
                "lines": 3,
                "subsections": [
                    {
                        "name": "Internet sites",
                        "lines": 38
                    },
                    {
                        "name": "Historical roff Documentation",
                        "lines": 30
                    },
                    {
                        "name": "Manual Pages",
                        "lines": 11
                    }
                ]
            }
        ]
    }
}