home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / M-BRIEF.ZIP / STDMACRO.C < prev    next >
C/C++ Source or Header  |  1989-02-22  |  19KB  |  906 lines
  1. /* STDMACRO.c - Standard macros for Msoft editor
  2. **
  3. ** Copyright (c) 1988, Christopher Laforet
  4. ** All Rights Reserved
  5. **
  6. */
  7.  
  8. #define LINT_ARGS
  9.  
  10.  
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include "ext.h"
  15.  
  16.  
  17. #define TRUE    -1
  18. #define FALSE    0
  19.  
  20.  
  21.  
  22. /* Globals */
  23.  
  24. unsigned char far locbuf[100];
  25. unsigned char far string[61];
  26. unsigned char far filename[51];
  27. unsigned char far zero_length[2];
  28. flagType search_direction = 1;        /* no previous search pattern */
  29. flagType case_sensitive = 1;        /* case sensitivity */
  30. flagType wrapping = 1;                /* word wrapping is off by default */
  31. flagType _tab = 1;                    /* every 4 spaces to tabs by default */
  32. flagType _soft = 1;                 /* soft cr is on by default */
  33. LINE top_row;
  34. COL top_col;
  35. LINE bottom_row;
  36. COL bottom_col;
  37. LINE row;
  38. COL col;
  39. COL new_col;
  40. unsigned char key;
  41. unsigned char far *cptr;
  42. unsigned char far *cptr1;
  43. unsigned short line;
  44. unsigned char numbuf[5];
  45. unsigned short factor;
  46. unsigned char execute_buffer[200];
  47. unsigned char name[21];
  48. short character;
  49. flagType rtn;
  50. short count;
  51. short temp;
  52. PFILE cur_file;
  53. PFILE output_file;
  54.  
  55.  
  56.  
  57. flagType pascal EXTERNAL toggle_case(argtype,argptr,metaflag)
  58. unsigned short argtype;
  59. ARG far *argptr;
  60. flagType metaflag;
  61.     {
  62.     if (case_sensitive)
  63.         {
  64.         case_sensitive = 0;
  65.         fExecute("arg \"nocase:\" assign");
  66.         DoMessage("Case insensitive searches");
  67.         }
  68.     else
  69.         {
  70.         case_sensitive = 1;
  71.         fExecute("arg \"case:\" assign");
  72.         DoMessage("Case sensitive searches");
  73.         }
  74.     }
  75.  
  76.  
  77. flagType pascal EXTERNAL toggle_wrap(argtype,argptr,metaflag)
  78. unsigned short argtype;
  79. ARG far *argptr;
  80. flagType metaflag;
  81.     {
  82.     if (wrapping)
  83.         {
  84.         wrapping = 0;
  85.         fExecute("Arg \"wordwrap:\" Assign");
  86.         DoMessage("Word wrapping is now active");
  87.         }
  88.     else
  89.         {
  90.         wrapping = 1;
  91.         fExecute("Arg \"nowordwrap:\" Assign");
  92.         DoMessage("Word wrapping is now inactive");
  93.         }
  94.     }
  95.  
  96.  
  97. flagType pascal EXTERNAL toggle_tab(argtype,argptr,metaflag)
  98. unsigned short argtype;
  99. ARG far *argptr;
  100. flagType metaflag;
  101.     {
  102.     if (_tab)
  103.         {
  104.         _tab = 0;
  105.         fExecute("Arg \"entab:0\" Assign");
  106.         DoMessage("Spaces are not encoded to Tabs");
  107.         }
  108.     else
  109.         {
  110.         _tab = 1;
  111.         fExecute("Arg \"entab:1\" Assign");
  112.         DoMessage("Spaces are encoded to Tabs");
  113.         }
  114.     }
  115.  
  116.  
  117. flagType pascal EXTERNAL toggle_cr(argtype,argptr,metaflag)
  118. unsigned short argtype;
  119. ARG far *argptr;
  120. flagType metaflag;
  121.     {
  122.     if (_soft)
  123.         {
  124.         _soft = 0;
  125.         fExecute("arg \"nosoftcr:\" assign");
  126.         DoMessage("Auto indent is off");
  127.         }
  128.     else
  129.         {
  130.         _soft = 1;
  131.         fExecute("arg \"softcr:\" assign");
  132.         DoMessage("Auto indent is on");
  133.         }
  134.     }
  135.  
  136.  
  137. flagType pascal EXTERNAL make_vertical_win(argtype,argptr,metaflag)
  138. unsigned short argtype;
  139. ARG far *argptr;
  140. flagType metaflag;
  141.     {
  142.     DoMessage("Do you want to create a Vertical window? ");
  143.     do
  144.         {
  145.         key = ReadChar();
  146.         key &= 0xdf;
  147.         }
  148.     while((key != 'Y') && (key != 'N'));
  149.     DoMessage("Done");
  150.     if (key == 'Y')
  151.         {
  152.         GetCursor(&col,&row);    /* save current cursor position */
  153.         fExecute("Home");            /* let's get our reference point established */
  154.         GetCursor(&top_col,&top_row);
  155.         fExecute("Meta Down Meta Right");
  156.         GetCursor(&bottom_col,&bottom_row);
  157.         MoveCur(top_col + ((bottom_col - top_col) >> 1),row);
  158.         fExecute("Arg Arg Window");     /* create window */
  159.         MoveCur(col,row);            /* leave as it was */
  160.         }
  161.     return(TRUE);
  162.     }
  163.  
  164.  
  165. flagType pascal EXTERNAL make_horizontal_win(argtype,argptr,metaflag)
  166. unsigned short argtype;
  167. ARG far *argptr;
  168. flagType metaflag;
  169.     {
  170.     DoMessage("Do you want to create a Horizontal window? ");
  171.     do
  172.         {
  173.         key = ReadChar();
  174.         key &= 0xdf;
  175.         }
  176.     while((key != 'Y') && (key != 'N'));
  177.     DoMessage("Done");
  178.     if (key == 'Y')
  179.         {
  180.         GetCursor(&col,&row);    /* save current cursor position */
  181.         fExecute("Home");            /* let's get our reference point established */
  182.         GetCursor(&top_col,&top_row);
  183.         fExecute("Meta Down Meta Right");
  184.         GetCursor(&bottom_col,&bottom_row);
  185.         MoveCur(col,(top_row + ((bottom_row - top_row) >> 1)));
  186.         fExecute("Arg Window");     /* create window */
  187.         MoveCur(col,row);            /* leave as it was */
  188.         }
  189.     return(TRUE);
  190.     }
  191.  
  192. unsigned char far *cptr3;
  193. unsigned char far *cptr4;
  194.  
  195. void pascal concat(str1,str2,result)
  196. unsigned char far *str1;
  197. unsigned char far *str2;
  198. unsigned char far *result;
  199.     {
  200.     cptr3= result;
  201.     cptr4 = str1;
  202.     while (*cptr4)
  203.         {
  204.         *cptr3++ = *cptr4++;
  205.         }
  206.     cptr4 = str2;
  207.     while (*cptr4)
  208.         {
  209.         *cptr3++ = *cptr4++;
  210.         }
  211.     *cptr3 = 0;
  212.     }
  213.  
  214.  
  215. flagType pascal EXTERNAL goto_line(argtype,argptr,metaflag)
  216. unsigned short argtype;
  217. ARG far *argptr;
  218. flagType metaflag;
  219.     {
  220.     factor = 1;
  221.     line = 0;
  222.     numbuf[0] = 0;
  223.     cptr = numbuf;
  224.     do
  225.         {
  226.         concat("Go to which line? ",numbuf,locbuf);
  227.         DoMessage(locbuf);
  228.         key = ReadChar();
  229.         if ((key >= '0') && (key <= '9') && (cptr < (numbuf + sizeof(numbuf) - 1)))
  230.             {
  231.             *cptr++ = key;
  232.             *cptr = 0;
  233.             }
  234.         else if ((key == 8) && (cptr != numbuf))
  235.             {
  236.             --cptr;
  237.             *cptr = 0;
  238.             }
  239.         }
  240.     while((key != 0x1b) && (key != 0xd));
  241.     if ((key == 0xd) && (*numbuf))
  242.         {
  243.         cptr = numbuf;
  244.         while (*(cptr + 1))
  245.             {
  246.             ++cptr;
  247.             }
  248.         while (cptr >= numbuf)
  249.             {
  250.             line += (short)(*cptr - (char)'0') * factor;
  251.             factor *= 10;
  252.             --cptr;
  253.             }
  254.         if (line)
  255.             {
  256.             line -= 1L;
  257.             }
  258.         if (line < FileLength(FileNameToHandle(zero_length,zero_length)))
  259.             {
  260.             MoveCur(0,(LINE)line);
  261.             DoMessage("Done");
  262.             }
  263.         else
  264.             {
  265.             DoMessage("Invalid line specified");
  266.             }
  267.         }
  268.     else
  269.         {
  270.         DoMessage("Operation cancelled");
  271.         }
  272.     }
  273.  
  274.  
  275. flagType pascal EXTERNAL psearch_expression(argtype,argptr,metaflag)
  276. unsigned short argtype;
  277. ARG far *argptr;
  278. flagType metaflag;
  279.     {
  280.     string[0] = 0;
  281.     cptr = string;
  282.     do
  283.         {
  284.         concat("Search (+) for? ",string,locbuf);
  285.         DoMessage(locbuf);
  286.         key = ReadChar();
  287.         if ((key >= ' ') && (key < 0x7f) && (cptr < (string + sizeof(string) - 1)))
  288.             {
  289.             *cptr++ = key;
  290.             *cptr = 0;
  291.             }
  292.         else if ((key == 8) && (cptr != string))
  293.             {
  294.             --cptr;
  295.             *cptr = 0;
  296.             }
  297.         }
  298.     while ((key != 0x1b) && (key != 0xd));
  299.     if ((key == 0xd) && (*string))
  300.         {
  301.         search_direction = FALSE;
  302.         concat("arg arg \"",string,locbuf);
  303.         concat(locbuf,"\" psearch",execute_buffer);
  304.         rtn = fExecute(execute_buffer);
  305.         if (rtn)
  306.             {
  307.             DoMessage("");
  308.             }
  309.         else
  310.             {
  311.             DoMessage("No match found");
  312.             }
  313.         }
  314.     else
  315.         {
  316.         DoMessage("Operation cancelled");
  317.         }
  318.     return(TRUE);
  319.     }
  320.  
  321.  
  322. flagType pascal EXTERNAL msearch_expression(argtype,argptr,metaflag)
  323. unsigned short argtype;
  324. ARG far *argptr;
  325. flagType metaflag;
  326.     {
  327.     string[0] = 0;
  328.     cptr = string;
  329.     do
  330.         {
  331.         concat("Search (-) for? ",string,locbuf);
  332.         DoMessage(locbuf);
  333.         key = ReadChar();
  334.         if ((key >= ' ') && (key < 0x7f) && (cptr < (string + sizeof(string) - 1)))
  335.             {
  336.             *cptr++ = key;
  337.             *cptr = 0;
  338.             }
  339.         else if ((key == 8) && (cptr != string))
  340.             {
  341.             --cptr;
  342.             *cptr = 0;
  343.             }
  344.         }
  345.     while ((key != 0x1b) && (key != 0xd));
  346.     if ((key == 0xd) && (*string))
  347.         {
  348.         search_direction = TRUE;
  349.         concat("arg arg \"",string,locbuf);
  350.         concat(locbuf,"\" msearch",execute_buffer);
  351.         rtn = fExecute(execute_buffer);
  352.         if (rtn)
  353.             {
  354.             DoMessage("");
  355.             }
  356.         else
  357.             {
  358.             DoMessage("No match found");
  359.             }
  360.         }
  361.     else
  362.         {
  363.         DoMessage("Operation cancelled");
  364.         }
  365.     return(TRUE);
  366.     }
  367.  
  368.  
  369. flagType pascal EXTERNAL search_again(argtype,argptr,metaflag)
  370. unsigned short argtype;
  371. ARG far *argptr;
  372. flagType metaflag;
  373.     {
  374.     if (search_direction == 1)
  375.         {
  376.         DoMessage("No previous search pattern");
  377.         return(FALSE);
  378.         }
  379.     if (search_direction)         /* search backwards */
  380.         {
  381.         concat("Search (-) again for: ",string,locbuf);
  382.         DoMessage(locbuf);
  383.         concat("arg arg \"",string,locbuf);
  384.         concat(locbuf,"\" msearch",execute_buffer);
  385.         fExecute(execute_buffer);
  386.         if (rtn)
  387.             {
  388.             DoMessage("");
  389.             }
  390.         else
  391.             {
  392.             DoMessage("No match found");
  393.             }
  394.         }
  395.     else
  396.         {
  397.         concat("Search (+) again for: ",string,locbuf);
  398.         DoMessage(locbuf);
  399.         concat("arg arg \"",string,locbuf);
  400.         concat(locbuf,"\" psearch",execute_buffer);
  401.         rtn = fExecute(execute_buffer);
  402.         if (rtn)
  403.             {
  404.             DoMessage("");
  405.             }
  406.         else
  407.             {
  408.             DoMessage("No match found");
  409.             }
  410.         }
  411.     return(TRUE);
  412.     }
  413.  
  414.  
  415. flagType pascal EXTERNAL open_file(argtype,argptr,metaflag)
  416. unsigned short argtype;
  417. ARG far *argptr;
  418. flagType metaflag;
  419.     {
  420.     filename[0] = 0;
  421.     cptr = filename;
  422.     do
  423.         {
  424.         concat("Edit what file? ",filename,locbuf);
  425.         DoMessage(locbuf);
  426.         key = ReadChar();
  427.         if ((key >= ' ') && (key < 0x7f) && (cptr < (filename + sizeof(filename) - 1)))
  428.             {
  429.             if (key == '\\')
  430.                 {
  431.                 *cptr++ = '\\';     /* double backslashes */
  432.                 }
  433.             *cptr++ = key;
  434.             *cptr = 0;
  435.             }
  436.         else if ((key == 8) && (cptr != filename))
  437.             {
  438.             --cptr;
  439.             if (*cptr == '\\')
  440.                 {
  441.                 --cptr;
  442.                 }
  443.             *cptr = 0;
  444.             }
  445.         }
  446.     while ((key != 0x1b) && (key != 0xd));
  447.     if ((key == 0xd) && (*filename))
  448.         {
  449.         concat("arg \"",filename,locbuf);
  450.         concat(locbuf,"\" setfile",execute_buffer);
  451.         fExecute(execute_buffer);
  452.         DoMessage("");
  453.         }
  454.     else
  455.         {
  456.         DoMessage("Operation cancelled");
  457.         }
  458.     return(TRUE);
  459.     }
  460.  
  461.  
  462. flagType pascal EXTERNAL write_out_file(argtype,argptr,metaflag)
  463. unsigned short argtype;
  464. ARG far *argptr;
  465. flagType metaflag;
  466.     {
  467.     filename[0] = 0;
  468.     cptr = filename;
  469.     do
  470.         {
  471.         concat("Write file to? ",filename,locbuf);
  472.         DoMessage(locbuf);
  473.         key = ReadChar();
  474.         if ((key >= ' ') && (key < 0x7f) && (cptr < (filename + sizeof(filename) - 1)))
  475.             {
  476.             if (key == '\\')
  477.                 {
  478.                 *cptr++ = '\\';     /* double backslashes */
  479.                 }
  480.             *cptr++ = key;
  481.             *cptr = 0;
  482.             }
  483.         else if ((key == 8) && (cptr != filename))
  484.             {
  485.             --cptr;
  486.             if (*cptr == '\\')
  487.                 {
  488.                 --cptr;
  489.                 }
  490.             *cptr = 0;
  491.             }
  492.         }
  493.     while ((key != 0x1b) && (key != 0xd));
  494.     if ((key == 0xd) && (*filename))
  495.         {
  496.         concat("arg arg \"",filename,locbuf);
  497.         concat(locbuf,"\" setfile",execute_buffer);
  498.         fExecute(execute_buffer);
  499.         DoMessage("");
  500.         }
  501.     else
  502.         {
  503.         DoMessage("Operation cancelled");
  504.         }
  505.     return(TRUE);
  506.     }
  507.  
  508.  
  509. flagType pascal EXTERNAL change_file(argtype,argptr,metaflag)
  510. unsigned short argtype;
  511. ARG far *argptr;
  512. flagType metaflag;
  513.     {
  514.     filename[0] = 0;
  515.     cptr = filename;
  516.     do
  517.         {
  518.         concat("Change to what file? ",filename,locbuf);
  519.         DoMessage(locbuf);
  520.         key = ReadChar();
  521.         if ((key >= ' ') && (key < 0x7f) && (cptr < (filename + sizeof(filename) - 1)))
  522.             {
  523.             if (key == '\\')
  524.                 {
  525.                 *cptr++ = '\\';     /* double backslashes */
  526.                 }
  527.             *cptr++ = key;
  528.             *cptr = 0;
  529.             }
  530.         else if ((key == 8) && (cptr != filename))
  531.             {
  532.             --cptr;
  533.             if (*cptr == '\\')
  534.                 {
  535.                 --cptr;
  536.                 }
  537.             *cptr = 0;
  538.             }
  539.         }
  540.     while ((key != 0x1b) && (key != 0xd));
  541.     if (key == 0xd)
  542.         {
  543.         if (filename[0])
  544.             {
  545.             concat("arg \"",filename,locbuf);
  546.             concat(locbuf,"\" setfile",execute_buffer);
  547.             fExecute(execute_buffer);
  548.             DoMessage("");
  549.             }
  550.         else
  551.             {
  552.             fExecute("setfile");
  553.             DoMessage("");
  554.             }
  555.         }
  556.     else
  557.         {
  558.         DoMessage("Operation cancelled");
  559.         }
  560.     return(TRUE);
  561.     }
  562.  
  563.  
  564.  
  565. flagType pascal EXTERNAL read_in_file(argtype,argptr,metaflag)
  566. unsigned short argtype;
  567. ARG far *argptr;
  568. flagType metaflag;
  569.     {
  570.     filename[0] = 0;
  571.     cptr = filename;
  572.     do
  573.         {
  574.         concat("Insert what file? ",filename,locbuf);
  575.         DoMessage(locbuf);
  576.         key = ReadChar();
  577.         if ((key >= ' ') && (key < 0x7f) && (cptr < (filename + sizeof(filename) - 1)))
  578.             {
  579.             if (key == '\\')
  580.                 {
  581.                 *cptr++ = '\\';     /* double backslashes */
  582.                 }
  583.             *cptr++ = key;
  584.             *cptr = 0;
  585.             }
  586.         else if ((key == 8) && (cptr != filename))
  587.             {
  588.             --cptr;
  589.             if (*cptr == '\\')
  590.                 {
  591.                 --cptr;
  592.                 }
  593.             *cptr = 0;
  594.             }
  595.         }
  596.     while ((key != 0x1b) && (key != 0xd));
  597.     if ((key == 0xd) && (*filename))
  598.         {
  599.         concat("arg arg \"",filename,locbuf);
  600.         concat(locbuf,"\" paste",execute_buffer);
  601.         fExecute(execute_buffer);
  602.         DoMessage("Done");
  603.         }
  604.     else
  605.         {
  606.         DoMessage("Operation cancelled");
  607.         }
  608.     return(TRUE);
  609.     }
  610.  
  611.  
  612. void pascal EXTERNAL delete(argtype,argptr,metaflag)
  613. unsigned short argtype;
  614. ARG far *argptr;
  615. flagType metaflag;
  616.     {
  617.     switch (argptr->argType)
  618.         {
  619.         case STREAMARG:
  620.             DelStream(FileNameToHandle(zero_length,zero_length),argptr->arg.streamarg.xStart,argptr->arg.streamarg.yStart,argptr->arg.streamarg.xEnd,argptr->arg.streamarg.yEnd);
  621.             break;
  622.         case BOXARG:
  623.             DelBox(FileNameToHandle(zero_length,zero_length),argptr->arg.boxarg.xLeft,argptr->arg.boxarg.yTop,argptr->arg.boxarg.xRight,argptr->arg.boxarg.yBottom);
  624.             break;
  625.         case LINEARG:
  626.             DelLine(FileNameToHandle(zero_length,zero_length),argptr->arg.linearg.yStart,argptr->arg.linearg.yEnd);
  627.             break;
  628.         case NOARG:
  629.             fExecute("right emacscdel");
  630.             break;
  631.         }
  632.     }
  633.  
  634.  
  635. flagType pascal EXTERNAL deltline(argtype,argptr,metaflag)
  636. unsigned short argtype;
  637. ARG far *argptr;
  638. flagType metaflag;
  639.     {
  640.     GetCursor(&col,&row);
  641.     DelLine(FileNameToHandle(zero_length,zero_length),row,row);
  642.     }
  643.  
  644.  
  645. void pascal EXTERNAL hack(argtype,argptr,metaflag)
  646. unsigned short argtype;
  647. ARG far *argptr;
  648. flagType metaflag;
  649.     {
  650.     fExecute("endline");
  651.     GetCursor(&col,&row);
  652.     MoveCur(argptr->arg.noarg.x,argptr->arg.noarg.y);
  653.     DelStream(FileNameToHandle(zero_length,zero_length),argptr->arg.noarg.x,argptr->arg.noarg.y,col,row);
  654.     }
  655.  
  656.  
  657. flagType pascal EXTERNAL mark_line(argtype,argptr,metaflag)
  658. unsigned short argtype;
  659. ARG far *argptr;
  660. flagType metaflag;
  661.     {
  662.     name[0] = 0;
  663.     cptr = name;
  664.     do
  665.         {
  666.         concat("What title do you want to mark this location as? ",name,locbuf);
  667.         DoMessage(locbuf);
  668.         key = ReadChar();
  669.         if ((key >= ' ') && (key < 0x7f) && (cptr < (name + sizeof(name) - 1)))
  670.             {
  671.             *cptr++ = key;
  672.             *cptr = 0;
  673.             }
  674.         else if ((key == 8) && (cptr != name))
  675.             {
  676.             --cptr;
  677.             *cptr = 0;
  678.             }
  679.         }
  680.     while((key != 0x1b) && (key != 0xd));
  681.     if ((key == 0xd) && (*name))
  682.         {
  683.         concat("arg arg \"",name,locbuf);
  684.         concat(locbuf,"\" mark",execute_buffer);
  685.         if (fExecute(execute_buffer))
  686.             {
  687.             DoMessage("Done");
  688.             }
  689.         }
  690.     else
  691.         {
  692.         DoMessage("Operation cancelled");
  693.         }
  694.     }
  695.  
  696.  
  697. flagType pascal EXTERNAL goto_mark(argtype,argptr,metaflag)
  698. unsigned short argtype;
  699. ARG far *argptr;
  700. flagType metaflag;
  701.     {
  702.     name[0] = 0;
  703.     cptr = name;
  704.     do
  705.         {
  706.         concat("Go to which mark? ",name,locbuf);
  707.         DoMessage(locbuf);
  708.         key = ReadChar();
  709.         if ((key >= ' ') && (key < 0x7f) && (cptr < (name + sizeof(name) - 1)))
  710.             {
  711.             *cptr++ = key;
  712.             *cptr = 0;
  713.             }
  714.         else if ((key == 8) && (cptr != name))
  715.             {
  716.             --cptr;
  717.             *cptr = 0;
  718.             }
  719.         }
  720.     while((key != 0x1b) && (key != 0xd));
  721.     if ((key == 0xd) && (*name))
  722.         {
  723.         concat("arg \"",name,locbuf);
  724.         concat(locbuf,"\" mark",execute_buffer);
  725.         if (fExecute(execute_buffer))
  726.             {
  727.             DoMessage("Done");
  728.             }
  729.         }
  730.     else
  731.         {
  732.         DoMessage("Operation cancelled");
  733.         }
  734.     }
  735.  
  736.  
  737.  
  738. void pascal EXTERNAL setdel(argtype,argptr,metaflag)
  739. unsigned short argtype;
  740. ARG far *argptr;
  741. flagType metaflag;
  742.     {
  743.     fExecute("arg \"sdelete:del\" assign");
  744.     }
  745.  
  746.  
  747. void pascal EXTERNAL resetdel(argtype,argptr,metaflag)
  748. unsigned short argtype;
  749. ARG far *argptr;
  750. flagType metaflag;
  751.     {
  752.     fExecute("arg \"delete:del\" assign");
  753.     }
  754.  
  755.  
  756. void pascal EXTERNAL tab_forward(argtype,argptr,metaflag)
  757. unsigned short argtype;
  758. ARG far *argptr;
  759. flagType metaflag;
  760.     {
  761.     GetCursor(&col,&row);
  762.     fExecute("tab");
  763.     GetCursor(&new_col,&row);
  764.     for (count = col; count < new_col; count++)
  765.         {
  766.         Replace(' ',col,row,FileNameToHandle(zero_length,zero_length),TRUE);
  767.         }
  768.     }
  769.  
  770.  
  771. flagType pascal EXTERNAL write_area(argtype,argptr,metaflag)
  772. unsigned short argtype;
  773. ARG far *argptr;
  774. flagType metaflag;
  775.     {
  776.     if (argptr->argType == NOARG)
  777.         {
  778.         DoMessage("Saving file");
  779.         fExecute("arg arg setfile");
  780.         DoMessage("");
  781.         }
  782.     else
  783.         {
  784.         filename[0] = 0;
  785.         cptr = filename;
  786.         do
  787.             {
  788.             concat("Write area as? ",filename,locbuf);
  789.             DoMessage(locbuf);
  790.             key = ReadChar();
  791.             if ((key >= ' ') && (key < 0x7f) && (cptr < (filename + sizeof(filename) - 1)))
  792.                 {
  793.                 if (key == '\\')
  794.                     {
  795.                     *cptr++ = '\\';     /* double backslashes */
  796.                     }
  797.                 *cptr++ = key;
  798.                 *cptr = 0;
  799.                 }
  800.             else if ((key == 8) && (cptr != filename))
  801.                 {
  802.                 --cptr;
  803.                 if (*cptr == '\\')
  804.                     {
  805.                     --cptr;
  806.                     }
  807.                 *cptr = 0;
  808.                 }
  809.             }
  810.         while ((key != 0x1b) && (key != 0xd));
  811.         if ((key == 0xd) && (*filename))
  812.             {
  813.             DoMessage("Now writing marked area to file");
  814.             cur_file = FileNameToHandle(zero_length,zero_length);
  815.             AddFile(filename);
  816.             output_file = FileNameToHandle(filename,zero_length);
  817.             CopyLine(cur_file,output_file,argptr->arg.linearg.yStart,argptr->arg.linearg.yEnd,0L);
  818.             pFileToTop(output_file);
  819.             concat("arg arg \"",filename,locbuf);
  820.             concat(locbuf,"\" setfile",execute_buffer);
  821.             if (!fExecute(execute_buffer))
  822.                 {
  823.                 DoMessage("Error writing file");
  824.                 pFileToTop(cur_file);
  825.                 RemoveFile(output_file);
  826.                 }
  827.             else
  828.                 {
  829.                 RemoveFile(output_file);
  830.                 pFileToTop(cur_file);
  831.                 DoMessage("");
  832.                 }
  833.             }
  834.         else
  835.             {
  836.             DoMessage("Operation cancelled");
  837.             }
  838.         }
  839.     return(TRUE);
  840.     }
  841.  
  842.  
  843. WhenLoaded()
  844.     {
  845.     DoMessage("Standard Macros (v 1.2) -- Copyright (c) 1988-89, Chris Laforet.");
  846.     zero_length[0] = (char)'\0';
  847.     SetKey("toggle_case","Alt+c");
  848.     SetKey("toggle_wrap","Alt+q");
  849.     SetKey("toggle_tab","Alt+t");
  850.     SetKey("toggle_cr","Alt+y");
  851.     SetKey("make_vertical_win","F1");
  852.     SetKey("make_horizontal_win","F2");
  853.     SetKey("goto_line","Alt+g");
  854.     SetKey("psearch_expression","F5");
  855.     SetKey("msearch_expression","Shift+F5");
  856.     SetKey("search_again","Shift+F6");
  857.     SetKey("open_file","Alt+e");
  858.     SetKey("read_in_file","Alt+r");
  859.     SetKey("delete","Del");
  860.     SetKey("deltline","Alt+d");
  861.     SetKey("hack","Alt+k");
  862.     SetKey("write_out_file","Alt+o");
  863.     SetKey("goto_mark","Alt+j");
  864.     SetKey("mark_line","Alt+s");
  865.     SetKey("tab_forward","Tab");
  866.     SetKey("change_file","Alt+n");
  867.     SetKey("write_area","Alt+w");
  868.     return(TRUE);
  869.     }
  870.  
  871.  
  872.  
  873. struct swiDesc swiTable[] =
  874.     {
  875.         {NULL,NULL,NULL}
  876.     };
  877.  
  878.  
  879. struct cmdDesc cmdTable[] =
  880.     {
  881.         {"toggle_case",toggle_case,NULL,NOARG},
  882.         {"toggle_wrap",toggle_wrap,NULL,NOARG},
  883.         {"toggle_tab",toggle_tab,NULL,NOARG},
  884.         {"toggle_cr",toggle_cr,NULL,NOARG},
  885.         {"make_vertical_win",make_vertical_win,NULL,NOARG},
  886.         {"make_horizontal_win",make_horizontal_win,NULL,NOARG},
  887.         {"goto_line",goto_line,NULL,NOARG},
  888.         {"psearch_expression",psearch_expression,NULL,NOARG},
  889.         {"msearch_expression",msearch_expression,NULL,NOARG},
  890.         {"search_again",search_again,NULL,NOARG},
  891.         {"open_file",open_file,NULL,NOARG},
  892.         {"read_in_file",read_in_file,NULL,NOARG},
  893.         {"delete",delete,NULL,NOARG | STREAMARG | BOXARG | LINEARG},
  894.         {"deltline",deltline,NULL,NOARG},
  895.         {"hack",hack,NULL,NOARG},
  896.         {"write_out_file",write_out_file,NULL,NOARG},
  897.         {"goto_mark",goto_mark,NULL,NOARG},
  898.         {"mark_line",mark_line,NULL,NOARG},
  899.         {"setdel",setdel,NULL,NOARG},
  900.         {"resetdel",resetdel,NULL,NOARG},
  901.         {"tab_forward",tab_forward,NULL,NOARG},
  902.         {"write_area",write_area,NULL,NOARG | LINEARG},
  903.         {"change_file",change_file,NULL,NOARG},
  904.         {NULL,NULL,NULL,NULL}
  905.     };
  906.