home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / wp_dtp / xdme1821.lha / XDME / io.c < prev    next >
C/C++ Source or Header  |  1993-03-25  |  8KB  |  432 lines
  1. /*
  2.  * CMD2.C
  3.  *
  4.  *    (C)Copyright 1987 by Matthew Dillon, All Rights Reserved
  5.  */
  6.  
  7. #include "defs.h"
  8.  
  9. Prototype void do_edit         (void);
  10. Prototype int  do_bappendsave(void);
  11. Prototype int  do_bsave      (void);
  12. Prototype int  do_barpsave   (void);
  13. Prototype int  do_appendsave (void);
  14. Prototype int  do_save         (void);
  15. Prototype int  do_saveas     (void);
  16. Prototype int  do_aslsave    (void);
  17. Prototype int  do_reqsave    (void);
  18. Prototype int  saveit         (const char *);
  19. Prototype void do_cd         (void);
  20.  
  21.  
  22. typedef struct WBStartup    WBS;
  23. typedef struct DiskObject   DISKOBJ;
  24.  
  25.  
  26. #include "rexx.h"
  27.  
  28.  
  29. void do_edit (void)
  30. {
  31.     FILE *  fi;
  32.     BPTR    oldlock;
  33.     BPTR    new_lock;
  34.     long    lines;
  35.     UBYTE   buf[MAXLINELEN];
  36.     UBYTE * ptr;
  37.     BOOL    failed = 1;
  38.     BOOL    newfile = (*av[0] == 'n');
  39.     ED      * ep       = Ep;
  40.  
  41.     text_sync ();
  42.  
  43.     if (newfile)
  44.     {    /* newfile or insfile */
  45.     if (ep->modified && getyn("XDME Warning", "Delete modified Image?", "Yes|No") == 0)
  46.         return;
  47.  
  48.     ep = uninit_init (ep);
  49.  
  50.     strncpy ((char *)ep->name, (char *)av[1], 63);
  51.     ep->name[63] = 0;
  52.     } else
  53.     {
  54.     ep->modified = 1;
  55.     }
  56.  
  57.     lines = ep->lines;
  58.     oldlock = CurrentDir (ep->dirlock);
  59.  
  60.     if (fi = fopen (av[1], "r"))
  61.     {
  62.     int  len;
  63.     char oktitle  = 1;
  64.  
  65.     /* Get lock for file */
  66.     if (newfile)
  67.     {
  68.         if (new_lock = Lock (av[1], SHARED_LOCK))
  69.         {
  70.         BOOL success;
  71.  
  72.         /* get full path */
  73.         success = NameFromLock (new_lock, tmp_buffer,
  74.                               sizeof (tmp_buffer));
  75.  
  76.         /* always unlock lock */
  77.         UnLock (new_lock);
  78.  
  79.         if (success)
  80.         {
  81.             strncpy (ep->name, FilePart (tmp_buffer),
  82.                               sizeof (ep->name)-1);
  83.             ep->name[sizeof(ep->name)-1] = 0;
  84.  
  85.             *(PathPart(tmp_buffer)) = 0;
  86.  
  87.             new_lock = Lock (tmp_buffer, SHARED_LOCK);
  88.  
  89.             UnLock (ep->dirlock);
  90.  
  91.             ep->dirlock = new_lock;
  92.         }
  93.         }
  94.     }
  95.  
  96.     sprintf (buf, "Loading %s ...", ep->name);
  97.     title (buf);
  98.  
  99.     while ((len = xefgets(fi, (char *)buf, MAXLINELEN-1)) >= 0)
  100.     {
  101.         failed = 0;
  102.         len ++;
  103.  
  104.         if (makeroom(256) && (ptr = allocline(len)))
  105.         {
  106.         SETLINE(ep,ep->lines) = ptr;
  107.         ep->lines ++;
  108.  
  109.         movmem(buf, ptr, len);
  110.         } else
  111.         {
  112.         set_window_params ();
  113.         nomemory ();
  114.         oktitle = 0;
  115.         break;
  116.         }
  117.     }
  118.  
  119.     set_window_params ();
  120.  
  121.     if (oktitle)
  122.     {
  123.         title ("Loading OK");
  124.         globalflags.MForceTitle = TRUE;
  125.     }
  126.  
  127.     fclose (fi);
  128.     } else /* couldn't open file */
  129.     {
  130.     if (!newfile) /* insertfile ? */
  131.     {
  132.         warn ("File `%s' not found", av[1]);
  133.  
  134.         cmderr = CMD_FAILED;
  135.     } else
  136.     {
  137.         /* copy argument */
  138.         strcpy (tmp_buffer, av[1]);
  139.  
  140.         /* copy name of file */
  141.         strncpy (ep->name, FilePart (tmp_buffer), sizeof (ep->name)-1);
  142.         ep->name[sizeof(ep->name)-1] = 0;
  143.  
  144.         /* clip name off */
  145.         *(PathPart (tmp_buffer)) = 0;
  146.  
  147.         /* get new lock */
  148.         new_lock = Lock (tmp_buffer, SHARED_LOCK);
  149.  
  150.         /* unlock old lock */
  151.         UnLock (ep->dirlock);
  152.  
  153.         /* remember new lock */
  154.         ep->dirlock = new_lock;
  155.     }
  156.     }
  157.  
  158.     CurrentDir (oldlock);
  159.  
  160.     if (ep->lines != 1 && lines == 1 && *GETTEXT(ep,0) == 0)
  161.     {
  162.     ep->modified = 0;
  163.     ep->line     = 0;
  164.     freeline (GETLINE(ep,0));
  165.     bmovl (ep->list+1, ep->list, --ep->lines);
  166.     } else
  167.     {
  168.     if (!failed && lines <= ep->lines - 1)
  169.     {
  170.         /* INSFILE: move text to correct position */
  171.         ActualBlock.ep       = ep;
  172.         ActualBlock.start_line = lines;
  173.         ActualBlock.end_line   = ep->lines - 1;
  174.         ActualBlock.type       = BT_LINE;
  175.  
  176.         do_bmove ();
  177.     }
  178.     }
  179.  
  180.     set_window_params ();
  181.     window_title ();
  182.     text_load ();
  183.     text_redisplay ();
  184. } /* do_edit */
  185.  
  186.  
  187. static BOOL blockmode;
  188.  
  189. int do_appendsave (void)
  190. {
  191.     return (saveit ("a"));
  192. } /* do_appendsave */
  193.  
  194.  
  195. int do_bappendsave (void)
  196. {
  197.     int result = FALSE;
  198.  
  199.     if (block_ok ())
  200.     {
  201.     blockmode = 1;
  202.  
  203.     result = saveit ("a");
  204.  
  205.     blockmode = 0;
  206.     } else
  207.     error ("bappendsave:\nNo block specified");
  208.  
  209.     return (result);
  210. } /* do_bappendsave */
  211.  
  212.  
  213. int do_bsave (void)
  214. {
  215.     int result = FALSE;
  216.  
  217.     if (block_ok ())
  218.     {
  219.     blockmode = 1;
  220.  
  221.     result = saveit ("w");
  222.  
  223.     blockmode = 0;
  224.     } else
  225.     error ("bsave:\nNo block specified");
  226.  
  227.     return (result);
  228. } /* do_bsave() */
  229.  
  230.  
  231. int do_barpsave (void)
  232. {
  233.     int result = FALSE;
  234.  
  235.     if (block_ok ())
  236.     {
  237.     blockmode = 1;
  238.  
  239.     result = aslsave ();
  240.  
  241.     blockmode = 0;
  242.     } else
  243.     error ("barpsave:\nNo block specified");
  244.  
  245.     return (result);
  246. } /* do_barpsave */
  247.  
  248.  
  249. int do_save (void)
  250. {
  251.     av[1] = Ep->name;
  252.  
  253.     return (do_saveas ());
  254. } /* do_save() */
  255.  
  256.  
  257. int do_saveas (void)
  258. {
  259.     return (saveit ("w"));
  260. } /* do_saveas */
  261.  
  262.  
  263. int do_aslsave (void)
  264. {
  265.     return (aslsave ());
  266. } /* do_aslsave */
  267.  
  268.  
  269. int do_reqsave (void)
  270. {
  271.     return (reqsave ());
  272. } /* do_reqsave */
  273.  
  274.  
  275. int saveit (const char * om)   /* av: xxx filename */
  276. {
  277.     BPTR    oldlock;
  278.     FILE  * fi;
  279.     long    i;
  280.     short   j,
  281.         k;
  282.     UBYTE * ptr,
  283.       * bp;
  284.     Line    xs,
  285.         xe;
  286.     ED      * ep;
  287.  
  288.     if (!stricmp (av[1], "unnamed"))
  289.     {
  290.     return (do_aslsave ());
  291.     } else if (!stricmp (Ep->name, "unnamed"))  /* get new name */
  292.     {
  293.     strncpy (Ep->name, FilePart (av[1]), sizeof (Ep->name)-1);
  294.     Ep->name[sizeof(Ep->name)-1] = 0;
  295.     }
  296.  
  297.     if (blockmode) /* block is ok */
  298.     {
  299.     xs = ActualBlock.start_line;
  300.     xe = ActualBlock.end_line + 1;
  301.     ep = ActualBlock.ep;
  302.     } else
  303.     {
  304.     xs = 0;
  305.     xe = Ep->lines;
  306.     ep = Ep;
  307.     }
  308.  
  309.     text_sync ();
  310.     oldlock = CurrentDir (Ep->dirlock);
  311.  
  312.     if (Wbs && globalflags.Wdisable == 0)
  313.     {      /* Write out .info file */
  314.     DISKOBJ sdo, * d;
  315.  
  316.     clrmem (&sdo, sizeof(sdo));
  317.  
  318.     if ((d = GetDiskObject ((char *)av[1])) == NULL)
  319.     {
  320.         /* Get path to XDME with name of the editor appended */
  321.         if (getpathto (Wbs->sm_ArgList[0].wa_Lock,
  322.                        Wbs->sm_ArgList[0].wa_Name, tmp_buffer))
  323.         {
  324.  
  325.         sdo.do_Magic   = WB_DISKMAGIC;
  326.         sdo.do_Version = WB_DISKVERSION;
  327.  
  328.         makemygadget (&sdo.do_Gadget);
  329.  
  330.         sdo.do_Type       = WBPROJECT;
  331.         sdo.do_DefaultTool = (char *)tmp_buffer;
  332.         sdo.do_ToolTypes   = NULL;
  333.         sdo.do_CurrentX    = NO_ICON_POSITION;
  334.         sdo.do_CurrentY    = NO_ICON_POSITION;
  335.         sdo.do_DrawerData  = NULL;
  336.         sdo.do_ToolWindow  = NULL;
  337.         sdo.do_StackSize   = 8192;
  338.  
  339.         PutDiskObject ((char *)av[1], &sdo);
  340.         }
  341.     } else
  342.     {
  343.         FreeDiskObject (d);
  344.     }
  345.     }
  346.  
  347.     if (fi = fopen (av[1], om))
  348.     {
  349.     title ("Saving ...");
  350.  
  351.     for (i = xs; i < xe; ++i)
  352.     {
  353.         ptr = GETTEXT(ep,i);
  354.  
  355.         if (globalflags.Savetabs)
  356.         {
  357.         for (bp = tmp_buffer, j = 0; *ptr; ++ptr, ++bp, j = (j+1)&7)
  358.         {
  359.             *bp = *ptr;
  360.             if (j == 7 && *bp == ' ' && *(bp-1) == ' ')
  361.             {
  362.             k = j;
  363.             while (k-- >= 0 && *bp == ' ')
  364.                 --bp;
  365.             *++bp = 9;
  366.             } else
  367.             {
  368.             if (globalflags.SimpleTabs)     /* PATCH_NULL [25 Jan 1993] : line added */
  369.                 break;            /* PATCH_NULL [25 Jan 1993] : line added */
  370.  
  371.             if (*bp < 32 || *bp == '\"' || *bp == '\'' || *bp == '`' || *bp == '(')
  372.                 break;
  373.             }
  374.         }
  375.         strcpy ((char *)bp, (char *)ptr);
  376.  
  377.         ptr = tmp_buffer;
  378.         }
  379.  
  380.         fputs (ptr, fi);
  381.         fputc ('\n', fi);
  382.     }
  383.     if (fclose (fi))
  384.     {
  385.         error ("save:\nWrite failed !");
  386.     } else
  387.     {
  388.         title ("Saving OK");
  389.         globalflags.MForceTitle = TRUE;
  390.  
  391.         /* Only remove modify if blockmode is OFF */
  392.         ep->modified = (ep->modified && blockmode);
  393.     }
  394.     } else
  395.     {
  396.     error ("save:\nUnable to open write file\n`%s'", av[1]);
  397.     }
  398.  
  399.     blockmode = 0;
  400.     CurrentDir (oldlock);
  401.  
  402.     window_title ();
  403.  
  404.     return (!globalflags.Abortcommand);
  405. } /* do_saveit() */
  406.  
  407.  
  408. /*
  409.  *  av[1] - Directory
  410.  */
  411.  
  412. void do_cd (void)
  413. {
  414.     BPTR oldlock;
  415.     BPTR lock;
  416.  
  417.     oldlock = CurrentDir (Ep->dirlock);
  418.  
  419.     if (lock = Lock (av[1], SHARED_LOCK))
  420.     {
  421.     UnLock (CurrentDir (oldlock));
  422.     Ep->dirlock = (long)lock;
  423.     } else
  424.     {
  425.     CurrentDir (oldlock);
  426.  
  427.     error ("cd:\nUnable to cd to\n`%s'", av[1]);
  428.     }
  429. } /* do_cd */
  430.  
  431.  
  432.