home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / ftes46b5.zip / ftes46b5 / src / c_config.cpp < prev    next >
C/C++ Source or Header  |  1997-06-22  |  33KB  |  1,094 lines
  1. /*    c_config.cpp
  2.  *
  3.  *    Copyright (c) 1994-1996, Marko Macek
  4.  *
  5.  *    You may distribute under the terms of either the GNU General Public
  6.  *    License or the Artistic License, as specified in the README file.
  7.  *
  8.  */
  9.  
  10. #include "fte.h"
  11.  
  12. typedef struct _CurPos {
  13.     int sz;
  14.     char *a;
  15.     char *c;
  16.     char *z;
  17.     int line;
  18.     char *name; // filename
  19. } CurPos;
  20.  
  21. #ifdef CONFIG_INDENT_C
  22. extern int C_Indent;
  23. extern int C_BraceOfs;
  24. extern int C_CaseOfs;
  25. extern int C_CaseDelta;
  26. extern int C_ClassOfs;
  27. extern int C_ClassDelta;
  28. extern int C_ColonOfs;
  29. extern int C_CommentOfs;
  30. extern int C_CommentDelta;
  31. extern int C_FirstLevelWidth;
  32. extern int C_FirstLevelIndent;
  33. extern int C_Continuation;
  34. extern int C_ParenDelta;
  35. #endif
  36.  
  37. #ifdef CONFIG_INDENT_REXX
  38. extern int REXX_Base_Indent;
  39. extern int REXX_Do_Offset;
  40. #endif
  41.  
  42. extern int ShowVScroll;
  43. extern int ShowHScroll;
  44. extern int ShowMenuBar;
  45.  
  46. int SystemClipboard = 0;
  47. int ScreenSizeX = -1, ScreenSizeY = -1;
  48. int ScrollBarWidth = 1;
  49. int CursorInsSize[2] = { 90, 100 };
  50. int CursorOverSize[2] = { 0, 100 };
  51. int OpenAfterClose = 1;
  52. int SelectPathname = 0;
  53. char DefaultModeName[32] = "";
  54. RxNode *CompletionFilter;
  55. #if defined(DOS) || defined(DOSP32)
  56. char PrintDevice[MAXPATH] = "PRN";
  57. #else
  58. char PrintDevice[MAXPATH] = "\\DEV\\PRN";
  59. #endif
  60. char CompileCommand[256] = "make";
  61. int KeepHistory = 0;
  62. int LoadDesktopOnEntry = 0;
  63. int SaveDesktopOnExit = 0;
  64. char WindowFont[64] = "";
  65. int KeepMessages = 0;
  66. int ScrollBorderX = 0;
  67. int ScrollBorderY = 0;
  68. int ScrollJumpX = 8;
  69. int ScrollJumpY = 1;
  70. int GUIDialogs = 1;
  71. int PMDisableAccel = 0;
  72. int SevenBit = 0;
  73. int WeirdScroll = 0;
  74. int LoadDesktopMode = 0;
  75. char HelpCommand[128] = "man -a";
  76. char *ConfigSourcePath = 0;
  77.  
  78. #ifdef CONFIG_SYNTAX_HILIT
  79. int AddKeyword(ColorKeywords *tab, char color, char *keyword) {
  80.     int len;
  81.     
  82.     len = strlen(keyword);
  83.     if (len < 1 || len >= CK_MAXLEN) return 0;
  84.     
  85.     if (tab->key[len]) {
  86.         int lx = strlen(tab->key[len]);
  87.         tab->key[len] = (char *)realloc(tab->key[len], lx + len + 1 + 1);
  88.         assert(tab->key[len] != 0);
  89.         strcpy(tab->key[len] + lx, keyword);
  90.         tab->key[len][lx + len] = color;
  91.         tab->key[len][lx + len + 1] = 0;
  92.     } else {
  93.         tab->key[len] = (char *)malloc(len + 2);
  94.         assert(tab->key[len] != 0);
  95.         strcpy(tab->key[len], keyword);
  96.         tab->key[len][len] = color;
  97.     tab->key[len][len + 1] = 0;
  98.     }
  99.     tab->count[len]++;
  100.     tab->TotalCount++;
  101.     return 1;
  102. }
  103. #endif
  104.  
  105. int SetModeNumber(EMode *mode, int what, int number) {
  106.     int j = what;
  107.  
  108.     if (j == BFI_LeftMargin || j == BFI_RightMargin) number--;
  109.     mode->Flags.num[j] = number;
  110.     return 0;
  111. }
  112.  
  113. int SetModeString(EMode *mode, int what, char *string) {
  114.     int j = what;
  115.     
  116. #ifdef CONFIG_SYNTAX_HILIT
  117.     if (j == BFI_Colorizer) {
  118.         mode->fColorize = FindColorizer(string);
  119.     } else
  120. #endif
  121.         if (j == BFI_EventMap) {
  122.         mode->fEventMap = FindEventMap(string);
  123.     } else if (j == BFI_IndentMode) {
  124.         mode->Flags.num[j] = GetIndentMode(string);
  125.     } else if (j == BFS_WordChars) {
  126.         SetWordChars(mode->Flags.WordChars, string);
  127.     } else if (j == BFS_FileNameRx) {
  128.         if (mode->MatchName)
  129.             free(mode->MatchName);
  130.         if (mode->MatchNameRx)
  131.             RxFree(mode->MatchNameRx);
  132.         mode->MatchName = strdup(string);
  133.         mode->MatchNameRx = RxCompile(string);
  134.     } else if (j == BFS_FirstLineRx) {
  135.         if (mode->MatchLine)
  136.             free(mode->MatchLine);
  137.         if (mode->MatchLineRx)
  138.             RxFree(mode->MatchLineRx);
  139.         mode->MatchLine = strdup(string);
  140.         mode->MatchLineRx = RxCompile(string);
  141.     } else {
  142.         mode->Flags.str[j & 0xFF] = strdup(string);
  143.     }
  144.     return 0;
  145. }
  146.  
  147. int SetGlobalNumber(int what, int number) {
  148.     switch (what) {
  149. #ifdef CONFIG_INDENT_C
  150.     case FLAG_C_Indent:          C_Indent = number; break;
  151.     case FLAG_C_BraceOfs:        C_BraceOfs = number; break;
  152.     case FLAG_C_CaseOfs:         C_CaseOfs = number; break;
  153.     case FLAG_C_CaseDelta:       C_CaseDelta = number; break;
  154.     case FLAG_C_ClassOfs:        C_ClassOfs = number; break;
  155.     case FLAG_C_ClassDelta:      C_ClassDelta = number; break;
  156.     case FLAG_C_ColonOfs:        C_ColonOfs = number; break;
  157.     case FLAG_C_CommentOfs:      C_CommentOfs = number; break;
  158.     case FLAG_C_CommentDelta:    C_CommentDelta = number; break;
  159.     case FLAG_C_FirstLevelIndent: C_FirstLevelIndent = number; break;
  160.     case FLAG_C_FirstLevelWidth: C_FirstLevelWidth = number; break;
  161.     case FLAG_C_Continuation:    C_Continuation = number; break;
  162.     case FLAG_C_ParenDelta:      C_ParenDelta = number; break;
  163. #endif
  164. #ifdef CONFIG_INDENT_REXX
  165.     case FLAG_REXX_Indent:       REXX_Base_Indent = number; break;
  166.     case FLAG_REXX_Do_Offset:    REXX_Do_Offset = number; break;
  167. #endif
  168.     case FLAG_ScreenSizeX:       ScreenSizeX = number; break;
  169.     case FLAG_ScreenSizeY:       ScreenSizeY = number; break;
  170.     case FLAG_CursorInsertStart: CursorInsSize[0] = number; break;
  171.     case FLAG_CursorInsertEnd:   CursorInsSize[1] = number; break;
  172.     case FLAG_CursorOverStart:   CursorOverSize[0] = number; break;
  173.     case FLAG_CursorOverEnd:     CursorOverSize[1] = number; break;
  174.     case FLAG_SysClipboard:      SystemClipboard = number; break;
  175.     case FLAG_OpenAfterClose:    OpenAfterClose = number; break;
  176.     case FLAG_ShowVScroll:       ShowVScroll = number; break;
  177.     case FLAG_ShowHScroll:       ShowHScroll = number; break;
  178.     case FLAG_ScrollBarWidth:    ScrollBarWidth = number; break;
  179.     case FLAG_SelectPathname:    SelectPathname = number; break;
  180.     case FLAG_ShowMenuBar:       ShowMenuBar = number; break;
  181.     case FLAG_ShowToolBar:       ShowToolBar = number; break;
  182.     case FLAG_KeepHistory:       KeepHistory = number; break;
  183.     case FLAG_LoadDesktopOnEntry: LoadDesktopOnEntry = number; break;
  184.     case FLAG_SaveDesktopOnExit: SaveDesktopOnExit = number; break;
  185.     case FLAG_KeepMessages:      KeepMessages = number; break;
  186.     case FLAG_ScrollBorderX:     ScrollBorderX = number; break;
  187.     case FLAG_ScrollBorderY:     ScrollBorderY = number; break;
  188.     case FLAG_ScrollJumpX:       ScrollJumpX = number; break;
  189.     case FLAG_ScrollJumpY:       ScrollJumpY = number; break;
  190.     case FLAG_GUIDialogs:        GUIDialogs = number; break;
  191.     case FLAG_PMDisableAccel:    PMDisableAccel = number; break;
  192.     case FLAG_SevenBit:          SevenBit = number; break;
  193.     case FLAG_WeirdScroll:       WeirdScroll = number; break;
  194.     case FLAG_LoadDesktopMode:   LoadDesktopMode = number; break;
  195.     default:
  196.         return -1;
  197.     }
  198.     return 0;
  199. }
  200.  
  201. int SetGlobalString(long what, char *string) {
  202.     switch (what) {
  203.     case FLAG_DefaultModeName: strcpy(DefaultModeName, string); break;
  204.     case FLAG_CompletionFilter: if ((CompletionFilter = RxCompile(string)) == NULL) return -1; break;
  205.     case FLAG_PrintDevice: strcpy(PrintDevice, string); break;
  206.     case FLAG_CompileCommand: strcpy(CompileCommand, string); break;
  207.     case FLAG_WindowFont: strcpy(WindowFont, string); break;
  208.     case FLAG_HelpCommand: strcpy(HelpCommand, string); break;
  209.     default:
  210.         return -1;
  211.     }
  212.     return 0;
  213. }
  214.  
  215. int SetEventString(EEventMap *Map, long what, char *string) {
  216.     switch (what) {
  217.     case EM_MainMenu:
  218.     case EM_LocalMenu:
  219.         Map->SetMenu(what, string);
  220.         break;
  221.     default:
  222.         return -1;
  223.     }
  224.     return 0;
  225. }
  226.  
  227. #ifdef CONFIG_SYNTAX_HILIT
  228. int SetColorizeString(EColorize *Colorize, long what, char *string) {
  229.     switch (what) {
  230.     case COL_SyntaxParser:
  231.         Colorize->SyntaxParser = GetHilitMode(string);
  232.         break;
  233.     default:
  234.         return -1;
  235.     }
  236.     return 0;
  237. }
  238. #endif
  239.  
  240. unsigned char GetObj(CurPos &cp, unsigned short &len) {
  241.     len = 0;
  242.     if (cp.c + 3 <= cp.z) {
  243.         unsigned char c;
  244.         c = *cp.c++;
  245.         memcpy(&len, cp.c, sizeof(unsigned short));
  246.         cp.c += sizeof(unsigned short);
  247.         return c;
  248.     }
  249.     return 0xFF;
  250. }
  251.  
  252. char *GetCharStr(CurPos &cp, unsigned short len) {
  253.     char *p = cp.c;
  254.     if (cp.c + len > cp.z)
  255.         return 0;
  256.     cp.c += len;
  257.     return p;
  258. }
  259.  
  260. char *GetString(CurPos &cp) {
  261.     unsigned short len;
  262.     
  263.     if (GetObj(cp, len) == 0xFF) return 0;
  264.     return GetCharStr(cp, len);
  265. }
  266.  
  267. int GetNum(CurPos &cp, long &num) {
  268.     if (cp.c + sizeof(long) > cp.z) return 0;
  269.     memcpy(&num, cp.c, sizeof(long));
  270.     cp.c += sizeof(long);
  271.     return 1;
  272. }
  273.  
  274. int ReadCommands(CurPos &cp, char *Name) {
  275.     unsigned char obj;
  276.     unsigned short len;
  277.     long Cmd = NewCommand(Name);
  278.     long cmdno;
  279.     
  280.     if (GetObj(cp, len) != CF_INT) return-1;
  281.     if (GetNum(cp, cmdno) == 0) return -1;
  282.     if (cmdno != (Cmd | CMD_EXT)) {
  283.         fprintf(stderr, "Bad Command map %s -> %ld != %ld\n", Name, Cmd, cmdno);
  284.         return -1;
  285.     }
  286.     
  287.     while ((obj = GetObj(cp, len)) != 0xFF) {
  288.         switch (obj) {
  289.         case CF_COMMAND:
  290.             {
  291.   //              char *s;
  292.                 long cnt;
  293.                 long ign;
  294.                 long cmd;
  295.                 
  296. //                if ((s = GetCharStr(cp, len)) == 0) return -1;
  297.                 if (GetNum(cp, cmd) == 0) return -1;
  298.                 if (GetObj(cp, len) != CF_INT) return -1;
  299.                 if (GetNum(cp, cnt) == 0) return -1;
  300.                 if (GetObj(cp, len) != CF_INT) return -1;
  301.                 if (GetNum(cp, ign) == 0) return -1;
  302.                 
  303. //                if (cmd != CmdNum(s)) {
  304. //                    fprintf(stderr, "Bad Command Id: %s -> %d\n", s, cmd);
  305. //                    return -1;
  306. //                }
  307.                 
  308.                 if (AddCommand(Cmd, cmd, cnt, ign) == 0) {
  309.                     if (Name == 0 || strcmp(Name, "xx") != 0) {
  310.                         fprintf(stderr, "Bad Command Id: %ld\n", cmd);
  311.                         return -1;
  312.                     }
  313.                 }
  314.             }
  315.             break;
  316.         case CF_STRING:
  317.             {
  318.                 char *s = GetCharStr(cp, len);
  319.                 
  320.                 if (s == 0) return -1;
  321.                 if (AddString(Cmd, s) == 0) return -1;
  322.             }
  323.             break;
  324.         case CF_INT:
  325.             {
  326.                 long num;
  327.                 
  328.                 if (GetNum(cp, num) == 0) return -1;
  329.                 if (AddNumber(Cmd, num) == 0) return -1;
  330.             }
  331.             break;
  332.         case CF_VARIABLE:
  333.             {
  334.                 long num;
  335.                 
  336.                 if (GetNum(cp, num) == 0) return -1;
  337.                 if (AddVariable(Cmd, num) == 0) return -1;
  338.             }
  339.             break;
  340.         case CF_CONCAT:
  341.             if (AddConcat(Cmd) == 0) return -1;
  342.             break;
  343.         case CF_END:
  344.             return Cmd;
  345.         default:
  346.             return -1;
  347.         }
  348.     }
  349.     return -1;
  350. }
  351.  
  352. int ReadMenu(CurPos &cp, char *MenuName) {
  353.     unsigned char obj;
  354.     unsigned short len;
  355.     
  356.     int menu = -1, item = -1;
  357.  
  358.     menu = NewMenu(MenuName);
  359.  
  360.     while ((obj = GetObj(cp, len)) != 0xFF) {
  361.         switch (obj) {
  362.         case CF_ITEM:
  363.             {
  364.                 if (len == 0) {
  365.                     item = NewItem(menu, 0);
  366.                 } else {
  367.                     char *s = GetCharStr(cp, len);
  368.                     int Cmd;
  369.                     if (s == 0) return -1;
  370.                     item = NewItem(menu, s);
  371.                     if ((obj = GetObj(cp, len)) != CF_MENUSUB) return -1;
  372.                     if ((Cmd = ReadCommands(cp, 0)) == -1) return -1;
  373.                     Menus[menu].Items[item].Cmd = Cmd + 65536;
  374.                 }
  375.             }
  376.             break;
  377.         case CF_SUBMENU:
  378.             {
  379.                 char *s = GetCharStr(cp, len);
  380.                 char *w;
  381.                 
  382.                 if ((obj = GetObj(cp, len)) != CF_STRING) return -1;
  383.                 if ((w = GetCharStr(cp, len)) == 0) return -1;
  384.                 item = NewSubMenu(menu, s, GetMenuId(w), SUBMENU_NORMAL);
  385.             }
  386.             break;
  387.  
  388.         case CF_SUBMENUCOND:
  389.             {
  390.                 char *s = GetCharStr(cp, len);
  391.                 char *w;
  392.                 
  393.                 if ((obj = GetObj(cp, len)) != CF_STRING) return -1;
  394.                 if ((w = GetCharStr(cp, len)) == 0) return -1;
  395.                 item = NewSubMenu(menu, s, GetMenuId(w), SUBMENU_CONDITIONAL);
  396.             }
  397.             break;
  398.             
  399.         case CF_END:
  400.             return 0;
  401.         default:
  402.             return -1;
  403.         }
  404.     }
  405.     return -1;
  406. }
  407.  
  408. int ReadColors(CurPos &cp, char *ObjName) {
  409.     unsigned char obj;
  410.     unsigned short len;
  411.     
  412.     while ((obj = GetObj(cp, len)) != 0xFF) {
  413.         switch (obj) {
  414.         case CF_STRING:
  415.             {
  416.                 char cl[30];
  417.                 char *sname = GetCharStr(cp, len);
  418.                 char *svalue;
  419.                 if (sname == 0) return -1;
  420.                 if ((obj = GetObj(cp, len)) != CF_STRING) return -1;
  421.                 if ((svalue = GetCharStr(cp, len)) == 0) return -1;
  422.                 strcpy(cl, ObjName);
  423.                 strcat(cl, ".");
  424.                 strcat(cl, sname);
  425.                 if (SetColor(cl, svalue) == 0) return -1;
  426.             }
  427.             break;
  428.         case CF_END:
  429.             return 0;
  430.         default:
  431.             return -1;
  432.         }
  433.     }
  434.     return -1;
  435. }
  436.  
  437. #ifdef CONFIG_SYNTAX_HILIT
  438. int ReadHilitColors(CurPos &cp, EColorize *Colorize, char */*ObjName*/) {
  439.     unsigned char obj;
  440.     unsigned short len;
  441.     
  442.     while ((obj = GetObj(cp, len)) != 0xFF) {
  443.         switch (obj) {
  444.         case CF_INT:
  445.             {
  446.                 long cidx;
  447.                 char *svalue;
  448.                 
  449.                 if (GetNum(cp, cidx) == 0) return -1;
  450.                 if ((obj = GetObj(cp, len)) != CF_STRING)
  451.                     return -1;
  452.                 if ((svalue = GetCharStr(cp, len)) == 0)
  453.                     return -1;
  454.                 if (Colorize->SetColor(cidx, svalue) == 0)
  455.                     return -1;
  456.             }
  457.             break;
  458.         case CF_END:
  459.             return 0;
  460.         default:
  461.             return -1;
  462.         }
  463.     }
  464.     return -1;
  465. }
  466.  
  467. int ReadKeywords(CurPos &cp, ColorKeywords *keywords, int color) {
  468.     unsigned char obj;
  469.     unsigned short len;
  470.     
  471.     while ((obj = GetObj(cp, len)) != 0xFF) {
  472.         switch (obj) {
  473.         case CF_STRING:
  474.             {
  475.                 char *kname = GetCharStr(cp, len);
  476.                 if (kname == 0) return -1;
  477.                 if (AddKeyword(keywords, (char) color, kname) != 1) return -1;
  478.             }
  479.             break;
  480.         case CF_END:
  481.             return 0;
  482.         default:
  483.             return -1;
  484.         }
  485.     }
  486.     return -1;
  487. }
  488. #endif
  489.  
  490. int ReadEventMap(CurPos &cp, EEventMap *Map, char */*MapName*/) {
  491.     unsigned char obj;
  492.     unsigned short len;
  493.     
  494.     while ((obj = GetObj(cp, len)) != 0xFF) {
  495.         switch (obj) {
  496.         case CF_KEY:
  497.             {
  498.                 EKey *Key;
  499.                 char *s;
  500.                 int Cmd;
  501.                 
  502.                 if ((s = GetCharStr(cp, len)) == 0) return -1;
  503.                 if ((Key = SetKey(Map, s)) == 0) return -1;
  504.                 if ((obj = GetObj(cp, len)) != CF_KEYSUB) return -1;
  505.                 if ((Cmd = ReadCommands(cp, 0)) == -1) return -1;
  506.                 Key->Cmd = Cmd;
  507.             }
  508.             break;
  509.  
  510. #ifdef CONFIG_ABBREV
  511.         case CF_ABBREV:
  512.             {
  513.                 EAbbrev *Ab;
  514.                 char *s;
  515.                 char *x;
  516.                 int Cmd;
  517.                 
  518.                 if ((s = GetCharStr(cp, len)) == 0) return -1;
  519.                 obj = GetObj(cp, len);
  520.                 if (obj == CF_KEYSUB) {
  521.                     if ((Cmd = ReadCommands(cp, 0)) == -1) return -1;
  522.                     Ab = new EAbbrev(s, Cmd);
  523.                 } else if (obj == CF_STRING) {
  524.                     x = GetCharStr(cp, len);
  525.                     Ab = new EAbbrev(s, x);
  526.                 } else
  527.                     return -1;
  528.                 if (Ab) {
  529.                     Map->AddAbbrev(Ab);
  530.                 }
  531.             }
  532.             break;
  533. #endif
  534.             
  535.         case CF_SETVAR:
  536.             {
  537.                 long what;
  538.                 
  539.                 if (GetNum(cp, what) == 0) return -1;
  540.                 switch (GetObj(cp, len)) {
  541.                 case CF_STRING:
  542.                     {
  543.                         char *val = GetCharStr(cp, len);
  544.                         if (len == 0) return -1;
  545.                         if (SetEventString(Map, what, val) != 0) return -1;
  546.                     }
  547.                     break;
  548. /*                case CF_INT:
  549.                     {
  550.                         long num;
  551.                         
  552.                         if (GetNum(cp, num) == 0) return -1;
  553.                         if (SetModeNumber(Mode, what, num) != 0) return -1;
  554.                     }
  555.                 break;*/
  556.                 default:
  557.                     return -1;
  558.                 }
  559.             }
  560.             break;
  561.         case CF_END:
  562.             return 0;
  563.         default:
  564.             return -1;
  565.         }
  566.     }
  567.     return -1;
  568. }
  569.  
  570. #ifdef CONFIG_SYNTAX_HILIT
  571. int ReadColorize(CurPos &cp, EColorize *Colorize, char *ModeName) {
  572.     unsigned char obj;
  573.     unsigned short len;
  574.  
  575.     long LastState = -1;
  576.     
  577.     while ((obj = GetObj(cp, len)) != 0xFF) {
  578.         switch (obj) {
  579.         case CF_COLOR:
  580.             if (ReadHilitColors(cp, Colorize, ModeName) == -1) return -1;
  581.             break;
  582.         
  583.         case CF_KEYWORD:
  584.             {
  585.                 char *colorstr;
  586.                 
  587.                 if ((colorstr = GetCharStr(cp, len)) == 0) return -1;
  588.  
  589.                 unsigned int Col;
  590.                 unsigned int ColBg, ColFg;
  591.                 
  592.                 if (sscanf(colorstr, "%1X %1X", &ColFg, &ColBg) != 2)
  593.                     return 0;
  594.                 
  595.                 Col = ColFg | (ColBg << 4);
  596.                 
  597.                 int color = ChColor(Col);
  598.                 if (ReadKeywords(cp, &Colorize->Keywords, color) == -1) return -1;
  599.             }
  600.             break;
  601.  
  602.         case CF_HSTATE:
  603.             {
  604.                 long stateno;
  605.                 long color;
  606.                 
  607.                 if (Colorize->hm == 0)
  608.                     Colorize->hm = new HMachine();
  609.  
  610.                 assert(Colorize->hm != 0);
  611.  
  612.                 if (GetNum(cp, stateno) == 0)
  613.                     return -1;
  614.  
  615.                 assert(stateno == LastState + 1);
  616.  
  617.                 obj = GetObj(cp, len);
  618.                 assert(obj == CF_INT);
  619.  
  620.                 if (GetNum(cp, color) == 0)
  621.                     return -1;
  622.  
  623.                 HState newState;
  624.  
  625.                 newState.InitState();
  626.  
  627.                 newState.color = color;
  628.  
  629.                 Colorize->hm->AddState(newState);
  630.                 LastState = stateno;
  631.             }
  632.             break;
  633.  
  634.         case CF_HTRANS:
  635.             {
  636.                 HTrans newTrans;
  637.                 long nextState;
  638.                 long matchFlags;
  639.                 char *match;
  640.                 long color;
  641.  
  642.                 if (GetNum(cp, nextState) == 0)
  643.                     return -1;
  644.                 obj = GetObj(cp, len);
  645.                 assert(obj == CF_INT);
  646.                 if (GetNum(cp, matchFlags) == 0)
  647.                     return -1;
  648.                 obj = GetObj(cp, len);
  649.                 assert(obj == CF_INT);
  650.                 if (GetNum(cp, color) == 0)
  651.                     return -1;
  652.                 obj = GetObj(cp, len);
  653.                 assert(obj == CF_STRING);
  654.                 if ((match = GetCharStr(cp, len)) == 0)
  655.                     return -1;
  656.  
  657.                 newTrans.InitTrans();
  658.  
  659.                 newTrans.matchFlags = matchFlags;
  660.                 newTrans.nextState = nextState;
  661.                 newTrans.color = color;
  662.                 
  663.                 if ((newTrans.matchFlags & MATCH_SET) ||
  664.                     (newTrans.matchFlags & MATCH_NOTSET))
  665.                 {
  666.                     newTrans.matchLen = 1;
  667.                     assert((newTrans.match = (char *)malloc(256/8)) != 0);
  668.                     SetWordChars(newTrans.match, match);
  669.                 } else {
  670.                     newTrans.match = strdup(match);
  671.                     newTrans.matchLen = strlen(match);
  672.                 }
  673.  
  674.                 Colorize->hm->AddTrans(newTrans);
  675.             }
  676.             break;
  677.  
  678.         case CF_HWTYPE:
  679.             {
  680.                 long nextKwdMatchedState;
  681.                 long nextKwdNotMatchedState;
  682.                 long nextKwdNoCharState;
  683.                 long options;
  684.                 char *wordChars;
  685.  
  686.                 obj = GetObj(cp, len);
  687.                 assert(obj == CF_INT);
  688.                 if (GetNum(cp, nextKwdMatchedState) == 0)
  689.                     return -1;
  690.  
  691.                 obj = GetObj(cp, len);
  692.                 assert(obj == CF_INT);
  693.                 if (GetNum(cp, nextKwdNotMatchedState) == 0)
  694.                     return -1;
  695.  
  696.                 obj = GetObj(cp, len);
  697.                 assert(obj == CF_INT);
  698.                 if (GetNum(cp, nextKwdNoCharState) == 0)
  699.                     return -1;
  700.  
  701.                 obj = GetObj(cp, len);
  702.                 assert(obj == CF_INT);
  703.                 if (GetNum(cp, options) == 0)
  704.                     return -1;
  705.  
  706.                 obj = GetObj(cp, len);
  707.                 assert(obj == CF_STRING);
  708.                 if ((wordChars = GetCharStr(cp, len)) == 0)
  709.                     return -1;
  710.  
  711.                 Colorize->hm->LastState()->options = options;
  712.                 Colorize->hm->LastState()->nextKwdMatchedState = nextKwdMatchedState;
  713.                 Colorize->hm->LastState()->nextKwdNotMatchedState = nextKwdNotMatchedState;
  714.                 Colorize->hm->LastState()->nextKwdNoCharState = nextKwdNoCharState;
  715.                 
  716.                 if (wordChars && *wordChars) {
  717.                     assert((Colorize->hm->LastState()->wordChars = (char *)malloc(256/8)) != 0);
  718.                     SetWordChars(Colorize->hm->LastState()->wordChars, wordChars);
  719.                 }
  720.             }
  721.             break;
  722.  
  723.         case CF_HWORDS:
  724.             {
  725.                 char *colorstr;
  726.                 int color;
  727.  
  728.                 if ((colorstr = GetCharStr(cp, len)) == 0) return -1;
  729.                 
  730.                 color = hcPlain_Keyword;
  731.                 
  732.                 if (strcmp(colorstr, "-") != 0) {
  733.                     char *Value = colorstr;
  734.                     int Col;
  735.                     
  736.                     if (*Value == '-') {
  737.                         Value++;
  738.                         if (sscanf(Value, "%1X", &Col) != 1) return -1;
  739.                         Col |= (hcPlain_Background & 0xF0);
  740.                     } else if (Value[1] == '-') {
  741.                         if (sscanf(Value, "%1X", &Col) != 1) return -1;
  742.                         Col <<= 4;
  743.                         Col |= (hcPlain_Background & 0x0F);
  744.                     } else {
  745.                         if (sscanf(Value, "%2X", &Col) != 1) return -1;
  746.                     }
  747.                     color = Col;
  748.                 }
  749.                 if (ReadKeywords(cp, &Colorize->hm->LastState()->keywords, color) == -1) return -1;
  750.             }
  751.             break;
  752.  
  753.         case CF_SETVAR:
  754.             {
  755.                 long what;
  756.                 
  757.                 if (GetNum(cp, what) == 0) return -1;
  758.                 switch (GetObj(cp, len)) {
  759.                 case CF_STRING:
  760.                     {
  761.                         char *val = GetCharStr(cp, len);
  762.                         if (len == 0) return -1;
  763.                         if (SetColorizeString(Colorize, what, val) != 0) return -1;
  764.                     }
  765.                     break;
  766. /*                case CF_INT:
  767.                     {
  768.                         long num;
  769.                         
  770.                         if (GetNum(cp, num) == 0) return -1;
  771.                         if (SetModeNumber(Mode, what, num) != 0) return -1;
  772.                     }
  773.                 break;*/
  774.                 default:
  775.                     return -1;
  776.                 }
  777.             }
  778.             break;
  779.         case CF_END:
  780.             return 0;
  781.         default:
  782.             return -1;
  783.         }
  784.     }
  785.     return -1;
  786. }
  787. #endif
  788.  
  789. int ReadMode(CurPos &cp, EMode *Mode, char */*ModeName*/) {
  790.     unsigned char obj;
  791.     unsigned short len;
  792.     
  793.     while ((obj = GetObj(cp, len)) != 0xFF) {
  794.         switch (obj) {
  795.         case CF_SETVAR:
  796.             {
  797.                 long what;
  798.                 
  799.                 if (GetNum(cp, what) == 0) return -1;
  800.                 switch (GetObj(cp, len)) {
  801.                 case CF_STRING:
  802.                     {
  803.                         char *val = GetCharStr(cp, len);
  804.                         if (len == 0) return -1;
  805.                         if (SetModeString(Mode, what, val) != 0) return -1;
  806.                     }
  807.                     break;
  808.                 case CF_INT:
  809.                     {
  810.                         long num;
  811.                         
  812.                         if (GetNum(cp, num) == 0) return -1;
  813.                         if (SetModeNumber(Mode, what, num) != 0) return -1;
  814.                     }
  815.                 break;
  816.                 default:
  817.                     return -1;
  818.                 }
  819.             }
  820.             break;
  821.         case CF_END:
  822.             return 0;
  823.         default:
  824.             return -1;
  825.         }
  826.     }
  827.     return -1;
  828. }
  829.  
  830. int ReadObject(CurPos &cp, char *ObjName) {
  831.     unsigned char obj;
  832.     unsigned short len;
  833.     
  834.     while ((obj = GetObj(cp, len)) != 0xFF) {
  835.         switch (obj) {
  836.         case CF_COLOR:
  837.             if (ReadColors(cp, ObjName) == -1) return -1;
  838.             break;
  839. #ifdef CONFIG_OBJ_MESSAGES
  840.         case CF_COMPRX:
  841.             {
  842.                 long file, line, msg;
  843.                 char *regexp;
  844.                 
  845.                 if (GetObj(cp, len) != CF_INT) return -1;
  846.                 if (GetNum(cp, file) == 0) return -1;
  847.                 if (GetObj(cp, len) != CF_INT) return -1;
  848.                 if (GetNum(cp, line) == 0) return -1;
  849.                 if (GetObj(cp, len) != CF_INT) return -1;
  850.                 if (GetNum(cp, msg) == 0) return -1;
  851.                 if (GetObj(cp, len) != CF_REGEXP) return -1;
  852.                 if ((regexp = GetCharStr(cp, len)) == 0) return -1;
  853.                 
  854.                 if (AddCRegexp(file, line, msg, regexp) == 0) return -1;
  855.             }
  856.             break;
  857. #endif
  858.         case CF_SETVAR:
  859.             {
  860.                 long what;
  861.                 if (GetNum(cp, what) == 0) return -1;
  862.                 
  863.                 switch (GetObj(cp, len)) {
  864.                 case CF_STRING:
  865.                     {
  866.                         char *val = GetCharStr(cp, len);
  867.                         if (len == 0) return -1;
  868.                         if (SetGlobalString(what, val) != 0) return -1;
  869.                     }
  870.                     break;
  871.                 case CF_INT:
  872.                     {
  873.                         long num;
  874.                         
  875.                         if (GetNum(cp, num) == 0) return -1;
  876.                         if (SetGlobalNumber(what, num) != 0) return -1;
  877.                     }
  878.                 break;
  879.                 default:
  880.                     return -1;
  881.                 }
  882.             }
  883.             break;
  884.         case CF_END:
  885.             return 0;
  886.         default:
  887.             return -1;
  888.         }
  889.     }
  890.     return -1;
  891. }
  892.             
  893. int ReadConfigFile(CurPos &cp) {
  894.     unsigned char obj;
  895.     unsigned short len;
  896.  
  897.     {
  898.         char *p;
  899.         
  900.         obj = GetObj(cp, len);
  901.         assert(obj == CF_STRING);
  902.         if ((p = GetCharStr(cp, len)) == 0)
  903.             return -1;
  904.         ConfigSourcePath = strdup(p);
  905.     }
  906.     
  907.     while ((obj = GetObj(cp, len)) != 0xFF) {
  908.         switch (obj) {
  909.         case CF_SUB:
  910.             {
  911.                 char *CmdName = GetCharStr(cp, len);
  912.                 
  913.                 if (ReadCommands(cp, strdup(CmdName)) == -1) return -1;
  914.             }
  915.             break;
  916.         case CF_MENU:
  917.             {
  918.                 char *MenuName = GetCharStr(cp, len);
  919.                 
  920.                 if (ReadMenu(cp, MenuName) == -1) return -1;
  921.             }
  922.             break;
  923.         case CF_EVENTMAP:
  924.             {
  925.                 EEventMap *EventMap = 0;
  926.                 char *MapName = GetCharStr(cp, len);
  927.                 char *UpMap = 0;
  928.                 
  929.                 if ((obj = GetObj(cp, len)) != CF_PARENT) return -1;
  930.                 if (len > 0)
  931.                     if ((UpMap = GetCharStr(cp, len)) == 0) return -1;
  932.             
  933.                 // add new mode
  934.                 if ((EventMap = FindEventMap(MapName)) == 0) {
  935.                     EEventMap *OrgMap = 0;
  936.                     
  937.                     if (strcmp(UpMap, "") != 0)
  938.                         OrgMap = FindEventMap(UpMap);
  939.                     EventMap = new EEventMap(MapName, OrgMap);
  940.                 } else {
  941.                     if (EventMap->Parent == 0)
  942.                         EventMap->Parent = FindEventMap(UpMap);
  943.                 }
  944.                 if (ReadEventMap(cp, EventMap, MapName) == -1) return -1;
  945.             }
  946.             break;
  947.  
  948.         case CF_COLORIZE:
  949.             {
  950.                 EColorize *Mode = 0;
  951.                 char *ModeName = GetCharStr(cp, len);
  952.                 char *UpMode = 0;
  953.                 
  954.                 if ((obj = GetObj(cp, len)) != CF_PARENT) return -1;
  955.                 if (len > 0)
  956.                     if ((UpMode = GetCharStr(cp, len)) == 0) return -1;
  957.                 
  958.                 // add new mode
  959.                 if ((Mode = FindColorizer(ModeName)) == 0)
  960.                     Mode = new EColorize(ModeName, UpMode);
  961.                 else {
  962.                     if (Mode->Parent == 0)
  963.                         Mode->Parent = FindColorizer(UpMode);
  964.                 }
  965.                 if (ReadColorize(cp, Mode, ModeName) == -1)
  966.                     return -1;
  967.             }
  968.             break;
  969.  
  970.         case CF_MODE:
  971.             {
  972.                 EMode *Mode = 0;
  973.                 char *ModeName = GetCharStr(cp, len);
  974.                 char *UpMode = 0;
  975.                 
  976.                 if ((obj = GetObj(cp, len)) != CF_PARENT) return -1;
  977.                 if (len > 0)
  978.                     if ((UpMode = GetCharStr(cp, len)) == 0) return -1;
  979.                 
  980.                 // add new mode
  981.                 if ((Mode = FindMode(ModeName)) == 0) {
  982.                     EMode *OrgMode = 0;
  983.                     EEventMap *Map;
  984.                     
  985.                     if (strcmp(UpMode, "") != 0)
  986.                         OrgMode = FindMode(UpMode);
  987.                     Map = FindEventMap(ModeName);
  988.                     if (Map == 0) {
  989.                         EEventMap *OrgMap = 0;
  990.                         
  991.                         if (strcmp(UpMode, "") != 0)
  992.                             OrgMap = FindEventMap(UpMode);
  993.                         Map = new EEventMap(ModeName, OrgMap);
  994.                     }
  995.                     Mode = new EMode(OrgMode, Map, ModeName);
  996.                     Mode->fNext = Modes;
  997.                     Modes = Mode;
  998.                 } else {
  999.                     if (Mode->fParent == 0)
  1000.                         Mode->fParent = FindMode(UpMode);
  1001.                 }
  1002.                 if (ReadMode(cp, Mode, ModeName) == -1)
  1003.                     return -1;
  1004.             }
  1005.             break;
  1006.         case CF_OBJECT:
  1007.             {
  1008.                 char *ObjName;
  1009.                 
  1010.                 if ((ObjName = GetCharStr(cp, len)) == 0)
  1011.                     return -1;
  1012.                 if (ReadObject(cp, ObjName) == -1)
  1013.                     return -1;
  1014.             }
  1015.             break;
  1016.         case CF_EOF:
  1017.             return 0;
  1018.         default:
  1019.             return -1;
  1020.         }
  1021.     }
  1022.     return -1;
  1023. }
  1024.  
  1025. int LoadConfig(int /*argc*/, char **/*argv*/, char *CfgFileName) {
  1026.     int fd, rc;
  1027.     char *buffer = 0;
  1028.     struct stat statbuf;
  1029.     CurPos cp;
  1030.     
  1031.     if ((fd = open(CfgFileName, O_RDONLY | O_BINARY)) == -1)
  1032.         return -1;
  1033.     if (fstat(fd, &statbuf) != 0) {
  1034.         close(fd);
  1035.         return -1;
  1036.     }
  1037.     buffer = (char *) malloc(statbuf.st_size);
  1038.     if (buffer == 0) {
  1039.         close(fd);
  1040.         return -1;
  1041.     }
  1042.     if (read(fd, buffer, statbuf.st_size) != statbuf.st_size) {
  1043.         close(fd);
  1044.         return -1;
  1045.     }
  1046.     close(fd);
  1047.     
  1048.     if (*(long *)buffer != CONFIG_ID) {
  1049.         DieError(0, "Bad .CNF signature");
  1050.         return -1;
  1051.     }
  1052.  
  1053.     if (((long *)buffer)[1] != VERNUM) {
  1054.         DieError(0, "Bad .CNF version.");
  1055.         return -1;
  1056.     }
  1057.     
  1058.     cp.name = CfgFileName;
  1059.     cp.sz = statbuf.st_size;
  1060.     cp.a = buffer;
  1061.     cp.c = cp.a + 2 * sizeof(long);
  1062.     cp.z = cp.a + cp.sz;
  1063.     cp.line = 1;
  1064.  
  1065.     rc = ReadConfigFile(cp);
  1066.  
  1067.     free(buffer);
  1068.     
  1069.     if (rc == -1) {
  1070.         DieError(1, "Error %s offset %d\n", CfgFileName, cp.c - cp.a);
  1071.     }
  1072.     return rc;
  1073. }
  1074.  
  1075. #include "defcfg.h"
  1076.  
  1077. int UseDefaultConfig() {
  1078.     CurPos cp;
  1079.     int rc;
  1080.     
  1081.     cp.name = "Internal Configuration";
  1082.     cp.sz = sizeof(DefaultConfig);
  1083.     cp.a = (char *)DefaultConfig;
  1084.     cp.c = (char *)DefaultConfig + 2 * sizeof(long);
  1085.     cp.z = cp.a + cp.sz;
  1086.     cp.line = 1;
  1087.     
  1088.     rc = ReadConfigFile(cp);
  1089.     
  1090.     if (rc == -1)
  1091.         DieError(1, "Error %s offset %d\n", cp.name, cp.c - cp.a);
  1092.     return rc;
  1093. }
  1094.