Annotation of rpl/src/instructions_n2.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
! 5:
! 6: This file is part of RPL/2.
! 7:
! 8: RPL/2 is free software; you can redistribute it and/or modify it
! 9: under the terms of the CeCILL V2 License as published by the french
! 10: CEA, CNRS and INRIA.
! 11:
! 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
! 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
! 15: for more details.
! 16:
! 17: You should have received a copy of the CeCILL License
! 18: along with RPL/2. If not, write to info@cecill.info.
! 19: ================================================================================
! 20: */
! 21:
! 22:
! 23: #include "rpl.conv.h"
! 24:
! 25:
! 26: /*
! 27: ================================================================================
! 28: Fonction 'num'
! 29: ================================================================================
! 30: Entrées : structure processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_num(struct_processus *s_etat_processus)
! 40: {
! 41: struct_objet *s_objet_argument;
! 42: struct_objet *s_objet_resultat;
! 43:
! 44: (*s_etat_processus).erreur_execution = d_ex;
! 45:
! 46: if ((*s_etat_processus).affichage_arguments == 'Y')
! 47: {
! 48: printf("\n NUM ");
! 49:
! 50: if ((*s_etat_processus).langue == 'F')
! 51: {
! 52: printf("(conversion d'un caractère en entier)\n\n");
! 53: }
! 54: else
! 55: {
! 56: printf("(character to integer conversion)\n\n");
! 57: }
! 58:
! 59: printf(" 1: %s\n", d_CHN);
! 60: printf("-> 1: 0 <= %s <= 255\n", d_INT);
! 61:
! 62: return;
! 63: }
! 64: else if ((*s_etat_processus).test_instruction == 'Y')
! 65: {
! 66: (*s_etat_processus).nombre_arguments = -1;
! 67: return;
! 68: }
! 69:
! 70: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 71: {
! 72: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 73: {
! 74: return;
! 75: }
! 76: }
! 77:
! 78: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 79: &s_objet_argument) == d_erreur)
! 80: {
! 81: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 82: return;
! 83: }
! 84:
! 85: /*
! 86: --------------------------------------------------------------------------------
! 87: Chaîne de caractères
! 88: --------------------------------------------------------------------------------
! 89: */
! 90:
! 91: if ((*s_objet_argument).type == CHN)
! 92: {
! 93: if (strlen((unsigned char *) (*s_objet_argument).objet) != 1)
! 94: {
! 95: liberation(s_etat_processus, s_objet_argument);
! 96:
! 97: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
! 98: return;
! 99: }
! 100:
! 101: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
! 102: {
! 103: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 104: return;
! 105: }
! 106:
! 107: (*((integer8 *) (*s_objet_resultat).objet)) =
! 108: (integer8) ((unsigned char *) (*s_objet_argument).objet)[0];
! 109: }
! 110:
! 111: /*
! 112: --------------------------------------------------------------------------------
! 113: Type invalide
! 114: --------------------------------------------------------------------------------
! 115: */
! 116:
! 117: else
! 118: {
! 119: liberation(s_etat_processus, s_objet_argument);
! 120:
! 121: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 122: return;
! 123: }
! 124:
! 125: liberation(s_etat_processus, s_objet_argument);
! 126:
! 127: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 128: s_objet_resultat) == d_erreur)
! 129: {
! 130: return;
! 131: }
! 132:
! 133: return;
! 134: }
! 135:
! 136:
! 137: /*
! 138: ================================================================================
! 139: Fonction 'ns'
! 140: ================================================================================
! 141: Entrées : structure processus
! 142: --------------------------------------------------------------------------------
! 143: Sorties :
! 144: --------------------------------------------------------------------------------
! 145: Effets de bord : néant
! 146: ================================================================================
! 147: */
! 148:
! 149: void
! 150: instruction_ns(struct_processus *s_etat_processus)
! 151: {
! 152: logical1 presence_variable;
! 153:
! 154: long i;
! 155:
! 156: struct_objet *s_objet_resultat;
! 157:
! 158: (*s_etat_processus).erreur_execution = d_ex;
! 159:
! 160: if ((*s_etat_processus).affichage_arguments == 'Y')
! 161: {
! 162: printf("\n NS ");
! 163:
! 164: if ((*s_etat_processus).langue == 'F')
! 165: {
! 166: printf("(nombre de données dans la matrice statistique\n\n");
! 167: }
! 168: else
! 169: {
! 170: printf("(number of data elements in statistical matrix)\n\n");
! 171: }
! 172:
! 173: printf("-> 1: %s\n", d_INT);
! 174:
! 175: return;
! 176: }
! 177: else if ((*s_etat_processus).test_instruction == 'Y')
! 178: {
! 179: (*s_etat_processus).nombre_arguments = -1;
! 180: return;
! 181: }
! 182:
! 183: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 184: {
! 185: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 186: {
! 187: return;
! 188: }
! 189: }
! 190:
! 191: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
! 192: {
! 193: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 194: return;
! 195: }
! 196:
! 197: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
! 198: {
! 199: /*
! 200: * Aucune variable SIGMA
! 201: */
! 202:
! 203: (*s_etat_processus).erreur_systeme = d_es;
! 204: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 205: }
! 206: else
! 207: {
! 208: /*
! 209: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
! 210: * d'une variable SIGMA globale...
! 211: */
! 212:
! 213: i = (*s_etat_processus).position_variable_courante;
! 214: presence_variable = d_faux;
! 215:
! 216: while(i >= 0)
! 217: {
! 218: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 219: ds_sdat) == 0) && ((*s_etat_processus)
! 220: .s_liste_variables[i].niveau == 1))
! 221: {
! 222: presence_variable = d_vrai;
! 223: break;
! 224: }
! 225:
! 226: i--;
! 227: }
! 228:
! 229: if (presence_variable == d_faux)
! 230: {
! 231: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 232: }
! 233: else
! 234: {
! 235: (*s_etat_processus).position_variable_courante = i;
! 236:
! 237: if (((*s_etat_processus).s_liste_variables[i]).objet == NULL)
! 238: {
! 239: liberation(s_etat_processus, s_objet_resultat);
! 240:
! 241: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
! 242: return;
! 243: }
! 244:
! 245: if (((*((*s_etat_processus).s_liste_variables
! 246: [(*s_etat_processus).position_variable_courante].objet))
! 247: .type != MIN) && ((*((*s_etat_processus)
! 248: .s_liste_variables[(*s_etat_processus)
! 249: .position_variable_courante].objet)).type != MRL))
! 250: {
! 251: liberation(s_etat_processus, s_objet_resultat);
! 252:
! 253: (*s_etat_processus).erreur_execution =
! 254: d_ex_matrice_statistique_invalide;
! 255: return;
! 256: }
! 257:
! 258: (*((integer8 *) (*s_objet_resultat).objet)) =
! 259: (*((struct_matrice *) (*((*s_etat_processus)
! 260: .s_liste_variables[(*s_etat_processus)
! 261: .position_variable_courante].objet)).objet))
! 262: .nombre_lignes;
! 263: }
! 264: }
! 265:
! 266: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 267: s_objet_resultat) == d_erreur)
! 268: {
! 269: return;
! 270: }
! 271:
! 272: return;
! 273: }
! 274:
! 275:
! 276: /*
! 277: ================================================================================
! 278: Fonction 'newplane'
! 279: ================================================================================
! 280: Entrées : structure processus
! 281: --------------------------------------------------------------------------------
! 282: Sorties :
! 283: --------------------------------------------------------------------------------
! 284: Effets de bord : néant
! 285: ================================================================================
! 286: */
! 287:
! 288: void
! 289: instruction_newplane(struct_processus *s_etat_processus)
! 290: {
! 291: (*s_etat_processus).erreur_execution = d_ex;
! 292:
! 293: if ((*s_etat_processus).affichage_arguments == 'Y')
! 294: {
! 295: printf("\n NEWPLANE ");
! 296:
! 297: if ((*s_etat_processus).langue == 'F')
! 298: {
! 299: printf("(nouveau plan graphique)\n\n");
! 300: printf(" Aucun argument\n");
! 301: }
! 302: else
! 303: {
! 304: printf("(new graphic plane)\n\n");
! 305: printf(" No argument\n");
! 306: }
! 307:
! 308: return;
! 309: }
! 310: else if ((*s_etat_processus).test_instruction == 'Y')
! 311: {
! 312: (*s_etat_processus).nombre_arguments = -1;
! 313: return;
! 314: }
! 315:
! 316: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 317: {
! 318: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 319: {
! 320: return;
! 321: }
! 322: }
! 323:
! 324: (*s_etat_processus).requete_nouveau_plan = d_vrai;
! 325:
! 326: return;
! 327: }
! 328:
! 329:
! 330: /*
! 331: ================================================================================
! 332: Fonction 'nrproc'
! 333: ================================================================================
! 334: Entrées : structure processus
! 335: --------------------------------------------------------------------------------
! 336: Sorties :
! 337: --------------------------------------------------------------------------------
! 338: Effets de bord : néant
! 339: ================================================================================
! 340: */
! 341:
! 342: void
! 343: instruction_nrproc(struct_processus *s_etat_processus)
! 344: {
! 345: (*s_etat_processus).erreur_execution = d_ex;
! 346:
! 347: if ((*s_etat_processus).affichage_arguments == 'Y')
! 348: {
! 349: printf("\n NRPROC ");
! 350:
! 351: if ((*s_etat_processus).langue == 'F')
! 352: {
! 353: printf("(nouvelle racine des processus)\n\n");
! 354: printf(" Aucun argument\n");
! 355: }
! 356: else
! 357: {
! 358: printf("(new root process)\n\n");
! 359: printf(" No argument\n");
! 360: }
! 361:
! 362: return;
! 363: }
! 364: else if ((*s_etat_processus).test_instruction == 'Y')
! 365: {
! 366: (*s_etat_processus).nombre_arguments = -1;
! 367: return;
! 368: }
! 369:
! 370: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 371: {
! 372: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 373: {
! 374: return;
! 375: }
! 376: }
! 377:
! 378: (*s_etat_processus).var_volatile_processus_pere = -1;
! 379: (*s_etat_processus).pid_processus_pere = getpid();
! 380: (*s_etat_processus).tid_processus_pere = pthread_self();
! 381:
! 382: return;
! 383: }
! 384:
! 385: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_n2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src