home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Mint / mntlib25.zoo / linea.c < prev    next >
C/C++ Source or Header  |  1992-10-01  |  4KB  |  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.     __asm__ volatile                        
  39.     ("
  40.         .word   0xA002"
  41.     :                           /* outputs */    
  42.     :                           /* inputs  */    
  43.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  44.     );                                
  45. }
  46.  
  47. void linea3()                             
  48. {                                    
  49.                                         
  50.     __asm__ volatile                        
  51.     ("
  52.         .word   0xA003" 
  53.     :                           /* outputs */    
  54.     :                           /* inputs  */    
  55.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  56.     );                                
  57. }
  58.  
  59. void linea4()                             
  60. {                                    
  61.                                         
  62.     __asm__ volatile                        
  63.     ("
  64.         .word   0xA004" 
  65.     :                           /* outputs */    
  66.     :                           /* inputs  */    
  67.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  68.     );                                
  69. }
  70.  
  71. void linea5()                             
  72. {                                    
  73.                                         
  74.     __asm__ volatile                        
  75.     ("
  76.         .word   0xA005" 
  77.     :                           /* outputs */    
  78.     :                           /* inputs  */    
  79.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  80.     );                                
  81. }
  82.  
  83. void linea6()                             
  84. {                                    
  85.                                         
  86.     __asm__ volatile                        
  87.     ("
  88.         .word   0xA006" 
  89.     :                           /* outputs */    
  90.     :                           /* inputs  */    
  91.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  92.     );                                
  93. }
  94.  
  95. void linea7(BBPB *P)                             
  96. {                                    
  97.     __asm__ volatile                        
  98.     ("
  99.         movml    d2/a2/a6, sp@-;
  100.          movl    %0,a6;  
  101.         .word   0xA007;
  102.         movml    sp@+,d2/a2/a6"
  103.     :                           /* outputs */    
  104.     : "r"(P)                      /* inputs  */    
  105.     : "d0", "d1", "a0", "a1"           /* clobbered regs */
  106.     );                                
  107. }
  108.  
  109. void linea8()                             
  110. {                                    
  111.                                         
  112.     __asm__ volatile                        
  113.     ("
  114.         .word   0xA008" 
  115.     :                           /* outputs */    
  116.     :                           /* inputs  */    
  117.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  118.     );                                
  119. }
  120.  
  121. void linea9()                             
  122. {                                    
  123.                                         
  124.     __asm__ volatile                        
  125.     ("
  126.         .word   0xA009" 
  127.     :                           /* outputs */    
  128.     :                           /* inputs  */    
  129.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  130.     );                                
  131. }
  132.  
  133. void lineaa()                             
  134. {                                    
  135.                                         
  136.     __asm__ volatile                        
  137.     ("
  138.         .word   0xA00A" 
  139.     :                           /* outputs */    
  140.     :                           /* inputs  */    
  141.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  142.     );                                
  143. }
  144.  
  145. void lineab()                             
  146. {                                    
  147.                                         
  148.     __asm__ volatile                        
  149.     ("
  150.         .word   0xA00B" 
  151.     :                           /* outputs */    
  152.     :                           /* inputs  */    
  153.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  154.     );                                
  155. }
  156.  
  157. void lineac(void *P)                             
  158. {                                    
  159.                                         
  160.     __asm__ volatile                        
  161.     ("
  162.          movl    %0,a2;  
  163.         movl    a6,sp@-;
  164.         .word   0xA00C;
  165.         movl    sp@+,a6"
  166.     :                           /* outputs */    
  167.     : "g"(P)                       /* inputs  */    
  168.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  169.     );                                
  170. }
  171.  
  172. void linead(int x, int y,  SFORM * sd, void *ss)
  173. {                                    
  174.                                         
  175.     __asm__ volatile                        
  176.     ("
  177.          movw    %0,d0;  
  178.          movw    %1,d1;  
  179.          movl    %2,a0;  
  180.          movl    %3,a2;  
  181.         movl    a6,sp@-;
  182.         .word   0xA00D;
  183.         movl    sp@+,a6"
  184.     :                           /* outputs */    
  185.     : "g"((short)x), "g"((short)y), "g"(sd), "g"(ss)  /* inputs  */    
  186.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* 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.