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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [completer.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Line completion stuff for GDB, the GNU debugger.
2
   Copyright (C) 2000, 2001, 2007, 2008 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
 
19
#include "defs.h"
20
#include "symtab.h"
21
#include "gdbtypes.h"
22
#include "expression.h"
23
#include "filenames.h"          /* For DOSish file names.  */
24
#include "language.h"
25
 
26
#include "cli/cli-decode.h"
27
 
28
/* FIXME: This is needed because of lookup_cmd_1 ().  We should be
29
   calling a hook instead so we eliminate the CLI dependency.  */
30
#include "gdbcmd.h"
31
 
32
/* Needed for rl_completer_word_break_characters() and for
33
   rl_filename_completion_function.  */
34
#include "readline/readline.h"
35
 
36
/* readline defines this.  */
37
#undef savestring
38
 
39
#include "completer.h"
40
 
41
/* Prototypes for local functions.  */
42
static
43
char *line_completion_function (const char *text, int matches,
44
                                char *line_buffer,
45
                                int point);
46
 
47
/* readline uses the word breaks for two things:
48
   (1) In figuring out where to point the TEXT parameter to the
49
   rl_completion_entry_function.  Since we don't use TEXT for much,
50
   it doesn't matter a lot what the word breaks are for this purpose, but
51
   it does affect how much stuff M-? lists.
52
   (2) If one of the matches contains a word break character, readline
53
   will quote it.  That's why we switch between
54
   current_language->la_word_break_characters() and
55
   gdb_completer_command_word_break_characters.  I'm not sure when
56
   we need this behavior (perhaps for funky characters in C++ symbols?).  */
57
 
58
/* Variables which are necessary for fancy command line editing.  */
59
 
60
/* When completing on command names, we remove '-' from the list of
61
   word break characters, since we use it in command names.  If the
62
   readline library sees one in any of the current completion strings,
63
   it thinks that the string needs to be quoted and automatically supplies
64
   a leading quote.  */
65
static char *gdb_completer_command_word_break_characters =
66
" \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
67
 
68
/* When completing on file names, we remove from the list of word
69
   break characters any characters that are commonly used in file
70
   names, such as '-', '+', '~', etc.  Otherwise, readline displays
71
   incorrect completion candidates.  */
72
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
73
/* MS-DOS and MS-Windows use colon as part of the drive spec, and most
74
   programs support @foo style response files.  */
75
static char *gdb_completer_file_name_break_characters = " \t\n*|\"';?><@";
76
#else
77
static char *gdb_completer_file_name_break_characters = " \t\n*|\"';:?><";
78
#endif
79
 
80
/* These are used when completing on locations, which can mix file
81
   names and symbol names separated by a colon.  */
82
static char *gdb_completer_loc_break_characters = " \t\n*|\"';:?><,";
83
 
84
/* Characters that can be used to quote completion strings.  Note that we
85
   can't include '"' because the gdb C parser treats such quoted sequences
86
   as strings.  */
87
static char *gdb_completer_quote_characters = "'";
88
 
89
/* Accessor for some completer data that may interest other files.  */
90
 
91
char *
92
get_gdb_completer_quote_characters (void)
93
{
94
  return gdb_completer_quote_characters;
95
}
96
 
97
/* Line completion interface function for readline.  */
98
 
99
char *
100
readline_line_completion_function (const char *text, int matches)
101
{
102
  return line_completion_function (text, matches, rl_line_buffer, rl_point);
103
}
104
 
105
/* This can be used for functions which don't want to complete on symbols
106
   but don't want to complete on anything else either.  */
107
char **
108
noop_completer (char *text, char *prefix)
109
{
110
  return NULL;
111
}
112
 
113
/* Complete on filenames.  */
114
char **
115
filename_completer (char *text, char *word)
116
{
117
  int subsequent_name;
118
  char **return_val;
119
  int return_val_used;
120
  int return_val_alloced;
121
 
122
  return_val_used = 0;
123
  /* Small for testing.  */
124
  return_val_alloced = 1;
125
  return_val = (char **) xmalloc (return_val_alloced * sizeof (char *));
126
 
127
  subsequent_name = 0;
128
  while (1)
129
    {
130
      char *p, *q;
131
      p = rl_filename_completion_function (text, subsequent_name);
132
      if (return_val_used >= return_val_alloced)
133
        {
134
          return_val_alloced *= 2;
135
          return_val =
136
            (char **) xrealloc (return_val,
137
                                return_val_alloced * sizeof (char *));
138
        }
139
      if (p == NULL)
140
        {
141
          return_val[return_val_used++] = p;
142
          break;
143
        }
144
      /* We need to set subsequent_name to a non-zero value before the
145
         continue line below, because otherwise, if the first file seen
146
         by GDB is a backup file whose name ends in a `~', we will loop
147
         indefinitely.  */
148
      subsequent_name = 1;
149
      /* Like emacs, don't complete on old versions.  Especially useful
150
         in the "source" command.  */
151
      if (p[strlen (p) - 1] == '~')
152
        {
153
          xfree (p);
154
          continue;
155
        }
156
 
157
      if (word == text)
158
        /* Return exactly p.  */
159
        return_val[return_val_used++] = p;
160
      else if (word > text)
161
        {
162
          /* Return some portion of p.  */
163
          q = xmalloc (strlen (p) + 5);
164
          strcpy (q, p + (word - text));
165
          return_val[return_val_used++] = q;
166
          xfree (p);
167
        }
168
      else
169
        {
170
          /* Return some of TEXT plus p.  */
171
          q = xmalloc (strlen (p) + (text - word) + 5);
172
          strncpy (q, word, text - word);
173
          q[text - word] = '\0';
174
          strcat (q, p);
175
          return_val[return_val_used++] = q;
176
          xfree (p);
177
        }
178
    }
179
#if 0
180
  /* There is no way to do this just long enough to affect quote inserting
181
     without also affecting the next completion.  This should be fixed in
182
     readline.  FIXME.  */
183
  /* Ensure that readline does the right thing
184
     with respect to inserting quotes.  */
185
  rl_completer_word_break_characters = "";
186
#endif
187
  return return_val;
188
}
189
 
190
/* Complete on locations, which might be of two possible forms:
191
 
192
       file:line
193
   or
194
       symbol+offset
195
 
196
   This is intended to be used in commands that set breakpoints etc.  */
197
char **
198
location_completer (char *text, char *word)
199
{
200
  int n_syms = 0, n_files = 0;
201
  char ** fn_list = NULL;
202
  char ** list = NULL;
203
  char *p;
204
  int quote_found = 0;
205
  int quoted = *text == '\'' || *text == '"';
206
  int quote_char = '\0';
207
  char *colon = NULL;
208
  char *file_to_match = NULL;
209
  char *symbol_start = text;
210
  char *orig_text = text;
211
  size_t text_len;
212
 
213
  /* Do we have an unquoted colon, as in "break foo.c::bar"?  */
214
  for (p = text; *p != '\0'; ++p)
215
    {
216
      if (*p == '\\' && p[1] == '\'')
217
        p++;
218
      else if (*p == '\'' || *p == '"')
219
        {
220
          quote_found = *p;
221
          quote_char = *p++;
222
          while (*p != '\0' && *p != quote_found)
223
            {
224
              if (*p == '\\' && p[1] == quote_found)
225
                p++;
226
              p++;
227
            }
228
 
229
          if (*p == quote_found)
230
            quote_found = 0;
231
          else
232
            break;              /* Hit the end of text.  */
233
        }
234
#if HAVE_DOS_BASED_FILE_SYSTEM
235
      /* If we have a DOS-style absolute file name at the beginning of
236
         TEXT, and the colon after the drive letter is the only colon
237
         we found, pretend the colon is not there.  */
238
      else if (p < text + 3 && *p == ':' && p == text + 1 + quoted)
239
        ;
240
#endif
241
      else if (*p == ':' && !colon)
242
        {
243
          colon = p;
244
          symbol_start = p + 1;
245
        }
246
      else if (strchr (current_language->la_word_break_characters(), *p))
247
        symbol_start = p + 1;
248
    }
249
 
250
  if (quoted)
251
    text++;
252
  text_len = strlen (text);
253
 
254
  /* Where is the file name?  */
255
  if (colon)
256
    {
257
      char *s;
258
 
259
      file_to_match = (char *) xmalloc (colon - text + 1);
260
      strncpy (file_to_match, text, colon - text + 1);
261
      /* Remove trailing colons and quotes from the file name.  */
262
      for (s = file_to_match + (colon - text);
263
           s > file_to_match;
264
           s--)
265
        if (*s == ':' || *s == quote_char)
266
          *s = '\0';
267
    }
268
  /* If the text includes a colon, they want completion only on a
269
     symbol name after the colon.  Otherwise, we need to complete on
270
     symbols as well as on files.  */
271
  if (colon)
272
    {
273
      list = make_file_symbol_completion_list (symbol_start, word,
274
                                               file_to_match);
275
      xfree (file_to_match);
276
    }
277
  else
278
    {
279
      list = make_symbol_completion_list (symbol_start, word);
280
      /* If text includes characters which cannot appear in a file
281
         name, they cannot be asking for completion on files.  */
282
      if (strcspn (text,
283
                   gdb_completer_file_name_break_characters) == text_len)
284
        fn_list = make_source_files_completion_list (text, text);
285
    }
286
 
287
  /* How many completions do we have in both lists?  */
288
  if (fn_list)
289
    for ( ; fn_list[n_files]; n_files++)
290
      ;
291
  if (list)
292
    for ( ; list[n_syms]; n_syms++)
293
      ;
294
 
295
  /* Make list[] large enough to hold both lists, then catenate
296
     fn_list[] onto the end of list[].  */
297
  if (n_syms && n_files)
298
    {
299
      list = xrealloc (list, (n_syms + n_files + 1) * sizeof (char *));
300
      memcpy (list + n_syms, fn_list, (n_files + 1) * sizeof (char *));
301
      xfree (fn_list);
302
    }
303
  else if (n_files)
304
    {
305
      /* If we only have file names as possible completion, we should
306
         bring them in sync with what rl_complete expects.  The
307
         problem is that if the user types "break /foo/b TAB", and the
308
         possible completions are "/foo/bar" and "/foo/baz"
309
         rl_complete expects us to return "bar" and "baz", without the
310
         leading directories, as possible completions, because `word'
311
         starts at the "b".  But we ignore the value of `word' when we
312
         call make_source_files_completion_list above (because that
313
         would not DTRT when the completion results in both symbols
314
         and file names), so make_source_files_completion_list returns
315
         the full "/foo/bar" and "/foo/baz" strings.  This produces
316
         wrong results when, e.g., there's only one possible
317
         completion, because rl_complete will prepend "/foo/" to each
318
         candidate completion.  The loop below removes that leading
319
         part.  */
320
      for (n_files = 0; fn_list[n_files]; n_files++)
321
        {
322
          memmove (fn_list[n_files], fn_list[n_files] + (word - text),
323
                   strlen (fn_list[n_files]) + 1 - (word - text));
324
        }
325
      /* Return just the file-name list as the result.  */
326
      list = fn_list;
327
    }
328
  else if (!n_syms)
329
    {
330
      /* No completions at all.  As the final resort, try completing
331
         on the entire text as a symbol.  */
332
      list = make_symbol_completion_list (orig_text, word);
333
      xfree (fn_list);
334
    }
335
  else
336
    xfree (fn_list);
337
 
338
  return list;
339
}
340
 
341
/* Complete on command names.  Used by "help".  */
342
char **
343
command_completer (char *text, char *word)
344
{
345
  return complete_on_cmdlist (cmdlist, text, word);
346
}
347
 
348
 
349
/* Here are some useful test cases for completion.  FIXME: These should
350
   be put in the test suite.  They should be tested with both M-? and TAB.
351
 
352
   "show output-" "radix"
353
   "show output" "-radix"
354
   "p" ambiguous (commands starting with p--path, print, printf, etc.)
355
   "p "  ambiguous (all symbols)
356
   "info t foo" no completions
357
   "info t " no completions
358
   "info t" ambiguous ("info target", "info terminal", etc.)
359
   "info ajksdlfk" no completions
360
   "info ajksdlfk " no completions
361
   "info" " "
362
   "info " ambiguous (all info commands)
363
   "p \"a" no completions (string constant)
364
   "p 'a" ambiguous (all symbols starting with a)
365
   "p b-a" ambiguous (all symbols starting with a)
366
   "p b-" ambiguous (all symbols)
367
   "file Make" "file" (word break hard to screw up here)
368
   "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
369
 */
370
 
371
/* Generate completions all at once.  Returns a NULL-terminated array
372
   of strings.  Both the array and each element are allocated with
373
   xmalloc.  It can also return NULL if there are no completions.
374
 
375
   TEXT is the caller's idea of the "word" we are looking at.
376
 
377
   LINE_BUFFER is available to be looked at; it contains the entire text
378
   of the line.  POINT is the offset in that line of the cursor.  You
379
   should pretend that the line ends at POINT.  */
380
 
381
char **
382
complete_line (const char *text, char *line_buffer, int point)
383
{
384
  char **list = NULL;
385
  char *tmp_command, *p;
386
  /* Pointer within tmp_command which corresponds to text.  */
387
  char *word;
388
  struct cmd_list_element *c, *result_list;
389
 
390
  /* Choose the default set of word break characters to break completions.
391
     If we later find out that we are doing completions on command strings
392
     (as opposed to strings supplied by the individual command completer
393
     functions, which can be any string) then we will switch to the
394
     special word break set for command strings, which leaves out the
395
     '-' character used in some commands.  */
396
 
397
  rl_completer_word_break_characters =
398
    current_language->la_word_break_characters();
399
 
400
  /* Decide whether to complete on a list of gdb commands or on symbols. */
401
  tmp_command = (char *) alloca (point + 1);
402
  p = tmp_command;
403
 
404
  strncpy (tmp_command, line_buffer, point);
405
  tmp_command[point] = '\0';
406
  /* Since text always contains some number of characters leading up
407
     to point, we can find the equivalent position in tmp_command
408
     by subtracting that many characters from the end of tmp_command.  */
409
  word = tmp_command + point - strlen (text);
410
 
411
  if (point == 0)
412
    {
413
      /* An empty line we want to consider ambiguous; that is, it
414
         could be any command.  */
415
      c = (struct cmd_list_element *) -1;
416
      result_list = 0;
417
    }
418
  else
419
    {
420
      c = lookup_cmd_1 (&p, cmdlist, &result_list, 1);
421
    }
422
 
423
  /* Move p up to the next interesting thing.  */
424
  while (*p == ' ' || *p == '\t')
425
    {
426
      p++;
427
    }
428
 
429
  if (!c)
430
    {
431
      /* It is an unrecognized command.  So there are no
432
         possible completions.  */
433
      list = NULL;
434
    }
435
  else if (c == (struct cmd_list_element *) -1)
436
    {
437
      char *q;
438
 
439
      /* lookup_cmd_1 advances p up to the first ambiguous thing, but
440
         doesn't advance over that thing itself.  Do so now.  */
441
      q = p;
442
      while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
443
        ++q;
444
      if (q != tmp_command + point)
445
        {
446
          /* There is something beyond the ambiguous
447
             command, so there are no possible completions.  For
448
             example, "info t " or "info t foo" does not complete
449
             to anything, because "info t" can be "info target" or
450
             "info terminal".  */
451
          list = NULL;
452
        }
453
      else
454
        {
455
          /* We're trying to complete on the command which was ambiguous.
456
             This we can deal with.  */
457
          if (result_list)
458
            {
459
              list = complete_on_cmdlist (*result_list->prefixlist, p,
460
                                          word);
461
            }
462
          else
463
            {
464
              list = complete_on_cmdlist (cmdlist, p, word);
465
            }
466
          /* Ensure that readline does the right thing with respect to
467
             inserting quotes.  */
468
          rl_completer_word_break_characters =
469
            gdb_completer_command_word_break_characters;
470
        }
471
    }
472
  else
473
    {
474
      /* We've recognized a full command.  */
475
 
476
      if (p == tmp_command + point)
477
        {
478
          /* There is no non-whitespace in the line beyond the command.  */
479
 
480
          if (p[-1] == ' ' || p[-1] == '\t')
481
            {
482
              /* The command is followed by whitespace; we need to complete
483
                 on whatever comes after command.  */
484
              if (c->prefixlist)
485
                {
486
                  /* It is a prefix command; what comes after it is
487
                     a subcommand (e.g. "info ").  */
488
                  list = complete_on_cmdlist (*c->prefixlist, p, word);
489
 
490
                  /* Ensure that readline does the right thing
491
                     with respect to inserting quotes.  */
492
                  rl_completer_word_break_characters =
493
                    gdb_completer_command_word_break_characters;
494
                }
495
              else if (c->enums)
496
                {
497
                  list = complete_on_enum (c->enums, p, word);
498
                  rl_completer_word_break_characters =
499
                    gdb_completer_command_word_break_characters;
500
                }
501
              else
502
                {
503
                  /* It is a normal command; what comes after it is
504
                     completed by the command's completer function.  */
505
                  if (c->completer == filename_completer)
506
                    {
507
                      /* Many commands which want to complete on
508
                         file names accept several file names, as
509
                         in "run foo bar >>baz".  So we don't want
510
                         to complete the entire text after the
511
                         command, just the last word.  To this
512
                         end, we need to find the beginning of the
513
                         file name by starting at `word' and going
514
                         backwards.  */
515
                      for (p = word;
516
                           p > tmp_command
517
                             && strchr (gdb_completer_file_name_break_characters, p[-1]) == NULL;
518
                           p--)
519
                        ;
520
                      rl_completer_word_break_characters =
521
                        gdb_completer_file_name_break_characters;
522
                    }
523
                  else if (c->completer == location_completer)
524
                    {
525
                      /* Commands which complete on locations want to
526
                         see the entire argument.  */
527
                      for (p = word;
528
                           p > tmp_command
529
                             && p[-1] != ' ' && p[-1] != '\t';
530
                           p--)
531
                        ;
532
                    }
533
                  list = (*c->completer) (p, word);
534
                }
535
            }
536
          else
537
            {
538
              /* The command is not followed by whitespace; we need to
539
                 complete on the command itself.  e.g. "p" which is a
540
                 command itself but also can complete to "print", "ptype"
541
                 etc.  */
542
              char *q;
543
 
544
              /* Find the command we are completing on.  */
545
              q = p;
546
              while (q > tmp_command)
547
                {
548
                  if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
549
                    --q;
550
                  else
551
                    break;
552
                }
553
 
554
              list = complete_on_cmdlist (result_list, q, word);
555
 
556
              /* Ensure that readline does the right thing
557
                 with respect to inserting quotes.  */
558
              rl_completer_word_break_characters =
559
                gdb_completer_command_word_break_characters;
560
            }
561
        }
562
      else
563
        {
564
          /* There is non-whitespace beyond the command.  */
565
 
566
          if (c->prefixlist && !c->allow_unknown)
567
            {
568
              /* It is an unrecognized subcommand of a prefix command,
569
                 e.g. "info adsfkdj".  */
570
              list = NULL;
571
            }
572
          else if (c->enums)
573
            {
574
              list = complete_on_enum (c->enums, p, word);
575
            }
576
          else
577
            {
578
              /* It is a normal command.  */
579
              if (c->completer == filename_completer)
580
                {
581
                  /* See the commentary above about the specifics
582
                     of file-name completion.  */
583
                  for (p = word;
584
                       p > tmp_command
585
                         && strchr (gdb_completer_file_name_break_characters, p[-1]) == NULL;
586
                       p--)
587
                    ;
588
                  rl_completer_word_break_characters =
589
                    gdb_completer_file_name_break_characters;
590
                }
591
              else if (c->completer == location_completer)
592
                {
593
                  for (p = word;
594
                       p > tmp_command
595
                         && p[-1] != ' ' && p[-1] != '\t';
596
                       p--)
597
                    ;
598
                }
599
              list = (*c->completer) (p, word);
600
            }
601
        }
602
    }
603
 
604
  return list;
605
}
606
 
607
/* Generate completions one by one for the completer.  Each time we are
608
   called return another potential completion to the caller.
609
   line_completion just completes on commands or passes the buck to the
610
   command's completer function, the stuff specific to symbol completion
611
   is in make_symbol_completion_list.
612
 
613
   TEXT is the caller's idea of the "word" we are looking at.
614
 
615
   MATCHES is the number of matches that have currently been collected from
616
   calling this completion function.  When zero, then we need to initialize,
617
   otherwise the initialization has already taken place and we can just
618
   return the next potential completion string.
619
 
620
   LINE_BUFFER is available to be looked at; it contains the entire text
621
   of the line.  POINT is the offset in that line of the cursor.  You
622
   should pretend that the line ends at POINT.
623
 
624
   Returns NULL if there are no more completions, else a pointer to a string
625
   which is a possible completion, it is the caller's responsibility to
626
   free the string.  */
627
 
628
static char *
629
line_completion_function (const char *text, int matches,
630
                          char *line_buffer, int point)
631
{
632
  static char **list = (char **) NULL;  /* Cache of completions.  */
633
  static int index;                     /* Next cached completion.  */
634
  char *output = NULL;
635
 
636
  if (matches == 0)
637
    {
638
      /* The caller is beginning to accumulate a new set of completions, so
639
         we need to find all of them now, and cache them for returning one at
640
         a time on future calls.  */
641
 
642
      if (list)
643
        {
644
          /* Free the storage used by LIST, but not by the strings inside.
645
             This is because rl_complete_internal () frees the strings.  */
646
          xfree (list);
647
        }
648
      index = 0;
649
      list = complete_line (text, line_buffer, point);
650
    }
651
 
652
  /* If we found a list of potential completions during initialization then
653
     dole them out one at a time.  The vector of completions is NULL
654
     terminated, so after returning the last one, return NULL (and continue
655
     to do so) each time we are called after that, until a new list is
656
     available.  */
657
 
658
  if (list)
659
    {
660
      output = list[index];
661
      if (output)
662
        {
663
          index++;
664
        }
665
    }
666
 
667
#if 0
668
  /* Can't do this because readline hasn't yet checked the word breaks
669
     for figuring out whether to insert a quote.  */
670
  if (output == NULL)
671
    /* Make sure the word break characters are set back to normal for the
672
       next time that readline tries to complete something.  */
673
    rl_completer_word_break_characters =
674
      current_language->la_word_break_characters();
675
#endif
676
 
677
  return (output);
678
}
679
 
680
/* Skip over the possibly quoted word STR (as defined by the quote
681
   characters QUOTECHARS and the the word break characters
682
   BREAKCHARS).  Returns pointer to the location after the "word".  If
683
   either QUOTECHARS or BREAKCHARS is NULL, use the same values used
684
   by the completer.  */
685
 
686
char *
687
skip_quoted_chars (char *str, char *quotechars, char *breakchars)
688
{
689
  char quote_char = '\0';
690
  char *scan;
691
 
692
  if (quotechars == NULL)
693
    quotechars = gdb_completer_quote_characters;
694
 
695
  if (breakchars == NULL)
696
    breakchars = current_language->la_word_break_characters();
697
 
698
  for (scan = str; *scan != '\0'; scan++)
699
    {
700
      if (quote_char != '\0')
701
        {
702
          /* Ignore everything until the matching close quote char.  */
703
          if (*scan == quote_char)
704
            {
705
              /* Found matching close quote.  */
706
              scan++;
707
              break;
708
            }
709
        }
710
      else if (strchr (quotechars, *scan))
711
        {
712
          /* Found start of a quoted string. */
713
          quote_char = *scan;
714
        }
715
      else if (strchr (breakchars, *scan))
716
        {
717
          break;
718
        }
719
    }
720
 
721
  return (scan);
722
}
723
 
724
/* Skip over the possibly quoted word STR (as defined by the quote
725
   characters and word break characters used by the completer).
726
   Returns pointer to the location after the "word".  */
727
 
728
char *
729
skip_quoted (char *str)
730
{
731
  return skip_quoted_chars (str, NULL, NULL);
732
}

powered by: WebSVN 2.1.0

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