Routix/tareas/lib/RoutixStd/routix.c

   1 /* routix.c */
   2 #include "stdarg.h"
   3 #include <sys/types.h>
   4 #include <lib/routix.h>
   5 #include <stdio.h>
   6 #include <sys/syscalls.h>
   7 #include <string.h>
   8 #include <signal.h>
   9
  10 void sprintn ( unsigned int num, int base);
  11 void sputchar (char car);
  12 char getascii (char c);
  13
  14 int sleep(int segundos)
  15 {
  16   int retorno;
  17
  18  _syscall1( SYS_TIMER | SYS_SLEEP, retorno, segundos);
  19
  20  return retorno;
  21 }
  22
  23
  24 int usleep(int usegundos)
  25 {
  26   int retorno;
  27
  28  _syscall1( SYS_TIMER | SYS_USLEEP, retorno, usegundos);
  29
  30  return retorno;
  31 }
  32
  33
  34 int proc_dump(void)
  35 {
  36  int retorno;
  37
  38  _syscall0( SYS_TIMER | SYS_PROC_DUMP, retorno);
  39
  40  return retorno;
  41 }
  42
  43 int proc_dump_v(int pid)
  44 {
  45  int retorno;
  46
  47  _syscall1( SYS_TIMER | SYS_PROC_DUMP_V, retorno, pid);
  48
  49  return retorno;
  50 }
  51
  52 int timer_dump(void)
  53 {
  54   int retorno;
  55
  56   _syscall0( SYS_TIMER | SYS_TIMER_DUMP, retorno);
  57
  58   return retorno;
  59 }
  60
  61 int read_debug(int sector)
  62 {
  63   int retorno;
  64
  65   _syscall1( SYS_MISC | SYS_READ_DEBUG, retorno, sector);
  66
  67   return retorno;
  68 }
  69
  70
  71 //Entrega una pagina al espacio de usuario
  72 void *malloc_page(void)
  73 {
  74     void *retorno;
  75     _syscall0( SYS_MEM | SYS_MALLOC_PAGE, retorno);
  76     return retorno;
  77 }
  78
  79 int free_page(void *dir)
  80 {
  81     int retorno;
  82     _syscall1( SYS_MEM | SYS_FREE_PAGE, retorno, dir);
  83     return retorno;
  84 }
  85
  86 size_t free_mem(void)
  87 {
  88     size_t retorno;
  89     _syscall0( SYS_MEM | SYS_FREE_MEM, retorno);
  90     return retorno;
  91 }
  92
  93 void perror (char *str)
  94 {
  95     int retorno;
  96     _syscall1(SYS_PROCESS | SYS_PERROR, retorno, str);
  97 }
  98
  99
 100 /*
 101 int exec (char *tarea)
 102 {
 103 //     int retorno;
 104 //    _syscall1(SYS_PROCESS | SYS_EXEC, retorno, tarea);
 105         printf("Llamando a execve ...\n");
 106     return execve(tarea, NULL, NULL);
 107 }
 108 */
 109 int execve (char *tarea, char **argv, char **envp)
 110 {
 111         int retorno;
 112     _syscall3(SYS_PROCESS | SYS_EXECVE, retorno, tarea, argv, envp);
 113
 114     return retorno;
 115 }
 116
 117
 118
 119 void gets (char *str)
 120 {
 121     int retorno;
 122     _syscall1(SYS_CONSOLE | SYS_GETS, retorno, str);
 123 }
 124
 125 pid_t fork(void)
 126 {
 127     int retorno;
 128     _syscall0(SYS_PROCESS | SYS_FORK, retorno);
 129         return retorno;
 130 }
 131
 132
 133 void voido (void)
 134 {
 135     int retorno;
 136     _syscall0(SYS_PROCESS | SYS_VOID, retorno);
 137 }
 138
 139 int renice(word pid, word prioridad)
 140 {
 141  int retorno;
 142
 143  _syscall2( SYS_PROCESS | SYS_RENICE, retorno, pid, prioridad);
 144
 145  return retorno;
 146 }
 147
 148 pid_t getpid (void)
 149 {
 150     pid_t retorno;
 151     _syscall0( SYS_PROCESS | SYS_GETPID, retorno);
 152     return retorno;
 153 }
 154
 155 pid_t getppid (void)
 156 {
 157     pid_t retorno;
 158     _syscall0( SYS_PROCESS | SYS_GETPPID, retorno);
 159     return retorno;
 160 }
 161
 162 void exit(int valor)
 163 {
 164         int retorno;
 165         _syscall1(SYS_PROCESS | SYS_EXIT, retorno, valor);
 166 }
 167
 168 void show(int valor)
 169 {
 170         int retorno;
 171         _syscall1(SYS_PROCESS | SYS_SHOW, retorno, valor);
 172 }
 173
 174 pid_t wait(int *valor)
 175 {
 176         return waitpid(0, valor, 0);
 177 }
 178
 179 pid_t waitpid (pid_t pid, int *valor, int options)
 180 {
 181         int retorno;
 182         _syscall3(SYS_PROCESS | SYS_WAIT, retorno, pid, valor, options);
 183         return retorno;
 184 }
 185
 186 int kill(pid_t pid, int sig)
 187 {
 188         int retorno;
 189         _syscall2(SYS_SIGNALS | SYS_KILL, retorno, pid, sig);
 190         return retorno;
 191 }
 192
 193 void *signal (int signo, void (*func)() )
 194 {
 195         void *retorno;
 196         _syscall2(SYS_SIGNALS | SYS_SIGNAL, retorno, signo, func);
 197         return retorno;
 198 }
 199
 200 int sigaction (int signo, struct sigaction *act, struct sigaction *oact)
 201 {
 202         int retorno;
 203         _syscall3(SYS_SIGNALS | SYS_SIGACTION, retorno, signo, act, oact);
 204         return retorno;
 205 }
 206
 207
 208 void *signal_check ()
 209 {
 210         int retorno;
 211         _syscall0(SYS_SIGNALS | SYS_SIGNAL_CHECK, retorno);
 212         return retorno;
 213 }
 214
 215 int sigprocmask(int flag, const sigset_t *set, sigset_t *old_set)
 216 {
 217         int retorno;
 218         _syscall3(SYS_SIGNALS | SYS_SIGPROCMASK, retorno, flag, set, old_set);
 219         return retorno;
 220 }
 221
 222 // Funcion de libraria "putchar"
 223 int putchar (char car)
 224 {
 225     char aux[2];
 226     aux[1]='\0';
 227     aux[0]=car;
 228     puts(aux);
 229         return 1;
 230 }
 231
 232 // llamada al sistema (similar a write pero hacia stdout)
 233 void puts(char *str)
 234 {
 235     int retorno;
 236     _syscall2(SYS_CONSOLE | SYS_PRINT, retorno, str, strlen(str));
 237 }
 238
 239 int clrscr(void)
 240 {
 241     int retorno;
 242     _syscall0(SYS_CONSOLE | SYS_CLRSCR, retorno);
 243         return retorno;
 244 }
 245
 246 #define MAX_STRING  100
 247
 248 word sposicion=0;
 249
 250
 251
 252 //****************************************************************************************************
 253 // printf ( char *string, ...)  y funciones requeridas por ella
 254 //****************************************************************************************************
 255
 256 //char getascii_ ( char c );
 257 void printn_ ( unsigned int num, int base);
 258
 259 void printf ( char *string, ...)
 260 {
 261
 262  char *p=string;
 263  char *d;
 264  char car;
 265
 266  unsigned int i;
 267
 268  va_list argumentos;
 269
 270  va_start(argumentos, string );
 271
 272  for ( p=string; *p ; p++ ) {
 273   if ( *p != '%' ) {
 274    putchar(*p);
 275    continue;
 276   }
 277
 278   switch (*++p) {
 279
 280    case 'c':
 281              car=va_arg(argumentos, int);
 282              putchar( (char) car);
 283              break;
 284
 285    case 'x':
 286              i = va_arg(argumentos, unsigned int );
 287              printn_(i,16);
 288              break;
 289
 290    case 'd':
 291              i = va_arg(argumentos, int);
 292                  if (i> (0xffffffff/2)) {
 293                         putchar('-');
 294                         printn_(~i+1,10);
 295                         break;
 296                  }
 297                  printn_(i,10);
 298              break;
 299
 300    case 'u':
 301              i = va_arg(argumentos, unsigned int);
 302                  printn_(i,10);
 303              break;
 304
 305    case 'o':
 306              i = va_arg(argumentos, unsigned int);
 307              printn_(i,8);
 308              break;
 309
 310    case 's':
 311              d = va_arg(argumentos, char *);
 312              puts(d);
 313              break;
 314
 315    default:
 316              putchar(*p);
 317              break;
 318   }
 319
 320  }
 321
 322  va_end(argumentos);
 323 }
 324
 325 void printn_s ( unsigned int num, int base, char *str, int *index);
 326
 327
 328 int sprintf(char *str, const char *string, ...)
 329 {
 330  char *p=(char *)string;
 331  char *d;
 332  char car;
 333
 334  unsigned int i;
 335  unsigned int index = 0;        // Posicion dentro de str donde se colocara el proximo dato
 336
 337  va_list argumentos;
 338
 339  va_start(argumentos, string );
 340
 341         for ( p=(char *)string; *p ; p++ ) {
 342
 343                 if ( *p != '%' ) {
 344                 str[index++] = *p;
 345                     continue;
 346                 }
 347
 348             switch (*++p) {
 349                         case 'c':
 350                     car=va_arg(argumentos, int);
 351                                 str[index++] = car;
 352                         break;
 353                         case 'x':
 354                             i = va_arg(argumentos, unsigned int );
 355                         printn_s(i,16, str, &index);
 356                         break;
 357                         case 'd':
 358                                 i = va_arg(argumentos, int);
 359                                 if (i> (0xffffffff/2)) {
 360                                         str[index++] = '-';
 361                                         printn_s(~i+1,10, str, &index);
 362                                         break;
 363                                 }
 364                                 printn_s(i,10, str, &index);
 365                                 break;
 366                         case 'u':
 367                                 i = va_arg(argumentos, unsigned int);
 368                                 printn_s(i,10, str, &index);
 369                                 break;
 370             //  case 'o':
 371                 //      i = va_arg(argumentos, unsigned int);
 372                 //      printn_s(i,8);
 373                 //      break;
 374                         case 's':
 375                                 d = va_arg(argumentos, char *);
 376                                 strcat(str+index, d);
 377                             index += strlen(d);
 378                             break;
 379                    default:
 380                             str[index++] = *p;
 381                         break;
 382                 }
 383
 384         }
 385
 386         str[index] = '\0';
 387         va_end(argumentos);
 388
 389         return index;
 390 }
 391
 392
 393 void printn_ ( unsigned int num, int base)
 394 {
 395  unsigned int div;
 396  if ( (div=num/base) ) printn_(div,base);
 397  putchar( getascii(num%base) );
 398 }
 399
 400 void printn_s ( unsigned int num, int base, char *str, int *index)
 401 {
 402         unsigned int div;
 403         if ( (div=num/base) )
 404                         printn_s(div,base, str, index);
 405         str[(*index)++] = ( getascii(num%base) );
 406 }
 407
 408
 409 char getascii ( char c )
 410 {
 411  char valor = '0' + c;
 412
 413  if ( valor > '9' ) valor += 7;
 414  return valor;
 415 }
 416
 417 ////////////////// Grupo Misc ///////////////////////////
 418 int setvar (char *nombre, int valor)
 419 {
 420     int retorno;
 421     _syscall2( SYS_MISC | SYS_SETVAR, retorno, nombre, valor);
 422     return retorno;
 423 }
 424
 425 int getvar (char *nombre)
 426 {
 427     int retorno;
 428          _syscall1( SYS_MISC | SYS_GETVAR, retorno, nombre);
 429     return retorno;
 430 }
 431
 432 int sched_yield()
 433 {
 434         __asm__ __volatile__("int $0x51");
 435         return 0;
 436 }
 437
 438 int clone(void *func)
 439 {
 440     int retorno;
 441     _syscall1( SYS_PROCESS | SYS_CLONE, retorno, func);
 442     return retorno;
 443 }