home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / mint / mntlib18 / linea.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-03  |  4.2 KB  |  213 lines
  1. /*
  2.  * function form of linea bindings
  3.  *    ++jrb
  4.  */
  5.  
  6. #define __NO_INLINE__
  7. #include <linea.h>
  8.  
  9. void linea0()                             
  10. {                                    
  11.                                         
  12.     __asm__ volatile                        
  13.     ("
  14.         .word   0xA000; 
  15.         movl    a0,%0;    
  16.         movl    a1,%1;    
  17.         movl    a2,%2"                        
  18.     : "=g"(__aline), "=g"(__fonts), "=g"(__funcs)     /* outputs */    
  19.     :                           /* inputs  */    
  20.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  21.     );                                
  22. }
  23.  
  24. void linea1()                             
  25. {                                    
  26.                                         
  27.     __asm__ volatile                        
  28.     ("
  29.         .word   0xA001" 
  30.     :                           /* outputs */    
  31.     :                           /* inputs  */    
  32.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  33.     );                                
  34. }
  35.  
  36. int linea2()                             
  37. {                                    
  38.     short retvalue;                            
  39.     __asm__ volatile                        
  40.     ("
  41.         .word   0xA002;  
  42.          movew    d0,%0"   
  43.     : "=g"(retvalue)                  /* outputs */    
  44.     :                           /* inputs  */    
  45.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  46.     );                                
  47.     return (int)retvalue;                            
  48. }
  49.  
  50. void linea3()                             
  51. {                                    
  52.                                         
  53.     __asm__ volatile                        
  54.     ("
  55.         .word   0xA003" 
  56.     :                           /* outputs */    
  57.     :                           /* inputs  */    
  58.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  59.     );                                
  60. }
  61.  
  62. void linea4()                             
  63. {                                    
  64.                                         
  65.     __asm__ volatile                        
  66.     ("
  67.         .word   0xA004" 
  68.     :                           /* outputs */    
  69.     :                           /* inputs  */    
  70.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  71.     );                                
  72. }
  73.  
  74. void linea5()                             
  75. {                                    
  76.                                         
  77.     __asm__ volatile                        
  78.     ("
  79.         .word   0xA005" 
  80.     :                           /* outputs */    
  81.     :                           /* inputs  */    
  82.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  83.     );                                
  84. }
  85.  
  86. void linea6()                             
  87. {                                    
  88.                                         
  89.     __asm__ volatile                        
  90.     ("
  91.         .word   0xA006" 
  92.     :                           /* outputs */    
  93.     :                           /* inputs  */    
  94.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  95.     );                                
  96. }
  97.  
  98. void linea7(BBPB *P)                             
  99. {                                    
  100.                                         
  101.     __asm__ volatile                        
  102.     ("
  103.         movml    d2/a2/a6, sp@-;
  104.          movl    %0,a6;  
  105.         .word   0xA007;
  106.         movml    sp@+, d2/a2/a6"
  107.     :                           /* outputs */    
  108.     : "r"(P)                      /* inputs  */    
  109.     : "d0", "d1", "a0", "a1"          /* clobbered regs */    \
  110.     );                                
  111. }
  112.  
  113. void linea8()                             
  114. {                                    
  115.                                         
  116.     __asm__ volatile                        
  117.     ("
  118.         .word   0xA008" 
  119.     :                           /* outputs */    
  120.     :                           /* inputs  */    
  121.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  122.     );                                
  123. }
  124.  
  125. void linea9()                             
  126. {                                    
  127.                                         
  128.     __asm__ volatile                        
  129.     ("
  130.         .word   0xA009" 
  131.     :                           /* outputs */    
  132.     :                           /* inputs  */    
  133.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  134.     );                                
  135. }
  136.  
  137. void lineaa()                             
  138. {                                    
  139.                                         
  140.     __asm__ volatile                        
  141.     ("
  142.         .word   0xA00A" 
  143.     :                           /* outputs */    
  144.     :                           /* inputs  */    
  145.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  146.     );                                
  147. }
  148.  
  149. void lineab()                             
  150. {                                    
  151.                                         
  152.     __asm__ volatile                        
  153.     ("
  154.         .word   0xA00B" 
  155.     :                           /* outputs */    
  156.     :                           /* inputs  */    
  157.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  158.     );                                
  159. }
  160.  
  161. void lineac(void *P)                             
  162. {                                    
  163.                                         
  164.     __asm__ volatile                        
  165.     ("
  166.          movl    %0,a2;  
  167.         .word   0xA00C" 
  168.     :                           /* outputs */    
  169.     : "r"(P)                      /* inputs  */    
  170.     : "d0", "d1", "d2", "a0", "a1", "a2", "a6" /* clobbered regs */    
  171.     );                                
  172. }
  173.  
  174. void __linead(int x, int y,  SFORM * sd, void *ss)
  175. {                                    
  176.                                         
  177.     __asm__ volatile                        
  178.     ("
  179.          movw    %0,d0;  
  180.          movw    %1,d1;  
  181.          movl    %2,a0;  
  182.          movl    %3,a2;  
  183.         .word   0xA00D" 
  184.     :                           /* outputs */    
  185.     : "r"((short)x), "r"((short)y), "r"(sd), "r"(ss)  /* inputs  */    
  186.     : "d0", "d1", "d2", "a0", "a1", "a2", "a6" /* clobbered regs */    
  187.     );                                
  188. }
  189.  
  190. void lineae()                             
  191. {                                    
  192.                                         
  193.     __asm__ volatile                        
  194.     ("
  195.         .word   0xA00E" 
  196.     :                           /* outputs */    
  197.     :                           /* inputs  */    
  198.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  199.     );                                
  200. }
  201.  
  202. void lineaf()                             
  203. {                                    
  204.                                         
  205.     __asm__ volatile                        
  206.     ("
  207.         .word   0xA00F" 
  208.     :                           /* outputs */    
  209.     :                           /* inputs  */    
  210.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  211.     );                                
  212. }
  213.