?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
debug-manager: removed size_request
[anjuta.git] / plugins / tools / execute.c
blob0b53c5d5c84089e98a797292b81eddabb53d21e8
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 execute.c
4 Copyright (C) 2005 Sebastien Granjoux
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 2 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, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /*
22 * Execute an external tool
23 *
24 *---------------------------------------------------------------------------*/
25
26 #include <config.h>
27
28 #include "execute.h"
29
30 #include "variable.h"
31
32 #include <libanjuta/anjuta-utils.h>
33 #include <libanjuta/interfaces/ianjuta-document-manager.h>
34 #include <libanjuta/interfaces/ianjuta-editor.h>
35 #include <libanjuta/interfaces/ianjuta-editor-selection.h>
36 #include <libanjuta/interfaces/ianjuta-file-savable.h>
37 #include <libanjuta/interfaces/ianjuta-file-loader.h>
38
39 #include <glib.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <ctype.h>
43
44 /*---------------------------------------------------------------------------*/
45
46 #define ICON_FILE "anjuta-tools-plugin-48.png"
47 #define MAX_TOOL_PANES 4
48
49 /* Widget and signal name found in glade file
50 *---------------------------------------------------------------------------*/
51
52 #define TOOL_PARAMS "param_dialog"
53 #define TOOL_PARAMS_EN "tool.params"
54 #define TOOL_PARAMS_EN_COMBO "tool.params.combo"
55
56 /*---------------------------------------------------------------------------*/
57
58 /* Output information
59 * Allow to have common code for handling stderr and stdout but it includes
60 * some part checking if this is used to implement stderr or stdout. So, It
61 * is strongly linked to ATPExecutionContext.
62 */
63 typedef struct
64 {
65 ATPOutputType type;
66 struct _ATPExecutionContext* execution;
67 IAnjutaMessageView* view;
68 gboolean created;
69 GString* buffer;
70 IAnjutaEditor* editor;
71 IAnjutaIterable *position;
72 } ATPOutputContext;
73
74 /* Execute information
75 * This is filled at the beginning with all necessary tool information,
76 * so it becomes independent from the tool after creation. It includes
77 * two OutputContext (one for stderr and one for stdout). The context
78 * is not destroyed when the tool execution terminate, so it can be
79 * reuse later for another tool. It useful mainly for keeping pointer
80 * on created message panes. All the tool context are kept in a list. */
81 typedef struct _ATPExecutionContext
82 {
83 gchar* name;
84 gchar* directory; // used for opening file from message pane
85 ATPOutputContext output;
86 ATPOutputContext error;
87 AnjutaPlugin *plugin;
88 AnjutaLauncher *launcher;
89 gboolean busy;
90 } ATPExecutionContext;
91
92 /* Helper function
93 *---------------------------------------------------------------------------*/
94
95 /* Save all current anjuta files */
96 static void
97 save_all_files (AnjutaPlugin *plugin)
98 {
99 IAnjutaDocumentManager *docman;
100 IAnjutaFileSavable* save;
101
102 docman = anjuta_shell_get_interface (plugin->shell, IAnjutaDocumentManager, NULL);
103 /* No document manager, so no file to save */
104 if (docman != NULL)
105 {
106 save = IANJUTA_FILE_SAVABLE (docman);
107 if (save) ianjuta_file_savable_save (save, NULL);
108 }
109 }
110
111 /* Replace variable in source and add prefix separated with a space */
112 static gchar*
113 replace_variable (const gchar* prefix, const gchar* source,
114 ATPVariable* variable)
115 {
116 guint len;
117 gchar *val;
118 GString* str;
119
120 /* Create string and add prefix */
121 str = g_string_new (prefix);
122 if (prefix != NULL)
123 {
124 g_string_append_c (str, ' ');
125 }
126
127 /* Add source and replace variable */
128 if (source != NULL)
129 {
130 for (; *source != '\0'; source += len)
131 {
132 if (source[0] != '$')
133 {
134 /* Just append anything that doesn't looks like a variable */
135 for (len = 0; (source[len] != '\0') &&
136 (source[len] != '$'); len++);
137 g_string_append_len (str, source, len);
138 }
139 else if (source[1] != '(')
140 {
141 g_string_append_c (str, '$');
142 len = 1;
143 }
144 else
145 {
146 /* Check if there is a variable */
147 for (len = 2; g_ascii_isalnum(source[len])
148 || (source[len] == '_') ; len++);
149 if (source[len] == ')')
150 {
151 len++;
152 val = atp_variable_get_value_from_name_part (variable, source + 2, len - 3);
153 if (val)
154 {
155 /* This is really a variable, replace */
156 g_string_append (str, val);
157 continue;
158 }
159 }
160
161 /* It's not a variable */
162 g_string_append_len (str, source, len);
163 }
164 }
165 }
166
167 /* Remove leading space, trailing space and empty string */
168 val = g_string_free (str, FALSE);
169 if (val != NULL)
170 {
171 g_strstrip (val);
172 if ((val != NULL) && (*val == '\0'))
173 {
174 g_free (val);
175 val = NULL;
176 }
177 }
178
179 return val;
180 }
181
182 static gboolean
183 parse_error_line (const gchar * line, gchar ** filename, int *lineno)
184 {
185 gint i = 0;
186 gint j = 0;
187 gint k = 0;
188 gchar *dummy;
189
190 while (line[i++] != ':')
191 {
192 if (i >= strlen (line) || i >= 512 || line[i - 1] == ' ')
193 {
194 goto down;
195 }
196 }
197 if (isdigit (line[i]))
198 {
199 j = i;
200 while (isdigit (line[i++])) ;
201 dummy = g_strndup (&line[j], i - j - 1);
202 *lineno = atoi (dummy);
203 if (dummy)
204 g_free (dummy);
205 dummy = g_strndup (line, j - 1);
206 *filename = g_strdup (g_strstrip (dummy));
207 if (dummy)
208 g_free (dummy);
209 return TRUE;
210 }
211
212 down:
213 i = strlen (line) - 1;
214 while (isspace (line[i]) == FALSE)
215 {
216 i--;
217 if (i < 0)
218 {
219 *filename = NULL;
220 *lineno = 0;
221 return FALSE;
222 }
223 }
224 k = i++;
225 while (line[i++] != ':')
226 {
227 if (i >= strlen (line) || i >= 512 || line[i - 1] == ' ')
228 {
229 *filename = NULL;
230 *lineno = 0;
231 return FALSE;
232 }
233 }
234 if (isdigit (line[i]))
235 {
236 j = i;
237 while (isdigit (line[i++])) ;
238 dummy = g_strndup (&line[j], i - j - 1);
239 *lineno = atoi (dummy);
240 if (dummy)
241 g_free (dummy);
242 dummy = g_strndup (&line[k], j - k - 1);
243 *filename = g_strdup (g_strstrip (dummy));
244 if (dummy)
245 g_free (dummy);
246 return TRUE;
247 }
248 *lineno = 0;
249 *filename = NULL;
250 return FALSE;
251 }
252
253 /* Output context functions
254 *---------------------------------------------------------------------------*/
255
256 static void
257 on_message_buffer_click (IAnjutaMessageView *view, const gchar *line,
258 ATPOutputContext *this)
259 {
260 gchar *filename;
261 gint lineno;
262
263 if (parse_error_line (line, &filename, &lineno))
264 {
265 gchar *path;
266 GFile* file;
267 IAnjutaDocumentManager* docman;
268
269 /* Go to file and line number */
270 docman = anjuta_shell_get_interface (this->execution->plugin->shell,
271 IAnjutaDocumentManager,
272 NULL);
273
274 /* Append current directory */
275 if ((this->execution->directory != NULL) &&
276 (*filename != G_DIR_SEPARATOR))
277 {
278 if (*filename == '.')
279 {
280 path = g_build_filename (this->execution->directory,
281 filename + 1, NULL);
282 }
283 else
284 {
285 path = g_build_filename (this->execution->directory,
286 filename, NULL);
287 }
288 }
289 else
290 {
291 path = g_strdup(filename);
292 }
293 g_free (filename);
294 file = g_file_new_for_path (path);
295 ianjuta_document_manager_goto_file_line (docman, file, lineno, NULL);
296 g_free (path);
297 g_object_unref (file);
298 }
299 }
300
301 static void
302 on_message_buffer_flush (IAnjutaMessageView *view, const gchar *msg_line,
303 ATPOutputContext *this)
304 {
305 gchar *dummy_fn;
306 gint dummy_int;
307 gchar *line;
308 IAnjutaMessageViewType type;
309
310 /* If there is a gdb style annotation to open a file, open it */
311 if (strlen(msg_line) > 2 && msg_line[0] == '\032' &&
312 msg_line[1] == '\032')
313 {
314 line = g_strdup_printf (_("Opening %s"), &msg_line[2]);
315 on_message_buffer_click (view, &msg_line[2], this);
316 }
317 else
318 {
319 line = g_strdup (msg_line);
320 }
321
322 if (this->view)
323 {
324 gchar *desc = "";
325
326 type = IANJUTA_MESSAGE_VIEW_TYPE_NORMAL;
327 if (parse_error_line(line, &dummy_fn, &dummy_int))
328 {
329 g_free (dummy_fn);
330 if ((strstr (line, _("warning:")) != NULL) ||
331 (strstr (line, "warning:") != NULL))
332 {
333 type = IANJUTA_MESSAGE_VIEW_TYPE_WARNING;
334 }
335 else if ((strstr (line, _("error:")) != NULL) ||
336 (strstr (line, "error:") != NULL))
337 {
338 type = IANJUTA_MESSAGE_VIEW_TYPE_ERROR;
339 }
340 desc = line;
341 }
342 else if (strstr (line, ":") != NULL)
343 {
344 type = IANJUTA_MESSAGE_VIEW_TYPE_INFO;
345 }
346 ianjuta_message_view_append (this->view, type, line, desc, NULL);
347 }
348 g_free (line);
349 }
350
351 /* Handle output for stdout and stderr */
352 static gboolean
353 atp_output_context_print (ATPOutputContext *this, const gchar* text)
354 {
355 const gchar* str;
356
357 if (this->type == ATP_TOUT_SAME)
358 {
359 /* Valid for error output only, get output type
360 * from standard output */
361 this = &this->execution->output;
362 }
363
364 switch (this->type)
365 {
366 case ATP_TOUT_SAME:
367 /* output should not use this */
368 g_return_val_if_reached (TRUE);
369 break;
370 case ATP_TOUT_NULL:
371 break;
372 case ATP_TOUT_COMMON_PANE:
373 case ATP_TOUT_NEW_PANE:
374 /* Check if the view has already been created */
375 if (this->created == FALSE)
376 {
377 IAnjutaMessageManager *man;
378 gchar* title = this->execution->name;
379
380 man = anjuta_shell_get_interface (this->execution->plugin->shell,
381 IAnjutaMessageManager, NULL);
382 if (this->view == NULL)
383 {
384 this->view = ianjuta_message_manager_add_view (man, title,
385 ICON_FILE,
386 NULL);
387 g_signal_connect (G_OBJECT (this->view), "buffer_flushed",
388 G_CALLBACK (on_message_buffer_flush), this);
389 g_signal_connect (G_OBJECT (this->view), "message_clicked",
390 G_CALLBACK (on_message_buffer_click), this);
391 g_object_add_weak_pointer (G_OBJECT (this->view),
392 (gpointer *)(gpointer)&this->view);
393 }
394 else
395 {
396 ianjuta_message_view_clear (this->view, NULL);
397 }
398 if (this->execution->error.type == ATP_TOUT_SAME)
399 {
400 /* Same message used for all outputs */
401 str = "";
402 }
403 else if (this == &this->execution->output)
404 {
405 /* This is append to the tool name to give something
406 * like "My tools (output)". It's used to name the message
407 * pane where the output of the tool is send to
408 */
409 str = _("(output)");
410 }
411 else
412 {
413 /* This is append to the tool name to give something
414 * like "My tools (error)". It's used to name the message
415 * pane where the errors of the tool is send to
416 */
417 str = _("(error)");
418 }
419 title = g_strdup_printf ("%s %s", this->execution->name, str);
420
421 ianjuta_message_manager_set_view_title (man, this->view,
422 title, NULL);
423 g_free (title);
424 this->created = TRUE;
425 }
426 /* Display message */
427 if (this->view)
428 {
429 ianjuta_message_view_buffer_append (this->view, text, NULL);
430 }
431 break;
432 case ATP_TOUT_NEW_BUFFER:
433 case ATP_TOUT_REPLACE_BUFFER:
434 if (this->editor)
435 {
436 ianjuta_editor_append (this->editor, text, strlen(text), NULL);
437 }
438 break;
439 case ATP_TOUT_INSERT_BUFFER:
440 case ATP_TOUT_APPEND_BUFFER:
441 case ATP_TOUT_REPLACE_SELECTION:
442 case ATP_TOUT_POPUP_DIALOG:
443 g_string_append (this->buffer, text);
444 break;
445 case ATP_TOUT_UNKNOWN:
446 case ATP_OUTPUT_TYPE_COUNT:
447 g_return_val_if_reached (TRUE);
448 }
449
450 return TRUE;
451 }
452
453 /* Write a small message at the beginning use only on stdout */
454 static gboolean
455 atp_output_context_print_command (ATPOutputContext *this, const gchar* command)
456 {
457 gboolean ok;
458 gchar *msg;
459
460 ok = TRUE;
461 switch (this->type)
462 {
463 case ATP_TOUT_NULL:
464 case ATP_TOUT_SAME:
465 break;
466 case ATP_TOUT_COMMON_PANE:
467 case ATP_TOUT_NEW_PANE:
468 /* Display the name of the command */
469 msg = g_strdup_printf(_("Running command: %s…\n"), command);
470 ok = atp_output_context_print (this, msg);
471 g_free (msg);
472 break;
473 case ATP_TOUT_NEW_BUFFER:
474 case ATP_TOUT_REPLACE_BUFFER:
475 case ATP_TOUT_INSERT_BUFFER:
476 case ATP_TOUT_APPEND_BUFFER:
477 case ATP_TOUT_REPLACE_SELECTION:
478 case ATP_TOUT_POPUP_DIALOG:
479 /* Do nothing for all these cases */
480 break;
481 case ATP_TOUT_UNKNOWN:
482 case ATP_OUTPUT_TYPE_COUNT:
483 g_return_val_if_reached (TRUE);
484 }
485
486 return ok;
487 };
488
489 /* Call at the end for stdout and stderr */
490 static gboolean
491 atp_output_context_print_result (ATPOutputContext *this, gint error)
492 {
493 gboolean ok;
494 gchar* buffer;
495 IAnjutaMessageManager *man;
496
497 ok = TRUE;
498 switch (this->type)
499 {
500 case ATP_TOUT_NULL:
501 case ATP_TOUT_SAME:
502 break;
503 case ATP_TOUT_COMMON_PANE:
504 case ATP_TOUT_NEW_PANE:
505 if (this == &this->execution->output)
506 {
507 if (error)
508 {
509 buffer = g_strdup_printf (_("Completed unsuccessfully with status code %d\n"),
510 error);
511 ok = atp_output_context_print (this, buffer);
512 g_free (buffer);
513 }
514 else
515 {
516 ok = atp_output_context_print (this, _("Completed successfully\n"));
517 }
518 ok &= atp_output_context_print (this, "\n");
519 if (this->view)
520 {
521 man = anjuta_shell_get_interface (this->execution->plugin->shell,
522 IAnjutaMessageManager, NULL);
523 ianjuta_message_manager_set_current_view (man, this->view, NULL);
524 }
525
526 }
527 break;
528 case ATP_TOUT_NEW_BUFFER:
529 case ATP_TOUT_REPLACE_BUFFER:
530 /* Do nothing */
531 break;
532 case ATP_TOUT_INSERT_BUFFER:
533 if (this->editor)
534 {
535 ianjuta_editor_insert (this->editor, this->position, this->buffer->str,
536 this->buffer->len, NULL);
537 }
538 g_string_free (this->buffer, TRUE);
539 this->buffer = NULL;
540 break;
541 case ATP_TOUT_APPEND_BUFFER:
542 if (this->editor)
543 {
544 ianjuta_editor_append (this->editor, this->buffer->str,
545 this->buffer->len, NULL);
546 }
547 g_string_free (this->buffer, TRUE);
548 this->buffer = NULL;
549 break;
550 case ATP_TOUT_REPLACE_SELECTION:
551 if (this->editor)
552 {
553 ianjuta_editor_selection_replace (IANJUTA_EDITOR_SELECTION (this->editor),
554 this->buffer->str,
555 this->buffer->len, NULL);
556 }
557 g_string_free (this->buffer, TRUE);
558 this->buffer = NULL;
559 break;
560 case ATP_TOUT_POPUP_DIALOG:
561 if (this->buffer->len)
562 {
563 if (this == &this->execution->output)
564 {
565 anjuta_util_dialog_info (GTK_WINDOW (this->execution->plugin->shell),
566 this->buffer->str);
567 }
568 else
569 {
570 anjuta_util_dialog_error (GTK_WINDOW (this->execution->plugin->shell),
571 this->buffer->str);
572 }
573 g_string_free (this->buffer, TRUE);
574 this->buffer = NULL;
575 }
576 break;
577 case ATP_TOUT_UNKNOWN:
578 case ATP_OUTPUT_TYPE_COUNT:
579 g_return_val_if_reached (TRUE);
580 }
581
582 return ok;
583 };
584
585 static IAnjutaEditor*
586 get_current_editor(IAnjutaDocumentManager* docman)
587 {
588 if (docman == NULL)
589 return NULL;
590 IAnjutaDocument* doc = ianjuta_document_manager_get_current_document(docman, NULL);
591 if (doc && IANJUTA_IS_EDITOR(doc))
592 return IANJUTA_EDITOR(doc);
593 else
594 return NULL;
595 }
596
597 static ATPOutputContext*
598 atp_output_context_initialize (ATPOutputContext *this,
599 ATPExecutionContext *execution,
600 ATPOutputType type)
601 {
602 IAnjutaDocumentManager *docman;
603
604 this->type = type;
605 switch (this->type)
606 {
607 case ATP_TOUT_NULL:
608 case ATP_TOUT_SAME:
609 break;
610 case ATP_TOUT_COMMON_PANE:
611 case ATP_TOUT_NEW_PANE:
612 this->created = FALSE;
613 break;
614 case ATP_TOUT_REPLACE_BUFFER:
615 docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (this->execution->plugin)->shell, IAnjutaDocumentManager, NULL);
616 this->editor = get_current_editor(docman);
617 if (this->editor != NULL)
618 {
619 g_object_add_weak_pointer (G_OBJECT (this->editor), (gpointer *)(gpointer)&this->editor);
620 ianjuta_editor_erase_all (this->editor, NULL);
621 break;
622 }
623 /* Go through, try to create a new buffer */
624 case ATP_TOUT_NEW_BUFFER:
625 docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (this->execution->plugin)->shell, IAnjutaDocumentManager, NULL);
626 this->editor = get_current_editor(docman);
627 if (this->editor == NULL)
628 {
629 anjuta_util_dialog_warning (GTK_WINDOW (this->execution->plugin->shell), _("Unable to create a buffer: command aborted"));
630 return NULL;
631 }
632 g_object_add_weak_pointer (G_OBJECT (this->editor), (gpointer *)(gpointer)&this->editor);
633 break;
634 case ATP_TOUT_INSERT_BUFFER:
635 case ATP_TOUT_APPEND_BUFFER:
636 case ATP_TOUT_REPLACE_SELECTION:
637 docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (this->execution->plugin)->shell, IAnjutaDocumentManager, NULL);
638 this->editor = docman == NULL ? NULL : IANJUTA_EDITOR( ianjuta_document_manager_get_current_document (docman, NULL));
639 if (this->editor == NULL)
640 {
641 anjuta_util_dialog_warning (GTK_WINDOW (this->execution->plugin->shell), _("No document currently open: command aborted"));
642 return NULL;
643 }
644 g_object_add_weak_pointer (G_OBJECT (this->editor), (gpointer *)(gpointer)&this->editor);
645 this->position = ianjuta_editor_get_position (this->editor, NULL);
646 /* No break, need a buffer too */
647 case ATP_TOUT_POPUP_DIALOG:
648 if (this->buffer == NULL)
649 {
650 this->buffer = g_string_new ("");
651 }
652 else
653 {
654 g_string_erase (this->buffer, 0, -1);
655 }
656 break;
657 case ATP_TOUT_UNKNOWN:
658 case ATP_OUTPUT_TYPE_COUNT:
659 g_return_val_if_reached (this);
660 }
661
662 return this;
663 }
664
665
666 static ATPOutputContext*
667 atp_output_context_construct (ATPOutputContext *this,
668 ATPExecutionContext *execution,
669 ATPOutputType type)
670 {
671
672 this->execution = execution;
673 this->view = NULL;
674 this->buffer = NULL;
675 this->position = NULL;
676
677 return atp_output_context_initialize (this, execution, type);
678 }
679
680 static void
681 atp_output_context_destroy (ATPOutputContext *this)
682 {
683 if (this->view)
684 {
685 IAnjutaMessageManager *man;
686
687 man = anjuta_shell_get_interface (this->execution->plugin->shell,
688 IAnjutaMessageManager, NULL);
689 ianjuta_message_manager_remove_view (man, this->view, NULL);
690 this->view = NULL;
691 }
692 if (this->buffer)
693 {
694 g_string_free (this->buffer, TRUE);
695 }
696 if (this->position)
697 {
698 g_object_unref (this->position);
699 }
700 }
701
702 /* Execution context
703 *---------------------------------------------------------------------------*/
704
705 static void
706 on_run_terminated (AnjutaLauncher* launcher, gint pid, gint status,
707 gulong time, gpointer user_data)
708 {
709 ATPExecutionContext *this = (ATPExecutionContext *)user_data;
710
711 atp_output_context_print_result (&this->output, status);
712 atp_output_context_print_result (&this->error, status);
713 this->busy = FALSE;
714 }
715
716 static void
717 on_run_output (AnjutaLauncher* launcher, AnjutaLauncherOutputType type,
718 const gchar* output, gpointer user_data)
719 {
720 ATPExecutionContext* this = (ATPExecutionContext*)user_data;
721
722 switch (type)
723 {
724 case ANJUTA_LAUNCHER_OUTPUT_STDOUT:
725 atp_output_context_print (&this->output, output);
726 break;
727 case ANJUTA_LAUNCHER_OUTPUT_STDERR:
728 atp_output_context_print (&this->error, output);
729 break;
730 case ANJUTA_LAUNCHER_OUTPUT_PTY:
731 break;
732 }
733 }
734
735 static ATPExecutionContext*
736 atp_execution_context_reuse (ATPExecutionContext* this, const gchar *name,
737 ATPOutputType output, ATPOutputType error)
738 {
739 if (this->name) g_free (this->name);
740 this->name = atp_remove_mnemonic (name);
741
742 if (atp_output_context_initialize (&this->output, this, output) == NULL)
743 {
744 return NULL;
745 }
746 if (atp_output_context_initialize (&this->error, this, error) == NULL)
747 {
748 return NULL;
749 }
750
751 return this;
752 }
753
754 static ATPExecutionContext*
755 atp_execution_context_new (AnjutaPlugin *plugin, const gchar *name,
756 guint id, ATPOutputType output, ATPOutputType error)
757 {
758 ATPExecutionContext *this;
759
760 this = g_new0 (ATPExecutionContext, 1);
761
762 this->plugin = plugin;
763 this->launcher = anjuta_launcher_new ();
764 g_signal_connect (G_OBJECT (this->launcher), "child-exited",
765 G_CALLBACK (on_run_terminated), this);
766 this->name = atp_remove_mnemonic (name);
767
768 if (atp_output_context_construct (&this->output, this, output) == NULL)
769 {
770 g_free (this);
771 return NULL;
772 }
773 if (atp_output_context_construct (&this->error, this, error) == NULL)
774 {
775 g_free (this);
776 return NULL;
777 }
778
779 return this;
780 }
781
782 static void
783 atp_execution_context_free (ATPExecutionContext* this)
784 {
785 atp_output_context_destroy (&this->output);
786 atp_output_context_destroy (&this->error);
787
788 if (this->launcher)
789 {
790 g_object_unref (this->launcher);
791 }
792 if (this->name) g_free (this->name);
793 if (this->directory) g_free (this->directory);
794
795 g_free (this);
796 }
797
798 static void
799 atp_execution_context_set_directory (ATPExecutionContext* this,
800 const gchar* directory)
801 {
802 if (this->directory != NULL) g_free (this->directory);
803 this->directory = directory == NULL ? NULL : g_strdup (directory);
804 }
805
806 static void
807 atp_execution_context_execute (ATPExecutionContext* this,
808 const gchar* command, const gchar* input)
809 {
810 gchar* prev_dir = NULL;
811
812 atp_output_context_print_command (&this->output, command);
813
814 /* Change working directory */
815 if (this->directory != NULL)
816 {
817 prev_dir = anjuta_util_get_current_dir();
818 chdir (this->directory);
819 }
820 /* Execute */
821 anjuta_launcher_execute (this->launcher, command, on_run_output, this);
822 /* Restore previous current directory */
823 if (this->directory != NULL)
824 {
825 chdir (prev_dir);
826 g_free (prev_dir);
827 }
828 anjuta_launcher_set_encoding (this->launcher, NULL);
829 this->busy = TRUE;
830
831 /* Send stdin data if needed */
832 if (input != NULL)
833 {
834 anjuta_launcher_send_stdin (this->launcher, input);
835 /* Send end marker */
836 anjuta_launcher_send_stdin (this->launcher, "\x04");
837 }
838 }
839
840 /* Execute context list
841 *---------------------------------------------------------------------------*/
842
843 ATPContextList *
844 atp_context_list_construct (ATPContextList *this)
845 {
846 this->list = NULL;
847 return this;
848 }
849
850 void
851 atp_context_list_destroy (ATPContextList *this)
852 {
853 GList *item;
854
855 for (item = this->list; item != NULL; item = this->list)
856 {
857 this->list = g_list_remove_link (this->list, item);
858 atp_execution_context_free ((ATPExecutionContext *)item->data);
859 g_list_free (item);
860 }
861 }
862
863 static ATPExecutionContext*
864 atp_context_list_find_context (ATPContextList *this, AnjutaPlugin *plugin,
865 const gchar* name, ATPOutputType output,
866 ATPOutputType error)
867 {
868 ATPExecutionContext* context;
869 GList* reuse = NULL;
870 guint best;
871 guint pane;
872 GList* node;
873 gboolean new_pane;
874 gboolean output_pane;
875 gboolean error_pane;
876
877 pane = 0;
878 best = 0;
879 context = NULL;
880 new_pane = (output == ATP_TOUT_NEW_PANE) || (error == ATP_TOUT_NEW_PANE);
881 output_pane = (output == ATP_TOUT_NEW_PANE) || (output == ATP_TOUT_COMMON_PANE);
882 error_pane = (error == ATP_TOUT_NEW_PANE) || (error == ATP_TOUT_COMMON_PANE);
883 for (node = this->list; node != NULL; node = g_list_next (node))
884 {
885 ATPExecutionContext* current;
886 guint score;
887
888 current = (ATPExecutionContext *)node->data;
889
890 /* Count number of used message panes */
891 if (current->output.view != NULL) pane++;
892 if (current->error.view != NULL) pane++;
893
894 score = 1;
895 if ((current->output.view != NULL) == output_pane) score++;
896 if ((current->error.view != NULL) == error_pane) score++;
897
898 if (!current->busy)
899 {
900 if ((score > best) || ((score == best) && (new_pane)))
901 {
902 /* Reuse this context */
903 context = current;
904 reuse = node;
905 best = score;
906 }
907 }
908 }
909
910 if ((new_pane) && (pane < MAX_TOOL_PANES))
911 {
912 /* Not too many message pane, we can create a new one */
913 context = NULL;
914 }
915
916 if (context == NULL)
917 {
918 /* Create a new node */
919 context = atp_execution_context_new (plugin, name, 0, output, error);
920 if (context != NULL)
921 {
922 this->list = g_list_prepend (this->list, context);
923 }
924 }
925 else
926 {
927 this->list = g_list_remove_link (this->list, reuse);
928 context = atp_execution_context_reuse (context, name, output, error);
929 if (context != NULL)
930 {
931 this->list = g_list_concat (reuse, this->list);
932 }
933 }
934
935 return context;
936 }
937
938 /* Execute tools
939 *---------------------------------------------------------------------------*/
940
941 /* Menu activate handler which executes the tool. It should do command
942 ** substitution, input, output and error redirection, setting the
943 ** working directory, etc.
944 */
945 void
946 atp_user_tool_execute (GtkMenuItem *item, ATPUserTool* this)
947 {
948 ATPPlugin* plugin;
949 ATPVariable* variable;
950 ATPContextList* list;
951 ATPExecutionContext* context;
952 IAnjutaDocumentManager *docman;
953 IAnjutaEditor *ed;
954 gchar* dir;
955 gchar* cmd;
956 gchar* input;
957 gchar* val = NULL;
958
959 plugin = atp_user_tool_get_plugin (this);
960 variable = atp_plugin_get_variable (plugin);
961
962 /* Save files if requested */
963 if (atp_user_tool_get_flag (this, ATP_TOOL_AUTOSAVE))
964 {
965 save_all_files (ANJUTA_PLUGIN (plugin));
966 }
967
968 /* Make command line */
969 cmd = replace_variable (atp_user_tool_get_command (this),
970 atp_user_tool_get_param (this), variable);
971
972 /* Get working directory and replace variable */
973 dir = replace_variable (NULL, atp_user_tool_get_working_dir (this),
974 variable);
975
976 if (atp_user_tool_get_flag (this, ATP_TOOL_TERMINAL))
977 {
978 /* Run in a terminal */
979 /* don't need a execution context, launch and forget */
980
981 anjuta_util_execute_terminal_shell (dir, cmd);
982 }
983 else
984 {
985 /* Get stdin if necessary */
986 input = NULL;
987 switch (atp_user_tool_get_input (this))
988 {
989 case ATP_TIN_BUFFER:
990 docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
991 IAnjutaDocumentManager, NULL);
992 ed = get_current_editor(docman);
993 if (ed != NULL)
994 {
995 input = ianjuta_editor_get_text_all (ed, NULL);
996 }
997 break;
998 case ATP_TIN_SELECTION:
999 docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
1000 IAnjutaDocumentManager, NULL);
1001 ed = get_current_editor(docman);
1002 if (ed != NULL)
1003 {
1004 input = ianjuta_editor_selection_get (IANJUTA_EDITOR_SELECTION (ed),
1005 NULL);
1006 }
1007 break;
1008 case ATP_TIN_STRING:
1009 input = replace_variable (NULL,
1010 atp_user_tool_get_input_string (this),
1011 variable);
1012 break;
1013 case ATP_TIN_FILE:
1014 val = replace_variable (NULL, atp_user_tool_get_input_string (this),
1015 variable);
1016 if ((val == NULL) || (!g_file_get_contents (val, &input, NULL, NULL)))
1017 {
1018 anjuta_util_dialog_error (atp_plugin_get_app_window (plugin),
1019 _("Unable to open input file %s, command aborted"), val == NULL ? "(null)" : val);
1020 if (val != NULL) g_free (val);
1021 if (dir != NULL) g_free (dir);
1022 if (cmd != NULL) g_free (cmd);
1023
1024 return;
1025 }
1026 g_free (val);
1027 break;
1028 default:
1029 break;
1030 }
1031
1032 list = atp_plugin_get_context_list (plugin);
1033
1034 context = atp_context_list_find_context (list, ANJUTA_PLUGIN(plugin),
1035 atp_user_tool_get_name (this),
1036 atp_user_tool_get_output (this),
1037 atp_user_tool_get_error (this));
1038
1039 if (context)
1040 {
1041 /* Set working directory */
1042 atp_execution_context_set_directory (context, dir);
1043
1044 /* Run command */
1045 atp_execution_context_execute (context, cmd, input);
1046 }
1047
1048 if (input != NULL) g_free(input);
1049 }
1050
1051 if (dir != NULL) g_free (dir);
1052 if (cmd != NULL) g_free (cmd);
1053 }
anjuta mirror