home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0600 / CCE_0657.ZIP / CCE_0657.PD / TREIBER.C < prev    next >
C/C++ Source or Header  |  1993-10-08  |  7KB  |  324 lines
  1. #include <signal.h>
  2. #include <atarierr.h>
  3.  
  4. #ifdef __GNUC__
  5. #include <fcntl.h>
  6. #include <ioctl.h>
  7. #include <osbind.h>
  8. #endif
  9.  
  10. #ifdef __TURBOC__
  11. #include "mintbind.h"    /* Geht seltsamerweise nur mit der eigenen Version */
  12. #include <filesys.h>
  13. #endif
  14.  
  15. #include <stdlib.h>
  16. #include <string.h>
  17.  
  18. #include "treiber.h"
  19.  
  20. #define FALSE 0
  21. #define TRUE 1
  22.  
  23. #define _SHOW_PRT_    /* Fortgang anzeigen */
  24.  
  25. /********************************************************************/
  26. /* Externe routinen in Assembler (FAST_DVI.S) */
  27. extern long    prn_byte( char *ptr, long byte );
  28. extern void    exstall( void );
  29.  
  30. extern volatile long    old_vec;
  31. /* 22.1.93 */
  32.  
  33. /********************************************************************/
  34.  
  35. /* Pufferspeicher */
  36. static char    *puffer, *druck_puffer;
  37. long    max_puffer_laenge = 8192L;    /* Kann vom Programm modifiziert werden */
  38. static long    puffer_laenge = 0L;
  39.  
  40. /* Shared Memory */
  41. char                shm_name[128];
  42. static int    shm;
  43. static char    *memory;
  44.  
  45. /* Name des temporären Files */
  46. char                 tmp_file[256];
  47. long                MiNT;
  48.  
  49. #ifdef _SHOW_PRT_
  50. char    *disp_status="\033Hp";
  51. char    *char_status="/-\\|";
  52. char    rot_status;
  53. #endif
  54.  
  55. /********************************************************************/
  56. /* Einige Routinen zum Druck */
  57.  
  58.  
  59. void    disp_wait( void )
  60. {
  61.     while(  old_vec!=0L  ||  Bcostat(0)==0  )
  62.     {
  63.         Fselect( 500, 0L, 0L, 0L );
  64. #ifdef _SHOW_PRT_
  65.         disp_status[2] = char_status[rot_status++];
  66.         rot_status &= 3;
  67.         Cconws( disp_status );
  68. #endif
  69.     }
  70. }
  71.  
  72.  
  73.     /* Gibt Puffer aus (SCHNELL!!) */
  74. void    flush_block( void )
  75. {
  76.     Psignal( SIGINT, SIG_DFL );
  77.     Psignal( SIGTERM, SIG_DFL );
  78.     if(  puffer_laenge>0  )
  79.     {
  80.         disp_wait();
  81.         memcpy( druck_puffer, puffer, puffer_laenge );
  82.         prn_byte( druck_puffer, puffer_laenge );
  83.     }
  84.     puffer_laenge = 0;
  85.     disp_wait();
  86. }
  87. /* 23.1.93 */
  88.  
  89.  
  90.  
  91.     /* Gibt an Spooler aus (SCHNELL!!) */
  92. long    print_block( long laenge, char *blk )
  93. {
  94.     if(  laenge+puffer_laenge>max_puffer_laenge  )
  95.     {
  96.         disp_wait();
  97.         if(  puffer_laenge>0  )
  98.         {
  99.             memcpy( druck_puffer, puffer, puffer_laenge );
  100.             prn_byte( druck_puffer, puffer_laenge );
  101.         }
  102.         puffer_laenge = 0L;
  103.     }
  104.  
  105.         /* Zu lang... */
  106.     if(  laenge>max_puffer_laenge  )
  107.     {
  108.         prn_byte( blk, laenge );
  109.         disp_wait();
  110.     }
  111.     else
  112.     {
  113.         memcpy( puffer+puffer_laenge, blk, laenge );
  114.         puffer_laenge += laenge;
  115.     }
  116.     return laenge;
  117. }
  118. /* 22.1.93 */
  119.  
  120.  
  121.  
  122. /* Versucht Drucker zu Öffnen und zu Verriegeln! */ 
  123. int    open_printer( void )
  124. {
  125.     int devh=5;
  126.  
  127.     puffer = Malloc( max_puffer_laenge );    /* Speicher holen */
  128.     druck_puffer = Malloc( max_puffer_laenge );
  129.     if(  druck_puffer<=0  ||  puffer<=0  )
  130.         return -1;
  131.  
  132.     if(  MiNT  )
  133.     {    /* Druckersemaphore bekommen! (Wird bei Beendigung automatisch frei) */
  134.         devh = (int)Psemaphore( 0, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );
  135.         if(  devh!=0  )
  136.             Psemaphore( 2, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );
  137.     }
  138.  
  139. #ifdef _SHOW_PRT_
  140.     disp_status[2] = '|';
  141.     Cconws( disp_status );
  142. #endif
  143.  
  144.     if(  MiNT  )
  145.     {
  146.         while(  (devh=(int)Fopen( "U:\\dev\\prn", O_WRONLY ))==EACCDN  )
  147.             Fselect( 100, 0L, 0L, 0L );
  148.         Psignal( SIGINT, (long)exstall );
  149.         Psignal( SIGTERM, (long)exstall );
  150.     }
  151.     return devh;
  152. }
  153. /* 6.2.93 */
  154.  
  155.  
  156.  
  157. int        get_tempfile( char *drucker_ext )
  158. {
  159.     char    *p;
  160.     long    lz;
  161.     int        th;
  162.  
  163.     if(  tmp_file[0]==0  )
  164.     {
  165.         /* In temporäre Datei drucken! */
  166.         if(  (p=getenv("TMPDIR"))!=0L  )
  167.         {
  168.             strcat( tmp_file, p );
  169.             if(  p[strlen(p-1)]!='\\'  )
  170.                 strcat( tmp_file, "\\" );
  171.         }
  172.         strcat( tmp_file, "print00." );
  173.         lz = strlen(tmp_file)-2;
  174.         strcat( tmp_file, drucker_ext );
  175.         while(  (th=(int)Fopen(tmp_file,O_RDWR))>0  )
  176.         {
  177.             Fclose( th );
  178.             if(  (++(tmp_file[lz]))=='9'  )
  179.             {
  180.                 ++(tmp_file[lz-1]);
  181.                 tmp_file[lz] = '0';
  182.             }
  183.         }
  184.         th = (int)Fcreate( tmp_file, 0 );
  185.     }
  186.     else
  187.         th = (int)Fopen( tmp_file, O_WRONLY|O_APPEND|O_CREAT );
  188. #ifdef _SHOW_PRT_
  189.     if(  th>=0  )
  190.         Cconws( disp_status );
  191. #endif
  192.     return th;
  193. }
  194. /* 6.2.93 */
  195.  
  196.  
  197.  
  198. /********************************************************************/
  199. /* Routinen für Optimierung */
  200.  
  201.  
  202. /* Ist diese Zeile Leerzeile? */
  203. int    ist_leerzeile( char *ptr, long offset )
  204. {
  205.     long    i;
  206.     for(  i=0;  i<offset;  i++  )
  207.         if(  *ptr++!=0  )
  208.             return FALSE;
  209.     return TRUE;
  210. }
  211. /* 16.1.93 */
  212.  
  213.  
  214.  
  215. /* Sind in den nächsten #next Zeilen Zeichen? */
  216. int    ist_next_leer( char *ptr, long offset, long next )
  217. {
  218.     while(  next>0  )
  219.     {
  220.         if(  *ptr!=0  )
  221.             return FALSE;
  222.         next--;
  223.         ptr += offset;
  224.     }
  225.     return TRUE;
  226. }
  227. /* 16.1.93 */
  228.  
  229.  
  230.  
  231. /********************************************************************/
  232. /* Hauptprogramm */
  233.  
  234.  
  235. int    main( int argc, const char *argv[] )
  236. {
  237.     long    i;
  238.     int        th, devh;
  239.     extern long    CookieJar( long cooks_name );
  240.  
  241.     if(  argc<6  )
  242.     {
  243.         Cconws( "Zuwenig Argumente!\xD\xA" );
  244.         Cconws( "Richtig: shared_mem_file weite hoehe hdpi vdpi (file)\xD\xA" );
  245.         return 0;
  246.     }
  247.  
  248.     MiNT = CookieJar( 0x4D694E54L /*'MiNT'*/ );
  249.     old_vec = 0L;
  250.  
  251.         /* Diese Routine mit Parameter versehen! */
  252.         /* Es wird mit Shared Memory gearbeitet */
  253.         /* Wenn der erste Buchstabe eine Zahl ist, */
  254.         /* dann wird diese als Adresse angenommen */
  255.     strcpy( shm_name, (char *)argv[1] );
  256.     if(  shm_name[0]>='0'  &&  shm_name[0]<='9'  )
  257.     {
  258.         memory = (char *)atol( shm_name );
  259.         shm_name[0] = 0;
  260.     }
  261.     else
  262.     {
  263.         shm = (int)Fopen( shm_name, O_RDONLY );
  264.         if(  shm<0  )
  265.             return -1;
  266.         memory = (char *)Fcntl( shm, 0L, SHMGETBLK );
  267.     }
  268.     if(  memory<=0  )
  269.         return 0;
  270.  
  271.     tmp_file[0] = 0;
  272.     if(  argv[6]>0L  )
  273.         strcpy( tmp_file, argv[6] );
  274.  
  275.     th = drucke( memory, atol(argv[2]), atol(argv[3]), atol(argv[4]), atol(argv[5]) );
  276.     if(  shm_name[0]>0  )
  277.     {
  278.         Fclose( shm );
  279.         Mfree( memory );    /* so kann der Speicher wieder freigegeben werden */
  280.         Fdelete( shm_name );
  281.         shm = 0;
  282.     }
  283.     Cconws( "\033H " );
  284.  
  285.     if(  th<=0    &&  argv[6]>(char*)0    ) /* || nach && umgewandelt 6.5.93 MH */
  286.     {    /* Hier bei Fehler oder Funktion gibt selber aus! */
  287.         if(  th<0  )
  288.             Fdelete( tmp_file );
  289.         return th;
  290.     }
  291.  
  292.     /* Nur Datei erzeugen? */
  293.     if(  argv[6]>0L  )
  294.         return Fclose( th );
  295.  
  296.         /* Ab hier wird es ernst */
  297.     if(  th<=0  )
  298.         return -1;
  299.     while(  (devh=open_printer())==-1  &&  max_puffer_laenge>128  )
  300.         max_puffer_laenge /= 2L;    /* Puffer halbieren */
  301.     if(  devh<0  )
  302.         return -1;
  303.  
  304.     Fseek( 0L, th, 0 );
  305.     i = max_puffer_laenge;
  306.     do
  307.     {
  308.         disp_wait();
  309.         i = Fread( th, i, druck_puffer );
  310.         if(  i>0  )
  311.             prn_byte( druck_puffer, i );
  312.     }
  313.     while(  i>0  );
  314.  
  315.     Fclose( th );
  316.     if(  tmp_file[0]>0  )
  317.         Fdelete( tmp_file );
  318.     flush_block();
  319.     Fclose( devh );
  320.     Cconws( "\033H " );
  321.     return 1;
  322. }
  323. /* 17.1.93 */
  324.