ait/shell.c

/* shell.c, Ait, BSD 3-Clause, Kevin Bloom, 2023 */

#include <stdio.h>
#include "header.h"
#include "termbox.h"

/* TODO: make this generic
   M-e will display "Shell Command: " in the msgline. You then input the command
   you want.
   Eventually maybe make it so that there are different types of commands:
   - input, inputs something at the point
   - open, runs a command and ait will open the output (this currently works)
   - region/replace, use the region as the input to the shell cmd and then
     replace the region with the output
   - new buffer, runs the command and the output is placed in a new buffer

   I probably would want some keybinds to certain commands, however.
   Also, I'd like to make it so that if you have a region selected, it can be
   executed much like how acme does it.

   io = Insert = 0, Open = 1
*/
void get_popen_data(int io) {
  FILE *pf;
  char *command = NULL;
  char *data = NULL;
  buffer_t *bp;
  char *prompt = "Shell Command: ";
  char str_line[10];
  int cpos = 0, done = FALSE;
  int c, hasregion = FALSE, cmdsize = 0, escaped_size = 0;
  int start_col = strlen(prompt);
  int i = 0, k = 0, isLineNumber = 0, line, l = 0;
  struct tb_event ev;
  char cmdtext[STRBUF_M];
  cmdtext[0] = '\0';
  point_t nregion = 0, point;
  char_t *region = NULL, *p, *escaped_region = NULL;

  if(io) {
    prompt = "Open Via: ";
    start_col = strlen(prompt);
  }

  display_prompt_and_response(prompt, cmdtext);
  cpos = strlen(cmdtext);

  for (;;) {
    tb_present();
    if(tb_poll_event(&ev) != TB_OK) return;

    if(!ev.mod)
      c = ev.ch;
    else
      c = ev.key;

    /* ignore control keys other than return, C-g, backspace, CR,  C-s, C-R, ESC */
      if (c < 32 &&
        c != TB_KEY_CTRL_G &&
        c != TB_KEY_BACKSPACE &&
        c != TB_KEY_BACKSPACE2 &&
       c != TB_KEY_ENTER &&
        c != TB_KEY_ESC)
      continue;

    switch(c) {
    case TB_KEY_ENTER: /* return */
      done = TRUE;
      break;

    case TB_KEY_ESC: /* esc */
    case TB_KEY_CTRL_G: /* ctrl-g */
      tb_set_cursor(0, MSGLINE);
      clrtoeol("", MSGLINE);
      return;

    case TB_KEY_BACKSPACE2: /* del, erase */
    case TB_KEY_BACKSPACE: /* backspace */
      if (cpos == 0)
        continue;
      cmdtext[--cpos] = '\0';
      tb_set_cursor(start_col + cpos, MSGLINE);
      display_prompt_and_response(prompt, cmdtext);
      break;

    default:
      if (cpos < STRBUF_M - 1) {
        tb_set_cursor(start_col + cpos, MSGLINE);
        cmdtext[cpos++] = c;
        cmdtext[cpos] = '\0';
        addch(c);
      }
      break;
    }
    if(done)
      break;
  }

  if(cmdtext[0] == '\0')
    return;

  undoset();

  if (curbp->b_mark != NOMARK && curbp->b_point != curbp->b_mark) {
    hasregion = TRUE;
    if (curbp->b_point < curbp->b_mark) {
      /* point above marker: move gap under point, region = marker - point */
      (void) movegap(curbp, curbp->b_point);
      p = ptr(curbp, curbp->b_point);
      nregion = curbp->b_mark - curbp->b_point;
    } else {
      /* if point below marker: move gap under marker, region = point - marker */
      (void) movegap(curbp, curbp->b_mark);
      p = ptr(curbp, curbp->b_mark);
      nregion = curbp->b_point - curbp->b_mark;
    }

    if ((region = (char_t*) malloc(nregion)) == NULL) {
      msg("No more memory available.");
    } else if(region != NULL) {
      (void) memcpy(region, p, nregion * sizeof (char_t));
      curbp->b_egap += nregion; /* if cut expand gap down */
      curbp->b_point = pos(curbp, curbp->b_egap); /* set point to after region */
      curbp->b_flags |= B_MODIFIED;
      curbp->b_mark = NOMARK;  /* unmark */
    }
  }

  strcpy(temp, editor_dir);

  tb_shutdown();

  if(hasregion) {
    /* Find all dollar signs and increase the size by one for each sign. */
    for(int i = 0; region[i] != '\0'; i++) {
      if(region[i] == '$' || region[i] == '`')
        escaped_size += 2;
      else
        escaped_size++;
    }
    escaped_region = malloc(sizeof(char_t *)*escaped_size);
    /* Escape all $ with \$. This prevents the echo command from trying to
       do a variable substitution.
    */
    for(int i = 0, k = 0; region[i] != '\0'; i++, k++) {
      if(region[i] == '$' || region[i] == '`') {
        escaped_region[k] = '\\';
        k++;
        escaped_region[k] = region[i];
      } else {
        escaped_region[k] = region[i];
      }
    }
    cmdsize = 6*4*escaped_size*strlen(cmdtext);
    command = malloc(sizeof(char *)*cmdsize);
    strcpy(command, "echo \"");
    strcat(command, (char *)escaped_region);
    strcat(command, "\" | ");
    strcat(command, cmdtext);
  } else {
    cmdsize = strlen(cmdtext);
    command = malloc(sizeof(char *)*cmdsize);
    strcpy(command, cmdtext);
  }

  // Setup our pipe for reading and execute our command.
  pf = popen(command,"r");

  if(pf == NULL){
    msg("Could not open pipe for output.");
    return;
  }

  data = malloc(sizeof(char *) * 512 * 3);
  fgets(data, sizeof(char *) * 512 * 3, pf);

  tb_init();
  LINES = tb_height();
  COLS = tb_width();
  MSGLINE = LINES-1;
  tb_set_input_mode(TB_INPUT_ALT | TB_INPUT_MOUSE);

  /* check if canceled command */
  if(data[0] == -1 || data[0] == 0) {
    if(io == 0) {
      if (nregion < curbp->b_egap - curbp->b_gap || growgap(curbp, nregion)) {
        curbp->b_point = movegap(curbp, curbp->b_point);
        memcpy(curbp->b_gap, region, nregion * sizeof (char_t));
        curbp->b_gap += nregion;
        curbp->b_point = pos(curbp, curbp->b_egap);
        curbp->b_flags |= B_MODIFIED;
      }
    }
  } else {
    switch(io) {
      case 0: {
        input = (char_t *)data;
        insert_str();
        while(fgets(data, 512*2, pf) != NULL) {
          input = (char_t *)data;
          insert_str();
        }
        backsp();
        if(nregion > 0)
          free(region);
        break;
      }
      case 1: {
        data[strlen(data)-1] = '\0';
        /* Find the file name and find the line number */
        while(data[i] != '\0') {
          if(isLineNumber) {
            str_line[k] = data[i];
            k++;
          } else if(data[i] != ':') {
            temp[strlen(editor_dir)+i] = data[i];
          } else {
            isLineNumber = TRUE;
            l = i;
          }
          i++;
        }
        if(!isLineNumber)
          l = i;
        temp[strlen(editor_dir)+l] = '\0';
        bp = find_buffer(temp, TRUE);
        disassociate_b(curwp);
        curbp = bp;
        associate_b2w(curbp, curwp);
        /* load the file if not already loaded */
        if (bp != NULL && bp->b_fname[0] == '\0') {
           if (!load_file(temp)) {
             msg("New file %s", temp);
           }
          strncpy(curbp->b_fname, temp, NAME_MAX);
          curbp->b_fname[NAME_MAX] = '\0'; /* truncate if required */
          if(isLineNumber) {
            line = atoi(str_line);
            point = line_to_point(line);
            if (point != -1) {
              curbp->b_point = point;
              if (curbp->b_epage < pos(curbp, curbp->b_ebuf)) curbp->b_reframe = 1;
              msg("Line %d", line);
            } else {
              msg("Line %d, not found", line);
            }
            update_display(TRUE);
          }
        }
        break;
      }
    }
  }
  if(command != NULL)
    free(command);
  if(data != NULL)
    free(data);
  if (pclose(pf) != 0)
    msg("Error: Failed to close command stream.");
}