/* Header for GDB line completion.
   Copyright (C) 2000-2024 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifndef GDB_LINESPEC_H
#define GDB_LINESPEC_H

struct symtab;

#include "location.h"

/* Flags to pass to decode_line_1 and decode_line_full.  */

enum decode_line_flags
  {
    /* Set this flag if you want the resulting SALs to describe the
       first line of indicated functions.  */
    DECODE_LINE_FUNFIRSTLINE = 1,

    /* Set this flag if you want "list mode".  In this mode, a
       FILE:LINE linespec will always return a result, and such
       linespecs will not be expanded to all matches.  */
    DECODE_LINE_LIST_MODE = 2
  };

/* decode_line_full returns a vector of these.  */

struct linespec_sals
{
  /* This is the location corresponding to the sals contained in this
     object.  It can be passed as the FILTER argument to future calls
     to decode_line_full.  This is freed by the linespec_result
     destructor.  */
  char *canonical;

  /* Sals.  */
  std::vector<symtab_and_line> sals;
};

/* An instance of this may be filled in by decode_line_1.  The caller
   must make copies of any data that it needs to keep.  */

struct linespec_result
{
  linespec_result () = default;
  ~linespec_result ();

  DISABLE_COPY_AND_ASSIGN (linespec_result);

  /* If true, the linespec should be displayed to the user.  This
     is used by "unusual" linespecs where the ordinary `info break'
     display mechanism would do the wrong thing.  */
  bool special_display = false;

  /* If true, the linespec result should be considered to be a
     "pre-expanded" multi-location linespec.  A pre-expanded linespec
     holds all matching locations in a single linespec_sals
     object.  */
  bool pre_expanded = false;

  /* If PRE_EXPANDED is true, this is set to the location spec
     entered by the user.  */
  location_spec_up locspec;

  /* The sals.  The vector will be freed by the destructor.  */
  std::vector<linespec_sals> lsals;
};

/* Decode a linespec using the provided default symtab and line.  */

extern std::vector<symtab_and_line>
	decode_line_1 (const location_spec *locspec, int flags,
		       struct program_space *search_pspace,
		       struct symtab *default_symtab, int default_line);

/* Parse LOCSPEC and return results.  This is the "full"
   interface to this module, which handles multiple results
   properly.

   For FLAGS, see decode_line_flags.  DECODE_LINE_LIST_MODE is not
   valid for this function.

   If SEARCH_PSPACE is not NULL, symbol search is restricted to just
   that program space.

   DEFAULT_SYMTAB and DEFAULT_LINE describe the default location.
   DEFAULT_SYMTAB can be NULL, in which case the current symtab and
   line are used.

   CANONICAL is where the results are stored.  It must not be NULL.

   SELECT_MODE must be one of the multiple_symbols_* constants, or
   NULL.  It determines how multiple results will be handled.  If
   NULL, the appropriate CLI value will be used.

   FILTER can either be NULL or a string holding a canonical name.
   This is only valid when SELECT_MODE is multiple_symbols_all.

   Multiple results are handled differently depending on the
   arguments:

   . With multiple_symbols_cancel, an exception is thrown.

   . With multiple_symbols_ask, a menu is presented to the user.  The
   user may select none, in which case an exception is thrown; or all,
   which is handled like multiple_symbols_all, below.  Otherwise,
   CANONICAL->SALS will have one entry for each name the user chose.

   . With multiple_symbols_all, CANONICAL->SALS will have a single
   entry describing all the matching locations.  If FILTER is
   non-NULL, then only locations whose canonical name is equal (in the
   strcmp sense) to FILTER will be returned; all others will be
   filtered out.  */

extern void decode_line_full (struct location_spec *locspec, int flags,
			      struct program_space *search_pspace,
			      struct symtab *default_symtab, int default_line,
			      struct linespec_result *canonical,
			      const char *select_mode,
			      const char *filter);

/* Given a string, return the line specified by it, using the current
   source symtab and line as defaults.
   This is for commands like "list" and "breakpoint".  */

extern std::vector<symtab_and_line> decode_line_with_current_source
    (const char *, int);

/* Given a string, return the line specified by it, using the last displayed
   codepoint's values as defaults, or nothing if they aren't valid.  */

extern std::vector<symtab_and_line> decode_line_with_last_displayed
    (const char *, int);

/* Does P represent one of the keywords?  If so, return
   the keyword.  If not, return NULL.  */

extern const char *linespec_lexer_lex_keyword (const char *p);

/* Parse a line offset from STRING.  */

extern struct line_offset linespec_parse_line_offset (const char *string);

/* Return the quote characters permitted by the linespec parser.  */

extern const char *get_gdb_linespec_parser_quote_characters (void);

/* Does STRING represent an Ada operator?  If so, return the length
   of the decoded operator name.  If not, return 0.  */

extern int is_ada_operator (const char *string);

/* Find the end of the (first) linespec pointed to by *STRINGP.
   STRINGP will be advanced to this point.  */

extern void linespec_lex_to_end (const char **stringp);

extern const char * const linespec_keywords[];

/* Complete a linespec.  */

extern void linespec_complete (completion_tracker &tracker,
			       const char *text,
			       symbol_name_match_type match_type);

/* Complete a function symbol, in linespec mode, according to
   FUNC_MATCH_TYPE.  If SOURCE_FILENAME is non-NULL, limits completion
   to the list of functions defined in source files that match
   SOURCE_FILENAME.  */

extern void linespec_complete_function (completion_tracker &tracker,
					const char *function,
					symbol_name_match_type func_match_type,
					const char *source_filename);

/* Complete a label symbol, in linespec mode.  Only labels of
   functions named FUNCTION_NAME are considered.  If SOURCE_FILENAME
   is non-NULL, limits completion to labels of functions defined in
   source files that match SOURCE_FILENAME.  */

extern void linespec_complete_label (completion_tracker &tracker,
				     const struct language_defn *language,
				     const char *source_filename,
				     const char *function_name,
				     symbol_name_match_type name_match_type,
				     const char *label_name);

/* Evaluate the expression pointed to by EXP_PTR into a CORE_ADDR,
   advancing EXP_PTR past any parsed text.  */

extern CORE_ADDR linespec_expression_to_pc (const char **exp_ptr);
#endif /* GDB_LINESPEC_H */