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"
24 #include "statistics.h"
28 /* Associates PTR (which can be a string, etc.) with the file location
29 specified by FILENAME and LINENO. */
36 /* This callback will be invoked whenever an md include directive is
37 processed. To be used for creation of the dependency file. */
38 void (*include_callback
) (const char *);
40 /* Global singleton. */
42 rtx_reader
*rtx_reader_ptr
;
44 /* Given an object that starts with a char * name field, return a hash
48 leading_string_hash (const void *def
)
50 return htab_hash_string (*(const char *const *) def
);
53 /* Given two objects that start with char * name fields, return true if
54 they have the same name. */
57 leading_string_eq_p (const void *def1
, const void *def2
)
59 return strcmp (*(const char *const *) def1
,
60 *(const char *const *) def2
) == 0;
63 /* Return a hash value for the pointer pointed to by DEF. */
66 leading_ptr_hash (const void *def
)
68 return htab_hash_pointer (*(const void *const *) def
);
71 /* Return true if DEF1 and DEF2 are pointers to the same pointer. */
74 leading_ptr_eq_p (const void *def1
, const void *def2
)
76 return *(const void *const *) def1
== *(const void *const *) def2
;
79 /* Associate PTR with the file position given by FILENAME and LINENO. */
82 rtx_reader::set_md_ptr_loc (const void *ptr
, const char *filename
, int lineno
)
86 loc
= (struct ptr_loc
*) obstack_alloc (&m_ptr_loc_obstack
,
87 sizeof (struct ptr_loc
));
89 loc
->filename
= filename
;
91 *htab_find_slot (m_ptr_locs
, loc
, INSERT
) = loc
;
94 /* Return the position associated with pointer PTR. Return null if no
97 const struct ptr_loc
*
98 rtx_reader::get_md_ptr_loc (const void *ptr
)
100 return (const struct ptr_loc
*) htab_find (m_ptr_locs
, &ptr
);
103 /* Associate NEW_PTR with the same file position as OLD_PTR. */
106 rtx_reader::copy_md_ptr_loc (const void *new_ptr
, const void *old_ptr
)
108 const struct ptr_loc
*loc
= get_md_ptr_loc (old_ptr
);
110 set_md_ptr_loc (new_ptr
, loc
->filename
, loc
->lineno
);
113 /* If PTR is associated with a known file position, print a #line
114 directive for it to OUTF. */
117 rtx_reader::fprint_md_ptr_loc (FILE *outf
, const void *ptr
)
119 const struct ptr_loc
*loc
= get_md_ptr_loc (ptr
);
121 fprintf (outf
, "#line %d \"%s\"\n", loc
->lineno
, loc
->filename
);
124 /* Special fprint_md_ptr_loc for writing to STDOUT. */
126 rtx_reader::print_md_ptr_loc (const void *ptr
)
128 fprint_md_ptr_loc (stdout
, ptr
);
131 /* Return a condition that satisfies both COND1 and COND2. Either string
132 may be null or empty. */
135 rtx_reader::join_c_conditions (const char *cond1
, const char *cond2
)
140 if (cond1
== 0 || cond1
[0] == 0)
143 if (cond2
== 0 || cond2
[0] == 0)
146 if (strcmp (cond1
, cond2
) == 0)
149 result
= concat ("(", cond1
, ") && (", cond2
, ")", NULL
);
150 obstack_ptr_grow (&m_joined_conditions_obstack
, result
);
151 obstack_ptr_grow (&m_joined_conditions_obstack
, cond1
);
152 obstack_ptr_grow (&m_joined_conditions_obstack
, cond2
);
153 entry
= XOBFINISH (&m_joined_conditions_obstack
, const void **);
154 *htab_find_slot (m_joined_conditions
, entry
, INSERT
) = entry
;
158 /* Print condition COND to OUTF, wrapped in brackets. If COND was created
159 by join_c_conditions, recursively invoke this function for the original
160 conditions and join the result with "&&". Otherwise print a #line
161 directive for COND if its original file position is known. */
164 rtx_reader::fprint_c_condition (FILE *outf
, const char *cond
)
166 const char **halves
= (const char **) htab_find (m_joined_conditions
, &cond
);
170 fprint_c_condition (outf
, halves
[1]);
171 fprintf (outf
, " && ");
172 fprint_c_condition (outf
, halves
[2]);
178 fprint_md_ptr_loc (outf
, cond
);
179 fprintf (outf
, "(%s)", cond
);
183 /* Special fprint_c_condition for writing to STDOUT. */
186 rtx_reader::print_c_condition (const char *cond
)
188 fprint_c_condition (stdout
, cond
);
191 /* A vfprintf-like function for reporting an error against line LINENO
192 of the current MD file. */
194 static void ATTRIBUTE_PRINTF(2,0)
195 message_at_1 (file_location loc
, const char *msg
, va_list ap
)
197 fprintf (stderr
, "%s:%d:%d: ", loc
.filename
, loc
.lineno
, loc
.colno
);
198 vfprintf (stderr
, msg
, ap
);
199 fputc ('\n', stderr
);
202 /* A printf-like function for reporting a message against location LOC. */
205 message_at (file_location loc
, const char *msg
, ...)
210 message_at_1 (loc
, msg
, ap
);
214 /* Like message_at, but treat the condition as an error. */
217 error_at (file_location loc
, const char *msg
, ...)
222 message_at_1 (loc
, msg
, ap
);
227 /* Like message_at, but treat the condition as a fatal error. */
230 fatal_at (file_location loc
, const char *msg
, ...)
235 message_at_1 (loc
, msg
, ap
);
240 /* A printf-like function for reporting an error against the current
241 position in the MD file. */
244 fatal_with_file_and_line (const char *msg
, ...)
253 fprintf (stderr
, "%s:%d:%d: error: ", rtx_reader_ptr
->get_filename (),
254 rtx_reader_ptr
->get_lineno (), rtx_reader_ptr
->get_colno ());
255 vfprintf (stderr
, msg
, ap
);
258 /* Gather some following context. */
259 for (i
= 0; i
< sizeof (context
)-1; ++i
)
264 if (c
== '\r' || c
== '\n')
273 fprintf (stderr
, "%s:%d:%d: note: following context is `%s'\n",
274 rtx_reader_ptr
->get_filename (), rtx_reader_ptr
->get_lineno (),
275 rtx_reader_ptr
->get_colno (), context
);
281 /* Report that we found character ACTUAL when we expected to find
282 character EXPECTED. */
285 fatal_expected_char (int expected
, int actual
)
288 fatal_with_file_and_line ("expected character `%c', found EOF",
291 fatal_with_file_and_line ("expected character `%c', found `%c'",
295 /* Read chars from the MD file until a non-whitespace char and return that.
296 Comments, both Lisp style and C style, are treated as whitespace. */
299 read_skip_spaces (void)
308 case ' ': case '\t': case '\f': case '\r': case '\n':
314 while (c
!= '\n' && c
!= EOF
);
324 fatal_with_file_and_line ("stray '/' in file");
328 while ((c
= read_char ()) && c
!= EOF
)
330 if (prevc
== '*' && c
== '/')
343 /* Consume the next character, issuing a fatal error if it is not
347 rtx_reader::require_char (char expected
)
349 int ch
= read_char ();
351 fatal_expected_char (expected
, ch
);
354 /* Consume any whitespace, then consume the next non-whitespace
355 character, issuing a fatal error if it is not EXPECTED. */
358 rtx_reader::require_char_ws (char expected
)
360 int ch
= read_skip_spaces ();
362 fatal_expected_char (expected
, ch
);
365 /* Consume any whitespace, then consume the next word (as per read_name),
366 issuing a fatal error if it is not EXPECTED. */
369 rtx_reader::require_word_ws (const char *expected
)
373 if (strcmp (name
.string
, expected
))
374 fatal_with_file_and_line ("missing '%s'", expected
);
377 /* Read the next character from the file. */
380 rtx_reader::read_char (void)
384 ch
= getc (m_read_md_file
);
388 m_last_line_colno
= m_read_md_colno
;
397 /* Put back CH, which was the last character read from the file. */
400 rtx_reader::unread_char (int ch
)
405 m_read_md_colno
= m_last_line_colno
;
409 ungetc (ch
, m_read_md_file
);
412 /* Peek at the next character from the file without consuming it. */
415 rtx_reader::peek_char (void)
417 int ch
= read_char ();
422 /* Read an rtx code name into NAME. It is terminated by any of the
423 punctuation chars of rtx printed syntax. */
426 rtx_reader::read_name (struct md_name
*name
)
430 int angle_bracket_depth
;
432 c
= read_skip_spaces ();
435 angle_bracket_depth
= 0;
439 angle_bracket_depth
++;
441 if ((c
== '>') && (angle_bracket_depth
> 0))
442 angle_bracket_depth
--;
444 if (c
== ' ' || c
== '\n' || c
== '\t' || c
== '\f' || c
== '\r'
447 if (angle_bracket_depth
== 0)
449 if (c
== ':' || c
== ')' || c
== ']'
450 || c
== '"' || c
== '/' || c
== '(' || c
== '[')
457 if (i
== sizeof (name
->buffer
) - 1)
458 fatal_with_file_and_line ("name too long");
459 name
->buffer
[i
++] = c
;
465 fatal_with_file_and_line ("missing name or number");
468 name
->string
= name
->buffer
;
472 /* Do constant expansion. */
473 struct md_constant
*def
;
477 struct md_constant tmp_def
;
479 tmp_def
.name
= name
->string
;
480 def
= (struct md_constant
*) htab_find (m_md_constants
, &tmp_def
);
482 name
->string
= def
->value
;
488 /* Subroutine of the string readers. Handles backslash escapes.
489 Caller has read the backslash, but not placed it into the obstack. */
492 rtx_reader::read_escape ()
494 int c
= read_char ();
498 /* Backslash-newline is replaced by nothing, as in C. */
502 /* \" \' \\ are replaced by the second character. */
508 /* Standard C string escapes:
511 all are passed through to the output string unmolested.
512 In normal use these wind up in a string constant processed
513 by the C compiler, which will translate them appropriately.
514 We do not bother checking that \[0-7] are followed by up to
515 two octal digits, or that \x is followed by N hex digits.
516 \? \u \U are left out because they are not in traditional C. */
517 case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
518 case '0': case '1': case '2': case '3': case '4': case '5': case '6':
520 obstack_1grow (&m_string_obstack
, '\\');
523 /* \; makes stuff for a C string constant containing
526 obstack_grow (&m_string_obstack
, "\\n\\t", 4);
529 /* pass anything else through, but issue a warning. */
531 fprintf (stderr
, "%s:%d: warning: unrecognized escape \\%c\n",
532 get_filename (), get_lineno (),
534 obstack_1grow (&m_string_obstack
, '\\');
538 obstack_1grow (&m_string_obstack
, c
);
541 /* Read a double-quoted string onto the obstack. Caller has scanned
542 the leading quote. */
545 rtx_reader::read_quoted_string ()
551 c
= read_char (); /* Read the string */
557 else if (c
== '"' || c
== EOF
)
560 obstack_1grow (&m_string_obstack
, c
);
563 obstack_1grow (&m_string_obstack
, 0);
564 return XOBFINISH (&m_string_obstack
, char *);
567 /* Read a braced string (a la Tcl) onto the string obstack. Caller
568 has scanned the leading brace. Note that unlike quoted strings,
569 the outermost braces _are_ included in the string constant. */
572 rtx_reader::read_braced_string ()
575 int brace_depth
= 1; /* caller-processed */
576 unsigned long starting_read_md_lineno
= get_lineno ();
578 obstack_1grow (&m_string_obstack
, '{');
581 c
= read_char (); /* Read the string */
593 fatal_with_file_and_line
594 ("missing closing } for opening brace on line %lu",
595 starting_read_md_lineno
);
597 obstack_1grow (&m_string_obstack
, c
);
600 obstack_1grow (&m_string_obstack
, 0);
601 return XOBFINISH (&m_string_obstack
, char *);
604 /* Read some kind of string constant. This is the high-level routine
605 used by read_rtx. It handles surrounding parentheses, leading star,
606 and dispatch to the appropriate string constant reader. */
609 rtx_reader::read_string (int star_if_braced
)
615 c
= read_skip_spaces ();
619 c
= read_skip_spaces ();
622 old_lineno
= get_lineno ();
624 stringbuf
= read_quoted_string ();
628 obstack_1grow (&m_string_obstack
, '*');
629 stringbuf
= read_braced_string ();
632 fatal_with_file_and_line ("expected `\"' or `{', found `%c'", c
);
635 require_char_ws (')');
637 set_md_ptr_loc (stringbuf
, get_filename (), old_lineno
);
641 /* Skip the rest of a construct that started at line LINENO and that
642 is currently nested by DEPTH levels of parentheses. */
645 rtx_reader::read_skip_construct (int depth
, file_location loc
)
652 c
= read_skip_spaces ();
655 error_at (loc
, "unterminated construct");
690 /* Given a string, return the number of comma-separated elements in it.
691 Return 0 for the null string. */
694 n_comma_elts (const char *s
)
708 /* Given a pointer to a (char *), return a pointer to the beginning of the
709 next comma-separated element in the string. Advance the pointer given
710 to the end of that element. Return NULL if at end of string. Caller
711 is responsible for copying the string if necessary. White space between
712 a comma and an element is ignored. */
715 scan_comma_elt (const char **pstr
)
718 const char *p
= *pstr
;
730 while (*p
!= ',' && *p
!= '\0')
737 /* Convert STRING to uppercase. */
740 upcase_string (char *string
)
744 for (i
= 0; string
[i
]; i
++)
745 string
[i
] = TOUPPER (string
[i
]);
748 /* Add a NAME = VALUE definition to md_constants-style hash table DEFS,
749 where both NAME and VALUE are malloc()ed strings. PARENT_ENUM is the
750 enum to which NAME belongs, or null if NAME is a stand-alone constant. */
752 static struct md_constant
*
753 add_constant (htab_t defs
, char *name
, char *value
,
754 struct enum_type
*parent_enum
)
756 struct md_constant
*def
, tmp_def
;
760 entry_ptr
= htab_find_slot (defs
, &tmp_def
, INSERT
);
763 def
= (struct md_constant
*) *entry_ptr
;
764 if (strcmp (def
->value
, value
) != 0)
765 fatal_with_file_and_line ("redefinition of `%s', was `%s', now `%s'",
766 def
->name
, def
->value
, value
);
767 else if (parent_enum
|| def
->parent_enum
)
768 fatal_with_file_and_line ("redefinition of `%s'", def
->name
);
774 def
= XNEW (struct md_constant
);
777 def
->parent_enum
= parent_enum
;
783 /* Process a define_constants directive, starting with the optional space
784 after the "define_constants". */
787 rtx_reader::handle_constants ()
792 require_char_ws ('[');
794 /* Disable constant expansion during definition processing. */
795 defs
= m_md_constants
;
797 while ( (c
= read_skip_spaces ()) != ']')
799 struct md_name name
, value
;
802 fatal_expected_char ('(', c
);
806 add_constant (defs
, xstrdup (name
.string
), xstrdup (value
.string
), 0);
808 require_char_ws (')');
810 m_md_constants
= defs
;
813 /* For every constant definition, call CALLBACK with two arguments:
814 a pointer a pointer to the constant definition and INFO.
815 Stop when CALLBACK returns zero. */
818 rtx_reader::traverse_md_constants (htab_trav callback
, void *info
)
820 htab_traverse (get_md_constants (), callback
, info
);
823 /* Return a malloc()ed decimal string that represents number NUMBER. */
826 md_decimal_string (int number
)
828 /* A safe overestimate. +1 for sign, +1 for null terminator. */
829 char buffer
[sizeof (int) * CHAR_BIT
+ 1 + 1];
831 sprintf (buffer
, "%d", number
);
832 return xstrdup (buffer
);
835 /* Process a define_enum or define_c_enum directive, starting with
836 the optional space after the "define_enum". LINENO is the line
837 number on which the directive started and MD_P is true if the
838 directive is a define_enum rather than a define_c_enum. */
841 rtx_reader::handle_enum (file_location loc
, bool md_p
)
843 char *enum_name
, *value_name
;
845 struct enum_type
*def
;
846 struct enum_value
*ev
;
850 enum_name
= read_string (false);
851 slot
= htab_find_slot (m_enum_types
, &enum_name
, INSERT
);
854 def
= (struct enum_type
*) *slot
;
855 if (def
->md_p
!= md_p
)
856 error_at (loc
, "redefining `%s' as a different type of enum",
861 def
= XNEW (struct enum_type
);
862 def
->name
= enum_name
;
865 def
->tail_ptr
= &def
->values
;
870 require_char_ws ('[');
872 while ((c
= read_skip_spaces ()) != ']')
876 error_at (loc
, "unterminated construct");
882 ev
= XNEW (struct enum_value
);
886 value_name
= concat (def
->name
, "_", name
.string
, NULL
);
887 upcase_string (value_name
);
888 ev
->name
= xstrdup (name
.string
);
892 value_name
= xstrdup (name
.string
);
893 ev
->name
= value_name
;
895 ev
->def
= add_constant (get_md_constants (), value_name
,
896 md_decimal_string (def
->num_values
), def
);
899 def
->tail_ptr
= &ev
->next
;
904 /* Try to find the definition of the given enum. Return null on failure. */
907 rtx_reader::lookup_enum_type (const char *name
)
909 return (struct enum_type
*) htab_find (m_enum_types
, &name
);
912 /* For every enum definition, call CALLBACK with two arguments:
913 a pointer to the constant definition and INFO. Stop when CALLBACK
917 rtx_reader::traverse_enum_types (htab_trav callback
, void *info
)
919 htab_traverse (m_enum_types
, callback
, info
);
923 /* Constructor for rtx_reader. */
925 rtx_reader::rtx_reader ()
926 : m_toplevel_fname (NULL
),
928 m_read_md_file (NULL
),
929 m_read_md_filename (NULL
),
930 m_read_md_lineno (0),
932 m_first_dir_md_include (NULL
),
933 m_last_dir_md_include_ptr (&m_first_dir_md_include
)
935 /* Set the global singleton pointer. */
936 rtx_reader_ptr
= this;
938 obstack_init (&m_string_obstack
);
940 m_ptr_locs
= htab_create (161, leading_ptr_hash
, leading_ptr_eq_p
, 0);
941 obstack_init (&m_ptr_loc_obstack
);
943 m_joined_conditions
= htab_create (161, leading_ptr_hash
, leading_ptr_eq_p
, 0);
944 obstack_init (&m_joined_conditions_obstack
);
946 m_md_constants
= htab_create (31, leading_string_hash
,
947 leading_string_eq_p
, (htab_del
) 0);
949 m_enum_types
= htab_create (31, leading_string_hash
,
950 leading_string_eq_p
, (htab_del
) 0);
952 /* Unlock the stdio streams. */
953 unlock_std_streams ();
956 /* rtx_reader's destructor. */
958 rtx_reader::~rtx_reader ()
962 htab_delete (m_enum_types
);
964 htab_delete (m_md_constants
);
966 obstack_free (&m_joined_conditions_obstack
, NULL
);
967 htab_delete (m_joined_conditions
);
969 obstack_free (&m_ptr_loc_obstack
, NULL
);
970 htab_delete (m_ptr_locs
);
972 obstack_free (&m_string_obstack
, NULL
);
974 /* Clear the global singleton pointer. */
975 rtx_reader_ptr
= NULL
;
978 /* Process an "include" directive, starting with the optional space
979 after the "include". Read in the file and use HANDLE_DIRECTIVE
980 to process each unknown directive. LINENO is the line number on
981 which the "include" occurred. */
984 rtx_reader::handle_include (file_location loc
)
986 const char *filename
;
987 const char *old_filename
;
988 int old_lineno
, old_colno
;
990 FILE *input_file
, *old_file
;
992 filename
= read_string (false);
995 /* If the specified file name is absolute, skip the include stack. */
996 if (!IS_ABSOLUTE_PATH (filename
))
998 struct file_name_list
*stackp
;
1000 /* Search the directory path, trying to open the file. */
1001 for (stackp
= m_first_dir_md_include
; stackp
; stackp
= stackp
->next
)
1003 static const char sep
[2] = { DIR_SEPARATOR
, '\0' };
1005 pathname
= concat (stackp
->fname
, sep
, filename
, NULL
);
1006 input_file
= fopen (pathname
, "r");
1007 if (input_file
!= NULL
)
1013 /* If we haven't managed to open the file yet, try combining the
1014 filename with BASE_DIR. */
1015 if (input_file
== NULL
)
1018 pathname
= concat (m_base_dir
, filename
, NULL
);
1020 pathname
= xstrdup (filename
);
1021 input_file
= fopen (pathname
, "r");
1024 if (input_file
== NULL
)
1027 error_at (loc
, "include file `%s' not found", filename
);
1031 /* Save the old cursor. Note that the LINENO argument to this
1032 function is the beginning of the include statement, while
1033 read_md_lineno has already been advanced. */
1034 old_file
= m_read_md_file
;
1035 old_filename
= m_read_md_filename
;
1036 old_lineno
= m_read_md_lineno
;
1037 old_colno
= m_read_md_colno
;
1039 if (include_callback
)
1040 include_callback (pathname
);
1042 m_read_md_file
= input_file
;
1043 m_read_md_filename
= pathname
;
1047 /* Restore the old cursor. */
1048 m_read_md_file
= old_file
;
1049 m_read_md_filename
= old_filename
;
1050 m_read_md_lineno
= old_lineno
;
1051 m_read_md_colno
= old_colno
;
1053 /* Do not free the pathname. It is attached to the various rtx
1057 /* Process the current file, assuming that read_md_file and
1058 read_md_filename are valid. Use HANDLE_DIRECTIVE to handle
1059 unknown directives. */
1062 rtx_reader::handle_file ()
1064 struct md_name directive
;
1067 m_read_md_lineno
= 1;
1068 m_read_md_colno
= 0;
1069 while ((c
= read_skip_spaces ()) != EOF
)
1071 file_location loc
= get_current_location ();
1073 fatal_expected_char ('(', c
);
1075 read_name (&directive
);
1076 if (strcmp (directive
.string
, "define_constants") == 0)
1077 handle_constants ();
1078 else if (strcmp (directive
.string
, "define_enum") == 0)
1079 handle_enum (loc
, true);
1080 else if (strcmp (directive
.string
, "define_c_enum") == 0)
1081 handle_enum (loc
, false);
1082 else if (strcmp (directive
.string
, "include") == 0)
1083 handle_include (loc
);
1085 handle_unknown_directive (loc
, directive
.string
);
1087 require_char_ws (')');
1089 fclose (m_read_md_file
);
1092 /* Like handle_file, but for top-level files. Set up m_toplevel_fname
1093 and m_base_dir accordingly. */
1096 rtx_reader::handle_toplevel_file ()
1100 m_toplevel_fname
= m_read_md_filename
;
1101 base
= lbasename (m_toplevel_fname
);
1102 if (base
== m_toplevel_fname
)
1105 m_base_dir
= xstrndup (m_toplevel_fname
, base
- m_toplevel_fname
);
1111 rtx_reader::get_current_location () const
1113 return file_location (m_read_md_filename
, m_read_md_lineno
, m_read_md_colno
);
1116 /* Parse a -I option with argument ARG. */
1119 rtx_reader::add_include_path (const char *arg
)
1121 struct file_name_list
*dirtmp
;
1123 dirtmp
= XNEW (struct file_name_list
);
1125 dirtmp
->fname
= arg
;
1126 *m_last_dir_md_include_ptr
= dirtmp
;
1127 m_last_dir_md_include_ptr
= &dirtmp
->next
;
1130 /* The main routine for reading .md files. Try to process all the .md
1131 files specified on the command line and return true if no error occurred.
1133 ARGC and ARGV are the arguments to main.
1135 PARSE_OPT, if nonnull, is passed all unknown command-line arguments.
1136 It should return true if it recognizes the argument or false if a
1137 generic error should be reported. */
1140 rtx_reader::read_md_files (int argc
, const char **argv
,
1141 bool (*parse_opt
) (const char *))
1144 bool no_more_options
;
1145 bool already_read_stdin
;
1148 /* First we loop over all the options. */
1149 for (i
= 1; i
< argc
; i
++)
1150 if (argv
[i
][0] == '-')
1152 /* An argument consisting of exactly one dash is a request to
1153 read stdin. This will be handled in the second loop. */
1154 if (argv
[i
][1] == '\0')
1157 /* An argument consisting of just two dashes causes option
1158 parsing to cease. */
1159 if (argv
[i
][1] == '-' && argv
[i
][2] == '\0')
1162 if (argv
[i
][1] == 'I')
1164 if (argv
[i
][2] != '\0')
1165 add_include_path (argv
[i
] + 2);
1166 else if (++i
< argc
)
1167 add_include_path (argv
[i
]);
1169 fatal ("directory name missing after -I option");
1173 /* The program may have provided a callback so it can
1174 accept its own options. */
1175 if (parse_opt
&& parse_opt (argv
[i
]))
1178 fatal ("invalid option `%s'", argv
[i
]);
1181 /* Now loop over all input files. */
1183 no_more_options
= false;
1184 already_read_stdin
= false;
1185 for (i
= 1; i
< argc
; i
++)
1187 if (argv
[i
][0] == '-')
1189 if (argv
[i
][1] == '\0')
1192 if (already_read_stdin
)
1193 fatal ("cannot read standard input twice");
1195 m_read_md_file
= stdin
;
1196 m_read_md_filename
= "<stdin>";
1197 handle_toplevel_file ();
1198 already_read_stdin
= true;
1201 else if (argv
[i
][1] == '-' && argv
[i
][2] == '\0')
1203 /* No further arguments are to be treated as options. */
1204 no_more_options
= true;
1207 else if (!no_more_options
)
1211 /* If we get here we are looking at a non-option argument, i.e.
1212 a file to be processed. */
1213 m_read_md_filename
= argv
[i
];
1214 m_read_md_file
= fopen (m_read_md_filename
, "r");
1215 if (m_read_md_file
== 0)
1217 perror (m_read_md_filename
);
1220 handle_toplevel_file ();
1224 /* If we get to this point without having seen any files to process,
1225 read the standard input now. */
1226 if (num_files
== 0 && !already_read_stdin
)
1228 m_read_md_file
= stdin
;
1229 m_read_md_filename
= "<stdin>";
1230 handle_toplevel_file ();
1236 /* class noop_reader : public rtx_reader */
1238 /* A dummy implementation which skips unknown directives. */
1240 noop_reader::handle_unknown_directive (file_location loc
, const char *)
1242 read_skip_construct (1, loc
);