Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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