1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.36
4: Copyright (C) 1989-2024 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 'gegvl'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_gegvl(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet_argument_1;
42: struct_objet *s_objet_argument_2;
43: struct_objet *s_objet_resultat;
44:
45: (*s_etat_processus).erreur_execution = d_ex;
46:
47: if ((*s_etat_processus).affichage_arguments == 'Y')
48: {
49: printf("\n GEGVL ");
50:
51: if ((*s_etat_processus).langue == 'F')
52: {
53: printf("(valeurs propres généralisées)\n\n");
54: }
55: else
56: {
57: printf("(generalized eigenvalues)\n\n");
58: }
59:
60: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
61: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
62: printf("-> 1: %s\n", d_VCX);
63:
64: return;
65: }
66: else if ((*s_etat_processus).test_instruction == 'Y')
67: {
68: (*s_etat_processus).nombre_arguments = -1;
69: return;
70: }
71:
72: if (test_cfsf(s_etat_processus, 31) == d_vrai)
73: {
74: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
75: {
76: return;
77: }
78: }
79:
80: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
81: &s_objet_argument_1) == d_erreur)
82: {
83: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
84: return;
85: }
86:
87: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
88: &s_objet_argument_2) == d_erreur)
89: {
90: liberation(s_etat_processus, s_objet_argument_1);
91:
92: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
93: return;
94: }
95:
96: /*
97: --------------------------------------------------------------------------------
98: Les arguments sont des matrices carrées de mêmes dimensions
99: --------------------------------------------------------------------------------
100: */
101:
102: if ((((*s_objet_argument_1).type == MIN) ||
103: ((*s_objet_argument_1).type == MRL) ||
104: ((*s_objet_argument_1).type == MCX)) &&
105: (((*s_objet_argument_2).type == MIN) ||
106: ((*s_objet_argument_2).type == MRL) ||
107: ((*s_objet_argument_2).type == MCX)))
108: {
109: if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
110: != (*((struct_matrice *) (*s_objet_argument_1).objet))
111: .nombre_colonnes) || ((*((struct_matrice *)
112: (*s_objet_argument_2).objet)).nombre_lignes !=
113: (*((struct_matrice *) (*s_objet_argument_2).objet))
114: .nombre_colonnes) || ((*((struct_matrice *)
115: (*s_objet_argument_1).objet)).nombre_lignes !=
116: (*((struct_matrice *) (*s_objet_argument_2).objet))
117: .nombre_lignes))
118: {
119: liberation(s_etat_processus, s_objet_argument_1);
120: liberation(s_etat_processus, s_objet_argument_2);
121:
122: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
123: return;
124: }
125:
126: if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL)
127: {
128: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
129: return;
130: }
131:
132: valeurs_propres_generalisees(s_etat_processus,
133: (struct_matrice *) (*s_objet_argument_2).objet,
134: (struct_matrice *) (*s_objet_argument_1).objet,
135: (struct_vecteur *) (*s_objet_resultat).objet,
136: NULL, NULL);
137:
138: if ((*s_etat_processus).erreur_systeme != d_ex)
139: {
140: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
141: return;
142: }
143:
144: if (((*s_etat_processus).exception != d_ep) ||
145: ((*s_etat_processus).erreur_execution != d_ex))
146: {
147: liberation(s_etat_processus, s_objet_argument_1);
148: liberation(s_etat_processus, s_objet_argument_2);
149: liberation(s_etat_processus, s_objet_resultat);
150: return;
151: }
152: }
153:
154: /*
155: --------------------------------------------------------------------------------
156: Type incompatible
157: --------------------------------------------------------------------------------
158: */
159:
160: else
161: {
162: liberation(s_etat_processus, s_objet_argument_1);
163: liberation(s_etat_processus, s_objet_argument_2);
164:
165: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
166: return;
167: }
168:
169: liberation(s_etat_processus, s_objet_argument_1);
170: liberation(s_etat_processus, s_objet_argument_2);
171:
172: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
173: s_objet_resultat) == d_erreur)
174: {
175: return;
176: }
177:
178: return;
179: }
180:
181:
182: /*
183: ================================================================================
184: Fonction 'gegv'
185: ================================================================================
186: Entrées : pointeur sur une structure struct_processus
187: --------------------------------------------------------------------------------
188: Sorties :
189: --------------------------------------------------------------------------------
190: Effets de bord : néant
191: ================================================================================
192: */
193:
194: void
195: instruction_gegv(struct_processus *s_etat_processus)
196: {
197: struct_objet *s_objet_argument_1;
198: struct_objet *s_objet_argument_2;
199: struct_objet *s_objet_resultat_1;
200: struct_objet *s_objet_resultat_2;
201: struct_objet *s_objet_resultat_3;
202:
203: (*s_etat_processus).erreur_execution = d_ex;
204:
205: if ((*s_etat_processus).affichage_arguments == 'Y')
206: {
207: printf("\n GEGV ");
208:
209: if ((*s_etat_processus).langue == 'F')
210: {
211: printf("(valeurs et vecteurs propres généralisés)\n\n");
212: }
213: else
214: {
215: printf("(generalized eigenvalues and eigenvectors)\n\n");
216: }
217:
218: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
219: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
220: printf("-> 3: %s\n", d_MCX);
221: printf(" 2: %s\n", d_MCX);
222: printf(" 1: %s\n", d_VCX);
223:
224: return;
225: }
226: else if ((*s_etat_processus).test_instruction == 'Y')
227: {
228: (*s_etat_processus).nombre_arguments = -1;
229: return;
230: }
231:
232: if (test_cfsf(s_etat_processus, 31) == d_vrai)
233: {
234: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
235: {
236: return;
237: }
238: }
239:
240: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
241: &s_objet_argument_1) == d_erreur)
242: {
243: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
244: return;
245: }
246:
247: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
248: &s_objet_argument_2) == d_erreur)
249: {
250: liberation(s_etat_processus, s_objet_argument_1);
251:
252: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
253: return;
254: }
255:
256: /*
257: --------------------------------------------------------------------------------
258: Les arguments sont des matrices carrées de mêmes dimensions
259: --------------------------------------------------------------------------------
260: */
261:
262: if ((((*s_objet_argument_1).type == MIN) ||
263: ((*s_objet_argument_1).type == MRL) ||
264: ((*s_objet_argument_1).type == MCX)) &&
265: (((*s_objet_argument_2).type == MIN) ||
266: ((*s_objet_argument_2).type == MRL) ||
267: ((*s_objet_argument_2).type == MCX)))
268: {
269: if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
270: != (*((struct_matrice *) (*s_objet_argument_1).objet))
271: .nombre_colonnes) || ((*((struct_matrice *)
272: (*s_objet_argument_2).objet)).nombre_lignes !=
273: (*((struct_matrice *) (*s_objet_argument_2).objet))
274: .nombre_colonnes) || ((*((struct_matrice *)
275: (*s_objet_argument_1).objet)).nombre_lignes !=
276: (*((struct_matrice *) (*s_objet_argument_2).objet))
277: .nombre_lignes))
278: {
279: liberation(s_etat_processus, s_objet_argument_1);
280: liberation(s_etat_processus, s_objet_argument_2);
281:
282: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
283: return;
284: }
285:
286: if ((s_objet_resultat_1 = allocation(s_etat_processus, VCX)) == NULL)
287: {
288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
289: return;
290: }
291:
292: if ((s_objet_resultat_2 = allocation(s_etat_processus, MCX)) == NULL)
293: {
294: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
295: return;
296: }
297:
298: if ((s_objet_resultat_3 = allocation(s_etat_processus, MCX)) == NULL)
299: {
300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
301: return;
302: }
303:
304: valeurs_propres_generalisees(s_etat_processus,
305: (struct_matrice *) (*s_objet_argument_2).objet,
306: (struct_matrice *) (*s_objet_argument_1).objet,
307: (struct_vecteur *) (*s_objet_resultat_1).objet,
308: (struct_matrice *) (*s_objet_resultat_3).objet,
309: (struct_matrice *) (*s_objet_resultat_2).objet);
310:
311: if ((*s_etat_processus).erreur_systeme != d_es)
312: {
313: return;
314: }
315:
316: if (((*s_etat_processus).exception != d_ep) ||
317: ((*s_etat_processus).erreur_execution != d_ex))
318: {
319: liberation(s_etat_processus, s_objet_argument_1);
320: liberation(s_etat_processus, s_objet_argument_2);
321: liberation(s_etat_processus, s_objet_resultat_1);
322: liberation(s_etat_processus, s_objet_resultat_2);
323: liberation(s_etat_processus, s_objet_resultat_3);
324:
325: return;
326: }
327: }
328:
329: /*
330: --------------------------------------------------------------------------------
331: Type incompatible
332: --------------------------------------------------------------------------------
333: */
334:
335: else
336: {
337: liberation(s_etat_processus, s_objet_argument_1);
338: liberation(s_etat_processus, s_objet_argument_2);
339:
340: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
341: return;
342: }
343:
344: liberation(s_etat_processus, s_objet_argument_1);
345: liberation(s_etat_processus, s_objet_argument_2);
346:
347: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
348: s_objet_resultat_3) == d_erreur)
349: {
350: return;
351: }
352:
353: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
354: s_objet_resultat_2) == d_erreur)
355: {
356: return;
357: }
358:
359: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
360: s_objet_resultat_1) == d_erreur)
361: {
362: return;
363: }
364:
365: return;
366: }
367:
368:
369: /*
370: ================================================================================
371: Fonction 'glegv'
372: ================================================================================
373: Entrées : pointeur sur une structure struct_processus
374: --------------------------------------------------------------------------------
375: Sorties :
376: --------------------------------------------------------------------------------
377: Effets de bord : néant
378: ================================================================================
379: */
380:
381: void
382: instruction_glegv(struct_processus *s_etat_processus)
383: {
384: struct_objet *s_objet_argument_1;
385: struct_objet *s_objet_argument_2;
386: struct_objet *s_objet_resultat_1;
387: struct_objet *s_objet_resultat_2;
388:
389: (*s_etat_processus).erreur_execution = d_ex;
390:
391: if ((*s_etat_processus).affichage_arguments == 'Y')
392: {
393: printf("\n GLEGV ");
394:
395: if ((*s_etat_processus).langue == 'F')
396: {
397: printf("(valeurs et vecteurs propres gauches généralisés)\n\n");
398: }
399: else
400: {
401: printf("(generalized eigenvalues and left eigenvectors)\n\n");
402: }
403:
404: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
405: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
406: printf("-> 2: %s\n", d_MCX);
407: printf(" 1: %s\n", d_VCX);
408:
409: return;
410: }
411: else if ((*s_etat_processus).test_instruction == 'Y')
412: {
413: (*s_etat_processus).nombre_arguments = -1;
414: return;
415: }
416:
417: if (test_cfsf(s_etat_processus, 31) == d_vrai)
418: {
419: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
420: {
421: return;
422: }
423: }
424:
425: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
426: &s_objet_argument_1) == d_erreur)
427: {
428: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
429: return;
430: }
431:
432: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
433: &s_objet_argument_2) == d_erreur)
434: {
435: liberation(s_etat_processus, s_objet_argument_1);
436:
437: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
438: return;
439: }
440:
441: /*
442: --------------------------------------------------------------------------------
443: Les arguments sont des matrices carrées de mêmes dimensions
444: --------------------------------------------------------------------------------
445: */
446:
447: if ((((*s_objet_argument_1).type == MIN) ||
448: ((*s_objet_argument_1).type == MRL) ||
449: ((*s_objet_argument_1).type == MCX)) &&
450: (((*s_objet_argument_2).type == MIN) ||
451: ((*s_objet_argument_2).type == MRL) ||
452: ((*s_objet_argument_2).type == MCX)))
453: {
454: if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
455: != (*((struct_matrice *) (*s_objet_argument_1).objet))
456: .nombre_colonnes) || ((*((struct_matrice *)
457: (*s_objet_argument_2).objet)).nombre_lignes !=
458: (*((struct_matrice *) (*s_objet_argument_2).objet))
459: .nombre_colonnes) || ((*((struct_matrice *)
460: (*s_objet_argument_1).objet)).nombre_lignes !=
461: (*((struct_matrice *) (*s_objet_argument_2).objet))
462: .nombre_lignes))
463: {
464: liberation(s_etat_processus, s_objet_argument_1);
465: liberation(s_etat_processus, s_objet_argument_2);
466:
467: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
468: return;
469: }
470:
471: if ((s_objet_resultat_1 = allocation(s_etat_processus, VCX)) == NULL)
472: {
473: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
474: return;
475: }
476:
477: if ((s_objet_resultat_2 = allocation(s_etat_processus, MCX)) == NULL)
478: {
479: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
480: return;
481: }
482:
483: valeurs_propres_generalisees(s_etat_processus,
484: (struct_matrice *) (*s_objet_argument_2).objet,
485: (struct_matrice *) (*s_objet_argument_1).objet,
486: (struct_vecteur *) (*s_objet_resultat_1).objet,
487: (struct_matrice *) (*s_objet_resultat_2).objet,
488: NULL);
489:
490: if ((*s_etat_processus).erreur_systeme != d_es)
491: {
492: return;
493: }
494:
495: if (((*s_etat_processus).exception != d_ep) ||
496: ((*s_etat_processus).erreur_execution != d_ex))
497: {
498: liberation(s_etat_processus, s_objet_argument_1);
499: liberation(s_etat_processus, s_objet_argument_2);
500: liberation(s_etat_processus, s_objet_resultat_1);
501: liberation(s_etat_processus, s_objet_resultat_2);
502:
503: return;
504: }
505: }
506:
507: /*
508: --------------------------------------------------------------------------------
509: Type incompatible
510: --------------------------------------------------------------------------------
511: */
512:
513: else
514: {
515: liberation(s_etat_processus, s_objet_argument_1);
516: liberation(s_etat_processus, s_objet_argument_2);
517:
518: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
519: return;
520: }
521:
522: liberation(s_etat_processus, s_objet_argument_1);
523: liberation(s_etat_processus, s_objet_argument_2);
524:
525: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
526: s_objet_resultat_2) == d_erreur)
527: {
528: return;
529: }
530:
531: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
532: s_objet_resultat_1) == d_erreur)
533: {
534: return;
535: }
536:
537: return;
538: }
539:
540:
541: /*
542: ================================================================================
543: Fonction 'gregv'
544: ================================================================================
545: Entrées : pointeur sur une structure struct_processus
546: --------------------------------------------------------------------------------
547: Sorties :
548: --------------------------------------------------------------------------------
549: Effets de bord : néant
550: ================================================================================
551: */
552:
553: void
554: instruction_gregv(struct_processus *s_etat_processus)
555: {
556: struct_objet *s_objet_argument_1;
557: struct_objet *s_objet_argument_2;
558: struct_objet *s_objet_resultat_1;
559: struct_objet *s_objet_resultat_2;
560:
561: (*s_etat_processus).erreur_execution = d_ex;
562:
563: if ((*s_etat_processus).affichage_arguments == 'Y')
564: {
565: printf("\n GREGV ");
566:
567: if ((*s_etat_processus).langue == 'F')
568: {
569: printf("(valeurs et vecteurs propres droits généralisés)\n\n");
570: }
571: else
572: {
573: printf("(generalized eigenvalues and right eigenvectors)\n\n");
574: }
575:
576: printf(" 2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
577: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
578: printf("-> 2: %s\n", d_MCX);
579: printf(" 1: %s\n", d_VCX);
580:
581: return;
582: }
583: else if ((*s_etat_processus).test_instruction == 'Y')
584: {
585: (*s_etat_processus).nombre_arguments = -1;
586: return;
587: }
588:
589: if (test_cfsf(s_etat_processus, 31) == d_vrai)
590: {
591: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
592: {
593: return;
594: }
595: }
596:
597: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
598: &s_objet_argument_1) == d_erreur)
599: {
600: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
601: return;
602: }
603:
604: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
605: &s_objet_argument_2) == d_erreur)
606: {
607: liberation(s_etat_processus, s_objet_argument_1);
608:
609: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
610: return;
611: }
612:
613: /*
614: --------------------------------------------------------------------------------
615: Les arguments sont des matrices carrées de mêmes dimensions
616: --------------------------------------------------------------------------------
617: */
618:
619: if ((((*s_objet_argument_1).type == MIN) ||
620: ((*s_objet_argument_1).type == MRL) ||
621: ((*s_objet_argument_1).type == MCX)) &&
622: (((*s_objet_argument_2).type == MIN) ||
623: ((*s_objet_argument_2).type == MRL) ||
624: ((*s_objet_argument_2).type == MCX)))
625: {
626: if (((*((struct_matrice *) (*s_objet_argument_1).objet)).nombre_lignes
627: != (*((struct_matrice *) (*s_objet_argument_1).objet))
628: .nombre_colonnes) || ((*((struct_matrice *)
629: (*s_objet_argument_2).objet)).nombre_lignes !=
630: (*((struct_matrice *) (*s_objet_argument_2).objet))
631: .nombre_colonnes) || ((*((struct_matrice *)
632: (*s_objet_argument_1).objet)).nombre_lignes !=
633: (*((struct_matrice *) (*s_objet_argument_2).objet))
634: .nombre_lignes))
635: {
636: liberation(s_etat_processus, s_objet_argument_1);
637: liberation(s_etat_processus, s_objet_argument_2);
638:
639: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
640: return;
641: }
642:
643: if ((s_objet_resultat_1 = allocation(s_etat_processus, VCX)) == NULL)
644: {
645: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
646: return;
647: }
648:
649: if ((s_objet_resultat_2 = allocation(s_etat_processus, MCX)) == NULL)
650: {
651: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
652: return;
653: }
654:
655: valeurs_propres_generalisees(s_etat_processus,
656: (struct_matrice *) (*s_objet_argument_2).objet,
657: (struct_matrice *) (*s_objet_argument_1).objet,
658: (struct_vecteur *) (*s_objet_resultat_1).objet,
659: NULL,
660: (struct_matrice *) (*s_objet_resultat_2).objet);
661:
662: if ((*s_etat_processus).erreur_systeme != d_es)
663: {
664: return;
665: }
666:
667: if (((*s_etat_processus).exception != d_ep) ||
668: ((*s_etat_processus).erreur_execution != d_ex))
669: {
670: /*
671: * Problème dans la diagonalisation
672: */
673:
674: liberation(s_etat_processus, s_objet_argument_1);
675: liberation(s_etat_processus, s_objet_argument_2);
676: liberation(s_etat_processus, s_objet_resultat_1);
677: liberation(s_etat_processus, s_objet_resultat_2);
678:
679: return;
680: }
681: }
682:
683: /*
684: --------------------------------------------------------------------------------
685: Type incompatible
686: --------------------------------------------------------------------------------
687: */
688:
689: else
690: {
691: liberation(s_etat_processus, s_objet_argument_1);
692: liberation(s_etat_processus, s_objet_argument_2);
693:
694: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
695: return;
696: }
697:
698: liberation(s_etat_processus, s_objet_argument_1);
699: liberation(s_etat_processus, s_objet_argument_2);
700:
701: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
702: s_objet_resultat_2) == d_erreur)
703: {
704: return;
705: }
706:
707: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
708: s_objet_resultat_1) == d_erreur)
709: {
710: return;
711: }
712:
713: return;
714: }
715:
716: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_g3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src