OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [bits/] [valarray_before.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
// The template and inlines for the -*- C++ -*- internal _Meta class.
2
 
3
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4
// 2006, 2007, 2008, 2009, 2010  Free Software Foundation, Inc.
5
//
6
// This file is part of the GNU ISO C++ Library.  This library is free
7
// software; you can redistribute it and/or modify it under the
8
// terms of the GNU General Public License as published by the
9
// Free Software Foundation; either version 3, or (at your option)
10
// any later version.
11
 
12
// This library is distributed in the hope that it will be useful,
13
// but WITHOUT ANY WARRANTY; without even the implied warranty of
14
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
// GNU General Public License for more details.
16
 
17
// Under Section 7 of GPL version 3, you are granted additional
18
// permissions described in the GCC Runtime Library Exception, version
19
// 3.1, as published by the Free Software Foundation.
20
 
21
// You should have received a copy of the GNU General Public License and
22
// a copy of the GCC Runtime Library Exception along with this program;
23
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
24
// <http://www.gnu.org/licenses/>.
25
 
26
/** @file bits/valarray_before.h
27
 *  This is an internal header file, included by other library headers.
28
 *  Do not attempt to use it directly. @headername{valarray}
29
 */
30
 
31
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@cmla.ens-cachan.fr>
32
 
33
#ifndef _VALARRAY_BEFORE_H
34
#define _VALARRAY_BEFORE_H 1
35
 
36
#pragma GCC system_header
37
 
38
#include <bits/slice_array.h>
39
 
40
namespace std _GLIBCXX_VISIBILITY(default)
41
{
42
_GLIBCXX_BEGIN_NAMESPACE_VERSION
43
 
44
  //
45
  // Implementing a loosened valarray return value is tricky.
46
  // First we need to meet 26.3.1/3: we should not add more than
47
  // two levels of template nesting. Therefore we resort to template
48
  // template to "flatten" loosened return value types.
49
  // At some point we use partial specialization to remove one level
50
  // template nesting due to _Expr<>
51
  //
52
 
53
  // This class is NOT defined. It doesn't need to.
54
  template<typename _Tp1, typename _Tp2> class _Constant;
55
 
56
  // Implementations of unary functions applied to valarray<>s.
57
  // I use hard-coded object functions here instead of a generic
58
  // approach like pointers to function:
59
  //    1) correctness: some functions take references, others values.
60
  //       we can't deduce the correct type afterwards.
61
  //    2) efficiency -- object functions can be easily inlined
62
  //    3) be Koenig-lookup-friendly
63
 
64
  struct _Abs
65
  {
66
    template<typename _Tp>
67
      _Tp operator()(const _Tp& __t) const
68
      { return abs(__t); }
69
  };
70
 
71
  struct _Cos
72
  {
73
    template<typename _Tp>
74
      _Tp operator()(const _Tp& __t) const
75
      { return cos(__t); }
76
  };
77
 
78
  struct _Acos
79
  {
80
    template<typename _Tp>
81
      _Tp operator()(const _Tp& __t) const
82
      { return acos(__t); }
83
  };
84
 
85
  struct _Cosh
86
  {
87
    template<typename _Tp>
88
      _Tp operator()(const _Tp& __t) const
89
      { return cosh(__t); }
90
  };
91
 
92
  struct _Sin
93
  {
94
    template<typename _Tp>
95
      _Tp operator()(const _Tp& __t) const
96
      { return sin(__t); }
97
  };
98
 
99
  struct _Asin
100
  {
101
    template<typename _Tp>
102
      _Tp operator()(const _Tp& __t) const
103
      { return asin(__t); }
104
  };
105
 
106
  struct _Sinh
107
  {
108
    template<typename _Tp>
109
      _Tp operator()(const _Tp& __t) const
110
      { return sinh(__t); }
111
  };
112
 
113
  struct _Tan
114
  {
115
    template<typename _Tp>
116
      _Tp operator()(const _Tp& __t) const
117
      { return tan(__t); }
118
  };
119
 
120
  struct _Atan
121
  {
122
    template<typename _Tp>
123
      _Tp operator()(const _Tp& __t) const
124
      { return atan(__t); }
125
  };
126
 
127
  struct _Tanh
128
  {
129
    template<typename _Tp>
130
      _Tp operator()(const _Tp& __t) const
131
      { return tanh(__t); }
132
  };
133
 
134
  struct _Exp
135
  {
136
    template<typename _Tp>
137
      _Tp operator()(const _Tp& __t) const
138
      { return exp(__t); }
139
  };
140
 
141
  struct _Log
142
  {
143
    template<typename _Tp>
144
      _Tp operator()(const _Tp& __t) const
145
      { return log(__t); }
146
  };
147
 
148
  struct _Log10
149
  {
150
    template<typename _Tp>
151
      _Tp operator()(const _Tp& __t) const
152
      { return log10(__t); }
153
  };
154
 
155
  struct _Sqrt
156
  {
157
    template<typename _Tp>
158
      _Tp operator()(const _Tp& __t) const
159
      { return sqrt(__t); }
160
  };
161
 
162
  // In the past, we used to tailor operator applications semantics
163
  // to the specialization of standard function objects (i.e. plus<>, etc.)
164
  // That is incorrect.  Therefore we provide our own surrogates.
165
 
166
  struct __unary_plus
167
  {
168
    template<typename _Tp>
169
      _Tp operator()(const _Tp& __t) const
170
      { return +__t; }
171
  };
172
 
173
  struct __negate
174
  {
175
    template<typename _Tp>
176
      _Tp operator()(const _Tp& __t) const
177
      { return -__t; }
178
  };
179
 
180
  struct __bitwise_not
181
  {
182
    template<typename _Tp>
183
      _Tp operator()(const _Tp& __t) const
184
      { return ~__t; }
185
  };
186
 
187
  struct __plus
188
  {
189
    template<typename _Tp>
190
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
191
      { return __x + __y; }
192
  };
193
 
194
  struct __minus
195
  {
196
    template<typename _Tp>
197
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
198
      { return __x - __y; }
199
  };
200
 
201
  struct __multiplies
202
  {
203
    template<typename _Tp>
204
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
205
      { return __x * __y; }
206
  };
207
 
208
  struct __divides
209
  {
210
    template<typename _Tp>
211
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
212
      { return __x / __y; }
213
  };
214
 
215
  struct __modulus
216
  {
217
    template<typename _Tp>
218
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
219
      { return __x % __y; }
220
  };
221
 
222
  struct __bitwise_xor
223
  {
224
    template<typename _Tp>
225
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
226
      { return __x ^ __y; }
227
  };
228
 
229
  struct __bitwise_and
230
  {
231
    template<typename _Tp>
232
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
233
      { return __x & __y; }
234
  };
235
 
236
  struct __bitwise_or
237
  {
238
    template<typename _Tp>
239
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
240
      { return __x | __y; }
241
  };
242
 
243
  struct __shift_left
244
  {
245
    template<typename _Tp>
246
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
247
      { return __x << __y; }
248
  };
249
 
250
  struct __shift_right
251
  {
252
    template<typename _Tp>
253
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
254
      { return __x >> __y; }
255
  };
256
 
257
  struct __logical_and
258
  {
259
    template<typename _Tp>
260
      bool operator()(const _Tp& __x, const _Tp& __y) const
261
      { return __x && __y; }
262
  };
263
 
264
  struct __logical_or
265
  {
266
    template<typename _Tp>
267
      bool operator()(const _Tp& __x, const _Tp& __y) const
268
      { return __x || __y; }
269
  };
270
 
271
  struct __logical_not
272
  {
273
    template<typename _Tp>
274
      bool operator()(const _Tp& __x) const
275
      { return !__x; }
276
  };
277
 
278
  struct __equal_to
279
  {
280
    template<typename _Tp>
281
      bool operator()(const _Tp& __x, const _Tp& __y) const
282
      { return __x == __y; }
283
  };
284
 
285
  struct __not_equal_to
286
  {
287
    template<typename _Tp>
288
      bool operator()(const _Tp& __x, const _Tp& __y) const
289
      { return __x != __y; }
290
  };
291
 
292
  struct __less
293
  {
294
    template<typename _Tp>
295
      bool operator()(const _Tp& __x, const _Tp& __y) const
296
      { return __x < __y; }
297
  };
298
 
299
  struct __greater
300
  {
301
    template<typename _Tp>
302
      bool operator()(const _Tp& __x, const _Tp& __y) const
303
      { return __x > __y; }
304
  };
305
 
306
  struct __less_equal
307
  {
308
    template<typename _Tp>
309
      bool operator()(const _Tp& __x, const _Tp& __y) const
310
      { return __x <= __y; }
311
  };
312
 
313
  struct __greater_equal
314
  {
315
    template<typename _Tp>
316
      bool operator()(const _Tp& __x, const _Tp& __y) const
317
      { return __x >= __y; }
318
  };
319
 
320
  // The few binary functions we miss.
321
  struct _Atan2
322
  {
323
    template<typename _Tp>
324
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
325
      { return atan2(__x, __y); }
326
  };
327
 
328
  struct _Pow
329
  {
330
    template<typename _Tp>
331
      _Tp operator()(const _Tp& __x, const _Tp& __y) const
332
      { return pow(__x, __y); }
333
  };
334
 
335
 
336
  // We need these bits in order to recover the return type of
337
  // some functions/operators now that we're no longer using
338
  // function templates.
339
  template<typename, typename _Tp>
340
    struct __fun
341
    {
342
      typedef _Tp result_type;
343
    };
344
 
345
  // several specializations for relational operators.
346
  template<typename _Tp>
347
    struct __fun<__logical_not, _Tp>
348
    {
349
      typedef bool result_type;
350
    };
351
 
352
  template<typename _Tp>
353
    struct __fun<__logical_and, _Tp>
354
    {
355
      typedef bool result_type;
356
    };
357
 
358
  template<typename _Tp>
359
    struct __fun<__logical_or, _Tp>
360
    {
361
      typedef bool result_type;
362
    };
363
 
364
  template<typename _Tp>
365
    struct __fun<__less, _Tp>
366
    {
367
      typedef bool result_type;
368
    };
369
 
370
  template<typename _Tp>
371
    struct __fun<__greater, _Tp>
372
    {
373
      typedef bool result_type;
374
    };
375
 
376
  template<typename _Tp>
377
    struct __fun<__less_equal, _Tp>
378
    {
379
      typedef bool result_type;
380
    };
381
 
382
  template<typename _Tp>
383
    struct __fun<__greater_equal, _Tp>
384
    {
385
      typedef bool result_type;
386
    };
387
 
388
  template<typename _Tp>
389
    struct __fun<__equal_to, _Tp>
390
    {
391
      typedef bool result_type;
392
    };
393
 
394
  template<typename _Tp>
395
    struct __fun<__not_equal_to, _Tp>
396
    {
397
      typedef bool result_type;
398
    };
399
 
400
  //
401
  // Apply function taking a value/const reference closure
402
  //
403
 
404
  template<typename _Dom, typename _Arg>
405
    class _FunBase
406
    {
407
    public:
408
      typedef typename _Dom::value_type value_type;
409
 
410
      _FunBase(const _Dom& __e, value_type __f(_Arg))
411
      : _M_expr(__e), _M_func(__f) {}
412
 
413
      value_type operator[](size_t __i) const
414
      { return _M_func (_M_expr[__i]); }
415
 
416
      size_t size() const { return _M_expr.size ();}
417
 
418
    private:
419
      const _Dom& _M_expr;
420
      value_type (*_M_func)(_Arg);
421
    };
422
 
423
  template<class _Dom>
424
    struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type>
425
    {
426
      typedef _FunBase<_Dom, typename _Dom::value_type> _Base;
427
      typedef typename _Base::value_type value_type;
428
      typedef value_type _Tp;
429
 
430
      _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {}
431
    };
432
 
433
  template<typename _Tp>
434
    struct _ValFunClos<_ValArray,_Tp> : _FunBase<valarray<_Tp>, _Tp>
435
    {
436
      typedef _FunBase<valarray<_Tp>, _Tp> _Base;
437
      typedef _Tp value_type;
438
 
439
      _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {}
440
    };
441
 
442
  template<class _Dom>
443
    struct _RefFunClos<_Expr, _Dom>
444
    : _FunBase<_Dom, const typename _Dom::value_type&>
445
    {
446
      typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base;
447
      typedef typename _Base::value_type value_type;
448
      typedef value_type _Tp;
449
 
450
      _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&))
451
      : _Base(__e, __f) {}
452
    };
453
 
454
  template<typename _Tp>
455
    struct _RefFunClos<_ValArray, _Tp>
456
    : _FunBase<valarray<_Tp>, const _Tp&>
457
    {
458
      typedef _FunBase<valarray<_Tp>, const _Tp&> _Base;
459
      typedef _Tp value_type;
460
 
461
      _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&))
462
      : _Base(__v, __f) {}
463
    };
464
 
465
  //
466
  // Unary expression closure.
467
  //
468
 
469
  template<class _Oper, class _Arg>
470
    class _UnBase
471
    {
472
    public:
473
      typedef typename _Arg::value_type _Vt;
474
      typedef typename __fun<_Oper, _Vt>::result_type value_type;
475
 
476
      _UnBase(const _Arg& __e) : _M_expr(__e) {}
477
 
478
      value_type operator[](size_t __i) const
479
      { return _Oper()(_M_expr[__i]); }
480
 
481
      size_t size() const { return _M_expr.size(); }
482
 
483
    private:
484
      const _Arg& _M_expr;
485
    };
486
 
487
  template<class _Oper, class _Dom>
488
    struct _UnClos<_Oper, _Expr, _Dom>
489
    : _UnBase<_Oper, _Dom>
490
    {
491
      typedef _Dom _Arg;
492
      typedef _UnBase<_Oper, _Dom> _Base;
493
      typedef typename _Base::value_type value_type;
494
 
495
      _UnClos(const _Arg& __e) : _Base(__e) {}
496
    };
497
 
498
  template<class _Oper, typename _Tp>
499
    struct _UnClos<_Oper, _ValArray, _Tp>
500
    : _UnBase<_Oper, valarray<_Tp> >
501
    {
502
      typedef valarray<_Tp> _Arg;
503
      typedef _UnBase<_Oper, valarray<_Tp> > _Base;
504
      typedef typename _Base::value_type value_type;
505
 
506
      _UnClos(const _Arg& __e) : _Base(__e) {}
507
    };
508
 
509
 
510
  //
511
  // Binary expression closure.
512
  //
513
 
514
  template<class _Oper, class _FirstArg, class _SecondArg>
515
    class _BinBase
516
    {
517
    public:
518
      typedef typename _FirstArg::value_type _Vt;
519
      typedef typename __fun<_Oper, _Vt>::result_type value_type;
520
 
521
      _BinBase(const _FirstArg& __e1, const _SecondArg& __e2)
522
      : _M_expr1(__e1), _M_expr2(__e2) {}
523
 
524
      value_type operator[](size_t __i) const
525
      { return _Oper()(_M_expr1[__i], _M_expr2[__i]); }
526
 
527
      size_t size() const { return _M_expr1.size(); }
528
 
529
    private:
530
      const _FirstArg& _M_expr1;
531
      const _SecondArg& _M_expr2;
532
    };
533
 
534
 
535
  template<class _Oper, class _Clos>
536
    class _BinBase2
537
    {
538
    public:
539
      typedef typename _Clos::value_type _Vt;
540
      typedef typename __fun<_Oper, _Vt>::result_type value_type;
541
 
542
      _BinBase2(const _Clos& __e, const _Vt& __t)
543
      : _M_expr1(__e), _M_expr2(__t) {}
544
 
545
      value_type operator[](size_t __i) const
546
      { return _Oper()(_M_expr1[__i], _M_expr2); }
547
 
548
      size_t size() const { return _M_expr1.size(); }
549
 
550
    private:
551
      const _Clos& _M_expr1;
552
      const _Vt& _M_expr2;
553
    };
554
 
555
  template<class _Oper, class _Clos>
556
    class _BinBase1
557
    {
558
    public:
559
      typedef typename _Clos::value_type _Vt;
560
      typedef typename __fun<_Oper, _Vt>::result_type value_type;
561
 
562
      _BinBase1(const _Vt& __t, const _Clos& __e)
563
      : _M_expr1(__t), _M_expr2(__e) {}
564
 
565
      value_type operator[](size_t __i) const
566
      { return _Oper()(_M_expr1, _M_expr2[__i]); }
567
 
568
      size_t size() const { return _M_expr2.size(); }
569
 
570
    private:
571
      const _Vt& _M_expr1;
572
      const _Clos& _M_expr2;
573
    };
574
 
575
  template<class _Oper, class _Dom1, class _Dom2>
576
    struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2>
577
    : _BinBase<_Oper, _Dom1, _Dom2>
578
    {
579
      typedef _BinBase<_Oper, _Dom1, _Dom2> _Base;
580
      typedef typename _Base::value_type value_type;
581
 
582
      _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {}
583
    };
584
 
585
  template<class _Oper, typename _Tp>
586
    struct _BinClos<_Oper,_ValArray, _ValArray, _Tp, _Tp>
587
    : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> >
588
    {
589
      typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base;
590
      typedef typename _Base::value_type value_type;
591
 
592
      _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w)
593
      : _Base(__v, __w) {}
594
    };
595
 
596
  template<class _Oper, class _Dom>
597
    struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type>
598
    : _BinBase<_Oper, _Dom, valarray<typename _Dom::value_type> >
599
    {
600
      typedef typename _Dom::value_type _Tp;
601
      typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base;
602
      typedef typename _Base::value_type value_type;
603
 
604
      _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2)
605
      : _Base(__e1, __e2) {}
606
    };
607
 
608
  template<class _Oper, class _Dom>
609
    struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom>
610
    : _BinBase<_Oper, valarray<typename _Dom::value_type>,_Dom>
611
    {
612
      typedef typename _Dom::value_type _Tp;
613
      typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base;
614
      typedef typename _Base::value_type value_type;
615
 
616
      _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2)
617
      : _Base(__e1, __e2) {}
618
    };
619
 
620
  template<class _Oper, class _Dom>
621
    struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type>
622
    : _BinBase2<_Oper, _Dom>
623
    {
624
      typedef typename _Dom::value_type _Tp;
625
      typedef _BinBase2<_Oper,_Dom> _Base;
626
      typedef typename _Base::value_type value_type;
627
 
628
      _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {}
629
    };
630
 
631
  template<class _Oper, class _Dom>
632
    struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom>
633
    : _BinBase1<_Oper, _Dom>
634
    {
635
      typedef typename _Dom::value_type _Tp;
636
      typedef _BinBase1<_Oper, _Dom> _Base;
637
      typedef typename _Base::value_type value_type;
638
 
639
      _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {}
640
    };
641
 
642
  template<class _Oper, typename _Tp>
643
    struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp>
644
    : _BinBase2<_Oper, valarray<_Tp> >
645
    {
646
      typedef _BinBase2<_Oper,valarray<_Tp> > _Base;
647
      typedef typename _Base::value_type value_type;
648
 
649
      _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {}
650
    };
651
 
652
  template<class _Oper, typename _Tp>
653
    struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp>
654
    : _BinBase1<_Oper, valarray<_Tp> >
655
    {
656
      typedef _BinBase1<_Oper, valarray<_Tp> > _Base;
657
      typedef typename _Base::value_type value_type;
658
 
659
      _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {}
660
    };
661
 
662
    //
663
    // slice_array closure.
664
    //
665
  template<typename _Dom>
666
    class _SBase
667
    {
668
    public:
669
      typedef typename _Dom::value_type value_type;
670
 
671
      _SBase (const _Dom& __e, const slice& __s)
672
      : _M_expr (__e), _M_slice (__s) {}
673
 
674
      value_type
675
      operator[] (size_t __i) const
676
      { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; }
677
 
678
      size_t
679
      size() const
680
      { return _M_slice.size (); }
681
 
682
    private:
683
      const _Dom& _M_expr;
684
      const slice& _M_slice;
685
    };
686
 
687
  template<typename _Tp>
688
    class _SBase<_Array<_Tp> >
689
    {
690
    public:
691
      typedef _Tp value_type;
692
 
693
      _SBase (_Array<_Tp> __a, const slice& __s)
694
      : _M_array (__a._M_data+__s.start()), _M_size (__s.size()),
695
        _M_stride (__s.stride()) {}
696
 
697
      value_type
698
      operator[] (size_t __i) const
699
      { return _M_array._M_data[__i * _M_stride]; }
700
 
701
      size_t
702
      size() const
703
      { return _M_size; }
704
 
705
    private:
706
      const _Array<_Tp> _M_array;
707
      const size_t _M_size;
708
      const size_t _M_stride;
709
    };
710
 
711
  template<class _Dom>
712
    struct _SClos<_Expr, _Dom>
713
    : _SBase<_Dom>
714
    {
715
      typedef _SBase<_Dom> _Base;
716
      typedef typename _Base::value_type value_type;
717
 
718
      _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {}
719
    };
720
 
721
  template<typename _Tp>
722
    struct _SClos<_ValArray, _Tp>
723
    : _SBase<_Array<_Tp> >
724
    {
725
      typedef  _SBase<_Array<_Tp> > _Base;
726
      typedef _Tp value_type;
727
 
728
      _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
729
    };
730
 
731
_GLIBCXX_END_NAMESPACE_VERSION
732
} // namespace
733
 
734
#endif /* _CPP_VALARRAY_BEFORE_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.