API tools faq
paste
Advertisement
lukhavi

CLI_Incompleto

lukhavi
Nov 9th, 2019
553
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 20.76 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include<stdlib.h>
  3. #include <stdint.h>
  4. #include<string.h>  // atoi
  5. #include<time.h>
  6. #include "parser.h"
  7.  
  8. /*
  9.     Ingresar opcion de tipo de archivo y nombre de archivo que queremos obtener
  10.     relleno con un vector de n datos    
  11. */
  12.  
  13. /*
  14.     -t ----> .txt
  15.     -c ----> .csv
  16.     -d ----> .dat
  17.    
  18.     programa.exe -/[options] -/n [tamanio vector] {-/i[value] -/s [value] -/o [archivo_salida.[txt/csv/dat]]}
  19.    
  20.     Programa.exe -t
  21.     Programa.exe -c
  22.     Programa.exe -d
  23.     Programa.exe -t -c
  24.     Programa.exe -c -t
  25.     Programa.exe -t -d
  26.     Programa.exe -d -t
  27.     Programa.exe -d -c
  28.     programa.exe -c -d 
  29.     programa.exe -t -c -d
  30.     programa.exe -t -d -c
  31.     programa.exe -c -t -d
  32.     programa.exe -c -d -t
  33.     programa.exe -d -c -t
  34.     programa.exe -d -t -c
  35.     programa.exe -tc
  36.     programa.exe -ct
  37.     programa.exe -td
  38.     programa.exe -dt
  39.     programa.exe -cd
  40.     programa.exe -dc
  41.     Programa.exe -tcd
  42.     Programa.exe -tdc
  43.     programa.exe -ctd
  44.     programa.exe -cdt
  45.     Programa.exe -dtc
  46.     programa.exe -dct
  47.    
  48.    
  49.     Opcionales:
  50.         programa.exe -h
  51.         programa.exe --help
  52.        
  53.         programa.exe -v
  54.         programa.exe --version
  55.        
  56.        
  57.         *** Ver caso cuando no ingresamos un numero en la ubicacion de numeros
  58. */
  59.  
  60.  
  61. #define MAX_LENGHT_DEFAULT 1000L
  62. #define MAX_VECTOR_DEFAULT MAX_LENGHT_DEFAULT
  63. #define MIN_VECTOR_DEFAULT 0L
  64.  
  65.  
  66. FILE *fileOutput = NULL;
  67.  
  68. int main(int argc, char **argv){
  69.    
  70.     int _argc = argc;
  71.    
  72.     int k;
  73.     for(k = 0;_argc>0;_argc--,k++)
  74.         printf("argv[%d] = %s\n",k,argv[k]);
  75.        
  76.     _argc = argc;
  77.    
  78.    
  79.     uint8_t txt,csv,dat,ene,min,Max, ene_min,emeOffEne,maxOffMin, min_max,outputFile;
  80.     txt = csv = dat = ene = min = Max = ene_min = min_max = outputFile = false;
  81.     emeOffEne = maxOffMin = true;
  82.     long lenghtVector = MAX_LENGHT_DEFAULT;
  83.     long maxVector = MAX_VECTOR_DEFAULT;
  84.     long minVector = MIN_VECTOR_DEFAULT;
  85.     long value;
  86.     int files = 0;
  87.     int n, nptos,ncharfile;
  88.     const char *namesFilesOutput[3] = {NULL};
  89.     ///char *formato[] = {".txt",".csv",".dat"};
  90.     int lockTDC = true;
  91.    
  92.     Format f_txt = {'t','x','t',{"xt","t"},{"t","tx","txt"},".txt"};
  93.     Format f_csv = {'c','s','v',{"sv","v"},{"c","cs","csv"},".csv"};
  94.     Format f_dat = {'d','a','t',{"at","t"},{"d","da","dat"},".dat"};
  95.    
  96.     if(_argc <2)
  97.         printf("Se crea vector por defecto,formato txt, Mil datos aleatorios entre 0 y 1000\n");
  98.        
  99.     int i = 1,j = 1;
  100.     // lee todos los comandos
  101.     while(_argc>1 && argv[i]!=NULL){    // avanza por string
  102.         if((argv[i][0] == '-' || argv[i][0] =='/') ){  
  103.             while(argv[i][j]!='\0'){    // avanza por caracter
  104.                 switch(toupper(argv[i][j])){
  105.                     case 'T':
  106.                         if(!txt && lockTDC){
  107.                             printf("Soy t\n");
  108.                             txt = true;
  109.                         }
  110.                         else{
  111.                             if(!lockTDC){
  112.                                 printf("Valor invalido, formato debe ser asignado al principio -t -c -d v -tdc\n");
  113.                             }
  114.                             else{
  115.                                 printf("Error: -t ya fue incluido\n");
  116.                                 return EXIT_FAILURE;
  117.                             }
  118.                         }
  119.                         break;
  120.                     case 'C':
  121.                         if(!csv && lockTDC){
  122.                             csv = true;
  123.                             printf("Soy c\n");
  124.                         }
  125.                         else{
  126.                             if(!lockTDC){
  127.                                 printf("Valor invalido, formato debe ser asignado al principio -t -c -d v -tdc\n");
  128.                            
  129.                             }
  130.                             else{
  131.                                 printf("Error: -c ya fue incluido\n");
  132.                                 return EXIT_FAILURE;
  133.                             }
  134.                         }
  135.                         break;
  136.                     case 'D':
  137.                         if(!dat && lockTDC){
  138.                             dat = true;
  139.                             printf("Soy d\n");
  140.                         }else{
  141.                             if(!lockTDC){
  142.                                 printf("Valor invalido, formato debe ser asignado al principio -t -c -d v -tdc\n");
  143.                            
  144.                             }else{
  145.                                 printf("Error: -d ya fue incluido\n");
  146.                                 return EXIT_FAILURE;
  147.                             }
  148.                         }
  149.                         break;
  150.                     case 'N':
  151.                         if(!ene){
  152.                             if(txt || csv || dat){
  153.                                 printf("Soy n\n");
  154.                                 ene = true;
  155.                                 lockTDC = false;    // deshabilita -t -c -d
  156.                             }
  157.                             else{
  158.                                 printf("*** Error1: Uso equivocado: file -[opcion] -n ***\n");
  159.                                 return EXIT_FAILURE;
  160.                             }
  161.                         }
  162.                         else{
  163.                             printf("Error: -n ya fue incluido\n");
  164.                             return EXIT_FAILURE;
  165.                         }
  166.                         break;
  167.                     case 'I':
  168.                         if(ene_min){
  169.                             if(!min){
  170.                                 min = true;
  171.                                 emeOffEne = false;  // apaga ene
  172.                                 printf("Soy min\n");
  173.                             }
  174.                             else{
  175.                                 printf("Error: -i ya fue incluido\n");
  176.                                 return EXIT_FAILURE;
  177.                             }
  178.                         }
  179.                         else{
  180.                             printf("Error: Debe ingresar un numero de iteraciones primero (>0)\n");
  181.                             return EXIT_FAILURE;
  182.                         }
  183.                         break;
  184.                     case 'S':
  185.                         if(min_max){
  186.                             if(!Max){
  187.                                 Max = true;
  188.                                 maxOffMin = false;
  189.                                 printf("Soy el Max\n");
  190.                             }
  191.                             else{
  192.                                 printf("Error: -s ya fue incluido\n");
  193.                                 return EXIT_FAILURE;
  194.                             }
  195.                         }
  196.                         else {
  197.                             printf("Error: Primero debe ingresar el valor minimo del vector (>0)\n");
  198.                             return EXIT_FAILURE;
  199.                         }
  200.                         break;
  201.                     case 'O':
  202.                         if(ene_min || Max){
  203.                             outputFile = true;
  204.                             printf("Soy el -O\n");
  205.                         }
  206.                         else {
  207.                             printf("Debe especificar al menos el formato de salida -t, -c o -d -n iteraciones -o\n");
  208.                             return EXIT_FAILURE;
  209.                         }
  210.                         break;  
  211.                     default:
  212.                         printf("*** Error2: Uso equivocado: file -t -n ***\n");
  213.                         return EXIT_FAILURE;
  214.                 }
  215.                 j++;
  216.             }
  217.             if((argv[i][0] == '-' || argv[i][0]=='/') && argv[i][1]=='\0'){ // caso '-' v '/' solito antes de -algo
  218.                 printf("***ErrorX: Uso equivocado file -t -n \n"); 
  219.                 return EXIT_FAILURE;
  220.             }
  221.             i++;
  222.         }
  223.         else{
  224.             printf("*** Error3: Uso equivocado: file -t -d -c ***\n");
  225.             return EXIT_FAILURE;
  226.         }
  227.        
  228.        
  229.        
  230.        
  231.        
  232.        
  233.        
  234.        
  235.         if(argv[i]){    // existe un string a continuacion de [Opcion]
  236.             if(ene || min || Max){
  237.                 if(esUnNumero(argv[i]) && !outputFile ){    // si el string es numerico v -o
  238.                     value = atoi(argv[i]);
  239.                     if(ene && emeOffEne ){  // argv[i] es el siguiente de -n i.e. el numero de iteraciones 
  240.                         if(value>0){
  241.                             lenghtVector = value;
  242.                             printf("Tamanio vector: %d: argc =%d\n",lenghtVector,_argc);
  243.                             ene_min = true; // Habilita -m
  244.                             //ene = false;
  245.                         }
  246.                         else if(value<0){
  247.                             lenghtVector = -value;
  248.                             ene_min = true;
  249.                         }
  250.                         else{
  251.                             printf("Numero de iteraciones tiene que ser entero positivo\n");
  252.                             return EXIT_FAILURE;   
  253.                         }    
  254.                             i++;
  255.                             _argc--;
  256.                     }else if(min && maxOffMin){         // argv[i] es minValorVector siguiente a -m
  257.                         minVector = value;
  258.                         printf("Minimo vector: %d: argc =%d\n",minVector,_argc);
  259.                         min_max = true;     // habilita -M
  260.                         //min_Max = true;
  261.                         i++;
  262.                         _argc--;
  263.                     }
  264.                     else if(Max){           // argv[i] es maxValorVector siguiente a -M
  265.                         if(value>minVector){
  266.                             maxVector = value;
  267.                             printf("Tope valor del vector: %d: argc =%d\n",maxVector,_argc);
  268.                             i++;
  269.                             _argc--;   
  270.                         }
  271.                         else{
  272.                             printf("Tope del vector debe ser mayor al limite inferior %d\n",minVector);
  273.                             return EXIT_FAILURE;
  274.                         }
  275.                     }  
  276.                 }
  277.                 else if(outputFile){        // se conforman los nombres finales
  278.                     files = (txt<<0) | (csv<<1) | (dat<<2);
  279.                     if(argv[i]){    // existe un argumento siguiente de -o
  280.                         n = nPunct(argv[i],&nptos,&ncharfile); 
  281.                         printf("Numero de signos de puntuacion %d\n",n);
  282.                         switch(files){
  283.                             case 1:     // txt
  284.                                 namesFilesOutput[0] = revisorN(argv[i],n,f_txt,ncharfile,nptos);
  285.                                 if(namesFilesOutput[0] == NULL){
  286.                                     printf("Error: Nombre de archivo no generado\n");
  287.                                     return EXIT_FAILURE;
  288.                                 }
  289.                                 printf("Soy el fichero final****: %s\n",namesFilesOutput[0]);
  290.                        
  291.                                 i++;
  292.                                 //return EXIT_SUCCESS;
  293.                                 break;
  294.                             case 2:     // csv
  295.                                 namesFilesOutput[1] = revisorN(argv[i],n,f_csv,ncharfile,nptos);
  296.                                 if(namesFilesOutput[1] == NULL){
  297.                                     printf("Error: Nombre de archivo no generado\n");
  298.                                     return EXIT_FAILURE;
  299.                                 }
  300.                                 printf("Soy el fichero final: %s\n",namesFilesOutput[1]);
  301.                                 i++;
  302.                                 //return EXIT_SUCCESS;
  303.                                 break;
  304.                             case 4:     // dat
  305.                                 namesFilesOutput[2] = revisorN(argv[i],n,f_dat,ncharfile,nptos);
  306.                                 if(namesFilesOutput[2] == NULL){
  307.                                     printf("Error: Nombre de archivo no generado\n");
  308.                                     return EXIT_FAILURE;
  309.                                 }
  310.                                 printf("Soy el fichero final: %s\n",namesFilesOutput[2]);
  311.                                 i++;
  312.                                 //return EXIT_SUCCESS;
  313.                                 break;
  314.                             case 3:     // csv && txt
  315.                                 namesFilesOutput[0] = revisorN(argv[i++],n,f_txt,ncharfile,nptos);
  316.                                 if(namesFilesOutput[0] == NULL){
  317.                                     printf("Error: Nombre de archivo no generado\n");
  318.                                     return EXIT_FAILURE;
  319.                                 }
  320.                                     printf("Soy: %s\n",namesFilesOutput[0]);
  321.                                 if(argv[i]){
  322.                                     n = nPunct(argv[i],&nptos,&ncharfile); 
  323.                                     namesFilesOutput[1] = revisorN(argv[i++],n,f_csv,ncharfile,nptos);
  324.                                     if(namesFilesOutput[1] == NULL){
  325.                                         printf("Error: Nombre de archivo no generado\n");
  326.                                         return EXIT_FAILURE;
  327.                                     }
  328.                                     printf("Soy: %s\n",namesFilesOutput[1]);
  329.                                 }else{
  330.                                     printf("Solo %s despues del -o\n",argv[i-1]);
  331.                                 }
  332.                                 break;
  333.                             case 5:     // dat && txt
  334.                                 namesFilesOutput[0] = revisorN(argv[i++],n,f_txt,ncharfile,nptos);
  335.                                 if(namesFilesOutput[0] == NULL){
  336.                                     printf("Error: Nombre de archivo no generado\n");
  337.                                     return EXIT_FAILURE;
  338.                                 }
  339.                                     printf("Soy: %s\n",namesFilesOutput[0]);   
  340.                                 if(argv[i]){
  341.                                     n = nPunct(argv[i],&nptos,&ncharfile); 
  342.                                     namesFilesOutput[2] = revisorN(argv[i++],n,f_dat,ncharfile,nptos);
  343.                                     if(namesFilesOutput[2] == NULL){
  344.                                         printf("Error: Nombre de archivo no generado\n");
  345.                                         return EXIT_FAILURE;
  346.                                     }
  347.                                     printf("Soy: %s\n",namesFilesOutput[2]);       
  348.                                 }else {
  349.                                     printf("Solo %s despues del -o\n",argv[i-1]);
  350.                                 }
  351.                                 break;
  352.                             case 6:     // csv && dat                      
  353.                                 namesFilesOutput[1] = revisorN(argv[i++],n,f_csv,ncharfile,nptos);
  354.                                 if(namesFilesOutput[1] == NULL){
  355.                                     printf("Error: Nombre de archivo no generado\n");
  356.                                     return EXIT_FAILURE;
  357.                                 }
  358.                                     printf("Soy: %s\n",namesFilesOutput[1]);   
  359.                                 if(argv[i]){
  360.                                     n = nPunct(argv[i],&nptos,&ncharfile); 
  361.                                     namesFilesOutput[2] = revisorN(argv[i++],n,f_dat,ncharfile,nptos);
  362.                                     if(namesFilesOutput[2] == NULL){
  363.                                         printf("Error: Nombre de archivo no generado\n");
  364.                                         return EXIT_FAILURE;
  365.                                     }
  366.                                     printf("Soy: %s\n",namesFilesOutput[2]);
  367.                                 }else{
  368.                                     printf("Solo %s despues del -o\n",argv[i-1]);
  369.                                 }
  370.                                 break;
  371.                             case 7:     // txt && csv && dat
  372.                                 namesFilesOutput[0] = revisorN(argv[i++],n,f_txt,ncharfile,nptos);  // txt
  373.                                 if(namesFilesOutput[0] == NULL){
  374.                                     printf("Error: Nombre de archivo no generado\n");
  375.                                     return EXIT_FAILURE;
  376.                                 }
  377.                                     printf("Soy: %s\n",namesFilesOutput[0]);   
  378.                                 if(argv[i]){
  379.                                     n = nPunct(argv[i],&nptos,&ncharfile); 
  380.                                     namesFilesOutput[1] = revisorN(argv[i++],n,f_csv,ncharfile,nptos);  // csv
  381.                                     if(namesFilesOutput[1] == NULL){
  382.                                         printf("Error: Nombre de archivo no generado\n");
  383.                                         return EXIT_FAILURE;
  384.                                     }
  385.                                     printf("Soy: %s\n",namesFilesOutput[1]);
  386.                                     if(argv[i]){
  387.                                         n = nPunct(argv[i],&nptos,&ncharfile); 
  388.                                         namesFilesOutput[2] = revisorN(argv[i++],n,f_dat,ncharfile,nptos);  // dat
  389.                                         if(namesFilesOutput[2] == NULL){
  390.                                             printf("Error: Nombre de archivo no generado\n");
  391.                                             return EXIT_FAILURE;
  392.                                         }
  393.                                         printf("Soy: %s\n",namesFilesOutput[2]);
  394.                                     }else{
  395.                                         printf("Solo dos nombres:\n");
  396.                                        
  397.                                     }
  398.                                    
  399.                                 }else{
  400.                                     printf("Solo %s despues del -o\n",argv[i-1]);
  401.                                 }
  402.                                 break;
  403.                             default:
  404.                                 printf("Error:Valor no esperado\n");
  405.                                 return EXIT_FAILURE;           
  406.                         }
  407.                     }// fin if outputfile
  408.                     else {
  409.                         printf("No hay nombres de archivos despues de -o\n");
  410.                     }
  411.                 }//  fin if argv[i]
  412.                 else{
  413.                     printf("Error: Ingrese un valor numerico\n");
  414.                     return EXIT_FAILURE;
  415.                 }
  416.             }
  417.         }
  418.         _argc--;
  419.         j = 1;
  420.    
  421.         if(argv[i]==NULL)
  422.             printf("Terminando...\n");
  423.     } // fin while principal
  424.    
  425.    
  426.     // Procesamiento de todos los datos recopilados
  427.     char *nameFileDefault[] = {"FileTxtDefault.txt","FileCsvDefault.csv","FileDatDefault.dat"};
  428.     int error = false;
  429.     Data d = {lenghtVector,minVector,maxVector};
  430.    
  431.     if(argc == 1){
  432.         //lenghtVector = MAX_LENGHT_DEFAULT;
  433.         //minVector = MIN_VECTOR_DEFAULT;           // limite valores del vector por defecto
  434.         //maxVector = MAX_VECTOR_DEFAULT;                          
  435.         namesFilesOutput[0] = nameFileDefault[0];
  436.         writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  437.     }else {
  438.         printf("files:%d\n",files); // files existe solo si {ponemos -o CualquierNombreDeArchivo}
  439.         //_lenghtVector = lenghtVector;
  440. //      _minVector = minVector;
  441. //      _maxVector = maxVector;
  442.        
  443.    
  444.        
  445.         switch(files){
  446.             case 0:     // no entró a -o          
  447.                 switch((txt<<0) | (csv<<1) | (dat<<2)){
  448.                     case 1: // txt
  449.                         namesFilesOutput[0] = nameFileDefault[0];
  450.                         writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  451.                         break; 
  452.                     case 2: // csv
  453.                         namesFilesOutput[1] = nameFileDefault[1];
  454.                         writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);
  455.                         break;
  456.                     case 4: // dat
  457.                         namesFilesOutput[2] = nameFileDefault[2];
  458.                         writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);
  459.                         break;
  460.                     case 3: // csv && txt
  461.                         namesFilesOutput[0] = nameFileDefault[0];   // name txt
  462.                         writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  463.                         namesFilesOutput[1] = nameFileDefault[1];   // name csv
  464.                         writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);
  465.                         break;
  466.                     case 5: // dat && txt
  467.                         namesFilesOutput[0] = nameFileDefault[0];   // name txt
  468.                         writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  469.                         namesFilesOutput[2] = nameFileDefault[2];   // name dat
  470.                         writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);
  471.                         break;
  472.                     case 6: // csv && dat
  473.                         namesFilesOutput[1] = nameFileDefault[1];   // name csv
  474.                         writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);
  475.                         namesFilesOutput[2] = nameFileDefault[2];   // name dat
  476.                         writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);
  477.                         break;
  478.                     case 7:
  479.                         namesFilesOutput[0] = nameFileDefault[0];   // name txt
  480.                         writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  481.                         namesFilesOutput[1] = nameFileDefault[1];   // name csv
  482.                         writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);
  483.                         namesFilesOutput[2] = nameFileDefault[2];   // name dat
  484.                         writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);
  485.                         break;
  486.                     default:
  487.                         printf("Error: Valor no esperado");
  488.                         return EXIT_FAILURE;   
  489.                 }
  490.                
  491.                 break;
  492.             case 1: // despues del -o   // solo txt
  493.                 //printf("ESTOYYYYYYYYYYYYY\n");
  494.                 if(namesFilesOutput[0]==NULL)
  495.                     namesFilesOutput[0] = nameFileDefault[0];
  496.                 writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);  
  497.                 break;
  498.             case 2: // solo csv
  499.                 if(namesFilesOutput[1]==NULL)
  500.                     namesFilesOutput[1] = nameFileDefault[1];  
  501.                 writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);      
  502.                 break;
  503.             case 3:// csv && txt
  504.                 if(namesFilesOutput[0]==NULL)
  505.                     namesFilesOutput[0] = nameFileDefault[0];
  506.                 writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  507.                 if(namesFilesOutput[1]==NULL)
  508.                     namesFilesOutput[1] = nameFileDefault[1];  
  509.                 writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);      
  510.                 break;
  511.             case 4: // dat
  512.                 if(namesFilesOutput[2]==NULL)
  513.                     namesFilesOutput[2] = nameFileDefault[2];
  514.                 writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);  
  515.                 break;
  516.             case 5: // dat && txt
  517.                 if(namesFilesOutput[0]==NULL)
  518.                     namesFilesOutput[0] = nameFileDefault[0];
  519.                 writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  520.                 if(namesFilesOutput[2]==NULL)
  521.                     namesFilesOutput[2] = nameFileDefault[2];
  522.                 writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);
  523.                 break;
  524.             case 6: // csv && dat
  525.                 if(namesFilesOutput[1]==NULL)
  526.                     namesFilesOutput[1] = nameFileDefault[1];
  527.                 writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);
  528.                 if(namesFilesOutput[2]==NULL)
  529.                     namesFilesOutput[2] = nameFileDefault[2];
  530.                 writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);
  531.                 break;
  532.             case 7: // txt && csv && dat
  533.                 if(namesFilesOutput[0]==NULL)
  534.                     namesFilesOutput[0] = nameFileDefault[0];
  535.                 writeFileOutput(argc,argv,namesFilesOutput[0],fileOutput,&d);
  536.                 if(namesFilesOutput[1]==NULL)
  537.                     namesFilesOutput[1] = nameFileDefault[1];
  538.                 writeFileOutput(argc,argv,namesFilesOutput[1],fileOutput,&d);
  539.                 if(namesFilesOutput[2]==NULL)
  540.                     namesFilesOutput[2] = nameFileDefault[2];
  541.                 writeFileOutput(argc,argv,namesFilesOutput[2],fileOutput,&d);
  542.                 break;
  543.             default:
  544.                 printf("Error: Valor no esperado");
  545.                 return EXIT_FAILURE;
  546.         }
  547.        
  548.     }
  549.    
  550.    
  551.     return 0;
  552. }
  553.  
  554.  
  555.  
  556.  
  557.  
  558. void writeFileOutput(int argc, char *argv[],const char *nameFileOutput,FILE * outFile, Data *d){
  559.    
  560.     int *dataVec;
  561.     fileOutput = fopen(nameFileOutput,"w");
  562.     if(!fileOutput){
  563.         fputs ("Error: Archivo no puede ser abierto\n",stderr);
  564.     }
  565.     dataVec = requestMemory(d);
  566.     if(strstr(nameFileOutput,".txt"))
  567.         writeTxt(argc,argv,dataVec,d);  //creamos .txt
  568.     else if(strstr(nameFileOutput,".csv"))
  569.         writeCsv(argc,argv,dataVec,d);  // creamos .csv
  570.     else if(strstr(nameFileOutput,".dat")){
  571.         writeDat(argc,argv,dataVec,d);  // creamos .dat
  572.     }
  573.     else // error
  574.         printf("Error\n");
  575. }
  576.  
  577.  
  578. /*  El archivo txt contendra lo siguiente:
  579.     // comando aplicado: <programa> <opciones> <basenombrearchivo>
  580.     #ifndef __VECTOR_BENCHMARK_H__
  581.     #define __VECTOR_BENCHMARK_H__
  582.    
  583.     #define lenghtVector xxxxxx
  584.     // minVector = ValorMinimo
  585.     // maxVector = ValorMaximo
  586.    
  587.     int vectorOutput[lengthVector] = { valor0, valor1,... valor15
  588.    
  589.    
  590.                                                         };
  591.     //
  592.    
  593.     #endif // end __VECTOR_BENCHMARK_H__
  594. */
  595.  
  596.  
  597. void writeTxt(int argc, char *argv[], int * v,Data *d){
  598.    
  599.     printCommand(argc,argv);
  600.     fprintf(fileOutput,"%s\n","#ifndef __VECTOR_BENCHMARK_H__");
  601.     fprintf(fileOutput,"%s\n","#define __VECTOR_BENCHMARK_H__");
  602.     fprintf(fileOutput,"%s %d\n\n","#define lenghtVector",d->lenght);
  603.    
  604.     fprintf(fileOutput,"%s = %d\n","// limInferior ",d->min);
  605.     fprintf(fileOutput,"%s = %d\n","// limSuperior ",d->max);
  606.    
  607.     fprintf(fileOutput,"%s","\n\nstatic int vectorBenchmark[lenghtVector] = \n{\n");
  608.     int i;
  609.     fprintf(fileOutput,"%s","   ");
  610.    
  611.     for(i = 0; i<d->lenght;i++){
  612.         if(i%15 == 0 && i!=0)       // revisar modulo generalizado
  613.             fprintf(fileOutput,"\n   ");
  614.         if(i == d->lenght-1)
  615.             fprintf(fileOutput,"%d",v[i]);
  616.         else
  617.             fprintf(fileOutput,"%d,",v[i]);
  618.     }
  619.     fprintf(fileOutput,"%s","\n};\n\n");
  620.     fprintf(fileOutput,"%s","#endif // end __VECTOR_BENCHMARK_H__");
  621.    
  622.    
  623. }
  624.  
  625. void writeCsv(int argc, char *argv[], int *v, Data *d){
  626.     int i = 0;
  627.     fprintf(fileOutput,"%s","ValuesVector\n");
  628.     fprintf(fileOutput,"%d",v[i]);
  629.    
  630.     for(i = 1; i<d->lenght;i++){
  631.         if(i%15 == 0)
  632.             fprintf(fileOutput,"\n%d",v[i]);
  633.         else
  634.             fprintf(fileOutput,",%d",v[i]);    
  635.     }
  636.    
  637. }
  638.  
  639. void writeDat(int argc, char *argv[],int *v,Data *d){
  640.     printCommand(argc,argv);
  641.     fprintf(fileOutput,"%s","\n\nstatic int vectorBenchmark[");
  642.     fprintf(fileOutput,"%d",d->lenght);
  643.     fprintf(fileOutput,"%s","] = \n{\n");
  644.    
  645.     int i;
  646.     fprintf(fileOutput,"%s","   ");
  647.    
  648.     for(i = 0; i<d->lenght;i++){
  649.         if(i%15 == 0 && i!=0)       // revisar modulo generalizado
  650.             fprintf(fileOutput,"\n   ");
  651.         if(i == d->lenght-1)
  652.             fprintf(fileOutput,"%d",v[i]);
  653.         else
  654.             fprintf(fileOutput,"%d,",v[i]);
  655.     }
  656.     fprintf(fileOutput,"%s","\n};\n\n");
  657.    
  658.    
  659. }
  660.  
  661. void printCommand(int argc, char *argv[]){
  662.     int i;
  663.     fprintf(fileOutput,"// Comando aplicado: ");
  664.     for(i = 0;i<argc;i++)
  665.         fprintf(fileOutput,"%s ",argv[i]);
  666.     fprintf(fileOutput,"\n\n");
  667. }
  668.  
  669. int *requestMemory(Data *d){
  670.     int i;
  671.     srand((unsigned)time(NULL));        // marca semilla
  672.    
  673.     int *vectorData = (int *)malloc((d->lenght)*sizeof(int));
  674.     for(i = 0;i<d->lenght;i++)
  675.         vectorData[i] = d->min + rand()%(d->max + 1 -d->min );      //vector aleatorio
  676.     return vectorData;
  677. }
  678.  
  679.  
  680.  
  681. int esUnNumero(const char *argv){
  682.     if(*argv == '-'){
  683.         if(*(argv+1)>=  '0' && *(argv+1)<='9'){ // si es digito negativo
  684.             //printf("%c\n",*(argv + 1));
  685.             return true;
  686.         }else
  687.             return  false;     
  688.     }else if(*argv  == '0'){   
  689.         return true;
  690.     }
  691.     else if(isdigit(*argv)){
  692.         //printf("%c\n",*argv);
  693.         return true;
  694.     }
  695.     else
  696.         return false;
  697. }
  698.  
  699. int nPunct(const char *str,int *ptos, int *nchar){
  700.     const char *pstr;
  701.     int countPunct = 0;
  702.     for(*nchar = 0,*ptos = 0,pstr = str;*pstr!='\0';pstr++,(*nchar)++){
  703.         if(ispunct(*pstr)){         // revisar tipo dato ispunct
  704.             countPunct++;
  705.             if(*pstr == '.')
  706.                 (*ptos)++;
  707.         }  
  708.     }
  709.     printf("caracteres %d\n",*nchar);
  710.     return countPunct;
  711. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!