home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / new / util / edit / jade / src / amiga_misc.c < prev    next >
C/C++ Source or Header  |  1994-10-06  |  17KB  |  673 lines
  1. /* amiga_misc.c -- Miscellaneous functions for AmigaDOS
  2.    Copyright (C) 1993, 1994 John Harper <jsh@ukc.ac.uk>
  3.  
  4.    This file is part of Jade.
  5.  
  6.    Jade is free software; you can redistribute it and/or modify it
  7.    under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2, or (at your option)
  9.    any later version.
  10.  
  11.    Jade is distributed in the hope that it will be useful, but
  12.    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 Jade; see the file COPYING.    If not, write to
  18.    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "jade.h"
  21. #include "jade_protos.h"
  22.  
  23. #include <clib/dos_protos.h>
  24. #define INTUI_V36_NAMES_ONLY
  25. #include <clib/intuition_protos.h>
  26. #include <clib/asl_protos.h>
  27. #include <exec/initializers.h>
  28. #include <string.h>
  29. #include <stdlib.h>
  30.  
  31. _PR void freq_kill(void);
  32. _PR void beep(VW *);
  33. _PR bool same_files(u_char *, u_char *);
  34. _PR u_char *file_part(u_char *);
  35. _PR void NewList(struct List *);
  36. _PR VALUE lookup_errno(void);
  37. _PR void doconmsg(u_char *);
  38. _PR VALUE read_file(u_char *);
  39.  
  40. _PR bool file_exists(u_char *);
  41. _PR long file_mod_time(u_char *);
  42. _PR long sys_time(void);
  43. _PR int add_file_part(u_char *, u_char *, int);
  44. _PR VALUE sys_expand_file_name(VALUE);
  45. _PR VALUE sys_fully_qualify_file_name(VALUE);
  46.  
  47. _PR void sys_misc_init(void);
  48.  
  49. /*
  50.  * File req stuff.
  51.  * I don't like the ASL requester but I couldn't be bothered to make the DICE
  52.  * libraries for reqtools.library. Use the RTpatch prog to get nice (fast)
  53.  * requesters.
  54.  */
  55. void *AslBase;
  56. static struct FileRequester *file_req;
  57.  
  58. void
  59. freq_kill(void)
  60. {
  61.     if(file_req)
  62.     {
  63.     FreeAslRequest(file_req);
  64.     file_req = NULL;
  65.     }
  66.     if(AslBase)
  67.     {
  68.     CloseLibrary(AslBase);
  69.     AslBase = NULL;
  70.     }
  71. }
  72.  
  73. _PR VALUE cmd_file_req(VALUE title, VALUE filename, VALUE writep);
  74. DEFUN("file-req", cmd_file_req, subr_file_req, (VALUE title, VALUE filename, VALUE writep), V_Subr3, DOC_file_req) /*
  75. ::doc:file_req::
  76. file-req TITLE [FILE-NAME] [FOR-WRITING-P]
  77. <AMIGA ONLY>
  78.  
  79. Displays a file requester (standard one from asl.library) asking for the name
  80. of a file. FOR-WRITING-P should be non-nil if the file being requested for
  81. will be written to. TITLE is the name of the requester. FILE-NAME is
  82. the starting value for the filename.
  83.  
  84. If a filename is selected its name is returned (a string), else this
  85. function returns nil.
  86. ::end:: */
  87. {
  88.     VALUE result = sym_nil;
  89.     DECLARE1(title, STRINGP);
  90.     if(!STRINGP(filename))
  91.     filename = null_string;
  92.     if(AslBase || (AslBase = OpenLibrary("asl.library", 36)))
  93.     {
  94.     if(file_req
  95.        || (file_req = AllocAslRequestTags(ASL_FileRequest, TAG_DONE)))
  96.     {
  97.         u_short flags = 0;
  98.         u_char *dircopy;
  99.         if(!NILP(writep))
  100.         flags |= FILF_SAVE;
  101.         if(dircopy = str_dup(VSTR(filename)))
  102.         {
  103.         u_char *actualfile = FilePart(VSTR(filename));
  104.         dircopy[actualfile - VSTR(filename)] = 0;
  105.         if(AslRequestTags(file_req,
  106.             ASL_Hail, VSTR(title),
  107.             ASL_Window, curr_vw->vw_Window,
  108.             ASL_File, actualfile,
  109.             ASL_Dir, dircopy,
  110.             ASL_FuncFlags, flags,
  111.             TAG_END))
  112.         {
  113.             long sellen = strlen(file_req->rf_File) + strlen(file_req->rf_Dir) + 2;
  114.             if(result = make_string(sellen))
  115.             {
  116.             strcpy(VSTR(result), file_req->rf_Dir);
  117.             AddPart(VSTR(result), file_req->rf_File, sellen);
  118.             /* Ensure that the length field contains the *correct*
  119.                value.  */
  120.             DSTRING_HDR(result)->ds_Length = strlen(VSTR(result));
  121.             }
  122.             else
  123.             mem_error();
  124.         }
  125.         str_free(dircopy);
  126.         }
  127.         else
  128.         mem_error();
  129.     }
  130.     else
  131.         cmd_signal(sym_error, LIST_1(MKSTR("Can't allocate file requester")));
  132.     }
  133.     else
  134.     cmd_signal(sym_error, LIST_1(MKSTR("Need `asl.library'")));
  135.     return(result);
  136. }
  137.  
  138. void
  139. beep(VW *vw)
  140. {
  141.     DisplayBeep(vw->vw_Window->WScreen);
  142. }
  143.  
  144. bool
  145. same_files(u_char *file1, u_char *file2)
  146. {
  147.     bool rc = FALSE;
  148.     BPTR lck1;
  149.     if(lck1 = Lock(file1, SHARED_LOCK))
  150.     {
  151.     BPTR lck2;
  152.     if(lck2 = Lock(file2, SHARED_LOCK))
  153.     {
  154.         if(SameLock(lck1, lck2) == LOCK_SAME)
  155.         rc = TRUE;
  156.         UnLock(lck2);
  157.     }
  158.     UnLock(lck1);
  159.     }
  160.     else
  161.     rc = !stricmp(file1, file2);
  162.     return(rc);
  163. }
  164.  
  165. u_char *
  166. file_part(u_char *file)
  167. {
  168.     return(FilePart(file));
  169. }
  170.  
  171. #ifdef _DCC
  172. void
  173. NewList(struct List *list)
  174. {
  175.     list->lh_Head = (struct Node *)&list->lh_Tail;
  176.     list->lh_Tail = NULL;
  177.     list->lh_TailPred = (struct Node *)&list->lh_Head;
  178. }
  179. #endif
  180.  
  181. VALUE
  182. lookup_errno(void)
  183. {
  184.     u_char buf[256];
  185.     if(!Fault(IoErr(), "", buf, 256))
  186.     sprintf(buf, "%d", IoErr());
  187.     return(string_dup(buf));
  188. }
  189.  
  190. void
  191. doconmsg(u_char *msg)
  192. {
  193.     /*
  194.      * CLI/WB & 1.3/2.0 compatible
  195.      */
  196.     if(ami_from_wb)
  197.     {
  198.     BPTR fh = Open("CON:///80/Jade output/WAIT/CLOSE", MODE_NEWFILE);
  199.     if(fh)
  200.         Write(fh, msg, strlen(msg));
  201.     Close(fh);
  202.     }
  203.     else
  204.     Write(Output(), msg, strlen(msg));
  205. }
  206.  
  207. VALUE
  208. read_file(u_char *fileName)
  209. {
  210.     BPTR fh = Open(fileName, MODE_OLDFILE);
  211.     if(fh)
  212.     {
  213.     long length;
  214.     VALUE mem;
  215.     Seek(fh, 0, OFFSET_END);
  216.     length = Seek(fh, 0, OFFSET_BEGINNING);
  217.     if(mem = make_string(length + 1))
  218.     {
  219.         Read(fh, VSTR(mem), length);
  220.         VSTR(mem)[length] = 0;
  221.         Close(fh);
  222.         return(mem);
  223.     }
  224.     else
  225.         mem_error();
  226.     Close(fh);
  227.     }
  228.     return(cmd_signal(sym_file_error, list_2(lookup_errno(), string_dup(fileName))));
  229. }
  230.  
  231. int
  232. add_file_part(u_char *buf, u_char *part, int len)
  233. {
  234.     return(AddPart(buf, part, len));
  235. }
  236.  
  237. VALUE
  238. sys_expand_file_name(VALUE name)
  239. {
  240.     return(name);
  241. }
  242.  
  243. VALUE
  244. sys_fully_qualify_file_name(VALUE name)
  245. {
  246.     u_char buf[512];
  247.     BPTR lock = Lock(VSTR(name), ACCESS_READ);
  248.     if(lock)
  249.     {
  250.     /* easy, just expand from the lock. */
  251.     if(NameFromLock(lock, buf, 512))
  252.         name = string_dup(buf);
  253.     else
  254.         name = NULL;
  255.     }
  256.     else
  257.     {
  258.     /* trickier, the file doesn't exist; find its parent and work from
  259.        there. */
  260.     long len = PathPart(VSTR(name)) - VSTR(name);
  261.     memcpy(buf, VSTR(name), len);
  262.     buf[len] = 0;
  263.     lock = Lock(buf, ACCESS_READ);
  264.     if(lock && NameFromLock(lock, buf, 512))
  265.     {
  266.         if(add_file_part(buf, VSTR(name) + len, 512))
  267.         name = string_dup(buf);
  268.         else
  269.         name = NULL;
  270.     }
  271.     }
  272.     if(lock != NULL)
  273.     UnLock(lock);
  274.     return(name);
  275. }
  276.  
  277. long
  278. getfibfield(u_char *file, int field)
  279. {
  280.     long rc = 0;
  281.     BPTR lock;
  282.     if(lock = Lock(file, SHARED_LOCK))
  283.     {
  284.     struct FileInfoBlock *fib;
  285.     if(fib = mymalloc(sizeof(struct FileInfoBlock)))
  286.     {
  287.         if(Examine(lock, fib))
  288.         rc = *(LONG *)((char *)fib + field);
  289.         myfree(fib);
  290.     }
  291.     UnLock(lock);
  292.     }
  293.     return(rc);
  294. }
  295.  
  296. _PR VALUE cmd_flush_output(void);
  297. DEFUN("flush-output", cmd_flush_output, subr_flush_output, (void), V_Subr0, DOC_flush_output)
  298. {
  299.     return(sym_t);
  300. }
  301.  
  302. _PR VALUE cmd_delete_file(VALUE file);
  303. DEFUN_INT("delete-file", cmd_delete_file, subr_delete_file, (VALUE file), V_Subr1, DOC_delete_file, "fDelete file:")
  304. {
  305.     DECLARE1(file, STRINGP);
  306.     if(DeleteFile(VSTR(file)))
  307.     return(sym_t);
  308.     return(cmd_signal(sym_file_error, list_2(lookup_errno(), file)));
  309. }
  310.  
  311. _PR VALUE cmd_rename_file(VALUE src, VALUE dst);
  312. DEFUN_INT("rename-file", cmd_rename_file, subr_rename_file, (VALUE src, VALUE dst), V_Subr2, DOC_rename_file, "fRename file:\nFRename file `%s' as:")
  313. {
  314.     DECLARE1(src, STRINGP);
  315.     DECLARE2(dst, STRINGP);
  316.     if(Rename(VSTR(src), VSTR(dst)))
  317.     return(sym_t);
  318.     return(cmd_signal(sym_file_error, list_3(lookup_errno(), src, dst)));
  319. }
  320.  
  321. _PR VALUE cmd_copy_file(VALUE src, VALUE dst);
  322. DEFUN_INT("copy-file", cmd_copy_file, subr_copy_file, (VALUE src, VALUE dst), V_Subr2, DOC_copy_file, "fCopy file:\nFCopy file `%s' to:")
  323. {
  324.     VALUE res = sym_t;
  325.     BPTR srcf;
  326.     DECLARE1(src, STRINGP);
  327.     DECLARE2(dst, STRINGP);
  328.     srcf = Open(VSTR(src), MODE_OLDFILE);
  329.     if(srcf != NULL)
  330.     {
  331.     int dstf = Open(VSTR(dst), MODE_NEWFILE);
  332.     if(dstf != NULL)
  333.     {
  334.         int rd;
  335.         int prot = getfibfield(VSTR(src), (int)OFFSET(FileInfoBlock, fib_Protection));
  336.         if(prot != 0)
  337.         SetProtection(VSTR(dst), prot &~ FIBF_ARCHIVE);
  338.         do {
  339.         u_char buf[BUFSIZ];
  340.         int wr;
  341.         rd = Read(srcf, buf, BUFSIZ);
  342.         if(rd < 0)
  343.         {
  344.             res = signal_