Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. #include "kolibri.h"
  2. #include "string.h"
  3.  
  4.  
  5. extern char KOL_PATH[256];
  6. extern char KOL_PARAM[256];
  7. extern char KOL_DIR[256];
  8.  
  9.  
  10. void kol_exit()
  11. {
  12. asm ("int $0x40"::"a"(-1));
  13. }
  14.  
  15.  
  16. void kol_sleep(unsigned d)
  17. {
  18. asm ("int $0x40"::"a"(5), "b"(d));
  19. }
  20.  
  21.  
  22. void kol_wnd_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c)
  23. {
  24. asm ("nop"::"a"(0), "b"(x*65536+w), "c"(y*65536+h), "d"(c));
  25. asm ("movl $0xffffff, %esi \n int $0x40");
  26. }
  27.  
  28.  
  29. void kol_wnd_move(unsigned x, unsigned y)
  30. {
  31. asm ("nop"::"a"(67), "b"(x), "c"(y));
  32. asm ("movl $-1, %edx \n movl $-1, %esi \n int $0x40");
  33. }
  34.  
  35.  
  36. void kol_event_mask(unsigned e)
  37. {
  38. asm ("int $0x40"::"a"(40), "b"(e));
  39. }
  40.  
  41.  
  42. unsigned kol_event_wait()
  43. {
  44. asm ("int $0x40"::"a"(10));
  45. }
  46.  
  47.  
  48. unsigned kol_event_wait_time(unsigned time)
  49. {
  50. asm ("int $0x40"::"a"(23), "b"(time));
  51. }
  52.  
  53.  
  54. unsigned kol_event_check()
  55. {
  56. asm ("int $0x40"::"a"(11));
  57. }
  58.  
  59.  
  60. void kol_paint_start()
  61. {
  62. asm ("int $0x40"::"a"(12), "b"(1));
  63. }
  64.  
  65.  
  66. void kol_paint_end()
  67. {
  68. asm ("int $0x40"::"a"(12), "b"(2));
  69. }
  70.  
  71.  
  72. void kol_paint_pixel(unsigned x, unsigned y, unsigned c)
  73. {
  74. asm ("int $0x40"::"a"(1), "b"(x), "c"(y), "d"(c));
  75. }
  76.  
  77.  
  78. void kol_paint_bar(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c)
  79. {
  80. asm ("int $0x40"::"a"(13), "b"(x*65536+w), "c"(y*65536+h), "d"(c));
  81. }
  82.  
  83.  
  84. void kol_paint_line(unsigned x1, unsigned y1, unsigned x2, unsigned y2, unsigned c)
  85. {
  86. asm ("int $0x40"::"a"(38), "b"(x1*65536+x2), "c"(y1*65536+y2), "d"(c));
  87. }
  88.  
  89.  
  90. void kol_paint_string(unsigned x, unsigned y,  unsigned c, char *s, unsigned l)
  91. {
  92. asm ("int $0x40"::"a"(4), "b"(x*65536+y), "c"(c), "d"(s), "S"(l));
  93. }
  94.  
  95.  
  96. void kol_paint_image(unsigned x, unsigned y, unsigned w, unsigned h, char *d)
  97. {
  98. asm ("int $0x40"::"a"(7), "c"(w*65536+h), "d"(x*65536+y), "b"(d));
  99. }
  100.  
  101.  
  102. void kol_paint_image_pal(unsigned x, unsigned y, unsigned w, unsigned h, char *d, unsigned *palette)
  103. {
  104. asm ("nop"::"c"(w*65536+h), "d"(x*65536+y), "b"(d));
  105. asm ("nop"::"a"(palette));
  106. asm ("movl %eax, %edi");
  107. asm ("xor %eax, %eax");
  108. asm ("movl %eax, %ebp");
  109. asm ("pushl $8");
  110. asm ("popl %esi");
  111. asm ("int $0x40"::"a"(65));
  112. }
  113.  
  114.  
  115. unsigned kol_key_get()
  116. {
  117.  unsigned __ret;
  118.  asm ("int $0x40":"=a"(__ret):"0"(2));
  119.  if(!(__ret & 0xFF)) return (__ret>>8)&0xFF; else return 0;
  120. }
  121.  
  122.  
  123. unsigned kol_key_control()
  124. {
  125. asm ("int $0x40"::"a"(66), "b"(3));
  126. }
  127.  
  128.  
  129. void kol_key_lang_set(unsigned lang)
  130. {
  131. asm ("int $0x40"::"a"(21), "b"(2), "c"(9), "d"(lang));
  132. }
  133.  
  134.  
  135. unsigned kol_key_lang_get()
  136. {
  137. asm ("int $0x40"::"a"(26), "b"(2), "c"(9));
  138. }
  139.  
  140.  
  141. void kol_key_mode_set(unsigned mode)
  142. {
  143. asm ("int $0x40"::"a"(66), "b"(1), "c"(mode));
  144. }
  145.  
  146.  
  147. unsigned kol_key_mode_get()
  148. {
  149. asm ("int $0x40"::"a"(66), "b"(2));
  150. }
  151.  
  152.  
  153. unsigned kol_btn_get()
  154. {
  155. unsigned __ret;
  156. asm ("int $0x40":"=a"(__ret):"0"(17));
  157.  if((__ret & 0xFF)==0) return (__ret>>8)&0xFF; else return -1;
  158. }
  159.  
  160.  
  161. void kol_btn_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned d, unsigned c)
  162. {
  163. asm ("nop"::"b"(x*65536+w), "c"(y*65536+h), "d"(d));
  164. asm ("nop"::"a"(c));
  165. asm ("movl %eax, %esi");
  166. asm ("int $0x40"::"a"(8));
  167. }
  168.  
  169.  
  170. void kol_btn_type(unsigned t)
  171. {
  172. asm ("int $0x40"::"a"(48), "b"(1), "c"(t));
  173. }
  174.  
  175.  
  176. void kol_wnd_caption(char *s)
  177. {
  178. asm ("int $0x40"::"a"(71), "b"(1), "c"(s));
  179. }
  180.  
  181.  
  182. unsigned kol_mouse_pos()
  183. {
  184. asm ("int $0x40"::"a"(37), "b"(0));
  185. }
  186.  
  187.  
  188. unsigned kol_mouse_posw()
  189. {
  190. asm ("int $0x40"::"a"(37), "b"(1));
  191. }
  192.  
  193.  
  194. unsigned kol_mouse_btn()
  195. {
  196. asm ("int $0x40"::"a"(37), "b"(2));
  197. }
  198.  
  199.  
  200. void kol_board_putc(char c)
  201. {
  202. asm ("int $0x40"::"a"(63), "b"(1), "c"(c));
  203. }
  204.  
  205.  
  206. void kol_board_puts(char *s)
  207. {
  208. unsigned i;
  209. i = 0;
  210. while (*(s+i))
  211.         {
  212.         asm ("int $0x40"::"a"(63), "b"(1), "c"(*(s+i)));
  213.         i++;
  214.         }
  215. }
  216.  
  217.  
  218. void kol_board_puti(int n)
  219. {
  220. char c;
  221. int i = 0;
  222. do
  223.         {
  224.         c = n % 10 + '0';
  225.         asm ("int $0x40"::"a"(63), "b"(1), "c"(c));
  226.         i++;
  227.         }
  228.         while ((n /= 10) > 0);
  229. }
  230.  
  231.  
  232. int kol_file_70(kol_struct70 *k)
  233. {
  234. asm ("int $0x40"::"a"(70), "b"(k));
  235. }
  236.  
  237.  
  238. kol_struct_import* kol_cofflib_load(char *name)
  239. {
  240. asm ("int $0x40"::"a"(68), "b"(19), "c"(name));
  241. }
  242.  
  243.  
  244. void* kol_cofflib_procload (kol_struct_import *imp, char *name)
  245. {
  246. int i;
  247. for (i=0;;i++)
  248.         if ( NULL == ((imp+i) -> name))
  249.                 break;
  250.         else
  251.                 if ( 0 == strcmp(name, (imp+i)->name) )
  252.                         return (imp+i)->data;
  253. return NULL;
  254. }
  255.  
  256.  
  257. unsigned kol_cofflib_procnum (kol_struct_import *imp)
  258. {
  259. unsigned i, n;
  260.  
  261. for (i=n=0;;i++)
  262.         if ( NULL == ((imp+i) -> name))
  263.                 break;
  264.         else
  265.                 n++;
  266.  
  267. return n;
  268. }
  269.  
  270.  
  271. void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n)
  272. {
  273. unsigned i;
  274. *name = 0;
  275.  
  276. for (i=0;;i++)
  277.         if ( NULL == ((imp+i) -> name))
  278.                 break;
  279.         else
  280.                 if ( i == n )
  281.                         {
  282.                         strcpy(name, ((imp+i)->name));
  283.                         break;
  284.                         }
  285.  
  286. }
  287.  
  288.  
  289. unsigned kol_system_cpufreq()
  290. {
  291. asm ("int $0x40"::"a"(18), "b"(5));
  292. }
  293.  
  294.  
  295. unsigned kol_system_mem()
  296. {
  297. asm ("int $0x40"::"a"(18), "b"(17));
  298. }
  299.  
  300.  
  301. unsigned kol_system_memfree()
  302. {
  303. asm ("int $0x40"::"a"(18), "b"(16));
  304. }
  305.  
  306.  
  307. unsigned kol_system_time_get()
  308. {
  309. asm ("int $0x40"::"a"(3));
  310. }
  311.  
  312.  
  313. unsigned kol_system_date_get()
  314. {
  315. asm ("int $0x40"::"a"(29));
  316. }
  317.  
  318.  
  319. unsigned kol_system_end(unsigned param)
  320. {
  321. asm ("int $0x40"::"a"(18), "b"(9), "c"(param));
  322. }
  323.  
  324.  
  325. void kol_path_file2dir(char *dir, char *fname)
  326. {
  327. unsigned i;
  328. strcpy (dir, fname);
  329. for ( i = strlen(dir);; --i)
  330.         if ( '/' == dir[i])
  331.                 {
  332.                 dir[i] = '\0';
  333.                 return;
  334.                 }
  335. }
  336.  
  337.  
  338. void kol_path_full(char *full, char *fname)
  339. {
  340. char temp[256];
  341.  
  342. switch (*fname)
  343. {
  344.  
  345. case '/':
  346.         strncpy(temp, fname+1, 2);
  347.         temp[2]=0;
  348.         if ( (!strcmp("rd", temp)) || (!strcmp("hd", temp)) || (!strcmp("cd", temp)) )
  349.                 strcpy (full, fname);
  350.         break;
  351.  
  352. case '.':
  353.         break;
  354.  
  355. default:
  356.         break;
  357.  
  358. };
  359.  
  360. }
  361.  
  362.  
  363.  
  364. void kol_screen_wait_rr()
  365. {
  366. asm ("int $0x40"::"a"(18), "b"(14));
  367. }
  368.  
  369.  
  370.  
  371. void kol_screen_get_size(unsigned *w, unsigned *h)
  372. {
  373. unsigned size;
  374. asm ("int $0x40":"=a"(size):"a"(14));
  375. *w = size / 65536;
  376. *h = size % 65536;
  377. }
  378.  
  379.  
  380.  
  381. unsigned kol_skin_height()
  382. {
  383. asm ("int $0x40"::"a"(48), "b"(4));
  384. }
  385.  
  386.  
  387. unsigned kol_thread_start(unsigned start, unsigned stack)
  388. {
  389. asm ("int $0x40"::"a"(51), "b"(1), "c"(start), "d"(stack));
  390. }
  391.  
  392.  
  393. unsigned kol_time_tick()
  394. {
  395. asm ("int $0x40"::"a"(26), "b"(9));
  396. }
  397.  
  398.  
  399. unsigned kol_sound_speaker(char data[])
  400. {
  401. asm ("movl %0, %%esi"::"a"(data));
  402. asm ("int $0x40"::"a"(55), "b"(55));
  403. }
  404.  
  405.  
  406. unsigned kol_process_info(unsigned slot, char buf1k[])
  407. {
  408. asm ("int $0x40"::"a"(9), "b"(buf1k), "c"(slot));
  409. }
  410.  
  411.  
  412. int kol_process_kill_pid(unsigned process)
  413. {
  414. asm ("int $0x40"::"a"(18), "b"(18), "c"(process));
  415. }
  416.