Package: freecad / 0.14.3702+dfsg-3

fix_armel_FTBFS.patch Patch series | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
Description: fix compilation on Armel due to coincident variables in 
 sys/ucontext.h (R2, R3, R4). Thanks to Paul Brook <paul@codesourcery.com>
 http://lists.alioth.debian.org/pipermail/debian-science-maintainers/2011-October/009876.html
Author: Anton Gladky <gladky.anton@gmail.com>
Last-Update: 2011-10-27

Index: freecad/src/3rdParty/salomesmesh/inc/Rn.h
===================================================================
--- freecad.orig/src/3rdParty/salomesmesh/inc/Rn.h
+++ freecad/src/3rdParty/salomesmesh/inc/Rn.h
@@ -33,7 +33,7 @@
 #include <gp_Dir.hxx>      //Dans OpenCascade
 
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// BUT:   Definir les espaces affines R R2 R3 R4 soit Rn pour n=1,2,3,4
+// BUT:   Definir les espaces affines R R_2 R_3 R_4 soit Rn pour n=1,2,3,4
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // AUTEUR : Frederic HECHT      ANALYSE NUMERIQUE UPMC  PARIS   OCTOBRE   2000
 // MODIFS : Alain    PERRONNET  ANALYSE NUMERIQUE UPMC  PARIS   NOVEMBRE  2000
@@ -84,155 +84,155 @@ typedef double R;
 //==============
 //typedef struct { short int x,y } XPoint;  //en fait ce type est defini dans X11-Window
                                             // #include <X11/Xlib.h>
-//la classe R2
+//la classe R_2
 //============
-class R2 
+class R_2 
 {
-  friend std::ostream& operator << (std::ostream& f, const R2 & P)
+  friend std::ostream& operator << (std::ostream& f, const R_2 & P)
   { f << P.x << ' ' << P.y ; return f; }
-  friend std::istream& operator >> (std::istream& f, R2 & P)
+  friend std::istream& operator >> (std::istream& f, R_2 & P)
   { f >> P.x >> P.y ; return f; }
 
-  friend std::ostream& operator << (std::ostream& f, const R2 * P)
+  friend std::ostream& operator << (std::ostream& f, const R_2 * P)
   { f << P->x << ' ' << P->y ; return f; }
-  friend std::istream& operator >> (std::istream& f, R2 * P)
+  friend std::istream& operator >> (std::istream& f, R_2 * P)
   { f >> P->x >> P->y ; return f; }
 
 public:
   R x,y;  //les donnees
 
-  R2 () :x(0),y(0) {}              //les constructeurs
-  R2 (R a,R b)   :x(a),y(b)  {}
-  R2 (R2 A,R2 B) :x(B.x-A.x),y(B.y-A.y)  {} //vecteur defini par 2 points
-
-  R2  operator+(R2 P) const {return R2(x+P.x,y+P.y);}     // Q+P possible
-  R2  operator+=(R2 P)  {x += P.x;y += P.y; return *this;}// Q+=P;
-  R2  operator-(R2 P) const {return R2(x-P.x,y-P.y);}     // Q-P
-  R2  operator-=(R2 P) {x -= P.x;y -= P.y; return *this;} // Q-=P;
-  R2  operator-()const  {return R2(-x,-y);}               // -Q
-  R2  operator+()const  {return *this;}                   // +Q
-  R   operator,(R2 P)const {return x*P.x+y*P.y;} // produit scalaire (Q,P)
-  R   operator^(R2 P)const {return x*P.y-y*P.x;} // produit vectoriel Q^P
-  R2  operator*(R c)const {return R2(x*c,y*c);}  // produit a droite  P*c
-  R2  operator*=(R c)  {x *= c; y *= c; return *this;}
-  R2  operator/(R c)const {return R2(x/c,y/c);}  // division par un reel
-  R2  operator/=(R c)  {x /= c; y /= c; return *this;}
+  R_2 () :x(0),y(0) {}              //les constructeurs
+  R_2 (R a,R b)   :x(a),y(b)  {}
+  R_2 (R_2 A,R_2 B) :x(B.x-A.x),y(B.y-A.y)  {} //vecteur defini par 2 points
+
+  R_2  operator+(R_2 P) const {return R_2(x+P.x,y+P.y);}     // Q+P possible
+  R_2  operator+=(R_2 P)  {x += P.x;y += P.y; return *this;}// Q+=P;
+  R_2  operator-(R_2 P) const {return R_2(x-P.x,y-P.y);}     // Q-P
+  R_2  operator-=(R_2 P) {x -= P.x;y -= P.y; return *this;} // Q-=P;
+  R_2  operator-()const  {return R_2(-x,-y);}               // -Q
+  R_2  operator+()const  {return *this;}                   // +Q
+  R   operator,(R_2 P)const {return x*P.x+y*P.y;} // produit scalaire (Q,P)
+  R   operator^(R_2 P)const {return x*P.y-y*P.x;} // produit vectoriel Q^P
+  R_2  operator*(R c)const {return R_2(x*c,y*c);}  // produit a droite  P*c
+  R_2  operator*=(R c)  {x *= c; y *= c; return *this;}
+  R_2  operator/(R c)const {return R_2(x/c,y/c);}  // division par un reel
+  R_2  operator/=(R c)  {x /= c; y /= c; return *this;}
   R & operator[](int i) {return (&x)[i];}        // la coordonnee i
-  R2  orthogonal() {return R2(-y,x);}    //le vecteur orthogonal dans R2
-  friend R2 operator*(R c,R2 P) {return P*c;}    // produit a gauche c*P
+  R_2  orthogonal() {return R_2(-y,x);}    //le vecteur orthogonal dans R_2
+  friend R_2 operator*(R c,R_2 P) {return P*c;}    // produit a gauche c*P
 };
 
 
-//la classe R3
+//la classe R_3
 //============
-class R3
+class R_3
 {
-  friend std::ostream& operator << (std::ostream& f, const R3 & P)
+  friend std::ostream& operator << (std::ostream& f, const R_3 & P)
   { f << P.x << ' ' << P.y << ' ' << P.z ; return f; }
-  friend std::istream& operator >> (std::istream& f, R3 & P)
+  friend std::istream& operator >> (std::istream& f, R_3 & P)
   { f >> P.x >> P.y >> P.z ; return f; }
 
-  friend std::ostream& operator << (std::ostream& f, const R3 * P)
+  friend std::ostream& operator << (std::ostream& f, const R_3 * P)
   { f << P->x << ' ' << P->y << ' ' << P->z ; return f; }
-  friend std::istream& operator >> (std::istream& f, R3 * P)
+  friend std::istream& operator >> (std::istream& f, R_3 * P)
   { f >> P->x >> P->y >> P->z ; return f; }
 
 public:  
   R  x,y,z;  //les 3 coordonnees
  
-  R3 () :x(0),y(0),z(0) {}  //les constructeurs
-  R3 (R a,R b,R c):x(a),y(b),z(c)  {}                  //Point ou Vecteur (a,b,c)
-  R3 (R3 A,R3 B):x(B.x-A.x),y(B.y-A.y),z(B.z-A.z)  {}  //Vecteur AB
-
-  R3 (gp_Pnt P) : x(P.X()), y(P.Y()), z(P.Z()) {}      //Point     d'OpenCascade
-  R3 (gp_Vec V) : x(V.X()), y(V.Y()), z(V.Z()) {}      //Vecteur   d'OpenCascade
-  R3 (gp_Dir P) : x(P.X()), y(P.Y()), z(P.Z()) {}      //Direction d'OpenCascade
-
-  R3   operator+(R3 P)const  {return R3(x+P.x,y+P.y,z+P.z);}
-  R3   operator+=(R3 P)  {x += P.x; y += P.y; z += P.z; return *this;}
-  R3   operator-(R3 P)const  {return R3(x-P.x,y-P.y,z-P.z);}
-  R3   operator-=(R3 P)  {x -= P.x; y -= P.y; z -= P.z; return *this;}
-  R3   operator-()const  {return R3(-x,-y,-z);}
-  R3   operator+()const  {return *this;}
-  R    operator,(R3 P)const {return  x*P.x+y*P.y+z*P.z;} // produit scalaire
-  R3   operator^(R3 P)const {return R3(y*P.z-z*P.y ,P.x*z-x*P.z, x*P.y-y*P.x);} // produit vectoriel
-  R3   operator*(R c)const {return R3(x*c,y*c,z*c);}
-  R3   operator*=(R c)  {x *= c; y *= c; z *= c; return *this;}
-  R3   operator/(R c)const {return R3(x/c,y/c,z/c);}
-  R3   operator/=(R c)  {x /= c; y /= c; z /= c; return *this;}
+  R_3 () :x(0),y(0),z(0) {}  //les constructeurs
+  R_3 (R a,R b,R c):x(a),y(b),z(c)  {}                  //Point ou Vecteur (a,b,c)
+  R_3 (R_3 A,R_3 B):x(B.x-A.x),y(B.y-A.y),z(B.z-A.z)  {}  //Vecteur AB
+
+  R_3 (gp_Pnt P) : x(P.X()), y(P.Y()), z(P.Z()) {}      //Point     d'OpenCascade
+  R_3 (gp_Vec V) : x(V.X()), y(V.Y()), z(V.Z()) {}      //Vecteur   d'OpenCascade
+  R_3 (gp_Dir P) : x(P.X()), y(P.Y()), z(P.Z()) {}      //Direction d'OpenCascade
+
+  R_3   operator+(R_3 P)const  {return R_3(x+P.x,y+P.y,z+P.z);}
+  R_3   operator+=(R_3 P)  {x += P.x; y += P.y; z += P.z; return *this;}
+  R_3   operator-(R_3 P)const  {return R_3(x-P.x,y-P.y,z-P.z);}
+  R_3   operator-=(R_3 P)  {x -= P.x; y -= P.y; z -= P.z; return *this;}
+  R_3   operator-()const  {return R_3(-x,-y,-z);}
+  R_3   operator+()const  {return *this;}
+  R    operator,(R_3 P)const {return  x*P.x+y*P.y+z*P.z;} // produit scalaire
+  R_3   operator^(R_3 P)const {return R_3(y*P.z-z*P.y ,P.x*z-x*P.z, x*P.y-y*P.x);} // produit vectoriel
+  R_3   operator*(R c)const {return R_3(x*c,y*c,z*c);}
+  R_3   operator*=(R c)  {x *= c; y *= c; z *= c; return *this;}
+  R_3   operator/(R c)const {return R_3(x/c,y/c,z/c);}
+  R_3   operator/=(R c)  {x /= c; y /= c; z /= c; return *this;}
   R  & operator[](int i) {return (&x)[i];}
-  friend R3 operator*(R c,R3 P) {return P*c;}
+  friend R_3 operator*(R c,R_3 P) {return P*c;}
 
-  R3   operator=(gp_Pnt P) {return R3(P.X(),P.Y(),P.Z());}
-  R3   operator=(gp_Dir P) {return R3(P.X(),P.Y(),P.Z());}
+  R_3   operator=(gp_Pnt P) {return R_3(P.X(),P.Y(),P.Z());}
+  R_3   operator=(gp_Dir P) {return R_3(P.X(),P.Y(),P.Z());}
 
-  friend gp_Pnt gp_pnt(R3 xyz) { return gp_Pnt(xyz.x,xyz.y,xyz.z); }
+  friend gp_Pnt gp_pnt(R_3 xyz) { return gp_Pnt(xyz.x,xyz.y,xyz.z); }
   //friend gp_Pnt operator=() { return gp_Pnt(x,y,z); }
-  friend gp_Dir gp_dir(R3 xyz) { return gp_Dir(xyz.x,xyz.y,xyz.z); }
+  friend gp_Dir gp_dir(R_3 xyz) { return gp_Dir(xyz.x,xyz.y,xyz.z); }
 
-  bool  DansPave( R3 & xyzMin, R3 & xyzMax )
+  bool  DansPave( R_3 & xyzMin, R_3 & xyzMax )
     { return xyzMin.x<=x && x<=xyzMax.x &&
      	     xyzMin.y<=y && y<=xyzMax.y &&
 	     xyzMin.z<=z && z<=xyzMax.z; }
 };
 
-//la classe R4
+//la classe R_4
 //============
-class R4: public R3
+class R_4: public R_3
 {
-  friend std::ostream& operator <<(std::ostream& f, const R4 & P )
+  friend std::ostream& operator <<(std::ostream& f, const R_4 & P )
   { f << P.x << ' ' << P.y << ' ' << P.z << ' ' << P.omega; return f; }
-  friend istream& operator >>(istream& f,  R4 & P)
+  friend istream& operator >>(istream& f,  R_4 & P)
   { f >> P.x >>  P.y >>  P.z >> P.omega ; return f; }
 
-  friend std::ostream& operator <<(std::ostream& f, const R4 * P )
+  friend std::ostream& operator <<(std::ostream& f, const R_4 * P )
   { f << P->x << ' ' << P->y << ' ' << P->z << ' ' << P->omega; return f; }
-  friend istream& operator >>(istream& f,  R4 * P)
+  friend istream& operator >>(istream& f,  R_4 * P)
   { f >> P->x >>  P->y >>  P->z >> P->omega ; return f; }
 
 public:  
   R  omega;  //la donnee du poids supplementaire
  
-  R4 () :omega(1.0) {}  //les constructeurs
-  R4 (R a,R b,R c,R d):R3(a,b,c),omega(d) {}
-  R4 (R4 A,R4 B) :R3(B.x-A.x,B.y-A.y,B.z-A.z),omega(B.omega-A.omega) {}
-
-  R4   operator+(R4 P)const  {return R4(x+P.x,y+P.y,z+P.z,omega+P.omega);}
-  R4   operator+=(R4 P)  {x += P.x;y += P.y;z += P.z;omega += P.omega;return *this;}
-  R4   operator-(R4 P)const  {return R4(x-P.x,y-P.y,z-P.z,omega-P.omega);}
-  R4   operator-=(R4 P) {x -= P.x;y -= P.y;z -= P.z;omega -= P.omega;return *this;}
-  R4   operator-()const  {return R4(-x,-y,-z,-omega);}
-  R4   operator+()const  {return *this;}
-  R    operator,(R4 P)const {return  x*P.x+y*P.y+z*P.z+omega*P.omega;} // produit scalaire
-  R4   operator*(R c)const {return R4(x*c,y*c,z*c,omega*c);}
-  R4   operator*=(R c)  {x *= c; y *= c; z *= c; omega *= c; return *this;}
-  R4   operator/(R c)const {return R4(x/c,y/c,z/c,omega/c);}
-  R4   operator/=(R c)  {x /= c; y /= c; z /= c; omega /= c; return *this;}
+  R_4 () :omega(1.0) {}  //les constructeurs
+  R_4 (R a,R b,R c,R d):R_3(a,b,c),omega(d) {}
+  R_4 (R_4 A,R_4 B) :R_3(B.x-A.x,B.y-A.y,B.z-A.z),omega(B.omega-A.omega) {}
+
+  R_4   operator+(R_4 P)const  {return R_4(x+P.x,y+P.y,z+P.z,omega+P.omega);}
+  R_4   operator+=(R_4 P)  {x += P.x;y += P.y;z += P.z;omega += P.omega;return *this;}
+  R_4   operator-(R_4 P)const  {return R_4(x-P.x,y-P.y,z-P.z,omega-P.omega);}
+  R_4   operator-=(R_4 P) {x -= P.x;y -= P.y;z -= P.z;omega -= P.omega;return *this;}
+  R_4   operator-()const  {return R_4(-x,-y,-z,-omega);}
+  R_4   operator+()const  {return *this;}
+  R    operator,(R_4 P)const {return  x*P.x+y*P.y+z*P.z+omega*P.omega;} // produit scalaire
+  R_4   operator*(R c)const {return R_4(x*c,y*c,z*c,omega*c);}
+  R_4   operator*=(R c)  {x *= c; y *= c; z *= c; omega *= c; return *this;}
+  R_4   operator/(R c)const {return R_4(x/c,y/c,z/c,omega/c);}
+  R_4   operator/=(R c)  {x /= c; y /= c; z /= c; omega /= c; return *this;}
   R  & operator[](int i) {return (&x)[i];}
-  friend R4 operator*(R c,R4 P) {return P*c;}
+  friend R_4 operator*(R c,R_4 P) {return P*c;}
 };
 
 //quelques fonctions supplementaires sur ces classes
 //==================================================
-inline R Aire2d(const R2 A,const R2 B,const R2 C){return (B-A)^(C-A);} 
-inline R Angle2d(R2 P){ return atan2(P.y,P.x);}
+inline R Aire2d(const R_2 A,const R_2 B,const R_2 C){return (B-A)^(C-A);} 
+inline R Angle2d(R_2 P){ return atan2(P.y,P.x);}
 
-inline R Norme2_2(const R2 & A){ return (A,A);}
-inline R Norme2(const R2 & A){ return sqrt((A,A));}
-inline R NormeInfinie(const R2 & A){return Max(Abs(A.x),Abs(A.y));}
-
-inline R Norme2_2(const R3 & A){ return (A,A);}
-inline R Norme2(const R3 & A){ return sqrt((A,A));}
-inline R NormeInfinie(const R3 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z));}
-
-inline R Norme2_2(const R4 & A){ return (A,A);}
-inline R Norme2(const R4 & A){ return sqrt((A,A));}
-inline R NormeInfinie(const R4 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z),Abs(A.omega));}
-
-inline R2 XY(R3 P) {return R2(P.x, P.y);}  //restriction a R2 d'un R3 par perte de z
-inline R3 Min(R3 P, R3 Q) 
-{return R3(P.x<Q.x ? P.x : Q.x, P.y<Q.y ? P.y : Q.y, P.z<Q.z ? P.z : Q.z);} //Pt de xyz Min
-inline R3 Max(R3 P, R3 Q) 
-{return R3(P.x>Q.x ? P.x : Q.x, P.y>Q.y ? P.y : Q.y, P.z>Q.z ? P.z : Q.z);} //Pt de xyz Max
+inline R Norme2_2(const R_2 & A){ return (A,A);}
+inline R Norme2(const R_2 & A){ return sqrt((A,A));}
+inline R NormeInfinie(const R_2 & A){return Max(Abs(A.x),Abs(A.y));}
+
+inline R Norme2_2(const R_3 & A){ return (A,A);}
+inline R Norme2(const R_3 & A){ return sqrt((A,A));}
+inline R NormeInfinie(const R_3 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z));}
+
+inline R Norme2_2(const R_4 & A){ return (A,A);}
+inline R Norme2(const R_4 & A){ return sqrt((A,A));}
+inline R NormeInfinie(const R_4 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z),Abs(A.omega));}
+
+inline R_2 XY(R_3 P) {return R_2(P.x, P.y);}  //restriction a R_2 d'un R_3 par perte de z
+inline R_3 Min(R_3 P, R_3 Q) 
+{return R_3(P.x<Q.x ? P.x : Q.x, P.y<Q.y ? P.y : Q.y, P.z<Q.z ? P.z : Q.z);} //Pt de xyz Min
+inline R_3 Max(R_3 P, R_3 Q) 
+{return R_3(P.x>Q.x ? P.x : Q.x, P.y>Q.y ? P.y : Q.y, P.z>Q.z ? P.z : Q.z);} //Pt de xyz Max
 
 #endif
Index: freecad/src/3rdParty/salomesmesh/inc/StdMeshers_MEFISTO_2D.hxx
===================================================================
--- freecad.orig/src/3rdParty/salomesmesh/inc/StdMeshers_MEFISTO_2D.hxx
+++ freecad/src/3rdParty/salomesmesh/inc/StdMeshers_MEFISTO_2D.hxx
@@ -61,7 +61,7 @@ public:
   typedef std::vector< StdMeshers_FaceSidePtr > TWireVector;
 
   bool LoadPoints(TWireVector &                       wires,
-		  R2*                                 uvslf, 
+		  R_2*                                 uvslf, 
 		  std::vector< const SMDS_MeshNode*>& mefistoToDS,
                   double scalex, double               scaley);
 
@@ -70,7 +70,7 @@ public:
 			  double& scalex,
 			  double& scaley);
 
-  void StoreResult (Z nbst, R2* uvst, Z nbt, Z* nust, 
+  void StoreResult (Z nbst, R_2* uvst, Z nbt, Z* nust, 
 		    std::vector< const SMDS_MeshNode*>& mefistoToDS,
                     double scalex, double scaley);
 					  
Index: freecad/src/3rdParty/salomesmesh/inc/aptrte.h
===================================================================
--- freecad.orig/src/3rdParty/salomesmesh/inc/aptrte.h
+++ freecad/src/3rdParty/salomesmesh/inc/aptrte.h
@@ -60,9 +60,9 @@
 
 MEFISTO2D_EXPORT
   void  aptrte( Z nutysu, R aretmx,
-	      Z nblf,   Z *nudslf, R2 *uvslf,
-	      Z nbpti,  R2 *uvpti,
-	      Z & nbst, R2 * & uvst, Z & nbt, Z * & nust,
+	      Z nblf,   Z *nudslf, R_2 *uvslf,
+	      Z nbpti,  R_2 *uvpti,
+	      Z & nbst, R_2 * & uvst, Z & nbt, Z * & nust,
 	      Z & ierr );
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // but : appel de la triangulation par un arbre-4 recouvrant
@@ -124,7 +124,7 @@ MEFISTO2D_EXPORT
   #define tesuex   TESUEX
   #define teamqt   TEAMQT
   #define nusotr   NUSOTR
-  #define qutr2d   QUTR2D
+  #define qutr2d   QUTR_2D
   #define surtd2   SURTD2
   #define qualitetrte	QUALITETRTE
   
@@ -159,7 +159,7 @@ MEFISTO2D_EXPORT
 
 #endif
 
-extern "C" { MEFISTO2D_EXPORT void MEFISTO2D_STDCALL qualitetrte( R3 *mnpxyd,
+extern "C" { MEFISTO2D_EXPORT void MEFISTO2D_STDCALL qualitetrte( R_3 *mnpxyd,
 		   Z & mosoar, Z & mxsoar, Z *mnsoar,
 	  	   Z & moartr, Z & mxartr, Z *mnartr,
 		   Z & nbtria, R & quamoy, R & quamin ); }
@@ -258,20 +258,20 @@ extern "C" {void MEFISTO2D_STDCALL fasoa
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 //initialisation du tableau letree et ajout dans letree des sommets 1 a nbsomm
-extern "C" {void MEFISTO2D_STDCALL teajte( Z & mxsomm, Z &  nbsomm, R3 * mnpxyd,  R3 * comxmi,
+extern "C" {void MEFISTO2D_STDCALL teajte( Z & mxsomm, Z &  nbsomm, R_3 * mnpxyd,  R_3 * comxmi,
 			    R & aretmx,  Z & mxtree, Z * letree,
 			    Z & ierr );
 }
 
-extern "C" {void MEFISTO2D_STDCALL tehote( Z & nutysu, Z & nbarpi, Z &  mxsomm, Z &  nbsomm, R3 * mnpxyd,
-			    R3 * comxmi, R & aretmx,
+extern "C" {void MEFISTO2D_STDCALL tehote( Z & nutysu, Z & nbarpi, Z &  mxsomm, Z &  nbsomm, R_3 * mnpxyd,
+			    R_3 * comxmi, R & aretmx,
 			    Z * letree, Z & mxqueu, Z * mnqueu,
 			    Z & ierr );
 }
 // homogeneisation de l'arbre des te a un saut de taille au plus
 // prise en compte des tailles d'aretes souhaitees autour des sommets initiaux
 
-extern "C" {void MEFISTO2D_STDCALL tetrte( R3 * comxmi, R & aretmx, Z & nbarpi, Z & mxsomm, R3 * mnpxyd,
+extern "C" {void MEFISTO2D_STDCALL tetrte( R_3 * comxmi, R & aretmx, Z & nbarpi, Z & mxsomm, R_3 * mnpxyd,
 			    Z & mxqueu,  Z * mnqueu,  Z * mntree,
 			    Z & mosoar,  Z & mxsoar,  Z & n1soar, Z * mnsoar,
 			    Z & moartr, Z &  mxartr,  Z & n1artr,  Z * mnartr,  Z * mnarst,
@@ -283,14 +283,14 @@ extern "C" {void MEFISTO2D_STDCALL tetrt
 extern "C" { void MEFISTO2D_STDCALL aisoar( Z & mosoar, Z & mxsoar, Z * mnsoar, Z & na ); }
 // formation du chainage 6 des aretes internes a echanger eventuellement
 
-extern "C" { void MEFISTO2D_STDCALL  tedela( R3 * mnpxyd, Z * mnarst,
+extern "C" { void MEFISTO2D_STDCALL  tedela( R_3 * mnpxyd, Z * mnarst,
 			    Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar, Z & na,
 			    Z & moartr, Z & mxartr, Z & n1artr, Z * mnartr, Z & n );
 }
 // boucle sur les aretes internes (non sur une ligne de la frontiere)
 // avec echange des 2 diagonales afin de rendre la triangulation delaunay
  
-extern "C" { void MEFISTO2D_STDCALL terefr( Z & nbarpi, R3 * mnpxyd,
+extern "C" { void MEFISTO2D_STDCALL terefr( Z & nbarpi, R_3 * mnpxyd,
 			    Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar,
 			    Z & moartr, Z & mxartr, Z & n1artr, Z * mnartr, Z * mnarst,
 			    Z & mxarcf, Z * mnarc1, Z * mnarc2,
@@ -301,7 +301,7 @@ extern "C" { void MEFISTO2D_STDCALL tere
 // triangulation frontale pour les restaurer
 
 extern "C" { void MEFISTO2D_STDCALL tesuex( Z & nblf, Z * nulftr,
-			    Z & ndtri0, Z & nbsomm, R3 * mnpxyd, Z * mnslig,
+			    Z & ndtri0, Z & nbsomm, R_3 * mnpxyd, Z * mnslig,
 			    Z & mosoar, Z & mxsoar, Z * mnsoar,
 			    Z & moartr, Z & mxartr, Z & n1artr, Z * mnartr, Z * mnarst,
 			    Z & nbtria, Z * mntrsu, Z & ierr );
@@ -314,7 +314,7 @@ extern "C" { void MEFISTO2D_STDCALL team
 			    Z & mxarcf, Z * mntrcf, Z * mnstbo,
 			    Z * n1arcf, Z * mnarcf, Z * mnarc1,
 			    Z & nbarpi, Z & nbsomm, Z & mxsomm,
-			    R3 * mnpxyd, Z * mnslig,
+			    R_3 * mnpxyd, Z * mnslig,
 			    Z & ierr );
 }
 // amelioration de la qualite de la triangulation par
@@ -327,10 +327,10 @@ extern "C" { void MEFISTO2D_STDCALL nuso
 }
 //retrouver les numero des 3 sommets du triangle nt
 
-extern "C" { void MEFISTO2D_STDCALL qutr2d( R3 & p1, R3 & p2, R3 & p3, R & qualite ); }
-//calculer la qualite d'un triangle de R2 de sommets p1, p2, p3
+extern "C" { void MEFISTO2D_STDCALL qutr2d( R_3 & p1, R_3 & p2, R_3 & p3, R & qualite ); }
+//calculer la qualite d'un triangle de R_2 de sommets p1, p2, p3
 
-extern "C" { R MEFISTO2D_STDCALL surtd2( R3 & p1, R3 & p2, R3 & p3 ); }
+extern "C" { R MEFISTO2D_STDCALL surtd2( R_3 & p1, R_3 & p2, R_3 & p3 ); }
 //calcul de la surface d'un triangle defini par 3 points de r**2
 
 #endif
Index: freecad/src/3rdParty/salomesmesh/src/MEFISTO2/aptrte.cpp
===================================================================
--- freecad.orig/src/3rdParty/salomesmesh/src/MEFISTO2/aptrte.cpp
+++ freecad/src/3rdParty/salomesmesh/src/MEFISTO2/aptrte.cpp
@@ -68,9 +68,9 @@ void MEFISTO2D_STDCALL deltacpu_( R & dt
 
 
 void  aptrte( Z   nutysu, R      aretmx,
-	      Z   nblf,   Z  *   nudslf,  R2 * uvslf,
-	      Z   nbpti,  R2 *   uvpti,
-	      Z & nbst,   R2 * & uvst,
+	      Z   nblf,   Z  *   nudslf,  R_2 * uvslf,
+	      Z   nbpti,  R_2 *   uvpti,
+	      Z & nbst,   R_2 * & uvst,
 	      Z & nbt,    Z  * & nust,
 	      Z & ierr )
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -122,11 +122,11 @@ void  aptrte( Z   nutysu, R      aretmx,
                  //no st1, st2, st3, 0 (non quadrangle)
 
   R  d, tcpu=0;
-  R3 direction=R3(0,0,0);  //direction pour areteideale() inactive ici!
+  R_3 direction=R_3(0,0,0);  //direction pour areteideale() inactive ici!
   Z  nbarfr=nudslf[nblf];  //nombre total d'aretes des lignes fermees
   Z  mxtrou = Max( 1024, nblf );  //nombre maximal de trous dans la surface
 
-  R3 *mnpxyd=NULL;
+  R_3 *mnpxyd=NULL;
   Z  *mnsoar=NULL, mosoar=7, mxsoar, n1soar; //le hachage des aretes
   Z  *mnartr=NULL, moartr=3, mxartr, n1artr; //le no des 3 aretes des triangles
   Z  *mntree=NULL, motree=9, mxtree; //L'arbre 4 de TE et nombre d'entiers par TE
@@ -141,7 +141,7 @@ void  aptrte( Z   nutysu, R      aretmx,
   Z  *mnarst=NULL;
   Z  *mnlftr=NULL;
 
-  R3 comxmi[2];            //coordonnees UV Min et Maximales
+  R_3 comxmi[2];            //coordonnees UV Min et Maximales
   R  aremin, aremax;       //longueur minimale et maximale des aretes
   R  airemx;               //aire maximale souhaitee d'un triangle
   R  quamoy, quamin;
@@ -171,7 +171,7 @@ void  aptrte( Z   nutysu, R      aretmx,
  NEWDEPART:
   //mnpxyd( 3, mxsomm ) les coordonnees UV des sommets et la taille d'arete aux sommets
   if( mnpxyd!=NULL ) delete [] mnpxyd;
-  mnpxyd = new R3[mxsomm];
+  mnpxyd = new R_3[mxsomm];
   if( mnpxyd==NULL ) goto ERREUR;
 
   // le tableau mnsoar des aretes des triangles
@@ -633,7 +633,7 @@ void  aptrte( Z   nutysu, R      aretmx,
   // generation du tableau uvst de la surface triangulee
   // ---------------------------------------------------
   if( uvst != NULL ) delete [] uvst;
-  uvst = new R2[nbst];
+  uvst = new R_2[nbst];
   if( uvst == NULL ) goto ERREUR;
 
   nbst=-1;
@@ -733,7 +733,7 @@ void  aptrte( Z   nutysu, R      aretmx,
   }
 }
 
-void MEFISTO2D_STDCALL qualitetrte( R3 *mnpxyd,
+void MEFISTO2D_STDCALL qualitetrte( R_3 *mnpxyd,
 		   Z & mosoar, Z & mxsoar, Z *mnsoar,
 		   Z & moartr, Z & mxartr, Z *mnartr,
 		   Z & nbtria, R & quamoy, R & quamin )
Index: freecad/src/3rdParty/salomesmesh/src/StdMeshers/StdMeshers_MEFISTO_2D.cpp
===================================================================
--- freecad.orig/src/3rdParty/salomesmesh/src/StdMeshers/StdMeshers_MEFISTO_2D.cpp
+++ freecad/src/3rdParty/salomesmesh/src/StdMeshers/StdMeshers_MEFISTO_2D.cpp
@@ -218,12 +218,12 @@ bool StdMeshers_MEFISTO_2D::Compute(SMES
 
   Z nblf;                 //nombre de lignes fermees (enveloppe en tete)
   Z *nudslf = NULL;       //numero du dernier sommet de chaque ligne fermee
-  R2 *uvslf = NULL;       
+  R_2 *uvslf = NULL;       
   Z nbpti = 0;            //nombre points internes futurs sommets de la triangulation
-  R2 *uvpti = NULL;
+  R_2 *uvpti = NULL;
   
   Z nbst;
-  R2 *uvst = NULL;
+  R_2 *uvst = NULL;
   Z nbt;
   Z *nust = NULL;
   Z ierr = 0;
@@ -246,7 +246,7 @@ bool StdMeshers_MEFISTO_2D::Compute(SMES
     nudslf[iw++] = nbpnt;
   }
 
-  uvslf = new R2[nudslf[nblf]];
+  uvslf = new R_2[nudslf[nblf]];
 
   double scalex, scaley;
   ComputeScaleOnFace(aMesh, F, scalex, scaley);
@@ -288,7 +288,7 @@ bool StdMeshers_MEFISTO_2D::Compute(SMES
 //purpose  : prevent failure due to overlapped adjacent links
 //=======================================================================
 
-static bool fixOverlappedLinkUV( R2& uv0, const R2& uv1, const R2& uv2 )
+static bool fixOverlappedLinkUV( R_2& uv0, const R_2& uv1, const R_2& uv2 )
 {
   gp_XY v1( uv0.x - uv1.x, uv0.y - uv1.y );
   gp_XY v2( uv2.x - uv1.x, uv2.y - uv1.y );
@@ -339,7 +339,7 @@ static bool fixOverlappedLinkUV( R2& uv0
 //purpose  : 
 //=======================================================================
 
-static bool fixCommonVertexUV (R2 &                 theUV,
+static bool fixCommonVertexUV (R_2 &                 theUV,
                                const TopoDS_Vertex& theV,
                                const TopoDS_Face&   theF,
                                const TopTools_IndexedDataMapOfShapeListOfShape & theVWMap,
@@ -438,7 +438,7 @@ static bool fixCommonVertexUV (R2 &
       nextUV  = uv;
     }
   }
-  R2 uv0, uv1, uv2;
+  R_2 uv0, uv1, uv2;
   uv0.x = thisUV.X();   uv0.y = thisUV.Y();
   uv1.x = nextUV.X();   uv1.y = nextUV.Y(); 
   uv2.x = thisUV.X();   uv2.y = thisUV.Y();
@@ -472,7 +472,7 @@ static bool fixCommonVertexUV (R2 &
 //=============================================================================
 
 bool StdMeshers_MEFISTO_2D::LoadPoints(TWireVector &                 wires,
-                                       R2 *                          uvslf,
+                                       R_2 *                          uvslf,
                                        vector<const SMDS_MeshNode*>& mefistoToDS,
                                        double                        scalex,
                                        double                        scaley)
@@ -647,7 +647,7 @@ void StdMeshers_MEFISTO_2D::ComputeScale
  */
 //=============================================================================
 
-void StdMeshers_MEFISTO_2D::StoreResult(Z nbst, R2 * uvst, Z nbt, Z * nust,
+void StdMeshers_MEFISTO_2D::StoreResult(Z nbst, R_2 * uvst, Z nbt, Z * nust,
                                         vector< const SMDS_MeshNode*>&mefistoToDS,
                                         double scalex, double scaley)
 {