home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 12 / MA_Cover_12.iso / internet / freedomc_112 / sourcecode / freedomcall / surround.h < prev   
Encoding:
C/C++ Source or Header  |  1999-05-25  |  67.8 KB  |  2,559 lines
  1. /*
  2.  
  3.  *-------------------------------------------*
  4.   SuRRouND.H Include to C, C++
  5.   Writed by Cristian Robert Gallas (SuRRouND)
  6.   Using SASC 6.58
  7.  
  8.   Versao Atual
  9.   -------------------------------------------
  10.   V0.2 - 26.05.99 - Arrumado bug na funcao PosicaoCaracter();
  11.  
  12.   $VER: SuRRouND.h 0.2 (26.05.99)
  13.   -------------------------------------------
  14.  
  15.   History:
  16.   -------------------------------------------
  17.   V0.1 - 01.05.99 - First Public release;
  18.   -------------------------------------------
  19.  
  20.   Excuse me but all comments are in Portugues
  21.  *-------------------------------------------*
  22.  
  23. */
  24.  
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include <ctype.h>
  29. #include <math.h>
  30. #include <dos.h>
  31. #include <sys/dir.h>
  32. #include <clib/dos_protos.h>
  33. #include <proto/exec.h>
  34.  
  35. char *Arredondar(char var[256])
  36. {
  37.   /*
  38.   Esta rotina arredonda numeros.
  39.  
  40.   Versao  : 1.0
  41.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  42.   Entrada : Numero a arredondar --> 10.57 (CHAR 256)
  43.   Saida   : Numero arredondado  --> 11    (CHAR 256)
  44.             Arredondar("10.57");
  45.   */
  46.  
  47.   char teste[256];
  48.   float x = 0;
  49.   long int y = 0;
  50.   x = atof(var);
  51.   y = x;
  52.   if((x - y) > 0.5)
  53.     y++;
  54.   sprintf(teste, "%d", y);
  55.   return teste;
  56. }
  57.  
  58. char *Corta(char var[256], char delimitador, int numero) 
  59. {
  60.   /*
  61.   Comando para cortar uma variavel apartir de um delimitador e
  62.   por campo, igual ao CUT do UNIX.
  63.  
  64.   Versao  : 1.0
  65.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  66.                                        0      1      2
  67.   Entrada: A linha em questao  --> cristian:robert:gallas (CHAR 256)
  68.            o delimitador       --> : (CHAR 1)
  69.            e o numero do campo --> 1 (INT)
  70.   Saida  : O campo retirado    --> robert (CHAR 256)
  71.   Erro   : "" (CHAR 256)
  72.            Corta("cristian:robert:gallas", ':' 1);
  73.   */
  74.  
  75.   char teste[256];
  76.   int x, y = 0, z = 0, h = 0;
  77.   for(x = 0; x <= strlen(var); x++)
  78.   {
  79.     teste[y++] = var[x];
  80.     if(var[x] == delimitador || var[x] == '\0' || var[x] == '\n')
  81.     {
  82.       
  83.       if(z++ >= numero) {
  84.         teste[--y] = '\0'; h = 1;
  85.         break; } else {
  86.         teste[0] = '\0'; y = 0; }
  87.       if(var[x] == '\0' || var[x] == '\n')
  88.         break;
  89.     }
  90.   }
  91.   teste[y] = '\0';
  92.   if(h == 0)
  93.     strcpy(teste, "CUTERRO");
  94.   return teste;
  95. }
  96.  
  97. char *ArrumaDataHora(char var[256], char caracter)
  98. {
  99.   /*
  100.   Este comando corrige o formato da data, acrescentando o zero
  101.   nos campos em que forem menor que 2.
  102.  
  103.   Versao  : 1.0
  104.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  105.   Entrada : Hora Completa --> 1:10:6 (CHAR 256)
  106.             Delimitador   --> : (CHAR 1)
  107.   Saida   : Hora Arrumada --> 01:10:06 (CHAR 256)
  108.             ArrumaHora("1:10:6", ':');
  109.   */
  110.  
  111.   char teste[256], hor[30], min[30], seg[30];
  112.   strcpy(hor, Corta(var, caracter, 0));
  113.   strcpy(min, Corta(var, caracter, 1));
  114.   strcpy(seg, Corta(var, caracter, 2));
  115.   strcpy(teste, hor);
  116.   if(strlen(hor) < 2)
  117.     sprintf(hor, "0%s", teste);
  118.   strcpy(teste, min);
  119.   if(strlen(min) < 2)
  120.     sprintf(min, "0%s", teste);
  121.   strcpy(teste, seg);
  122.   if(strlen(seg) < 2)
  123.     sprintf(seg, "0%s", teste);
  124.   if(strcmp(seg, "CUTERRO"))
  125.     sprintf(teste, "%s%c%s%c%s", hor, caracter, min, caracter, seg);
  126.   else
  127.     sprintf(teste, "%s%c%s", hor, caracter, min);
  128.  
  129.   return teste;
  130. }
  131.  
  132. char *RetiraPontas(char var[256], int numero) 
  133. {
  134.   /*
  135.   Este comando retira as pontas da variavel passada
  136.  
  137.   Versao  : 1.0
  138.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  139.   Entrada : Linha a recortar      --> Cristian Gallas (CHAR 256)
  140.             Caracteres a recortar --> 1 (INT)
  141.   Saida   : A linha recortada     --> ristian Galla (CHAR 256)
  142.             RetiraPontas("Cristian Gallas", 1);
  143.   */
  144.  
  145.   char teste[256];
  146.   int x = 0, y = 0; 
  147.   if(strlen(var) < 2)
  148.     return "";
  149.   for(x = numero; x < (strlen(var) - numero); x++)
  150.     teste[y++] = var[x];
  151.  
  152.   teste[y] = '\0';
  153.   return teste;
  154. }
  155.  
  156. char *HoraSegundo(char var[256])
  157. {
  158.   /*
  159.   Este comando recebe uma hora e retorna em segundos
  160.  
  161.   Versao  : 1.0
  162.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  163.   Entrada : Hora:Minutos:Segundos --> 24:59:59 (CHAR 256)
  164.   Saida   : Em Segundos           --> 24234 (LONG)
  165.             HoraSegundo("24:59:59");
  166.   */
  167.  
  168.   char teste[256], hora[50], minutos[50], segundos[50];
  169.   long total;
  170.  
  171.   strcpy(hora,     Corta(var, ':', 0));
  172.   strcpy(minutos,  Corta(var, ':', 1));
  173.   strcpy(segundos, Corta(var, ':', 2));
  174.  
  175.   total = ((atoi(hora) * 3600) + (atoi(minutos) * 60) + atoi(segundos));
  176.   sprintf(teste, "%ld", total);
  177.   return teste;
  178. }
  179.  
  180. char *SegundoHora(char var[256])
  181. {
  182.   /*
  183.   Este comando recebe em segundos e retorna uma hora completa
  184.   
  185.   Versao  : 1.0
  186.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  187.   Entrada : Segundos      --> 456545 (CHAR 256)
  188.   Saida   : Hora Completa --> 24:59:59 (CHAR 256)
  189.             SegundoHora("456545");
  190.   */
  191.  
  192.   char teste[256];
  193.   float total;
  194.   int hor, min, seg;
  195.  
  196.   total = atof(var) / 3600;
  197.   sprintf(teste, "%f", total);
  198.   hor = atoi(Corta(teste, '.', 0));
  199.  
  200.   total = (total - hor) * 60;
  201.   sprintf(teste, "%f", total);
  202.   min = atoi(Corta(teste, '.', 0));
  203.  
  204.   total = (total - min) * 60;
  205.   sprintf(teste, "%f", total);
  206.   seg = atoi(Corta(teste, '.', 0));
  207.  
  208.   sprintf(teste, "%d:%d:%d", hor, min, seg);
  209.   strcpy(teste, ArrumaDataHora(teste, ':'));
  210.   return teste;
  211. }
  212.  
  213. char *IntervaloHora(char var1[256], char var2[256])
  214. {
  215.   /*
  216.   Este comando recebe duas horas "em segundo" e retorna
  217.  
  218.   Versao  : 1.0
  219.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  220.   Entrada : Hora 1 "Em segundo"  --> 12345 (CHAR 256)
  221.             Hora 2 "Em segundo"  --> 54321 (CHAR 256)
  222.   Saida   : Diferenca em Segundo --> 41976 (CHAR 256)
  223.             IntervaloHora("12345", "54321");
  224.   */
  225.  
  226.   char teste[256];
  227.   long total;
  228.  
  229.   total = atoi(var1) - atoi(var2);
  230.  
  231.   if (total < 0)
  232.     total = (total * (-1));
  233.  
  234.   sprintf(teste, "%ld", total);
  235.   return teste;
  236. }
  237.  
  238. int PosicaoCaracter(char var[256], char caracter, int numero)
  239. {
  240.   /*
  241.   Este comando procura dentro de uma string um determinado 
  242.   CARACTER, e devolve sua posicao no string, sempre sera passado
  243.   a primeira ocorrencia partindo da posicao inicial de 1
  244.  
  245.   Versao  : 1.1
  246.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  247.   Entrada : String   --> Cristian Robert Gallas (CHAR 256)
  248.             Caracter --> o (CHAR 1)
  249.             Numero   --> 2 (INT)
  250.   Obs     : O Numero eh o numero de ocorrencias na string. 
  251.             No caso de 2 sera pego a posicao do segundo caracter
  252.             encontrado.
  253.             Se o caracter nao for encontrado retorna 0;
  254.   Saida   : Posicao  --> 11 (INT)
  255.             PosicaoCaracter("Cristian Robert Gallas", 'o', 2);
  256.   */
  257.  
  258.   int x = 0, y = 0;
  259.   for(x = 0; x < strlen(var); x++)
  260.   {
  261.     if(caracter == var[x])
  262.     {
  263.       y++;
  264.       if(y >= numero)
  265.         return ++x;
  266.     }
  267.   }
  268.   return 0;
  269. }
  270.  
  271. char *HoraFrase(char var[256])
  272. {
  273.   /*
  274.   Este comando recebe uma hora e transforma em uma frase
  275.  
  276.   Versao  : 1.0
  277.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  278.   Entrada : Hora completa --> 24:59:59 (CHAR 256)
  279.   Saida   : Frase    --> 24 hours, 59 seconds and 50 minutes (CHAR 256)
  280.             HoraFrase("24:59:59);
  281.   */
  282.  
  283.   char teste[256], hor[5], min[5], seg[5];
  284.  
  285.   strcpy(hor, Corta(var, ':', 0));
  286.   strcpy(min, Corta(var, ':', 1));
  287.   strcpy(seg, Corta(var, ':', 2));
  288.  
  289.   sprintf(teste, "%s hours, %s minutes and %s seconds", hor, min, seg);
  290.   return teste;
  291. }
  292.  
  293. char *DiaJuliano(char var[256])
  294. {
  295.   /*
  296.   Este comando recebe uma data e retorna seu dia juliano
  297.  
  298.   Versao  : 1.0
  299.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  300.   Entrada : Dia.Mes.Ano --> 24.05.1997 (CHAR 256)
  301.   Saida   : Dia Juliano --> 354555 (CHAR 256)
  302.             DiaJuliano("24.05.1997");
  303.   */
  304.  
  305.   char teste[256];
  306.   float x = 0, ano = 0, Aux = 0;
  307.   int dia = 0, mes = 0;
  308.   dia = atoi(Corta(var, '.', 0));
  309.   mes = atoi(Corta(var, '.', 1));
  310.   ano = atoi(Corta(var, '.', 2));
  311.   Aux = ((ano - 1) / 4) + ((ano - 1) * 365) + dia;
  312.   switch (mes) 
  313.   {
  314.        case 2: Aux = Aux + 31; break;
  315.        case 3: Aux = Aux + 59; break;
  316.        case 4: Aux = Aux + 90; break;
  317.        case 5: Aux = Aux + 120; break;
  318.        case 6: Aux = Aux + 151; break;
  319.        case 7: Aux = Aux + 181; break;
  320.        case 8: Aux = Aux + 212; break;
  321.        case 9: Aux = Aux + 243; break;
  322.       case 10: Aux = Aux + 273; break;
  323.       case 11: Aux = Aux + 304; break;
  324.       case 12: Aux = Aux + 334; break;
  325.   }
  326.   x = fmod(ano, 4.0);
  327.   if((x == 0) && (mes > 2))
  328.      Aux++;
  329.   sprintf(teste, "%f", Aux);
  330.   return teste;
  331. }
  332.  
  333. char *DiferencaDias(char var1[256], char var2[256])
  334. {
  335.   /*
  336.   Este comando retorna os dias e a diferenca em segundos dos dias
  337.  
  338.   Versao  : 1.0
  339.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  340.   Entrada : Dia.Mes.Ano  --> 24.05.1997 (CHAR 256)
  341.             Dia.Mes.Ano  --> 24.05.1997 (CHAR 256)
  342.   Saida   : Dias Intervalo e Segundos de Intervalo --> 0:0 (CHAR 256)
  343.             DiferencaDias("24.05.1997", "24.05.1997");
  344.   */
  345.  
  346.   char dia1[50], dia2[50], teste[256], dias[20];
  347.   int total;
  348.  
  349.   strcpy(dia1, DiaJuliano(var1));
  350.   strcpy(dia2, DiaJuliano(var2));
  351.  
  352.   total = atoi(dia2) - atoi(dia1);
  353.   sprintf(dias, "%d", total);
  354.   total = total * 86400;
  355.  
  356.   if(total < 0)
  357.     total = 0;
  358.  
  359.   sprintf(teste, "%s:%d", dias, total);
  360.   return teste;
  361. }
  362.  
  363. int ContaVezesCampo(char arquivo[256], char var[256], char delimitador, int numero)
  364. {
  365.   /*
  366.   Este comando retorna o total de vezes que um determinado registro
  367.   eh encontrado no arquivo.
  368.  
  369.   Versao  : 1.0
  370.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  371.   Entrada : Path+Nome do arquivo  --> dh2:tmp/miami.txt (CHAR 256)
  372.             Chave de procura      --> Me Encontre (CHAR 256)
  373.             Delimitador de campos --> , (CHAR 1)
  374.             Numero do campo       --> 2 (INT)
  375.   Saida   : O total de vezes encontrado no arquivo --> 10 (CHAR 256)
  376.   ContaVezesCampo("dh2:tmp/miami.txt", "Me Encontre", ',', 2);
  377.   */
  378.  
  379.   char teste[256], a;
  380.   int x, total;
  381.   FILE *entrada;
  382.  
  383.   if(!(entrada = fopen(arquivo, "r")))
  384.     return -1;
  385.   else 
  386.   {
  387.     x = 0; total = 0;
  388.     while(a = getc(entrada), ! feof(entrada))
  389.     {
  390.       teste[x++] = a;
  391.       if(a == '\n')
  392.       {
  393.         teste[--x] = '\0';
  394.         strcpy(teste, Corta(teste, delimitador, numero));
  395.         if(!(strcmp(var, teste)))
  396.           total++;
  397.  
  398.         teste[0] = '\0';
  399.         x = 0;
  400.       }
  401.     }
  402.     fclose(entrada);
  403.     return total;
  404.   }
  405. }
  406.  
  407. int ExisteIssoCampo(char arquivo[256], char var[256], char delimitador, int numero)
  408. {
  409.   /*
  410.   Este comando verifica se um conteudo de um determinado campo
  411.   existe ou nao, retornando 1 se sim e 0 se nao
  412.  
  413.   Versao  : 1.0
  414.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  415.   Entrada : Path,Nome do arquivo  --> dh2:tmp/miami.txt (CHAR 256)
  416.             Chave de procura      --> Me Encontre (CHAR 256)
  417.             Delimitador de campos --> , (CHAR 1)
  418.             Numero do campo       --> 2 (INT)
  419.   Saida   : Retorna 1 se existe e 0 se nao existe --> 0 (INT)
  420.             ExisteIssoCampo("dh2:tmp/miami.txt", "Me Encontre", ',', 2);
  421.   */
  422.  
  423.   char teste[256], a;
  424.   int x, sim;
  425.   FILE *entrada;
  426.  
  427.   if(!(entrada = fopen(arquivo, "r")))
  428.     return 9;
  429.   else 
  430.   {
  431.     x = 0; sim = 0;
  432.     while(a = getc(entrada), ! feof(entrada))
  433.     {
  434.       teste[x++] = a;
  435.       if(a == '\n')
  436.       {
  437.         teste[--x] = '\0';
  438.         strcpy(teste, Corta(teste, delimitador, numero));
  439.         if(!(strcmp(var, teste)))
  440.         {
  441.           sim = 1;
  442.           break;
  443.         }
  444.         teste[0] = '\0';
  445.         x = 0;
  446.       }
  447.     }
  448.     fclose(entrada);
  449.     return sim;
  450.   }
  451. }
  452.  
  453. char *Copia(char *var, int inicio, int fim) 
  454. {
  455.   /*
  456.   Este comando copia uma determinada palavra, passando como 
  457.   parametro caractere inicial e final para copia
  458.  
  459.   Entrada : Palavra           --> Cristian Robert Gallas (CHAR*)
  460.             Caracter inicial  --> 2 (INT)
  461.             Caracter Final    --> 11 (INT)
  462.   Saida   : A palavra cortada --> ristian Ro (CHAR*)
  463.             copia("Cristian Robert Gallas", 2, 11);
  464.   */
  465.  
  466.   char *teste;
  467.   int x = 0, y = 0;
  468.  
  469.   teste = malloc(strlen(var) + 1);
  470.   teste[0] = '\0';
  471.  
  472.   if(inicio < 1)
  473.     inicio = 1;
  474.   if(fim == -1)
  475.  /*   fim = (strlen(var) + 1); */
  476.     fim = 1000;
  477.  
  478.   inicio--;
  479.   for(x = inicio; x < fim; x++) 
  480.   {
  481.     if(x <= strlen(var))
  482.       teste[y++] = var[x];
  483.   }
  484.  
  485.   teste[y] = '\0';
  486.   return teste;
  487. }
  488.  
  489. int LinhasArquivo(char var[256])
  490. {
  491.   /*
  492.   Este comando conta o numero de linhas de um arquivo
  493.  
  494.   Versao  : 1.0
  495.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  496.   Entrada : Path+Nome Arquivo --> dh2:tmp/gallas.html (CHAR 256)
  497.   Saida   : Numero de linhas  --> 234 (INT)
  498.   Erro    : -1 (INT)
  499.             LinhasArquivo("dh2:tmp/gallas.html");
  500.   */
  501.  
  502.   char a;
  503.   int total = 0;
  504.   FILE *entrada;
  505.   if(!(entrada = fopen(var, "r")))
  506.     return -1;
  507.   else
  508.   {
  509.     while(a = getc(entrada), ! feof(entrada))
  510.       if(a == '\n')
  511.         total++;
  512.  
  513.     fclose(entrada);
  514.     return total;
  515.   }
  516. }
  517.  
  518. char *LinhaNumero(char var[256], int numero)
  519. {
  520.   /*
  521.   Este comando pega de um arquivo uma linha determinada linha.
  522.  
  523.   Versao  : 1.0
  524.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  525.   Entrada : Path+Nome Arquivo --> dh2:tmp/gallas.html (CHAR 256)
  526.             Linha a pegar     --> 10 (INT)
  527.   Saida   : A linha 10 do arq --> SuRRouND RuLeZ! (CHAR 256)
  528.   Erro    : ERRO (CHAR 256)
  529.             LinhaNumero("dh2:tmp/gallas.html", 10);
  530.   */
  531.  
  532.   char teste[256], a;
  533.   int x, y;
  534.   FILE *entrada;
  535.   
  536.   if(!(entrada = fopen(var, "r")))
  537.     return "ERRO";
  538.  
  539.   x = 0; y = 0;
  540.   while(a = getc(entrada), ! feof(entrada))
  541.   {
  542.     teste[x++] = a;
  543.     if(a == '\n')
  544.     {
  545.       y++;
  546.       if(y == numero) {
  547.         teste[--x] = '\0';
  548.         break;
  549.       } else {
  550.         x = 0;
  551.         teste[0] = '\0'; }
  552.     }
  553.   }
  554.   teste[x] = '\0';
  555.   fclose(entrada);
  556.   return teste;
  557. }
  558.  
  559. int ExisteArquivo(char var[256]) 
  560. {
  561.   /*
  562.   Rotina que testa se um arquivo existe.  
  563.  
  564.   Versao  : 1.0
  565.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  566.   Entrada : Path+Nome Arquivo --> dh2:tmp/gallas.txt (CHAR 256)
  567.   Saida   : True (-1) se existir e False (0) se nao existir (INT)
  568.             if(ExisteArquivo("dh2:tmp/gallas.txt"))
  569.   */
  570.  
  571.   FILE *entrada;
  572.   if(!(entrada = fopen(var, "r"))) {
  573.     fclose(entrada);
  574.     return 0;
  575.   } else {
  576.     fclose(entrada);
  577.     return -1; }
  578. }
  579.  
  580. char *SubstituiCaracter(char var[256], char caracter1, char caracter2)
  581. {
  582.   /*
  583.   Este comando substitui em uma determinada string um caracter
  584.   por outro definido na funcao.
  585.  
  586.   Versao  : 1.0
  587.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  588.   Entrada : String              --> Cristian Gallas (CHAR 256)
  589.             Caracter a procurar --> i (CHAR 1)
  590.             Substituir por      --> X (CHAR 1)
  591.   Saida   : String substituida  --> CrXstXan Gallas (CHAR 256)
  592.             SubstituiCaracter("Cristian Gallas", 'i', 'X');
  593.   */        
  594.  
  595.   char teste[256];
  596.   int x = 0, y = 0;
  597.   for(x = 0; x < strlen(var); x++)
  598.     if(var[x] == caracter1)
  599.       teste[y++] = caracter2;
  600.     else
  601.       teste[y++] = var[x];
  602.   teste[y] = '\0';
  603.   return teste;
  604. }
  605.  
  606. char *MediaCampo(char var[256], char delimitador, int numero)
  607. {
  608.   /*
  609.   Este comando faz a media de um determinado campo.
  610.  
  611.   Versao  : 1.0
  612.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  613.   Entrada : Path+Nome Arquivo --> dh2:gallas.txt (CHAR 256)
  614.             Delimitador Campo --> : (CHAR 1)
  615.             Coluna do Campo   --> 0 (INT)
  616.   Saida   : Total do Campo    --> 5465655 (CHAR 256)
  617.             Media do Campo    --> 2323 (CHAR 256)
  618.   Obs     : O separador da saida eh : ex: 5465655:2323
  619.   Erro    : ERRO (CHAR 256)
  620.             MediaCampo("dh2:gallas.txt", ':', 0);
  621.   */
  622.  
  623.   char teste[256], a;
  624.   float totallinhas = 0, total = 0;
  625.   int x = 0;
  626.   FILE *entrada;
  627.   if(!(entrada = fopen(var, "r")))
  628.     return "ERRO";
  629.   totallinhas = LinhasArquivo(var);
  630.   x = 0; total = 0;
  631.   while(a = getc(entrada), ! feof(entrada))
  632.   {
  633.     teste[x++] = a;
  634.     if(a == '\n')
  635.     {
  636.       teste[--x] = '\0';
  637.       total = total + atof(Corta(teste, delimitador, numero));
  638.       teste[0] = '\0';
  639.       x = 0;
  640.     }
  641.   }
  642.   fclose(entrada);
  643.   sprintf(teste, "%f:%f", total, (total / totallinhas));
  644.   return teste;
  645. }
  646.  
  647. char *AposCaracter(char var[256], char caracter, int numero)
  648. {
  649.   /* 
  650.   Este comando separa uma string apartir de um caracter especifico
  651.   e ainda aceita um numero que serve de pulo apos o caracter espec.
  652.  
  653.   Versao  : 1.0
  654.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  655.   Entrada : String   --> Cristian Robert Gallas (CHAR 256)
  656.             Caracter --> t (CHAR 1)
  657.             Numero   --> 1 (INT)
  658.   Saida   : A String apos o caracter --> ian Robert Gallas (CHAR 256)
  659.   Obs     : Se o Numero fosse 2      --> an Robert Gallas (CHAR 256)
  660.             Se o Numero fosse 3      --> n Robert Gallas (CHAR 256)
  661.             AposCaracter("Cristian Robert Gallas", 't', 1);
  662.   */
  663.  
  664.   char teste[256];
  665.   int x = 0, y = 0, h = 0;
  666.   if(numero >= strlen(var))
  667.     numero = 0;
  668.   for(x = 0; x < strlen(var); x++)
  669.   {
  670.     if((y == 0) && (var[x] == caracter))
  671.     {
  672.       x = x + numero;
  673.       y = 1;
  674.     }
  675.     if(y == 1)
  676.       teste[h++] = var[x];
  677.   }
  678.   teste[h] = '\0';
  679.   return teste;
  680. }
  681.  
  682. int DiferencaMes(char var1[30], char var2[30])
  683. {
  684.   /*
  685.   Este comando pega a diferenca de meses entre duas datas
  686.  
  687.   Versao  : 1.0
  688.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  689.   Entrada : Data Um         --> 01.02.1997 (CHAR 30)
  690.             Data Dois       --> 01.10.1997 (CHAR 30)
  691.   Saida   : Numero de Meses --> 8 (INT)
  692.             DiferencaMes("01.02.1997", "01.10.1997");
  693.   */
  694.  
  695.   int difmes, mes1, mes2, ano1, ano2;
  696.   mes1 = atoi(Corta(var1, '.', 1));
  697.   ano1 = atoi(Corta(var1, '.', 2));
  698.   mes2 = atoi(Corta(var2, '.', 1));
  699.   ano2 = atoi(Corta(var2, '.', 2));
  700.   if (ano1 == ano2)
  701.     difmes = mes1 - mes2;
  702.   else
  703.     difmes = (mes1 - mes2) + ((ano1 - ano2) * 12); 
  704.   if(difmes < 0)
  705.     difmes = difmes * (-1);
  706.   return difmes;
  707. }
  708.  
  709. char *DeletaCaracter(char var[256], char caracter)
  710. {
  711.   /*
  712.   Este comando retira de uma string um determinado CARACTER,
  713.   retorna o string filtrado e o numero de caracter`s deletados.
  714.  
  715.   Versao  : 1.0
  716.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  717.   Entrada : String   --> Cristian Robert Gallas
  718.             Caracter --> i
  719.   Saida   : String Filtrada                --> Crstan Robert Gallas
  720.             Numero de Caracteres Deletados --> 2
  721.             DeletaCaracter("Cristian Robert Gallas", 'i');
  722.   */
  723.  
  724.   char teste[256];
  725.   int x = 0, y = 0, total = 0;
  726.   for(x = 0; x < strlen(var); x++)
  727.     if(var[x] != caracter)
  728.       teste[y++] = var[x];
  729.     else 
  730.       total++;
  731.   teste[y] = '\0';
  732.   sprintf(teste, "%s:%d", teste, total);
  733.   return teste;
  734. }
  735.  
  736. char *Copia2(char var[256], int inicio, int fim) 
  737. {
  738.   /*
  739.   Este comando copia uma determinada palavra, passando como 
  740.   parametro o numero do caractere inicial e o numero do caracter
  741.   que se vai andar apos o inicial.
  742.  
  743.   Versao  : 1.0
  744.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  745.   Entrada : Palavra           --> Cristian Robert Gallas (CHAR 256)
  746.             Caracter inicial  --> 2 (INT)
  747.             Caracter Final    --> 6 (INT)
  748.   Saida   : A palavra cortada --> ristia (CHAR 256)
  749.             Copia2("Cristian Robert Gallas", 2, 6);
  750.   */
  751.  
  752.   char teste[256];
  753.   int x = 0, y = 0;
  754.   if(fim > 256)
  755.     fim = 256;
  756.   if(inicio < 1)
  757.     inicio = 1;
  758.   inicio--;
  759.   for(x = inicio; x < (inicio + fim); x++)
  760.     if(x <= strlen(var))
  761.       teste[y++] = var[x];
  762.   teste[y] = '\0';
  763.   return teste;
  764. }
  765.  
  766. char *Esquerda(char var[256], int numero)
  767. {
  768.   /*
  769.   Este comando recorta uma String da esquerda para direita
  770.  
  771.   Versao  : 1.0
  772.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  773.   Entrada : String               --> Cristian (CHAR 256)
  774.             Numero de Caracteres --> 6 (INT)
  775.   Saida   : String cortada       --> Cristi (CHAR 256)
  776.             Esquerda("Cristian", 6);
  777.   */
  778.  
  779.   char teste[256];
  780.   int x = 0, y = 0;
  781.   if (numero > strlen(var))
  782.     numero = strlen(var);
  783.   for(x = 0; x < numero; x++)
  784.     teste[y++] = var[x];
  785.  
  786.   teste[y] = '\0';
  787.   return teste;
  788. }
  789.  
  790. char *Direita(char var[256], int numero)
  791. {
  792.   /*
  793.   Este comando recorta uma String da direita para a esquerda
  794.  
  795.   Versao  : 1.0
  796.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  797.   Entrada : String               --> Cristian (CHAR 256)
  798.             Numero de Caracteres --> 6 (INT)
  799.   Saida   : String cortada       --> istian (CHAR 256)
  800.             Direita("Cristian", 6);
  801.   */
  802.  
  803.   char teste[256];
  804.   int x = 0, y = 0;
  805.   if (numero > strlen(var))
  806.     numero = strlen(var);
  807.   for(x = (strlen(var) - numero); x < strlen(var); x++)
  808.     teste[y++] = var[x];
  809.  
  810.   teste[y] = '\0';
  811.   return teste;
  812. }
  813.  
  814. char *PrimeiroUltimoCampo(char var[256], char caracter, int numero, char caracter2)
  815. {
  816.   /*
  817.   Este comando retira de um arquivo o primeiro e o ultimo campo
  818.   de uma determinada coluna.
  819.  
  820.   Versao  : 1.0
  821.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  822.   Entrada : Path+Nome Arquivo    --> dh2:gallas.txt (CHAR 256)
  823.             Delimitador Campo    --> : (CHAR 1)
  824.             Numero do Campo      --> 2 (INT)
  825.             Delimitador de Saida --> @ (CHAR 1)
  826.   Saida   : Campo da primeira Linha --> Gallas
  827.             Campo da ultima Linha   --> Robert
  828.   Obs     : O formato da SAIDA eh   --> Gallas:Robert (CHAR 256)
  829.   Erro    : ERRO (CHAR 256)
  830.             PrimeiroUltimoCampo("dh2:gallas.txt", ':', 2, '@');
  831.   */
  832.  
  833.   char teste[256], a, campo1[256], campo2[256]; 
  834.   int x, y;
  835.   FILE *entrada;
  836.   if(!(entrada = fopen(var, "r"))) {
  837.     fclose(entrada);
  838.     return "ERRO"; }
  839.   x = 0; y = 0;
  840.   while(a = getc(entrada), ! feof(entrada))
  841.   {
  842.     teste[x++] = a;
  843.     if(a == '\n')
  844.     {
  845.       y++;
  846.       teste[x] = '\0';
  847.       if(y == 1)
  848.         strcpy(campo1, Corta(teste, caracter, numero));
  849.       if(feof(entrada))
  850.       teste[0] = '\0'; x = 0;
  851.     }
  852.   }
  853.   fclose(entrada);
  854.   strcpy(campo2, Corta(teste, caracter, numero));
  855.   sprintf(teste, "%s%c%s", campo1, caracter2, campo2);
  856.   return teste;
  857. }
  858.  
  859. int QtdCaracter(char var[256], char caracter)
  860. {
  861.   /*
  862.   Este comando retorna o numero de caracters encontrados em uma
  863.   determinada String.
  864.  
  865.   Versao  : 1.0
  866.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  867.   Entrada : String            --> Cristian Robert Gallas (CHAR 256)
  868.             Caracter a contar --> a (CHAR 1)
  869.   Saida   : Numero de vezes   --> 3 (INT)
  870.             QtdCaracter("Cristian Robert Gallas", 'a');
  871.   */
  872.  
  873.   int x = 0, total = 0;
  874.   for(x = 0; x < strlen(var); x++)
  875.     if(caracter == var[x])
  876.   total++;
  877.   return total;
  878. }
  879.  
  880. int FiltraCampoParaArquivo(char var[256], char arq1[256], char arq2[256], char caracter, int numero, char caracter2)
  881. {
  882.   /*
  883.   Este comando filtra um determinado campo de um arquivo, e grava
  884.   outro arquivo com o conteudo igual ao argumento passado.
  885.  
  886.   Versao  : 1.0
  887.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  888.   Entrada : String a comparar     --> 01.02.1997 (CHAR 256)
  889.             Arquivo de Entrada    --> dh1:gallas.txt (CHAR 256)
  890.             Arquivo de Saida      --> dh1:filtro.txt (CHAR 256)
  891.             Delimitador do Arquivo Entrada --> , (CHAR 1)
  892.             Numero do Campo       --> 1 (INT)
  893.             Delimitador da String --> . (CHAR 1)
  894.   Saida   : Eh gerado o arquivo de saida com o conteudo da linha toda
  895.   Erro    : -1 (INT) Caso de problema de abrir arquivo entrada, saida
  896.   Obs     : Este comando foi feito para filtrar datas que seguem o
  897.             formato [XX.XX.XX] [01.02.1997], deve ser passado o deli-
  898.             mitador da data, nesse caso eh ., pode ser comparado ate
  899.             3 campos, ex: [ANO], [MES.ANO], [DIA.MES.ANO]. So 3 campos.
  900.             FiltraCampoParaArquivo("01.02.1997", "dh1:gallas.txt",
  901.                                    "dh1:filtro.txt", ',', 1, '.');
  902.   */
  903.  
  904.   char teste[256], a, mes[20];
  905.   int x, opcao;
  906.   FILE *entrada, *saida;
  907.   if(!(entrada = fopen(arq1, "r")))
  908.     return -1;
  909.   if(!(saida = fopen(arq2, "w")))
  910.     return -1;
  911.   opcao = QtdCaracter(var, caracter2);
  912.   x = 0;
  913.   while(a = getc(entrada), ! feof(entrada))
  914.   {
  915.     teste[x++] = a;
  916.     if(a == '\n')
  917.     {
  918.       teste[--x] = '\0';
  919.       if(opcao == 0)
  920.         strcpy(mes, AposCaracter(AposCaracter(Corta(teste, caracter, numero), caracter2, 1), caracter2, 1));
  921.       if(opcao == 1)
  922.         strcpy(mes, AposCaracter(Corta(teste, caracter, numero), caracter2, 1));
  923.       if(opcao == 2)
  924.         strcpy(mes, Corta(teste, caracter, numero));
  925.       if(!(strcmp(var, mes)))
  926.         fprintf(saida, "%s\n", teste);
  927.       teste[0] = '\0'; x = 0;
  928.     }
  929.   }
  930.   fclose(entrada);
  931.   fclose(saida);
  932.   return 0;
  933. }
  934.  
  935. char *MaiorMenorCampo(char arq[256], char caracter, int numero, int opcao)
  936. {
  937.   /*
  938.   Este comando abre um determinado arquivo rastreando um 
  939.   determinado campo e traz somente o maior ou o menor campo.
  940.  
  941.   Versao  : 1.0
  942.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  943.   Entrada : Path+Nome do Arquivo --> dh2:gallas.txt (CHAR 256)
  944.             Delimitador Campo    --> , (CHAR 1)
  945.             Numero do Campo      --> 1 (INT)
  946.           * Tipo de opcao        --> 0 (MENOR) e 1 (MAIOR) (INT)
  947.   Saida   : Campo Maior ou Menor --> 34,56,99,10 (CHAR 256)
  948.   Erro    : ERRO (CHAR 256) Caso o arquivo de entrada nao exista
  949.             MaiorMenorCampo("dh2:gallas.txt", ',', 1, 0);
  950.             MaiorMenorCampo("dh2:gallas.txt", ',', 1, 1);
  951.   */
  952.  
  953.   char teste[256], a, saida[256];
  954.   int x, total, conta;
  955.   FILE *entrada;
  956.   if(!(entrada = fopen(arq, "r")))
  957.     return "ERRO";
  958.   if(opcao < 0 && opcao > 1)
  959.     opcao = 0;
  960.   x = 0; total = 0; conta = 0;
  961.   while(a = getc(entrada), ! feof(entrada))
  962.   {
  963.     teste[x++] = a;
  964.     if(a == '\n')
  965.     {
  966.       teste[--x] = '\0';
  967.       ++conta;
  968.       if(conta == 1)
  969.       {
  970.         total = atoi(Corta(teste, caracter, numero));
  971.         strcpy(saida, teste);
  972.       }
  973.       if(opcao == 0)
  974.       {
  975.         if(atoi(Corta(teste, caracter, numero)) < total)
  976.         {
  977.           strcpy(saida, teste);
  978.           total = atoi(Corta(teste, caracter, numero));
  979.         }
  980.       } else {
  981.         if(atoi(Corta(teste, caracter, numero)) > total)
  982.         {
  983.           strcpy(saida, teste);
  984.           total = atoi(Corta(teste, caracter, numero));
  985.         }
  986.       }
  987.       teste[0] = '\0'; x = 0;
  988.     }
  989.   }
  990.   fclose(entrada);
  991.   if(!(strcmp(saida, "")))
  992.     strcpy(saida, LinhaNumero(arq, 1));
  993.   return saida;
  994. }
  995.  
  996. char *DataHora(int tipo)
  997. {
  998.   /*
  999.   Este comando pega o dia ou hora do sistema Operacional.
  1000.  
  1001.   Versao  : 1.0
  1002.   Compila : AmigaDos
  1003.   Entrada : Tipo de Campo --> 0 (INT)
  1004.   Obs     : Tipos [0] [DD.MM.AAAA]
  1005.                   [1] [MM.AAAA]
  1006.                   [2] [MM.DD.AAAA]
  1007.                   [3] [AAAA.DD.MM]
  1008.                   [4] [AAAA.MM.DD]
  1009.                   [5] [HH:MM:SS]
  1010.                   [6] [HH:MM]
  1011.                   [7] [HHMMSS]
  1012.   Saida   : A data Formatada  --> 30.12.1997 (CHAR 20)
  1013.             DataHora(0);
  1014.             Ou Hora Formatada --> 24:10:05 (CHAR 20)
  1015.             DataHora(4);
  1016.   */
  1017.  
  1018.   char teste[256];
  1019.   unsigned char clock[8];
  1020.   getclk(clock);
  1021.   switch (tipo) 
  1022.   {
  1023.     case 0: sprintf(teste, "%d.%d.%d", clock[3], clock[2], (1980 + clock[1])); return ArrumaDataHora(teste, '.');
  1024.     case 1: sprintf(teste, "%d.%d", clock[2], (1980 + clock[1])); return ArrumaDataHora(teste, '.');
  1025.     case 2: sprintf(teste, "%d.%d.%d", clock[2], clock[3], (1980 + clock[1])); return ArrumaDataHora(teste, '.');
  1026.     case 3: sprintf(teste, "%d.%d.%d", (1980 + clock[1]), clock[3], clock[2]); return ArrumaDataHora(teste, '.');
  1027.     case 4: sprintf(teste, "%d.%d.%d", (1980 + clock[1]), clock[2], clock[3]); return ArrumaDataHora(teste, '.');
  1028.     case 5: sprintf(teste, "%d:%d:%d", clock[4], clock[5], clock[6]); return ArrumaDataHora(teste, ':');
  1029.     case 6: sprintf(teste, "%d:%d", clock[4], clock[5]); return ArrumaDataHora(teste, ':');
  1030.     case 7: sprintf(teste, "%d%d%d", clock[4], clock[5], clock[6]); return teste;
  1031.   }
  1032.   return "ERRO";
  1033. }
  1034.  
  1035. char *DescricaoMes(int mes, int opcao)
  1036. {
  1037.   /*
  1038.   Este comando fornece o mes em formato extenso, se passa o
  1039.   numero do mes e a opcao e sera retornado o nome do mes.
  1040.  
  1041.   Versao  : 1.0
  1042.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1043.   Entrada : Numero do mes  --> 2 (INT)
  1044.             Opcao a listar --> 0 (INT)
  1045.   Obs     : Opcao 0 retorna em Portugues e 1 em Ingles.
  1046.   Saida   : Fevereiro (CHAR RETURN)
  1047.   Erro    : ERRO (CHAR RETURN) Mes invalido! < 0 e > 12
  1048.   Obs     : Caso seja necessario abrevidado use:
  1049.             Esquerda(DescricaoMes(2, 0), 3);
  1050.   */
  1051.  
  1052.   switch (mes)
  1053.   {
  1054.     case  1: if(opcao == 0) return "Janeiro"; else return "January";
  1055.     case  2: if(opcao == 0) return "Fevereiro"; else return "February";
  1056.     case  3: if(opcao == 0) return "Marco"; else return "March";
  1057.     case  4: if(opcao == 0) return "Abril"; else return "April";
  1058.     case  5: if(opcao == 0) return "Maio"; else return "May";
  1059.     case  6: if(opcao == 0) return "Junho"; else return "June";
  1060.     case  7: if(opcao == 0) return "Julho"; else return "July";
  1061.     case  8: if(opcao == 0) return "Agosto"; else return "August";
  1062.     case  9: if(opcao == 0) return "Setembro"; else return "September";
  1063.     case 10: if(opcao == 0) return "Outubro"; else return "October";
  1064.     case 11: if(opcao == 0) return "Novembro"; else return "November";
  1065.     case 12: if(opcao == 0) return "Dezembro"; else return "December";
  1066.   }
  1067.   return "ERRO";
  1068. }
  1069.  
  1070. int CopiaArquivo(char var1[256], char var2[256])
  1071. {
  1072.   /*
  1073.   Este comando copia um determinado arquivo.
  1074.  
  1075.   Versao  : 1.0
  1076.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1077.   Entrada : Path+Nome arquivo origem  --> dh2:gallas.txt (CHAR 256)
  1078.             Path+Nome arquivo destino --> dh2:gallas.tmp (CHAR 256)
  1079.   Saida   : -1 Erro abertura na origem ou criacao destino, 0 OK (INT)
  1080.             CopiaArquivo("dh2:gallas.txt", "dh2:gallas.tmp");
  1081.   */
  1082.  
  1083.   char a;
  1084.   FILE *entrada, *saida;
  1085.   if(!(entrada = fopen(var1, "r")))
  1086.     return -1;
  1087.   if(!(saida = fopen(var2, "w")))
  1088.     return -1;
  1089.   while(a = getc(entrada), ! feof(entrada))
  1090.     fputc(a, saida);
  1091.   fclose(entrada);
  1092.   fclose(saida);
  1093.   return 0;
  1094. }
  1095.  
  1096. int MoveArquivo(char var1[256], char var2[256])
  1097. {
  1098.   /*
  1099.   Este comando move um determinado arquivo.
  1100.  
  1101.   Versao  : 1.0
  1102.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1103.   Entrada : Path+Nome arquivo origem  --> dh2:gallas.txt (CHAR 256)
  1104.             Path+Nome arquivo destino --> dh2:gallas.tmp (CHAR 256)
  1105.   Saida   : -1 Erro abertura na origem ou criacao destino, 0 OK (INT)
  1106.             MoveArquivo("dh2:gallas.txt", "dh2:gallas.tmp");
  1107.   */
  1108.  
  1109.   char a;
  1110.   FILE *entrada, *saida;
  1111.   if(!(entrada = fopen(var1, "r")))
  1112.     return -1;
  1113.   if(!(saida = fopen(var2, "w")))
  1114.     return -1;
  1115.   while(a = getc(entrada), ! feof(entrada))
  1116.     fputc(a, saida);
  1117.   fclose(entrada);
  1118.   fclose(saida);
  1119.   remove(var1);
  1120.   return 0;
  1121. }
  1122.  
  1123. int GravaRegistroDB(char arq[256], char var[256], char campo[256], char caracter[10])
  1124. {
  1125.   /*
  1126.   Este comando grava ou adiciona um registro em um arquivo texto,
  1127.   tipo DB!
  1128.  
  1129.   Versao  : 1.0
  1130.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1131.   Entrada : Path+Nome Arquivo --> dh2:sur.db (CHAR 256)
  1132.             Linha a Gravar    --> Cristian Gallas (CHAR 256)
  1133.             Campo do registro --> Nome (CHAR 256)
  1134.             Tipo de Gravacao  --> a (CHAR 10)
  1135.   Obs     : a --> Append, w --> Write (CASE SENSITIVE)
  1136.   Saida   : 0 se o arq a gravar nao tiver permissao, -1 OK (INT)
  1137.   Obs     : Nao deve ser gravado 2 registros com o mesmo campo.
  1138.   GravaRegistroDB("dh2:sur.db", "Cristian Gallas", "Nome", "a");
  1139.   */
  1140.  
  1141.   FILE *saida;
  1142.   if(!(saida = fopen(arq, caracter)))
  1143.     return 0;
  1144.   fprintf(saida, "**>%s:%s\n", campo, var);
  1145.   fclose(saida);
  1146.   return -1;
  1147. }
  1148.  
  1149. int TotalRegistroDB(char arq[256], char campo[256])
  1150. {
  1151.   /*
  1152.   Este comando verifica o total de campos iguais do arquivo, Tambem
  1153.   usado para verificar se um determinado campo existe no arquivo,
  1154.   so testar se o retorno eh maior que 0.
  1155.  
  1156.   Versao  : 1.0
  1157.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1158.   Entrada : Path+Nome Arquivo --> tmp:gallas.txt (CHAR 256)
  1159.             Campo do Registro --> path (CHAR 256)
  1160.   Saida   : Numero de Chaves iguais --> 1 (INT)
  1161.   Erro    : -1 Caso o arquivo de entrada nao exista, 0 Ok. (INT)
  1162.             TotalRegistroDB("tmp:gallas.txt", "path");
  1163.   */
  1164.  
  1165.   char teste[256], a;
  1166.   int x, total;
  1167.   FILE *entrada;
  1168.   if(!(entrada = fopen(arq, "r")))
  1169.     return -1;
  1170.   x = 0; total = 0;
  1171.   while(a = getc(entrada), ! feof(entrada))
  1172.   {
  1173.     teste[x++] = a;
  1174.     if(a == '\n')
  1175.     {
  1176.       teste[--x] = '\0';
  1177.       if(!(strcmp(Copia(Corta(teste, ':', 0), 4, 15), campo)))
  1178.         total++;
  1179.       teste[0] = '\0'; x = 0;
  1180.     }
  1181.   }
  1182.   fclose(entrada);
  1183.   return total;
  1184. }
  1185.  
  1186. int DeletaRegistroDB(char arq[256], char campo[256], char tmp[256])
  1187. {
  1188.   /*
  1189.   Este comando deleta um determinado campo do arquivo DB, caso
  1190.   exista mais de um campo igual, todos serao deletados.
  1191.  
  1192.   Versao  : 1.0
  1193.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1194.   Entradas : Path+Nome Arquivo  --> dh2:gallas.txt (CHAR 256)
  1195.              Campo a deletar    --> path (CHAR 256)
  1196.              Arquivo temporario --> ram:surround.tmp (CHAR 256)
  1197.   Saida    : O total de campos deletados --> 1 (INT)
  1198.   Erro     : -1 caso de problema na abertura do arquivo DB ou
  1199.              problema ao criar o arquivo temporario. > 0 Ok.
  1200.   Obs      : Caso o arquivo temporario seja pequeno, e nao muito
  1201.              variavel, jogue ele na RAM: assim sera bem mais rapido.
  1202.   DeletaRegistroDB("dh2:gallas.txt", "path", "ram:surround.tmp");
  1203.   */
  1204.  
  1205.   char teste[256], a;
  1206.   int x, total;
  1207.   FILE *entrada, *saida;
  1208.   if(!(entrada = fopen(arq, "r")))
  1209.     return -1;
  1210.   if(!(saida = fopen(tmp, "w")))
  1211.     return -1;
  1212.   x = 0; total = 0;
  1213.   while(a = getc(entrada), ! feof(entrada))
  1214.   {
  1215.     teste[x++] = a;
  1216.     if(a == '\n')
  1217.     {
  1218.       teste[--x] = '\0';
  1219.       if(!(strcmp(Copia(Corta(teste, ':', 0), 4, 15), campo)))
  1220.         total++;
  1221.       else
  1222.         fprintf(saida, "%s\n", teste);
  1223.       teste[0] = '\0'; x = 0;
  1224.     }
  1225.   }
  1226.   fclose(saida);
  1227.   fclose(entrada);
  1228.   CopiaArquivo(tmp, arq);
  1229.   remove(tmp);
  1230.   return total;
  1231. }
  1232.  
  1233. char *LeRegistroDB(char arq[256], char campo[256])
  1234. {
  1235.   /*
  1236.   Este comando le um determinado registro pela seu campo. Se o campo
  1237.   nao existir no arquivo o retorno sera nulo "". Se existir mais
  1238.   de um campo igual, sera retornado a primeiro.
  1239.  
  1240.   Versao  : 1.0
  1241.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1242.   Entrada : Path+Nome Arquivo  --> dh2:gallas.db (CHAR 256)
  1243.             Campo a ler        --> path (CHAR 256)
  1244.   Saida   : A linha da Chave 2 --> Campo da Chave 2 (CHAR 256)
  1245.             LeRegistroDB("dh2:gallas.db", "path");
  1246.   */
  1247.  
  1248.   char teste[256], a;
  1249.   int x;
  1250.   FILE *entrada;
  1251.   if(!(entrada = fopen(arq, "r")))
  1252.     return "";
  1253.   x = 0;
  1254.   while(a = getc(entrada), ! feof(entrada))
  1255.   {
  1256.     teste[x++] = a;
  1257.     if(a == '\n')
  1258.     {
  1259.       teste[--x] = '\0';
  1260.       if(!(strcmp(Corta(Corta(teste, ':', 0), '>', 1), campo))) {
  1261.         fclose(entrada);
  1262.       return AposCaracter(teste, ':', 1); }
  1263.       teste[0] = '\0'; x = 0;
  1264.     }
  1265.   }
  1266.   fclose(entrada);
  1267.   return "";
  1268. }
  1269.  
  1270. char *StringAscii(char key[256], int numero)
  1271. {
  1272.   /*
  1273.   Este comando recebe uma determinada String e retorna ela em
  1274.   codigos da tabela ASCII. Podendo ainda somar cada caracter ascii
  1275.   com um determinado numero.
  1276.  
  1277.   Versao  : 1.0
  1278.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1279.   Entrada : String a converter --> Gallas (CHAR 256)
  1280.             Numero a somar     --> 2
  1281.   Saida   : String em ASCII    --> 073099110110099117 (CHAR 256)
  1282.   Obs     : O Numero chave a ser passado nao deve exceder a 740,
  1283.             caso isso aconteca sera calculado como 1. Esta rotina
  1284.             foi feita para ajudar na criptografia de dados.
  1285.             StringAscii("Gallas", 2);
  1286.   */
  1287.  
  1288.   char cha[5], chat[5], chave[256];
  1289.   int x = 0;
  1290.   if(numero > 740)
  1291.     numero = 1;
  1292.   chave[0] = '\0';
  1293.   for(x = 0; x < strlen(key); x++)
  1294.   {
  1295.     sprintf(chat, "%u", key[x]);
  1296.     sprintf(cha, "%d", atoi(chat) + numero);
  1297.     if(strlen(cha) == 1)
  1298.       sprintf(chave, "%s00%s", chave, cha);
  1299.     if(strlen(cha) == 2)
  1300.       sprintf(chave, "%s0%s", chave, cha);
  1301.     if(strlen(cha) == 3)
  1302.       sprintf(chave, "%s%s", chave, cha);
  1303.   }
  1304.   return chave;
  1305. }
  1306.  
  1307. char *AsciiString(char key[256], int numero)
  1308. {
  1309.   /*
  1310.   Este comando recebe a string convertida para ascii e retorna
  1311.   ela para a sua string de origem baseado no numero chave que deve
  1312.   ser o mesmo.  
  1313.  
  1314.   Versao  : 1.0
  1315.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1316.   Entrada : Ascii a retornar    --> 073099110110099117 (CHAR 256)
  1317.             Numero a chave      --> 2
  1318.   Saida   : String de retorno   --> Gallas (CHAR 256)
  1319.             AsciiString("073099110110099117", 2);
  1320.   */
  1321.  
  1322.   char chave[256], saida[256], teste[256];
  1323.   int x = 0, contador = 0, y = 0;
  1324.  
  1325.   teste[0] = '\0';
  1326.   for(x = 0; x < strlen(key); x++)
  1327.   {
  1328.     chave[y++] = key[x]; contador++;
  1329.     if(contador == 3)
  1330.     {
  1331.       chave[y] = '\0';
  1332.       sprintf(saida, "%s%c", teste, (atoi(chave) - numero));
  1333.       strcpy(teste, saida);
  1334.       chave[0] = '\0'; y = 0; contador = 0;
  1335.     }
  1336.   }
  1337.   return saida;
  1338. }
  1339.  
  1340. char *CriptografiaSimples(char var[256], int opcao)
  1341. {
  1342.   /*
  1343.   Este comando criptografa e descriptografa uma determinada String.
  1344.  
  1345.   Versao  : 1.0
  1346.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1347.   Entrada : String --> Cristian (CHAR 256)
  1348.             Opcao  --> 0 (INT)
  1349.   Obs     : 0 Criptografa, 1 Descriptografa
  1350.   Saida   : String Alterada --> 2$#5%5mO (CHAR 256)
  1351.             CriptografiaSimples("Cristian", 0);
  1352.   */
  1353.  
  1354.   char teste[256], tabela1[256], tabela2[256];
  1355.   int x, posicao;
  1356.   if(opcao < 0 && opcao > 1)
  1357.     opcao = 0;
  1358.   strcpy(tabela1, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890~`!@#$%^&*()-_+=|\\{}[]:;'<>,./?\" öóòôõáàâãúùûéèêëíìîï®ç");
  1359.   strcpy(tabela2, " ~`!@#$%^&*()-_+=|\\{}[]:;'<>,./?\"1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzòôõáàâãúùûéèêëíìîïöóç®");
  1360.   teste[0] = '\0';
  1361.   posicao = 0;
  1362.   for(x = 0; x < strlen(var); x++)
  1363.   {
  1364.     if(opcao == 0) {
  1365.       posicao = PosicaoCaracter(tabela1, var[x], 1);
  1366.       sprintf(teste, "%s%c", teste, tabela2[--posicao]);
  1367.     } else {
  1368.       posicao = PosicaoCaracter(tabela2, var[x], 1);
  1369.       sprintf(teste, "%s%c", teste, tabela1[--posicao]);
  1370.     }
  1371.   }
  1372.   return teste;
  1373. }
  1374.  
  1375. char *TrimSur(char var[256], int opcao) 
  1376. {
  1377.   /*
  1378.   Este comando retira espacos dos cantos de uma string.
  1379.  
  1380.   Versao  : 1.0
  1381.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1382.   Entrada : String --> "     Cristian Robert Gallas     " (CHAR 256)
  1383.             Opcao  --> 0 (INT)
  1384.   Obs     : 0 Retira da esquerda e direita
  1385.             1 da direita
  1386.             2 da esquerda
  1387.   Saida   : String --> "Cristian Robert Gallas" (CHAR 256)
  1388.   Obs     : as aspas sao somente para demonstrar o efeito.
  1389.             TrimSur("     Cristian Robert Gallas     ", 0);
  1390.   */
  1391.  
  1392.   int x = 0;
  1393.   if(opcao < 0 && opcao > 2)
  1394.     opcao = 0;
  1395.   if(opcao == 1 || opcao == 0)
  1396.   {
  1397.     for(x = 0; x < strlen(var); x++)
  1398.       if(var[x] != ' ')
  1399.         break;
  1400.     strcpy(var, Copia(var, ++x, 256));
  1401.   }
  1402.   if(opcao == 2 || opcao == 0)
  1403.   {
  1404.     for(x = (strlen(var) - 1); x > 1; x--)
  1405.       if(var[x] != ' ')
  1406.         break;
  1407.     strcpy(var, Copia(var, 1, ++x));
  1408.   }
  1409.   return var;
  1410. }
  1411.  
  1412. char *DiaSemana(char var[20], int opcao) 
  1413. {
  1414.   /*
  1415.   Este comando recebe uma data e retorna o dia da semana.
  1416.  
  1417.   Versao  : 1.0
  1418.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1419.   Entrada : Data  --> 01.02.1997 (CHAR 20)
  1420.             Opcao --> 0 (INT)
  1421.   Obs     : 0 retorna em portugues
  1422.             1 ingles
  1423.             2 o numero do dia, inicio em 1 -> domingo.
  1424.   Saida   : Dia da Semana -> Segunda (CHAR RETURN)
  1425.             DiaSemana("01.02.1997", 0);
  1426.   */
  1427.  
  1428.   char teste[256];
  1429.   int x = 0;
  1430.   x = fmod(atof(Arredondar(DiaJuliano(var))), 7.0);
  1431.   if(opcao == 2)
  1432.   {
  1433.     sprintf(teste, "%d", x);
  1434.     return teste;
  1435.   }
  1436.   switch(x)
  1437.   {
  1438.     case 1: if(opcao == 0) return "Domingo"; else return "Sunday";
  1439.     case 2: if(opcao == 0) return "Segunda"; else return "Monday";
  1440.     case 3: if(opcao == 0) return "Terca"; else return "Tuesday";
  1441.     case 4: if(opcao == 0) return "Quarta"; else return "Wednesday";
  1442.     case 5: if(opcao == 0) return "Quinta"; else return "Thursday";
  1443.     case 6: if(opcao == 0) return "Sexta"; else return "Friday";
  1444.     case 0: if(opcao == 0) return "Sabado"; else return "Saturday";
  1445.   }
  1446.   return "ERRO";
  1447. }
  1448.  
  1449. char *EspacoString(char var[256], int tamanho, int opcao)
  1450. {
  1451.   /*
  1452.   Este comando acrescenta espacos na frente ou atras de uma string.
  1453.  
  1454.   Versao  : 1.0
  1455.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1456.   Entrada : String           --> "Cristian" (CHAR 256)
  1457.             Tamanho do campo --> 20 (INT)
  1458.             Opcao            --> 0 (INT)
  1459.   Obs     : 0 - Esquerda
  1460.             1 - Direita
  1461.   Saida   : String com espacos --> "            Cristian" (CHAR 256)
  1462.   Obs     : As aspas sao so para demonstrar o resultado.
  1463.             Caso o tamanho especificado do campo final for menor que o
  1464.             tamanho da string, o resultado sera cortado.
  1465.             EspacoString("Cristian", 20, 0);
  1466.   */
  1467.  
  1468.   char saida[256], teste[256];
  1469.   int x, y;
  1470.   x = strlen(var);
  1471.   y = tamanho - x;
  1472.   if(y <= 0)
  1473.     return Copia(var, 1, tamanho);
  1474.   for(x = 0; x < y; x++)
  1475.     teste[x] = ' ';
  1476.   teste[x] = '\0';
  1477.   if(opcao == 0)
  1478.     sprintf(saida, "%s%s", teste, var);
  1479.   else
  1480.     sprintf(saida, "%s%s", var, teste);
  1481.   return saida;
  1482. }
  1483.  
  1484. char *UltimaLinha(char var[256])
  1485. {
  1486.   /*
  1487.   Este comando pega a ultima linha de um arquivo. Rotina super
  1488.   rapida, usa posicionamento de arquivo.
  1489.  
  1490.   Versao  : 1.0
  1491.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1492.   Entrada : Path+Nome Arquivo --> dh2:gallas.txt (CHAR 256)
  1493.   Saida   : Ultima linha      --> Last Line (CHAR 256)
  1494.   Erro    : "ERRO" (CHAR RETURN)
  1495.             UltimaLinha("dh2:gallas.txt");
  1496.   */
  1497.  
  1498.   char a, teste[256];
  1499.   int x = 0, y = 0;
  1500.   FILE *entrada;
  1501.   if(!(entrada = fopen(var, "r")))
  1502.     return "ERRO";
  1503.   while(a = getc(entrada), ! feof(entrada))
  1504.   {
  1505.     teste[x++] = a;
  1506.     if(a == '\n')
  1507.     {
  1508.       y++; teste[--x] = '\0';
  1509.       if(y > 1)
  1510.         break;
  1511.     }
  1512.   }
  1513.   if(y == 1)
  1514.   {
  1515.     fclose(entrada);
  1516.     return teste;
  1517.   }
  1518.   fseek(entrada, 0, SEEK_END);
  1519.   while(a = getc(entrada), a != '\n' && a != '\0')
  1520.     fseek(entrada, -2, 1);
  1521.   x = 0; teste[0] = '\0';
  1522.   while(a = getc(entrada), ! feof(entrada))
  1523.     teste[x++] = a;
  1524.   teste[--x] = '\0';
  1525.   fclose(entrada);
  1526.   return teste;
  1527. }
  1528.  
  1529. char *UpperCase(char var[256]) 
  1530. {
  1531.   /*
  1532.   Este comando converte uma string para todos os caracteres em
  1533.   maiusculo.
  1534.  
  1535.   Versao  : 1.0
  1536.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1537.   Entrada : String a converter --> Cristian Gallas (CHAR 256)
  1538.   Saida   : String maiuscula   --> CRISTIAN GALLAS (CHAR 256)
  1539.             UpperCase("Cristian Gallas");
  1540.   */
  1541.  
  1542.   char teste[256];
  1543.   int x = 0, y = 0;
  1544.   for(x = 0; x < strlen(var); x++)
  1545.     teste[y++] = toupper(var[x]);
  1546.   teste[y] = '\0';
  1547.   return teste;
  1548. }
  1549.  
  1550. char *LowerCase(char var[256]) 
  1551. {
  1552.   /*
  1553.   Este comando converte uma string para todos os caracteres em
  1554.   minusculo.
  1555.  
  1556.   Versao  : 1.0
  1557.   Entrada : String a converter --> CRISTIAN GALLAS (CHAR 256)
  1558.   Saida   : String maiuscula   --> cristian gallas (CHAR 256)
  1559.             LowerCase("CRISTIAN GALLAS");
  1560.   */
  1561.  
  1562.   char teste[256];
  1563.   int x = 0, y = 0;
  1564.   for(x = 0; x < strlen(var); x++)
  1565.     teste[y++] = tolower(var[x]);
  1566.   teste[y] = '\0';
  1567.   return teste;
  1568. }
  1569.  
  1570. char *PrimeiroUpper(char var[256]) 
  1571. {
  1572.   /*
  1573.   Este comando converto todos os primeiros caracteres das palavras
  1574.   de uma determinada frase ou string para maiusculo.
  1575.  
  1576.   Versao  : 1.0
  1577.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1578.   Entrada : String a converter --> cristian gallas (CHAR 256)
  1579.   Saida   : String convertida  --> Cristian Gallas (CHAR 256)
  1580.             PrimeiroUpper("cristian gallas");
  1581.   */
  1582.  
  1583.   char teste[256];
  1584.   int x = 0, y = 0, ativa = 0;
  1585.   for(x = 0; x < strlen(var); x++)
  1586.   {
  1587.     if(x == 0 || var[x - 1] == ' ')
  1588.       ativa = 1;
  1589.     if(ativa == 0)
  1590.       teste[y++] = tolower(var[x]);
  1591.     else
  1592.     {
  1593.       ativa = 0;
  1594.       teste[y++] = toupper(var[x]);
  1595.     }
  1596.   }
  1597.   teste[y] = '\0';
  1598.   return teste;
  1599. }
  1600.  
  1601. char *StringParaCgc(char var[30])
  1602. {
  1603.   /*
  1604.   Este comando recebe um numero de 14 algarismos e retorna formatado
  1605.   no formato padrao de CGC.
  1606.  
  1607.   Versao  : 1.0
  1608.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1609.   Entrada : Numero --> 12345678901234 (CHAR 30)
  1610.   Saida   : Cgc    --> 12.345.678/9012-34 (CHAR 30)
  1611.   Erro    : ERRO (CHAR RETURN) Quando passado diferente de 14 algarismos
  1612.             StringParaCgc("12345678901234");
  1613.   */
  1614.  
  1615.   char x1[6], x2[6], x3[6], x4[6], x5[6], teste[256];
  1616.   if(strlen(var) != 14)
  1617.     return "ERRO";
  1618.   strcpy(x1, Copia2(var, 1, 2));
  1619.   strcpy(x2, Copia2(var, 3, 3));
  1620.   strcpy(x3, Copia2(var, 6, 3));
  1621.   strcpy(x4, Copia2(var, 9, 4));
  1622.   strcpy(x5, Copia2(var, 13, 2));
  1623.   sprintf(teste, "%s.%s.%s/%s-%s", x1, x2, x3, x4, x5);
  1624.   return teste;
  1625. }
  1626.  
  1627. int ExisteDiretorio(char var[256]) 
  1628. {
  1629.   /*
  1630.   Rotina que testa se um diretorio existe.  
  1631.  
  1632.   Versao  : 1.0
  1633.   Compila : AmigaDos
  1634.   Entrada : Path --> dh2:tmp/ (CHAR 256)
  1635.   Saida   : True (-1) se existir e False (0) se nao existir (INT)
  1636.             if(ExisteDiretorio("dh2:tmp/"))
  1637.   */
  1638.  
  1639.   DIR *dfd;
  1640.  
  1641.   if(!(dfd = opendir(var))) {
  1642.     closedir(dfd);
  1643.     return 0;
  1644.   } else {
  1645.     closedir(dfd);
  1646.     return -1; }
  1647. }
  1648.  
  1649. int FinalArquivo(char var[256], char var2[256], int numero)
  1650. {
  1651.   /*
  1652.   Este comando pega determinadas linhas do final do arquivo
  1653.   e gera outro arquivo com seu conteudo.
  1654.  
  1655.   Versao  : 1.0
  1656.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1657.   Entrada : Path+Nome Arquivo Entrada --> dh2:gallas.txt (CHAR 256)
  1658.             Path+Nome Arquivo Saida   --> dh2:saida.txt  (CHAR 256)
  1659.             Numero de linhas          --> 10
  1660.   Saida   : Sera pego as ultimas 10 linhas do arquivo de entrada
  1661.             e gravado no arquivo de saida.
  1662.             Retorna [-1] se sucesso e [0] se erro.
  1663.             FinalArquivo("dh2:gallas.txt", "dh2:saida.txt", 10);
  1664.   */
  1665.  
  1666.   char a, teste[256];
  1667.   int x = 0, total = 0;
  1668.   FILE *entrada, *saida;
  1669.   total = LinhasArquivo(var);
  1670.   if(total <= numero)
  1671.   {
  1672.     CopiaArquivo(var, var2);
  1673.     return -1;
  1674.   }
  1675.   if(!(entrada = fopen(var, "r")))
  1676.     return 0;
  1677.   if(!(saida = fopen(var2, "w")))
  1678.     return 0;
  1679.   /* Posiciona e pega as linhas requisitadas do final */
  1680.   fseek(entrada, 0, SEEK_END);
  1681.   while(a = getc(entrada), x < numero) {
  1682.     if(a == '\n')
  1683.       x++;
  1684.     fseek(entrada, -2, 1); }
  1685.   x = 0; teste[0] = '\0'; getc(entrada);
  1686.   while(a = getc(entrada), ! feof(entrada))
  1687.     fprintf(saida, "%c", a);
  1688.   fclose(entrada);
  1689.   fclose(saida);
  1690.   return -1;
  1691. }
  1692.  
  1693. char *FiltraCaracter(char var[256], int opcao) 
  1694. {
  1695.   /* 
  1696.   Este comando filtra uma string seguindo as seguintes opcoes.
  1697.  
  1698.   Versao  : 1.0
  1699.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1700.   Entrada : String a filtrar --> 051-632-28-05
  1701.             Opcao            --> 0
  1702.   Obs:    : Opcoes de tipo de filtro
  1703.             0 -> Filtra e retorna somente numeros
  1704.             1 -> Filtra e retorna somente letras
  1705.             2 -> Filtra e retorna somente letras e numeros
  1706.   Saida   : String Filtrada  --> 0516322805
  1707.             FiltraCaracter("051-632-28-05", 0);
  1708.   */
  1709.  
  1710.   char teste[256];
  1711.   int x = 0, y = 0;
  1712.   if(opcao < 0 || opcao > 2)
  1713.     opcao = 2;
  1714.   for(x = 0; x < strlen(var); x++)
  1715.   {
  1716.     if(opcao == 0)
  1717.       if(isdigit(var[x]))
  1718.         teste[y++] = var[x];
  1719.     if(opcao == 1)
  1720.       if(isalpha(var[x]))
  1721.         teste[y++] = var[x];
  1722.     if(opcao == 2)
  1723.       if(isalnum(var[x]))
  1724.         teste[y++] = var[x];
  1725.   }
  1726.   teste[y] = '\0';
  1727.   return teste;
  1728. }
  1729.  
  1730. char *InsereString(char var[256], char var2[256], int numero)
  1731. {
  1732.   /*
  1733.   Esta rotina acrescenta uma string dentro de outra, adicionando
  1734.   na posicao passada como parametro.
  1735.  
  1736.   Versao  : 1.0
  1737.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1738.   Entrada : String Inicial      --> CristianGallas (CHAR 256)
  1739.             String a Adicionar  --> Robert (CHAR 256)
  1740.             Posicao a Adicionar --> 9 (INT)
  1741.   Saida   : Juncao das duas     --> CristianRobertGallas (CHAR 256)
  1742.             InsereString("CristianGallas", "Robert", 9);
  1743.   Obs     : O caracter inicia em 1!
  1744.   */
  1745.  
  1746.   char parte1[256], parte2[256], teste[256];
  1747.   numero--;
  1748.   strcpy(parte1, Copia(var, 1, numero));
  1749.   strcpy(parte2, Copia(var, numero+1, 256));
  1750.   sprintf(teste, "%s%s%s", parte1, var2, parte2);
  1751.   return teste;
  1752. }
  1753.  
  1754. char *Online(char dat[256], char hora[256], char tempo[256])
  1755. {
  1756.   /*
  1757.   Esta rotina retorna os dados referentes a uma coneccao 
  1758.   calculando a hora de desconeccao e o dia.
  1759.  
  1760.   Versao  : 1.0
  1761.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1762.   Entrada : Dia da coneccao  --> 01.01.1997 (CHAR 256)
  1763.             Hora da coneccao --> 23:10:10 (CHAR 256)
  1764.             Tempo online     --> 01:20:02 (CHAR 256)
  1765.   Saida   : A saida sao 5 campos separados pelo caracter @
  1766.             Ex: 729398@729398@8341@1812@4802@10153
  1767.             Campo 1 --> Data de coneccao (Juliano)
  1768.             Campo 2 --> Data de desconeccao (Juliano)
  1769.             Campo 3 --> Hora de coneccao (Segundos)
  1770.             Campo 4 --> Hora de desconeccao (Segundos)
  1771.             Campo 5 --> Tempo de coneccao (Segundos)
  1772.             Campo 6 --> Hora Direta +24 (Segundos)
  1773.             Online("01.01.1997", "23:10:10", "01:20:02");
  1774.   */
  1775.  
  1776.   char teste[256];
  1777.   float dia1, dia2;
  1778.   int hora1, hora2, tempoon, horadireta;
  1779.   dia1 = atof(DiaJuliano(dat));
  1780.   hora1 = atoi(HoraSegundo(hora));
  1781.   hora2 = hora1 + atoi(HoraSegundo(tempo));
  1782.   tempoon = atoi(HoraSegundo(tempo));
  1783.   sprintf(teste, "%d", hora2);
  1784.   strcpy(teste, Corta(SegundoHora(teste), ':', 0));
  1785.   dia2 = dia1 + (atoi(teste) / 24);
  1786.   horadireta = hora2;
  1787.   if(atoi(teste) > 23)
  1788.     hora2 = hora2 - 86400; 
  1789.   sprintf(teste, "%f@%f@%d@%d@%d@%d", dia1, dia2, hora1, hora2, tempoon, horadireta);
  1790.   return teste;
  1791. }
  1792.  
  1793. int GravaLinha(char var[256], char linha[256], char comando[10])
  1794. {
  1795.   /* 
  1796.   Este comando adiciona uma linha em um determinado arquivo.
  1797.  
  1798.   Versao  : 1.0
  1799.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1800.   Entrada : Path+Nome Arquivo --> dh2:gallas.txt
  1801.             A Linha a adicionar --> Gallas
  1802.             O tipo de comando   --> a, w
  1803.   Saida   : Caso de erro retornado -1 se ok, retorna 0.
  1804.   Obs     : a Adiciona no arquivo, w inicializa arquivo com a linha.
  1805.             GravaLinha("dh2:gallas.txt", "Gallas", "a");
  1806.   */
  1807.  
  1808.   FILE *saida;
  1809.   if(!(saida = fopen(var, comando)))
  1810.     return -1;
  1811.   fprintf(saida, "%s", linha);
  1812.   fclose(saida);
  1813.   return 0;
  1814. }
  1815.  
  1816. int InsereArquivo(char var1[256], char var2[256])
  1817. {
  1818.   /*
  1819.   Este comando insere um arquivo em outro.
  1820.  
  1821.   Versao  : 1.0
  1822.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1823.   Entrada : Path+Nome arquivo origem  --> dh2:gallas.txt (CHAR 256)
  1824.             Path+Nome arquivo destino --> dh2:gallas.tmp (CHAR 256)
  1825.   Saida   : -1 Erro abertura na origem ou criacao destino, 0 OK (INT)
  1826.             InsereArquivo("dh2:gallas.txt", "dh2:gallas.tmp");
  1827.   */
  1828.  
  1829.   char a;
  1830.   FILE *entrada, *saida;
  1831.   if(!(entrada = fopen(var1, "r")))
  1832.     return -1;
  1833.   if(!(saida = fopen(var2, "a")))
  1834.     return -1;
  1835.   while(a = getc(entrada), ! feof(entrada))
  1836.     fputc(a, saida);
  1837.   fclose(entrada);
  1838.   fclose(saida);
  1839.   return 0;
  1840. }
  1841.  
  1842. char *JulianoDia(char var[256])
  1843. {
  1844.   /* Esta rotina converte dia juliano para data.
  1845.  
  1846.   Versao  : 1.0
  1847.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  1848.   Entrada : Dia Juliano         --> 729040 (CHAR 256)
  1849.   Saida   : Data Correspondente --> 01.01.1997 (CHAR 256)
  1850.             JulianoDia("729040");
  1851.   */
  1852.  
  1853.   char teste[256];
  1854.   float pdatajul = 0, x = 0;
  1855.   int y = 0, ano = 0, mes = 1, dia = 0;
  1856.   pdatajul = atof(var);
  1857.   ano = (((pdatajul - 1) - ((pdatajul - 1) / 1461)) / 365) + 1;
  1858.   x = ano;
  1859.   y = fmod(x, 4.0);
  1860.   if(y != 0)
  1861.   {
  1862.     y = (pdatajul - 1) / 1461;
  1863.     x = ((pdatajul - 1) - y);
  1864.     dia = fmod(x, 365.0) + 1;
  1865.     if((dia > 31) && (dia <= 59))
  1866.     {
  1867.       mes = 2;
  1868.       dia = dia - 31;
  1869.     }
  1870.     if((dia > 59) && (dia <= 90))
  1871.     {
  1872.       mes = 3;
  1873.       dia = dia - 59;
  1874.     }
  1875.     if((dia > 90) && (dia <= 120))
  1876.     {
  1877.       mes = 4;
  1878.       dia = dia - 90;
  1879.     }
  1880.     if((dia > 120) && (dia <= 151))
  1881.     {
  1882.       mes = 5;
  1883.       dia = dia - 120;
  1884.     }
  1885.     if((dia > 151) && (dia <= 181))
  1886.     {
  1887.       mes = 6;
  1888.       dia = dia - 151;
  1889.     }
  1890.     if((dia > 181) && (dia <= 212))
  1891.     {
  1892.       mes = 7;
  1893.       dia = dia - 181;
  1894.     }
  1895.     if((dia > 212) && (dia <= 243))
  1896.     {
  1897.       mes = 8;
  1898.       dia = dia - 212;
  1899.     }
  1900.     if((dia > 243) && (dia <= 273))
  1901.     {
  1902.       mes = 9;
  1903.       dia = dia - 243;
  1904.     }
  1905.     if((dia > 273) && (dia <= 304))
  1906.     {
  1907.       mes = 10;
  1908.       dia = dia - 273;
  1909.     }
  1910.     if((dia > 304) && (dia <= 334))
  1911.     {
  1912.       mes = 11;
  1913.       dia = dia - 304;
  1914.     }
  1915.     if(dia > 334)
  1916.     {
  1917.       mes = 12;
  1918.       dia = dia - 334;
  1919.     }
  1920.   }
  1921.   else
  1922.   {
  1923.     y = fmod(pdatajul, 1461.0);
  1924.     if(y != 0)
  1925.     {
  1926.       y = (pdatajul - 1) / 1461;
  1927.       x = pdatajul - 1;
  1928.       dia = (fmod((x - y), 365.0)) + 1;
  1929.     }
  1930.     else
  1931.       dia = 366;
  1932.     
  1933.     if((dia > 31) && (dia <= 60))
  1934.     {
  1935.       mes = 2;
  1936.       dia = dia - 31;
  1937.     }
  1938.     if((dia > 60) && (dia <= 91))
  1939.     {
  1940.       mes = 3;
  1941.       dia = dia - 60;
  1942.     }
  1943.     if((dia > 91) && (dia <= 121))
  1944.     {
  1945.       mes = 4;
  1946.       dia = dia - 91;
  1947.     }
  1948.     if((dia > 121) && (dia <= 152))
  1949.     {
  1950.       mes = 5;
  1951.       dia = dia - 121;
  1952.     }
  1953.     if((dia > 152) && (dia <= 182))
  1954.     {
  1955.       mes = 6;
  1956.       dia = dia - 152;
  1957.     }
  1958.     if((dia > 182) && (dia <= 213))
  1959.     {
  1960.       mes = 7;
  1961.       dia = dia - 182;
  1962.     }
  1963.     if((dia > 213) && (dia <= 244))
  1964.     {
  1965.       mes = 8;
  1966.       dia = dia - 213;
  1967.     }
  1968.     if((dia > 244) && (dia <= 274))
  1969.     {
  1970.       mes = 9;
  1971.       dia = dia - 244;
  1972.     }
  1973.     if((dia > 274) && (dia <= 305))
  1974.     {
  1975.       mes = 10;
  1976.       dia = dia - 274;
  1977.     }
  1978.     if((dia > 305) && (dia <= 335))
  1979.     {
  1980.       mes = 11;
  1981.       dia = dia - 305;
  1982.     }
  1983.     if(dia > 335)
  1984.     {
  1985.       mes = 12;
  1986.       dia = dia - 335;
  1987.     }
  1988.   }
  1989.   sprintf(teste, "%d.%d.%d", dia, mes, ano);
  1990.   strcpy(teste, ArrumaDataHora(teste, '.'));
  1991.   return teste;
  1992. }
  1993.  
  1994. char *SomaDiminuiMes(char data[256], int nmes)
  1995. {
  1996.   /* 
  1997.   Esta rotina soma ou diminui um mes a uma determinada data,   
  1998.   testando e arrumando o ano, caso necessario.
  1999.  
  2000.   Versao  : 1.0
  2001.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2002.   Ex1:
  2003.   Entrada : Data             --> 10.01.1997 (CHAR 256)
  2004.             Meses a calcular --> 2 (INT)
  2005.   Saida   : Data com a soma de 2 meses --> 10.03.1997 (CHAR 256)
  2006.   Ex2:
  2007.   Entrada : Data             --> 10.01.1997 (CHAR 256)
  2008.             Meses a calcular --> -2 (INT)
  2009.   Saida   : Data com a soma de 2 meses --> 10.11.1996 (CHAR 256)
  2010.   Obs     : Essa rotina nao testa o dia.
  2011.             SomaDiminuiMes("10.01.1997", 2);
  2012.             SomaDiminuiMes("10.01.1997", -2);
  2013.   */
  2014.  
  2015.   char teste[256];
  2016.   int x, dia, mes, ano;
  2017.   dia = atoi(Corta(data, '.', 0));
  2018.   mes = atoi(Corta(data, '.', 1));
  2019.   ano = atoi(Corta(data, '.', 2));
  2020.   if(nmes > 0)
  2021.   {
  2022.     for(x = 0; x < nmes; x++) {
  2023.       mes++;
  2024.       if(mes == 13) {
  2025.   mes = 1;
  2026.   ano++; } }
  2027.   }
  2028.   else
  2029.   {
  2030.     for(x = 0; x < (nmes * -1); x++) {
  2031.       mes--;
  2032.       if(mes == 0) {
  2033.         mes = 12;
  2034.         ano--; } }
  2035.   }
  2036.   sprintf(teste, "%d.%d.%d", dia, mes, ano);
  2037.   strcpy(teste, ArrumaDataHora(teste, '.'));
  2038.   return teste;
  2039. }
  2040.  
  2041. char *IntervaloPeriodo(char periodo1[30], char periodo2[30], char periodo3[30], char periodo4[30], int xdias)
  2042. {
  2043.   /*
  2044.   Este comando verifica o periodo valido de um determinado periodo
  2045.   de tempo em relacao a outro.
  2046.  
  2047.   Versao  : 1.0
  2048.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2049.   Entrada : Periodo 1 (Fixo) --> 01:00:00 (CHAR 30)
  2050.             Periodo 2 (Fixo) --> 05:00:00 (CHAR 30)
  2051.             Periodo 3        --> 03:00:00 (CHAR 30)
  2052.             Periodo 4        --> 06:00:00 (CHAR 30)
  2053.             Dias intermediarios --> 1 (INT)
  2054.   Obs     : O pediodo 1 e 2 sao fixos, no caso nao contabilizam
  2055.             no horario de saida.
  2056.   Saida   : Periodo real usado --> 01:00:00 (CHAR 30)
  2057.             IntervaloPeriodo("01:00:00", "05:00:00", "03:00:00", "06:00:00", 1);
  2058.   */
  2059.  
  2060.   char teste[256];
  2061.   int r = 0, h1 = 0, h2 = 0, x1 = 0, x2 = 0, horas = 0;
  2062.  
  2063.   h1 = atoi(HoraSegundo(periodo1));
  2064.   h2 = atoi(HoraSegundo(periodo2));
  2065.   x1 = atoi(HoraSegundo(periodo3));
  2066.   x2 = atoi(HoraSegundo(periodo4));
  2067.  
  2068.   if(xdias == 0)
  2069.     xdias = 1;
  2070.   if((x2 < x1) || (h2 < h1))
  2071.   {
  2072.     x2 = x2 + (xdias * 86400);
  2073.     if((h1 < h2) && (h1 > 0))
  2074.       h1 = h1 + (xdias * 86400);
  2075.     h2 = h2 + (xdias * 86400);
  2076.   }
  2077.  
  2078.   horas = x2 - x1;
  2079.   if((x1 < h1) && (x2 > h2))
  2080.     horas = (h1 - x1) + (x2 - h2);
  2081.   else
  2082.   {
  2083.     if((x1 >= h1) && (x1 <= h2)) {
  2084.       if((x2 >= h1) && (x2 <= h2)) {
  2085.         r = x2 - x1;
  2086.       } else {
  2087.         r = h2 - x1; }
  2088.     } else
  2089.       if((x2 >= h1) && (x2 <= h2)) {
  2090.         r = x2 - h1;
  2091.       } else {
  2092.         r = 0; }
  2093.     horas = horas - r;
  2094.   }
  2095.   sprintf(teste, "%d", horas);
  2096.   return ArrumaDataHora(SegundoHora(teste), ':');
  2097. }
  2098.  
  2099. char *AlteraCampo(char var[256], char var2[256], char delimitador, int campo)
  2100. {
  2101.   /*
  2102.   Esta funcao altera um determinado campo dentro de uma string.
  2103.  
  2104.   Versao  : 1.0
  2105.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2106.   Entrada : String com os campos--> Cristian,Rbr,Gallas (CHAR 256)
  2107.             Campo novo          --> Robert (CHAR 256)
  2108.             Delimitador campos  --> , (CHAR 1)
  2109.             Campo (inicia em 0) --> 1 (INT)
  2110.   Saida   : Linha alterada      --> Cristian,Robert,Gallas (CHAR 256)
  2111.             AlteraCampo("Cristian,Rbr,Gallas", "Robert", ',', 1);
  2112.   */
  2113.  
  2114.   char teste[256], parte1[256], parte2[256];
  2115.   int posicao1 = 0,  posicao2 = 0;
  2116.   if(campo == 0)
  2117.     posicao1 = 0;
  2118.   else
  2119.     posicao1 = PosicaoCaracter(var, delimitador, campo);
  2120.   posicao2 = PosicaoCaracter(var, delimitador, campo+1);
  2121.   strcpy(parte1, Copia(var, 1, posicao1));
  2122.   strcpy(parte2, Copia(var, posicao2, 256));
  2123.   sprintf(teste, "%s%s%s", parte1, var2, parte2);
  2124.   return teste;
  2125. }
  2126.  
  2127. int DiretorioArquivo(char var[256], char arquivo[256], int opcao)
  2128. {
  2129.   /* 
  2130.   Este comando lista o conteudo de um determinado diretorio
  2131.   e gera um arquivo com o conteudo em si.
  2132.  
  2133.   Versao  : 1.0
  2134.   Compila : AmigaDos
  2135.   Entrada : Path a listar --> dh0:c/ (CHAR 256)
  2136.             Arquivo Saida --> ram:saida.tmp (CHAR 256)
  2137.             Opcao         --> 1 (INT)
  2138.           * Opcao 0, grava sem path absoluta, 1 grava com path.
  2139.   Saida   : Sera gerado o arquivo com o conteudo do diretorio,
  2140.             retorna um INT, -1 tudo ok, e 0 deu erro. (INT)
  2141.             DiretorioArquivo("dh0:c/", "ram:saida.tmp", 1);
  2142.   */
  2143.  
  2144.   char teste[256];
  2145.   DIR *dfd;
  2146.   FILE *saida;
  2147.   struct dirent *dptr;
  2148.   if(strcmp(Copia2(var, strlen(var), 1), ":") &&
  2149.      strcmp(Copia2(var, strlen(var), 1), "/"))
  2150.     sprintf(teste, "%s/", var);
  2151.   else 
  2152.     strcpy(teste, var);
  2153.   if(!ExisteDiretorio(teste))
  2154.     return 0;
  2155.   if(!(saida = fopen(arquivo, "w")))
  2156.     return 0;
  2157.   dfd = opendir(teste);
  2158.   while ((dptr = readdir(dfd)) != NULL)
  2159.     if(opcao == 0)
  2160.       fprintf(saida, "%s\n", dptr->d_name);
  2161.     else
  2162.       fprintf(saida, "%s%s\n", teste, dptr->d_name);
  2163.   closedir(dfd);
  2164.   fclose(saida);
  2165.   return -1;
  2166. }
  2167.  
  2168. int TestaData(char var[256])
  2169. {
  2170.   /*
  2171.   Esta rotina testa a validade de um determinado formato de 
  2172.   data.
  2173.  
  2174.   Versao  : 1.0
  2175.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2176.   Entrada : Data [DD.MM.AAAA] --> 01.01.1997 (CHAR 256)
  2177.   Saida   : 0 se data invalida e -1 se data certa. (INT)
  2178.   Obs     : O separador de data deve ser sempre o [.]  
  2179.             Os testes de validade consistem em:
  2180.             Dia >= 1 e Dia <=31, Mes >= 1 e Mes <= 12,
  2181.             Ano >= 1900, Tamanho do formato da data = 10
  2182.             if(TestaData("01.01.1997"))
  2183.   */
  2184.           
  2185.   int dia = 0, mes = 0, ano = 0;
  2186.   dia = atoi(Corta(var, '.', 0));
  2187.   mes = atoi(Corta(var, '.', 1));
  2188.   ano = atoi(Corta(var, '.', 2));
  2189.   if(((dia < 1) || (dia > 31)) ||
  2190.      ((mes < 1) || (mes > 12)) ||
  2191.      (ano < 1900) ||
  2192.      (strlen(var) != 10))
  2193.     return 0;
  2194.   return -1;
  2195. }
  2196.  
  2197. int TestaHora(char var[256])
  2198. {
  2199.   /*
  2200.   Este comando testa se um determinado horario eh valido.
  2201.  
  2202.   Versao  : 1.0
  2203.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2204.   Entrada : Hora completa [HH:MM:SS] --> 23:59:59 (CHAR 259)
  2205.   Saida   : 0 se a hora eh invalida e -1 se a hora eh certa. (INT)
  2206.   Obs     : O separador deve ser sempre o [:]
  2207.             Os testes de validade consistem sempre em:
  2208.             Hora > 0 e Hora < 24, Minutos > 0 e Minutos < 60,
  2209.             Segundos > 0 e Segundos < 60,
  2210.             Formado da Hora = 8
  2211.             if(TestaHora("23:59:59"))
  2212.   */         
  2213.  
  2214.   int hh = 0, mm = 0, ss = 0;
  2215.   hh = atoi(Corta(var, ':', 0));
  2216.   mm = atoi(Corta(var, ':', 1));
  2217.   ss = atoi(Corta(var, ':', 2));
  2218.   if(((hh < 0) || (hh > 23)) ||
  2219.      ((mm < 0) || (mm > 59)) ||
  2220.      ((ss < 0) || (ss > 59)) ||
  2221.      (strlen(var) != 8))
  2222.     return 0;
  2223.   return -1;
  2224. }
  2225.  
  2226. int UnirArquivos(char saida[256], char lista[256]) 
  2227. {
  2228.   /*
  2229.   Este comando uni arquivos apartir de uma lista.
  2230.  
  2231.   Versao  : 1.0
  2232.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2233.   Entrada : Path+Nome Arquivo Saida --> gallas.txt (CHAR 256)
  2234.             Path+Nome Arquivo Lista --> lista.txt (CHAR 256)
  2235.   Saida   : Sera gerado o arquivo de saida contendo todos os
  2236.             arquivos incluidos na lista. O comando retorna
  2237.             0 se ocorrer erro e -1 se sucesso. (INT)
  2238.   Obs     : A lista eh um arquivo texto, ex:
  2239.             Arquivo1.txt
  2240.             Arquivo2.txt
  2241.             Arquivo3.txt
  2242.             UnirArquivos("gallas.txt", "lista.txt");
  2243.   */
  2244.  
  2245.   char a, teste[256];
  2246.   int x = 0;
  2247.   FILE *entrada;
  2248.   if(!(entrada = fopen(lista, "r")))
  2249.     return 0;
  2250.   x = 0;
  2251.   while(a = getc(entrada), ! feof(entrada))
  2252.   {
  2253.     teste[x++] = a;
  2254.     if(a == '\n')
  2255.     {
  2256.       teste[--x] = '\0';
  2257.       InsereArquivo(teste, saida);   
  2258.       teste[0] = '\0'; x = 0;
  2259.     }
  2260.   } 
  2261.   fclose(entrada);
  2262.   return -1;
  2263. }
  2264.  
  2265. char *UltimoCaracter(char var[256])
  2266. {
  2267.   /*
  2268.   Este comando retorna o ultimo caracter de uma string.
  2269.  
  2270.   Versao  : 1.0
  2271.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2272.   Entrada : String --> Cristian (CHAR 256)
  2273.   Saida   : Ultimo --> n        (CHAR 256)
  2274.             UltimoCaracter("Cristian");
  2275.   */
  2276.  
  2277.   char teste[256];
  2278.   strcpy(teste, Copia2(var, strlen(var), 1));
  2279.   return teste;
  2280. }
  2281.  
  2282. char *FiltraDir(char var[256], int opcao)
  2283. {
  2284.   /*
  2285.   Este comando filtra um diretorio.
  2286.  
  2287.   Versao  : 1.0
  2288.   Entrada : Diretorio --> tmp:gallas (CHAR 256)
  2289.             Opcao     --> 1 (INT)
  2290.           * Opcao 0 sem barra no final, 1 com barra no final.
  2291.   Obs     : Device eh retornado igual, ex: work:
  2292.   Saida   : Diretorio Filtrado --> tmp:gallas/ (CHAR 256)
  2293.             FiltraDir("tmp:gallas", 1);
  2294.   */
  2295.   
  2296.   char teste[256];
  2297.   strcpy(teste, UltimoCaracter(var));
  2298.   if(!strcmp(teste, ":"))
  2299.     return var;
  2300.   if(!strcmp(teste, "/") && opcao == 0)
  2301.     return Copia(var, 1, (strlen(var) - 1));
  2302.   if(strcmp(teste, "/") && opcao == 1)
  2303.   {
  2304.     sprintf(teste, "%s/", var);
  2305.     return teste;
  2306.   }
  2307.   return var;
  2308. }
  2309.  
  2310. int DeletaArquivos(char lista[256]) 
  2311. {
  2312.   /*
  2313.   Este comando deleta arquivos apartir de uma lista.
  2314.  
  2315.   Versao  : 1.0
  2316.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2317.   Entrada : Path+Nome Arquivo Lista --> lista.txt (CHAR 256)
  2318.   Saida   : Sera deletado todos os arquivos contidos na lista,
  2319.             0 se ocorrer erro e -1 se sucesso. (INT)
  2320.   Obs     : A lista eh um arquivo texto, ex:
  2321.             Arquivo1.txt
  2322.             Arquivo2.txt
  2323.             Arquivo3.txt
  2324.             DeletaArquivos("lista.txt");
  2325.   */
  2326.  
  2327.   char a, teste[256];
  2328.   int x = 0;
  2329.   FILE *entrada;
  2330.   if(!(entrada = fopen(lista, "r")))
  2331.     return 0;
  2332.   x = 0;
  2333.   while(a = getc(entrada), ! feof(entrada))
  2334.   {
  2335.     teste[x++] = a;
  2336.     if(a == '\n')
  2337.     {
  2338.       teste[--x] = '\0';
  2339.       remove(teste);
  2340.       teste[0] = '\0'; x = 0;
  2341.     }
  2342.   } 
  2343.   fclose(entrada);
  2344.   return -1;
  2345. }
  2346.  
  2347. char *CasasAposCaracter(char var[256], char caracter, int casas)
  2348. {
  2349.   /* 
  2350.   Este comando recorta a string determinadas casas apos um 
  2351.   caracter, partindo do inicio, bom para cortar valores, 
  2352.   determinando numero de casas apos a virgula.
  2353.  
  2354.   Versao  : 1.0
  2355.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2356.   Entrada : String      --> 123,3456 (CHAR 256)
  2357.             Caracter    --> , (CHAR 1)
  2358.             Numero apos --> 2
  2359.   Saida   : String com duas casas apos virgula --> 123,34 (CHAR 256)
  2360.             CasasAposCaracter("123,3456", ',', 2);
  2361.   */
  2362.  
  2363.   char teste[256];
  2364.   int x = 0;
  2365.   x = PosicaoCaracter(var, caracter, 1);
  2366.   x = x + casas;
  2367.   strcpy(teste, Copia(var, 1, x));
  2368.   return teste;
  2369. }
  2370.  
  2371. char *ExaminaArquivo(char arq[256], int opcao)
  2372. {
  2373.   /* 
  2374.   Este comando retira informacoes sobre um determinado arquivo.
  2375.  
  2376.   Versao  : 1.0
  2377.   Compila : AmigaDos
  2378.   Entrada : Path+Nome Arquivo --> dh2:texto.txt (CHAR 256)
  2379.             Opcao             --> 0 (INT)
  2380.   Obs     : 0 --> Tamanho em bytes do arquivo
  2381.             1 --> DiskKey
  2382.             2 --> Se eh arquivo ou diretorio, < 0 arquivo, > 0 diretorio
  2383.             3 --> Nome do arquivo
  2384.             4 --> Protecao do arquivo
  2385.             5 --> Numero de blocos do arquivo
  2386.             6 --> Comentario do arquivo
  2387.   Saida   : Qtd de caracteres --> 2434 (INT)
  2388.             ExaminaArquivo("dh2:texto.txt", 0);
  2389.   */
  2390.  
  2391.   char teste[256];
  2392.   BPTR lock;
  2393.   struct FileInfoBlock __aligned fib;
  2394.   if(!(lock = Lock(arq, SHARED_LOCK)))
  2395.     return 0;
  2396.   if(!Examine(lock, &fib)) {
  2397.     UnLock(lock);
  2398.     return 0; }
  2399.   UnLock(lock);
  2400.   switch(opcao)
  2401.   {
  2402.     case 0: sprintf(teste, "%d", fib.fib_Size); break;
  2403.     case 1: sprintf(teste, "%d", fib.fib_DiskKey); break;
  2404.     case 2: sprintf(teste, "%d", fib.fib_DirEntryType); break;
  2405.     case 3: sprintf(teste, "%s", fib.fib_FileName); break;
  2406.     case 4: sprintf(teste, "%d", fib.fib_Protection); break;
  2407.     case 5: sprintf(teste, "%d", fib.fib_NumBlocks); break;
  2408.     case 6: sprintf(teste, "%s", fib.fib_Comment); break;
  2409.   }
  2410.   return teste;
  2411. }
  2412.  
  2413. int Conectado(void)
  2414. {
  2415.   /*
  2416.   Comando para testar se o micro esta usando a library que
  2417.   conecta a web.
  2418.  
  2419.   Versao  : 1.0
  2420.   Compila : AmigaDos
  2421.   Entrada : Sem necessidade
  2422.   Saida   : 0 se conectado, e -1 se nao conectado.
  2423.             x = Conectado();
  2424.   */
  2425.     
  2426.   struct Library *SocketBase;
  2427.   if(!(SocketBase = OpenLibrary("socket.library", 0)))
  2428.     return 0;
  2429.   CloseLibrary(SocketBase);
  2430.   return -1;
  2431. }
  2432.  
  2433. int ContaStrings(char *frase, char *string)
  2434. {
  2435.   /*
  2436.   Este comando conta quantas vezes uma determinada string
  2437.   esta presente em uma outra string.
  2438.  
  2439.   Entrada : Frase             --> Cristian Robert Gallas (CHAR*)
  2440.             String a procurar --> "is" (CHAR*)
  2441.   Saida   : Numero de ocorrencias --> 1 (INT)
  2442.             x = ContaStrings("Cristian Robert Gallas", "is");
  2443.   */
  2444.  
  2445.   char *tmp;
  2446.   int x = 0;
  2447.  
  2448.   tmp = malloc(strlen(frase));
  2449.   strcpy(tmp, frase);
  2450.  
  2451.   if(!strcmp(tmp, "") || !strcmp(string, ""))
  2452.     return 0;
  2453.  
  2454.   while(strstr(tmp, string))
  2455.   {
  2456.     x++;
  2457.     strcpy(tmp, strstr(tmp, string));
  2458.     strcpy(tmp, Copia(tmp, (strlen(string) + 1), 1000));
  2459.   }
  2460.   free(tmp);
  2461.   return x;
  2462. }
  2463.  
  2464. char *SubstituiString(char *frase, char *str1, char *str2)
  2465. {
  2466.   /* Comando para substituir strings dentro de outra string.
  2467.  
  2468.   Versao  : 1.0
  2469.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2470.   Entrada : Texto principal     --> "CristianGallas" (CHAR*)
  2471.             String a substituir --> "tian" (CHAR*)
  2472.             String nova         --> "XX" (CHAR*)
  2473.   Saida   : String principal alterada
  2474.             "CrisXXGallas" (CHAR*)
  2475.             SubstituiString("CristianGallas", "tian", "XX");
  2476.   */
  2477.  
  2478.   char *saida, *parte1, *parte2, *tmp;
  2479.   int x = 0, frasefinal = 0;
  2480.  
  2481.   if(!strcmp(frase, "") || !strcmp(str1, ""))
  2482.     return frase;
  2483.  
  2484.   /* CALCULA O TAMANHO FINAL DA STRING PARA ALOCAR MEMORIA */
  2485.   x          = ContaStrings(frase, str1);
  2486.   frasefinal = (strlen(frase) - (strlen(str1) * x) + (strlen(str2) * x));
  2487.   frasefinal = frasefinal * 2;
  2488.  
  2489.   saida  = malloc(frasefinal);
  2490.   parte1 = malloc(frasefinal);
  2491.   parte2 = malloc(frasefinal);
  2492.   tmp    = malloc(frasefinal);
  2493.  
  2494.   strcpy(tmp, frase);
  2495.   strcpy(saida, frase);
  2496.   while(strstr(saida, str1))
  2497.   {
  2498.     strcpy(tmp, strstr(saida, str1));
  2499.     strcpy(parte1, Copia(saida, 1, (strlen(saida) - strlen(tmp))));
  2500.     strcpy(parte2, Copia(tmp, (strlen(str1) + 1), 1000));
  2501.     sprintf(tmp, "%s%s%s", parte1, str2, parte2);
  2502.     strcpy(saida, tmp);
  2503.   }
  2504.   strcpy(saida, tmp);
  2505.   free(parte1); free(parte2); free(tmp);
  2506.   return saida;
  2507. }
  2508.  
  2509. char *CortaStringArquivo(char *arq, char *str1, char *str2, int vezes)
  2510. {
  2511.   /*
  2512.   Comando abre um arquivo txt e corta determinado texto de dentro
  2513.   dele, delimitando inicio e fim do corte, inicio da string a achar
  2514.   e cortar ate o inicio da outra string.
  2515.  
  2516.   Versao  : 1.0
  2517.   Compila : AmigaDos, HP-UX, IBM AIX, Windows 95, Dos, Windows NT
  2518.   Entrada : Arquivo Texto    --> "ram:crg.txt" (CHAR*)
  2519.             String inicial   --> "Cristian" (CHAR*)
  2520.             String final     --> "Gallas" (CHAR*)
  2521.             Nr string no txt --> 2
  2522.             Esse numero permite o pulo de strings iniciais,
  2523.             exemplo, pegar determinado txt entre a segunda string
  2524.             inicial e a final.
  2525.   Saida   : Conteudo que existe entre a string inicial e a final
  2526.             nao sera pego as strings delimitadoras
  2527.             CortaFileString("ram:crg.txt", "Cristian", "Gallas", 2);
  2528.   */
  2529.  
  2530.   char *teste, *tmp, a;
  2531.   int x = 0;
  2532.   FILE *entrada;
  2533.  
  2534.   if(!(entrada = fopen(arq, "r")))
  2535.     return "ERROR";
  2536.  
  2537.   teste = malloc(atoi(ExaminaArquivo(arq, 0)) + 1);
  2538.   tmp   = malloc(atoi(ExaminaArquivo(arq, 0)) + 1);
  2539.  
  2540.   x = 0;
  2541.   while(a = getc(entrada),! feof(entrada))
  2542.     teste[x++] = a;
  2543.   teste[x] = '\0';
  2544.   fclose(entrada);
  2545.  
  2546.   if(!strstr(teste, str1)) {
  2547.     return teste; }
  2548.  
  2549.   for(x = 0; x < vezes; x++) {
  2550.     strcpy(teste, strstr(teste, str1));
  2551.     teste[0] = 'X'; }
  2552.  
  2553.   tmp = strstr(teste, str2);
  2554.   *tmp = '\0';
  2555.  
  2556.   strcpy(teste, Copia(teste, strlen(str1) + 1, -1));
  2557.   return teste;
  2558. }
  2559.