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