home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 2001 June / VPR0106A.BIN / OLS / TCL228 / TCL228.lzh / EXESRC.lzh / utl.c < prev   
C/C++ Source or Header  |  1999-09-18  |  12KB  |  604 lines
  1. /*-------------------------------------------
  2.   utl.c
  3.     その他の関数
  4.     KAZUBON 1997-1998
  5. ---------------------------------------------*/
  6.  
  7. #include <windows.h>
  8. #include <windowsx.h>
  9.  
  10. extern HINSTANCE hInst;
  11.  
  12. /*-------------------------------------------
  13.   ランタイム関数の代用
  14. ---------------------------------------------*/
  15. int atoi(const char *p)
  16. {
  17.     int r = 0;
  18.     while(*p)
  19.     {
  20.         if('0' <= *p && *p <= '9')
  21.             r = r * 10 + *p - '0';
  22.         p++;
  23.  
  24.     }
  25.     return r;
  26. }
  27.  
  28. int atox(const char *p)
  29. {
  30.     int r = 0;
  31.     while(*p)
  32.     {
  33.         if('0' <= *p && *p <= '9')
  34.             r = r * 16 + *p - '0';
  35.         else if('A' <= *p && *p <= 'F')
  36.             r = r * 16 + *p - 'A' + 10;
  37.         else if('a' <= *p && *p <= 'f')
  38.             r = r * 16 + *p - 'a' + 10;
  39.         p++;
  40.  
  41.     }
  42.     return r;
  43. }
  44.  
  45. __inline int toupper(int c)
  46. {
  47.     if('a' <= c && c <= 'z')
  48.         c -= 'a' - 'A';
  49.     return c;
  50. }
  51.  
  52. int _strnicmp(const char* d, const char* s, size_t n)
  53. {
  54.     int c1, c2;
  55.     unsigned int i;
  56.     for(i = 0; i < n; i++)
  57.     {
  58.         if(*s == 0 && *d == 0) break;
  59.         c1 = toupper(*d); c2 = toupper(*s);
  60.         if(c1 != c2) return (c1 - c2);
  61.         d++; s++;
  62.     }
  63.     return 0;
  64. }
  65.  
  66. int _stricmp(const char* d, const char* s)
  67. {
  68.     int c1, c2;
  69.     unsigned int i;
  70.     while(1)
  71.     {
  72.         if(*s == 0 && *d == 0) break;
  73.         c1 = toupper(*d); c2 = toupper(*s);
  74.         if(c1 != c2) return (c1 - c2);
  75.         d++; s++;
  76.     }
  77.     return 0;
  78. }
  79.  
  80. /*-------------------------------------------
  81. 　パス名にファイル名をつける
  82. ---------------------------------------------*/
  83. void add_title(char *path, char *title)
  84. {
  85.     char *p;
  86.     
  87.     p = path;
  88.  
  89.     if(*title && *(title + 1) == ':') ;
  90.     else if(*title == '\\')
  91.     {
  92.         if(*p && *(p + 1) == ':') p += 2;
  93.     }
  94.     else
  95.     {
  96.         while(*p)
  97.         {
  98.             if((*p == '\\' || *p == '/') && *(p + 1) == 0)
  99.             {
  100.                 break;
  101.             }
  102.             p = CharNext(p);
  103.         }
  104.         *p++ = '\\';
  105.     }
  106.     while(*title) *p++ = *title++;
  107.     *p = 0;
  108. }
  109.  
  110. /*-------------------------------------------
  111. 　パス名からファイル名をとりのぞく
  112. ---------------------------------------------*/
  113. void del_title(char *path)
  114. {
  115.     char *p, *ep;
  116.  
  117.     p = ep = path;
  118.     while(*p)
  119.     {
  120.         if(*p == '\\' || *p == '/')
  121.         {
  122.             if(p > path && *(p - 1) == ':') ep = p + 1;
  123.             else ep = p;
  124.         }
  125.         p = CharNext(p);
  126.     }
  127.     *ep = 0;
  128. }
  129.  
  130. /*------------------------------------------------
  131. 　ファイルの拡張子の比較
  132. --------------------------------------------------*/
  133. int ext_cmp(char *fname, char *ext)
  134. {
  135.     char* p, *sp;
  136.     
  137.     sp = NULL; p = fname;
  138.     while(*p)
  139.     {
  140.         if(*p == '.') sp = p;
  141.         else if(*p == '\\' || *p == '/') sp = NULL;
  142.         p = CharNext(p);
  143.     }
  144.     
  145.     if(sp == NULL) sp = p;
  146.     if(*sp == '.') sp++;
  147.     
  148.     while(1)
  149.     {
  150.         if(*sp == 0 && *ext == 0) return 0;
  151.         if(toupper(*sp) != toupper(*ext))
  152.             return (toupper(*sp) - toupper(*ext));
  153.         sp++; ext++;
  154.     }
  155.     return 0;
  156. }
  157.  
  158. /*------------------------------------------------
  159.     カンマで区切られた文字列を取り出す
  160. --------------------------------------------------*/
  161. void parse(char *dst, char *src, int n)
  162. {
  163.     char *dp;
  164.     int i;
  165.  
  166.     for(i = 0; i < n; i++)
  167.     {
  168.         while(*src && *src != ',') src++;
  169.         if(*src == ',') src++;
  170.     }
  171.     if(*src == 0) 
  172.     {
  173.         *dst = 0; return;
  174.     }
  175.     
  176.     while(*src == ' ') src++;
  177.     
  178.     dp = dst;
  179.     while(*src && *src != ',') *dst++ = *src++;
  180.     *dst = 0;
  181.     
  182.     while(dst != dp)
  183.     {
  184.         dst--;
  185.         if(*dst == ' ') *dst = 0;
  186.         else break;
  187.     }
  188. }
  189.  
  190. /*------------------------------------------------
  191.     文字で区切られた文字列を取り出す
  192. --------------------------------------------------*/
  193. void parsechar(char *dst, char *src, char ch, int n)
  194. {
  195.     char *dp;
  196.     int i;
  197.  
  198.     for(i = 0; i < n; i++)
  199.     {
  200.         while(*src && *src != ch) src++;
  201.         if(*src == ch) src++;
  202.     }
  203.     if(*src == 0) 
  204.     {
  205.         *dst = 0; return;
  206.     }
  207.     
  208.     while(*src == ' ') src++;
  209.     
  210.     dp = dst;
  211.     while(*src && *src != ch) *dst++ = *src++;
  212.     *dst = 0;
  213.     
  214.     while(dst != dp)
  215.     {
  216.         dst--;
  217.         if(*dst == ' ') *dst = 0;
  218.         else break;
  219.     }
  220. }
  221.  
  222. /*------------------------------------------------
  223. 　'\0'で終了する文字列を追加する
  224. 　最後は"\0\0"で終了
  225. --------------------------------------------------*/
  226. void str0cat(char* dst, const char* src)
  227. {
  228.     char* p;
  229.     p = dst;
  230.     while(*p) { while(*p) p++; p++; }
  231.     strcpy(p, src);
  232.     while(*p) p++; p++; *p = 0;
  233. }
  234.  
  235. /*-------------------------------------------
  236.   returns a resource string
  237. ---------------------------------------------*/
  238. char* MyString(UINT id)
  239. {
  240.     static char buf[80];
  241.     
  242.     if(LoadString(hInst, id, buf, 80) == 0)
  243.         buf[0] = 0;
  244.     
  245.     return buf;
  246. }
  247.  
  248. /*-------------------------------------------
  249.   アイコンつきメッセージボックス
  250. ---------------------------------------------*/
  251. int MyMessageBox(HWND hwnd, char* msg, char* title, UINT uType, UINT uBeep)
  252. {
  253.     MSGBOXPARAMS mbp;
  254.     
  255.     memset(&mbp, 0, sizeof(MSGBOXPARAMS));
  256.     mbp.cbSize = sizeof(MSGBOXPARAMS);
  257.     mbp.hwndOwner = hwnd;
  258.     mbp.hInstance = hInst;
  259.     mbp.lpszText = msg;
  260.     mbp.lpszCaption = title;
  261.     mbp.dwStyle = MB_USERICON | uType;
  262.     mbp.lpszIcon = MAKEINTRESOURCE(101);
  263.     mbp.dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
  264.     if(uBeep != 0xFFFFFFFF)
  265.         MessageBeep(uBeep);
  266.     return MessageBoxIndirect(&mbp);
  267. }
  268.  
  269. /*------------------------------------------------
  270.   get locale info for 95/NT
  271. --------------------------------------------------*/
  272. int GetLocaleInfoWA(int ilang, LCTYPE LCType, char* dst, int n)
  273. {
  274.     int r;
  275.     LCID Locale;
  276.     
  277.     *dst = 0;
  278.     Locale = MAKELCID((WORD)ilang, SORT_DEFAULT);
  279.     if(GetVersion() & 0x80000000) // 95
  280.         r = GetLocaleInfoA(Locale, LCType, dst, n);
  281.     else  // NT
  282.     {
  283.         WCHAR* pw;
  284.         pw = (WCHAR*)GlobalAllocPtr(GHND, sizeof(WCHAR)*(n+1));
  285.         r = GetLocaleInfoW(Locale, LCType, pw, n);
  286.         if(r)
  287.             WideCharToMultiByte(CP_ACP, 0, pw, -1, dst, n,
  288.                 NULL, NULL);
  289.         GlobalFreePtr(pw);
  290.     }
  291.     return r;
  292. }
  293.  
  294. /*-------------------------------------------
  295.   32bit x 32bit = 64bit
  296. ---------------------------------------------*/
  297. DWORDLONG M32x32to64(DWORD a, DWORD b)
  298. {
  299.     ULARGE_INTEGER r;
  300.     DWORD *p1, *p2, *p3;
  301.     memset(&r, 0, 8);
  302.     p1 = &r.LowPart;
  303.     p2 = (DWORD*)((BYTE*)p1 + 2);
  304.     p3 = (DWORD*)((BYTE*)p2 + 2);
  305.     *p1 = LOWORD(a) * LOWORD(b);
  306.     *p2 += LOWORD(a) * HIWORD(b) + HIWORD(a) * LOWORD(b);
  307.     *p3 += HIWORD(a) * HIWORD(b);
  308.     return *(DWORDLONG*)(&r);
  309. }
  310.  
  311. void WriteDebug(char* s);
  312.  
  313. /*-------------------------------------------
  314.   SetForegroundWindow for Windows98
  315. ---------------------------------------------*/
  316. void SetForegroundWindow98(HWND hwnd)
  317. {
  318.     DWORD dwVer;
  319.     
  320.     dwVer = GetVersion();
  321.     if((dwVer & 0x80000000) && HIBYTE(LOWORD(dwVer)) >= 10) // Win98
  322.     {
  323.         DWORD thread1, thread2;
  324.         DWORD pid;
  325.         thread1 = GetWindowThreadProcessId(
  326.             GetForegroundWindow(), &pid);
  327.         thread2 = GetCurrentThreadId();
  328.         AttachThreadInput(thread2, thread1, TRUE);
  329.         SetForegroundWindow(hwnd);
  330.         AttachThreadInput(thread2, thread1, FALSE);
  331.         BringWindowToTop(hwnd);
  332.     }
  333.     else  // Win95/NT
  334.         SetForegroundWindow(hwnd);
  335. }
  336.  
  337. /*-------------------------------------------
  338.   for debugging
  339. ---------------------------------------------*/
  340. void WriteDebug(char* s)
  341. {
  342.     HFILE hf;
  343.     char fname[] = "DEBUG.TXT";
  344.     
  345.     hf = _lopen(fname, OF_WRITE);
  346.     if(hf == HFILE_ERROR)
  347.         hf = _lcreat(fname, 0);
  348.     if(hf == HFILE_ERROR) return;
  349.     _llseek(hf, 0, 2);
  350.     _lwrite(hf, s, lstrlen(s));
  351.     _lwrite(hf, "\x0d\x0a", 2);
  352.     _lclose(hf);
  353. }
  354.  
  355. //TClock用のレジストリのキー
  356. char mykey[] = "Software\\Kazubon\\TClock";
  357.  
  358. /*------------------------------------------------
  359. 　自分のレジストリから文字列を得る
  360. --------------------------------------------------*/
  361. int GetMyRegStr(char* section, char* entry, char* val, int cbData,
  362.     char* defval)
  363. {
  364.     char keystr[80];
  365.     HKEY hkey;
  366.     DWORD regtype;
  367.     DWORD size;
  368.     BOOL b;
  369.     int r;
  370.     
  371.     strcpy(keystr, mykey);
  372.     if(section && *section)
  373.     {
  374.         strcat(keystr, "\\"); strcat(keystr, section);
  375.     }
  376.     b = FALSE;
  377.     if(RegOpenKey(HKEY_CURRENT_USER, keystr, &hkey) == 0)
  378.     {
  379.         size = cbData;
  380.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  381.             (LPBYTE)val, &size) == 0)
  382.         {
  383.             if(size == 0) *val = 0;
  384.             r = size;
  385.             b = TRUE;
  386.         }
  387.         RegCloseKey(hkey);
  388.     }
  389.     if(b == FALSE)
  390.     {
  391.         strcpy(val, defval);
  392.         r = strlen(defval);
  393.     }
  394.     return r;
  395. }
  396.  
  397. /*------------------------------------------------
  398. 　自分のレジストリからLONG値を得る
  399. --------------------------------------------------*/
  400. LONG GetMyRegLong(char* section, char* entry, LONG defval)
  401. {
  402.     char keystr[80];
  403.     HKEY hkey;
  404.     DWORD regtype;
  405.     DWORD size;
  406.     BOOL b;
  407.     LONG r;
  408.  
  409.     strcpy(keystr, mykey);
  410.     if(section && *section)
  411.     {
  412.         strcat(keystr, "\\"); strcat(keystr, section);
  413.     }
  414.     b = FALSE;
  415.     if(RegOpenKey(HKEY_CURRENT_USER, keystr, &hkey) == 0)
  416.     {
  417.         size = 4;
  418.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  419.             (LPBYTE)&r, &size) == 0)
  420.         {
  421.             if(size == 4) b = TRUE;
  422.         }
  423.         RegCloseKey(hkey);
  424.     }
  425.     if(b == FALSE) r = defval;
  426.     return r;
  427. }
  428.  
  429. /*------------------------------------------------
  430.   get DWORD value from registry
  431. --------------------------------------------------*/
  432. LONG GetRegLong(HKEY rootkey, char*subkey, char* entry, LONG defval)
  433. {
  434.     HKEY hkey;
  435.     DWORD regtype;
  436.     DWORD size;
  437.     BOOL b;
  438.     int r;
  439.     
  440.     b = FALSE;
  441.     if(RegOpenKey(rootkey, subkey, &hkey) == 0)
  442.     {
  443.         size = 4;
  444.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  445.             (LPBYTE)&r, &size) == 0)
  446.         {
  447.             if(size == 4) b = TRUE;
  448.         }
  449.         RegCloseKey(hkey);
  450.     }
  451.     if(b == FALSE) r = defval;
  452.     return r;
  453. }
  454.  
  455. /*------------------------------------------------
  456. 　レジストリから文字列を得る
  457. --------------------------------------------------*/
  458. int GetRegStr(HKEY rootkey, char*subkey, char* entry,
  459.     char* val, int cbData, char* defval)
  460. {
  461.     HKEY hkey;
  462.     DWORD regtype;
  463.     DWORD size;
  464.     BOOL b;
  465.     int r;
  466.     
  467.     b = FALSE;
  468.     if(RegOpenKey(rootkey, subkey, &hkey) == 0)
  469.     {
  470.         size = cbData;
  471.         if(RegQueryValueEx(hkey, entry, 0, ®type,
  472.             (LPBYTE)val, &size) == 0)
  473.         {
  474.             if(size == 0) *val = 0;
  475.             b = TRUE;
  476.         }
  477.         RegCloseKey(hkey);
  478.     }
  479.     if(b == FALSE)
  480.     {
  481.         strcpy(val, defval);
  482.         r = strlen(defval);
  483.     }
  484.     return r;
  485. }
  486.  
  487. /*-------------------------------------------
  488. 　レジストリに文字列を書き込む
  489. ---------------------------------------------*/
  490. BOOL SetMyRegStr(char* subkey, char* entry, char* val)
  491. {
  492.     HKEY hkey;
  493.     BOOL r;
  494.     char key[80];
  495.     
  496.     strcpy(key, mykey);
  497.     if(*subkey)
  498.     {
  499.         strcat(key, "\\"); strcat(key, subkey);
  500.     }
  501.     r = FALSE;
  502.     if(RegCreateKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  503.     {
  504.         if(RegSetValueEx(hkey, entry, 0, REG_SZ,
  505.             (CONST BYTE*)val, strlen(val)) == 0)
  506.         {
  507.             r = TRUE;
  508.         }
  509.         RegCloseKey(hkey);
  510.     }
  511.     return r;
  512. }
  513.  
  514. /*-------------------------------------------
  515. 　レジストリに文字列を書き込む
  516. ---------------------------------------------*/
  517. BOOL SetRegStr(HKEY rootkey, char* subkey, char* entry, char* val)
  518. {
  519.     HKEY hkey;
  520.     BOOL r;
  521.  
  522.     if(RegCreateKey(rootkey, subkey, &hkey) == 0)
  523.     {
  524.         if(RegSetValueEx(hkey, entry, 0, REG_SZ,
  525.             (CONST BYTE*)val, strlen(val)) == 0)
  526.         {
  527.             r = TRUE;
  528.         }
  529.         RegCloseKey(hkey);
  530.     }
  531.     return r;
  532. }
  533.  
  534. /*-------------------------------------------
  535. 　レジストリにDWORD値を書き込む
  536. ---------------------------------------------*/
  537. BOOL SetMyRegLong(char* subkey, char* entry, DWORD val)
  538. {
  539.     HKEY hkey;
  540.     BOOL r;
  541.     char key[80];
  542.     
  543.     strcpy(key, mykey);
  544.     if(*subkey)
  545.     {
  546.         strcat(key, "\\"); strcat(key, subkey);
  547.     }
  548.     r = FALSE;
  549.     if(RegCreateKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  550.     {
  551.         if(RegSetValueEx(hkey, entry, 0, REG_DWORD,
  552.             (CONST BYTE*)&val, 4) == 0)
  553.         {
  554.             r = TRUE;
  555.         }
  556.         RegCloseKey(hkey);
  557.     }
  558.     return r;
  559. }
  560.  
  561.  
  562. /*-------------------------------------------
  563. 　レジストリの値を削除
  564. ---------------------------------------------*/
  565. BOOL DelMyReg(char* subkey, char* entry)
  566. {
  567.     BOOL r;
  568.     char key[80];
  569.     HKEY hkey;
  570.     
  571.     strcpy(key, mykey);
  572.     if(*subkey)
  573.     {
  574.         strcat(key, "\\"); strcat(key, subkey);
  575.     }
  576.     r = FALSE;
  577.     if(RegOpenKey(HKEY_CURRENT_USER, key, &hkey) == 0)
  578.     {
  579.         if(RegDeleteValue(hkey, entry) == 0)
  580.             r = TRUE;
  581.         RegCloseKey(hkey);
  582.     }
  583.     return r;
  584. }
  585.  
  586. /*-------------------------------------------
  587. 　レジストリのキーを削除
  588. ---------------------------------------------*/
  589. BOOL DelMyRegKey(char* subkey)
  590. {
  591.     BOOL r;
  592.     char key[80];
  593.     
  594.     strcpy(key, mykey);
  595.     if(subkey && *subkey)
  596.     {
  597.         strcat(key, "\\"); strcat(key, subkey);
  598.     }
  599.     r = FALSE;
  600.     if(RegDeleteKey(HKEY_CURRENT_USER, key) == 0)
  601.         r = TRUE;
  602.     return r;
  603. }
  604.