Subversion Repositories Kolibri OS

Rev

Rev 7544 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2.  
  3. #include "func.h"
  4. #include "parser.h"
  5. #include "calc.h"
  6. #include "kosSyst.h"
  7. //#include "KosFile.h"
  8.  
  9. #define DEFAULT_CELL_W 82
  10. #define DEFAULT_CELL_H 21
  11.  
  12. extern DWORD col_count, row_count;
  13. extern char ***cells;
  14. extern DWORD *cell_w, *cell_h;
  15. extern char ***values;
  16.  
  17. extern DWORD *cell_x, *cell_y;
  18.  
  19. // áóôåð îáìåíà
  20. extern char ***buffer;
  21. extern DWORD buf_col, buf_row;
  22. extern DWORD buf_old_x, buf_old_y;
  23. DWORD filesize;
  24.  
  25. extern bool sel_moved;
  26.  
  27. extern struct GRID
  28. {
  29.         int x,y,w,h;
  30. } grid;
  31.  
  32. int cf_x0, cf_x1, cf_y0, cf_y1;
  33.  
  34.  
  35. #define sign(x) ((x) < 0 ? -1 : ((x) == 0 ? 0 : 1))
  36.  
  37.  
  38. //extern const char er_file_not_found[];
  39. //extern const char er_format[];
  40. extern const char *sFileSign;
  41.  
  42. struct cell_list
  43. {
  44.         int x,y;
  45.         cell_list *next;
  46. };
  47.  
  48.  
  49. // ïîëó÷èòü õ-êîîðäèíàòó ÿ÷åéêè ñ íîìåðîì õ
  50. int get_x(int x)
  51. {
  52.         int i, r = 0;
  53.         if (x > col_count)
  54.                 x = col_count;
  55.         for (i = 0; i < x; i++)
  56.                 r+=cell_w[i];
  57.         return r;
  58. }
  59.  
  60. // àíàëîã
  61. int get_y(int y)
  62. {
  63.         int i, r = 0;
  64.         if (y > row_count)
  65.                 y = row_count;
  66.         for (i = 0; i < y; i++)
  67.                 r+=cell_h[i];
  68.         return r;
  69. }
  70.  
  71.  
  72.  
  73. // ñãåíåðèòü çàãîëîâîê ñòîëáöà
  74. char *make_col_cap(int i)
  75. {
  76.         char *r = (char*)allocmem(3);
  77.         if (i <= 26)
  78.         {
  79.                 r[0] = 'A' + i - 1;
  80.                 r[1] = '\0';
  81.                 return r;
  82.         }
  83.         else if (i % 26 == 0)   // ôèêñ áàãà êîòîðûé íå ïîíÿë - äà ïðîñòÿò ìåíÿ ÷èòàòåëè è þçåðà
  84.         {
  85.                 r[0] = (i / 26) - 1 + 'A' - 1;
  86.                 r[1] = 'Z';
  87.                 r[2] = '\0';
  88.                 return r;
  89.         }
  90.         r[0] = (i / 26) + 'A' - 1;
  91.         r[1] = (i % 26) + 'A' - 1;
  92.         r[2] = '\0';
  93.         return r;
  94. }
  95.  
  96. // -"- ñòðîêè
  97. char *make_row_cap(int i)
  98. {
  99.         char *r = (char*)allocmem(3);
  100.         if (i <= 9)
  101.         {
  102.                 r[0] = '0' + i;
  103.                 r[1] = '\0';
  104.                 return r;
  105.         }
  106.         r[0] = (i / 10) + '0';
  107.         r[1] = (i % 10) + '0';
  108.         r[2] = '\0';
  109.         return r;
  110. }
  111.  
  112. // èíèöèàëèçàöèÿ ÿ÷ååê
  113. void init()
  114. {
  115.         int i, j;
  116.  
  117.         cell_w = (DWORD*)allocmem(col_count * sizeof(DWORD));
  118.         cell_h = (DWORD*)allocmem(row_count * sizeof(DWORD));
  119.         cell_x = (DWORD*)allocmem(col_count * sizeof(DWORD));
  120.         cell_y = (DWORD*)allocmem(row_count * sizeof(DWORD));
  121.         for (i = 0; i < col_count; i++)
  122.         {
  123.                 cell_w[i] = DEFAULT_CELL_W;
  124.         }
  125.         cell_w[0] = 30; //make row headers smaller
  126.  
  127.         for (i = 0; i < row_count; i++)
  128.         {
  129.                 cell_h[i] = DEFAULT_CELL_H;
  130.         }
  131.  
  132.         cells = (char***)allocmem(col_count * sizeof(char**));
  133.         values = (char***)allocmem(col_count * sizeof(char**));
  134.         for (i = 0; i < col_count; i++)
  135.         {
  136.                 cells[i] = (char**)allocmem(row_count * sizeof(char*));
  137.                 values[i] = (char**)allocmem(row_count * sizeof(char*));
  138.                 for (j = 0; j < row_count; j++)
  139.                 {
  140.                         cells[i][j] = NULL;
  141.                         if (i == 0 && j)
  142.                         {
  143.                                 cells[i][j] = make_row_cap(j);
  144.                         }
  145.                         else if (j == 0 && i)
  146.                         {
  147.                                 cells[i][j] = make_col_cap(i);
  148.                         }
  149.                 }
  150.         }
  151. }
  152.  
  153. void reinit()
  154. {
  155.         int i, j;
  156.  
  157.         for (i = 0; i < col_count; i++)
  158.         {
  159.                 cell_w[i] = DEFAULT_CELL_W;
  160.         }
  161.         cell_w[0] = 30; //make row headers smaller
  162.  
  163.         for (i = 0; i < row_count; i++)
  164.         {
  165.                 cell_h[i] = DEFAULT_CELL_H;
  166.         }
  167.  
  168.         for (i = 1; i < col_count; i++)
  169.         {
  170.                 for (j = 1; j < row_count; j++)
  171.                 {
  172.                         if (cells[i][j])
  173.                                 freemem(cells[i][j]);
  174.                         cells[i][j] = NULL;
  175.                         if (values[i][j])
  176.                                 freemem(values[i][j]);
  177.                         values[i][j] = NULL;
  178.                 }
  179.         }
  180. }
  181.  
  182. void fill_cells(int sel_x, int sel_y, int sel_end_x, int sel_end_y, int old_end_x, int old_end_y)
  183. {
  184.         // èòàê, (sel_x, sel_y) :: (old_end_x, old_end_y) - èñòî÷íèê
  185.         // ðåçóëüòàò õðàíèòñÿ ëèáî â ñòðîêå sel_x .. sel_end_x, ëèáî â ñòîëáöå sel_y .. sel_end_y
  186.        
  187.         int i, start, end, step, gdir = -1;
  188.         int pdir = -1;
  189.         char *source;
  190.  
  191.         cf_x0 = cf_y0 = 0;
  192.         cf_x1 = col_count;
  193.         cf_y1 = row_count;
  194.  
  195.         if (sel_end_x == -1)
  196.                 sel_end_x = sel_x;
  197.         if (sel_end_y == -1)
  198.                 sel_end_y = sel_y;
  199.  
  200.         // åñëè íàïðàâëåíèÿ âûäåëåíèé ïåðïåíäèêóëÿðíû, òî ïðîñòî â öèêëå ïîâòîðÿåì òî æå, ÷òî äëÿ 1 ÿ÷åéêè:
  201.  
  202.         if (old_end_x == sel_end_x && sel_y == old_end_y)
  203.         {
  204.                 gdir = 0;
  205.         }
  206.         else if (old_end_y == sel_end_y && sel_x == old_end_x)
  207.         {
  208.                 gdir = 1;
  209.         }
  210.  
  211.         //sprintf(debuf, "fuck in ass %U %U %U %U %U %U dir %U",sel_x,sel_y,sel_end_x,sel_end_y,old_end_x,old_end_y,gdir);
  212.         //rtlDebugOutString(debuf);
  213.         if (gdir != -1)
  214.         {
  215.                 int gstep = gdir ? sign(old_end_y - sel_y) : sign(old_end_x - sel_x);
  216.                 if (gstep == 0)
  217.                 {
  218.                 /*      if (gdir)
  219.                         {
  220.                                 //old_end_y += 1;
  221.                         }
  222.                         else
  223.                         {
  224.                                 //old_end_x += 1;
  225.                         }
  226.                 */
  227.                         gstep = 1;
  228.                 }
  229.  
  230.                 for (;gdir ? (sel_y != old_end_y + gstep) : (sel_x != old_end_x + gstep);
  231.                         gdir ? (sel_y += gstep) : (sel_x += gstep))
  232.                 {
  233.                         //sprintf(debuf, "cycle %U %U %U %U %U %U dir %U",sel_x,sel_y,sel_end_x,sel_end_y,old_end_x,old_end_y,gdir);
  234.                         //rtlDebugOutString(debuf);
  235.                         int dir;
  236.                         source = cells[sel_x][sel_y];
  237.                         if (gdir == 0)
  238.                         {
  239.                                 start = sel_y;
  240.                                 end = sel_end_y;
  241.                                 step = (sel_y < sel_end_y ? 1 : -1);
  242.                                 dir = 1;
  243.                         }
  244.                         else
  245.                         {
  246.                                 start = sel_x;
  247.                                 end = sel_end_x;
  248.                                 step = (sel_x < sel_end_x ? 1 : -1);
  249.                                 dir = 0;
  250.                         }
  251.  
  252.                         //sprintf(debuf, "cyc %U %U %U %U",start,end,step,dir);
  253.                         //rtlDebugOutString(debuf);
  254.                         for (i = start + step; i != end + step; i += step)
  255.                         {
  256.                                 //char **p = &cells[dir ? sel_x : i][dir ? i : sel_end_y];
  257.                                 //sprintf(debuf, "to %U %U dir %U copying '%S'",dir ? sel_x : i,dir ? i : sel_y,dir,source);
  258.                                 //rtlDebugOutString(debuf);
  259.                                 if (cells[dir ? sel_x : i][dir ? i : sel_y])
  260.                                 {
  261.                                         freemem(cells[dir ? sel_x : i][dir ? i : sel_y]);
  262.                                 }
  263.                                 if (source)
  264.                                 {
  265.                                         cells[dir ? sel_x : i][dir ? i : sel_y] = change_formula(source, dir ? 0 : (i - start), dir ? (i - start) : 0);
  266.                                         //cells[dir ? sel_x : i][dir ? i : sel_y] = (char *)allocmem(strlen(source) + 1);
  267.                                         //strcpy(cells[dir ? sel_x : i][dir ? i : sel_y], source);
  268.                                 }
  269.                                 else
  270.                                         cells[dir ? sel_x : i][dir ? i : sel_y] = NULL;
  271.                         }
  272.                 }
  273.         }
  274.  
  275.         // à âîò åñëè ïàðàëëåëüíû...
  276.         /*
  277.        
  278.         if (sel_x == sel_end_x && sel_x == old_end_x)
  279.         {
  280.                 pdir = 0;
  281.         }
  282.         if (sel_y == sel_end_y && sel_y == old_end_y)
  283.         {
  284.                 pdir = 1;
  285.         }
  286.         if (pdir != -1)
  287.         {
  288.                 // àðèôìåòè÷åñêàÿ ïðîãðåññèÿ - åñëè ÷èñëà. è òóïî ðàçìíîæèòüò ïîñëåäíåå, åñëè íåò
  289.  
  290.                 sprintf(debuf, "maybe arith dir %U", pdir);
  291.                 rtlDebugOutString(debuf);
  292.  
  293.                 int is_arith = 1;
  294.                 int gstep = pdir ? sign(old_end_y - sel_y) : sign(old_end_x - sel_x);
  295.                 if (gstep == 0)
  296.                         gstep = 1;
  297.  
  298.                 for (int i = pdir ? sel_y : sel_x; i != pdir ? (old_end_y + gstep) : (old_end_x + gstep); i++)
  299.                 {
  300.                         convert_error = 0;
  301.                         sprintf(debuf,"cell %U %U", !pdir ? sel_x : i, !pdir ? i : sel_y);
  302.                         rtlDebugOutString(debuf);
  303.                         if (cells[!pdir ? sel_x : i][!pdir ? i : sel_y])
  304.                         {
  305.                                 double d = atof(cells[!pdir ? sel_x : i][!pdir ? i : sel_y]);
  306.                                 if (convert_error)
  307.                                 {
  308.                                         rtlDebugOutString("failed arith");
  309.                                         is_arith = 0;
  310.                                         break;
  311.                                 }
  312.                         }
  313.                         else
  314.                         {
  315.                                 is_arith = 0;
  316.                                 rtlDebugOutString("failed arith in null");
  317.                                 break;
  318.                         }
  319.                 }
  320.  
  321.                 double arith_first, arith_step;
  322.                 if (is_arith)
  323.                 {
  324.                         rtlDebugOutString("really arith");
  325.                         arith_first = atof(cells[sel_x][sel_y]);
  326.                         arith_step = atof(cells[pdir ? sel_x : old_end_x][pdir ? sel_y : old_end_y]) - arith_first;
  327.                         arith_first += arith_step * pdir ? abs(sel_end_x - old_end_x) : abs(sel_end_y - old_end_y);
  328.                 }
  329.                 else
  330.                         rtlDebugOutString("none arith");
  331.  
  332.                 // ñîáñòâåííî çàïîëíåíèå
  333.                 for (i = pdir ? old_end_y : old_end_x; i != pdir ? (sel_end_y + gstep) : (sel_end_x + gstep); i++)
  334.                 {
  335.                         if (cells[pdir ? sel_x : i][pdir ? i : sel_y])
  336.                                 freemem(cells[pdir ? sel_x : i][pdir ? i : sel_y]);
  337.                         if (is_arith)
  338.                         {
  339.                                 cells[pdir ? sel_x : i][pdir ? i : sel_y] = ftoa(arith_first);
  340.                                 arith_first += arith_step;
  341.                         }
  342.                         else
  343.                         {
  344.                                 if (cells[sel_x][sel_y])
  345.                                 {
  346.                                         cells[pdir ? sel_x : i][pdir ? i : sel_y] = (char*)allocmem(strlen(cells[sel_x][sel_y]) + 1);
  347.                                         strcpy(cells[pdir ? sel_x : i][pdir ? i : sel_y], cells[sel_x][sel_y]);
  348.                                 }
  349.                         }
  350.                 }
  351.         }
  352.         */
  353.  
  354.         calculate_values();
  355. }
  356.  
  357. int Kos_FileWrite(kosFileInfo &fileInfo, char *line, int mode = 3) // åñëè mode = 2 - ïåðåçàïèñàòü ôàéë
  358. {
  359.         int res = 0;
  360.         fileInfo.dataCount = strlen(line);
  361.         fileInfo.bufferPtr = (Byte*)line;
  362.         fileInfo.rwMode = mode;
  363.         res = kos_FileSystemAccess(&fileInfo);
  364.         if (res != 0)
  365.                 return 0;
  366.         fileInfo.OffsetLow += fileInfo.dataCount;
  367.         return 1;
  368. }
  369.  
  370. int SaveCSV(char *fname)
  371. {
  372.         int i, j;
  373.         int min_col = col_count, min_row = row_count, max_row = -1, max_col = -1;
  374.         int first = 1;
  375.  
  376.         kosFileInfo fileInfo;
  377.         memset((Byte*)&fileInfo, 0, sizeof(fileInfo));
  378.         strcpy(fileInfo.fileURL,fname);
  379.         fileInfo.OffsetLow = 0;
  380.         fileInfo.OffsetHigh = 0;
  381.         fileInfo.rwMode = 8;    // delete
  382.  
  383.         rtlDebugOutString("savecsv: old file deleted");
  384.  
  385.         for (i = 1; i < col_count; i++)
  386.         {
  387.                 for (j = 1; j < row_count; j++)
  388.                 {
  389.                         if (cells[i][j])
  390.                         {
  391.                                 min_col = min(min_col, i);
  392.                                 min_row = min(min_row, j);
  393.                                 max_col = max(max_col, i);
  394.                                 max_row = max(max_row, j);
  395.                         }
  396.                 }
  397.         }
  398.  
  399.         sprintf(debuf, "col %U %U row", min_col, max_col, min_row, max_row);
  400.         rtlDebugOutString(debuf);
  401.  
  402.         for (j = min_row; j <= max_row; j++)
  403.         {
  404.                 char buffer[1024]; // íå íàäî òàê äåëàòü
  405.                 int buf_len = 0;
  406.  
  407.                 memset((Byte*)buffer, 0, 1024);
  408.  
  409.                 for (i = min_col; i <= max_col; i++)
  410.                 {
  411.                         char *cur = values[i][j] ? values[i][j] : cells[i][j];
  412.                         if (cur)
  413.                         {
  414.                                 buffer[buf_len++] = '\"';
  415.                                 for (int k = 0; k < strlen(cur); k++)
  416.                                 {
  417.                                         if (cur[k] == '\"')
  418.                                                 buffer[buf_len++] = '\"';       // êàâû÷åê - ïî äâå
  419.                                         buffer[buf_len++] = cur[k];
  420.                                 }
  421.                                 buffer[buf_len++] = '\"';
  422.                         }
  423.                         buffer[buf_len++] = ',';
  424.                 }
  425.                 rtlDebugOutString(buffer);
  426.                 // î÷åðåäíàÿ ñòðîêà òåïåðü â áóôåðå
  427.                 buffer[buf_len++] = '\n';
  428.                 if (!Kos_FileWrite(fileInfo, buffer, first ? (first = 0, 2) : 3))
  429.                         return 0;
  430.         }
  431.         return 1;
  432. }
  433.  
  434. int str_is_csv(char *str)
  435. {
  436.         int str_len = strlen(str);
  437.         if (str_len >= 5) {
  438.                 if ( strnicmp(str + str_len - 4, ".CSV", 4) == 0) return 1;
  439.         }
  440.         return 0;
  441. }
  442.  
  443. #define BUF_FOR_ALL 5000
  444. int SaveFile(char *fname)
  445. {
  446.         kosFileInfo fileInfo;
  447.         char *buffer = (char*)allocmem(BUF_FOR_ALL);    // óæàñ! íî ïîêà ÷òî äîñòàòî÷íî
  448.         int filePointer = 0;
  449.  
  450.         int i,j;
  451.         Dword res;
  452.  
  453.         if (str_is_csv(fname))
  454.                 return SaveCSV(fname);
  455.  
  456.  
  457.         //rtlDebugOutString(fname);
  458.  
  459.         memset((Byte*)&fileInfo, 0, sizeof(fileInfo));
  460.         strcpy(fileInfo.fileURL,fname);
  461.         fileInfo.OffsetLow = 0;
  462.         fileInfo.OffsetHigh = 0;
  463.         fileInfo.rwMode = 8;
  464.         res = kos_FileSystemAccess(&fileInfo);  // óäàëèòü
  465.         fileInfo.dataCount = strlen(sFileSign);
  466.         fileInfo.bufferPtr = (Byte*)sFileSign;
  467.         fileInfo.rwMode = 2;
  468.         res = kos_FileSystemAccess(&fileInfo);
  469.         if (res != 0)
  470.                 return 0;
  471.         //sprintf(debuf, "create %U",res);
  472.         //rtlDebugOutString(debuf);
  473.         fileInfo.OffsetLow += fileInfo.dataCount;
  474.  
  475.         // øèðèíó ñòîëáöîâ ñîõðàíÿåì
  476.         memset((Byte*)buffer,0,BUF_FOR_ALL);
  477.         for (i = 1; i < col_count; i++)
  478.         {
  479.                 char smalbuf[32];
  480.                 memset((Byte*)smalbuf,0,32);
  481.                 sprintf(smalbuf, "%U,", cell_w[i]);
  482.                 strcpy(buffer+strlen(buffer),smalbuf);
  483.         }
  484.         buffer[strlen(buffer)-1] = '\n';        // çàìåíèëè ïîñëåäíþþ çàïÿòóþ íà ïåðåâîä ñòðîêè
  485.         //rtlDebugOutString(buffer);
  486.         fileInfo.dataCount = strlen(buffer);
  487.         fileInfo.bufferPtr = (Byte*)buffer;
  488.         fileInfo.rwMode = 3;
  489.         res = kos_FileSystemAccess(&fileInfo);
  490.         if (res != 0)
  491.                 return 0;
  492.  
  493.         // ïåðåìîòàòü çàáûë ÿ ýòîò ôàéë
  494.         // íî óæ òåïåðü íå ïîïàäóñü íà ýòî!
  495.         fileInfo.OffsetLow += fileInfo.dataCount;
  496.  
  497.         // âûñîòó ñòðîê ñîõðàíÿåì â ôàéëå ìû
  498.         memset((Byte*)buffer,0,BUF_FOR_ALL);
  499.         for (i = 1; i < row_count; i++)
  500.         {
  501.                 char smalbuf[32];
  502.                 memset((Byte*)smalbuf,0,32);
  503.                 sprintf(smalbuf, "%U,", cell_h[i]);
  504.                 strcpy(buffer+strlen(buffer),smalbuf);
  505.         }
  506.         buffer[strlen(buffer)-1] = '\n';        // çàìåíèëè ïîñëåäíþþ çàïÿòóþ íà ïåðåâîä ñòðîêè
  507.         //rtlDebugOutString(buffer);
  508.         fileInfo.dataCount = strlen(buffer);
  509.         fileInfo.bufferPtr = (Byte*)buffer;
  510.         fileInfo.rwMode = 3;
  511.         res = kos_FileSystemAccess(&fileInfo);
  512.         if (res != 0)
  513.                 return 0;
  514.  
  515.         // è âíîâü ïåðåìîòàþ ÿ ñåé ôàéë
  516.        
  517.         fileInfo.OffsetLow += fileInfo.dataCount;
  518.         memset((Byte*)buffer,0,BUF_FOR_ALL);
  519.  
  520.         // ñîõðàíèëè ïàðàìåòðû ÿ÷ååê ìû, ñîõðàíÿåì ñîäåðæèìîå èõ òåïåðü
  521.  
  522.         for (i = 1; i < row_count; i++)
  523.         {
  524.                 for (j = 1; j < col_count; j++)
  525.                         if (cells[j][i])
  526.                         {
  527.                                 memset((Byte*)buffer,0,512);
  528.                                 sprintf(buffer, "%U %U:%S\n", j, i, cells[j][i]);
  529.                                 fileInfo.dataCount = strlen(buffer);
  530.                                 fileInfo.bufferPtr = (Byte*)buffer;
  531.                                 fileInfo.rwMode = 3;
  532.                                 res = kos_FileSystemAccess(&fileInfo);
  533.                                 if (res != 0)
  534.                                         return 0;
  535.                                 //sprintf(debuf, "create %U",res);
  536.                                 //rtlDebugOutString(debuf);
  537.                                 fileInfo.OffsetLow += fileInfo.dataCount;
  538.                         }
  539.         }
  540.  
  541.         //rtlDebugOutString("saving finished");
  542.  
  543.         freemem(buffer);
  544.         return 1;
  545. }
  546.  
  547. char *Kos_FileRead(kosFileInfo &fileInfo, int &code)
  548. {
  549.         char buffer[512], *p, *r;
  550.         fileInfo.dataCount = 512;
  551.         fileInfo.rwMode = 0;
  552.         fileInfo.bufferPtr = (Byte *)buffer;
  553.         memset((Byte*)buffer, 0, 512);
  554.         int z = kos_FileSystemAccess(&fileInfo);
  555.         code = z;
  556.  
  557.         //sprintf(debuf, "kos file read %U", code);
  558.         //rtlDebugOutString(debuf);
  559.  
  560.         if (z != 0 && z != 6)
  561.                 return NULL;
  562.  
  563.         p = buffer;
  564.         while (*p && *p++ != '\n');
  565.  
  566.         if (p == buffer)
  567.                 return NULL;
  568.  
  569.         r = (char*)allocmem(p - buffer);
  570.         memset((Byte*)r, 0, p - buffer);
  571.         //strncpy(r, buffer, p - buffer);
  572.         for (int l = 0; l < p - buffer - 1; l++)
  573.                 r[l] = buffer[l];
  574.         fileInfo.OffsetLow += p - buffer;
  575.         return r;
  576. }
  577.  
  578. char GetCsvSeparator(char *fname)
  579. {
  580.         char buffer[4096];
  581.         kosFileInfo fileInfo;
  582.         DWORD load_size;
  583.        
  584.         if (filesize < 4096) {
  585.                 load_size = filesize;
  586.         } else {
  587.                 load_size = 4096;
  588.         }
  589.  
  590.         rtlDebugOutString(fname);
  591.  
  592.         strcpy(fileInfo.fileURL, fname);
  593.         fileInfo.OffsetLow = 0;
  594.         fileInfo.OffsetHigh = 0;
  595.         fileInfo.dataCount = load_size;
  596.         fileInfo.rwMode = 0;
  597.         fileInfo.bufferPtr = (Byte *)buffer;
  598.        
  599.         if (kos_FileSystemAccess(&fileInfo) == 0) {
  600.                 int separ_coma = chrnum(buffer, ',');
  601.                 int separ_semicolon = chrnum(buffer, ';');
  602.                 //kos_DebugValue(",", separ_coma);
  603.                 //kos_DebugValue(";", separ_semicolon);
  604.                 if (separ_semicolon>separ_coma) return ';';
  605.         }
  606.         return ',';
  607. }
  608.  
  609. int LoadCSV(char *fname)
  610. {
  611.         // clear the table
  612.         reinit();
  613.  
  614.         kosFileInfo fileInfo;
  615.         strcpy(fileInfo.fileURL,fname);
  616.         fileInfo.OffsetLow = 0;
  617.         fileInfo.OffsetHigh = 0;
  618.  
  619.         char separator = GetCsvSeparator(fileInfo.fileURL);
  620.  
  621.         char *line;
  622.  
  623.         int col = 1, row = 1;
  624.         int code = 0;
  625.         do
  626.         {
  627.                 line = Kos_FileRead(fileInfo, code);
  628.                 if (!line || *line == '\0' || (code != 0 && code != 6))
  629.                 {
  630.                         sprintf(debuf, "read end, line not null = %U, code = %U", !line, code);
  631.                         rtlDebugOutString(debuf);
  632.                         break;
  633.                 }
  634.                 sprintf(debuf, "read '%S' len %U", line, strlen(line));
  635.                 rtlDebugOutString(debuf);
  636.  
  637.                 // ðàçáîðàòü ñòðîêó
  638.                 // âûäåëèòü ;, ïðè÷åì âíå "
  639.                 int i = 0;
  640.                 while (i <= strlen(line))
  641.                 {
  642.                         int inPar = 0;
  643.                         // inPar: 0 - íå êàâû÷êè, 1 - òîëüêî ÷òî áûëà êàâû÷êà, 2 - êàâû÷êà áûëà, íî äàâíî
  644.                         int start = i;
  645.                         while (i <= strlen(line))
  646.                         {
  647.                                 char c = line[i];
  648.                                 if (!c)
  649.                                         c = separator;
  650.                                 int yes_semicolon = 0;
  651.  
  652.                                 switch (inPar)
  653.                                 {
  654.                                         case 0:
  655.                                                 if (c == '\"')
  656.                                                 {
  657.                                                         inPar = 1;
  658.                                                 }
  659.                                                 else
  660.                                                 {
  661.                                                         if (c == separator)
  662.                                                                 yes_semicolon = 1;
  663.                                                 }
  664.                                                 break;
  665.                                         case 1:
  666.                                                 inPar = 2;
  667.                                                 break;
  668.                                         case 2:
  669.                                                 if (c == '\"')  // îíà çàêðûëàñü
  670.                                                 {
  671.                                                         inPar = 0;
  672.                                                 }
  673.                                                 /*else
  674.                                                 {
  675.                                                         if (c == separator)
  676.                                                                 yes_semicolon = 1;
  677.  
  678.                                                 }*/
  679.                                                 break;
  680.                                 }
  681.                                 if (yes_semicolon)
  682.                                 {
  683.                                         // èòàê, line[i] = separator
  684.                                         int tmp = line[start] == '"' ? 1 : 0;
  685.                                         int sz = i - start - tmp * 2;
  686.                                         if (sz > 0)
  687.                                         {
  688.                                                 cells[col][row] = (char *)allocmem(sz + 1);
  689.                                                 memset((Byte*)cells[col][row], 0, sz + 1);
  690.                                                 int m = 0;
  691.                                                 for (int l = 0; l < sz; l++)
  692.                                                 {
  693.                                                         if (line[start + tmp + l] == '\"')
  694.                                                         {
  695.                                                                 cells[col][row][m++] = '\"';
  696.                                                                 l++;    // ïðîïóñòèòü ñëåäóþùóþ êàâû÷êó
  697.                                                         }
  698.                                                         else
  699.                                                                 cells[col][row][m++] = line[start + tmp + l];
  700.                                                 }
  701.                                                 sprintf(debuf, "set %U %U = '%S'", col, row, cells[col][row]);
  702.                                                 rtlDebugOutString(debuf);
  703.                                         }
  704.                                         start = i + 1;
  705.                                         col++;
  706.                                 }
  707.                                 i++;
  708.                         }
  709.                         row++;
  710.                         col = 1;
  711.                         i++;
  712.                 }
  713.  
  714.         } while(line);
  715.  
  716.         return 1;
  717. }
  718.  
  719.  
  720. int LoadFile(char *fname)
  721. {
  722.         kosFileInfo fileInfo;
  723.         kosBDVK bdvk;
  724.         int filePointer = 0, i, j;
  725.         Dword res;
  726.         char buffer[512 + 1];
  727.         char *d, *s, *k;
  728.         int step = 0, items;
  729.  
  730.         strcpy(fileInfo.fileURL,fname);
  731.         fileInfo.OffsetLow = 0;
  732.         fileInfo.OffsetHigh = 0;
  733.  
  734.         fileInfo.rwMode = 5;
  735.         fileInfo.bufferPtr = (Byte *)&bdvk;
  736.         Dword rr = kos_FileSystemAccess(&fileInfo); // â CKosFile íåò îïðåäåëåíèÿ ðàçìåðà
  737.         //sprintf(debuf, "getsize: %U\n", rr);
  738.         //rtlDebugOutString(debuf);
  739.         if (rr != 0)
  740.         {
  741.                 return -1;
  742.         }
  743.        
  744.         filesize = bdvk.size_low;
  745.  
  746.         if (str_is_csv(fname))
  747.                 return LoadCSV(fname);
  748.  
  749.  
  750.         // clear the table
  751.         reinit();
  752.  
  753.         fileInfo.rwMode = 0;
  754.         fileInfo.dataCount = strlen(sFileSign);
  755.         fileInfo.bufferPtr = (Byte*)buffer;
  756.         kos_FileSystemAccess(&fileInfo);
  757.         s = (char*)sFileSign;
  758.         d = buffer;
  759.         while (*s && *d && *s++==*d++);         // çàñòðåëèòå ìåíÿ
  760.         if (*s != '\0' || *d != '\0')
  761.         {
  762.                 return -2;
  763.         }
  764.         fileInfo.OffsetLow += fileInfo.dataCount;
  765.         items = 1;
  766.         while (fileInfo.OffsetLow < filesize)
  767.         {
  768.                 // òàê ïðî÷èòàëè ëè ìû øèðèíó âñåõ ñòîáëöîâ, è äëèíó âñåõ ñòðîê ïðî÷èòàëè ëè ìû?
  769.                 fileInfo.dataCount = 512;
  770.                 memset((Byte*)buffer, 0, 512);
  771.                 kos_FileSystemAccess(&fileInfo);
  772.                 //sprintf(debuf, "%U", fileInfo.OffsetLow);
  773.                 //rtlDebugOutString(debuf);
  774.                 //sprintf(debuf, "buffer: %S", buffer);
  775.                 //rtlDebugOutString(debuf);
  776.                 // ÷òî ÿ óâèæó íà äîñêå îòëàäêè
  777.                 // òî ìíå ïîìîæåò â æèçíåííîì ïóòè
  778.                 // ñìîãó òîãäà ñâîåé îøèáêè ãàäêîé
  779.                 // ïðè÷èíó íåïîñðåäñòâåííî íàéòè
  780.  
  781.                 switch (step)
  782.                 {
  783.                 case 0:                 // ñòîáëöû
  784.                         d = buffer;
  785.                         while (*d && *d != ',' && *d != '\n') d++;     
  786.                         //d--;
  787.                         if (!*d)
  788.                         {      
  789.                                 return -2;
  790.                         }
  791.                         *d = '\0';
  792.                         i = atoi(buffer);
  793.                         cell_w[items++] = i;
  794.                         if (items == col_count)
  795.                         {
  796.                                 step++;
  797.                                 items = 1;      //      òåïåðü âûñîòû ñòðîê ÷èòàòü ìû áóäåì ñìåëî
  798.                                                         //  ÷òîá èõ âîññòàíîâèòü è áûëî êàê âñåãäà
  799.                                 //sprintf(debuf, "col_count read done last buf %S file pos %U",buffer,fileInfo.OffsetLow);
  800.                                 //rtlDebugOutString(debuf);
  801.                         }
  802.                         d+=2;
  803.                         break;
  804.  
  805.                 case 1:                 // ñòðîêè, êîèõ âûñîòà çàïèñàíà
  806.                         d = buffer;
  807.                         while (*d && *d != ',' && *d != '\n') d++;     
  808.                         //d--;
  809.                         if (!*d)
  810.                         {      
  811.                                 //sprintf(debuf,"oh shit, error at %U",items);
  812.                                 //rtlDebugOutString(debuf);
  813.                                 return -2;
  814.                         }
  815.                         *d = '\0';
  816.                         i = atoi(buffer);
  817.                         cell_h[items++] = i;
  818.                         /*if (items > 5)
  819.                         {
  820.                                 sprintf(debuf, "set row from %S hei %U %U",buffer,items-1,i);
  821.                                 rtlDebugOutString(debuf);
  822.                         }*/
  823.  
  824.                         if (items == row_count)
  825.                         {
  826.                                 step++;         // à äàëåå ëåæàò ÿ÷åéêè â ôàéëå
  827.                                                         // çàïèñàíû îíè â êðèâîì ôîðìàòå
  828.                                                         // èáî ïèñàë ñåé êîä ÿ òåìíîé íî÷üþ
  829.                                                         // íî íå êóðèë òðàâû, êëÿíóñü ÿ âàì
  830.                                                         // èíà÷å áû è ýòîãî íå ñêîäèë
  831.  
  832.                                                         // äåáàæèòü ñåé ìíå êîä ïðåìíîãî âïàäëó
  833.                                                         // íî ïîìíþ ïðàâèëî - êîëü íàïèñàë äåáàæü
  834.                                                         // íåìåäëåííî - à òî íàõ âñå çàáóäåøü.
  835.                                                         // âîò âûïüþ - à òàì ñðàçó çà îòëàäêó.
  836.                                 //sprintf(debuf, "before read cells offset %U %X",fileInfo.OffsetLow,fileInfo.OffsetLow);
  837.                                 //rtlDebugOutString(debuf);
  838.                         }
  839.                         d+=2;
  840.                         break;
  841.  
  842.                         // î, áðÿêè ÿ çàáûë çàáèòü. î óæàñ.
  843.                         // ïîçîð ìíå, íà êîñòðå ìåíÿ ñîæãèòå
  844.                         // âåäü òîò, êòî break íå ñòàâèò ïîñëå casa
  845.                         // ïîäîáåí ëàìåðó, ÷òî ñè íå çíàåò
  846.                         // ñìîãó ëè ÿ òàêîå ïåðåæèòü?
  847.  
  848.                 case 2:                 // ÿ÷åéêè, èáî èõ ñîäåðæèìîå ñîõðàíåíî çäåñü îò èñ÷åçíîâåíèÿ
  849.                         d = buffer;
  850.                         while (*d && *d++ != ' ');      // îóææàñ. çà÷åì òîëüêî ÿ ïèñàë ýòîò áðåä....
  851.                         d--;
  852.                         if (!*d)
  853.                         {      
  854.                                 return -2;
  855.                         }
  856.                         *d = '\0';
  857.                         i = atoi(buffer);
  858.                         d++;
  859.                         s=d;
  860.                         while (*d && *d++ != ':');      // êîãäà-òî ÿ óäèâëÿëñÿ, êàê ëþäè ìîãóò òàêóþ õåðíþ ïèñàòü... äîæèë
  861.                         d--;
  862.                         if (!*d)
  863.                         {      
  864.                                 return -2;
  865.                         }
  866.                         *d = '\0';
  867.                         j = atoi(s);
  868.                         //rtlDebugOutString(s);
  869.                         d++;
  870.                         k = d;
  871.                         while (*d && *d++ != '\n');
  872.                         d--;
  873.                         *d = '\0';
  874.                         d+=2;
  875.                         //sprintf(debuf, "i:%U j:%U d:%S\n",i,j,k);
  876.                         //rtlDebugOutString(debuf);
  877.                         cells[i][j] = (char*)allocmem(strlen(k) + 1);
  878.                         //memset(cells[i][j], 0, strlen(k) + 1);
  879.                         strcpy(cells[i][j], k);
  880.                         //sprintf(debuf, "offset: %U", fileInfo.OffsetLow);
  881.                         //rtlDebugOutString(debuf);
  882.                 }
  883.                 fileInfo.OffsetLow += d - (char*)buffer - 1;
  884.         }
  885.         //rtlDebugOutString("loading finished");
  886.         return 1;
  887. }
  888.  
  889. // î÷èñòèòü áóôåð îáìåíà
  890. void freeBuffer()
  891. {
  892.         int i, j;
  893.  
  894.         if (!buffer)
  895.                 return;
  896.         for (i = 0; i < buf_col; i++)
  897.         {
  898.                 for (j = 0; j < buf_row; j++)
  899.                         if (buffer[i][j])
  900.                                 freemem(buffer[i][j]);
  901.                 freemem(buffer[i]);
  902.         }
  903.         freemem(buffer);
  904.         buffer = NULL;
  905.         buf_row = buf_col = 0;
  906.  
  907. }
  908.  
  909.  
  910. // äàëåå - âû÷èñëåíèå ïî ôîðìóëàì
  911.  
  912. int abort_calc = 0;
  913. cell_list *last_dep;
  914.  
  915. // ïïö, ãäå òî áàã, à ýòî òèïà ôèêñ
  916. //#define allocmem2(x) allocmem(x+1000)
  917.  
  918. double calc_callback(char *str)
  919. {
  920.         int i,j,x,y;
  921.  
  922.         if (abort_calc == 1)
  923.                 return 0.0;
  924.  
  925.         //rtlDebugOutString(str);
  926.         if (*str == '$') str++;
  927.         for (i = 0; i < strlen(str); i++)
  928.                 if (str[i] >= '0' && str[i] <= '9')
  929.                         break;
  930.         if (str[i-1] == '$')
  931.                 i--;
  932.         if (i == strlen(str))
  933.         {
  934.                 abort_calc = 1;
  935.                 serror(ERR_BADVARIABLE);
  936.                 return 0.0;
  937.         }
  938.         x = -1;
  939.         for (j = 0; j < col_count; j++)
  940. //              if (strnicmp(str,cells[j][0],i-1)==0)
  941.                 if (str[0] == cells[j][0][0] && ((i == 1) || (str[1] == cells[j][0][1])))
  942.                 {
  943.                         x = j;
  944.                         break;
  945.                 }
  946.         if (str[i] == '$')
  947.                 i++;
  948.         y = -1;
  949.         for (j = 0; j < row_count; j++)
  950.                 if (strcmp(str+i,cells[0][j])==0)
  951.                 {
  952.                         y = j;
  953.                         break;
  954.                 }
  955.         if (x == -1 || y == -1)
  956.         {
  957.                 abort_calc = 1;
  958.                 serror(ERR_BADVARIABLE);
  959.                 return 0.0;
  960.         }
  961.  
  962.         double hold;
  963.         if (values[x][y])
  964.                 if (values[x][y][0] == '#')
  965.                 {
  966.                         serror(ERR_BADVARIABLE);
  967.                         abort_calc = 1;
  968.                 }
  969.                 else
  970.                 {
  971.                         hold = atof(values[x][y]);
  972.                         //if (convert_error)                            // íåðåàëüíûé ñëó÷àé...
  973.                         //{
  974.                         //      serror(ERR_BADVARIABLE);
  975.                         //      abort_calc = 1;
  976.                         //}
  977.                 }
  978.         else
  979.         {
  980.                 if (cells[x][y])
  981.                 {
  982.                         hold = atof(cells[x][y]);
  983.                         if (convert_error == ERROR || convert_error == ERROR_END)
  984.                         {
  985.                                 serror(ERR_BADVARIABLE);
  986.                                 abort_calc = 1;
  987.                         }
  988.                 }
  989.                 else
  990.                 {
  991.                         sprintf(debuf, "bad var %S", str);
  992.                         rtlDebugOutString(debuf);
  993.                         serror(ERR_BADVARIABLE);
  994.                         abort_calc = 1;
  995.                 }
  996.         }
  997.         return hold;
  998. }
  999.  
  1000. double depend_callback(char *str)
  1001. {
  1002.         cell_list *cur;
  1003.         // íàäî âûäðàòü èç ÀÂ47 çíà÷åíèÿ õ è ó.
  1004.         int i,j,x,y;
  1005.  
  1006.         if (abort_calc == 1)
  1007.                 return 0.0;
  1008.  
  1009.         if (*str == '$') str++;
  1010.         for (i = 0; i < strlen(str); i++)
  1011.                 if (str[i] >= '0' && str[i] <= '9')
  1012.                         break;
  1013.         if (str[i-1] == '$')
  1014.                 i--;
  1015.         if (i == strlen(str))
  1016.         {
  1017.                 abort_calc = 1;
  1018.                 serror(ERR_BADVARIABLE);
  1019.                 return 0.0;
  1020.         }
  1021.         x = -1;
  1022.         for (j = 1; j < col_count; j++)
  1023.                 //if (strncmp(str,cells[j][0],i)==0)
  1024.                 if (str[0] == cells[j][0][0] && ((i == 1) || (str[1] == cells[j][0][1])))
  1025.                 {
  1026.                         x = j;
  1027.                         break;
  1028.                 }
  1029.         if (str[i] == '$')
  1030.                 i++;
  1031.  
  1032.         y = -1;
  1033.         for (j = 1; j < row_count; j++)
  1034.                 if (strcmp(str+i,cells[0][j])==0)
  1035.                 {
  1036.                         y = j;
  1037.                         break;
  1038.                 }
  1039.         if (x == -1 || y == -1)
  1040.         {
  1041.                 abort_calc = 1;
  1042.                 serror(ERR_BADVARIABLE);
  1043.                 return 0.0;
  1044.         }
  1045.         cur = (cell_list*)allocmem(sizeof(cell_list));
  1046.         cur->x = x;
  1047.         cur->y = y;
  1048.         cur->next = last_dep;
  1049.         last_dep = cur;
  1050.  
  1051.         return 0.0;
  1052. }
  1053.  
  1054. cell_list *find_depend(char *str)
  1055. {
  1056.         double hold;
  1057.         last_dep = NULL;
  1058.         find_var = &depend_callback;
  1059.         set_exp(str);
  1060.         get_exp(&hold);
  1061.  
  1062.         return last_dep;
  1063. }
  1064.  
  1065. bool is_in_list(cell_list *c1, cell_list *c2)
  1066. {
  1067.         cell_list *p = c2;
  1068.         while (p)
  1069.         {
  1070.                 if (c1->x == p->x && c1->y == p->y)
  1071.                         return 1;
  1072.                 p = p->next;
  1073.         }
  1074.         return 0;
  1075. }
  1076.  
  1077. void calculate_values()
  1078. {
  1079.         cell_list ***depend = NULL;
  1080.         cell_list *first = NULL;
  1081.         cell_list *sorted = NULL, *sorted_last = NULL;
  1082.         cell_list *p = NULL;
  1083.         int i,j;
  1084.  
  1085.         //rtlDebugOutString("calc");
  1086.  
  1087.         abort_calc = 0;
  1088.         depend = (cell_list***)allocmem(col_count * sizeof(void*));
  1089.         for (i = 0; i < col_count; i++)
  1090.         {
  1091.                 depend[i] = (cell_list**)allocmem(row_count * sizeof(void*));
  1092.                 for (j = 0; j < row_count; j++)
  1093.                 {
  1094.                         if (values[i][j])
  1095.                                 freemem(values[i][j]);
  1096.                         values[i][j] = NULL;
  1097.  
  1098.                         if (cells[i][j] && cells[i][j][0] == '=')
  1099.                         {
  1100.                                 depend[i][j] = find_depend(cells[i][j] + 1);            // ïîñëå =
  1101.                                 if (abort_calc)
  1102.                                 {
  1103.                                         values[i][j] = (char*)allocmem(2);
  1104.                                         values[i][j][0] = '#';
  1105.                                         values[i][j][1] = '\0';
  1106.                                         abort_calc = 0;
  1107.                                         continue;
  1108.                                 }
  1109.                                 cell_list *cur;
  1110.                                 cur = (cell_list*)allocmem(sizeof(cell_list));
  1111.                                 cur->x = i;
  1112.                                 cur->y = j;
  1113.                                 cur->next = first;      // âñòàâèëè òåê. ÿ÷åéêó â íà÷àëî ñïèñêà ÿ÷ååê ñ ôîðìóëàìè
  1114.                                 first = cur;
  1115.                         }
  1116.                 }
  1117.         }
  1118.  
  1119.         //rtlDebugOutString("depend end");
  1120.         // òîïîëîãè÷åñêàÿ ñîðòèðîâêà
  1121.         if (!first)
  1122.                 goto free_memory;
  1123.  
  1124.         if (abort_calc)
  1125.                 goto free_memory;
  1126.  
  1127.         while (first)
  1128.         {
  1129.                 // íàéòè íàèìåíüøèé ýëåìåíò. åñëè åãî íåò - îøèáêà, ò.ê. öèêëè÷åñêàÿ çàâèñèìîñòü
  1130.                 cell_list *prev = NULL,*min = first;
  1131.  
  1132.                 bool is_min;
  1133.                 while (min)
  1134.                 {
  1135.                         cell_list *p = first;
  1136.                         is_min = 1;
  1137.                         while (p && is_min)
  1138.                         {
  1139.                                 if (is_in_list(p,depend[min->x][min->y]))
  1140.                                         is_min = 0;
  1141.                                 p = p->next;
  1142.                         }
  1143.                         if (is_min)
  1144.                                 break;
  1145.                         prev = min;
  1146.                         min = min->next;
  1147.                 }
  1148.                 if (!is_min)
  1149.                 {
  1150.                         abort_calc = 1;
  1151.                         goto free_memory;               // âñå ïëîõî. óæàñíî. ÿ ïëàêàþ, íî ïèøó goto
  1152.                 }
  1153.                 // íàäî óáðàòü ìèíèìóì âî âòîðîé ñïèñîê
  1154.                 if (prev == NULL)
  1155.                 {
  1156.                         first = first->next;
  1157.                 }
  1158.                 else
  1159.                 {
  1160.                         prev->next = min->next;
  1161.                 }
  1162.                 /*
  1163.                 min->next = sorted;
  1164.                 sorted = min;
  1165.                 */
  1166.                 if (sorted == NULL)
  1167.                 {
  1168.                         sorted = min;
  1169.                         sorted_last = min;
  1170.                 }
  1171.                 else
  1172.                 {
  1173.                         sorted_last->next = min;
  1174.                         sorted_last = min;
  1175.                         min->next = NULL;
  1176.                 }
  1177.         }
  1178.  
  1179.         // âû÷èñëåíèå çíà÷åíèé
  1180.         //rtlDebugOutString("sort end");
  1181.  
  1182.         p = sorted;
  1183.         while (p)
  1184.         {
  1185.                 double d;
  1186.                 abort_calc = 0;
  1187.                 set_exp(cells[p->x][p->y]+1);   // âñå ÷òî ïîñëå "="
  1188.                 find_var = &calc_callback;
  1189.                 if (get_exp(&d))
  1190.                 {
  1191.                         char *new_val = ftoa(d);
  1192.                         if (values[p->x][p->y] && strcmp(values[p->x][p->y],new_val) == 0)
  1193.                         {
  1194.                                 freemem(new_val);
  1195.                         }
  1196.                         else
  1197.                         {
  1198.                                 if (values[p->x][p->y])
  1199.                                         freemem(values[p->x][p->y]);
  1200.                                 values[p->x][p->y] = new_val;
  1201.                                 sel_moved = 0;
  1202.                         }
  1203.                         //sprintf(debuf,"calc %U %U formula %S result %f",p->x,p->y,cells[p->x][p->y]+1,d);
  1204.                         //rtlDebugOutString(debuf);
  1205.                 }
  1206.                 else
  1207.                 {
  1208.                         values[p->x][p->y] = (char*)allocmem(2);
  1209.                         values[p->x][p->y][0] = '#';
  1210.                         values[p->x][p->y][1] = '\0';
  1211.                         //sprintf(debuf,"calc %U %U formula %S result #",p->x,p->y,cells[p->x][p->y]+1);
  1212.                         //rtlDebugOutString(debuf);
  1213.                 }
  1214.                 p = p->next;
  1215.         }
  1216.  
  1217.         if (abort_calc)
  1218.                 goto free_memory;
  1219.  
  1220.         //rtlDebugOutString("calc end");
  1221.  
  1222.  
  1223.         // îñâîáîæäåíèå ïàìÿòè
  1224.  
  1225. free_memory:
  1226.        
  1227.         p = sorted;
  1228.         while (p)
  1229.         {
  1230.                 cell_list *tmp = p->next;
  1231.                 cell_list *pp = depend[p->x][p->y];
  1232.                 while (pp)
  1233.                 {
  1234.                         cell_list *tmp = pp->next;
  1235.                         freemem(pp);
  1236.                         pp = tmp;
  1237.                 }
  1238.                 freemem(p);
  1239.                 p = tmp;
  1240.         }
  1241.  
  1242.         for (i = 0; i < col_count; i++)
  1243.                 freemem(depend[i]);
  1244.         freemem(depend);
  1245.  
  1246.         //rtlDebugOutString("freemem end");
  1247.  
  1248.        
  1249. }
  1250.  
  1251. int parse_cell_name(char *str, int *px, int *py, int *xd, int *yd)
  1252. {
  1253.         // íàäî âûäðàòü èç ÀÂ47 çíà÷åíèÿ õ è ó.
  1254.         int i,j,x,y,dx = 0,dy = 0;
  1255.  
  1256.         if (*str == '$')
  1257.         {
  1258.                 str++;
  1259.                 dx = 1;
  1260.         }
  1261.         for (i = 0; i < strlen(str); i++)
  1262.                 if (str[i] >= '0' && str[i] <= '9')
  1263.                         break;
  1264.         if (str[i-1] == '$')
  1265.         {
  1266.                 i--;
  1267.                 dy = 1;
  1268.         }
  1269.         if (i == strlen(str))
  1270.         {
  1271.                 return 0;
  1272.         }
  1273.         x = -1;
  1274.         for (j = 1; j < col_count; j++)
  1275.                 if (strncmp(str,cells[j][0],i)==0)
  1276.         {
  1277.                 /*int p = 0, z = 1;
  1278.                 for (p = 0; p < i; p++)
  1279.                         if (!str[p] || str[p] != cells[j][0][p])
  1280.                         {
  1281.                                 z = 0;
  1282.                                 break;
  1283.                         }
  1284.                 if (z)
  1285.                 */
  1286.                 {
  1287.                         x = j;
  1288.                         break;
  1289.                 }
  1290.         }
  1291.         if (str[i] == '$')
  1292.                 i++;
  1293.         y = -1;
  1294.         for (j = 1; j < row_count; j++)
  1295.                 if (strcmp(str+i,cells[0][j])==0)
  1296.         {
  1297.                         /*
  1298.                 int p = 0, z = 1;
  1299.                 for (p = 0;; p++)
  1300.                 {
  1301.                         if (str[i + p] != cells[0][j][p])
  1302.                         {
  1303.                                 z = 0;
  1304.                                 break;
  1305.                         }
  1306.                         if (cells[0][j][p] == '\0')
  1307.                                 break;
  1308.                 }
  1309.                 if (z)
  1310.                 */
  1311.                 {
  1312.                         y = j;
  1313.                         break;
  1314.                 }
  1315.         }
  1316.         if (x == -1 || y == -1)
  1317.         {
  1318.                 return 0;
  1319.         }
  1320.         *px = x;
  1321.         *py = y;
  1322.         if (xd)
  1323.                 *xd = dx;
  1324.         if (yd)
  1325.                 *yd = dy;
  1326.         return 1;
  1327. }
  1328.  
  1329. char *make_cell_name(int x, int y, int xd, int yd)
  1330. {
  1331.         char *col_cap = make_col_cap(x);
  1332.         char *row_cap = make_row_cap(y);
  1333.  
  1334.         if (x <= 0 || x > col_count || y <= 0 || y > row_count)
  1335.                 return NULL;
  1336.  
  1337.         char *res = (char*)allocmem(strlen(col_cap) + strlen(row_cap) + xd ? 1 : 0 + yd ? 1 : 0 + 1);
  1338.         int i = 0;
  1339.         if (xd)
  1340.         {
  1341.                 res[i] = '$';
  1342.                 i++;
  1343.         }
  1344.         strcpy(res + i, col_cap);
  1345.         i += strlen(col_cap);
  1346.         if (yd)
  1347.         {
  1348.                 res[i] = '$';
  1349.                 i++;
  1350.         }
  1351.         strcpy(res + i, row_cap);
  1352.         i += strlen(row_cap);
  1353.         res[i] = '\0';
  1354.         freemem(col_cap);
  1355.         freemem(row_cap);
  1356.         return res;
  1357. }
  1358.  
  1359. // çàìåíû ññûëêè íà îäíó ÿ÷åéêó
  1360. char *change_cell_ref(char *name, int sx, int sy)
  1361. {
  1362.         int x0, y0, xd, yd;
  1363.  
  1364.         parse_cell_name(name, &x0, &y0, &xd, &yd);
  1365.  
  1366.         //sprintf(debuf, "parsed cell name %S to %U %U", name, x0, y0);
  1367.         //rtlDebugOutString(debuf);
  1368.  
  1369.         // ó íàñ åñòü õ0 è ó0.
  1370.         //sprintf(debuf, "%U in %U %U, %U in %U %U",x0, cf_x0, cf_x1, y0, cf_y0, cf_y1);
  1371.         //rtlDebugOutString(debuf);
  1372.         if (x0 >= cf_x0 && x0 <= cf_x1 && y0 >= cf_y0 && y0 <= cf_y1)
  1373.         {
  1374.                 if (!xd)
  1375.                 {
  1376.                         x0 += sx;
  1377.                         if (x0 <= 0 || x0 > col_count)
  1378.                                 x0 -= sx;
  1379.                 }
  1380.                 if (!yd)
  1381.                 {
  1382.                         y0 += sy;
  1383.                         if (y0 <= 0 || y0 > row_count)
  1384.                                 y0 -= sy;
  1385.                 }
  1386.         }
  1387.  
  1388.         return make_cell_name(x0, y0, xd, yd);
  1389. }
  1390.  
  1391. // çàìåíà âñåõ ññûëîê íà ÿ÷åéêè
  1392. char *change_formula(char *name, int sx, int sy)
  1393. {
  1394.         int i = 0;
  1395.         int in_name = 0;        // 1 - ÷èòàåì áóêâåííóþ ÷àñòü. 2 - ÷èòàåì öèôðîâóþ. 0 - ÷èòàåì ðàçäåëèòåëè è ò.ä.
  1396.         int alp_len = 0, dig_len = 0;
  1397.         int buf_i = 0;
  1398.  
  1399.         char buffer[256]; // î÷åíü ïëîõî
  1400.         memset((Byte*)buffer, 0, 256);
  1401.  
  1402.         //sprintf(debuf, "change formula %S by %U %U", name, sx, sy);
  1403.         //rtlDebugOutString(debuf);
  1404.  
  1405.         while (i < strlen(name) + 1)
  1406.         {
  1407.                 char c;
  1408.                 if (i == strlen(name))
  1409.                         c = ' ';
  1410.                 else
  1411.                         c = name[i];
  1412.                 buffer[buf_i++] = c;
  1413.  
  1414.                 switch (in_name)
  1415.                 {
  1416.                         case 0:
  1417.                         {
  1418.                                 if (isalpha2(c) || c == '$')
  1419.                                 {
  1420.                                         in_name = 1;
  1421.                                         alp_len = 1;
  1422.                                         dig_len = 0;
  1423.                                 }
  1424.                         }
  1425.                         break;
  1426.                         case 1:
  1427.                         {
  1428.                                 if (isalpha2(c))
  1429.                                 {
  1430.                                         alp_len++;
  1431.                                 }
  1432.                                 else if (c == '$' || isdigit(c))
  1433.                                 {
  1434.                                         in_name = 2;
  1435.                                         dig_len++;
  1436.                                 }
  1437.                                 else
  1438.                                 {
  1439.                                         // íåçàâåðøåííîå èìÿ ÿ÷åéêè - íå èìÿ
  1440.                                         in_name = 0;
  1441.                                         alp_len = dig_len = 0;
  1442.                                 }
  1443.                         }
  1444.                         break;
  1445.                         case 2:
  1446.                         {
  1447.                                 if (isdigit(c))
  1448.                                 {
  1449.                                         dig_len++;
  1450.                                 }
  1451.                                 else
  1452.                                 {
  1453.                                         if (alp_len > 0 && dig_len > 0)
  1454.                                         {
  1455.                                                 // âîò íîðìàëüíàÿ ÿ÷åéêà
  1456.                                                 int idx = i - alp_len - dig_len;
  1457.                                                 int len = alp_len + dig_len;
  1458.                                                 char *cell = (char*)allocmem(len + 1);
  1459.                                                 //strncpy(cell, name + i, alp_len + dig_len);
  1460.                                                 for (int l = 0; l < len; l++)
  1461.                                                         cell[l] = name[idx + l];
  1462.                                                 cell[len] = '\0';
  1463.  
  1464.                                                 //sprintf(debuf, "found cell name '%S' alp %U dig %U", cell, alp_len, dig_len);
  1465.                                                 //rtlDebugOutString(debuf);
  1466.                                                 char *cell_new = change_cell_ref(cell, sx, sy);
  1467.                                                 //sprintf(debuf, "rename to '%S'", cell_new);
  1468.                                                 //rtlDebugOutString(debuf);
  1469.                                                 if (cell_new)
  1470.                                                 {
  1471.                                                         char cc = buffer[buf_i - 1];
  1472.                                                         strcpy(buffer + buf_i - len - 1, cell_new);
  1473.                                                         buf_i += strlen(cell_new) - len;
  1474.                                                         buffer[buf_i - 1] = cc;
  1475.                                                 }
  1476.                                                 //freemem(cell);
  1477.                                                 //freemem(cell_new);
  1478.                                                 alp_len = dig_len = 0;
  1479.                                                 in_name = 0;
  1480.                                         }
  1481.                                 }
  1482.                         }
  1483.                 }
  1484.                 i++;
  1485.         }
  1486.         //sprintf(debuf, "change formula done");
  1487.         //rtlDebugOutString(debuf);
  1488.         char *res = (char*)allocmem(strlen(buffer) + 1);
  1489.         strcpy(res, buffer);
  1490.         return res;
  1491. }
  1492.  
  1493.  
  1494.  
  1495.  
  1496.