home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1996 February / VPR9602A.ISO / fwindows / tmedt090 / toold101 / ls.c < prev    next >
C/C++ Source or Header  |  1995-11-19  |  8KB  |  305 lines
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include "comwin.h"
  5.  
  6. #define DLLNAME "cwtools.dll"
  7. #define APINAME "CallCommand"
  8.  
  9. typedef int INT;
  10.  
  11. char gszNullStr[] = "";
  12.  
  13. char *cwStrrchr(char *s, int c)
  14. {
  15.     unsigned char *p;
  16.     unsigned char *pr;
  17.  
  18.     pr = NULL;
  19.     for (p = s; *p != '\0'; p++) {
  20.         /* for DBCS */
  21.         if (IsDBCSLeadByte(*p) == TRUE) {
  22.             p++;
  23.             if (*p == '\0') {
  24.                 break;
  25.             }
  26.             continue;
  27.         }
  28.         if (*p == c) {
  29.             pr = p;
  30.         }
  31.     }
  32.     return pr;
  33. }
  34.  
  35. INT GetCommandName(LPSTR lpCmd, INT nSize)
  36. {
  37.     char szModule[MAX_PATH];
  38.     char szAlias[MAX_PATH];
  39.     LPSTR lpS, lpP;
  40.  
  41.     GetModuleFileName(NULL, szModule, sizeof(szModule));
  42.     lpS = cwStrrchr(szModule, '\\');
  43.     lpS = (lpS == NULL) ? szModule : lpS + 1;
  44.     lstrcpyn(lpCmd, lpS, nSize);
  45.     lpP = cwStrrchr(lpCmd, '.');
  46.     if (lpP != NULL) *lpP = '\0';
  47.     lstrcpy(lpS, "cwtools.ini");
  48.     GetPrivateProfileString("alias", lpCmd, lpCmd,
  49.                             szAlias, sizeof(szAlias), szModule);
  50.     lstrcpyn(lpCmd, szAlias, nSize);
  51.     return 0;
  52. }
  53.  
  54. #ifdef COMWIN
  55.  
  56. BOOL GetConsoleInfo(LP_CW_S_CONSOLE_INFO lpci)
  57. {
  58.     return GetComWinLong(CW_GETMSG, (LONG)lpci);
  59. }
  60.  
  61. LONG FAR PASCAL StubPuts(LPSTR lpStr)
  62. {
  63.     return Puts(lpStr);
  64. }
  65.  
  66. LPSTR FAR PASCAL StubGets(LPSTR lpStr)
  67. {
  68.     return Gets(lpStr);
  69. }
  70.  
  71. LONG FAR PASCAL StubFputs(LPSTR lpStr, LPSTR lpFile)
  72. {
  73.     return Fputs(lpStr, lpFile);
  74. }
  75.  
  76. LPSTR FAR PASCAL StubFgets(LPSTR lpStr, LONG lSize, LPSTR lpFile)
  77. {
  78.     return Fgets(lpStr, lSize, lpFile);
  79. }
  80.  
  81. LONG FAR PASCAL StubSystem(LPSTR lpStr)
  82. {
  83.     return System(lpStr);
  84. }
  85.  
  86. BOOL FAR PASCAL StubCallConsole(FARPROC FAR *lpfnIO,
  87.                                 LPSTR lpszCmdLine,
  88.                                 LPLONG lpInfo)
  89. {
  90.     LP_CW_S_CONSOLE_INFO lpci;
  91.  
  92.     switch (*lpInfo) {
  93.         case CW_M_CONSOLE_INFO:
  94.             lpci = (LP_CW_S_CONSOLE_INFO)lpInfo;
  95.             switch (lpci->lMode) {
  96.                 case CW_MODE_GET:
  97.                     return GetConsoleInfo(lpci);
  98.             }
  99.     }
  100.     return FALSE;
  101. }
  102.  
  103. LONG FAR PASCAL StubGetch(void)
  104. {
  105.     return Getch();
  106. }
  107.  
  108. LONG FAR PASCAL StubInkey(void)
  109. {
  110.     return Inkey();
  111. }
  112.  
  113. INT PASCAL WinMain(HINSTANCE hInstance,
  114.                    HINSTANCE hPrevInstance,
  115.                    LPSTR lpszCmdParam,
  116.                    INT nCmdShow)
  117. {
  118.     FARPROC lpfnIO[8];
  119.     BOOL (FAR PASCAL *CallCommand)(FARPROC FAR *, LPSTR, LPLONG);
  120.     HINSTANCE hInstDLL;
  121.     LONG lReturn;
  122.     char szCmdLine[512];
  123.     char szCmd[512];
  124.     CW_S_CONSOLE_INFO ci;
  125.  
  126.     lpfnIO[0] = MakeProcInstance((FARPROC)StubPuts,        hInstance);
  127.     lpfnIO[1] = MakeProcInstance((FARPROC)StubGets,        hInstance);
  128.     lpfnIO[2] = MakeProcInstance((FARPROC)StubFputs,       hInstance);
  129.     lpfnIO[3] = MakeProcInstance((FARPROC)StubFgets,       hInstance);
  130.     lpfnIO[4] = MakeProcInstance((FARPROC)StubSystem,      hInstance);
  131.     lpfnIO[5] = MakeProcInstance((FARPROC)StubCallConsole, hInstance);
  132.     lpfnIO[6] = MakeProcInstance((FARPROC)StubGetch,       hInstance);
  133.     lpfnIO[7] = MakeProcInstance((FARPROC)StubInkey,       hInstance);
  134.  
  135.     GetCommandName(szCmd, sizeof(szCmd));
  136.     lstrcpy(szCmdLine, szCmd);
  137.     lstrcat(szCmdLine, " ");
  138.     lstrcat(szCmdLine, lpszCmdParam);
  139.  
  140.     hInstDLL = LoadLibrary(DLLNAME);
  141.     if (hInstDLL == NULL) {
  142.         return -1;
  143.     }
  144.     (FARPROC)CallCommand = GetProcAddress(hInstDLL, APINAME);
  145.  
  146.     memset(&ci, 0, sizeof(ci));
  147.     ci.lMessage = CW_M_CONSOLE_INFO;
  148.     ci.lSize = sizeof(ci);
  149.     ci.lMode = CW_MODE_GET;
  150.     GetConsoleInfo(&ci);
  151.  
  152.     ci.lMode = CW_MODE_INIT;
  153.     ci.lFuncMax = 8;
  154.     CallCommand(lpfnIO, gszNullStr, (LPLONG)&ci);
  155.  
  156.     lReturn = CW_M_EXEC;
  157.     CallCommand(lpfnIO, szCmdLine, &lReturn);
  158.  
  159.     ci.lMode = CW_MODE_CLEAR;
  160.     CallCommand(lpfnIO, gszNullStr, (LPLONG)&ci);
  161.  
  162.     FreeLibrary(hInstDLL);
  163.     return (INT)lReturn;
  164. }
  165.  
  166. #else
  167.  
  168. BOOL GetConsoleInfo(LP_CW_S_CONSOLE_INFO lpci)
  169. {
  170.     HANDLE hCon;
  171.     CONSOLE_SCREEN_BUFFER_INFO csbi;
  172.     char szTitle[80];
  173.     HWND hwnd;
  174.     RECT rc;
  175.     COORD co;
  176.  
  177.     hCon = GetStdHandle(STD_OUTPUT_HANDLE);
  178.     GetConsoleScreenBufferInfo(hCon, &csbi);
  179.     lpci->lColumns = csbi.srWindow.Right  - csbi.srWindow.Left;
  180.     lpci->lLines   = csbi.srWindow.Bottom - csbi.srWindow.Top;
  181.  
  182.     co = GetLargestConsoleWindowSize(hCon);
  183.     lpci->lBufMax = co.X;
  184.  
  185.     GetConsoleTitle(szTitle, sizeof(szTitle));
  186.     hwnd = FindWindow(NULL, szTitle);
  187.     lpci->hwnd = (DWORD)hwnd;
  188.  
  189.     GetClientRect(hwnd, &rc);
  190.     lpci->lWidth = rc.right;
  191.     lpci->lHeight = rc.bottom;
  192.  
  193.     if (IsIconic(hwnd) == TRUE) {
  194.         lpci->lColumns = 80;
  195.         lpci->lLines = 25;
  196.         lpci->lBufMax = 80;
  197.     }
  198.  
  199.     return TRUE;
  200. }
  201.  
  202. LONG FAR PASCAL StubPuts(LPSTR lpStr)
  203. {
  204.     return puts(lpStr);
  205. }
  206.  
  207. LPSTR FAR PASCAL StubGets(LPSTR lpStr)
  208. {
  209.     return gets(lpStr);
  210. }
  211.  
  212. LONG FAR PASCAL StubFputs(LPSTR lpStr, LPSTR lpFile)
  213. {
  214.     return fputs(lpStr, (lpFile != (LPSTR)-1) ? stdout : stderr);
  215. }
  216.  
  217. LPSTR FAR PASCAL StubFgets(LPSTR lpStr, LONG lSize, LPSTR lpFile)
  218. {
  219.     return fgets(lpStr, lSize, stdin);
  220. }
  221.  
  222. LONG FAR PASCAL StubSystem(LPSTR lpStr)
  223. {
  224.     return system(lpStr);
  225. }
  226.  
  227. BOOL FAR PASCAL StubCallConsole(FARPROC FAR *lpfnIO,
  228.                                 LPSTR lpszCmdLine,
  229.                                 LPLONG lpInfo)
  230. {
  231.     LP_CW_S_CONSOLE_INFO lpci;
  232.  
  233.     switch (*lpInfo) {
  234.         case CW_M_CONSOLE_INFO:
  235.             lpci = (LP_CW_S_CONSOLE_INFO)lpInfo;
  236.             switch (lpci->lMode) {
  237.                 case CW_MODE_GET:
  238.                     return GetConsoleInfo(lpci);
  239.             }
  240.     }
  241.     return FALSE;
  242. }
  243.  
  244. LONG FAR PASCAL StubGetch(void)
  245. {
  246.     return getch();
  247. }
  248.  
  249. LONG FAR PASCAL StubInkey(void)
  250. {
  251.     return (kbhit() == 0) ? 0 : getch();
  252. }
  253.  
  254. int main(int argc, char **argv)
  255. {
  256.     FARPROC lpfnIO[8];
  257.     BOOL (FAR PASCAL *CallCommand)(FARPROC FAR *, LPSTR, LPLONG);
  258.     HINSTANCE hInstDLL;
  259.     LONG lReturn;
  260.     char szCmdLine[512];
  261.     char szCmd[512];
  262.     CW_S_CONSOLE_INFO ci;
  263.  
  264.     lpfnIO[0] = MakeProcInstance((FARPROC)StubPuts,        hInstance);
  265.     lpfnIO[1] = MakeProcInstance((FARPROC)StubGets,        hInstance);
  266.     lpfnIO[2] = MakeProcInstance((FARPROC)StubFputs,       hInstance);
  267.     lpfnIO[3] = MakeProcInstance((FARPROC)StubFgets,       hInstance);
  268.     lpfnIO[4] = MakeProcInstance((FARPROC)StubSystem,      hInstance);
  269.     lpfnIO[5] = MakeProcInstance((FARPROC)StubCallConsole, hInstance);
  270.     lpfnIO[6] = MakeProcInstance((FARPROC)StubGetch,       hInstance);
  271.     lpfnIO[7] = MakeProcInstance((FARPROC)StubInkey,       hInstance);
  272.  
  273.     GetCommandName(szCmd, sizeof(szCmd));
  274.     lstrcpy(szCmdLine, szCmd);
  275.     lstrcat(szCmdLine, " ");
  276.     lstrcat(szCmdLine, (argc == 1) ? "" : strchr(GetCommandLine(), ' ') + 1);
  277.  
  278.     hInstDLL = LoadLibrary(DLLNAME);
  279.     if (hInstDLL == NULL) {
  280.         return -1;
  281.     }
  282.     (FARPROC)CallCommand = GetProcAddress(hInstDLL, APINAME);
  283.  
  284.     memset(&ci, 0, sizeof(ci));
  285.     ci.lMessage = CW_M_CONSOLE_INFO;
  286.     ci.lSize = sizeof(ci);
  287.     ci.lMode = CW_MODE_GET;
  288.     GetConsoleInfo(&ci);
  289.  
  290.     ci.lMode = CW_MODE_INIT;
  291.     ci.lFuncMax = 8;
  292.     CallCommand(lpfnIO, gszNullStr, (LPLONG)&ci);
  293.  
  294.     lReturn = CW_M_EXEC;
  295.     CallCommand(lpfnIO, szCmdLine, &lReturn);
  296.  
  297.     ci.lMode = CW_MODE_CLEAR;
  298.     CallCommand(lpfnIO, gszNullStr, (LPLONG)&ci);
  299.  
  300.     FreeLibrary(hInstDLL);
  301.  
  302.     return (INT)lReturn;
  303. }
  304. #endif
  305.