home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Mint / mntlib32.zoo / linea.c < prev    next >
C/C++ Source or Header  |  1993-02-13  |  4KB  |  210 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.                                         
  98.     __asm__ volatile                        
  99.     ("
  100.         movml    d2/a2/a6, sp@-;
  101.          movl    %0,a6;  
  102.         .word   0xA007;
  103.         movml    sp@+, d2/a2/a6"
  104.     :                           /* outputs */    
  105.     : "r"(P)                      /* inputs  */    
  106.     : "d0", "d1", "a0", "a1"          /* clobbered regs */    \
  107.     );                                
  108. }
  109.  
  110. void linea8()                             
  111. {                                    
  112.                                         
  113.     __asm__ volatile                        
  114.     ("
  115.         .word   0xA008" 
  116.     :                           /* outputs */    
  117.     :                           /* inputs  */    
  118.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  119.     );                                
  120. }
  121.  
  122. void linea9()                             
  123. {                                    
  124.                                         
  125.     __asm__ volatile                        
  126.     ("
  127.         .word   0xA009" 
  128.     :                           /* outputs */    
  129.     :                           /* inputs  */    
  130.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  131.     );                                
  132. }
  133.  
  134. void lineaa()                             
  135. {                                    
  136.                                         
  137.     __asm__ volatile                        
  138.     ("
  139.         .word   0xA00A" 
  140.     :                           /* outputs */    
  141.     :                           /* inputs  */    
  142.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  143.     );                                
  144. }
  145.  
  146. void lineab()                             
  147. {                                    
  148.                                         
  149.     __asm__ volatile                        
  150.     ("
  151.         .word   0xA00B" 
  152.     :                           /* outputs */    
  153.     :                           /* inputs  */    
  154.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  155.     );                                
  156. }
  157.  
  158. void lineac(void *P)                             
  159. {                                    
  160.                                         
  161.     __asm__ volatile                        
  162.     ("
  163.          movl    %0,a2;  
  164.         .word   0xA00C" 
  165.     :                           /* outputs */    
  166.     : "r"(P)                      /* inputs  */    
  167.     : "d0", "d1", "d2", "a0", "a1", "a2", "a6" /* clobbered regs */    
  168.     );                                
  169. }
  170.  
  171. void linead(int x, int y,  SFORM * sd, void *ss)
  172. {                                    
  173.                                         
  174.     __asm__ volatile                        
  175.     ("
  176.          movw    %0,d0;  
  177.          movw    %1,d1;  
  178.          movl    %2,a0;  
  179.          movl    %3,a2;  
  180.         .word   0xA00D" 
  181.     :                           /* outputs */    
  182.     : "r"((short)x), "r"((short)y), "r"(sd), "r"(ss)  /* inputs  */    
  183.     : "d0", "d1", "d2", "a0", "a1", "a2", "a6" /* clobbered regs */    
  184.     );                                
  185. }
  186.  
  187. void lineae()                             
  188. {                                    
  189.                                         
  190.     __asm__ volatile                        
  191.     ("
  192.         .word   0xA00E" 
  193.     :                           /* outputs */    
  194.     :                           /* inputs  */    
  195.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  196.     );                                
  197. }
  198.  
  199. void lineaf()                             
  200. {                                    
  201.                                         
  202.     __asm__ volatile                        
  203.     ("
  204.         .word   0xA00F" 
  205.     :                           /* outputs */    
  206.     :                           /* inputs  */    
  207.     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  208.     );                                
  209. }
  210.