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