Changeset 647 for soft/giet_vm/giet_libs


Ignore:
Timestamp:
Jul 22, 2015, 1:09:15 PM (9 years ago)
Author:
alain
Message:

Cosmetic.

Location:
soft/giet_vm/giet_libs
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_libs/stdio.c

    r641 r647  
    4949
    5050//////////////////////////////////////////////////////////////////////////////
    51 ///////////////////// Task context  system calls /////////////////////////////
     51///////////////////// Task related  system calls /////////////////////////////
    5252//////////////////////////////////////////////////////////////////////////////
    5353
    … …  
    7373}
    7474
     75//////////////////////////////
     76void giet_exit( char* string )
     77{
     78    sys_call( SYSCALL_EXIT,
     79              (unsigned int)string,
     80              0, 0, 0 );
     81}
     82
     83/////////////////////////////////////////
     84void giet_assert( unsigned int condition,
     85                  char*        string )
     86{
     87    if ( condition == 0 ) giet_exit( string );
     88}
     89
     90//////////////////////////
     91void giet_context_switch()
     92{
     93    sys_call( SYSCALL_CTX_SWITCH,
     94              0, 0, 0, 0 );
     95}
     96
     97//////////////////////////////////////////////////////////////////////////////
     98///////////////////// Applications  system calls /////////////////////////////
     99//////////////////////////////////////////////////////////////////////////////
     100
     101///////////////////////////////////////
     102int giet_kill_application( char* name )
     103{
     104    return ( sys_call( SYSCALL_KILL_APP,
     105                       (unsigned int)name,
     106                       0, 0, 0 ) );
     107}
     108
     109///////////////////////////////////////
     110int giet_exec_application( char* name )
     111{
     112    return ( sys_call( SYSCALL_EXEC_APP,
     113                       (unsigned int)name,
     114                       0, 0, 0 ) );
     115}
    75116
    76117//////////////////////////////////////////////////////////////////////////////
    … …  
    515556                    unsigned int bufsize )
    516557{
    517     int           ret;
     558    int           ret;                           // return value from syscalls
    518559    unsigned char byte;
    519560    unsigned int  index = 0;
     561    unsigned int  string_cancel = 0x00082008;    // string containing BS/SPACE/BS
    520562 
    521563    while (index < (bufsize - 1))
    522564    {
     565        // get one character
    523566        do
    524567        {
    … …  
    526569                           (unsigned int)(&byte),
    527570                           1,
    528                            0xFFFFFFFF,
     571                           0xFFFFFFFF,        // channel index from task context
    529572                           0);
    530573            if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
    … …  
    532575        while (ret != 1);
    533576
    534         if (byte == 0x0A)  /* LF */
     577        // analyse character
     578        if (byte == 0x0A)                          // LF  special character
    535579        {
    536580            break;
    537581        }
    538         else if ((byte == 0x7F) && (index > 0))  /* DEL */
    539         {
    540             index--;
    541         }
    542         else
     582        else if ( (byte == 0x7F) ||                // DEL special character
     583                  (byte == 0x08) )                 // BS  special character
     584        {
     585            if ( index > 0 )     
     586            {
     587                index--;
     588
     589                // cancel character
     590                ret = sys_call( SYSCALL_TTY_WRITE,
     591                                (unsigned int)(&string_cancel),
     592                                3,
     593                                0XFFFFFFFF,        // channel index from task context
     594                                0 );
     595                if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
     596            }
     597        }
     598        else if ( (byte < 0x20) || (byte > 0x7F) )  // non printable characters
     599        {
     600        }
     601        else                                       // take all other characters
    543602        {
    544603            buf[index] = byte;
    545604            index++;
     605
     606            // echo
     607            ret = sys_call( SYSCALL_TTY_WRITE,
     608                            (unsigned int)(&byte),
     609                            1,
     610                            0XFFFFFFFF,        // channel index from task context
     611                            0 );
     612            if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
     613     
    546614        }
    547615    }
    548616    buf[index] = 0;
    549 }
     617
     618}   // end giet_tty_gets()
    550619
    551620///////////////////////////////////////
    … …  
    561630    unsigned int  length = 0;
    562631    unsigned int  i;
    563     unsigned int  channel = 0xFFFFFFFF;
    564632    int           ret;      // return value from syscalls
    565633 
    … …  
    573641                            (unsigned int)(&string_byte),
    574642                            1,
    575                             channel,
     643                            0xFFFFFFFF,    // channel index from task context
    576644                            0);
    577645            if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
    … …  
    580648
    581649        // analyse character
    582         if ((string_byte > 0x2F) && (string_byte < 0x3A))  /* decimal character */
     650        if ((string_byte > 0x2F) && (string_byte < 0x3A))  // decimal character
    583651        {
    584652            buf[length] = (unsigned char)string_byte;
    … …  
    589657                            (unsigned int)(&string_byte),
    590658                            1,
    591                             channel,
     659                            0xFFFFFFFF,    // channel index from task context
    592660                            0 );
    593             if ( ret < 0 ) giet_exit("error in giet_tty_gets()");
    594         }
    595         else if (string_byte == 0x0A)                     /* LF character */
     661            if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
     662        }
     663        else if (string_byte == 0x0A)                     // LF character
    596664        {
    597665            done = 1;
    598666        }
    599         else if ( (string_byte == 0x7F) ||                /* DEL character */
    600                   (string_byte == 0x08) )                 /* BS  character */
     667        else if ( (string_byte == 0x7F) ||                // DEL character
     668                  (string_byte == 0x08) )                 // BS  character
    601669        {
    602670            if ( length > 0 )
    … …  
    607675                                (unsigned int)(&string_cancel),
    608676                                3,
    609                                 channel,
     677                                0xFFFFFFFF,    // channel index from task context
    610678                                0 );
    611679                if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
    … …  
    646714                            (unsigned int)(&string_cancel),
    647715                            3,
    648                             channel,
     716                            0xFFFFFFFF,    // channel index from task context
    649717                            0 );
    650718            if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
    … …  
    655723                        (unsigned int)(&string_byte),
    656724                        1,
    657                         channel,
     725                        0xFFFFFFFF,    // channel index from task context
    658726                        0 );
    659727        if ( ret < 0 ) giet_exit("error in giet_tty_getw()");
    … …  
    662730        *val = 0;
    663731    }
    664 }
     732}   // end giet_tty_getw()
    665733
    666734
    … …  
    9991067///////////////////// Miscellaneous system calls /////////////////////////////////
    10001068//////////////////////////////////////////////////////////////////////////////////
    1001 
    1002 //////////////////////////////
    1003 void giet_exit( char* string )
    1004 {
    1005     sys_call( SYSCALL_EXIT,
    1006               (unsigned int)string,
    1007               0, 0, 0 );
    1008 }
    1009 
    1010 //////////////////////////////
    1011 void giet_kill( char* name )
    1012 {
    1013     sys_call( SYSCALL_KILL_APP,
    1014               (unsigned int)name,
    1015               0, 0, 0 );
    1016 }
    1017 
    1018 //////////////////////////////
    1019 void giet_exec( char* name )
    1020 {
    1021     sys_call( SYSCALL_EXIT,
    1022               (unsigned int)name,
    1023               0, 0, 0 );
    1024 }
    1025 
    1026 /////////////////////////////////////////
    1027 void giet_assert( unsigned int condition,
    1028                   char*        string )
    1029 {
    1030     if ( condition == 0 ) giet_exit( string );
    1031 }
    1032 
    1033 //////////////////////////
    1034 void giet_context_switch()
    1035 {
    1036     sys_call( SYSCALL_CTX_SWITCH,
    1037               0, 0, 0, 0 );
    1038 }
    10391069
    10401070/////////////////////////////////////////////////

  • soft/giet_vm/giet_libs/stdio.h

    r628 r647  
    170170
    171171//////////////////////////////////////////////////////////////////////////
    172 //                    Task context system calls
     172//              Task related system calls
    173173//////////////////////////////////////////////////////////////////////////
    174174
    … …  
    178178
    179179extern unsigned int giet_thread_id();
     180
     181extern void giet_exit( char* string );
     182
     183extern void giet_assert( unsigned int condition,
     184                         char*        string );
     185
     186extern void giet_context_switch();
     187
     188//////////////////////////////////////////////////////////////////////////
     189//               Application related system calls
     190//////////////////////////////////////////////////////////////////////////
     191
     192extern int giet_kill_application( char* name );
     193
     194extern int giet_exec_application( char* name );
    180195
    181196//////////////////////////////////////////////////////////////////////////
    … …  
    323338//////////////////////////////////////////////////////////////////////////
    324339
    325 extern void giet_exit( char* string );
    326 
    327 extern void giet_kill( char* name );
    328 
    329 extern void giet_exec( char* name );
    330 
    331 extern void giet_assert( unsigned int condition,
    332                          char*        string );
    333 
    334 extern void giet_context_switch();
    335 
    336340extern void giet_procs_number( unsigned int* x_size,
    337341                               unsigned int* y_size,

  • soft/giet_vm/giet_libs/stdlib.c

    r580 r647  
    88#include <stdlib.h>
    99
    10 ///////////////////////////////////////////////////////////////////////////////////
     10/////////////////////////
    1111int atoi(const char *str)
    12 ///////////////////////////////////////////////////////////////////////////////////
    1312{
    1413    int res  = 0; // Initialize result
    … …  
    3130}
    3231
    33 ///////////////////////////////////////////////////////////////////////////////////
     32////////////////////////////
    3433double atof(const char *str)
    35 ///////////////////////////////////////////////////////////////////////////////////
    3634{
    3735    const char *pstr = str;
    … …  
    7775}
    7876
    79 ////////////////////////////////////////////////////////////////////////////////////////
     77///////////////////////////////////////////////////////////////
    8078void * memcpy(void *_dst, const void * _src, unsigned int size)
    81 ////////////////////////////////////////////////////////////////////////////////////////
    8279{
    8380    unsigned int * dst = _dst;
    … …  
    10299}
    103100
    104 ////////////////////////////////////////////////////////////////////////////////////////
     101//////////////////////////////////////////////////////////
    105102inline void * memset(void * dst, int s, unsigned int size)
    106 ////////////////////////////////////////////////////////////////////////////////////////
    107103{
    108104    char * a = (char *) dst;
    … …  
    114110}
    115111
     112///////////////////////////////////
     113unsigned int strlen( char* string )
     114{
     115    unsigned int i = 0;
     116    while ( string[i] != 0 ) i++;
     117    return i;
     118}
     119
     120///////////////////////////////
     121unsigned int strcmp( char * s1,
     122                     char * s2 )
     123{
     124    while (1)
     125    {
     126        if (*s1 != *s2) return 1;
     127        if (*s1 == 0)   break;
     128        s1++, s2++;
     129    }
     130    return 0;
     131}
     132
     133/////////////////////////
     134char* strcpy( char* dest,
     135              char* source )
     136{
     137    if (!dest || !source) return dest;
     138
     139    while (*source)
     140    {
     141        *(dest) = *(source);
     142        dest++;
     143        source++;
     144    }
     145    *dest = 0;
     146    return dest;
     147}
     148
    116149// Local Variables:
    117150// tab-width: 4

  • soft/giet_vm/giet_libs/stdlib.h

    r580 r647  
    1010
    1111////////////////////////////////////////////////////////////////////////////////////////
    12 // This function translate a character string to a signed integer. 
     12// This function translates a character string to a signed integer. 
    1313// For a negative value, the first character must be a '-' (minus) character.
    1414////////////////////////////////////////////////////////////////////////////////////////
    … …  
    3939                     unsigned int size );
    4040
     41////////////////////////////////////////////////////////////////////////////////////////
     42// This function returns the number of characters in a string.
     43// The terminating NUL character is not taken into account.
     44////////////////////////////////////////////////////////////////////////////////////////
     45unsigned int strlen( char* string );
     46
     47////////////////////////////////////////////////////////////////////////////////////////
     48// This function compare the two s1 & s2 strings.
     49// It returns 0 if strings are identical (including the terminating NUL character).
     50// It returns 1 if they are not.
     51////////////////////////////////////////////////////////////////////////////////////////
     52unsigned int strcmp( char* s1,
     53                     char* s2 );
     54
     55////////////////////////////////////////////////////////////////////////////////////////
     56// This function copies the source string to the dest string.
     57// It returns a pointer on the dest string.
     58////////////////////////////////////////////////////////////////////////////////////////
     59char* strcpy( char* dest,
     60              char* source );
     61
    4162#endif
    4263
Note: See TracChangeset for help on using the changeset viewer.