BurritOS/test/userlib/libnachos.c

/*! \file libnachos.c
 *  \brief Functions of our library, for user programs.
 *
 * This library only provides some  usefull functions for
 * programming.
 * 
 * -----------------------------------------------------
 * This file is part of the Nachos-RiscV distribution
 * Copyright (c) 2022 University of Rennes 1.
 * 
 * This program is free software: you can redistribute it and/or modify  
 * it under the terms of the GNU General Public License as published by  
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
 * General Public License for more details 
 * (see see <http://www.gnu.org/licenses/>).
 * -----------------------------------------------------
 */

#include "libnachos.h"
#include <stdarg.h>
#include <stdint.h>

//----------------------------------------------------------------------
// threadStart()
/*!	Makes a thread execute a function or program. This function
//      is static, it is called internally by library function threadCreate
//      and should not be called directly by user programs. The interest
//      of this function is to be able to terminate threads correctly,
//      even when the thread to be terminated does not explicitly call
//      Exit. threadStart provides the mechanism by which Exit
//      is called automatically
//
//	\param func is the identificator of the function to execute.
*/
//----------------------------------------------------------------------

static void threadStart(uint64_t func)
{
    VoidNoArgFunctionPtr func2;
    func2=(VoidNoArgFunctionPtr)func;
    // Call the function that actually contains the thread code
    (*func2)();
    // Call exit, such that there is no return using an empty stack
    Exit(0);    
}

//----------------------------------------------------------------------
// threadCreate()
/*!	 Creates a thread and makes it execute a function.
//
//      NB : instead of directly executing the required function,
//           function threadStart is called so as to ensure
//           that the thread will properly exit
//      This function must be called instead of calling directly
//      the system call newThread
//
//      \param name the name of the thread (for debugging purpose)
//	\param func is the address of the function to execute.
*/
//----------------------------------------------------------------------
ThreadId threadCreate(char *debug_name, VoidNoArgFunctionPtr func) 
{ 
    return newThread(debug_name, (uint64_t)threadStart,(uint64_t)func);
}

//----------------------------------------------------------------------
// n_strcmp()
/*!	String comparison
//
//	\param s1 is the first string,
//	\param s2 is the second one.
//	\return an integer greater than, equal to, or less than 0,
//	  if the first string is greater than, equal to, or less than 
//	  the the second string. 
*/
//----------------------------------------------------------------------
int n_strcmp(const char *s1, const char *s2)
{
  int comparaison;
  int fini=0;
  int i=0;
  while(!fini) {
    if ((s1[i]==0)&&(s2[i]==0)) {
      fini=1;
      comparaison=0;
    }
    if (s1[i]<s2[i]) {
      fini=1;
      comparaison=-1;
    }
    if(s1[i]>s2[i]) {
      fini=1;
      comparaison=1;
    }
    i++;
  }
  return comparaison;
}

//----------------------------------------------------------------------
// n_strcpy()
/*!	String copy
//
//	\param dst is where the string is to be copied,
//	\param src is where the string to copy is.
//	\return dst, if the copy successes, 0 otherwise
*/
//----------------------------------------------------------------------
char *n_strcpy(char *dst, const char *src)
{
  int i=0;
  int fini=0;
  if ((dst!=0)&&(src!=0)) {
    while(fini==0) {
      if(src[i]=='\0') fini=1;
      dst[i]=src[i];
      i++;
    }
    return dst;
  }
  else return 0;
}

//----------------------------------------------------------------------
// n_strlen()
/*!	Gives the number of bytes in a string, not including the 
//	terminating null character.
//
//	\param c is a pointer onto a string.
//	\return the length of the string.
*/
//----------------------------------------------------------------------
size_t n_strlen(const char *s)
{
  size_t i=0;
  while (s[i] != 0) i++;
  return i;
}


//----------------------------------------------------------------------
// n_strcat()
/*!	Appends a copy of a string, including null character, to the end
//	of another string. Enough memory has to be available in the
//      destination string.
//
//	\param dst is a pointer onto the string where the other string
//	will be appended.
//	\param src is the string to append.
//	\return the pointer string dst.
*/
//----------------------------------------------------------------------
char *n_strcat(char *dst, const char *src)
{
  int i,j,k;
  i=(int)n_strlen(dst);
  j=(int)n_strlen(src);  
  for(k=i;k<=j+i;k++) {
      dst[k]=src[k-i];
  }
  return dst;
}


//----------------------------------------------------------------------
// n_toupper()
/*!	Gives the upper-case letter corresponding to the lower-case
//	letter passed as parameter.
//
//	\param c is the ASCII code of the letter to transform.
//	\return the corresponding upper-case letter 
*/
//----------------------------------------------------------------------
int n_toupper(int c)
{
  if((c>='a')&&(c<='z'))
	return c+('A'-'a');
  else return c;
}

//----------------------------------------------------------------------
// n_tolower()
/*!	Gives the lower-case letter corresponding to the upper-case
//	letter passed as parameter
//
//	\param c is the ASCII code of the letter to transform.
//	\return the corresponding lower-case letter 
*/
//----------------------------------------------------------------------
int n_tolower(int c)
{
  if((c<='Z')&&(c>='A'))
	return c+('a'-'A');
  else return c;
}

//----------------------------------------------------------------------
// n_atoi()
/*!	String to integer conversion.
//
//	\param c is a pointer onto a string.
//	\return the corresponding value 
*/
//----------------------------------------------------------------------
int n_atoi(const char *str)
{
  int i=0;
  int fini=0;
  int val=0;
  int negative = 0;
  if (str[i] == '-') {
    negative = 1; i=1;
  }
  while(!fini)
    {
      if(str[i]==0 || str[i]<'0' || str[i]>'9')
	fini=1;
      else 
	{
	  val*=10;
	  val+=str[i]-'0';
	  i++;
	}
    }
  if (negative) return(-val); else return val;
}

//----------------------------------------------------------------------
// n_memcmp()
/*!	Memory comparison.
//
//	\param s1 is the first memory area,
//	\param s2 is the second memory area.
//      \param n size in bytes of the area to be compared.
//	\return an integer less than, equal to, or greater than 0, 
//	according as s1 is lexicographically less than, equal to, 
//	or greater than s2 when taken to be unsigned characters.
//
*/
//----------------------------------------------------------------------
int n_memcmp(const void *s1, const void *s2, size_t n)
{
  unsigned char* c1=(unsigned char*)s1;
  unsigned char* c2=(unsigned char*)s2;

  int comparaison=0;
  int fini=0;
  int i=0;
  while ((!fini)&&(i<n)) {
    if (c1[i]<c2[i]) {
      fini=1;
      comparaison=-1;
    }
    if (c1[i]>c2[i]) {
      fini=1;
      comparaison=1;
    }
    i++;
  }
  return comparaison;
}

//----------------------------------------------------------------------
// n_memcpy()
/*!	Memory copy.
//
//	\param s1 is where the elements are to be copied,
//	\param s2 is the memory area to copy.
//      \param n size in bytes of the area to be copied.
//	\return the memory area where the copy has been done.
*/
//----------------------------------------------------------------------
void *n_memcpy(void *s1, const void *s2, size_t n)
{
 
  unsigned char* c1=(unsigned char*)s1;
  unsigned char* c2=(unsigned char*)s2;
  
  int i=0;
  if ((c1!=0)&&(c2!=0)) {
    while(i<n) {
      c1[i]=c2[i];
      i++;
    }
    return (void *)c1;
  }
  else return 0;
}


//----------------------------------------------------------------------
// n_memset()
/*!	Sets the first n bytes of a memory area to a value (converted to 
//	an unsigned char).
//
//	\param s is the memory area to transform,
//	\param c is the value wanted,
//	\param n is the number of bytes to put at c.
//	\return s.
*/
//----------------------------------------------------------------------
void *n_memset(void *s, int c, size_t n)
{
  unsigned char* c1=(unsigned char*)s;
  int i;
  for (i=0;i<n;i++) {
    c1[i]=c;
  }
  return (void *)c1;
}

//----------------------------------------------------------------------
// n_dumpmem()
/*!	Dumps on the string the n first bytes of a memory area
//      (used for debugging)
//
//	\param addr address of the memory area
//	\param len number of bytes to be dumped
*/
//----------------------------------------------------------------------
void n_dumpmem(char *addr, int len)
{
#define TOHEX(x) \
  ({ char __x = (x); if(__x < 10) __x+='0'; else __x='a'+(__x-10) ; __x; })

  int i;
  for (i = 0 ; i < len ; i++) {
    char s[3];
    if ((i%16) == 0)
      n_printf("%x\t", (unsigned long)&addr[i]);
    else if ((i%8) == 0)
      n_printf("   ");
    s[0] = TOHEX((addr[i] >> 4) & 0xf);
    s[1] = TOHEX(addr[i] & 0xf);
    s[2] = '\0';
    n_printf("%s ", s);
    if ((((i+1)%16) == 0) || (i == len-1))
      n_printf("\n");
  }
}

#define PUTCHAR(carac) \
  do { \
    if (result < len-1) *buff++ = carac;\
    result++; \
  } while (0)


//----------------------------------------------------------------------
// n_vsnprintf()
/*!	Build a string according to a specified format (internal function)
//
//	Nachos vsnprintf accepts:
//		%c to print a character,
//		%s, to print a string,
//		%d, to print an integer,
//		%x, to print an integer in hexa
//              %lx %ld same for 64-bit values
//              %f, to print a floating point value
//
//      \param buff the destination buffer to generate the string to
//      \param len the size of buff, determines the number max of
//        characters copied to buff (taking the final \0 into account)
//	\param format the string to parse
//	\param ap parameters to print
//
//      \return the number of characters formatted (NOT including \0),
//        that is, the number of characters that would have been written
//        to the buffer if it were large enough. -1 on error.
*/
//----------------------------------------------------------------------
static int n_vsnprintf(char *buff, int len, const char *format, va_list ap)
{
  int i, result;

  if (!buff || !format || (len < 0)) {
    return -1;
  }
  result = 0;

  for (i=0 ; format[i] != '\0' ; i++) {
    switch (format[i]) {
    case '%':
      i++;
      switch(format[i]) {
      case '%': {
	PUTCHAR('%');
	break;
      }
      case 'i':
      case'd': {
	int integer = (int) va_arg(ap,int);
	int cpt2 = 0;
	char buff_int[11];
	if (integer<0) {PUTCHAR('-');
	}
	do {	
	  int m10 = integer%10;
	  m10 = (m10 < 0)? -m10:m10;
	  buff_int[cpt2++]=(char)('0'+ m10);
	  integer=integer/10;
	} while(integer!=0);
	for (cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--) {
	  PUTCHAR(buff_int[cpt2]);
	}
	break;
      }
      case 'l': {
	i++;
	switch(format[i]) {
	case 'd': {
	  long longer = va_arg(ap,long);
	  int cpt2 = 0;
	  char buff_long[20];
	  if (longer<0) {
	    PUTCHAR('-');
	  }
	  do {	
	    int m10 = longer%10;				
	    m10 = (m10 < 0)? -m10:m10;
	    buff_long[cpt2++]=(char)('0'+ m10);
	    longer=longer/10;
	  } while(longer!=0);
	  for (cpt2 = cpt2 - 1 ; cpt2 >= 0 ; cpt2--) {
	    PUTCHAR(buff_long[cpt2]);
	  }
	  break;
	}
	case 'x': {
	  uint64_t hexa = va_arg(ap,long);
	  uint64_t nb;
	  uint32_t i, had_nonzero = 0;
	  for (i=0 ; i < 16 ; i++) {
	    nb = (hexa << (i*4));
	    nb = (nb >> 60);
	    nb = nb & 0x000000000000000f;
	    // Skip the leading zeros
	    if (nb == 0) {
	      if (had_nonzero) {
		PUTCHAR((uint8_t)'0');
	      }
	    }
	    else {
	      had_nonzero = 1;
	      if (nb < 10)
		PUTCHAR((uint8_t)'0'+(uint8_t)nb);
	      else
		PUTCHAR((uint8_t)'a'+(uint8_t)(nb-10));
	    }
	  }
	  if (! had_nonzero)
	    PUTCHAR((uint8_t)'0');
	  break;
	}
	default: {
	  PUTCHAR('%');		
	  PUTCHAR('l');
	  PUTCHAR(format[i]);
	  break;
	}
	}
	
	break;
      }
      case 'c': {
	int value = va_arg(ap,int);
	PUTCHAR((char)value);
	break;
      }
      case 's': {
	char *string = va_arg(ap,char *);
	if (! string)
	  string = "(null)";
	for( ; *string != '\0' ; string++)
	  PUTCHAR(*string);
	break;
      }
      case 'x':  {
	uint32_t hexa = va_arg(ap,int);
	uint32_t nb;
	uint32_t i, had_nonzero = 0;
	for (i=0 ; i < 8 ; i++) {
	  nb = (hexa << (i*4));
	  nb = (nb >> 28);
	  nb = nb & 0x0000000f;
	  // Skip the leading zeros
	  if (nb == 0) {
	    if (had_nonzero)
	      PUTCHAR((uint8_t)'0');
	  }
	  else {
	    had_nonzero = 1;
	    if (nb < 10)
	      PUTCHAR((uint8_t)'0'+(uint8_t)nb);
	    else
	      PUTCHAR((uint8_t)'a'+(uint8_t)(nb-10));
	  }
	}
	if (! had_nonzero)
	  PUTCHAR((uint8_t)'0');
	break;
      }
	/*case 'f': {
	// Very simple routine to print floats as xxxx.yyyyy
	// Not very good (unable to print large numbers)
	// If anyone wants to re-write it, feel free ...
	double f = (double) va_arg(ap,double);
	int cpt2, j;
	char buff_float[200];
	long ient,idec;
	if (f<0) {
	  PUTCHAR('-');
	  f = -f;
	}
	ient = (int)f;
	// 100000 = print 5 digits max
	idec = (int)((f - ((double)ient))*100000);
	// Round up
	if ( f - ((double)ient) - ((double)idec)/100000.0 >= 0.5E-5)
	  idec ++;
	cpt2 = 0;
	// Print digits after the '.'
	for (j=0 ; j<5 ; j++) {
	  buff_float[cpt2++]=(char)('0'+(idec%10));
	  idec=idec/10;
	}
	buff_float[cpt2++] = '.';
	// Print digits before the '.'
	do {
	  buff_float[cpt2++]=(char)('0'+ (ient%10));
	  ient=ient/10;
	} while (ient!=0);
	for(j = cpt2 - 1 ; j >= 0 ; j--)
	  PUTCHAR(buff_float[j]);
	break;
      }
	*/
      default:
	PUTCHAR('%');
	PUTCHAR(format[i]);
      }
      break;
    default:
      PUTCHAR(format[i]);
    }
  }
  *buff = '\0';
  return result;
}

//----------------------------------------------------------------------
// n_snprintf()
/*!	Build a string according to a specified format
//
//	Nachos snprintf accepts:
//		%c to print a character,
//		%s, to print a string,
//		%d, to print an integer,
//		%x, to print a string in hexa
//              %f, to print a floating point value
//		
//      \param buff the destination buffer to generate the string to
//      \param len the size of buff, determines the number max of
//        characters copied to buff (taking the final \0 into account)
//	\param format the string to parse
//	\param ... the (variable number of) arguments
//
//      \return the number of characters formatted (NOT including \0),
//        that is, the number of characters that would have been written
//        to the buffer if it were large enough. -1 on error.
*/
//----------------------------------------------------------------------
int n_snprintf(char * buff, int len, const char *format, ...){
  va_list ap;
  va_start(ap, format);
  len = n_vsnprintf(buff, len, format, ap);
  va_end(ap);
  return len;
}

//----------------------------------------------------------------------
// n_printf()
/*!	Print to the standard output parameters.
//
//	Nachos printf accepts:
//		%c to print a character,
//		%s, to print a string,
//		%d, to print an integer,
//		%x, to print a string in hexa
//              %ld, %lx, same for 64-bit values
//              %f, to print a floating point value
//		
//	\param parameters to print,
//	\param type of print.
*/
//----------------------------------------------------------------------
void n_printf(const char *format, ...){

  va_list ap;
  char buff[200];
  int len;

  va_start(ap, format);
  len = n_vsnprintf(buff, sizeof(buff), format, ap);
  va_end(ap);

  if (len >= sizeof(buff)) {
    len = sizeof(buff) - 1;
  }
  if (len > 0) {
    Write(buff,len,CONSOLE_OUTPUT);
  }
}

//----------------------------------------------------------------------
// n_read_int()
/*!	
// Very basic minimalist read integer function, no error
// checking...
*/
//----------------------------------------------------------------------
int n_read_int(void) {
  char buff[200];
  Read(buff,200,CONSOLE_INPUT);
  return n_atoi(buff);
}