| blob | efb48d023f83c1c75a326cc960655c062d0593f9 |
1 /* $Id: mdoc_macro.c,v 1.183 2015/02/12 12:24:33 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010, 2012-2015 Ingo Schwarze <schwarze@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
20 #include <sys/types.h>
22 #include <assert.h>
23 #include <ctype.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <time.h>
199 };
204 /*
205 * This is called at the end of parsing. It must traverse up the tree,
206 * closing out open [implicit] scopes. Obviously, open explicit scopes
207 * are errors.
208 */
209 void
211 {
214 /* Scan for open explicit scopes. */
225 /* Rewind to the first. */
228 }
230 /*
231 * Look up the macro at *p called by "from",
232 * or as a line macro if from == MDOC_MAX.
233 */
234 static enum mdoct
236 {
247 }
248 }
250 }
252 /*
253 * Rewind up to and including a specific node.
254 */
255 static void
257 {
263 /*
264 * Save the parent here, because we may delete the
265 * mdoc->last node in the post-validation phase and reset
266 * it to mdoc->last->parent, causing a step in the closing
267 * out to be lost.
268 */
275 }
277 }
279 /*
280 * Rewind up to a specific block, including all blocks that broke it.
281 */
282 static void
284 {
297 }
310 else
312 }
313 }
314 }
315 }
317 /*
318 * For a block closing macro, return the corresponding opening one.
319 * Otherwise, return the macro itself.
320 */
321 static enum mdoct
323 {
359 }
360 /* NOTREACHED */
361 }
363 static void
365 {
374 }
376 /*
377 * Allocate a word and check whether it's punctuation or not.
378 * Punctuation consists of those tokens found in mdoc_isdelim().
379 */
380 static void
383 {
394 }
398 /*
399 * If the word consists of a bare delimiter,
400 * flag the new node accordingly,
401 * unless doing so was vetoed by the invoking macro.
402 * Always clear the veto, it is only valid for one word.
403 */
412 }
414 static void
416 {
429 /*
430 * If we encounter end-of-sentence symbols, then trigger
431 * the double-space.
432 *
433 * XXX: it's easy to allow this to propagate outward to
434 * the last symbol, such that `. )' will cause the
435 * correct double-spacing. However, (1) groff isn't
436 * smart enough to do this and (2) it would require
437 * knowing which symbols break this behaviour, for
438 * example, `. ;' shouldn't propagate the double-space.
439 */
443 }
444 }
446 /*
447 * Parse one word.
448 * If it is a macro, call it and return 1.
449 * Otherwise, allocate it and return 0.
450 */
451 static int
453 {
460 p++;
475 }
476 }
478 /*
479 * Close out block partial/full explicit.
480 */
481 static void
483 {
503 /* FALLTHROUGH */
507 }
509 /*
510 * Search backwards for beginnings of blocks,
511 * both of our own and of pending sub-blocks.
512 */
521 }
523 /* Remember the start of our own body. */
529 }
537 }
542 /*
543 * Found the start of our own block.
544 * When there is no pending sub block,
545 * just proceed to closing out.
546 */
552 /*
553 * When there is a pending sub block, postpone
554 * closing out the current block until the
555 * rew_pending() closing out the sub-block.
556 * Mark the place where the formatting - but not
557 * the scope - of the current block ends.
558 */
571 /*
572 * If a block closing macro taking arguments
573 * breaks another block, put the arguments
574 * into the end marker.
575 */
580 }
582 /* Explicit blocks close out description lines. */
587 }
589 /* Breaking an open sub block. */
594 }
600 /*
601 * Stray .Ec without previous .Eo:
602 * Break the output line, keep the arguments.
603 */
606 }
611 }
622 }
632 }
645 }
650 }
654 }
660 }
662 static void
664 {
674 /*
675 * Whether we allow ignored elements (those without content,
676 * usually because of reserved words) to squeak by.
677 */
681 /* FALLTHROUGH */
683 /* FALLTHROUGH */
685 /* FALLTHROUGH */
687 /* FALLTHROUGH */
689 /* FALLTHROUGH */
696 }
707 /*
708 * At the end of a macro line,
709 * opening delimiters do not suppress spacing.
710 */
716 }
718 /*
719 * The rest of the macro line is only punctuation,
720 * to be handled by append_delims().
721 * If there were no other arguments,
722 * do not allow the first one to suppress spacing,
723 * even if it turns out to be a closing one.
724 */
730 }
735 /*
736 * In this case, we've located a submacro and must
737 * execute it. Close out scope, if open. If no
738 * elements have been generated, either create one (nc)
739 * or raise a warning.
740 */
753 }
758 }
760 /*
761 * Non-quote-enclosed punctuation. Set up our scope, if
762 * a word; rewind the scope, if a delimiter; then append
763 * the word.
764 */
769 /*
770 * If we encounter closing punctuation, no word
771 * has been emitted, no scope is open, and we're
772 * allowed to have an empty element, then start
773 * a new scope.
774 */
780 cnt++;
783 }
784 /*
785 * Close out our scope, if one is open, before
786 * any punctuation.
787 */
796 cnt++;
797 }
802 /*
803 * If the first argument is a closing delimiter,
804 * do not suppress spacing before it.
805 */
811 /*
812 * `Fl' macros have their scope re-opened with each new
813 * word so that the `-' can be added to each one without
814 * having to parse out spaces.
815 */
819 }
820 }
825 /*
826 * If no elements have been collected and we're allowed to have
827 * empties (nc), open a scope and close it out. Otherwise,
828 * raise a warning.
829 */
839 }
840 }
843 }
845 static void
847 {
863 }
867 /* Here, tok is one of Sh Ss Nm Nd It. */
875 }
886 }
888 }
893 /* FALLTHROUGH */
904 /* Delay in case it's astray. */
909 }
911 }
913 /* Here, n is one of Sh Ss Nm Nd It. */
920 /* Item breaking an explicit block. */
929 }
931 /* Close out prior implicit scopes. */
934 }
936 /* Skip items outside lists. */
944 }
945 }
947 /*
948 * This routine accommodates implicitly- and explicitly-scoped
949 * macro openings. Implicit ones first close out prior scope
950 * (seen above). Delay opening the head until necessary to
951 * allow leading punctuation to print. Special consideration
952 * for `It -column', which has phrase-part syntax instead of
953 * regular child nodes.
954 */
960 /*
961 * Exception: Heads of `It' macros in `-diag' lists are not
962 * parsed, even though `It' macros in general are parsed.
963 */
969 /*
970 * The `Nd' macro has all arguments in its body: it's a hybrid
971 * of block partial-explicit and full-implicit. Stupid.
972 */
978 }
991 /*
992 * This is necessary: if the last token on a
993 * line is a `Ta' or tab, then we'll get
994 * ARGS_EOLN, so we must be smart enough to
995 * reopen our scope if the last parse was a
996 * phrase or partial phrase.
997 */
1002 }
1008 }
1013 }
1017 /*
1018 * Emit leading punctuation (i.e., punctuation before
1019 * the MDOC_HEAD) for non-phrase types.
1020 */
1030 }
1032 /* Open a head if one hasn't been opened. */
1041 /*
1042 * If we haven't opened a body yet, rewind the
1043 * head; if we have, rewind that instead.
1044 */
1049 /*
1050 * Process phrases: set whether we're in a
1051 * partial-phrase (this effects line handling)
1052 * then call down into the phrase parser.
1053 */
1062 }
1066 }
1077 /*
1078 * If there is an open (i.e., unvalidated) sub-block requiring
1079 * explicit close-out, postpone switching the current block from
1080 * head to body until the rew_pending() call closing out that
1081 * sub-block.
1082 */
1088 }
1093 }
1094 }
1098 /* Close out scopes to remain in a consistent state. */
1102 out:
1107 }
1108 }
1110 static void
1112 {
1122 /*
1123 * A macro that spans to the end of the line. This is generally
1124 * (but not necessarily) called as the first macro. The block
1125 * has a head as the immediate child, which is always empty,
1126 * followed by zero or more opening punctuation nodes, then the
1127 * body (which may be empty, depending on the macro), then zero
1128 * or more closing punctuation nodes.
1129 */
1134 /*
1135 * Open the body scope "on-demand", that is, after we've
1136 * processed all our the leading delimiters (open parenthesis,
1137 * etc.).
1138 */
1150 }
1157 }
1161 /*
1162 * If there is an open sub-block requiring explicit close-out,
1163 * postpone closing out the current block until the
1164 * rew_pending() call closing out the sub-block.
1165 */
1173 }
1184 }
1185 }
1186 }
1196 /* Move trailing .Ns out of scope. */
1202 }
1204 static void
1206 {
1214 /*
1215 * The opening of an explicit macro having zero or more leading
1216 * punctuation nodes; a head with optional single element (the
1217 * case of `Eo'); and a body that may be empty.
1218 */
1228 /* Flush out leading punctuation. */
1234 }
1244 }
1248 }
1250 /* Clean-up to leave in a consistent state. */
1255 }
1258 }
1260 static void
1262 {
1272 /*
1273 * A line macro that has a fixed number of arguments (maxargs).
1274 * Only open the scope once the first non-leading-punctuation is
1275 * found (unless MDOC_IGNDELIM is noted, like in `Pf'), then
1276 * keep it open until the maximum number of arguments are
1277 * exhausted.
1278 */
1282 /* FALLTHROUGH */
1284 /* FALLTHROUGH */
1289 /* FALLTHROUGH */
1291 /* FALLTHROUGH */
1298 }
1313 }
1319 }
1327 }
1332 }
1341 }
1344 }
1353 state++;
1357 }
1361 }
1367 }
1375 }
1377 static void
1379 {
1390 }
1397 }
1404 }
1406 /*
1407 * The simplest argument parser available: Parse the remaining
1408 * words until the end of the phrase or line and return 0
1409 * or until the next macro, call that macro, and return 1.
1410 */
1411 static int
1413 {
1422 }
1423 }
1425 static void
1427 {
1436 }
1437 }
1439 /*
1440 * Phrases occur within `Bl -column' entries, separated by `Ta' or tabs.
1441 * They're unusual because they're basically free-form text until a
1442 * macro is encountered.
1443 */
1444 static void
1446 {
1449 /* Make sure we are in a column list or ignore this macro. */
1459 }
1465 }
1467 /* Advance to the next column. */
1472 }