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