Return to types.rplc CVS log

Up to [local] / rpl / modules / sets

Annotation of rpl/modules/sets/types.rplc, revision 1.2

1.1       bertrand    1: #define TYPE_DECLARATION
                      2: #include "src/rplexternals.h"
                      3: #include "sets.h"
                      4: 
                      5: // Les objets de type ensemble sont délimités par ([ ]) et ne contiennent
                      6: // que des entiers.
                      7: 
1.2     ! bertrand    8: // Attention : ces fonctions sont à écrire directement en C et non
        !             9: // en RPL/C car elles interviennent dans le noyau RPL/2.
        !            10: 
1.1       bertrand   11: declareTypeExtension(parse)
                     12:    if ((*rptr) == '(')
                     13:    {
                     14:        rptr++;
                     15: 
                     16:        if ((*rptr) == '[')
                     17:        {
                     18:            rptr++;
                     19:            while((*rptr) != 0)
                     20:            {
                     21:                switch (*rptr)
                     22:                {
                     23:                    case '0':
                     24:                    case '1':
                     25:                    case '2':
                     26:                    case '3':
                     27:                    case '4':
                     28:                    case '5':
                     29:                    case '6':
                     30:                    case '7':
                     31:                    case '8':
                     32:                    case '9':
                     33:                    case ' ':
                     34:                    {
                     35:                        break;
                     36:                    }
                     37: 
                     38:                    case ']':
                     39:                    {
                     40:                        rptr++;
                     41: 
                     42:                        if ((*rptr) == ')')
                     43:                        {
                     44:                            rptr++;
                     45:                            return(sizeOfParse);
                     46:                        }
                     47:                        else
                     48:                        {
                     49:                            parseError;
                     50:                        }
                     51:                    }
                     52: 
                     53:                    default:
                     54:                    {
                     55:                        parseError;
                     56:                    }
                     57:                }
                     58: 
                     59:                rptr++;
                     60:            }
                     61:        }
                     62:    }
                     63: endTypeExtension
                     64: 
                     65: declareTypeExtension(new)
1.2     ! bertrand   66:    // Si le premier caractère de la chaîne est '(' et que le dernier est ')',
        !            67:    // on les retire.
        !            68: 
        !            69:    char *tmp;
        !            70: 
        !            71: printf("<1>\n");
        !            72:    if (((*iptr) == '(') && ((*(iptr + strlen(iptr) - 1)) == ')'))
        !            73:    {
        !            74:        if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char)))
        !            75:                == NULL)
        !            76:        {
        !            77: printf("<2>\n");
        !            78:            typeError;
        !            79:        }
        !            80: printf("<3>\n");
        !            81: 
        !            82:        // Sauvegarde de l'instruction courante.
        !            83:        strcpy(tmp, iptr);
        !            84: 
        !            85:        // Création d'une nouvelle instruction courante amputée de ses premier
        !            86:        // et dernier caractères.
        !            87:        memmove(iptr, iptr + 1, strlen(iptr) - 2);
        !            88:        *(iptr + strlen(iptr) - 2) = 0;
        !            89: 
        !            90: printf("<4>\n");
        !            91:        searchType;
        !            92: printf("<5>\n");
        !            93: 
        !            94:        // Restauration de l'instruction courante
        !            95:        free(iptr);
        !            96: printf("<6>\n");
        !            97:        iptr = tmp;
        !            98: 
        !            99: printf("<7>\n");
        !           100:        if (((*arg) = malloc(sizeof(integer8))) == NULL)
        !           101:        {
        !           102:            typeError;
        !           103:        }
        !           104: 
        !           105:        (*((integer8 *) arg)) = 10;
        !           106: printf("<8>\n");
        !           107:        instruction_drop(s_etat_processus);
        !           108: printf("<9>\n");
        !           109:        typeFound(ISET);
        !           110:    }
        !           111: 
        !           112: printf("<10>\n");
        !           113:    typeError;
1.1       bertrand  114: endTypeExtension
                    115: 
1.2     ! bertrand  116: declareTypeExtension(disp)
        !           117:    (*arg) = malloc(10);
        !           118:    strcpy((*arg), "ici");
1.1       bertrand  119: endTypeExtension
                    120: 
1.2     ! bertrand  121: declareTypeExtension(dup)
1.1       bertrand  122: endTypeExtension
                    123: 
                    124: declareTypeExtension(drop)
                    125: endTypeExtension