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