home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / util / misc / ascsend / cli / source / ascsend.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-19  |  12.7 KB  |  445 lines
  1. #include "ascsend.h"
  2.  
  3. UBYTE          *version = ASCSEND_VERSION; 
  4. LONG            values[10] = {0L,0L,0L,0L,0L,0L,0L,0L,0L,0L};
  5. struct  RDArgs *args;
  6. ULONG           verzoegerung = 12;
  7. ULONG           v_char;
  8. long          __OSlibversion = 37;
  9. ULONG          filesize;
  10. ULONG          filepos;
  11. UBYTE         *filename;
  12. UBYTE          windowname[STRINGSIZE];
  13. UBYTE         *screenname;
  14. ULONG          waits;
  15. LONG           do_it = FALSE;
  16.  
  17. void __stdargs main(int argc,char **argv)
  18. {
  19.  {
  20.   if(args = ReadArgs("FILE/A,WINDOW/K/M,SCREEN/K,WAIT/K/N,DELAY/K/N,DELAYCHAR/K/N,",values,NULL))
  21.   {
  22.    filename   = (UBYTE *)(values[0]);
  23.    if(values[1])
  24.    {
  25.     UBYTE **p;
  26.     p = (UBYTE **)values[1];
  27.     while(*p)
  28.     {
  29.      strcat(windowname,*p);strcat(windowname," ");
  30.      p++;
  31.     }
  32.     windowname[strlen(windowname)-1] = 0;
  33.    }
  34.    if(values[2])screenname = (UBYTE *)values[2];
  35.    if(values[3]){ LONG *n = (LONG *)values[3];waits = ((LONG)*n > 0) ? (LONG)*n : 0 ;}
  36.    if(values[4]){ LONG *n = (LONG *)values[4];verzoegerung = ((LONG)*n > 0) ? (LONG)*n : 0 ;}
  37.    if(values[5]){ LONG *n = (LONG *)values[5];v_char = ((LONG)*n > 0) ? (LONG)*n : 0 ;}
  38.  
  39.    if(screenname && windowname[0])printf("*ASCSEND FEHLER* SCREEN und WINDOW Parameter geht nicht !\n");  
  40.    else
  41.    {
  42.     if(!(screenname || windowname[0]))do_it = TRUE;
  43.     if(waits)Delay(waits);
  44.     if(screenname)   activate_screen(screenname);
  45.     if(windowname[0])activate_window(windowname);
  46.     if(do_it)Sendfile(filename,GET_A_FILE);
  47.    }
  48.   }
  49.   FreeArgs(args);
  50.  }
  51.  exit(0);
  52. }
  53.  
  54. long __regargs Sendfile(UBYTE *filename,ULONG mode)
  55. {
  56.  int rc = TRUE;
  57.  struct InputEvent *ie;
  58.  UBYTE buffer[STRINGSIZE];
  59.  UBYTE *filebuffer;
  60.  int Ldelay     = FALSE;
  61.  ULONG           stop = FALSE;
  62.  ULONG           v_line;
  63.  ULONG           v_z;
  64.  ULONG           fpm;
  65.  v_line = verzoegerung;
  66.  v_z = v_char;
  67.  filepos = 0;
  68.  if(filebuffer = getfilebuffer(filename,mode))
  69.  {
  70.   while((getnextchar(filebuffer,buffer)) && (!stop))
  71.   {
  72.    *(buffer + 1) = 0;
  73.    switch(*buffer)
  74.    {
  75.     case '\n' : Ldelay = TRUE;
  76.                 strcpy(buffer,"\\n");
  77.                 break;
  78.     case '\r' : Ldelay = TRUE;
  79.                 strcpy(buffer,"\\r");
  80.                 break;
  81.     case '\t' : strcpy(buffer,"\\t");
  82.                 break;
  83.     case '\\' : fpm = filepos;
  84.                 getnextchar(filebuffer,buffer + 1);
  85.                 *(buffer + 2) = 0;
  86.                 {
  87.                  int end = FALSE;
  88.                  int p = 2;
  89.                  ULONG v;
  90.                  if((*(buffer + 1)=='d')||(*(buffer + 1)=='l')||(*(buffer + 1)=='c')||
  91.                     (*(buffer + 1)=='n')||(*(buffer + 1)=='r')||(*(buffer + 1)=='t'))
  92.                  {
  93.                   do
  94.                   {
  95.                    if( (*(buffer + 1)=='n')||(*(buffer + 1)=='r')||(*(buffer + 1)=='t'))
  96.                    {
  97.                     end = TRUE;
  98.                    }
  99.                    else
  100.                    {
  101.                     getnextchar(filebuffer,buffer + p);
  102.                     if(!(isdigit(*(buffer + p))) || (p >= 6))
  103.                     {
  104.                      end = TRUE;
  105.                      *(buffer + p + 1) = 0;
  106.                      v = atol(buffer + 2);
  107.                      switch(*(buffer + 1))
  108.                      {
  109.                       case 'd' : Delay(v);
  110.                                  break;
  111.                       case 'l' : v_line = v;
  112.                                  break;
  113.                       case 'c' : v_z = v;
  114.                                  break;
  115.                       default  : break;
  116.                      }
  117.                      *buffer = 0;
  118.                      filepos -= 1;
  119.                     }
  120.                     p++;
  121.                     if(p >= (STRINGSIZE - 2))end = TRUE;
  122.                    }
  123.                   }
  124.                   while(!end); 
  125.                  }
  126.                  else
  127.                  {
  128.                   UBYTE t[2] = {0,0}; 
  129.                   struct InputEvent ev;
  130.                   if(*(buffer + 1) == '(')
  131.                   {
  132.                    getnextchar(filebuffer,buffer + 2);
  133.                    getnextchar(filebuffer,buffer + 3);
  134.                    getnextchar(filebuffer,buffer + 4);
  135.                    getnextchar(filebuffer,buffer + 5);
  136.                    if((*(buffer + 3) == 'm')&&(*(buffer + 5)==':'))
  137.                    {
  138.                     int p = 6;
  139.                     int py;
  140.                     int end = FALSE;
  141.                     while(!end)
  142.                     {
  143.                      getnextchar(filebuffer,buffer + p);
  144.                      if(!(isdigit(*(buffer + p))))
  145.                      {
  146.                       end = TRUE;
  147.                      }
  148.                      p++;
  149.                     }
  150.                     --p;
  151.                     if(*(buffer + p) == ',')
  152.                     {
  153.                      p++;
  154.                      py = p;
  155.                      end = FALSE;
  156.                      while(!end)
  157.                      {
  158.                       getnextchar(filebuffer,buffer + p);
  159.                       if(!(isdigit(*(buffer + p))))
  160.                       {
  161.                        end = TRUE;
  162.                       }
  163.                       p++;
  164.                      }
  165.                      --p;
  166.                      if(*(buffer + p) == ')')
  167.                      {
  168.                       ev.ie_Class = IECLASS_POINTERPOS;
  169.                       ev.ie_NextEvent = NULL;
  170.                       ev.ie_Qualifier = 0;
  171.                       ev.ie_SubClass  = 0;
  172.                       ev.ie_TimeStamp.tv_secs = 0;
  173.                       ev.ie_TimeStamp.tv_micro = 0;
  174.                       ev.ie_Y = (WORD)atol(buffer + py);
  175.                       ev.ie_X = (WORD)atol(buffer + 6);
  176.                       switch(*(buffer + 2))
  177.                       {
  178.                        case 'l' : if(*(buffer + 4) == 'd')
  179.                                    ev.ie_Code      = IECODE_LBUTTON ;
  180.                                   else
  181.                                     ev.ie_Code      = IECODE_LBUTTON | IECODE_UP_PREFIX;
  182.                                   AddIEvents(&ev);
  183.                                   break;
  184.                        case 'r' : if(*(buffer + 4) == 'd')
  185.                                    ev.ie_Code      = IECODE_RBUTTON ;
  186.                                   else
  187.                                     ev.ie_Code      = IECODE_RBUTTON | IECODE_UP_PREFIX;
  188.                                   AddIEvents(&ev);
  189.                                   break;
  190.                         case 'm' : if(*(buffer + 4) == 'd')
  191.                                    ev.ie_Code      = IECODE_MBUTTON ;
  192.                                   else
  193.                                     ev.ie_Code      = IECODE_MBUTTON | IECODE_UP_PREFIX;
  194.                                   AddIEvents(&ev);
  195.                                   break;
  196.                       }
  197.                       *buffer = 0;
  198.                      }
  199.                      else
  200.                      {
  201.                       filepos =fpm;
  202.                       strcpy(buffer,"\\\\");
  203.                       if(ie = InvertString(buffer,NULL))
  204.                       {
  205.                        AddIEvents(ie);
  206.                        FreeIEvents(ie);
  207.                        *buffer = 0;
  208.                       }
  209.                      }
  210.                     }
  211.                     else
  212.                     {
  213.                      filepos = fpm;
  214.                      strcpy(buffer,"\\\\");
  215.                      if(ie = InvertString(buffer,NULL))
  216.                      {
  217.                       AddIEvents(ie);
  218.                       FreeIEvents(ie);
  219.                       *buffer = 0;
  220.                      }
  221.                     }
  222.                    }
  223.                    else
  224.                    {
  225.                     filepos = fpm;
  226.                     strcpy(buffer,"\\\\");
  227.                     if(ie = InvertString(buffer,NULL))
  228.                     {
  229.                      AddIEvents(ie);
  230.                      FreeIEvents(ie);
  231.                      *buffer = 0;
  232.                     }
  233.                    }
  234.                   }
  235.                   else
  236.                   {
  237.                    t[0] = *(buffer + 1);
  238.                    strcpy(buffer,"\\\\");
  239.                    if(ie = InvertString(buffer,NULL))
  240.                    {
  241.                     AddIEvents(ie);
  242.                     FreeIEvents(ie);
  243.                    }
  244.                   }
  245.                   strcpy(buffer,t);
  246.                   switch(*buffer)
  247.                   {
  248.                    case '\n' : strcpy(buffer,"\\n");
  249.                                break;
  250.                    case '\r' : strcpy(buffer,"\\r");
  251.                                break;
  252.                    case '<'  : *buffer = 0;filepos -= 1;
  253.                                break;
  254.                   }
  255.                  }
  256.                 }
  257.                 break;
  258.     case '<'  : {
  259.                  int end;
  260.                  int p;
  261.                  end = FALSE;
  262.                  p = 1;
  263.                  fpm = filepos;
  264.                  do
  265.                  {
  266.                   getnextchar(filebuffer,buffer + p);
  267.                   switch(*(buffer + p))
  268.                   {
  269.                    case '\r': 
  270.                    case '\n': if(ie = InvertString("\\<",NULL))
  271.                               {
  272.                                AddIEvents(ie); 
  273.                                FreeIEvents(ie);
  274.                               }
  275.                               filepos = fpm;
  276.                               *buffer = 0;
  277.                               end = TRUE;
  278.                               break;
  279.                    case '>' : *(buffer + p + 1) = 0;
  280.                               if(ie = InvertString(buffer,NULL))
  281.                               {
  282.                                AddIEvents(ie); 
  283.                                FreeIEvents(ie);
  284.                               }
  285.                               else
  286.                               {
  287.                                if(ie = InvertString("\\<",NULL))
  288.                                {
  289.                                 AddIEvents(ie); 
  290.                                 FreeIEvents(ie);
  291.                                }
  292.                                filepos = fpm;
  293.                               }
  294.                               *buffer = 0;
  295.                               end = TRUE;
  296.                               break;
  297.                    default  : break;
  298.                   }
  299.                   p++;
  300.                   if(p >= (STRINGSIZE - 2))end = TRUE;
  301.                  }
  302.                  while(!end);
  303.                  break;
  304.                 }
  305.     
  306.     case '>'  : if(ie = InvertString(buffer,NULL))
  307.                 {
  308.                  AddIEvents(ie); 
  309.                  FreeIEvents(ie);
  310.                 }
  311.                 strcpy(buffer,"\\>");
  312.                 break;
  313.     default   : *(buffer + 1) = 0;
  314.                 break;
  315.    }
  316.    if(ie = InvertString(buffer,NULL))
  317.    {
  318.     if(v_z)Delay(v_z);
  319.     AddIEvents(ie);
  320.     if(Ldelay)
  321.     {
  322.      Delay(v_line);
  323.      Ldelay = FALSE;    
  324.     }
  325.     FreeIEvents(ie);
  326.    }
  327.   }
  328.  }
  329.  return rc;
  330. }
  331.  
  332. UBYTE __regargs *makemem(ULONG size)
  333. {
  334.  return((UBYTE *)AllocVec(size,MEMF_PUBLIC | MEMF_CLEAR));   
  335. }
  336.  
  337. void releasemem(void *mem)
  338. {
  339.  FreeVec(mem);   
  340. }
  341.  
  342. UBYTE __regargs *getfilebuffer(UBYTE *filename,ULONG mode)
  343. {
  344.  struct FileInfoBlock *fib;
  345.  BPTR lock,fh;
  346.  UBYTE *buffer;
  347.  switch( mode )
  348.  {
  349.   case GET_A_FILE: 
  350.   if(lock = Lock(filename,ACCESS_READ))
  351.   {
  352.    if(fib = AllocDosObject(DOS_FIB,TAG_DONE))
  353.    {
  354.     Examine(lock,fib);
  355.     filesize = fib->fib_Size;
  356.     FreeDosObject(DOS_FIB,fib);
  357.     if(buffer = (UBYTE *)makemem(filesize))
  358.     {
  359.      if(fh = OpenFromLock(lock))
  360.      {
  361.       FRead(fh,buffer,filesize,1);
  362.       Close(fh);
  363.       return buffer;
  364.      }
  365.      else UnLock(lock);
  366.     }
  367.    }
  368.   }
  369.   return NULL;
  370.   break;
  371.   case GET_A_STRING :
  372.   filesize = strlen(filename + 1);
  373.   if(buffer = (UBYTE *)makemem(filesize))
  374.   {
  375.    strcpy(buffer,filename);
  376.    return buffer;
  377.   }
  378.   else return NULL;
  379.   break;
  380.  }    
  381.  return NULL;
  382. }
  383.  
  384. void __regargs freefilebuffer(UBYTE *buffer,ULONG size)
  385. {
  386.  releasemem(buffer);   
  387. }
  388.  
  389. BOOL __regargs getnextchar(UBYTE *buffer,UBYTE *where)
  390. {
  391.  if(filepos >= filesize)return FALSE;
  392.  *where = *(buffer + filepos);
  393.  filepos++;   
  394.  return TRUE;
  395. }
  396.  
  397. void activate_screen(UBYTE *screen)
  398. {
  399.  ULONG i_lock;
  400.  struct Window *wd;
  401.  struct Screen *cs;
  402.  int end = FALSE;
  403.  i_lock = LockIBase(0);
  404.  cs = IntuitionBase->FirstScreen;
  405.  while(cs && !end)
  406.  {
  407.   if(!strnicmp(screen,cs->Title,strlen(screen)))
  408.   {
  409.    end = TRUE;
  410.    ScreenToFront(cs);
  411.    if(wd = cs->FirstWindow)
  412.    {
  413.     do_it = TRUE;
  414.    }
  415.   }
  416.   cs = cs->NextScreen;
  417.  }
  418.  UnlockIBase(i_lock);
  419.  if(do_it == TRUE) ActivateWindow(wd);
  420. }
  421.  
  422. void activate_window(UBYTE *wnd)
  423. {
  424.  struct Window *wd;
  425.  struct Screen *sc;
  426.  int end = FALSE;
  427.  sc = IntuitionBase->FirstScreen;
  428.  while(sc && !end)
  429.  {
  430.   wd = sc->FirstWindow;
  431.   while(wd && !end)
  432.   {
  433.    if(!strnicmp(wnd,wd->Title,strlen(wnd)))
  434.    {
  435.     end = TRUE;
  436.     do_it = TRUE;
  437.     ScreenToFront(sc);
  438.     ActivateWindow(wd);
  439.    }
  440.    wd = wd->NextWindow;
  441.   }
  442.   sc = sc->NextScreen;
  443.  }
  444. }
  445.