Skip to content
Snippets Groups Projects
Select Git revision
  • b0ba662709a95ff55d8bc6dac7c27211607b7235
  • master default protected
  • new-money
  • dev
  • serial
  • plot
  • stast
  • acquisition-dialog
  • multiacc
  • v1.18
  • v1.17.4
  • v1.17.3
  • v1.17.2
  • v1.17.1
  • v1.17
  • v1.16
  • v1.15
  • v1.14.1
  • v1.14
  • v1.13.42
  • v1.13.41
  • v1.13
  • v1.12
  • v1.11
  • v1.10
  • v1.9
  • acquisition
  • v1.8
  • v1.7
29 results

mainwindow.cpp

Blame
  • sed.pmod 6.09 KiB
    #pike __REAL_VERSION__
    
    //! edit commands supported:
    //! @pre{
    //! <firstline>,<lastline><edit command>
    //!    ^^ numeral (17) ^^
    //!       or relative (+17, -17)
    //!       or a search regexp (/regexp/)
    //!       or multiple (17/regexp//regexp/+2)
    //! @}
    //!
    //! @xml{
    //! <matrix>
    //! <r><c><b>Command</b></c><c><b>Action</b></c></r>
    //! <r><c>D</c><c>Delete first line in space</c></r>
    //! <r><c>G</c><c>Insert hold space</c></r>
    //! <r><c>H</c><c>Append current space to hold space</c></r>
    //! <r><c>P</c><c>Print current data</c></r>
    //! <r><c>a&lt;string&gt;</c><c>Insert</c></r>
    //! <r><c>c&lt;string&gt;</c><c>Change current space</c></r>
    //! <r><c>d</c><c>Delete current space</c></r>
    //! <r><c>h</c><c>Copy current space to hold space</c></r>
    //! <r><c>i&lt;string&gt;</c><c>Print string</c></r>
    //! <r><c>l</c><c>Print current space</c></r>
    //! <r><c>p</c><c>Print first line in data</c></r>
    //! <r><c>q</c><c>Quit evaluating</c></r>
    //! <r><c>s/regexp/with/x</c><c>Replace</c></r>
    //! <r><c>y/chars/chars/</c><c>Replace chars</c></r>
    //! </matrix>
    //! @}
    //!
    //! where line is numeral, first 'line'==0
    
    protected array sedreplace(string s,object re,string with,
    			array whatin,int first,int lastmod,
    			multiset flags)
    {
       array a;
       string w=0;
       array pr=({});
    
       if (!(a=re->split(s)))
          return 0;
    
       if (first)
       {
          array wa;
          wa=sedreplace(a[0],re,with,whatin,first,lastmod,flags);
          if (wa)
    	 if (!flags["g"])
    	    return ({wa[0],wa[1]+s[sizeof(a[0])..]});
    	 else
    	    pr=wa[0],w=wa[1];
          else
    	 w=a[0];
       }
       
       string t=
          replace(with,whatin[..sizeof(a)-first+lastmod-1],
    	      a[first..sizeof(a)+lastmod-1]);
    
       if (flags["p"]) pr+=({t});
    
       s=(w||"")+t;
       if (flags["g"])
       {
          if (lastmod) 
          {
    	 array wa;
    	 wa=sedreplace(a[-1],re,with,whatin,first,lastmod,flags);
    	 if (wa) 
    	 {
    	    pr+=wa[0];
    	    s+=wa[1];
    	 }
    	 else
    	    s+=a[-1];
          }
       }
       else
          s+=a[-1];
    
       return ({pr,s});
    };
    
    protected array scan_for_linenumber(string cmd,
    				 array(string) in,
    				 int n)
    {
       int x;
       string what;
       object re;
    
       while (cmd!="" && ((cmd[0]>='0' && cmd[0]<='9') 
    		      || cmd[0]=='/' || cmd[0]=='+' || cmd[0]=='-'))
       {
          if (cmd[0]>='0' && cmd[0]<='9')
          {
    	 sscanf(cmd,"%d%s",n,cmd);
    	 // n--; if first line==1
          }
          else if (cmd[0]=='+')
          {
    	 sscanf(cmd,"+%d%s",x,cmd);
    	 n+=x; 
          }
          else if (cmd[0]=='-')
          {
    	 sscanf(cmd,"-%d%s",x,cmd);
    	 n-=x; 
          }
          else if (sscanf(cmd,"/%s/%s",what,cmd)==2)
          {
    	 re=Regexp(what);
    	 while (n<sizeof(in))
    	 {
    	    if (re->match(in[n])) break;
    	    n++;
    	 }
          }
          else break;
       }
       if (n<0) n=0; else if (n>=sizeof(in)) n=sizeof(in)-1;
       return ({n,cmd});
    }
    
    //!
    string|array `()(string|array(string) commands,
    		 string|array(string) data,
    		 void|int suppress)
    {
       int start,stop;
       string div,what,with,inflags;
       multiset flags;
       array whatin=({"\\1","\\2","\\3","\\4","\\5","\\6","\\7","\\8","\\9"});
       array print=({});
       array hold=({});
       object re;
       array a1,a2;
       array in,e;
    
       if (arrayp(data)) in=copy_value(data);
       else in=data/"\n";
    
       if (arrayp(commands)) e=commands;
       else e=commands/"\n";
    
       start=0; 
       stop=sizeof(in)-1;
    
       foreach (e, string cmd)
       {
          if (cmd!="" && ((cmd[0]>='0' && cmd[0]<='9') 
    		      || cmd[0]=='/' || cmd[0]=='+' || cmd[0]=='-'))
          {
    	 a1=scan_for_linenumber(cmd,in,start);
    	 stop=start=a1[0]; 
    	 cmd=a1[1];
          }
    
          if (cmd[0..1]==",$") { cmd=cmd[2..]; stop=sizeof(in)-1; }
          else if (sscanf(cmd,",%s",cmd))
          {
    	 a1=scan_for_linenumber(cmd,in,start);
    	 stop=a1[0]; 
    	 cmd=a1[1];
          }
    
          if (stop>sizeof(in)-1) stop=sizeof(in)-1;
          if (start<0) start=0;
          
          if (cmd=="") continue;
          switch (cmd[0])
          {
    	 case 's':
    	    div=cmd[1..1]; 
    	    if (div=="%") div="%%";
    	    inflags="";
    	    if (sscanf(cmd,"%*c"+div+"%s"+div+"%s"+div+"%s",
    		       what,with,inflags)<3) continue;
    	    flags=aggregate_multiset(@(inflags/""));
    	    
    	    int first=0,lastmod=0;
    	    if (what!="") // fix the regexp for working split
    	    {
    	       if (what[0]!='^') what="^(.*)"+what,first=1;
    	       if (what[-1]!='$') what=what+"(.*)$",lastmod=-1;
    	    }
    	    re=Regexp(what);
    
    	    while (start<=stop)
    	    {
    	       array sa=sedreplace(in[start],re,with,whatin,
    				   first,lastmod,flags);
    
    	       if (sa)
    	       {
    		  in[start]=sa[1];
    		  print+=sa[0];
    		  if (!flags["g"]) break;
    	       }
    	       start++;
    	    }
    	    
    	    break;
    
    	 case 'y':
    	    div=cmd[1..1]; 
    	    if (div=="%") div="%%";
    	    inflags="";
    	    if (sscanf(cmd,"%*c"+div+"%s"+div+"%s"+div+"%s",
    		       what,with,inflags)<3) continue;
    	    if (sizeof(what)!=sizeof(with))
    	    {
    	       what=what[0..sizeof(with)-1];
    	       with=with[0..sizeof(what)-1];
    	    }
    	    
    	    a1=what/"",a2=with/"";
    
    	    while (start<=stop)
    	    {
    	       in[start]=replace(in[start],a1,a2);
    	       start++;
    	    }
    	    break;
    
    	 case 'G': // insert hold space
    	    in=in[..start-1]+hold+in[start..];
    	    if (stop>=start) stop+=sizeof(hold);
    	    break;
    
    	 case 'a': // insert line
    	    in=in[..start-1]+({cmd[1..]})+in[start..];
    	    if (stop>=start) stop++;
    	    break;
    
    	 case 'c': // change 
    	    in=in[..start-1]+({cmd[1..]})+in[stop+1..];
    	    stop=start;
    	    break;
    
    	 case 'd': // delete 
    	    in=in[..start-1]+in[stop+1..];
    	    stop=start;
    	    break;
    
    	 case 'D': // delete first line
    	    in=in[..start-1]+in[start+1..];
    	    stop=start;
    	    break;
    
    	 case 'h': // copy
    	    hold=in[start..stop];
    	    break;
    
    	 case 'H': // appending copy
    	    hold+=in[start..stop];
    	    break;
    	    
    	 case 'i': // print text
    	    print+=({cmd[1..]});
    	    break;
    
    	 case 'l': // print space
    	    print+=in[start..stop];
    	    break;
    
    	 case 'P': // print all
    	    print+=in;
    	    break;
    
    	 case 'p': // print first
    	    print+=in[..0];
    	    break;
    
    	 case 'q': // quit
    	    if (!suppress) 
    	       return (arrayp(data)?(print+in):((print+in)*"\n"));
    	    return (arrayp(data)?(print):(print*"\n"));
       
    	 default:
    	    // error? just ignore for now
          }
       }
       if (!suppress) 
          return (arrayp(data)?(print+in):(print+in)*"\n");
       return (arrayp(data)?(print):(print*"\n"));
    }