sample

linux 下类似于TC功能的编译器,但还没有完成,希望大家共同研究

                                        currow=totalrow-1;
                                        wmove (basewin, totalrow-nextpgl-1, curcol);
                                }
                                totalcol=GetCurColWidth(NULL,currow);
                                ret = UPDATE_STATUS;
                        }
                        break;
                case KEY_TAB:
                        for(i=0;i<TABSIZE;i++)
                                waddch(basewin,COLOR_PAIR(GetColor())|KEY_SPACE);
                        ret = UPDATE_STATUS;
                        break;
                case KEY_INSERT:
                        if (insertmode)
                        {
                                insertmode=FALSE;
                                ret=UPDATE_STATUS_REPLACE;
                        }
                        else
                        {
                                insertmode=TRUE;
                                ret=UPDATE_STATUS_INSERT;
                        }
                        break;
                default:
                        int line;
                        PageList page;
                        getyx(basewin,tempy,tempx);
                        page=LocatePage(NULL,currow);
                        line=currow % CODE_QSET;
                        if(insertmode)        //insert mode
                        {
                                if(totalcol+1<CODE_QUANTUM)
                                {
                                        for(i=0;i<totalcol-curcol;i++)
                                        {
                                                page->data[line][totalcol-i]=page->data[line][totalcol-i-1];
                                        }
                                        page->data[line][curcol]=COLOR_PAIR(GetColor())|key;
                                        totalcol++;
                                        maxcol=(maxcol>totalcol)?(maxcol):(totalcol);
                                        if(tempx+1>=GetWidth())
                                        {
                                                offcol++;
                                                ShowPage(offcol*TABSIZE);
                                                wmove(basewin,tempy,tempx-TABSIZE+1);
                                        }
                                        else
                                        {
                                                ShowLine(page->data[line],curcol,GetWidth()-tempx,tempy,tempx);
                                                wmove(basewin,tempy,tempx+1);
                                        }
                                        curcol++;                                        
                                        ret = UPDATE_STATUS;
                                }
                        }
                        else                //replace mode
                        {
                                if(curcol+1<CODE_QUANTUM)
                                {
                                        if(curcol+1>totalcol)        //new character
                                        {
                                                totalcol++;
                                                maxcol=(maxcol>totalcol)?(maxcol):(totalcol);
                                        }
                                        if(tempx+1>=GetWidth())
                                        {
                                                offcol++;
                                                page->data[line][curcol]=COLOR_PAIR(GetColor())|key;
                                                ShowPage(offcol*TABSIZE);
                                                wmove(basewin,tempy,tempx-TABSIZE+1);
                                        }
                                        else
                                        {
                                                page->data[line][curcol]=COLOR_PAIR(GetColor())|key;
                                                waddch(basewin,COLOR_PAIR(GetColor())|key);
                                        }
                                        curcol++;
                                        ret = UPDATE_STATUS;
                                }
                        }
                        break;        
        }
        return ret;
}

void CodeArea::DestroyCodeArea()
{
        Trim();
        DestroyBaseWindow();
}


int  CodeArea::Active(int item)
{
        if(active!=TRUE)
        {
                active=TRUE;
        }
        return active;
}

int  CodeArea::Active()
{
        if (active!=TRUE)
        {
                active=TRUE;
        }
        curs_set(1);
        ShowPage();
        //wmove(basewin,currow,curcol);
        return active;
}

int  CodeArea::IsActive()
{
        return active;
}

int  CodeArea::LostActive()
{
        if(active!=FALSE)
        {
                active=FALSE;
        }
        curs_set(0);
        return active;
}

int  CodeArea::GetCurCol()
{
        return curcol;
}

int  CodeArea::GetCurRow()
{
        return currow;
}

int  CodeArea::GetTotalRow()
{
        return totalrow;
}

int  CodeArea::GetMaxCol()
{
        return maxcol;
}

int CodeArea::Trim()
{
        PageList  next, dptr;
        next=NULL;
        dptr=pagelist->next;

        for (;dptr && dptr!=pagelist;dptr = next) 
        {
                next=dptr->next;
                FreePage(dptr);
        }
        FreePage(pagelist);
        return 0;
}

PageList CodeArea::AllocPage()
{
        int i;
        PageList page=NULL;
        if ((page=(PageList)malloc(sizeof(Page)))==NULL)
                goto nomem_page;
        page->quantum=CODE_QUANTUM;
        page->qset=CODE_QSET;
        page->data=NULL;
        page->next=NULL;
        page->prev=NULL;
        if ( (page->data=(chtype **)malloc(sizeof(chtype *)*CODE_QSET)) ==NULL)
                goto nomem_data;
        memset(page->data, 0, sizeof(chtype *)*CODE_QSET);
        for(i=0;i<CODE_QSET;i++)
        {
                page->data[i]=(chtype*)malloc(sizeof(chtype *)*CODE_QUANTUM);
                if( page->data[i] ==NULL)
                        goto nomem_qset;
                memset(page->data[i], 0, sizeof(chtype *)*CODE_QUANTUM);
        }
        goto success;
nomem_qset:
        while(i>0)
        {
                if(page->data[i-1])
                        free(page->data[i-1]);
                i--;
        }
        free(page->data);
        page->data=NULL;
nomem_data:
        free(page);
        page=NULL;
nomem_page:
        return page;
success:
        return page;
}

void CodeArea::InsertPage(PageList prev,PageList newpage)
{
        PageList next=prev->next;
        prev->next=newpage;
        newpage->prev=prev;
        next->prev=newpage;
        newpage->next=next;
}

void CodeArea::FreePage(PageList page)
{
        int i=0;
        PageList prev,next;
        prev=page->prev;
        next=page->next;

        if (page->data)
        {
                for (i = 0; i <CODE_QSET; i++)
                        if (page->data[i])
                                free(page->data[i]);
                free(page->data);
                page->data=NULL;
        }
        if(page!=page->prev || page!=page->next)
        {
                prev->next=next;
                next->prev=prev;
                if(page==pagelist)
                {
                        pagelist=next;
                }
        }
        free(page);
        page=NULL;
}

void CodeArea::ShowPage()
{
        int y,x;
        getyx(basewin,y,x);
        if ( (currow-y)<0)
                {printf("\n%d %d %d",currow,y,currow-y);exit(1);}
        ShowPage(NULL,(currow-y)%CODE_QSET,CODE_QSET,offcol*TABSIZE,GetWidth(),0,0);
        wmove(basewin,y,x);
}

void CodeArea::ShowPage(int offcols)
{
        int y,x;
        getyx(basewin,y,x);
        if ( (currow-y)<0)
                {printf("\n%d %d %d",currow,y,currow-y);exit(1);}
        ShowPage(NULL,(currow-y)%CODE_QSET,CODE_QSET,offcols,GetWidth(),0,0);
        wmove(basewin,y,x);
}

void CodeArea::ShowPage(PageList page,int beginline,int lines,int begincol,int cols,int y,int x)
{
        int i, j;
        int line=beginline%CODE_QSET;
        int endcol=begincol + cols;
        int begrow=y;
        offline=line;
        if(page==NULL)
                page=beginpage;
        else
                beginpage=page;
        for (i = 0; i < lines; i++) 
        {
                wmove (basewin, begrow, x);
                for (j = begincol; j < endcol; j++)
                        if(j<CODE_QUANTUM && page->data[line][j]!='\0')
                                waddch (basewin,page->data[line][j]);
                        else
                                waddch (basewin,COLOR_PAIR(GetColor())|' ');
                line++;
                begrow++;
                if(line>=CODE_QSET)
                {
                        if(page->next!=pagelist)
                        {
                                line=0;
                                page=page->next;
                        }
                        else
                        {
                                draw_box (begrow,0,GetHeight()-begrow,GetWidth(),COLOR_PAIR(GetColor())|' ',COLOR_PAIR(GetColor()));        
                                break;
                        }
                }
        }
}

void CodeArea::ShowLine(chtype *line, int beginpos, int chars, int row, int col)
{
        int i=0;
        for(i=0;i<chars;i++)
        {
                if(beginpos+i<totalcol && line[beginpos+i]!='\0')
                        mvwaddch(basewin,row,col,line[beginpos+i]);
                else
                        mvwaddch(basewin,row,col,COLOR_PAIR(GetColor())|' ');
                col++;
        }
        wrefresh(basewin);
}

//line:base on 0
void CodeArea::ShiftLines(PageList pg,int line,int shift)
{
        PageList source=pagelist->prev;
        PageList target=NULL;
        int pages=(int)(totalrow/GetHeight())+1;
        int lines=0;
        int j=0;                        //shifted pages
        int i=0;
        int rows=totalrow;
        while(source!=pg)
        {
                lines=rows-(pages-1)*CODE_QSET;
                rows=rows-lines;
                while(lines>0)
                {
                        j=(int)( (lines-1+shift)/CODE_QSET );//shift no.j line(start from 0)
                        target=source;
                        while(j>0)