1 /* $Id: man.c,v 1.190 2025/08/22 13:17:06 schwarze Exp $ */ 2 /* 3 * Copyright (c) 2013-2015,2017-2019,2022 Ingo Schwarze <schwarze@openbsd.org> 4 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv> 5 * Copyright (c) 2011 Joerg Sonnenberger <joerg@netbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 #include "config.h" 20 21 #include <sys/types.h> 22 23 #include <assert.h> 24 #include <ctype.h> 25 #include <stdarg.h> 26 #include <stdlib.h> 27 #include <stdio.h> 28 #include <string.h> 29 30 #include "mandoc_aux.h" 31 #include "mandoc.h" 32 #include "roff.h" 33 #include "man.h" 34 #include "libmandoc.h" 35 #include "roff_int.h" 36 #include "libman.h" 37 38 static char *man_hasc(char *); 39 static int man_ptext(struct roff_man *, int, char *, int); 40 static int man_pmacro(struct roff_man *, int, char *, int); 41 42 43 int 44 man_parseln(struct roff_man *man, int ln, char *buf, int offs) 45 { 46 47 if (man->last->type != ROFFT_EQN || ln > man->last->line) 48 man->flags |= MAN_NEWLINE; 49 50 return roff_getcontrol(man->roff, buf, &offs) ? 51 man_pmacro(man, ln, buf, offs) : 52 man_ptext(man, ln, buf, offs); 53 } 54 55 /* 56 * If the string ends with \c, return a pointer to the backslash. 57 * Otherwise, return NULL. 58 */ 59 static char * 60 man_hasc(char *start) 61 { 62 char *cp, *ep; 63 64 ep = strchr(start, '\0') - 2; 65 if (ep < start || ep[0] != '\\' || ep[1] != 'c') 66 return NULL; 67 for (cp = ep; cp > start; cp--) 68 if (cp[-1] != '\\') 69 break; 70 return (ep - cp) % 2 ? NULL : ep; 71 } 72 73 /* 74 * Rewind all open next-line scopes. 75 */ 76 void 77 man_descope(struct roff_man *man, int line, int offs, char *start) 78 { 79 /* First close out all next-line element scopes, if any. */ 80 81 if (man->flags & MAN_ELINE) { 82 while (man->last->parent->type != ROFFT_ROOT && 83 man_macro(man->last->parent->tok)->flags & MAN_ESCOPED) 84 man_unscope(man, man->last->parent); 85 man->flags &= ~MAN_ELINE; 86 } 87 88 /* Trailing \c keeps next-line block scope open. */ 89 90 if (start != NULL && man_hasc(start) != NULL) 91 return; 92 93 /* Close out the next-line block scope, if there is one. */ 94 95 if ( ! (man->flags & MAN_BLINE)) 96 return; 97 man_unscope(man, man->last->parent); 98 roff_body_alloc(man, line, offs, man->last->tok); 99 man->flags &= ~(MAN_BLINE | ROFF_NONOFILL); 100 } 101 102 static int 103 man_ptext(struct roff_man *man, int line, char *buf, int offs) 104 { 105 int i; 106 char *ep; 107 108 /* In no-fill mode, whitespace is preserved on text lines. */ 109 110 if (man->flags & ROFF_NOFILL) { 111 roff_word_alloc(man, line, offs, buf + offs); 112 man_descope(man, line, offs, buf + offs); 113 return 1; 114 } 115 116 for (i = offs; buf[i] == ' '; i++) 117 /* Skip leading whitespace. */ ; 118 119 /* 120 * Blank lines are ignored in next line scope 121 * and right after headings and cancel preceding \c, 122 * but add a single vertical space elsewhere. 123 */ 124 125 if (buf[i] == '\0') { 126 if (man->flags & (MAN_ELINE | MAN_BLINE)) { 127 mandoc_msg(MANDOCERR_BLK_BLANK, line, 0, NULL); 128 return 1; 129 } 130 if (man->last->tok == MAN_SH || man->last->tok == MAN_SS) 131 return 1; 132 if (man->last->type == ROFFT_TEXT && 133 ((ep = man_hasc(man->last->string)) != NULL)) { 134 *ep = '\0'; 135 return 1; 136 } 137 mandoc_msg(MANDOCERR_FI_BLANK, line, i, NULL); 138 roff_elem_alloc(man, line, offs, ROFF_sp); 139 man->next = ROFF_NEXT_SIBLING; 140 return 1; 141 } 142 143 /* 144 * Warn if the last un-escaped character is whitespace. Then 145 * strip away the remaining spaces (tabs stay!). 146 */ 147 148 i = (int)strlen(buf); 149 assert(i); 150 151 if (' ' == buf[i - 1] || '\t' == buf[i - 1]) { 152 if (i > 1 && '\\' != buf[i - 2]) 153 mandoc_msg(MANDOCERR_SPACE_EOL, line, i - 1, NULL); 154 155 for (--i; i && ' ' == buf[i]; i--) 156 /* Spin back to non-space. */ ; 157 158 /* Jump ahead of escaped whitespace. */ 159 i += '\\' == buf[i] ? 2 : 1; 160 161 buf[i] = '\0'; 162 } 163 roff_word_alloc(man, line, offs, buf + offs); 164 165 /* 166 * End-of-sentence check. If the last character is an unescaped 167 * EOS character, then flag the node as being the end of a 168 * sentence. The front-end will know how to interpret this. 169 */ 170 171 assert(i); 172 if (mandoc_eos(buf, (size_t)i)) 173 man->last->flags |= NODE_EOS; 174 175 man_descope(man, line, offs, buf + offs); 176 return 1; 177 } 178 179 static int 180 man_pmacro(struct roff_man *man, int ln, char *buf, int offs) 181 { 182 struct roff_node *n; 183 const char *cp; 184 size_t sz; 185 enum roff_tok tok; 186 int ppos; 187 int bline; 188 189 /* Determine the line macro. */ 190 191 ppos = offs; 192 tok = TOKEN_NONE; 193 for (sz = 0; sz < 4 && strchr(" \t\\", buf[offs]) == NULL; sz++) 194 offs++; 195 if (sz > 0 && sz < 4) 196 tok = roffhash_find(man->manmac, buf + ppos, sz); 197 if (tok == TOKEN_NONE) { 198 mandoc_msg(MANDOCERR_MACRO, ln, ppos, "%s", buf + ppos - 1); 199 return 1; 200 } 201 202 /* Skip a leading escape sequence or tab. */ 203 204 switch (buf[offs]) { 205 case '\\': 206 cp = buf + offs + 1; 207 mandoc_escape(&cp, NULL, NULL); 208 offs = cp - buf; 209 break; 210 case '\t': 211 offs++; 212 break; 213 default: 214 break; 215 } 216 217 /* Jump to the next non-whitespace word. */ 218 219 while (buf[offs] == ' ') 220 offs++; 221 222 /* 223 * Trailing whitespace. Note that tabs are allowed to be passed 224 * into the parser as "text", so we only warn about spaces here. 225 */ 226 227 if (buf[offs] == '\0' && buf[offs - 1] == ' ') 228 mandoc_msg(MANDOCERR_SPACE_EOL, ln, offs - 1, NULL); 229 230 /* 231 * Some macros break next-line scopes; otherwise, remember 232 * whether we are in next-line scope for a block head. 233 */ 234 235 man_breakscope(man, tok); 236 bline = man->flags & MAN_BLINE; 237 238 /* 239 * If the line in next-line scope ends with \c, keep the 240 * next-line scope open for the subsequent input line. 241 * That is not at all portable, only groff >= 1.22.4 242 * does it, but *if* this weird idiom occurs in a manual 243 * page, that's very likely what the author intended. 244 */ 245 246 if (bline && man_hasc(buf + offs)) 247 bline = 0; 248 249 /* Call to handler... */ 250 251 (*man_macro(tok)->fp)(man, tok, ln, ppos, &offs, buf); 252 253 /* In quick mode (for mandocdb), abort after the NAME section. */ 254 255 if (man->quick && tok == MAN_SH) { 256 n = man->last; 257 if (n->type == ROFFT_BODY && 258 strcmp(n->prev->child->string, "NAME")) 259 return 2; 260 } 261 262 /* 263 * If we are in a next-line scope for a block head, 264 * close it out now and switch to the body, 265 * unless the next-line scope is allowed to continue. 266 */ 267 268 if (bline == 0 || 269 (man->flags & MAN_BLINE) == 0 || 270 man->flags & MAN_ELINE || 271 man_macro(tok)->flags & MAN_NSCOPED) 272 return 1; 273 274 man_unscope(man, man->last->parent); 275 roff_body_alloc(man, ln, ppos, man->last->tok); 276 man->flags &= ~(MAN_BLINE | ROFF_NONOFILL); 277 return 1; 278 } 279 280 /* 281 * Rewind open next-line scopes 282 * unless the tok request or macro is allowed inside them. 283 */ 284 void 285 man_breakscope(struct roff_man *man, int tok) 286 { 287 struct roff_node *n; 288 289 /* 290 * An element next line scope is open, 291 * and the new macro is not allowed inside elements. 292 * Delete the element that is being broken. 293 */ 294 295 if (man->flags & MAN_ELINE && (tok < MAN_TH || 296 (man_macro(tok)->flags & MAN_NSCOPED) == 0)) { 297 n = man->last; 298 if (n->type == ROFFT_TEXT) 299 n = n->parent; 300 if (n->tok < MAN_TH || 301 (man_macro(n->tok)->flags & (MAN_NSCOPED | MAN_ESCOPED)) 302 == MAN_NSCOPED) 303 n = n->parent; 304 for (;;) { 305 mandoc_msg(MANDOCERR_BLK_LINE, n->line, n->pos, 306 "%s breaks %s", roff_name[tok], roff_name[n->tok]); 307 if (n->parent->type != ROFFT_ELEM || 308 (man_macro(n->parent->tok)->flags & 309 MAN_ESCOPED) == 0) 310 break; 311 n = n->parent; 312 } 313 roff_node_delete(man, n); 314 man->flags &= ~MAN_ELINE; 315 } 316 317 /* 318 * Weird special case: 319 * Switching fill mode closes section headers. 320 */ 321 322 if (man->flags & MAN_BLINE && 323 (tok == ROFF_nf || tok == ROFF_fi) && 324 (man->last->tok == MAN_SH || man->last->tok == MAN_SS)) { 325 n = man->last; 326 man_unscope(man, n); 327 roff_body_alloc(man, n->line, n->pos, n->tok); 328 man->flags &= ~(MAN_BLINE | ROFF_NONOFILL); 329 } 330 331 /* 332 * A block header next line scope is open, 333 * and the new macro is not allowed inside block headers. 334 * Delete the block that is being broken. 335 */ 336 337 if (man->flags & MAN_BLINE && tok != ROFF_nf && tok != ROFF_fi && 338 (tok < MAN_TH || man_macro(tok)->flags & MAN_XSCOPE)) { 339 n = man->last; 340 if (n->type == ROFFT_TEXT) 341 n = n->parent; 342 if (n->tok < MAN_TH || 343 (man_macro(n->tok)->flags & MAN_XSCOPE) == 0) 344 n = n->parent; 345 346 assert(n->type == ROFFT_HEAD); 347 n = n->parent; 348 assert(n->type == ROFFT_BLOCK); 349 assert(man_macro(n->tok)->flags & MAN_BSCOPED); 350 351 mandoc_msg(MANDOCERR_BLK_LINE, n->line, n->pos, 352 "%s breaks %s", roff_name[tok], roff_name[n->tok]); 353 354 roff_node_delete(man, n); 355 man->flags &= ~(MAN_BLINE | ROFF_NONOFILL); 356 } 357 } 358