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