API tools faq
paste
libdo

Untitled

libdo
Oct 27th, 2017
151
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.18 KB | None | 0 0
raw download clone embed print report
  1. /*notes
  2.     when finding "movie_facebook_likes", it reads it as "\tmovie_facebook_likes" when you compare it to argv[2].  This "\t" is believed to be from tabs in the stdin file.  *ask tjang about this*
  3.  
  4. */
  5.  
  6. #include<stdio.h>
  7. #include<stdlib.h>
  8. #include<string.h>
  9. #include<ctype.h>
  10. #include<unistd.h>
  11. #include<dirent.h>
  12. #include<sys/types.h>
  13. #include<sys/stat.h>
  14. #include<sys/wait.h>
  15. #include "sorter.h"
  16. #include "mergesort.c"
  17.  
  18. #define MAX_FILES 300
  19. int counter = 0;
  20. int numProcessesMade;
  21.  
  22. int numColumns(char * csvname){
  23.     int numcolumns = 0;
  24.     FILE * fp;
  25.     fp = fopen(csvname,"r");
  26.     char str[1000];
  27.     fgets(str, 1000, fp);  //fgets the stream from file pointer    <--------------some issue here Address sanitizer
  28.    
  29.     //this is for output
  30.     char *string1 = strdup(str);
  31.     string1 = trimWhiteSpace(string1);
  32.    
  33.     int i;
  34.     for(i=0;i< (strlen(string1));i++){
  35.         if(string1[i] == ','){
  36.             numcolumns++;
  37.         }
  38.     }
  39.     numcolumns++; //to get the true # of columns since i basically counted the commas between them.
  40.     return numcolumns;
  41. }
  42.  
  43. int isCSV(char * string){
  44.     int length = strlen(string);
  45.     if(length<4){
  46.         //printf("String is too short to be a CSV file!\n");
  47.         return 0;
  48.     }
  49.     char * ending = malloc(sizeof(char)*length);
  50.     strncpy(ending, string+length-4, 4);
  51.  
  52.     if(strcmp(ending,".csv") == 0){ //0 means that this is a CSV file.
  53.         free(ending);
  54.         return 1;
  55.     }else{              //1 means that this is not a CSV file.
  56.         free(ending);
  57.         return 0;
  58.     }
  59.  
  60.     free(ending);
  61.     return 0;
  62. }
  63.  
  64. void sortFile(char * csvname, char * colname){
  65.     FILE * fp;
  66.     fp = fopen(csvname,"r");
  67.     char str[1000];
  68.     fgets(str, 1000, fp);  //fgets the stream from file pointer    <--------------some issue here Address sanitizer
  69.  
  70.     //this is for output
  71.     char *string1 = strdup(str);
  72.     string1 = trimWhiteSpace(string1);  //string1 is the column headers
  73.     //puts(string1);
  74.  
  75.     char *string = strdup(str);
  76.     char * token = strsep(&string, ",");
  77.  
  78.     while(token != NULL){ //tokenizes the first columns
  79.         token = trimWhiteSpace(token);
  80.         if(strcmp(token,colname)==0){
  81.             //printf("found it!! \n");
  82.             break;
  83.         }
  84.         token = strsep(&string,",");
  85.     }
  86.        
  87.     if(token == NULL){
  88.         printf("\n");
  89.         printf("error: no column exists, sorting failed on: %s\n",csvname);
  90.         return;
  91.     }
  92.        
  93.     int colnum;
  94.     if(strcmp(colname,"color")==0){
  95.         colnum = 0;
  96.     }else if(strcmp(colname,"director_name")==0){
  97.         colnum = 1;
  98.     }else if(strcmp(colname,"num_critic_for_reviews")==0){
  99.         colnum = 2;
  100.     }else if(strcmp(colname,"duration")==0){
  101.         colnum = 3;
  102.     }else if(strcmp(colname,"director_facebook_likes")==0){
  103.         colnum = 4;
  104.     }else if(strcmp(colname,"actor_3_facebook_likes")==0){
  105.         colnum = 5;
  106.     }else if(strcmp(colname,"actor_2_name")==0){
  107.         colnum = 6;
  108.     }else if(strcmp(colname,"actor_1_facebook_likes")==0){
  109.         colnum = 7;
  110.     }else if(strcmp(colname,"gross")==0){
  111.         colnum = 8;
  112.     }else if(strcmp(colname,"genres")==0){
  113.         colnum = 9;
  114.     }else if(strcmp(colname,"actor_1_name")==0){
  115.         colnum = 10;
  116.     }else if(strcmp(colname,"movie_title")==0){
  117.         colnum = 11;
  118.     }else if(strcmp(colname,"num_voted_users")==0){
  119.         colnum = 12;
  120.     }else if(strcmp(colname,"cast_total_facebook_likes")==0){
  121.         colnum = 13;
  122.     }else if(strcmp(colname,"actor_3_name")==0){
  123.         colnum = 14;
  124.     }else if(strcmp(colname,"facenumber_in_poster")==0){
  125.         colnum = 15;
  126.     }else if(strcmp(colname,"plot_keywords")==0){
  127.         colnum = 16;
  128.     }else if(strcmp(colname,"movie_imdb_link")==0){
  129.         colnum = 17;
  130.     }else if(strcmp(colname,"num_user_for_reviews")==0){
  131.         colnum = 18;
  132.     }else if(strcmp(colname,"language")==0){
  133.         colnum = 19;
  134.     }else if(strcmp(colname,"country")==0){
  135.         colnum = 20;
  136.     }else if(strcmp(colname,"content_rating")==0){
  137.         colnum = 21;
  138.     }else if(strcmp(colname,"budget")==0){
  139.         colnum = 22;
  140.     }else if(strcmp(colname,"title_year")==0){
  141.         colnum = 23;
  142.     }else if(strcmp(colname,"actor_2_facebook_likes")==0){
  143.         colnum = 24;
  144.     }else if(strcmp(colname,"imdb_score")==0){
  145.         colnum = 25;
  146.     }else if(strcmp(colname,"aspect_ratio")==0){
  147.         colnum = 26;
  148.     }else if(strcmp(colname,"movie_facebook_likes")==0){
  149.         colnum = 27;
  150.     }
  151.  
  152.     int n = 5100;
  153.     record * records = malloc(sizeof(record)*n);
  154.     int i=0;
  155.     int j=0;
  156.     char * qm = "\"";
  157.     char * symbol = malloc(sizeof(char)*2);
  158.  
  159.     while(!feof(fp)){ //goes through EVERY (5000) lines of the file and prints out EVERYTHING from the line
  160.         fgets(str,1000,fp); //gets input from standard input
  161.         string = strdup(str);
  162.         token = strsep(&string,","); //an entry of a line
  163.  
  164.         if(j+1>n){ //reallocates more more entries into the array of structs
  165.             n = n*2;
  166.             records = realloc(records, n*sizeof(record));
  167.         }
  168.  
  169.         while(token != NULL){ //tokenizes EACH line of the file
  170.             token = trimWhiteSpace(token);
  171.             switch(i){
  172.                 case 0:
  173.                     records[j].color = token;
  174.                     break;                 
  175.                 case 1:
  176.                     records[j].directorName = token;
  177.                     break;                 
  178.                 case 2:
  179.                     records[j].numCriticReviews = atoi(token);
  180.                     break;                 
  181.                 case 3:
  182.                     records[j].duration = atoi(token);
  183.                     break;
  184.                 case 4:
  185.                     records[j].directorFBlikes = atoi(token);
  186.                     break;                 
  187.                 case 5:
  188.                     records[j].actor3FBlikes = atoi(token);
  189.                     break;                 
  190.                 case 6:
  191.                     records[j].actor2name = token;
  192.                     break;                 
  193.                 case 7:
  194.                     records[j].actor1FBlikes = atoi(token);
  195.                     break;                 
  196.                 case 8:
  197.                     records[j].gross = atof(token);
  198.                     break;
  199.                 case 9:
  200.                     records[j].genres = token;
  201.                     break;                 
  202.                 case 10:
  203.                     records[j].actor1name = token;
  204.                     break;
  205.                 case 11:
  206.                     records[j].movieTitle = token;
  207.                     break;
  208.                 case 12:
  209.                     records[j].numVotedUsers = atoi(token);
  210.                     break;
  211.                 case 13:
  212.                     records[j].castTotalFBlikes = atoi(token);
  213.                     break;
  214.                 case 14:
  215.                     records[j].actor3name = token;
  216.                     break;
  217.                 case 15:
  218.                     records[j].faceNumberPoster = atoi(token);
  219.                     break;
  220.                 case 16:
  221.                     records[j].plotKeywords = token;
  222.                     break;
  223.                 case 17:
  224.                     records[j].link = token;
  225.                     break;
  226.                 case 18:
  227.                     records[j].numUserReviews = atoi(token);
  228.                     break;
  229.                 case 19:
  230.                     records[j].language = token;
  231.                     break;
  232.                 case 20:
  233.                     records[j].country = token;
  234.                     break;
  235.                 case 21:
  236.                     records[j].contentRating = token;
  237.                     break;
  238.                 case 22:
  239.                     records[j].budget = atof(token);
  240.                     break;
  241.                 case 23:
  242.                     records[j].titleYear = atoi(token);
  243.                     break;
  244.                 case 24:
  245.                     records[j].actor2FBlikes = atoi(token);
  246.                     break;
  247.                 case 25:
  248.                     records[j].imdbScore = atof(token);
  249.                     break;
  250.                 case 26:
  251.                     records[j].aspectRatio = atof(token);
  252.                     break;
  253.                 case 27:
  254.                     records[j].movieFBlikes = atoi(token);
  255.                     break;
  256.             }          
  257.             if(string != NULL){  //FIXED
  258.                 strncpy(symbol,string,1); //char for the first char of the string (used to check if theres a quotation mark"))         
  259.             }
  260.             if(strcmp(symbol,qm)==0){
  261.                 string = string + 1; //delete the string[0] which is currently a "
  262.                 token = strsep(&string,qm);
  263.                 string = string + 1; //delete the , after "
  264.             }else{
  265.                 token = strsep(&string,",");
  266.             }
  267.            
  268.             //token = strsep(&string,",");
  269.             if(i == 28){ //after i has hit 28, we reset it back to 0.  
  270.                 i = 0;
  271.             }
  272.             i++;
  273.         }
  274.         j++;
  275.         i=0;
  276.     }
  277.     //printf("%d \n",j); //j is the number of movies (AKA the "array size" when used for mergesort)
  278.  
  279.     mergesort(records, colnum, j-1);  //j-1 because the last entry is a repeat for some reason....
  280.     int k;
  281.     for(k=0;k<j-1;k++){
  282.            
  283.         //this if statement takes each title with a "," and puts quotations around it
  284.         if(strchr(records[k].movieTitle,',')){ //detection works fine
  285.             char qm1[100] = "";
  286.             char qm2[100] = "";
  287.             qm1[0] = '\"';
  288.             qm2[0] = '\"';
  289.             strcat(qm1,records[k].movieTitle);
  290.             strcat(qm1,qm2);
  291.             records[k].movieTitle = qm1;
  292.         }
  293.         //printf("%s,%s,%d,%d,%d,%d,%s,%d,%f,%s,%s,%s,%d,%d,%s,%d,%s,%s,%d,%s,%s,%s,%f,%d,%d,%f,%f,%d\n", records[k].color,records[k].directorName,records[k].numCriticReviews,records[k].duration, records[k].directorFBlikes, records[k].actor3FBlikes, records[k].actor2name,records[k].actor1FBlikes,records[k].gross, records[k].genres, records[k].actor1name, records[k].movieTitle, records[k].numVotedUsers,records[k].castTotalFBlikes, records[k].actor3name,records[k].faceNumberPoster, records[k].plotKeywords, records[k].link, records[k].numUserReviews,records[k].language,records[k].country,records[k].contentRating,records[k].budget,records[k].titleYear,records[k].actor2FBlikes,records[k].imdbScore,records[k].aspectRatio,records[k].movieFBlikes);
  294.     }
  295.     //printf("SORTEDDDDDDDDDDDDDDDDDDDDDDDDDDD\n");
  296.     free(records);
  297.     free(symbol);
  298. }
  299.  
  300. void getFile(char * path, char * colname){  
  301.     int pathlen = strlen(path) + 5;
  302.     char * newpath = malloc(sizeof(char) * pathlen);
  303.     sprintf(newpath, "%s", path);
  304.     //strcpy(newpath, path);
  305.     DIR * dir;
  306.     dir = opendir(path);
  307.     struct dirent * string;
  308.     while(dir){ //traverses through contents of directory
  309.         if((string = readdir(dir)) != NULL){  //checks to see if we've checked everything in the directory
  310.             if(string->d_type == DT_DIR){  //If directory  <--some error is happening here
  311.                 if( (strcmp(string->d_name,".") !=0) && (strcmp(string->d_name, "..") !=0) ){ //Makes sure its not a hidden directory
  312.                     //printf("found a DIRECTORY <%s>, <------- fork here\n", string->d_name);  
  313.                     if(!fork()){ //If this is a child
  314.                         printf("%d, ", getpid()); //print pid
  315.                         fflush(stdout);
  316.                         int newsize = (strlen(newpath) + strlen(string->d_name) + 1);
  317.                         char * fullpath = malloc(sizeof(char)*(newsize + 1));
  318.                             strcpy(fullpath, newpath);
  319.                             strcat(fullpath, "/");
  320.                         strcat(fullpath, string->d_name);  
  321.                        
  322.                         closedir(dir); //closes the old path  **IMPORTANT SO NO DOUBLING OCCURS**
  323.                         dir = opendir(fullpath);  //creates new path for the child process
  324.                         //printf("=======================%s\n", newpath);
  325.                         free(newpath);
  326.                         newpath = malloc(sizeof(char) * (strlen(fullpath) + 10));  //resets newpath with new size
  327.                         strcpy(newpath, fullpath);
  328.                         free(fullpath);
  329.                         //printf("=======================%s\n", newpath);
  330.                        
  331.                         counter = 0;  //reset counter
  332.                     }
  333.                     else{  //else still in parent
  334.                         counter++;
  335.                     }
  336.                 }
  337.             }else{  //Not a directory, but could be a csv file
  338.                 int c = isCSV(string->d_name);
  339.                 if(c==1){
  340.                     //printf("Found CSV FILE: <---- fork here %s\n", string->d_name);
  341.                     //printf("file path at %s, is %s\n", string->d_name, path);
  342.                     if(!fork()){   //If this is a child
  343.                         int newsize = (strlen(newpath) + strlen(string->d_name) + 1);
  344.                         char * fullpath = malloc(sizeof(char)* (newsize+1));                   
  345.                             strcpy(fullpath, newpath);
  346.                             strcat(fullpath, "/");
  347.                         strcat(fullpath, string->d_name);
  348.                        
  349.                         //printf("file path for %s --->>> %s\n", string->d_name,fullpath);
  350.                         //printf("Sorting file: %s\n", string->d_name);
  351.  
  352.                         //SORTS on file here
  353.  
  354.                         int colnums = 0;
  355.                         colnums = numColumns(fullpath);
  356.                         //printf("number of columns in csv file is: %d\n", colnums);
  357.                                                
  358.                         if(colnums != 28){
  359.                             //printf("ERROR: different number of columns\n");
  360.                             //printf("failed to sort on file: %s\n", string->d_name);
  361.                             return;
  362.                         }
  363.  
  364.                         printf("%d, ", getpid());  //print pid
  365.                         fflush(stdout);
  366.                         sortFile(fullpath, colname);
  367.                        
  368.                         free(fullpath);
  369.                         return;   //signals that the sorting process is done
  370.                     }else{    //else still in parent
  371.                         counter++;
  372.                     }
  373.                 }
  374.             }
  375.         }else{ //if theres nothing else to see in the directory, stop looping through directory
  376.             break;
  377.         }
  378.     }
  379.    
  380.     while(counter != 0){   //all files in the immediate folder have been forked if directory or csv file, now waits for #counter of processes to return
  381.         //printf("process completed\n");       
  382.         int status;    
  383.         wait(&status);
  384.         counter--;
  385.     }
  386.    
  387.     free(newpath);
  388.     return; //signals that directory fork is done
  389. }
  390.  
  391. //finds the number of processes made in the directory
  392. void numProcess(char * stream){  
  393.     DIR * dir;
  394.     dir = opendir(stream);
  395.     struct dirent * string;
  396.     while(dir){
  397.         if((string = readdir(dir)) != NULL){
  398.             if (string->d_type == DT_DIR){
  399.                 if(     (strcmp(string->d_name, ".") != 0) && (strcmp(string->d_name, "..") != 0)      ){
  400.                     numProcessesMade++;
  401.  
  402.                     if ((strlen(stream) + strlen(string->d_name) + 1) > PATH_MAX){  //path is say "/ilab/users/CS214/Part1" here
  403.                             //return 0;
  404.                         }
  405.                     char fullpath[PATH_MAX + 1];
  406.  
  407.                         strcpy(fullpath, stream);
  408.                         strcat(fullpath, "/");
  409.                         strcat(fullpath, string->d_name);  
  410.  
  411.                         numProcess(fullpath); //new path is say "/ilab/users/CS214/Part1/csv_files" here
  412.                 }else{
  413.  
  414.                 }
  415.             }else{
  416.                
  417.             }
  418.             //printf("path is: %s\n", stream);
  419.             int c = isCSV(string->d_name);
  420.             if(c == 1){
  421.                 if ((strlen(stream) + strlen(string->d_name) + 1) > PATH_MAX){  //path is say "/ilab/users/CS214/Part1" here
  422.                         //return 0;
  423.                     }
  424.                 char fullpath[PATH_MAX + 1];
  425.  
  426.                     strcpy(fullpath, stream);
  427.                     strcat(fullpath, "/");
  428.                     strcat(fullpath, string->d_name);
  429.  
  430.                 int colnums = 0;
  431.                 colnums = numColumns(fullpath);
  432.                 if(colnums == 28){
  433.                     numProcessesMade++;
  434.                 }
  435.             }else{
  436.  
  437.             }
  438.  
  439.         }else{
  440.             closedir(dir);
  441.             return;
  442.         }
  443.     }
  444.     closedir(dir);
  445. }
  446.  
  447. int main(int argc, char ** argv){
  448.     /*
  449.     if(argc<3){  //checks if there are enough parameters in this function
  450.         printf("error: not enough arguments \n");
  451.         return 0;
  452.     }
  453.     */ 
  454.  
  455.     //put sorted directories in <original.csv>-sorted-<column_name>.
  456.     //   argv[4] = this_directory       argv[6] = output directory
  457.  
  458.     //we will be searching through argv[4] and all sub-directories within argv[4] for ".csv" files.  Once we locate a .csv file, we will fork a
  459.     //process to sort on that .csv file
  460.  
  461.     int pid = getpid();
  462.     printf("Initial PID: %d \n", pid);
  463.     printf("PIDS of all child processes: ");
  464.     fflush(stdout);
  465.    
  466.     char cwd[1024];
  467.     numProcessesMade = 0;  
  468.  
  469.     if(argv[4] != NULL){
  470.         getFile(argv[4],argv[2]);
  471.         numProcess(argv[4]);
  472.     }else{
  473.         if(getcwd(cwd, sizeof(cwd)) != NULL){
  474.             fprintf(stdout, "Current working dir: %s \n", cwd);
  475.         }else{
  476.             perror("getcwd() error");
  477.             return 0;
  478.         }
  479.         getFile(cwd,argv[2]);
  480.         numProcess(cwd);
  481.     }
  482.  
  483.     int status;
  484.     wait(&status);
  485.     if(pid == getpid()){
  486.         printf("\n");
  487.         printf("Total Number of Processes Made: %d \n", numProcessesMade);
  488.     }
  489.  
  490.     return 0;
  491. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!