Author: Not specified Language: c
Description: Not specified Timestamp: 2013-06-05 09:13:42 +0000
View raw paste Reply
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. // ?????????
  5. const int SIZE = 20;
  6. const char *msgs[]={"0. End","1. Add Item", "2. Find Items", "3. Cleaning", "4. Show Table"};
  7. const int Nmsgs = sizeof(msgs)/sizeof(msgs[0]);
  8.  
  9. typedef struct Item
  10. {
  11.     int key;
  12.     int release;
  13.     int len;
  14.     int offset;
  15. }Item ;
  16.  
  17. // ??????? ?????
  18. char *getStr();
  19. int getInt(int *N);
  20. char* antispace(char *str);
  21. //?????????? ???????
  22. int dialog(const char *msgs[], int N);
  23. int D_Add(Item *table, int *ntab, FILE **fp,char* filename),           // ??????? ???????? ? ???????
  24.     D_Find(Item *table, int *ntab, FILE **fp,char* filename),         // ????? ???????? ? ???????
  25.     D_Delete(Item *table, int *ntab, FILE **fp,char* filename),      // ???????? ???????? ?? ???????
  26.     D_Show(Item *table, int *ntab, FILE **fp,char* filename);       // ????? ??????????? ???????
  27. int (*fptr[])(Item *table, int *ntab, FILE **fp,char* filename) = {NULL,D_Add,D_Find,D_Delete,D_Show};
  28.  
  29. //????????? ???????
  30. int insert(Item *table, int *n, int key, int len, int offset);
  31. int find(Item* table, int n, int key);
  32. //???????? ???????
  33. int load(Item *table, int *n, FILE **fp,char **filename);
  34. int loadtable(Item *table, int *n, FILE **fp);
  35. int main()
  36. {
  37.     FILE *fp, *in;
  38.     char *filename;
  39.     int i, ntab=0;
  40.     Item *table=(Item*)malloc(SIZE*sizeof(Item));
  41.     int rc;
  42.  
  43.     load(table, &ntab, &fp, &filename);
  44.     while(rc = dialog(msgs, Nmsgs))
  45.     {
  46.         loadtable(table,&ntab,&fp);
  47.         fptr[rc](table, &ntab, &fp,filename);
  48.     }
  49.     fclose(fp);
  50.     fclose(in);
  51.     return 0;
  52.  
  53. }
  54.  
  55. int load(Item *table, int *n, FILE **fp,char **filename)
  56. {
  57.     while(1)
  58.     {
  59.  
  60.         puts("Please enter file name");
  61.         *filename=(char*)malloc(sizeof(char));
  62.         *filename=getStr();
  63.         *filename=(char*)realloc(*filename, strlen(*filename)+5);
  64.  
  65.         strcat(*filename,".dat");
  66.  
  67.             if(*fp=fopen(*filename,"r+b"))
  68.             {
  69.                 fread(n,sizeof(int),1,*fp);
  70.                 break;
  71.             }
  72.  
  73.             else if (*fp=fopen(*filename,"w+b"))
  74.                 break;
  75.             else
  76.                 puts("Error. Try again.");
  77.  
  78.     }
  79. }
  80. int loadtable(Item *table, int *n, FILE **fp)
  81. {
  82.     int i;
  83.     Item temp;
  84.     rewind(*fp);
  85.     fread(n,sizeof(int),1,*fp);
  86.     if (*n>0)
  87.         for(i=0;i<*n;)
  88.         {
  89.  
  90.             fread(&temp,sizeof(Item),1,*fp);
  91.             fseek(*fp,temp.len,SEEK_CUR);
  92.             insert(table,&i,temp.key,temp.len, temp.offset);
  93.         }
  94.     else
  95.         return 0;
  96. }
  97.  
  98. char* antispace(char* str)
  99. {
  100.     for(;*str!='\0';str++)
  101.         if (*str != ' ' && *str != '\t')
  102.             return str;
  103.     return NULL;
  104. }
  105.  
  106. char* getStr()
  107. {
  108.  
  109.     char *ptr = (char *)malloc(1);
  110.     char buf[21];
  111.     int n, len = 0;
  112.     *ptr = '\0';
  113.     do
  114.     {
  115.         n = scanf("%20[^\n]", buf);
  116.         if(n < 0)
  117.         {
  118.  
  119.             free(ptr);
  120.             ptr = NULL;
  121.             break;
  122.  
  123.         }
  124.         if(n == 0)
  125.             scanf("%*c");
  126.  
  127.  
  128.         else
  129.         {
  130.             len += strlen(buf);
  131.             ptr = (char *) realloc(ptr, len + 1);
  132.             strcat(ptr, buf);
  133.         }
  134.  
  135.     }
  136.  
  137.     while(n > 0);
  138.     return ptr;
  139. }
  140.  
  141. int getInt(int *N)
  142. {
  143.     int n;
  144.     n=scanf("%d",N);
  145.  
  146.         if (n < 0)
  147.         {
  148.             *N=0;
  149.             return 0;
  150.         }
  151.  
  152.         if( (n == 0) || (scanf("%[a-z]") == 1) )
  153.         {
  154.             *N=-1;
  155.             fflush(stdin);
  156.             return*N;
  157.         }
  158.         else
  159.         {
  160.             fflush(stdin);
  161.             return n;
  162.         }
  163.  
  164.  
  165. }
  166.  
  167.  
  168. int dialog(const char *msgs[], int N)
  169. {
  170.     int rc=1, i;
  171.     do
  172.     {
  173.         if (rc < 0 || rc >= N)
  174.             puts("Sorry, your request is wrong. Please, try again");
  175.         else
  176.             puts("Please put the number of selected action:");
  177.         for (i=0;i<N;i++)
  178.             puts(msgs[i]);
  179.  
  180.         getInt(&rc);
  181.     }
  182.     while (rc < 0 || rc >= N) ;
  183.     return rc;
  184. }
  185.  
  186. int D_Add(Item *table, int *ntab, FILE **fp,char* filename)
  187. {
  188.  
  189.     int k,n=1,len,offset, rel=1,i;
  190.     char *info = NULL,*str2;
  191.     info=(char*)malloc(sizeof(char));
  192.     do
  193.     {
  194.         if(n<0 || k<0)
  195.             puts("Your key is wrong. Please try again:");
  196.         else
  197.             puts("Enter key:");
  198.         n=getInt(&k);
  199.     }
  200.     while (n<0 || k<0);
  201.  
  202.     if(n == 0)
  203.         return 0;
  204.     do
  205.     {
  206.         if (info == NULL)
  207.             puts("Info is empty. Please try again:");
  208.         else
  209.             puts("Enter info:");
  210.  
  211.         info = getStr();
  212.         if (info != NULL)
  213.         info = antispace(info);
  214.             else
  215.         return 0;
  216.     }
  217.     while (info == NULL);
  218.  
  219.  
  220.     *ntab=*ntab+1;
  221.     len=strlen(info)+1;
  222.     rewind(*fp);
  223.     fwrite(ntab,sizeof(int),1,*fp);
  224.     fseek(*fp,0,SEEK_END);
  225.     offset=ftell(*fp);
  226.     fwrite(&k,sizeof(int),1,*fp);
  227.     fwrite(&rel,sizeof(int),1,*fp);
  228.     fwrite(&len,sizeof(int),1,*fp);
  229.     fwrite(&offset,sizeof(int),1,*fp);
  230.     fwrite(info,1,len,*fp);
  231.  
  232.  
  233.     return 1;
  234. }
  235.  
  236. int D_Find(Item *table, int *ntab, FILE **fp,char* filename)
  237. {
  238.     loadtable(table,ntab,fp);
  239.     int i,j,k,rel=0,n=1,nnew=0;
  240.     Item *newtable;
  241.  
  242.     do
  243.     {
  244.         if(n<0 || k<0)
  245.             puts("Your key is wrong. Please try again:");
  246.         else
  247.             puts("Enter key:");
  248.         n=getInt(&k);
  249.     }
  250.     while (n<0 || k<0);
  251.  
  252.     if(n == 0)
  253.         return 0;
  254.  
  255.     n=0;
  256.         do
  257.     {
  258.         if(n<0 || rel<0)
  259.             puts("Your release is wrong. Please try again:");
  260.         else
  261.             puts("Enter release[if necessary] or <0>");
  262.         n=getInt(&rel);
  263.     }
  264.     while (n<0 || rel<0);
  265.  
  266.     if(n == 0)
  267.         return 0;
  268.  
  269.     if (find(table,*ntab,k) >= 0)
  270.     {
  271.         j=i=find(table,*ntab,k);
  272.         if (rel<=0)
  273.         {
  274.             for(;table[j].key == k;j++,nnew++);
  275.  
  276.             newtable=(Item *)malloc(nnew*sizeof(Item));
  277.             for(j=i;table[j].key == k;j++)
  278.                 newtable[j-i]=table[j];
  279.  
  280.         }
  281.  
  282.         else
  283.             for(j=i;table[j].key == k;j++)
  284.             {
  285.                 if(table[j].release == rel)
  286.                 {
  287.                     nnew++;
  288.                     newtable=(Item *)malloc(sizeof(Item));
  289.                     newtable[0]=table[j];
  290.                 }
  291.  
  292.             }
  293.  
  294.     }
  295.     if(nnew>0)
  296.         D_Show(newtable,&nnew, fp,filename);
  297.     else
  298.         puts("Item not found");
  299.  
  300.     return 1;
  301. }
  302.  
  303. int D_Show (Item *table, int *ntab, FILE **fp,char* filename)
  304. {
  305.     int i;
  306.     char *info;
  307.     rewind(*fp);
  308.     puts("///////////////////////////");
  309.     printf("*ntab is %d\n",*ntab);
  310.     if(*ntab>0)
  311.         for(i=0;i<*ntab;i++)
  312.         {
  313.             if(table[i].key >= 0)
  314.             {
  315.                 if(table[i].key != 0)
  316.                 info=(char*)malloc(table[i].len);
  317.                 *info=NULL;
  318.                 fseek(*fp,table[i].offset,SEEK_SET);
  319.                 fseek(*fp,sizeof(Item),SEEK_CUR);
  320.                 fread(info,1,table[i].len,*fp);
  321.                 printf("Item: key - %d, release - %d, info - %s\n",table[i].key,table[i].release,info);
  322.                 free(info);
  323.             }
  324.  
  325.         }
  326.     else
  327.         puts("Table is empty");
  328.     puts("///////////////////////////");
  329.     return 1;
  330. }
  331.  
  332. int D_Delete (Item *table, int *ntab, FILE **fp,char* filename)
  333. {
  334.  
  335.     int i,j,n=-1;
  336.     if(*ntab>0)
  337.         for(i=0;i<(*ntab-1);i++)
  338.         {
  339.             if(table[i].key == table[i+1].key)
  340.             {
  341.                 rewind(*fp);
  342.                 fseek(*fp,table[i].offset,SEEK_SET);
  343.                 fwrite(&n,sizeof(int),1,*fp);
  344.             }
  345.  
  346.         }
  347.     else
  348.         {
  349.             puts("Table is empty");
  350.             return 0;
  351.         }
  352.  
  353.     puts("Table changed");
  354.     return 1;
  355. }
  356.  
  357. int find(Item* table, int ntab, int key)
  358. {
  359.     int i;
  360.     for (i=0;i<ntab;i++)
  361.     {
  362.         if (table[i].key == key)
  363.             return i;
  364.  
  365.  
  366.     }
  367.     return -1;
  368. }
  369.  
  370. int insert(Item *table, int *ntab, int key, int len, int offset)
  371. {
  372.     int i,j,rel;
  373.     rel=1;
  374.     if (*ntab == 0)
  375.         i=0;
  376.  
  377.    else
  378.    {
  379.        i=find(table,*ntab,key);
  380.     if (i >= 0)
  381.         {
  382.  
  383.  
  384.  
  385.             while (table[i].key == key)
  386.             {
  387.  
  388.                 i++;
  389.                 rel++;
  390.  
  391.             }
  392.             for(j=*ntab;j>i;j--)
  393.                 table[j]=table[j-1];
  394.  
  395.  
  396.  
  397.         }
  398.     else
  399.         {
  400.             i=0;j=0;
  401.             while (i<*ntab)
  402.             {
  403.  
  404.                 if(table[i].len == 0)
  405.                 {
  406.                     table[j]=table[i];
  407.                     j++;
  408.                 }
  409.                 i++;
  410.             }
  411.             j=i;
  412.         }
  413.    }
  414.     *ntab=*ntab+1;
  415.     table[i].key=key;
  416.     table[i].release=rel;
  417.     table[i].len=len;
  418.     table[i].offset=offset;
  419.  
  420.  
  421.     return rel;
  422. }
  423.  
View raw paste Reply