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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [macroexp.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* C preprocessor macro expansion for GDB.
2
   Copyright (C) 2002, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
3
   Contributed by Red Hat, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
 
20
#include "defs.h"
21
#include "gdb_obstack.h"
22
#include "bcache.h"
23
#include "macrotab.h"
24
#include "macroexp.h"
25
#include "gdb_assert.h"
26
#include "c-lang.h"
27
 
28
 
29
 
30
/* A resizeable, substringable string type.  */
31
 
32
 
33
/* A string type that we can resize, quickly append to, and use to
34
   refer to substrings of other strings.  */
35
struct macro_buffer
36
{
37
  /* An array of characters.  The first LEN bytes are the real text,
38
     but there are SIZE bytes allocated to the array.  If SIZE is
39
     zero, then this doesn't point to a malloc'ed block.  If SHARED is
40
     non-zero, then this buffer is actually a pointer into some larger
41
     string, and we shouldn't append characters to it, etc.  Because
42
     of sharing, we can't assume in general that the text is
43
     null-terminated.  */
44
  char *text;
45
 
46
  /* The number of characters in the string.  */
47
  int len;
48
 
49
  /* The number of characters allocated to the string.  If SHARED is
50
     non-zero, this is meaningless; in this case, we set it to zero so
51
     that any "do we have room to append something?" tests will fail,
52
     so we don't always have to check SHARED before using this field.  */
53
  int size;
54
 
55
  /* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc
56
     block).  Non-zero if TEXT is actually pointing into the middle of
57
     some other block, and we shouldn't reallocate it.  */
58
  int shared;
59
 
60
  /* For detecting token splicing.
61
 
62
     This is the index in TEXT of the first character of the token
63
     that abuts the end of TEXT.  If TEXT contains no tokens, then we
64
     set this equal to LEN.  If TEXT ends in whitespace, then there is
65
     no token abutting the end of TEXT (it's just whitespace), and
66
     again, we set this equal to LEN.  We set this to -1 if we don't
67
     know the nature of TEXT.  */
68
  int last_token;
69
 
70
  /* If this buffer is holding the result from get_token, then this
71
     is non-zero if it is an identifier token, zero otherwise.  */
72
  int is_identifier;
73
};
74
 
75
 
76
/* Set the macro buffer *B to the empty string, guessing that its
77
   final contents will fit in N bytes.  (It'll get resized if it
78
   doesn't, so the guess doesn't have to be right.)  Allocate the
79
   initial storage with xmalloc.  */
80
static void
81
init_buffer (struct macro_buffer *b, int n)
82
{
83
  b->size = n;
84
  if (n > 0)
85
    b->text = (char *) xmalloc (n);
86
  else
87
    b->text = NULL;
88
  b->len = 0;
89
  b->shared = 0;
90
  b->last_token = -1;
91
}
92
 
93
 
94
/* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
95
   shared substring.  */
96
static void
97
init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
98
{
99
  buf->text = addr;
100
  buf->len = len;
101
  buf->shared = 1;
102
  buf->size = 0;
103
  buf->last_token = -1;
104
}
105
 
106
 
107
/* Free the text of the buffer B.  Raise an error if B is shared.  */
108
static void
109
free_buffer (struct macro_buffer *b)
110
{
111
  gdb_assert (! b->shared);
112
  if (b->size)
113
    xfree (b->text);
114
}
115
 
116
 
117
/* A cleanup function for macro buffers.  */
118
static void
119
cleanup_macro_buffer (void *untyped_buf)
120
{
121
  free_buffer ((struct macro_buffer *) untyped_buf);
122
}
123
 
124
 
125
/* Resize the buffer B to be at least N bytes long.  Raise an error if
126
   B shouldn't be resized.  */
127
static void
128
resize_buffer (struct macro_buffer *b, int n)
129
{
130
  /* We shouldn't be trying to resize shared strings.  */
131
  gdb_assert (! b->shared);
132
 
133
  if (b->size == 0)
134
    b->size = n;
135
  else
136
    while (b->size <= n)
137
      b->size *= 2;
138
 
139
  b->text = xrealloc (b->text, b->size);
140
}
141
 
142
 
143
/* Append the character C to the buffer B.  */
144
static void
145
appendc (struct macro_buffer *b, int c)
146
{
147
  int new_len = b->len + 1;
148
 
149
  if (new_len > b->size)
150
    resize_buffer (b, new_len);
151
 
152
  b->text[b->len] = c;
153
  b->len = new_len;
154
}
155
 
156
 
157
/* Append the LEN bytes at ADDR to the buffer B.  */
158
static void
159
appendmem (struct macro_buffer *b, char *addr, int len)
160
{
161
  int new_len = b->len + len;
162
 
163
  if (new_len > b->size)
164
    resize_buffer (b, new_len);
165
 
166
  memcpy (b->text + b->len, addr, len);
167
  b->len = new_len;
168
}
169
 
170
 
171
 
172
/* Recognizing preprocessor tokens.  */
173
 
174
 
175
int
176
macro_is_whitespace (int c)
177
{
178
  return (c == ' '
179
          || c == '\t'
180
          || c == '\n'
181
          || c == '\v'
182
          || c == '\f');
183
}
184
 
185
 
186
int
187
macro_is_digit (int c)
188
{
189
  return ('0' <= c && c <= '9');
190
}
191
 
192
 
193
int
194
macro_is_identifier_nondigit (int c)
195
{
196
  return (c == '_'
197
          || ('a' <= c && c <= 'z')
198
          || ('A' <= c && c <= 'Z'));
199
}
200
 
201
 
202
static void
203
set_token (struct macro_buffer *tok, char *start, char *end)
204
{
205
  init_shared_buffer (tok, start, end - start);
206
  tok->last_token = 0;
207
 
208
  /* Presumed; get_identifier may overwrite this. */
209
  tok->is_identifier = 0;
210
}
211
 
212
 
213
static int
214
get_comment (struct macro_buffer *tok, char *p, char *end)
215
{
216
  if (p + 2 > end)
217
    return 0;
218
  else if (p[0] == '/'
219
           && p[1] == '*')
220
    {
221
      char *tok_start = p;
222
 
223
      p += 2;
224
 
225
      for (; p < end; p++)
226
        if (p + 2 <= end
227
            && p[0] == '*'
228
            && p[1] == '/')
229
          {
230
            p += 2;
231
            set_token (tok, tok_start, p);
232
            return 1;
233
          }
234
 
235
      error (_("Unterminated comment in macro expansion."));
236
    }
237
  else if (p[0] == '/'
238
           && p[1] == '/')
239
    {
240
      char *tok_start = p;
241
 
242
      p += 2;
243
      for (; p < end; p++)
244
        if (*p == '\n')
245
          break;
246
 
247
      set_token (tok, tok_start, p);
248
      return 1;
249
    }
250
  else
251
    return 0;
252
}
253
 
254
 
255
static int
256
get_identifier (struct macro_buffer *tok, char *p, char *end)
257
{
258
  if (p < end
259
      && macro_is_identifier_nondigit (*p))
260
    {
261
      char *tok_start = p;
262
 
263
      while (p < end
264
             && (macro_is_identifier_nondigit (*p)
265
                 || macro_is_digit (*p)))
266
        p++;
267
 
268
      set_token (tok, tok_start, p);
269
      tok->is_identifier = 1;
270
      return 1;
271
    }
272
  else
273
    return 0;
274
}
275
 
276
 
277
static int
278
get_pp_number (struct macro_buffer *tok, char *p, char *end)
279
{
280
  if (p < end
281
      && (macro_is_digit (*p)
282
          || (*p == '.'
283
              && p + 2 <= end
284
              && macro_is_digit (p[1]))))
285
    {
286
      char *tok_start = p;
287
 
288
      while (p < end)
289
        {
290
          if (p + 2 <= end
291
              && strchr ("eEpP", *p)
292
              && (p[1] == '+' || p[1] == '-'))
293
            p += 2;
294
          else if (macro_is_digit (*p)
295
                   || macro_is_identifier_nondigit (*p)
296
                   || *p == '.')
297
            p++;
298
          else
299
            break;
300
        }
301
 
302
      set_token (tok, tok_start, p);
303
      return 1;
304
    }
305
  else
306
    return 0;
307
}
308
 
309
 
310
 
311
/* If the text starting at P going up to (but not including) END
312
   starts with a character constant, set *TOK to point to that
313
   character constant, and return 1.  Otherwise, return zero.
314
   Signal an error if it contains a malformed or incomplete character
315
   constant.  */
316
static int
317
get_character_constant (struct macro_buffer *tok, char *p, char *end)
318
{
319
  /* ISO/IEC 9899:1999 (E)  Section 6.4.4.4  paragraph 1
320
     But of course, what really matters is that we handle it the same
321
     way GDB's C/C++ lexer does.  So we call parse_escape in utils.c
322
     to handle escape sequences.  */
323
  if ((p + 1 <= end && *p == '\'')
324
      || (p + 2 <= end
325
          && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
326
          && p[1] == '\''))
327
    {
328
      char *tok_start = p;
329
      char *body_start;
330
      int char_count = 0;
331
 
332
      if (*p == '\'')
333
        p++;
334
      else if (*p == 'L' || *p == 'u' || *p == 'U')
335
        p += 2;
336
      else
337
        gdb_assert (0);
338
 
339
      body_start = p;
340
      for (;;)
341
        {
342
          if (p >= end)
343
            error (_("Unmatched single quote."));
344
          else if (*p == '\'')
345
            {
346
              if (!char_count)
347
                error (_("A character constant must contain at least one "
348
                       "character."));
349
              p++;
350
              break;
351
            }
352
          else if (*p == '\\')
353
            {
354
              p++;
355
              char_count += c_parse_escape (&p, NULL);
356
            }
357
          else
358
            {
359
              p++;
360
              char_count++;
361
            }
362
        }
363
 
364
      set_token (tok, tok_start, p);
365
      return 1;
366
    }
367
  else
368
    return 0;
369
}
370
 
371
 
372
/* If the text starting at P going up to (but not including) END
373
   starts with a string literal, set *TOK to point to that string
374
   literal, and return 1.  Otherwise, return zero.  Signal an error if
375
   it contains a malformed or incomplete string literal.  */
376
static int
377
get_string_literal (struct macro_buffer *tok, char *p, char *end)
378
{
379
  if ((p + 1 <= end
380
       && *p == '"')
381
      || (p + 2 <= end
382
          && (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
383
          && p[1] == '"'))
384
    {
385
      char *tok_start = p;
386
 
387
      if (*p == '"')
388
        p++;
389
      else if (*p == 'L' || *p == 'u' || *p == 'U')
390
        p += 2;
391
      else
392
        gdb_assert (0);
393
 
394
      for (;;)
395
        {
396
          if (p >= end)
397
            error (_("Unterminated string in expression."));
398
          else if (*p == '"')
399
            {
400
              p++;
401
              break;
402
            }
403
          else if (*p == '\n')
404
            error (_("Newline characters may not appear in string "
405
                   "constants."));
406
          else if (*p == '\\')
407
            {
408
              p++;
409
              c_parse_escape (&p, NULL);
410
            }
411
          else
412
            p++;
413
        }
414
 
415
      set_token (tok, tok_start, p);
416
      return 1;
417
    }
418
  else
419
    return 0;
420
}
421
 
422
 
423
static int
424
get_punctuator (struct macro_buffer *tok, char *p, char *end)
425
{
426
  /* Here, speed is much less important than correctness and clarity.  */
427
 
428
  /* ISO/IEC 9899:1999 (E)  Section 6.4.6  Paragraph 1.
429
     Note that this table is ordered in a special way.  A punctuator
430
     which is a prefix of another punctuator must appear after its
431
     "extension".  Otherwise, the wrong token will be returned.  */
432
  static const char * const punctuators[] = {
433
    "[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
434
    "...", ".",
435
    "->", "--", "-=", "-",
436
    "++", "+=", "+",
437
    "*=", "*",
438
    "!=", "!",
439
    "&&", "&=", "&",
440
    "/=", "/",
441
    "%>", "%:%:", "%:", "%=", "%",
442
    "^=", "^",
443
    "##", "#",
444
    ":>", ":",
445
    "||", "|=", "|",
446
    "<<=", "<<", "<=", "<:", "<%", "<",
447
    ">>=", ">>", ">=", ">",
448
    "==", "=",
449
 
450
  };
451
 
452
  int i;
453
 
454
  if (p + 1 <= end)
455
    {
456
      for (i = 0; punctuators[i]; i++)
457
        {
458
          const char *punctuator = punctuators[i];
459
 
460
          if (p[0] == punctuator[0])
461
            {
462
              int len = strlen (punctuator);
463
 
464
              if (p + len <= end
465
                  && ! memcmp (p, punctuator, len))
466
                {
467
                  set_token (tok, p, p + len);
468
                  return 1;
469
                }
470
            }
471
        }
472
    }
473
 
474
  return 0;
475
}
476
 
477
 
478
/* Peel the next preprocessor token off of SRC, and put it in TOK.
479
   Mutate TOK to refer to the first token in SRC, and mutate SRC to
480
   refer to the text after that token.  SRC must be a shared buffer;
481
   the resulting TOK will be shared, pointing into the same string SRC
482
   does.  Initialize TOK's last_token field.  Return non-zero if we
483
   succeed, or 0 if we didn't find any more tokens in SRC.  */
484
static int
485
get_token (struct macro_buffer *tok,
486
           struct macro_buffer *src)
487
{
488
  char *p = src->text;
489
  char *end = p + src->len;
490
 
491
  gdb_assert (src->shared);
492
 
493
  /* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
494
 
495
     preprocessing-token:
496
         header-name
497
         identifier
498
         pp-number
499
         character-constant
500
         string-literal
501
         punctuator
502
         each non-white-space character that cannot be one of the above
503
 
504
     We don't have to deal with header-name tokens, since those can
505
     only occur after a #include, which we will never see.  */
506
 
507
  while (p < end)
508
    if (macro_is_whitespace (*p))
509
      p++;
510
    else if (get_comment (tok, p, end))
511
      p += tok->len;
512
    else if (get_pp_number (tok, p, end)
513
             || get_character_constant (tok, p, end)
514
             || get_string_literal (tok, p, end)
515
             /* Note: the grammar in the standard seems to be
516
                ambiguous: L'x' can be either a wide character
517
                constant, or an identifier followed by a normal
518
                character constant.  By trying `get_identifier' after
519
                we try get_character_constant and get_string_literal,
520
                we give the wide character syntax precedence.  Now,
521
                since GDB doesn't handle wide character constants
522
                anyway, is this the right thing to do?  */
523
             || get_identifier (tok, p, end)
524
             || get_punctuator (tok, p, end))
525
      {
526
        /* How many characters did we consume, including whitespace?  */
527
        int consumed = p - src->text + tok->len;
528
        src->text += consumed;
529
        src->len -= consumed;
530
        return 1;
531
      }
532
    else
533
      {
534
        /* We have found a "non-whitespace character that cannot be
535
           one of the above."  Make a token out of it.  */
536
        int consumed;
537
 
538
        set_token (tok, p, p + 1);
539
        consumed = p - src->text + tok->len;
540
        src->text += consumed;
541
        src->len -= consumed;
542
        return 1;
543
      }
544
 
545
  return 0;
546
}
547
 
548
 
549
 
550
/* Appending token strings, with and without splicing  */
551
 
552
 
553
/* Append the macro buffer SRC to the end of DEST, and ensure that
554
   doing so doesn't splice the token at the end of SRC with the token
555
   at the beginning of DEST.  SRC and DEST must have their last_token
556
   fields set.  Upon return, DEST's last_token field is set correctly.
557
 
558
   For example:
559
 
560
   If DEST is "(" and SRC is "y", then we can return with
561
   DEST set to "(y" --- we've simply appended the two buffers.
562
 
563
   However, if DEST is "x" and SRC is "y", then we must not return
564
   with DEST set to "xy" --- that would splice the two tokens "x" and
565
   "y" together to make a single token "xy".  However, it would be
566
   fine to return with DEST set to "x y".  Similarly, "<" and "<" must
567
   yield "< <", not "<<", etc.  */
568
static void
569
append_tokens_without_splicing (struct macro_buffer *dest,
570
                                struct macro_buffer *src)
571
{
572
  int original_dest_len = dest->len;
573
  struct macro_buffer dest_tail, new_token;
574
 
575
  gdb_assert (src->last_token != -1);
576
  gdb_assert (dest->last_token != -1);
577
 
578
  /* First, just try appending the two, and call get_token to see if
579
     we got a splice.  */
580
  appendmem (dest, src->text, src->len);
581
 
582
  /* If DEST originally had no token abutting its end, then we can't
583
     have spliced anything, so we're done.  */
584
  if (dest->last_token == original_dest_len)
585
    {
586
      dest->last_token = original_dest_len + src->last_token;
587
      return;
588
    }
589
 
590
  /* Set DEST_TAIL to point to the last token in DEST, followed by
591
     all the stuff we just appended.  */
592
  init_shared_buffer (&dest_tail,
593
                      dest->text + dest->last_token,
594
                      dest->len - dest->last_token);
595
 
596
  /* Re-parse DEST's last token.  We know that DEST used to contain
597
     at least one token, so if it doesn't contain any after the
598
     append, then we must have spliced "/" and "*" or "/" and "/" to
599
     make a comment start.  (Just for the record, I got this right
600
     the first time.  This is not a bug fix.)  */
601
  if (get_token (&new_token, &dest_tail)
602
      && (new_token.text + new_token.len
603
          == dest->text + original_dest_len))
604
    {
605
      /* No splice, so we're done.  */
606
      dest->last_token = original_dest_len + src->last_token;
607
      return;
608
    }
609
 
610
  /* Okay, a simple append caused a splice.  Let's chop dest back to
611
     its original length and try again, but separate the texts with a
612
     space.  */
613
  dest->len = original_dest_len;
614
  appendc (dest, ' ');
615
  appendmem (dest, src->text, src->len);
616
 
617
  init_shared_buffer (&dest_tail,
618
                      dest->text + dest->last_token,
619
                      dest->len - dest->last_token);
620
 
621
  /* Try to re-parse DEST's last token, as above.  */
622
  if (get_token (&new_token, &dest_tail)
623
      && (new_token.text + new_token.len
624
          == dest->text + original_dest_len))
625
    {
626
      /* No splice, so we're done.  */
627
      dest->last_token = original_dest_len + 1 + src->last_token;
628
      return;
629
    }
630
 
631
  /* As far as I know, there's no case where inserting a space isn't
632
     enough to prevent a splice.  */
633
  internal_error (__FILE__, __LINE__,
634
                  _("unable to avoid splicing tokens during macro expansion"));
635
}
636
 
637
/* Stringify an argument, and insert it into DEST.  ARG is the text to
638
   stringify; it is LEN bytes long.  */
639
 
640
static void
641
stringify (struct macro_buffer *dest, char *arg, int len)
642
{
643
  /* Trim initial whitespace from ARG.  */
644
  while (len > 0 && macro_is_whitespace (*arg))
645
    {
646
      ++arg;
647
      --len;
648
    }
649
 
650
  /* Trim trailing whitespace from ARG.  */
651
  while (len > 0 && macro_is_whitespace (arg[len - 1]))
652
    --len;
653
 
654
  /* Insert the string.  */
655
  appendc (dest, '"');
656
  while (len > 0)
657
    {
658
      /* We could try to handle strange cases here, like control
659
         characters, but there doesn't seem to be much point.  */
660
      if (macro_is_whitespace (*arg))
661
        {
662
          /* Replace a sequence of whitespace with a single space.  */
663
          appendc (dest, ' ');
664
          while (len > 1 && macro_is_whitespace (arg[1]))
665
            {
666
              ++arg;
667
              --len;
668
            }
669
        }
670
      else if (*arg == '\\' || *arg == '"')
671
        {
672
          appendc (dest, '\\');
673
          appendc (dest, *arg);
674
        }
675
      else
676
        appendc (dest, *arg);
677
      ++arg;
678
      --len;
679
    }
680
  appendc (dest, '"');
681
  dest->last_token = dest->len;
682
}
683
 
684
 
685
/* Expanding macros!  */
686
 
687
 
688
/* A singly-linked list of the names of the macros we are currently
689
   expanding --- for detecting expansion loops.  */
690
struct macro_name_list {
691
  const char *name;
692
  struct macro_name_list *next;
693
};
694
 
695
 
696
/* Return non-zero if we are currently expanding the macro named NAME,
697
   according to LIST; otherwise, return zero.
698
 
699
   You know, it would be possible to get rid of all the NO_LOOP
700
   arguments to these functions by simply generating a new lookup
701
   function and baton which refuses to find the definition for a
702
   particular macro, and otherwise delegates the decision to another
703
   function/baton pair.  But that makes the linked list of excluded
704
   macros chained through untyped baton pointers, which will make it
705
   harder to debug.  :( */
706
static int
707
currently_rescanning (struct macro_name_list *list, const char *name)
708
{
709
  for (; list; list = list->next)
710
    if (strcmp (name, list->name) == 0)
711
      return 1;
712
 
713
  return 0;
714
}
715
 
716
 
717
/* Gather the arguments to a macro expansion.
718
 
719
   NAME is the name of the macro being invoked.  (It's only used for
720
   printing error messages.)
721
 
722
   Assume that SRC is the text of the macro invocation immediately
723
   following the macro name.  For example, if we're processing the
724
   text foo(bar, baz), then NAME would be foo and SRC will be (bar,
725
   baz).
726
 
727
   If SRC doesn't start with an open paren ( token at all, return
728
   zero, leave SRC unchanged, and don't set *ARGC_P to anything.
729
 
730
   If SRC doesn't contain a properly terminated argument list, then
731
   raise an error.
732
 
733
   For a variadic macro, NARGS holds the number of formal arguments to
734
   the macro.  For a GNU-style variadic macro, this should be the
735
   number of named arguments.  For a non-variadic macro, NARGS should
736
   be -1.
737
 
738
   Otherwise, return a pointer to the first element of an array of
739
   macro buffers referring to the argument texts, and set *ARGC_P to
740
   the number of arguments we found --- the number of elements in the
741
   array.  The macro buffers share their text with SRC, and their
742
   last_token fields are initialized.  The array is allocated with
743
   xmalloc, and the caller is responsible for freeing it.
744
 
745
   NOTE WELL: if SRC starts with a open paren ( token followed
746
   immediately by a close paren ) token (e.g., the invocation looks
747
   like "foo()"), we treat that as one argument, which happens to be
748
   the empty list of tokens.  The caller should keep in mind that such
749
   a sequence of tokens is a valid way to invoke one-parameter
750
   function-like macros, but also a valid way to invoke zero-parameter
751
   function-like macros.  Eeew.
752
 
753
   Consume the tokens from SRC; after this call, SRC contains the text
754
   following the invocation.  */
755
 
756
static struct macro_buffer *
757
gather_arguments (const char *name, struct macro_buffer *src,
758
                  int nargs, int *argc_p)
759
{
760
  struct macro_buffer tok;
761
  int args_len, args_size;
762
  struct macro_buffer *args = NULL;
763
  struct cleanup *back_to = make_cleanup (free_current_contents, &args);
764
 
765
  /* Does SRC start with an opening paren token?  Read from a copy of
766
     SRC, so SRC itself is unaffected if we don't find an opening
767
     paren.  */
768
  {
769
    struct macro_buffer temp;
770
    init_shared_buffer (&temp, src->text, src->len);
771
 
772
    if (! get_token (&tok, &temp)
773
        || tok.len != 1
774
        || tok.text[0] != '(')
775
      {
776
        discard_cleanups (back_to);
777
        return 0;
778
      }
779
  }
780
 
781
  /* Consume SRC's opening paren.  */
782
  get_token (&tok, src);
783
 
784
  args_len = 0;
785
  args_size = 6;
786
  args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);
787
 
788
  for (;;)
789
    {
790
      struct macro_buffer *arg;
791
      int depth;
792
 
793
      /* Make sure we have room for the next argument.  */
794
      if (args_len >= args_size)
795
        {
796
          args_size *= 2;
797
          args = xrealloc (args, sizeof (*args) * args_size);
798
        }
799
 
800
      /* Initialize the next argument.  */
801
      arg = &args[args_len++];
802
      set_token (arg, src->text, src->text);
803
 
804
      /* Gather the argument's tokens.  */
805
      depth = 0;
806
      for (;;)
807
        {
808
          char *start = src->text;
809
 
810
          if (! get_token (&tok, src))
811
            error (_("Malformed argument list for macro `%s'."), name);
812
 
813
          /* Is tok an opening paren?  */
814
          if (tok.len == 1 && tok.text[0] == '(')
815
            depth++;
816
 
817
          /* Is tok is a closing paren?  */
818
          else if (tok.len == 1 && tok.text[0] == ')')
819
            {
820
              /* If it's a closing paren at the top level, then that's
821
                 the end of the argument list.  */
822
              if (depth == 0)
823
                {
824
                  /* In the varargs case, the last argument may be
825
                     missing.  Add an empty argument in this case.  */
826
                  if (nargs != -1 && args_len == nargs - 1)
827
                    {
828
                      /* Make sure we have room for the argument.  */
829
                      if (args_len >= args_size)
830
                        {
831
                          args_size++;
832
                          args = xrealloc (args, sizeof (*args) * args_size);
833
                        }
834
                      arg = &args[args_len++];
835
                      set_token (arg, src->text, src->text);
836
                    }
837
 
838
                  discard_cleanups (back_to);
839
                  *argc_p = args_len;
840
                  return args;
841
                }
842
 
843
              depth--;
844
            }
845
 
846
          /* If tok is a comma at top level, then that's the end of
847
             the current argument.  However, if we are handling a
848
             variadic macro and we are computing the last argument, we
849
             want to include the comma and remaining tokens.  */
850
          else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
851
                   && (nargs == -1 || args_len < nargs))
852
            break;
853
 
854
          /* Extend the current argument to enclose this token.  If
855
             this is the current argument's first token, leave out any
856
             leading whitespace, just for aesthetics.  */
857
          if (arg->len == 0)
858
            {
859
              arg->text = tok.text;
860
              arg->len = tok.len;
861
              arg->last_token = 0;
862
            }
863
          else
864
            {
865
              arg->len = (tok.text + tok.len) - arg->text;
866
              arg->last_token = tok.text - arg->text;
867
            }
868
        }
869
    }
870
}
871
 
872
 
873
/* The `expand' and `substitute_args' functions both invoke `scan'
874
   recursively, so we need a forward declaration somewhere.  */
875
static void scan (struct macro_buffer *dest,
876
                  struct macro_buffer *src,
877
                  struct macro_name_list *no_loop,
878
                  macro_lookup_ftype *lookup_func,
879
                  void *lookup_baton);
880
 
881
 
882
/* A helper function for substitute_args.
883
 
884
   ARGV is a vector of all the arguments; ARGC is the number of
885
   arguments.  IS_VARARGS is true if the macro being substituted is a
886
   varargs macro; in this case VA_ARG_NAME is the name of the
887
   "variable" argument.  VA_ARG_NAME is ignored if IS_VARARGS is
888
   false.
889
 
890
   If the token TOK is the name of a parameter, return the parameter's
891
   index.  If TOK is not an argument, return -1.  */
892
 
893
static int
894
find_parameter (const struct macro_buffer *tok,
895
                int is_varargs, const struct macro_buffer *va_arg_name,
896
                int argc, const char * const *argv)
897
{
898
  int i;
899
 
900
  if (! tok->is_identifier)
901
    return -1;
902
 
903
  for (i = 0; i < argc; ++i)
904
    if (tok->len == strlen (argv[i]) && ! memcmp (tok->text, argv[i], tok->len))
905
      return i;
906
 
907
  if (is_varargs && tok->len == va_arg_name->len
908
      && ! memcmp (tok->text, va_arg_name->text, tok->len))
909
    return argc - 1;
910
 
911
  return -1;
912
}
913
 
914
/* Given the macro definition DEF, being invoked with the actual
915
   arguments given by ARGC and ARGV, substitute the arguments into the
916
   replacement list, and store the result in DEST.
917
 
918
   IS_VARARGS should be true if DEF is a varargs macro.  In this case,
919
   VA_ARG_NAME should be the name of the "variable" argument -- either
920
   __VA_ARGS__ for c99-style varargs, or the final argument name, for
921
   GNU-style varargs.  If IS_VARARGS is false, this parameter is
922
   ignored.
923
 
924
   If it is necessary to expand macro invocations in one of the
925
   arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
926
   definitions, and don't expand invocations of the macros listed in
927
   NO_LOOP.  */
928
 
929
static void
930
substitute_args (struct macro_buffer *dest,
931
                 struct macro_definition *def,
932
                 int is_varargs, const struct macro_buffer *va_arg_name,
933
                 int argc, struct macro_buffer *argv,
934
                 struct macro_name_list *no_loop,
935
                 macro_lookup_ftype *lookup_func,
936
                 void *lookup_baton)
937
{
938
  /* A macro buffer for the macro's replacement list.  */
939
  struct macro_buffer replacement_list;
940
  /* The token we are currently considering.  */
941
  struct macro_buffer tok;
942
  /* The replacement list's pointer from just before TOK was lexed.  */
943
  char *original_rl_start;
944
  /* We have a single lookahead token to handle token splicing.  */
945
  struct macro_buffer lookahead;
946
  /* The lookahead token might not be valid.  */
947
  int lookahead_valid;
948
  /* The replacement list's pointer from just before LOOKAHEAD was
949
     lexed.  */
950
  char *lookahead_rl_start;
951
 
952
  init_shared_buffer (&replacement_list, (char *) def->replacement,
953
                      strlen (def->replacement));
954
 
955
  gdb_assert (dest->len == 0);
956
  dest->last_token = 0;
957
 
958
  original_rl_start = replacement_list.text;
959
  if (! get_token (&tok, &replacement_list))
960
    return;
961
  lookahead_rl_start = replacement_list.text;
962
  lookahead_valid = get_token (&lookahead, &replacement_list);
963
 
964
  for (;;)
965
    {
966
      /* Just for aesthetics.  If we skipped some whitespace, copy
967
         that to DEST.  */
968
      if (tok.text > original_rl_start)
969
        {
970
          appendmem (dest, original_rl_start, tok.text - original_rl_start);
971
          dest->last_token = dest->len;
972
        }
973
 
974
      /* Is this token the stringification operator?  */
975
      if (tok.len == 1
976
          && tok.text[0] == '#')
977
        {
978
          int arg;
979
 
980
          if (!lookahead_valid)
981
            error (_("Stringification operator requires an argument."));
982
 
983
          arg = find_parameter (&lookahead, is_varargs, va_arg_name,
984
                                def->argc, def->argv);
985
          if (arg == -1)
986
            error (_("Argument to stringification operator must name "
987
                     "a macro parameter."));
988
 
989
          stringify (dest, argv[arg].text, argv[arg].len);
990
 
991
          /* Read one token and let the loop iteration code handle the
992
             rest.  */
993
          lookahead_rl_start = replacement_list.text;
994
          lookahead_valid = get_token (&lookahead, &replacement_list);
995
        }
996
      /* Is this token the splicing operator?  */
997
      else if (tok.len == 2
998
               && tok.text[0] == '#'
999
               && tok.text[1] == '#')
1000
        error (_("Stray splicing operator"));
1001
      /* Is the next token the splicing operator?  */
1002
      else if (lookahead_valid
1003
               && lookahead.len == 2
1004
               && lookahead.text[0] == '#'
1005
               && lookahead.text[1] == '#')
1006
        {
1007
          int arg, finished = 0;
1008
          int prev_was_comma = 0;
1009
 
1010
          /* Note that GCC warns if the result of splicing is not a
1011
             token.  In the debugger there doesn't seem to be much
1012
             benefit from doing this.  */
1013
 
1014
          /* Insert the first token.  */
1015
          if (tok.len == 1 && tok.text[0] == ',')
1016
            prev_was_comma = 1;
1017
          else
1018
            {
1019
              int arg = find_parameter (&tok, is_varargs, va_arg_name,
1020
                                        def->argc, def->argv);
1021
              if (arg != -1)
1022
                appendmem (dest, argv[arg].text, argv[arg].len);
1023
              else
1024
                appendmem (dest, tok.text, tok.len);
1025
            }
1026
 
1027
          /* Apply a possible sequence of ## operators.  */
1028
          for (;;)
1029
            {
1030
              if (! get_token (&tok, &replacement_list))
1031
                error (_("Splicing operator at end of macro"));
1032
 
1033
              /* Handle a comma before a ##.  If we are handling
1034
                 varargs, and the token on the right hand side is the
1035
                 varargs marker, and the final argument is empty or
1036
                 missing, then drop the comma.  This is a GNU
1037
                 extension.  There is one ambiguous case here,
1038
                 involving pedantic behavior with an empty argument,
1039
                 but we settle that in favor of GNU-style (GCC uses an
1040
                 option).  If we aren't dealing with varargs, we
1041
                 simply insert the comma.  */
1042
              if (prev_was_comma)
1043
                {
1044
                  if (! (is_varargs
1045
                         && tok.len == va_arg_name->len
1046
                         && !memcmp (tok.text, va_arg_name->text, tok.len)
1047
                         && argv[argc - 1].len == 0))
1048
                    appendmem (dest, ",", 1);
1049
                  prev_was_comma = 0;
1050
                }
1051
 
1052
              /* Insert the token.  If it is a parameter, insert the
1053
                 argument.  If it is a comma, treat it specially.  */
1054
              if (tok.len == 1 && tok.text[0] == ',')
1055
                prev_was_comma = 1;
1056
              else
1057
                {
1058
                  int arg = find_parameter (&tok, is_varargs, va_arg_name,
1059
                                            def->argc, def->argv);
1060
                  if (arg != -1)
1061
                    appendmem (dest, argv[arg].text, argv[arg].len);
1062
                  else
1063
                    appendmem (dest, tok.text, tok.len);
1064
                }
1065
 
1066
              /* Now read another token.  If it is another splice, we
1067
                 loop.  */
1068
              original_rl_start = replacement_list.text;
1069
              if (! get_token (&tok, &replacement_list))
1070
                {
1071
                  finished = 1;
1072
                  break;
1073
                }
1074
 
1075
              if (! (tok.len == 2
1076
                     && tok.text[0] == '#'
1077
                     && tok.text[1] == '#'))
1078
                break;
1079
            }
1080
 
1081
          if (prev_was_comma)
1082
            {
1083
              /* We saw a comma.  Insert it now.  */
1084
              appendmem (dest, ",", 1);
1085
            }
1086
 
1087
          dest->last_token = dest->len;
1088
          if (finished)
1089
            lookahead_valid = 0;
1090
          else
1091
            {
1092
              /* Set up for the loop iterator.  */
1093
              lookahead = tok;
1094
              lookahead_rl_start = original_rl_start;
1095
              lookahead_valid = 1;
1096
            }
1097
        }
1098
      else
1099
        {
1100
          /* Is this token an identifier?  */
1101
          int substituted = 0;
1102
          int arg = find_parameter (&tok, is_varargs, va_arg_name,
1103
                                    def->argc, def->argv);
1104
 
1105
          if (arg != -1)
1106
            {
1107
              struct macro_buffer arg_src;
1108
 
1109
              /* Expand any macro invocations in the argument text,
1110
                 and append the result to dest.  Remember that scan
1111
                 mutates its source, so we need to scan a new buffer
1112
                 referring to the argument's text, not the argument
1113
                 itself.  */
1114
              init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
1115
              scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
1116
              substituted = 1;
1117
            }
1118
 
1119
          /* If it wasn't a parameter, then just copy it across.  */
1120
          if (! substituted)
1121
            append_tokens_without_splicing (dest, &tok);
1122
        }
1123
 
1124
      if (! lookahead_valid)
1125
        break;
1126
 
1127
      tok = lookahead;
1128
      original_rl_start = lookahead_rl_start;
1129
 
1130
      lookahead_rl_start = replacement_list.text;
1131
      lookahead_valid = get_token (&lookahead, &replacement_list);
1132
    }
1133
}
1134
 
1135
 
1136
/* Expand a call to a macro named ID, whose definition is DEF.  Append
1137
   its expansion to DEST.  SRC is the input text following the ID
1138
   token.  We are currently rescanning the expansions of the macros
1139
   named in NO_LOOP; don't re-expand them.  Use LOOKUP_FUNC and
1140
   LOOKUP_BATON to find definitions for any nested macro references.
1141
 
1142
   Return 1 if we decided to expand it, zero otherwise.  (If it's a
1143
   function-like macro name that isn't followed by an argument list,
1144
   we don't expand it.)  If we return zero, leave SRC unchanged.  */
1145
static int
1146
expand (const char *id,
1147
        struct macro_definition *def,
1148
        struct macro_buffer *dest,
1149
        struct macro_buffer *src,
1150
        struct macro_name_list *no_loop,
1151
        macro_lookup_ftype *lookup_func,
1152
        void *lookup_baton)
1153
{
1154
  struct macro_name_list new_no_loop;
1155
 
1156
  /* Create a new node to be added to the front of the no-expand list.
1157
     This list is appropriate for re-scanning replacement lists, but
1158
     it is *not* appropriate for scanning macro arguments; invocations
1159
     of the macro whose arguments we are gathering *do* get expanded
1160
     there.  */
1161
  new_no_loop.name = id;
1162
  new_no_loop.next = no_loop;
1163
 
1164
  /* What kind of macro are we expanding?  */
1165
  if (def->kind == macro_object_like)
1166
    {
1167
      struct macro_buffer replacement_list;
1168
 
1169
      init_shared_buffer (&replacement_list, (char *) def->replacement,
1170
                          strlen (def->replacement));
1171
 
1172
      scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
1173
      return 1;
1174
    }
1175
  else if (def->kind == macro_function_like)
1176
    {
1177
      struct cleanup *back_to = make_cleanup (null_cleanup, 0);
1178
      int argc = 0;
1179
      struct macro_buffer *argv = NULL;
1180
      struct macro_buffer substituted;
1181
      struct macro_buffer substituted_src;
1182
      struct macro_buffer va_arg_name;
1183
      int is_varargs = 0;
1184
 
1185
      if (def->argc >= 1)
1186
        {
1187
          if (strcmp (def->argv[def->argc - 1], "...") == 0)
1188
            {
1189
              /* In C99-style varargs, substitution is done using
1190
                 __VA_ARGS__.  */
1191
              init_shared_buffer (&va_arg_name, "__VA_ARGS__",
1192
                                  strlen ("__VA_ARGS__"));
1193
              is_varargs = 1;
1194
            }
1195
          else
1196
            {
1197
              int len = strlen (def->argv[def->argc - 1]);
1198
              if (len > 3
1199
                  && strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
1200
                {
1201
                  /* In GNU-style varargs, the name of the
1202
                     substitution parameter is the name of the formal
1203
                     argument without the "...".  */
1204
                  init_shared_buffer (&va_arg_name,
1205
                                      (char *) def->argv[def->argc - 1],
1206
                                      len - 3);
1207
                  is_varargs = 1;
1208
                }
1209
            }
1210
        }
1211
 
1212
      make_cleanup (free_current_contents, &argv);
1213
      argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
1214
                               &argc);
1215
 
1216
      /* If we couldn't find any argument list, then we don't expand
1217
         this macro.  */
1218
      if (! argv)
1219
        {
1220
          do_cleanups (back_to);
1221
          return 0;
1222
        }
1223
 
1224
      /* Check that we're passing an acceptable number of arguments for
1225
         this macro.  */
1226
      if (argc != def->argc)
1227
        {
1228
          if (is_varargs && argc >= def->argc - 1)
1229
            {
1230
              /* Ok.  */
1231
            }
1232
          /* Remember that a sequence of tokens like "foo()" is a
1233
             valid invocation of a macro expecting either zero or one
1234
             arguments.  */
1235
          else if (! (argc == 1
1236
                      && argv[0].len == 0
1237
                      && def->argc == 0))
1238
            error (_("Wrong number of arguments to macro `%s' "
1239
                   "(expected %d, got %d)."),
1240
                   id, def->argc, argc);
1241
        }
1242
 
1243
      /* Note that we don't expand macro invocations in the arguments
1244
         yet --- we let subst_args take care of that.  Parameters that
1245
         appear as operands of the stringifying operator "#" or the
1246
         splicing operator "##" don't get macro references expanded,
1247
         so we can't really tell whether it's appropriate to macro-
1248
         expand an argument until we see how it's being used.  */
1249
      init_buffer (&substituted, 0);
1250
      make_cleanup (cleanup_macro_buffer, &substituted);
1251
      substitute_args (&substituted, def, is_varargs, &va_arg_name,
1252
                       argc, argv, no_loop, lookup_func, lookup_baton);
1253
 
1254
      /* Now `substituted' is the macro's replacement list, with all
1255
         argument values substituted into it properly.  Re-scan it for
1256
         macro references, but don't expand invocations of this macro.
1257
 
1258
         We create a new buffer, `substituted_src', which points into
1259
         `substituted', and scan that.  We can't scan `substituted'
1260
         itself, since the tokenization process moves the buffer's
1261
         text pointer around, and we still need to be able to find
1262
         `substituted's original text buffer after scanning it so we
1263
         can free it.  */
1264
      init_shared_buffer (&substituted_src, substituted.text, substituted.len);
1265
      scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
1266
 
1267
      do_cleanups (back_to);
1268
 
1269
      return 1;
1270
    }
1271
  else
1272
    internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
1273
}
1274
 
1275
 
1276
/* If the single token in SRC_FIRST followed by the tokens in SRC_REST
1277
   constitute a macro invokation not forbidden in NO_LOOP, append its
1278
   expansion to DEST and return non-zero.  Otherwise, return zero, and
1279
   leave DEST unchanged.
1280
 
1281
   SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
1282
   SRC_FIRST must be a string built by get_token.  */
1283
static int
1284
maybe_expand (struct macro_buffer *dest,
1285
              struct macro_buffer *src_first,
1286
              struct macro_buffer *src_rest,
1287
              struct macro_name_list *no_loop,
1288
              macro_lookup_ftype *lookup_func,
1289
              void *lookup_baton)
1290
{
1291
  gdb_assert (src_first->shared);
1292
  gdb_assert (src_rest->shared);
1293
  gdb_assert (! dest->shared);
1294
 
1295
  /* Is this token an identifier?  */
1296
  if (src_first->is_identifier)
1297
    {
1298
      /* Make a null-terminated copy of it, since that's what our
1299
         lookup function expects.  */
1300
      char *id = xmalloc (src_first->len + 1);
1301
      struct cleanup *back_to = make_cleanup (xfree, id);
1302
      memcpy (id, src_first->text, src_first->len);
1303
      id[src_first->len] = 0;
1304
 
1305
      /* If we're currently re-scanning the result of expanding
1306
         this macro, don't expand it again.  */
1307
      if (! currently_rescanning (no_loop, id))
1308
        {
1309
          /* Does this identifier have a macro definition in scope?  */
1310
          struct macro_definition *def = lookup_func (id, lookup_baton);
1311
 
1312
          if (def && expand (id, def, dest, src_rest, no_loop,
1313
                             lookup_func, lookup_baton))
1314
            {
1315
              do_cleanups (back_to);
1316
              return 1;
1317
            }
1318
        }
1319
 
1320
      do_cleanups (back_to);
1321
    }
1322
 
1323
  return 0;
1324
}
1325
 
1326
 
1327
/* Expand macro references in SRC, appending the results to DEST.
1328
   Assume we are re-scanning the result of expanding the macros named
1329
   in NO_LOOP, and don't try to re-expand references to them.
1330
 
1331
   SRC must be a shared buffer; DEST must not be one.  */
1332
static void
1333
scan (struct macro_buffer *dest,
1334
      struct macro_buffer *src,
1335
      struct macro_name_list *no_loop,
1336
      macro_lookup_ftype *lookup_func,
1337
      void *lookup_baton)
1338
{
1339
  gdb_assert (src->shared);
1340
  gdb_assert (! dest->shared);
1341
 
1342
  for (;;)
1343
    {
1344
      struct macro_buffer tok;
1345
      char *original_src_start = src->text;
1346
 
1347
      /* Find the next token in SRC.  */
1348
      if (! get_token (&tok, src))
1349
        break;
1350
 
1351
      /* Just for aesthetics.  If we skipped some whitespace, copy
1352
         that to DEST.  */
1353
      if (tok.text > original_src_start)
1354
        {
1355
          appendmem (dest, original_src_start, tok.text - original_src_start);
1356
          dest->last_token = dest->len;
1357
        }
1358
 
1359
      if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
1360
        /* We didn't end up expanding tok as a macro reference, so
1361
           simply append it to dest.  */
1362
        append_tokens_without_splicing (dest, &tok);
1363
    }
1364
 
1365
  /* Just for aesthetics.  If there was any trailing whitespace in
1366
     src, copy it to dest.  */
1367
  if (src->len)
1368
    {
1369
      appendmem (dest, src->text, src->len);
1370
      dest->last_token = dest->len;
1371
    }
1372
}
1373
 
1374
 
1375
char *
1376
macro_expand (const char *source,
1377
              macro_lookup_ftype *lookup_func,
1378
              void *lookup_func_baton)
1379
{
1380
  struct macro_buffer src, dest;
1381
  struct cleanup *back_to;
1382
 
1383
  init_shared_buffer (&src, (char *) source, strlen (source));
1384
 
1385
  init_buffer (&dest, 0);
1386
  dest.last_token = 0;
1387
  back_to = make_cleanup (cleanup_macro_buffer, &dest);
1388
 
1389
  scan (&dest, &src, 0, lookup_func, lookup_func_baton);
1390
 
1391
  appendc (&dest, '\0');
1392
 
1393
  discard_cleanups (back_to);
1394
  return dest.text;
1395
}
1396
 
1397
 
1398
char *
1399
macro_expand_once (const char *source,
1400
                   macro_lookup_ftype *lookup_func,
1401
                   void *lookup_func_baton)
1402
{
1403
  error (_("Expand-once not implemented yet."));
1404
}
1405
 
1406
 
1407
char *
1408
macro_expand_next (char **lexptr,
1409
                   macro_lookup_ftype *lookup_func,
1410
                   void *lookup_baton)
1411
{
1412
  struct macro_buffer src, dest, tok;
1413
  struct cleanup *back_to;
1414
 
1415
  /* Set up SRC to refer to the input text, pointed to by *lexptr.  */
1416
  init_shared_buffer (&src, *lexptr, strlen (*lexptr));
1417
 
1418
  /* Set up DEST to receive the expansion, if there is one.  */
1419
  init_buffer (&dest, 0);
1420
  dest.last_token = 0;
1421
  back_to = make_cleanup (cleanup_macro_buffer, &dest);
1422
 
1423
  /* Get the text's first preprocessing token.  */
1424
  if (! get_token (&tok, &src))
1425
    {
1426
      do_cleanups (back_to);
1427
      return 0;
1428
    }
1429
 
1430
  /* If it's a macro invocation, expand it.  */
1431
  if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
1432
    {
1433
      /* It was a macro invocation!  Package up the expansion as a
1434
         null-terminated string and return it.  Set *lexptr to the
1435
         start of the next token in the input.  */
1436
      appendc (&dest, '\0');
1437
      discard_cleanups (back_to);
1438
      *lexptr = src.text;
1439
      return dest.text;
1440
    }
1441
  else
1442
    {
1443
      /* It wasn't a macro invocation.  */
1444
      do_cleanups (back_to);
1445
      return 0;
1446
    }
1447
}

powered by: WebSVN 2.1.0

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