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