home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / fed0217s.zip / source / palette.cpp < prev    next >
C/C++ Source or Header  |  2001-11-07  |  31KB  |  947 lines
  1. /*
  2. ** Module   :PALETTE.CPP
  3. ** Abstract :Color palette for all visible elements of editor
  4. **
  5. ** Copyright (C) Sergey I. Yevtushenko
  6. **
  7. ** Log: Sun  09/11/1997       Updated to V0.1
  8. */
  9.  
  10. #include <editbox.h>
  11. #include <version.h>
  12.  
  13. Buffer* Clipboard = 0;
  14.  
  15. char *untitled=".";
  16. char *statusline="L%3r:C%2c %h [%u%f]";
  17. char StartupDir[FED_MAXPATH];
  18. char cPipe[] = "\\PIPE\\FED";
  19. char Search[1025];
  20. char Replace[1025];
  21. char Flags[33];
  22. char cName[1025];
  23. char toupper_cvt_table[256];
  24. char tolower_cvt_table[256];
  25. char collate_cvt_table[256];
  26. char _cFedPATH[FED_MAXPATH];
  27.  
  28. char *Screen;
  29. char *AlignedBuffer;
  30. int Rows;
  31. int Cols;
  32. int iTabWidth = 4;
  33. int iWWDef    = WW_MERGE;
  34. int iDefWidth = 78;
  35. int BufLen;
  36. int iShape[2] = { 90, 0};
  37. int iForce;
  38. int iDefType = 0;
  39. int iCtrlBrk = 0;
  40. int iUpperStatus = 0;
  41. int iNoEA = 0;
  42. int iFileName = 1;
  43. int iSaveSyntax = 1;
  44.  
  45. char app_pal[]=
  46. {
  47.     //CL_APPLICATION_START
  48.     0x07,   //CL_DEFAULT
  49.     0x70,   //CL_STATUSLINE
  50.  
  51.     //CL_DIALOG_START
  52.     0x70,   //CL_DEFAULT
  53.     0x70,   //CL_BORDER
  54.  
  55.     //CL_STEXT_START
  56.     0x70,   //CL_DEFAULT
  57.     0x7C,   //CL_HILITE
  58.  
  59.     //CL_EDITBOX_START
  60.     0x08,   //CL_DEFAULT
  61.     0x70,   //CL_SELECTION
  62.     0x1B,   //CL_EOF
  63.     0x06,   //CL_COMMENT
  64.     0x07,   //CL_IDENT
  65.     0x0E,   //CL_CONST
  66.     0x0A,   //CL_PREPROC
  67.     0x0C,   //CL_NUMBER
  68.     0x0F,   //CL_STDWORD
  69.     0x09,   //CL_SEMICOL
  70.     0x0F,   //CL_FUNCTION
  71.     0x0D,   //CL_XNUMBER
  72.  
  73.     //CL_EDITLINE_ACTIVE
  74.     0x0F,   //CL_DEFAULT
  75.     0x30,   //CL_SELECTION
  76.     0x07,   //CL_EOF
  77.     0x07,   //CL_COMMENT
  78.     0x07,   //CL_IDENT
  79.     0x07,   //CL_CONST
  80.     0x07,   //CL_PREPROC
  81.     0x07,   //CL_NUMBER
  82.     0x07,   //CL_STDWORD
  83.     0x07,   //CL_SEMICOL
  84.     0x07,   //CL_FUNCTION
  85.     0x07,   //CL_XNUMBER
  86.  
  87.     //CL_EDITLINE_INACTIVE
  88.     0x1B,   //CL_DEFAULT
  89.     0x3B,   //CL_SELECTION
  90.     0x07,   //CL_EOF
  91.     0x07,   //CL_COMMENT
  92.     0x07,   //CL_IDENT
  93.     0x07,   //CL_CONST
  94.     0x07,   //CL_PREPROC
  95.     0x07,   //CL_NUMBER
  96.     0x07,   //CL_STDWORD
  97.     0x07,   //CL_SEMICOL
  98.     0x07,   //CL_FUNCTION
  99.     0x07,   //CL_XNUMBER
  100.  
  101.     //CL_LISTBOX_START_ACTIVE
  102.     0x30,   //CL_DEFAULT
  103.     0x3B,   //CL_SELECTION
  104.     0x07,   //CL_CURRENT
  105.     0x0B,   //CL_CURRSEL
  106.  
  107.     //CL_LISTBOX_START_INACTIVE
  108.     0x30,   //CL_DEFAULT
  109.     0x3B,   //CL_SELECTION
  110.     0x1B,   //CL_CURRENT
  111.     0x1B,   //CL_CURRSEL
  112.  
  113.     //CL_MENU
  114.     0x70,   //CL_DEFAULT
  115.     0x7C,   //CL_SELECTION
  116.     0x07,   //CL_CURRENT
  117.     0x0C,   //CL_CURRSEL
  118.  
  119.     //CL_END_OF_PALETTE
  120.     0
  121. };
  122.  
  123. char ProgressBar[]="■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■";
  124.  
  125. char _cZero[]="";
  126.  
  127. char* FileDialogNames[]=
  128. {
  129.     " File Open ",
  130.     " File Save ",
  131.     " File Save As ",
  132.     _cZero
  133. };
  134.  
  135. char *Yes_No[]=
  136. {
  137.     " ~Y~es",
  138.     " ~N~o",
  139.     " ~C~ancel ",
  140.     0
  141. };
  142.  
  143. char *help_text="No Help available";
  144.  
  145. stKeyMap AltKey[] =
  146. {
  147.     { 0x00, _cZero },
  148.     { 0x1A, "Esc" },
  149.     { 0x02, "1" },
  150.     { 0x03, "2" },
  151.     { 0x04, "3" },
  152.     { 0x05, "4" },
  153.     { 0x06, "5" },
  154.     { 0x07, "6" },
  155.     { 0x08, "7" },
  156.     { 0x09, "8" },
  157.     { 0x0A, "9" },
  158.     { 0x01, "0" },
  159.     { 0x38, "Minus" },
  160.     { 0x19, "Equal" },
  161.     { 0x0E, "Bksp" },
  162.     { 0x48, "Tab" },
  163.     { 0x3F, "Q" },
  164.     { 0x4D, "W" },
  165.     { 0x16, "E" },
  166.     { 0x41, "R" },
  167.     { 0x47, "T" },
  168.     { 0x4F, "Y" },
  169.     { 0x4A, "U" },
  170.     { 0x30, "I" },
  171.     { 0x3A, "O" },
  172.     { 0x3B, "P" },
  173.     { 0x35, "Lbracket" },
  174.     { 0x42, "Rbracket" },
  175.     { 0x18, "Enter" },
  176.     { 0x00, _cZero },
  177.     { 0x0B, "A" },
  178.     { 0x44, "S" },
  179.     { 0x12, "D" },
  180.     { 0x1B, "F" },
  181.     { 0x28, "G" },
  182.     { 0x2E, "H" },
  183.     { 0x32, "J" },
  184.     { 0x33, "K" },
  185.     { 0x34, "L" },
  186.     { 0x45, "Semicolon" },
  187.     { 0x40, "Quote" },
  188.     { 0x49, "Tilde" },
  189.     { 0x00, _cZero },
  190.     { 0x0D, "BackSlash" },
  191.     { 0x50, "Z" },
  192.     { 0x4E, "X" },
  193.     { 0x0F, "C" },
  194.     { 0x4C, "V" },
  195.     { 0x0C, "B" },
  196.     { 0x39, "N" },
  197.     { 0x37, "M" },
  198.     { 0x11, "Comma" },
  199.     { 0x3E, "Point" },
  200.     { 0x14, "Div" },
  201.     { 0x00, _cZero },
  202.     { 0x2C, "GrMul" },
  203.     { 0x00, _cZero },
  204.     { 0x46, "Space" },
  205.     { 0x00, _cZero },
  206.     { 0x1C, "F1" },
  207.     { 0x20, "F2" },
  208.     { 0x21, "F3" },
  209.     { 0x22, "F4" },
  210.     { 0x23, "F5" },
  211.     { 0x24, "F6" },
  212.     { 0x25, "F7" },
  213.     { 0x26, "F8" },
  214.     { 0x27, "F9" },
  215.     { 0x1D, "F10" },
  216.     { 0x00, _cZero },
  217.     { 0x00, _cZero },
  218.     { 0x2F, "Home" },
  219.     { 0x4B, "Up" },
  220.     { 0x3D, "PgUp" },
  221.     { 0x2B, "GrMinus" },
  222.     { 0x36, "Left" },
  223.     { 0x10, "Center" },
  224.     { 0x43, "Right" },
  225.     { 0x2D, "GrPlus" },
  226.     { 0x17, "End" },
  227.     { 0x15, "Down" },
  228.     { 0x3C, "PgDown" },
  229.     { 0x31, "Ins" },
  230.     { 0x13, "Del" },
  231.     { 0x1C, "F1" },
  232.     { 0x20, "F2" },
  233.     { 0x21, "F3" },
  234.     { 0x22, "F4" },
  235.     { 0x23, "F5" },
  236.     { 0x24, "F6" },
  237.     { 0x25, "F7" },
  238.     { 0x26, "F8" },
  239.     { 0x27, "F9" },
  240.     { 0x1D, "F10" },
  241.     { 0x1C, "F1" },
  242.     { 0x20, "F2" },
  243.     { 0x21, "F3" },
  244.     { 0x22, "F4" },
  245.     { 0x23, "F5" },
  246.     { 0x24, "F6" },
  247.     { 0x25, "F7" },
  248.     { 0x26, "F8" },
  249.     { 0x27, "F9" },
  250.     { 0x1D, "F10" },
  251.     { 0x1C, "F1" },
  252.     { 0x20, "F2" },
  253.     { 0x21, "F3" },
  254.     { 0x22, "F4" },
  255.     { 0x23, "F5" },
  256.     { 0x24, "F6" },
  257.     { 0x25, "F7" },
  258.     { 0x26, "F8" },
  259.     { 0x27, "F9" },
  260.     { 0x1D, "F10" },
  261.     { 0x00, _cZero },
  262.     { 0x36, "Left" },
  263.     { 0x43, "Right" },
  264.     { 0x17, "End" },
  265.     { 0x3C, "PgDown" },
  266.     { 0x2F, "Home" },
  267.     { 0x02, "1" },
  268.     { 0x03, "2" },
  269.     { 0x04, "3" },
  270.     { 0x05, "4" },
  271.     { 0x06, "5" },
  272.     { 0x07, "6" },
  273.     { 0x08, "7" },
  274.     { 0x09, "8" },
  275.     { 0x0A, "9" },
  276.     { 0x01, "0" },
  277.     { 0x38, "Minus" },
  278.     { 0x19, "Equal" },
  279.     { 0x3D, "PgUp" },
  280.     { 0x1E, "F11" }, //Norm
  281.     { 0x1F, "F12" },
  282.     { 0x1E, "F11" }, //Shift
  283.     { 0x1F, "F12" },
  284.     { 0x1E, "F11" }, //Ctrl
  285.     { 0x1F, "F12" },
  286.     { 0x1E, "F11" }, //Alt
  287.     { 0x1F, "F12" },
  288.     { 0x4B, "Up" },
  289.     { 0x2B, "GrMinus" },
  290.     { 0x10, "Center" },
  291.     { 0x2D, "GrPlus" },
  292.     { 0x15, "Down" },
  293.     { 0x31, "Ins" },
  294.     { 0x13, "Del" },
  295.     { 0x48, "Tab" },
  296.     { 0x29, "GrDiv" },
  297.     { 0x2C, "GrMul" },
  298.     { 0x2F, "Home" },
  299.     { 0x4B, "Up" },
  300.     { 0x3D, "PgUp" },
  301.     { 0x00, _cZero },
  302.     { 0x36, "Left" },
  303.     { 0x00, _cZero },
  304.     { 0x43, "Right" },
  305.     { 0x00, _cZero },
  306.     { 0x17, "End" },
  307.     { 0x15, "Down" },
  308.     { 0x3C, "PgDown" },
  309.     { 0x31, "Ins" },
  310.     { 0x13, "Del" },
  311.     { 0x29, "GrDiv" },
  312.     { 0x00, _cZero },
  313.     { 0x2A, "GrEnter" },
  314.     { 0x00, _cZero },
  315.     { 0x00, _cZero },
  316.     { 0x00, _cZero },
  317.     { 0x00, _cZero },
  318.     { 0x00, _cZero },
  319.     { 0x00, _cZero },
  320.     { 0x00, _cZero },
  321.     { 0x00, _cZero },
  322.     { 0x00, _cZero },
  323.     { 0x00, _cZero },
  324.     { 0x00, _cZero },
  325.     { 0x00, _cZero },
  326.     { 0x00, _cZero },
  327.     { 0x00, _cZero },
  328.     { 0x00, _cZero },
  329.     { 0x00, _cZero },
  330.     { 0x00, _cZero },
  331.     { 0x00, _cZero },
  332.     { 0x00, _cZero },
  333.     { 0x00, _cZero },
  334.     { 0x00, _cZero },
  335.     { 0x00, _cZero },
  336.     { 0x00, _cZero },
  337.     { 0x00, _cZero },
  338.     { 0x00, _cZero },
  339.     { 0x00, _cZero },
  340.     { 0x00, _cZero },
  341.     { 0x00, _cZero },
  342.     { 0x00, _cZero },
  343.     { 0x00, _cZero },
  344.     { 0x00, _cZero },
  345.     { 0x00, _cZero },
  346.     { 0x00, _cZero },
  347.     { 0x00, _cZero },
  348.     { 0x00, _cZero },
  349.     { 0x00, _cZero },
  350.     { 0x00, _cZero },
  351.     { 0x00, _cZero },
  352.     { 0x00, _cZero },
  353.     { 0x00, _cZero },
  354.     { 0x00, _cZero },
  355.     { 0x00, _cZero },
  356.     { 0x00, _cZero },
  357.     { 0x00, _cZero },
  358.     { 0x00, _cZero },
  359.     { 0x00, _cZero },
  360.     { 0x00, _cZero },
  361.     { 0x00, _cZero },
  362.     { 0x00, _cZero },
  363.     { 0x00, _cZero },
  364.     { 0x00, _cZero },
  365.     { 0x00, _cZero },
  366.     { 0x00, _cZero },
  367.     { 0x00, _cZero },
  368.     { 0x00, _cZero },
  369.     { 0x00, _cZero },
  370.     { 0x00, _cZero },
  371.     { 0x2A, "GrEnter" },
  372.     { 0x00, _cZero },
  373.     { 0x00, _cZero },
  374.     { 0x00, _cZero },
  375.     { 0x00, _cZero },
  376.     { 0x00, _cZero },
  377.     { 0x00, _cZero },
  378.     { 0x00, _cZero },
  379.     { 0x00, _cZero },
  380.     { 0x00, _cZero },
  381.     { 0x00, _cZero },
  382.     { 0x00, _cZero },
  383.     { 0x00, _cZero },
  384.     { 0x00, _cZero },
  385.     { 0x00, _cZero },
  386.     { 0x00, _cZero },
  387.     { 0x00, _cZero },
  388.     { 0x00, _cZero },
  389.     { 0x00, _cZero },
  390.     { 0x00, _cZero },
  391.     { 0x00, _cZero },
  392.     { 0x00, _cZero },
  393.     { 0x00, _cZero },
  394.     { 0x00, _cZero },
  395.     { 0x00, _cZero },
  396.     { 0x00, _cZero },
  397.     { 0x00, _cZero },
  398.     { 0x00, _cZero },
  399.     { 0x00, _cZero },
  400.     { 0x00, _cZero },
  401.     { 0x00, _cZero },
  402.     { 0x00, _cZero }
  403. };
  404.  
  405. int __r_ctype[]=
  406. {
  407.      0, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP,
  408.  IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP,
  409.  IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP,
  410.  IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP, IS_SP,
  411.  IS_SP                          /*' ' - 0x20*/,
  412.  IS_PU                          /*'!' - 0x21*/,
  413.  IS_PU | IS_QU                  /*'"' - 0x22*/,
  414.  IS_PU | IS_IS                  /*'#' - 0x23*/,
  415.  IS_PU                          /*'$' - 0x24*/,
  416.  IS_PU                          /*'%' - 0x25*/,
  417.  IS_PU                          /*'&' - 0x26*/,
  418.  IS_PU | IS_QU                  /*''' - 0x27*/,
  419.  IS_PU                          /*'(' - 0x28*/,
  420.  IS_PU                          /*')' - 0x29*/,
  421.  IS_PU                          /*'*' - 0x2A*/,
  422.  IS_PU                          /*'+' - 0x2B*/,
  423.  IS_PU                          /*',' - 0x2C*/,
  424.  IS_PU                          /*'-' - 0x2D*/,
  425.  IS_PU                          /*'.' - 0x2E*/,
  426.  IS_PU                          /*'/' - 0x2F*/,
  427.  IS_DI | IS_XD | IS_HD          /*'0' - 0x30*/,
  428.  IS_DI | IS_XD | IS_HD          /*'1' - 0x31*/,
  429.  IS_DI | IS_XD | IS_HD          /*'2' - 0x32*/,
  430.  IS_DI | IS_XD | IS_HD          /*'3' - 0x33*/,
  431.  IS_DI | IS_XD | IS_HD          /*'4' - 0x34*/,
  432.  IS_DI | IS_XD | IS_HD          /*'5' - 0x35*/,
  433.  IS_DI | IS_XD | IS_HD          /*'6' - 0x36*/,
  434.  IS_DI | IS_XD | IS_HD          /*'7' - 0x37*/,
  435.  IS_DI | IS_XD | IS_HD          /*'8' - 0x38*/,
  436.  IS_DI | IS_XD | IS_HD          /*'9' - 0x39*/,
  437.  IS_PU                          /*':' - 0x3A*/,
  438.  IS_PU | IS_SE                  /*';' - 0x3B*/,
  439.  IS_PU                          /*'<' - 0x3C*/,
  440.  IS_PU                          /*'=' - 0x3D*/,
  441.  IS_PU                          /*'>' - 0x3E*/,
  442.  IS_PU                          /*'?' - 0x3F*/,
  443.  IS_PU                          /*'@' - 0x40*/,
  444.  IS_AL | IS_XD | IS_HD | IS_IS  /*'A' - 0x41*/,
  445.  IS_AL | IS_XD | IS_HD | IS_IS  /*'B' - 0x42*/,
  446.  IS_AL | IS_XD | IS_HD | IS_IS  /*'C' - 0x43*/,
  447.  IS_AL | IS_XD | IS_HD | IS_IS  /*'D' - 0x44*/,
  448.  IS_AL | IS_XD | IS_HD | IS_IS  /*'E' - 0x45*/,
  449.  IS_AL | IS_XD | IS_HD | IS_IS  /*'F' - 0x46*/,
  450.  IS_AL                 | IS_IS  /*'G' - 0x47*/,
  451.  IS_AL                 | IS_IS  /*'H' - 0x48*/,
  452.  IS_AL                 | IS_IS  /*'I' - 0x49*/,
  453.  IS_AL                 | IS_IS  /*'J' - 0x4A*/,
  454.  IS_AL                 | IS_IS  /*'K' - 0x4B*/,
  455.  IS_AL                 | IS_IS  /*'L' - 0x4C*/,
  456.  IS_AL                 | IS_IS  /*'M' - 0x4D*/,
  457.  IS_AL                 | IS_IS  /*'N' - 0x4E*/,
  458.  IS_AL                 | IS_IS  /*'O' - 0x4F*/,
  459.  IS_AL                 | IS_IS  /*'P' - 0x50*/,
  460.  IS_AL                 | IS_IS  /*'Q' - 0x51*/,
  461.  IS_AL                 | IS_IS  /*'R' - 0x52*/,
  462.  IS_AL                 | IS_IS  /*'S' - 0x53*/,
  463.  IS_AL                 | IS_IS  /*'T' - 0x54*/,
  464.  IS_AL                 | IS_IS  /*'U' - 0x55*/,
  465.  IS_AL                 | IS_IS  /*'V' - 0x56*/,
  466.  IS_AL                 | IS_IS  /*'W' - 0x57*/,
  467.  IS_AL                 | IS_IS  /*'X' - 0x58*/,
  468.  IS_AL                 | IS_IS  /*'Y' - 0x59*/,
  469.  IS_AL                 | IS_IS  /*'Z' - 0x5A*/,
  470.  IS_PU                          /*'[' - 0x5B*/,
  471.  IS_PU                          /*'\' - 0x5C*/,
  472.  IS_PU                          /*']' - 0x5D*/,
  473.  IS_PU                          /*'^' - 0x5E*/,
  474.  IS_PU                 | IS_IS  /*'_' - 0x5F*/,
  475.  IS_PU                          /*'`' - 0x60*/,
  476.  IS_AL | IS_XD | IS_HD | IS_IS  /*'a' - 0x61*/,
  477.  IS_AL | IS_XD | IS_HD | IS_IS  /*'b' - 0x62*/,
  478.  IS_AL | IS_XD | IS_HD | IS_IS  /*'c' - 0x63*/,
  479.  IS_AL | IS_XD | IS_HD | IS_IS  /*'d' - 0x64*/,
  480.  IS_AL | IS_XD | IS_HD | IS_IS  /*'e' - 0x65*/,
  481.  IS_AL | IS_XD | IS_HD | IS_IS  /*'f' - 0x66*/,
  482.  IS_AL                 | IS_IS  /*'g' - 0x67*/,
  483.  IS_AL                 | IS_IS  /*'h' - 0x68*/,
  484.  IS_AL                 | IS_IS  /*'i' - 0x69*/,
  485.  IS_AL                 | IS_IS  /*'j' - 0x6A*/,
  486.  IS_AL                 | IS_IS  /*'k' - 0x6B*/,
  487.  IS_AL                 | IS_IS  /*'l' - 0x6C*/,
  488.  IS_AL                 | IS_IS  /*'m' - 0x6D*/,
  489.  IS_AL                 | IS_IS  /*'n' - 0x6E*/,
  490.  IS_AL                 | IS_IS  /*'o' - 0x6F*/,
  491.  IS_AL                 | IS_IS  /*'p' - 0x70*/,
  492.  IS_AL                 | IS_IS  /*'q' - 0x71*/,
  493.  IS_AL                 | IS_IS  /*'r' - 0x72*/,
  494.  IS_AL                 | IS_IS  /*'s' - 0x73*/,
  495.  IS_AL                 | IS_IS  /*'t' - 0x74*/,
  496.  IS_AL                 | IS_IS  /*'u' - 0x75*/,
  497.  IS_AL                 | IS_IS  /*'v' - 0x76*/,
  498.  IS_AL                 | IS_IS  /*'w' - 0x77*/,
  499.  IS_AL                 | IS_IS  /*'x' - 0x78*/,
  500.  IS_AL                 | IS_IS  /*'y' - 0x79*/,
  501.  IS_AL                 | IS_IS  /*'z' - 0x7A*/,
  502.  IS_PU                          /*'{' - 0x7B*/,
  503.  IS_PU                          /*'|' - 0x7C*/,
  504.  IS_PU                          /*'}' - 0x7D*/,
  505.  IS_PU                          /*'~' - 0x7E*/,
  506.  IS_SP | IS_PU                  /*' ' - 0x7F*/,
  507.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  508.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  509.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  510.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  511.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  512.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  513.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  514.  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  515.  0
  516. };
  517.  
  518. char *hi_map = _cZero;
  519. int iDateFmt = 0;
  520. int cDateSep = '/';
  521. int iVSearch = 0;
  522. int iMouseMask = 0x06;
  523. int iSenseShift = 1;
  524.  
  525. //-----------------------------------------
  526. // Static initializer for dictionary of keywords
  527. //-----------------------------------------
  528.  
  529. kwdPair keywords [] =
  530. {
  531.  
  532.     { "AUTOLOAD"        , MASK_PL},
  533.     { "BEGIN"           , MASK_PL},
  534.     { "CHECK"           , MASK_PL},
  535.     { "CORE"            , MASK_PL},
  536.     { "DESTROY"         , MASK_PL},
  537.     { "END"             , MASK_PL},
  538.     { "EQ"              , MASK_PL},
  539.     { "GE"              , MASK_PL},
  540.     { "GT"              , MASK_PL},
  541.     { "INIT"            , MASK_PL},
  542.     { "LE"              , MASK_PL},
  543.     { "LT"              , MASK_PL},
  544.     { "NE"              , MASK_PL},
  545.     { "NULL"            , MASK_PL},
  546.     { "__DATA__"        , MASK_PL},
  547.     { "__END__"         , MASK_PL},
  548.     { "__FILE__"        , MASK_PL},
  549.     { "__LINE__"        , MASK_PL},
  550.     { "__PACKAGE__"     , MASK_PL},
  551.  
  552.     { "::method"        , MASK_REXX},
  553.     { "::class"         , MASK_REXX},
  554.     { "::requires"      , MASK_REXX},
  555.  
  556.     { "abs"             , MASK_PL},
  557.     { "absolute"        , MASK_PAS },
  558.     { "abstract"        , MASK_JAVA},
  559.     { "accept"          , MASK_PL},
  560.     { "address"         , MASK_REXX},
  561.     { "alarm"           , MASK_PL},
  562.     { "all"             , MASK_REXX},
  563.     { "and"             , MASK_PAS | MASK_PL},
  564.     { "arg"             , MASK_REXX},
  565.     { "array"           , MASK_PAS },
  566.     { "asm"             , MASK_PAS },
  567.     { "assembler"       , MASK_PAS },
  568.     { "atan2"           , MASK_PL},
  569.     { "auto"            , MASK_CPP },
  570.     { "begin"           , MASK_PAS },
  571.     { "bind"            , MASK_PL},
  572.     { "binmode"         , MASK_PL},
  573.     { "bless"           , MASK_PL},
  574.     { "bool"            , MASK_CPP },
  575.     { "boolean"         , MASK_JAVA},
  576.     { "break"           , MASK_CPP | MASK_JAVA},
  577.     { "by"              , MASK_REXX},
  578.     { "byte"            , MASK_ASM | MASK_JAVA},
  579.     { "call"            , MASK_ASM | MASK_REXX},
  580.     { "caller"          , MASK_PL},
  581.     { "case"            , MASK_CPP | MASK_PAS | MASK_JAVA},
  582.     { "catch"           , MASK_CPP | MASK_JAVA},
  583.     { "char"            , MASK_CPP },
  584.     { "chdir"           , MASK_PL},
  585.     { "chmod"           , MASK_PL},
  586.     { "chomp"           , MASK_PL},
  587.     { "chop"            , MASK_PL},
  588.     { "chown"           , MASK_PL},
  589.     { "chr"             , MASK_PL},
  590.     { "chroot"          , MASK_PL},
  591.     { "class"           , MASK_CPP | MASK_JAVA},
  592.     { "close"           , MASK_PL},
  593.     { "closedir"        , MASK_PL},
  594.     { "cmp"             , MASK_PL},
  595.     { "commands"        , MASK_REXX},
  596.     { "connect"         , MASK_PL},
  597.     { "const"           , MASK_CPP | MASK_PAS | MASK_JAVA},
  598.     { "constructor"     , MASK_PAS },
  599.     { "continue"        , MASK_CPP | MASK_JAVA | MASK_PL},
  600.     { "cos"             , MASK_PL},
  601.     { "crypt"           , MASK_PL},
  602.     { "dbmclose"        , MASK_PL},
  603.     { "dbmopen"         , MASK_PL},
  604.     { "default"         , MASK_CPP | MASK_JAVA},
  605.     { "define"          , MASK_CPP },
  606.     { "defined"         , MASK_PL},
  607.     { "delete"          , MASK_CPP | MASK_PL},
  608.     { "destructor"      , MASK_PAS },
  609.     { "die"             , MASK_PL},
  610.     { "digits"          , MASK_REXX},
  611.     { "div"             , MASK_PAS },
  612.     { "do"              , MASK_REXX | MASK_CPP | MASK_PAS | MASK_JAVA | MASK_PL},
  613.     { "double"          , MASK_CPP | MASK_JAVA},
  614.     { "downto"          , MASK_PAS },
  615.     { "drop"            , MASK_REXX},
  616.     { "dump"            , MASK_PL},
  617.     { "dword"           , MASK_ASM },
  618.     { "each"            , MASK_PL},
  619.     { "else"            , MASK_REXX | MASK_CPP | MASK_PAS | MASK_JAVA | MASK_PL},
  620.     { "elsif"           , MASK_PL},
  621.     { "end"             , MASK_REXX | MASK_ASM | MASK_PAS},
  622.     { "endgrent"        , MASK_PL},
  623.     { "endhostent"      , MASK_PL},
  624.     { "endif"           , MASK_CPP },
  625.     { "endnetent"       , MASK_PL},
  626.     { "endp"            , MASK_ASM },
  627.     { "endprotoent"     , MASK_PL},
  628.     { "endpwent"        , MASK_PL},
  629.     { "ends"            , MASK_ASM },
  630.     { "endservent"      , MASK_PL},
  631.     { "engineering"     , MASK_REXX},
  632.     { "entry"           , MASK_CPP },
  633.     { "enum"            , MASK_CPP },
  634.     { "eof"             , MASK_PL},
  635.     { "eq"              , MASK_PL},
  636.     { "error"           , MASK_REXX},
  637.     { "errors"          , MASK_REXX},
  638.     { "eval"            , MASK_PL},
  639.     { "exec"            , MASK_PL},
  640.     { "exists"          , MASK_PL},
  641.     { "exit"            , MASK_REXX | MASK_PL},
  642.     { "exp"             , MASK_PL},
  643.     { "expose"          , MASK_REXX},
  644.     { "extends"         , MASK_JAVA},
  645.     { "extern"          , MASK_CPP },
  646.     { "external"        , MASK_PAS },
  647.     { "false"           , MASK_CPP | MASK_JAVA},
  648.     { "far"             , MASK_PAS },
  649.     { "fcntl"           , MASK_PL},
  650.     { "file"            , MASK_PAS },
  651.     { "fileno"          , MASK_PL},
  652.     { "final"           , MASK_JAVA},
  653.     { "finally"         , MASK_JAVA},
  654.     { "float"           , MASK_CPP | MASK_JAVA},
  655.     { "flock"           , MASK_PL},
  656.     { "for"             , MASK_REXX | MASK_CPP | MASK_PAS | MASK_JAVA | MASK_PL},
  657.     { "foreach"         , MASK_PL},
  658.     { "forever"         , MASK_REXX},
  659.     { "fork"            , MASK_PL},
  660.     { "form"            , MASK_REXX},
  661.     { "format"          , MASK_PL},
  662.     { "formline"        , MASK_PL},
  663.     { "forward"         , MASK_PAS },
  664.     { "friend"          , MASK_CPP },
  665.     { "function"        , MASK_PAS },
  666.     { "fuzz"            , MASK_REXX},
  667.     { "ge"              , MASK_PL},
  668.     { "getc"            , MASK_PL},
  669.     { "getgrent"        , MASK_PL},
  670.     { "getgrgid"        , MASK_PL},
  671.     { "getgrnam"        , MASK_PL},
  672.     { "gethostbyaddr"   , MASK_PL},
  673.     { "gethostbyname"   , MASK_PL},
  674.     { "gethostent"      , MASK_PL},
  675.     { "getlogin"        , MASK_PL},
  676.     { "getnetbyaddr"    , MASK_PL},
  677.     { "getnetbyname"    , MASK_PL},
  678.     { "getnetent"       , MASK_PL},
  679.     { "getpeername"     , MASK_PL},
  680.     { "getpgrp"         , MASK_PL},
  681.     { "getppid"         , MASK_PL},
  682.     { "getpriority"     , MASK_PL},
  683.     { "getprotobyname"  , MASK_PL},
  684.     { "getprotobynumber", MASK_PL},
  685.     { "getprotoent"     , MASK_PL},
  686.     { "getpwent"        , MASK_PL},
  687.     { "getpwnam"        , MASK_PL},
  688.     { "getpwuid"        , MASK_PL},
  689.     { "getservbyname"   , MASK_PL},
  690.     { "getservbyport"   , MASK_PL},
  691.     { "getservent"      , MASK_PL},
  692.     { "getsockname"     , MASK_PL},
  693.     { "getsockopt"      , MASK_PL},
  694.     { "glob"            , MASK_PL},
  695.     { "gmtime"          , MASK_PL},
  696.     { "goto"            , MASK_CPP | MASK_PAS | MASK_JAVA | MASK_PL},
  697.     { "grep"            , MASK_PL},
  698.     { "gt"              , MASK_PL},
  699.     { "halt"            , MASK_REXX},
  700.     { "hex"             , MASK_PL},
  701.     { "if"              , MASK_REXX | MASK_CPP | MASK_PAS | MASK_JAVA | MASK_PL},
  702.     { "ifdef"           , MASK_CPP },
  703.     { "ifndef"          , MASK_CPP },
  704.     { "implementation"  , MASK_PAS },
  705.     { "implements"      , MASK_JAVA},
  706.     { "import"          , MASK_JAVA},
  707.     { "in"              , MASK_PAS },
  708.     { "include"         , MASK_CPP },
  709.     { "index"           , MASK_PL},
  710.     { "inherited"       , MASK_PAS },
  711.     { "inline"          , MASK_CPP | MASK_PAS},
  712.     { "instanceof"      , MASK_JAVA},
  713.     { "int"             , MASK_CPP | MASK_JAVA | MASK_PL},
  714.     { "interface"       , MASK_PAS | MASK_JAVA},
  715.     { "intermediates"   , MASK_REXX},
  716.     { "interpret"       , MASK_REXX},
  717.     { "interrupt"       , MASK_PAS },
  718.     { "ioctl"           , MASK_PL},
  719.     { "iterate"         , MASK_REXX},
  720.     { "join"            , MASK_PL},
  721.     { "keys"            , MASK_PL},
  722.     { "kill"            , MASK_PL},
  723.     { "label"           , MASK_ASM | MASK_PAS},
  724.     { "labels"          , MASK_REXX},
  725.     { "last"            , MASK_PL},
  726.     { "lc"              , MASK_PL},
  727.     { "lcfirst"         , MASK_PL},
  728.     { "le"              , MASK_PL},
  729.     { "leave"           , MASK_REXX},
  730.     { "length"          , MASK_PL},
  731.     { "link"            , MASK_PL},
  732.     { "listen"          , MASK_PL},
  733.     { "local"           , MASK_PL},
  734.     { "localtime"       , MASK_PL},
  735.     { "lock"            , MASK_PL},
  736.     { "log"             , MASK_PL},
  737.     { "long"            , MASK_CPP | MASK_JAVA},
  738.     { "lstat"           , MASK_PL},
  739.     { "lt"              , MASK_PL},
  740.     { "m"               , MASK_PL},
  741.     { "map"             , MASK_PL},
  742.     { "mkdir"           , MASK_PL},
  743.     { "mod"             , MASK_PAS },
  744.     { "msgctl"          , MASK_PL},
  745.     { "msgget"          , MASK_PL},
  746.     { "msgrcv"          , MASK_PL},
  747.     { "msgsnd"          , MASK_PL},
  748.     { "my"              , MASK_PL},
  749.     { "native"          , MASK_JAVA},
  750.     { "ne"              , MASK_PL},
  751.     { "near"            , MASK_ASM | MASK_PAS},
  752.     { "negative"        , MASK_REXX},
  753.     { "new"             , MASK_CPP | MASK_JAVA},
  754.     { "next"            , MASK_PL},
  755.     { "nil"             , MASK_REXX | MASK_PAS },
  756.     { "no"              , MASK_PL},
  757.     { "nop"             , MASK_REXX},
  758.     { "normal"          , MASK_REXX},
  759.     { "not"             , MASK_PAS | MASK_PL},
  760.     { "novalue"         , MASK_REXX},
  761.     { "null"            , MASK_JAVA},
  762.     { "numeric"         , MASK_REXX},
  763.     { "object"          , MASK_PAS },
  764.     { "oct"             , MASK_PL},
  765.     { "of"              , MASK_PAS },
  766.     { "off"             , MASK_REXX},
  767.     { "offset"          , MASK_ASM },
  768.     { "on"              , MASK_REXX},
  769.     { "open"            , MASK_PL},
  770.     { "opendir"         , MASK_PL},
  771.     { "or"              , MASK_PAS | MASK_PL},
  772.     { "ord"             , MASK_PL},
  773.     { "otherwise"       , MASK_REXX},
  774.     { "our"             , MASK_PL},
  775.     { "pack"            , MASK_PL},
  776.     { "package"         , MASK_JAVA | MASK_PL},
  777.     { "packed"          , MASK_PAS },
  778.     { "parse"           , MASK_REXX},
  779.     { "pipe"            , MASK_PL},
  780.     { "pop"             , MASK_PL},
  781.     { "pos"             , MASK_PL},
  782.     { "print"           , MASK_PL},
  783.     { "printf"          , MASK_PL},
  784.     { "private"         , MASK_CPP | MASK_PAS | MASK_JAVA},
  785.     { "proc"            , MASK_ASM },
  786.     { "procedure"       , MASK_REXX | MASK_PAS},
  787.     { "program"         , MASK_PAS },
  788.     { "protected"       , MASK_CPP | MASK_JAVA},
  789.     { "prototype"       , MASK_PL},
  790.     { "ptr"             , MASK_ASM },
  791.     { "public"          , MASK_CPP | MASK_PAS | MASK_JAVA},
  792.     { "pull"            , MASK_REXX},
  793.     { "push"            , MASK_REXX | MASK_PL},
  794.     { "q"               , MASK_PL},
  795.     { "qq"              , MASK_PL},
  796.     { "qr"              , MASK_PL},
  797.     { "queue"           , MASK_REXX},
  798.     { "quotemeta"       , MASK_PL},
  799.     { "qw"              , MASK_PL},
  800.     { "qword"           , MASK_ASM },
  801.     { "qx"              , MASK_PL},
  802.     { "rand"            , MASK_PL},
  803.     { "read"            , MASK_PL},
  804.     { "readdir"         , MASK_PL},
  805.     { "readline"        , MASK_PL},
  806.     { "readlink"        , MASK_PL},
  807.     { "readpipe"        , MASK_PL},
  808.     { "record"          , MASK_PAS },
  809.     { "recv"            , MASK_PL},
  810.     { "redo"            , MASK_PL},
  811.     { "ref"             , MASK_PL},
  812.     { "register"        , MASK_CPP },
  813.     { "rename"          , MASK_PL},
  814.     { "repeat"          , MASK_PAS },
  815.     { "require"         , MASK_PL},
  816.     { "reset"           , MASK_PL},
  817.     { "results"         , MASK_REXX},
  818.     { "return"          , MASK_REXX | MASK_CPP | MASK_JAVA | MASK_PL},
  819.     { "reverse"         , MASK_PL},
  820.     { "rewinddir"       , MASK_PL},
  821.     { "rindex"          , MASK_PL},
  822.     { "rmdir"           , MASK_PL},
  823.     { "s"               , MASK_PL},
  824.     { "say"             , MASK_REXX},
  825.     { "scalar"          , MASK_PL},
  826.     { "scan"            , MASK_REXX},
  827.     { "scientific"      , MASK_REXX},
  828.     { "seek"            , MASK_PL},
  829.     { "seekdir"         , MASK_PL},
  830.     { "segment"         , MASK_ASM },
  831.     { "select"          , MASK_REXX | MASK_PL},
  832.     { "self"            , MASK_REXX | MASK_PAS},
  833.     { "semctl"          , MASK_PL},
  834.     { "semget"          , MASK_PL},
  835.     { "semop"           , MASK_PL},
  836.     { "send"            , MASK_PL},
  837.     { "set"             , MASK_PAS },
  838.     { "setgrent"        , MASK_PL},
  839.     { "sethostent"      , MASK_PL},
  840.     { "setnetent"       , MASK_PL},
  841.     { "setpgrp"         , MASK_PL},
  842.     { "setpriority"     , MASK_PL},
  843.     { "setprotoent"     , MASK_PL},
  844.     { "setpwent"        , MASK_PL},
  845.     { "setservent"      , MASK_PL},
  846.     { "setsockopt"      , MASK_PL},
  847.     { "shift"           , MASK_PL},
  848.     { "shl"             , MASK_PAS },
  849.     { "shmctl"          , MASK_PL},
  850.     { "shmget"          , MASK_PL},
  851.     { "shmread"         , MASK_PL},
  852.     { "shmwrite"        , MASK_PL},
  853.     { "short"           , MASK_CPP | MASK_JAVA},
  854.     { "shr"             , MASK_PAS },
  855.     { "shutdown"        , MASK_PL},
  856.     { "sigl"            , MASK_REXX},
  857.     { "signal"          , MASK_REXX},
  858.     { "signed"          , MASK_CPP },
  859.     { "sin"             , MASK_PL},
  860.     { "sizeof"          , MASK_CPP },
  861.     { "sleep"           , MASK_PL},
  862.     { "socket"          , MASK_PL},
  863.     { "socketpair"      , MASK_PL},
  864.     { "sort"            , MASK_PL},
  865.     { "splice"          , MASK_PL},
  866.     { "split"           , MASK_PL},
  867.     { "sprintf"         , MASK_PL},
  868.     { "sqrt"            , MASK_PL},
  869.     { "srand"           , MASK_PL},
  870.     { "stat"            , MASK_PL},
  871.     { "static"          , MASK_CPP | MASK_JAVA},
  872.     { "string"          , MASK_PAS },
  873.     { "struc"           , MASK_ASM },
  874.     { "struct"          , MASK_CPP },
  875.     { "study"           , MASK_PL},
  876.     { "sub"             , MASK_PL},
  877.     { "substr"          , MASK_PL},
  878.     { "super"           , MASK_JAVA},
  879.     { "switch"          , MASK_CPP | MASK_JAVA},
  880.     { "symlink"         , MASK_PL},
  881.     { "synchronized"    , MASK_JAVA},
  882.     { "syntax"          , MASK_REXX},
  883.     { "syscall"         , MASK_PL},
  884.     { "sysopen"         , MASK_PL},
  885.     { "sysread"         , MASK_PL},
  886.     { "sysseek"         , MASK_PL},
  887.     { "system"          , MASK_PL},
  888.     { "syswrite"        , MASK_PL},
  889.     { "tell"            , MASK_PL},
  890.     { "telldir"         , MASK_PL},
  891.     { "then"            , MASK_REXX | MASK_PAS},
  892.     { "this"            , MASK_CPP | MASK_JAVA},
  893.     { "throw"           , MASK_CPP | MASK_JAVA},
  894.     { "throws"          , MASK_JAVA},
  895.     { "tie"             , MASK_PL},
  896.     { "tied"            , MASK_PL},
  897.     { "time"            , MASK_PL},
  898.     { "times"           , MASK_PL},
  899.     { "to"              , MASK_REXX | MASK_PAS},
  900.     { "tr"              , MASK_PL},
  901.     { "trace"           , MASK_REXX},
  902.     { "transient"       , MASK_JAVA},
  903.     { "true"            , MASK_CPP | MASK_JAVA},
  904.     { "truncate"        , MASK_PL},
  905.     { "try"             , MASK_CPP | MASK_JAVA},
  906.     { "type"            , MASK_PAS },
  907.     { "typedef"         , MASK_CPP },
  908.     { "uc"              , MASK_PL},
  909.     { "ucfirst"         , MASK_PL},
  910.     { "umask"           , MASK_PL},
  911.     { "undef"           , MASK_PL},
  912.     { "union"           , MASK_CPP },
  913.     { "unit"            , MASK_PAS },
  914.     { "unless"          , MASK_PL},
  915.     { "unlink"          , MASK_PL},
  916.     { "unpack"          , MASK_PL},
  917.     { "unshift"         , MASK_PL},
  918.     { "unsigned"        , MASK_CPP },
  919.     { "untie"           , MASK_PL},
  920.     { "until"           , MASK_REXX | MASK_PAS | MASK_PL},
  921.     { "upper"           , MASK_REXX},
  922.     { "use"             , MASK_REXX | MASK_PL},
  923.     { "uses"            , MASK_PAS },
  924.     { "utime"           , MASK_PL},
  925.     { "value"           , MASK_REXX},
  926.     { "values"          , MASK_PL},
  927.     { "var"             , MASK_REXX | MASK_PAS},
  928.     { "vec"             , MASK_PL},
  929.     { "virtual"         , MASK_CPP | MASK_PAS },
  930.     { "void"            , MASK_CPP | MASK_JAVA},
  931.     { "volatile"        , MASK_CPP | MASK_JAVA},
  932.     { "wait"            , MASK_PL},
  933.     { "waitpid"         , MASK_PL},
  934.     { "wantarray"       , MASK_PL},
  935.     { "warn"            , MASK_PL},
  936.     { "when"            , MASK_REXX},
  937.     { "while"           , MASK_REXX | MASK_CPP | MASK_PAS | MASK_JAVA | MASK_PL},
  938.     { "with"            , MASK_REXX | MASK_PAS},
  939.     { "word"            , MASK_ASM },
  940.     { "write"           , MASK_PL},
  941.     { "x"               , MASK_PL},
  942.     { "xor"             , MASK_PAS | MASK_PL},
  943.     { "y"               , MASK_PL},
  944.     {0,0}
  945. };
  946.  
  947.