2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 /* Associates PTR (which can be a string, etc.) with the file location
27 specified by FILENAME and LINENO. */
34 /* A singly-linked list of filenames. */
35 struct file_name_list
{
36 struct file_name_list
*next
;
40 /* Obstack used for allocating MD strings. */
41 struct obstack string_obstack
;
43 /* A table of ptr_locs, hashed on the PTR field. */
44 static htab_t ptr_locs
;
46 /* An obstack for the above. Plain xmalloc is a bit heavyweight for a
47 small structure like ptr_loc. */
48 static struct obstack ptr_loc_obstack
;
50 /* A hash table of triples (A, B, C), where each of A, B and C is a condition
51 and A is equivalent to "B && C". This is used to keep track of the source
52 of conditions that are made up of separate MD strings (such as the split
53 condition of a define_insn_and_split). */
54 static htab_t joined_conditions
;
56 /* An obstack for allocating joined_conditions entries. */
57 static struct obstack joined_conditions_obstack
;
59 /* The file we are reading. */
62 /* The filename of READ_MD_FILE. */
63 const char *read_md_filename
;
65 /* The current line number in READ_MD_FILE. */
68 /* The name of the toplevel file that indirectly included READ_MD_FILE. */
71 /* The directory part of IN_FNAME. NULL if IN_FNAME is a bare filename. */
72 static char *base_dir
;
74 /* The first directory to search. */
75 static struct file_name_list
*first_dir_md_include
;
77 /* A pointer to the null terminator of the md include chain. */
78 static struct file_name_list
**last_dir_md_include_ptr
= &first_dir_md_include
;
80 /* This callback will be invoked whenever an md include directive is
81 processed. To be used for creation of the dependency file. */
82 void (*include_callback
) (const char *);
84 /* The current maximum length of directory names in the search path
85 for include files. (Altered as we get more of them.) */
86 static size_t max_include_len
;
88 /* A table of md_constant structures, hashed by name. Null if no
89 constant expansion should occur. */
90 static htab_t md_constants
;
92 /* A table of enum_type structures, hashed by name. */
93 static htab_t enum_types
;
95 static void handle_file (directive_handler_t
);
97 /* Given an object that starts with a char * name field, return a hash
101 leading_string_hash (const void *def
)
103 return htab_hash_string (*(const char *const *) def
);
106 /* Given two objects that start with char * name fields, return true if
107 they have the same name. */
110 leading_string_eq_p (const void *def1
, const void *def2
)
112 return strcmp (*(const char *const *) def1
,
113 *(const char *const *) def2
) == 0;
116 /* Return a hash value for the pointer pointed to by DEF. */
119 leading_ptr_hash (const void *def
)
121 return htab_hash_pointer (*(const void *const *) def
);
124 /* Return true if DEF1 and DEF2 are pointers to the same pointer. */
127 leading_ptr_eq_p (const void *def1
, const void *def2
)
129 return *(const void *const *) def1
== *(const void *const *) def2
;
132 /* Associate PTR with the file position given by FILENAME and LINENO. */
135 set_md_ptr_loc (const void *ptr
, const char *filename
, int lineno
)
139 loc
= (struct ptr_loc
*) obstack_alloc (&ptr_loc_obstack
,
140 sizeof (struct ptr_loc
));
142 loc
->filename
= filename
;
143 loc
->lineno
= lineno
;
144 *htab_find_slot (ptr_locs
, loc
, INSERT
) = loc
;
147 /* Return the position associated with pointer PTR. Return null if no
150 static const struct ptr_loc
*
151 get_md_ptr_loc (const void *ptr
)
153 return (const struct ptr_loc
*) htab_find (ptr_locs
, &ptr
);
156 /* Associate NEW_PTR with the same file position as OLD_PTR. */
159 copy_md_ptr_loc (const void *new_ptr
, const void *old_ptr
)
161 const struct ptr_loc
*loc
= get_md_ptr_loc (old_ptr
);
163 set_md_ptr_loc (new_ptr
, loc
->filename
, loc
->lineno
);
166 /* If PTR is associated with a known file position, print a #line
167 directive for it to OUTF. */
170 fprint_md_ptr_loc (FILE *outf
, const void *ptr
)
172 const struct ptr_loc
*loc
= get_md_ptr_loc (ptr
);
174 fprintf (outf
, "#line %d \"%s\"\n", loc
->lineno
, loc
->filename
);
177 /* Special fprint_md_ptr_loc for writing to STDOUT. */
179 print_md_ptr_loc (const void *ptr
)
181 fprint_md_ptr_loc (stdout
, ptr
);
184 /* Return a condition that satisfies both COND1 and COND2. Either string
185 may be null or empty. */
188 join_c_conditions (const char *cond1
, const char *cond2
)
193 if (cond1
== 0 || cond1
[0] == 0)
196 if (cond2
== 0 || cond2
[0] == 0)
199 if (strcmp (cond1
, cond2
) == 0)
202 result
= concat ("(", cond1
, ") && (", cond2
, ")", NULL
);
203 obstack_ptr_grow (&joined_conditions_obstack
, result
);
204 obstack_ptr_grow (&joined_conditions_obstack
, cond1
);
205 obstack_ptr_grow (&joined_conditions_obstack
, cond2
);
206 entry
= XOBFINISH (&joined_conditions_obstack
, const void **);
207 *htab_find_slot (joined_conditions
, entry
, INSERT
) = entry
;
211 /* Print condition COND to OUTF, wrapped in brackets. If COND was created
212 by join_c_conditions, recursively invoke this function for the original
213 conditions and join the result with "&&". Otherwise print a #line
214 directive for COND if its original file position is known. */
217 fprint_c_condition (FILE *outf
, const char *cond
)
219 const char **halves
= (const char **) htab_find (joined_conditions
, &cond
);
223 fprint_c_condition (outf
, halves
[1]);
224 fprintf (outf
, " && ");
225 fprint_c_condition (outf
, halves
[2]);
231 fprint_md_ptr_loc (outf
, cond
);
232 fprintf (outf
, "(%s)", cond
);
236 /* Special fprint_c_condition for writing to STDOUT. */
239 print_c_condition (const char *cond
)
241 fprint_c_condition (stdout
, cond
);
244 /* A vfprintf-like function for reporting an error against line LINENO
245 of the current MD file. */
247 static void ATTRIBUTE_PRINTF(2,0)
248 message_at_1 (file_location loc
, const char *msg
, va_list ap
)
250 fprintf (stderr
, "%s:%d: ", loc
.filename
, loc
.lineno
);
251 vfprintf (stderr
, msg
, ap
);
252 fputc ('\n', stderr
);
255 /* A printf-like function for reporting a message against location LOC. */
258 message_at (file_location loc
, const char *msg
, ...)
263 message_at_1 (loc
, msg
, ap
);
267 /* Like message_at, but treat the condition as an error. */
270 error_at (file_location loc
, const char *msg
, ...)
275 message_at_1 (loc
, msg
, ap
);
280 /* Like message_at, but treat the condition as a fatal error. */
283 fatal_at (file_location loc
, const char *msg
, ...)
288 message_at_1 (loc
, msg
, ap
);
293 /* A printf-like function for reporting an error against the current
294 position in the MD file. */
297 fatal_with_file_and_line (const char *msg
, ...)
306 fprintf (stderr
, "%s:%d: ", read_md_filename
, read_md_lineno
);
307 vfprintf (stderr
, msg
, ap
);
310 /* Gather some following context. */
311 for (i
= 0; i
< sizeof (context
)-1; ++i
)
316 if (c
== '\r' || c
== '\n')
325 fprintf (stderr
, "%s:%d: following context is `%s'\n",
326 read_md_filename
, read_md_lineno
, context
);
332 /* Report that we found character ACTUAL when we expected to find
333 character EXPECTED. */
336 fatal_expected_char (int expected
, int actual
)
339 fatal_with_file_and_line ("expected character `%c', found EOF",
342 fatal_with_file_and_line ("expected character `%c', found `%c'",
346 /* Read chars from the MD file until a non-whitespace char and return that.
347 Comments, both Lisp style and C style, are treated as whitespace. */
350 read_skip_spaces (void)
359 case ' ': case '\t': case '\f': case '\r': case '\n':
365 while (c
!= '\n' && c
!= EOF
);
375 fatal_with_file_and_line ("stray '/' in file");
379 while ((c
= read_char ()) && c
!= EOF
)
381 if (prevc
== '*' && c
== '/')
394 /* Consume any whitespace, then consume the next non-whitespace
395 character, issuing a fatal error if it is not EXPECTED. */
398 require_char_ws (char expected
)
400 int ch
= read_skip_spaces ();
402 fatal_expected_char (expected
, ch
);
405 /* Read an rtx code name into NAME. It is terminated by any of the
406 punctuation chars of rtx printed syntax. */
409 read_name (struct md_name
*name
)
413 int angle_bracket_depth
;
415 c
= read_skip_spaces ();
418 angle_bracket_depth
= 0;
422 angle_bracket_depth
++;
424 if ((c
== '>') && (angle_bracket_depth
> 0))
425 angle_bracket_depth
--;
427 if (c
== ' ' || c
== '\n' || c
== '\t' || c
== '\f' || c
== '\r'
430 if (angle_bracket_depth
== 0)
432 if (c
== ':' || c
== ')' || c
== ']'
433 || c
== '"' || c
== '/' || c
== '(' || c
== '[')
440 if (i
== sizeof (name
->buffer
) - 1)
441 fatal_with_file_and_line ("name too long");
442 name
->buffer
[i
++] = c
;
448 fatal_with_file_and_line ("missing name or number");
451 name
->string
= name
->buffer
;
455 /* Do constant expansion. */
456 struct md_constant
*def
;
460 struct md_constant tmp_def
;
462 tmp_def
.name
= name
->string
;
463 def
= (struct md_constant
*) htab_find (md_constants
, &tmp_def
);
465 name
->string
= def
->value
;
471 /* Subroutine of the string readers. Handles backslash escapes.
472 Caller has read the backslash, but not placed it into the obstack. */
477 int c
= read_char ();
481 /* Backslash-newline is replaced by nothing, as in C. */
485 /* \" \' \\ are replaced by the second character. */
491 /* Standard C string escapes:
494 all are passed through to the output string unmolested.
495 In normal use these wind up in a string constant processed
496 by the C compiler, which will translate them appropriately.
497 We do not bother checking that \[0-7] are followed by up to
498 two octal digits, or that \x is followed by N hex digits.
499 \? \u \U are left out because they are not in traditional C. */
500 case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
501 case '0': case '1': case '2': case '3': case '4': case '5': case '6':
503 obstack_1grow (&string_obstack
, '\\');
506 /* \; makes stuff for a C string constant containing
509 obstack_grow (&string_obstack
, "\\n\\t", 4);
512 /* pass anything else through, but issue a warning. */
514 fprintf (stderr
, "%s:%d: warning: unrecognized escape \\%c\n",
515 read_md_filename
, read_md_lineno
, c
);
516 obstack_1grow (&string_obstack
, '\\');
520 obstack_1grow (&string_obstack
, c
);
523 /* Read a double-quoted string onto the obstack. Caller has scanned
524 the leading quote. */
527 read_quoted_string (void)
533 c
= read_char (); /* Read the string */
539 else if (c
== '"' || c
== EOF
)
542 obstack_1grow (&string_obstack
, c
);
545 obstack_1grow (&string_obstack
, 0);
546 return XOBFINISH (&string_obstack
, char *);
549 /* Read a braced string (a la Tcl) onto the string obstack. Caller
550 has scanned the leading brace. Note that unlike quoted strings,
551 the outermost braces _are_ included in the string constant. */
554 read_braced_string (void)
557 int brace_depth
= 1; /* caller-processed */
558 unsigned long starting_read_md_lineno
= read_md_lineno
;
560 obstack_1grow (&string_obstack
, '{');
563 c
= read_char (); /* Read the string */
575 fatal_with_file_and_line
576 ("missing closing } for opening brace on line %lu",
577 starting_read_md_lineno
);
579 obstack_1grow (&string_obstack
, c
);
582 obstack_1grow (&string_obstack
, 0);
583 return XOBFINISH (&string_obstack
, char *);
586 /* Read some kind of string constant. This is the high-level routine
587 used by read_rtx. It handles surrounding parentheses, leading star,
588 and dispatch to the appropriate string constant reader. */
591 read_string (int star_if_braced
)
597 c
= read_skip_spaces ();
601 c
= read_skip_spaces ();
604 old_lineno
= read_md_lineno
;
606 stringbuf
= read_quoted_string ();
610 obstack_1grow (&string_obstack
, '*');
611 stringbuf
= read_braced_string ();
614 fatal_with_file_and_line ("expected `\"' or `{', found `%c'", c
);
617 require_char_ws (')');
619 set_md_ptr_loc (stringbuf
, read_md_filename
, old_lineno
);
623 /* Skip the rest of a construct that started at line LINENO and that
624 is currently nested by DEPTH levels of parentheses. */
627 read_skip_construct (int depth
, file_location loc
)
634 c
= read_skip_spaces ();
637 error_at (loc
, "unterminated construct");
672 /* Given a string, return the number of comma-separated elements in it.
673 Return 0 for the null string. */
676 n_comma_elts (const char *s
)
690 /* Given a pointer to a (char *), return a pointer to the beginning of the
691 next comma-separated element in the string. Advance the pointer given
692 to the end of that element. Return NULL if at end of string. Caller
693 is responsible for copying the string if necessary. White space between
694 a comma and an element is ignored. */
697 scan_comma_elt (const char **pstr
)
700 const char *p
= *pstr
;
712 while (*p
!= ',' && *p
!= '\0')
719 /* Convert STRING to uppercase. */
722 upcase_string (char *string
)
726 for (i
= 0; string
[i
]; i
++)
727 string
[i
] = TOUPPER (string
[i
]);
730 /* Add a NAME = VALUE definition to md_constants-style hash table DEFS,
731 where both NAME and VALUE are malloc()ed strings. PARENT_ENUM is the
732 enum to which NAME belongs, or null if NAME is a stand-alone constant. */
734 static struct md_constant
*
735 add_constant (htab_t defs
, char *name
, char *value
,
736 struct enum_type
*parent_enum
)
738 struct md_constant
*def
, tmp_def
;
742 entry_ptr
= htab_find_slot (defs
, &tmp_def
, INSERT
);
745 def
= (struct md_constant
*) *entry_ptr
;
746 if (strcmp (def
->value
, value
) != 0)
747 fatal_with_file_and_line ("redefinition of `%s', was `%s', now `%s'",
748 def
->name
, def
->value
, value
);
749 else if (parent_enum
|| def
->parent_enum
)
750 fatal_with_file_and_line ("redefinition of `%s'", def
->name
);
756 def
= XNEW (struct md_constant
);
759 def
->parent_enum
= parent_enum
;
765 /* Process a define_constants directive, starting with the optional space
766 after the "define_constants". */
769 handle_constants (void)
774 require_char_ws ('[');
776 /* Disable constant expansion during definition processing. */
779 while ( (c
= read_skip_spaces ()) != ']')
781 struct md_name name
, value
;
784 fatal_expected_char ('(', c
);
788 add_constant (defs
, xstrdup (name
.string
), xstrdup (value
.string
), 0);
790 require_char_ws (')');
795 /* For every constant definition, call CALLBACK with two arguments:
796 a pointer a pointer to the constant definition and INFO.
797 Stop when CALLBACK returns zero. */
800 traverse_md_constants (htab_trav callback
, void *info
)
802 htab_traverse (md_constants
, callback
, info
);
805 /* Return a malloc()ed decimal string that represents number NUMBER. */
808 md_decimal_string (int number
)
810 /* A safe overestimate. +1 for sign, +1 for null terminator. */
811 char buffer
[sizeof (int) * CHAR_BIT
+ 1 + 1];
813 sprintf (buffer
, "%d", number
);
814 return xstrdup (buffer
);
817 /* Process a define_enum or define_c_enum directive, starting with
818 the optional space after the "define_enum". LINENO is the line
819 number on which the directive started and MD_P is true if the
820 directive is a define_enum rather than a define_c_enum. */
823 handle_enum (file_location loc
, bool md_p
)
825 char *enum_name
, *value_name
;
827 struct enum_type
*def
;
828 struct enum_value
*ev
;
832 enum_name
= read_string (false);
833 slot
= htab_find_slot (enum_types
, &enum_name
, INSERT
);
836 def
= (struct enum_type
*) *slot
;
837 if (def
->md_p
!= md_p
)
838 error_at (loc
, "redefining `%s' as a different type of enum",
843 def
= XNEW (struct enum_type
);
844 def
->name
= enum_name
;
847 def
->tail_ptr
= &def
->values
;
852 require_char_ws ('[');
854 while ((c
= read_skip_spaces ()) != ']')
858 error_at (loc
, "unterminated construct");
864 ev
= XNEW (struct enum_value
);
868 value_name
= concat (def
->name
, "_", name
.string
, NULL
);
869 upcase_string (value_name
);
870 ev
->name
= xstrdup (name
.string
);
874 value_name
= xstrdup (name
.string
);
875 ev
->name
= value_name
;
877 ev
->def
= add_constant (md_constants
, value_name
,
878 md_decimal_string (def
->num_values
), def
);
881 def
->tail_ptr
= &ev
->next
;
886 /* Try to find the definition of the given enum. Return null on failure. */
889 lookup_enum_type (const char *name
)
891 return (struct enum_type
*) htab_find (enum_types
, &name
);
894 /* For every enum definition, call CALLBACK with two arguments:
895 a pointer to the constant definition and INFO. Stop when CALLBACK
899 traverse_enum_types (htab_trav callback
, void *info
)
901 htab_traverse (enum_types
, callback
, info
);
904 /* Process an "include" directive, starting with the optional space
905 after the "include". Read in the file and use HANDLE_DIRECTIVE
906 to process each unknown directive. LINENO is the line number on
907 which the "include" occurred. */
910 handle_include (file_location loc
, directive_handler_t handle_directive
)
912 const char *filename
;
913 const char *old_filename
;
916 FILE *input_file
, *old_file
;
918 filename
= read_string (false);
921 /* If the specified file name is absolute, skip the include stack. */
922 if (!IS_ABSOLUTE_PATH (filename
))
924 struct file_name_list
*stackp
;
926 /* Search the directory path, trying to open the file. */
927 for (stackp
= first_dir_md_include
; stackp
; stackp
= stackp
->next
)
929 static const char sep
[2] = { DIR_SEPARATOR
, '\0' };
931 pathname
= concat (stackp
->fname
, sep
, filename
, NULL
);
932 input_file
= fopen (pathname
, "r");
933 if (input_file
!= NULL
)
939 /* If we haven't managed to open the file yet, try combining the
940 filename with BASE_DIR. */
941 if (input_file
== NULL
)
944 pathname
= concat (base_dir
, filename
, NULL
);
946 pathname
= xstrdup (filename
);
947 input_file
= fopen (pathname
, "r");
950 if (input_file
== NULL
)
953 error_at (loc
, "include file `%s' not found", filename
);
957 /* Save the old cursor. Note that the LINENO argument to this
958 function is the beginning of the include statement, while
959 read_md_lineno has already been advanced. */
960 old_file
= read_md_file
;
961 old_filename
= read_md_filename
;
962 old_lineno
= read_md_lineno
;
964 if (include_callback
)
965 include_callback (pathname
);
967 read_md_file
= input_file
;
968 read_md_filename
= pathname
;
969 handle_file (handle_directive
);
971 /* Restore the old cursor. */
972 read_md_file
= old_file
;
973 read_md_filename
= old_filename
;
974 read_md_lineno
= old_lineno
;
976 /* Do not free the pathname. It is attached to the various rtx
980 /* Process the current file, assuming that read_md_file and
981 read_md_filename are valid. Use HANDLE_DIRECTIVE to handle
982 unknown directives. */
985 handle_file (directive_handler_t handle_directive
)
987 struct md_name directive
;
991 while ((c
= read_skip_spaces ()) != EOF
)
993 file_location
loc (read_md_filename
, read_md_lineno
);
995 fatal_expected_char ('(', c
);
997 read_name (&directive
);
998 if (strcmp (directive
.string
, "define_constants") == 0)
1000 else if (strcmp (directive
.string
, "define_enum") == 0)
1001 handle_enum (loc
, true);
1002 else if (strcmp (directive
.string
, "define_c_enum") == 0)
1003 handle_enum (loc
, false);
1004 else if (strcmp (directive
.string
, "include") == 0)
1005 handle_include (loc
, handle_directive
);
1006 else if (handle_directive
)
1007 handle_directive (loc
, directive
.string
);
1009 read_skip_construct (1, loc
);
1011 require_char_ws (')');
1013 fclose (read_md_file
);
1016 /* Like handle_file, but for top-level files. Set up in_fname and
1017 base_dir accordingly. */
1020 handle_toplevel_file (directive_handler_t handle_directive
)
1024 in_fname
= read_md_filename
;
1025 base
= lbasename (in_fname
);
1026 if (base
== in_fname
)
1029 base_dir
= xstrndup (in_fname
, base
- in_fname
);
1031 handle_file (handle_directive
);
1034 /* Parse a -I option with argument ARG. */
1037 parse_include (const char *arg
)
1039 struct file_name_list
*dirtmp
;
1041 dirtmp
= XNEW (struct file_name_list
);
1043 dirtmp
->fname
= arg
;
1044 *last_dir_md_include_ptr
= dirtmp
;
1045 last_dir_md_include_ptr
= &dirtmp
->next
;
1046 if (strlen (dirtmp
->fname
) > max_include_len
)
1047 max_include_len
= strlen (dirtmp
->fname
);
1050 /* The main routine for reading .md files. Try to process all the .md
1051 files specified on the command line and return true if no error occurred.
1053 ARGC and ARGV are the arguments to main.
1055 PARSE_OPT, if nonnull, is passed all unknown command-line arguments.
1056 It should return true if it recognizes the argument or false if a
1057 generic error should be reported.
1059 If HANDLE_DIRECTIVE is nonnull, the parser calls it for each
1060 unknown directive, otherwise it just skips such directives.
1061 See the comment above the directive_handler_t definition for
1062 details about the callback's interface. */
1065 read_md_files (int argc
, const char **argv
, bool (*parse_opt
) (const char *),
1066 directive_handler_t handle_directive
)
1069 bool no_more_options
;
1070 bool already_read_stdin
;
1073 /* Initialize global data. */
1074 obstack_init (&string_obstack
);
1075 ptr_locs
= htab_create (161, leading_ptr_hash
, leading_ptr_eq_p
, 0);
1076 obstack_init (&ptr_loc_obstack
);
1077 joined_conditions
= htab_create (161, leading_ptr_hash
, leading_ptr_eq_p
, 0);
1078 obstack_init (&joined_conditions_obstack
);
1079 md_constants
= htab_create (31, leading_string_hash
,
1080 leading_string_eq_p
, (htab_del
) 0);
1081 enum_types
= htab_create (31, leading_string_hash
,
1082 leading_string_eq_p
, (htab_del
) 0);
1084 /* Unlock the stdio streams. */
1085 unlock_std_streams ();
1087 /* First we loop over all the options. */
1088 for (i
= 1; i
< argc
; i
++)
1089 if (argv
[i
][0] == '-')
1091 /* An argument consisting of exactly one dash is a request to
1092 read stdin. This will be handled in the second loop. */
1093 if (argv
[i
][1] == '\0')
1096 /* An argument consisting of just two dashes causes option
1097 parsing to cease. */
1098 if (argv
[i
][1] == '-' && argv
[i
][2] == '\0')
1101 if (argv
[i
][1] == 'I')
1103 if (argv
[i
][2] != '\0')
1104 parse_include (argv
[i
] + 2);
1105 else if (++i
< argc
)
1106 parse_include (argv
[i
]);
1108 fatal ("directory name missing after -I option");
1112 /* The program may have provided a callback so it can
1113 accept its own options. */
1114 if (parse_opt
&& parse_opt (argv
[i
]))
1117 fatal ("invalid option `%s'", argv
[i
]);
1120 /* Now loop over all input files. */
1122 no_more_options
= false;
1123 already_read_stdin
= false;
1124 for (i
= 1; i
< argc
; i
++)
1126 if (argv
[i
][0] == '-')
1128 if (argv
[i
][1] == '\0')
1131 if (already_read_stdin
)
1132 fatal ("cannot read standard input twice");
1134 read_md_file
= stdin
;
1135 read_md_filename
= "<stdin>";
1136 handle_toplevel_file (handle_directive
);
1137 already_read_stdin
= true;
1140 else if (argv
[i
][1] == '-' && argv
[i
][2] == '\0')
1142 /* No further arguments are to be treated as options. */
1143 no_more_options
= true;
1146 else if (!no_more_options
)
1150 /* If we get here we are looking at a non-option argument, i.e.
1151 a file to be processed. */
1152 read_md_filename
= argv
[i
];
1153 read_md_file
= fopen (read_md_filename
, "r");
1154 if (read_md_file
== 0)
1156 perror (read_md_filename
);
1159 handle_toplevel_file (handle_directive
);
1163 /* If we get to this point without having seen any files to process,
1164 read the standard input now. */
1165 if (num_files
== 0 && !already_read_stdin
)
1167 read_md_file
= stdin
;
1168 read_md_filename
= "<stdin>";
1169 handle_toplevel_file (handle_directive
);