Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. #include "common.h"
  3.  
  4. #pragma pack(push, 1)
  5. typedef struct
  6. {
  7.   char sec;
  8.   char min;
  9.   char hour;
  10.   char rsv;
  11. }detime_t;
  12. #pragma pack(pop)
  13.  
  14. #pragma pack(push, 1)
  15. typedef struct
  16. {
  17.   char  day;
  18.   char  month;
  19.   short year;
  20. }dedate_t;
  21. #pragma pack(pop)
  22.  
  23.  
  24. #pragma pack(push, 1)
  25. typedef struct
  26. {   unsigned    attr;
  27.     unsigned    flags;
  28.     union
  29.     {
  30.       detime_t  ctime;
  31.       unsigned  cr_time;
  32.     };
  33.     union
  34.     {
  35.       dedate_t  cdate;
  36.       unsigned  cr_date;
  37.     };
  38.     union
  39.     {
  40.       detime_t  atime;
  41.       unsigned  acc_time;
  42.     };
  43.     union
  44.     {
  45.       dedate_t  adate;
  46.       unsigned  acc_date;
  47.     };
  48.     union
  49.     {
  50.       detime_t  mtime;
  51.       unsigned  mod_time;
  52.     };
  53.     union
  54.     {
  55.       dedate_t  mdate;
  56.       unsigned  mod_date;
  57.     };
  58.     unsigned    size;
  59.     unsigned    size_high;
  60. } FILEINFO;
  61. #pragma pack(pop)
  62.  
  63. typedef struct
  64. {
  65.   char *path;
  66.   int  offset;
  67. } dbgfile_t;
  68.  
  69. static dbgfile_t dbgfile;
  70.  
  71. static void __SysMsgBoardStr(char *text)
  72. {
  73.   asm __volatile__
  74.   (
  75.     "call *__imp__SysMsgBoardStr"
  76.     :
  77.     :"S" (text)
  78.   );
  79. };
  80.  
  81. int get_fileinfo(const char *path,FILEINFO *info)
  82. {
  83.    int retval;
  84.  
  85.    asm __volatile__
  86.       (
  87.        "pushl $0 \n\t"
  88.        "pushl $0 \n\t"
  89.        "movl %%eax, 1(%%esp) \n\t"
  90.        "pushl %%ebx \n\t"
  91.        "pushl $0 \n\t"
  92.        "pushl $0 \n\t"
  93.        "pushl $0 \n\t"
  94.        "pushl $5 \n\t"
  95.        "movl %%esp, %%ebx \n\t"
  96.        "movl $70, %%eax \n\t"
  97.        "int $0x40 \n\t"
  98.        "addl $28, %%esp \n\t"
  99.        :"=eax" (retval)
  100.        :"a" (path), "b" (info)
  101.        );
  102.    return retval;
  103. };
  104.  
  105. int create_file(const char *path)
  106. {
  107.   int retval;
  108.   asm __volatile__
  109.     (
  110.       "pushl %%ebx \n\t"
  111.       "pushl $0 \n\t"
  112.       "pushl $0 \n\t"
  113.       "movl %%eax, 1(%%esp) \n\t"
  114.       "pushl $0 \n\t"
  115.       "pushl $0 \n\t"
  116.       "pushl $0 \n\t"
  117.       "pushl $0 \n\t"
  118.       "pushl $2 \n\t"
  119.       "movl %%esp, %%ebx \n\t"
  120.       "movl $70, %%eax \n\t"
  121.       "int $0x40 \n\t"
  122.       "addl $28, %%esp \n\t"
  123.       "popl %%ebx"
  124.       :"=eax" (retval)
  125.       :"a" (path)
  126.       );
  127.   return retval;
  128. };
  129.  
  130. int set_file_size(const char *path, unsigned size)
  131. {
  132.   int retval;
  133.   asm __volatile__(
  134.       "pushl $0 \n\t"
  135.       "pushl $0 \n\t"
  136.       "movl %%eax, 1(%%esp) \n\t"
  137.       "pushl $0 \n\t"
  138.       "pushl $0 \n\t"
  139.       "pushl $0 \n\t"
  140.       "pushl %%ebx \n\t"
  141.       "push $4 \n\t"
  142.       "movl %%esp, %%ebx \n\t"
  143.       "movl $70, %%eax \n\t"
  144.       "int $0x40 \n\t"
  145.       "addl $28, %%esp \n\t"
  146.       :"=eax" (retval)
  147.       :"a" (path), "b" (size)
  148.       );
  149.   return retval;
  150. };
  151.  
  152. int write_file(const char *path,const void *buff,
  153.                unsigned offset,unsigned count,unsigned *writes)
  154. {
  155.   int retval;
  156.   asm __volatile__
  157.      (
  158.       "pushl $0 \n\t"
  159.       "pushl $0 \n\t"
  160.       "movl %%eax, 1(%%esp) \n\t"
  161.       "pushl %%ebx \n\t"
  162.       "pushl %%edx \n\t"
  163.       "pushl $0 \n\t"
  164.       "pushl %%ecx \n\t"
  165.       "pushl $3 \n\t"
  166.       "movl %%esp, %%ebx \n\t"
  167.       "mov $70, %%eax \n\t"
  168.       "int $0x40 \n\t"
  169.       "testl %%esi, %%esi \n\t"
  170.       "jz 1f \n\t"
  171.       "movl %%ebx, (%%esi) \n\t"
  172. "1:"
  173.       "addl $28, %%esp \n\t"
  174.       :"=eax" (retval)
  175.       :"a"(path),"b"(buff),"c"(offset),"d"(count),"S"(writes)
  176.      );
  177.   return retval;
  178. };
  179.  
  180. char * _putc(char *s, int c)
  181. {
  182.   int i=0;
  183.  
  184.   switch(c)
  185.   {
  186.       case '\n':
  187.         *s++ = '\r';
  188.         *s++ = '\n';
  189.  
  190.       case '\r':
  191.         break;
  192.  
  193.       case '\t':
  194.         do
  195.         {
  196.           *s++ = ' ';
  197.         }
  198.         while (i % 8 != 0);
  199.         break;
  200.       default:
  201.         *s++ = c;
  202.   }
  203.   return s;
  204. }
  205.  
  206. char *print_string(char *buff, char* s)
  207. {
  208.   int i=0;
  209.   char c;
  210.  
  211.   while (c=*s++)
  212.   {
  213.     switch(c)
  214.     {
  215.       case '\r':
  216.         break;
  217.  
  218.       case '\n':
  219.         *buff++ = '\r';
  220.         *buff++ = '\n';
  221.         i=0;
  222.  
  223.       case '\t':
  224.         do
  225.         {
  226.           *buff++ = ' ';
  227.           i++;
  228.         }
  229.         while (i % 8 != 0);
  230.         break;
  231.  
  232.       default:
  233.         *buff++ = c;
  234.         i++;
  235.     };
  236.   }
  237.   return buff;
  238. }
  239.  
  240. char *print_dec(char *buff,int val)
  241. {
  242.     char dbuff[16];
  243.     int i = 14;
  244.  
  245.     dbuff[15] = '\0';
  246.     do
  247.     {
  248.       dbuff[i] = (val % 10) + '0';
  249.       val = val / 10;
  250.       i--;
  251.     } while(val);
  252.  
  253.     return print_string(buff, &dbuff[i+1]);
  254. }
  255.  
  256. const char  hexchars[] = "0123456789ABCDEF";
  257.  
  258. char *print_hex(char *buff,u32 val)
  259. {
  260.   int i;
  261.   for (i=sizeof(u32)*8-4; i >= 0; i -= 4)
  262.     buff = _putc(buff,hexchars[((u32)val >> i) & 0xF]);
  263.   return buff;
  264. }
  265.  
  266. #define va_start(v,l) __builtin_va_start(v,l)
  267. #define va_end(v)       __builtin_va_end(v)
  268. #define va_arg(v,l)     __builtin_va_arg(v,l)
  269. #if !defined(__STRICT_ANSI__) || __STDC_VERSION__ + 0 >= 199900L
  270. #define va_copy(d,s)    __builtin_va_copy(d,s)
  271. #endif
  272. #define __va_copy(d,s)  __builtin_va_copy(d,s)
  273.  
  274. typedef __builtin_va_list __gnuc_va_list;
  275. typedef __gnuc_va_list va_list;
  276.  
  277. #define arg(x) va_arg (ap, u32)
  278.  
  279. char txtbuf[128];
  280.  
  281. int printf(const char* format, ...)
  282. {
  283.     u32 ret = 1;
  284.     u32 i = 0;
  285.     char *sbuf = txtbuf;
  286.  
  287.     va_list ap;
  288.  
  289.     va_start (ap, format);
  290.  
  291.     if (format == 0)
  292.       return 0;
  293.  
  294.     while (*format)
  295.     {
  296.       switch (*(format))
  297.       {
  298.         case '%':
  299. next_fmt:
  300.           switch (*(++format))
  301.           {
  302.             case 'l': case '-':
  303.             case '0': case '1': case '2': case '3': case '4':
  304.             case '5': case '6': case '7': case '8': case '9':
  305.             goto next_fmt;
  306.  
  307.             case 'c':
  308.               sbuf = _putc (sbuf,arg (i));
  309.               break;
  310.             case 'd':
  311.               sbuf = print_dec (sbuf,arg (i));
  312.               break;
  313.             case 'p':
  314.             case 'x':
  315.               sbuf = print_hex (sbuf,(u32) arg (i));
  316.               break;
  317.             case 's':
  318.               sbuf = print_string (sbuf,(char*) arg (i));
  319.               break;
  320.             default:
  321.               sbuf = print_string (sbuf,"?");
  322.               break;
  323.           }
  324.           i++;
  325.           break;
  326.  
  327.         default:
  328.           sbuf = _putc (sbuf,*format);
  329.           break;
  330.       }
  331.       format++;
  332.     }
  333.  
  334.     va_end (ap);
  335.     *sbuf=0;
  336.     SysMsgBoardStr(txtbuf);
  337.     return ret;
  338. }
  339.  
  340. int dbg_open(char *path)
  341. {
  342.   FILEINFO info;
  343.  
  344.   dbgfile.offset = 0;
  345.  
  346.   if(get_fileinfo(path,&info))
  347.   {
  348.     if(!create_file(path))
  349.     {
  350.       dbgfile.path = path;
  351.       return TRUE;
  352.     }
  353.     else
  354.       return FALSE;
  355.   };
  356.   set_file_size(path, 0);
  357.   dbgfile.path   = path;
  358.   dbgfile.offset = 0;
  359.   return TRUE;
  360. };
  361.  
  362. int vsnprintf(char *s, size_t n, const char *format, va_list arg);
  363.  
  364. int dbgprintf(const char* format, ...)
  365. {
  366.     unsigned writes;
  367.  
  368.     int len=0;
  369. //    char *sbuf = txtbuf;
  370.  
  371.     va_list ap;
  372.  
  373.     va_start(ap, format);
  374.     if (format)
  375.       len = vsnprintf(txtbuf, 128, format, ap);
  376.     va_end(ap);
  377.  
  378.     SysMsgBoardStr(txtbuf);
  379.  
  380.     if(dbgfile.path)
  381.     {
  382.       write_file(dbgfile.path,txtbuf,dbgfile.offset,len,&writes);
  383.       dbgfile.offset+=writes;
  384.     };
  385.     return len;
  386. }
  387.  
  388. int xf86DrvMsg(int skip, int code, const char* format, ...)
  389. {
  390.     unsigned writes;
  391.     va_list ap;
  392.  
  393.     int len=0;
  394.  
  395.     va_start(ap, format);
  396.     if (format)
  397.       len = vsnprintf(txtbuf, 128, format, ap);
  398.     va_end(ap);
  399.  
  400.     SysMsgBoardStr(txtbuf);
  401.  
  402.     if(dbgfile.path)
  403.     {
  404.       write_file(dbgfile.path,txtbuf,dbgfile.offset,len,&writes);
  405.       dbgfile.offset+=writes;
  406.     };
  407.     return len;
  408. }
  409.  
  410. int snprintf(char *s, size_t n, const char *format, ...)
  411. {
  412.         va_list ap;
  413.         int retval;
  414.  
  415.         va_start(ap, format);
  416.         retval = vsnprintf(s, n, format, ap);
  417.         va_end(ap);
  418.  
  419.         return retval;
  420. }
  421. /*
  422. int snprintf(char *buf,int count, const char* format, ...)
  423. {
  424.     int len;
  425.  
  426.   //  u32 ret = 1;
  427.     u32 i = 0;
  428.     char *sbuf = buf;
  429.  
  430.     va_list ap;
  431.  
  432.     va_start (ap, format);
  433.  
  434.     if (format == 0)
  435.       return 0;
  436.  
  437.     while (*format)
  438.     {
  439.       switch (*(format))
  440.       {
  441.         case '%':
  442. next_fmt:
  443.           switch (*(++format))
  444.           {
  445.             case 'l': case '-':
  446.             case '0': case '1': case '2': case '3': case '4':
  447.             case '5': case '6': case '7': case '8': case '9':
  448.             goto next_fmt;
  449.  
  450.             case 'c':
  451.               sbuf = _putc (sbuf,arg (i));
  452.               break;
  453.             case 'd':
  454.               sbuf = print_dec (sbuf,arg (i));
  455.               break;
  456.             case 'p':
  457.             case 'x':
  458.               sbuf = print_hex (sbuf,(u32) arg (i));
  459.               break;
  460.             case 's':
  461.               sbuf = print_string (sbuf,(char*) arg (i));
  462.               break;
  463.             default:
  464.               sbuf = print_string (sbuf,"?");
  465.               break;
  466.           }
  467.           i++;
  468.           break;
  469.  
  470.         default:
  471.           sbuf = _putc (sbuf,*format);
  472.           break;
  473.       }
  474.       format++;
  475.     }
  476.  
  477.     va_end (ap);
  478.     *sbuf=0;
  479.     len = sbuf-txtbuf;
  480.  
  481.     return len;
  482. }
  483. */
  484.  
  485. char *
  486. RhdAppendString(char *s1, const char *s2)
  487. {
  488.  
  489.   if (!s2)
  490.     return s1;
  491.   else
  492.     if (!s1)
  493.       return strdup(s2);
  494.     else
  495.     {
  496.       int len = strlen(s1) + strlen(s2) + 1;
  497.       char *result  = (char *)kmalloc(len);
  498.  
  499.       if (!result) return s1;
  500.  
  501.       strcpy(result,s1);
  502.       strcat(result,s2);
  503.       kfree(s1);
  504.       return result;
  505.     }
  506.  
  507.   return 0;
  508. }
  509.  
  510.  
  511.