home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / mmm_pkg.zip / mmmx.cpp < prev    next >
C/C++ Source or Header  |  1996-12-05  |  53KB  |  1,582 lines
  1. /**********************************************
  2. ***********************************************
  3. ***  Main Editor file, contains commands,   ***
  4. ***  macro-language & setup stuff           ***
  5. ***********************************************
  6. **********************************************/
  7. //&<<&MMM headers
  8. #include "mmmgrep.h"
  9. #include "mmm_comm.h"
  10.  
  11. #ifdef __DOS__
  12.     #include "mmm_dos.h"
  13. #endif
  14. #ifdef WIN32
  15.     #include "mmm_w95.h"
  16. #endif
  17. #ifdef __OS2__
  18.     #include "mmm_os2.h"
  19. #endif
  20. #ifdef __linux__
  21.     #include "mmm_lnx.h"
  22. #endif
  23.  
  24. //&>>&10 0 10 16
  25.  
  26. //&<<&Global class elements     !!!!!!  UN-EDIT-ABLE  !!!!!!
  27. //&<<&TPair_String_Function CommandArray[LEN_COMMAND_ARRAY]={  /// the first (before editor)
  28.     TPair_String_Function CommandArray[LEN_COMMAND_ARRAY]={
  29.         TPair_String_Function ( "Ascii0"        , MMMlib_Ascii0        ) ,
  30.         TPair_String_Function ( "Ascii1"        , MMMlib_Ascii1        ) ,
  31.         TPair_String_Function ( "Ascii2"        , MMMlib_Ascii2        ) ,
  32.         TPair_String_Function ( "Space"         , MMMlib_Space         ) ,
  33.         TPair_String_Function ( "Up"            , MMMlib_Up            ) ,
  34.         TPair_String_Function ( "Down"          , MMMlib_Down          ) ,
  35.         TPair_String_Function ( "Left"          , MMMlib_Left          ) ,
  36.         TPair_String_Function ( "Right"         , MMMlib_Right         ) ,
  37.         TPair_String_Function ( "TUp"           , MMMlib_TUp           ) ,
  38.         TPair_String_Function ( "TDown"         , MMMlib_TDown         ) ,
  39.         TPair_String_Function ( "TLeft"         , MMMlib_TLeft         ) ,
  40.         TPair_String_Function ( "TRight"        , MMMlib_TRight        ) ,
  41.         TPair_String_Function ( "PUp"           , MMMlib_PUp           ) ,
  42.         TPair_String_Function ( "PDown"         , MMMlib_PDown         ) ,
  43.         TPair_String_Function ( "FUp"           , MMMlib_FUp           ) ,
  44.         TPair_String_Function ( "FDown"         , MMMlib_FDown         ) ,
  45.         TPair_String_Function ( "FLeft"         , MMMlib_FLeft         ) ,
  46.         TPair_String_Function ( "FRight"        , MMMlib_FRight        ) ,
  47.         TPair_String_Function ( "Enter"         , MMMlib_Enter         ) ,
  48.         TPair_String_Function ( "Tab"           , MMMlib_Tab           ) ,
  49.         TPair_String_Function ( "LTab"          , MMMlib_LTab          ) ,
  50.         TPair_String_Function ( "InsCh"         , MMMlib_InsCh         ) ,
  51.         TPair_String_Function ( "DelCh"         , MMMlib_DelCh         ) ,
  52.         TPair_String_Function ( "InsLine"       , MMMlib_InsLine       ) ,
  53.         TPair_String_Function ( "InsFold"       , MMMlib_InsFold       ) ,
  54.         TPair_String_Function ( "DelLine"       , MMMlib_DelLine       ) ,
  55.         TPair_String_Function ( "BS"            , MMMlib_BS            ) ,
  56.         TPair_String_Function ( "KillEnd"       , MMMlib_KillEnd       ) ,
  57.         TPair_String_Function ( "KillBeg"       , MMMlib_KillBeg       ) ,
  58.         TPair_String_Function ( "CSave"         , MMMlib_CSave         ) ,
  59.         TPair_String_Function ( "CMove"         , MMMlib_CMove         ) ,
  60.         TPair_String_Function ( "WSave"         , MMMlib_WSave         ) ,
  61.         TPair_String_Function ( "WMove"         , MMMlib_WMove         ) ,
  62.         TPair_String_Function ( "BWord"         , MMMlib_BWord         ) ,
  63.         TPair_String_Function ( "TSave"         , MMMlib_TSave         ) ,
  64.         TPair_String_Function ( "TMove"         , MMMlib_TMove         ) ,
  65.         TPair_String_Function ( "CRest"         , MMMlib_CRest         ) ,
  66.         TPair_String_Function ( "CClear"        , MMMlib_CClear        ) ,
  67.         TPair_String_Function ( "LSave"         , MMMlib_LSave         ) ,
  68.         TPair_String_Function ( "LTSave"        , MMMlib_LTSave        ) ,
  69.         TPair_String_Function ( "LMove"         , MMMlib_LMove         ) ,
  70.         TPair_String_Function ( "LTMove"        , MMMlib_LTMove        ) ,
  71.         TPair_String_Function ( "LRest"         , MMMlib_LRest         ) ,
  72.         TPair_String_Function ( "LClear"        , MMMlib_LClear        ) ,
  73.         TPair_String_Function ( "Escape"        , MMMlib_Escape        ) ,
  74.         TPair_String_Function ( "EscapeExec"    , MMMlib_EscapeExec    ) ,
  75.         TPair_String_Function ( "EscapeExecLCB" , MMMlib_EscapeExecLCB ) ,
  76.         TPair_String_Function ( "ABORT"         , MMMlib_ABORT         ) ,
  77.         TPair_String_Function ( "S_AutoIndent"  , MMMlib_S_AutoIndent  ) ,
  78.         TPair_String_Function ( "S_ModeIns"     , MMMlib_S_ModeIns     ) ,
  79.         TPair_String_Function ( "S_ModeOvr"     , MMMlib_S_ModeOvr     ) ,
  80.         TPair_String_Function ( "S_ACode1"      , MMMlib_S_ACode1      ) ,
  81.         TPair_String_Function ( "S_ACode2"      , MMMlib_S_ACode2      ) ,
  82.         TPair_String_Function ( "S_ACode3"      , MMMlib_S_ACode3      ) ,
  83.         TPair_String_Function ( "S_StatusLine"  , MMMlib_S_StatusLine  ) ,
  84.         TPair_String_Function ( "S_SearchMode"  , MMMlib_S_SearchMode  ) ,
  85.         TPair_String_Function ( "SearchFWD"     , MMMlib_SearchFWD     ) ,
  86.         TPair_String_Function ( "SearchBCK"     , MMMlib_SearchBCK     ) ,
  87.         TPair_String_Function ( "Replace"       , MMMlib_Replace       ) ,
  88.         TPair_String_Function ( "SearchPage"    , MMMlib_SearchPage    ) ,
  89.         TPair_String_Function ( "PageIns"       , MMMlib_PageIns       ) ,
  90.         TPair_String_Function ( "MarkUp"        , MMMlib_MarkUp        ) ,
  91.         TPair_String_Function ( "MarkDown"      , MMMlib_MarkDown      ) ,
  92.         TPair_String_Function ( "MarkTUp"       , MMMlib_MarkTUp       ) ,
  93.         TPair_String_Function ( "MarkTDown"     , MMMlib_MarkTDown     ) ,
  94.         TPair_String_Function ( "MarkPUp"       , MMMlib_MarkPUp       ) ,
  95.         TPair_String_Function ( "MarkPDown"     , MMMlib_MarkPDown     ) ,
  96.         TPair_String_Function ( "MarkSaveB"     , MMMlib_MarkSaveB     ) ,
  97.         TPair_String_Function ( "MarkRestB"     , MMMlib_MarkRestB     ) ,
  98.         TPair_String_Function ( "MarkLast"      , MMMlib_MarkLast      ) ,
  99.         TPair_String_Function ( "MarkFirst"     , MMMlib_MarkFirst     ) ,
  100.         TPair_String_Function ( "MarkPrev"      , MMMlib_MarkPrev      ) ,
  101.         TPair_String_Function ( "MarkNext"      , MMMlib_MarkNext      ) ,
  102.         TPair_String_Function ( "MarkBS"        , MMMlib_MarkBS        ) ,
  103.         TPair_String_Function ( "Macro"         , MMMlib_Macro         ) ,
  104.         TPair_String_Function ( "MacroRec"      , MMMlib_MacroRec      ) ,
  105.         TPair_String_Function ( "Console"       , MMMlib_Console       )
  106.         };
  107. //&>>&14 0 D 30
  108. TKeyArray KeyArray;                /// the second (before editor)
  109. TCommandUsrArray CommandUsrArray;  /// also before editor
  110. EDITOR Editor;                     ///  must be the last destructor
  111. mmm_Screen mmm_screen;             /// must be !!BEFORE!! mmm_KBD, bcause of con_fd opening
  112. mmm_KeyBoard mmm_KBD;              ///      in mmm_Screen::mmm_Screen()
  113. //&>>&0 0 0 1C
  114.  
  115. //&<<&Forward_declarations
  116.  
  117. //&<<&void MemTest(int i){
  118. void MemTest(int i){
  119.     if(i)return;
  120. //&<<&    #ifdef _ENABLE_LOGGING_
  121.     #ifdef _ENABLE_LOGGING_
  122.         DoLog("                ........TestMem(%x (%x))\n",i,MinimalExitFromEditor);
  123.     #endif
  124. //&>>&1 0 1 8
  125.     Beep();
  126.     Beep();
  127.     if(MinimalExitFromEditor) abort();
  128.     MinimalExitFromEditor=1;
  129.     exit(1);
  130.     }
  131. //&>>&0 0 0 14
  132. //&<<&void Redr(int LineToRedraw)
  133. void Redr(int LineToRedraw){
  134.     if(mmm_screen.Need()<LineToRedraw)
  135.         mmm_screen.Need()=LineToRedraw;
  136.     }
  137. //&>>&2 0 2 12
  138. //&<<&int lower(int c){
  139. int lower(int c){
  140.     if(c>='A' && c<='Z') return c+'a'-'A';
  141.     return c;
  142.     }
  143. //&>>&0 0 0 1A
  144. //&<<&char *getcurdir(int f){  // f -- reread current directory
  145. static char pcGCD_SavedDir[256]="";
  146. unsigned int iGCD_SavedDev=(unsigned int)-1;
  147.  
  148. //&<<&int SaveGetDrive()
  149. int SaveGetDrive()
  150.     { return iGCD_SavedDev; }
  151. //&>>&1 0 1 1A
  152. //&<<&void SaveChDir(char *s){
  153. void SaveChDir(char *s){
  154.   if(strcmp(s,pcGCD_SavedDir)==0) return;
  155.   chdir(s);
  156.   getcwd(pcGCD_SavedDir,255);
  157. }
  158. //&>>&3 0 3 17
  159. //&<<&void SaveSetDrive(unsigned int n){
  160. void SaveSetDrive(unsigned int n){
  161.   if(iGCD_SavedDev==n) return;
  162.   iGCD_SavedDev=n;
  163.   unsigned int t;
  164.   _dos_setdrive(n,&t);
  165.   getcwd(pcGCD_SavedDir,255);
  166. }
  167.  
  168. //&>>&2 0 2 F
  169. //&<<&unsigned int GetSavedDev(){
  170. unsigned int GetSavedDev(){
  171.     unsigned int sd;
  172.     _dos_getdrive(&sd);
  173.     return sd;
  174.     }
  175. //&>>&0 0 0 18
  176.  
  177. char *getcurdir(int f){
  178.     if(f){
  179.         char *d=new char[strlen(pcGCD_SavedDir)+1];
  180.         strcpy(d,pcGCD_SavedDir);
  181.         return d;
  182.         }else return pcGCD_SavedDir;
  183.     }
  184.  
  185. //&>>&0 0 0 1B
  186.  
  187. //&>>&0 0 0 4
  188. //&<<&Constants and variables
  189. int MinimalExitFromEditor=0;
  190.  
  191. char *templine;    // line to be used as temporary strings storage
  192.  
  193. int fRecordingMacro=0;
  194.  
  195. Fold *RuntimeStack=NewFold(0);
  196. long RuntimeFlag;
  197.  
  198. //&>>&7 0 7 3
  199.  
  200. //&<<&Commands in Canonical form
  201. TMacro *my_macroF7=0;  int my_macroF7_ptr=0; /// I must Remove it out of here
  202.  
  203. //&<<&Movement
  204. // Movement
  205. void MMMlib_Up     (int ccode) { cur->Up   ();    }
  206. void MMMlib_Down   (int ccode) { cur->Down ();    }
  207. void MMMlib_Left   (int ccode) { cur->Left ();    }
  208. void MMMlib_Right  (int ccode) { cur->Right();    }
  209.  
  210. void MMMlib_TUp    (int ccode) { cur->TUp   ();   }
  211. void MMMlib_TDown  (int ccode) { cur->TDown ();   }
  212. void MMMlib_TLeft  (int ccode) { cur->TLeft ();   }
  213. void MMMlib_TRight (int ccode) { cur->TRight();   }
  214.  
  215. void MMMlib_PUp    (int ccode) { cur->PUp   ();   }
  216. void MMMlib_PDown  (int ccode) { cur->PDown ();   }
  217.  
  218. void MMMlib_FUp    (int ccode) { _EXIT(0);        }
  219. void MMMlib_FDown  (int ccode) { cur->FDown (0);  }
  220. //&<<&void MMMlib_FLeft  (int ccode) {
  221. void MMMlib_FLeft (int ccode) {
  222.         if(Editor.IsInSearchFold)return;
  223.         CurrentPage=CurrentPage->PagePrev();
  224.         GetCurrentFileNameAndDepth();
  225.         Redr();
  226.         }
  227. //&>>&2 0 2 8
  228. //&<<&void MMMlib_FRight (int ccode) {
  229. void MMMlib_FRight (int ccode) {
  230.     if(Editor.IsInSearchFold)return;
  231.     CurrentPage=CurrentPage->PageNext();
  232.     GetCurrentFileNameAndDepth();
  233.     Redr();
  234.     }
  235. //&>>&0 0 0 C
  236.  
  237. void MMMlib_Enter  (int ccode) { cur->_Enter();   }
  238. void MMMlib_Tab    (int ccode) { cur->Tab();      }
  239. void MMMlib_LTab   (int ccode) { cur->LTab();     }
  240.  
  241. //&>>&14 0 14 0
  242. //&<<&Insert and delete
  243. // Insert and delete
  244. void MMMlib_InsCh   (int ccode) { cur->InsCh  ();  }
  245. void MMMlib_DelCh   (int ccode) { cur->DelCh  ();  }
  246. void MMMlib_InsLine (int ccode) { cur->InsLine();  }
  247. void MMMlib_InsFold (int ccode) { cur->InsFold();  }
  248. void MMMlib_DelLine (int ccode) { cur->DelLine();  }
  249. void MMMlib_BS      (int ccode) { cur->BackSpace();}
  250.  
  251. //&>>&7 0 7 0
  252. //&<<&Characters/Digits/delimiters Typing
  253. //&<<&void MMMlib_Ascii0   (int ccode) {     // for digits
  254. void MMMlib_Ascii0   (int ccode) {   // for digits
  255.     int code=ccode & 0xff;
  256.     int p_alt=(ccode & 0x200)>>8;
  257.     int p_shift=(ccode & 0x100)>>8;
  258.     cur->Ascii(( p_alt ? acode : mcode)[code*2+p_shift]);
  259.     }
  260. //&>>&1 0 1 1A
  261. //&<<&void MMMlib_Ascii1   (int ccode) {     // for letters 
  262. void MMMlib_Ascii1   (int ccode) {  // for letters
  263.     int code=ccode & 0xff;
  264.     int p_alt=(ccode & 0x200)>>8;
  265.     int p_shift=(ccode & 0x100)>>8;
  266.     cur->Ascii(( p_alt ? acode : mcode)[code*2+p_shift]);
  267.     }
  268. //&>>&1 0 1 19
  269. //&<<&void MMMlib_Ascii2   (int ccode) {     // for delimiters
  270. void MMMlib_Ascii2   (int ccode) {     // for delimiters
  271.     int code=ccode & 0xff;
  272.     int p_alt=(ccode & 0x200)>>8;
  273.     int p_shift=(ccode & 0x100)>>8;
  274.     cur->Ascii( p_alt ? acode[code*2+ p_shift ] : mcode[code*2+p_shift]);  return;
  275.     }
  276. //&>>&1 0 1 0
  277. void MMMlib_Space    (int ccode) { cur->Ascii(' '); }
  278. //&>>&0 0 0 32
  279. //&<<&Line Killing
  280. // Line Killing
  281. void MMMlib_KillEnd  (int ccode) {   cur->KillEnd();  }
  282. void MMMlib_KillBeg  (int ccode) {   cur->KillBeg();  }
  283. //&>>&1 0 1 C
  284. //&<<&Copying of chars
  285. // Copying of chars
  286. void MMMlib_CSave    (int ccode) { cur->CCopy(0); }
  287. void MMMlib_CMove    (int ccode) { cur->CCopy(1); }
  288. void MMMlib_WSave    (int ccode) { cur->BWord(); cur->WCopy(0); }
  289. void MMMlib_WMove    (int ccode) { cur->BWord(); cur->WCopy(1); }
  290. void MMMlib_BWord    (int ccode) { cur->BWord(); }
  291. void MMMlib_TSave    (int ccode) { cur->TCopy(0); }
  292. void MMMlib_TMove    (int ccode) { cur->TCopy(1); }
  293. void MMMlib_CRest    (int ccode) { cur->CRest(); }
  294. void MMMlib_CClear   (int ccode) { CClear(); }
  295. //&>>&9 0 9 C
  296. //&<<&Copying of lines
  297.  
  298. void MMMlib_LSave    (int ccode) { cur->LSave(0); }
  299. void MMMlib_LTSave   (int ccode) { cur->LSave(1); }
  300. void MMMlib_LMove    (int ccode) { cur->LMove(0); }
  301. void MMMlib_LTMove   (int ccode) { cur->LMove(1); }
  302. void MMMlib_LRest    (int ccode) { cur->LRest();  }
  303. void MMMlib_LClear   (int ccode) { LClear();  }
  304. //&>>&6 0 6 C
  305. //&<<&Various types of exit
  306. // Various types of exit
  307. void MMMlib_Escape        (int ccode) { LClear(); __EXIT(); }
  308. void MMMlib_EscapeExec    (int ccode) { LClear(); cur->LSave(0); __EXIT(); }
  309. void MMMlib_EscapeExecLCB (int ccode) { __EXIT(); }
  310. //&<<&void MMMlib_ABORT         (int ccode) {
  311. void MMMlib_ABORT         (int ccode) {
  312.     MinimalExitFromEditor=1;
  313.     exit(1);
  314.     }
  315. //&>>&0 0 0 C
  316.  
  317. //&>>&4 0 4 C
  318. //&<<&Various switchings  (ins/ovr , alt key , status line .........)
  319. // Various switchings  (ins/ovr , alt key , status line .........)
  320. void MMMlib_S_AutoIndent (int ccode) { Editor.IndFlag^=1; }
  321. void MMMlib_S_ModeIns    (int ccode) { Editor.InsFlag=1; }
  322. void MMMlib_S_ModeOvr    (int ccode) { Editor.InsFlag=0; }
  323. void MMMlib_S_ACode1     (int ccode) { mmm_KBD.SetACode(1); }
  324. void MMMlib_S_ACode2     (int ccode) { mmm_KBD.SetACode(2); }
  325. void MMMlib_S_ACode3     (int ccode) { mmm_KBD.SetACode(3); }
  326. void MMMlib_S_StatusLine (int ccode) { Editor.ShowStatusLineFlag^=1; Redr(); }
  327. void MMMlib_S_SearchMode (int ccode) { Editor.SearchMode^=1; }
  328.  
  329. //&>>&6 0 6 2E
  330. //&<<&Search & replace commands
  331. // Search & replace commands
  332. void MMMlib_SearchFWD  (int ccode) { SearchReplaceTextFragment(SEARCH_FORWARD); }
  333. void MMMlib_SearchBCK  (int ccode) { SearchReplaceTextFragment(SEARCH_BACK); }
  334. void MMMlib_Replace    (int ccode) { SearchReplaceTextFragment(SEARCH_FORWARD,1); }
  335. void MMMlib_SearchPage (int ccode) { SwitchIntoSearchPage(); }
  336. //&>>&4 0 4 C
  337. void MMMlib_PageIns (int ccode) { cur->FDown(1); }
  338. //&<<&Marked Lines Commands
  339. void MMMlib_MarkUp    (int ccode) { cur->Up   (1); }
  340. void MMMlib_MarkDown  (int ccode) { cur->Down (1); }
  341. void MMMlib_MarkTUp   (int ccode) { cur->TUp  (1); }
  342. void MMMlib_MarkTDown (int ccode) { cur->TDown(1); }
  343. void MMMlib_MarkPUp   (int ccode) { cur->PUp  (1); }
  344. void MMMlib_MarkPDown (int ccode) { cur->PDown(1); }
  345. void MMMlib_MarkSaveB (int ccode) { SaveMarkedBlock(); }
  346. void MMMlib_MarkRestB (int ccode) { RestMarkedBlock(); }
  347. void MMMlib_MarkLast  (int ccode) { LastMarked();      }
  348. void MMMlib_MarkFirst (int ccode) { FirstMarked();     }
  349. void MMMlib_MarkPrev  (int ccode) { PrevMarked();      }
  350. void MMMlib_MarkNext  (int ccode) { NextMarked();      }
  351. void MMMlib_MarkBS    (int ccode) { LastMarked();  cur->MarkLine(); }
  352.  
  353. //&>>&C 0 C C
  354. //&<<&MacroCommands
  355. void MMMlib_Macro(int ccode){
  356.  
  357.     static int i=-1;
  358.     if(fRecordingMacro){
  359.         fRecordingMacro=0;
  360.         (*my_macroF7)[my_macroF7_ptr-1]=0;
  361.         i=CommandUsrArray.AddEntry("MacroF7",my_macroF7);
  362.         return;
  363.         }
  364.     CommandUsrArray.base[i].Execute(ccode);
  365.     }
  366.  
  367. void MMMlib_MacroRec(int ccode){
  368.     if(my_macroF7!=0)delete my_macroF7;
  369.     my_macroF7=new TMacro;
  370.     fRecordingMacro=1;
  371.     (*my_macroF7)[0]=MACRO_KEYSEQ;
  372.     my_macroF7_ptr=1;
  373.     }
  374. //&>>&9 0 9 0
  375.  
  376. //&>>&2 0 2 1A
  377.  
  378. //&<<&TCommand.. / TKey / TMacro / TPair_String_Int
  379. //&<<&int TKeyArray::AddEntry(int _scan, int _fnum){
  380. int TKeyArray::AddEntry(int _scan, int _fnum){
  381.     int i;
  382.     for(i=0; i<lbase ; i++){
  383.         if(base[i].fnum==-1) goto l_ka_InsertData;
  384.         }
  385.  
  386.     TKey *base1;
  387.     lbase+=0x100;
  388.     base1=new TKey[lbase]; MemTest(base1!=0);
  389.     if(base!=0){
  390.         memcpy(base1, base, i * sizeof(TKey) );
  391.         delete base;
  392.         }
  393.     base=base1;
  394.  
  395. l_ka_InsertData:
  396.     base[i].scan   = _scan   ;
  397.     base[i].fnum   = _fnum   ;
  398.     return i;
  399.     }
  400. //&>>&0 0 0 5
  401. //&<<&int TCommandUsrArray::AddEntry(char *_fname, TMacro *_fcode) {
  402. int TCommandUsrArray::AddEntry(char *_fname, TMacro *_fcode) {
  403.  
  404. // TCommandUsr {
  405. //     char *fName;
  406. //     short *fCode; };
  407.  
  408. // ¬«¡µ«¼ óÑ¬Γ«αá ßτ¿ΓáÑΓß∩ Σ-∩ íѺ ¿¼Ñ¡¿ (fName==0)
  409.  
  410.     int i,j;
  411.     for(i=0; i<lbase ; i++){
  412.         if(base[i].fName==0)                 goto l_cua_InsertName;
  413.         if(strcmp(base[i].fName, _fname)==0) goto l_cua_InsertContents;
  414.         }
  415.  
  416.     TCommandUsr *base1;
  417.     lbase+=0x100;
  418.     base1=new TCommandUsr[lbase]; MemTest(base1!=0);
  419.     if(base!=0){
  420.         memcpy(base1, base, i * sizeof(TCommandUsr) );
  421.         delete base;
  422.         }
  423.     base=base1;
  424.  
  425. l_cua_InsertName:
  426.     base[i].fName=new char[strlen(_fname)+1];  MemTest( base[i].fName!=0 );
  427.     strcpy (base[i].fName , _fname );
  428.  
  429. l_cua_InsertContents:
  430.     if(_fcode!=0){
  431.         for(j=0;j<_fcode->lbase;j++){
  432.             base[i].fCode[j]=(*_fcode)[j];
  433.             }
  434.         }
  435.  
  436. //&<<&    #ifdef _ENABLE_LOGGING_
  437.     #ifdef _ENABLE_LOGGING_
  438.     {
  439.         DoLog("TCommandUsrArray::AddEntry(char *_fname, TMacro *_fcode) {\n");
  440.         DoLog("    fname=%s\n    Entry=\n",_fname);
  441.         if(_fcode!=0){
  442.             for(int pppp=0;(*_fcode)[pppp]!=0;pppp++)
  443.                 DoLog("        %4d->%4x\n",pppp,(*_fcode)[pppp]);
  444.             }
  445.     }
  446.     #endif
  447. //&>>&4 0 4 0
  448.     return i;
  449.     }
  450. //&>>&0 0 0 0
  451.  
  452. //&<<&short &TMacro::operator[](int idx) {
  453. short &TMacro::operator[](int idx) {
  454.     if(idx>=lbase){
  455.         int i;
  456.         short *base1;
  457.         lbase+=0x10;
  458.         base1=new short[lbase]; MemTest(base1!=0);
  459.         if(base!=0){
  460.             memcpy(base1, base, (lbase-0x10) * sizeof(short) );
  461.             delete base;
  462.             }
  463.         base=base1;
  464.         for(i=lbase-0x10;i<lbase;i++) base[i]=0;
  465.         }
  466.     return base[idx];
  467.     }
  468. //&>>&1 0 1 12
  469. //&<<&int TCommandUsr::Execute(int arg){
  470. int TCommandUsr::Execute(int arg) {
  471.     int pc;
  472.     if(fCode.base==0)return -1;
  473.     switch(fCode[0]){
  474.         case MACRO_PROC:
  475. //&<<&            #ifdef _ENABLE_LOGGING_
  476.             #ifdef _ENABLE_LOGGING_
  477.                 DoLog("Procedure <%s>execution {\n",fName);
  478.             #endif
  479. //&>>&1 0 1 1A
  480.             for(pc=1; fCode[pc]!=0 && fCode[pc]!=TKN_RETURN_ ; pc++) {
  481. //&<<&                #ifdef _ENABLE_LOGGING_
  482.             #ifdef _ENABLE_LOGGING_
  483.                 DoLog("[%x->%x] ",pc,fCode[pc]);
  484.             #endif
  485. //&>>&1 0 1 22
  486. //&<<&                if(fCode[pc]<LEN_LANGUAGE){     // if, do, ... analisys
  487.         if(fCode[pc]>=0 && fCode[pc]<LEN_LANGUAGE){
  488.             Line *nl;
  489. //            char *tpc;
  490.             int i,l;
  491.             switch(fCode[pc]){
  492.                 case TKN_GOTO_:
  493.                     pc=fCode[pc+1]-1;
  494.                     break;
  495.                 case TKN_IF_:
  496.                     if(RuntimeFlag) pc++;
  497.                     else pc=fCode[pc+1]-1;
  498.                     break;
  499. //&<<&                case TKN_CONST_INT_:
  500.                 case TKN_CONST_INT_:
  501.                     nl=NewLine(0);
  502.                     nl->linenumber=fCode[++pc];
  503.                     nl->type=SDATA_INT;
  504.                     nl->LinkBefore(RuntimeStack->pos);
  505.                     RuntimeStack->pos=nl;
  506.                     break;
  507. //&>>&7 0 7 15
  508. //&<<&                case TKN_CONST_STRING_:
  509.                 case TKN_CONST_STRING_:
  510.                     templine=new char[(l=fCode[++pc])+1]; MemTest(templine!=0);
  511.                     for(i=0;i<l;i++)templine[i]=char(fCode[++pc]);
  512.                     templine[i]=0;
  513.                     nl=NewLine(templine);
  514.                     delete templine;
  515.                     nl->type=SDATA_STRING;
  516.                     nl->LinkBefore(RuntimeStack->pos);
  517.                     RuntimeStack->pos=nl;
  518.                     break;
  519.  
  520. //&>>&1 0 1 4D
  521.                 case TKN_SWP_ :
  522.                     RuntimeStack->stackSwp();
  523.                     break;
  524.                 case TKN_DUP_ :
  525.                     RuntimeStack->stackDup();
  526.                     break;
  527.                 case TKN_DEL_ :
  528.                     RuntimeStack->stackDel();
  529.                     break;
  530.                 case TKN_SGET_:
  531.                     RuntimeStack->stackSget();
  532.                     break;
  533.                 case TKN_SPUT_:
  534.                     RuntimeStack->stackSput();
  535.                     break;
  536.                 case TKN_POP_:
  537.                     RuntimeStack->stackPop();
  538.                     break;
  539.                 case TKN_PUSH_:
  540.                     RuntimeStack->stackPush();
  541.                     break;
  542.                 case TKN_CONVERT_:
  543.                     RuntimeStack->stackConvert();
  544.                     break;
  545.                 case TKN_MATHOP_:
  546.                     RuntimeStack->stackMathOperation();
  547.                     break;
  548.                 case TKN_PREDICATE_:
  549.                     RuntimeStack->stackPredicate();
  550.                     break;
  551.                 case TKN_IOCTL_:
  552.                     RuntimeStack->stackIOCTL();
  553.                     break;
  554.                 case TKN_QUERY_:
  555.                     RuntimeStack->stackQuery();
  556.                     break;
  557.                 }
  558.             // here must be analisys of Language Constructions
  559.             //          if , do , ...
  560.             // HERE "pc" may be modifyed
  561.             continue;
  562.             }
  563. //&>>&A 0 A 0
  564. //&<<&                if(fCode[pc]>=LEN_LANGUAGE && fCode[pc]<USER_FUNC){ // MMMlib
  565.         if(fCode[pc]>=LEN_LANGUAGE && fCode[pc]<USER_FUNC){
  566.             CommandArray[fCode[pc]-LEN_LANGUAGE].fRef(arg);
  567.             continue;
  568.             }
  569. //&>>&1 0 1 0
  570. //&<<&                if(fCode[pc]>=USER_FUNC && fCode[pc]<USER_FUNC+CommandUsrArray.lbase ) {
  571.         if(fCode[pc]>=USER_FUNC && fCode[pc]<USER_FUNC+CommandUsrArray.lbase ){
  572.             arg=CommandUsrArray.base[fCode[pc]-USER_FUNC].Execute(arg);
  573.             continue;
  574.             }
  575. //&>>&1 0 1 12
  576.                 }
  577. //&<<&            #ifdef _ENABLE_LOGGING_
  578.             #ifdef _ENABLE_LOGGING_
  579.                 DoLog("    }complete.\n");
  580.             #endif
  581. //&>>&1 0 1 2A
  582.             break;
  583.         case MACRO_KEYSEQ:
  584.             for(pc=1; fCode[pc]!=0 ; pc++) Command(fCode[pc]);
  585.             break;
  586.         }
  587.     Redr();
  588.     return arg;
  589.     }
  590. //
  591. // ¼á¬α«¬«¼á¡ñá ßó«αáτ¿óáÑΓß∩ ó "short *"<==>(TMacro) ß½ÑñπεΘ¿¼ «íαẫ¼:
  592. //     0 -- ¬«¡Ñµ ¼á¬αδ.
  593. //     [ 1 , LEN_LANGUAGE ) -- ¿ß»«½∞ºπѼδÑ ó ∩ºδ¬Ñ ¬«¡ßΓαπ¬µ¿¿, »«¬á 1 (»πßΓ«).
  594. //            /*    #define USER_FUNC (LEN_LANGUAGE+LEN_COMMAND_ARRAY)   */
  595. //     [ LEN_LANGUAGE , USER_FUNC ) -- óßΓα«Ñ¡¡δÑ ó αÑñá¬Γ«α C-Σ-¿
  596. //     [ USER_FUNC , INFTY ] -- Σ-¿ ¡á»¿ßá¡¡δÑ ó Σ«½ñÑ *MACRO* ¿½¿
  597. //                                              ¡áí¿ΓδÑ ß ¬½áó¿áΓπαδ.
  598. //&>>&6 0 6 0
  599.  
  600. //&<<&int fPair_String2Int  (TPair_String_Int psArr[], int len, const char *pcNam) {
  601. int fPair_String2Int  (TPair_String_Int psArr[], int len, const char *pcNam) {
  602.     for(int i=0;i<len;i++)
  603.         if(0==strcmp(pcNam, psArr[i].fName))return psArr[i].iValue;
  604.     return -1;
  605.     }
  606.  
  607. //&>>&2 0 2 0
  608. //&<<&char *fPair_Int2String(TPair_String_Int psArr[], int len, int iIdx   ) {
  609. char *fPair_Int2String(TPair_String_Int psArr[], int len, int iIdx   ) {
  610.     for(int i=0;i<len;i++)
  611.         if(iIdx==psArr[i].iValue)return psArr[i].fName;
  612.     return 0;
  613.     }
  614.  
  615. //&>>&2 0 2 0
  616.  
  617. //&>>&4 0 4 F
  618. //&<<&compiler
  619. //&<<&char *ScanLanguageWord(FILE *fptr){
  620. char *ScanLanguageWord(FILE *fptr){
  621.     static int FoldDepth;
  622.     char *body;
  623.     static char *tline=0, *lptr=0;
  624.     int i=0;
  625. //&<<&    if(fptr!=0 && tline==0){
  626.     if(fptr!=0 && tline==0){
  627.         FoldDepth=0;
  628.         tline=new char[0x100]; MemTest(tline!=0);
  629.         lptr=tline;
  630.         *lptr=0;
  631.         }
  632. //&>>&1 0 1 0
  633.     if(fptr==0 && tline!=0) goto l_ShutdownScanner;
  634.  
  635.     do{
  636.         if(*lptr==0){
  637.             if(fgets(tline,0x100,fptr)==0)goto l_ShutdownScanner;
  638.             if( Editor.IsComment(tline,"&<<&") )  FoldDepth++;
  639.             else if( Editor.IsComment(tline,"&>>&") )  FoldDepth--;
  640.             if(FoldDepth<0) goto l_ShutdownScanner;
  641.             lptr=tline;
  642.             }
  643.         else{
  644.             while(*lptr<=' '&& *lptr)lptr++;
  645.             switch(*lptr){
  646.                 case '\"':    case '\'':
  647.                     for(i=1; lptr[i]!=0 && lptr[i]!='\"' && lptr[i]!='\''  ; i++)
  648.                         if(lptr[i]>0 && lptr[i]<' ')lptr[i]=' ';
  649.                     if(lptr[i]!=0)i++;
  650.                     break;
  651.                 case 0x25:  case 0:  // % & 0
  652.                     *lptr=0;
  653.                     i=0;
  654.                 default:
  655.                     for(i=0; lptr[i]>' '; i++);
  656.                 }
  657.             }
  658.     }while(i==0);
  659.  
  660.     body=new char[i+1];
  661.     memcpy(body, lptr, i * sizeof(char) );      body[i]=0;
  662.     for(lptr+=i; *lptr!=0 && *lptr<=' '; lptr++);
  663.     return body;
  664.  
  665. l_ShutdownScanner:
  666.     delete tline;
  667.     tline=lptr=0;
  668.     return 0;
  669.     }
  670. //&>>&5 0 5 19
  671. //&<<&int TestToken(char *lptr){
  672. ///////// supp_mmm.cpp supp_mmm.cpp supp_mmm.cpp supp_mmm.cpp
  673.  
  674. #define LENGTH_sToken2tId (21)
  675. //&<<&TPair_String_Int psToken2tId[LENGTH_sToken2tId]={
  676. TPair_String_Int psToken2tId[LENGTH_sToken2tId]={
  677. //        TPair_String_Int("CONST_CHAR_"   , TKN_CONST_CHAR_ ) ,
  678. //        TPair_String_Int("CONST_INT_"    , TKN_CONST_INT_ ) ,
  679. //        TPair_String_Int("CONST_STRING_" , TKN_CONST_STRING_ ) ,
  680. //        TPair_String_Int("GOTO_"         , TKN_GOTO_ ) ,
  681. //        TPair_String_Int("CALL_"         , TKN_CALL_ ) ,
  682.  
  683.         TPair_String_Int("proc"          , TKN_PROC_     ) ,
  684.         TPair_String_Int("endp"          , TKN_ENDP_     ) ,
  685.         TPair_String_Int("if"            , TKN_IF_       ) ,
  686.         TPair_String_Int("else"          , TKN_ELSE_     ) ,
  687.         TPair_String_Int("endif"         , TKN_ENDIF_    ) ,
  688.         TPair_String_Int("do"            , TKN_DO_       ) ,
  689.         TPair_String_Int("enddo"         , TKN_ENDDO_    ) ,
  690.         TPair_String_Int("break"         , TKN_BREAK_    ) ,
  691.         TPair_String_Int("ret"           , TKN_RETURN_   ) ,
  692.         TPair_String_Int("swp"           , TKN_SWP_      ) ,
  693.         TPair_String_Int("dup"           , TKN_DUP_      ) ,
  694.         TPair_String_Int("del"           , TKN_DEL_      ) ,
  695.         TPair_String_Int("sget"          , TKN_SGET_     ) ,
  696.         TPair_String_Int("sput"          , TKN_SPUT_     ) ,
  697.         TPair_String_Int("mathop"        , TKN_MATHOP_   ) ,
  698.         TPair_String_Int("predicate"     , TKN_PREDICATE_) ,
  699.         TPair_String_Int("convert"       , TKN_CONVERT_  ) ,
  700.         TPair_String_Int("query"         , TKN_QUERY_    ) ,
  701.         TPair_String_Int("pop"           , TKN_POP_      ) ,
  702.         TPair_String_Int("push"          , TKN_PUSH_     ) ,
  703.         TPair_String_Int("ioctl"         , TKN_IOCTL_    ) };
  704. //&>>&F 0 F B
  705. int TestToken(const char *lptr){
  706.     if(*lptr=='\"')return TKN_CONST_STRING_;
  707.     if(*lptr=='\'')return TKN_CONST_CHAR_;
  708.     if( (*lptr=='-' && lptr[1]>='0' && lptr[1]<='9')  ||
  709.                        (*lptr>='0' && *lptr<='9') )
  710.         return TKN_CONST_INT_;
  711.  
  712.     int i=fPair_String2Int( psToken2tId, LENGTH_sToken2tId, lptr);
  713.     return (i>=0)?i:TKN_CALL_;
  714.     }
  715. //&>>&3 0 3 4
  716. //&<<&void Compile(FILE *fptr){
  717.  
  718. void Compile(FILE *fptr){
  719.     int i,l;
  720.     char *tk;
  721.     int cstat=TKN_INITIAL_;
  722.     int ttype;
  723.     char *FuncName;
  724.     TMacro *ctStack, *mb;
  725.     int p,np;
  726.     while( (tk=ScanLanguageWord(fptr))!=0 ) {
  727.         ttype=TestToken(tk);
  728. //&<<&        #ifdef _ENABLE_LOGGING_
  729. #ifdef _ENABLE_LOGGING_
  730.     DoLog(">%25s< <-0x%-4x : cstat=0x%-4x p=0x%-4x\n",tk,ttype,cstat,p);
  731. #endif
  732. //&>>&0 0 0 26
  733.         switch(cstat){
  734. //&<<&            case TKN_INITIAL_:
  735.             case TKN_INITIAL_:
  736.                 if(ttype==TKN_PROC_){
  737.                     cstat=TKN_PROC_;
  738.                     }
  739.                 break;
  740. //&>>&2 0 2 2A
  741. //&<<&            case TKN_PROC_:
  742.             case TKN_PROC_:
  743.                 ctStack=new TMacro;
  744.                 mb=new TMacro;
  745.                 FuncName=new char[strlen(tk)+1];
  746.                 MemTest(mb!=0 && ctStack!=0 && FuncName!=0);
  747.                 strcpy(FuncName,tk);
  748.                 (*mb)[0]=MACRO_PROC;
  749.                 p=1; np=0;
  750.                 cstat=TKN_INPROC_;
  751.                 break;
  752. //&>>&A 0 A D
  753. //&<<&            case TKN_INPROC_:
  754.     case TKN_INPROC_:
  755.         switch(ttype){
  756. //&<<&            case TKN_ENDP:
  757.             case TKN_ENDP_:
  758.                 CommandUsrArray.AddEntry(FuncName,mb);
  759.                 delete FuncName;
  760.                 delete mb;
  761.                 delete ctStack;
  762.                 cstat=TKN_INITIAL_;
  763.                 p=np=0;
  764.                 break;
  765. //&>>&5 0 5 22
  766. //&<<&            case TKN_IF, TKN_ELSE, TKN_ENDIF 
  767.             case TKN_IF_:
  768.                 (*mb)[p++]=TKN_IF_;
  769.                 (*ctStack)[++np]=p++;
  770.                 break;
  771.             case TKN_ELSE_:
  772.                 (*mb)[p++]=TKN_GOTO_;
  773.                 (*mb)[(*ctStack)[np]]=p+1;
  774.                 (*ctStack)[np]=p++;
  775.                 break;
  776.             case TKN_ENDIF_:
  777.                 (*mb)[(*ctStack)[np--]]=p;
  778.                 break;
  779.  
  780. //&>>&9 0 9 0
  781. //&<<&            case TKN_DO, TKN_ENDDO
  782.             case TKN_DO_:
  783.                 (*mb)[p++]=TKN_IF_;
  784.                 (*ctStack)[++np]=p++;
  785.                 break;
  786.             case TKN_ENDDO_:
  787.                 (*mb)[p++]=TKN_GOTO_;
  788.                 (*mb)[p++]=(*ctStack)[np]-1;
  789.                 (*mb)[(*ctStack)[np--]]=p;
  790.                 break;
  791.  
  792. //&>>&6 0 6 2A
  793. //&<<&            case TKN_CONST_CHAR, TKN_CONST_NUMBER, TKN_CONST_STRING:
  794.             case TKN_CONST_CHAR_:
  795.                 (*mb)[p++]=TKN_CONST_INT_;
  796.                 (*mb)[p++]=tk[1];
  797.                 break;
  798.  
  799.             case TKN_CONST_INT_:
  800.                 (*mb)[p++]=TKN_CONST_INT_   ;
  801.                 (*mb)[p++]=short(strtol(tk,0,16));
  802.                 break;
  803.  
  804.             case TKN_CONST_STRING_:
  805.                 l=strlen(tk);
  806.                 (*mb)[p++]=TKN_CONST_STRING_;
  807.                 (*mb)[p++]=l-2;
  808.                 for(i=1;i<l-1;i++)(*mb)[p++]=tk[i];
  809.                 break;
  810.  
  811. //&>>&6 0 6 34
  812. //&<<&            case TKN_CALL_:
  813.             case TKN_CALL_:
  814.                 for(i=0;i<LEN_COMMAND_ARRAY;i++)
  815.                     if(strcmp(CommandArray[i].fName,tk)==0)break;
  816.                 if(i<LEN_COMMAND_ARRAY)
  817.                     i+=LEN_LANGUAGE;
  818.                 else
  819.                     i=CommandUsrArray.AddEntry(tk)+USER_FUNC;
  820.                 (*mb)[p++]=i;
  821.                 break;
  822. //&>>&0 0 0 8
  823. //&<<&            default: // Arithm, pred, ... functions
  824.             default:
  825.                 (*mb)[p++]=ttype;
  826.                 break;
  827. //&>>&0 0 0 0
  828.             }
  829. //&>>&4 0 4 17
  830.             }
  831.         delete tk;
  832.         }
  833.     }
  834. //&>>&F 0 F 17
  835. //&>>&1 0 1 0
  836. //&<<&RuntimeStack functions
  837. // mmmx.h
  838.  
  839. //&<<&void Fold::stackSwp() {           ?
  840. void Fold::stackSwp() {
  841.     Line *ff=pos->next;
  842.     if(ff==0)return;
  843.     ff->UnLink();
  844.     ff->LinkBefore(pos);
  845.     pos=ff;
  846.     }
  847. //&>>&5 0 5 0
  848. //&<<&void Fold::stackDel() {           ?
  849. void Fold::stackDel() {
  850.     Line *ff=pos;
  851.     pos=pos->next;
  852.     delete ff;
  853.     }
  854. //&>>&1 0 1 0
  855. //&<<&void Fold::stackDup() {           ok
  856. void Fold::stackDup() {
  857.     Line *ff=pos->Copy(1);
  858.     ff->LinkBefore(pos);
  859.     pos=ff;
  860.     }
  861. //&>>&0 0 0 0
  862. //&<<&void Fold::stackSget() {          ok
  863. void Fold::stackSget() {
  864.     if(pos->type!=SDATA_INT)return;
  865.     Line *nl;
  866.     Line *optr;
  867.     int dpth=pos->linenumber;
  868.     stackDel();
  869.     optr=pos;
  870.     while(--dpth > 0){ if(0==(optr=optr->next))return; }
  871.     nl=optr->Copy(1);
  872.     nl->LinkBefore(pos);
  873.     pos=nl;
  874.     }
  875. //&>>&B 0 B 4
  876. //&<<&void Fold::stackSput() {          ok
  877. void Fold::stackSput() {
  878.     if(pos->type!=SDATA_INT)return;
  879. //    Line *nl;
  880.     Line *optr,*oput;
  881.     int dpth=pos->linenumber;
  882.     stackDel();
  883.     oput=pos; optr=pos=pos->next;
  884.     oput->UnLink();
  885.     while(--dpth > 0){ if(0==(optr=optr->next))return; }
  886.     oput->LinkBefore(optr);
  887.     delete optr;
  888.     }
  889.  
  890.  
  891. //&>>&A 0 A 0
  892.  
  893. //&<<&Line *Fold::TestTopOfTheStackIsInt() { ok
  894. Line *Fold::TestTopOfTheStackIsInt() {
  895.     Line *nxt=pos->next;
  896.     if(nxt==0)return 0;
  897.     Line *nnxt=nxt->next;
  898.     if( pos->type!=SDATA_INT || nxt->type!=SDATA_INT ||
  899.           nnxt==0 || nnxt->type!=SDATA_INT )return 0;
  900.     return nnxt; // 2-nd argument
  901.     }
  902.  
  903. //&>>&4 0 4 0
  904. //&<<&void Fold::stackMathOperation() {      ok
  905. void Fold::stackMathOperation() {
  906.     Line *nnext=TestTopOfTheStackIsInt();
  907.     if(nnext==0)return;
  908.     long val1=pos->next->linenumber;
  909.     long val2=nnext->linenumber;
  910.     long valr;
  911.     switch(pos->linenumber) {
  912.         case MATHOP_SUB:
  913.             valr=val2 - val1;
  914.             break;
  915.         case MATHOP_MUL:
  916.             valr=val2 * val1;
  917.             break;
  918.         case MATHOP_DIV:
  919.             valr=val2 / val1;
  920.             break;
  921.         case MATHOP_MOD:
  922.             valr=val2 % val1;
  923.             break;
  924.         case MATHOP_AND:
  925.             valr=val2 & val1;
  926.             break;
  927.         case MATHOP_OR:
  928.             valr=val2 | val1;
  929.             break;
  930.         case MATHOP_XOR:
  931.             valr=val2 ^ val1;
  932.             break;
  933.         default:  ///  case MATHOP_ADD: (as default, for idiots)
  934.             valr=val2 + val1;
  935.             break;
  936.         }
  937.     pos->linenumber=valr;
  938.     delete pos->next;
  939.     delete pos->next;
  940.     }
  941.  
  942. //&>>&25 0 1A 2
  943. //&<<&void Fold::stackPredicate() {          ok
  944. void Fold::stackPredicate() {
  945.     Line *nnext=TestTopOfTheStackIsInt();
  946.     if(nnext==0)return;
  947.     int val1=pos->next->linenumber;
  948.     int val2=nnext->linenumber;
  949.     switch(pos->linenumber) {
  950.         case PREDICATE_EQ:
  951.             RuntimeFlag=(val2 == val1)?1:0;
  952.             break;
  953.         case PREDICATE_LT:
  954.             RuntimeFlag=(val2 < val1)?1:0;
  955.             break;
  956.         case PREDICATE_GT:
  957.             RuntimeFlag=(val2 > val1)?1:0;
  958.             break;
  959.         default:         /// case PREDICATE_NE: (by default, for idiots)
  960.             RuntimeFlag=(val2 != val1)?1:0;
  961.             break;
  962.         }
  963.     stackDel();  // kill operation type
  964.     stackDel();  // kill 1-st agrument
  965.     stackDel();  // kill 2-nd agrument
  966.     }
  967.  
  968. //&>>&0 0 0 0
  969. //&<<&void Fold::stackQuery() {              ok
  970. void Fold::stackQuery() {
  971.     Line *pp=NewLine(0);
  972.     pp->type=SDATA_INT;
  973.     pp->linenumber=pos->type;
  974.     pp->LinkBefore(pos);
  975.     pos=pos->prev;
  976.     }
  977. //&>>&2 0 2 0
  978. //&<<&void Fold::stackConvert() {            ok
  979. void Fold::stackConvert() {
  980.     if(pos->type!=SDATA_INT)return;
  981. //&<<&    #ifdef _ENABLE_LOGGING_
  982.     #ifdef _ENABLE_LOGGING_
  983.         DoLog("Fold::stackConvert(0x%x){\n",pos->linenumber);
  984.     #endif
  985. //&>>&1 0 1 3D
  986.     short ct=short(pos->linenumber);
  987.     stackDel();
  988.     long n;
  989.     char *ts;
  990.     Line *nl;
  991.     switch(ct){
  992.         case CONVERT_I2SH:
  993.         case CONVERT_I2SD:
  994.         case CONVERT_I2C:
  995.             if(pos->type!=SDATA_INT)return;
  996.             ts=new char[0x10]; MemTest(ts!=0);
  997.             sprintf(ts,
  998.                     (ct==CONVERT_I2SH)?"%x":
  999.                         (ct==CONVERT_I2SD)?"%d":"%c"
  1000.                    ,int(pos->linenumber));
  1001.             nl=NewLine(ts);
  1002.             nl->type=SDATA_STRING;
  1003.             delete ts;
  1004.             break;
  1005.         case CONVERT_S2IH:
  1006.         case CONVERT_S2ID:
  1007.         case CONVERT_C2I:
  1008.             if(pos->type!=SDATA_STRING)return;
  1009.             if(ct==CONVERT_C2I) n=pos->buf[0];
  1010.             else n=strtol( pos->buf, 0, (ct==CONVERT_S2IH)?16:10 );
  1011.             nl=NewLine(0);
  1012.             nl->linenumber=n;
  1013.             nl->type=SDATA_INT;
  1014.             break;
  1015.         case CONVERT_S2L:
  1016.             if(pos->type!=SDATA_STRING)return;
  1017.             pos->type=SDATA_LINE;
  1018. //&<<&    #ifdef _ENABLE_LOGGING_
  1019.     #ifdef _ENABLE_LOGGING_
  1020.         DoLog("    }\n");
  1021.     #endif
  1022. //&>>&1 0 1 19
  1023.             return;
  1024.         case CONVERT_L2S:
  1025.             if(pos->type!=SDATA_LINE)return;
  1026.             pos->type=SDATA_STRING;
  1027. //&<<&    #ifdef _ENABLE_LOGGING_
  1028.     #ifdef _ENABLE_LOGGING_
  1029.         DoLog("    }\n");
  1030.     #endif
  1031. //&>>&1 0 1 19
  1032.             return;
  1033.         }
  1034.     nl->LinkBefore(pos);
  1035.     delete pos;
  1036.     pos=nl;
  1037. //&<<&    #ifdef _ENABLE_LOGGING_
  1038.     #ifdef _ENABLE_LOGGING_
  1039.         DoLog("    }\n");
  1040.     #endif
  1041. //&>>&1 0 1 19
  1042.     }
  1043. //&>>&2 0 2 0
  1044. //&<<&void Fold::stackPop() {                ok
  1045. void Fold::stackPop() {
  1046. //&<<&    #ifdef _ENABLE_LOGGING_
  1047.     #ifdef _ENABLE_LOGGING_
  1048.         DoLog("Fold::stackPop(){\n");
  1049.     #endif
  1050. //&>>&1 0 1 0
  1051.     int i;
  1052.     Line *ff;
  1053.     switch(pos->type){
  1054.         case SDATA_LINE:
  1055.             ff=pos;
  1056.             pos=pos->next;
  1057.             ff->UnLink();
  1058.             ff->LinkBefore(cur->pos);
  1059.             cur->pos=ff;
  1060.             return;  // !!NOT break!!
  1061.         case SDATA_INT:
  1062.             RuntimeFlag=pos->linenumber;
  1063.             break;
  1064.         case SDATA_STRING:
  1065.             for(i=0;*(pos->Buf(i));i++) cur->Ascii(*(pos->Buf(i)));
  1066.             break;
  1067.         }
  1068.     stackDel();
  1069. //&<<&    #ifdef _ENABLE_LOGGING_
  1070.     #ifdef _ENABLE_LOGGING_
  1071.         DoLog("    }\n");
  1072.     #endif
  1073. //&>>&1 0 1 19
  1074.     }
  1075. //&>>&10 0 10 41
  1076. //&<<&void Fold::stackPush() {               ok
  1077. void Fold::stackPush() {
  1078. //&<<&    #ifdef _ENABLE_LOGGING_
  1079.     #ifdef _ENABLE_LOGGING_
  1080.         DoLog("Fold::stackPush(){\n");
  1081.     #endif
  1082. //&>>&3 0 3 4
  1083. //    char aa[2];
  1084.     Line *nl;
  1085.     int itPush=pos->linenumber;
  1086.     stackDel();
  1087.     switch(itPush){
  1088.         case PUSH_FLAG    :
  1089.             nl=NewLine(0);
  1090.             nl->linenumber=RuntimeFlag;
  1091.             nl->type=SDATA_INT;
  1092.             break;
  1093.         case PUSH_CLINE_L :
  1094.             nl=cur->pos->Copy();
  1095.             nl->type=SDATA_LINE;
  1096.             break;
  1097.         case PUSH_CLINE_S :
  1098.             nl=NewLine(cur->pos->buf);
  1099.             nl->type=SDATA_STRING;
  1100.             break;
  1101.         case PUSH_CCB     :
  1102.             nl=NewLine(mmm_CharClipboard.buf);
  1103.             nl->type=SDATA_STRING;
  1104.             break;
  1105.         case PUSH_LCB     :
  1106.             nl=fLineClipboard->Copy();
  1107.             nl->type=SDATA_LINE;
  1108.             break;
  1109.         case PUSH_CHAR    :
  1110.             nl=NewLine(0);
  1111.             nl->linenumber=byte(cur->GetCh());
  1112.             nl->type=SDATA_INT;
  1113.             break;
  1114.         }
  1115.     nl->LinkBefore(pos);
  1116.     pos=nl;
  1117. //&<<&    #ifdef _ENABLE_LOGGING_
  1118.     #ifdef _ENABLE_LOGGING_
  1119.         DoLog("    }\n");
  1120.     #endif
  1121. //&>>&1 0 1 19
  1122.     }
  1123. //&>>&1E 0 F 0
  1124. //&<<&void Fold::stackIOCTL() {
  1125. void Fold::stackIOCTL() {
  1126.     Line *nl;
  1127. //    int i;
  1128.     int itF=pos->linenumber;
  1129.     stackDel();
  1130.     switch(itF){
  1131.         case IOCTL_MODEINS   :     // Ä»α«ß¿Γ∞, ó¬½ετÑ¡ ½¿ αѪ¿¼ óßΓáó¬¿.
  1132.             RuntimeFlag=Editor.InsFlag;
  1133.             return;
  1134.         case IOCTL_MODEAI    :     // Ä»α«ß¿Γ∞, ó¬½ετÑ¡ ½¿ αѪ¿¼ áóΓ««ΓßΓπ»á.
  1135.             RuntimeFlag=Editor.IndFlag;
  1136.             return;
  1137.         case IOCTL_MODESEARCH:     // Ä»α«ß¿Γ∞, αѪ¿¼ »«¿ß¬á
  1138.             RuntimeFlag=Editor.SearchMode;
  1139.             return;
  1140.         case IOCTL_MODECAPS  :     // Ä»α«ß¿Γ∞, ó¬½ετÑ¡ ½¿ CAPS (óÑασ¡¿Ñ íπ¬óδ íÑ
  1141.             RuntimeFlag=mmm_f_FixShift;
  1142.             return;
  1143.         case IOCTL_MODEALT   :     // Ä»α«ß¿Γ∞, ó¬½ετÑ¡ ½¿ ALT (---''---)
  1144.             RuntimeFlag=mmm_f_FixAlt;
  1145.             return;
  1146.         case IOCTL_ISFOLD    :     // Ä»α«ß¿Γ∞, ΓѬπΘá∩ ßΓ᫬á -- Σ«½ñ?
  1147.             RuntimeFlag=(cur->pos->Enter()!=0);
  1148.             return;
  1149.         case IOCTL_ISMARKED  :     // Ä»α«ß¿Γ∞, »«¼ÑτÑ¡á ½¿ ΓѬπΘá∩ ßΓ᫬á.
  1150.             RuntimeFlag=cur->pos->marked;
  1151.             return;
  1152.         case IOCTL_ISLAST    :     // Ä»α«ß¿Γ∞, »«ß½Ññ¡∩∩ ßΓ᫬á ó Σ«½ñÑ?
  1153.             RuntimeFlag=(cur->pos->next==0);
  1154.             return;
  1155.         case IOCTL_INSEARCH  :     // Ä»α«ß¿Γ∞, ¡áσ«ñ¿¼ß∩ ½¿ ó {\tt SearchPage}.
  1156.             RuntimeFlag=Editor.IsInSearchFold;
  1157.             return;
  1158.         case IOCTL_INTEMP    :     // Ä»α«ß¿Γ∞, ¡áσ«ñ¿¼ß∩ ½¿ ó {\tt *TEMP*}.
  1159.             RuntimeFlag=(CurrentPage==ConstantPage);
  1160.             return;
  1161.         case IOCTL_MAXY      :     // Å«½«ª¿Γ∞ ¡á ßΓѬ ¬«½-ó« ßΓ᫬ ¡á φ¬αá¡Ñ
  1162.             nl=NewLine(0);
  1163.             nl->type=SDATA_INT;
  1164.             nl->linenumber=mmm_screen.GetH();
  1165.             break;
  1166.         case IOCTL_MAXX      :     // Å«½«ª¿Γ∞ ¡á ßΓѬ ¬«½-ó« ßΓ«½íµ«ó ¡á φ¬αá¡Ñ
  1167.             nl=NewLine(0);
  1168.             nl->type=SDATA_INT;
  1169.             nl->linenumber=mmm_screen.GetW();
  1170.             break;
  1171.         case IOCTL_CX        :     // Å«½«ª¿Γ∞ ¡á ßΓѬ {\tt cx}
  1172.             nl=NewLine(0);
  1173.             nl->type=SDATA_INT;
  1174.             nl->linenumber=cur->cx;
  1175.             break;
  1176.         case IOCTL_SX        :     // Å«½«ª¿Γ∞ ¡á ßΓѬ {\tt sx}
  1177.             nl=NewLine(0);
  1178.             nl->type=SDATA_INT;
  1179.             nl->linenumber=cur->sx;
  1180.             break;
  1181.         case IOCTL_SY        :     // Å«½«ª¿Γ∞ ¡á ßΓѬ {\tt sy}
  1182.             nl=NewLine(0);
  1183.             nl->type=SDATA_INT;
  1184.             nl->linenumber=cur->sy;
  1185.             break;
  1186.         case IOCTL_LINENUM   :     // Å«½«ª¿Γ∞ ¡á ßΓѬ ¡«¼Ñα ßΓ᫬¿
  1187.             nl=NewLine(0);
  1188.             nl->type=SDATA_INT;
  1189.             nl->linenumber=cur->pos->linenumber;
  1190.             break;
  1191.         }
  1192.     nl->LinkBefore(pos);
  1193.     pos=nl;
  1194.     }
  1195. //&>>&23 0 17 19
  1196.  
  1197. //&>>&E 0 E 1
  1198.  
  1199. void Process(){ for(;;) MkScan(mmm_KBD.GetScan()); }
  1200.  
  1201. //&<<&void Command(short MMMscan){
  1202. void Command(short MMMscan){
  1203.     if(MMMscan==0) return;
  1204. //&<<&    #ifdef _ENABLE_LOGGING_
  1205.     #ifdef _ENABLE_LOGGING_
  1206.         DoLog("Command(int code=0x%4x ) {\n", MMMscan);
  1207.     #endif
  1208. //&>>&1 0 1 3A
  1209.  
  1210.     if(MMMscan==0x701) MMMlib_ABORT(0x701);
  1211.  
  1212.     if(fRecordingMacro)  (*my_macroF7)[my_macroF7_ptr++]=MMMscan;
  1213.  
  1214.     int i,fnum;
  1215.     for(i=0;i<KeyArray.lbase;i++){
  1216.         fnum=KeyArray.base[i].fnum;
  1217.         if(fnum==-1) break;
  1218.         if(KeyArray.base[i].scan==MMMscan)
  1219.             {
  1220.             if(fnum<LEN_COMMAND_ARRAY)
  1221.                 CommandArray[fnum].fRef(MMMscan);
  1222.             else
  1223.                 CommandUsrArray.base[fnum-LEN_COMMAND_ARRAY].Execute(MMMscan);
  1224.             return;
  1225.             }
  1226.         }
  1227. //&<<&    #ifdef _ENABLE_LOGGING_
  1228.     #ifdef _ENABLE_LOGGING_
  1229.         DoLog("    }\n");
  1230.     #endif
  1231. //&>>&1 0 1 8
  1232.     }
  1233. //&>>&F 0 F 2
  1234.  
  1235. //&<<&EDITOR functions
  1236. //&<<&int EDITOR::IsComment(char *buf,char *ptrn);
  1237. int EDITOR::IsComment(char *buf,char *ptrn){
  1238.   if(buf==0) return 0;
  1239.   if(memcmp(buf,comment,lcomment)) return 0;
  1240.   if(memcmp(buf+lcomment,ptrn,strlen(ptrn))) return 0;
  1241.   return 1;
  1242. }
  1243. //&>>&3 0 3 6
  1244. //&<<&void EDITOR::SetComment(char *n);
  1245. void EDITOR::SetComment(char *name){
  1246.   int i,j,k;
  1247.   for(i=0;name[i];i++) if(name[i]=='.'){ i++; break; }
  1248.   for(j=0;j<nExt;j++){
  1249.     for(k=0;name[i+k];k++) if(lower(FileExt[j][k])!=lower(name[i+k])) break;
  1250.     if(name[i+k]==0 && FileExt[j][k]==0){
  1251.       comment=FileCmt[j]; lcomment=strlen(comment); return;
  1252.     }
  1253.   }
  1254.   comment=""; lcomment=0;
  1255. }
  1256. //&>>&0 0 0 8
  1257.  
  1258. //&<<&void EDITOR::Init_ExtensionsFold2Mem(Fold *ExtFold){
  1259. void EDITOR::Init_ExtensionsFold2Mem(Fold *ExtFold){
  1260.    int i, k, fldd;
  1261.  
  1262.    Line *pp=ExtFold->pos;
  1263.    while(pp->next)pp=pp->next;
  1264.    for(nExt=0;pp->prev;nExt++)pp=pp->prev;
  1265.  
  1266.    FileExt=new char*[nExt]; MemTest(FileExt!=0);
  1267.    FileCmt=new char*[nExt]; MemTest(FileCmt!=0);
  1268.  
  1269.     for(i=0;pp && i<nExt;i++){
  1270.         fldd=0;
  1271.         FileExt[i]=new char[4]; MemTest(FileExt[i]!=0);
  1272.         FileCmt[i]=new char[8]; MemTest(FileCmt[i]!=0);
  1273.         for(k=0;*(pp->Buf(k))!=0;k++){
  1274.             if(*(pp->Buf(k))==' ' && !fldd){
  1275.                 strncpy(FileExt[i], pp->Buf(0), k); FileExt[i][k]=0;
  1276.                 fldd=k+1;
  1277.                 }
  1278.             }
  1279.         strncpy(FileCmt[i], pp->Buf(fldd), k+1-fldd);
  1280.         FileCmt[i][k+1-fldd]=0;
  1281.         pp=pp->next;
  1282.         }
  1283.    }
  1284. ///const nExt=13;
  1285. ///char *FileExt[nExt]={"h" ,"hpp","c" ,"cpp","tex","bat"  ,"asm","sty","prg","ch","" ,"rc","sys"};
  1286. ///char *FileCmt[nExt]={"//","//" ,"//","//" ,"%"  ,"@rem ",";"  ,"%"  ,"//" ,"//","#","//","Rem "};
  1287. //&>>&1C 0 1C 6
  1288. //&<<&void EDITOR::Init_keymapFold2Mem(FILE *fptr) {
  1289. void EDITOR::Init_keymapFold2Mem(FILE *fptr) {
  1290.     int i=0,l,j;
  1291.     for(;fgets(templine,0xff,fptr)!=0;i++){
  1292.         if ( Editor.IsComment(templine,"&>>&") ) return;
  1293.         if(i==0){
  1294.             l=strlen(templine);
  1295.             for(j=0;j<l;j+=2){            // read altcase table
  1296.                 mmm_KBD.AltCase[templine[j]]   =templine[j+1];
  1297.                 mmm_KBD.AltCase[templine[j+1]] =templine[j];
  1298.                 }
  1299.             continue;
  1300.             }
  1301.         if(i<5) memcpy(mmm_KBD.keys[i-1],templine,108*sizeof(char)); // read keytable
  1302.         }
  1303.    }
  1304. //&>>&C 0 C 1E
  1305. //&<<&void  EDITOR::Init_SetupFold2Mem() {
  1306. void EDITOR::Init_SetupFold2Mem(FILE *fptr) {
  1307.     char *s;
  1308.     int i;
  1309.     while(fgets(templine,0xff,fptr)!=0){
  1310.         if( Editor.IsComment(templine,"&>>&") ) return;
  1311.         if(memcmp(templine,"Attrs=",6)==0){
  1312.             s=templine+6;
  1313.             for(i=0;i<NAttr;i++) Attrs[i]=int(strtol(s,&s,16));
  1314.             }
  1315.         if(memcmp(templine,"Params=",7)==0){
  1316.             s=templine+7;
  1317.             for(i=0;i<NParams;i++) Params[i]=int(strtol(s,&s,16));
  1318.             }
  1319.         }
  1320.     }
  1321. //&>>&B 0 B D
  1322. //&<<&void EDITOR::Init_CommandFold2Mem(FILE *fptr) {
  1323. void EDITOR::Init_CommandFold2Mem(FILE *fptr) {
  1324.     //// This function is called only from EDITOR::InitEditorSetup,
  1325.     //// Where 'templine' is already allocated!
  1326.     ////     if(strcmp(templine,"&<<&*COMMAND*\n")==0) Init_CommandFold2Mem();
  1327.  
  1328.     char *s;
  1329.     int nl,i;
  1330.     int _scan;
  1331.     while(fgets(templine,0xff,fptr)!=0){
  1332.         if( Editor.IsComment(templine,"&>>&") ) return;
  1333.         s=templine;
  1334.         _scan=int(strtol(s,&s,16));
  1335.         while(*s<=' ')s++;
  1336.         for(nl=0 ; s[nl]>' '; nl++);    s[nl]=0;
  1337.         for(i=0;i<LEN_COMMAND_ARRAY;i++){
  1338.             if(strcmp(CommandArray[i].fName,s)==0){
  1339.                 KeyArray.AddEntry(_scan, i);
  1340.                 break;
  1341.                 }
  1342.             }
  1343.         if(i>=LEN_COMMAND_ARRAY){          // Notfound in MMMLIB, add to UsrLib.
  1344.             i=CommandUsrArray.AddEntry(s,0);
  1345.             KeyArray.AddEntry(_scan, LEN_COMMAND_ARRAY+i);
  1346.             }
  1347.         }
  1348.     }
  1349.  
  1350. //&>>&16 0 11 0
  1351. //&<<&void EDITOR::Init_MacroFold2Mem(FILE *fptr) {
  1352.  
  1353.  
  1354.  
  1355. //&>>&0 0 0 2
  1356.  
  1357.  
  1358. //&<<&EDITOR::EDITOR();
  1359. EDITOR::EDITOR(){
  1360. //&<<&#ifdef _ENABLE_LOGGING_
  1361. #ifdef _ENABLE_LOGGING_
  1362. {
  1363. FILE *flog=fopen("log.","w");
  1364. if(flog){ fputs("MM2 LogFile\n",flog); fclose(flog); }
  1365. }
  1366. #endif
  1367. //&>>&6 0 6 1B
  1368. IsInSearchFold=0; attrs=Attrs;
  1369. }
  1370. //&>>&3 0 3 A
  1371. //&<<&void EDITOR::InitFirstPage()
  1372. void EDITOR::InitFirstPage()
  1373.     {
  1374.     cur=new Fold("*TEMP*");
  1375.     cur->top=0;
  1376.     CurrentPage=new Chain(cur);
  1377.     CurrentPage->next=CurrentPage;
  1378.     CurrentPage->prev=CurrentPage;
  1379.     ConstantPage=CurrentPage;
  1380.     NumberOfPages=1;
  1381.     }
  1382. //&>>&0 0 0 7
  1383. //&<<&void EDITOR::InitUserSetup() {
  1384. void EDITOR::InitUserSetup() {
  1385.     FILE *f;
  1386.     InitialDir=getcurdir();
  1387.  
  1388. //&<<&    UserSetup Folds Init
  1389.     MarkedBlock=new MarkedLine("*ML*");
  1390.     SearchFold=new Fold("*SEARCH*"); SearchFold->top=0;
  1391.  
  1392.     mmm_LineClipboard=NewLine(0);
  1393.     fLineClipboard=new Fold("*LCB*");
  1394.     fLineClipboard->pos=mmm_LineClipboard;
  1395.  
  1396.     InitFirstPage();
  1397. //&>>&5 0 5 5
  1398.     templine=new char[INFTY+1]; MemTest(templine!=0);
  1399.  
  1400.     comment=""; lcomment=0;
  1401.  
  1402.     f=fopen(ConfigFileName,"r"); if(f==0)return;
  1403.     while(fgets(templine,INFTY,f)!=0){
  1404. //&<<&        if(strcmp(templine,"&<<&*SEARCH*\n")==0){
  1405.         if(strcmp(templine,"&<<&*SEARCH*\n")==0){
  1406.             SearchFold->Read(f,FILE_FOLD);
  1407.             }
  1408. //&>>&1 0 1 0
  1409. //&<<&        if(strcmp(templine,"&<<&*TEMP*\n")==0){
  1410.         if(strcmp(templine,"&<<&*TEMP*\n")==0){
  1411.             cur->Read(f,FILE_FOLD);
  1412.             }
  1413. //&>>&1 0 1 C
  1414. //&<<&        if(strcmp(templine,"&<<&*LCB*\n")==0){
  1415.         if(strcmp(templine,"&<<&*LCB*\n")==0){
  1416.             fLineClipboard->Read(f,FILE_FOLD);
  1417.             }
  1418. //&>>&1 0 1 D
  1419.         }
  1420.     fclose(f);
  1421.     while(mmm_LineClipboard->prev) mmm_LineClipboard=mmm_LineClipboard->prev;
  1422.     delete templine;
  1423.  
  1424.     }
  1425. //&>>&D 0 D 0
  1426. //&<<&void EDITOR::InitEditorSetup(){
  1427. void EDITOR::InitEditorSetup(){
  1428.     FILE *f;
  1429.     SetDefaultAttributes();
  1430. //&<<&    ExtensionsFold 
  1431.     Fold *ExtensionsFold=new Fold("*EXTENSIONS*");
  1432.     ExtensionsFold->pos=NewLine(0);
  1433. //&>>&0 0 0 1D
  1434.     templine=new char[INFTY+1]; MemTest(templine!=0);
  1435.  
  1436.     comment=""; lcomment=0;
  1437. //&<<&    f=fopen(cFName,"r"); if(f==0)return; delete cFName;
  1438.     char *cFName=MFileName("mmm_base.cfg");
  1439.     f=fopen(cFName,"r"); if(f==0)return; delete cFName;
  1440. //&>>&0 0 0 0
  1441.     while(fgets(templine,INFTY,f)!=0){
  1442. //&<<&        if(strcmp(templine,"&<<&*EXTENSIONS*\n")==0) {
  1443.         if(strcmp(templine,"&<<&*EXTENSIONS*\n")==0) {
  1444.             ExtensionsFold->Read(f,FILE_FOLD);
  1445.             Init_ExtensionsFold2Mem(ExtensionsFold);
  1446.             }
  1447. //&>>&2 0 2 37
  1448. //&<<&        if(strcmp(templine,"&<<&*KEYMAP*\n")==0) {
  1449.         if(strcmp(templine,"&<<&*KEYMAP*\n")==0) {
  1450.             Init_keymapFold2Mem(f);
  1451.             }
  1452. //&>>&1 0 1 2D
  1453. //&<<&        if(strcmp(templine,"&<<&*SETUP*\n")==0) {
  1454.         if(strcmp(templine,"&<<&*SETUP*\n")==0) {
  1455.             Init_SetupFold2Mem(f);
  1456.             }
  1457. //&>>&1 0 1 10
  1458. //&<<&        if(strcmp(templine,"&<<&*COMMAND*\n")==0) {
  1459.         if(strcmp(templine,"&<<&*COMMAND*\n")==0) {
  1460.             Init_CommandFold2Mem(f);
  1461.             }
  1462. //&>>&1 0 1 13
  1463. //&<<&        if(strcmp(templine,"&<<&*MACRO*\n")==0) {
  1464.         if(strcmp(templine,"&<<&*MACRO*\n")==0) {
  1465.             Compile(f);
  1466.             }
  1467. //&>>&1 0 1 17
  1468.         }
  1469.     fclose(f);
  1470.     delete ExtensionsFold;
  1471.  
  1472.     delete templine;
  1473.  
  1474.     RuntimeStack->pos=NewLine(0);
  1475.     }
  1476. //&>>&D 0 D 8
  1477. //&<<&EDITOR::~EDITOR();
  1478. EDITOR::~EDITOR(){
  1479.     if(MinimalExitFromEditor) return;
  1480. //&<<&    #ifdef _ENABLE_LOGGING_
  1481.   #ifdef _ENABLE_LOGGING_
  1482.       DoLog("EDITOR::~EDITOR() {\n");
  1483.   #endif
  1484. //&>>&1 0 1 19
  1485.     SaveChDir(InitialDir);
  1486. //&<<&    ConstantPage->Exit();   SearchFold->Exit();
  1487. //&<<&    #ifdef _ENABLE_LOGGING_
  1488.   #ifdef _ENABLE_LOGGING_
  1489.       DoLog("    ConstantPage, SearchFold ->Exit() {\n");
  1490.   #endif
  1491. //&>>&1 0 1 F
  1492.     if(CurrentPage!=ConstantPage)cur=ConstantPage->entry;
  1493.     Fold *r=0;    /// temporary variable
  1494.     while((r=cur->Exit())!=0) cur=r;
  1495.     while((r=SearchFold->Exit())!=0) SearchFold=r;
  1496. //&<<&    #ifdef _ENABLE_LOGGING_
  1497.   #ifdef _ENABLE_LOGGING_
  1498.       DoLog("        }(r=0)\n");
  1499.   #endif
  1500. //&>>&1 0 1 6
  1501. //&>>&0 0 0 19
  1502.     comment=""; lcomment=0;
  1503. //&<<&          #ifdef _ENABLE_LOGGING_
  1504.         #ifdef _ENABLE_LOGGING_
  1505.             DoLog("    f=fopen(ConfigFileName,w);\n");
  1506.         #endif
  1507. //&>>&1 0 1 C
  1508.     FILE *f=fopen(ConfigFileName,"w");  MemTest(f!=0);
  1509. //&<<&          #ifdef _ENABLE_LOGGING_
  1510.         #ifdef _ENABLE_LOGGING_
  1511.             DoLog("    SearchFold->Write\n");
  1512.         #endif
  1513. //&>>&1 0 1 C
  1514.     SearchFold->Write(f,FILE_FOLD);     //// Writing *SEARCH*
  1515. //&<<&          #ifdef _ENABLE_LOGGING_
  1516.         #ifdef _ENABLE_LOGGING_
  1517.             DoLog("    cur->Write\n");
  1518.         #endif
  1519. //&>>&1 0 1 C
  1520.     cur->Write(f,FILE_FOLD);            //// Writing *TEMP*
  1521. //&<<&          #ifdef _ENABLE_LOGGING_
  1522.         #ifdef _ENABLE_LOGGING_
  1523.             DoLog("    LCB->Write\n");
  1524.         #endif
  1525. //&>>&1 0 1 C
  1526.     fLineClipboard->Write(f,FILE_FOLD);  //// Writing *LCB*
  1527. //&<<&          #ifdef _ENABLE_LOGGING_
  1528.         #ifdef _ENABLE_LOGGING_
  1529.             DoLog("    written!!!!!\n");
  1530.         #endif
  1531. //&>>&1 0 1 C
  1532.     fclose(f);
  1533. //&<<&          #ifdef _ENABLE_LOGGING_
  1534.         #ifdef _ENABLE_LOGGING_
  1535.             DoLog("    CLOSED!!!!!\n");
  1536.         #endif
  1537. //&>>&1 0 1 D
  1538.  
  1539. //&<<&    #ifdef _ENABLE_LOGGING_
  1540.   #ifdef _ENABLE_LOGGING_
  1541.       DoLog("    }\n");
  1542.   #endif
  1543. //&>>&1 0 1 10
  1544.     }
  1545. //&>>&D 0 D 5
  1546.  
  1547. //&>>&6 0 6 1A
  1548.  
  1549. //&<<&void main()
  1550.  
  1551. void main(int argc,char *argv[]){
  1552.   int i;
  1553.  
  1554.   strcpy(RunDir,argv[0]);
  1555.   SaveChDir(".");
  1556.  
  1557.   iGCD_SavedDev=GetSavedDev();
  1558.  
  1559.   Editor.InitEditorSetup();
  1560.   Editor.ConfigFileName=MFileName("mmm.cfg");
  1561.   Editor.InitUserSetup();
  1562.  
  1563.   int fx=FILE_FOLD,fn=1;
  1564.   int k=0;
  1565.  
  1566.  
  1567.   FILE *pfScriptExists=fopen(MFileName("__mmm__.mmm"),"r");
  1568.   if(pfScriptExists==0){
  1569.       for(i=1;i<argc;i++) k|=_EDIT(argv[i],fn,fx,1);
  1570.       if(k==0) _EDIT("",fn,fx,1);
  1571.   }else{
  1572.       fclose(pfScriptExists);
  1573.       _EDIT_ScriptFile(MFileName("__mmm__.mmm")-1,fn,fx);
  1574.       }
  1575.  
  1576.   GetCurrentFileNameAndDepth();
  1577.   Process();
  1578. }
  1579. //&>>&E 0 E 7
  1580. //// mmmx.err mmmx.err mmmx.err mmmx.err mmmx.err mmmx.err
  1581. //&>>&11 0 D 7
  1582.