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 [DWORD PTR __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.        "push 0 \n\t"
  88.        "push 0 \n\t"
  89.        "mov [esp+1], eax \n\t"
  90.        "push ebx \n\t"
  91.        "push 0 \n\t"
  92.        "push 0 \n\t"
  93.        "push 0 \n\t"
  94.        "push 5 \n\t"
  95.        "mov ebx, esp \n\t"
  96.        "mov eax, 70 \n\t"
  97.        "int 0x40 \n\t"
  98.        "add esp, 28 \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.       "push 0 \n\t"
  110.       "push 0 \n\t"
  111.       "mov [esp+1], eax \n\t"
  112.       "push 0 \n\t"
  113.       "push 0 \n\t"
  114.       "push 0 \n\t"
  115.       "push 0 \n\t"
  116.       "push 2 \n\t"
  117.       "mov ebx, esp \n\t"
  118.       "mov eax, 70 \n\t"
  119.       "int 0x40 \n\t"
  120.       "add esp, 28"
  121.       :"=eax" (retval)
  122.       :"a" (path)
  123.       );
  124.   return retval;
  125. };
  126.  
  127. int set_file_size(const char *path, unsigned size)
  128. {
  129.   int retval;
  130.   asm __volatile__(
  131.       "push 0 \n\t"
  132.       "push 0 \n\t"
  133.       "mov [esp+1], eax \n\t"
  134.       "push 0 \n\t"
  135.       "push 0 \n\t"
  136.       "push 0 \n\t"
  137.       "push ebx \n\t"
  138.       "push 4 \n\t"
  139.       "mov ebx, esp \n\t"
  140.       "mov eax, 70 \n\t"
  141.       "int 0x40 \n\t"
  142.       "add esp, 28"
  143.       :"=eax" (retval)
  144.       :"a" (path), "b" (size)
  145.       );
  146.   return retval;
  147. };
  148.  
  149. int write_file(const char *path,const void *buff,
  150.                unsigned offset,unsigned count,unsigned *writes)
  151. {
  152.   int retval;
  153.   asm __volatile__
  154.      ("push ebx \n\t"
  155.       "push 0 \n\t"
  156.       "push 0 \n\t"
  157.       "mov [esp+1], eax \n\t"
  158.       "push ebx \n\t"
  159.       "push edx \n\t"
  160.       "push 0 \n\t"
  161.       "push ecx \n\t"
  162.       "push 3 \n\t"
  163.       "mov ebx, esp \n\t"
  164.       "mov eax, 70 \n\t"
  165.       "int 0x40 \n\t"
  166.       "test esi, esi \n\t"
  167.       "jz 1f \n\t"
  168.       "mov [esi], ebx \n\t"
  169. "1:"
  170.       "add esp, 28 \n\t"
  171.       "pop ebx"
  172.       :"=eax" (retval)
  173.       :"a"(path),"b"(buff),"c"(offset),"d"(count),"S"(writes)
  174.      );
  175.   return retval;
  176. };
  177.  
  178. char * _putc(char *s, int c)
  179. {
  180.   int i=0;
  181.  
  182.   switch(c)
  183.   {
  184.       case '\n':
  185.         *s++ = '\r';
  186.         *s++ = '\n';
  187.  
  188.       case '\r':
  189.         break;
  190.  
  191.       case '\t':
  192.         do
  193.         {
  194.           *s++ = ' ';
  195.         }
  196.         while (i % 8 != 0);
  197.         break;
  198.       default:
  199.         *s++ = c;
  200.   }
  201.   return s;
  202. }
  203.  
  204. char *print_string(char *buff, char* s)
  205. {
  206.   int i=0;
  207.   char c;
  208.  
  209.   while (c=*s++)
  210.   {
  211.     switch(c)
  212.     {
  213.       case '\r':
  214.         break;
  215.  
  216.       case '\n':
  217.         *buff++ = '\r';
  218.         *buff++ = '\n';
  219.         i=0;
  220.  
  221.       case '\t':
  222.         do
  223.         {
  224.           *buff++ = ' ';
  225.           i++;
  226.         }
  227.         while (i % 8 != 0);
  228.         break;
  229.  
  230.       default:
  231.         *buff++ = c;
  232.         i++;
  233.     };
  234.   }
  235.   return buff;
  236. }
  237.  
  238. char *print_dec(char *buff,int val)
  239. {
  240.     char dbuff[16];
  241.     int i = 14;
  242.  
  243.     dbuff[15] = '\0';
  244.     do
  245.     {
  246.       dbuff[i] = (val % 10) + '0';
  247.       val = val / 10;
  248.       i--;
  249.     } while(val);
  250.  
  251.     return print_string(buff, &dbuff[i+1]);
  252. }
  253.  
  254. const char  hexchars[] = "0123456789ABCDEF";
  255.  
  256. char *print_hex(char *buff, u32_t val)
  257. {
  258.   int i;
  259.   for (i=sizeof(u32_t)*8-4; i >= 0; i -= 4)
  260.     buff = _putc(buff,hexchars[((u32_t)val >> i) & 0xF]);
  261.   return buff;
  262. }
  263.  
  264. #define va_start(v,l) __builtin_va_start(v,l)
  265. #define va_end(v)     __builtin_va_end(v)
  266. #define va_arg(v,l)   __builtin_va_arg(v,l)
  267. #if !defined(__STRICT_ANSI__) || __STDC_VERSION__ + 0 >= 199900L
  268. #define va_copy(d,s)    __builtin_va_copy(d,s)
  269. #endif
  270. #define __va_copy(d,s)  __builtin_va_copy(d,s)
  271.  
  272. typedef __builtin_va_list __gnuc_va_list;
  273. typedef __gnuc_va_list va_list;
  274.  
  275. #define arg(x) va_arg (ap, u32_t)
  276.  
  277. char txtbuf[128];
  278.  
  279. int printf(const char* format, ...)
  280. {
  281.     u32_t ret = 1;
  282.     u32_t i = 0;
  283.     char *sbuf = txtbuf;
  284.  
  285.     va_list ap;
  286.  
  287.     va_start (ap, format);
  288.  
  289.     if (format == 0)
  290.       return 0;
  291.  
  292.     while (*format)
  293.     {
  294.       switch (*(format))
  295.       {
  296.         case '%':
  297. next_fmt:
  298.           switch (*(++format))
  299.           {
  300.             case 'l': case '-':
  301.             case '0': case '1': case '2': case '3': case '4':
  302.             case '5': case '6': case '7': case '8': case '9':
  303.             goto next_fmt;
  304.  
  305.             case 'c':
  306.               sbuf = _putc (sbuf,arg (i));
  307.               break;
  308.             case 'd':
  309.               sbuf = print_dec (sbuf,arg (i));
  310.               break;
  311.             case 'p':
  312.             case 'x':
  313.               sbuf = print_hex (sbuf,(u32_t) arg (i));
  314.               break;
  315.             case 's':
  316.               sbuf = print_string (sbuf,(char*) arg (i));
  317.               break;
  318.             default:
  319.               sbuf = print_string (sbuf,"?");
  320.               break;
  321.           }
  322.           i++;
  323.           break;
  324.  
  325.         default:
  326.           sbuf = _putc (sbuf,*format);
  327.           break;
  328.       }
  329.       format++;
  330.     }
  331.  
  332.     va_end (ap);
  333.     *sbuf=0;
  334.     _SysMsgBoardStr(txtbuf);
  335.     return ret;
  336. }
  337.  
  338. int dbg_open(char *path)
  339. {
  340.   FILEINFO info;
  341.  
  342.   dbgfile.offset = 0;
  343.  
  344.   if(get_fileinfo(path,&info))
  345.   {
  346.     if(!create_file(path))
  347.     {
  348.       dbgfile.path = path;
  349.       return TRUE;
  350.     }
  351.     else
  352.       return FALSE;
  353.   };
  354.   set_file_size(path, 0);
  355.   dbgfile.path   = path;
  356.   dbgfile.offset = 0;
  357.   return TRUE;
  358. };
  359.  
  360. int vsnprintf(char *s, size_t n, const char *format, va_list arg);
  361.  
  362. int dbgprintf(const char* format, ...)
  363. {
  364.     unsigned writes;
  365.  
  366.     int len=0;
  367. //    char *sbuf = txtbuf;
  368.  
  369.     va_list ap;
  370.  
  371.     va_start(ap, format);
  372.     if (format)
  373.       len = vsnprintf(txtbuf, 128, format, ap);
  374.     va_end(ap);
  375.  
  376.     _SysMsgBoardStr(txtbuf);
  377.  
  378.     if(dbgfile.path)
  379.     {
  380.       write_file(dbgfile.path,txtbuf,dbgfile.offset,len,&writes);
  381.       dbgfile.offset+=writes;
  382.     };
  383.     return len;
  384. }
  385.  
  386. int snprintf(char *s, size_t n, const char *format, ...)
  387. {
  388.         va_list ap;
  389.         int retval;
  390.  
  391.         va_start(ap, format);
  392.         retval = vsnprintf(s, n, format, ap);
  393.         va_end(ap);
  394.  
  395.         return retval;
  396. }
  397. /*
  398. int snprintf(char *buf,int count, const char* format, ...)
  399. {
  400.     int len;
  401.  
  402.   //  u32 ret = 1;
  403.     u32 i = 0;
  404.     char *sbuf = buf;
  405.  
  406.     va_list ap;
  407.  
  408.     va_start (ap, format);
  409.  
  410.     if (format == 0)
  411.       return 0;
  412.  
  413.     while (*format)
  414.     {
  415.       switch (*(format))
  416.       {
  417.         case '%':
  418. next_fmt:
  419.           switch (*(++format))
  420.           {
  421.             case 'l': case '-':
  422.             case '0': case '1': case '2': case '3': case '4':
  423.             case '5': case '6': case '7': case '8': case '9':
  424.             goto next_fmt;
  425.  
  426.             case 'c':
  427.               sbuf = _putc (sbuf,arg (i));
  428.               break;
  429.             case 'd':
  430.               sbuf = print_dec (sbuf,arg (i));
  431.               break;
  432.             case 'p':
  433.             case 'x':
  434.               sbuf = print_hex (sbuf,(u32) arg (i));
  435.               break;
  436.             case 's':
  437.               sbuf = print_string (sbuf,(char*) arg (i));
  438.               break;
  439.             default:
  440.               sbuf = print_string (sbuf,"?");
  441.               break;
  442.           }
  443.           i++;
  444.           break;
  445.  
  446.         default:
  447.           sbuf = _putc (sbuf,*format);
  448.           break;
  449.       }
  450.       format++;
  451.     }
  452.  
  453.     va_end (ap);
  454.     *sbuf=0;
  455.     len = sbuf-txtbuf;
  456.  
  457.     return len;
  458. }
  459. */
  460.  
  461. char *
  462. RhdAppendString(char *s1, const char *s2)
  463. {
  464.  
  465.   if (!s2)
  466.     return s1;
  467.   else
  468.     if (!s1)
  469.       return strdup(s2);
  470.     else
  471.     {
  472.       int len = strlen(s1) + strlen(s2) + 1;
  473.       char *result  = (char *)malloc(len);
  474.  
  475.       if (!result) return s1;
  476.  
  477.       strcpy(result,s1);
  478.       strcat(result,s2);
  479.       free(s1);
  480.       return result;
  481.     }
  482.  
  483.   return 0;
  484. }
  485.  
  486.  
  487.