Annotation of rpl/src/instructions_s10.c, revision 1.73
1.1 bertrand 1: /*
2: ================================================================================
1.73 ! bertrand 3: RPL/2 (R) version 4.1.14
1.68 bertrand 4: Copyright (C) 1989-2013 Dr. BERTRAND Joël
1.1 bertrand 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:
1.19 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'spawn'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_spawn(struct_processus *s_etat_processus)
40: {
41: logical1 drapeau;
42: logical1 variable_partagee;
43:
44: pthread_attr_t attributs;
45:
46: pthread_mutexattr_t attributs_mutex;
47:
48: pthread_t thread_surveillance;
49:
50: struct_descripteur_thread *s_argument_thread;
51:
52: struct_liste_chainee *l_element_courant;
53:
54: struct_objet *s_copie;
55: struct_objet *s_objet;
56: struct_objet *s_objet_resultat;
57: struct_objet *s_objet_systeme;
58:
59: struct_processus *s_nouvel_etat_processus;
60:
61: struct timespec attente;
62:
63: (*s_etat_processus).erreur_execution = d_ex;
64:
65: if ((*s_etat_processus).affichage_arguments == 'Y')
66: {
67: printf("\n SPAWN ");
68:
69: if ((*s_etat_processus).langue == 'F')
70: {
71: printf("(lancement d'un thread)\n\n");
72: }
73: else
74: {
75: printf("(create thread)\n\n");
76: }
77:
78: printf(" 1: %s, %s\n", d_NOM, d_RPN);
79: printf("-> 1: %s\n", d_PRC);
80:
81: return;
82: }
83: else if ((*s_etat_processus).test_instruction == 'Y')
84: {
85: (*s_etat_processus).nombre_arguments = -1;
86: return;
87: }
88:
89: if (test_cfsf(s_etat_processus, 31) == d_vrai)
90: {
91: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
92: {
93: return;
94: }
95: }
96:
97: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
98: &s_objet) == d_erreur)
99: {
100: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
101: return;
102: }
103:
104: /*
105: * Une routine fille doit pouvoir renvoyer des objets au processus
106: * père au travers de la fonction SEND. Il ne peut donc s'agir que
107: * d'une fonction ou d'une expression RPN.
108: */
109:
1.8 bertrand 110: if (((*s_objet).type != NOM) && ((*s_objet).type != RPN))
1.1 bertrand 111: {
112: liberation(s_etat_processus, s_objet);
113:
114: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
115: return;
116: }
117:
118: /*
119: * Si l'argument est de type NOM, il faut que la variable correspondante
120: * soit une variable de type RPN.
121: */
122:
123: variable_partagee = d_faux;
124: s_copie = NULL;
125:
126: if ((*s_objet).type == NOM)
127: {
128: if (recherche_variable(s_etat_processus, (*((struct_nom *)
129: (*s_objet).objet)).nom) == d_vrai)
130: {
1.33 bertrand 131: if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
1.1 bertrand 132: {
133: if (recherche_variable_partagee(s_etat_processus,
1.33 bertrand 134: (*(*s_etat_processus).pointeur_variable_courante).nom,
135: (*(*s_etat_processus).pointeur_variable_courante)
136: .variable_partagee, (*(*s_etat_processus)
1.64 bertrand 137: .pointeur_variable_courante).origine) == NULL)
1.1 bertrand 138: {
139: liberation(s_etat_processus, s_objet);
140:
141: (*s_etat_processus).erreur_systeme = d_es;
142: (*s_etat_processus).erreur_execution =
143: d_ex_argument_invalide;
144: return;
145: }
146:
1.63 bertrand 147: if (((*(*(*s_etat_processus)
148: .pointeur_variable_partagee_courante).objet).type
149: != RPN) && ((*(*(*s_etat_processus)
150: .pointeur_variable_partagee_courante).objet).type
151: != ADR))
1.1 bertrand 152: {
153: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1.63 bertrand 154: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 155: {
156: (*s_etat_processus).erreur_systeme = d_es_processus;
157: return;
158: }
159:
160: liberation(s_etat_processus, s_objet);
161:
162: (*s_etat_processus).erreur_execution =
163: d_ex_argument_invalide;
164: return;
165: }
166:
167: if ((s_copie = copie_objet(s_etat_processus,
168: (*(*s_etat_processus)
1.63 bertrand 169: .pointeur_variable_partagee_courante).objet, 'P'))
170: == NULL)
1.1 bertrand 171: {
172: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1.63 bertrand 173: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 174: {
175: (*s_etat_processus).erreur_systeme = d_es_processus;
176: return;
177: }
178:
179: (*s_etat_processus).erreur_systeme =
180: d_es_allocation_memoire;
181:
182: return;
183: }
184:
185: variable_partagee = d_vrai;
186:
187: if (pthread_mutex_unlock(&((*(*s_etat_processus)
1.63 bertrand 188: .pointeur_variable_partagee_courante).mutex)) != 0)
1.1 bertrand 189: {
190: (*s_etat_processus).erreur_systeme = d_es_processus;
191: return;
192: }
193: }
194: else
195: {
1.33 bertrand 196: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
197: .type != RPN) && ((*(*(*s_etat_processus)
198: .pointeur_variable_courante).objet).type != ADR))
1.1 bertrand 199: {
200: liberation(s_etat_processus, s_objet);
201:
202: (*s_etat_processus).erreur_execution =
203: d_ex_argument_invalide;
204: return;
205: }
206: }
207: }
208: else // Variable inexistante
209: {
210: liberation(s_etat_processus, s_objet);
211:
212: (*s_etat_processus).erreur_systeme = d_es;
213: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
214: return;
215: }
216: }
217:
218: if ((s_argument_thread = malloc(sizeof(struct_descripteur_thread))) == NULL)
219: {
220: (*s_etat_processus).erreur_systeme = d_es_processus;
221: return;
222: }
223:
224: if (pipe((*s_argument_thread).pipe_erreurs) != 0)
225: {
226: (*s_etat_processus).erreur_systeme = d_es_processus;
227: return;
228: }
229:
230: if (pipe((*s_argument_thread).pipe_interruptions) != 0)
231: {
232: (*s_etat_processus).erreur_systeme = d_es_processus;
233: return;
234: }
235:
236: if (pipe((*s_argument_thread).pipe_nombre_interruptions_attente) != 0)
237: {
238: (*s_etat_processus).erreur_systeme = d_es_processus;
239: return;
240: }
241:
242: if (pipe((*s_argument_thread).pipe_objets) != 0)
243: {
244: (*s_etat_processus).erreur_systeme = d_es_processus;
245: return;
246: }
247:
248: if (pipe((*s_argument_thread).pipe_acquittement) != 0)
249: {
250: (*s_etat_processus).erreur_systeme = d_es_processus;
251: return;
252: }
253:
254: if (pipe((*s_argument_thread).pipe_nombre_objets_attente) != 0)
255: {
256: (*s_etat_processus).erreur_systeme = d_es_processus;
257: return;
258: }
259:
260: if (pipe((*s_argument_thread).pipe_injections) != 0)
261: {
262: (*s_etat_processus).erreur_systeme = d_es_processus;
263: return;
264: }
265:
266: if (pipe((*s_argument_thread).pipe_nombre_injections) != 0)
267: {
268: (*s_etat_processus).erreur_systeme = d_es_processus;
269: return;
270: }
271:
272: if ((s_nouvel_etat_processus = copie_etat_processus(s_etat_processus))
273: == NULL)
274: {
275: return;
276: }
277:
278: pthread_mutexattr_init(&attributs_mutex);
279: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
280: pthread_mutex_init(&((*s_argument_thread).mutex), &attributs_mutex);
281: pthread_mutexattr_destroy(&attributs_mutex);
282:
1.25 bertrand 283: pthread_mutexattr_init(&attributs_mutex);
284: pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
285: pthread_mutex_init(&((*s_argument_thread).mutex_nombre_references),
286: &attributs_mutex);
287: pthread_mutexattr_destroy(&attributs_mutex);
288:
1.1 bertrand 289: (*s_argument_thread).processus_detache = d_faux;
290: (*s_argument_thread).thread_actif = d_faux;
291: (*s_argument_thread).thread_pere = pthread_self();
292: (*s_argument_thread).pid = getpid();
293:
294: (*s_nouvel_etat_processus).pipe_donnees =
295: (*s_argument_thread).pipe_objets[1];
296: (*s_nouvel_etat_processus).pipe_nombre_objets_attente =
297: (*s_argument_thread).pipe_nombre_objets_attente[1];
298: (*s_nouvel_etat_processus).pipe_interruptions =
299: (*s_argument_thread).pipe_interruptions[1];
300: (*s_nouvel_etat_processus).pipe_nombre_interruptions_attente =
301: (*s_argument_thread).pipe_nombre_interruptions_attente[1];
302: (*s_nouvel_etat_processus).pipe_injections =
303: (*s_argument_thread).pipe_injections[0];
304: (*s_nouvel_etat_processus).pipe_nombre_injections =
305: (*s_argument_thread).pipe_nombre_injections[0];
306: (*s_nouvel_etat_processus).pipe_acquittement =
307: (*s_argument_thread).pipe_acquittement[0];
308: (*s_nouvel_etat_processus).presence_pipes = d_vrai;
309:
310: (*s_nouvel_etat_processus).niveau_initial =
311: (*s_etat_processus).niveau_courant;
312: (*s_nouvel_etat_processus).debug_programme = d_faux;
313: (*s_nouvel_etat_processus).nombre_objets_injectes = 0;
314: (*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
315: (*s_nouvel_etat_processus).temps_maximal_cpu = 0;
316: (*s_nouvel_etat_processus).presence_fusible = d_faux;
317: (*s_nouvel_etat_processus).thread_fusible = 0;
318:
319: (*s_nouvel_etat_processus).pile_profilage = NULL;
320: (*s_nouvel_etat_processus).pile_profilage_fonctions = NULL;
321:
322: /*
323: * Lancement du thread fils et du thread de surveillance
324: */
325:
326: if (pthread_attr_init(&attributs) != 0)
327: {
328: (*s_etat_processus).erreur_systeme = d_es_processus;
329: return;
330: }
331:
332: if (pthread_attr_setdetachstate(&attributs, PTHREAD_CREATE_JOINABLE) != 0)
333: {
334: (*s_etat_processus).erreur_systeme = d_es_processus;
335: return;
336: }
337:
1.50 bertrand 338: # ifdef SCHED_OTHER
1.1 bertrand 339: if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
340: {
341: (*s_etat_processus).erreur_systeme = d_es_processus;
342: return;
343: }
1.50 bertrand 344: # endif
1.1 bertrand 345:
1.50 bertrand 346: # ifdef PTHREAD_EXPLICIT_SCHED
1.1 bertrand 347: if (pthread_attr_setinheritsched(&attributs, PTHREAD_EXPLICIT_SCHED) != 0)
348: {
349: (*s_etat_processus).erreur_systeme = d_es_processus;
350: return;
351: }
1.50 bertrand 352: # endif
1.1 bertrand 353:
1.50 bertrand 354: # ifdef PTHREAD_SCOPE_SYSTEM
1.1 bertrand 355: if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
356: {
357: (*s_etat_processus).erreur_systeme = d_es_processus;
358: return;
359: }
1.19 bertrand 360: # endif
1.1 bertrand 361:
362: /*
363: * Création de l'objet à retourner
364: */
365:
366: if ((s_objet_resultat = allocation(s_etat_processus, PRC)) == NULL)
367: {
368: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
369: return;
370: }
371:
372: (*((struct_processus_fils *) (*s_objet_resultat).objet)).thread
373: = s_argument_thread;
374:
375: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread)
376: .nombre_objets_dans_pipe = 0;
377: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread)
378: .nombre_interruptions_dans_pipe = 0;
379: (*(*((struct_processus_fils *) (*s_objet_resultat).objet)).thread)
380: .nombre_references = 1;
381:
382: // Lancement du thread fils
383:
384: (*s_argument_thread).s_nouvel_etat_processus = s_nouvel_etat_processus;
385: (*s_argument_thread).s_etat_processus = s_etat_processus;
386:
387: if (variable_partagee == d_vrai)
388: {
389: (*s_argument_thread).argument = s_copie;
390: (*s_argument_thread).destruction_objet = d_vrai;
391: }
392: else
393: {
394: (*s_argument_thread).argument = s_objet;
395: (*s_argument_thread).destruction_objet = d_faux;
396: }
397:
1.15 bertrand 398: (*s_argument_thread).thread_actif = d_faux;
1.1 bertrand 399:
1.52 bertrand 400: if (pthread_create(&(*s_nouvel_etat_processus).tid,
401: &attributs, lancement_thread, s_argument_thread) != 0)
1.1 bertrand 402: {
403: (*s_etat_processus).erreur_systeme = d_es_processus;
404: return;
405: }
406:
1.15 bertrand 407: attente.tv_sec = 0;
408: attente.tv_nsec = GRANULARITE_us * 1000;
409:
410: while((*s_argument_thread).thread_actif == d_faux)
411: {
1.45 bertrand 412: scrutation_interruptions(s_etat_processus);
1.15 bertrand 413: nanosleep(&attente, NULL);
414: INCR_GRANULARITE(attente.tv_nsec);
415: }
416:
1.1 bertrand 417: if (pthread_attr_destroy(&attributs) != 0)
418: {
419: (*s_etat_processus).erreur_systeme = d_es_processus;
420: return;
421: }
422:
423: if (pthread_attr_init(&attributs) != 0)
424: {
425: (*s_etat_processus).erreur_systeme = d_es_processus;
426: return;
427: }
428:
429: if (pthread_attr_setdetachstate(&attributs,
430: PTHREAD_CREATE_DETACHED) != 0)
431: {
432: (*s_etat_processus).erreur_systeme = d_es_processus;
433: return;
434: }
435:
1.50 bertrand 436: # ifdef SCHED_OTHER
1.1 bertrand 437: if (pthread_attr_setschedpolicy(&attributs, SCHED_OTHER) != 0)
438: {
439: (*s_etat_processus).erreur_systeme = d_es_processus;
440: return;
441: }
1.50 bertrand 442: # endif
1.1 bertrand 443:
1.50 bertrand 444: # ifdef PTHREAD_EXPLICIT_SCHED
1.1 bertrand 445: if (pthread_attr_setinheritsched(&attributs,
446: PTHREAD_EXPLICIT_SCHED) != 0)
447: {
448: (*s_etat_processus).erreur_systeme = d_es_processus;
449: return;
450: }
1.50 bertrand 451: # endif
1.1 bertrand 452:
1.50 bertrand 453: # ifdef PTHREAD_SCOPE_SYSTEM
1.1 bertrand 454: if (pthread_attr_setscope(&attributs, PTHREAD_SCOPE_SYSTEM) != 0)
455: {
456: (*s_etat_processus).erreur_systeme = d_es_processus;
457: return;
458: }
1.19 bertrand 459: # endif
1.1 bertrand 460:
461: /*
462: * On copie l'objet plutôt que le pointeur car cet objet peut être
463: * accédé depuis deux threads distincts et aboutir à un blocage lors d'une
464: * copie.
465: */
466:
467: if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet_resultat, 'O'))
468: == NULL)
469: {
470: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
471: return;
472: }
473:
474: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
475: {
1.46 bertrand 476: pthread_mutex_unlock(&((*s_nouvel_etat_processus).mutex));
1.1 bertrand 477: (*s_etat_processus).erreur_systeme = d_es_processus;
478: return;
479: }
480:
481: // Si le tid existe déjà dans la pile des processus, il s'agit forcement
482: // d'un processus moribond. On attend donc qu'il soit effectivement
483: // libéré.
484:
485: do
486: {
487: l_element_courant = (struct_liste_chainee *)
488: (*s_etat_processus).l_base_pile_processus;
489: drapeau = d_faux;
490:
491: attente.tv_sec = 0;
492: attente.tv_nsec = GRANULARITE_us * 1000;
493:
494: while(l_element_courant != NULL)
495: {
496: if (((*(*((struct_processus_fils *)
497: (*(*l_element_courant).donnee).objet)).thread)
498: .processus_detache == d_faux) &&
499: ((*s_argument_thread).processus_detache == d_faux))
500: {
501: if (pthread_equal((*(*((struct_processus_fils *)
502: (*(*l_element_courant).donnee).objet)).thread)
503: .tid, (*s_argument_thread).tid) != 0)
504: {
505: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
506: {
507: (*s_etat_processus).erreur_systeme = d_es_processus;
508: return;
509: }
510:
511: scrutation_injection(s_etat_processus);
512:
513: if ((*s_etat_processus).nombre_interruptions_non_affectees
514: != 0)
515: {
516: affectation_interruptions_logicielles(s_etat_processus);
517: }
518:
519: if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
520: {
521: traitement_interruptions_logicielles(s_etat_processus);
522: }
523:
524: nanosleep(&attente, NULL);
525: INCR_GRANULARITE(attente.tv_nsec);
526:
527: if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
528: {
529: (*s_etat_processus).erreur_systeme = d_es_processus;
530: return;
531: }
532:
533: drapeau = d_vrai;
534: break;
535: }
536: }
537:
1.45 bertrand 538: scrutation_interruptions(s_etat_processus);
1.1 bertrand 539: l_element_courant = (*l_element_courant).suivant;
540: }
541: } while(drapeau == d_vrai);
542:
543: if (empilement(s_etat_processus,
544: (struct_liste_chainee **) &((*s_etat_processus)
545: .l_base_pile_processus), s_objet_systeme) == d_erreur)
546: {
547: pthread_mutex_unlock(&((*s_etat_processus).mutex));
548: return;
549: }
550:
551: if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
552: {
553: (*s_etat_processus).erreur_systeme = d_es_processus;
554: return;
555: }
556:
557: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
558: s_objet_resultat) == d_erreur)
559: {
560: return;
561: }
562:
563: if (pthread_mutex_lock(&(*s_argument_thread).mutex) != 0)
564: {
565: (*s_etat_processus).erreur_systeme = d_es_processus;
566: return;
567: }
568:
569: if ((*s_argument_thread).thread_actif == d_faux)
570: {
571: // Le thread n'existe plus.
572:
573: pthread_join((*s_argument_thread).tid, NULL);
574: pthread_mutex_unlock(&(*s_argument_thread).mutex);
575: (*s_etat_processus).erreur_systeme = d_es_processus;
576: return;
577: }
578:
579: if (pthread_mutex_unlock(&(*s_argument_thread).mutex) != 0)
580: {
581: (*s_etat_processus).erreur_systeme = d_es_processus;
582: return;
583: }
584:
585: // Lancement du thread de surveillance
586:
587: if (pthread_create(&thread_surveillance, &attributs,
588: surveillance_processus, s_argument_thread) != 0)
589: {
590: (*s_etat_processus).erreur_systeme = d_es_processus;
591: return;
592: }
593:
594: if (pthread_attr_destroy(&attributs) != 0)
595: {
596: (*s_etat_processus).erreur_systeme = d_es_processus;
597: return;
598: }
599:
600: // Le fils peut être présent sans être en attente du signal de départ.
601:
1.43 bertrand 602: if (envoi_signal_thread((*s_argument_thread).tid, rpl_sigstart) != 0)
1.1 bertrand 603: {
604: (*s_etat_processus).erreur_systeme = d_es_processus;
605: return;
606: }
607:
608: return;
609: }
610:
611:
612: /*
613: ================================================================================
614: Fonction 'sqlconnect'
615: ================================================================================
616: Entrées :
617: --------------------------------------------------------------------------------
618: Sorties :
619: --------------------------------------------------------------------------------
620: Effets de bord : néant
621: ================================================================================
622: */
623:
624: void
625: instruction_sqlconnect(struct_processus *s_etat_processus)
626: {
627: struct_objet *s_objet_argument;
628: struct_objet *s_objet_resultat;
629: struct_objet *s_objet_systeme;
630:
631: (*s_etat_processus).erreur_execution = d_ex;
632:
633: if ((*s_etat_processus).affichage_arguments == 'Y')
634: {
635: printf("\n SQLCONNECT ");
636:
637: if ((*s_etat_processus).langue == 'F')
638: {
639: printf("(connexion à une base de données SQL)\n\n");
640: }
641: else
642: {
643: printf("(connect to SQL database)\n\n");
644: }
645:
646: printf(" 1: %s\n", d_LST);
647: printf("-> 1: %s\n\n", d_SQL);
648:
649: if ((*s_etat_processus).langue == 'F')
650: {
651: printf(" Utilisation :\n\n");
652: }
653: else
654: {
655: printf(" Usage:\n\n");
656: }
657:
658: printf(" { \"mysql\" \"server\" \"database\" "
659: "\"user\" \"password\" } SQLCONNECT\n");
1.67 bertrand 660: printf(" { \"sqlite\" \"file\" } SQLCONNECT\n");
1.1 bertrand 661: printf(" { \"postgresql:iso-8859-1\" \"server\" "
662: "\"database\" \"user\" \"password\" port }\n");
663: printf(" SQLCONNECT\n");
664:
665: return;
666: }
667: else if ((*s_etat_processus).test_instruction == 'Y')
668: {
669: (*s_etat_processus).nombre_arguments = -1;
670: return;
671: }
672:
673: if (test_cfsf(s_etat_processus, 31) == d_vrai)
674: {
675: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
676: {
677: return;
678: }
679: }
680:
681: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
682: &s_objet_argument) == d_erreur)
683: {
684: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
685: return;
686: }
687:
688: if ((*s_objet_argument).type == LST)
689: {
690: if ((s_objet_resultat = parametres_sql(s_etat_processus,
691: s_objet_argument)) == NULL)
692: {
1.56 bertrand 693: liberation(s_etat_processus, s_objet_resultat);
1.1 bertrand 694: liberation(s_etat_processus, s_objet_argument);
695: return;
696: }
697:
1.56 bertrand 698: if ((*s_etat_processus).erreur_execution ==
699: d_ex_instruction_indisponible)
700: {
701: liberation(s_etat_processus, s_objet_resultat);
702: return;
703: }
704:
1.1 bertrand 705: if ((s_objet_systeme = copie_objet(s_etat_processus, s_objet_resultat,
706: 'O')) == NULL)
707: {
708: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
709: return;
710: }
711:
712: if (empilement(s_etat_processus,
713: (struct_liste_chainee **) &((*s_etat_processus)
714: .s_connecteurs_sql), s_objet_systeme) == d_erreur)
715: {
716: return;
717: }
718:
719: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
720: s_objet_resultat) == d_erreur)
721: {
722: return;
723: }
724: }
725: else
726: {
727: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
728:
729: liberation(s_etat_processus, s_objet_argument);
730: return;
731: }
732:
733: liberation(s_etat_processus, s_objet_argument);
734: return;
735: }
736:
737:
738: /*
739: ================================================================================
1.8 bertrand 740: Fonction 'sqldisconnect'
1.1 bertrand 741: ================================================================================
742: Entrées :
743: --------------------------------------------------------------------------------
744: Sorties :
745: --------------------------------------------------------------------------------
746: Effets de bord : néant
747: ================================================================================
748: */
749:
750: void
751: instruction_sqldisconnect(struct_processus *s_etat_processus)
752: {
753: logical1 drapeau;
754:
755: struct_liste_chainee *l_element_courant;
756: struct_liste_chainee *l_element_precedent;
757:
758: struct_objet *s_objet;
759:
760: (*s_etat_processus).erreur_execution = d_ex;
761:
762: if ((*s_etat_processus).affichage_arguments == 'Y')
763: {
764: printf("\n SQLDISCONNECT ");
765:
766: if ((*s_etat_processus).langue == 'F')
767: {
768: printf("(déconnexion d'une base de donnée SQL)\n\n");
769: }
770: else
771: {
772: printf("(disconnection from SQL database)\n\n");
773: }
774:
775: printf(" 1: %s\n", d_SQL);
776: return;
777: }
778: else if ((*s_etat_processus).test_instruction == 'Y')
779: {
780: (*s_etat_processus).nombre_arguments = -1;
781: return;
782: }
783:
784: if (test_cfsf(s_etat_processus, 31) == d_vrai)
785: {
786: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
787: {
788: return;
789: }
790: }
791:
792: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
793: &s_objet) == d_erreur)
794: {
795: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
796: return;
797: }
798:
799: if ((*s_objet).type == SQL)
800: {
801: if (((*((struct_connecteur_sql *) (*s_objet).objet)).pid !=
802: getpid()) || (pthread_equal((*((struct_connecteur_sql *)
803: (*s_objet).objet)).tid, pthread_self()) == 0))
804: {
805: (*s_etat_processus).erreur_execution = d_ex_fichier_hors_contexte;
806:
807: liberation(s_etat_processus, s_objet);
808: return;
809: }
810:
811: l_element_courant = (*s_etat_processus).s_connecteurs_sql;
812: l_element_precedent = NULL;
813:
814: while(l_element_courant != NULL)
815: {
816: if (((*((struct_connecteur_sql *) (*(*l_element_courant).donnee)
817: .objet)).pid == getpid()) && (pthread_equal(
818: (*((struct_connecteur_sql *) (*(*l_element_courant).donnee)
819: .objet)).tid, pthread_self()) != 0) &&
820: (strcmp((*((struct_connecteur_sql *) (*(*l_element_courant)
821: .donnee).objet)).type, (*((struct_connecteur_sql *)
822: (*s_objet).objet)).type) == 0))
823: {
824: if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type,
825: "MYSQL") == 0)
826: {
827: # ifdef MYSQL_SUPPORT
1.17 bertrand 828:
1.1 bertrand 829: if ((*((struct_connecteur_sql *) (*(*l_element_courant)
830: .donnee).objet)).descripteur.mysql ==
831: (*((struct_connecteur_sql *) (*s_objet).objet))
832: .descripteur.mysql)
833: {
834: drapeau = d_vrai;
835: }
836: else
837: {
838: drapeau = d_faux;
839: }
1.17 bertrand 840:
1.1 bertrand 841: # else
842:
843: if ((*s_etat_processus).langue == 'F')
844: {
845: printf("+++Attention : Support de MySQL "
846: "non compilé !\n");
847: }
848: else
849: {
850: printf("+++Warning : MySQL support not available !\n");
851: }
852:
853: fflush(stdout);
854:
855: drapeau = d_faux;
856: # endif
857: }
858: else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet))
859: .type, "POSTGRESQL") == 0)
860: {
861: # ifdef POSTGRESQL_SUPPORT
1.17 bertrand 862:
1.1 bertrand 863: if ((*((struct_connecteur_sql *) (*(*l_element_courant)
864: .donnee).objet)).descripteur.postgresql ==
865: (*((struct_connecteur_sql *) (*s_objet).objet))
866: .descripteur.postgresql)
867: {
868: drapeau = d_vrai;
869: }
870: else
871: {
872: drapeau = d_faux;
873: }
874:
875: # else
876:
877: if ((*s_etat_processus).langue == 'F')
878: {
879: printf("+++Attention : Support de PostgreSQL "
880: "non compilé !\n");
881: }
882: else
883: {
884: printf("+++Warning : PostgreSQL support "
885: "not available !\n");
886: }
887:
888: fflush(stdout);
889:
890: drapeau = d_faux;
891: # endif
892: }
1.67 bertrand 893: else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet))
894: .type, "SQLITE") == 0)
895: {
896: if ((*((struct_connecteur_sql *) (*(*l_element_courant)
897: .donnee).objet)).descripteur.sqlite ==
898: (*((struct_connecteur_sql *) (*s_objet).objet))
899: .descripteur.sqlite)
900: {
901: drapeau = d_vrai;
902: }
903: else
904: {
905: drapeau = d_faux;
906: }
907: }
1.1 bertrand 908: else
909: {
910: BUG(1, printf("SQL type '%s' not allowed!",
911: (*((struct_connecteur_sql *) (*s_objet).objet))
912: .type));
913: return;
914: }
915:
916: if (drapeau == d_vrai)
917: {
918: if (l_element_precedent == NULL)
919: {
920: (*s_etat_processus).s_connecteurs_sql =
921: (*l_element_courant).suivant;
922: }
923: else if ((*l_element_courant).suivant == NULL)
924: {
925: (*l_element_precedent).suivant = NULL;
926: }
927: else
928: {
929: (*l_element_precedent).suivant =
930: (*l_element_courant).suivant;
931: }
932:
933: liberation(s_etat_processus, (*l_element_courant).donnee);
934: free(l_element_courant);
935:
936: break;
937: }
938: }
939:
940: l_element_precedent = l_element_courant;
941: l_element_courant = (*l_element_courant).suivant;
942: }
943:
944: sqlclose(s_objet);
945: }
946: else
947: {
948: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
949:
950: liberation(s_etat_processus, s_objet);
951: return;
952: }
953:
954: liberation(s_etat_processus, s_objet);
955: return;
956: }
957:
958:
959: /*
960: ================================================================================
961: Fonction 'smphrincr'
962: ================================================================================
963: Entrées :
964: --------------------------------------------------------------------------------
965: Sorties :
966: --------------------------------------------------------------------------------
967: Effets de bord : néant
968: ================================================================================
969: */
970:
971: void
972: instruction_smphrincr(struct_processus *s_etat_processus)
973: {
974: struct_objet *s_objet_argument;
975:
976: (*s_etat_processus).erreur_execution = d_ex;
977:
978: if ((*s_etat_processus).affichage_arguments == 'Y')
979: {
980: printf("\n SMPHRINCR ");
981:
982: if ((*s_etat_processus).langue == 'F')
983: {
984: printf("(incrémentation du sémaphore)\n\n");
985: }
986: else
987: {
988: printf("(semaphore incrementation)\n\n");
989: }
990:
991: printf(" 1: %s\n", d_SPH);
992: return;
993: }
994: else if ((*s_etat_processus).test_instruction == 'Y')
995: {
996: (*s_etat_processus).nombre_arguments = -1;
997: return;
998: }
999:
1000: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1001: {
1002: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1003: {
1004: return;
1005: }
1006: }
1007:
1008: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1009: &s_objet_argument) == d_erreur)
1010: {
1011: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1012: return;
1013: }
1014:
1015: if ((*s_objet_argument).type == SPH)
1016: {
1017: if (sem_post((*((struct_semaphore *) (*s_objet_argument).objet))
1018: .semaphore) != 0)
1019: {
1020: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1021:
1022: liberation(s_etat_processus, s_objet_argument);
1023: return;
1024: }
1025:
1026: liberation(s_etat_processus, s_objet_argument);
1027: }
1028: else
1029: {
1030: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1031:
1032: liberation(s_etat_processus, s_objet_argument);
1033: return;
1034: }
1035:
1036: return;
1037: }
1038:
1039:
1040: /*
1041: ================================================================================
1042: Fonction 'smphrdecr'
1043: ================================================================================
1044: Entrées :
1045: --------------------------------------------------------------------------------
1046: Sorties :
1047: --------------------------------------------------------------------------------
1048: Effets de bord : néant
1049: ================================================================================
1050: */
1051:
1052: void
1053: instruction_smphrdecr(struct_processus *s_etat_processus)
1054: {
1055: struct_objet *s_objet_argument;
1056:
1057: unsigned char *tampon;
1058:
1059: (*s_etat_processus).erreur_execution = d_ex;
1060:
1061: if ((*s_etat_processus).affichage_arguments == 'Y')
1062: {
1063: printf("\n SMPHRDECR ");
1064:
1065: if ((*s_etat_processus).langue == 'F')
1066: {
1067: printf("(decrémentation du sémaphore)\n\n");
1068: }
1069: else
1070: {
1071: printf("(semaphore decrementation)\n\n");
1072: }
1073:
1074: printf(" 1: %s\n", d_SPH);
1075: return;
1076: }
1077: else if ((*s_etat_processus).test_instruction == 'Y')
1078: {
1079: (*s_etat_processus).nombre_arguments = -1;
1080: return;
1081: }
1082:
1083: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1084: {
1085: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1086: {
1087: return;
1088: }
1089: }
1090:
1091: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1092: &s_objet_argument) == d_erreur)
1093: {
1094: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1095: return;
1096: }
1097:
1098: if ((*s_objet_argument).type == SPH)
1099: {
1100: if ((*s_etat_processus).profilage == d_vrai)
1101: {
1102: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
1103: == NULL)
1104: {
1105: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1106: return;
1107: }
1108:
1109: profilage(s_etat_processus, tampon);
1110: free(tampon);
1111:
1112: if ((*s_etat_processus).erreur_systeme != d_es)
1113: {
1114: return;
1115: }
1116: }
1117:
1.48 bertrand 1118: # ifndef SEMAPHORES_NOMMES
1119: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1120: # else
1121: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1122: # endif
1.1 bertrand 1123: {
1124: (*s_etat_processus).erreur_systeme = d_es_processus;
1125: return;
1126: }
1127:
1128: while(sem_wait((*((struct_semaphore *) (*s_objet_argument).objet))
1129: .semaphore) == -1)
1130: {
1131: if (errno != EINTR)
1132: {
1.48 bertrand 1133: # ifndef SEMAPHORES_NOMMES
1134: sem_post(&((*s_etat_processus).semaphore_fork));
1135: # else
1136: sem_post((*s_etat_processus).semaphore_fork);
1137: # endif
1138:
1.1 bertrand 1139: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1140:
1141: if ((*s_etat_processus).profilage == d_vrai)
1142: {
1143: profilage(s_etat_processus, NULL);
1144: }
1145:
1146: liberation(s_etat_processus, s_objet_argument);
1147: return;
1148: }
1149: }
1150:
1.48 bertrand 1151: # ifndef SEMAPHORES_NOMMES
1152: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1153: # else
1154: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1155: # endif
1.1 bertrand 1156: {
1.47 bertrand 1157: if (errno != EINTR)
1.1 bertrand 1158: {
1.47 bertrand 1159: if ((*s_etat_processus).profilage == d_vrai)
1160: {
1161: profilage(s_etat_processus, NULL);
1162: }
1163:
1164: (*s_etat_processus).erreur_systeme = d_es_processus;
1165: return;
1.44 bertrand 1166: }
1.1 bertrand 1167: }
1168:
1169: if ((*s_etat_processus).profilage == d_vrai)
1170: {
1171: profilage(s_etat_processus, NULL);
1172: }
1173:
1174: liberation(s_etat_processus, s_objet_argument);
1175: }
1176: else
1177: {
1178: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1179:
1180: liberation(s_etat_processus, s_objet_argument);
1181: return;
1182: }
1183:
1184: return;
1185: }
1186:
1187:
1188: /*
1189: ================================================================================
1190: Fonction 'smphrtrydecr'
1191: ================================================================================
1192: Entrées :
1193: --------------------------------------------------------------------------------
1194: Sorties :
1195: --------------------------------------------------------------------------------
1196: Effets de bord : néant
1197: ================================================================================
1198: */
1199:
1200: void
1201: instruction_smphrtrydecr(struct_processus *s_etat_processus)
1202: {
1.58 bertrand 1203: real8 partie_entiere;
1204:
1205: struct_objet *s_objet_argument_1;
1206: struct_objet *s_objet_argument_2;
1.1 bertrand 1207: struct_objet *s_objet_resultat;
1208:
1.58 bertrand 1209: struct timeval horodatage;
1210:
1211: struct timespec horodatage_absolu;
1212:
1.1 bertrand 1213: unsigned char *tampon;
1214:
1215: (*s_etat_processus).erreur_execution = d_ex;
1216:
1217: if ((*s_etat_processus).affichage_arguments == 'Y')
1218: {
1219: printf("\n SMPHRTRYDECR ");
1220:
1221: if ((*s_etat_processus).langue == 'F')
1222: {
1223: printf("(essai de decrémentation du sémaphore)\n\n");
1224: }
1225: else
1226: {
1227: printf("(try to decremente semaphore)\n\n");
1228: }
1229:
1.58 bertrand 1230: printf(" 2: %s\n", d_SPH);
1231: printf(" 1: %s, %s\n", d_INT, d_REL);
1.1 bertrand 1232: printf("-> 1: %s\n", d_INT);
1233: return;
1234: }
1235: else if ((*s_etat_processus).test_instruction == 'Y')
1236: {
1237: (*s_etat_processus).nombre_arguments = -1;
1238: return;
1239: }
1240:
1241: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1242: {
1.58 bertrand 1243: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
1.1 bertrand 1244: {
1245: return;
1246: }
1247: }
1248:
1249: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1.58 bertrand 1250: &s_objet_argument_1) == d_erreur)
1251: {
1252: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1253: return;
1254: }
1255:
1256: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1257: &s_objet_argument_2) == d_erreur)
1.1 bertrand 1258: {
1259: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1260: return;
1261: }
1262:
1.58 bertrand 1263: if (((*s_objet_argument_2).type == SPH) && (((*s_objet_argument_1).type
1264: == INT) || ((*s_objet_argument_1).type == REL)))
1.1 bertrand 1265: {
1.58 bertrand 1266: gettimeofday(&horodatage, NULL);
1267:
1268: if ((*s_objet_argument_1).type == INT)
1269: {
1270: if ((*((integer8 *) (*s_objet_argument_1).objet)) < 0)
1271: {
1272: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1273:
1274: liberation(s_etat_processus, s_objet_argument_1);
1275: liberation(s_etat_processus, s_objet_argument_2);
1276: return;
1277: }
1278:
1.72 bertrand 1279: horodatage.tv_sec += (time_t) (*((integer8 *)
1280: (*s_objet_argument_1).objet));
1.58 bertrand 1281: }
1282: else
1283: {
1284: if ((*((real8 *) (*s_objet_argument_1).objet)) < 0)
1285: {
1286: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1287:
1288: liberation(s_etat_processus, s_objet_argument_1);
1289: liberation(s_etat_processus, s_objet_argument_2);
1290: return;
1291: }
1292:
1293: partie_entiere = floor((*((real8 *) (*s_objet_argument_1).objet)));
1.71 bertrand 1294: horodatage.tv_sec += (time_t) partie_entiere;
1.59 bertrand 1295: horodatage.tv_usec += ((suseconds_t) ((*((real8 *)
1296: (*s_objet_argument_1).objet)) - partie_entiere)) * 1000000;
1.58 bertrand 1297:
1298: if (horodatage.tv_usec > 1000000)
1299: {
1300: horodatage.tv_usec -= 1000000;
1301: horodatage.tv_sec += 1;
1302: }
1303: }
1304:
1305: horodatage_absolu.tv_sec = horodatage.tv_sec;
1306: horodatage_absolu.tv_nsec = horodatage.tv_usec * 1000;
1307:
1.1 bertrand 1308: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1309: {
1310: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1311: return;
1312: }
1313:
1314: if ((*s_etat_processus).profilage == d_vrai)
1315: {
1.58 bertrand 1316: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument_2))
1.1 bertrand 1317: == NULL)
1318: {
1319: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1320: return;
1321: }
1322:
1323: profilage(s_etat_processus, tampon);
1324: free(tampon);
1325:
1326: if ((*s_etat_processus).erreur_systeme != d_es)
1327: {
1328: return;
1329: }
1330: }
1331:
1.48 bertrand 1332: # ifndef SEMAPHORES_NOMMES
1333: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
1334: # else
1335: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
1336: # endif
1.7 bertrand 1337: {
1.44 bertrand 1338: if ((*s_etat_processus).profilage == d_vrai)
1339: {
1340: profilage(s_etat_processus, NULL);
1341: }
1342:
1.7 bertrand 1343: (*s_etat_processus).erreur_systeme = d_es_processus;
1344: return;
1345: }
1.1 bertrand 1346:
1.58 bertrand 1347: (*((integer8 *) (*s_objet_resultat).objet)) = -1;
1.1 bertrand 1348:
1.58 bertrand 1349: while(sem_timedwait((*((struct_semaphore *) (*s_objet_argument_2)
1350: .objet)).semaphore, &horodatage_absolu) == -1)
1.1 bertrand 1351: {
1352: switch(errno)
1353: {
1354: case EINTR :
1355: {
1356: break;
1357: }
1358:
1359: case EINVAL :
1360: {
1361: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1362:
1363: if ((*s_etat_processus).profilage == d_vrai)
1364: {
1365: profilage(s_etat_processus, NULL);
1366: }
1367:
1.58 bertrand 1368: liberation(s_etat_processus, s_objet_argument_1);
1369: liberation(s_etat_processus, s_objet_argument_2);
1.1 bertrand 1370: return;
1371: }
1372:
1.58 bertrand 1373: case ETIMEDOUT :
1.1 bertrand 1374: {
1.58 bertrand 1375: (*((integer8 *) (*s_objet_resultat).objet)) = 0;
1.1 bertrand 1376: break;
1377: }
1378: }
1379:
1.58 bertrand 1380: if ((*((integer8 *) (*s_objet_resultat).objet)) == 0)
1.1 bertrand 1381: {
1382: break;
1383: }
1384: }
1385:
1.48 bertrand 1386: # ifndef SEMAPHORES_NOMMES
1387: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
1388: # else
1389: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
1390: # endif
1.1 bertrand 1391: {
1.47 bertrand 1392: if (errno != EINTR)
1.1 bertrand 1393: {
1.47 bertrand 1394: if ((*s_etat_processus).profilage == d_vrai)
1395: {
1396: profilage(s_etat_processus, NULL);
1397: }
1398:
1399: (*s_etat_processus).erreur_systeme = d_es_processus;
1400: return;
1.44 bertrand 1401: }
1.1 bertrand 1402: }
1403:
1404: if ((*s_etat_processus).profilage == d_vrai)
1405: {
1406: profilage(s_etat_processus, NULL);
1407: }
1408:
1.58 bertrand 1409: liberation(s_etat_processus, s_objet_argument_1);
1410: liberation(s_etat_processus, s_objet_argument_2);
1.1 bertrand 1411: }
1412: else
1413: {
1414: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1415:
1.58 bertrand 1416: liberation(s_etat_processus, s_objet_argument_1);
1417: liberation(s_etat_processus, s_objet_argument_2);
1.1 bertrand 1418: return;
1419: }
1420:
1421: return;
1422: }
1423:
1424:
1425: /*
1426: ================================================================================
1427: Fonction 'smphrgetv'
1428: ================================================================================
1429: Entrées :
1430: --------------------------------------------------------------------------------
1431: Sorties :
1432: --------------------------------------------------------------------------------
1433: Effets de bord : néant
1434: ================================================================================
1435: */
1436:
1437: void
1438: instruction_smphrgetv(struct_processus *s_etat_processus)
1439: {
1440: int valeur;
1441:
1442: struct_objet *s_objet_argument;
1443: struct_objet *s_objet_resultat;
1444:
1445: (*s_etat_processus).erreur_execution = d_ex;
1446:
1447: if ((*s_etat_processus).affichage_arguments == 'Y')
1448: {
1449: printf("\n SMPHRGETV ");
1450:
1451: if ((*s_etat_processus).langue == 'F')
1452: {
1453: printf("(valeur du sémaphore)\n\n");
1454: }
1455: else
1456: {
1457: printf("(semaphore value)\n\n");
1458: }
1459:
1460: printf(" 1: %s\n", d_SPH);
1461: return;
1462: }
1463: else if ((*s_etat_processus).test_instruction == 'Y')
1464: {
1465: (*s_etat_processus).nombre_arguments = -1;
1466: return;
1467: }
1468:
1469: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1470: {
1471: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1472: {
1473: return;
1474: }
1475: }
1476:
1477: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1478: &s_objet_argument) == d_erreur)
1479: {
1480: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1481: return;
1482: }
1483:
1484: if ((*s_objet_argument).type == SPH)
1485: {
1486: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
1487: {
1488: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1489:
1490: liberation(s_etat_processus, s_objet_argument);
1491: return;
1492: }
1493:
1494: if (sem_getvalue((*((struct_semaphore *) (*s_objet_argument).objet))
1495: .semaphore, &valeur) != 0)
1496: {
1497: (*s_etat_processus).erreur_execution = d_ex_semaphore;
1498:
1499: liberation(s_etat_processus, s_objet_argument);
1500: return;
1501: }
1502:
1503: (*((integer8 *) (*s_objet_resultat).objet)) = valeur;
1504:
1505: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1506: s_objet_resultat) == d_erreur)
1507: {
1508: return;
1509: }
1510:
1511: liberation(s_etat_processus, s_objet_argument);
1512: }
1513: else
1514: {
1515: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1516:
1517: liberation(s_etat_processus, s_objet_argument);
1518: return;
1519: }
1520:
1521: return;
1522: }
1523:
1524:
1525: /*
1526: ================================================================================
1527: Fonction 'svl'
1528: ================================================================================
1529: Entrées :
1530: --------------------------------------------------------------------------------
1531: Sorties :
1532: --------------------------------------------------------------------------------
1533: Effets de bord : néant
1534: ================================================================================
1535: */
1536:
1537: void
1538: instruction_svl(struct_processus *s_etat_processus)
1539: {
1540: struct_objet *s_objet_argument;
1541: struct_objet *s_objet_resultat;
1542:
1543: (*s_etat_processus).erreur_execution = d_ex;
1544:
1545: if ((*s_etat_processus).affichage_arguments == 'Y')
1546: {
1547: printf("\n SVL ");
1548:
1549: if ((*s_etat_processus).langue == 'F')
1550: {
1551: printf("(valeurs singulières)\n\n");
1552: }
1553: else
1554: {
1555: printf("(singular values)\n\n");
1556: }
1557:
1558: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1559: printf("-> 1: %s\n", d_VRL);
1560: return;
1561: }
1562: else if ((*s_etat_processus).test_instruction == 'Y')
1563: {
1564: (*s_etat_processus).nombre_arguments = -1;
1565: return;
1566: }
1567:
1568: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1569: {
1570: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1571: {
1572: return;
1573: }
1574: }
1575:
1576: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1577: &s_objet_argument) == d_erreur)
1578: {
1579: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1580: return;
1581: }
1582:
1583: if (((*s_objet_argument).type == MIN) ||
1584: ((*s_objet_argument).type == MRL) ||
1585: ((*s_objet_argument).type == MCX))
1586: {
1587: if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
1588: {
1589: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1590: return;
1591: }
1592:
1593: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1594: NULL, (*s_objet_resultat).objet, NULL);
1595:
1596: if ((*s_etat_processus).erreur_systeme != d_es)
1597: {
1598: return;
1599: }
1600:
1601: if (((*s_etat_processus).erreur_execution != d_ex) ||
1602: ((*s_etat_processus).exception != d_ep))
1603: {
1604: liberation(s_etat_processus, s_objet_resultat);
1605: liberation(s_etat_processus, s_objet_argument);
1606: return;
1607: }
1608:
1609: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1610: s_objet_resultat) == d_erreur)
1611: {
1612: return;
1613: }
1614: }
1615: else
1616: {
1617: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1618:
1619: liberation(s_etat_processus, s_objet_argument);
1620: return;
1621: }
1622:
1623: liberation(s_etat_processus, s_objet_argument);
1624:
1625: return;
1626: }
1627:
1628:
1629: /*
1630: ================================================================================
1631: Fonction 'svd'
1632: ================================================================================
1633: Entrées :
1634: --------------------------------------------------------------------------------
1635: Sorties :
1636: --------------------------------------------------------------------------------
1637: Effets de bord : néant
1638: ================================================================================
1639: */
1640:
1641: void
1642: instruction_svd(struct_processus *s_etat_processus)
1643: {
1644: struct_objet *s_objet_argument;
1645: struct_objet *s_objet_resultat_1;
1646: struct_objet *s_objet_resultat_2;
1647: struct_objet *s_objet_resultat_3;
1648:
1649: struct_vecteur s_vecteur;
1650:
1.70 bertrand 1651: integer8 i;
1652: integer8 j;
1.1 bertrand 1653:
1654: (*s_etat_processus).erreur_execution = d_ex;
1655:
1656: if ((*s_etat_processus).affichage_arguments == 'Y')
1657: {
1658: printf("\n SVD ");
1659:
1660: if ((*s_etat_processus).langue == 'F')
1661: {
1662: printf("(décomposition en valeurs singulières)\n\n");
1663: }
1664: else
1665: {
1666: printf("(singular value decomposition)\n\n");
1667: }
1668:
1669: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
1670: printf("-> 3: %s, %s\n", d_MRL, d_MCX);
1671: printf(" 2: %s, %s\n", d_MRL, d_MCX);
1672: printf(" 1: %s\n", d_VRL);
1673: return;
1674: }
1675: else if ((*s_etat_processus).test_instruction == 'Y')
1676: {
1677: (*s_etat_processus).nombre_arguments = -1;
1678: return;
1679: }
1680:
1681: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1682: {
1683: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1684: {
1685: return;
1686: }
1687: }
1688:
1689: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1690: &s_objet_argument) == d_erreur)
1691: {
1692: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1693: return;
1694: }
1695:
1696: if (((*s_objet_argument).type == MIN) ||
1697: ((*s_objet_argument).type == MRL))
1698: {
1699: if ((s_objet_resultat_1 = allocation(s_etat_processus, MRL)) == NULL)
1700: {
1701: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1702: return;
1703: }
1704:
1705: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL)
1706: {
1707: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1708: return;
1709: }
1710:
1711: if ((s_objet_resultat_3 = allocation(s_etat_processus, MRL)) == NULL)
1712: {
1713: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1714: return;
1715: }
1716:
1717: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1718: (*s_objet_resultat_3).objet, &s_vecteur,
1719: (*s_objet_resultat_1).objet);
1720:
1721: if ((*s_etat_processus).erreur_systeme != d_es)
1722: {
1723: return;
1724: }
1725:
1726: if (((*s_etat_processus).erreur_execution != d_ex) ||
1727: ((*s_etat_processus).exception != d_ep))
1728: {
1729: liberation(s_etat_processus, s_objet_resultat_1);
1730: liberation(s_etat_processus, s_objet_resultat_2);
1731: liberation(s_etat_processus, s_objet_resultat_3);
1732: liberation(s_etat_processus, s_objet_argument);
1733: return;
1734: }
1735:
1736: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
1737: (*((struct_matrice *) (*s_objet_argument).objet))
1738: .nombre_colonnes;
1739: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
1740: (*((struct_matrice *) (*s_objet_argument).objet))
1741: .nombre_lignes;
1742:
1743: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
1.70 bertrand 1744: malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat_2)
1745: .objet)).nombre_lignes) * sizeof(real8 *))) == NULL)
1.1 bertrand 1746: {
1747: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1748: return;
1749: }
1750:
1751: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1752: .nombre_lignes; i++)
1753: {
1754: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1.70 bertrand 1755: .objet)).tableau)[i] = malloc(((size_t)
1756: (*((struct_matrice *) (*s_objet_resultat_2).objet))
1757: .nombre_colonnes) * sizeof(real8 *))) == NULL)
1.1 bertrand 1758: {
1759: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1760: return;
1761: }
1762:
1763: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1764: .nombre_colonnes; j++)
1765: {
1766: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1767: .objet)).tableau)[i][j] = 0;
1768: }
1769: }
1770:
1771: for(i = 0; i < s_vecteur.taille; i++)
1772: {
1773: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
1774: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i];
1775: }
1776:
1777: free(s_vecteur.tableau);
1778:
1779: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1780: s_objet_resultat_3) == d_erreur)
1781: {
1782: return;
1783: }
1784:
1785: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1786: s_objet_resultat_2) == d_erreur)
1787: {
1788: return;
1789: }
1790:
1791: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1792: s_objet_resultat_1) == d_erreur)
1793: {
1794: return;
1795: }
1796: }
1797: else if ((*s_objet_argument).type == MCX)
1798: {
1799: if ((s_objet_resultat_1 = allocation(s_etat_processus, MCX)) == NULL)
1800: {
1801: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1802: return;
1803: }
1804:
1805: if ((s_objet_resultat_2 = allocation(s_etat_processus, MRL)) == NULL)
1806: {
1807: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1808: return;
1809: }
1810:
1811: if ((s_objet_resultat_3 = allocation(s_etat_processus, MCX)) == NULL)
1812: {
1813: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1814: return;
1815: }
1816:
1817: valeurs_singulieres(s_etat_processus, (*s_objet_argument).objet,
1818: (*s_objet_resultat_3).objet, &s_vecteur,
1819: (*s_objet_resultat_1).objet);
1820:
1821: if ((*s_etat_processus).erreur_systeme != d_es)
1822: {
1823: return;
1824: }
1825:
1826: if (((*s_etat_processus).erreur_execution != d_ex) ||
1827: ((*s_etat_processus).exception != d_ep))
1828: {
1829: liberation(s_etat_processus, s_objet_resultat_1);
1830: liberation(s_etat_processus, s_objet_resultat_2);
1831: liberation(s_etat_processus, s_objet_resultat_3);
1832: liberation(s_etat_processus, s_objet_argument);
1833: return;
1834: }
1835:
1836: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_colonnes =
1837: (*((struct_matrice *) (*s_objet_argument).objet))
1838: .nombre_colonnes;
1839: (*((struct_matrice *) (*s_objet_resultat_2).objet)).nombre_lignes =
1840: (*((struct_matrice *) (*s_objet_argument).objet))
1841: .nombre_lignes;
1842:
1843: if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
1.70 bertrand 1844: malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat_2)
1845: .objet)).nombre_lignes) * sizeof(real8 *))) == NULL)
1.1 bertrand 1846: {
1847: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1848: return;
1849: }
1850:
1851: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1852: .nombre_lignes; i++)
1853: {
1854: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1.70 bertrand 1855: .objet)).tableau)[i] = malloc(((size_t)
1856: (*((struct_matrice *) (*s_objet_resultat_2).objet))
1857: .nombre_colonnes) * sizeof(real8 *))) == NULL)
1.1 bertrand 1858: {
1859: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1860: return;
1861: }
1862:
1863: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat_2).objet))
1864: .nombre_colonnes; j++)
1865: {
1866: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
1867: .objet)).tableau)[i][j] = 0;
1868: }
1869: }
1870:
1871: for(i = 0; i < s_vecteur.taille; i++)
1872: {
1873: ((real8 **) (*((struct_matrice *) (*s_objet_resultat_2).objet))
1874: .tableau)[i][i] = ((real8 *) (s_vecteur.tableau))[i];
1875: }
1876:
1877: free(s_vecteur.tableau);
1878:
1879: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1880: s_objet_resultat_3) == d_erreur)
1881: {
1882: return;
1883: }
1884:
1885: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1886: s_objet_resultat_2) == d_erreur)
1887: {
1888: return;
1889: }
1890:
1891: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1892: s_objet_resultat_1) == d_erreur)
1893: {
1894: return;
1895: }
1896: }
1897: else
1898: {
1899: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1900:
1901: liberation(s_etat_processus, s_objet_argument);
1902: return;
1903: }
1904:
1905: liberation(s_etat_processus, s_objet_argument);
1906: return;
1907: }
1908:
1909:
1910: /*
1911: ================================================================================
1912: Fonction 'swapcntxt'
1913: ================================================================================
1914: Entrées :
1915: --------------------------------------------------------------------------------
1916: Sorties :
1917: --------------------------------------------------------------------------------
1918: Effets de bord : néant
1919: ================================================================================
1920: */
1921:
1922: void
1923: instruction_swapcntxt(struct_processus *s_etat_processus)
1924: {
1925: integer8 i;
1926: integer8 registre_taille;
1927:
1928: struct_liste_chainee *l_element_courant;
1929: struct_liste_chainee *l_element_courant_taille;
1930: struct_liste_chainee *registre;
1931:
1932: struct_objet *s_objet_argument;
1933:
1934: (*s_etat_processus).erreur_execution = d_ex;
1935:
1936: if ((*s_etat_processus).affichage_arguments == 'Y')
1937: {
1938: printf("\n SWAPCNTXT ");
1939:
1940: if ((*s_etat_processus).langue == 'F')
1941: {
1942: printf("(échange de contextes)\n\n");
1943: }
1944: else
1945: {
1946: printf("(swap contexts)\n\n");
1947: }
1948:
1949: printf(" 1: %s\n", d_INT);
1950: return;
1951: }
1952: else if ((*s_etat_processus).test_instruction == 'Y')
1953: {
1954: (*s_etat_processus).nombre_arguments = -1;
1955: return;
1956: }
1957:
1958: if (test_cfsf(s_etat_processus, 31) == d_vrai)
1959: {
1960: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
1961: {
1962: return;
1963: }
1964: }
1965:
1966: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
1967: &s_objet_argument) == d_erreur)
1968: {
1969: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1970: return;
1971: }
1972:
1973: if ((*s_objet_argument).type == INT)
1974: {
1975: l_element_courant = (*s_etat_processus).l_base_pile_contextes;
1976: l_element_courant_taille = (*s_etat_processus)
1977: .l_base_pile_taille_contextes;
1978:
1979: i = (*((integer8 *) (*s_objet_argument).objet));
1980:
1981: while((l_element_courant != NULL) && (l_element_courant_taille != NULL))
1982: {
1983: i--;
1984:
1985: if (i == 0)
1986: {
1987: break;
1988: }
1989:
1990: l_element_courant = (*l_element_courant).suivant;
1991: l_element_courant_taille = (*l_element_courant_taille).suivant;
1992: }
1993:
1994: if ((l_element_courant == NULL) || (l_element_courant_taille == NULL))
1995: {
1996: liberation(s_etat_processus, s_objet_argument);
1997:
1998: (*s_etat_processus).erreur_execution = d_ex_contexte;
1999: return;
2000: }
2001:
2002: if ((*(*l_element_courant).donnee).type != LST)
2003: {
2004: (*s_etat_processus).erreur_systeme = d_es_contexte;
2005: return;
2006: }
2007:
2008: if ((*(*l_element_courant_taille).donnee).type != INT)
2009: {
2010: (*s_etat_processus).erreur_systeme = d_es_contexte;
2011: return;
2012: }
2013:
2014: registre = (*s_etat_processus).l_base_pile;
2015: registre_taille = (*s_etat_processus).hauteur_pile_operationnelle;
2016:
2017: (*s_etat_processus).l_base_pile = (*(*l_element_courant).donnee).objet;
2018: (*s_etat_processus).hauteur_pile_operationnelle =
2019: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet));
2020:
2021: (*(*l_element_courant).donnee).objet = registre;
2022: (*((integer8 *) (*(*l_element_courant_taille).donnee).objet)) =
2023: registre_taille;
2024: }
2025: else
2026: {
2027: liberation(s_etat_processus, s_objet_argument);
2028:
2029: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2030: return;
2031: }
2032:
2033: liberation(s_etat_processus, s_objet_argument);
2034: }
2035:
2036: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s10.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src