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