OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [fixincludes/] [fixlib.c] - Blame information for rev 294

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 266 jeremybenn
 
2
/* Install modified versions of certain ANSI-incompatible system header
3
   files which are fixed to work correctly with ANSI C and placed in a
4
   directory that GCC will search.
5
 
6
   Copyright (C) 1999, 2000, 2001, 2004, 2009 Free Software Foundation, Inc.
7
 
8
This file is part of GCC.
9
 
10
GCC is free software; you can redistribute it and/or modify
11
it under the terms of the GNU General Public License as published by
12
the Free Software Foundation; either version 3, or (at your option)
13
any later version.
14
 
15
GCC is distributed in the hope that it will be useful,
16
but WITHOUT ANY WARRANTY; without even the implied warranty of
17
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
GNU General Public License for more details.
19
 
20
You should have received a copy of the GNU General Public License
21
along with GCC; see the file COPYING3.  If not see
22
<http://www.gnu.org/licenses/>.  */
23
 
24
#include "fixlib.h"
25
 
26
/* * * * * * * * * * * * *
27
 
28
   load_file_data loads all the contents of a file into malloc-ed memory.
29
   Its argument is the file pointer of the file to read in; the returned
30
   result is the NUL terminated contents of the file.  The file
31
   is presumed to be an ASCII text file containing no NULs.  */
32
 
33
char *
34
load_file_data (FILE* fp)
35
{
36
  char *pz_data = (char*)NULL;
37
  int    space_left = -1;  /* allow for terminating NUL */
38
  size_t space_used = 0;
39
 
40
  if (fp == (FILE*)NULL)
41
    return pz_data;
42
 
43
  do
44
    {
45
      size_t  size_read;
46
 
47
      if (space_left < 1024)
48
        {
49
          space_left += 4096;
50
          pz_data = XRESIZEVEC (char, pz_data, space_left + space_used + 1 );
51
        }
52
      size_read = fread (pz_data + space_used, 1, space_left, fp);
53
 
54
      if (size_read == 0)
55
        {
56
          if (feof (fp))
57
            break;
58
 
59
          if (ferror (fp))
60
            {
61
              int err = errno;
62
              if (err != EISDIR)
63
                fprintf (stderr, "error %d (%s) reading input\n", err,
64
                         xstrerror (err));
65
              free ((void *) pz_data);
66
              return (char *) NULL;
67
            }
68
        }
69
 
70
      space_left -= size_read;
71
      space_used += size_read;
72
    } while (! feof (fp));
73
 
74
  pz_data = XRESIZEVEC (char, pz_data, space_used+1 );
75
  pz_data[ space_used ] = NUL;
76
 
77
  return pz_data;
78
}
79
 
80
#ifdef IS_CXX_HEADER_NEEDED
81
t_bool
82
is_cxx_header (tCC* fname, tCC* text)
83
{
84
  /*  First, check to see if the file is in a C++ directory */
85
  for (;;)
86
    {
87
      switch (*(fname++))
88
        {
89
        case 'C': /* check for "CC/" */
90
          if ((fname[0] == 'C') && (fname[1] == '/'))
91
            return BOOL_TRUE;
92
          break;
93
 
94
        case 'x': /* check for "xx/" */
95
          if ((fname[0] == 'x') && (fname[1] == '/'))
96
            return BOOL_TRUE;
97
          break;
98
 
99
        case '+': /* check for "++" */
100
          if (fname[0] == '+')
101
            return BOOL_TRUE;
102
          break;
103
 
104
        case NUL:
105
          goto not_cxx_name;
106
        }
107
    } not_cxx_name:;
108
 
109
  /* Or it might contain one of several phrases which indicate C++ code.
110
     Currently recognized are:
111
     extern "C++"
112
     -*- (Mode: )? C++ -*-   (emacs mode marker)
113
     template <
114
   */
115
    {
116
      tSCC cxxpat[] = "\
117
extern[ \t]*\"C\\+\\+\"|\
118
-\\*-[ \t]*([mM]ode:[ \t]*)?[cC]\\+\\+[; \t]*-\\*-|\
119
template[ \t]*<|\
120
^[ \t]*class[ \t]|\
121
(public|private|protected):|\
122
^[ \t]*#[ \t]*pragma[ \t]+(interface|implementation)\
123
";
124
      static regex_t cxxre;
125
      static int compiled;
126
 
127
      if (!compiled)
128
        compile_re (cxxpat, &cxxre, 0, "contents check", "is_cxx_header");
129
 
130
      if (xregexec (&cxxre, text, 0, 0, 0) == 0)
131
        return BOOL_TRUE;
132
    }
133
 
134
  return BOOL_FALSE;
135
}
136
#endif /* CXX_TYPE_NEEDED */
137
 
138
#ifdef SKIP_QUOTE_NEEDED
139
/*
140
 *  Skip over a quoted string.  Single quote strings may
141
 *  contain multiple characters if the first character is
142
 *  a backslash.  Especially a backslash followed by octal digits.
143
 *  We are not doing a correctness syntax check here.
144
 */
145
tCC*
146
skip_quote(char q, char* text )
147
{
148
  for (;;)
149
    {
150
      char ch = *(text++);
151
      switch (ch)
152
        {
153
        case '\\':
154
          text++; /* skip over whatever character follows */
155
          break;
156
 
157
        case '"':
158
        case '\'':
159
          if (ch != q)
160
            break;
161
          /*FALLTHROUGH*/
162
 
163
        case '\n':
164
        case NUL:
165
          goto skip_done;
166
        }
167
    } skip_done:;
168
 
169
  return text;
170
}
171
#endif /* SKIP_QUOTE_NEEDED */
172
 
173
/* * * * * * * * * * * * *
174
 
175
   Compile one regular expression pattern for later use.  PAT contains
176
   the pattern, RE points to a regex_t structure (which should have
177
   been bzeroed).  MATCH is 1 if we need to know where the regex
178
   matched, 0 if not. If xregcomp fails, prints an error message and
179
   aborts; E1 and E2 are strings to shove into the error message.
180
 
181
   The patterns we search for are all egrep patterns.
182
   REG_EXTENDED|REG_NEWLINE produces identical regex syntax/semantics
183
   to egrep (verified from 4.4BSD Programmer's Reference Manual).  */
184
void
185
compile_re( tCC* pat, regex_t* re, int match, tCC* e1, tCC* e2 )
186
{
187
  tSCC z_bad_comp[] = "fixincl ERROR:  cannot compile %s regex for %s\n\
188
\texpr = `%s'\n\terror %s\n";
189
  int flags, err;
190
 
191
  flags = (match ? REG_EXTENDED|REG_NEWLINE
192
           : REG_EXTENDED|REG_NEWLINE|REG_NOSUB);
193
  err = xregcomp (re, pat, flags);
194
 
195
  if (err)
196
    {
197
      char rerrbuf[1024];
198
      regerror (err, re, rerrbuf, 1024);
199
      fprintf (stderr, z_bad_comp, e1, e2, pat, rerrbuf);
200
      exit (EXIT_FAILURE);
201
    }
202
}
203
 
204
/* * * * * * * * * * * * *
205
 
206
   Helper routine and data for the machine_name test and fix.  */
207
 
208
tSCC mn_label_pat[] = "^[ \t]*#[ \t]*(if|ifdef|ifndef)[ \t]+";
209
static regex_t mn_label_re;
210
static regex_t mn_name_re;
211
 
212
static int mn_compiled = 0;
213
 
214
t_bool
215
mn_get_regexps(regex_t** label_re, regex_t** name_re, tCC* who )
216
{
217
  if (! pz_mn_name_pat)
218
    return BOOL_FALSE;
219
 
220
  if (! mn_compiled)
221
    {
222
      compile_re (mn_label_pat, &mn_label_re, 1, "label pattern", who);
223
      compile_re (pz_mn_name_pat, &mn_name_re, 1, "name pattern", who);
224
      mn_compiled++;
225
    }
226
  *label_re = &mn_label_re;
227
  *name_re = &mn_name_re;
228
  return BOOL_TRUE;
229
}
230
 
231
 
232
#ifdef SEPARATE_FIX_PROC
233
 
234
char*
235
make_raw_shell_str( char* pz_d, tCC* pz_s, size_t smax )
236
{
237
  tSCC zQ[] = "'\\''";
238
  size_t     dtaSize;
239
  char*      pz_d_start = pz_d;
240
 
241
  smax--; /* adjust for trailing NUL */
242
 
243
  dtaSize = strlen( pz_s ) + 3;
244
 
245
  {
246
    const char* pz = pz_s - 1;
247
 
248
    for (;;) {
249
      pz = strchr( pz+1, '\'' );
250
      if (pz == (char*)NULL)
251
        break;
252
      dtaSize += sizeof( zQ )-1;
253
    }
254
  }
255
  if (dtaSize > smax)
256
    return (char*)NULL;
257
 
258
  *(pz_d++) = '\'';
259
 
260
  for (;;) {
261
    if ((size_t) (pz_d - pz_d_start) >= smax)
262
      return (char*)NULL;
263
    switch (*(pz_d++) = *(pz_s++)) {
264
    case NUL:
265
      goto loopDone;
266
 
267
    case '\'':
268
      if ((size_t) (pz_d - pz_d_start) >= smax - sizeof( zQ )-1)
269
        return (char*)NULL;
270
      strcpy( pz_d-1, zQ );
271
      pz_d += sizeof( zQ )-2;
272
    }
273
  } loopDone:;
274
  pz_d[-1] = '\'';
275
  *pz_d    = NUL;
276
 
277
  return pz_d;
278
}
279
 
280
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.