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