回复：不会贴，瞎贴试试。

d

/* Turbo C - (C) Copyright 1987, 1988 by Borland International */

#include <string.h>
#include <mem.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>
#include <conio.h>
#include "mcalc.h"

char *name = MSGNAME;

void moverowup(void)
/* Moves up 1 row */
{
 displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
 if (currow > toprow)
 currow--;
 else if (toprow != 0)
 {
 scroll(DOWN, 1, LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
 displayrow(--toprow, NOUPDATE);
 currow--;
 setbottomrow();
 }
} /* moverowup */

void moverowdown(void)
/* Moves down one row */
{
 displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
 if (currow < bottomrow)
 currow++;
 else if (bottomrow < (MAXROWS - 1))
 {
 scroll(UP, 1, LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
 toprow++;
 currow++;
 setbottomrow();
 displayrow(bottomrow, NOUPDATE);
 }
} /* moverowdown */

void movecolleft(void)
/* Moves left one column */
{
 int col, oldleftcol;
 unsigned char oldcolstart[SCREENCOLS];

 oldleftcol = leftcol;
 movmem(colstart, oldcolstart, sizeof(colstart));
 displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
 if (curcol > leftcol)
 curcol--;
 else if (leftcol != 0)
 {
 curcol--;
 leftcol--;
 setrightcol();
 setleftcol();
 if (oldleftcol <= rightcol)
 scroll(RIGHT, colstart[oldleftcol - leftcol] - LEFTMARGIN, LEFTMARGIN + 1,
 3, 80, SCREENROWS + 2, WHITE);
 clearlastcol();
 for (col = leftcol; col <= oldleftcol - 1; col++)
 displaycol(col, NOUPDATE);
 }
} /* movecolleft */

void movecolright(void)
/* Moves right one column */
{
 int col, oldleftcol, oldrightcol;
 unsigned char oldcolstart[SCREENCOLS];

 movmem(colstart, oldcolstart, sizeof(colstart));
 oldleftcol = leftcol;
 oldrightcol = rightcol;
 displaycell(curcol, currow, NOHIGHLIGHT, NOUPDATE);
 if (curcol < rightcol)
 curcol++;
 else if (rightcol < (MAXCOLS - 1))
 {
 curcol++;
 rightcol++;
 setleftcol();
 setrightcol();
 if (oldrightcol >= leftcol)
 scroll(LEFT, oldcolstart[leftcol - oldleftcol] - LEFTMARGIN,
 LEFTMARGIN + 1, 3, 80, SCREENROWS + 2, WHITE);
 clearlastcol();
 for (col = oldrightcol + 1; col <= rightcol; col++)
 displaycol(col, NOUPDATE);
 }
} /* movecolright */

void recalc(void)
/* Recalculates all of the numbers in the speadsheet */
{
 int col, row, dummy;

 for (col = 0; col <= lastcol; col++)
 {
 for (row = 0; row <= lastrow; row++)
 {
 if ((cell[col][row] != NULL) && (cell[col][row]->attrib == FORMULA))
 cell[col][row]->v.f.fvalue = parse(cell[col][row]->v.f.formula, &dummy);
 }
 }
 displayscreen(UPDATE);
} /* recalc */

void changeautocalc(int newmode)
/* Changes and prints the current AutoCalc value on the screen */
{
 char s[15];

 if (!autocalc && newmode)
 recalc();
 autocalc = newmode;
 if (autocalc)
 strcpy(s, MSGAUTOCALC);
 else
 s[0] = 0;
 writef(73, 1, MSGAUTOCALCCOLOR, strlen(MSGAUTOCALC), s);
} /* autocalc */

void changeformdisplay(int newmode)
/* Changes and prints the current formula display value on the screen */


{
 char s[15];

 formdisplay = newmode;
 if (formdisplay)
 strcpy(s, MSGFORMDISPLAY);
 else
 s[0] = 0;
 writef(65, 1, MSGFORMDISPLAYCOLOR, strlen(MSGFORMDISPLAY), s);
} /* autocalc */

void editcell(CELLPTR ecell)
/* Edits a selected cell */
{
 char s[MAXINPUT + 1];

 if (ecell == NULL)
 return;
 switch(ecell->attrib)
 {
 case TEXT :
 strcpy(s, ecell->v.text);
 break;
 case VALUE :
 if (ecell->v.value == HUGE_VAL)
 strcpy(s, "0");
 else
 sprintf(s, "%.*f", MAXPLACES, ecell->v.value);
 break;
 case FORMULA :
 strcpy(s, ecell->v.f.formula);
 break;
 } /* switch */
 if (!editstring(s, "", MAXINPUT) || (s[0] == 0))
 return;
 act(s);
 changed = TRUE;
} /* editcell */

void clearsheet(void)
/* Clears the current spreadsheet */
{
 int col, row;

 for (row = 0; row <= lastrow; row++)
 {
 for (col = 0; col <= lastcol; col++)
 deletecell(col, row, NOUPDATE);
 }
 initvars();
 setrightcol();
 setbottomrow();
 displayscreen(NOUPDATE);
 printfreemem();
 changed = FALSE;
} /* clearsheet */

struct CELLREC rec;

void loadsheet(char *filename)
/* Loads a new spreadsheet */
{
 int size, allocated, reallastcol = 0, reallastrow = 0, file;
 char check[81];

 if (filename[0] == 0)
 {
 writeprompt(MSGFILENAME);
 if (!editstring(filename, "", MAXINPUT))
 return;
 }
 if (access(filename, 0))
 {
 errormsg(MSGNOEXIST);
 return;
 }
 if ((file = open(filename, O_RDWR | O_BINARY)) == -1)
 {
 errormsg(MSGNOOPEN);
 return;
 }
 read(file, check, strlen(name) + 1);
 if (strcmp(check, name) != 0)
 {
 errormsg(MSGNOMICROCALC);
 close(file);
 return;
 }
 writef(1, 25, PROMPTCOLOR, 79, MSGLOADING);
 gotoxy(strlen(MSGLOADING) + 1, 25);
 clearsheet();
 read(file, (char *)&size, 1);
 read(file, (char *)&lastcol, 2);
 read(file, (char *)&lastrow, 2);
 read(file, (char *)&size, 2);
 read(file, colwidth, sizeof(colwidth));
 do
 {
 if (read(file, (char *)&curcol, 2) <= 0)
 break;
 read(file, (char *)&currow, 2);
 read(file, &format[curcol][currow], 1);
 read(file, (char *)&size, 2);
 read(file, (char *)&rec, size);
 switch (rec.attrib)
 {
 case TEXT :
 if ((allocated = alloctext(curcol, currow, rec.v.text)) == TRUE)
 setoflags(curcol, currow, NOUPDATE);
 break;
 case VALUE :
 allocated = allocvalue(curcol, currow, rec.v.value);
 break;
 case FORMULA :
 allocated = allocformula(curcol, currow, rec.v.f.formula, rec.v.f.fvalue);
 break;
 } /* switch */
 if (!allocated)
 {
 errormsg(MSGFILELOMEM);
 lastrow = reallastrow;
 lastcol = reallastcol;
 format[curcol][currow] = DEFAULTFORMAT;
 break;
 }
 else
 {
 if (curcol > reallastcol)
 reallastcol = curcol;
 if (currow > reallastrow)
 reallastrow = currow;
 }
 }
 while (TRUE);
 writef(1, 25, WHITE, strlen(MSGLOADING), "");
 gotoxy(1, 25);
 printfreemem();
 close(file);
 curcol = currow = 0;
 setrightcol();
 displayscreen(NOUPDATE);
 changed = FALSE;
} /* loadsheet */

void savesheet(void)
/* Saves the current spreadsheet */
{
 char filename[MAXINPUT+1], eof = 26;
 int size, col, row, overwrite, file;


 CELLPTR cellptr;

 filename[0] = 0;
 writeprompt(MSGFILENAME);
 if (!editstring(filename, "", MAXINPUT))
 return;
 if (!access(filename, 0))
 {
 if (!getyesno(&overwrite, MSGOVERWRITE) || (overwrite == 'N'))
 return;
 }
 if ((file = open(filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY,
 S_IREAD | S_IWRITE)) == -1)
 {
 errormsg(MSGNOOPEN);
 return;
 }
 writef(1, 25, PROMPTCOLOR, 79, MSGSAVING);
 gotoxy(strlen(MSGSAVING) + 1, 25);
 write(file, name, strlen(name) + 1);
 write(file, &eof, 1);
 write(file, (char *)&lastcol, 2);
 write(file, (char *)&lastrow, 2);
 size = MAXCOLS;
 write(file, (char *)&size, 2);
 write(file, colwidth, sizeof(colwidth));
 for (row = 0; row <= lastrow; row++)
 {
 for (col = lastcol; col >= 0; col--)
 {
 if (cell[col][row] != NULL)
 {
 cellptr = cell[col][row];
 switch(cellptr->attrib)
 {
 case TEXT :
 size = strlen(cellptr->v.text) + 2;
 break;
 case VALUE :
 size = sizeof(double) + 1;
 break;
 case FORMULA :
 size = strlen(cellptr->v.f.formula) + 2 + sizeof(double);
 break;
 } /* switch */
 write(file, (char *)&col, 2);
 write(file, (char *)&row, 2);
 write(file, (char *)&format[col][row], 1);
 write(file, (char *)&size, 2);
 write(file, (char *)cellptr, size);
 }
 }
 }
 close(file);
 writef(1, 25, WHITE, strlen(MSGSAVING), "");
 gotoxy(1, 25);
 changed = FALSE;
} /* savesheet */

int pagerows(int row, int toppage, int border)
/* Returns the number of rows to print */
{
 int rows;

 rows = toppage ? 66 - TOPMARGIN : 66;
 if (border)
 rows--;
 if (row + rows - 1 > lastrow)
 return(lastrow - row + 1);
 else
 return(rows);
} /* pagerows */

int pagecols(int col, int border, int columns)
/* Returns the number of columns to print starting at col */
{
 int len = ((col == 0) && (border)) ? columns - LEFTMARGIN : columns;
 int firstcol = col;

 while ((len > 0) && (col <= lastcol))
 len -= colwidth[col++];
 if (len < 0)
 col--;
 return(col - firstcol);
} /* pagecols */

void printsheet(void)
/* Prints a copy of the spreadsheet to a file or to the printer */
{
 char filename[MAXINPUT + 1], s[133], colstr[MAXCOLWIDTH + 1];
 FILE *file;
 int columns, counter1, counter2, counter3, col = 0, row, border, toppage,
 lcol, lrow, dummy, printed, oldlastcol;

 filename[0] = 0;
 writeprompt(MSGPRINT);
 if (!editstring(filename, "", MAXINPUT))
 return;
 if (filename[0] == 0)
 strcpy(filename, "PRN");
 if ((file = fopen(filename, "wt")) == NULL)
 {
 errormsg(MSGNOOPEN);
 return;
 }
 oldlastcol = lastcol;
 for (counter1 = 0; counter1 <= lastrow; counter1++)
 {
 for (counter2 = lastcol; counter2 < MAXCOLS; counter2++)
 {
 if (format[counter2][counter1] >= OVERWRITE)
 lastcol = counter2;
 }
 }
 if (!getyesno(&columns, MSGCOLUMNS))
 return;
 columns = (columns == 'Y') ? 131 : 79;
 if (!getyesno(&border, MSGBORDER))
 return;
 border = (border == 'Y');
 while (col <= lastcol)
 {
 row = 0;
 toppage = TRUE;
 lcol = pagecols(col, border, columns) + col;
 while (row <= lastrow)
 {
 lrow = pagerows(row, toppage, border) + row;


 deletecell(col, counter, NOUPDATE);
 printfreemem();
 if (col != MAXCOLS - 1)
 {
 movmem(&cell[col + 1][0], &cell[col][0], MAXROWS * sizeof(CELLPTR) *
 (MAXCOLS - col - 1));
 movmem(&format[col + 1][0], &format[col][0], MAXROWS * (MAXCOLS - col - 1));
 movmem(&colwidth[col + 1], &colwidth[col], MAXCOLS - col - 1);
 }
 setmem(&cell[MAXCOLS - 1][0], MAXROWS * sizeof(CELLPTR), 0);
 setmem(&format[MAXCOLS - 1][0], MAXROWS, DEFAULTFORMAT);
 colwidth[MAXCOLS - 1] = DEFAULTWIDTH;
 if ((lastcol >= col) && (lastcol > 0))
 lastcol--;
 setrightcol();
 if (curcol > rightcol)
 {
 rightcol++;
 setleftcol();
 }
 clearlastcol();
 for (counter = 0; counter <= lastcol; counter++)
 {
 for (row = 0; row <= lastrow; row++)
 {
 if ((cell[counter][row] != NULL) &&
 (cell[counter][row]->attrib == FORMULA))
 fixformula(counter, row, COLDEL, col);
 updateoflags(col, row, NOUPDATE);
 }
 }
 while (col <= rightcol)
 displaycol(col++, NOUPDATE);
 changed = TRUE;
 recalc();
} /* deletecol */

void insertcol(int col)
/* Inserts a column */
{
 int counter, row;

 if (lastcol == MAXCOLS - 1)
 {
 for (counter = 0; counter <= lastrow; counter++)
 deletecell(lastcol, counter, NOUPDATE);
 printfreemem();
 }
 if (col != MAXCOLS - 1)
 {
 movmem(&cell[col][0], &cell[col + 1][0], MAXROWS * sizeof(CELLPTR) *
 (MAXCOLS - col - 1));
 movmem(&format[col][0], &format[col + 1][0], MAXROWS * (MAXCOLS - col - 1));
 movmem(&colwidth[col], &colwidth[col + 1], MAXCOLS - col - 1);
 }
 setmem(&cell[col][0], MAXROWS * sizeof(CELLPTR), 0);
 setmem(&format[col][0], MAXROWS, DEFAULTFORMAT);
 colwidth[col] = DEFAULTWIDTH;
 lastcol = MAXCOLS - 1;
 setlastcol();
 setrightcol();
 if (curcol > rightcol)
 {
 rightcol++;
 setleftcol();
 }
 for (counter = 0; counter <= lastcol; counter++)
 {
 for (row = 0; row <= lastrow; row++)
 {
 if ((cell[counter][row] != NULL) &&
 (cell[counter][row]->attrib == FORMULA))
 fixformula(counter, row, COLADD, col);
 updateoflags(col, row, NOUPDATE);
 }
 }
 while (col <= rightcol)
 displaycol(col++, NOUPDATE);
 changed = TRUE;
 recalc();
} /* insertcol */

void deleterow(int row)
/* Deletes a row */
{
 int counter, rowc;

 for (counter = 0; counter <= lastcol; counter++)
 deletecell(counter, row, NOUPDATE);
 printfreemem();
 if (row != MAXROWS - 1)
 {
 for (counter = 0; counter < MAXCOLS; counter++)
 {
 movmem(&cell[counter][row + 1], &cell[counter][row],
 sizeof(CELLPTR) * (MAXROWS - row - 1));
 movmem(&format[counter][row + 1], &format[counter][row], MAXROWS - row - 1);
 }
 }
 else
 {
 for (counter = 0; counter <= lastcol; counter++)
 {
 cell[counter][MAXROWS - 1] = NULL;
 format[counter][MAXROWS - 1] = DEFAULTFORMAT;
 }
 }
 if ((lastrow >= row) && (lastrow > 0))
 lastrow--;
 for (counter = 0; counter <= lastcol; counter++)
 {
 for (rowc = 0; rowc <= lastrow; rowc++)
 {
 if ((cell[counter][rowc] != NULL) &&
 (cell[counter][rowc]->attrib == FORMULA))
 fixformula(counter, rowc, ROWDEL, row);
 }
 }
 while (row <= bottomrow)
 displayrow(row++, NOUPDATE);


 changed = TRUE;
 recalc();
} /* deleterow */

void insertrow(int row)
/* Inserts a row */
{
 int counter, rowc;

 if (lastrow == MAXROWS - 1)
 {
 for (counter = 0; counter <= lastcol; counter++)
 deletecell(counter, lastrow, NOUPDATE);
 printfreemem();
 }
 if (row != MAXROWS - 1)
 {
 for (counter = 0; counter < MAXCOLS; counter++)
 {
 movmem(&cell[counter][row], &cell[counter][row + 1],
 sizeof(CELLPTR) * (MAXROWS - row - 1));
 movmem(&format[counter][row], &format[counter][row + 1], MAXROWS - row - 1);
 }
 }
 for (counter = 0; counter < MAXCOLS; counter++)
 {
 cell[counter][row] = NULL;
 format[counter][row] = DEFAULTFORMAT;
 }
 lastrow = MAXROWS - 1;
 setlastrow();
 for (counter = 0; counter <= lastcol; counter++)
 {
 for (rowc = 0; rowc <= lastrow; rowc++)
 {
 if ((cell[counter][rowc] != NULL) &&
 (cell[counter][rowc]->attrib == FORMULA))
 fixformula(counter, rowc, ROWADD, row);
 }
 }
 while (row <= bottomrow)
 displayrow(row++, NOUPDATE);
 changed = TRUE;
 recalc();
} /* insertrow */

void smenu(void)
/* Executes the commands in the spreadsheet menu */
{
 char filename[MAXINPUT + 1];

 filename[0] = 0;
 switch(getcommand(SMENU, SCOMMAND))
 {
 case 0 :
 checkforsave();
 loadsheet(filename);
 break;
 case 1 :
 savesheet();
 break;
 case 2 :
 printsheet();
 break;
 case 3 :
 checkforsave();
 clearsheet();
 break;
 } /* switch */
} /* smenu */

void cmenu(void)
/* Executes the commands in the column menu */
{
 switch(getcommand(CMENU, CCOMMAND))
 {
 case 0 :
 insertcol(curcol);
 break;
 case 1 :
 deletecol(curcol);
 break;
 case 2 :
 setcolwidth(curcol);
 break;
 } /* switch */
} /* cmenu */

void rmenu(void)
/* Executes the commands in the row menu */
{
 switch(getcommand(RMENU, RCOMMAND))
 {
 case 0 :
 insertrow(currow);
 break;
 case 1 :
 deleterow(currow);
 break;
 } /* switch */
} /* rmenu */

void umenu(void)
/* Executes the commands in the utility menu */
{
 switch(getcommand(UMENU, UCOMMAND))
 {
 case 0 :
 recalc();
 break;
 case 1 :
 changeformdisplay(!formdisplay);
 displayscreen(UPDATE);
 break;
 } /* switch */
} /* umenu */

void mainmenu(void)
/* Executes the commands in the main menu */
{
 switch(getcommand(MENU, COMMAND))
 {
 case 0 :
 smenu();
 break;
 case 1 :
 formatcells();
 break;
 case 2 :
 deletecell(curcol, currow, UPDATE);
 printfreemem();
 if (autocalc)
 recalc();
 break;
 case 3 :
 gotocell();
 break;
 case 4 :
 cmenu();
 break;
 case 5 :
 rmenu();
 break;
 case 6 :
 editcell(curcell);
 break;
 case 7 :
 umenu();
 break;
 case 8 :
 changeautocalc(!autocalc);
 break;
 case 9 :
 checkforsave();
 stop = TRUE;
 break;
 } /* switch */
} /* mainmenu */