Funções em C ANSI

Valores em reais por extenso

Interface com o NATURAL (ADABAS)

#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include "funcoes.h"
#include "natuser.h"
#define  BRANCO	  32
#define  TAMBUF	  1250
 
/*----------------------------------------------------------------------*
 *									*
 *	Modulo ....................... PB19040A				*
 *	Autor ........................ Lercio Teotonio Gontijo		*
 *	Data ......................... 14 de julho de 1994		*
 *	Funcao ....................... Valores monetarios por extenso 	*
 *									*
 *	Descricao sumaria:						*
 *									*
 *	Esta subrotina sera chamada no NATURAL AIX com a passagem de	*
 *	3 parametros. O primeiro parametro sera o valor a ser conver-	*
 *	tido por extenso e podera ter no maximo 14 bytes devendo ser	*
 *	composto somente por numeros ("8234868743" por exemplo).   O	*
 *	segundo parametro sera o tamanho do primeiro parametro ("10"	*
 *	por exemplo). O ultimo parametro sera a area reservada de 255	*
 *	bytes para receber o valor por extenso.				*
 *									*
 *	Se ocorrer algum erro na passagem dos parametros a subrotina	*
 *	ira devolver um "*" (asterisco) no terceiro parametro junta-	*
 *	mente com um return code diferente de 0.			*
 *									*
 *----------------------------------------------------------------------*/
long PB19040A (WORD nparm, BYTE **parmptr, FINFO *parmdec)
{
  char extenso[255], *pointer, string[20];
  int tam;
 
  extenso[0] = '*';
  extenso[1] = 0;
  memmove((char *) parmptr[2], (char *) &extenso, 2);
 
  memmove((char *) &string, (char *) parmptr[1], 2); /* OBTEM O TAMANHO */
  string[2] = '\0';				     /* COM DOIS BYTES  */
  tam = atoi(string);		      /* MOVE PARA UMA VARIAVEL INTEIRA */
  if (tam > 14) return 1;	      /* TAMANHO LIMITADO EM 14 BYTES   */
  memmove((char *) &string, (char *) parmptr[0], tam);
  string[tam]= '\0';		      /* OBTEM O VALOR COM O TAMANHO 	*/
 
  pointer = Extenso(string,0);
  if (pointer[0] == 32) pointer++;
  strcpy(extenso,pointer);
 
  memmove((char *) parmptr[2], (char *) &extenso, strlen(extenso));
 
  return 0;
}

Include do funcoes.h

#define  BRANCO	  32
#define  TAMBUF	  1250
 
extern char tab1[15][15];
extern char tab2[37][15];
extern int  indice, redondo, decimais, centenas, flag1, jareais;
 
extern void clear(unsigned char linhas);
extern char *strrev(char *string);
extern void MontaTipo(char tipo);
extern char *Dezenas(char *string);
extern char *Centenas(char *string);
extern void MontaTabela();
extern char *ComeBrancos(char *string);
extern int  ConsisteData(char *Data, char tipo);
extern int  ImpressaoOnline(FILE *out,char *tamanho,char *saltos,char *cor,char *texto);

Funcao de Reais por Extenso

#include <stdio.h>
#define  BRANCO	  32
#define  TAMBUF	  1250
 
char tab1[15][15];
char tab2[37][15];
int  indice, redondo, decimais, centenas, flag1, jareais;
char *Dezenas(char *string);
 
void clear(unsigned char linhas)
{
   char i;
   for(i=0;i<linhas;i++,printf("%79s\n"," "));
}
 
char *strrev(char *string)
{
   char buffer[TAMBUF];
   int i, j, length;
   for(length=0;string[length]!=0;length++)
      if ( length > TAMBUF-1)
      {
	 clear(25);
	 printf("Programa cancelado no uso da funcao \"strrev\"\n");
	 printf("Limite de %s excedido.\n\n",TAMBUF);
	 exit(0);
      }
   for(j=0,i=length;i>0;i--,j++)
      buffer[j] = string[i-1];
   buffer[length] = 0;
   strcpy(string,buffer);
   return(string);
}
 
void MontaTipo(char tipo) 
{
   char Tipos[4][15], i;
   strcpy(Tipos[0]," CENTIMETRO");
   strcpy(Tipos[1]," CENTIMETROS");
   strcpy(Tipos[2]," METRO");
   strcpy(Tipos[3]," METROS");
   if (tipo)
      for(i=0;i<4;i++)
	 strcpy(tab1[i],strrev((char *)Tipos[i]));
}
 
char *Centenas(char *string) {
   char *pointer, extenso[80];
   if (strlen(string) == 0)
      return(string);
   extenso[0] = centenas = 0;
   pointer = string;
   pointer += strlen(string) - 1;
   if (pointer[0]-48 < 1)
      return("");
   centenas = 1;
   if (atoi(pointer) == 1) {
      if (redondo)
	 strcat(extenso,"OTNEC ");
      else {
	 if (!jareais || indice > 2)
	    strcpy(extenso,tab1[indice+1]);
	 strcat(extenso,"MEC ");
      }
      return(extenso);
   }
   if (!redondo && (!jareais || indice > 2))
      strcpy(extenso,tab1[indice+1]);
 
   strcat(extenso,tab2[pointer[0]-48+26]);
 
   return(extenso);
}
 
void MontaTabela() {
   strcpy(tab2[0],"MU ");
   strcpy(tab2[1],"SIOD ");
   strcpy(tab2[2],"SERT ");
   strcpy(tab2[3],"ORTAUQ ");
   strcpy(tab2[4],"OCNIC ");
   strcpy(tab2[5],"SIES ");
   strcpy(tab2[6],"ETES ");
   strcpy(tab2[7],"OTIO ");
   strcpy(tab2[8],"EVON ");
   strcpy(tab2[9],"ZED ");
   strcpy(tab2[10],"EZNO ");
   strcpy(tab2[11],"EZOD ");
   strcpy(tab2[12],"EZERT ");
   strcpy(tab2[13],"EZROTAUQ ");
   strcpy(tab2[14],"EZNIUQ ");
   strcpy(tab2[15],"SIESSEZED ");
   strcpy(tab2[16],"ETESSEZED ");
   strcpy(tab2[17],"OTIOZED ");
   strcpy(tab2[18],"EVONEZED ");
 
   strcpy(tab2[19],"ETNIV ");
   strcpy(tab2[20],"ATNIRT ");
   strcpy(tab2[21],"ATNERAUQ ");
   strcpy(tab2[22],"ATNEUQNIC ");
   strcpy(tab2[23],"ATNESSES ");
   strcpy(tab2[24],"ATNETES ");
   strcpy(tab2[25],"ATNETIO ");
   strcpy(tab2[26],"ATNEVON ");
   strcpy(tab2[27],"OTNEC ");
   strcpy(tab2[28],"SOTNEZUD ");
   strcpy(tab2[29],"SOTNEZERT ");
   strcpy(tab2[30],"SOTNECORTAUQ ");
   strcpy(tab2[31],"SOTNEHNIUQ ");
   strcpy(tab2[32],"SOTNECSIES ");
   strcpy(tab2[33],"SOTNECETES ");
   strcpy(tab2[34],"SOTNECOTIO ");
   strcpy(tab2[35],"SOTNECEVON ");
 
   strcpy(tab1[0], "OVATNEC ");
   strcpy(tab1[1], "SOVATNEC ");
   strcpy(tab1[2], "LAER ");
   strcpy(tab1[3], "SIAER ");
   strcpy(tab1[4], "LIM ");
   strcpy(tab1[5], "LIM ");
   strcpy(tab1[6], "OAHLIM ");
   strcpy(tab1[7], "SEOHLIM ");
   strcpy(tab1[8], "OAHLIB ");
   strcpy(tab1[9], "SEOHLIB ");
   strcpy(tab1[10],"OAHLIRT ");
   strcpy(tab1[11],"SEOHLIRT ");
   strcpy(tab1[12],"OAHLIRTAUQ ");
   strcpy(tab1[12],"SEOHLIRTAUQ ");
   strcpy(tab1[14],"*********** "); /* FINAL FLAG */
}
 
 
char *ComeBrancos(char *string)
{
   long i, j;
   char *pointer;
   pointer = string;
   while(!*pointer) pointer++;
   for(i=0;*pointer;pointer++)
      if (*pointer != ' ' || (*pointer+1 != ' ' && *pointer+1 != 0)) 
	 string[i++] = *pointer;
   string[i-1]=0;
   return(string);
}
 
 
ConsisteData(char *Data, char tipo)
{
   int dia, mes, ano;
   char str[4];
   str[2] = str[3] = '\0';
 
   switch(tipo)
   {
      case 'G' : /* Data gregoriana	*/
	 str[0] = Data[0]; str[1] = Data[1]; dia = atoi(str);
	 str[0] = Data[2]; str[1] = Data[3]; mes = atoi(str);
	 str[0] = Data[4]; str[1] = Data[5]; ano = atoi(str);
	 if ((mes < 1) || (mes > 12)) return 0;
	 if ((dia < 1) || (dia > 31)) return 0;
	 if ((mes == 2) && (ano % 4 == 0) && (dia > 29)) return 0;
	 if ((mes == 2) && (ano % 4 != 0) && (dia > 28)) return 0;
	 if ((mes == 4 || mes == 6 || mes == 9 || mes == 11) 
            && (dia > 30)) return 0;
	 break;
      case 'J' : /* Data juliana	*/
	 str[0] = Data[0]; str[1] = Data[1]; str[2] = '\0'; ano = atoi(str);
	 str[0] = Data[2]; str[1] = Data[3]; str[2] = Data[4];
	 dia = atoi(str);
	 if (ano % 4 == 0)
	 {
	    if ((dia < 1) || (dia > 366))
	       return 0;
	 }
	 else
	    if ((dia < 1) || (dia > 365))
	       return 0;
	 break;
      default : return 0;
   }
   return 1;
}
 
 
/*----------------------------------------------------------------------*
 *									*
 *	Modulo ........................... Extenso			*
 *	Autor ............................ Lercio Teotonio Gontijo	*
 *	Data ............................. 13 de julho de 1994		*
 *	Local ............................ PRODABEL - GAD		*
 *	Funcao ........................... Valores em reais por extenso *
 *									*
 *	Descricao Sumaria:						*
 *									*
 *	Foram desenvolvidas 4 funcoes para conversao de valores em 	*
 *	reais por extenso relacionadas na ordem que sao usadas:		*
 *									*
 *		1 - char *Extenso(char *string,char tipo)		*
 *		2 - char *Dezenas(char *string)				*
 *		3 - char *Centenas(char *string)			*
 *									*
 *	1 - char *Extenso(char *string)					*
 *		Recebe um string (valor alfanumerico) contendo o numero *
 *		a ser convertido por extenso. Precede a casa dos centa- *
 *		vos com um "0" se o numero tiver mais de 2 algarismos.  *
 *		Há duas tabelas,a primeira, tipo de unidade, possui 15	*
 *		palavras:						*
 *		CENTAVO - CENTAVOS		REAL - REAIS		*
 *		MIL - MIL			MILHAO - MILHOES	*
 *		BILHAO - BILHOES		TRILHAO - TRILOES	*
 *		QUATRILHAO - QUATRILHOES	******* (flag fim)	*
 *		MAIOR NUMERO: 99.999.999.999.999,99			*
 *									*
 *		A segunda tabela, valores por extenso, possui 36:	*
 *		UM - DOIS ate VINTE (inclusive), TRINTA - QUARENTA -	*
 *		CINQUENTA - SESSENTA - SETENTA - OITENTA - NOVENTA -	*
 *		CENTO - DUZENTOS - TREZENTOS - QUATROCENTOS - 		*
 *		QUINHENTOS - SEISCENTOS - SETECENTOS - OITOCENTOS e	*
 *		por fim NOVECENTOS.					*
 *									*
 *		A rotina processa a conversao do numero de 3 em 3 	*
 *		algarismos da direita para a esquerda gerando, primeiro *
 *		CENTAVOS e por ultimo TRILHOES, existe tratamento	*
 *		para o caso especial "CEM" e para os "E". Ao final da	*
 *		conversao o extenso gerado sera invertido e retornado	*
 *		a rotina chamadora.					*
 * 									*
 *      	Exemplo de chamada a funcao:				*
 *									*
 *		#include <stdio.h>					*
 *		char *Extenso(char *,char *) / * prototipacao * /	*
 *		int main(void)						*
 *		{							*
 *		  char *pointer; / * declara um ponteiro de memoria * /	*
 *		  pointer = Extenso("456746936786","1");		*
 *		  printf("Numero por extenso: %s\n",pointer);		*
 *		  return 0;						*
 *		}							*
 *									*
 *	2 - char *Dezenas(char *string) 				*
 *									*
 *		Recebe a parte remanescente do string (o pedaco que	*
 *		ainda falta ser convertido), pega as duas posicoes	*
 *		mais a direita, se o resultado der menos que dois 	*
 *		algarismos o numero sera precedido de zeros ate com-	*
 *		pletar duas possices (dois algarismos) e sera entao	*
 *		convertido para extenso.				*
 *		A ROTINA DEVOLVE O STRING CONVERTIDO.			*
 *									*
 *	3 - char *Centenas(char *string) 				*
 *									*
 *		Recebe a parte remanescente do string (o pedaco que	*
 *		ainda falta ser convertido), pega a ultima posicao e	*
 *		converte por extenso.					*
 *		A ROTINA DEVOLVE O STRING CONVERTIDO.			*
 *									*
 *----------------------------------------------------------------------*/
 
char *Extenso(char *string,char *tipo) 
{
   char  *pointer, extenso[304];
   unsigned long valor;
 
   extenso[0] = 0;
   indice = 0;
   jareais = 0;
   pointer = string;
   while(*pointer == '0') pointer++;    /* IGNORA OS ZEROS INICIAIS */
   strcpy(string,pointer);
   valor = atol(string);
 
   MontaTipo(tipo);
 
   /*
	   * Se numero a ser convertido por extenso tiver dois ou
	     mais algarismos, os dois algarismos mais a direita
	     serao precedidos por um "0" (zero), permitindo desta
	     forma que a conversao utilize a tabela padrao. Assim:
	     CASO 1: O numero recebido     "83",
		     o numero convertido  "083",
	     CASO 2: O numero recebido	  "1234",
		     o numero convertido "12034".
	     Isto nao afetara a conversao porque a rotina de Dezenas()
	     convertera os dois algarismos a direita (83 caso 1 e 34
	     caso 2) e a rotina Centenas() convertera o proximo algaris-
	     mo que sera sempre "0" e nao produzira nenhum resultado.
 
   */
   if (strlen(string) > 2) {                   /* SE VALOR MAIOR QUE CENTAVOS */
      pointer = string + strlen(string) - 2;   /* LOCALIZA CENTAVOS DO VALOR */
      strcpy(extenso,"0");                     /* COLOCA ZERO NO EXTENSO */
      strcat(extenso,pointer);                 /* ACRESCENTA CENTAVOS NO EXTENSO */
      pointer[0] = 0;                          /* ENCERRA STRING NA UNIDADE  */
      strcat(string,extenso);                  /* ACRESCENTA EXTENSO NO STRING */
      extenso[0] = 0;     /* DEVOLVE VASIO PARA EXTENSO */
   }
 
   /*------------------------------------------------------------------*\
    *	    PROCESSAMENTO DO STRING (NUMERO) A SER CONVERTIDO	       *
   \*------------------------------------------------------------------*/
 
   while(strlen(string) > 0) {
      pointer = Dezenas(string); 	/* CONVERTE DEZENAS 		*/
      string[strlen(string)-2] = 0;	/* ELIMINA DOIS BYTES A DIREITA */
      if (strlen(extenso) > strlen(tab1[2]) &&	/* COLOCA OU NAO COLOCA "E"	*/
         extenso[strlen(extenso)-2] != 'E' &&
	 strcmp(&extenso[strlen(extenso)-strlen(tab1[2])],strrev(tab1[2])) &&
	 strcmp(&extenso[strlen(extenso)-strlen(tab1[3])],strrev(tab1[3])))
         strcat(extenso,"E ");
      strcat(extenso,pointer);		/* GUARDA EXTENSO CONVERTIDO 	*/
 
      pointer = Centenas(string);	/* CONVERTE CENTENAS 		*/
      string[strlen(string)-1] = 0;	/* ELIMINA UM BYTES A DIREITA */
 
      if (string[strlen(string)-1] > MENOSVIRANUM &&
	 strlen(extenso) > strlen(tab1[2]) &&	/* COLOCA OU NAO COLOCA "E"	*/
	 extenso[strlen(extenso)-2] != 'E' &&
	 strcmp(&extenso[strlen(extenso)-strlen(tab1[2])],strrev(tab1[2])) &&
	 strcmp(&extenso[strlen(extenso)-strlen(tab1[3])],strrev(tab1[3])))
         strcat(extenso,"E ");
      indice += 2;			/* INCREMENTA INDICE TABELA 1	*/
 
      if (strlen(pointer) > 0 && decimais > 0 && !flag1)
	 if (extenso[strlen(extenso)-2] != 'E')
	    strcat(extenso,"E ");	/* COLOCA OU NAO COLOCA "E"	*/
      strcat(extenso,pointer);          /* GUARDA EXTENSO CONVERTIDO	*/
      if (strlen(pointer) > 0 && centenas > 0 && strlen(string) > 0)
	 strcat(extenso,"E ");		/* COLOCA OU NAO COLOCA "E"	*/
      if (strlen(string) &&
	 strlen(extenso) > strlen(tab1[2]) &&	/* COLOCA OU NAO COLOCA "E"	*/
	 extenso[strlen(extenso)-2] != 'E' &&
	 strcmp(&extenso[strlen(extenso)-strlen(tab1[2])],strrev(tab1[2])) &&
	 strcmp(&extenso[strlen(extenso)-strlen(tab1[3])],strrev(tab1[3])))
         strcat(extenso,"E ");
      if (strlen(string) && !jareais) { /* COLOCA A PALAVRA REAIS ???	*/
	 if (strlen(string) == 1 && string[0] == '1')
	    strcat(extenso,strrev(tab1[2]));
	 else strcat(extenso,strrev(tab1[3]));
	 jareais = 1;
      }
      if (tab1[indice][0] == '*')	/* STRING DE VALOR ALTO 	*/
	 break;
   }
 
   pointer = strrev(extenso);
   return(pointer);
}
 
 
 
char *Dezenas(char *string) 
{
   int  num;
   char *pointer, extenso[204];
 
   extenso[0] = decimais = flag1 = redondo = 0;
 
   if (strlen(string) < 1)
      return(string);
   pointer = string;
   if (strlen(string) > 2) {
      pointer += strlen(string) - 2;
      num = atoi(pointer);
      sprintf(pointer,"%02d",num);
   } else {
      num = atoi(string);
      sprintf(pointer,"%02d",num);
   }
   if (num > 1) {
      if (!jareais || indice > 2)
	 strcpy(extenso,strrev(tab1[indice+1]));
      redondo = 2;
   }
   else if (num == 1) {
      if (strlen(string) < 3 && (!jareais || indice > 2))
	 strcpy(extenso,strrev(tab1[indice]));
      else if (indice > 2 && (!jareais || indice > 2))
	 strcpy(extenso,strrev(tab1[indice+1]));
      else if (indice < 2 && (!jareais || indice > 2))
	 strcpy(extenso,strrev(tab1[indice]));
      else if (!jareais || indice > 2)
	 strcpy(extenso,strrev(tab1[indice+1]));
      redondo = flag1 = 1;
   }
 
   if (num < 21 && num > 0)
      strcat(extenso,strrev(tab2[num-1]));
   else {
      if (pointer[1]-MENOSVIRANUM > 0)
	 strcat(extenso,strrev(tab2[pointer[1]-MENOSVIRANUM-1]));
      if (pointer[0]-MENOSVIRANUM > 1) {
	 if (pointer[1]-MENOSVIRANUM > 0)
	    strcat(extenso,"E ");
	 strcat(extenso,strrev(tab2[MAIS2ACHAVINTE+pointer[0]-MENOSVIRANUM]));
      }
   }
   if (num)
      decimais = 1;
   return(extenso);
}