/*****************************************************************************
 Gestionnaire de terminal Unix: printf.c  (c) Pierre ADRIAANS 1994
*****************************************************************************/

#include "printf.h"

int Printf(char *Format,...)
 {
  int LS,CS,         /* Fenetre active d'affichage */ 
      LI,CI,
      HT,LN,
      CursY,CursX,   /* Position actuelle du curseur */
      NbPut = 0,     /* Nombre de caracteres affiches (linefeed, carriage
                        return et bell compris). Code de retour de 
			la fonction */ 
      ToPrint = 0,   /* Nombre de caracteres a reellement afficher */
      LineFeeds = 0, /* Nombre de linefeeds a imprimer */
      Reste,         /* Nombre de caracteres encore disponibles dans
      			la fenetre active */
      RowsToPrint,   /* Nombre de lignes de la fenetre active a imprimer */
      RowsLeft,      /* Nombre de lignes encore disponibles dans la
      			fenetre active */
      DeltaRows,     /* Difference des deux precedents */
      src,           /* Nbre de caracteres ajoutes par sprintf() */
      Offset,	     /* Offset dans la memoire video */
      CptFormat = 0, /* Offset dans la chaine argument */
      CptBuf = 0;    /* Offset dans la chaine de formattage */

  char Attr,           /* Attribut d'affichage courant */
       ch,             /* Caractere a afficher */
       FormatStr[10],  /* Chaine de format pour sprintf */
       TempStr[2],     /* Chaine Temporaire pour strcat */
       *FormatBuffer = (char *)NULL,  /* Buffer de formattage des arguments */
       *TmpBuf = (char *)NULL;        /* Buffer d'impression de sprintf() */


  VideoEle_t *VM;      /* Memoire video */

 /* variables de recuperation des arguments */
  int i,j;
  unsigned u;
  char c;
  double d;
  char *s;
  int *pi;
  void *p;

  va_list ap; /* pointeur d'argument dans la pile */

 /* Premiere partie: impression dans FormatBuffer par sprintf. Tous les
    formats sont recuperes un a un et passes a sprintf. L'impression commence
    au debut du buffer, et un offset suit le nombre de caracteres renvoye
    par sprintf ou place dans le buffer chaque fois. Toutes les options de
    format sont supportees.                                                 */

  FormatBuffer = (char *)malloc(PRINTF_BUF_SIZE);
  if(FormatBuffer == (char *)NULL) raise(SIGME);
  FormatBuffer[0] = 0;
  TmpBuf = (char *)malloc(PRINTF_BUF_SIZE);
  if(TmpBuf == (char *)NULL) raise(SIGME);
  TmpBuf[0] = 0;
  va_start(ap,Format); /* Initialisation sur le seul parametre fixe */

  while((Format[CptFormat] != 0) && (CptBuf < PRINTF_BUF_SIZE))
   {
    if(Format[CptFormat] != '%')      /* Afficher le caractere */
     {
      switch(Format[CptFormat])
       {
	case '\n': FormatBuffer[CptBuf] = LF; CptBuf++;
		   FormatBuffer[CptBuf] = CR; CptBuf++;
		   FormatBuffer[CptBuf] = 0;
		   CptFormat++; LineFeeds++; break;
	case '\r': FormatBuffer[CptBuf] = CR; CptBuf++; CptFormat++;
		   FormatBuffer[CptBuf] = 0; break;
	case '\t': /* Conversion du TAB en espaces: il faut aligner sur
		      des multiples de PRINTF_TAB_SIZE */
		   j = PRINTF_TAB_SIZE - (CptBuf % PRINTF_TAB_SIZE);
		   for(i=0;i<j;i++)
                    {
		     FormatBuffer[CptBuf] = SPACE;
                     CptBuf++;
                    }
		   CptFormat++;
		   FormatBuffer[CptBuf] = 0;
		   break;
	case '\b': FormatBuffer[CptBuf] = BELL; CptBuf++; CptFormat++;
		   FormatBuffer[CptBuf] = 0; break;
	default: FormatBuffer[CptBuf] = Format[CptFormat];
		 CptBuf++; CptFormat++; ToPrint++;
		 FormatBuffer[CptBuf] = 0;
		 break;
       }
     }
    else  /* Extraction de la pile et passage a sprintf */
     {
     /* Extraction de la totalite de la chaine de format */
      strcpy(FormatStr,"%");
      do
	{
         CptFormat++;
	 TempStr[0] = Format[CptFormat];
	 TempStr[1] = 0;
	 strcat(FormatStr,TempStr);
	}
      while(Format[CptFormat] != 'i' && Format[CptFormat] != 'd' &&
            Format[CptFormat] != 'o' && Format[CptFormat] != 'x' &&
            Format[CptFormat] != 'X' && Format[CptFormat] != 'u' &&
            Format[CptFormat] != 'n' && Format[CptFormat] != 'c' &&
            Format[CptFormat] != 's' && Format[CptFormat] != 'f' &&
            Format[CptFormat] != 'e' && Format[CptFormat] != 'E' &&
            Format[CptFormat] != 'g' && Format[CptFormat] != 'G' &&
            Format[CptFormat] != 'p' && Format[CptFormat] != '%');

     /* extraction de l'argument de la pile et passage a sprintf de celui-ci
	avec la chaine de format complete */
      switch(Format[CptFormat])
       {
	case 'i': /* int */
	case 'd': /* int */
		  i = va_arg(ap,int);
		  sprintf(TmpBuf,FormatStr,i);
		  strcat(FormatBuffer,TmpBuf);
		  src = strlen(TmpBuf);
		  CptBuf += src; ToPrint += src;
		  break;
	case 'o': /* unsigned int Octal */
	case 'x': /* unsigned int Hexa minuscule */
	case 'X': /* unsigned int Hexa majuscule */
	case 'u': /* unsigned int */
		  u = va_arg(ap,unsigned);
		  sprintf(TmpBuf,FormatStr,u);
		  strcat(FormatBuffer,TmpBuf);
		  src = strlen(TmpBuf);
		  CptBuf += src; ToPrint += src;
		  break;
	case 'n': /* (int *) */
		  pi = va_arg(ap,int*);
		  sprintf(TmpBuf,FormatStr,*pi);
		  strcat(FormatBuffer,TmpBuf);
		  src = strlen(TmpBuf);
		  CptBuf += src; ToPrint += src;
		  break;
	case 'c': /* Caractere */
		  c = (char)va_arg(ap,char); /* char pushe sur 2 bytes !! */
		  FormatBuffer[CptBuf] = c;
		  CptBuf++; ToPrint++;
		  FormatBuffer[CptBuf] = 0;
		  break;
	case 's': /* Pointeur sur char (string) */
		  s = va_arg(ap,char *);
		  strcat(FormatBuffer,s);
		  src = strlen(s);
		  CptBuf += src; ToPrint += src;
		  break;
	case 'f': /* Float */
	case 'e': /* Reel ou Float [-]XXXXe[+/-]XX */
	case 'E': /* Reel ou Float [-]XXXXE[+/-]XX */
	case 'g': /* Reel ou Float */
	case 'G': /* Reel ou Float */
		  d = va_arg(ap,double);
		  sprintf(TmpBuf,FormatStr,d);
		  strcat(FormatBuffer,TmpBuf);
		  src = strlen(TmpBuf);
		  CptBuf += src; ToPrint += src;
		  break;
	case 'p': /* Pointeur */
		  p = va_arg(ap,void*);
		  sprintf(TmpBuf,FormatStr,p);
		  strcat(FormatBuffer,TmpBuf);
		  src = strlen(TmpBuf);
		  CptBuf += src; ToPrint += src;
		  break;
	case '%': /* Afficher */
		  FormatBuffer[CptBuf] = '%';
		  CptBuf++; ToPrint++;
		  FormatBuffer[CptBuf] = 0;
		  break;
       } /* switch */
      CptFormat++;
     } /* else */
   } /* while */

  va_end(ap);
  FormatBuffer[CptBuf] = 0;
   /* Fin de ligne: necessaire si le dernier ajout au */
   /* buffer l'a ete directement et pas par sprintf.  */

  VM = GetVideoMemoryAdress();
  GetActiveWindow(&LS,&CS,&HT,&LN);
  LI = LS+HT-1; /* Ligne inf de la fenetre active */
  CI = CS+LN-1; /* Colonne inferieure de la fenetre active */
  GetXY(&CursY,&CursX);
  Attr = GetCurrentAtt();

  LockKbd();

  /* Scrolling anticipatif avec approximation:
      - essayer de calculer le nombre de lignes d'ecran que cet affichage
	va necessiter
      - y soustraire le nombre de lignes disponibles sans scroller
      - si le resultat est positif (pas assez de place), on scrolle
	du nombre de lignes manquantes AVANT d'imprimer, et ce en
	une seule fois. Si ca marche, c'est beaucoup plus rapide
	que de scroller plusieurs fois une ligne lors de l'affichage.
      - le mecanisme de scolling en cours d'affichage est laisse dans
	le code car les calculs ne sont pas fiables a 100 %
      - pour des fenetres actives <= 3, les calculs plantent */

  RowsToPrint = (ToPrint / LN) + LineFeeds;
  Reste = ((LI-CursY) * LN)+(CI-CursX);
  RowsLeft = Reste / LN;
  DeltaRows = RowsToPrint - RowsLeft -1;
  if(DeltaRows > 0 && DeltaRows < HT && HT > 3)
   {
    ScrollUpWin(LS,CS,HT,LN,DeltaRows);
    CursY -= DeltaRows;
    GotoXY(CursY,CursX);
   }

  while((ch = FormatBuffer[NbPut]) != 0)
   {
    switch(ch)
     {
      case BELL: putchar(BELL);
		 NbPut++;
		 break;
      case LF: if(CursY == LI) ScrollUpWin(LS,CS,HT,LN,1);
	       else { CursY++; GotoXY(CursY,CursX); }
	       NbPut++;
	       break;
      case CR: CursX = CS;
	       GotoXY(CursY,CursX);
	       if(FormatBuffer[NbPut - 1] == LF) fflush(stdout);
	       NbPut++;
	       break;
      default: if(isdisplay(ch))
		{
		 PutToScr(ch);
		 Offset = VidMemOffset(CursY,CursX);
		 VM[Offset].Code = ch;
		 VM[Offset].Attr = Attr;
		 CursX++;
		 SetXY(CursY,CursX);
		 if(CursX > CI)
		  {
		   CursX = CS;
		   if(CursY == LI)
		    ScrollUpWin(LS,CS,HT,LN,1);
		   else
		    CursY++;
		   GotoXY(CursY,CursX);
		  }
		}
	       NbPut++;
     }
   }
  free(FormatBuffer);
  free(TmpBuf);
  UnlockKbd();
  return(NbPut);
 }