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