home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 2002 December (Special) / DOSV2002_12.iso / utility / tcl230ja95.lzh / source.lzh / dll / utl.c < prev   
Encoding:
C/C++ Source or Header  |  2000-01-03  |  6.2 KB  |  325 lines
  1. /*-------------------------------------------
  2.   utl.c
  3.   misc functions
  4.   KAZUBON 1997-1999
  5. ---------------------------------------------*/
  6.  
  7. #include <windows.h>
  8.  
  9. void WriteDebug(LPSTR s);
  10.  
  11. extern HANDLE hmod;
  12.  
  13. int _strncmp(const char* d, const char* s, size_t n)
  14. {
  15.     unsigned int i;
  16.     for(i = 0; i < n; i++)
  17.     {
  18.         if(*s == 0 && *d == 0) break;
  19.         if(*d != *s) return (*d - *s);
  20.         d++; s++;
  21.     }
  22.     return 0;
  23. }
  24.  
  25. /*-------------------------------------------
  26. 　パス名にファイル名をつける
  27. ---------------------------------------------*/
  28. void add_title(char *path, char *title)
  29. {
  30.     char *p;
  31.     
  32.     p = path;
  33.  
  34.     if(*title && *(title + 1) == ':') ;
  35.     else if(*title == '\\')
  36.     {
  37.         if(*p && *(p + 1) == ':') p += 2;
  38.     }
  39.     else
  40.     {
  41.         while(*p)
  42.         {
  43.             if((*p == '\\' || *p == '/') && *(p + 1) == 0)
  44.             {
  45.                 break;
  46.             }
  47.             p = CharNext(p);
  48.         }
  49.         *p++ = '\\';
  50.     }
  51.     while(*title) *p++ = *title++;
  52.     *p = 0;
  53. }
  54.  
  55. /*-------------------------------------------
  56. 　パス名からファイル名をとりのぞく
  57. ---------------------------------------------*/
  58. void del_title(char *path)
  59. {
  60.     char *p, *ep;
  61.  
  62.     p = ep = path;
  63.     while(*p)
  64.     {
  65.         if(*p == '\\' || *p == '/')
  66.         {
  67.             if(p > path && *(p - 1) == ':') ep = p + 1;
  68.             else ep = p;
  69.         }
  70.         p = CharNext(p);
  71.     }
  72.     *ep = 0;
  73. }
  74.  
  75. /*------------------------------------------------
  76.     カンマで区切られた文字列を取り出す
  77. --------------------------------------------------*/
  78. void parse(char *dst, char *src, int n)
  79. {
  80.     char *dp;
  81.     int i;
  82.  
  83.     for(i = 0; i < n; i++)
  84.     {
  85.         while(*src && *src != ',') src++;
  86.         if(*src == ',') src++;
  87.     }
  88.     if(*src == 0) 
  89.     {
  90.         *dst = 0; return;
  91.     }
  92.     
  93.     while(*src == ' ') src++;
  94.     
  95.     dp = dst;
  96.     while(*src && *src != ',') *dst++ = *src++;
  97.     *dst = 0;
  98.     
  99.     while(dst != dp)
  100.     {
  101.         dst--;
  102.         if(*dst == ' ') *dst = 0;
  103.         else break;
  104.     }
  105. }
  106.  
  107. /*-------------------------------------------
  108.   returns a resource string
  109. ---------------------------------------------*/
  110. char* MyString(UINT id)
  111. {
  112.     static char buf[80];
  113.     
  114.     if(LoadString(hmod, id, buf, 80) == 0)
  115.         buf[0] = 0;
  116.     
  117.     return buf;
  118. }
  119.  
  120. char mykey[] = "Software\\Kazubon\\TClock";
  121.  
  122. /*------------------------------------------------
  123. 　自分のレジストリから文字列を得る
  124. --------------------------------------------------*/
  125. int GetMyRegStr(char* section, char* entry, char* val, int cbData,
  126.     char* defval)
  127. {
  128.     char keystr[80];
  129.     HKEY hkey;
  130.     DWORD regtype;
  131.     DWORD size;
  132.     BOOL b;
  133.     int r;
  134.     
  135.     strcpy(keystr, mykey);
  136.     if(section && *section)
  137.     {
  138.         strcat(keystr, "\\"); strcat(keystr, section);
  139.     }
  140.     b = FALSE;
  141.     if(RegOpenKey(HKEY_CURRENT_USER, keystr, &hkey) == 0)
  142.     {
  143.         size = cbData;
  144.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  145.             (LPBYTE)val, &size) == 0)
  146.         {
  147.             if(size == 0) *val = 0;
  148.             r = size;
  149.             b = TRUE;
  150.         }
  151.         RegCloseKey(hkey);
  152.     }
  153.     if(b == FALSE)
  154.     {
  155.         strcpy(val, defval);
  156.         r = strlen(defval);
  157.     }
  158.     return r;
  159. }
  160.  
  161. /*------------------------------------------------
  162. 　自分のレジストリからLONG値を得る
  163. --------------------------------------------------*/
  164. LONG GetMyRegLong(char* section, char* entry, LONG defval)
  165. {
  166.     char keystr[80];
  167.     HKEY hkey;
  168.     DWORD regtype;
  169.     DWORD size;
  170.     BOOL b;
  171.     LONG r;
  172.  
  173.     strcpy(keystr, mykey);
  174.     if(section && *section)
  175.     {
  176.         strcat(keystr, "\\"); strcat(keystr, section);
  177.     }
  178.     b = FALSE;
  179.     if(RegOpenKey(HKEY_CURRENT_USER, keystr, &hkey) == 0)
  180.     {
  181.         size = 4;
  182.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  183.             (LPBYTE)&r, &size) == 0)
  184.         {
  185.             if(size == 4) b = TRUE;
  186.         }
  187.         RegCloseKey(hkey);
  188.     }
  189.     if(b == FALSE) r = defval;
  190.     return r;
  191. }
  192.  
  193. /*------------------------------------------------
  194.   get DWORD value from registry
  195. --------------------------------------------------*/
  196. LONG GetRegLong(HKEY rootkey, char*subkey, char* entry, LONG defval)
  197. {
  198.     HKEY hkey;
  199.     DWORD regtype;
  200.     DWORD size;
  201.     BOOL b;
  202.     int r;
  203.     
  204.     b = FALSE;
  205.     if(RegOpenKey(rootkey, subkey, &hkey) == 0)
  206.     {
  207.         size = 4;
  208.         regtype = REG_DWORD;
  209.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  210.             (LPBYTE)&r, &size) == 0)
  211.         {
  212.             if(size == 4) b = TRUE;
  213.         }
  214.         RegCloseKey(hkey);
  215.     }
  216.     if(b == FALSE) r = defval;
  217.     return r;
  218. }
  219.  
  220. /*------------------------------------------------
  221. 　レジストリから文字列を得る
  222. --------------------------------------------------*/
  223. int GetRegStr(HKEY rootkey, char*subkey, char* entry,
  224.     char* val, int cbData, char* defval)
  225. {
  226.     HKEY hkey;
  227.     DWORD regtype;
  228.     DWORD size;
  229.     BOOL b;
  230.     int r;
  231.     
  232.     b = FALSE;
  233.     if(RegOpenKey(rootkey, subkey, &hkey) == 0)
  234.     {
  235.         size = cbData;
  236.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  237.             (LPBYTE)val, &size) == 0)
  238.         {
  239.             if(size == 0) *val = 0;
  240.             b = TRUE;
  241.         }
  242.         RegCloseKey(hkey);
  243.     }
  244.     if(b == FALSE)
  245.     {
  246.         strcpy(val, defval);
  247.         r = strlen(defval);
  248.     }
  249.     return r;
  250. }
  251.  
  252. /*-------------------------------------------
  253. 　レジストリに文字列を書き込む
  254. ---------------------------------------------*/
  255. BOOL SetMyRegStr(char* subkey, char* entry, char* val)
  256. {
  257.     HKEY hkey;
  258.     BOOL r;
  259.     char key[80];
  260.     
  261.     strcpy(key, mykey);
  262.     if(*subkey)
  263.     {
  264.         strcat(key, "\\"); strcat(key, subkey);
  265.     }
  266.     r = FALSE;
  267.     if(RegCreateKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  268.     {
  269.         if(RegSetValueEx(hkey, entry, 0, REG_SZ,
  270.             (CONST BYTE*)val, strlen(val)) == 0)
  271.         {
  272.             r = TRUE;
  273.         }
  274.         RegCloseKey(hkey);
  275.     }
  276.     return r;
  277. }
  278.  
  279. /*-------------------------------------------
  280. 　レジストリにDWORD値を書き込む
  281. ---------------------------------------------*/
  282. BOOL SetMyRegLong(char* subkey, char* entry, DWORD val)
  283. {
  284.     HKEY hkey;
  285.     BOOL r;
  286.     char key[80];
  287.     
  288.     strcpy(key, mykey);
  289.     if(*subkey)
  290.     {
  291.         strcat(key, "\\"); strcat(key, subkey);
  292.     }
  293.     r = FALSE;
  294.     if(RegCreateKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  295.     {
  296.         if(RegSetValueEx(hkey, entry, 0, REG_DWORD,
  297.             (CONST BYTE*)&val, 4) == 0)
  298.         {
  299.             r = TRUE;
  300.         }
  301.         RegCloseKey(hkey);
  302.     }
  303.     return r;
  304. }
  305.  
  306. /*------------------------------------------------
  307. 　デバッグ用
  308. --------------------------------------------------*/
  309. void WriteDebug(LPSTR s)
  310. {
  311.     HFILE hf;
  312.     char fname[MAX_PATH], title[] = "DEBUG.TXT";
  313.  
  314.     GetModuleFileName(hmod, fname, MAX_PATH);
  315.     del_title(fname);
  316.     add_title(fname, title);
  317.     hf = _lopen(fname, OF_WRITE);
  318.     if(hf == HFILE_ERROR) hf = _lcreat(fname, 0);
  319.     if(hf == HFILE_ERROR) return;
  320.     _llseek(hf, 0, 2);
  321.     _lwrite(hf, s, lstrlen(s));
  322.     _lwrite(hf, "\x0d\x0a", 2);
  323.     _lclose(hf);
  324. }
  325.