Annotation of rpl/src/instructions_r7.c, revision 1.2
1.1 bertrand 1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.5
4: Copyright (C) 1989-2011 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 'restart'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_restart(struct_processus *s_etat_processus)
40: {
41: struct timespec attente;
42:
43: (*s_etat_processus).erreur_execution = d_ex;
44:
45: if ((*s_etat_processus).affichage_arguments == 'Y')
46: {
47: printf("\n RESTART ");
48:
49: if ((*s_etat_processus).langue == 'F')
50: {
51: printf("(réinitialisation du programme)\n\n");
52: printf(" Aucun argument\n");
53: }
54: else
55: {
56: printf("(program reinitialization)\n\n");
57: printf(" No argument\n");
58: }
59:
60: return;
61: }
62: else if ((*s_etat_processus).test_instruction == 'Y')
63: {
64: (*s_etat_processus).nombre_arguments = -1;
65: return;
66: }
67:
68: if (test_cfsf(s_etat_processus, 31) == d_vrai)
69: {
70: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
71: {
72: return;
73: }
74: }
75:
76: envoi_signal_processus((*s_etat_processus).pid_processus_pere,
77: rpl_sigabort);
78: (*s_etat_processus).requete_arret = 'Y';
79:
80: attente.tv_sec = 0;
81: attente.tv_nsec = GRANULARITE_us * 1000;
82:
83: while((*s_etat_processus).var_volatile_requete_arret == 0)
84: {
85: scrutation_interruptions(s_etat_processus);
86: nanosleep(&attente, NULL);
87: INCR_GRANULARITE(attente.tv_nsec);
88: }
89:
90: if ((*s_etat_processus).traitement_instruction_halt == d_vrai)
91: {
92: (*s_etat_processus).execution_pas_suivant = d_vrai;
93: }
94:
95: (*s_etat_processus).requete_redemarrage = d_vrai;
96: return;
97: }
98:
1.2 ! bertrand 99:
! 100: /*
! 101: ================================================================================
! 102: Fonction 'regex'
! 103: ================================================================================
! 104: Entrées : pointeur sur une structure struct_processus
! 105: --------------------------------------------------------------------------------
! 106: Sorties :
! 107: --------------------------------------------------------------------------------
! 108: Effets de bord : néant
! 109: ================================================================================
! 110: */
! 111:
! 112: void
! 113: instruction_regex(struct_processus *s_etat_processus)
! 114: {
! 115: regex_t expression;
! 116:
! 117: struct_liste_chainee *l_element_courant_ecriture;
! 118: struct_liste_chainee *l_element_courant_lecture;
! 119:
! 120: struct_objet *s_objet_argument_1;
! 121: struct_objet *s_objet_argument_2;
! 122: struct_objet *s_objet_resultat;
! 123:
! 124: (*s_etat_processus).erreur_execution = d_ex;
! 125:
! 126: if ((*s_etat_processus).affichage_arguments == 'Y')
! 127: {
! 128: printf("\n REGEX ");
! 129:
! 130: if ((*s_etat_processus).langue == 'F')
! 131: {
! 132: printf("(expression régulière)\n\n");
! 133: }
! 134: else
! 135: {
! 136: printf("(regular expression)\n\n");
! 137: }
! 138:
! 139: printf(" 1: %s, %s\n", d_LST);
! 140: printf("-> 1: %s\n\n", d_LST);
! 141:
! 142: printf(" 1: %s\n", d_CHN);
! 143: printf("-> 1: %s (0 or -1)\n", d_INT);
! 144:
! 145: return;
! 146: }
! 147: else if ((*s_etat_processus).test_instruction == 'Y')
! 148: {
! 149: (*s_etat_processus).nombre_arguments = 2;
! 150: return;
! 151: }
! 152:
! 153: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 154: {
! 155: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 156: {
! 157: return;
! 158: }
! 159: }
! 160:
! 161: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 162: &s_objet_argument_1) == d_erreur)
! 163: {
! 164: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 165: return;
! 166: }
! 167:
! 168: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 169: &s_objet_argument_2) == d_erreur)
! 170: {
! 171: liberation(s_etat_processus, s_objet_argument_1);
! 172:
! 173: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 174: return;
! 175: }
! 176:
! 177: if (((*s_objet_argument_1).type == CHN) &&
! 178: ((*s_objet_argument_2).type == CHN))
! 179: {
! 180: // Renvoie 0 ou -1
! 181:
! 182: if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet,
! 183: REG_EXTENDED | REG_NOSUB) != 0)
! 184: {
! 185: liberation(s_etat_processus, s_objet_argument_1);
! 186: liberation(s_etat_processus, s_objet_argument_2);
! 187:
! 188: (*s_etat_processus).erreur_execution = d_ex_expression_reguliere;
! 189: return;
! 190: }
! 191:
! 192: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
! 193: {
! 194: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 195: return;
! 196: }
! 197:
! 198: if (regexec(&expression, (const char *) (*s_objet_argument_1).objet,
! 199: 0, NULL, 0) == 0)
! 200: {
! 201: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
! 202: }
! 203: else // REG_NOMATCH
! 204: {
! 205: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
! 206: }
! 207:
! 208: regfree(&expression);
! 209: }
! 210: else if (((*s_objet_argument_1).type == CHN) &&
! 211: ((*s_objet_argument_2).type == LST))
! 212: {
! 213: // Renvoie une liste de chaînes qui correspondent
! 214:
! 215: if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet,
! 216: REG_EXTENDED | REG_NOSUB) != 0)
! 217: {
! 218: liberation(s_etat_processus, s_objet_argument_1);
! 219: liberation(s_etat_processus, s_objet_argument_2);
! 220:
! 221: (*s_etat_processus).erreur_execution = d_ex_expression_reguliere;
! 222: return;
! 223: }
! 224:
! 225: if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
! 226: {
! 227: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 228: return;
! 229: }
! 230:
! 231: l_element_courant_lecture = (*s_objet_argument_2).objet;
! 232: l_element_courant_ecriture = NULL;
! 233:
! 234: while(l_element_courant_lecture != NULL)
! 235: {
! 236: if ((*(*l_element_courant_lecture).donnee).type != CHN)
! 237: {
! 238: liberation(s_etat_processus, s_objet_argument_1);
! 239: liberation(s_etat_processus, s_objet_argument_2);
! 240: liberation(s_etat_processus, s_objet_resultat);
! 241:
! 242: (*s_etat_processus).erreur_execution =
! 243: d_ex_erreur_type_argument;
! 244: return;
! 245: }
! 246:
! 247: if (regexec(&expression, (const char *)
! 248: (*(*l_element_courant_lecture).donnee).objet,
! 249: 0, NULL, 0) == 0)
! 250: {
! 251: if (l_element_courant_ecriture == NULL)
! 252: {
! 253: if (((*s_objet_resultat).objet =
! 254: allocation_maillon(s_etat_processus)) == NULL)
! 255: {
! 256: (*s_etat_processus).erreur_systeme =
! 257: d_es_allocation_memoire;
! 258: return;
! 259: }
! 260:
! 261: l_element_courant_ecriture = (*s_objet_resultat).objet;
! 262:
! 263: if (((*l_element_courant_ecriture).donnee =
! 264: copie_objet(s_etat_processus,
! 265: (*l_element_courant_lecture).donnee, 'P'))
! 266: == NULL)
! 267: {
! 268: (*s_etat_processus).erreur_systeme =
! 269: d_es_allocation_memoire;
! 270: return;
! 271: }
! 272:
! 273: (*l_element_courant_ecriture).suivant = NULL;
! 274: }
! 275: else
! 276: {
! 277: if (((*l_element_courant_ecriture).suivant =
! 278: allocation_maillon(s_etat_processus)) == NULL)
! 279: {
! 280: (*s_etat_processus).erreur_systeme =
! 281: d_es_allocation_memoire;
! 282: return;
! 283: }
! 284:
! 285: l_element_courant_ecriture =
! 286: (*l_element_courant_ecriture).suivant;
! 287:
! 288: if (((*l_element_courant_ecriture).donnee =
! 289: copie_objet(s_etat_processus,
! 290: (*l_element_courant_lecture).donnee, 'P'))
! 291: == NULL)
! 292: {
! 293: (*s_etat_processus).erreur_systeme =
! 294: d_es_allocation_memoire;
! 295: return;
! 296: }
! 297:
! 298: (*l_element_courant_ecriture).suivant = NULL;
! 299: }
! 300: }
! 301:
! 302: l_element_courant_lecture = (*l_element_courant_lecture).suivant;
! 303: }
! 304:
! 305: regfree(&expression);
! 306: }
! 307: else
! 308: {
! 309: liberation(s_etat_processus, s_objet_argument_1);
! 310: liberation(s_etat_processus, s_objet_argument_2);
! 311:
! 312: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 313: return;
! 314: }
! 315:
! 316: liberation(s_etat_processus, s_objet_argument_1);
! 317: liberation(s_etat_processus, s_objet_argument_2);
! 318:
! 319: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 320: s_objet_resultat) == d_erreur)
! 321: {
! 322: return;
! 323: }
! 324:
! 325: return;
! 326: }
! 327:
1.1 bertrand 328: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_r7.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src