Part 3)Trying to get MakeBottle.cxx to compile.

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 152 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 3 4
typedef int ptrdiff_t;
# 214 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 3 4
typedef unsigned int size_t;
# 8 “/usr/include/opencascade/Standard_TypeDef.hxx” 2

typedef int Standard_Integer;
typedef double Standard_Real;
typedef unsigned int Standard_Boolean;
typedef float Standard_ShortReal;
typedef char Standard_Character;
typedef short Standard_ExtCharacter;
typedef unsigned char Standard_Byte;
typedef char* Standard_CString;
typedef void* Standard_Address;
typedef short* Standard_ExtString;
typedef size_t Standard_Size;

# 1 “/usr/include/opencascade/Standard_Macro.hxx” 1
# 54 “/usr/include/opencascade/Standard_Macro.hxx”
# 1 “/usr/include/opencascade/arch/Standard_Macro64.hxx” 1
# 55 “/usr/include/opencascade/Standard_Macro.hxx” 2
# 26 “/usr/include/opencascade/Standard_TypeDef.hxx” 2

class Standard_Stream;
void ShallowDump(const Standard_Boolean, Standard_Stream& );
void ShallowDump(const Standard_CString, Standard_Stream& );
void ShallowDump(const Standard_Character, Standard_Stream& );
void ShallowDump(const Standard_ExtCharacter, Standard_Stream& );
void ShallowDump(const Standard_ExtString, Standard_Stream& );
void ShallowDump(const Standard_Integer, Standard_Stream& );
void ShallowDump(const Standard_Address, Standard_Stream& );
void ShallowDump(const Standard_Real, Standard_Stream& );
void ShallowDump(const Standard_ShortReal, Standard_Stream& );
# 19 “/usr/include/opencascade/Standard_Boolean.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_Boolean_Type_();
# 39 “/usr/include/opencascade/Standard_Boolean.hxx”
Standard_Boolean ShallowCopy (const Standard_Boolean);
Standard_Integer HashCode (const Standard_Boolean, const Standard_Integer);
# 49 “/usr/include/opencascade/Standard_Boolean.hxx”
inline Standard_Boolean IsEqual(const Standard_Boolean One
,const Standard_Boolean Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar(const Standard_Boolean One
,const Standard_Boolean Two)
{ return One == Two; }
# 27 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom_Surface.hxx” 1
# 29 “/usr/include/opencascade/Handle_Geom_Surface.hxx”
# 1 “/usr/include/opencascade/Standard.hxx” 1
# 28 “/usr/include/opencascade/Standard.hxx”
# 1 “/usr/include/opencascade/Standard_Address.hxx” 1
# 12 “/usr/include/opencascade/Standard_Address.hxx”
# 1 “/usr/include/string.h” 1 3 4
# 26 “/usr/include/string.h” 3 4
# 1 “/usr/include/features.h” 1 3 4
# 330 “/usr/include/features.h” 3 4
# 1 “/usr/include/sys/cdefs.h” 1 3 4
# 348 “/usr/include/sys/cdefs.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 349 “/usr/include/sys/cdefs.h” 2 3 4
# 331 “/usr/include/features.h” 2 3 4
# 354 “/usr/include/features.h” 3 4
# 1 “/usr/include/gnu/stubs.h” 1 3 4

# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 5 “/usr/include/gnu/stubs.h” 2 3 4

# 1 “/usr/include/gnu/stubs-32.h” 1 3 4
# 8 “/usr/include/gnu/stubs.h” 2 3 4
# 355 “/usr/include/features.h” 2 3 4
# 27 “/usr/include/string.h” 2 3 4

extern “C” {

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 34 “/usr/include/string.h” 2 3 4

extern void *memcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *memmove (void *__dest, __const void *__src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
int __c, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern void *memchr (__const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern void *rawmemchr (__const void *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern void *memrchr (__const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int strcmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strcoll (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (2)));

# 1 “/usr/include/xlocale.h” 1 3 4
# 28 “/usr/include/xlocale.h” 3 4
typedef struct __locale_struct
{

struct locale_data *__locales[13];

const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;

const char *__names[13];
} *__locale_t;
# 119 “/usr/include/string.h” 2 3 4

extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
__locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));

extern char *strdup (__const char *__s)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));

extern char *strndup (__const char *__string, size_t __n)
throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 165 “/usr/include/string.h” 3 4

extern char *strchr (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strrchr (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strchrnul (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern size_t strcspn (__const char *__s, __const char *__reject)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strspn (__const char *__s, __const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strpbrk (__const char *__s, __const char *__accept)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strstr (__const char *__haystack, __const char *__needle)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (2)));

extern char *__strtok_r (char *__restrict __s,
__const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
char **__restrict __save_ptr)
throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strcasestr (__const char *__haystack, __const char *__needle)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern void *memmem (__const void *__haystack, size_t __haystacklen,
__const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));

extern void *__mempcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern size_t strlen (__const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern size_t strnlen (__const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strerror (int __errnum) throw ();

# 281 “/usr/include/string.h” 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));

extern char *strerror_l (int __errnum, __locale_t __l) throw ();

extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern void bcopy (__const void *__src, void *__dest, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *index (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *rindex (__const char *__s, int __c)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern int ffs (int __i) throw () __attribute__ ((__const__));

extern int ffsl (long int __l) throw () __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));

extern int strcasecmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strcasecmp_l (__const char *__s1, __const char *__s2,
__locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));

extern char *strsep (char **__restrict __stringp,
__const char *__restrict __delim)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int strverscmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strsignal (int __sig) throw ();

extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *__stpncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));

extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));

extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
# 432 “/usr/include/string.h” 3 4
}
# 13 “/usr/include/opencascade/Standard_Address.hxx” 2
# 21 “/usr/include/opencascade/Standard_Address.hxx”
# 1 “/usr/include/opencascade/Standard_Integer.hxx” 1
# 9 “/usr/include/opencascade/Standard_Integer.hxx”
# 1 “/usr/include/opencascade/Standard_values.h” 1
# 10 “/usr/include/opencascade/Standard_Integer.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_Integer_Type_();
# 27 “/usr/include/opencascade/Standard_Integer.hxx”
Standard_Integer NextPrimeForMap(const Standard_Integer anInt ) ;
long NextPrime (const long me);
Standard_Integer CharToInt (const Standard_Character me);
Standard_Integer CharToInt (const Standard_CString me);
Standard_Integer ShallowCopy (const Standard_Integer me);
# 41 “/usr/include/opencascade/Standard_Integer.hxx”
inline Standard_Integer Abs (const Standard_Integer Value)
{
if ( Value >= 0 )
return Value;
else
return -Value;
}

inline Standard_Integer HashCode(const Standard_Integer me,
const Standard_Integer Upper)
{

return ( ( me & 0x7fffffff ) % Upper) + 1;
}

inline Standard_Boolean IsEqual(const Standard_Integer One
,const Standard_Integer Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar (const Standard_Integer One,
const Standard_Integer Two)
{ return One == Two; }

inline Standard_Boolean IsEven (const Standard_Integer Value)
{ return Value % 2 == 0; }

inline Standard_Boolean IsOdd (const Standard_Integer Value)
{ return Value % 2 == 1; }

inline Standard_Integer Max (const Standard_Integer Val1,
const Standard_Integer Val2)
{
if (Val1 >= Val2)
return Val1;
else
return Val2;
}

inline Standard_Integer Min (const Standard_Integer Val1,
const Standard_Integer Val2)
{
if (Val1 <= Val2)
return Val1;
else
return Val2;
}

inline Standard_Integer Modulus (const Standard_Integer Value,
const Standard_Integer Divisor)
{ return Value % Divisor; }

inline Standard_Integer Square(const Standard_Integer Value)
{ return Value * Value; }

inline Standard_Integer IntegerFirst()
{ return INT_MIN; }

inline Standard_Integer IntegerLast()
{ return INT_MAX; }

inline Standard_Integer IntegerSize()
{ return ((CHAR_BIT * sizeof(Standard_Integer))); }
# 22 “/usr/include/opencascade/Standard_Address.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_Address_Type_();

inline Standard_Address ShallowCopy (const Standard_Address Value)
{
return Value;
}

inline Standard_Integer HashCode (const Standard_Address Value,
const Standard_Integer Upper)
{
union {Standard_Address L ;
Standard_Integer I[2] ;} U ;
U.I[0] = 0 ;
U.I[1] = 0 ;
U.L = Value;
return HashCode( ( ( U.I[0] ^ U.I[1] ) & 0x7fffffff ) , Upper ) ;
}

inline Standard_Boolean IsSimilar(const Standard_Address One
,const Standard_Address Two)
{ return One == Two; }

inline Standard_Boolean IsEqual(const Standard_Address One
,const Standard_Address Two)
{ return One == Two; }
# 29 “/usr/include/opencascade/Standard.hxx” 2
# 37 “/usr/include/opencascade/Standard.hxx”
# 1 “/usr/include/opencascade/Standard_Size.hxx” 1
# 38 “/usr/include/opencascade/Standard.hxx” 2

# 1 “/usr/include/opencascade/Standard_OStream.hxx” 1

# 1 “/usr/include/opencascade/Standard_Stream.hxx” 1
# 8 “/usr/include/opencascade/Standard_OStream.hxx” 2

class Handle_Standard_Type;

Handle_Standard_Type& Standard_OStream_Type_();
# 41 “/usr/include/opencascade/Standard.hxx” 2

# 1 “/usr/include/opencascade/Standard_CString.hxx” 1
# 27 “/usr/include/opencascade/Standard_CString.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_CString_Type_();

inline Standard_Integer Abs (const Standard_Integer);
inline Standard_CString ShallowCopy (const Standard_CString Value);
inline Standard_Boolean IsSimilar(const Standard_CString One
,const Standard_CString Two);
inline Standard_Boolean IsEqual(const Standard_CString One
,const Standard_CString Two);
Standard_Integer HashCode (const Standard_CString,
const Standard_Integer);
inline Standard_Integer HashCode (const Standard_CString,
const Standard_Integer,
const Standard_Integer);
inline Standard_Integer HashCode (const Standard_CString,
const Standard_Integer ,
const Standard_Integer ,
Standard_Integer& );
Standard_Integer HashCodes (const Standard_CString ,
const Standard_Integer );
inline Standard_Boolean ISEQUAL(const Standard_CString One ,
const Standard_Integer LenOne ,
const Standard_CString Two,
const Standard_Integer LenTwo );
Standard_Boolean ISSIMILAR(const Standard_CString One ,
const Standard_Integer Len ,
const Standard_CString Two );
inline Standard_Integer HASHCODE (const Standard_CString,
const Standard_Integer,
const Standard_Integer);
inline Standard_Integer HASHCODE (const Standard_CString,
const Standard_Integer,
const Standard_Integer ,
Standard_Integer& );
Standard_Integer HASHCODES (const Standard_CString,
const Standard_Integer);

inline Standard_CString ShallowCopy (const Standard_CString Value)
{
return Value;
}

inline Standard_Boolean IsSimilar(const Standard_CString One
,const Standard_CString Two)
{
return (strcmp(One,Two) == 0);
}

inline Standard_Boolean IsEqual(const Standard_CString One
,const Standard_CString Two)
{
return (One == Two);
}

inline Standard_Integer HashCode (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper ,
Standard_Integer& aHashCode )
{
aHashCode = HashCodes( Value , Len );

return HashCode( (const Standard_Integer) aHashCode , Upper ) ;
}

inline Standard_Integer HashCode (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper )
{

return HashCode( (const Standard_Integer) HashCodes( Value , Len ) , Upper ) ;
}

inline Standard_Integer HASHCODE (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper ,
Standard_Integer& aHashCode )
{
aHashCode = HASHCODES( Value , Len );

return HashCode( (const Standard_Integer) aHashCode , Upper ) ;
}

inline Standard_Integer HASHCODE (const Standard_CString Value,
const Standard_Integer Len ,
const Standard_Integer Upper)
{

return HashCode( (const Standard_Integer) HASHCODES( Value , Len ) , Upper ) ;
}
# 153 “/usr/include/opencascade/Standard_CString.hxx”
inline Standard_Boolean ISEQUAL(const Standard_CString One ,
const Standard_Integer LenOne ,
const Standard_CString Two,
const Standard_Integer LenTwo )
{

if ( One == Two )
return (Standard_Boolean) 1 ;
if ( LenOne != LenTwo )
return (Standard_Boolean) 0 ;

return ISSIMILAR( One , LenOne , Two ) ;

}
# 44 “/usr/include/opencascade/Standard.hxx” 2

class Standard_ErrorHandler;
class Standard_AncestorIterator;
class Standard_Storable;
class Standard_Persistent;
class Standard_GUID;
class Standard_Transient;
class Standard_Type;
class Standard_Failure;

class Standard {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

static Standard_Address Allocate(const Standard_Size size) ;
static void Free(Standard_Address& aStorage) ;
static Standard_Address Reallocate(Standard_Address& aStorage, const Standard_Size newSize) ;
static Standard_Integer Purge() ;

protected:
# 92 “/usr/include/opencascade/Standard.hxx”
friend class Standard_ErrorHandler;
friend class Standard_AncestorIterator;
friend class Standard_Storable;
friend class Standard_Persistent;
friend class Standard_GUID;
friend class Standard_Transient;
friend class Standard_Type;
friend class Standard_Failure;

};
# 30 “/usr/include/opencascade/Handle_Geom_Surface.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom_Geometry.hxx” 1
# 33 “/usr/include/opencascade/Handle_Geom_Geometry.hxx”
# 1 “/usr/include/opencascade/Handle_MMgt_TShared.hxx” 1
# 33 “/usr/include/opencascade/Handle_MMgt_TShared.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_Transient.hxx” 1
# 10 “/usr/include/opencascade/Handle_Standard_Transient.hxx”
# 1 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 1

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 5 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2
# 1 “/usr/include/stdlib.h” 1 3 4
# 33 “/usr/include/stdlib.h” 3 4
# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 34 “/usr/include/stdlib.h” 2 3 4

extern “C” {

# 1 “/usr/include/bits/waitflags.h” 1 3 4
# 43 “/usr/include/stdlib.h” 2 3 4
# 1 “/usr/include/bits/waitstatus.h” 1 3 4
# 65 “/usr/include/bits/waitstatus.h” 3 4
# 1 “/usr/include/endian.h” 1 3 4
# 37 “/usr/include/endian.h” 3 4
# 1 “/usr/include/bits/endian.h” 1 3 4
# 38 “/usr/include/endian.h” 2 3 4
# 66 “/usr/include/bits/waitstatus.h” 2 3 4

union wait
{
int w_status;
struct
{

unsigned int __w_termsig:7;
unsigned int __w_coredump:1;
unsigned int __w_retcode:8;
unsigned int:16;

} __wait_terminated;
struct
{

unsigned int __w_stopval:8;
unsigned int __w_stopsig:8;
unsigned int:16;

} __wait_stopped;
};
# 44 “/usr/include/stdlib.h” 2 3 4
# 96 “/usr/include/stdlib.h” 3 4

typedef struct
{
int quot;
int rem;
} div_t;

typedef struct
{
long int quot;
long int rem;
} ldiv_t;

__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;

# 140 “/usr/include/stdlib.h” 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () ;

extern double atof (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern int atoi (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern long int atol (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

__extension__ extern long long int atoll (__const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern double strtod (__const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1))) ;

extern float strtof (__const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))) ;

extern long double strtold (__const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1))) ;

extern long int strtol (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

extern unsigned long int strtoul (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern long long int strtoq (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern long long int strtoll (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1))) ;

# 240 “/usr/include/stdlib.h” 3 4
extern long int strtol_l (__const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))) ;

extern unsigned long int strtoul_l (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4))) ;

__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4))) ;

__extension__
extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4))) ;

extern double strtod_l (__const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3))) ;

extern float strtof_l (__const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3))) ;

extern long double strtold_l (__const char *__restrict __nptr,
char **__restrict __endptr,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3))) ;
# 311 “/usr/include/stdlib.h” 3 4
extern char *l64a (long int __n) throw () ;

extern long int a64l (__const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

# 1 “/usr/include/sys/types.h” 1 3 4
# 29 “/usr/include/sys/types.h” 3 4
extern “C” {

# 1 “/usr/include/bits/types.h” 1 3 4
# 28 “/usr/include/bits/types.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 29 “/usr/include/bits/types.h” 2 3 4

typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;

typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;

__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 131 “/usr/include/bits/types.h” 3 4
# 1 “/usr/include/bits/typesizes.h” 1 3 4
# 132 “/usr/include/bits/types.h” 2 3 4

__extension__ typedef __u_quad_t __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef __u_quad_t __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef __u_quad_t __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;

__extension__ typedef int __clockid_t;

__extension__ typedef void * __timer_t;

__extension__ typedef long int __blksize_t;

__extension__ typedef long int __blkcnt_t;
__extension__ typedef __quad_t __blkcnt64_t;

__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef __u_quad_t __fsblkcnt64_t;

__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef __u_quad_t __fsfilcnt64_t;

__extension__ typedef int __ssize_t;

typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;

__extension__ typedef int __intptr_t;

__extension__ typedef unsigned int __socklen_t;
# 32 “/usr/include/sys/types.h” 2 3 4

typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;

typedef __loff_t loff_t;

typedef __ino_t ino_t;

typedef __ino64_t ino64_t;

typedef __dev_t dev_t;

typedef __gid_t gid_t;

typedef __mode_t mode_t;

typedef __nlink_t nlink_t;

typedef __uid_t uid_t;

typedef __off_t off_t;

typedef __off64_t off64_t;

typedef __pid_t pid_t;

typedef __id_t id_t;

typedef __ssize_t ssize_t;

typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;

typedef __key_t key_t;
# 133 “/usr/include/sys/types.h” 3 4
# 1 “/usr/include/time.h” 1 3 4
# 59 “/usr/include/time.h” 3 4

typedef __clock_t clock_t;

# 75 “/usr/include/time.h” 3 4

typedef __time_t time_t;

# 93 “/usr/include/time.h” 3 4
typedef __clockid_t clockid_t;
# 105 “/usr/include/time.h” 3 4
typedef __timer_t timer_t;
# 134 “/usr/include/sys/types.h” 2 3 4

typedef __useconds_t useconds_t;

typedef __suseconds_t suseconds_t;

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 148 “/usr/include/sys/types.h” 2 3 4

typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 195 “/usr/include/sys/types.h” 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));

typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 220 “/usr/include/sys/types.h” 3 4
# 1 “/usr/include/sys/select.h” 1 3 4
# 31 “/usr/include/sys/select.h” 3 4
# 1 “/usr/include/bits/select.h” 1 3 4
# 32 “/usr/include/sys/select.h” 2 3 4

# 1 “/usr/include/bits/sigset.h” 1 3 4
# 24 “/usr/include/bits/sigset.h” 3 4
typedef int __sig_atomic_t;

typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 35 “/usr/include/sys/select.h” 2 3 4

typedef __sigset_t sigset_t;

# 1 “/usr/include/time.h” 1 3 4
# 121 “/usr/include/time.h” 3 4
struct timespec
{
__time_t tv_sec;
long int tv_nsec;
};
# 45 “/usr/include/sys/select.h” 2 3 4

# 1 “/usr/include/bits/time.h” 1 3 4
# 69 “/usr/include/bits/time.h” 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 47 “/usr/include/sys/select.h” 2 3 4
# 55 “/usr/include/sys/select.h” 3 4
typedef long int __fd_mask;
# 67 “/usr/include/sys/select.h” 3 4
typedef struct
{

__fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];

} fd_set;

typedef __fd_mask fd_mask;
# 99 “/usr/include/sys/select.h” 3 4
extern “C” {
# 109 “/usr/include/sys/select.h” 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
# 121 “/usr/include/sys/select.h” 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);

}
# 221 “/usr/include/sys/types.h” 2 3 4

# 1 “/usr/include/sys/sysmacros.h” 1 3 4
# 30 “/usr/include/sys/sysmacros.h” 3 4
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
throw ();
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
throw ();
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
unsigned int __minor)
throw ();
# 224 “/usr/include/sys/types.h” 2 3 4

typedef __blksize_t blksize_t;

typedef __blkcnt_t blkcnt_t;

typedef __fsblkcnt_t fsblkcnt_t;

typedef __fsfilcnt_t fsfilcnt_t;
# 262 “/usr/include/sys/types.h” 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;

# 1 “/usr/include/bits/pthreadtypes.h” 1 3 4
# 23 “/usr/include/bits/pthreadtypes.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 24 “/usr/include/bits/pthreadtypes.h” 2 3 4
# 50 “/usr/include/bits/pthreadtypes.h” 3 4
typedef unsigned long int pthread_t;

typedef union
{
char __size[36];
long int __align;
} pthread_attr_t;
# 67 “/usr/include/bits/pthreadtypes.h” 3 4
typedef struct __pthread_internal_slist
{
struct __pthread_internal_slist *__next;
} __pthread_slist_t;

typedef union
{
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;

int __kind;

unsigned int __nusers;
__extension__ union
{
int __spins;
__pthread_slist_t __list;
};

} __data;
char __size[24];
long int __align;
} pthread_mutex_t;

typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;

typedef union
{
struct
{
int __lock;
unsigned int __futex;
__extension__ unsigned long long int __total_seq;
__extension__ unsigned long long int __wakeup_seq;
__extension__ unsigned long long int __woken_seq;
void *__mutex;
unsigned int __nwaiters;
unsigned int __broadcast_seq;
} __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;

typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;

typedef unsigned int pthread_key_t;

typedef int pthread_once_t;

typedef union
{
# 170 “/usr/include/bits/pthreadtypes.h” 3 4
struct
{
int __lock;
unsigned int __nr_readers;
unsigned int __readers_wakeup;
unsigned int __writer_wakeup;
unsigned int __nr_readers_queued;
unsigned int __nr_writers_queued;

unsigned char __flags;
unsigned char __shared;
unsigned char __pad1;
unsigned char __pad2;
int __writer;
} __data;

char __size[32];
long int __align;
} pthread_rwlock_t;

typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;

typedef volatile int pthread_spinlock_t;

typedef union
{
char __size[20];
long int __align;
} pthread_barrier_t;

typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
# 271 “/usr/include/sys/types.h” 2 3 4

}
# 321 “/usr/include/stdlib.h” 2 3 4

extern long int random (void) throw ();

extern void srandom (unsigned int __seed) throw ();

extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));

extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));

struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};

extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();

extern int rand_r (unsigned int *__seed) throw ();

extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));

extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));

extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));

extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));

struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
unsigned long long int __a;
};

extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));

extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;

extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) ;

extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__));

extern void free (void *__ptr) throw ();

extern void cfree (void *__ptr) throw ();

# 1 “/usr/include/alloca.h” 1 3 4
# 25 “/usr/include/alloca.h” 3 4
# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/stddef.h” 1 3 4
# 26 “/usr/include/alloca.h” 2 3 4

extern “C” {

extern void *alloca (size_t __size) throw ();

}
# 498 “/usr/include/stdlib.h” 2 3 4

extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;

extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;

extern void abort (void) throw () __attribute__ ((__noreturn__));

extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));

extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));

extern void exit (int __status) throw () __attribute__ ((__noreturn__));

extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));

extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;

extern char *__secure_getenv (__const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;

extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));

extern int setenv (__const char *__name, __const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));

extern int unsetenv (__const char *__name) throw ();

extern int clearenv (void) throw ();
# 583 “/usr/include/stdlib.h” 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 594 “/usr/include/stdlib.h” 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 604 “/usr/include/stdlib.h” 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 614 “/usr/include/stdlib.h” 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 625 “/usr/include/stdlib.h” 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 635 “/usr/include/stdlib.h” 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;

extern int system (__const char *__command) ;

extern char *canonicalize_file_name (__const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
# 662 “/usr/include/stdlib.h” 3 4
extern char *realpath (__const char *__restrict __name,
char *__restrict __resolved) throw () ;

typedef int (*__compar_fn_t) (__const void *, __const void *);

typedef __compar_fn_t comparison_fn_t;

extern void *bsearch (__const void *__key, __const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;

extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));

extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;

__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;

extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;

__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;

# 727 “/usr/include/stdlib.h” 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;

extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;

extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;

extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;

extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int mblen (__const char *__s, size_t __n) throw () ;

extern int mbtowc (wchar_t *__restrict __pwc,
__const char *__restrict __s, size_t __n) throw () ;

extern int wctomb (char *__s, wchar_t __wchar) throw () ;

extern size_t mbstowcs (wchar_t *__restrict __pwcs,
__const char *__restrict __s, size_t __n) throw ();

extern size_t wcstombs (char *__restrict __s,
__const wchar_t *__restrict __pwcs, size_t __n)
throw ();

extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
# 815 “/usr/include/stdlib.h” 3 4
extern int getsubopt (char **__restrict __optionp,
char *__const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;

extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));

extern int posix_openpt (int __oflag) ;

extern int grantpt (int __fd) throw ();

extern int unlockpt (int __fd) throw ();

extern char *ptsname (int __fd) throw () ;

extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));

extern int getpt (void);

extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
# 883 “/usr/include/stdlib.h” 3 4
}
# 6 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

class Standard_Type;
class Handle_Standard_Type;

class Handle_Standard_Transient;
class Standard_Transient;
# 23 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx”
# 1 “/usr/include/opencascade/Standard_Real.hxx” 1

# 1 “/usr/lib/gcc/i486-linux-gnu/4.2.3/include/float.h” 1 3 4
# 5 “/usr/include/opencascade/Standard_Real.hxx” 2
# 1 “/usr/include/math.h” 1 3 4
# 30 “/usr/include/math.h” 3 4
extern “C” {

# 1 “/usr/include/bits/huge_val.h” 1 3 4
# 35 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/huge_valf.h” 1 3 4
# 37 “/usr/include/math.h” 2 3 4
# 1 “/usr/include/bits/huge_vall.h” 1 3 4
# 38 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/inf.h” 1 3 4
# 41 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/nan.h” 1 3 4
# 44 “/usr/include/math.h” 2 3 4

# 1 “/usr/include/bits/mathdef.h” 1 3 4
# 26 “/usr/include/bits/mathdef.h” 3 4
# 1 “/usr/include/bits/wordsize.h” 1 3 4
# 27 “/usr/include/bits/mathdef.h” 2 3 4
# 38 “/usr/include/bits/mathdef.h” 3 4
typedef long double float_t;

typedef long double double_t;
# 48 “/usr/include/math.h” 2 3 4
# 71 “/usr/include/math.h” 3 4
# 1 “/usr/include/bits/mathcalls.h” 1 3 4
# 53 “/usr/include/bits/mathcalls.h” 3 4

extern double acos (double __x) throw (); extern double __acos (double __x) throw ();

extern double asin (double __x) throw (); extern double __asin (double __x) throw ();

extern double atan (double __x) throw (); extern double __atan (double __x) throw ();

extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();

extern double cos (double __x) throw (); extern double __cos (double __x) throw ();

extern double sin (double __x) throw (); extern double __sin (double __x) throw ();

extern double tan (double __x) throw (); extern double __tan (double __x) throw ();

extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();

extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();

extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();

extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();

extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();

extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();

extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();

extern double exp (double __x) throw (); extern double __exp (double __x) throw ();

extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();

extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();

extern double log (double __x) throw (); extern double __log (double __x) throw ();

extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();

extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();

extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();

extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();

extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();

extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();

extern double logb (double __x) throw (); extern double __logb (double __x) throw ();

extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();

extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();

extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();

extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();

extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();

extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();

extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));

extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));

extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));

extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();

extern int __isinf (double __value) throw () __attribute__ ((__const__));

extern int __finite (double __value) throw () __attribute__ ((__const__));

extern int isinf (double __value) throw () __attribute__ ((__const__));

extern int finite (double __value) throw () __attribute__ ((__const__));

extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();

extern double significand (double __x) throw (); extern double __significand (double __x) throw ();

extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));

extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));

extern int __isnan (double __value) throw () __attribute__ ((__const__));

extern int isnan (double __value) throw () __attribute__ ((__const__));

extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();

extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();

extern double tgamma (double) throw (); extern double __tgamma (double) throw ();

extern double gamma (double) throw (); extern double __gamma (double) throw ();

extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();

extern double rint (double __x) throw (); extern double __rint (double __x) throw ();

extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));

extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();

extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();

extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();

extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();

extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();

extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));

extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));

extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();

extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();

extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();

extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();

extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();

extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();

extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));

extern int __signbit (double __value) throw ()
__attribute__ ((__const__));

extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();

extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 72 “/usr/include/math.h” 2 3 4
# 94 “/usr/include/math.h” 3 4
# 1 “/usr/include/bits/mathcalls.h” 1 3 4
# 53 “/usr/include/bits/mathcalls.h” 3 4

extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();

extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();

extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();

extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();

extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();

extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();

extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();

extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();

extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();

extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();

extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();

extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();

extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();

extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();

extern float expf (float __x) throw (); extern float __expf (float __x) throw ();

extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();

extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();

extern float logf (float __x) throw (); extern float __logf (float __x) throw ();

extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();

extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();

extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();

extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();

extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();

extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();

extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();

extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();

extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();

extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();

extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();

extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();

extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();

extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));

extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));

extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));

extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();

extern int __isinff (float __value) throw () __attribute__ ((__const__));

extern int __finitef (float __value) throw () __attribute__ ((__const__));

extern int isinff (float __value) throw () __attribute__ ((__const__));

extern int finitef (float __value) throw () __attribute__ ((__const__));

extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();

extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();

extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));

extern int __isnanf (float __value) throw () __attribute__ ((__const__));

extern int isnanf (float __value) throw () __attribute__ ((__const__));

extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();

extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();

extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();

extern float gammaf (float) throw (); extern float __gammaf (float) throw ();

extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();

extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();

extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));

extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();

extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();

extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();

extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();

extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();

extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));

extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));

extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();

extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();

extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();

extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();

extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();

extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();

extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));

extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));

extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();

extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 95 “/usr/include/math.h” 2 3 4
# 141 “/usr/include/math.h” 3 4
# 1 “/usr/include/bits/mathcalls.h” 1 3 4
# 53 “/usr/include/bits/mathcalls.h” 3 4

extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();

extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();

extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();

extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();

extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();

extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();

extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();

extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();

extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();

extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();

extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();

extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();

extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();

extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();

extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();

extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();

extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();

extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();

extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();

extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();

extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();

extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();

extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();

extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();

extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();

extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();

extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();

extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();

extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();

extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();

extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();

extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));

extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));

extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));

extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();

extern int __isinfl (long double __value) throw () __attribute__ ((__const__));

extern int __finitel (long double __value) throw () __attribute__ ((__const__));

extern int isinfl (long double __value) throw () __attribute__ ((__const__));

extern int finitel (long double __value) throw () __attribute__ ((__const__));

extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();

extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();

extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));

extern int __isnanl (long double __value) throw () __attribute__ ((__const__));

extern int isnanl (long double __value) throw () __attribute__ ((__const__));

extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();

extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();

extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();

extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();

extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();

extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();

extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();

extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();

extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();

extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();

extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();

extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));

extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));

extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();

extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();

extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();

extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();

extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();

extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();

extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));

extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));

extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();

extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 142 “/usr/include/math.h” 2 3 4
# 157 “/usr/include/math.h” 3 4
extern int signgam;
# 198 “/usr/include/math.h” 3 4
enum
{
FP_NAN,

FP_INFINITE,

FP_ZERO,

FP_SUBNORMAL,

FP_NORMAL

};
# 284 “/usr/include/math.h” 3 4
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;

extern _LIB_VERSION_TYPE _LIB_VERSION;
# 307 “/usr/include/math.h” 3 4
struct __exception

{
int type;
char *name;
double arg1;
double arg2;
double retval;
};

extern int matherr (struct __exception *__exc) throw ();
# 465 “/usr/include/math.h” 3 4
}
# 6 “/usr/include/opencascade/Standard_Real.hxx” 2
# 18 “/usr/include/opencascade/Standard_Real.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_Real_Type_();
# 34 “/usr/include/opencascade/Standard_Real.hxx”
extern const Standard_Real PI;
extern const Standard_Real PI180;

extern const Standard_Real Standard_PI;
extern const Standard_Real Standard_PI180;
# 53 “/usr/include/opencascade/Standard_Real.hxx”
Standard_Integer HashCode (const Standard_Real, const Standard_Integer);
Standard_Real ShallowCopy (const Standard_Real );

Standard_Real ACos (const Standard_Real );
Standard_Real ASin (const Standard_Real );
Standard_Real ATan2 (const Standard_Real , const Standard_Real );
Standard_Real NextAfter (const Standard_Real , const Standard_Real );
Standard_Real Sign (const Standard_Real , const Standard_Real );
Standard_Real ATanh (const Standard_Real );
Standard_Real ACosh (const Standard_Real );
Standard_Real Log (const Standard_Real );
Standard_Real Sqrt (const Standard_Real );

inline Standard_Real RealSmall()
{ return 2.2250738585072014e-308; }

inline Standard_Real Abs(const Standard_Real Value)
{ return fabs(Value); }

inline Standard_Boolean IsEqual (const Standard_Real Value1,
const Standard_Real Value2)
{ return Abs((Value1 – Value2)) < RealSmall(); }

inline Standard_Boolean IsSimilar(const Standard_Real One,
const Standard_Real Two)
{ return IsEqual (One,Two); }
# 109 “/usr/include/opencascade/Standard_Real.hxx”
inline Standard_Integer RealDigits()
{ return 15; }

inline Standard_Real RealEpsilon()
{ return 2.2204460492503131e-16; }

inline Standard_Real RealFirst()
{Standard_Real aValue = -1.7976931348623157e+308; return aValue; }

inline Standard_Integer RealFirst10Exp()
{ return (-307); }

inline Standard_Real RealLast()
{ return 1.7976931348623157e+308; }

inline Standard_Integer RealLast10Exp()
{ return 308; }

inline Standard_Integer RealMantissa()
{ return 53; }

inline Standard_Integer RealRadix()
{ return 2; }

inline Standard_Integer RealSize()
{ return (CHAR_BIT * sizeof(Standard_Real)); }
# 174 “/usr/include/opencascade/Standard_Real.hxx”
inline Standard_Real IntToReal(const Standard_Integer Value)
{ return Value; }

inline Standard_Real ATan(const Standard_Real Value)
{ return atan(Value); }

inline Standard_Real Ceiling (const Standard_Real Value)
{ return ceil(Value); }

inline Standard_Real Cos (const Standard_Real Value)
{ return cos(Value); }

inline Standard_Real Cosh (const Standard_Real Value)
{ return cosh(Value); }

inline Standard_Real Epsilon (const Standard_Real Value)
{
Standard_Real aEpsilon;

if (Value>=0.0){
aEpsilon = NextAfter(Value, RealLast()) – Value;
} else {
aEpsilon = Value – NextAfter(Value, RealFirst());
}
return aEpsilon;
}

inline Standard_Real Exp (const Standard_Real Value)
{ return exp(Value); }

inline Standard_Real Floor (const Standard_Real Value)
{ return floor(Value); }

inline Standard_Real IntegerPart (const Standard_Real Value)
{ return ( (Value>0) ? floor(Value) : ceil(Value) ); }

inline Standard_Real Log10 (const Standard_Real Value)
{ return log10(Value); }

inline Standard_Real Max (const Standard_Real Val1,
const Standard_Real Val2)
{
if (Val1 >= Val2) {
return Val1;
} else {
return Val2;
}
}

inline Standard_Real Min (const Standard_Real Val1,
const Standard_Real Val2)
{
if (Val1 <= Val2) {
return Val1;
} else {
return Val2;
}
}

inline Standard_Real Pow (const Standard_Real Value, const Standard_Real P)
{ return pow(Value,P); }

inline Standard_Real RealPart (const Standard_Real Value)
{ return fabs(IntegerPart(Value) – Value); }

inline Standard_Integer RealToInt (const Standard_Real Value)
{

return ( (Value>0) ? (Standard_Integer)floor(Value) : (Standard_Integer)ceil(Value) );

}

inline Standard_Real Round (const Standard_Real Value)
{ return IntegerPart(Value + (Value > 0 ? 0.5 : -0.5)); }

inline Standard_Real Sin (const Standard_Real Value)
{ return sin(Value); }

inline Standard_Real Sinh(const Standard_Real Value)
{ return sinh(Value); }

inline Standard_Real ASinh(const Standard_Real Value)
{ return asinh(Value); }

inline Standard_Real Square(const Standard_Real Value)
{ return Value * Value; }

inline Standard_Real Tan (const Standard_Real Value)
{ return tan(Value); }

inline Standard_Real Tanh (const Standard_Real Value)
{ return tanh(Value); }
# 24 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_Character.hxx” 1
# 14 “/usr/include/opencascade/Standard_Character.hxx”
# 1 “/usr/include/opencascade/Standard_ctype.hxx” 1
# 18 “/usr/include/opencascade/Standard_ctype.hxx”
# 1 “/usr/include/ctype.h” 1 3 4
# 30 “/usr/include/ctype.h” 3 4
extern “C” {
# 48 “/usr/include/ctype.h” 3 4
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 81 “/usr/include/ctype.h” 3 4
extern __const unsigned short int **__ctype_b_loc (void)
__attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
__attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
__attribute__ ((__const));
# 96 “/usr/include/ctype.h” 3 4

extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();

extern int tolower (int __c) throw ();

extern int toupper (int __c) throw ();

extern int isblank (int) throw ();

extern int isctype (int __c, int __mask) throw ();

extern int isascii (int __c) throw ();

extern int toascii (int __c) throw ();

extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 247 “/usr/include/ctype.h” 3 4
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();

extern int isblank_l (int, __locale_t) throw ();

extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();

extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 323 “/usr/include/ctype.h” 3 4
}
# 19 “/usr/include/opencascade/Standard_ctype.hxx” 2
# 15 “/usr/include/opencascade/Standard_Character.hxx” 2
# 23 “/usr/include/opencascade/Standard_Character.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_Character_Type_();

Standard_Integer HashCode(const Standard_Character, const Standard_Integer);
# 50 “/usr/include/opencascade/Standard_Character.hxx”
inline Standard_Boolean IsEqual(const Standard_Character One,
const Standard_Character Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar(const Standard_Character One,
const Standard_Character Two)
{ return One == Two; }
# 79 “/usr/include/opencascade/Standard_Character.hxx”
inline Standard_Boolean IsAlphabetic(const Standard_Character me)
{ return isalpha((unsigned char)me); }

inline Standard_Boolean IsDigit(const Standard_Character me)
{ return isdigit((unsigned char)me); }

inline Standard_Boolean IsXDigit(const Standard_Character me)
{ return isxdigit((unsigned char)me); }

inline Standard_Boolean IsAlphanumeric(const Standard_Character me)
{ return (IsAlphabetic(me) || IsDigit(me)) ; }

inline Standard_Boolean IsControl(const Standard_Character me)
{ return iscntrl((unsigned char)me); }

inline Standard_Boolean IsGraphic(const Standard_Character me)
{ return isgraph((unsigned char)me); }

inline Standard_Boolean IsLowerCase(const Standard_Character me)
{ return islower((unsigned char)me); }

inline Standard_Boolean IsPrintable(const Standard_Character me)
{ return isprint((unsigned char)me); }

inline Standard_Boolean IsPunctuation(const Standard_Character me)
{ return ( IsGraphic(me) && !IsAlphanumeric(me)); }

inline Standard_Boolean IsSpace(const Standard_Character me)
{ return isspace((unsigned char)me); }

inline Standard_Boolean IsUpperCase(const Standard_Character me)
{ return isupper((unsigned char)me); }

inline Standard_Character LowerCase(const Standard_Character me)
{ return tolower(me); }

inline Standard_Character UpperCase(const Standard_Character me)
{ return toupper(me); }

inline Standard_Character ShallowCopy (const Standard_Character me)
{ return me; }
# 27 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_ExtCharacter.hxx” 1
# 27 “/usr/include/opencascade/Standard_ExtCharacter.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_ExtCharacter_Type_();

Standard_Integer HashCode(const Standard_ExtCharacter, const Standard_Integer);
# 53 “/usr/include/opencascade/Standard_ExtCharacter.hxx”
inline Standard_ExtCharacter ToExtCharacter(const Standard_Character achar)
{

return ( achar & (Standard_ExtCharacter ) 0x00ff ) ;
}

inline Standard_Character ToCharacter(const Standard_ExtCharacter achar)
{

return (achar & 0x00ff) ;
}

inline Standard_Boolean IsAnAscii(const Standard_ExtCharacter achar)
{
return ( ( achar & (Standard_ExtCharacter ) 0xff00 ) == 0 ) ;
}

inline Standard_Boolean IsEqual(const Standard_ExtCharacter One,
const Standard_ExtCharacter Two)
{ return One == Two; }

inline Standard_Boolean IsSimilar(const Standard_ExtCharacter One,
const Standard_ExtCharacter Two)
{ return One == Two; }

inline Standard_ExtCharacter ShallowCopy (const Standard_ExtCharacter me)
{ return me; }
# 30 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_ExtString.hxx” 1
# 16 “/usr/include/opencascade/Standard_ExtString.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_ExtString_Type_();

inline Standard_ExtString ShallowCopy (const Standard_ExtString Value)
{
return Value;
}

Standard_Integer HashCode (const Standard_ExtString, const Standard_Integer);

inline Standard_Boolean IsSimilar(const Standard_ExtString One
,const Standard_ExtString Two)
{ return One == Two; }

inline Standard_Boolean IsEqual(const Standard_ExtString One
,const Standard_ExtString Two)
{ return One == Two; }
# 36 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

# 1 “/usr/include/opencascade/Standard_Storable.hxx” 1
# 46 “/usr/include/opencascade/Standard_Storable.hxx”
Handle_Standard_Type& Standard_Storable_Type_();
# 57 “/usr/include/opencascade/Standard_Storable.hxx”
class Standard_Storable {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~Standard_Storable(){Delete();}

virtual Standard_Integer HashCode(const Standard_Integer Upper) const;

Standard_Boolean IsEqual(const Standard_Storable& Other) const;
Standard_Boolean operator ==(const Standard_Storable& Other) const
{
return IsEqual(Other);
}

Standard_Boolean IsSimilar(const Standard_Storable& Other) const;

virtual void ShallowDump(ostream& S) const;

friend Handle_Standard_Type& Standard_Storable_Type_();

protected:
# 120 “/usr/include/opencascade/Standard_Storable.hxx”
private:
# 130 “/usr/include/opencascade/Standard_Storable.hxx”
};

inline Standard_Integer HashCode(const Standard_Storable& me,const Standard_Integer Upper) {
return me.HashCode(Upper);
}

inline Standard_Boolean IsSimilar(const Standard_Storable& me,const Standard_Storable& Other) {
return me.IsSimilar(Other);
}

inline void ShallowDump(const Standard_Storable& me,ostream& S) {
me.ShallowDump(S);
}
# 42 “/usr/include/opencascade/Standard_PrimitiveTypes.hxx” 2

Standard_Address ShallowCopy(const Standard_Address,
const Handle_Standard_Type& );

Standard_Integer HashCode(const Standard_Address,
const Standard_Integer,
const Handle_Standard_Type&);
class Standard_Stream;
void ShallowDump(const Standard_Address,
const Handle_Standard_Type&,
Standard_Stream &aOut);
# 11 “/usr/include/opencascade/Handle_Standard_Transient.hxx” 2

# 1 “/usr/include/opencascade/Standard_Transient_proto.hxx” 1
# 16 “/usr/include/opencascade/Standard_Transient_proto.hxx”
class Handle_Standard_Transient;
class Standard_Type;
class Handle_Standard_Type;
class Standard_Type;

class Handle_Standard_Transient;
Handle_Standard_Type& Standard_Transient_Type_();

class Standard_Transient
{

friend Handle_Standard_Type& Standard_Transient_Type_();
friend class Handle_Standard_Transient;

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}

void* operator new(size_t size)
{
return Standard::Allocate(size);
}

void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

Standard_Transient() : count(0) {}

Standard_Transient(const Standard_Transient&) : count(0) {}

Standard_Transient& operator= (const Standard_Transient&) { return *this; }

virtual ~Standard_Transient();

virtual void Delete() const;

virtual Standard_Integer HashCode(const Standard_Integer Upper) const;

virtual void ShallowDump(ostream& ) const;

virtual const Handle_Standard_Type& DynamicType() const;

Standard_Boolean IsInstance(const Handle_Standard_Type& theType) const;

Standard_Boolean IsInstance(const Standard_CString& theTypeName) const;

Standard_Boolean IsKind(const Handle_Standard_Type& theType) const;

Standard_Boolean IsKind(const Standard_CString& theTypeName) const;

virtual Handle_Standard_Transient This() const;

Standard_Integer GetRefCount() const { return count; }

private:

Standard_Integer count;
};
# 14 “/usr/include/opencascade/Handle_Standard_Transient.hxx” 2
# 30 “/usr/include/opencascade/Handle_Standard_Transient.hxx”
class Handle_Standard_Transient;

Standard_Integer HashCode(const Handle_Standard_Transient& ,const Standard_Integer);
# 43 “/usr/include/opencascade/Handle_Standard_Transient.hxx”
class Handle_Standard_Transient
{
public:

Handle_Standard_Transient ()
: entity(((Standard_Transient *)0xfefd0000))
{
}

Handle_Standard_Transient (const Standard_Transient *anItem)
: entity ( anItem ? (Standard_Transient*)anItem : ((Standard_Transient *)0xfefd0000) )
{
BeginScope();
}

Handle_Standard_Transient (const Handle_Standard_Transient& aTid)
: entity ( aTid.entity )
{
BeginScope();
}

~Handle_Standard_Transient()
{
EndScope();
}

Handle_Standard_Transient& operator=(const Handle_Standard_Transient& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_Transient& operator=(const Standard_Transient* anItem)
{
Assign(anItem);
return *this;
}

void Nullify()
{
EndScope();
}

Standard_Boolean IsNull() const
{
return entity == ((Standard_Transient *)0xfefd0000);
}

Standard_Transient* Access()
{
return entity;
}

const Standard_Transient* Access() const
{
return entity;
}

operator Standard_Transient*()
{
return entity;
}

operator const Standard_Transient*() const
{
return entity;
}

Standard_Transient* operator->() const
{
return entity;
}

Standard_Transient& operator*()
{
return *entity;
}

const Standard_Transient& operator*() const
{
return *entity;
}

int operator==(const Handle_Standard_Transient& right) const
{
return entity == right.entity;
}

int operator==(const Standard_Transient *right) const
{
return entity == right;
}

friend int operator==(const Standard_Transient *left, const Handle_Standard_Transient& right)
{
return left == right.entity;
}

int operator!=(const Handle_Standard_Transient& right) const
{
return entity != right.entity;
}

int operator!=(const Standard_Transient *right) const
{
return entity != right;
}

friend int operator!=(const Standard_Transient *left, const Handle_Standard_Transient& right)
{
return left != right.entity;
}

static const Handle_Standard_Transient DownCast(const Handle_Standard_Transient& AnObject);

void Dump(ostream& out) const;

protected:

Standard_Transient* ControlAccess() const
{
return entity;
}

void Assign (const Standard_Transient *anItem);

private:

inline void BeginScope() const
{
if (entity != ((Standard_Transient *)0xfefd0000))
entity->count++;
}

void EndScope();

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress, size_t )
{
if (anAddress) Standard::Free(anAddress);
}

private:

Standard_Transient *entity;
};
# 34 “/usr/include/opencascade/Handle_MMgt_TShared.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Transient;
class MMgt_TShared;
Handle_Standard_Type& MMgt_TShared_Type_();

class Handle_MMgt_TShared : public Handle_Standard_Transient {
public:
Handle_MMgt_TShared():Handle_Standard_Transient() {}
Handle_MMgt_TShared(const Handle_MMgt_TShared& aHandle) : Handle_Standard_Transient(aHandle)
{
}

Handle_MMgt_TShared(const MMgt_TShared* anItem) : Handle_Standard_Transient((Standard_Transient *)anItem)
{
}

Handle_MMgt_TShared& operator=(const Handle_MMgt_TShared& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_MMgt_TShared& operator=(const MMgt_TShared* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

MMgt_TShared* operator->() const
{
return (MMgt_TShared *)ControlAccess();
}

static const Handle_MMgt_TShared DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Geom_Geometry.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Geom_Geometry;
Handle_Standard_Type& Geom_Geometry_Type_();

class Handle_Geom_Geometry : public Handle_MMgt_TShared {
public:
Handle_Geom_Geometry():Handle_MMgt_TShared() {}
Handle_Geom_Geometry(const Handle_Geom_Geometry& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Geom_Geometry(const Geom_Geometry* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Geom_Geometry& operator=(const Handle_Geom_Geometry& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_Geometry& operator=(const Geom_Geometry* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_Geometry* operator->() const
{
return (Geom_Geometry *)ControlAccess();
}

static const Handle_Geom_Geometry DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Geom_Surface.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom_Geometry;
class Geom_Surface;
Handle_Standard_Type& Geom_Surface_Type_();

class Handle_Geom_Surface : public Handle_Geom_Geometry {
public:
Handle_Geom_Surface():Handle_Geom_Geometry() {}
Handle_Geom_Surface(const Handle_Geom_Surface& aHandle) : Handle_Geom_Geometry(aHandle)
{
}

Handle_Geom_Surface(const Geom_Surface* anItem) : Handle_Geom_Geometry((Geom_Geometry *)anItem)
{
}

Handle_Geom_Surface& operator=(const Handle_Geom_Surface& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_Surface& operator=(const Geom_Surface* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_Surface* operator->() const
{
return (Geom_Surface *)ControlAccess();
}

static const Handle_Geom_Surface DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_Triangulation.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_Triangulation.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_Triangulation;
Handle_Standard_Type& Poly_Triangulation_Type_();

class Handle_Poly_Triangulation : public Handle_MMgt_TShared {
public:
Handle_Poly_Triangulation():Handle_MMgt_TShared() {}
Handle_Poly_Triangulation(const Handle_Poly_Triangulation& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_Triangulation(const Poly_Triangulation* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_Triangulation& operator=(const Handle_Poly_Triangulation& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_Triangulation& operator=(const Poly_Triangulation* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_Triangulation* operator->() const
{
return (Poly_Triangulation *)ControlAccess();
}

static const Handle_Poly_Triangulation DownCast(const Handle_Standard_Transient& AnObject);
};
# 33 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom_Curve.hxx” 1
# 36 “/usr/include/opencascade/Handle_Geom_Curve.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom_Geometry;
class Geom_Curve;
Handle_Standard_Type& Geom_Curve_Type_();

class Handle_Geom_Curve : public Handle_Geom_Geometry {
public:
Handle_Geom_Curve():Handle_Geom_Geometry() {}
Handle_Geom_Curve(const Handle_Geom_Curve& aHandle) : Handle_Geom_Geometry(aHandle)
{
}

Handle_Geom_Curve(const Geom_Curve* anItem) : Handle_Geom_Geometry((Geom_Geometry *)anItem)
{
}

Handle_Geom_Curve& operator=(const Handle_Geom_Curve& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom_Curve& operator=(const Geom_Curve* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom_Curve* operator->() const
{
return (Geom_Curve *)ControlAccess();
}

static const Handle_Geom_Curve DownCast(const Handle_Standard_Transient& AnObject);
};
# 39 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_Polygon3D.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_Polygon3D.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_Polygon3D;
Handle_Standard_Type& Poly_Polygon3D_Type_();

class Handle_Poly_Polygon3D : public Handle_MMgt_TShared {
public:
Handle_Poly_Polygon3D():Handle_MMgt_TShared() {}
Handle_Poly_Polygon3D(const Handle_Poly_Polygon3D& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_Polygon3D(const Poly_Polygon3D* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_Polygon3D& operator=(const Handle_Poly_Polygon3D& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_Polygon3D& operator=(const Poly_Polygon3D* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_Polygon3D* operator->() const
{
return (Poly_Polygon3D *)ControlAccess();
}

static const Handle_Poly_Polygon3D DownCast(const Handle_Standard_Transient& AnObject);
};
# 42 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Geom2d_Curve.hxx” 1
# 33 “/usr/include/opencascade/Handle_Geom2d_Curve.hxx”
# 1 “/usr/include/opencascade/Handle_Geom2d_Geometry.hxx” 1
# 36 “/usr/include/opencascade/Handle_Geom2d_Geometry.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Geom2d_Geometry;
Handle_Standard_Type& Geom2d_Geometry_Type_();

class Handle_Geom2d_Geometry : public Handle_MMgt_TShared {
public:
Handle_Geom2d_Geometry():Handle_MMgt_TShared() {}
Handle_Geom2d_Geometry(const Handle_Geom2d_Geometry& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Geom2d_Geometry(const Geom2d_Geometry* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Geom2d_Geometry& operator=(const Handle_Geom2d_Geometry& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom2d_Geometry& operator=(const Geom2d_Geometry* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom2d_Geometry* operator->() const
{
return (Geom2d_Geometry *)ControlAccess();
}

static const Handle_Geom2d_Geometry DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Geom2d_Curve.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Geom2d_Geometry;
class Geom2d_Curve;
Handle_Standard_Type& Geom2d_Curve_Type_();

class Handle_Geom2d_Curve : public Handle_Geom2d_Geometry {
public:
Handle_Geom2d_Curve():Handle_Geom2d_Geometry() {}
Handle_Geom2d_Curve(const Handle_Geom2d_Curve& aHandle) : Handle_Geom2d_Geometry(aHandle)
{
}

Handle_Geom2d_Curve(const Geom2d_Curve* anItem) : Handle_Geom2d_Geometry((Geom2d_Geometry *)anItem)
{
}

Handle_Geom2d_Curve& operator=(const Handle_Geom2d_Curve& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Geom2d_Curve& operator=(const Geom2d_Curve* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Geom2d_Curve* operator->() const
{
return (Geom2d_Curve *)ControlAccess();
}

static const Handle_Geom2d_Curve DownCast(const Handle_Standard_Transient& AnObject);
};
# 45 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_Polygon2D.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_Polygon2D.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_Polygon2D;
Handle_Standard_Type& Poly_Polygon2D_Type_();

class Handle_Poly_Polygon2D : public Handle_MMgt_TShared {
public:
Handle_Poly_Polygon2D():Handle_MMgt_TShared() {}
Handle_Poly_Polygon2D(const Handle_Poly_Polygon2D& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_Polygon2D(const Poly_Polygon2D* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_Polygon2D& operator=(const Handle_Poly_Polygon2D& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_Polygon2D& operator=(const Poly_Polygon2D* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_Polygon2D* operator->() const
{
return (Poly_Polygon2D *)ControlAccess();
}

static const Handle_Poly_Polygon2D DownCast(const Handle_Standard_Transient& AnObject);
};
# 51 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/Handle_Poly_PolygonOnTriangulation.hxx” 1
# 36 “/usr/include/opencascade/Handle_Poly_PolygonOnTriangulation.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class Poly_PolygonOnTriangulation;
Handle_Standard_Type& Poly_PolygonOnTriangulation_Type_();

class Handle_Poly_PolygonOnTriangulation : public Handle_MMgt_TShared {
public:
Handle_Poly_PolygonOnTriangulation():Handle_MMgt_TShared() {}
Handle_Poly_PolygonOnTriangulation(const Handle_Poly_PolygonOnTriangulation& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_Poly_PolygonOnTriangulation(const Poly_PolygonOnTriangulation* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_Poly_PolygonOnTriangulation& operator=(const Handle_Poly_PolygonOnTriangulation& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Poly_PolygonOnTriangulation& operator=(const Poly_PolygonOnTriangulation* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Poly_PolygonOnTriangulation* operator->() const
{
return (Poly_PolygonOnTriangulation *)ControlAccess();
}

static const Handle_Poly_PolygonOnTriangulation DownCast(const Handle_Standard_Transient& AnObject);
};
# 54 “/usr/include/opencascade/BRep_Tool.hxx” 2

# 1 “/usr/include/opencascade/GeomAbs_Shape.hxx” 1
# 26 “/usr/include/opencascade/GeomAbs_Shape.hxx”
enum GeomAbs_Shape {
GeomAbs_C0,
GeomAbs_G1,
GeomAbs_C1,
GeomAbs_G2,
GeomAbs_C2,
GeomAbs_C3,
GeomAbs_CN
};
# 57 “/usr/include/opencascade/BRep_Tool.hxx” 2

class Standard_NullObject;
class Standard_NoSuchObject;
class TopoDS_Shape;
class Geom_Surface;
class TopoDS_Face;
class TopLoc_Location;
class Poly_Triangulation;
class TopoDS_Edge;
class Geom_Curve;
class Poly_Polygon3D;
class Geom2d_Curve;
class Poly_Polygon2D;
class Poly_PolygonOnTriangulation;
class gp_Pnt2d;
class Bnd_Box2d;
class gp_Pnt;
class TopoDS_Vertex;
# 86 “/usr/include/opencascade/BRep_Tool.hxx”
class BRep_Tool {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

static Standard_Boolean IsClosed(const TopoDS_Shape& S) ;

static const Handle_Geom_Surface& Surface(const TopoDS_Face& F,TopLoc_Location& L) ;

static Handle_Geom_Surface Surface(const TopoDS_Face& F) ;

static const Handle_Poly_Triangulation& Triangulation(const TopoDS_Face& F,TopLoc_Location& L) ;

static Standard_Real Tolerance(const TopoDS_Face& F) ;

static Standard_Boolean NaturalRestriction(const TopoDS_Face& F) ;

static Standard_Boolean IsGeometric(const TopoDS_Edge& E) ;

static const Handle_Geom_Curve& Curve(const TopoDS_Edge& E,TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static Handle_Geom_Curve Curve(const TopoDS_Edge& E,Standard_Real& First,Standard_Real& Last) ;

static const Handle_Poly_Polygon3D& Polygon3D(const TopoDS_Edge& E,TopLoc_Location& L) ;

static Handle_Geom2d_Curve CurveOnSurface(const TopoDS_Edge& E,const TopoDS_Face& F,Standard_Real& First,Standard_Real& Last) ;

static Handle_Geom2d_Curve CurveOnSurface(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static void CurveOnSurface(const TopoDS_Edge& E,Handle_Geom2d_Curve& C,Handle_Geom_Surface& S,TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static void CurveOnSurface(const TopoDS_Edge& E,Handle_Geom2d_Curve& C,Handle_Geom_Surface& S,TopLoc_Location& L,Standard_Real& First,Standard_Real& Last,const Standard_Integer Index) ;

static Handle_Poly_Polygon2D PolygonOnSurface(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Handle_Poly_Polygon2D PolygonOnSurface(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static void PolygonOnSurface(const TopoDS_Edge& E,Handle_Poly_Polygon2D& C,Handle_Geom_Surface& S,TopLoc_Location& L) ;

static void PolygonOnSurface(const TopoDS_Edge& E,Handle_Poly_Polygon2D& C,Handle_Geom_Surface& S,TopLoc_Location& L,const Standard_Integer Index) ;

static const Handle_Poly_PolygonOnTriangulation& PolygonOnTriangulation(const TopoDS_Edge& E,const Handle_Poly_Triangulation& T,const TopLoc_Location& L) ;

static void PolygonOnTriangulation(const TopoDS_Edge& E,Handle_Poly_PolygonOnTriangulation& P,Handle_Poly_Triangulation& T,TopLoc_Location& L) ;

static void PolygonOnTriangulation(const TopoDS_Edge& E,Handle_Poly_PolygonOnTriangulation& P,Handle_Poly_Triangulation& T,TopLoc_Location& L,const Standard_Integer Index) ;

static Standard_Boolean IsClosed(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Standard_Boolean IsClosed(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static Standard_Boolean IsClosed(const TopoDS_Edge& E,const Handle_Poly_Triangulation& T) ;

static Standard_Real Tolerance(const TopoDS_Edge& E) ;

static Standard_Boolean SameParameter(const TopoDS_Edge& E) ;

static Standard_Boolean SameRange(const TopoDS_Edge& E) ;

static Standard_Boolean Degenerated(const TopoDS_Edge& E) ;

static void Range(const TopoDS_Edge& E,Standard_Real& First,Standard_Real& Last) ;

static void Range(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,Standard_Real& First,Standard_Real& Last) ;

static void Range(const TopoDS_Edge& E,const TopoDS_Face& F,Standard_Real& First,Standard_Real& Last) ;

static void UVPoints(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,gp_Pnt2d& PFirst,gp_Pnt2d& PLast) ;

static void UVPoints(const TopoDS_Edge& E,const TopoDS_Face& F,gp_Pnt2d& PFirst,gp_Pnt2d& PLast) ;

static void SetUVPoints(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L,const gp_Pnt2d& PFirst,const gp_Pnt2d& PLast) ;

static void SetUVPoints(const TopoDS_Edge& E,const TopoDS_Face& F,const gp_Pnt2d& PFirst,const gp_Pnt2d& PLast) ;

static const Bnd_Box2d& UVBox(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static const Bnd_Box2d& UVBox(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Bnd_Box2d& ChangeUVBox(const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static Bnd_Box2d& ChangeUVBox(const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Standard_Boolean HasContinuity(const TopoDS_Edge& E,const TopoDS_Face& F1,const TopoDS_Face& F2) ;

static GeomAbs_Shape Continuity(const TopoDS_Edge& E,const TopoDS_Face& F1,const TopoDS_Face& F2) ;

static Standard_Boolean HasContinuity(const TopoDS_Edge& E,const Handle_Geom_Surface& S1,const Handle_Geom_Surface& S2,const TopLoc_Location& L1,const TopLoc_Location& L2) ;

static GeomAbs_Shape Continuity(const TopoDS_Edge& E,const Handle_Geom_Surface& S1,const Handle_Geom_Surface& S2,const TopLoc_Location& L1,const TopLoc_Location& L2) ;

static gp_Pnt Pnt(const TopoDS_Vertex& V) ;

static Standard_Real Tolerance(const TopoDS_Vertex& V) ;

static Standard_Real Parameter(const TopoDS_Vertex& V,const TopoDS_Edge& E) ;

static Standard_Real Parameter(const TopoDS_Vertex& V,const TopoDS_Edge& E,const TopoDS_Face& F) ;

static Standard_Real Parameter(const TopoDS_Vertex& V,const TopoDS_Edge& E,const Handle_Geom_Surface& S,const TopLoc_Location& L) ;

static gp_Pnt2d Parameters(const TopoDS_Vertex& V,const TopoDS_Face& F) ;

protected:
# 323 “/usr/include/opencascade/BRep_Tool.hxx”
private:
# 333 “/usr/include/opencascade/BRep_Tool.hxx”
};
# 2 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx” 1
# 26 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
# 1 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 1
# 26 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
# 1 “/usr/include/opencascade/TopoDS_Shape.hxx” 1
# 26 “/usr/include/opencascade/TopoDS_Shape.hxx”
# 1 “/usr/include/opencascade/Handle_TopoDS_TShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopoDS_TShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopoDS_TShape;
Handle_Standard_Type& TopoDS_TShape_Type_();

class Handle_TopoDS_TShape : public Handle_MMgt_TShared {
public:
Handle_TopoDS_TShape():Handle_MMgt_TShared() {}
Handle_TopoDS_TShape(const Handle_TopoDS_TShape& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopoDS_TShape(const TopoDS_TShape* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopoDS_TShape& operator=(const Handle_TopoDS_TShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopoDS_TShape& operator=(const TopoDS_TShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopoDS_TShape* operator->() const
{
return (TopoDS_TShape *)ControlAccess();
}

static const Handle_TopoDS_TShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 27 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

# 1 “/usr/include/opencascade/TopLoc_Location.hxx” 1
# 26 “/usr/include/opencascade/TopLoc_Location.hxx”
# 1 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx” 1
# 26 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
# 1 “/usr/include/opencascade/Handle_TopLoc_SListNodeOfSListOfItemLocation.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopLoc_SListNodeOfSListOfItemLocation.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopLoc_SListNodeOfSListOfItemLocation;
Handle_Standard_Type& TopLoc_SListNodeOfSListOfItemLocation_Type_();

class Handle_TopLoc_SListNodeOfSListOfItemLocation : public Handle_MMgt_TShared {
public:
Handle_TopLoc_SListNodeOfSListOfItemLocation():Handle_MMgt_TShared() {}
Handle_TopLoc_SListNodeOfSListOfItemLocation(const Handle_TopLoc_SListNodeOfSListOfItemLocation& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopLoc_SListNodeOfSListOfItemLocation(const TopLoc_SListNodeOfSListOfItemLocation* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopLoc_SListNodeOfSListOfItemLocation& operator=(const Handle_TopLoc_SListNodeOfSListOfItemLocation& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopLoc_SListNodeOfSListOfItemLocation& operator=(const TopLoc_SListNodeOfSListOfItemLocation* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopLoc_SListNodeOfSListOfItemLocation* operator->() const
{
return (TopLoc_SListNodeOfSListOfItemLocation *)ControlAccess();
}

static const Handle_TopLoc_SListNodeOfSListOfItemLocation DownCast(const Handle_Standard_Transient& AnObject);
};
# 27 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx” 2

class TopLoc_SListNodeOfSListOfItemLocation;
class Standard_NoSuchObject;
class TopLoc_ItemLocation;
# 44 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
class TopLoc_SListOfItemLocation {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopLoc_SListOfItemLocation();

TopLoc_SListOfItemLocation(const TopLoc_ItemLocation& anItem,const TopLoc_SListOfItemLocation& aTail);

TopLoc_SListOfItemLocation(const TopLoc_SListOfItemLocation& Other);

TopLoc_SListOfItemLocation& Assign(const TopLoc_SListOfItemLocation& Other) ;
TopLoc_SListOfItemLocation& operator =(const TopLoc_SListOfItemLocation& Other)
{
return Assign(Other);
}

Standard_Boolean IsEmpty() const;

void Clear() ;
~TopLoc_SListOfItemLocation()
{
Clear();
}

const TopLoc_ItemLocation& Value() const;

TopLoc_ItemLocation& ChangeValue() ;

void SetValue(const TopLoc_ItemLocation& anItem) ;

const TopLoc_SListOfItemLocation& Tail() const;

TopLoc_SListOfItemLocation& ChangeTail() ;

void SetTail(const TopLoc_SListOfItemLocation& aList) ;

void Construct(const TopLoc_ItemLocation& anItem) ;

TopLoc_SListOfItemLocation Constructed(const TopLoc_ItemLocation& anItem) const;

void ToTail() ;

void Initialize(const TopLoc_SListOfItemLocation& aList) ;

Standard_Boolean More() const;

void Next() ;

protected:
# 134 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
private:

Handle_TopLoc_SListNodeOfSListOfItemLocation myNode;

};
# 156 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx”
# 1 “/usr/include/opencascade/TCollection_SList.lxx” 1
# 12 “/usr/include/opencascade/TCollection_SList.lxx”
inline Standard_Boolean TopLoc_SListOfItemLocation::IsEmpty() const
{
return myNode.IsNull();
}
# 27 “/usr/include/opencascade/TCollection_SList.lxx”
inline void TopLoc_SListOfItemLocation::Construct(const TopLoc_ItemLocation& anItem)
{
Assign(TopLoc_SListOfItemLocation(anItem,*this));
}

inline TopLoc_SListOfItemLocation TopLoc_SListOfItemLocation::Constructed(const TopLoc_ItemLocation& anItem) const
{
return TopLoc_SListOfItemLocation(anItem,*this);
}

inline void TopLoc_SListOfItemLocation::ToTail()
{
Assign(Tail());
}

inline void TopLoc_SListOfItemLocation::Initialize(const TopLoc_SListOfItemLocation& aList)
{
Assign(aList);
}

inline Standard_Boolean TopLoc_SListOfItemLocation::More() const
{
return !IsEmpty();
}

inline void TopLoc_SListOfItemLocation::Next()
{
ToTail();
}
# 157 “/usr/include/opencascade/TopLoc_SListOfItemLocation.hxx” 2
# 27 “/usr/include/opencascade/TopLoc_Location.hxx” 2

# 1 “/usr/include/opencascade/Handle_TopLoc_Datum3D.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopLoc_Datum3D.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TopLoc_Datum3D;
Handle_Standard_Type& TopLoc_Datum3D_Type_();

class Handle_TopLoc_Datum3D : public Handle_MMgt_TShared {
public:
Handle_TopLoc_Datum3D():Handle_MMgt_TShared() {}
Handle_TopLoc_Datum3D(const Handle_TopLoc_Datum3D& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TopLoc_Datum3D(const TopLoc_Datum3D* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TopLoc_Datum3D& operator=(const Handle_TopLoc_Datum3D& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopLoc_Datum3D& operator=(const TopLoc_Datum3D* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopLoc_Datum3D* operator->() const
{
return (TopLoc_Datum3D *)ControlAccess();
}

static const Handle_TopLoc_Datum3D DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopLoc_Location.hxx” 2
# 40 “/usr/include/opencascade/TopLoc_Location.hxx”
class Standard_NoSuchObject;
class Standard_ConstructionError;
class gp_Trsf;
class TopLoc_Datum3D;
# 57 “/usr/include/opencascade/TopLoc_Location.hxx”
class TopLoc_Location {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopLoc_Location();

TopLoc_Location(const gp_Trsf& T);

TopLoc_Location(const Handle_TopLoc_Datum3D& D);

Standard_Boolean IsIdentity() const;

void Identity() ;

const Handle_TopLoc_Datum3D& FirstDatum() const;

Standard_Integer FirstPower() const;

const TopLoc_Location& NextLocation() const;

const gp_Trsf& Transformation() const;
operator gp_Trsf() const;

TopLoc_Location Inverted() const;

TopLoc_Location Multiplied(const TopLoc_Location& Other) const;
TopLoc_Location operator*(const TopLoc_Location& Other) const
{
return Multiplied(Other);
}

TopLoc_Location Divided(const TopLoc_Location& Other) const;
TopLoc_Location operator/(const TopLoc_Location& Other) const
{
return Divided(Other);
}

TopLoc_Location Predivided(const TopLoc_Location& Other) const;

TopLoc_Location Powered(const Standard_Integer pwr) const;

Standard_Integer HashCode(const Standard_Integer Upper) const;

Standard_Boolean IsEqual(const TopLoc_Location& Other) const;
Standard_Boolean operator ==(const TopLoc_Location& Other) const
{
return IsEqual(Other);
}

Standard_Boolean IsDifferent(const TopLoc_Location& Other) const;
Standard_Boolean operator !=(const TopLoc_Location& Other) const
{
return IsDifferent(Other);
}

void ShallowDump(ostream& S) const;

protected:
# 194 “/usr/include/opencascade/TopLoc_Location.hxx”
private:

TopLoc_SListOfItemLocation myItems;

};

# 1 “/usr/include/opencascade/TopLoc_Location.lxx” 1

# 1 “/usr/include/opencascade/TopLoc_ItemLocation.hxx” 1
# 32 “/usr/include/opencascade/TopLoc_ItemLocation.hxx”
# 1 “/usr/include/opencascade/TopLoc_TrsfPtr.hxx” 1
# 25 “/usr/include/opencascade/TopLoc_TrsfPtr.hxx”
class gp_Trsf;

typedef gp_Trsf* TopLoc_TrsfPtr;
# 33 “/usr/include/opencascade/TopLoc_ItemLocation.hxx” 2

class TopLoc_Datum3D;
class TopLoc_Location;
# 59 “/usr/include/opencascade/TopLoc_ItemLocation.hxx”
class TopLoc_ItemLocation {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopLoc_ItemLocation(const Handle_TopLoc_Datum3D& D,const Standard_Integer P,const Standard_Boolean fromTrsf = (Standard_Boolean) 0);

TopLoc_ItemLocation(const TopLoc_ItemLocation& anOther);

TopLoc_ItemLocation& Assign(const TopLoc_ItemLocation& anOther) ;
TopLoc_ItemLocation& operator=(const TopLoc_ItemLocation& anOther)
{
return Assign(anOther);
}

void Destroy() ;
~TopLoc_ItemLocation()
{
Destroy();
}

friend class TopLoc_Location;

protected:
# 116 “/usr/include/opencascade/TopLoc_ItemLocation.hxx”
private:

Handle_TopLoc_Datum3D myDatum;
Standard_Integer myPower;
TopLoc_TrsfPtr myTrsf;

};
# 9 “/usr/include/opencascade/TopLoc_Location.lxx” 2

inline Standard_Boolean TopLoc_Location::IsIdentity() const
{
return myItems.IsEmpty();
}

inline void TopLoc_Location::Identity()
{
myItems.Clear();
}

inline const Handle_TopLoc_Datum3D& TopLoc_Location::FirstDatum()const
{
return myItems.Value().myDatum;
}

inline Standard_Integer TopLoc_Location::FirstPower()const
{
return myItems.Value().myPower;
}

inline const TopLoc_Location& TopLoc_Location::NextLocation()const
{
return (*(TopLoc_Location*) &(myItems.Tail()));
}
# 209 “/usr/include/opencascade/TopLoc_Location.hxx” 2

inline Standard_Integer HashCode(const TopLoc_Location& me,const Standard_Integer Upper) {
return me.HashCode(Upper);
}

inline void ShallowDump(const TopLoc_Location& me,ostream& S) {
me.ShallowDump(S);
}
# 30 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

# 1 “/usr/include/opencascade/TopAbs_Orientation.hxx” 1
# 45 “/usr/include/opencascade/TopAbs_Orientation.hxx”
enum TopAbs_Orientation {
TopAbs_FORWARD,
TopAbs_REVERSED,
TopAbs_INTERNAL,
TopAbs_EXTERNAL
};
# 33 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

# 1 “/usr/include/opencascade/TopAbs_ShapeEnum.hxx” 1
# 65 “/usr/include/opencascade/TopAbs_ShapeEnum.hxx”
enum TopAbs_ShapeEnum {
TopAbs_COMPOUND,
TopAbs_COMPSOLID,
TopAbs_SOLID,
TopAbs_SHELL,
TopAbs_FACE,
TopAbs_WIRE,
TopAbs_EDGE,
TopAbs_VERTEX,
TopAbs_SHAPE
};
# 39 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

class TopoDS_TShape;
class Standard_NullObject;
class Standard_DomainError;
class Standard_TypeMismatch;
class TopLoc_Location;
# 67 “/usr/include/opencascade/TopoDS_Shape.hxx”
class TopoDS_Shape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_Shape();

Standard_Boolean IsNull() const;

void Nullify() ;

const TopLoc_Location& Location() const;

void Location(const TopLoc_Location& Loc) ;

TopoDS_Shape Located(const TopLoc_Location& Loc) const;

TopAbs_Orientation Orientation() const;

void Orientation(const TopAbs_Orientation Orient) ;

TopoDS_Shape Oriented(const TopAbs_Orientation Or) const;

const Handle_TopoDS_TShape& TShape() const;

TopAbs_ShapeEnum ShapeType() const;

Standard_Boolean Free() const;

void Free(const Standard_Boolean F) ;

Standard_Boolean Modified() const;

void Modified(const Standard_Boolean M) ;

Standard_Boolean Checked() const;

void Checked(const Standard_Boolean C) ;

Standard_Boolean Orientable() const;

void Orientable(const Standard_Boolean C) ;

Standard_Boolean Closed() const;

void Closed(const Standard_Boolean C) ;

Standard_Boolean Infinite() const;

void Infinite(const Standard_Boolean C) ;

Standard_Boolean Convex() const;

void Convex(const Standard_Boolean C) ;

void Move(const TopLoc_Location& position) ;

TopoDS_Shape Moved(const TopLoc_Location& position) const;

void Reverse() ;

TopoDS_Shape Reversed() const;

void Complement() ;

TopoDS_Shape Complemented() const;

void Compose(const TopAbs_Orientation Orient) ;

TopoDS_Shape Composed(const TopAbs_Orientation Orient) const;

Standard_Boolean IsPartner(const TopoDS_Shape& other) const;

Standard_Boolean IsSame(const TopoDS_Shape& other) const;

Standard_Boolean IsEqual(const TopoDS_Shape& other) const;
Standard_Boolean operator ==(const TopoDS_Shape& other) const
{
return IsEqual(other);
}

Standard_Boolean IsNotEqual(const TopoDS_Shape& other) const;
Standard_Boolean operator !=(const TopoDS_Shape& other) const
{
return IsNotEqual(other);
}

Standard_Integer HashCode(const Standard_Integer Upper) const;

void EmptyCopy() ;

TopoDS_Shape EmptyCopied() const;

void TShape(const Handle_TopoDS_TShape& T) ;

protected:
# 261 “/usr/include/opencascade/TopoDS_Shape.hxx”
private:

Handle_TopoDS_TShape myTShape;
TopLoc_Location myLocation;
TopAbs_Orientation myOrient;

};

# 1 “/usr/include/opencascade/TopoDS_Shape.lxx” 1

# 1 “/usr/include/opencascade/TopoDS_TShape.hxx” 1
# 34 “/usr/include/opencascade/TopoDS_TShape.hxx”
# 1 “/usr/include/opencascade/TopoDS_ListOfShape.hxx” 1
# 29 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TopoDS_ListNodeOfListOfShape.hxx” 1
# 33 “/usr/include/opencascade/Handle_TopoDS_ListNodeOfListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TCollection_MapNode.hxx” 1
# 36 “/usr/include/opencascade/Handle_TCollection_MapNode.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class TCollection_MapNode;
Handle_Standard_Type& TCollection_MapNode_Type_();

class Handle_TCollection_MapNode : public Handle_MMgt_TShared {
public:
Handle_TCollection_MapNode():Handle_MMgt_TShared() {}
Handle_TCollection_MapNode(const Handle_TCollection_MapNode& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_TCollection_MapNode(const TCollection_MapNode* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_TCollection_MapNode& operator=(const Handle_TCollection_MapNode& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TCollection_MapNode& operator=(const TCollection_MapNode* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TCollection_MapNode* operator->() const
{
return (TCollection_MapNode *)ControlAccess();
}

static const Handle_TCollection_MapNode DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_TopoDS_ListNodeOfListOfShape.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopoDS_ListNodeOfListOfShape;
Handle_Standard_Type& TopoDS_ListNodeOfListOfShape_Type_();

class Handle_TopoDS_ListNodeOfListOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopoDS_ListNodeOfListOfShape():Handle_TCollection_MapNode() {}
Handle_TopoDS_ListNodeOfListOfShape(const Handle_TopoDS_ListNodeOfListOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopoDS_ListNodeOfListOfShape(const TopoDS_ListNodeOfListOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopoDS_ListNodeOfListOfShape& operator=(const Handle_TopoDS_ListNodeOfListOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopoDS_ListNodeOfListOfShape& operator=(const TopoDS_ListNodeOfListOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopoDS_ListNodeOfListOfShape* operator->() const
{
return (TopoDS_ListNodeOfListOfShape *)ControlAccess();
}

static const Handle_TopoDS_ListNodeOfListOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopoDS_ListOfShape.hxx” 2

class Standard_NoSuchObject;
class TopoDS_ListIteratorOfListOfShape;
class TopoDS_Shape;
class TopoDS_ListNodeOfListOfShape;
# 51 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
class TopoDS_ListOfShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_ListOfShape();

void Assign(const TopoDS_ListOfShape& Other) ;
void operator=(const TopoDS_ListOfShape& Other)
{
Assign(Other);
}

Standard_Integer Extent() const;

void Clear() ;
~TopoDS_ListOfShape()
{
Clear();
}

Standard_Boolean IsEmpty() const;

void Prepend(const TopoDS_Shape& I) ;

void Prepend(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& theIt) ;

void Prepend(TopoDS_ListOfShape& Other) ;

void Append(const TopoDS_Shape& I) ;

void Append(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& theIt) ;

void Append(TopoDS_ListOfShape& Other) ;

TopoDS_Shape& First() const;

TopoDS_Shape& Last() const;

void RemoveFirst() ;

void Remove(TopoDS_ListIteratorOfListOfShape& It) ;

void InsertBefore(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& It) ;

void InsertBefore(TopoDS_ListOfShape& Other,TopoDS_ListIteratorOfListOfShape& It) ;

void InsertAfter(const TopoDS_Shape& I,TopoDS_ListIteratorOfListOfShape& It) ;

void InsertAfter(TopoDS_ListOfShape& Other,TopoDS_ListIteratorOfListOfShape& It) ;

friend class TopoDS_ListIteratorOfListOfShape;

protected:
# 151 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
private:

TopoDS_ListOfShape(const TopoDS_ListOfShape& Other);

Standard_Address myFirst;
Standard_Address myLast;

};
# 179 “/usr/include/opencascade/TopoDS_ListOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_List.lxx” 1
# 12 “/usr/include/opencascade/TCollection_List.lxx”
inline Standard_Boolean TopoDS_ListOfShape::IsEmpty() const

{
return myFirst == 0L;
}
# 180 “/usr/include/opencascade/TopoDS_ListOfShape.hxx” 2
# 35 “/usr/include/opencascade/TopoDS_TShape.hxx” 2

# 1 “/usr/include/opencascade/MMgt_TShared.hxx” 1
# 34 “/usr/include/opencascade/MMgt_TShared.hxx”
# 1 “/usr/include/opencascade/Standard_Transient.hxx” 1
# 14 “/usr/include/opencascade/Standard_Transient.hxx”
# 1 “/usr/include/opencascade/Standard_Type.hxx” 1
# 30 “/usr/include/opencascade/Standard_Type.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_Type.hxx” 1
# 36 “/usr/include/opencascade/Handle_Standard_Type.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Transient;
class Standard_Type;
Handle_Standard_Type& Standard_Type_Type_();

class Handle_Standard_Type : public Handle_Standard_Transient {
public:
Handle_Standard_Type():Handle_Standard_Transient() {}
Handle_Standard_Type(const Handle_Standard_Type& aHandle) : Handle_Standard_Transient(aHandle)
{
}

Handle_Standard_Type(const Standard_Type* anItem) : Handle_Standard_Transient((Standard_Transient *)anItem)
{
}

Handle_Standard_Type& operator=(const Handle_Standard_Type& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_Type& operator=(const Standard_Type* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_Type* operator->() const
{
return (Standard_Type *)ControlAccess();
}

static const Handle_Standard_Type DownCast(const Handle_Standard_Transient& AnObject);
};
# 31 “/usr/include/opencascade/Standard_Type.hxx” 2
# 40 “/usr/include/opencascade/Standard_Type.hxx”
# 1 “/usr/include/opencascade/Standard_KindOfType.hxx” 1
# 26 “/usr/include/opencascade/Standard_KindOfType.hxx”
enum Standard_KindOfType {
Standard_IsUnKnown,
Standard_IsClass,
Standard_IsEnumeration,
Standard_IsPrimitive,
Standard_IsImported,
Standard_IsPackage
};
# 41 “/usr/include/opencascade/Standard_Type.hxx” 2
# 54 “/usr/include/opencascade/Standard_Type.hxx”
class Standard_TypeMismatch;
class Standard_NoSuchObject;
class Standard_OutOfRange;
class Standard_AncestorIterator;

class Standard_Type : public Standard_Transient {

public:

Standard_CString Name() const;

Standard_Integer Size() const;

Standard_Type(const Standard_CString aName,const Standard_Integer aSize);

Standard_Type(const Standard_CString aName);

Standard_Type(const Standard_CString aName,const Standard_Integer aSize,const Standard_Integer aNumberOfParent,const Standard_Address aAncestors);

Standard_Type(const Standard_CString aName,const Standard_Integer aSize,const Standard_Integer aNumberOfElement,const Standard_Integer aNumberOfParent,const Standard_Address anAncestors,const Standard_Address aElements);

Standard_Type(const Standard_CString aName,const Standard_Integer aSize,const Standard_Integer aNumberOfParent,const Standard_Address anAncestors,const Standard_Address aFields);

Standard_Boolean SubType(const Handle_Standard_Type& aOther) const;

Standard_Boolean SubType(const Standard_CString theName) const;

Standard_Boolean IsImported() const;

Standard_Boolean IsPrimitive() const;

Standard_Boolean IsEnumeration() const;

Standard_Boolean IsClass() const;

Standard_Integer NumberOfParent() const;

Standard_Integer NumberOfAncestor() const;

void ShallowDump() const;

void ShallowDump(ostream& S) const;
# 150 “/usr/include/opencascade/Standard_Type.hxx”
void Print(ostream& s) const;
void operator<<(ostream& s) const { Print(s); }

friend class Standard_AncestorIterator;

const Handle_Standard_Type& DynamicType() const;

protected:
# 173 “/usr/include/opencascade/Standard_Type.hxx”
private:

Standard_Address Ancestors() const;

void InLineDummy() const;

Standard_CString myName;
Standard_Integer mySize;
Standard_KindOfType myKind;
Standard_Integer myNumberOfParent;
Standard_Integer myNumberOfAncestor;
Standard_Address myAncestors;

};

# 1 “/usr/include/opencascade/Standard_Type.lxx” 1
# 9 “/usr/include/opencascade/Standard_Type.lxx”
inline void Standard_Type::InLineDummy() const
{
}

ostream& operator << (ostream& AStream
,const Handle_Standard_Type& AType);
# 202 “/usr/include/opencascade/Standard_Type.hxx” 2

inline void ShallowDump(const Handle_Standard_Type& me) {
me->ShallowDump();
}

inline void ShallowDump(const Handle_Standard_Type& me,ostream& S) {
me->ShallowDump(S);
}
# 15 “/usr/include/opencascade/Standard_Transient.hxx” 2
# 35 “/usr/include/opencascade/MMgt_TShared.hxx” 2

class Standard_OutOfMemory;
# 58 “/usr/include/opencascade/MMgt_TShared.hxx”
class MMgt_TShared : public Standard_Transient {

public:

virtual void Delete() const;

const Handle_Standard_Type& DynamicType() const;

protected:
# 86 “/usr/include/opencascade/MMgt_TShared.hxx”
private:
# 96 “/usr/include/opencascade/MMgt_TShared.hxx”
};
# 41 “/usr/include/opencascade/TopoDS_TShape.hxx” 2

class Standard_ConstructionError;
class TopoDS_Iterator;
class TopoDS_Builder;
class TopoDS_ListOfShape;
# 76 “/usr/include/opencascade/TopoDS_TShape.hxx”
class TopoDS_TShape : public MMgt_TShared {

public:

Standard_Boolean Free() const;

void Free(const Standard_Boolean F) ;

Standard_Boolean Modified() const;

void Modified(const Standard_Boolean M) ;

Standard_Boolean Checked() const;

void Checked(const Standard_Boolean C) ;

Standard_Boolean Orientable() const;

void Orientable(const Standard_Boolean C) ;

Standard_Boolean Closed() const;

void Closed(const Standard_Boolean C) ;

Standard_Boolean Infinite() const;

void Infinite(const Standard_Boolean C) ;

Standard_Boolean Convex() const;

void Convex(const Standard_Boolean C) ;

virtual TopAbs_ShapeEnum ShapeType() const = 0;

virtual Handle_TopoDS_TShape EmptyCopy() const = 0;

friend class TopoDS_Iterator;
friend class TopoDS_Builder;

const Handle_Standard_Type& DynamicType() const;

protected:
# 155 “/usr/include/opencascade/TopoDS_TShape.hxx”
TopoDS_TShape();

private:

const TopoDS_ListOfShape& Shapes() const;

TopoDS_ListOfShape& ChangeShapes() ;

TopoDS_ListOfShape myShapes;
Standard_Integer myFlags;

};

# 1 “/usr/include/opencascade/TopoDS_TShape.lxx” 1
# 11 “/usr/include/opencascade/TopoDS_TShape.lxx”
inline const TopoDS_ListOfShape& TopoDS_TShape::Shapes() const
{
return myShapes;
}

inline TopoDS_ListOfShape& TopoDS_TShape::ChangeShapes()
{
return myShapes;
}
# 182 “/usr/include/opencascade/TopoDS_TShape.hxx” 2
# 8 “/usr/include/opencascade/TopoDS_Shape.lxx” 2
# 1 “/usr/include/opencascade/TopAbs.hxx” 1
# 35 “/usr/include/opencascade/TopAbs.hxx”
# 1 “/usr/include/opencascade/TopAbs_State.hxx” 1
# 30 “/usr/include/opencascade/TopAbs_State.hxx”
enum TopAbs_State {
TopAbs_IN,
TopAbs_OUT,
TopAbs_ON,
TopAbs_UNKNOWN
};
# 36 “/usr/include/opencascade/TopAbs.hxx” 2
# 47 “/usr/include/opencascade/TopAbs.hxx”
class TopAbs {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 84 “/usr/include/opencascade/TopAbs.hxx”
static TopAbs_Orientation Compose(const TopAbs_Orientation Or1,const TopAbs_Orientation Or2) ;
# 97 “/usr/include/opencascade/TopAbs.hxx”
static TopAbs_Orientation Reverse(const TopAbs_Orientation Or) ;
# 113 “/usr/include/opencascade/TopAbs.hxx”
static TopAbs_Orientation Complement(const TopAbs_Orientation Or) ;

static ostream& Print(const TopAbs_ShapeEnum SE,ostream& S) ;

static ostream& Print(const TopAbs_Orientation Or,ostream& S) ;

static ostream& Print(const TopAbs_State St,ostream& S) ;

protected:
# 144 “/usr/include/opencascade/TopAbs.hxx”
private:
# 154 “/usr/include/opencascade/TopAbs.hxx”
};
# 9 “/usr/include/opencascade/TopoDS_Shape.lxx” 2

inline Standard_Boolean TopoDS_Shape::IsNull () const
{
return myTShape.IsNull();
}

inline void TopoDS_Shape::Nullify ()
{
myTShape.Nullify();
}

inline const TopLoc_Location& TopoDS_Shape::Location () const
{
return myLocation;
}

inline void TopoDS_Shape::Location (const TopLoc_Location& Loc)
{
myLocation = Loc;
}

inline TopoDS_Shape TopoDS_Shape::Located(const TopLoc_Location& Loc) const
{
TopoDS_Shape S(*this);
S.Location(Loc);
return S;
}

inline TopAbs_Orientation TopoDS_Shape::Orientation () const
{
return myOrient;
}

inline void TopoDS_Shape::Orientation (const TopAbs_Orientation Orient)
{
myOrient = Orient;
}

inline TopoDS_Shape TopoDS_Shape::Oriented(const TopAbs_Orientation Or) const
{
TopoDS_Shape S(*this);
S.Orientation(Or);
return S;
}

inline const Handle_TopoDS_TShape& TopoDS_Shape::TShape () const
{
return myTShape;
}

inline TopAbs_ShapeEnum TopoDS_Shape::ShapeType() const
{
return myTShape->ShapeType();
}

inline Standard_Boolean TopoDS_Shape::Free () const
{
return myTShape->Free();
}

inline void TopoDS_Shape::Free (const Standard_Boolean B)
{
myTShape->Free(B);
}

inline Standard_Boolean TopoDS_Shape::Modified () const
{
return myTShape->Modified();
}

inline void TopoDS_Shape::Modified (const Standard_Boolean B)
{
myTShape->Modified(B);
}

inline Standard_Boolean TopoDS_Shape::Checked () const
{
return myTShape->Checked();
}

inline void TopoDS_Shape::Checked (const Standard_Boolean B)
{
myTShape->Checked(B);
}

inline Standard_Boolean TopoDS_Shape::Orientable () const
{
return myTShape->Orientable();
}

inline void TopoDS_Shape::Orientable (const Standard_Boolean B)
{
myTShape->Orientable(B);
}

inline Standard_Boolean TopoDS_Shape::Closed () const
{
return myTShape->Closed();
}

inline void TopoDS_Shape::Closed (const Standard_Boolean B)
{
myTShape->Closed(B);
}

inline Standard_Boolean TopoDS_Shape::Infinite () const
{
return myTShape->Infinite();
}

inline void TopoDS_Shape::Infinite (const Standard_Boolean B)
{
myTShape->Infinite(B);
}

inline Standard_Boolean TopoDS_Shape::Convex () const
{
return myTShape->Convex();
}

inline void TopoDS_Shape::Convex (const Standard_Boolean B)
{
myTShape->Convex(B);
}

inline void TopoDS_Shape::Move (const TopLoc_Location& position)
{
myLocation = position * myLocation;
}

inline TopoDS_Shape TopoDS_Shape::Moved
(const TopLoc_Location& position) const
{
TopoDS_Shape S(*this);
S.Move(position);
return S;
}

inline void TopoDS_Shape::Reverse()
{
myOrient = TopAbs::Reverse(myOrient);
}

inline TopoDS_Shape TopoDS_Shape::Reversed() const
{
TopoDS_Shape S(*this);
S.Reverse();
return S;
}

inline void TopoDS_Shape::Complement()
{
myOrient = TopAbs::Complement(myOrient);
}

inline TopoDS_Shape TopoDS_Shape::Complemented() const
{
TopoDS_Shape S(*this);
S.Complement();
return S;
}

inline void TopoDS_Shape::Compose(const TopAbs_Orientation Orient)
{
myOrient = TopAbs::Compose(myOrient,Orient);
}

inline TopoDS_Shape TopoDS_Shape::Composed
(const TopAbs_Orientation Orient) const
{
TopoDS_Shape S(*this);
S.Compose(Orient);
return S;
}

inline Standard_Boolean TopoDS_Shape::IsPartner
(const TopoDS_Shape& other) const
{
return myTShape == other.TShape();
}

inline void TopoDS_Shape::EmptyCopy()
{
myTShape = myTShape->EmptyCopy();
}

inline TopoDS_Shape TopoDS_Shape::EmptyCopied() const
{
TopoDS_Shape S(*this);
S.EmptyCopy();
return S;
}

inline void TopoDS_Shape::TShape (const Handle_TopoDS_TShape& TS)
{
myTShape = TS;
}
# 278 “/usr/include/opencascade/TopoDS_Shape.hxx” 2

inline Standard_Integer HashCode(const TopoDS_Shape& me,const Standard_Integer Upper) {
return me.HashCode(Upper);
}
# 27 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BOP_Operation.hxx” 1
# 26 “/usr/include/opencascade/BOP_Operation.hxx”
enum BOP_Operation {
BOP_COMMON,
BOP_FUSE,
BOP_CUT,
BOP_CUT21,
BOP_SECTION,
BOP_UNKNOWN
};
# 33 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BOPTools_PDSFiller.hxx” 1
# 25 “/usr/include/opencascade/BOPTools_PDSFiller.hxx”
class BOPTools_DSFiller;

typedef BOPTools_DSFiller* BOPTools_PDSFiller;
# 39 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BOP_PBuilder.hxx” 1
# 25 “/usr/include/opencascade/BOP_PBuilder.hxx”
class BOP_Builder;

typedef BOP_Builder* BOP_PBuilder;
# 42 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/Handle_BOP_HistoryCollector.hxx” 1
# 36 “/usr/include/opencascade/Handle_BOP_HistoryCollector.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_MMgt_TShared;
class BOP_HistoryCollector;
Handle_Standard_Type& BOP_HistoryCollector_Type_();

class Handle_BOP_HistoryCollector : public Handle_MMgt_TShared {
public:
Handle_BOP_HistoryCollector():Handle_MMgt_TShared() {}
Handle_BOP_HistoryCollector(const Handle_BOP_HistoryCollector& aHandle) : Handle_MMgt_TShared(aHandle)
{
}

Handle_BOP_HistoryCollector(const BOP_HistoryCollector* anItem) : Handle_MMgt_TShared((MMgt_TShared *)anItem)
{
}

Handle_BOP_HistoryCollector& operator=(const Handle_BOP_HistoryCollector& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_BOP_HistoryCollector& operator=(const BOP_HistoryCollector* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

BOP_HistoryCollector* operator->() const
{
return (BOP_HistoryCollector *)ControlAccess();
}

static const Handle_BOP_HistoryCollector DownCast(const Handle_Standard_Transient& AnObject);
};
# 45 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx” 1
# 29 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx”
# 1 “/usr/include/opencascade/TopTools_ListOfShape.hxx” 1
# 29 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
# 1 “/usr/include/opencascade/Handle_TopTools_ListNodeOfListOfShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_ListNodeOfListOfShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_ListNodeOfListOfShape;
Handle_Standard_Type& TopTools_ListNodeOfListOfShape_Type_();

class Handle_TopTools_ListNodeOfListOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopTools_ListNodeOfListOfShape():Handle_TCollection_MapNode() {}
Handle_TopTools_ListNodeOfListOfShape(const Handle_TopTools_ListNodeOfListOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_ListNodeOfListOfShape(const TopTools_ListNodeOfListOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_ListNodeOfListOfShape& operator=(const Handle_TopTools_ListNodeOfListOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_ListNodeOfListOfShape& operator=(const TopTools_ListNodeOfListOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_ListNodeOfListOfShape* operator->() const
{
return (TopTools_ListNodeOfListOfShape *)ControlAccess();
}

static const Handle_TopTools_ListNodeOfListOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_ListOfShape.hxx” 2

class Standard_NoSuchObject;
class TopTools_ListIteratorOfListOfShape;
class TopoDS_Shape;
class TopTools_ListNodeOfListOfShape;
# 51 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
class TopTools_ListOfShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_ListOfShape();

void Assign(const TopTools_ListOfShape& Other) ;
void operator=(const TopTools_ListOfShape& Other)
{
Assign(Other);
}

Standard_Integer Extent() const;

void Clear() ;
~TopTools_ListOfShape()
{
Clear();
}

Standard_Boolean IsEmpty() const;

void Prepend(const TopoDS_Shape& I) ;

void Prepend(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& theIt) ;

void Prepend(TopTools_ListOfShape& Other) ;

void Append(const TopoDS_Shape& I) ;

void Append(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& theIt) ;

void Append(TopTools_ListOfShape& Other) ;

TopoDS_Shape& First() const;

TopoDS_Shape& Last() const;

void RemoveFirst() ;

void Remove(TopTools_ListIteratorOfListOfShape& It) ;

void InsertBefore(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& It) ;

void InsertBefore(TopTools_ListOfShape& Other,TopTools_ListIteratorOfListOfShape& It) ;

void InsertAfter(const TopoDS_Shape& I,TopTools_ListIteratorOfListOfShape& It) ;

void InsertAfter(TopTools_ListOfShape& Other,TopTools_ListIteratorOfListOfShape& It) ;

friend class TopTools_ListIteratorOfListOfShape;

protected:
# 151 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
private:

TopTools_ListOfShape(const TopTools_ListOfShape& Other);

Standard_Address myFirst;
Standard_Address myLast;

};
# 179 “/usr/include/opencascade/TopTools_ListOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_List.lxx” 1
# 12 “/usr/include/opencascade/TCollection_List.lxx”
inline Standard_Boolean TopTools_ListOfShape::IsEmpty() const

{
return myFirst == 0L;
}
# 180 “/usr/include/opencascade/TopTools_ListOfShape.hxx” 2
# 30 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx” 2

# 1 “/usr/include/opencascade/BRepBuilderAPI_Command.hxx” 1
# 28 “/usr/include/opencascade/BRepBuilderAPI_Command.hxx”
class StdFail_NotDone;
# 47 “/usr/include/opencascade/BRepBuilderAPI_Command.hxx”
class BRepBuilderAPI_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~BRepBuilderAPI_Command(){Delete() ; }

virtual Standard_Boolean IsDone() const;

void Check() const;

protected:

BRepBuilderAPI_Command();

void Done() ;

void NotDone() ;

private:

Standard_Boolean myDone;

};
# 33 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx” 2

class StdFail_NotDone;
class TopoDS_Shape;
class TopTools_ListOfShape;
# 54 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx”
class BRepBuilderAPI_MakeShape : public BRepBuilderAPI_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~BRepBuilderAPI_MakeShape(){Delete() ; }

virtual void Build() ;

const TopoDS_Shape& Shape() const;
operator TopoDS_Shape() const;

virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& S) ;

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& S) ;

virtual Standard_Boolean IsDeleted(const TopoDS_Shape& S) ;

protected:

BRepBuilderAPI_MakeShape();

TopoDS_Shape myShape;
TopTools_ListOfShape myGenerated;

private:
# 126 “/usr/include/opencascade/BRepBuilderAPI_MakeShape.hxx”
};
# 48 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx” 2

class BOP_HistoryCollector;
class TopoDS_Shape;
class BOPTools_DSFiller;
class TopTools_ListOfShape;
# 71 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
class BRepAlgoAPI_BooleanOperation : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 96 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
void SetOperation(const BOP_Operation anOp) ;

virtual void Build() ;

const TopoDS_Shape& Shape1() const;

const TopoDS_Shape& Shape2() const;

BOP_Operation Operation() const;

Standard_Boolean BuilderCanWork() const;
# 125 “/usr/include/opencascade/BRepAlgoAPI_BooleanOperation.hxx”
Standard_Integer ErrorStatus() const;

virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& aS) ;

virtual Standard_Boolean IsDeleted(const TopoDS_Shape& aS) ;

virtual const TopTools_ListOfShape& Modified2(const TopoDS_Shape& aS) ;

virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& S) ;

virtual Standard_Boolean HasModified() const;

virtual Standard_Boolean HasGenerated() const;

virtual Standard_Boolean HasDeleted() const;

void Destroy() ;
virtual ~BRepAlgoAPI_BooleanOperation(){Destroy();}

const TopTools_ListOfShape& SectionEdges() const;

protected:

BRepAlgoAPI_BooleanOperation(const TopoDS_Shape& S1,const TopoDS_Shape& S2,const BOP_Operation anOperation);

BRepAlgoAPI_BooleanOperation(const TopoDS_Shape& S1,const TopoDS_Shape& S2,const BOPTools_DSFiller& aDSF,const BOP_Operation anOperation);

Standard_Boolean PrepareFiller() ;

TopoDS_Shape myS1;
TopoDS_Shape myS2;
Standard_Boolean myBuilderCanWork;
BOP_Operation myOperation;
Standard_Integer myErrorStatus;
BOPTools_PDSFiller myDSFiller;
BOP_PBuilder myBuilder;
Handle_BOP_HistoryCollector myHistory;

private:

Standard_Integer myEntryType;

};
# 27 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx” 2

class TopoDS_Shape;
class BOPTools_DSFiller;
# 45 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
class BRepAlgoAPI_Fuse : public BRepAlgoAPI_BooleanOperation {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepAlgoAPI_Fuse(const TopoDS_Shape& S1,const TopoDS_Shape& S2);

BRepAlgoAPI_Fuse(const TopoDS_Shape& S1,const TopoDS_Shape& S2,const BOPTools_DSFiller& aDSF);

protected:
# 84 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
private:
# 94 “/usr/include/opencascade/BRepAlgoAPI_Fuse.hxx”
};
# 4 “MakeBottle.cxx” 2

# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
# 1 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
# 1 “/usr/include/opencascade/BRepLib_EdgeError.hxx” 1
# 27 “/usr/include/opencascade/BRepLib_EdgeError.hxx”
enum BRepLib_EdgeError {
BRepLib_EdgeDone,
BRepLib_PointProjectionFailed,
BRepLib_ParameterOutOfRange,
BRepLib_DifferentPointsOnClosedCurve,
BRepLib_PointWithInfiniteParameter,
BRepLib_DifferentsPointAndParameter,
BRepLib_LineThroughIdenticPoints
};
# 27 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 2

# 1 “/usr/include/opencascade/TopoDS_Vertex.hxx” 1
# 45 “/usr/include/opencascade/TopoDS_Vertex.hxx”
class TopoDS_Vertex : public TopoDS_Shape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_Vertex();

protected:
# 81 “/usr/include/opencascade/TopoDS_Vertex.hxx”
private:
# 91 “/usr/include/opencascade/TopoDS_Vertex.hxx”
};
# 30 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 2

# 1 “/usr/include/opencascade/BRepLib_MakeShape.hxx” 1
# 32 “/usr/include/opencascade/BRepLib_MakeShape.hxx”
# 1 “/usr/include/opencascade/BRepLib_Command.hxx” 1
# 28 “/usr/include/opencascade/BRepLib_Command.hxx”
class StdFail_NotDone;
# 47 “/usr/include/opencascade/BRepLib_Command.hxx”
class BRepLib_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

virtual void Delete() ;
virtual ~BRepLib_Command(){Delete() ; }

Standard_Boolean IsDone() const;

void Check() const;

protected:

BRepLib_Command();

void Done() ;

void NotDone() ;

private:

Standard_Boolean myDone;

};
# 33 “/usr/include/opencascade/BRepLib_MakeShape.hxx” 2

# 1 “/usr/include/opencascade/BRepLib_ShapeModification.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_ShapeModification.hxx”
enum BRepLib_ShapeModification {
BRepLib_Preserved,
BRepLib_Deleted,
BRepLib_Trimmed,
BRepLib_Merged,
BRepLib_BoundaryModified
};
# 36 “/usr/include/opencascade/BRepLib_MakeShape.hxx” 2

class StdFail_NotDone;
class TopoDS_Shape;
class TopoDS_Face;
class TopTools_ListOfShape;
class TopoDS_Edge;
# 62 “/usr/include/opencascade/BRepLib_MakeShape.hxx”
class BRepLib_MakeShape : public BRepLib_Command {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

void Build() ;

const TopoDS_Shape& Shape() const;
operator TopoDS_Shape() const;

virtual BRepLib_ShapeModification FaceStatus(const TopoDS_Face& F) const;

virtual Standard_Boolean HasDescendants(const TopoDS_Face& F) const;

virtual const TopTools_ListOfShape& DescendantFaces(const TopoDS_Face& F) ;

virtual Standard_Integer NbSurfaces() const;

virtual const TopTools_ListOfShape& NewFaces(const Standard_Integer I) ;

virtual const TopTools_ListOfShape& FacesFromEdges(const TopoDS_Edge& E) ;

protected:

BRepLib_MakeShape();

TopoDS_Shape myShape;
TopTools_ListOfShape myGenFaces;
TopTools_ListOfShape myNewFaces;
TopTools_ListOfShape myEdgFaces;

private:
# 141 “/usr/include/opencascade/BRepLib_MakeShape.hxx”
};
# 33 “/usr/include/opencascade/BRepLib_MakeEdge.hxx” 2
# 46 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
class StdFail_NotDone;
class TopoDS_Vertex;
class gp_Pnt;
class gp_Lin;
class gp_Circ;
class gp_Elips;
class gp_Hypr;
class gp_Parab;
class Geom_Curve;
class Geom2d_Curve;
class Geom_Surface;
class TopoDS_Edge;
# 98 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
class BRepLib_MakeEdge : public BRepLib_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepLib_MakeEdge();

BRepLib_MakeEdge(const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Lin& L);

BRepLib_MakeEdge(const gp_Lin& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Lin& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Lin& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Circ& L);

BRepLib_MakeEdge(const gp_Circ& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Circ& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Circ& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Elips& L);

BRepLib_MakeEdge(const gp_Elips& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Elips& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Elips& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Hypr& L);

BRepLib_MakeEdge(const gp_Hypr& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Hypr& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Hypr& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const gp_Parab& L);

BRepLib_MakeEdge(const gp_Parab& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const gp_Parab& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const gp_Parab& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);

BRepLib_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

void Init(const Handle_Geom_Curve& C) ;

void Init(const Handle_Geom_Curve& C,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

BRepLib_EdgeError Error() const;

const TopoDS_Edge& Edge() const;
operator TopoDS_Edge() const;

const TopoDS_Vertex& Vertex1() const;

const TopoDS_Vertex& Vertex2() const;

protected:
# 287 “/usr/include/opencascade/BRepLib_MakeEdge.hxx”
private:

BRepLib_EdgeError myError;
TopoDS_Vertex myVertex1;
TopoDS_Vertex myVertex2;

};
# 27 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx” 2
# 47 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
# 1 “/usr/include/opencascade/BRepBuilderAPI_EdgeError.hxx” 1
# 49 “/usr/include/opencascade/BRepBuilderAPI_EdgeError.hxx”
enum BRepBuilderAPI_EdgeError {
BRepBuilderAPI_EdgeDone,
BRepBuilderAPI_PointProjectionFailed,
BRepBuilderAPI_ParameterOutOfRange,
BRepBuilderAPI_DifferentPointsOnClosedCurve,
BRepBuilderAPI_PointWithInfiniteParameter,
BRepBuilderAPI_DifferentsPointAndParameter,
BRepBuilderAPI_LineThroughIdenticPoints
};
# 48 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx” 2

class StdFail_NotDone;
class TopoDS_Vertex;
class gp_Pnt;
class gp_Lin;
class gp_Circ;
class gp_Elips;
class gp_Hypr;
class gp_Parab;
class Geom_Curve;
class Geom2d_Curve;
class Geom_Surface;
class TopoDS_Edge;
# 101 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
class BRepBuilderAPI_MakeEdge : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepBuilderAPI_MakeEdge();

BRepBuilderAPI_MakeEdge(const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Lin& L);

BRepBuilderAPI_MakeEdge(const gp_Lin& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Lin& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Lin& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Circ& L);

BRepBuilderAPI_MakeEdge(const gp_Circ& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Circ& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Circ& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Elips& L);

BRepBuilderAPI_MakeEdge(const gp_Elips& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Elips& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Elips& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Hypr& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const gp_Parab& L);

BRepBuilderAPI_MakeEdge(const gp_Parab& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const gp_Parab& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const gp_Parab& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom_Curve& L,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2);

BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2);
# 284 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
BRepBuilderAPI_MakeEdge(const Handle_Geom2d_Curve& L,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2);

void Init(const Handle_Geom_Curve& C) ;

void Init(const Handle_Geom_Curve& C,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom_Curve& C,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom_Curve& C,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const gp_Pnt& P1,const gp_Pnt& P2,const Standard_Real p1,const Standard_Real p2) ;

void Init(const Handle_Geom2d_Curve& C,const Handle_Geom_Surface& S,const TopoDS_Vertex& V1,const TopoDS_Vertex& V2,const Standard_Real p1,const Standard_Real p2) ;

virtual Standard_Boolean IsDone() const;

BRepBuilderAPI_EdgeError Error() const;

const TopoDS_Edge& Edge() const;
operator TopoDS_Edge() const;

const TopoDS_Vertex& Vertex1() const;
# 352 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
const TopoDS_Vertex& Vertex2() const;

protected:
# 368 “/usr/include/opencascade/BRepBuilderAPI_MakeEdge.hxx”
private:

BRepLib_MakeEdge myMakeEdge;

};
# 6 “MakeBottle.cxx” 2
# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
# 1 “/usr/include/opencascade/BRepLib_MakeFace.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
# 1 “/usr/include/opencascade/BRepLib_FaceError.hxx” 1
# 28 “/usr/include/opencascade/BRepLib_FaceError.hxx”
enum BRepLib_FaceError {
BRepLib_FaceDone,
BRepLib_NoFace,
BRepLib_NotPlanar,
BRepLib_CurveProjectionFailed,
BRepLib_ParametersOutOfRange,
BRepLib_SurfaceNotC2
};
# 27 “/usr/include/opencascade/BRepLib_MakeFace.hxx” 2
# 40 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
class StdFail_NotDone;
class TopoDS_Face;
class gp_Pln;
class gp_Cylinder;
class gp_Cone;
class gp_Sphere;
class gp_Torus;
class Geom_Surface;
class TopoDS_Wire;
# 87 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
class BRepLib_MakeFace : public BRepLib_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepLib_MakeFace();

BRepLib_MakeFace(const TopoDS_Face& F);

BRepLib_MakeFace(const gp_Pln& P);

BRepLib_MakeFace(const gp_Cylinder& C);

BRepLib_MakeFace(const gp_Cone& C);

BRepLib_MakeFace(const gp_Sphere& S);

BRepLib_MakeFace(const gp_Torus& C);

BRepLib_MakeFace(const Handle_Geom_Surface& S);

BRepLib_MakeFace(const gp_Pln& P,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Cylinder& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Cone& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Sphere& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const gp_Torus& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepLib_MakeFace(const TopoDS_Wire& W,const Standard_Boolean OnlyPlane = (Standard_Boolean) 0);

BRepLib_MakeFace(const gp_Pln& P,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Cylinder& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Cone& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Sphere& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const gp_Torus& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const Handle_Geom_Surface& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepLib_MakeFace(const TopoDS_Face& F,const TopoDS_Wire& W);

void Init(const TopoDS_Face& F) ;

void Init(const Handle_Geom_Surface& S,const Standard_Boolean Bound = (Standard_Boolean) 1) ;

void Init(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax) ;

void Add(const TopoDS_Wire& W) ;

BRepLib_FaceError Error() const;

const TopoDS_Face& Face() const;
operator TopoDS_Face() const;

protected:
# 211 “/usr/include/opencascade/BRepLib_MakeFace.hxx”
private:

void CheckInside() ;

BRepLib_FaceError myError;

};
# 27 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx” 2
# 41 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
# 1 “/usr/include/opencascade/BRepBuilderAPI_FaceError.hxx” 1
# 39 “/usr/include/opencascade/BRepBuilderAPI_FaceError.hxx”
enum BRepBuilderAPI_FaceError {
BRepBuilderAPI_FaceDone,
BRepBuilderAPI_NoFace,
BRepBuilderAPI_NotPlanar,
BRepBuilderAPI_CurveProjectionFailed,
BRepBuilderAPI_ParametersOutOfRange,
BRepBuilderAPI_SurfaceNotC2
};
# 42 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx” 2

class StdFail_NotDone;
class TopoDS_Face;
class gp_Pln;
class gp_Cylinder;
class gp_Cone;
class gp_Sphere;
class gp_Torus;
class Geom_Surface;
class TopoDS_Wire;
# 101 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
class BRepBuilderAPI_MakeFace : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepBuilderAPI_MakeFace();

BRepBuilderAPI_MakeFace(const TopoDS_Face& F);

BRepBuilderAPI_MakeFace(const gp_Pln& P);

BRepBuilderAPI_MakeFace(const gp_Cylinder& C);

BRepBuilderAPI_MakeFace(const gp_Cone& C);

BRepBuilderAPI_MakeFace(const gp_Sphere& S);

BRepBuilderAPI_MakeFace(const gp_Torus& C);

BRepBuilderAPI_MakeFace(const Handle_Geom_Surface& S);

BRepBuilderAPI_MakeFace(const gp_Pln& P,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Cylinder& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Cone& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Sphere& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const gp_Torus& C,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax);

BRepBuilderAPI_MakeFace(const TopoDS_Wire& W,const Standard_Boolean OnlyPlane = (Standard_Boolean) 0);

BRepBuilderAPI_MakeFace(const gp_Pln& P,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Cylinder& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Cone& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Sphere& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const gp_Torus& C,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);

BRepBuilderAPI_MakeFace(const Handle_Geom_Surface& S,const TopoDS_Wire& W,const Standard_Boolean Inside = (Standard_Boolean) 1);
# 233 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
BRepBuilderAPI_MakeFace(const TopoDS_Face& F,const TopoDS_Wire& W);

void Init(const TopoDS_Face& F) ;
# 249 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
void Init(const Handle_Geom_Surface& S,const Standard_Boolean Bound = (Standard_Boolean) 1) ;
# 262 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
void Init(const Handle_Geom_Surface& S,const Standard_Real UMin,const Standard_Real UMax,const Standard_Real VMin,const Standard_Real VMax) ;
# 277 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
void Add(const TopoDS_Wire& W) ;

virtual Standard_Boolean IsDone() const;

BRepBuilderAPI_FaceError Error() const;

const TopoDS_Face& Face() const;
operator TopoDS_Face() const;

protected:
# 310 “/usr/include/opencascade/BRepBuilderAPI_MakeFace.hxx”
private:

BRepLib_MakeFace myMakeFace;

};
# 7 “MakeBottle.cxx” 2
# 1 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
# 1 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 1
# 26 “/usr/include/opencascade/BRepLib_MakeWire.hxx”
# 1 “/usr/include/opencascade/BRepLib_WireError.hxx” 1
# 27 “/usr/include/opencascade/BRepLib_WireError.hxx”
enum BRepLib_WireError {
BRepLib_WireDone,
BRepLib_EmptyWire,
BRepLib_DisconnectedWire,
BRepLib_NonManifoldWire
};
# 27 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 2

# 1 “/usr/include/opencascade/TopoDS_Edge.hxx” 1
# 45 “/usr/include/opencascade/TopoDS_Edge.hxx”
class TopoDS_Edge : public TopoDS_Shape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopoDS_Edge();

protected:
# 81 “/usr/include/opencascade/TopoDS_Edge.hxx”
private:
# 91 “/usr/include/opencascade/TopoDS_Edge.hxx”
};
# 30 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 2

# 1 “/usr/include/opencascade/TopTools_MapOfShape.hxx” 1
# 26 “/usr/include/opencascade/TopTools_MapOfShape.hxx”
# 1 “/usr/include/opencascade/TCollection_BasicMap.hxx” 1
# 32 “/usr/include/opencascade/TCollection_BasicMap.hxx”
# 1 “/usr/include/opencascade/TCollection_MapNodePtr.hxx” 1
# 25 “/usr/include/opencascade/TCollection_MapNodePtr.hxx”
class TCollection_MapNode;

typedef TCollection_MapNode* TCollection_MapNodePtr;
# 33 “/usr/include/opencascade/TCollection_BasicMap.hxx” 2

class TCollection_BasicMapIterator;
# 105 “/usr/include/opencascade/TCollection_BasicMap.hxx”
class TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

Standard_Integer NbBuckets() const;

Standard_Integer Extent() const;

Standard_Boolean IsEmpty() const;

void Statistics(ostream& S) const;

friend class TCollection_BasicMapIterator;

protected:
# 151 “/usr/include/opencascade/TCollection_BasicMap.hxx”
TCollection_BasicMap(const Standard_Integer NbBuckets,const Standard_Boolean single);

Standard_Boolean BeginResize(const Standard_Integer NbBuckets,Standard_Integer& NewBuckets,TCollection_MapNodePtr& data1,TCollection_MapNodePtr& data2) const;

void EndResize(const Standard_Integer NbBuckets,const Standard_Integer NewBuckets,const TCollection_MapNodePtr& data1,const TCollection_MapNodePtr& data2) ;

Standard_Boolean Resizable() const;

void Increment() ;

void Decrement() ;

void Destroy() ;

TCollection_MapNodePtr myData1;
TCollection_MapNodePtr myData2;

private:

Standard_Boolean isDouble;
Standard_Boolean mySaturated;
Standard_Integer myNbBuckets;
Standard_Integer mySize;

};

# 1 “/usr/include/opencascade/TCollection_BasicMap.lxx” 1
# 12 “/usr/include/opencascade/TCollection_BasicMap.lxx”
inline Standard_Integer TCollection_BasicMap::NbBuckets() const
{
return myNbBuckets;
}

inline Standard_Integer TCollection_BasicMap::Extent() const
{
return mySize;
}

inline Standard_Boolean TCollection_BasicMap::IsEmpty() const
{
return mySize == 0;
}

inline Standard_Boolean TCollection_BasicMap::Resizable()const
{
return IsEmpty() || (!mySaturated && (mySize > myNbBuckets));
}

inline void TCollection_BasicMap::Increment()
{
mySize++;
}

inline void TCollection_BasicMap::Decrement()
{
mySize–;
}
# 199 “/usr/include/opencascade/TCollection_BasicMap.hxx” 2
# 27 “/usr/include/opencascade/TopTools_MapOfShape.hxx” 2

# 1 “/usr/include/opencascade/Handle_TopTools_StdMapNodeOfMapOfShape.hxx” 1
# 36 “/usr/include/opencascade/Handle_TopTools_StdMapNodeOfMapOfShape.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_TCollection_MapNode;
class TopTools_StdMapNodeOfMapOfShape;
Handle_Standard_Type& TopTools_StdMapNodeOfMapOfShape_Type_();

class Handle_TopTools_StdMapNodeOfMapOfShape : public Handle_TCollection_MapNode {
public:
Handle_TopTools_StdMapNodeOfMapOfShape():Handle_TCollection_MapNode() {}
Handle_TopTools_StdMapNodeOfMapOfShape(const Handle_TopTools_StdMapNodeOfMapOfShape& aHandle) : Handle_TCollection_MapNode(aHandle)
{
}

Handle_TopTools_StdMapNodeOfMapOfShape(const TopTools_StdMapNodeOfMapOfShape* anItem) : Handle_TCollection_MapNode((TCollection_MapNode *)anItem)
{
}

Handle_TopTools_StdMapNodeOfMapOfShape& operator=(const Handle_TopTools_StdMapNodeOfMapOfShape& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_TopTools_StdMapNodeOfMapOfShape& operator=(const TopTools_StdMapNodeOfMapOfShape* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

TopTools_StdMapNodeOfMapOfShape* operator->() const
{
return (TopTools_StdMapNodeOfMapOfShape *)ControlAccess();
}

static const Handle_TopTools_StdMapNodeOfMapOfShape DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/TopTools_MapOfShape.hxx” 2

class Standard_DomainError;
class TopoDS_Shape;
class TopTools_ShapeMapHasher;
class TopTools_StdMapNodeOfMapOfShape;
class TopTools_MapIteratorOfMapOfShape;
# 52 “/usr/include/opencascade/TopTools_MapOfShape.hxx”
class TopTools_MapOfShape : public TCollection_BasicMap {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

TopTools_MapOfShape(const Standard_Integer NbBuckets = 1);

TopTools_MapOfShape& Assign(const TopTools_MapOfShape& Other) ;
TopTools_MapOfShape& operator =(const TopTools_MapOfShape& Other)
{
return Assign(Other);
}

void ReSize(const Standard_Integer NbBuckets) ;

void Clear() ;
~TopTools_MapOfShape()
{
Clear();
}

Standard_Boolean Add(const TopoDS_Shape& aKey) ;

Standard_Boolean Contains(const TopoDS_Shape& aKey) const;

Standard_Boolean Remove(const TopoDS_Shape& aKey) ;

protected:
# 116 “/usr/include/opencascade/TopTools_MapOfShape.hxx”
private:

TopTools_MapOfShape(const TopTools_MapOfShape& Other);

};
# 36 “/usr/include/opencascade/BRepLib_MakeWire.hxx” 2

class StdFail_NotDone;
class TopoDS_Edge;
class TopoDS_Wire;
class TopTools_ListOfShape;
class TopoDS_Vertex;
# 97 “/usr/include/opencascade/BRepLib_MakeWire.hxx”
class BRepLib_MakeWire : public BRepLib_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

BRepLib_MakeWire();

BRepLib_MakeWire(const TopoDS_Edge& E);

BRepLib_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2);

BRepLib_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3);

BRepLib_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3,const TopoDS_Edge& E4);

BRepLib_MakeWire(const TopoDS_Wire& W);

BRepLib_MakeWire(const TopoDS_Wire& W,const TopoDS_Edge& E);

void Add(const TopoDS_Edge& E) ;

void Add(const TopoDS_Wire& W) ;

void Add(const TopTools_ListOfShape& L) ;

BRepLib_WireError Error() const;

const TopoDS_Wire& Wire() const;
operator TopoDS_Wire() const;

const TopoDS_Edge& Edge() const;

const TopoDS_Vertex& Vertex() const;

protected:
# 178 “/usr/include/opencascade/BRepLib_MakeWire.hxx”
private:

BRepLib_WireError myError;
TopoDS_Edge myEdge;
TopoDS_Vertex myVertex;
TopTools_MapOfShape myVertices;
TopoDS_Vertex FirstVertex;
TopoDS_Vertex VF;
TopoDS_Vertex VL;

};
# 27 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx” 2
# 35 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
# 1 “/usr/include/opencascade/BRepBuilderAPI_WireError.hxx” 1
# 35 “/usr/include/opencascade/BRepBuilderAPI_WireError.hxx”
enum BRepBuilderAPI_WireError {
BRepBuilderAPI_WireDone,
BRepBuilderAPI_EmptyWire,
BRepBuilderAPI_DisconnectedWire,
BRepBuilderAPI_NonManifoldWire
};
# 36 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx” 2

class StdFail_NotDone;
class TopoDS_Edge;
class TopoDS_Wire;
class TopTools_ListOfShape;
class TopoDS_Vertex;
# 82 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
class BRepBuilderAPI_MakeWire : public BRepBuilderAPI_MakeShape {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 109 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
BRepBuilderAPI_MakeWire();

BRepBuilderAPI_MakeWire(const TopoDS_Edge& E);

BRepBuilderAPI_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2);

BRepBuilderAPI_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3);
# 140 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
BRepBuilderAPI_MakeWire(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Edge& E3,const TopoDS_Edge& E4);

BRepBuilderAPI_MakeWire(const TopoDS_Wire& W);

BRepBuilderAPI_MakeWire(const TopoDS_Wire& W,const TopoDS_Edge& E);
# 161 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
void Add(const TopoDS_Edge& E) ;

void Add(const TopoDS_Wire& W) ;
# 173 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
void Add(const TopTools_ListOfShape& L) ;

virtual Standard_Boolean IsDone() const;

BRepBuilderAPI_WireError Error() const;

const TopoDS_Wire& Wire() const;
operator TopoDS_Wire() const;
# 200 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
const TopoDS_Edge& Edge() const;

const TopoDS_Vertex& Vertex() const;

protected:
# 224 “/usr/include/opencascade/BRepBuilderAPI_MakeWire.hxx”
private:

BRepLib_MakeWire myMakeWire;

};
# 8 “MakeBottle.cxx” 2
# 1 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx” 1
# 26 “/usr/include/opencascade/BRepBuilderAPI_Transform.hxx”
# 1 “/usr/include/opencascade/gp_Trsf.hxx” 1
# 29 “/usr/include/opencascade/gp_Trsf.hxx”
# 1 “/usr/include/opencascade/gp_TrsfForm.hxx” 1
# 26 “/usr/include/opencascade/gp_TrsfForm.hxx”
enum gp_TrsfForm {
gp_Identity,
gp_Rotation,
gp_Translation,
gp_PntMirror,
gp_Ax1Mirror,
gp_Ax2Mirror,
gp_Scale,
gp_CompoundTrsf,
gp_Other
};
# 30 “/usr/include/opencascade/gp_Trsf.hxx” 2

# 1 “/usr/include/opencascade/gp_Mat.hxx” 1
# 40 “/usr/include/opencascade/gp_Mat.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_XYZ;
class gp_Trsf;
class gp_GTrsf;
# 54 “/usr/include/opencascade/gp_Mat.hxx”
Handle_Standard_Type& gp_Mat_Type_();

class gp_Mat {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Mat();

gp_Mat(const Standard_Real a11,const Standard_Real a12,const Standard_Real a13,const Standard_Real a21,const Standard_Real a22,const Standard_Real a23,const Standard_Real a31,const Standard_Real a32,const Standard_Real a33);

gp_Mat(const gp_XYZ& Col1,const gp_XYZ& Col2,const gp_XYZ& Col3);

void SetCol(const Standard_Integer Col,const gp_XYZ& Value) ;

void SetCols(const gp_XYZ& Col1,const gp_XYZ& Col2,const gp_XYZ& Col3) ;
# 104 “/usr/include/opencascade/gp_Mat.hxx”
void SetCross(const gp_XYZ& Ref) ;

void SetDiagonal(const Standard_Real X1,const Standard_Real X2,const Standard_Real X3) ;

void SetDot(const gp_XYZ& Ref) ;

void SetIdentity() ;

void SetRotation(const gp_XYZ& Axis,const Standard_Real Ang) ;

void SetRow(const Standard_Integer Row,const gp_XYZ& Value) ;

void SetRows(const gp_XYZ& Row1,const gp_XYZ& Row2,const gp_XYZ& Row3) ;

void SetScale(const Standard_Real S) ;

void SetValue(const Standard_Integer Row,const Standard_Integer Col,const Standard_Real Value) ;

gp_XYZ Column(const Standard_Integer Col) const;

Standard_Real Determinant() const;

gp_XYZ Diagonal() const;

gp_XYZ Row(const Standard_Integer Row) const;

const Standard_Real& Value(const Standard_Integer Row,const Standard_Integer Col) const;
const Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col) const
{
return Value(Row,Col);
}

Standard_Real& ChangeValue(const Standard_Integer Row,const Standard_Integer Col) ;
Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col)
{
return ChangeValue(Row,Col);
}

Standard_Boolean IsSingular() const;

void Add(const gp_Mat& Other) ;
void operator +=(const gp_Mat& Other)
{
Add(Other);
}

gp_Mat Added(const gp_Mat& Other) const;
gp_Mat operator +(const gp_Mat& Other) const
{
return Added(Other);
}

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Mat Divided(const Standard_Real Scalar) const;
gp_Mat operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

void Invert() ;
# 226 “/usr/include/opencascade/gp_Mat.hxx”
gp_Mat Inverted() const;

gp_Mat Multiplied(const gp_Mat& Other) const;
gp_Mat operator *(const gp_Mat& Other) const
{
return Multiplied(Other);
}

void Multiply(const gp_Mat& Other) ;
void operator *=(const gp_Mat& Other)
{
Multiply(Other);
}

void PreMultiply(const gp_Mat& Other) ;

gp_Mat Multiplied(const Standard_Real Scalar) const;
gp_Mat operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Power(const Standard_Integer N) ;

gp_Mat Powered(const Standard_Integer N) const;

void Subtract(const gp_Mat& Other) ;
void operator -=(const gp_Mat& Other)
{
Subtract(Other);
}

gp_Mat Subtracted(const gp_Mat& Other) const;
gp_Mat operator -(const gp_Mat& Other) const
{
return Subtracted(Other);
}

void Transpose() ;

gp_Mat Transposed() const;
Standard_Real& _CSFDB_Getgp_Matmatrix(const Standard_Integer i1,const Standard_Integer i2) { return matrix[i1][i2]; }

friend class gp_XYZ;
friend class gp_Trsf;
friend class gp_GTrsf;

friend Handle_Standard_Type& gp_Mat_Type_();

protected:
# 312 “/usr/include/opencascade/gp_Mat.hxx”
private:

Standard_Real matrix[3][3];

};

# 1 “/usr/include/opencascade/gp_Mat.lxx” 1

# 1 “/usr/include/opencascade/gp.hxx” 1
# 28 “/usr/include/opencascade/gp.hxx”
class gp_Pnt;
class gp_Dir;
class gp_Ax1;
class gp_Ax2;
class gp_Pnt2d;
class gp_Dir2d;
class gp_Ax2d;
class gp_XYZ;
class gp_Mat;
class gp_Trsf;
class gp_GTrsf;
class gp_Pnt;
class gp_Vec;
class gp_Dir;
class gp_Ax1;
class gp_Ax2;
class gp_Ax3;
class gp_Lin;
class gp_Circ;
class gp_Elips;
class gp_Hypr;
class gp_Parab;
class gp_Pln;
class gp_Cylinder;
class gp_Sphere;
class gp_Torus;
class gp_Cone;
class gp_XY;
class gp_Mat2d;
class gp_Trsf2d;
class gp_GTrsf2d;
class gp_Pnt2d;
class gp_Vec2d;
class gp_Dir2d;
class gp_Ax2d;
class gp_Ax22d;
class gp_Lin2d;
class gp_Circ2d;
class gp_Elips2d;
class gp_Hypr2d;
class gp_Parab2d;
# 88 “/usr/include/opencascade/gp.hxx”
class gp {

public:

void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}
# 113 “/usr/include/opencascade/gp.hxx”
static Standard_Real Resolution() ;

static const gp_Pnt& Origin() ;

static const gp_Dir& DX() ;

static const gp_Dir& DY() ;

static const gp_Dir& DZ() ;

static const gp_Ax1& OX() ;

static const gp_Ax1& OY() ;

static const gp_Ax1& OZ() ;

static const gp_Ax2& XOY() ;

static const gp_Ax2& ZOX() ;

static const gp_Ax2& YOZ() ;

static const gp_Pnt2d& Origin2d() ;

static const gp_Dir2d& DX2d() ;

static const gp_Dir2d& DY2d() ;

static const gp_Ax2d& OX2d() ;

static const gp_Ax2d& OY2d() ;

protected:
# 185 “/usr/include/opencascade/gp.hxx”
private:
# 194 “/usr/include/opencascade/gp.hxx”
friend class gp_XYZ;
friend class gp_Mat;
friend class gp_Trsf;
friend class gp_GTrsf;
friend class gp_Pnt;
friend class gp_Vec;
friend class gp_Dir;
friend class gp_Ax1;
friend class gp_Ax2;
friend class gp_Ax3;
friend class gp_Lin;
friend class gp_Circ;
friend class gp_Elips;
friend class gp_Hypr;
friend class gp_Parab;
friend class gp_Pln;
friend class gp_Cylinder;
friend class gp_Sphere;
friend class gp_Torus;
friend class gp_Cone;
friend class gp_XY;
friend class gp_Mat2d;
friend class gp_Trsf2d;
friend class gp_GTrsf2d;
friend class gp_Pnt2d;
friend class gp_Vec2d;
friend class gp_Dir2d;
friend class gp_Ax2d;
friend class gp_Ax22d;
friend class gp_Lin2d;
friend class gp_Circ2d;
friend class gp_Elips2d;
friend class gp_Hypr2d;
friend class gp_Parab2d;

};

# 1 “/usr/include/opencascade/gp.lxx” 1

inline Standard_Real gp::Resolution ()
{
return RealSmall();
}
# 233 “/usr/include/opencascade/gp.hxx” 2
# 4 “/usr/include/opencascade/gp_Mat.lxx” 2
# 1 “/usr/include/opencascade/Standard_OutOfRange.hxx” 1
# 29 “/usr/include/opencascade/Standard_OutOfRange.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_OutOfRange.hxx” 1
# 33 “/usr/include/opencascade/Handle_Standard_OutOfRange.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_RangeError.hxx” 1
# 33 “/usr/include/opencascade/Handle_Standard_RangeError.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_DomainError.hxx” 1
# 33 “/usr/include/opencascade/Handle_Standard_DomainError.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_Failure.hxx” 1
# 36 “/usr/include/opencascade/Handle_Standard_Failure.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Transient;
class Standard_Failure;
Handle_Standard_Type& Standard_Failure_Type_();

class Handle_Standard_Failure : public Handle_Standard_Transient {
public:
Handle_Standard_Failure():Handle_Standard_Transient() {}
Handle_Standard_Failure(const Handle_Standard_Failure& aHandle) : Handle_Standard_Transient(aHandle)
{
}

Handle_Standard_Failure(const Standard_Failure* anItem) : Handle_Standard_Transient((Standard_Transient *)anItem)
{
}

Handle_Standard_Failure& operator=(const Handle_Standard_Failure& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_Failure& operator=(const Standard_Failure* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_Failure* operator->() const
{
return (Standard_Failure *)ControlAccess();
}

static const Handle_Standard_Failure DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Standard_DomainError.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_Failure;
class Standard_DomainError;
Handle_Standard_Type& Standard_DomainError_Type_();

class Handle_Standard_DomainError : public Handle_Standard_Failure {
public:
Handle_Standard_DomainError():Handle_Standard_Failure() {}
Handle_Standard_DomainError(const Handle_Standard_DomainError& aHandle) : Handle_Standard_Failure(aHandle)
{
}

Handle_Standard_DomainError(const Standard_DomainError* anItem) : Handle_Standard_Failure((Standard_Failure *)anItem)
{
}

Handle_Standard_DomainError& operator=(const Handle_Standard_DomainError& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_DomainError& operator=(const Standard_DomainError* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_DomainError* operator->() const
{
return (Standard_DomainError *)ControlAccess();
}

static const Handle_Standard_DomainError DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Standard_RangeError.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_DomainError;
class Standard_RangeError;
Handle_Standard_Type& Standard_RangeError_Type_();

class Handle_Standard_RangeError : public Handle_Standard_DomainError {
public:
Handle_Standard_RangeError():Handle_Standard_DomainError() {}
Handle_Standard_RangeError(const Handle_Standard_RangeError& aHandle) : Handle_Standard_DomainError(aHandle)
{
}

Handle_Standard_RangeError(const Standard_RangeError* anItem) : Handle_Standard_DomainError((Standard_DomainError *)anItem)
{
}

Handle_Standard_RangeError& operator=(const Handle_Standard_RangeError& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_RangeError& operator=(const Standard_RangeError* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_RangeError* operator->() const
{
return (Standard_RangeError *)ControlAccess();
}

static const Handle_Standard_RangeError DownCast(const Handle_Standard_Transient& AnObject);
};
# 34 “/usr/include/opencascade/Handle_Standard_OutOfRange.hxx” 2

class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_RangeError;
class Standard_OutOfRange;
Handle_Standard_Type& Standard_OutOfRange_Type_();

class Handle_Standard_OutOfRange : public Handle_Standard_RangeError {
public:
Handle_Standard_OutOfRange():Handle_Standard_RangeError() {}
Handle_Standard_OutOfRange(const Handle_Standard_OutOfRange& aHandle) : Handle_Standard_RangeError(aHandle)
{
}

Handle_Standard_OutOfRange(const Standard_OutOfRange* anItem) : Handle_Standard_RangeError((Standard_RangeError *)anItem)
{
}

Handle_Standard_OutOfRange& operator=(const Handle_Standard_OutOfRange& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_OutOfRange& operator=(const Standard_OutOfRange* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_OutOfRange* operator->() const
{
return (Standard_OutOfRange *)ControlAccess();
}

static const Handle_Standard_OutOfRange DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/Standard_OutOfRange.hxx” 2

# 1 “/usr/include/opencascade/Standard_SStream.hxx” 1
# 52 “/usr/include/opencascade/Standard_SStream.hxx”
class Handle_Standard_Type;

Handle_Standard_Type& Standard_SStream_Type_();

class Standard_SStream : public strstream {

public:
Standard_SStream();
Standard_SStream(ostream& );
~Standard_SStream();
};
# 34 “/usr/include/opencascade/Standard_OutOfRange.hxx” 2

# 1 “/usr/include/opencascade/Standard_RangeError.hxx” 1
# 38 “/usr/include/opencascade/Standard_RangeError.hxx”
# 1 “/usr/include/opencascade/Standard_DomainError.hxx” 1
# 38 “/usr/include/opencascade/Standard_DomainError.hxx”
# 1 “/usr/include/opencascade/Standard_Failure.hxx” 1
# 45 “/usr/include/opencascade/Standard_Failure.hxx”
class Standard_NoSuchObject;

class Standard_Failure : public Standard_Transient {

public:

Standard_Failure();
Standard_Failure (const Standard_Failure& f);

Standard_Failure(const Standard_CString aString);
Standard_Failure& operator= (const Standard_Failure& f);

void Destroy() ;
~Standard_Failure()
{
Destroy();
}
# 83 “/usr/include/opencascade/Standard_Failure.hxx”
void Print(ostream& s) const;
void operator<<(ostream& s) const
{
Print(s);
}

Standard_CString GetMessageString() const;

void SetMessageString(const Standard_CString aMessage) ;

void Reraise() ;

void Reraise(const Standard_CString aMessage) ;

static void Raise(const Standard_CString aMessage = “”) ;

static void Raise(Standard_SStream& aReason) ;

static Handle_Standard_Failure NewInstance(const Standard_CString aMessage) ;

void Jump() const;

static Handle_Standard_Failure Caught() ;

const Handle_Standard_Type& DynamicType() const;

protected:
# 147 “/usr/include/opencascade/Standard_Failure.hxx”
virtual void Throw() const;

private:

Standard_CString myMessage;

};

# 1 “/usr/include/opencascade/Standard_Failure.lxx” 1
# 9 “/usr/include/opencascade/Standard_Failure.lxx”
inline ostream& operator <<(ostream& AStream,
const Handle_Standard_Failure& AFailure)
{
AFailure->Print(AStream);
return AStream;
}

inline Standard_CString Standard_Failure::GetMessageString () const
{
return (myMessage ? myMessage+sizeof(Standard_Integer) : myMessage);
}
# 169 “/usr/include/opencascade/Standard_Failure.hxx” 2
# 39 “/usr/include/opencascade/Standard_DomainError.hxx” 2
# 49 “/usr/include/opencascade/Standard_DomainError.hxx”
class Standard_DomainError : public Standard_Failure {

virtual void Throw() const;

public:
Standard_DomainError():Standard_Failure(){}
Standard_DomainError(const Standard_CString AString):Standard_Failure(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_DomainError NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_DomainError_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 39 “/usr/include/opencascade/Standard_RangeError.hxx” 2
# 49 “/usr/include/opencascade/Standard_RangeError.hxx”
class Standard_RangeError : public Standard_DomainError {

virtual void Throw() const;

public:
Standard_RangeError():Standard_DomainError(){}
Standard_RangeError(const Standard_CString AString):Standard_DomainError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_RangeError NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_RangeError_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 39 “/usr/include/opencascade/Standard_OutOfRange.hxx” 2
# 49 “/usr/include/opencascade/Standard_OutOfRange.hxx”
class Standard_OutOfRange : public Standard_RangeError {

virtual void Throw() const;

public:
Standard_OutOfRange():Standard_RangeError(){}
Standard_OutOfRange(const Standard_CString AString):Standard_RangeError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_OutOfRange NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_OutOfRange_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 5 “/usr/include/opencascade/gp_Mat.lxx” 2
# 1 “/usr/include/opencascade/Standard_ConstructionError.hxx” 1
# 29 “/usr/include/opencascade/Standard_ConstructionError.hxx”
# 1 “/usr/include/opencascade/Handle_Standard_ConstructionError.hxx” 1
# 36 “/usr/include/opencascade/Handle_Standard_ConstructionError.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_DomainError;
class Standard_ConstructionError;
Handle_Standard_Type& Standard_ConstructionError_Type_();

class Handle_Standard_ConstructionError : public Handle_Standard_DomainError {
public:
Handle_Standard_ConstructionError():Handle_Standard_DomainError() {}
Handle_Standard_ConstructionError(const Handle_Standard_ConstructionError& aHandle) : Handle_Standard_DomainError(aHandle)
{
}

Handle_Standard_ConstructionError(const Standard_ConstructionError* anItem) : Handle_Standard_DomainError((Standard_DomainError *)anItem)
{
}

Handle_Standard_ConstructionError& operator=(const Handle_Standard_ConstructionError& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_Standard_ConstructionError& operator=(const Standard_ConstructionError* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}

Standard_ConstructionError* operator->() const
{
return (Standard_ConstructionError *)ControlAccess();
}

static const Handle_Standard_ConstructionError DownCast(const Handle_Standard_Transient& AnObject);
};
# 30 “/usr/include/opencascade/Standard_ConstructionError.hxx” 2
# 49 “/usr/include/opencascade/Standard_ConstructionError.hxx”
class Standard_ConstructionError : public Standard_DomainError {

virtual void Throw() const;

public:
Standard_ConstructionError():Standard_DomainError(){}
Standard_ConstructionError(const Standard_CString AString):Standard_DomainError(AString){}
static void Raise(const Standard_CString aMessage = “”);
static void Raise(Standard_SStream& aReason);
static Handle_Standard_ConstructionError NewInstance(const Standard_CString aMessage);

friend Handle_Standard_Type& Standard_ConstructionError_Type_();
const Handle_Standard_Type& DynamicType() const;

};
# 6 “/usr/include/opencascade/gp_Mat.lxx” 2
# 37 “/usr/include/opencascade/gp_Mat.lxx”
inline gp_Mat::gp_Mat () {
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] =
((Standard_Real*)M)[1] =
((Standard_Real*)M)[2] =
((Standard_Real*)M)[3] =
((Standard_Real*)M)[4] =
((Standard_Real*)M)[5] =
((Standard_Real*)M)[6] =
((Standard_Real*)M)[7] =
((Standard_Real*)M)[8] = 0.0;
}

inline gp_Mat::gp_Mat (const Standard_Real a11,
const Standard_Real a12,
const Standard_Real a13,
const Standard_Real a21,
const Standard_Real a22,
const Standard_Real a23,
const Standard_Real a31,
const Standard_Real a32,
const Standard_Real a33) {

const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = a11;
((Standard_Real*)M)[1] = a12;
((Standard_Real*)M)[2] = a13;
((Standard_Real*)M)[3] = a21;
((Standard_Real*)M)[4] = a22;
((Standard_Real*)M)[5] = a23;
((Standard_Real*)M)[6] = a31;
((Standard_Real*)M)[7] = a32;
((Standard_Real*)M)[8] = a33;
}

inline void gp_Mat::SetDiagonal (const Standard_Real X1,
const Standard_Real X2,
const Standard_Real X3)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = X1; ((Standard_Real*)M)[4] = X2; ((Standard_Real*)M)[8] = X3;
}

inline void gp_Mat::SetIdentity ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[4] = ((Standard_Real*)M)[8] = 1.0;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = ((Standard_Real*)M)[3] = ((Standard_Real*)M)[5] = ((Standard_Real*)M)[6] = ((Standard_Real*)M)[7] = 0.0;
}

inline void gp_Mat::SetScale (const Standard_Real S)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[4] = ((Standard_Real*)M)[8] = S;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = ((Standard_Real*)M)[3] = ((Standard_Real*)M)[5] = ((Standard_Real*)M)[6] = ((Standard_Real*)M)[7] = 0.0;
}

inline void gp_Mat::SetValue (const Standard_Integer Row,
const Standard_Integer Col,
const Standard_Real Value)
{
if (Row < 1 || Row > 3 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

matrix[Row-1][Col-1] = Value;
}

inline Standard_Real gp_Mat::Determinant () const
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
return
((Standard_Real*)M)[0] * (((Standard_Real*)M)[4] * ((Standard_Real*)M)[8] – ((Standard_Real*)M)[7] * ((Standard_Real*)M)[5]) –
((Standard_Real*)M)[1] * (((Standard_Real*)M)[3] * ((Standard_Real*)M)[8] – ((Standard_Real*)M)[6] * ((Standard_Real*)M)[5]) +
((Standard_Real*)M)[2] * (((Standard_Real*)M)[3] * ((Standard_Real*)M)[7] – ((Standard_Real*)M)[6] * ((Standard_Real*)M)[4]);
}

inline const Standard_Real& gp_Mat::Value (const Standard_Integer Row,
const Standard_Integer Col) const
{
if (Row < 1 || Row > 3 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Real& gp_Mat::ChangeValue (const Standard_Integer Row,
const Standard_Integer Col)
{
if (Row < 1 || Row > 3 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Boolean gp_Mat::IsSingular () const
{

Standard_Real val = Determinant();
if (val < 0) val = – val;
return val <= gp::Resolution();
}

inline void gp_Mat::Add (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[0] + ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] = ((Standard_Real*)M)[2] + ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] = ((Standard_Real*)M)[3] + ((Standard_Real*)O)[3];
((Standard_Real*)M)[4] = ((Standard_Real*)M)[4] + ((Standard_Real*)O)[4];
((Standard_Real*)M)[5] = ((Standard_Real*)M)[5] + ((Standard_Real*)O)[5];
((Standard_Real*)M)[6] = ((Standard_Real*)M)[6] + ((Standard_Real*)O)[6];
((Standard_Real*)M)[7] = ((Standard_Real*)M)[7] + ((Standard_Real*)O)[7];
((Standard_Real*)M)[8] = ((Standard_Real*)M)[8] + ((Standard_Real*)O)[8];
}

inline gp_Mat gp_Mat::Added (const gp_Mat& Other) const
{
gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] + ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] + ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] + ((Standard_Real*)O)[3];
((Standard_Real*)N)[4] = ((Standard_Real*)M)[4] + ((Standard_Real*)O)[4];
((Standard_Real*)N)[5] = ((Standard_Real*)M)[5] + ((Standard_Real*)O)[5];
((Standard_Real*)N)[6] = ((Standard_Real*)M)[6] + ((Standard_Real*)O)[6];
((Standard_Real*)N)[7] = ((Standard_Real*)M)[7] + ((Standard_Real*)O)[7];
((Standard_Real*)N)[8] = ((Standard_Real*)M)[8] + ((Standard_Real*)O)[8];
return NewMat;
}

inline void gp_Mat::Divide (const Standard_Real Scalar)
{
Standard_Real val = Scalar;
if (val < 0) val = – val;
if (val <= gp::Resolution()) Standard_ConstructionError::Raise(“gp_Mat : Divide by 0”);;

Standard_Real UnSurScalar = 1.0 / Scalar;
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] *= UnSurScalar;
((Standard_Real*)M)[1] *= UnSurScalar;
((Standard_Real*)M)[2] *= UnSurScalar;
((Standard_Real*)M)[3] *= UnSurScalar;
((Standard_Real*)M)[4] *= UnSurScalar;
((Standard_Real*)M)[5] *= UnSurScalar;
((Standard_Real*)M)[6] *= UnSurScalar;
((Standard_Real*)M)[7] *= UnSurScalar;
((Standard_Real*)M)[8] *= UnSurScalar;
}

inline gp_Mat gp_Mat::Divided (const Standard_Real Scalar) const
{
Standard_Real val = Scalar;
if (val < 0) val = – val;
if (val <= gp::Resolution()) Standard_ConstructionError::Raise(“gp_Mat : Divide by 0”);;

gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
Standard_Real UnSurScalar = 1.0 / Scalar;
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] * UnSurScalar;
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] * UnSurScalar;
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] * UnSurScalar;
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] * UnSurScalar;
((Standard_Real*)N)[4] = ((Standard_Real*)M)[4] * UnSurScalar;
((Standard_Real*)N)[5] = ((Standard_Real*)M)[5] * UnSurScalar;
((Standard_Real*)N)[6] = ((Standard_Real*)M)[6] * UnSurScalar;
((Standard_Real*)N)[7] = ((Standard_Real*)M)[7] * UnSurScalar;
((Standard_Real*)N)[8] = ((Standard_Real*)M)[8] * UnSurScalar;
return NewMat;
}

inline gp_Mat gp_Mat::Multiplied (const gp_Mat& Other) const
{
gp_Mat NewMat = *this;
NewMat.Multiply(Other);
return NewMat;
}

inline void gp_Mat::Multiply (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
Standard_Real T00,T01,T02,T10,T11,T12,T20,T21,T22;
T00 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[3] + ((Standard_Real*)M)[2] * ((Standard_Real*)O)[6];
T01 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[4] + ((Standard_Real*)M)[2] * ((Standard_Real*)O)[7];
T02 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[2] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[5] + ((Standard_Real*)M)[2] * ((Standard_Real*)O)[8];
T10 = ((Standard_Real*)M)[3] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[4] * ((Standard_Real*)O)[3] + ((Standard_Real*)M)[5] * ((Standard_Real*)O)[6];
T11 = ((Standard_Real*)M)[3] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[4] * ((Standard_Real*)O)[4] + ((Standard_Real*)M)[5] * ((Standard_Real*)O)[7];
T12 = ((Standard_Real*)M)[3] * ((Standard_Real*)O)[2] + ((Standard_Real*)M)[4] * ((Standard_Real*)O)[5] + ((Standard_Real*)M)[5] * ((Standard_Real*)O)[8];
T20 = ((Standard_Real*)M)[6] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[7] * ((Standard_Real*)O)[3] + ((Standard_Real*)M)[8] * ((Standard_Real*)O)[6];
T21 = ((Standard_Real*)M)[6] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[7] * ((Standard_Real*)O)[4] + ((Standard_Real*)M)[8] * ((Standard_Real*)O)[7];
T22 = ((Standard_Real*)M)[6] * ((Standard_Real*)O)[2] + ((Standard_Real*)M)[7] * ((Standard_Real*)O)[5] + ((Standard_Real*)M)[8] * ((Standard_Real*)O)[8];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[1] = T01;
((Standard_Real*)M)[2] = T02;
((Standard_Real*)M)[3] = T10;
((Standard_Real*)M)[4] = T11;
((Standard_Real*)M)[5] = T12;
((Standard_Real*)M)[6] = T20;
((Standard_Real*)M)[7] = T21;
((Standard_Real*)M)[8] = T22;
}

inline void gp_Mat::PreMultiply (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
Standard_Real T00,T01,T02,T10,T11,T12,T20,T21,T22;
T00 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[3] + ((Standard_Real*)O)[2] * ((Standard_Real*)M)[6];
T01 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[4] + ((Standard_Real*)O)[2] * ((Standard_Real*)M)[7];
T02 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[2] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[5] + ((Standard_Real*)O)[2] * ((Standard_Real*)M)[8];
T10 = ((Standard_Real*)O)[3] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[4] * ((Standard_Real*)M)[3] + ((Standard_Real*)O)[5] * ((Standard_Real*)M)[6];
T11 = ((Standard_Real*)O)[3] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[4] * ((Standard_Real*)M)[4] + ((Standard_Real*)O)[5] * ((Standard_Real*)M)[7];
T12 = ((Standard_Real*)O)[3] * ((Standard_Real*)M)[2] + ((Standard_Real*)O)[4] * ((Standard_Real*)M)[5] + ((Standard_Real*)O)[5] * ((Standard_Real*)M)[8];
T20 = ((Standard_Real*)O)[6] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[7] * ((Standard_Real*)M)[3] + ((Standard_Real*)O)[8] * ((Standard_Real*)M)[6];
T21 = ((Standard_Real*)O)[6] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[7] * ((Standard_Real*)M)[4] + ((Standard_Real*)O)[8] * ((Standard_Real*)M)[7];
T22 = ((Standard_Real*)O)[6] * ((Standard_Real*)M)[2] + ((Standard_Real*)O)[7] * ((Standard_Real*)M)[5] + ((Standard_Real*)O)[8] * ((Standard_Real*)M)[8];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[1] = T01;
((Standard_Real*)M)[2] = T02;
((Standard_Real*)M)[3] = T10;
((Standard_Real*)M)[4] = T11;
((Standard_Real*)M)[5] = T12;
((Standard_Real*)M)[6] = T20;
((Standard_Real*)M)[7] = T21;
((Standard_Real*)M)[8] = T22;
}

inline gp_Mat gp_Mat::Multiplied (const Standard_Real Scalar) const
{
gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
((Standard_Real*)N)[0] = Scalar * ((Standard_Real*)M)[0];
((Standard_Real*)N)[1] = Scalar * ((Standard_Real*)M)[1];
((Standard_Real*)N)[2] = Scalar * ((Standard_Real*)M)[2];
((Standard_Real*)N)[3] = Scalar * ((Standard_Real*)M)[3];
((Standard_Real*)N)[4] = Scalar * ((Standard_Real*)M)[4];
((Standard_Real*)N)[5] = Scalar * ((Standard_Real*)M)[5];
((Standard_Real*)N)[6] = Scalar * ((Standard_Real*)M)[6];
((Standard_Real*)N)[7] = Scalar * ((Standard_Real*)M)[7];
((Standard_Real*)N)[8] = Scalar * ((Standard_Real*)M)[8];
return NewMat;
}

inline void gp_Mat::Multiply (const Standard_Real Scalar)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] *= Scalar;
((Standard_Real*)M)[1] *= Scalar;
((Standard_Real*)M)[2] *= Scalar;
((Standard_Real*)M)[3] *= Scalar;
((Standard_Real*)M)[4] *= Scalar;
((Standard_Real*)M)[5] *= Scalar;
((Standard_Real*)M)[6] *= Scalar;
((Standard_Real*)M)[7] *= Scalar;
((Standard_Real*)M)[8] *= Scalar;
}

inline gp_Mat gp_Mat::Powered (const Standard_Integer N) const
{
gp_Mat MatN = *this;
MatN.Power (N);
return MatN;
}

inline void gp_Mat::Subtract (const gp_Mat& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] -= ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] -= ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] -= ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] -= ((Standard_Real*)O)[3];
((Standard_Real*)M)[4] -= ((Standard_Real*)O)[4];
((Standard_Real*)M)[5] -= ((Standard_Real*)O)[5];
((Standard_Real*)M)[6] -= ((Standard_Real*)O)[6];
((Standard_Real*)M)[7] -= ((Standard_Real*)O)[7];
((Standard_Real*)M)[8] -= ((Standard_Real*)O)[8];
}

inline gp_Mat gp_Mat::Subtracted (const gp_Mat& Other) const
{
gp_Mat NewMat;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] – ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] – ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] – ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] – ((Standard_Real*)O)[3];
((Standard_Real*)N)[4] = ((Standard_Real*)M)[4] – ((Standard_Real*)O)[4];
((Standard_Real*)N)[5] = ((Standard_Real*)M)[5] – ((Standard_Real*)O)[5];
((Standard_Real*)N)[6] = ((Standard_Real*)M)[6] – ((Standard_Real*)O)[6];
((Standard_Real*)N)[7] = ((Standard_Real*)M)[7] – ((Standard_Real*)O)[7];
((Standard_Real*)N)[8] = ((Standard_Real*)M)[8] – ((Standard_Real*)O)[8];
return NewMat;
}

inline void gp_Mat::Transpose ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
Standard_Real Temp;
Temp = ((Standard_Real*)M)[1];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[3];
((Standard_Real*)M)[3] = Temp;
Temp = ((Standard_Real*)M)[2];
((Standard_Real*)M)[2] = ((Standard_Real*)M)[6];
((Standard_Real*)M)[6] = Temp;
Temp = ((Standard_Real*)M)[5];
((Standard_Real*)M)[5] = ((Standard_Real*)M)[7];
((Standard_Real*)M)[7] = Temp;
}

inline gp_Mat gp_Mat::Transposed () const
{
gp_Mat NewMat = *this;
NewMat.Transpose();
return NewMat;
}

inline gp_Mat operator* (const Standard_Real Scalar, const gp_Mat& Mat3D)
{ return Mat3D.Multiplied (Scalar); }
# 327 “/usr/include/opencascade/gp_Mat.hxx” 2
# 33 “/usr/include/opencascade/gp_Trsf.hxx” 2

# 1 “/usr/include/opencascade/gp_XYZ.hxx” 1
# 40 “/usr/include/opencascade/gp_XYZ.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_Mat;
# 52 “/usr/include/opencascade/gp_XYZ.hxx”
Handle_Standard_Type& gp_XYZ_Type_();
# 61 “/usr/include/opencascade/gp_XYZ.hxx”
class gp_XYZ {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_XYZ();

gp_XYZ(const Standard_Real X,const Standard_Real Y,const Standard_Real Z);

void SetCoord(const Standard_Real X,const Standard_Real Y,const Standard_Real Z) ;

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& X,Standard_Real& Y,Standard_Real& Z) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

Standard_Real Modulus() const;

Standard_Real SquareModulus() const;
# 127 “/usr/include/opencascade/gp_XYZ.hxx”
Standard_Boolean IsEqual(const gp_XYZ& Other,const Standard_Real Tolerance) const;

void Add(const gp_XYZ& Other) ;
void operator +=(const gp_XYZ& Other)
{
Add(Other);
}

gp_XYZ Added(const gp_XYZ& Other) const;
gp_XYZ operator +(const gp_XYZ& Other) const
{
return Added(Other);
}

void Cross(const gp_XYZ& Right) ;
void operator ^=(const gp_XYZ& Right)
{
Cross(Right);
}

gp_XYZ Crossed(const gp_XYZ& Right) const;
gp_XYZ operator ^(const gp_XYZ& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_XYZ& Right) const;

Standard_Real CrossSquareMagnitude(const gp_XYZ& Right) const;

void CrossCross(const gp_XYZ& Coord1,const gp_XYZ& Coord2) ;

gp_XYZ CrossCrossed(const gp_XYZ& Coord1,const gp_XYZ& Coord2) const;

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_XYZ Divided(const Standard_Real Scalar) const;
gp_XYZ operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

Standard_Real Dot(const gp_XYZ& Other) const;
Standard_Real operator *(const gp_XYZ& Other) const
{
return Dot(Other);
}

Standard_Real DotCross(const gp_XYZ& Coord1,const gp_XYZ& Coord2) const;

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Multiply(const gp_XYZ& Other) ;
void operator *=(const gp_XYZ& Other)
{
Multiply(Other);
}

void Multiply(const gp_Mat& Matrix) ;
void operator *=(const gp_Mat& Matrix)
{
Multiply(Matrix);
}

gp_XYZ Multiplied(const Standard_Real Scalar) const;
gp_XYZ operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

gp_XYZ Multiplied(const gp_XYZ& Other) const;

gp_XYZ Multiplied(const gp_Mat& Matrix) const;
gp_XYZ operator *(const gp_Mat& Matrix) const
{
return Multiplied(Matrix);
}

void Normalize() ;

gp_XYZ Normalized() const;

void Reverse() ;

gp_XYZ Reversed() const;

void Subtract(const gp_XYZ& Right) ;
void operator -=(const gp_XYZ& Right)
{
Subtract(Right);
}

gp_XYZ Subtracted(const gp_XYZ& Right) const;
gp_XYZ operator -(const gp_XYZ& Right) const
{
return Subtracted(Right);
}

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2,const Standard_Real A3,const gp_XYZ& XYZ3,const gp_XYZ& XYZ4) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2,const Standard_Real A3,const gp_XYZ& XYZ3) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2,const gp_XYZ& XYZ3) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const Standard_Real A2,const gp_XYZ& XYZ2) ;

void SetLinearForm(const Standard_Real A1,const gp_XYZ& XYZ1,const gp_XYZ& XYZ2) ;

void SetLinearForm(const gp_XYZ& XYZ1,const gp_XYZ& XYZ2) ;
Standard_Real _CSFDB_Getgp_XYZx() const { return x; }
void _CSFDB_Setgp_XYZx(const Standard_Real p) { x = p; }
Standard_Real _CSFDB_Getgp_XYZy() const { return y; }
void _CSFDB_Setgp_XYZy(const Standard_Real p) { y = p; }
Standard_Real _CSFDB_Getgp_XYZz() const { return z; }
void _CSFDB_Setgp_XYZz(const Standard_Real p) { z = p; }

friend Handle_Standard_Type& gp_XYZ_Type_();

protected:
# 342 “/usr/include/opencascade/gp_XYZ.hxx”
private:

Standard_Real x;
Standard_Real y;
Standard_Real z;

};

# 1 “/usr/include/opencascade/gp_XYZ.lxx” 1
# 19 “/usr/include/opencascade/gp_XYZ.lxx”
inline gp_XYZ::gp_XYZ () { }

inline gp_XYZ::gp_XYZ (const Standard_Real X,
const Standard_Real Y,
const Standard_Real Z) : x(X),y(Y),z(Z) { }

inline void gp_XYZ::SetCoord (const Standard_Real X,
const Standard_Real Y,
const Standard_Real Z)
{ x = X; y = Y; z = Z; }

inline void gp_XYZ::SetCoord (const Standard_Integer i,
const Standard_Real X) {
if (i < 1 || i > 3) Standard_OutOfRange::Raise(__null);;
(&x)[i-1] = X;
}

inline void gp_XYZ::SetX (const Standard_Real X)
{ x = X; }

inline void gp_XYZ::SetY (const Standard_Real Y)
{ y = Y; }

inline void gp_XYZ::SetZ (const Standard_Real Z)
{ z = Z; }

inline Standard_Real gp_XYZ::Coord (const Standard_Integer i) const {
if (i < 1 || i > 3) Standard_OutOfRange::Raise(__null);;
return (&x)[i-1];
}

inline void gp_XYZ::Coord (Standard_Real& X,
Standard_Real& Y,
Standard_Real& Z) const
{ X = x; Y = y; Z = z; }

inline Standard_Real gp_XYZ::X () const
{ return x; }

inline Standard_Real gp_XYZ::Y () const
{ return y; }

inline Standard_Real gp_XYZ::Z () const
{ return z; }

inline Standard_Real gp_XYZ::Modulus () const {
return sqrt (x * x + y * y + z * z);
}

inline Standard_Real gp_XYZ::SquareModulus () const {
return (x * x + y * y + z * z);
}

inline void gp_XYZ::Add (const gp_XYZ& Other)
{
x += Other.x;
y += Other.y;
z += Other.z;
}

inline gp_XYZ gp_XYZ::Added (const gp_XYZ& Other) const {
return gp_XYZ(x + Other.x,y + Other.y,z + Other.z);
}

inline void gp_XYZ::Cross (const gp_XYZ& Right)
{
Standard_Real Xresult = y * Right.z – z * Right.y;
Standard_Real Yresult = z * Right.x – x * Right.z;
z = x * Right.y – y * Right.x;
x = Xresult;
y = Yresult;
}

inline gp_XYZ gp_XYZ::Crossed (const gp_XYZ& Right) const
{
return gp_XYZ (y * Right.z – z * Right.y,
z * Right.x – x * Right.z,
x * Right.y – y * Right.x);
}

inline Standard_Real gp_XYZ::CrossMagnitude (const gp_XYZ& Right) const
{
Standard_Real Xresult = y * Right.z – z * Right.y;
Standard_Real Yresult = z * Right.x – x * Right.z;
Standard_Real Zresult = x * Right.y – y * Right.x;
return sqrt(Xresult * Xresult + Yresult * Yresult + Zresult * Zresult);
}

inline Standard_Real gp_XYZ::CrossSquareMagnitude (const gp_XYZ& Right) const
{
Standard_Real Xresult = y * Right.z – z * Right.y;
Standard_Real Yresult = z * Right.x – x * Right.z;
Standard_Real Zresult = x * Right.y – y * Right.x;
return Xresult * Xresult + Yresult * Yresult + Zresult * Zresult;
}

inline void gp_XYZ::CrossCross (const gp_XYZ& Coord1,
const gp_XYZ& Coord2)
{
Standard_Real Xresult =
y * (Coord1.x * Coord2.y – Coord1.y * Coord2.x) –
z * (Coord1.z * Coord2.x – Coord1.x * Coord2.z);
Standard_Real Yresult =
z * (Coord1.y * Coord2.z – Coord1.z * Coord2.y) –
x * (Coord1.x * Coord2.y – Coord1.y * Coord2.x);
z =
x * (Coord1.z * Coord2.x – Coord1.x * Coord2.z) –
y * (Coord1.y * Coord2.z – Coord1.z * Coord2.y);
x = Xresult;
y = Yresult;
}

inline gp_XYZ gp_XYZ::CrossCrossed (const gp_XYZ& Coord1,
const gp_XYZ& Coord2) const
{
gp_XYZ Coord0 = *this;
Coord0.CrossCross (Coord1, Coord2);
return Coord0;
}

inline void gp_XYZ::Divide (const Standard_Real Scalar)
{
x /= Scalar;
y /= Scalar;
z /= Scalar;
}

inline gp_XYZ gp_XYZ::Divided (const Standard_Real Scalar) const {
return gp_XYZ(x / Scalar,y / Scalar,z / Scalar);
}

inline Standard_Real gp_XYZ::Dot (const gp_XYZ& Other) const {
return(x * Other.x + y * Other.y + z * Other.z);
}

inline Standard_Real gp_XYZ::DotCross (const gp_XYZ& Coord1,
const gp_XYZ& Coord2) const
{
Standard_Real Xresult = Coord1.y * Coord2.z – Coord1.z * Coord2.y;
Standard_Real Yresult = Coord1.z * Coord2.x – Coord1.x * Coord2.z;
Standard_Real Zresult = Coord1.x * Coord2.y – Coord1.y * Coord2.x;
return ( x * Xresult + y * Yresult + z * Zresult);
}

inline void gp_XYZ::Multiply (const Standard_Real Scalar)
{
x *= Scalar;
y *= Scalar;
z *= Scalar;
}

inline void gp_XYZ::Multiply (const gp_XYZ& Other)
{
x *= Other.x;
y *= Other.y;
z *= Other.z;
}

inline void gp_XYZ::Multiply (const gp_Mat& Matrix)
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
Standard_Real Xresult = ((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y + ((Standard_Real*)M)[2] * z;
Standard_Real Yresult = ((Standard_Real*)M)[3] * x + ((Standard_Real*)M)[4] * y + ((Standard_Real*)M)[5] * z;
z = ((Standard_Real*)M)[6] * x + ((Standard_Real*)M)[7] * y + ((Standard_Real*)M)[8] * z;
x = Xresult;
y = Yresult;
}

inline gp_XYZ gp_XYZ::Multiplied (const Standard_Real Scalar) const {
return gp_XYZ(x * Scalar,y * Scalar,z * Scalar);
}

inline gp_XYZ gp_XYZ::Multiplied (const gp_XYZ& Other) const {
return gp_XYZ(x * Other.x, y * Other.y, z * Other.z);
}

inline gp_XYZ gp_XYZ::Multiplied (const gp_Mat& Matrix) const
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
return gp_XYZ (((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y + ((Standard_Real*)M)[2] * z,
((Standard_Real*)M)[3] * x + ((Standard_Real*)M)[4] * y + ((Standard_Real*)M)[5] * z,
((Standard_Real*)M)[6] * x + ((Standard_Real*)M)[7] * y + ((Standard_Real*)M)[8] * z);
}

inline void gp_XYZ::Normalize ()
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
x = x / D; y = y / D; z = z / D;
}

inline gp_XYZ gp_XYZ::Normalized () const
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
return gp_XYZ (x / D, y / D, z / D);
}

inline void gp_XYZ::Reverse ()
{
x = – x;
y = – y;
z = – z;
}

inline gp_XYZ gp_XYZ::Reversed () const
{
return gp_XYZ(-x, -y, -z);
}

inline void gp_XYZ::Subtract (const gp_XYZ& Right)
{
x-=Right.x;
y-=Right.y;
z-=Right.z;
}

inline gp_XYZ gp_XYZ::Subtracted (const gp_XYZ& Right) const
{
return gp_XYZ(x – Right.x, y – Right.y, z – Right.z);
}

inline void gp_XYZ::SetLinearForm (const Standard_Real L,
const gp_XYZ& Left,
const Standard_Real R,
const gp_XYZ& Right) {

x = L * Left.x + R * Right.x;
y = L * Left.y + R * Right.y;
z = L * Left.z + R * Right.z;
}

inline void gp_XYZ::SetLinearForm(const Standard_Real L,
const gp_XYZ& Left,
const gp_XYZ& Right) {
x = L * Left.x + Right.x;
y = L * Left.y + Right.y;
z = L * Left.z + Right.z;
}

inline void gp_XYZ::SetLinearForm (const gp_XYZ& Left, const gp_XYZ& Right) {
x = Left.x + Right.x;
y = Left.y + Right.y;
z = Left.z + Right.z;
}

inline void gp_XYZ::SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1,
const Standard_Real A2, const gp_XYZ& XYZ2,
const Standard_Real A3, const gp_XYZ& XYZ3) {

x = A1 * XYZ1.x + A2 * XYZ2.x + A3 * XYZ3.x;
y = A1 * XYZ1.y + A2 * XYZ2.y + A3 * XYZ3.y;
z = A1 * XYZ1.z + A2 * XYZ2.z + A3 * XYZ3.z;
}

inline void gp_XYZ::SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1,
const Standard_Real A2, const gp_XYZ& XYZ2,
const gp_XYZ& XYZ3) {
x = A1 * XYZ1.x + A2 * XYZ2.x + XYZ3.x;
y = A1 * XYZ1.y + A2 * XYZ2.y + XYZ3.y;
z = A1 * XYZ1.z + A2 * XYZ2.z + XYZ3.z;
}

inline void gp_XYZ::SetLinearForm (const Standard_Real A1, const gp_XYZ& XYZ1,
const Standard_Real A2, const gp_XYZ& XYZ2,
const Standard_Real A3, const gp_XYZ& XYZ3,
const gp_XYZ& XYZ4) {
x = A1 * XYZ1.x + A2 * XYZ2.x + A3 * XYZ3.x + XYZ4.x;
y = A1 * XYZ1.y + A2 * XYZ2.y + A3 * XYZ3.y + XYZ4.y;
z = A1 * XYZ1.z + A2 * XYZ2.z + A3 * XYZ3.z + XYZ4.z;

}

inline gp_XYZ operator* (const gp_Mat& Matrix, const gp_XYZ& Coord1) {
return Coord1.Multiplied (Matrix);
}

inline gp_XYZ operator* (const Standard_Real Scalar, const gp_XYZ& Coord1) {
return Coord1.Multiplied (Scalar);
}
# 359 “/usr/include/opencascade/gp_XYZ.hxx” 2
# 36 “/usr/include/opencascade/gp_Trsf.hxx” 2
# 49 “/usr/include/opencascade/gp_Trsf.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_GTrsf;
class gp_Trsf2d;
class gp_Pnt;
class gp_Ax1;
class gp_Ax2;
class gp_Ax3;
class gp_Vec;
class gp_XYZ;
class gp_Mat;
# 69 “/usr/include/opencascade/gp_Trsf.hxx”
Handle_Standard_Type& gp_Trsf_Type_();
# 85 “/usr/include/opencascade/gp_Trsf.hxx”
class gp_Trsf {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Trsf();
# 121 “/usr/include/opencascade/gp_Trsf.hxx”
gp_Trsf(const gp_Trsf2d& T);

void SetMirror(const gp_Pnt& P) ;

void SetMirror(const gp_Ax1& A1) ;

void SetMirror(const gp_Ax2& A2) ;

void SetRotation(const gp_Ax1& A1,const Standard_Real Ang) ;

void SetScale(const gp_Pnt& P,const Standard_Real S) ;
# 172 “/usr/include/opencascade/gp_Trsf.hxx”
void SetDisplacement(const gp_Ax3& FromSystem1,const gp_Ax3& ToSystem2) ;
# 192 “/usr/include/opencascade/gp_Trsf.hxx”
void SetTransformation(const gp_Ax3& FromSystem1,const gp_Ax3& ToSystem2) ;
# 204 “/usr/include/opencascade/gp_Trsf.hxx”
void SetTransformation(const gp_Ax3& ToSystem) ;

void SetTranslation(const gp_Vec& V) ;

void SetTranslation(const gp_Pnt& P1,const gp_Pnt& P2) ;

void SetTranslationPart(const gp_Vec& V) ;

void SetScaleFactor(const Standard_Real S) ;
# 236 “/usr/include/opencascade/gp_Trsf.hxx”
void SetValues(const Standard_Real a11,const Standard_Real a12,const Standard_Real a13,const Standard_Real a14,const Standard_Real a21,const Standard_Real a22,const Standard_Real a23,const Standard_Real a24,const Standard_Real a31,const Standard_Real a32,const Standard_Real a33,const Standard_Real a34,const Standard_Real Tolang,const Standard_Real TolDist) ;

Standard_Boolean IsNegative() const;

gp_TrsfForm Form() const;

Standard_Real ScaleFactor() const;

const gp_XYZ& TranslationPart() const;

gp_Mat VectorialPart() const;

const gp_Mat& HVectorialPart() const;

Standard_Real Value(const Standard_Integer Row,const Standard_Integer Col) const;

void Invert() ;
# 287 “/usr/include/opencascade/gp_Trsf.hxx”
gp_Trsf Inverted() const;

gp_Trsf Multiplied(const gp_Trsf& T) const;
gp_Trsf operator *(const gp_Trsf& T) const
{
return Multiplied(T);
}
# 310 “/usr/include/opencascade/gp_Trsf.hxx”
void Multiply(const gp_Trsf& T) ;
void operator *=(const gp_Trsf& T)
{
Multiply(T);
}

void PreMultiply(const gp_Trsf& T) ;

void Power(const Standard_Integer N) ;

gp_Trsf Powered(const Standard_Integer N) ;

void Transforms(Standard_Real& X,Standard_Real& Y,Standard_Real& Z) const;

void Transforms(gp_XYZ& Coord) const;
Standard_Real _CSFDB_Getgp_Trsfscale() const { return scale; }
void _CSFDB_Setgp_Trsfscale(const Standard_Real p) { scale = p; }
gp_TrsfForm _CSFDB_Getgp_Trsfshape() const { return shape; }
void _CSFDB_Setgp_Trsfshape(const gp_TrsfForm p) { shape = p; }
const gp_Mat& _CSFDB_Getgp_Trsfmatrix() const { return matrix; }
const gp_XYZ& _CSFDB_Getgp_Trsfloc() const { return loc; }

friend class gp_GTrsf;

friend Handle_Standard_Type& gp_Trsf_Type_();

protected:
# 359 “/usr/include/opencascade/gp_Trsf.hxx”
private:

Standard_Real scale;
gp_TrsfForm shape;
gp_Mat matrix;
gp_XYZ loc;

};

# 1 “/usr/include/opencascade/gp_Trsf.lxx” 1

# 1 “/usr/include/opencascade/gp_Trsf2d.hxx” 1
# 32 “/usr/include/opencascade/gp_Trsf2d.hxx”
# 1 “/usr/include/opencascade/gp_Mat2d.hxx” 1
# 40 “/usr/include/opencascade/gp_Mat2d.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_Trsf2d;
class gp_GTrsf2d;
class gp_XY;
# 54 “/usr/include/opencascade/gp_Mat2d.hxx”
Handle_Standard_Type& gp_Mat2d_Type_();

class gp_Mat2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Mat2d();

gp_Mat2d(const gp_XY& Col1,const gp_XY& Col2);

void SetCol(const Standard_Integer Col,const gp_XY& Value) ;

void SetCols(const gp_XY& Col1,const gp_XY& Col2) ;

void SetDiagonal(const Standard_Real X1,const Standard_Real X2) ;

void SetIdentity() ;

void SetRotation(const Standard_Real Ang) ;

void SetRow(const Standard_Integer Row,const gp_XY& Value) ;

void SetRows(const gp_XY& Row1,const gp_XY& Row2) ;

void SetScale(const Standard_Real S) ;

void SetValue(const Standard_Integer Row,const Standard_Integer Col,const Standard_Real Value) ;

gp_XY Column(const Standard_Integer Col) const;

Standard_Real Determinant() const;

gp_XY Diagonal() const;

gp_XY Row(const Standard_Integer Row) const;

const Standard_Real& Value(const Standard_Integer Row,const Standard_Integer Col) const;
const Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col) const
{
return Value(Row,Col);
}

Standard_Real& ChangeValue(const Standard_Integer Row,const Standard_Integer Col) ;
Standard_Real& operator()(const Standard_Integer Row,const Standard_Integer Col)
{
return ChangeValue(Row,Col);
}

Standard_Boolean IsSingular() const;

void Add(const gp_Mat2d& Other) ;
void operator +=(const gp_Mat2d& Other)
{
Add(Other);
}
# 169 “/usr/include/opencascade/gp_Mat2d.hxx”
gp_Mat2d Added(const gp_Mat2d& Other) const;
gp_Mat2d operator +(const gp_Mat2d& Other) const
{
return Added(Other);
}

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Mat2d Divided(const Standard_Real Scalar) const;
gp_Mat2d operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

void Invert() ;

gp_Mat2d Inverted() const;

gp_Mat2d Multiplied(const gp_Mat2d& Other) const;
gp_Mat2d operator *(const gp_Mat2d& Other) const
{
return Multiplied(Other);
}

void Multiply(const gp_Mat2d& Other) ;

void PreMultiply(const gp_Mat2d& Other) ;

gp_Mat2d Multiplied(const Standard_Real Scalar) const;
gp_Mat2d operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Power(const Standard_Integer N) ;

gp_Mat2d Powered(const Standard_Integer N) const;

void Subtract(const gp_Mat2d& Other) ;
void operator -=(const gp_Mat2d& Other)
{
Subtract(Other);
}

gp_Mat2d Subtracted(const gp_Mat2d& Other) const;
gp_Mat2d operator -(const gp_Mat2d& Other) const
{
return Subtracted(Other);
}

void Transpose() ;

gp_Mat2d Transposed() const;
Standard_Real& _CSFDB_Getgp_Mat2dmatrix(const Standard_Integer i1,const Standard_Integer i2) { return matrix[i1][i2]; }

friend class gp_Trsf2d;
friend class gp_GTrsf2d;
friend class gp_XY;

friend Handle_Standard_Type& gp_Mat2d_Type_();

protected:
# 278 “/usr/include/opencascade/gp_Mat2d.hxx”
private:

Standard_Real matrix[2][2];

};

# 1 “/usr/include/opencascade/gp_Mat2d.lxx” 1
# 21 “/usr/include/opencascade/gp_Mat2d.lxx”
inline gp_Mat2d::gp_Mat2d ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = ((Standard_Real*)M)[3] = 0.0;
}

inline void gp_Mat2d::SetDiagonal (const Standard_Real X1,
const Standard_Real X2)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = X1; ((Standard_Real*)M)[3] = X2;
}

inline void gp_Mat2d::SetIdentity ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[3] = 1.0;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = 0.0;
}

inline void gp_Mat2d::SetRotation (const Standard_Real Ang)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
Standard_Real SinA = sin(Ang);
Standard_Real CosA = cos(Ang);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[3] = CosA;
((Standard_Real*)M)[1] = -SinA;
((Standard_Real*)M)[2] = SinA;
}

inline void gp_Mat2d::SetScale (const Standard_Real S)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] = ((Standard_Real*)M)[3] = S;
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2] = 0.0;
}

inline void gp_Mat2d::SetValue (const Standard_Integer Row,
const Standard_Integer Col,
const Standard_Real Value)
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 2) Standard_OutOfRange::Raise(” “);;

matrix[Row-1][Col-1] = Value;
}

inline Standard_Real gp_Mat2d::Determinant () const
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
return ((Standard_Real*)M)[0] * ((Standard_Real*)M)[3] – ((Standard_Real*)M)[2] * ((Standard_Real*)M)[1];
}

inline const Standard_Real& gp_Mat2d::Value (const Standard_Integer Row,
const Standard_Integer Col) const
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 2) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Real&
gp_Mat2d::ChangeValue (const Standard_Integer Row,
const Standard_Integer Col)
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 2) Standard_OutOfRange::Raise(” “);;

return matrix[Row-1][Col-1];
}

inline Standard_Boolean gp_Mat2d::IsSingular () const
{
Standard_Real det = Determinant();
if (det < 0) det = – det;
return det <= gp::Resolution();
}

inline void gp_Mat2d::Add (const gp_Mat2d& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] += ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] += ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] += ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] += ((Standard_Real*)O)[3];
}

inline gp_Mat2d gp_Mat2d::Added (const gp_Mat2d& Other) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] + ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] + ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] + ((Standard_Real*)O)[3];
return NewMat2d;
}

inline void gp_Mat2d::Divide (const Standard_Real Scalar)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] /= Scalar;
((Standard_Real*)M)[1] /= Scalar;
((Standard_Real*)M)[2] /= Scalar;
((Standard_Real*)M)[3] /= Scalar;
}

inline gp_Mat2d gp_Mat2d::Divided (const Standard_Real Scalar) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] / Scalar;
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] / Scalar;
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] / Scalar;
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] / Scalar;
return NewMat2d;
}

inline gp_Mat2d gp_Mat2d::Inverted () const
{
gp_Mat2d NewMat = *this;
NewMat.Invert();
return NewMat;
}

inline gp_Mat2d gp_Mat2d::Multiplied (const gp_Mat2d& Other) const
{
gp_Mat2d NewMat2d = *this;
NewMat2d.Multiply(Other);
return NewMat2d;
}

inline void gp_Mat2d::Multiply (const gp_Mat2d& Other)
{
Standard_Real T00,T10;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
T00 = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[2];
T10 = ((Standard_Real*)M)[2] * ((Standard_Real*)O)[0] + ((Standard_Real*)M)[3] * ((Standard_Real*)O)[2];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[0] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[1] * ((Standard_Real*)O)[3];
((Standard_Real*)M)[3] = ((Standard_Real*)M)[2] * ((Standard_Real*)O)[1] + ((Standard_Real*)M)[3] * ((Standard_Real*)O)[3];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[2] = T10;
}

inline void gp_Mat2d::PreMultiply (const gp_Mat2d& Other)
{
Standard_Real T00,T01;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
T00 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[2];
((Standard_Real*)M)[2] = ((Standard_Real*)O)[2] * ((Standard_Real*)M)[0] + ((Standard_Real*)O)[3] * ((Standard_Real*)M)[2];
T01 = ((Standard_Real*)O)[0] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[1] * ((Standard_Real*)M)[3];
((Standard_Real*)M)[3] = ((Standard_Real*)O)[2] * ((Standard_Real*)M)[1] + ((Standard_Real*)O)[3] * ((Standard_Real*)M)[3];
((Standard_Real*)M)[0] = T00;
((Standard_Real*)M)[1] = T01;
}

inline gp_Mat2d gp_Mat2d::Multiplied (const Standard_Real Scalar) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] * Scalar;
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] * Scalar;
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] * Scalar;
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] * Scalar;
return NewMat2d;
}

inline void gp_Mat2d::Multiply (const Standard_Real Scalar)
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
((Standard_Real*)M)[0] *= Scalar;
((Standard_Real*)M)[1] *= Scalar;
((Standard_Real*)M)[2] *= Scalar;
((Standard_Real*)M)[3] *= Scalar;
}

inline gp_Mat2d gp_Mat2d::Powered (const Standard_Integer N) const
{
gp_Mat2d Mat2dN = *this;
Mat2dN.Power (N);
return Mat2dN;
}

inline void gp_Mat2d::Subtract (const gp_Mat2d& Other)
{
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
((Standard_Real*)M)[0] -= ((Standard_Real*)O)[0];
((Standard_Real*)M)[1] -= ((Standard_Real*)O)[1];
((Standard_Real*)M)[2] -= ((Standard_Real*)O)[2];
((Standard_Real*)M)[3] -= ((Standard_Real*)O)[3];
}

inline gp_Mat2d gp_Mat2d::Subtracted (const gp_Mat2d& Other) const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
const Standard_Address O = (Standard_Address)&(Other .matrix[0][0]);
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0] – ((Standard_Real*)O)[0];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[1] – ((Standard_Real*)O)[1];
((Standard_Real*)N)[2] = ((Standard_Real*)M)[2] – ((Standard_Real*)O)[2];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3] – ((Standard_Real*)O)[3];
return NewMat2d;
}

inline void gp_Mat2d::Transpose ()
{
const Standard_Address M = (Standard_Address)&(matrix[0][0]);
Standard_Real Temp;
Temp = ((Standard_Real*)M)[1];
((Standard_Real*)M)[1] = ((Standard_Real*)M)[2];
((Standard_Real*)M)[2] = Temp;
}

inline gp_Mat2d gp_Mat2d::Transposed () const
{
gp_Mat2d NewMat2d;
const Standard_Address M = (Standard_Address)&( matrix[0][0]);
const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
((Standard_Real*)N)[2] = ((Standard_Real*)M)[1];
((Standard_Real*)N)[1] = ((Standard_Real*)M)[2];
((Standard_Real*)N)[0] = ((Standard_Real*)M)[0];
((Standard_Real*)N)[3] = ((Standard_Real*)M)[3];
return NewMat2d;
}

inline gp_Mat2d operator* (const Standard_Real Scalar,
const gp_Mat2d& Mat2D)
{ return Mat2D.Multiplied (Scalar); }
# 293 “/usr/include/opencascade/gp_Mat2d.hxx” 2
# 33 “/usr/include/opencascade/gp_Trsf2d.hxx” 2

# 1 “/usr/include/opencascade/gp_XY.hxx” 1
# 40 “/usr/include/opencascade/gp_XY.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_Mat2d;
# 52 “/usr/include/opencascade/gp_XY.hxx”
Handle_Standard_Type& gp_XY_Type_();
# 61 “/usr/include/opencascade/gp_XY.hxx”
class gp_XY {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_XY();

gp_XY(const Standard_Real X,const Standard_Real Y);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real X,const Standard_Real Y) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& X,Standard_Real& Y) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Modulus() const;

Standard_Real SquareModulus() const;

Standard_Boolean IsEqual(const gp_XY& Other,const Standard_Real Tolerance) const;

void Add(const gp_XY& Other) ;
void operator +=(const gp_XY& Other)
{
Add(Other);
}

gp_XY Added(const gp_XY& Other) const;
gp_XY operator +(const gp_XY& Other) const
{
return Added(Other);
}

Standard_Real Crossed(const gp_XY& Right) const;
Standard_Real operator ^(const gp_XY& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_XY& Right) const;

Standard_Real CrossSquareMagnitude(const gp_XY& Right) const;

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_XY Divided(const Standard_Real Scalar) const;
gp_XY operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

Standard_Real Dot(const gp_XY& Other) const;
Standard_Real operator *(const gp_XY& Other) const
{
return Dot(Other);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

void Multiply(const gp_XY& Other) ;
void operator *=(const gp_XY& Other)
{
Multiply(Other);
}

void Multiply(const gp_Mat2d& Matrix) ;
void operator *=(const gp_Mat2d& Matrix)
{
Multiply(Matrix);
}

gp_XY Multiplied(const Standard_Real Scalar) const;
gp_XY operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

gp_XY Multiplied(const gp_XY& Other) const;

gp_XY Multiplied(const gp_Mat2d& Matrix) const;
gp_XY operator *(const gp_Mat2d& Matrix) const
{
return Multiplied(Matrix);
}

void Normalize() ;

gp_XY Normalized() const;

void Reverse() ;

gp_XY Reversed() const;
gp_XY operator -() const
{
return Reversed();
}

void SetLinearForm(const Standard_Real A1,const gp_XY& XY1,const Standard_Real A2,const gp_XY& XY2) ;

void SetLinearForm(const Standard_Real A1,const gp_XY& XY1,const Standard_Real A2,const gp_XY& XY2,const gp_XY& XY3) ;

void SetLinearForm(const Standard_Real A1,const gp_XY& XY1,const gp_XY& XY2) ;

void SetLinearForm(const gp_XY& XY1,const gp_XY& XY2) ;

void Subtract(const gp_XY& Right) ;
void operator -=(const gp_XY& Right)
{
Subtract(Right);
}

gp_XY Subtracted(const gp_XY& Right) const;
gp_XY operator -(const gp_XY& Right) const
{
return Subtracted(Right);
}

Standard_Real _CSFDB_Getgp_XYx() const { return x; }
void _CSFDB_Setgp_XYx(const Standard_Real p) { x = p; }
Standard_Real _CSFDB_Getgp_XYy() const { return y; }
void _CSFDB_Setgp_XYy(const Standard_Real p) { y = p; }

friend Handle_Standard_Type& gp_XY_Type_();

protected:
# 303 “/usr/include/opencascade/gp_XY.hxx”
private:

Standard_Real x;
Standard_Real y;

};

# 1 “/usr/include/opencascade/gp_XY.lxx” 1
# 14 “/usr/include/opencascade/gp_XY.lxx”
inline gp_XY::gp_XY () { }

inline gp_XY::gp_XY (const Standard_Real X,
const Standard_Real Y) : x (X), y (Y) { }

inline void gp_XY::SetCoord (const Standard_Integer i,
const Standard_Real X)
{
if (i < 1 || i > 2) Standard_OutOfRange::Raise(__null);;
(&x)[i-1] = X;
}

inline void gp_XY::SetCoord (const Standard_Real X,
const Standard_Real Y)
{ x = X; y = Y; }

inline void gp_XY::SetX (const Standard_Real X)
{ x = X; }

inline void gp_XY::SetY (const Standard_Real Y)
{ y = Y; }

inline Standard_Real gp_XY::Coord (const Standard_Integer i) const
{
if (i < 1 || i > 2) Standard_OutOfRange::Raise(__null);;
return (&x)[i-1];
}

inline void gp_XY::Coord (Standard_Real& X,
Standard_Real& Y) const
{ X = x; Y = y; }

inline Standard_Real gp_XY::X () const
{ return x; }

inline Standard_Real gp_XY::Y () const
{ return y; }

inline Standard_Real gp_XY::Modulus () const
{
return sqrt (x * x + y * y);
}

inline Standard_Real gp_XY::SquareModulus () const
{
return x * x + y * y;
}

inline void gp_XY::Add (const gp_XY& Other) {
x += Other.x;
y += Other.y;
}

inline gp_XY gp_XY::Added (const gp_XY& Other) const {
return gp_XY(x + Other.X(),y + Other.Y());
}

inline Standard_Real gp_XY::Crossed (const gp_XY& Right) const {
return x * Right.y – y * Right.x;
}

inline Standard_Real gp_XY::CrossMagnitude (const gp_XY& Right) const
{
Standard_Real val = x * Right.y – y * Right.x;
if (val < 0) val = – val;
return val;
}

inline Standard_Real gp_XY::CrossSquareMagnitude (const gp_XY& Right) const {
Standard_Real Zresult = x * Right.y – y * Right.x;
return Zresult * Zresult;
}

inline void gp_XY::Divide (const Standard_Real Scalar)
{
x /= Scalar;
y /= Scalar;
}

inline gp_XY gp_XY::Divided (const Standard_Real Scalar) const {
return gp_XY(x / Scalar,y / Scalar);
}

inline Standard_Real gp_XY::Dot (const gp_XY& Other) const
{
return x * Other.x + y * Other.y;
}

inline void gp_XY::Multiply (const Standard_Real Scalar)
{
x *= Scalar;
y *= Scalar;
}

inline void gp_XY::Multiply (const gp_XY& Other)
{
x *= Other.x;
y *= Other.y;
}

inline void gp_XY::Multiply (const gp_Mat2d& Matrix)
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
Standard_Real Xresult = ((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y;
y = ((Standard_Real*)M)[2] * x + ((Standard_Real*)M)[3] * y;
x = Xresult;
}

inline gp_XY gp_XY::Multiplied (const Standard_Real Scalar) const {
return gp_XY(x * Scalar,y * Scalar);
}

inline gp_XY gp_XY::Multiplied (const gp_XY& Other) const {
return(gp_XY(x * Other.X(),y * Other.Y()));
}

inline gp_XY gp_XY::Multiplied (const gp_Mat2d& Matrix) const
{
const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
return gp_XY (((Standard_Real*)M)[0] * x + ((Standard_Real*)M)[1] * y,
((Standard_Real*)M)[2] * x + ((Standard_Real*)M)[3] * y);
}

inline void gp_XY::Normalize ()
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
x = x / D; y = y / D;
}

inline gp_XY gp_XY::Normalized () const
{
Standard_Real D = Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
return gp_XY (x / D, y / D);
}

inline void gp_XY::Reverse ()
{ x = – x; y = – y; }

inline gp_XY gp_XY::Reversed () const
{
gp_XY Coord2D = *this;
Coord2D.Reverse();
return Coord2D;
}

inline void gp_XY::SetLinearForm (const Standard_Real L,
const gp_XY& Left,
const Standard_Real R,
const gp_XY& Right) {
x = L * Left.x + R * Right.x;
y = L * Left.y + R * Right.y;
}

inline void gp_XY::SetLinearForm (const Standard_Real L,
const gp_XY& Left,
const gp_XY& Right) {
x = L * Left.x + Right.x;
y = L * Left.y + Right.y;
}

inline void gp_XY::SetLinearForm (const gp_XY& Left,
const gp_XY& Right) {
x = Left.x + Right.x;
y = Left.y + Right.y;
}

inline void gp_XY::SetLinearForm (const Standard_Real A1,
const gp_XY& XY1,
const Standard_Real A2,
const gp_XY& XY2,
const gp_XY& XY3) {
x = A1 * XY1.x + A2 * XY2.x + XY3.x;
y = A1 * XY1.y + A2 * XY2.y + XY3.y;
}

inline void gp_XY::Subtract (const gp_XY& Right)
{
x -= Right.x;
y -= Right.y;
}

inline gp_XY gp_XY::Subtracted (const gp_XY& Right) const
{
gp_XY Coord2D = *this;
Coord2D.Subtract(Right);
return Coord2D;
}

inline gp_XY operator* (const gp_Mat2d& Matrix,
const gp_XY& Coord1) {
return Coord1.Multiplied(Matrix);
}

inline gp_XY operator* (const Standard_Real Scalar,
const gp_XY& Coord1) {
return Coord1.Multiplied(Scalar);
}
# 319 “/usr/include/opencascade/gp_XY.hxx” 2
# 36 “/usr/include/opencascade/gp_Trsf2d.hxx” 2
# 49 “/usr/include/opencascade/gp_Trsf2d.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_GTrsf2d;
class gp_Trsf;
class gp_Pnt2d;
class gp_Ax2d;
class gp_Vec2d;
class gp_XY;
class gp_Mat2d;
# 67 “/usr/include/opencascade/gp_Trsf2d.hxx”
Handle_Standard_Type& gp_Trsf2d_Type_();
# 82 “/usr/include/opencascade/gp_Trsf2d.hxx”
class gp_Trsf2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Trsf2d();

gp_Trsf2d(const gp_Trsf& T);

void SetMirror(const gp_Pnt2d& P) ;

void SetMirror(const gp_Ax2d& A) ;

void SetRotation(const gp_Pnt2d& P,const Standard_Real Ang) ;

void SetScale(const gp_Pnt2d& P,const Standard_Real S) ;

void SetTransformation(const gp_Ax2d& FromSystem1,const gp_Ax2d& ToSystem2) ;

void SetTransformation(const gp_Ax2d& ToSystem) ;

void SetTranslation(const gp_Vec2d& V) ;

void SetTranslation(const gp_Pnt2d& P1,const gp_Pnt2d& P2) ;

void SetTranslationPart(const gp_Vec2d& V) ;

void SetScaleFactor(const Standard_Real S) ;

Standard_Boolean IsNegative() const;

gp_TrsfForm Form() const;

Standard_Real ScaleFactor() const;

const gp_XY& TranslationPart() const;

gp_Mat2d VectorialPart() const;

const gp_Mat2d& HVectorialPart() const;

Standard_Real RotationPart() const;

Standard_Real Value(const Standard_Integer Row,const Standard_Integer Col) const;

void Invert() ;

gp_Trsf2d Inverted() const;

gp_Trsf2d Multiplied(const gp_Trsf2d& T) const;
gp_Trsf2d operator *(const gp_Trsf2d& T) const
{
return Multiplied(T);
}
# 213 “/usr/include/opencascade/gp_Trsf2d.hxx”
void Multiply(const gp_Trsf2d& T) ;
void operator *=(const gp_Trsf2d& T)
{
Multiply(T);
}

void PreMultiply(const gp_Trsf2d& T) ;

void Power(const Standard_Integer N) ;

gp_Trsf2d Powered(const Standard_Integer N) ;

void Transforms(Standard_Real& X,Standard_Real& Y) const;

void Transforms(gp_XY& Coord) const;
Standard_Real _CSFDB_Getgp_Trsf2dscale() const { return scale; }
void _CSFDB_Setgp_Trsf2dscale(const Standard_Real p) { scale = p; }
gp_TrsfForm _CSFDB_Getgp_Trsf2dshape() const { return shape; }
void _CSFDB_Setgp_Trsf2dshape(const gp_TrsfForm p) { shape = p; }
const gp_Mat2d& _CSFDB_Getgp_Trsf2dmatrix() const { return matrix; }
const gp_XY& _CSFDB_Getgp_Trsf2dloc() const { return loc; }

friend class gp_GTrsf2d;

friend Handle_Standard_Type& gp_Trsf2d_Type_();

protected:
# 262 “/usr/include/opencascade/gp_Trsf2d.hxx”
private:

Standard_Real scale;
gp_TrsfForm shape;
gp_Mat2d matrix;
gp_XY loc;

};

# 1 “/usr/include/opencascade/gp_Trsf2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Trsf.hxx” 1
# 4 “/usr/include/opencascade/gp_Trsf2d.lxx” 2
# 1 “/usr/include/opencascade/gp_Pnt2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Pnt2d.hxx”
class Standard_OutOfRange;
class gp_XY;
class gp_Ax2d;
class gp_Trsf2d;
class gp_Vec2d;
# 57 “/usr/include/opencascade/gp_Pnt2d.hxx”
Handle_Standard_Type& gp_Pnt2d_Type_();

class gp_Pnt2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Pnt2d();

gp_Pnt2d(const gp_XY& Coord);

gp_Pnt2d(const Standard_Real Xp,const Standard_Real Yp);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xp,const Standard_Real Yp) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetXY(const gp_XY& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xp,Standard_Real& Yp) const;

Standard_Real X() const;

Standard_Real Y() const;

const gp_XY& XY() const;

const gp_XY& Coord() const;

gp_XY& ChangeCoord() ;

Standard_Boolean IsEqual(const gp_Pnt2d& Other,const Standard_Real LinearTolerance) const;

Standard_Real Distance(const gp_Pnt2d& Other) const;

Standard_Real SquareDistance(const gp_Pnt2d& Other) const;

void Mirror(const gp_Pnt2d& P) ;

gp_Pnt2d Mirrored(const gp_Pnt2d& P) const;

void Mirror(const gp_Ax2d& A) ;

gp_Pnt2d Mirrored(const gp_Ax2d& A) const;

void Rotate(const gp_Pnt2d& P,const Standard_Real Ang) ;

gp_Pnt2d Rotated(const gp_Pnt2d& P,const Standard_Real Ang) const;

void Scale(const gp_Pnt2d& P,const Standard_Real S) ;

gp_Pnt2d Scaled(const gp_Pnt2d& P,const Standard_Real S) const;

void Transform(const gp_Trsf2d& T) ;

gp_Pnt2d Transformed(const gp_Trsf2d& T) const;

void Translate(const gp_Vec2d& V) ;

gp_Pnt2d Translated(const gp_Vec2d& V) const;

void Translate(const gp_Pnt2d& P1,const gp_Pnt2d& P2) ;

gp_Pnt2d Translated(const gp_Pnt2d& P1,const gp_Pnt2d& P2) const;
const gp_XY& _CSFDB_Getgp_Pnt2dcoord() const { return coord; }

friend Handle_Standard_Type& gp_Pnt2d_Type_();

protected:
# 190 “/usr/include/opencascade/gp_Pnt2d.hxx”
private:

gp_XY coord;

};

# 1 “/usr/include/opencascade/gp_Pnt2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Vec2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Vec2d.hxx”
class Standard_ConstructionError;
class Standard_OutOfRange;
class gp_VectorWithNullMagnitude;
class gp_Dir2d;
class gp_XY;
class gp_Pnt2d;
class gp_Ax2d;
class gp_Trsf2d;
# 60 “/usr/include/opencascade/gp_Vec2d.hxx”
Handle_Standard_Type& gp_Vec2d_Type_();

class gp_Vec2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Vec2d();

gp_Vec2d(const gp_Dir2d& V);

gp_Vec2d(const gp_XY& Coord);

gp_Vec2d(const Standard_Real Xv,const Standard_Real Yv);

gp_Vec2d(const gp_Pnt2d& P1,const gp_Pnt2d& P2);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xv,const Standard_Real Yv) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetXY(const gp_XY& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv) const;

Standard_Real X() const;

Standard_Real Y() const;

const gp_XY& XY() const;

Standard_Boolean IsEqual(const gp_Vec2d& Other,const Standard_Real LinearTolerance,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Vec2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Vec2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Vec2d& Other,const Standard_Real AngularTolerance) const;
# 154 “/usr/include/opencascade/gp_Vec2d.hxx”
Standard_Real Angle(const gp_Vec2d& Other) const;

Standard_Real Magnitude() const;

Standard_Real SquareMagnitude() const;

void Add(const gp_Vec2d& Other) ;
void operator +=(const gp_Vec2d& Other)
{
Add(Other);
}

gp_Vec2d Added(const gp_Vec2d& Other) const;
gp_Vec2d operator +(const gp_Vec2d& Other) const
{
return Added(Other);
}

Standard_Real Crossed(const gp_Vec2d& Right) const;
Standard_Real operator ^(const gp_Vec2d& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_Vec2d& Right) const;

Standard_Real CrossSquareMagnitude(const gp_Vec2d& Right) const;

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Vec2d Divided(const Standard_Real Scalar) const;
gp_Vec2d operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

Standard_Real Dot(const gp_Vec2d& Other) const;
Standard_Real operator *(const gp_Vec2d& Other) const
{
return Dot(Other);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

gp_Vec2d Multiplied(const Standard_Real Scalar) const;
gp_Vec2d operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Normalize() ;

gp_Vec2d Normalized() const;

void Reverse() ;

gp_Vec2d Reversed() const;
gp_Vec2d operator -() const
{
return Reversed();
}

void Subtract(const gp_Vec2d& Right) ;
void operator -=(const gp_Vec2d& Right)
{
Subtract(Right);
}

gp_Vec2d Subtracted(const gp_Vec2d& Right) const;
gp_Vec2d operator -(const gp_Vec2d& Right) const
{
return Subtracted(Right);
}

void SetLinearForm(const Standard_Real A1,const gp_Vec2d& V1,const Standard_Real A2,const gp_Vec2d& V2,const gp_Vec2d& V3) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec2d& V1,const Standard_Real A2,const gp_Vec2d& V2) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec2d& V1,const gp_Vec2d& V2) ;

void SetLinearForm(const gp_Vec2d& Left,const gp_Vec2d& Right) ;

void Mirror(const gp_Vec2d& V) ;
# 281 “/usr/include/opencascade/gp_Vec2d.hxx”
gp_Vec2d Mirrored(const gp_Vec2d& V) const;

void Mirror(const gp_Ax2d& A1) ;

gp_Vec2d Mirrored(const gp_Ax2d& A1) const;

void Rotate(const Standard_Real Ang) ;

gp_Vec2d Rotated(const Standard_Real Ang) const;

void Scale(const Standard_Real S) ;

gp_Vec2d Scaled(const Standard_Real S) const;

void Transform(const gp_Trsf2d& T) ;

gp_Vec2d Transformed(const gp_Trsf2d& T) const;
const gp_XY& _CSFDB_Getgp_Vec2dcoord() const { return coord; }

friend Handle_Standard_Type& gp_Vec2d_Type_();

protected:
# 325 “/usr/include/opencascade/gp_Vec2d.hxx”
private:

gp_XY coord;

};

# 1 “/usr/include/opencascade/gp_Vec2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Dir2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Dir2d.hxx”
class Standard_ConstructionError;
class Standard_DomainError;
class Standard_OutOfRange;
class gp_Vec2d;
class gp_XY;
class gp_Ax2d;
class gp_Trsf2d;
# 59 “/usr/include/opencascade/gp_Dir2d.hxx”
Handle_Standard_Type& gp_Dir2d_Type_();
# 69 “/usr/include/opencascade/gp_Dir2d.hxx”
class gp_Dir2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Dir2d();

gp_Dir2d(const gp_Vec2d& V);

gp_Dir2d(const gp_XY& Coord);

gp_Dir2d(const Standard_Real Xv,const Standard_Real Yv);
# 112 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;
# 128 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetCoord(const Standard_Real Xv,const Standard_Real Yv) ;
# 142 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetX(const Standard_Real X) ;
# 156 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetY(const Standard_Real Y) ;
# 171 “/usr/include/opencascade/gp_Dir2d.hxx”
void SetXY(const gp_XY& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv) const;

Standard_Real X() const;

Standard_Real Y() const;

const gp_XY& XY() const;

Standard_Boolean IsEqual(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Dir2d& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Dir2d& Other) const;

Standard_Real Crossed(const gp_Dir2d& Right) const;
Standard_Real operator ^(const gp_Dir2d& Right) const
{
return Crossed(Right);
}

Standard_Real Dot(const gp_Dir2d& Other) const;
Standard_Real operator *(const gp_Dir2d& Other) const
{
return Dot(Other);
}

void Reverse() ;

gp_Dir2d Reversed() const;
gp_Dir2d operator -() const
{
return Reversed();
}

void Mirror(const gp_Dir2d& V) ;

gp_Dir2d Mirrored(const gp_Dir2d& V) const;

void Mirror(const gp_Ax2d& A) ;

gp_Dir2d Mirrored(const gp_Ax2d& A) const;

void Rotate(const Standard_Real Ang) ;

gp_Dir2d Rotated(const Standard_Real Ang) const;

void Transform(const gp_Trsf2d& T) ;

gp_Dir2d Transformed(const gp_Trsf2d& T) const;
const gp_XY& _CSFDB_Getgp_Dir2dcoord() const { return coord; }

friend Handle_Standard_Type& gp_Dir2d_Type_();

protected:
# 290 “/usr/include/opencascade/gp_Dir2d.hxx”
private:

gp_XY coord;

};

# 1 “/usr/include/opencascade/gp_Dir2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Ax2d.hxx” 1
# 43 “/usr/include/opencascade/gp_Ax2d.hxx”
class gp_Pnt2d;
class gp_Dir2d;
class gp_Trsf2d;
class gp_Vec2d;
# 56 “/usr/include/opencascade/gp_Ax2d.hxx”
Handle_Standard_Type& gp_Ax2d_Type_();
# 77 “/usr/include/opencascade/gp_Ax2d.hxx”
class gp_Ax2d {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Ax2d();

gp_Ax2d(const gp_Pnt2d& P,const gp_Dir2d& V);

void SetLocation(const gp_Pnt2d& Locat) ;

void SetDirection(const gp_Dir2d& V) ;

const gp_Pnt2d& Location() const;

const gp_Dir2d& Direction() const;
# 119 “/usr/include/opencascade/gp_Ax2d.hxx”
Standard_Boolean IsCoaxial(const gp_Ax2d& Other,const Standard_Real AngularTolerance,const Standard_Real LinearTolerance) const;

Standard_Boolean IsNormal(const gp_Ax2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Ax2d& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Ax2d& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Ax2d& Other) const;

void Reverse() ;

gp_Ax2d Reversed() const;

void Mirror(const gp_Pnt2d& P) ;

gp_Ax2d Mirrored(const gp_Pnt2d& P) const;

void Mirror(const gp_Ax2d& A) ;

gp_Ax2d Mirrored(const gp_Ax2d& A) const;

void Rotate(const gp_Pnt2d& P,const Standard_Real Ang) ;

gp_Ax2d Rotated(const gp_Pnt2d& P,const Standard_Real Ang) const;

void Scale(const gp_Pnt2d& P,const Standard_Real S) ;

gp_Ax2d Scaled(const gp_Pnt2d& P,const Standard_Real S) const;

void Transform(const gp_Trsf2d& T) ;

gp_Ax2d Transformed(const gp_Trsf2d& T) const;

void Translate(const gp_Vec2d& V) ;

gp_Ax2d Translated(const gp_Vec2d& V) const;

void Translate(const gp_Pnt2d& P1,const gp_Pnt2d& P2) ;

gp_Ax2d Translated(const gp_Pnt2d& P1,const gp_Pnt2d& P2) const;
const gp_Pnt2d& _CSFDB_Getgp_Ax2dloc() const { return loc; }
const gp_Dir2d& _CSFDB_Getgp_Ax2dvdir() const { return vdir; }

friend Handle_Standard_Type& gp_Ax2d_Type_();

protected:
# 213 “/usr/include/opencascade/gp_Ax2d.hxx”
private:

gp_Pnt2d loc;
gp_Dir2d vdir;

};

# 1 “/usr/include/opencascade/gp_Ax2d.lxx” 1

# 1 “/usr/include/opencascade/gp_Ax2d.hxx” 1
# 6 “/usr/include/opencascade/gp_Ax2d.lxx” 2

inline gp_Ax2d::gp_Ax2d()
{ }

inline gp_Ax2d::gp_Ax2d (const gp_Pnt2d& P,
const gp_Dir2d& V) : loc(P), vdir(V)
{ }

inline void gp_Ax2d::SetLocation(const gp_Pnt2d& P)
{ loc = P; }

inline void gp_Ax2d::SetDirection(const gp_Dir2d& V)
{ vdir = V; }

inline const gp_Pnt2d& gp_Ax2d::Location () const
{ return loc; }

inline const gp_Dir2d& gp_Ax2d::Direction () const
{ return vdir; }

inline Standard_Boolean gp_Ax2d::IsNormal
(const gp_Ax2d& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsNormal(Other.vdir, AngularTolerance); }

inline Standard_Boolean gp_Ax2d::IsOpposite
(const gp_Ax2d& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsOpposite (Other.vdir, AngularTolerance); }

inline Standard_Boolean gp_Ax2d::IsParallel
(const gp_Ax2d& Other,
const Standard_Real AngularTolerance) const
{ return vdir.IsParallel(Other.vdir, AngularTolerance); }

inline Standard_Real gp_Ax2d::Angle (const gp_Ax2d& Other) const
{ return vdir.Angle (Other.vdir); }

inline void gp_Ax2d::Reverse()
{ vdir.Reverse(); }

inline gp_Ax2d gp_Ax2d::Reversed() const
{
gp_Ax2d Temp = *this;
Temp.Reverse ();
return Temp;
}

inline void gp_Ax2d::Rotate (const gp_Pnt2d& P,
const Standard_Real Ang)
{
loc.Rotate (P, Ang);
vdir.Rotate (Ang);
}

inline gp_Ax2d gp_Ax2d::Rotated (const gp_Pnt2d& P,
const Standard_Real Ang) const
{
gp_Ax2d A = *this;
A.Rotate (P, Ang);
return A;
}

inline gp_Ax2d gp_Ax2d::Scaled (const gp_Pnt2d& P,
const Standard_Real S) const
{
gp_Ax2d A = *this;
A.Scale (P, S);
return A;
}

inline void gp_Ax2d::Transform (const gp_Trsf2d& T)
{
loc.Transform (T);
vdir.Transform (T);
}

inline gp_Ax2d gp_Ax2d::Transformed (const gp_Trsf2d& T) const
{
gp_Ax2d A = *this;
A.Transform (T);
return A;
}

inline void gp_Ax2d::Translate (const gp_Vec2d& V)
{ loc.Translate (V); }

inline gp_Ax2d gp_Ax2d::Translated (const gp_Vec2d& V) const
{
gp_Ax2d A = *this;
(A.loc).Translate (V);
return A;
}

inline void gp_Ax2d::Translate (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{ loc.Translate (P1,P2); }

inline gp_Ax2d gp_Ax2d::Translated (const gp_Pnt2d& P1,
const gp_Pnt2d& P2) const
{
gp_Ax2d A = *this;
(A.loc).Translate( gp_Vec2d (P1, P2));
return A;
}
# 229 “/usr/include/opencascade/gp_Ax2d.hxx” 2
# 8 “/usr/include/opencascade/gp_Dir2d.lxx” 2
# 1 “/usr/include/opencascade/gp_Trsf2d.hxx” 1
# 9 “/usr/include/opencascade/gp_Dir2d.lxx” 2

inline gp_Dir2d::gp_Dir2d()
{ coord.SetCoord (1.0, 0.0); }

inline gp_Dir2d::gp_Dir2d (const gp_Vec2d& V)
{
const gp_XY& XY = V.XY();
Standard_Real X = XY.X();
Standard_Real Y = XY.Y();
Standard_Real D = sqrt(X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline gp_Dir2d::gp_Dir2d (const gp_XY& XY)
{
Standard_Real X = XY.X();
Standard_Real Y = XY.Y();
Standard_Real D = sqrt(X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline gp_Dir2d::gp_Dir2d (const Standard_Real Xv,
const Standard_Real Yv)
{
Standard_Real D = sqrt (Xv * Xv + Yv * Yv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
}

inline void gp_Dir2d::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{
Standard_Real X = coord.X();
Standard_Real Y = coord.Y();
if (Index < 1 || Index > 2) Standard_OutOfRange::Raise(” “);;
if (Index == 1) X = Xi;
else Y = Xi;
Standard_Real D = sqrt (X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline void gp_Dir2d::SetCoord (const Standard_Real Xv,
const Standard_Real Yv)
{
Standard_Real D = sqrt (Xv * Xv + Yv * Yv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
}

inline void gp_Dir2d::SetX (const Standard_Real X)
{
Standard_Real Y = coord.Y();
Standard_Real D = sqrt (X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline void gp_Dir2d::SetY (const Standard_Real Y)
{
Standard_Real X = coord.X();
Standard_Real D = sqrt (X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline void gp_Dir2d::SetXY (const gp_XY& XY)
{
Standard_Real X = XY.X();
Standard_Real Y = XY.Y();
Standard_Real D = sqrt(X * X + Y * Y);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
}

inline Standard_Real gp_Dir2d::Coord (const Standard_Integer Index) const
{ return coord.Coord(Index); }

inline void gp_Dir2d::Coord(Standard_Real& Xv, Standard_Real& Yv) const
{ coord.Coord (Xv, Yv); }

inline Standard_Real gp_Dir2d::X() const
{ return coord.X() ; }

inline Standard_Real gp_Dir2d::Y() const
{ return coord.Y() ; }

inline const gp_XY& gp_Dir2d::XY () const
{ return coord; }

inline Standard_Boolean gp_Dir2d::IsEqual
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir2d::IsNormal
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
Ang = Standard_PI / 2.0 – Ang;
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir2d::IsOpposite
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir2d::IsParallel
(const gp_Dir2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance || Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Real gp_Dir2d::Crossed (const gp_Dir2d& Right) const
{ return coord.Crossed (Right.coord); }

inline Standard_Real gp_Dir2d::Dot (const gp_Dir2d& Other) const
{ return coord.Dot (Other.coord); }

inline void gp_Dir2d::Reverse()
{ coord.Reverse(); }

inline gp_Dir2d gp_Dir2d::Reversed() const
{
gp_Dir2d V = *this;
V.coord.Reverse ();
return V;
}

inline void gp_Dir2d::Rotate (const Standard_Real Ang)
{
gp_Trsf2d T;
T.SetRotation (gp_Pnt2d (0.0, 0.0), Ang);
coord.Multiply (T.HVectorialPart());
}

inline gp_Dir2d gp_Dir2d::Rotated (const Standard_Real Ang) const
{
gp_Dir2d V = *this;
V.Rotate (Ang);
return V;
}

inline gp_Dir2d gp_Dir2d::Transformed (const gp_Trsf2d& T) const
{
gp_Dir2d V = *this;
V.Transform (T);
return V;
}
# 305 “/usr/include/opencascade/gp_Dir2d.hxx” 2
# 6 “/usr/include/opencascade/gp_Vec2d.lxx” 2

# 1 “/usr/include/opencascade/gp_Pnt2d.hxx” 1
# 8 “/usr/include/opencascade/gp_Vec2d.lxx” 2

inline gp_Vec2d::gp_Vec2d()
{}

inline gp_Vec2d::gp_Vec2d (const gp_Dir2d& V)
{ coord = V.XY(); }

inline gp_Vec2d::gp_Vec2d (const gp_XY& Coord) : coord(Coord)
{}

inline gp_Vec2d::gp_Vec2d (const Standard_Real Xv,
const Standard_Real Yv) : coord (Xv, Yv)
{ }

inline gp_Vec2d::gp_Vec2d (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{ coord = P2.XY().Subtracted (P1.XY()); }

inline void gp_Vec2d::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Vec2d::SetCoord (const Standard_Real Xv,
const Standard_Real Yv)
{ coord.SetCoord (Xv, Yv); }

inline void gp_Vec2d::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Vec2d::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Vec2d::SetXY (const gp_XY& Coord)
{ coord = Coord; }

inline Standard_Real gp_Vec2d::Coord (const Standard_Integer Index) const
{ return coord.Coord(Index); }

inline void gp_Vec2d::Coord(Standard_Real& Xv,
Standard_Real& Yv) const
{ coord.Coord(Xv, Yv); }

inline Standard_Real gp_Vec2d::X() const
{ return coord.X(); }

inline Standard_Real gp_Vec2d::Y() const
{ return coord.Y(); }

inline const gp_XY& gp_Vec2d::XY () const
{ return coord; }

inline Standard_Boolean gp_Vec2d::IsNormal
(const gp_Vec2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
Ang = Standard_PI / 2.0 – Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Vec2d::IsOpposite
(const gp_Vec2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Vec2d::IsParallel
(const gp_Vec2d& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle(Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance || Standard_PI – Ang <= AngularTolerance;
}

inline Standard_Real gp_Vec2d::Magnitude() const
{ return coord.Modulus(); }

inline Standard_Real gp_Vec2d::SquareMagnitude() const
{ return coord.SquareModulus(); }

inline void gp_Vec2d::Add (const gp_Vec2d& Other)
{ coord.Add (Other.coord); }

inline gp_Vec2d gp_Vec2d::Added (const gp_Vec2d& Other) const
{
gp_Vec2d V = *this;
V.coord.Add (Other.coord);
return V;
}

inline Standard_Real gp_Vec2d::Crossed (const gp_Vec2d& Right) const
{ return coord.Crossed (Right.coord); }

inline Standard_Real gp_Vec2d::CrossMagnitude (const gp_Vec2d& Right) const
{ return coord.CrossMagnitude (Right.coord); }

inline Standard_Real gp_Vec2d::CrossSquareMagnitude
(const gp_Vec2d& Right) const
{ return coord.CrossSquareMagnitude (Right.coord); }

inline void gp_Vec2d::Divide (const Standard_Real Scalar)
{ coord.Divide (Scalar); }

inline gp_Vec2d gp_Vec2d::Divided (const Standard_Real Scalar) const
{
gp_Vec2d V = *this;
V.coord.Divide(Scalar);
return V;
}

inline Standard_Real gp_Vec2d::Dot (const gp_Vec2d& Other) const
{ return coord.Dot (Other.coord); }

inline void gp_Vec2d::Multiply (const Standard_Real Scalar)
{ coord.Multiply (Scalar); }

inline gp_Vec2d gp_Vec2d::Multiplied (const Standard_Real Scalar) const
{
gp_Vec2d V = *this;
V.coord.Multiply(Scalar);
return V;
}

inline void gp_Vec2d::Normalize()
{
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.Divide (D);
}

inline gp_Vec2d gp_Vec2d::Normalized() const
{
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
gp_Vec2d V = *this;
V.coord.Divide (D);
return V;
}

inline void gp_Vec2d::Reverse()
{ coord.Reverse(); }

inline gp_Vec2d gp_Vec2d::Reversed() const
{
gp_Vec2d V = *this;
V.coord.Reverse();
return V;
}

inline void gp_Vec2d::Subtract (const gp_Vec2d& Right)
{ coord.Subtract (Right.coord); }

inline gp_Vec2d gp_Vec2d::Subtracted (const gp_Vec2d& Right) const
{
gp_Vec2d V = *this;
V.coord.Subtract (Right.coord);
return V;
}

inline void gp_Vec2d::SetLinearForm (const Standard_Real L,
const gp_Vec2d& Left,
const Standard_Real R,
const gp_Vec2d& Right)
{ coord.SetLinearForm (L, Left.coord, R, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const Standard_Real L,
const gp_Vec2d& Left,
const gp_Vec2d& Right)
{ coord.SetLinearForm (L, Left.coord, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const gp_Vec2d& Left,
const gp_Vec2d& Right)
{ coord.SetLinearForm (Left.coord, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const Standard_Real A1,
const gp_Vec2d& V1,
const Standard_Real A2,
const gp_Vec2d& V2,
const gp_Vec2d& V3)
{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }

inline void gp_Vec2d::Rotate (const Standard_Real Ang)
{
gp_Trsf2d T;
T.SetRotation (gp_Pnt2d (0.0, 0.0), Ang);
coord.Multiply (T.VectorialPart ());
}

inline gp_Vec2d gp_Vec2d::Rotated (const Standard_Real Ang) const
{
gp_Vec2d V = *this;
V.Rotate (Ang);
return V;
}

inline void gp_Vec2d::Scale (const Standard_Real S)
{ coord.Multiply (S); }

inline gp_Vec2d gp_Vec2d::Scaled (const Standard_Real S) const
{
gp_Vec2d V = *this;
V.coord.Multiply (S);
return V;
}

inline gp_Vec2d gp_Vec2d::Transformed (const gp_Trsf2d& T) const
{
gp_Vec2d V = *this;
V.Transform(T);
return V;
}

inline gp_Vec2d operator* (const Standard_Real Scalar,
const gp_Vec2d& V)
{ return V.Multiplied(Scalar); }
# 340 “/usr/include/opencascade/gp_Vec2d.hxx” 2
# 7 “/usr/include/opencascade/gp_Pnt2d.lxx” 2

inline gp_Pnt2d::gp_Pnt2d (const gp_XY& Coordinates) : coord (Coordinates)
{ }

inline gp_Pnt2d::gp_Pnt2d (const Standard_Real Xp,
const Standard_Real Yp) : coord (Xp, Yp)
{ }

inline gp_Pnt2d::gp_Pnt2d() { }

inline Standard_Real gp_Pnt2d::Coord(const Standard_Integer Index) const { return coord.Coord(Index); }

inline void gp_Pnt2d::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Pnt2d::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Pnt2d::SetXY (const gp_XY& Coordinates)
{ coord = Coordinates; }

inline void gp_Pnt2d::SetCoord (const Standard_Real Xp,
const Standard_Real Yp)
{ coord.SetCoord (Xp, Yp);}

inline void gp_Pnt2d::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Pnt2d::Coord (Standard_Real& Xp,
Standard_Real& Yp) const
{ coord.Coord (Xp, Yp); }

inline Standard_Real gp_Pnt2d::X() const
{ return coord.X(); }

inline Standard_Real gp_Pnt2d::Y() const
{ return coord.Y(); }

inline const gp_XY& gp_Pnt2d::XY () const
{ return coord; }

inline const gp_XY& gp_Pnt2d::Coord () const
{ return coord; }

inline gp_XY& gp_Pnt2d::ChangeCoord ()
{ return coord; }

inline Standard_Boolean gp_Pnt2d::IsEqual
(const gp_Pnt2d& Other,
const Standard_Real LinearTolerance) const
{ return Distance (Other) <= LinearTolerance; }

inline Standard_Real gp_Pnt2d::Distance (const gp_Pnt2d& Other) const
{
const gp_XY& XY = Other.coord;
Standard_Real X = coord.X() – XY.X();
Standard_Real Y = coord.Y() – XY.Y();
return sqrt (X * X + Y * Y);
}

inline Standard_Real gp_Pnt2d::SquareDistance (const gp_Pnt2d& Other) const
{
const gp_XY& XY = Other.coord;
Standard_Real X = coord.X() – XY.X();
Standard_Real Y = coord.Y() – XY.Y();
return (X * X + Y * Y);
}

inline void gp_Pnt2d::Rotate (const gp_Pnt2d& P,
const Standard_Real Ang)
{
gp_Trsf2d T;
T.SetRotation (P, Ang);
T.Transforms (coord);
}

inline gp_Pnt2d gp_Pnt2d::Rotated (const gp_Pnt2d& P,
const Standard_Real Ang) const
{
gp_Pnt2d Pres = *this;
Pres.Rotate (P, Ang);
return Pres;
}

inline void gp_Pnt2d::Scale (const gp_Pnt2d& P,
const Standard_Real S)
{
gp_XY XY = P.coord;
XY.Multiply (1.0 – S);
coord.Multiply (S);
coord.Add (XY);
}

inline gp_Pnt2d gp_Pnt2d::Scaled (const gp_Pnt2d& P,
const Standard_Real S) const
{
gp_Pnt2d Pres = *this;
Pres.Scale (P, S);
return Pres;
}

inline gp_Pnt2d gp_Pnt2d::Transformed (const gp_Trsf2d& T) const
{
gp_Pnt2d Pres = *this;
Pres.Transform (T);
return Pres;
}

inline void gp_Pnt2d::Translate (const gp_Vec2d& V)
{ coord.Add (V.XY()); }

inline gp_Pnt2d gp_Pnt2d::Translated (const gp_Vec2d& V) const
{
gp_Pnt2d P = *this;
P.coord.Add (V.XY ());
return P;
}

inline void gp_Pnt2d::Translate (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{
coord.Add (P2.coord);
coord.Subtract (P1.coord);
}

inline gp_Pnt2d gp_Pnt2d::Translated (const gp_Pnt2d& P1,
const gp_Pnt2d& P2) const
{
gp_Pnt2d P = *this;
P.Translate (P1, P2);
return P;
}
# 205 “/usr/include/opencascade/gp_Pnt2d.hxx” 2
# 5 “/usr/include/opencascade/gp_Trsf2d.lxx” 2

inline gp_Trsf2d::gp_Trsf2d () {
shape = gp_Identity;
scale = 1.0;
matrix.SetIdentity ();
loc.SetCoord (0.0, 0.0);
}

inline gp_Trsf2d::gp_Trsf2d (const gp_Trsf& T) :
scale(T.ScaleFactor()),
shape(T.Form()),
loc(T.TranslationPart().X(),T.TranslationPart().Y())
{
const gp_Mat& M = T.HVectorialPart();
matrix(1,1) = M(1,1);
matrix(1,2) = M(1,2);
matrix(2,1) = M(2,1);
matrix(2,2) = M(2,2);
}

inline void gp_Trsf2d::SetMirror(const gp_Pnt2d& P)
{
shape = gp_PntMirror;
scale = -1.0;
matrix.SetIdentity ();
loc = P.XY();
loc.Multiply (2.0);
}

inline void gp_Trsf2d::SetRotation (const gp_Pnt2d& P,
const Standard_Real Ang)
{
shape = gp_Rotation;
scale = 1.0;
loc = P.XY ();
loc.Reverse ();
matrix.SetRotation (Ang);
loc.Multiply (matrix);
loc.Add (P.XY());
}

inline void gp_Trsf2d::SetScale (const gp_Pnt2d& P,
const Standard_Real S)
{
shape = gp_Scale;
scale = S;
matrix.SetIdentity ();
loc = P.XY ();
loc.Multiply (1.0 – S);
}

inline void gp_Trsf2d::SetTranslation(const gp_Vec2d& V)
{
shape = gp_Translation;
scale = 1.0;
matrix.SetIdentity ();
loc = V.XY ();
}

inline void gp_Trsf2d::SetTranslation (const gp_Pnt2d& P1,
const gp_Pnt2d& P2)
{
shape = gp_Translation;
scale = 1.0;
matrix.SetIdentity ();
loc = (P2.XY()).Subtracted (P1.XY());
}

inline Standard_Boolean gp_Trsf2d::IsNegative() const
{ return (scale < 0.0); }

inline const gp_XY& gp_Trsf2d::TranslationPart () const
{ return loc; }

inline const gp_Mat2d& gp_Trsf2d::HVectorialPart () const
{ return matrix; }

inline Standard_Real gp_Trsf2d::Value (const Standard_Integer Row,
const Standard_Integer Col) const
{
if (Row < 1 || Row > 2 || Col < 1 || Col > 3) Standard_OutOfRange::Raise(” “);;

if (Col < 3) return scale * matrix.Value (Row, Col);
else return loc.Coord (Row);
}

inline gp_TrsfForm gp_Trsf2d::Form() const
{ return shape; }

inline Standard_Real gp_Trsf2d::ScaleFactor() const
{ return scale; }

inline gp_Trsf2d gp_Trsf2d::Inverted() const
{
gp_Trsf2d T = *this;
T.Invert();
return T;
}

inline gp_Trsf2d gp_Trsf2d::Multiplied (const gp_Trsf2d& T) const {
gp_Trsf2d Tresult(*this);
Tresult.Multiply(T);
return Tresult;
}

inline gp_Trsf2d gp_Trsf2d::Powered (const Standard_Integer N)
{
gp_Trsf2d T = *this;
T.Power (N);
return T;
}

inline void gp_Trsf2d::Transforms (Standard_Real& X,
Standard_Real& Y) const
{
gp_XY Doublet (X, Y);
Doublet.Multiply (matrix);
if (scale != 1.0) Doublet.Multiply (scale);
Doublet.Add(loc);
Doublet.Coord (X, Y);
}

inline void gp_Trsf2d::Transforms (gp_XY& Coord) const
{
Coord.Multiply (matrix);
if (scale != 1.0) Coord.Multiply (scale);
Coord.Add(loc);
}
# 280 “/usr/include/opencascade/gp_Trsf2d.hxx” 2
# 8 “/usr/include/opencascade/gp_Trsf.lxx” 2
# 1 “/usr/include/opencascade/gp_Vec.hxx” 1
# 43 “/usr/include/opencascade/gp_Vec.hxx”
class Standard_ConstructionError;
class Standard_DomainError;
class Standard_OutOfRange;
class gp_VectorWithNullMagnitude;
class gp_Dir;
class gp_XYZ;
class gp_Pnt;
class gp_Ax1;
class gp_Ax2;
class gp_Trsf;
# 62 “/usr/include/opencascade/gp_Vec.hxx”
Handle_Standard_Type& gp_Vec_Type_();

class gp_Vec {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Vec();

gp_Vec(const gp_Dir& V);

gp_Vec(const gp_XYZ& Coord);

gp_Vec(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv);

gp_Vec(const gp_Pnt& P1,const gp_Pnt& P2);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

void SetXYZ(const gp_XYZ& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv,Standard_Real& Zv) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

const gp_XYZ& XYZ() const;

Standard_Boolean IsEqual(const gp_Vec& Other,const Standard_Real LinearTolerance,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Vec& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Vec& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Vec& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Vec& Other) const;
# 174 “/usr/include/opencascade/gp_Vec.hxx”
Standard_Real AngleWithRef(const gp_Vec& Other,const gp_Vec& VRef) const;

Standard_Real Magnitude() const;

Standard_Real SquareMagnitude() const;

void Add(const gp_Vec& Other) ;
void operator +=(const gp_Vec& Other)
{
Add(Other);
}

gp_Vec Added(const gp_Vec& Other) const;
gp_Vec operator +(const gp_Vec& Other) const
{
return Added(Other);
}

void Subtract(const gp_Vec& Right) ;
void operator -=(const gp_Vec& Right)
{
Subtract(Right);
}

gp_Vec Subtracted(const gp_Vec& Right) const;
gp_Vec operator -(const gp_Vec& Right) const
{
return Subtracted(Right);
}

void Multiply(const Standard_Real Scalar) ;
void operator *=(const Standard_Real Scalar)
{
Multiply(Scalar);
}

gp_Vec Multiplied(const Standard_Real Scalar) const;
gp_Vec operator *(const Standard_Real Scalar) const
{
return Multiplied(Scalar);
}

void Divide(const Standard_Real Scalar) ;
void operator /=(const Standard_Real Scalar)
{
Divide(Scalar);
}

gp_Vec Divided(const Standard_Real Scalar) const;
gp_Vec operator /(const Standard_Real Scalar) const
{
return Divided(Scalar);
}

void Cross(const gp_Vec& Right) ;
void operator ^=(const gp_Vec& Right)
{
Cross(Right);
}

gp_Vec Crossed(const gp_Vec& Right) const;
gp_Vec operator ^(const gp_Vec& Right) const
{
return Crossed(Right);
}

Standard_Real CrossMagnitude(const gp_Vec& Right) const;

Standard_Real CrossSquareMagnitude(const gp_Vec& Right) const;

void CrossCross(const gp_Vec& V1,const gp_Vec& V2) ;

gp_Vec CrossCrossed(const gp_Vec& V1,const gp_Vec& V2) const;

Standard_Real Dot(const gp_Vec& Other) const;
Standard_Real operator *(const gp_Vec& Other) const
{
return Dot(Other);
}

Standard_Real DotCross(const gp_Vec& V1,const gp_Vec& V2) const;

void Normalize() ;

gp_Vec Normalized() const;

void Reverse() ;

gp_Vec Reversed() const;
gp_Vec operator -() const
{
return Reversed();
}

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2,const Standard_Real A3,const gp_Vec& V3,const gp_Vec& V4) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2,const Standard_Real A3,const gp_Vec& V3) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2,const gp_Vec& V3) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const Standard_Real A2,const gp_Vec& V2) ;

void SetLinearForm(const Standard_Real A1,const gp_Vec& V1,const gp_Vec& V2) ;

void SetLinearForm(const gp_Vec& V1,const gp_Vec& V2) ;

void Mirror(const gp_Vec& V) ;

gp_Vec Mirrored(const gp_Vec& V) const;

void Mirror(const gp_Ax1& A1) ;

gp_Vec Mirrored(const gp_Ax1& A1) const;

void Mirror(const gp_Ax2& A2) ;

gp_Vec Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Vec Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Scale(const Standard_Real S) ;

gp_Vec Scaled(const Standard_Real S) const;

void Transform(const gp_Trsf& T) ;

gp_Vec Transformed(const gp_Trsf& T) const;
const gp_XYZ& _CSFDB_Getgp_Veccoord() const { return coord; }

friend Handle_Standard_Type& gp_Vec_Type_();

protected:
# 374 “/usr/include/opencascade/gp_Vec.hxx”
private:

gp_XYZ coord;

};

# 1 “/usr/include/opencascade/gp_Vec.lxx” 1

# 1 “/usr/include/opencascade/gp_Dir.hxx” 1
# 43 “/usr/include/opencascade/gp_Dir.hxx”
class Standard_ConstructionError;
class Standard_DomainError;
class Standard_OutOfRange;
class gp_Vec;
class gp_XYZ;
class gp_Ax1;
class gp_Ax2;
class gp_Trsf;
# 60 “/usr/include/opencascade/gp_Dir.hxx”
Handle_Standard_Type& gp_Dir_Type_();
# 70 “/usr/include/opencascade/gp_Dir.hxx”
class gp_Dir {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Dir();

gp_Dir(const gp_Vec& V);

gp_Dir(const gp_XYZ& Coord);

gp_Dir(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv);
# 117 “/usr/include/opencascade/gp_Dir.hxx”
void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xv,const Standard_Real Yv,const Standard_Real Zv) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

void SetXYZ(const gp_XYZ& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xv,Standard_Real& Yv,Standard_Real& Zv) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

const gp_XYZ& XYZ() const;

Standard_Boolean IsEqual(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsNormal(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsOpposite(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Boolean IsParallel(const gp_Dir& Other,const Standard_Real AngularTolerance) const;

Standard_Real Angle(const gp_Dir& Other) const;
# 179 “/usr/include/opencascade/gp_Dir.hxx”
Standard_Real AngleWithRef(const gp_Dir& Other,const gp_Dir& VRef) const;

void Cross(const gp_Dir& Right) ;
void operator ^=(const gp_Dir& Right)
{
Cross(Right);
}

gp_Dir Crossed(const gp_Dir& Right) const;
gp_Dir operator ^(const gp_Dir& Right) const
{
return Crossed(Right);
}

void CrossCross(const gp_Dir& V1,const gp_Dir& V2) ;
# 211 “/usr/include/opencascade/gp_Dir.hxx”
gp_Dir CrossCrossed(const gp_Dir& V1,const gp_Dir& V2) const;

Standard_Real Dot(const gp_Dir& Other) const;
Standard_Real operator *(const gp_Dir& Other) const
{
return Dot(Other);
}

Standard_Real DotCross(const gp_Dir& V1,const gp_Dir& V2) const;

void Reverse() ;

gp_Dir Reversed() const;
gp_Dir operator -() const
{
return Reversed();
}

void Mirror(const gp_Dir& V) ;

gp_Dir Mirrored(const gp_Dir& V) const;

void Mirror(const gp_Ax1& A1) ;

gp_Dir Mirrored(const gp_Ax1& A1) const;

void Mirror(const gp_Ax2& A2) ;

gp_Dir Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Dir Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Transform(const gp_Trsf& T) ;

gp_Dir Transformed(const gp_Trsf& T) const;
const gp_XYZ& _CSFDB_Getgp_Dircoord() const { return coord; }

friend Handle_Standard_Type& gp_Dir_Type_();

protected:
# 299 “/usr/include/opencascade/gp_Dir.hxx”
private:

gp_XYZ coord;

};

# 1 “/usr/include/opencascade/gp_Dir.lxx” 1

# 1 “/usr/include/opencascade/gp_Vec.hxx” 1
# 4 “/usr/include/opencascade/gp_Dir.lxx” 2

inline gp_Dir::gp_Dir ()
{ coord.SetCoord (1.0, 0.0, 0.0); }

inline gp_Dir::gp_Dir (const gp_Vec& V)
{
const gp_XYZ& XYZ = V.XYZ();
Standard_Real X = XYZ.X();
Standard_Real Y = XYZ.Y();
Standard_Real Z = XYZ.Z();
Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline gp_Dir::gp_Dir (const gp_XYZ& XYZ)
{
Standard_Real X = XYZ.X();
Standard_Real Y = XYZ.Y();
Standard_Real Z = XYZ.Z();
Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline gp_Dir::gp_Dir (const Standard_Real Xv,
const Standard_Real Yv,
const Standard_Real Zv)
{
Standard_Real D = sqrt (Xv * Xv + Yv * Yv + Zv * Zv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
coord.SetZ(Zv / D);
}

inline void gp_Dir::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{
Standard_Real X = coord.X();
Standard_Real Y = coord.Y();
Standard_Real Z = coord.Z();
if (Index < 1 || Index > 3) Standard_OutOfRange::Raise(” “);;
if (Index == 1) X = Xi;
else if (Index == 2) Y = Xi;
else Z = Xi;
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetCoord (const Standard_Real Xv,
const Standard_Real Yv,
const Standard_Real Zv) {
Standard_Real D = sqrt(Xv * Xv + Yv * Yv + Zv * Zv);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(Xv / D);
coord.SetY(Yv / D);
coord.SetZ(Zv / D);
}

inline void gp_Dir::SetX (const Standard_Real X)
{
Standard_Real Y = coord.Y();
Standard_Real Z = coord.Z();
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetY (const Standard_Real Y)
{
Standard_Real Z = coord.Z();
Standard_Real X = coord.X();
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetZ (const Standard_Real Z)
{
Standard_Real X = coord.X();
Standard_Real Y = coord.Y();
Standard_Real D = sqrt (X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline void gp_Dir::SetXYZ (const gp_XYZ& XYZ)
{
Standard_Real X = XYZ.X();
Standard_Real Y = XYZ.Y();
Standard_Real Z = XYZ.Z();
Standard_Real D = sqrt(X * X + Y * Y + Z * Z);
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.SetX(X / D);
coord.SetY(Y / D);
coord.SetZ(Z / D);
}

inline Standard_Real gp_Dir::Coord (const Standard_Integer Index) const
{ return coord.Coord (Index);}

inline void gp_Dir::Coord (Standard_Real& Xv,
Standard_Real& Yv,
Standard_Real& Zv) const
{ coord.Coord (Xv, Yv, Zv); }

inline Standard_Real gp_Dir::X() const
{ return coord.X() ; }

inline Standard_Real gp_Dir::Y() const
{ return coord.Y() ; }

inline Standard_Real gp_Dir::Z() const
{ return coord.Z() ; }

inline const gp_XYZ& gp_Dir::XYZ () const
{ return coord; }

inline Standard_Boolean gp_Dir::IsEqual
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{ return Angle (Other) <= AngularTolerance; }

inline Standard_Boolean gp_Dir::IsNormal
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Standard_PI / 2.0 – Angle (Other);
if (Ang < 0) Ang = – Ang;
return Ang <= AngularTolerance;
}

inline Standard_Boolean gp_Dir::IsOpposite
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{ return Standard_PI – Angle (Other) <= AngularTolerance; }

inline Standard_Boolean gp_Dir::IsParallel
(const gp_Dir& Other,
const Standard_Real AngularTolerance) const
{
Standard_Real Ang = Angle (Other);
return Ang <= AngularTolerance || Standard_PI – Ang <= AngularTolerance;
}

inline void gp_Dir::Cross (const gp_Dir& Right)
{
coord.Cross (Right.coord);
Standard_Real D = coord.Modulus ();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.Divide (D);
}

inline gp_Dir gp_Dir::Crossed (const gp_Dir& Right) const
{
gp_Dir V = *this;
V.coord.Cross (Right.coord);
Standard_Real D = V.coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
V.coord.Divide (D);
return V;
}

inline void gp_Dir::CrossCross (const gp_Dir& V1,
const gp_Dir& V2)
{
coord.CrossCross (V1.coord, V2.coord);
Standard_Real D = coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
coord.Divide(D);
}

inline gp_Dir gp_Dir::CrossCrossed (const gp_Dir& V1,
const gp_Dir& V2) const
{
gp_Dir V = *this;
(V.coord).CrossCross (V1.coord, V2.coord);
Standard_Real D = V.coord.Modulus();
if (D <= gp::Resolution()) Standard_ConstructionError::Raise(“”);;
V.coord.Divide(D);
return V;
}

inline Standard_Real gp_Dir::Dot (const gp_Dir& Other) const
{ return coord.Dot (Other.coord); }

inline Standard_Real gp_Dir::DotCross (const gp_Dir& V1,
const gp_Dir& V2) const
{ return coord.Dot (V1.coord.Crossed (V2.coord)); }

inline void gp_Dir::Reverse ()
{ coord.Reverse(); }

inline gp_Dir gp_Dir::Reversed () const {
gp_Dir V = *this;
V.coord.Reverse ();
return V;
}

inline void gp_Dir::Rotate (const gp_Ax1& A1, const Standard_Real Ang)
{
gp_Trsf T;
T.SetRotation (A1, Ang);
coord.Multiply (T.HVectorialPart ());
}

inline gp_Dir gp_Dir::Rotated (const gp_Ax1& A1,
const Standard_Real Ang) const
{
gp_Dir V = *this;
V.Rotate (A1, Ang);
return V;
}

inline gp_Dir gp_Dir::Transformed (const gp_Trsf& T) const
{
gp_Dir V = *this;
V.Transform (T);
return V;
}
# 314 “/usr/include/opencascade/gp_Dir.hxx” 2
# 7 “/usr/include/opencascade/gp_Vec.lxx” 2
# 1 “/usr/include/opencascade/gp_Pnt.hxx” 1
# 43 “/usr/include/opencascade/gp_Pnt.hxx”
class Standard_OutOfRange;
class gp_XYZ;
class gp_Ax1;
class gp_Ax2;
class gp_Trsf;
class gp_Vec;
# 58 “/usr/include/opencascade/gp_Pnt.hxx”
Handle_Standard_Type& gp_Pnt_Type_();

class gp_Pnt {

public:
void* operator new(size_t,void* anAddress)
{
return anAddress;
}
void* operator new(size_t size)
{
return Standard::Allocate(size);
}
void operator delete(void *anAddress)
{
if (anAddress) Standard::Free((Standard_Address&)anAddress);
}

gp_Pnt();

gp_Pnt(const gp_XYZ& Coord);

gp_Pnt(const Standard_Real Xp,const Standard_Real Yp,const Standard_Real Zp);

void SetCoord(const Standard_Integer Index,const Standard_Real Xi) ;

void SetCoord(const Standard_Real Xp,const Standard_Real Yp,const Standard_Real Zp) ;

void SetX(const Standard_Real X) ;

void SetY(const Standard_Real Y) ;

void SetZ(const Standard_Real Z) ;

void SetXYZ(const gp_XYZ& Coord) ;

Standard_Real Coord(const Standard_Integer Index) const;

void Coord(Standard_Real& Xp,Standard_Real& Yp,Standard_Real& Zp) const;

Standard_Real X() const;

Standard_Real Y() const;

Standard_Real Z() const;

const gp_XYZ& XYZ() const;

const gp_XYZ& Coord() const;

gp_XYZ& ChangeCoord() ;

void BaryCenter(const Standard_Real Alpha,const gp_Pnt& P,const Standard_Real Beta) ;

Standard_Boolean IsEqual(const gp_Pnt& Other,const Standard_Real LinearTolerance) const;

Standard_Real Distance(const gp_Pnt& Other) const;

Standard_Real SquareDistance(const gp_Pnt& Other) const;

void Mirror(const gp_Pnt& P) ;

gp_Pnt Mirrored(const gp_Pnt& P) const;

void Mirror(const gp_Ax1& A1) ;

gp_Pnt Mirrored(const gp_Ax1& A1) const;

void Mirror(const gp_Ax2& A2) ;

gp_Pnt Mirrored(const gp_Ax2& A2) const;

void Rotate(const gp_Ax1& A1,const Standard_Real Ang) ;

gp_Pnt Rotated(const gp_Ax1& A1,const Standard_Real Ang) const;

void Scale(const gp_Pnt& P,const Standard_Real S) ;

gp_Pnt Scaled(const gp_Pnt& P,const Standard_Real S) const;

void Transform(const gp_Trsf& T) ;

gp_Pnt Transformed(const gp_Trsf& T) const;

void Translate(const gp_Vec& V) ;

gp_Pnt Translated(const gp_Vec& V) const;

void Translate(const gp_Pnt& P1,const gp_Pnt& P2) ;

gp_Pnt Translated(const gp_Pnt& P1,const gp_Pnt& P2) const;
const gp_XYZ& _CSFDB_Getgp_Pntcoord() const { return coord; }

friend Handle_Standard_Type& gp_Pnt_Type_();

protected:
# 208 “/usr/include/opencascade/gp_Pnt.hxx”
private:

gp_XYZ coord;

};

# 1 “/usr/include/opencascade/gp_Pnt.lxx” 1
# 9 “/usr/include/opencascade/gp_Pnt.lxx”
inline gp_Pnt::gp_Pnt() { }

inline gp_Pnt::gp_Pnt (const gp_XYZ& Coordinates) : coord (Coordinates)
{ }

inline gp_Pnt::gp_Pnt (const Standard_Real Xp,
const Standard_Real Yp,
const Standard_Real Zp) : coord(Xp, Yp,Zp)
{ }

inline void gp_Pnt::SetCoord (const Standard_Integer Index,
const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Pnt::SetCoord (const Standard_Real Xp,
const Standard_Real Yp,
const Standard_Real Zp) {
coord.SetCoord (Xp, Yp, Zp);
}

inline void gp_Pnt::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Pnt::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Pnt::SetZ (const Standard_Real Z)
{ coord.SetZ (Z); }

inline void gp_Pnt::SetXYZ (const gp_XYZ& Coordinates)
{ coord = Coordinates; }

inline Standard_Real gp_Pnt::Coord (const Standard_Integer Index) const
{ return coord.Coord(Index); }

inline void gp_Pnt::Coord (Standard_Real& Xp,
Standard_Real& Yp,
Standard_Real& Zp) const {
coord.Coord (Xp, Yp, Zp);
}

inline Standard_Real gp_Pnt::X() const
{ return coord.X(); }

inline Standard_Real gp_Pnt::Y() const
{ return coord.Y(); }

inline Standard_Real gp_Pnt::Z() const
{ return coord.Z(); }

inline const gp_XYZ& gp_Pnt::XYZ () const
{ return coord; }

inline const gp_XYZ& gp_Pnt::Coord () const
{ return coord; }

inline gp_XYZ& gp_Pnt::ChangeCoord ()
{ return coord; }

inline void gp_Pnt::BaryCenter(const Standard_Real A,
const gp_Pnt& P,
const Standard_Real B)
{
coord.SetLinearForm(A,coord,B,P.coord);
coord.Divide(A + B);
}

inline Standard_Boolean gp_Pnt::IsEqual
(const gp_Pnt& Other,
const Standard_Real LinearTolerance) const
{ return Distance (Other) <= LinearTolerance; }

inline Standard_Real gp_Pnt::Distance (const gp_Pnt& Other) const
{
Standard_Real d=0,dd;
const gp_XYZ& XYZ = Other.coord;
dd = coord.X(); dd -= XYZ.X(); dd *= dd; d += dd;
dd = coord.Y(); dd -= XYZ.Y(); dd *= dd; d += dd;
dd = coord.Z(); dd -= XYZ.Z(); dd *= dd; d += dd;
return(sqrt(d));
}

inline Standard_Real gp_Pnt::SquareDistance (const gp_Pnt& Other) const
{
Standard_Real d=0,dd;
const gp_XYZ& XYZ = Other.coord;
dd = coord.X(); dd -= XYZ.X(); dd *= dd; d += dd;
dd = coord.Y(); dd -= XYZ.Y(); dd *= dd; d += dd;
dd = coord.Z(); dd -= XYZ.Z(); dd *= dd; d += dd;
return(d);
}

inline void gp_Pnt::Rotate (const gp_Ax1& A1,
const Standard_Real Ang)
{
gp_Trsf T;
T.SetRotation (A1, Ang);
T.Transforms (coord);
}

inline gp_Pnt gp_Pnt::Rotated (const gp_Ax1& A1,
const Standard_Real Ang) const
{
gp_Pnt P = *this;
P.Rotate (A1, Ang);
return P;
}

inline void gp_Pnt::Scale (const gp_Pnt& P,
const Standard_Real S)
{
gp_XYZ XYZ = P.coord;
XYZ.Multiply (1.0 – S);
coord.Multiply (S);
coord.Add (XYZ);
}

inline gp_Pnt gp_Pnt::Scaled (const gp_Pnt& P,
const Standard_Real S) const
{
gp_Pnt Pres = *this;
Pres.Scale (P, S);
return Pres;
}

inline gp_Pnt gp_Pnt::Transformed (const gp_Trsf& T) const
{
gp_Pnt P = *this;
P.Transform (T);
return P;
}

inline void gp_Pnt::Translate (const gp_Vec& V)
{ coord.Add (V.XYZ()); }

inline gp_Pnt gp_Pnt::Translated (const gp_Vec& V) const
{
gp_Pnt P = *this;
P.coord.Add (V.XYZ());
return P;
}

inline void gp_Pnt::Translate (const gp_Pnt& P1,
const gp_Pnt& P2)
{
coord.Add (P2.coord);
coord.Subtract (P1.coord);
}

inline gp_Pnt gp_Pnt::Translated (const gp_Pnt& P1,
const gp_Pnt& P2) const
{
gp_Pnt P = *this;
P.Translate (P1 , P2);
return P;
}
# 223 “/usr/include/opencascade/gp_Pnt.hxx” 2
# 8 “/usr/include/opencascade/gp_Vec.lxx” 2

# 1 “/usr/include/opencascade/gp_VectorWithNullMagnitude.hxx” 1
# 29 “/usr/include/opencascade/gp_VectorWithNullMagnitude.hxx”
# 1 “/usr/include/opencascade/Handle_gp_VectorWithNullMagnitude.hxx” 1
# 36 “/usr/include/opencascade/Handle_gp_VectorWithNullMagnitude.hxx”
class Standard_Transient;
class Handle_Standard_Type;
class Handle_Standard_DomainError;
class gp_VectorWithNullMagnitude;
Handle_Standard_Type& gp_VectorWithNullMagnitude_Type_();

class Handle_gp_VectorWithNullMagnitude : public Handle_Standard_DomainError {
public:
Handle_gp_VectorWithNullMagnitude():Handle_Standard_DomainError() {}
Handle_gp_VectorWithNullMagnitude(const Handle_gp_VectorWithNullMagnitude& aHandle) : Handle_Standard_DomainError(aHandle)
{
}

Handle_gp_VectorWithNullMagnitude(const gp_VectorWithNullMagnitude* anItem) : Handle_Standard_DomainError((Standard_DomainError *)anItem)
{
}

Handle_gp_VectorWithNullMagnitude& operator=(const Handle_gp_VectorWithNullMagnitude& aHandle)
{
Assign(aHandle.Access());
return *this;
}

Handle_gp_VectorWithNullMagnitude& operator=(const gp_VectorWithNullMagnitude* anItem)
{
Assign((Standard_Transient *)anItem);
return *this;
}