groff(1)

groff(1)

NAMN

groff – frontände till GNU:s roff-system för dokumentformatering

SYNOPSIS

groff [-abcCeEgGijklNpRsStUVXzZ] [-d ctext] [-d sträng=text]
      [-D reservkodning] [-f typsnittsfamilj] [-F typsnittskatalog]
      [-I inkluderingskatalog] [-K indatakodning] [-L spooler-argument]
      [-m makropaket] [-M makrokatalog] [-n sidnummer]
      [-o sidlista] [-P efterbehandlarargument]
      [-r cregisteruttryck] [-r register=numeriskt-uttryck]
      [-T utenhet] [-w varningskategori] [-W varningskategori]
      [fil ...]

groff -h
groff --help

groff -v [alternativ ...] [fil ...]
groff --version [alternativ ...] [fil ...]

BESKRIVNING

groff är den primära frontänden till GNU:s roff-system för dokumentformatering. GNU roff är ett typsättningssystem som läser vanliga textfiler med formateringskommandon och producerar utdata i PostScript, PDF, HTML, DVI eller andra format, eller för visning i terminal. Formateringskommandon kan vara typsättningsprimitiver på låg nivå, makron från ett medföljande paket eller användardefinierade makron. Alla tre tillvägagångssätten kan kombineras. Om inga fil-operander anges, eller om fil är -, läser groff från standard in.

Som en omimplementation och utvidgning av typsättaren från AT&T Unix finns groff på de flesta POSIX-system tack vare dess långa koppling till Unix-manualer (inklusive man-sidor). Det och dess föregångare är särskilt kända för att ha producerat flera bästsäljande texter inom programvaruteknik. groff kan producera typografiskt avancerade dokument med mycket liten resursförbrukning.

Kommandot groff orkestrerar körningen av förprocessorer, omvandlingen av indatadokument till ett enhetsoberoende sidbeskrivningsspråk och framställningen av utdata från detta språk.

FLAGGOR

-h och --help visar ett användningsmeddelande och avslutar.

Eftersom groff är avsett att ersätta de flesta användares direkta anrop av formatteraren troff(1), delar de två programmen en mängd flaggor. groff har dock vissa flaggor som troff inte har, och andra som tolkas annorlunda av groff. Samtidigt kan inte alla giltiga troff-flaggor ges till groff.

groff-specifika flaggor

Följande flaggor finns antingen inte i GNU troff eller tolkas annorlunda av groff.

-D enc

Ange reservkodning för indata som används av preconv(1) till enc; implicerar -k.

-e

Kör förprocessorn eqn(1).

-g

Kör förprocessorn grn(1).

-G

Kör förprocessorn grap(1); implicerar -p.

-I katalog

Fungerar som motsvarande flagga i troff (se nedan), men implicerar även -g och -s. Den skickas vidare till soelim(1) och utdataenhetens drivrutin, och grn får en -M-flagga med katalog som argument.

-j

Kör förprocessorn chem(1); implicerar -p.

-k

Kör förprocessorn preconv(1). Se dess manualsida för beteende om varken groffs -K- eller -D-flaggor också anges.

-K enc

Ange indatakodning som används av preconv(1) till enc; implicerar -k.

-l

Skicka utdatan till ett spoolerprogram för utskrift. Direktivet print i enhetsbeskrivningsfilen anger standardkommandot som ska användas; se groff_font(5). Om inget sådant direktiv finns för utenheten skickas utdatan till lpr(1). Se flaggorna -L och -X.

-L arg

Skicka arg till utskriftsspoolern. Om flera argument krävs, ange vart och ett med en separat -L-flagga. groff lägger inte till något inledande bindestreck före arg innan det skickas till spoolerprogrammet.

-M

Fungerar som motsvarande flagga i troff (se nedan), men skickas även vidare till eqn(1), grap(1) och grn(1).

-N

Förbjud radbrytningar mellan eqn-avgränsare: skicka -N till eqn(1).

-p

Kör förprocessorn pic(1).

-P arg

Skicka arg till efterbehandlaren. Om flera argument krävs, ange vart och ett med en separat -P-flagga. groff lägger inte till något inledande bindestreck före arg innan det skickas till efterbehandlaren.

-R

Kör förprocessorn refer(1). Det finns ingen mekanism för att skicka argument till refer, eftersom de flesta refer-flaggor har motsvarande språkelement som kan anges i dokumentet.

-s

Kör förprocessorn soelim(1).

-S

Arbeta i ”säkrare” läge; se -U nedan för motsatsen. Av säkerhetsskäl är säkrare läge aktiverat som standard.

-t

Kör förprocessorn tbl(1).

-T enhet

Instruera troff att formatera indata för utenheten enhet. groff anropar sedan en utdataenhetsdrivrutin för att omvandla troffs utdata till en form som passar enhet; se underavsnittet ”Utdataenheter” nedan.

-U

Arbeta i osäkert läge: skicka flaggan -U till pic och troff.

-v, --version

Skriv versionsinformation för groff och alla program som körs av det till standard ut; det vill säga att den givna kommandoraden behandlas på vanligt sätt, med -v skickad till formatteraren och eventuella för- eller efterprocessorer som anropas.

-V

Skriv ut pipeline som groff skulle köra till standard ut, men kör den inte. Om flaggan ges fler än en gång skriver och kör groff både pipelinen.

-X

Använd gxditview(1) i stället för den vanliga efterbehandlaren för att förhandsvisa ett dokument på en X11-skärm. Att kombinera denna flagga med -Tps använder teckensnittsmetrik för PostScript-enheten, medan -TX75 och -TX100 använder metriken för X11-typsnitt.

-Z

Stäng av efterbehandling. troff-utdata visas då på standard ut (om det inte undertrycks med -z); se groff_out(5) för en beskrivning av detta format.

Transparanta flaggor

Följande flaggor skickas oförändrade till formatteraren troff(1) och beskrivs mer i detalj i dess manualsida.

-a

Generera en ren textapproximation av den satta utdatan.

-b

Skriv en backtrace till standard error vid varje fel eller varning.

-c

Börja med färgutdata avstängd.

-C

Aktivera kompatibilitetsläge med AT&T troff; implicerar -c.

-d cs

-d namn=sträng

Definiera sträng.

-E

Undertryck troff-felmeddelanden; implicerar -Ww.

-f familj

Ange standardfamilj för typsnitt.

-F katalog

Sök i katalogen katalog efter den valda utenhetens katalog med enhets- och teckensnittsbeskrivningsfiler.

-i

Behandla standard in efter de angivna indatafilerna.

-I katalog

Sök i katalog efter indatafiler.

-m namn

Behandla namn.tmac före indatafilerna.

-M katalog

Sök i katalogen katalog efter makrofiler.

-n nummer

Numrera första sidan med nummer.

-o lista

Mata endast ut sidor i lista.

-r cnumeriskt-uttryck

-r register=numeriskt-uttryck

Definiera register.

-w namn

-W namn

Aktivera (-w) eller undertryck (-W) varningar i kategorin namn.

-z

Undertryck formaterad enhetsoberoende utdata från troff.

ANVÄNDNING

Arkitekturen för GNU roff följer andra enhetsoberoende roff-implementationer och består av förprocessorer, makropaket, utdataenhetsdrivrutiner (”efterbehandlare”), en samling verktyg samt formatteraren troff i centrum. Se roff(7) för en översikt över hur ett roff-system fungerar.

Frontändesprogrammen i GNU roff gör systemet enklare att använda än traditionella roff-implementationer, där man behövde bygga pipelines manuellt eller använda temporära filer för att föra ett källdokument från underhållbar form till enhetsanpassad utdata. Diskussionen nedan sammanfattar GNU roff-systemets beståndsdelar och kompletterar roff(7) med groff-specifik information.

Komma igång

De som föredrar att lära genom experiment eller vill ha snabb återkoppling från systemet kan börja med ett ”Hello, world!”-dokument.

$ echo "Hello, world!" | groff -Tascii | sed '/^$/d'
Hello, world!

Vi använde ett sed-kommando endast för att ta bort de 65 tomma rader som annars skulle fylla terminalskärmen. (roff-system utvecklades på den tid då pappersbaserade terminaler med 66 rader per sida var vanliga.)

Dagens användare kan föredra utdata till en terminal som stöder UTF-8.

$ echo "Hello, world!" | groff -Tutf8 | sed '/^$/d'

Att producera PDF, HTML eller TeX-formatet DVI är också enkelt. Den svåra delen kan vara att välja ett visningsprogram för resultatet.

$ echo "Hello, world!" | groff -Tpdf > hello.pdf
$ evince hello.pdf
$ echo "Hello, world!" | groff -Thtml > hello.html
$ firefox hello.html
$ echo "Hello, world!" | groff -Tdvi > hello.dvi
$ xdvi hello.html

Använda groff som en REPL

Den som har ett programmeringssinne kan uppskatta att groff kan användas i en read-evaluate-print loop (REPL). Det kan vara praktiskt för att verifiera förståelsen av formatterarens beteende och/eller syntaxen den accepterar. Att slå på alla varningar med -ww kan vara till hjälp.

$ groff -ww -Tutf8
\# Detta är en kommentar. Låt oss definiera ett register.
.nr a 1
\# Gör heltalsaritmetik med operatorer evaluerade vänster till höger.
.nr b \n[a]+5/2
\# Låt oss få resultatet på standard error.
.tm \n[b]
3
\# Nu definierar vi en sträng.
.ds name Leslie\" Detta är en annan form av kommentar.
.nr b (\n[a] + (7/2))
\# Centrera de två nästa textraderna.
.ce 2
Hi, \*[name].
Your secret number is \n[b].
\# Vi kommer att se att divisionen avrundades mot noll.
It is
\# Här är en if-else-struktur.
.ie (\n[b] % 2) odd.
.el even.
\# Detta trick sätter sidlängden till aktuell vertikal position
\# så att tomma rader inte sprutar ut när vi är klara.
.pl \n[nl]u
<Control-D>
                              Hi, Leslie.
                       Your secret number is 4.
It is even.

Pappersformat

I GNU roff hanteras sidmått för formatteraren troff och för utenheter separat. I formatteraren används begäranden för att sätta sidlängd (.pl), sidförskjutning eller vänstermarginal (.po) och radlängd (.ll). Högermarginalen konfigureras inte uttryckligen; kombinationen av sidförskjutning och radlängd ger tillräcklig information för att härleda den. Makropaketet papersize, som laddas automatiskt av troff, tillhandahåller ett gränssnitt för att konfigurera sidmått med bekväma namn som ”letter” eller ”A4”; se groff_tmac(5). Standard i denna installation är letter.

Det är upp till varje makropaket att respektera sidmåtten som konfigurerats på detta sätt. Vissa erbjuder alternativa mekanismer.

För varje utenhet kan storleken på utmatningsmediet sättas i dess DESC-fil. De flesta utdataenhetsdrivrutiner känner också igen en kommandoradsflagga -p för att åsidosätta standardmått och en flagga -l för liggande orientering. Se groff_font(5) för en beskrivning av direktivet papersize, som tar ett argument i samma form som -p. Utdrivarens manualsida, såsom grops(1), kan också vara till hjälp. groff använder kommandoradsflaggan -P för att skicka flaggor till utenheter; använd till exempel följande för PostScript-utdata på A4-papper i liggande orientering.

groff -Tps -dpaper=a4l -P-pa4 -P-l -ms foo.ms > foo.ps

Frontände

Programmet groff är ett omslag kring programmet troff(1). Det gör det möjligt att ange förprocessorer via kommandoradsflaggor och kör automatiskt rätt efterbehandlare för vald utenhet. Därmed slipper användaren den manuella konstruktionen av pipelines eller hanteringen av temporära filer som krävdes i traditionella roff(7)-system. Använd programmet grog(1) för att härleda en lämplig groff-kommandorad för att formatera ett dokument.

Språk

Indata till ett roff-system är vanlig text blandad med styr-rader och escape-sekvenser. Kombinationen utgör ett dokument i en familj av språk som också kallas roff; se roff(7) för bakgrund. En översikt över GNU roff-språkets syntax och funktioner, inklusive listor över alla stödda escape-sekvenser, begäranden och fördefinierade register, finns i groff(7). GNU roff-utvidgningar till AT&T troff-språket, en vanlig delmängd av dagens roff-dialekter, beskrivs i groff_diff(7).

Förprocessorer

En förprocessor tolkar ett domänspecifikt språk som producerar roff-språkutdata. Ofta är sådan indata begränsad till avsnitt eller regioner i en roff-fil, inramade av makroanrop specifika för varje förprocessor, vilka den ersätter. Förprocessorer tolkar därför ofta en delmängd av roff-syntax tillsammans med sitt eget språk. GNU roff tillhandahåller omimplementationer av de flesta förprocessorer som AT&T troff-användare känner till; dessa har ofta utökad funktionalitet och/eller kräver GNU troff för att formatera sin utdata.

tbl         lägger ut tabeller;
eqn         sätter matematik;
pic         ritar diagram;
refer       behandlar bibliografiska referenser;
soelim      förbehandlar ”inkluderade” indatafiler;
grn         återger gremlin(1)-diagram;
chem        ritar kemiska strukturformler med hjälp av pic;
gperl       fyller groff-register och strängar med hjälp av perl(1);
glilypond   bäddar in notskrift från LilyPond; och
gpinyin     underlättar inmatning av mandarin med Hanyu Pinyin.

En förprocessor som är unik för GNU roff är preconv(1), som konverterar olika indatakodningar till något som GNU troff förstår. När den används körs den före alla andra förprocessorer.

De flesta förprocessorer omsluter innehåll mellan ett karakteristiskt tokenpar. Ett sådant token måste förekomma i början av en indatarad och använda punkt som styrtecken. Mellanslag och tabbar får inte följa styrtecknet eller föregå radslutet. Om man avviker från dessa regler kan förprocessorn misslyckas med att känna igen token. Token bevaras i allmänhet i förprocessorutdata och tolkas senare som makroanrop av troff. Förprocessorn ideal finns ännu inte tillgänglig i groff.

förprocessor	starttoken	sluttoken
chem	.cstart	.cend
eqn	.EQ	.EN
grap	.G1	.G2
grn	.GS	.GE
ideal	.IS	.IE / .IF
pic	.PS	.PE / .PF / .PY
refer	.R1	.R2
tbl	.TS	.TE
glilypond	.lilypond start	.lilypond stop
gperl	.Perl start	.Perl stop
gpinyin	.pinyin start	.pinyin stop

Makropaket

Makrofiler är roff-indatafiler som inte är avsedda att producera utdata själva, utan i stället underlättar framställningen av andra roff-dokument. När en makrofil installeras på en standardplats och är lämplig för allmän användning kallas den ett makropaket.

Makropaket kan laddas före alla roff-indatafiler med flaggan -m. GNU roff implementerar de flesta välkända makropaket från AT&T troff på ett kompatibelt sätt och utvidgar dem. Dessa har namn på en eller två bokstäver, vilket härrör från den extrema namn-ekonomi som präglade tidig Unix-kultur. Det lakoniska sättet att namnge ledde till att många paket i allmänt bruk identifierades med den nroff- eller troff-flagga som användes för att aktivera dem, ibland med ordlekseffekt, som med ”man” (kort för ”manual”), och ibland till och med med själva flaggbindestrecket, som i fallet med paketet s, mycket bättre känt som ms eller till och med -ms.

Makropaket tjänar olika syften. Vissa är ”fullservicelösningar”, som tar ansvar för sidlayout och andra grundläggande uppgifter samt definierar ett eget vokabulär av makron för dokumentsammansättning; varje sådant paket står på egna ben och ett givet dokument kan använda högst ett.

an

används för att skriva man-sidor i det format som introducerades i Version 7 Unix (1979); se groff_man(7). Det kan anges på kommandoraden som -man.

doc

används för att skriva man-sidor i det format som introducerades i 4.3BSD-Reno (1990); se groff_mdoc(7). Det kan anges på kommandoraden som -mdoc.

e

är Berkeleys allmänna makrosvit, utvecklad som ett alternativ till AT&T:s s; se groff_me(7). Det kan anges på kommandoraden som -me.

m

implementerar formatet som används av AT&T:s andra generation av makrosvit för allmänna dokument, en efterföljare till s; se groff_mm(7). Det kan anges på kommandoraden som -mm.

om

(alltid kallat ”mom”) är ett modernt paket skrivet av Peter Schaffter specifikt för GNU roff. Se mom-manualen i HTML på ⟨file:///usr/local/share/doc/groff-1.23.0/html/mom/toc.html⟩ för omfattande dokumentation. Hon — för mom tar femininum — kan anges på kommandoraden som -mom.

s

är AT&T:s ursprungliga allmänna dokumentformat; se groff_ms(7). Det kan anges på kommandoraden som -ms.

Andra paket är kompletterande. Till exempel är andoc ett wrapper-paket som är specifikt för GNU roff och känner igen om ett dokument använder man- eller mdoc-format och laddar motsvarande makropaket. Det kan anges på kommandoraden som -mandoc. Ett biblioteksprogram som man(1) kan använda denna makrofil för att delegera valet av rätt makropaket; därmed behöver man självt inte skanna dokumentets innehåll för att avgöra detta.

Många makrofiler utökar funktionaliteten hos fullservicelösningarna, eller hos roff-dokument som inte använder något sådant paket — de senare kallas ibland ”råa”. Dessa hjälppaket beskrivs, tillsammans med detaljer om makrofilernas namn och placering, i groff_tmac(5).

Formatterare

Formatteraren, det program som tolkar roff-språkinmatning, är troff(1). Det tillhandahåller funktionerna från AT&T:s program troff och nroff samt många utökningar. Kommandoradsflaggan -C sätter troff i kompatibilitetsläge, som försöker efterlikna AT&T troff så nära som praktiskt möjligt för att kunna formatera dokument skrivna för det äldre systemet.

Ett skalskript, nroff(1), emulerar beteendet hos AT&T nroff. Det försöker koda utdatan korrekt utifrån locale, vilket befriar användaren från att behöva ange en utenhet med flaggan -T, och är därför bekvämt för användning med terminalenheter som beskrivs i nästa underavsnitt.

GNU troff genererar utdata i ett enhetsoberoende, men inte enhetsagnostiskt, sidbeskrivningsspråk som dokumenteras i groff_out(5).

Utdataenheter

troff-utdata formateras för en viss utenhet, vanligtvis angiven med flaggan -T till formatteraren eller en frontände. Om varken denna flagga eller miljövariabeln GROFF_TYPESETTER används, är standardutenheten ps. En utenhet kan vara någon av följande.

ascii

för terminaler som använder teckenuppsättningen och kodningen ISO 646 1991:IRV, även känd som US-ASCII.

cp1047

för terminaler som använder IBM:s kodsida 1047.

dvi

för TeX DVI-format.

html

xhtml

för HTML- respektive XHTML-utdata.

latin1

för terminaler som använder ISO Latin-1 (ISO 8859-1).

lbp

för Canon CaPSL-skrivare (LBP-4 och LBP-8-seriens laserskrivare).

lj4

för HP LaserJet4-kompatibla skrivare (eller andra PCL5-kompatibla skrivare).

pdf

för PDF-utdata.

ps

för PostScript-utdata.

utf8

för terminaler som använder ISO 10646 (”Unicode”) i UTF-8-kodning.

X75

för förhandsvisning med gxditview med 75 dpi upplösning och 10 punkters grundstorlek.

X75-12

för förhandsvisning med gxditview med 75 dpi upplösning och 12 punkters grundstorlek.

X100

för förhandsvisning med gxditview med 100 dpi upplösning och 10 punkters grundstorlek.

X100-12

för förhandsvisning med gxditview med 100 dpi upplösning och 12 punkters grundstorlek.

Efterbehandlare

Alla program som tolkar utdata från GNU troff är en efterbehandlare. De efterbehandlare som tillhandahålls av GNU roff är utdataenhetsdrivrutiner, som förbereder dokumentet för visning eller utskrift. Efterbehandlare för andra syften, som omsortering av sidor eller statistisk analys av dokument, är tänkbara.

En utdataenhetsdrivrutin stöder en eller flera utenheter, var och en med sin egen enhetsbeskrivningsfil. Enheten bestämmer sin efterbehandlare med direktivet postpro i sin enhetsbeskrivningsfil; se groff_font(5). Flaggan -X åsidosätter detta val och tvingar gxditview att fungera som utdataenhetsdrivrutin.

grodvi(1)

tillhandahåller dvi.

grohtml(1)

tillhandahåller html och xhtml.

grolbp(1)

tillhandahåller lbp.

grolj4(1)

tillhandahåller lj4.

gropdf(1)

tillhandahåller pdf.

grops(1)

tillhandahåller ps.

grotty(1)

tillhandahåller ascii, cp1047, latin1 och utf8.

gxditview(1)

tillhandahåller X75, X75-12, X100 och X100-12, och kan dessutom förhandsvisa ps.

Verktyg

GNU roff innehåller en verktygssvit.

gdiffmk(1)

markerar skillnader mellan ett par roff-indatafiler.

grog(1)

härleder vilket groff-kommando ett dokument behöver.

Flera verktyg förbereder beskrivningar av typsnitt så att formatteraren kan använda dem när utdata produceras för en viss enhet.

addftinfo(1)

lägger till information till AT&T troff-typsnittsbeskrivningsfiler så att de kan användas med GNU troff.

afmtodit(1)

skapar typsnittsbeskrivningsfiler för PostScript Type 1-typsnitt.

pfbtops(1)

översätter ett PostScript Type 1-typsnitt i PFB-format (Printer Font Binary) till PFA-format (Printer Font ASCII), som därefter kan tolkas av afmtodit.

hpftodit(1)

skapar typsnittsbeskrivningsfiler för HP LaserJet 4-familjen.

tfmtodit(1)

skapar typsnittsbeskrivningsfiler för TeX DVI-enheten.

xtotroff(1)

skapar typsnittsbeskrivningsfiler för X Window Systems kärntypsnitt.

En trio verktyg omvandlar material konstruerat med roff-förprocessorspråk till grafiska bildfiler.

eqn2graph(1)

omvandlar en eqn-ekvation till en beskuren bild.

grap2graph(1)

omvandlar ett grap-diagram till en beskuren bild.

pic2graph(1)

omvandlar ett pic-diagram till en beskuren bild.

En annan grupp program arbetar med bibliografiska datafiler som används av förprocessorn refer(1).

indxbib(1)

skapar inverterade index för bibliografiska databaser och snabbar därmed upp uppslagningar.

lkbib(1)

söker i databaserna.

lookbib(1)

söker interaktivt i databaserna.

AVSLUTNINGSSTATUS

groff avslutas med felstatus om det uppstod problem vid tolkning av dess argument och med framgångsstatus om någon av flaggorna -h eller --help angavs. I annat fall kör groff en pipeline för att behandla sin indata; om alla kommandon i pipelinen avslutas framgångsrikt gör groff detsamma. Om inte, kodar groffs avslutningsstatus en sammanfattning av problemen: bit 0 sätts om ett kommando avslutades med felstatus, bit 1 om ett kommando terminerades av en signal och bit 2 om ett kommando inte kunde köras. (Om alltså alla tre olyckor drabbade pipelinen, skulle groff avslutas med status 2^0 + 2^1 + 2^2 = 1+2+4 = 7.) För felsökning av pipelineproblem kan det vara klokt att köra om groff med flaggan -V och bryta ned den rapporterade pipelinen i separata steg, och inspektera avslutningsstatus och diagnostiska meddelanden för varje kommando.

MILJÖ

Normalt är sökvägsavgränsaren i miljövariabler som slutar på PATH kolon; detta kan variera beroende på operativsystem. Windows använder till exempel semikolon.

GROFF_BIN_PATH

Denna sökväg, följd av PATH, används för att hitta kommandon som körs av groff. Om den inte är satt genomsöks installationskatalogen för GNU roff-programmen, /usr/local/bin, före PATH.

GROFF_COMMAND_PREFIX

GNU roff kan konfigureras vid kompilering så att ett prefix läggs till namnen på program som motsvarar sådana i AT&T troff, för att undvika namnkonflikter vid körning. Standardprefixet är tomt.

När ett prefix används är det konventionellt bokstaven ”g”. Till exempel skulle GNU troff installeras som gtroff. Förutom troff gäller prefixet formatteraren nroff; förprocessorerna eqn, grn, pic, refer, tbl och soelim; samt verktygen indxbib och lookbib.

GROFF_ENCODING

Värdet i denna variabel skickas till förprocessorn preconv(1) med flaggan -e för att välja teckenkodning för indatafiler. Förekomsten av denna variabel implicerar groff-flaggan -k. Om den är satt men tom anropar groff preconv utan -e. groffs -K-flagga åsidosätter GROFF_ENCODING.

GROFF_FONT_PATH

Sök efter den valda utenhetens katalog med enhets- och typsnittsbeskrivningsfiler i denna lista över kataloger. Se troff(1) och groff_font(5).

GROFF_TMAC_PATH

Sök efter makrofiler i denna lista över kataloger. Se troff(1) och groff_tmac(5).

GROFF_TMPDIR

Skapa temporära filer i denna katalog. Om den inte är satt men miljövariabeln TMPDIR är satt, skapas temporära filer där i stället. På Windows-system kontrolleras även TMP och TEMP (i den ordningen) om varken ovanstående finns. Annars skapas temporära filer i /tmp. Kommandona refer(1), grohtml(1) och grops(1) använder temporära filer.

GROFF_TYPESETTER

Ange standardutenhet. Om tom eller osatt används ps. Flaggan -T åsidosätter GROFF_TYPESETTER.

SOURCE_DATE_EPOCH

En tidsstämpel (uttryckt som sekunder sedan Unix-epoken) som används som dokumentets skapandetid i stället för aktuell tid. Tiden omvandlas till läsbar form med localtime(3) när formatteraren startar och lagras i register som dokument och makropaket kan använda.

TZ

Tidszon som ska användas när aktuell tid (eller värdet av SOURCE_DATE_EPOCH) omvandlas till läsbar form; se tzset(3).

EXEMPEL

roff-system är mest kända för att formatera man-sidor. När ett biblioteksprogram som man(1) har hittat en man-sida kan det köra ett groff-kommando ungefär som följande.

groff -t -man -Tutf8 /usr/share/man/man1/groff.1

Biblioteksprogrammet skickar också utdatan genom en pager, som kanske inte tolkar de SGR-terminalsekvenser som groff skickar ut för fetstil, understrykning eller kursiv stil; se avsnittet ”Begränsningar” nedan.

För att behandla en roff-fil med förprocessorerna tbl och pic och makropaketet me på det sätt AT&T troff-användare var vana vid, skulle man skriva (eller skripta) en pipeline.

pic foo.me | tbl | troff -me -Tutf8 | grotty

Med groff kan denna pipeline förkortas till ett ekvivalent kommando.

groff -p -t -me -T utf8 foo.me

Ett ännu enklare sätt är att använda grog(1) för att gissa lämpliga förprocessor- och makroflaggor och sedan köra resultatet med skalets kommandosubstitution.

$(grog -Tutf8 foo.me)

Varje kommandoradsflagga till en efterbehandlare måste anges med eventuella nödvändiga inledande bindestreck -, eftersom groff skickar argumenten oförändrade till efterbehandlaren; detta gör det möjligt att vidarebefordra godtyckliga argument. Till exempel är följande två kommandon ekvivalenta för att skicka en titel till efterbehandlaren gxditview.

groff -X -P -title -P 'trial run' mydoc.t

och

groff -X -Z mydoc.t | gxditview -title 'trial run' -

BEGRÄNSNINGAR

Vid paginering av utdata för enheterna ascii, cp1047, latin1 och utf8 kan program som more(1) och less(1) kräva kommandoradsflaggor för att korrekt hantera vissa terminalsekvenser; se grotty(1).

På EBCDIC-värdar såsom OS/390 Unix är utenheterna ascii och latin1 inte tillgängliga. Omvänt är utenheten cp1047 inte tillgänglig på system baserade på teckenkodningsstandarderna ISO 646 eller ISO 8859.

INSTALLATIONSKATALOGER

GNU roff installerar filer på olika platser beroende på dess kompilering. I denna installation används följande platser.

/usr/local/bin

Katalog som innehåller groffs körbara kommandon.

/usr/local/share/groff/1.23.0/eign

Lista över vanliga ord för indxbib(1).

/usr/local/share/groff/1.23.0

Katalog för datafiler.

/usr/dict/papers/Ind

Standardindex för lkbib(1) och refer(1).

/usr/local/share/doc/groff-1.23.0

Dokumentationskatalog.

/usr/local/share/doc/groff-1.23.0/examples

Exempelkatalog.

/usr/local/share/groff/1.23.0/font

Typsnittskatalog.

/usr/local/share/doc/groff-1.23.0/html

HTML-dokumentationskatalog.

/usr/lib/font

Äldre typsnittskatalog.

/usr/local/share/groff/site-font

Lokal typsnittskatalog.

/usr/local/share/groff/site-tmac

Lokal katalog för makropaket (tmac-filer).

/usr/local/share/groff/1.23.0/tmac

Katalog för makropaket (tmac-filer).

/usr/local/share/groff/1.23.0/oldfont

Typsnittskatalog för kompatibilitet med äldre versioner av groff; se grops(1).

/usr/local/share/doc/groff-1.23.0/pdf

PDF-dokumentationskatalog.

groffs makrokatalog

De flesta makrofiler som levereras med GNU roff lagras i /usr/local/share/groff/1.23.0/tmac för den installation som motsvarar detta dokument. Som regel genomsöks flera kataloger efter makrofiler; se troff(1). För en katalog över de makrofiler GNU roff tillhandahåller, se groff_tmac(5).

groffs katalog för enhets- och typsnittsbeskrivningar

Enhets- och typsnittsbeskrivningsfiler som levereras med GNU roff lagras i /usr/local/share/groff/1.23.0/font för den installation som motsvarar detta dokument. Som regel genomsöks flera kataloger efter sådana filer; se troff(1). För filformaten, se groff_font(5).

TILLGÄNGLIGHET

Länkar till nedladdning av groff-utgåvor, dess källkodsarkiv, diskussionslistor, ärendehantering och ytterligare information finns på groff-sidan på GNU:s webbplats: http://www.gnu.org/software/groff

En fri implementation av förprocessorn grap, skriven av Ted Faber ⟨faber@lunabase.org⟩, finns på grap-webbplatsen: http://www.lunabase.org/~faber/Vault/software/grap/

groff stöder endast denna implementation av grap.

FÖRFATTARE

groff (både frontändeskommandot och systemet som helhet) skrevs huvudsakligen av James Clark ⟨jjc@jclark.com⟩. Bidragsgivare till detta dokument inkluderar Clark, Trent A. Fisher, Werner Lemberg ⟨wl@gnu.org⟩, Bernd Warken ⟨groff-bernd.warken-72@web.de⟩ och G. Branden Robinson ⟨g.branden.robinson@gmail.com⟩.

SE ÄVEN

Groff: The GNU Implementation of troff, av Trent A. Fisher och Werner Lemberg, är den huvudsakliga manualen för groff. Den kan läsas interaktivt med kommandot info groff.

Introduktion, historik och vidare läsning:

• roff(7)

Visningsprogram för groff-dokument (och AT&T:s enhetsoberoende troff):

• gxditview(1)

Förprocessorer:

• chem(1)
• eqn(1)
• neqn(1)
• glilypond(1)
• grn(1)
• preconv(1)
• gperl(1)
• pic(1)
• gpinyin(1)
• refer(1)
• soelim(1)
• tbl(1)

Makropaket och paketspecifika verktyg:

• groff_hdtbl(7)
• groff_man(7)
• groff_man_style(7)
• groff_mdoc(7)
• groff_me(7)
• groff_mm(7)
• groff_mmse(7)
• mmroff(1)
• groff_mom(7)
• pdfmom(1)
• groff_ms(7)
• groff_rfc1345(7)
• groff_trace(7)
• groff_www(7)

Verktyg för bibliografiska databaser:

• indxbib(1)
• lkbib(1)
• lookbib(1)

Språk, konventioner och GNU-utvidgningar:

• groff(7)
• groff_char(7)
• groff_diff(7)
• groff_font(5)
• groff_tmac(5)

Mellanliggande utdataspråk:

• groff_out(5)

Formatterarprogram:

• troff(1)

Omslag kring formatteraren:

• nroff(1)
• pdfroff(1)

Efterbehandlare för utenheter:

• grodvi(1)
• grohtml(1)
• grolbp(1)
• grolj4(1)
• gropdf(1)
• grops(1)
• grotty(1)

Verktyg för typsnittsstöd:

• addftinfo(1)
• afmtodit(1)
• hpftodit(1)
• pfbtops(1)
• tfmtodit(1)
• xtotroff(1)

Verktyg för grafikomvandling:

• eqn2graph(1)
• grap2graph(1)
• pic2graph(1)

Verktyg för differensmarkering:

• gdiffmk(1)

Verktyg för ”groff-gissning”:

• grog(1)

KOLOFON

Denna sida är en del av projektet groff (GNU troff). Information om projektet finns på: http://www.gnu.org/software/groff/

Om du har en felrapport för denna manualsida, se: http://www.gnu.org/software/groff/

Denna sida hämtades från tar-arkivet groff-1.23.0.tar.gz, hämtat från: https://ftp.gnu.org/gnu/groff/

den 2026-01-16.

Om du upptäcker renderingsproblem i denna HTML-version av sidan, eller om du tror att det finns en bättre eller mer uppdaterad källa för sidan, eller om du har rättelser eller förbättringar till informationen i detta KOLOFON (som inte är en del av den ursprungliga manualsidan), skicka e-post till: man-pages@man7.org

Sidslut

Orginalhemsidan på Engelska https://man7.org/linux/man-pages/man1/groff.1.html Det här är en maskinöversättning av Linux man sidor till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på https://www.linux.se/kontaka-linux-se/

Tack till PC Service som har sponsrat Linux.se med webbhotell.