home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / fed0217s.zip / source / rx.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-08-01  |  34.5 KB  |  1,174 lines
  1. /*
  2. ** Module   :RX.CPP
  3. ** Abstract :
  4. **
  5. ** Copyright (C) Sergey I. Yevtushenko
  6. **
  7. ** Log: Fri  10/04/1998 Created
  8. **
  9. */
  10.  
  11. #include <string.h>
  12.  
  13. #include <boxcoll.h>
  14. #include <stddlg.h>
  15. #include <keynames.h>
  16. #include <fio.h>
  17. #include <varpool.h>
  18.  
  19. #define INCL_REXXSAA
  20. #define INCL_DOS
  21.  
  22. #ifdef __EMX__
  23. extern "C" {
  24. #include <os2emx.h>
  25. }
  26. #else
  27. #include <rexxsaa.h>
  28. #endif
  29.  
  30. /*************************************************************
  31. ** Data Types
  32. */
  33.  
  34. typedef struct
  35. {
  36.     char *pszName;
  37.     char internalFunc;
  38.     PFN pfnFunc;
  39. } FuncListItem;
  40.  
  41. /*************************************************************
  42. ** Function Prototypes
  43. */
  44.  
  45. ULONG APIENTRY fedNoparm  (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  46. ULONG APIENTRY fedGet     (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  47. ULONG APIENTRY fedSet     (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  48. ULONG APIENTRY fedFind    (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  49. ULONG APIENTRY fedInsChar (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  50. ULONG APIENTRY fedGetChar (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  51. ULONG APIENTRY fedOpen    (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  52. ULONG APIENTRY fedJumpList(PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  53. ULONG APIENTRY fedMsgBox  (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  54.  
  55. ULONG APIENTRY fedVarSet  (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  56. ULONG APIENTRY fedVarGet  (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  57. ULONG APIENTRY fedVarDrop (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  58.  
  59. ULONG APIENTRY fedInput   (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  60. ULONG APIENTRY fedGetClip (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  61. ULONG APIENTRY fedSetClip (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  62.  
  63. ULONG APIENTRY fedBind    (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  64. ULONG APIENTRY fedMenu    (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  65. ULONG APIENTRY fedSendKey (PSZ, ULONG, PRXSTRING, PSZ, PRXSTRING);
  66.  
  67. int makeRC   (PRXSTRING, LONG );
  68. int makeRCstr(PRXSTRING, char*);
  69. int makeRCstr(PRXSTRING, int  );
  70.  
  71. ULONG ULfromParm(PRXSTRING rxArg);
  72. ULONG ULfromSTR(char *str);
  73.  
  74. APIRET GetRexxVariable(char* name, char* value, LONG len);
  75. static char* mk_var(char *buff, char *beg, int num, char *end, int mode);
  76.  
  77. static VarPool RexxVars;
  78.  
  79. /*************************************************************
  80. ** Static Data
  81. */
  82.  
  83. extern EditBoxCollection Editor;
  84. extern JumpList JList[];
  85.  
  86.  
  87. FuncListItem FunctionList[]=
  88. {
  89.     { "fedAbort",            FUNC_ABORT             , (PFN)fedNoparm },
  90.     { "fedBksp",             FUNC_BKSP              , (PFN)fedNoparm },
  91.     { "fedClose",            FUNC_CLOSE             , (PFN)fedNoparm },
  92.     { "fedCopy",             FUNC_COPY              , (PFN)fedNoparm },
  93.     { "fedCopyright",        FUNC_COPYRIGHT2        , (PFN)fedNoparm },
  94.     { "fedCut",              FUNC_CUT               , (PFN)fedNoparm },
  95.     { "fedDel",              FUNC_DEL               , (PFN)fedNoparm },
  96.     { "fedDelline",          FUNC_DELLINE           , (PFN)fedNoparm },
  97.     { "fedDeltoeol",         FUNC_DELTOEOL          , (PFN)fedNoparm },
  98.     { "fedDelwordleft",      FUNC_DELWORDLEFT       , (PFN)fedNoparm },
  99.     { "fedDelwordright",     FUNC_DELWORDRIGHT      , (PFN)fedNoparm },
  100.     { "fedDown",             FUNC_DOWN              , (PFN)fedNoparm },
  101.     { "fedDownmark",         FUNC_DOWNMARK          , (PFN)fedNoparm },
  102.     { "fedDupLine",          FUNC_DUPLICATE_LINE    , (PFN)fedNoparm },
  103.     { "fedEnd",              FUNC_END               , (PFN)fedNoparm },
  104.     { "fedEndmark",          FUNC_ENDMARK           , (PFN)fedNoparm },
  105.     { "fedExit",             FUNC_EXIT              , (PFN)fedNoparm },
  106.     { "fedFilebegin",        FUNC_FILEBEGIN         , (PFN)fedNoparm },
  107.     { "fedFilebeginmark",    FUNC_FILEBEGINMARK     , (PFN)fedNoparm },
  108.     { "fedFileend",          FUNC_FILEEND           , (PFN)fedNoparm },
  109.     { "fedFileendmark",      FUNC_FILEENDMARK       , (PFN)fedNoparm },
  110.     { "fedFilelist",         FUNC_FILELIST          , (PFN)fedNoparm },
  111.     { "fedFillJumpList",     0                      , (PFN)fedJumpList},
  112.     { "fedFlipautoindent",   FUNC_FLIPAUTOINDENT    , (PFN)fedNoparm },
  113.     { "fedFlipblockmode",    FUNC_FLIPBLOCKMODE     , (PFN)fedNoparm },
  114.     { "fedFliphiliting",     FUNC_FLIPHILITING      , (PFN)fedNoparm },
  115.     { "fedHelpscreen",       FUNC_HELPSCREEN        , (PFN)fedNoparm },
  116.     { "fedHome",             FUNC_HOME              , (PFN)fedNoparm },
  117.     { "fedHomemark",         FUNC_HOMEMARK          , (PFN)fedNoparm },
  118.     { "fedIndent",           FUNC_INDENT            , (PFN)fedNoparm },
  119.     { "fedIns",              FUNC_INS               , (PFN)fedNoparm },
  120.     { "fedInsdate",          FUNC_INSDATE           , (PFN)fedNoparm },
  121.     { "fedInsfilename",      FUNC_INSFILENAME       , (PFN)fedNoparm },
  122.     { "fedInsfilenameshort", FUNC_INSFILENAMESHORT  , (PFN)fedNoparm },
  123.     { "fedJumpcol",          FUNC_JUMPCOL           , (PFN)fedNoparm },
  124.     { "fedJumpline",         FUNC_JUMPLINE          , (PFN)fedNoparm },
  125.     { "fedLeft",             FUNC_LEFT              , (PFN)fedNoparm },
  126.     { "fedLeftmark",         FUNC_LEFTMARK          , (PFN)fedNoparm },
  127.     { "fedLoad",             FUNC_LOAD              , (PFN)fedNoparm },
  128.     { "fedLower",            FUNC_LOWER             , (PFN)fedNoparm },
  129.     { "fedMacrorecend",      FUNC_MACRORECEND       , (PFN)fedNoparm },
  130.     { "fedMacrorecstart",    FUNC_MACRORECSTART     , (PFN)fedNoparm },
  131.     { "fedMatchbracket",     FUNC_MATCHBRACKET      , (PFN)fedNoparm },
  132.     { "fedMatchbracketmark", FUNC_MATCHBRACKETMARK  , (PFN)fedNoparm },
  133.     { "fedMsgBox",           0                      , (PFN)fedMsgBox },
  134.     { "fedMenu",             0                      , (PFN)fedMenu   },
  135.     { "fedNew",              FUNC_NEW               , (PFN)fedNoparm },
  136.     { "fedNextfile",         FUNC_NEXTFILE          , (PFN)fedNoparm },
  137.     { "fedOpenJumpList",     0                      , (PFN)fedJumpList},
  138.     { "fedOpenFile",         0                      , (PFN)fedOpen   },
  139.     { "fedPaste",            FUNC_PASTE             , (PFN)fedNoparm },
  140.     { "fedPgdn",             FUNC_PGDN              , (PFN)fedNoparm },
  141.     { "fedPgdnmark",         FUNC_PGDNMARK          , (PFN)fedNoparm },
  142.     { "fedPgup",             FUNC_PGUP              , (PFN)fedNoparm },
  143.     { "fedPgupmark",         FUNC_PGUPMARK          , (PFN)fedNoparm },
  144.     { "fedPrevfile",         FUNC_PREVFILE          , (PFN)fedNoparm },
  145.     { "fedRight",            FUNC_RIGHT             , (PFN)fedNoparm },
  146.     { "fedRightmark",        FUNC_RIGHTMARK         , (PFN)fedNoparm },
  147.     { "fedSave",             FUNC_SAVE              , (PFN)fedNoparm },
  148.     { "fedSaveall",          FUNC_SAVEALL           , (PFN)fedNoparm },
  149.     { "fedSaveas",           FUNC_SAVEAS            , (PFN)fedNoparm },
  150.     { "fedSearch",           FUNC_SEARCH            , (PFN)fedNoparm },
  151.     { "fedSearchAgain",      FUNC_SEARCHAGAIN       , (PFN)fedNoparm },
  152.     { "fedSort",             FUNC_SORT              , (PFN)fedNoparm },
  153.     { "fedUndo",             FUNC_UNDO              , (PFN)fedNoparm },
  154.     { "fedUnindent",         FUNC_UNINDENT          , (PFN)fedNoparm },
  155.     { "fedUp",               FUNC_UP                , (PFN)fedNoparm },
  156.     { "fedUpmark",           FUNC_UPMARK            , (PFN)fedNoparm },
  157.     { "fedUpper",            FUNC_UPPER             , (PFN)fedNoparm },
  158.     { "fedWordleft",         FUNC_WORDLEFT          , (PFN)fedNoparm },
  159.     { "fedWordleftmark",     FUNC_WORDLEFTMARK      , (PFN)fedNoparm },
  160.     { "fedWordright",        FUNC_WORDRIGHT         , (PFN)fedNoparm },
  161.     { "fedWordrightmark",    FUNC_WORDRIGHTMARK     , (PFN)fedNoparm },
  162.     { "fedInsChar",          0                      , (PFN)fedInsChar},
  163.     { "fedGetChar",          0                      , (PFN)fedGetChar},
  164.     { "fedSet",              0                      , (PFN)fedSet    },
  165.     { "fedGet",              0                      , (PFN)fedGet    },
  166.     { "fedFind",             0                      , (PFN)fedFind   },
  167.     { "fedVarSet",           0                      , (PFN)fedVarSet },
  168.     { "fedVarGet",           0                      , (PFN)fedVarGet },
  169.     { "fedVarDrop",          0                      , (PFN)fedVarDrop},
  170.     { "fedInput",            0                      , (PFN)fedInput  },
  171.     { "fedGetClip",          0                      , (PFN)fedGetClip},
  172.     { "fedSetClip",          0                      , (PFN)fedSetClip},
  173.     { "fedBind"   ,          0                      , (PFN)fedBind   },
  174.     { "fedSendKey",          0                      , (PFN)fedSendKey},
  175.     { 0, 0, 0}
  176.  
  177. };
  178.  
  179. Dictionary *pFuncs = 0;
  180.  
  181. void InitREXX(void)
  182. {
  183.     if(!pFuncs)
  184.     {
  185.         int i;
  186.         pFuncs = new Dictionary(0,0,0);
  187.  
  188.         for(i = 0; FunctionList[i].pszName; i++)
  189.         {
  190.             pFuncs->Add(&FunctionList[i]);
  191.             RexxRegisterFunctionExe(FunctionList[i].pszName,
  192. #ifdef __EMX__
  193.                                     (RexxFunctionHandler*)FunctionList[i].pfnFunc);
  194. #else
  195.                                     FunctionList[i].pfnFunc);
  196. #endif
  197.         }
  198.     }
  199. }
  200.  
  201. //-----------------------------------------------------------------------
  202. // REXX API
  203. //-----------------------------------------------------------------------
  204.  
  205. ULONG APIENTRY fedInput(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  206. {
  207.     char *hdr = 0;
  208.     char *res = 0;
  209.     int r = 5;
  210.     int c = 5;
  211.     int rc;
  212.  
  213.     if(lCnt > 3)
  214.         return 40;
  215.  
  216.     if(lCnt > 0)
  217.         hdr = (char*)rxArgv[0].strptr;
  218.  
  219.     if(lCnt > 1)
  220.         r = ULfromParm(&rxArgv[1]);
  221.  
  222.     if(lCnt > 2)
  223.         c = ULfromParm(&rxArgv[2]);
  224.  
  225.     rc = AskString(r, c, &res, hdr);
  226.  
  227.     if(!rc)
  228.     {
  229.         int Len = strlen(res);
  230.  
  231.         makeRCstr(prxRC, Len + 1);
  232.  
  233.         strcpy((char*)prxRC->strptr, res);
  234.         prxRC->strlength = Len;
  235.  
  236.         delete res;
  237.         return 0;
  238.     }
  239.  
  240.     prxRC->strlength = 0;
  241.     return 0;
  242. }
  243.  
  244. ULONG APIENTRY fedGetClip(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  245. {
  246.     if(lCnt)
  247.         return 40;
  248.  
  249.     if(!Clipboard)
  250.     {
  251.         prxRC->strlength = 0;
  252.         return 0;
  253.     }
  254.  
  255.     Clipboard->from_pm();
  256.  
  257.     char *res = Clipboard->as_text();
  258.  
  259.     prxRC->strlength = strlen(res);
  260.     prxRC->strptr    = (PCH)res;
  261.  
  262.     return 0;
  263. }
  264.  
  265. ULONG APIENTRY fedSetClip(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  266. {
  267.     if(lCnt != 1 || !rxArgv[0].strptr)
  268.         return 40;
  269.  
  270.     if(!Clipboard)
  271.         return 0;
  272.  
  273.     Clipboard->from_text((char*)rxArgv[0].strptr);
  274.     Clipboard->to_pm();
  275.  
  276.     return 0;
  277. }
  278.  
  279. ULONG APIENTRY fedSendKey(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  280. {
  281.     if(lCnt != 1 || !rxArgv[0].strlength || !rxArgv[0].strptr)
  282.         return 40;
  283.  
  284.     Editor.SendKey(rxArgv[0].strptr);
  285.  
  286.     prxRC->strlength = 0;
  287.     return 0;
  288. }
  289.  
  290. ULONG APIENTRY fedBind(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  291. {
  292.     if(lCnt)
  293.     {
  294.         if(!rxArgv[0].strptr || !rxArgv[0].strlength)
  295.             return 40;
  296.  
  297.         char *file = _ld_file((char*)rxArgv[0].strptr);
  298.  
  299.         if(file)
  300.             Editor.load_profile(file);
  301.  
  302.         _fr_file(file);
  303.     }
  304.     else
  305.         Editor.doLoadProfile();
  306.  
  307.     prxRC->strlength = 0;
  308.     return 0;
  309. }
  310.  
  311. ULONG APIENTRY fedVarSet(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  312. {
  313.     if(lCnt < 1 || lCnt > 2)
  314.         return 40;
  315.  
  316.     if(lCnt == 1)
  317.         RexxVars.del((char*)rxArgv[0].strptr);
  318.     else
  319.         RexxVars.set((char*)rxArgv[0].strptr, (char*)rxArgv[1].strptr);
  320.  
  321.     prxRC->strlength = 0;
  322.     return 0;
  323. }
  324.  
  325. ULONG APIENTRY fedVarGet(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  326. {
  327.     if(lCnt < 1 || lCnt > 2)
  328.         return 40;
  329.  
  330.     char *var = RexxVars.get((char*)rxArgv[0].strptr);
  331.  
  332.     if(var)
  333.     {
  334.         int mLen = strlen(var);
  335.         if(mLen > prxRC->strlength)
  336.         {
  337.             if (DosAllocMem((PPVOID)&prxRC->strptr, mLen, PAG_COMMIT | PAG_WRITE))
  338.             {
  339.                 prxRC->strlength = 0;
  340.                 return 0;
  341.             }
  342.         }
  343.         strcpy((char*)prxRC->strptr, var);
  344.     }
  345.     else
  346.         if(lCnt == 1)
  347.             strcpy((char*)prxRC->strptr, strupr((char*)rxArgv[0].strptr));
  348.         else
  349.             if(lCnt == 2)
  350.                 strcpy((char*)prxRC->strptr, (char*)rxArgv[1].strptr);
  351.  
  352.     prxRC->strlength = strlen((char*)prxRC->strptr);
  353.     return 0;
  354. }
  355.  
  356. ULONG APIENTRY fedVarDrop(PSZ pName, ULONG lCnt, PRXSTRING rxArgv, PSZ, PRXSTRING prxRC)
  357. {
  358.     if(lCnt != 1)
  359.         return 40;
  360.  
  361.     RexxVars.drop((char*)rxArgv[0].strptr);
  362.  
  363.     prxRC->strlength = 0;
  364.     return 0;
  365. }
  366.  
  367. //---------------------------
  368. // fedOpen: open file with given name.
  369. ULONG APIENTRY fedOpen(PSZ,
  370.                        ULONG lCnt,
  371.                        PRXSTRING rxArgv,
  372.                        PSZ,
  373.                        PRXSTRING prxRC)
  374. {
  375.     if(lCnt > 1)
  376.         return makeRC(prxRC, -1);
  377.  
  378.     if(!lCnt || !rxArgv[0].strptr || !rxArgv[0].strlength ||
  379.        strchr((char*)rxArgv[0].strptr, '?') ||
  380.        strchr((char*)rxArgv[0].strptr, '*'))
  381.     {
  382.         Editor.open();
  383.         return makeRC(prxRC, 1);
  384.     }
  385.     else
  386.         Editor.doOpenFile((char*)rxArgv[0].strptr);
  387.  
  388.     return makeRC(prxRC, 0);
  389. }
  390.  
  391. ULONG APIENTRY fedMsgBox(PSZ,
  392.                          ULONG lCnt,
  393.                          PRXSTRING rxArgv,
  394.                          PSZ,
  395.                          PRXSTRING prxRC)
  396. {
  397.     if(lCnt < 1 || lCnt > 2 || !rxArgv[0].strptr || !rxArgv[0].strlength)
  398.         return makeRC(prxRC, -1);
  399.  
  400.     int timeout = 0;
  401.  
  402.     if(lCnt > 1)
  403.         timeout = ULfromParm(&rxArgv[1]);
  404.  
  405.     MessageBox((char*)rxArgv[0].strptr, 0, timeout);
  406.  
  407.     return makeRC(prxRC, 0);
  408. }
  409.  
  410. //---------------------------
  411. // fedNoparm: rexx API for calls without parameters
  412.  
  413. ULONG APIENTRY fedNoparm(PSZ pName,
  414.                          ULONG lCnt,
  415.                          PRXSTRING,
  416.                          PSZ,
  417.                          PRXSTRING prxRC)
  418. {
  419.     if(lCnt != 0) //No arguments should be given
  420.         return makeRC(prxRC, -1);
  421.  
  422.     FuncListItem* pItem = (FuncListItem*)pFuncs->IsIn((char*)pName,0);
  423.  
  424.     if(pItem && pItem->internalFunc)
  425.     {
  426.         char macro[3];
  427.         macro[0] = FUNC_ESCAPE;
  428.         macro[1] = pItem->internalFunc;
  429.         macro[2] = 0;
  430.         Editor.play_macro(macro);
  431.     }
  432.  
  433.     return makeRC(prxRC, 0);
  434. }
  435.  
  436. ULONG APIENTRY fedInsChar(PSZ,
  437.                           ULONG lCnt,
  438.                           PRXSTRING rxArgv,
  439.                           PSZ,
  440.                           PRXSTRING prxRC)
  441. {
  442.     if(lCnt != 1) //One argument should be given
  443.         return makeRC(prxRC, -1);
  444.  
  445.     Editor.play_macro((char*)rxArgv[0].strptr);
  446.     return makeRC(prxRC, 0);
  447. }
  448.  
  449. ULONG APIENTRY fedGetChar(PSZ,
  450.                           ULONG lCnt,
  451.                           PRXSTRING rxArgv,
  452.                           PSZ,
  453.                           PRXSTRING prxRC)
  454. {
  455.     //If no arguments given,
  456.     //return current string
  457.     //With one argument, return full string
  458.     //With two arguments, return rest of string from given pos
  459.     //With three arguments, return part of string from given pos;
  460.  
  461.     int Row = Editor.current()->abs_row();
  462.     int Col = 0;
  463.     int Len = -1;
  464.  
  465.     switch(lCnt)
  466.     {
  467.         case 3:
  468.             if(rxArgv[2].strlength != 0) //Length
  469.             {
  470.                 Len = ULfromParm(&rxArgv[2]);
  471.  
  472.                 if(Len == 0)
  473.                     return makeRC(prxRC, -1);
  474.             }
  475.  
  476.         case 2:
  477.  
  478.             if(rxArgv[1].strlength != 0) //Col
  479.             {
  480.                 Col = ULfromParm(&rxArgv[1]);
  481.  
  482.                 if(Col == 0)
  483.                     return makeRC(prxRC, -2);
  484.  
  485.                 Col--;
  486.  
  487.                 if(Len < 0)
  488.                     Len = -2;
  489.             }
  490.  
  491.         case 1:
  492.  
  493.             if(rxArgv[0].strlength != 0) //Row
  494.             {
  495.                 Row = ULfromParm(&rxArgv[0]);
  496.  
  497.                 if(Row == 0)
  498.                     return makeRC(prxRC, -3);
  499.             }
  500.  
  501.             Row--;
  502.  
  503.         case 0:
  504.  
  505.             /*
  506.             prxRC->strlength = (Editor.current()->get_cur_char()) ? 1:0;
  507.             prxRC->strptr[0] = (char)Editor.current()->get_cur_char();
  508.             prxRC->strptr[1] = '\0';
  509.             break;
  510.             */
  511.  
  512.             if(Editor.current()->Count() < Row)
  513.                 return makeRC(prxRC, -1);
  514.  
  515.             if(Len == -2)
  516.                 Len = Editor.current()->line(Row)->len() - Col;
  517.  
  518.             if(Len == -1)
  519.                 Len = Editor.current()->line(Row)->len();
  520.  
  521.             makeRCstr(prxRC, Len);
  522.  
  523.             Editor.current()->line(Row)->get_print(Col,
  524.                                                    (char*)prxRC->strptr,
  525.                                                    Len);
  526.             prxRC->strlength = Len;
  527.             break;
  528.  
  529.         default:
  530.             return makeRC(prxRC, -4);
  531.     }
  532.  
  533.     return 0;
  534. }
  535.  
  536.  
  537. ULONG APIENTRY fedGet(PSZ,
  538.                       ULONG lCnt,
  539.                       PRXSTRING rxArgv,
  540.                       PSZ,
  541.                       PRXSTRING prxRC)
  542. {
  543.     if(lCnt != 1 || rxArgv[0].strlength < 1)
  544.         return makeRC(prxRC, -1);
  545.  
  546.     //Supported values:
  547.     //  Ins    - Insert mode
  548.     //  Hi     - Hiliting mode
  549.     //  Auto   - Autoindent state
  550.     //  Mark   - Marking state
  551.     //  Row    - Current absolute Row
  552.     //  Col    - Current absolute Col
  553.     //   CH      - Changed status
  554.     //   CR      - Cursor Row
  555.     //   CC      - Cursor Col
  556.     //  CP     - Code Page
  557.     //  Buffer - Current buffer handle
  558.     //  BR     - Marking position start row
  559.     //  BC     - Marking position start col
  560.     //  ? BufferCount - Number of buffers
  561.     //  Name   - Current buffer name
  562.     //  XSize  - Rect size X (Cols)
  563.     //  YSize  - Rect size Y (Rows)
  564.     //  Last   - Last row number
  565.     //  Dir    - Startup dir
  566.     //  WW     - WordWrap Width
  567.     //  WS     - WordWrap Status
  568.     //  WM     - WordWrap Merge
  569.     //  WP     - WordWrap Para
  570.  
  571.     switch(__to_upper(rxArgv[0].strptr[0]))
  572.     {
  573.         case 'I': return makeRC(prxRC, Editor.current()->get_ins_mode());
  574.         case 'H': return makeRC(prxRC, Editor.current()->get_hiliting()   );
  575.         case 'A': return makeRC(prxRC, Editor.current()->get_auto_indent());
  576.         case 'M': return makeRC(prxRC, Editor.current()->get_mark_state() );
  577.         case 'R': return makeRC(prxRC, Editor.current()->get_edit_row()   );
  578.         case '?': return makeRC(prxRC, (ULONG)Editor.Count());
  579.         case 'X': return makeRC(prxRC, Editor.current()->cols );
  580.         case 'Y': return makeRC(prxRC, Editor.current()->rows );
  581.         //String return
  582.         case 'N': return makeRCstr(prxRC, Editor.current()->get_name());
  583.         case 'D': return makeRCstr(prxRC, StartupDir);
  584.  
  585.         case 'B':
  586.             if(rxArgv[0].strlength < 2)
  587.                 return makeRC(prxRC, (ULONG)Editor.current());
  588.  
  589.             switch(__to_upper(rxArgv[0].strptr[1]))
  590.             {
  591.                 case 'R':
  592.                     if(!Editor.current()->get_mark_state())
  593.                         return makeRC(prxRC, Editor.current()->get_edit_row());
  594.  
  595.                     return makeRC(prxRC, Editor.current()->get_edit_row_2());
  596.  
  597.                 case 'C':
  598.                     if(!Editor.current()->get_mark_state())
  599.                         return makeRC(prxRC, Editor.current()->get_edit_col());
  600.  
  601.                     return makeRC(prxRC, Editor.current()->get_edit_col_2());
  602.             }
  603.             break;
  604.  
  605.         //Possible other cases
  606.         case 'C':
  607.             if(rxArgv[0].strlength < 2)
  608.                 return makeRC(prxRC, Editor.current()->get_edit_col());
  609.  
  610.             switch(__to_upper(rxArgv[0].strptr[1]))
  611.             {
  612.                 case 'H': return makeRC(prxRC, Editor.current()->get_changed());
  613.                 case 'R': return makeRC(prxRC, Editor.current()->get_cur_row());
  614.                 case 'C': return makeRC(prxRC, Editor.current()->get_cur_col());
  615.                 case 'P': return makeRCstr(prxRC, Editor.current()->get_cur_cp());
  616.             }
  617.             break;
  618.  
  619.         case 'W':
  620.             if(rxArgv[0].strlength != 2)
  621.                 break;
  622.  
  623.             switch(__to_upper(rxArgv[0].strptr[1]))
  624.             {
  625.                 case 'W': return makeRC(prxRC, Editor.current()->ww_get_width());
  626.                 case 'S': return makeRC(prxRC, (Editor.current()->ww_get() & WW_STATE) ? 1:0);
  627.                 case 'M': return makeRC(prxRC, (Editor.current()->ww_get() & WW_MERGE) ? 1:0);
  628.                 case 'P': return makeRC(prxRC, (Editor.current()->ww_get() & WW_LONG ) ? 1:0);
  629.             }
  630.             break;
  631.  
  632.  
  633.         case 'L':
  634.             if(__to_upper(rxArgv[0].strptr[1]) == 'C')  //Last char
  635.                 return makeRCstr(prxRC, kiLastKey.KeyName);
  636.  
  637.             return makeRC(prxRC, Editor.current()->Count());
  638.  
  639.         default:
  640.             break;
  641.     }
  642.     return makeRC(prxRC, -2);
  643. }
  644.  
  645. ULONG APIENTRY fedSet(PSZ,
  646.                       ULONG lCnt,
  647.                       PRXSTRING rxArgv,
  648.                       PSZ,
  649.                       PRXSTRING prxRC)
  650.  
  651. {
  652.     if(lCnt < 1 || rxArgv[0].strlength < 1)
  653.         return makeRC(prxRC, -1);
  654.  
  655.     //Supported values:
  656.     //  Ins    - Insert mode               (flip)
  657.     //  Hi     - Hiliting mode             (flip)
  658.     //  Auto   - Autoindent state          (flip)
  659.     //  Mark   - Marking state             1 | 0
  660.     //  Row    - Current absolute Row
  661.     //  Col    - Current absolute Col
  662.     //  Page   - Codepage
  663.     //  Buffer - switch to buffer with handle
  664.     //  Name   - Current buffer name
  665.     //  WW     - WordWrap Width
  666.     //  WS     - WordWrap Status
  667.     //  WM     - WordWrap Merge
  668.     //  WP     - WordWrap Para
  669.  
  670.     switch(__to_upper(rxArgv[0].strptr[0]))
  671.     {
  672.         case 'I':
  673.                 if(lCnt == 2 && rxArgv[1].strlength == 1)
  674.                 {
  675.                     switch(rxArgv[1].strptr[0])
  676.                     {
  677.                         case '0':
  678.                         case '1':
  679.                             Editor.current()->set_ins_mode(rxArgv[1].strptr[0] - '0');
  680.                             return makeRC(prxRC, 0);
  681.  
  682.                         default:
  683.                             return makeRC(prxRC, -3);
  684.                     }
  685.                 }
  686.                 if(lCnt == 2)
  687.                     return makeRC(prxRC, -3);
  688.  
  689.                 Editor.current()->set_ins_mode(1 - Editor.current()->get_ins_mode());
  690.  
  691.                 return makeRC(prxRC, 0);
  692.  
  693.         case 'A':
  694.  
  695.                 if(lCnt == 2 && rxArgv[1].strlength == 1)
  696.                 {
  697.                     switch(rxArgv[1].strptr[0])
  698.                     {
  699.                         case '0':
  700.                         case '1':
  701.                             Editor.current()->set_auto_indent(rxArgv[1].strptr[0] - '0');
  702.                             return makeRC(prxRC, 0);
  703.  
  704.                         default:
  705.                             return makeRC(prxRC, -4);
  706.                     }
  707.                 }
  708.                 if(lCnt == 2)
  709.                     return makeRC(prxRC, -4);
  710.  
  711.                 Editor.current()->set_auto_indent(1 - Editor.current()->get_auto_indent());
  712.  
  713.                 return makeRC(prxRC, 0);
  714.  
  715.         case 'H':
  716.  
  717.                 if(lCnt == 2 && rxArgv[1].strlength == 1)
  718.                 {
  719.                     switch(rxArgv[1].strptr[0])
  720.                     {
  721.                         case '0': case '1': case '2': case '3': case '4':
  722.                         case '5': case '6': case '7': case '8': case '9':
  723.                             Editor.current()->set_hiliting(rxArgv[1].strptr[0] - '0');
  724.                             return makeRC(prxRC, 0);
  725.  
  726.                         default:
  727.                             return makeRC(prxRC, -5);
  728.                     }
  729.                 }
  730.                 if(lCnt == 2)
  731.                     return makeRC(prxRC, -5);
  732.  
  733.                 Editor.current()->flip_hiliting();
  734.  
  735.                 return makeRC(prxRC, 0);
  736.  
  737.  
  738.         //For listed below options, additional parameter is required
  739.         case 'M':
  740.  
  741.                 if(lCnt == 1)
  742.                 {
  743.                     Editor.current()->unmark();
  744.                     return makeRC(prxRC, 0);
  745.                 }
  746.  
  747.                 if(rxArgv[1].strlength == 1)
  748.                 {
  749.                     if(rxArgv[1].strptr[0] == '1')
  750.                     {
  751.                         Editor.current()->mark();
  752.                         return makeRC(prxRC, 0);
  753.                     }
  754.                     else
  755.                     {
  756.                         Editor.current()->unmark();
  757.                         return makeRC(prxRC, 0);
  758.                     }
  759.                 }
  760.                 return makeRC(prxRC, -6);
  761.  
  762.         case 'R':
  763.                 if(lCnt == 2 && rxArgv[1].strlength > 0)
  764.                 {
  765.                     ULONG ulData = ULfromParm(&rxArgv[1]);
  766.                     if(ulData)
  767.                     {
  768.                         Editor.current()->goto_line(*Editor.current(), ulData - 1);
  769.                         return makeRC(prxRC, 0);
  770.                     }
  771.                 }
  772.  
  773.                 return makeRC(prxRC, -7);
  774.  
  775.         case 'C':
  776.  
  777.                 if(lCnt == 2 && rxArgv[1].strlength > 0)
  778.                 {
  779.                     ULONG ulData = ULfromParm(&rxArgv[1]);
  780.                     if(ulData)
  781.                     {
  782.                         Editor.current()->goto_col(*Editor.current(), ulData - 1);
  783.                         return makeRC(prxRC, 0);
  784.                     }
  785.                 }
  786.  
  787.                 return makeRC(prxRC, -8);
  788.  
  789.         case 'B':
  790.                 if(lCnt == 2 && rxArgv[1].strlength > 0)
  791.                 {
  792.                     EditBox* new_box = (EditBox*)ULfromParm(&rxArgv[1]);
  793.                     if(new_box)
  794.                     {
  795.                         Editor.select(new_box);
  796.                         return makeRC(prxRC, 0);
  797.                     }
  798.                 }
  799.  
  800.                 return makeRC(prxRC, -9);
  801.  
  802.         case 'N':
  803.                 if(lCnt == 2 && rxArgv[1].strlength > 0)
  804.                     Editor.current()->set_name((char*)rxArgv[1].strptr);
  805.                 else
  806.                     return makeRC(prxRC, -10);
  807.  
  808.                 return makeRC(prxRC, 0);
  809.  
  810.         case 'P':
  811.                 if(lCnt == 2 && rxArgv[1].strlength > 0)
  812.                     Editor.current()->set_xlate((char*)rxArgv[1].strptr);
  813.                 else
  814.                     return makeRC(prxRC, -11);
  815.  
  816.                 return makeRC(prxRC, 0);
  817.  
  818.         case 'W':
  819.                 {
  820.                     if(rxArgv[0].strlength != 2 || lCnt != 2)
  821.                        break;
  822.  
  823.                     Buffer* p = Editor.current();
  824.                     int flags = p->ww_get();
  825.                     int fnew  = 0;
  826.                     int val   = ULfromParm(&rxArgv[1]);
  827.  
  828.                     switch(__to_upper(rxArgv[0].strptr[1]))
  829.                     {
  830.                         case 'W':
  831.                             p->ww_set_width(val);
  832.                             return makeRC(prxRC, 0);
  833.  
  834.                         case 'S': fnew = WW_STATE; break;
  835.                         case 'M': fnew = WW_MERGE; break;
  836.                         case 'P': fnew = WW_LONG ; break;
  837.                     }
  838.  
  839.                     if(val)
  840.                         flags |= fnew;
  841.                     else
  842.                         flags &= ~fnew;
  843.  
  844.                     p->ww_set(flags);
  845.  
  846.                     return makeRC(prxRC, 0);
  847.                 }
  848.                 break;
  849.     }
  850.  
  851.     return makeRC(prxRC, -2);
  852. }
  853.  
  854. ULONG APIENTRY fedFind(PSZ,
  855.                        ULONG lCnt,
  856.                        PRXSTRING rxArgv,
  857.                        PSZ,
  858.                        PRXSTRING prxRC)
  859. {
  860.     if(lCnt != 2)
  861.         return makeRC(prxRC, -1);
  862.  
  863.     int match_len = Editor.current()->search((char*)rxArgv[1].strptr,
  864.                                              (char*)rxArgv[0].strptr);
  865.  
  866.     return makeRC(prxRC, match_len);
  867. }
  868.  
  869. ULONG APIENTRY fedMenu(PSZ,
  870.                        ULONG lCnt,
  871.                        PRXSTRING rxArgv,
  872.                        PSZ,
  873.                        PRXSTRING prxRC)
  874. {
  875.     int r = 0;
  876.     int c = 0;
  877.  
  878.     if(lCnt < 3 ||
  879.        !rxArgv[0].strlength ||
  880.        !rxArgv[1].strlength ||
  881.        !rxArgv[2].strlength)
  882.     {
  883.         return makeRC(prxRC, -1);
  884.     }
  885.  
  886.     r = ULfromSTR(rxArgv[0].strptr);
  887.     c = ULfromSTR(rxArgv[1].strptr);
  888.  
  889.     int choice = -1;
  890.     int i;
  891.  
  892.     Dialog dlg(r, c, 1, 1);
  893.     Menu* menu = new Menu(1, 1, 0);
  894.  
  895.     for(i = 2; i < lCnt; i++)
  896.     {
  897.         if(rxArgv[i].strlength)
  898.             menu->add_menu(rxArgv[i].strptr);
  899.     }
  900.  
  901.     dlg.Ins(menu);
  902.     dlg.rows = menu->rows+2;
  903.     dlg.cols = menu->cols+2;
  904.  
  905.     KeyInfo k;
  906.     do
  907.     {
  908.         dlg.draw();
  909.         vio_read_key(&k);
  910.  
  911.         if((k.skey & 0x00FF) == kbEnter || (k.skey & 0x00FF) == kbGrEnter)
  912.         {
  913.             choice = menu->first_selected();
  914.             break;
  915.         }
  916.  
  917.         dlg.do_key(k);
  918.  
  919.         if(menu->selected_by_key())
  920.         {
  921.             choice = menu->first_selected();
  922.             break;
  923.         }
  924.     }
  925.     while(k.skey != (kbEsc | shIsCtrl));
  926.  
  927.     return makeRC(prxRC, choice + 1);
  928. }
  929.  
  930. ULONG APIENTRY fedJumpList(PSZ pName,
  931.                            ULONG lCnt,
  932.                            PRXSTRING rxArgv,
  933.                            PSZ,
  934.                            PRXSTRING prxRC)
  935. {
  936.     char varname[512];
  937.     char varvalue[512];
  938.     char header[512];
  939.     APIRET rc;
  940.     int len;
  941.     int i;
  942.     int list;
  943.  
  944.     if(lCnt < 1 || rxArgv[0].strlength == 0 || !rxArgv[0].strptr)
  945.         return makeRC(prxRC, -1);
  946.  
  947.     if(!strcmp((char*)pName, "FEDOPENJUMPLIST"))
  948.     {
  949.         if(lCnt < 1)
  950.             return makeRC(prxRC, -2);
  951.  
  952.         list = ULfromParm(&rxArgv[0]);
  953.  
  954.         if(list > 9)
  955.             return makeRC(prxRC, -3);
  956.  
  957.         int r  = 0;
  958.         int c  = 0;
  959.         int nr = 0;
  960.         int nc = 0;
  961.  
  962.         if(lCnt >= 2)
  963.             r = ULfromParm(&rxArgv[1]);
  964.         if(lCnt >= 3)
  965.             c = ULfromParm(&rxArgv[2]);
  966.         if(lCnt >= 4)
  967.             nr = ULfromParm(&rxArgv[3]);
  968.         if(lCnt >= 5)
  969.             nc = ULfromParm(&rxArgv[4]);
  970.  
  971.         return makeRC(prxRC, JumpListBox(&JList[list], r, c, nr, nc));
  972.     }
  973.  
  974.     if(lCnt != 2)
  975.         return makeRC(prxRC, -2);
  976.  
  977.     list = ULfromParm(&rxArgv[1]);
  978.  
  979.     if(list > 9)
  980.         return makeRC(prxRC, -3);
  981.  
  982.     JList[list].RemoveAll();
  983.  
  984.     rc = GetRexxVariable(mk_var(varname, (char*)rxArgv[0].strptr,0,"jump_len",0),
  985.                          varvalue, sizeof(varvalue)-1);
  986.  
  987.     if(rc)
  988.     {
  989.         //mk_var(varname,rxArgv[0].strptr,0,"jump_len not found", 0);
  990.         //MessageBox(varname, 0);
  991.         return makeRC(prxRC, -4);
  992.     }
  993.  
  994.     len = ULfromSTR(varvalue);
  995.  
  996.     if(!len)
  997.     {
  998.         return makeRC(prxRC, 0);
  999.     }
  1000.  
  1001.     for(i = 0; i < len; i++)
  1002.     {
  1003.         int row;
  1004.         int col;
  1005.         APIRET rc2 = 1;
  1006.  
  1007.         rc = GetRexxVariable(mk_var(varname,(char*)rxArgv[0].strptr, i, "jump_row", 1),
  1008.                              varvalue, sizeof(varvalue)-1);
  1009.  
  1010.         if(rc)
  1011.         {
  1012.             //mk_var(varname,rxArgv[0].strptr, i, "jump_row not found", 1);
  1013.             //MessageBox(varname, 0);
  1014.             return makeRC(prxRC, -5);
  1015.         }
  1016.  
  1017.         row = ULfromSTR(varvalue);
  1018.  
  1019.         rc = GetRexxVariable(mk_var(varname,(char*)rxArgv[0].strptr, i, "jump_col", 1),
  1020.                              varvalue, sizeof(varvalue)-1);
  1021.  
  1022.         if(rc)
  1023.         {
  1024.             //mk_var(varname,rxArgv[0].strptr, i, "jump_col not found", 1);
  1025.             //MessageBox(varname, 0);
  1026.             return makeRC(prxRC, -6);
  1027.         }
  1028.  
  1029.         col = ULfromSTR(varvalue);
  1030.  
  1031.         rc2 = GetRexxVariable(mk_var(varname,(char*)rxArgv[0].strptr, i, "jump_header", 1),
  1032.                              header, sizeof(header)-1);
  1033.  
  1034.         rc = GetRexxVariable(mk_var(varname,(char*)rxArgv[0].strptr, i, "jump_file", 1),
  1035.                              varvalue, sizeof(varvalue)-1);
  1036.         if(rc)
  1037.         {
  1038.             //mk_var(varname,rxArgv[0].strptr, i, "jump_file not found", 1);
  1039.             //MessageBox(varname, 0);
  1040.             return makeRC(prxRC, -7);
  1041.         }
  1042.  
  1043.         if(rc2)
  1044.             strcpy(header, varvalue);
  1045.  
  1046.         JList[list].add_entry(row, col, header, varvalue);
  1047.     }
  1048.  
  1049.     return makeRC(prxRC, 0);
  1050. }
  1051.  
  1052. /*************************************************************
  1053. ** Utility functions
  1054. */
  1055.  
  1056. int makeRC(PRXSTRING prxRC, LONG lData)
  1057. {
  1058.     char *str ;
  1059.     char *buff;
  1060.     int  slen = 0;
  1061.  
  1062.     buff = (char*)prxRC->strptr;
  1063.  
  1064.     if(lData < 0)
  1065.     {
  1066.         *buff++ = '-';
  1067.         slen++;
  1068.     }
  1069.  
  1070.     str = buff;
  1071.  
  1072.     do
  1073.     {
  1074.         *str++ = (char)((lData % 10) + '0');
  1075.         lData /= 10;
  1076.         slen++;
  1077.     }
  1078.     while(lData);
  1079.  
  1080.     *str-- = 0;
  1081.  
  1082.     for(; str > buff; str--, buff++)
  1083.     {
  1084.         *buff ^= *str;
  1085.         *str  ^= *buff;
  1086.         *buff ^= *str;
  1087.     }
  1088.     prxRC->strlength = slen;
  1089.     return 0;
  1090. }
  1091.  
  1092. int makeRCstr(PRXSTRING prxRC, char *str)
  1093. {
  1094.     if(!str)
  1095.         return 0;
  1096.  
  1097.     makeRCstr(prxRC, strlen(str));
  1098.     strcpy((char*)prxRC->strptr, str);
  1099.     prxRC->strlength = strlen(str);
  1100.     return 0;
  1101. }
  1102.  
  1103. int makeRCstr(PRXSTRING prxRC, int Len)
  1104. {
  1105.     if(Len > prxRC->strlength)
  1106.     {
  1107.         DosFreeMem(prxRC->strptr);
  1108.  
  1109.         DosAllocMem((PPVOID)&prxRC->strptr,
  1110.                      Len,
  1111.                      PAG_COMMIT | PAG_WRITE);
  1112.     }
  1113.     prxRC->strlength = Len;
  1114.     return 0;
  1115. }
  1116.  
  1117. ULONG ULfromSTR(char *str)
  1118. {
  1119.     ULONG ulRes = 0;
  1120.  
  1121.     if(!str)
  1122.         return ulRes;
  1123.     while(*str)
  1124.     {
  1125.         if(*str < '0' || *str > '9')
  1126.             break;
  1127.         ulRes *= 10;
  1128.         ulRes += *str - '0';
  1129.         str++;
  1130.     }
  1131.     return ulRes;
  1132. }
  1133.  
  1134. ULONG ULfromParm(PRXSTRING rxArg)
  1135. {
  1136.     return ULfromSTR((char*)rxArg->strptr);
  1137. }
  1138.  
  1139. APIRET GetRexxVariable(char* name, char* value, LONG len)
  1140. {
  1141.     APIRET rc;
  1142.     SHVBLOCK   block;
  1143.     block.shvcode = RXSHV_SYFET;
  1144. //    block.shvcode = RXSHV_FETCH;
  1145.     block.shvret=(UCHAR)0;
  1146.     block.shvnext=(PSHVBLOCK)0;
  1147.  
  1148.     MAKERXSTRING(block.shvname, name, strlen(name));
  1149.     MAKERXSTRING(block.shvvalue, value, len);
  1150.  
  1151.     block.shvvaluelen=len;
  1152.     rc = RexxVariablePool(&block);
  1153.     if(!rc)
  1154.         value[block.shvvalue.strlength]=0;
  1155.     else
  1156.         value[0]=0;
  1157.     return rc;
  1158. }
  1159.  
  1160. char* mk_var(char *buff, char *beg, int num, char *end, int mode)
  1161. {
  1162.     strcpy(buff, beg);
  1163.     if(mode)
  1164.     {
  1165.         strcat(buff, ".");
  1166.         strcat(buff, cvt_num(num,0));
  1167.     }
  1168.     strcat(buff, ".");
  1169.     strcat(buff, end);
  1170.     return buff;
  1171. }
  1172.  
  1173.  
  1174.