gdb/mi/mi-cmd-env.c - gdb

Global variables defined

Functions defined

Source code

  1. /* MI Command Set - environment commands.
  2.    Copyright (C) 2002-2015 Free Software Foundation, Inc.

  4.    Contributed by Red Hat Inc.

  6.    This file is part of GDB.

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

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

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

  21. #include "defs.h"
  22. #include "inferior.h"
  23. #include "value.h"
  24. #include "mi-out.h"
  25. #include "mi-cmds.h"
  26. #include "mi-getopt.h"
  27. #include "symtab.h"
  28. #include "target.h"
  29. #include "environ.h"
  30. #include "command.h"
  31. #include "ui-out.h"
  32. #include "top.h"
  33. #include <sys/stat.h>

  35. static void env_mod_path (char *dirname, char **which_path);

  37. extern void _initialize_mi_cmd_env (void);

  39. ‌static const char path_var_name[] = "PATH";
  40. ‌static char *orig_path = NULL;

  42. /* The following is copied from mi-main.c so for m1 and below we can
  43.    perform old behavior and use cli commands.  If ARGS is non-null,
  44.    append it to the CMD.  */

  46. static void
  47. ‌env_execute_cli_command (const char *cmd, const char *args)
  48. {
  49.   if (cmd != 0)
  50.     {
  51.       struct cleanup *old_cleanups;
  52.       char *run;

  54.       if (args != NULL)
  55.         run = xstrprintf ("%s %s", cmd, args);
  56.       else
  57.         run = xstrdup (cmd);
  58.       old_cleanups = make_cleanup (xfree, run);
  59.       execute_command ( /*ui */ run, 0 /*from_tty */ );
  60.       do_cleanups (old_cleanups);
  61.       return;
  62.     }
  63. }

  65. /* Print working directory.  */

  67. void
  68. ‌mi_cmd_env_pwd (char *command, char **argv, int argc)
  69. {
  70.   struct ui_out *uiout = current_uiout;

  72.   if (argc > 0)
  73.     error (_("-environment-pwd: No arguments allowed"));

  75.   if (mi_version (uiout) < 2)
  76.     {
  77.       env_execute_cli_command ("pwd", NULL);
  78.       return;
  79.     }

  81.   /* Otherwise the mi level is 2 or higher.  */

  83.   if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
  84.     error (_("-environment-pwd: error finding name of working directory: %s"),
  85.            safe_strerror (errno));

  87.   ui_out_field_string (uiout, "cwd", gdb_dirbuf);
  88. }

  90. /* Change working directory.  */

  92. void
  93. ‌mi_cmd_env_cd (char *command, char **argv, int argc)
  94. {
  95.   if (argc == 0 || argc > 1)
  96.     error (_("-environment-cd: Usage DIRECTORY"));

  98.   env_execute_cli_command ("cd", argv[0]);
  99. }

  101. static void
  102. ‌env_mod_path (char *dirname, char **which_path)
  103. {
  104.   if (dirname == 0 || dirname[0] == '\0')
  105.     return;

  107.   /* Call add_path with last arg 0 to indicate not to parse for
  108.      separator characters.  */
  109.   add_path (dirname, which_path, 0);
  110. }

  112. /* Add one or more directories to start of executable search path.  */

  114. void
  115. ‌mi_cmd_env_path (char *command, char **argv, int argc)
  116. {
  117.   struct ui_out *uiout = current_uiout;
  118.   char *exec_path;
  119.   char *env;
  120.   int reset = 0;
  121.   int oind = 0;
  122.   int i;
  123.   char *oarg;
  124.   enum opt
  125.     {
  126.       RESET_OPT
  127.     };
  128.   static const struct mi_opt opts[] =
  129.   {
  130.     {"r", RESET_OPT, 0},
  131.     { 0, 0, 0 }
  132.   };

  134.   dont_repeat ();

  136.   if (mi_version (uiout) < 2)
  137.     {
  138.       for (i = argc - 1; i >= 0; --i)
  139.         env_execute_cli_command ("path", argv[i]);
  140.       return;
  141.     }

  143.   /* Otherwise the mi level is 2 or higher.  */
  144.   while (1)
  145.     {
  146.       int opt = mi_getopt ("-environment-path", argc, argv, opts,
  147.                            &oind, &oarg);

  149.       if (opt < 0)
  150.         break;
  151.       switch ((enum opt) opt)
  152.         {
  153.         case RESET_OPT:
  154.           reset = 1;
  155.           break;
  156.         }
  157.     }
  158.   argv += oind;
  159.   argc -= oind;


  162.   if (reset)
  163.     {
  164.       /* Reset implies resetting to original path first.  */
  165.       exec_path = xstrdup (orig_path);
  166.     }
  167.   else
  168.     {
  169.       /* Otherwise, get current path to modify.  */
  170.       env = get_in_environ (current_inferior ()->environment, path_var_name);

  172.       /* Can be null if path is not set.  */
  173.       if (!env)
  174.         env = "";
  175.       exec_path = xstrdup (env);
  176.     }

  178.   for (i = argc - 1; i >= 0; --i)
  179.     env_mod_path (argv[i], &exec_path);

  181.   set_in_environ (current_inferior ()->environment, path_var_name, exec_path);
  182.   xfree (exec_path);
  183.   env = get_in_environ (current_inferior ()->environment, path_var_name);
  184.   ui_out_field_string (uiout, "path", env);
  185. }

  187. /* Add zero or more directories to the front of the source path.  */

  189. void
  190. ‌mi_cmd_env_dir (char *command, char **argv, int argc)
  191. {
  192.   struct ui_out *uiout = current_uiout;
  193.   int i;
  194.   int oind = 0;
  195.   int reset = 0;
  196.   char *oarg;
  197.   enum opt
  198.     {
  199.       RESET_OPT
  200.     };
  201.   static const struct mi_opt opts[] =
  202.   {
  203.     {"r", RESET_OPT, 0},
  204.     { 0, 0, 0 }
  205.   };

  207.   dont_repeat ();

  209.   if (mi_version (uiout) < 2)
  210.     {
  211.       for (i = argc - 1; i >= 0; --i)
  212.         env_execute_cli_command ("dir", argv[i]);
  213.       return;
  214.     }

  216.   /* Otherwise mi level is 2 or higher.  */
  217.   while (1)
  218.     {
  219.       int opt = mi_getopt ("-environment-directory", argc, argv, opts,
  220.                            &oind, &oarg);

  222.       if (opt < 0)
  223.         break;
  224.       switch ((enum opt) opt)
  225.         {
  226.         case RESET_OPT:
  227.           reset = 1;
  228.           break;
  229.         }
  230.     }
  231.   argv += oind;
  232.   argc -= oind;

  234.   if (reset)
  235.     {
  236.       /* Reset means setting to default path first.  */
  237.       xfree (source_path);
  238.       init_source_path ();
  239.     }

  241.   for (i = argc - 1; i >= 0; --i)
  242.     env_mod_path (argv[i], &source_path);

  244.   ui_out_field_string (uiout, "source-path", source_path);
  245.   forget_cached_source_info ();
  246. }

  248. /* Set the inferior terminal device name.  */

  250. void
  251. ‌mi_cmd_inferior_tty_set (char *command, char **argv, int argc)
  252. {
  253.   set_inferior_io_terminal (argv[0]);
  254. }

  256. /* Print the inferior terminal device name.  */

  258. void
  259. ‌mi_cmd_inferior_tty_show (char *command, char **argv, int argc)
  260. {
  261.   const char *inferior_io_terminal = get_inferior_io_terminal ();

  263.   if ( !mi_valid_noargs ("-inferior-tty-show", argc, argv))
  264.     error (_("-inferior-tty-show: Usage: No args"));

  266.   if (inferior_io_terminal)
  267.     ui_out_field_string (current_uiout,
  268.                          "inferior_tty_terminal", inferior_io_terminal);
  269. }

  271. void
  272. ‌_initialize_mi_cmd_env (void)
  273. {
  274.   struct gdb_environ *environment;
  275.   char *env;

  277.   /* We want original execution path to reset to, if desired later.
  278.      At this point, current inferior is not created, so cannot use
  279.      current_inferior ()->environment.  Also, there's no obvious
  280.      place where this code can be moved such that it surely run
  281.      before any code possibly mangles original PATH.  */
  282.   environment = make_environ ();
  283.   init_environ (environment);
  284.   env = get_in_environ (environment, path_var_name);

  286.   /* Can be null if path is not set.  */
  287.   if (!env)
  288.     env = "";
  289.   orig_path = xstrdup (env);
  290.   free_environ (environment);
  291. }