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