@@ -258,6 +258,26 @@ redata_getchar(redata_t *redata, long pos)

         return(-1); /* not found */

 }

+int

+redata_getdata(redata_t *redata, long frompos, long size, char *dest)

+{

+        int nchunk,off,avail;

+        long n;

+        if(redata==NULL || frompos<0 || size<0 || dest==NULL || (frompos+size)>redata_getused(redata) || redata_getposptr(redata,frompos,&nchunk,&off)!=0)

+                return(-1); /* sanity check failed */

+        for(n=0;n<size && nchunk<redata->sizechunks;nchunk++,off=0) {

+                avail=redata->chunks[nchunk]->useddata-off;

+                if(avail<=0)

+                        continue;

+                if(avail>(size-n))

+                        avail=size-n;

+                memcpy(dest+n,redata->chunks[nchunk]->data+off,avail);

+                n+=avail;

+        }

+        return(0);

+}

+

+

 int

 redata_wipe(redata_t *redata)

 {

@@ -647,7 +667,6 @@ redata_load(redata_t *redata, char *filename, char **errordesc)

         struct stat statbuf;

         rechunk_t *chunk;

         int i;

-        int reply;

         if(redata==NULL || filename==NULL) {

                 if(errordesc!=NULL)

                         *errordesc="Internal error";

@@ -2157,6 +2176,107 @@ redata_linecol2pos(redata_t *redata, int line, int colrequest, long *pos, int *c

         return(0);

 }

+int

+redata_line_total(redata_t *redata)

+{

+        long chunkpos;

+        int nchunk;

+        int startline;

+        rechunk_t *chunk,*lastchunkwithdata;

+        if(redata==NULL)

+                return(-1);

+        /* find line */

+        lastchunkwithdata=NULL;

+        for(nchunk=0,chunkpos=0,startline=0

+          ;nchunk<redata->sizechunks

+          ;chunkpos+=(chunk!=NULL)?chunk->useddata:0

+            ,startline+=(chunk!=NULL)?chunk->whatin.nlcount:0,nchunk++) {

+                if((chunk=redata->chunks[nchunk])==NULL)

+                        continue;

+                if(!(chunk->whatin_fresh))

+                        redata_whatin_refresh(redata,nchunk);

+                if(chunk->useddata>0)

+                        lastchunkwithdata=chunk;

+        }

+        if(lastchunkwithdata!=NULL && lastchunkwithdata->data[lastchunkwithdata->useddata-1]!='\n')

+                startline++;

+        return(startline);

+}

+

+int

+redata_line_getendstr(redata_t *redata, int line, char *buf, int sizebuf)

+{

+        return(redata_line_getendstrtrimmed(redata,line,buf,sizebuf,NULL));

+}

+

+int

+redata_line_getendstrtrimmed(redata_t *redata, int line, char *buf, int sizebuf, char *trimchars)

+{

+        long startpos,endpos;

+        int coldone;

+        if(redata==NULL || line<0 || buf==NULL || sizebuf<1)

+                return(-1); /* sanity check error */

+        if(redata_linecol2pos(redata,line,0,&startpos,&coldone)!=0

+          || redata_line_realend(redata,startpos,&endpos)!=0) {

+                return(-1); /* line not found */

+        }

+        if(endpos>startpos && redata_getchar(redata,endpos-1)=='\n')

+                endpos--;

+        if(trimchars!=NULL) {

+                while(endpos>startpos && strchr(trimchars,redata_getchar(redata,endpos))!=NULL)

+                        endpos--;

+        }

+        if((endpos-startpos)>(sizebuf-1))

+                startpos=endpos-(sizebuf-1);

+        redata_getdata(redata,startpos,endpos-startpos,buf);

+        buf[endpos-startpos]='\0';

+        return(0);

+}

+

+int

+redata_line_getsize(redata_t *redata, int line) /* includes the \n */

+{

+        long startpos,endpos;

+        int coldone;

+        if(redata==NULL || line<0)

+                return(-1); /* sanity check error */

+        if(redata_linecol2pos(redata,line,0,&startpos,&coldone)!=0

+          || redata_line_realend(redata,startpos,&endpos)!=0) {

+                return(-1); /* line not found */

+        }

+        return(endpos-startpos);

+}

+

+int

+redata_line_getstartstr(redata_t *redata, int line, char *buf, int sizebuf)

+{

+        return(redata_line_getstartstrtrimmed(redata,line,buf,sizebuf,NULL));

+}

+

+int

+redata_line_getstartstrtrimmed(redata_t *redata, int line, char *buf, int sizebuf, char *trimchars)

+{

+        long startpos,endpos;

+        int coldone;

+        if(redata==NULL || line<0 || buf==NULL || sizebuf<1)

+                return(-1); /* sanity check error */

+        if(redata_linecol2pos(redata,line,0,&startpos,&coldone)!=0

+          || redata_line_realend(redata,startpos,&endpos)!=0) {

+                return(-1); /* line not found */

+        }

+        if(endpos>startpos && redata_getchar(redata,endpos-1)=='\n')

+                endpos--;

+        if(trimchars!=NULL) {

+                while(startpos<endpos && strchr(trimchars,redata_getchar(redata,startpos))!=NULL)

+                        startpos++;

+        }

+        if((endpos-startpos)>(sizebuf-1))

+                endpos=startpos+(sizebuf-1);

+        redata_getdata(redata,startpos,endpos-startpos,buf);

+        buf[endpos-startpos]='\0';

+        return(0);

+}

+

 static char *

 securesave_genname(char *filename, char *buf, int bufsize)

 {

@@ -109,6 +109,7 @@ long redata_getused(redata_t *redata);

 long redata_getavailable(redata_t *redata);

 int redata_getposptr(redata_t *redata, long pos, int *numchunk, int *offset);

 int redata_getchar(redata_t *redata, long pos);

+int redata_getdata(redata_t *redata, long frompos, long size, char *dest);

 /* low level stuff */

 int redata_wipe(redata_t *redata);

@@ -209,4 +210,11 @@ int redata_pos2linecol(redata_t *redata, long pos, int *line, int *col);

 /* get the pos of that line/col (calculated using the utf8 convenience functions) */

 int redata_linecol2pos(redata_t *redata, int line, int colrequest, long *pos, int *coldone);

+int redata_line_total(redata_t *redata);

+int redata_line_getendstr(redata_t *redata, int line, char *buf, int sizebuf);

+int redata_line_getendstrtrimmed(redata_t *redata, int line, char *buf, int sizebuf, char *trimchars);

+int redata_line_getsize(redata_t *redata, int line); /* includes the \n */

+int redata_line_getstartstr(redata_t *redata, int line, char *buf, int sizebuf);

+int redata_line_getstartstrtrimmed(redata_t *redata, int line, char *buf, int sizebuf, char *trimchars);

+

 #endif

@@ -107,6 +107,9 @@ typedef struct re_t {

         int sizeprints;

         int usedprints;

         printout_t *prints;

+        redata_t *funclisting;

+        int originlinefunclisting;

+        int curlinefunclisting;

 } re_t;

 volatile int flag_sigint;

@@ -153,6 +156,9 @@ long re_getmatchingbracket(re_t *re,long posini, char originalchar, char *matchi

 int re_drawheader_editing(re_t *re);

 int re_drawheader_command(re_t *re);

 int re_drawcontents(re_t *re, printout_t *printout);

+redata_t *re_getfunclisting(re_t *re);

+int re_funclistingxy2line(re_t *re,int mx,int my);

+

 int

 main(int argc, char *argv[])

@@ -437,11 +443,65 @@ fprintf(stderr,"Resizing from %ix%i to %ix%i...\n",re->ui->w,re->ui->h,(int)even

                                 case SDL_MOUSEBUTTONUP:

                                 case SDL_MOUSEMOTION:

                                         {

-#warning TODO

+#warning TODO: select with mouse

                                                 int mx,my;

                                                 mx=(event.type!=SDL_MOUSEMOTION)?event.button.x:event.motion.x;

                                                 my=(event.type!=SDL_MOUSEMOTION)?event.button.y:event.motion.y;

-                                                if(!(event.type==SDL_MOUSEMOTION && (re->mouseselactive==0 || my<re->y || mx<re->x))) {

+                                                if(re->mouseselactive==0 && event.type==SDL_MOUSEBUTTONDOWN && my<re->y && re->funclisting==NULL) {

+                                                        redata_t *funclisting;

+                                                        if((funclisting=re_getfunclisting(re))==NULL)

+                                                                break; /* mem. insuf. */

+                                                        if(re->funclisting!=NULL)

+                                                                redata_free(re->funclisting),re->funclisting=NULL;

+                                                        re->funclisting=funclisting;

+                                                        re->originlinefunclisting=0;

+                                                        re->curlinefunclisting=-1;

+                                                        re->contentsdirty=1;

+                                                } else if(event.type==SDL_MOUSEBUTTONUP && re->funclisting!=NULL) {

+                                                        char linebuf[32],*cmdend;

+                                                        if(redata_line_getstartstrtrimmed(re->funclisting,re->curlinefunclisting,linebuf,sizeof(linebuf)," ")==0) {

+                                                                int oldline;

+                                                                if((cmdend=strchr(linebuf,':'))!=NULL)

+                                                                        *cmdend='\0';

+                                                                re->command=COMMAND_GOTOLINE;

+                                                                strncpy(re->commandbuf,linebuf,sizeof(re->commandbuf));

+                                                                re->commandbuf[sizeof(re->commandbuf)-1]='\0';

+                                                                oldline=re->curline;

+                                                                re_processcommand(re);

+                                                                if(oldline!=re->curline) {

+                                                                        /* position the cursor near the top of the window */

+                                                                        re->originline=re->curline-3;

+                                                                        re->originline=(re->originline<0)?0:re->originline;

+                                                                }

+                                                        }

+                                                        redata_free(re->funclisting),re->funclisting=NULL;

+                                                        re->contentsdirty=1;

+                                                } else if(event.type==SDL_MOUSEMOTION && re->funclisting!=NULL) {

+                                                        if(mx<re->ui->fontwidth*10) {

+                                                                /* scroll */

+                                                                int total;

+                                                                total=redata_line_total(re->funclisting);

+                                                                if(my<re->y) {

+                                                                        if(re->originlinefunclisting!=0) {

+                                                                                re->originlinefunclisting=0;

+                                                                                re->contentsdirty=1;

+                                                                        }

+                                                                } else if(my>re->y && re->h>re->y) {

+                                                                        int old;

+                                                                        old=re->originlinefunclisting;

+                                                                        re->originlinefunclisting=total*(my-re->y)/(re->h-re->y);

+                                                                        if(old!=re->originlinefunclisting)

+                                                                                re->contentsdirty=1;

+                                                                }

+                                                        } else {

+                                                                /* select */

+                                                                int oldlinefunclisting;

+                                                                oldlinefunclisting=re->curlinefunclisting;

+                                                                re->curlinefunclisting=re_funclistingxy2line(re,mx,my);

+                                                                if(oldlinefunclisting!=re->curlinefunclisting)

+                                                                        re->contentsdirty=1;

+                                                        }

+                                                } else if(!(event.type==SDL_MOUSEMOTION && (re->mouseselactive==0 || my<re->y || mx<re->x))) {

                                                         int newposx,newposy;

                                                         long tmppos;

                                                         if(event.type==SDL_MOUSEBUTTONDOWN && event.button.button==SDL_BUTTON_LEFT) {

@@ -557,6 +617,8 @@ re_free(re_t *re)

         int i;

         if(re==NULL)

                 return; /* all done */

+        if(re->funclisting!=NULL)

+                redata_free(re->funclisting),re->funclisting=NULL;

         for(i=0;i<re->sizeprints;i++) {

                 if(re->prints[i].ui!=NULL)

                         re_delprint(re,i);

@@ -1771,25 +1833,18 @@ re_selectbuf_resize(re_t *re,long size)

 int

 re_selectbuf_fill(re_t *re,long frompos,long size, int nadditionalspaces)

 {

-        int nchunk,off,avail;

-        long n;

-        if(re==NULL || size<0 || nadditionalspaces<0 || (frompos+size)>redata_getused(re->data) || redata_getposptr(re->data,frompos,&nchunk,&off)!=0)

+        if(re==NULL || size<0 || nadditionalspaces<0 || (frompos+size)>redata_getused(re->data))

                 return(-1); /* sanity check failed */

         re->usedselectbuf=0;

         if((size+nadditionalspaces+1)>re->sizeselectbuf

           && re_selectbuf_resize(re,size+nadditionalspaces+1)!=0) {

                 return(-1); /* insuf. mem. */

         }

-        for(n=0;n<size && nchunk<re->data->sizechunks;nchunk++,off=0) {

-                avail=re->data->chunks[nchunk]->useddata-off;

-                if(avail<=0)

-                        continue;

-                if(avail>(size-n))

-                        avail=size-n;

-                memcpy(re->selectbuf+n,re->data->chunks[nchunk]->data+off,avail);

-                n+=avail;

+        if(redata_getdata(re->data,frompos,size,re->selectbuf)!=0) {

+                re->usedselectbuf=0;

+                return(-1); /* internal error */

         }

-        re->usedselectbuf=n;

+        re->usedselectbuf=size;

         if(nadditionalspaces>0) {

                 memset(re->selectbuf+re->usedselectbuf,' ',nadditionalspaces);

                 re->usedselectbuf+=nadditionalspaces;

@@ -2315,6 +2370,23 @@ re_drawcontents(re_t *re, printout_t *printout)

                                 reui_balloon(ui, '\0', x0+w/2, y0+ui->fontheight*((curline-originline)*2+5)/2, "\x80\x80\x80\xff", "\xff\xff\xff\xcf",(char *) hint,strlen(hint));

                 }

         }

+        /* show func listing if requested */

+        if(printout==NULL && re->funclisting!=NULL) {

+                int total,i,ypos;

+                char linebuf[1024];

+                char *fg;

+                reui_fill(ui,x0,y0,w,re->h-y0,"\x44\x33\x22\x7f");

+                for(total=redata_line_total(re->funclisting),i=re->originlinefunclisting,ypos=y0;i<total && ypos<re->h;i++,ypos+=(ui->fontheight/((linebuf[0]=='\0')?2:1))) {

+                        fg="\xff\xff\xff\xff";

+                        if(i==re->curlinefunclisting) {

+                                reui_fill(ui,x0+ui->fontwidth*3,ypos,w-ui->fontwidth*6,ui->fontheight,"\xdf\xdf\xdf\xff");

+                                fg="\x00\x00\x00\xff";

+                        }

+                        if(redata_line_getstartstr(re->funclisting,i,linebuf,sizeof(linebuf))!=0)

+                                break;

+                        reui_write(ui,x0+ui->fontwidth*3,ypos,fg,linebuf,strlen(linebuf));

+                }

+        }

         /* all done */

         if(printout==NULL || printout==&fakeprintout) {

                 re->contentsdirty=0;

@@ -2326,4 +2398,93 @@ re_drawcontents(re_t *re, printout_t *printout)

         return(0);

 }

+redata_t *

+re_getfunclisting(re_t *re)

+{

+        int lineno,total;

+        char startbuf[3];

+        char endbuf[3];

+        char nextendbuf[3];

+        int flag_havenextendbuf;

+        int flag_isstart;

+        int flag_semicolon;

+        int flag_curlybrace;

+        int flag_nextcurlybrace;

+        int flag_previsstart;

+        char linebuf[1024];

+        char annotatedlinebuf[1024];

+        redata_t *newdata;

+        if(re==NULL)

+                return(NULL); /* sanity check error */;

+        if((newdata=redata_init(NULL))==NULL)

+                return(NULL); /* couldn't init new buffer */

+        for(lineno=0,total=redata_line_total(re->data);lineno<total;lineno++) {

+                if(redata_line_getstartstr(re->data,lineno,startbuf,sizeof(startbuf))!=0)

+                        break; /* internal error */

+                if(flag_havenextendbuf==1) {

+                        strncpy(endbuf,nextendbuf,sizeof(endbuf));

+                        endbuf[sizeof(endbuf)-1]='\0';

+                } else if(redata_line_getendstrtrimmed(re->data,lineno,endbuf,sizeof(endbuf)," \t")!=0) {

+                        break; /* internal error */

+                }

+                flag_havenextendbuf=flag_nextcurlybrace=0;

+                if(redata_line_getendstrtrimmed(re->data,lineno+1,nextendbuf,sizeof(nextendbuf)," \t")==0) {

+                        flag_havenextendbuf=1;

+                        flag_nextcurlybrace=(*nextendbuf!='\0' && nextendbuf[strlen(nextendbuf)-1]=='{')?1:0;

+                }

+                flag_isstart=(*startbuf!='\0' && strchr("# \t{/",*startbuf)==NULL)?1:0;

+                flag_semicolon=(*endbuf!='\0' && endbuf[strlen(endbuf)-1]==';')?1:0;

+                flag_curlybrace=(*endbuf!='\0' && endbuf[strlen(endbuf)-1]=='{')?1:0;

+

+                if(flag_isstart && !flag_semicolon && (flag_curlybrace || (flag_havenextendbuf && flag_nextcurlybrace))) {

+                        if(flag_previsstart) {

+                                snprintf(annotatedlinebuf,sizeof(annotatedlinebuf),"%6i: %s\n",lineno+1-1,linebuf);

+                                annotatedlinebuf[sizeof(annotatedlinebuf)-1]='\0';

+                                redata_op_add(newdata,redata_getused(newdata),annotatedlinebuf,strlen(annotatedlinebuf),NULL);

+                                flag_previsstart=0;

+                        }

+                        redata_line_getstartstr(re->data,lineno,linebuf,sizeof(linebuf));

+                        snprintf(annotatedlinebuf,sizeof(annotatedlinebuf),"%6i: %s\n\n",lineno+1,linebuf);

+                        annotatedlinebuf[sizeof(annotatedlinebuf)-1]='\0';

+                        redata_op_add(newdata,redata_getused(newdata),annotatedlinebuf,strlen(annotatedlinebuf),NULL);

+                } else if(flag_isstart) {

+                        redata_line_getstartstr(re->data,lineno,linebuf,sizeof(linebuf));

+                        flag_previsstart=1;

+                } else {

+                        flag_previsstart=0;

+                }

+        }

+        return(newdata);

+}

+

+int

+re_funclistingxy2line(re_t *re,int mx,int my)

+{

+        int total,i,ypos;

+        char linebuf[2];

+        int h;

+        if(re==NULL || mx<0 || my<0)

+                return(-1);

+        for(total=redata_line_total(re->funclisting),i=re->originlinefunclisting,ypos=re->y;i<total && ypos<re->h;i++,ypos+=h) {

+                if(redata_line_getstartstr(re->funclisting,i,linebuf,sizeof(linebuf))!=0)

+                        break;

+                h=(re->ui->fontheight/((linebuf[0]=='\0')?2:1));

+                if(my>=ypos && my<(ypos+h)) {

+                        if(linebuf[0]=='\0')

+                                return(-1);

+                        return(i);

+                }

+        }

+        return(-1);

+}

+

+

+

+

+

+

+

+

+

+