Community hub
0 subscribers7 pages, 0 posts
Recent from talks
All channels
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Welcome to the community hub built to collect knowledge and have discussions related to Roff (software).
Nothing was collected or created yet.
Roff (software)
View on Wikipediafrom Wikipedia
 | This article includes a list of general references, but it lacks sufficient corresponding inline citations. (February 2013) |
| roff | |
|---|---|
| Original authors | Joe Ossanna, Ken Thompson |
| Developer | AT&T Bell Laboratories |
| Initial release | November 3, 1971 |
| Operating system | Unix and Unix-like |
| Type | Command |
roff is a typesetting markup language. As the first Unix text-formatting computer program, it is a predecessor of the nroff and troff document processing systems.[1]: 290
Roff was a Unix version of the runoff text-formatting program from Multics, which was a descendant of RUNOFF for CTSS (the first computerized text-formatting application). [1]
History
[edit]CTSS
[edit]roff is a descendant of the RUNOFF program by Jerry Saltzer, which ran on CTSS. Douglas McIlroy and Robert Morris wrote runoff for Multics in BCPL based on Saltzer's program written in MAD assembler. Their program in turn was "transliterated" by Ken Thompson into PDP-7 assembler language for his early Unix operating system, circa 1970.[2][3]
When the first PDP-11 was acquired for Unix in late 1970, the justification cited to management for the funding required was that it was to be used as a word processing system, and so roff was quickly transliterated again, into PDP-11 assembly, in 1971.
roff printed the man pages for Versions 1 to 3 of Unix, and when the Bell Labs patent department began using it, it became the first Unix application with an outside client.[4] Dennis Ritchie noted that the ability to rapidly modify roff (because it was locally written software) to provide special features was an important factor in leading to the adoption of Unix by the patent department to fill its word processing needs. This in turn gave Unix enough credibility inside Bell Labs to secure the funding to purchase one of the first PDP-11/45s produced.[citation needed]
See also
[edit]References
[edit]- ^ a b Shotts, William E. (2019). The Linux command line: a complete introduction (2 ed.). San Francisco: No Starch Press. ISBN 978-1-59327-953-0.
- ^ Ritchie, Dennis M. (1984). "The Evolution of the Unix Time-sharing System". AT&T Bell Laboratories Technical Journal. 63 (6 Part 2): 1577–93. doi:10.1002/j.1538-7305.1984.tb00054.x. Archived from the original on 6 May 2010. As PDF
- ^ Van Vleck, Tom, ed. (20 April 2024). "Multics Features". Retrieved 6 May 2024.
- ^ McIlroy, M. D. (1987). A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 (PDF) (Technical report). CSTR. Bell Labs. 139.
Sources
[edit]- D. M. Ritchie, The Evolution of the UNIX Time-sharing System (AT&T Bell Laboratories Technical Journal, Vol. 63, No. 8, October 1984)
External links
[edit] | This digital typography article is a stub. You can help Wikipedia by adding missing information. |
Roff (software)
View on Grokipediafrom Grokipedia
.sp for spacing), escape sequences (e.g., \f for font changes), and registers for variables, enabling complex document production with minimal overhead.[1] It remains foundational for Unix manual pages (man pages) and technical documentation, powering tools that format content for terminals, printers, and modern digital outputs.[3]
In contemporary use, the GNU implementation, groff (GNU roff), serves as the de facto standard, extending the original AT&T troff with enhanced compatibility, additional macros, and support for outputs including HTML, DVI, and PDF while preserving backward compatibility.[3] First released in 1990 by James Clark, groff is actively maintained under the GNU General Public License, with its latest stable version (1.23.0) issued in July 2023, ensuring roff's relevance in software engineering and open-source documentation workflows.[3]
Introduction
Definition and Purpose
Roff is a family of document formatting systems originating in the 1960s that function as extensible markup languages, blending plain text content with embedded control instructions to direct typesetting operations.[1][4] These systems process input documents to generate formatted output suitable for various devices, such as line printers, typesetters, or modern digital formats.[5] The core purpose of roff is to automate the formatting of text documents, performing essential tasks including line filling, hyphenation, justification, and pagination to produce professional-looking output without manual intervention.[6][1] This enables efficient creation of structured documents like manuals, reports, and technical papers, where content and layout instructions are interleaved for precise control over appearance.[7] As the first text-formatting program developed for Unix, roff holds historical significance and serves as an early predecessor to modern programmable markup tools like LaTeX by introducing a framework for embedding formatting logic within text.[8][5] Its design emphasized extensibility through a programming-like language, influencing the evolution of document processing in computing.[1] At its basic architecture, a roff system operates via a pipeline that typically involves optional preprocessors to handle specialized input (such as equations or tables), a central roff formatter to interpret the markup and generate intermediate output, and postprocessors to adapt the results for specific output devices like terminals or printers.[1][9] This modular approach allows flexibility in processing diverse document types while maintaining compatibility across implementations.[10]Relation to Other Systems
Roff traces its origins to the RUNOFF program developed by J.H. Saltzer at MIT in the mid-1960s for the Compatible Time-Sharing System (CTSS), which provided basic text formatting capabilities through simple markup commands.[11] This was adapted for the Multics operating system as runoff, incorporating enhancements for more structured document preparation, and subsequently ported to early Unix as roff to support documentation needs.[12][1] From its Unix implementation, roff evolved into the n/troff family, with nroff introduced in 1973 for formatting output suitable for line printers and terminals, emphasizing simplicity and portability.[1] Troff, developed concurrently by Joseph Ossanna, extended roff for high-quality output on phototypesetters, enabling precise control over typography and layout.[5] Modern derivatives include GNU roff (groff), released in 1990, which builds on these foundations with improved compatibility, additional features, and support for contemporary output devices while maintaining backward compatibility with nroff and troff.[5] Roff played a foundational role in Unix documentation, serving as the primary tool for generating the system's manual pages (man pages) from the earliest editions, such as the 1971 Unix Programmer's Manual.[13] Its macro packages, like those for man pages, influenced standardized formatting for software references and research documents, embedding roff deeply into Unix culture and subsequent BSD and Linux distributions.[1] In contrast to fixed-format systems prevalent in early word processors, which relied on predefined templates with limited customization, roff introduced programmability through an extensible language of requests and macros, allowing dynamic adjustment of text flow, spacing, and structure.[1] It shares markup-based principles with TeX, developed by Donald Knuth in 1978 for mathematical typesetting, but roff prioritizes general-purpose document preparation with a lighter syntax, whereas TeX excels in complex equation rendering; both avoid what-you-see-is-what-you-get (WYSIWYG) interfaces, differing from modern tools like Microsoft Word that emphasize visual editing over code-like input.[14][15] Roff integrates seamlessly within a toolchain of preprocessors to handle specialized content, such as tbl for creating tables, eqn for embedding mathematical equations, and pic for generating diagrams from textual descriptions, which expand input before core processing.[1] This modular approach remains evident in its ongoing use for BSD and Linux man pages, where these components enable comprehensive yet efficient documentation workflows.[1]History
Origins in RUNOFF
The origins of roff trace back to the RUNOFF program, developed by Jerome H. "Jerry" Saltzer at MIT's Project MAC in the early 1960s as part of the Compatible Time-Sharing System (CTSS). Written in the MAD (Michigan Algorithm Decoder) programming language, RUNOFF was implemented between 1963 and 1964 to address the need for automated text formatting in a time-sharing environment running on an IBM 7094 computer.[16][17] This program marked one of the earliest efforts to use computers for document preparation, replacing manual typing and rudimentary duplication tools like DITTO, and enabling users to produce formatted manuscripts efficiently on shared systems.[18] RUNOFF's primary purpose was to process text files—typically prepared using the companion TYPSET editor—and output them in a readable format suitable for line printers or typewriter consoles, with basic features like line filling, justification, and pagination. It introduced inline control words beginning with a period (.), which served as non-printing instructions to control formatting, such as.line length n to set the output line width to n characters (defaulting to 60) or .indent m to adjust paragraph indentation by m spaces.[19] These commands allowed simple markup for academic papers, theses, and memos, drawing inspiration from traditional typesetting notations while adapting them for computational processing; for instance, .adjust enabled right-justified text, and .double space added spacing between lines.[19] Unlike later systems, RUNOFF lacked macro facilities, relying solely on these primitive control words as direct precursors to roff's request syntax, and it established the enduring "." convention for distinguishing formatting directives from regular text content.[20]
Despite its innovations, RUNOFF was inherently limited by the CTSS environment and the hardware of the era, producing output restricted to monospaced fonts on line printers without support for advanced typography like boldface, italics, or variable spacing. Control words had to start on new lines and were ignored if malformed, with issues like incompatible tab handling in justification mode further constraining usability.[19] These constraints tied the program closely to CTSS's 12-bit BCD file format and specific peripherals, such as IBM 1403 printers, preventing portability but providing a foundational model that influenced subsequent text processing tools at Bell Labs.[16]
Early Bell Labs Implementations
In the late 1960s, following Bell Labs' withdrawal from the Multics project, Doug McIlroy reimplemented the original CTSS RUNOFF in the BCPL programming language for the GE 645 mainframe running under the GECOS operating system at Bell Labs' Murray Hill facility.[1][21] This 1969 version marked an early adaptation tailored for industrial research environments, extending the original's capabilities to handle Bell Labs' internal documentation needs, such as memos and technical papers, with output directed to line printers.[22] McIlroy's implementation introduced key enhancements, including the.na request for no-adjustment of line lengths, the .hy request for automatic hyphenation, number registers to store variables like page numbers, basic arithmetic operations for dynamic content, and improved hyphenation rules to better support justified text.[21]
The name "roff," a contraction of "run off," was coined by Bob Morris to distinguish this new system from the existing CTSS RUNOFF, as both were in use concurrently at Bell Labs.[23] Morris, collaborating with McIlroy, contributed to porting the BCPL code to related platforms, including a version for the GE 635, further solidifying roff's role in Bell Labs' document preparation workflow.[24]
A version of McIlroy's roff was adapted for Multics, the GE 645-based operating system from which Bell Labs had recently departed, incorporating the aforementioned enhancements for producing research documents.[1] J. F. Ossanna, a key figure in Multics software design at Bell Labs, contributed to this port, ensuring compatibility with the system's environment while maintaining the focus on extensible text formatting for technical output.[25] These early roff implementations represented a pivotal shift from academic tools like RUNOFF to robust systems suited for commercial and industrial text processing at Bell Labs.
By 1971, an early assembly-language port of roff—known as "rf"—was developed by Dennis Ritchie for the PDP-7 minicomputer, a precursor to full Unix development, and used to format the inaugural Unix manual pages.[26] This adaptation built directly on McIlroy's BCPL codebase, enabling efficient document production on limited hardware and laying groundwork for roff's integration into Unix.
Transition to Unix and nroff/troff
In 1971, Ken Thompson and Dennis Ritchie adapted the roff formatter to the PDP-7's assembly language as part of the early Unix development at Bell Labs, enabling the production of the First Edition Unix Programmer's Manual released on November 3 of that year.[27][28] This port marked roff's initial integration into the Unix environment, transitioning it from its Multics origins to support the nascent operating system's documentation needs on limited hardware.[27] By 1973, with the release of Unix Version 3, Joe Ossanna introduced nroff, a rewritten and enhanced version of roff optimized for output on terminal devices such as ASCII Teletype models and line printers.[1][27] This implementation, still coded in PDP-11 assembly, incorporated key advancements including the .de request for macro definitions and .wh for page traps to monitor specific output positions, allowing more dynamic control over formatted text.[1] nroff emphasized simplicity and compatibility with monospaced, fixed-width output, making it suitable for everyday terminal-based previewing and printing without specialized hardware.[27] The debut of troff followed in 1974 with Unix Version 4, extending Ossanna's work to drive the Graphic Systems C/A/T phototypesetter for professional typesetting.[27][24] This variant introduced support for proportional fonts, kerning to adjust inter-character spacing, ligatures for combined glyphs, and the first use of digitized fonts in a Unix text processor, enabling high-fidelity output with variable spacing to accommodate ascenders and descenders.[27][24] In contrast to nroff's focus on plain text for terminals, troff prioritized typographic quality for printed documents, though both shared a common input syntax for broad compatibility.[29] The introduction of nroff and troff profoundly impacted Unix by standardizing documentation production across the system, with these tools becoming essential utilities for generating manuals and technical reports.[27] Their design influenced subsequent developments, such as the device-independent ditroff, which generalized output handling beyond specific hardware.[27]Post-1970s Developments
Following Joe Ossanna's death in late 1977, Brian Kernighan took over the development of troff at Bell Labs, rewriting it in the C programming language to enhance maintainability and portability.[24] In 1979, Kernighan further revised troff to support multiple phototypesetters, including the Autologic APS-5, while preserving the original input syntax.[24] In the mid-1970s, key preprocessors extended troff's capabilities for technical content, including eqn for typesetting mathematical equations, developed by Lorinda Cherry and Brian Kernighan in 1975, and tbl for formatting tables, introduced by Mike Lesk and Kernighan around the same time. These tools, included in Unix Version 6, allowed higher-level input for complex elements like formulas and tabular data.[1] A major advancement came with the completion of device-independent input in 1982, as detailed in Kernighan's Computing Science Technical Report #97 ("A Typesetter-Independent TROFF"), which introduced an abstract intermediate output format known as ditroff.[30] This allowed troff to generate device-agnostic postscript that could be tailored to various output devices without altering the source documents, significantly improving flexibility for typesetting across hardware.[31] The 1980s saw further additions of preprocessors, such as pic for generating diagrams from textual descriptions, with its user manual released in 1981 (revised 1984) by Kernighan, and refer for automating bibliography management and citations.[30] Macro packages also proliferated, including the -ms package originally developed by Mike Lesk for formatting technical papers and memos, and the -man package standardized for Unix manual pages.[5] Portability efforts advanced with the inclusion of standardized nroff and troff in Unix Version 7, released in 1979, which influenced subsequent distributions like BSD Unix and AT&T's System III and System V.[32] By the late 1980s, troff's proprietary status under AT&T restricted its adoption outside licensed Unix environments, paving the way for open alternatives as Unix clones proliferated.[24] In response, James Clark initiated the groff project in early 1989 as a GNU implementation of ditroff, primarily to meet the Free Software Foundation's needs for free documentation typesetting tools.[5]Core Concepts
Input Conventions
Roff input files consist of text lines and control lines, with text lines containing the content to be formatted and ending in newlines typically after sentences, colons, semicolons, or optionally commas for readability.[1] Control lines, which invoke requests or macros, begin with a dot (.) for standard processing or a neutral apostrophe (') to suppress the break that would otherwise occur before the next text line.[1][33] In roff, words are defined as sequences of non-space characters, while sentences are identified by end-of-sentence characters such as "!", "?", or "." followed by two spaces or a newline.[1] To suppress end-of-sentence detection or prevent unwanted breaks—such as after an abbreviation—the non-printing escape sequence & can be inserted immediately after the punctuation.[1] This handling ensures proper justification and spacing during filling, which is enabled by default in most implementations.[34] Best practices for preparing roff input emphasize simplicity and portability: lines should be limited to 72 characters or fewer to accommodate editor fill columns and avoid wrapping issues, leading spaces should be avoided for indentation (instead using the .in request), and comments can be added via the " escape sequence at the beginning of a line or after a control line.[1] Empty control lines (simply ".") can be used for visual separation in the source without affecting output, while true empty lines (containing only a newline) introduce paragraph breaks and default vertical spacing.[1][33] For long lines, the \newline escape (backslash followed by newline) allows invisible continuation across multiple input lines.[34] Special characters like the dot (.) or apostrophe (') must be handled carefully in text: if they appear at the start of a line after a space, they are interpreted as control characters, so prefixing them with & allows literal printing.[1] Input files use Unix-style newlines (U+000A) and should stick to US-ASCII or ISO Latin-1 encoding, avoiding invalid control characters to prevent warnings or errors during processing.[34] Editor support enhances productivity for roff authoring: Emacs provides nroff-mode, a major mode suitable for all roff dialects, activated manually via M-x nroff-mode or automatically through file-local variables such asmode: nroff and fill-column: 72 at the file's end, or by file extensions common to man pages.[1] Vim supports syntax highlighting for roff files by setting the filetype option in a modeline, such as .\ vim: set filetype=groff textwidth=72:`, with "groff" recognizing GNU extensions or "nroff" for stricter compatibility; this requires Vim compiled with relevant features enabled.[1]
These conventions promote portability by standardizing input preparation, allowing documents to process consistently across nroff, troff, and derivatives like GNU groff without device-specific adjustments.[1]
Requests and Macros
In roff, requests are the fundamental built-in commands that control formatting and processing, invoked by a period (.) followed by the request name at the beginning of a line, optionally with arguments specified in scalable units such as inches (i), ems (m), or vertical motion units (v).[1] Examples include.ll N to set the line length to N units, .sp [N] to insert N lines of vertical space (defaulting to 1 line if unspecified), and .ce [N] to center the next N lines of text without filling or justifying them.[34] Number registers provide variable storage for integers, defined or modified with .nr reg ±value [increment], where the optional increment applies to subsequent interpolations like \n(reg) for retrieval.[1] Arguments to requests do not undergo interpolation unless explicitly escaped, ensuring predictable behavior in macro expansions.[34]
Macros enable reusable code blocks in roff, defined using .de name [end] followed by the macro body and terminated by .. or the specified end string, allowing users to create custom commands that accept arguments accessed via $1, $2, etc., or $* for all arguments.[1] For instance, .de hello Hello, $1! .. defines a macro invoked as .hello World to output "Hello, World!".[34] Macros support integration with conditionals like .if condition text (or { text } for multi-line), which evaluates numeric, string, or existence conditions to execute text if true, and diversions via .di name to capture subsequent output into a named buffer for later reuse, ended by another .di.[1]
Escape sequences, introduced by a backslash (\), provide inline control without starting a new line, handling special functions such as \" for comments (ignored until the end of the line in copy mode), \f[font] to change the current font (e.g., \fB for bold), and \s[±N] to adjust type size by or to N points.[34] The backslash itself is escaped as \\, and sequences like \n(reg) interpolate register values directly in text or macro arguments.[1] Unlike requests, escape sequences enable fine-grained formatting within running text.
Traps allow macros to be invoked automatically at specific events, using .wh position macname to set a page-location trap that triggers the macro when the vertical position reaches the specified distance from the top (useful for headers or footers, e.g., .wh 0 header), or .it N macname for an input-line trap that activates after N lines of input.[34] These mechanisms facilitate dynamic page layout without manual intervention at every occurrence.
Roff includes basic programming constructs for control flow, such as loops with .while condition { followed by the body on subsequent lines until a line containing only }, (e.g., .while \n(a < 5 { .nr a \n(a+1 .sp 1 } to increment register a and add space five times), and arithmetic operations on registers using .nr reg expr where expr supports integer addition (+), subtraction (-), multiplication (*), division (/ with truncation), and scaling indicators.[1] String variables can store and interpolate text via .ds name "string" and \*[name], complementing numeric registers for more complex manipulations.[34]
Limitations in roff's control language include exclusive support for integer arithmetic with no floating-point operations, restricting precision in calculations to whole numbers within a 32-bit signed range (approximately ±2 billion); division truncates toward zero.[34] Register and macro scope is file-local by default, though .rm name removes definitions to manage namespace, and compatibility modes may alter behavior across implementations.[1] These features form the basis for macro packages that extend roff for specialized document types.[34]
Output Processing
The roff formatting system processes input text through a sequential pipeline that transforms markup into rendered output suitable for various devices. It reads the input file line by line, initially scanning each line to identify and execute requests—commands prefixed with a period—and escape sequences beginning with a backslash, which control formatting attributes such as font changes or positioning.[29] Following this recognition phase, the system collects words into lines, applying filling to distribute text across the specified line length and justification if enabled, while handling hyphenation either algorithmically (enabled by default) or manually suppressed via the .nh request to prevent unwanted breaks.[29] This pipeline ensures that textual content is assembled into cohesive units before further refinement, with no inherent validation of input syntax beyond basic parsing, leading to runtime errors if malformed.[5] Line breaking in roff occurs automatically when accumulated text reaches the full measure set by the line length, such as via the .ll request, promoting natural flow while respecting punctuation and spaces. Manual intervention is possible through blank lines, which force a break, or the : escape sequence to insert an unbreakable space; conversely, lines beginning with an apostrophe (') are treated as no-break controls, preventing interruption before that point to preserve phrases or headings. Adjustment for justification is toggled with the .ad request, distributing extra space evenly across lines for a polished appearance, while inter-sentence spacing adds an additional unit after periods, exclamation marks, or question marks to enhance readability. Vertical spacing is managed via the .vs request, defaulting to 120% of the current font size (e.g., 12 points for a 10-point font), allowing precise control over paragraph separation and overall layout density.[29] Page geometry in roff employs a coordinate system with the origin at the upper-left corner of the page, where positive directions extend downward and to the right, facilitating absolute positioning of elements. Measurements use basic units of 1/720 inch in traditional troff implementations, enabling fine-grained control over margins and indents, with page transitions invoked by the .bp request to eject the current page and begin a new one. For device adaptation, roff generates an intermediate output format, such as ditroff, which encodes glyphs, their positions, and attributes in a device-independent manner; this is then passed to postprocessors that interpret device-specific details from DESC files—describing font metrics, resolutions, and capabilities—to produce final output in formats like ASCII for terminals or PostScript for printers. Error handling during processing includes issuing warnings for undefined macros or invalid requests, with the .ab request available to abort execution immediately upon detecting critical issues, though the system lacks comprehensive built-in validation to enforce document integrity.[29][5]Implementations
GNU groff
GNU groff, the GNU implementation of the roff typesetting system, was initiated in early 1989 by James Clark as part of the GNU Project to provide a free alternative to proprietary troff implementations. The first release, version 0.3.1, appeared in June 1990, and it has since evolved into a robust, device-independent formatter compatible with AT&T's ditroff while adding numerous extensions. Distributed under the GNU General Public License (GPL), groff is maintained by G. Branden Robinson and supports platforms including Linux, BSD variants, and Windows.[10][35][36] Key enhancements in groff include its device-independent architecture, which allows output generation for multiple formats without device-specific recompilation, mirroring ditroff's capabilities but under a free license. It employs a high internal resolution of 72,000 basic units per inch for the PostScript device, enabling precise rendering far beyond classical troff's 720 units per inch. Color support is provided via the.color request, which enables or disables color output and works with various color spaces (up to 16 bits per channel), though terminal devices may have limitations. For PDF generation, the pdfroff wrapper simplifies multi-pass processing to produce PDF documents directly from roff input.[5][37][38][39]
Groff integrates several preprocessors to handle specialized content: gtbl for tables, geqn for mathematical equations, gpic for diagrams, and grefer for bibliographic citations. Additional extensions include gchem for chemical structure diagrams and grohtml (with its pre-grohtml preprocessor) for HTML output. Macro packages are built-in and include -man for Unix manual pages, -mdoc for BSD-style documentation, -ms for general manuscripts, and -me for Berkeley-style memos. Support for X11 environments features drivers like X75 (75 dpi) and X100 (100 dpi), which utilize standard X11 fonts for terminal previewing.[40][41][42][43][44]
Typical usage involves command-line invocation, such as groff -Tutf8 file.roff to process a file for UTF-8 terminal output, with options to specify macro packages (e.g., -man) or preprocessors (e.g., -e for eqn). The .sy request allows embedding system calls within documents for dynamic content, such as executing external commands and capturing output. Groff's input handling supports multiple streams, facilitating parallel processing in pipelines with tools like preprocessors. As the default roff implementation on GNU/Linux distributions, groff is essential for rendering man pages and serves as a lightweight alternative to TeX in minimal or embedded systems. Development remains active, with version 1.23.0 released in July 2023 serving as the current stable release as of late 2025.[45][5][34][45][46][10]