home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 October / VPR9710A.ISO / OLS / WIN32 / Comwp371 / comwp371.exe / SAMPLES.EXE / SAMPLE3.C < prev    next >
C/C++ Source or Header  |  1997-06-20  |  18KB  |  606 lines
  1. /*----------------------------------------------------------------------*
  2.  * このDLLを利用するためには、次の操作が必要です。
  3.  * 1. sample3.dllをwindowsディレクトリ、windows\systemディレクトリ
  4.  *    PATHのあるディレクトリのいずれかに移動する。
  5.  * 2. comwin.iniの[CommandDll]セクションに次の記述を加える。
  6.  *    sample3.dll=SampleCommand
  7.  * 3. comwinのプロンプトに次のように入力する。
  8.  *    c:\>command0
  9.  *    c:\>command1
  10.  *----------------------------------------------------------------------*
  11.  */
  12.  
  13. #include <windows.h>
  14. #include <windowsx.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18. #include "comwin.h"
  19.  
  20. typedef struct CMDTABLE CMDTABLE;
  21. struct CMDTABLE {
  22.     char *pszCmd;
  23.     int (*pfnCmd)(int, char **);
  24. };
  25.  
  26. PUTS        NEAR cwsPuts;
  27. GETS        NEAR cwsGets;
  28. FPUTS       NEAR cwsFputs;
  29. FGETS       NEAR cwsFgets;
  30. SYSTEM      NEAR cwsSystem;
  31. CALLCOMMAND NEAR cwsCallConsole;
  32. GETCH       NEAR cwsGetch;
  33. INKEY       NEAR cwsInkey;
  34. FWRITE      NEAR cwsFwrite;
  35. FREAD       NEAR cwsFread;
  36.  
  37. #if !defined(WIN32)
  38. int FAR PASCAL LibMain(HINSTANCE hInstance, WORD wDataSeg, WORD wHeapSize,
  39.                        LPSTR lpszCmdLine)
  40. {
  41.     if (wHeapSize > 0) {
  42.         UnlockData(0);
  43.     }
  44.     return 1;
  45. }
  46. #endif
  47.  
  48. /********************
  49.   CallCommand Sample
  50.  ********************
  51.  */
  52. BOOL ListCommand(CMDTABLE *cmdTable, LPSTR lpszCmdName);
  53. int command0Cmd(int, char **);
  54. int command1Cmd(int, char **);
  55. int command2Cmd(int, char **);
  56. int clipCmd(int, char **);
  57. int pasteCmd(int, char **);
  58. int printfCmd(int, char **);
  59. int verCmd(int, char **);
  60.  
  61. BOOL FAR PASCAL SampleCommand(FARPROC FAR *lpfnIO,
  62.                               LPSTR lpszCmdLine,
  63.                               LPLONG lpReturn)
  64. {
  65.     static CMDTABLE cmdTable[] = {
  66.         {"command0", command0Cmd},
  67.         {"command1", command1Cmd},
  68.         {"command2", command2Cmd},
  69.         {"clip",     clipCmd},
  70.         {"paste",    pasteCmd},
  71.         {"printf",   printfCmd},
  72.         {"ver",      verCmd},
  73.         {NULL, NULL}
  74.     };
  75.     CMDTABLE *pCT;
  76.     int nArgv[0x80];
  77.     char szReturn[0x100];
  78.     int argc;
  79.     char *argv[0x80];
  80.     int i;
  81.  
  82.     /* 通常処理のチェック */
  83.     if (lpReturn[0] != CW_M_EXEC) { /* 実は -1 */
  84.  
  85.         /* 特別処理、メッセージのチェック */
  86.         switch (lpReturn[0]) {
  87.             case CW_M_HELP: /* 実は 0 */
  88.                 /* コマンドの一覧を返す */
  89.                 return ListCommand(cmdTable, lpszCmdLine);
  90.             case CW_M_CONSOLE_INFO:
  91.                 /* コンソール情報が来るが、
  92.                    マルチスレッド(=WIN32)、マルチタスク(=WIN16)対応が
  93.                    大変なので処理していない */
  94.                 return FALSE;
  95.             default:
  96.                 return FALSE;
  97.         }
  98.     }
  99.  
  100.     /* 入出力部を実体化する lpfnIO[0] - lpfnIO[5] は必ず定義されている */
  101.     cwsPuts        = (PUTS)lpfnIO[0];
  102.     cwsGets        = (GETS)lpfnIO[1];
  103.     cwsFputs       = (FPUTS)lpfnIO[2];
  104.     cwsFgets       = (FGETS)lpfnIO[3];
  105.     cwsSystem      = (SYSTEM)lpfnIO[4];
  106.  
  107. #if 1 /* コンソール側と通信の必要があるときに定義 */
  108.     cwsCallConsole = (CALLCOMMAND)lpfnIO[5];
  109. #endif
  110. #if 0 /* コンソール側が直接入力をサポートしているとき定義 */
  111.     cwsGetch       = (GETCH)lpfnIO[6];
  112.     cwsInkey       = (INKEY)lpfnIO[7];
  113. #endif
  114. #if 0 /* コンソール側が２進入出力をサポートしているとき定義 */
  115.     cwsFwrite      = (GETCH)lpfnIO[8];
  116.     cwsFread       = (INKEY)lpfnIO[9];
  117. #endif
  118.  
  119.     /* 通常処理、一致したコマンドがあれば処理する */
  120.     for (pCT = cmdTable; pCT->pszCmd != NULL; pCT++) {
  121.         if (strncmp(pCT->pszCmd, lpszCmdLine, lstrlen(pCT->pszCmd)) == 0) break;
  122.     }
  123.     if (pCT->pszCmd == NULL) return FALSE;
  124.  
  125.     /* 引数の作成 */
  126.     argc = MakeArgument(NULL, pCT->pszCmd, lpszCmdLine, 
  127.                                 nArgv, szReturn, sizeof(szReturn));
  128.     if (lstrcmp(pCT->pszCmd, szReturn) != 0) return FALSE;
  129.  
  130.     for (i = 0; i < argc; i++) {
  131.         argv[i] = szReturn + nArgv[i];
  132.     }
  133.     argv[i] = NULL;
  134.  
  135.     /* コマンド呼び出し */
  136.     *lpReturn = (LONG)pCT->pfnCmd(argc, argv);
  137.     return TRUE;
  138. }
  139.  
  140. BOOL ListCommand(CMDTABLE *cmdTable, LPSTR lpszCmdName)
  141. {
  142.     static int i = 0; /* マルチスレッド、マルチタスクに注意 */
  143.  
  144.     if (cmdTable[i].pszCmd == NULL) {
  145.         i = 0;
  146.         return FALSE;
  147.     }
  148.     lstrcpy(lpszCmdName, cmdTable[i].pszCmd); i++;
  149.     return TRUE;
  150. }
  151.  
  152. int command0Cmd(int argc, char **argv)
  153. {
  154.     cwsPuts("command0 は0を返すコマンドです");
  155.     return 0;
  156. }
  157.  
  158. int command1Cmd(int argc, char **argv)
  159. {
  160.     static char szMsg[] = "command1 は1を返すコマンドです";
  161.  
  162.     cwsPuts(szMsg);
  163.     return 1;
  164. }
  165.  
  166. int command2Cmd(int argc, char **argv)
  167. {
  168. #if !defined(WIN32)
  169.     cwsFputs("Win16 上では Unicode をサポートしていません。\n", NULL);
  170.     return 1;
  171. #else
  172.     FPUTSW cwsFputsW;
  173.     FGETSW cwsFgetsW;
  174.     FARPROC afnIO[6];
  175.     CW_S_UNICODE_ENTRY ue;
  176.  
  177.     /* 構造体の初期化 */
  178.     memset(&ue, 0, sizeof(ue));
  179.     ue.lMessage = CW_M_UNICODE_ENTRY;
  180.     ue.lSize = sizeof(ue);
  181.     ue.lMode = CW_MODE_GET;
  182.     ue.lFuncMax = 6; /* 6 以上の数値 */
  183.  
  184.     if (cwsCallConsole(afnIO, "", (LPLONG)&ue) == FALSE) {
  185.         cwsPuts("この端末は Unicode をサポートしていません。");
  186.         return 1;
  187.     }
  188.     cwsFputsW = (FPUTSW)afnIO[2];
  189.  
  190.     if (cwsFputsW == NULL) {
  191.         cwsPuts("この端末は cwFputsW 機能をもっていません。");
  192.         return 1;
  193.     }
  194.  
  195.     cwsFgetsW = (FGETSW)afnIO[3];
  196.     if (cwsFgetsW == NULL) {
  197.         cwsPuts("この端末は cwFgetsW 機能をもっていません。");
  198.     }
  199.  
  200.     cwsFputsW(L"このテキストは Unicode です。\n", NULL);
  201.     return 0;
  202. #endif
  203. }
  204.  
  205. int printfCmd(int argc, char **argv)
  206. {
  207.     LPSTR lpOut;
  208.     LPSTR lpS, lpE;
  209.     char szBuf[0x80];
  210.     char cStack;
  211.     int nArg, nOut;
  212.     LPSTR lpArg;
  213.  
  214.     /* 引数チェック */
  215.     if (argc <= 1) {
  216.         cwsFputs("printf format [env1 ...]\n", NULL);
  217.         return 1;
  218.     }
  219.  
  220.     /* 出力用のバッファを確保 (4096文字分) */
  221.     /* メモリオーバーチェックはいい加減です。(^^;) */
  222.     lpOut = GlobalAllocPtr(GMEM_MOVEABLE, 0x1000);
  223.     if (lpOut == NULL) {
  224.         cwsFputs("memory error\n", NULL);
  225.         return 1;
  226.     }
  227.  
  228.     /* 各引数の環境変数値を保存 */
  229.  
  230.     nArg = 2; nOut = 0;
  231.     for (lpS = argv[1]; *lpS != '\0' && nOut < 0x800; lpS++) {
  232.         if (IsDBCSLeadByte(*lpS) == TRUE && *(lpS + 1) != '\0') {
  233.  
  234.             /* 2バイトコード */
  235.  
  236.             *(lpOut + nOut) = *lpS; nOut++;
  237.             if (*(lpS + 1) != '\0') {
  238.                 lpS++;
  239.                 *(lpOut + nOut) = *lpS; nOut++;
  240.             }
  241.  
  242.         } else if (*lpS == '%') {
  243.  
  244.             /* 出力フォーマット */
  245.  
  246.             for (lpE = lpS + 1; *lpE != '\0'; lpE++) {
  247.  
  248.                 if (*lpE == 'd' ||
  249.                     *lpE == 'i' ||
  250.                     *lpE == 'o' ||
  251.                     *lpE == 'x' ||
  252.                     *lpE == 'X' ||
  253.                     *lpE == 'u' ||
  254.                     *lpE == 'c') {
  255.  
  256.                     /* 整数系 */
  257.  
  258.                     LONG lArg;
  259.  
  260.                     lpArg = (nArg < argc) ? cwGetenv(argv[nArg]) : "";
  261.                     if (lpArg == NULL) lpArg = "";
  262.                     nArg++;
  263.  
  264.                     lstrcpyn(szBuf, lpArg, 0x80);
  265.                     if (*lpArg == '0' && *(lpArg + 1) == 'x') {
  266.                         lArg = strtol(szBuf, NULL, 0x10);
  267.                     } else {
  268.                         lArg = strtol(szBuf, NULL, 10);
  269.                     }
  270.  
  271.                     cStack = *(lpE + 1); *(lpE + 1) = '\0';
  272.                     wsprintf(lpOut + nOut, lpS, lArg);
  273.                     *(lpE + 1) = cStack;
  274.                     nOut += lstrlen(lpOut + nOut);
  275.                     break;
  276.  
  277.                 } else if (*lpE == 's') {
  278.  
  279.                     /* 文字列 */
  280.  
  281.                     lpArg = (nArg < argc) ? cwGetenv(argv[nArg]) : "";
  282.                     if (lpArg == NULL) lpArg = "";
  283.                     nArg++;
  284.  
  285.                     if (lstrlen(lpArg) + nOut >= 0x800) break;
  286.  
  287.                     cStack = *(lpE + 1); *(lpE + 1) = '\0';
  288.                     wsprintf(lpOut + nOut, lpS, lpArg);
  289.                     *(lpE + 1) = cStack;
  290.                     nOut += lstrlen(lpOut + nOut);
  291.                     break;
  292.  
  293.                 } else if (*lpE == 'f' ||
  294.                            *lpE == 'e' ||
  295.                            *lpE == 'E' ||
  296.                            *lpE == 'g' ||
  297.                            *lpE == 'G') {
  298.  
  299.                     /* 浮動小数点系 */
  300.  
  301.                     double eArg;
  302.  
  303.                     lpArg = (nArg < argc) ? cwGetenv(argv[nArg]) : "";
  304.                     if (lpArg == NULL) lpArg = "";
  305.                     nArg++;
  306.  
  307.                     lstrcpyn(szBuf, lpArg, 0x80);
  308.                     eArg = strtod(szBuf, NULL);
  309.  
  310.                     cStack = *(lpE + 1); *(lpE + 1) = '\0';
  311.                     sprintf(lpOut + nOut, lpS, eArg); /* sprintf */
  312.                     *(lpE + 1) = cStack;
  313.                     nOut += lstrlen(lpOut + nOut);
  314.                     break;
  315.  
  316.                 } else if (*lpE == '%') {
  317.  
  318.                     /* '%' 文字 */
  319.  
  320.                     cStack = *(lpE + 1); *(lpE + 1) = '\0';
  321.                     wsprintf(lpOut + nOut, lpS);
  322.                     *(lpE + 1) = cStack;
  323.                     nOut += lstrlen(lpOut + nOut);
  324.                     break;
  325.  
  326.                 }
  327.             }
  328.             lpS = lpE;
  329.         } else if (*lpS == '\\' && *(lpS + 1) != '\0') {
  330.  
  331.             /* エスケープ文字 */
  332.  
  333.             lpS++;
  334.             switch (*lpS) {
  335.                 case 'a':
  336.                     *(lpOut + nOut) = '\a'; nOut++;
  337.                     break;
  338.                 case 'b':
  339.                     *(lpOut + nOut) = '\b'; nOut++;
  340.                     break;
  341.                 case 'f':
  342.                     *(lpOut + nOut) = '\f'; nOut++;
  343.                     break;
  344.                 case 'n':
  345.                     *(lpOut + nOut) = '\n'; nOut++;
  346.                     break;
  347.                 case 'r':
  348.                     *(lpOut + nOut) = '\r'; nOut++;
  349.                     break;
  350.                 case 't':
  351.                     *(lpOut + nOut) = '\t'; nOut++;
  352.                     break;
  353.                 case 'v':
  354.                     *(lpOut + nOut) = '\v'; nOut++;
  355.                     break;
  356.                 case 'x':
  357.                     if (*(lpS + 1) != '\0') {
  358.                         if (*(lpS + 2) != '\0') {
  359.                             unsigned char c1, c2;
  360.  
  361.                             c1 = *(lpS + 1);
  362.                             c2 = *(lpS + 2);
  363.  
  364.                             if ('0' <= c1 && c1 <= '9') {
  365.                                 c1 -= '0';
  366.                             } else if ('A' <= c1 && c1 <= 'F') {
  367.                                 c1 -= 'A' - 10;
  368.                             } else if ('a' <= c1 && c1 <= 'f') {
  369.                                 c1 -= 'a' - 10;
  370.                             } else {
  371.                                 c1 = 0;
  372.                             }
  373.                             if ('0' <= c2 && c2 <= '9') {
  374.                                 c2 -= '0';
  375.                             } else if ('A' <= c2 && c2 <= 'F') {
  376.                                 c2 -= 'A' - 10;
  377.                             } else if ('a' <= c2 && c2 <= 'f') {
  378.                                 c2 -= 'a' - 10;
  379.                             } else {
  380.                                 c2 = 0;
  381.                             }
  382.  
  383.                             *(lpOut + nOut) = c1 * 0x10 + c2; nOut++;
  384.                             lpS += 2;
  385.                             break;
  386.                         }
  387.                     }
  388.                     *(lpOut + nOut) = 'x'; nOut++;
  389.                     break;
  390.                 case '\\':
  391.                     *(lpOut + nOut) = '\\'; nOut++;
  392.                     break;
  393.                 case '?':
  394.                     *(lpOut + nOut) = '\?'; nOut++;
  395.                     break;
  396.                 case '\'':
  397.                     *(lpOut + nOut) = '\''; nOut++;
  398.                     break;
  399.                 case '\"':
  400.                     *(lpOut + nOut) = '\"'; nOut++;
  401.                     break;
  402.                 default:
  403.                     *(lpOut + nOut) = *lpS; nOut++;
  404.                     break;
  405.             }
  406.         } else {
  407.  
  408.             /* 一般文字 */
  409.  
  410.             *(lpOut + nOut) = *lpS; nOut++;
  411.         }
  412.     }
  413.     *(lpOut + nOut) = '\0';
  414.  
  415.     cwsFputs(lpOut, NULL);
  416.  
  417.     GlobalFreePtr(lpOut);
  418.  
  419.     return 0;
  420. }
  421.  
  422. #if defined(WIN32)
  423. #define _huge
  424. #endif
  425.  
  426. int clipCmd(int argc, char **argv)
  427. {
  428.     char szBuf[256];
  429.     HGLOBAL hClip;
  430.     HGLOBAL hClipNew;
  431.     char _huge *lpClipNew;
  432.     DWORD dwSize;
  433.     DWORD dwSizeNew;
  434.  
  435.     dwSize = 0;
  436.     hClip = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, 1);
  437.  
  438.     while (cwsFgets(szBuf, 256, NULL) != NULL) {
  439.         dwSizeNew = dwSize + lstrlen(szBuf);
  440.         hClipNew = GlobalReAlloc(hClip, dwSizeNew + 1,
  441.                                  GMEM_MOVEABLE | GMEM_ZEROINIT);
  442.         lpClipNew = GlobalLock(hClipNew);
  443.         if (lpClipNew == NULL) {
  444.             break;
  445.         }
  446.         hmemcpy(lpClipNew + dwSize, szBuf, dwSizeNew - dwSize);
  447.         GlobalUnlock(hClipNew);
  448.         dwSize = dwSizeNew;
  449.         hClip = hClipNew;
  450.     }
  451.     OpenClipboard(NULL);
  452.     EmptyClipboard();
  453.     SetClipboardData(CF_TEXT, hClip);
  454.     CloseClipboard();
  455.  
  456.     return 0;
  457. }
  458.  
  459. int pasteCmd(int argc, char **argv)
  460. {
  461.     HGLOBAL hClip;
  462.     HGLOBAL hMem;
  463.     char _huge *lpClip;
  464.     char _huge *lpMem;
  465.     DWORD dwSize;
  466.  
  467.     OpenClipboard(NULL);
  468.     hClip = GetClipboardData(CF_TEXT);
  469.     lpClip = GlobalLock(hClip);
  470.     if (lpClip == NULL) {
  471.         CloseClipboard();
  472.         cwsFputs("can't find CF_TEXT\n", (LPSTR)-1);
  473.         return -1;
  474.     }
  475.     dwSize = lstrlen(lpClip);
  476.     hMem = GlobalAlloc(GHND, dwSize + 1);
  477.     lpMem = GlobalLock(hMem);
  478.     if (lpMem == NULL) {
  479.         CloseClipboard();
  480.         cwsFputs("can't alloc Memory\n", (LPSTR)-1);
  481.         return -1;
  482.     }
  483.     hmemcpy(lpMem, lpClip, dwSize);
  484.  
  485.     GlobalUnlock(hClip);
  486.     CloseClipboard();
  487.  
  488.     cwsFputs(lpMem, NULL);
  489.     GlobalUnlock(hMem);
  490.     GlobalFree(hMem);
  491.  
  492.     return 0;
  493. }
  494.  
  495. int verCmd(int argc, char **argv)
  496. {
  497.     cwsPuts("Sample3 for ComWin Ver. 3.71 "
  498.             "Copyright (c) 1994-97 by M.Maedera(JPN)");
  499.     return 0;
  500. }
  501.  
  502. /****************************************************
  503.     CallInterpreter Sample (UNIX ライクな語句解釈)
  504.  
  505.     この機能を用いるためには comwin.ini の [InterpreterDll] セクションに
  506.     sample3.dll=SampleInterpreter を先頭に書き込む。
  507.  
  508.  **********************************************************
  509.  */
  510. BOOL FAR PASCAL SampleInterpreter(FARPROC FAR *lpfnIO,
  511.                                   LPSTR lpszCmdLine,
  512.                                   LPLONG lpReturn)
  513. {
  514.     static HGLOBAL hGlobal = NULL;
  515.     LPSTR lpGlobal;
  516.     int nLen;
  517.  
  518.     /* 特別処理、確保した領域があれば解放する。*/
  519.     if (lpReturn[0] == 0) {
  520.         if (lpszCmdLine[0] == '\0') {
  521.             if (hGlobal != NULL) {
  522.                 GlobalUnlock(hGlobal);
  523.                 GlobalFree(hGlobal);
  524.                 return TRUE;
  525.             }
  526.         }
  527.         return FALSE;
  528.     }
  529.  
  530.     /* 通常処理のチェック */
  531.     if (lpReturn[0] != -1) {
  532.         return FALSE;
  533.     }
  534.  
  535.     /* 入出力部を実体化する */
  536.     cwsPuts = (PUTS)lpfnIO[0];
  537.     cwsGets = (GETS)lpfnIO[1];
  538.     cwsFputs = (FPUTS)lpfnIO[2];
  539.     cwsFgets = (FGETS)lpfnIO[3];
  540.     cwsSystem = (SYSTEM)lpfnIO[4];
  541.  
  542.     /* 通常処理、lpReturn[0] に分解したコマンド群を返す。*/
  543.     /* 形式は "str1\0str2\0str3\0str4\0\0" に準ずる */
  544.     nLen = lstrlen(lpszCmdLine);
  545.     hGlobal = GlobalAlloc(GHND, nLen + 5); /* lpszCmdLine + "\0fg\0\0" */
  546.     if (hGlobal == NULL) {
  547.         return FALSE;
  548.     }
  549.     lpGlobal = GlobalLock(hGlobal);
  550.  
  551.     lstrcpy(lpGlobal, lpszCmdLine);
  552.     if (nLen > 0 && lpGlobal[nLen - 1] == '&') {
  553.         lpGlobal[nLen - 1] = '\0';
  554.     } else {
  555.         lstrcpy(&lpGlobal[nLen+1], "fg");
  556.     }
  557.     lpReturn[0] = (LONG)lpGlobal;
  558.     return TRUE;
  559. }
  560.  
  561. /*-----------------------------------------------------------------
  562.     CallScript Sample (拡張子 DOC のファイルをメモ帳に関連づける)
  563.  
  564.     この機能を用いるためには comwin.ini の [ScriptDll] セクションに
  565.     sample3.dll=SampleScript を先頭に書き込む。
  566.  
  567.  *------------------------------------------------------------------
  568.  */
  569. BOOL FAR PASCAL SampleScript(FARPROC FAR *lpfnIO,
  570.                              LPSTR lpszCmdLine,
  571.                              LPLONG lpReturn)
  572. {
  573.     static char szExt[]= "doc\0c\0h\0asm\0\0"; /* NULL文字を２つ続ける */
  574.                        /* 形式は "str1\0str2\0str3\0str4\0\0" */
  575.     static char szCommand[256];
  576.  
  577.     /* 特別処理、lpReturn[0] に拡張子へのポインタを返す。*/
  578.     if (lpReturn[0] == 0) {
  579.         if (lpszCmdLine[0] == '\0') {
  580.             lpReturn[0] = (LONG)(LPSTR)szExt;
  581.             return TRUE;
  582.         }
  583.         return FALSE;
  584.     }
  585.  
  586.     /* 通常処理のチェック */
  587.     if (lpReturn[0] != -1) {
  588.         return FALSE;
  589.     }
  590.  
  591.     /* 入出力部を実体化する */
  592.     cwsPuts = (PUTS)lpfnIO[0];
  593.     cwsGets = (GETS)lpfnIO[1];
  594.     cwsFputs = (FPUTS)lpfnIO[2];
  595.     cwsFgets = (FGETS)lpfnIO[3];
  596.     cwsSystem = (SYSTEM)lpfnIO[4];
  597.  
  598.     /* 通常処理 */
  599.     lstrcpy(szCommand, "notepad");
  600.     lstrcat(szCommand, " ");
  601.     lstrcat(szCommand, lpszCmdLine);
  602.  
  603.     cwsSystem(szCommand);
  604.     return TRUE;
  605. }
  606.