[occt.git] / src / LDOM / LDOMBasicString.cxx

// Created on: 2001-06-26
// Created by: Alexander GRIGORIEV
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#include <LDOMBasicString.hxx>
#include <LDOM_MemManager.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <errno.h>

//=======================================================================
//function : LDOMString
//purpose  : Create a free string (not connected to any type of container)
//=======================================================================

LDOMBasicString::LDOMBasicString (const char * aValue)
{
  if (aValue == NULL /*|| aValue[0] == '\0'*/) {
    myType = LDOM_NULL;
    myVal.ptr = NULL;
  } else {
    myType = LDOM_AsciiFree;
    Standard_Size aLen = strlen (aValue) + 1;
    myVal.ptr = new char [aLen];
    memcpy (myVal.ptr, aValue, aLen);
  }
}

//=======================================================================
//function : LDOMString
//purpose  : Create an Ascii string managed by LDOM_Document
//=======================================================================

LDOMBasicString::LDOMBasicString (const char                     * aValue,
                                  const Handle(LDOM_MemManager)& aDoc)
{
  if (aValue == NULL /*|| aValue[0] == '\0'*/) {
    myType = LDOM_NULL;
    myVal.ptr = NULL;
  } else {
    myType = LDOM_AsciiDoc;
    Standard_Integer aLen = (Standard_Integer) strlen (aValue) + 1;
    myVal.ptr = aDoc -> Allocate (aLen);
    memcpy (myVal.ptr, aValue, aLen);
  }
}
  
//=======================================================================
//function : LDOMString
//purpose  : Create an Ascii string managed by LDOM_Document
//=======================================================================

LDOMBasicString::LDOMBasicString (const char                     * aValue,
                                  const Standard_Integer         aLen,
                                  const Handle(LDOM_MemManager)& aDoc)
{
  if (aValue == NULL || aLen == 0) {
    myType = LDOM_NULL;
    myVal.ptr = NULL;
  } else {
    myType = LDOM_AsciiDoc;
    myVal.ptr = aDoc -> Allocate (aLen + 1);
    memcpy (myVal.ptr, aValue, aLen);
    ((char *)myVal.ptr)[aLen] = '\0';
  }
}
  
//=======================================================================
//function : LDOMBasicString
//purpose  : Copy constructor
//=======================================================================

LDOMBasicString::LDOMBasicString (const LDOMBasicString& anOther)
    : myType (anOther.Type())
{
  switch (myType) {
  case LDOM_AsciiFree:
    if (anOther.myVal.ptr) {
      Standard_Size aLen = strlen ((const char *)anOther.myVal.ptr) + 1;
      myVal.ptr = new char [aLen];
      memcpy (myVal.ptr, anOther.myVal.ptr, aLen);
      break;
    }
    Standard_FALLTHROUGH
  case LDOM_AsciiDoc:
  case LDOM_AsciiDocClear:
  case LDOM_AsciiHashed:
    myVal.ptr = anOther.myVal.ptr;
    break;
  case LDOM_Integer:
    myVal.i = anOther.myVal.i;
  default: ;
  }
}

//=======================================================================
//function : ~LDOMString()
//purpose  : Destructor
//=======================================================================

LDOMBasicString::~LDOMBasicString ()
{
  if (myType == LDOM_AsciiFree) {
    if (myVal.ptr)
      delete [] (char *) myVal.ptr;
  }
}

//=======================================================================
//function : operator =
//purpose  : Assignment to NULL
//=======================================================================

LDOMBasicString& LDOMBasicString::operator = (const LDOM_NullPtr *)
{
  if (myType == LDOM_AsciiFree && myVal.ptr)
    delete [] (char *) myVal.ptr;
  myType    = LDOM_NULL;
  myVal.ptr = NULL;
  return * this;
}

//=======================================================================
//function : operator =
//purpose  : Assignment
//=======================================================================

LDOMBasicString& LDOMBasicString::operator = (const LDOMBasicString& anOther)
{
  if (myType == LDOM_AsciiFree && myVal.ptr)
    delete [] (char *) myVal.ptr;
  myType    = anOther.Type();
  switch (myType) {
  case LDOM_AsciiFree:
    if (anOther.myVal.ptr) {
      Standard_Size aLen = strlen ((const char *)anOther.myVal.ptr) + 1;
      myVal.ptr = new char [aLen];
      memcpy (myVal.ptr, anOther.myVal.ptr, aLen);
      break;
    }
    Standard_FALLTHROUGH
  case LDOM_AsciiDoc:
  case LDOM_AsciiDocClear:
  case LDOM_AsciiHashed:
    myVal.ptr = anOther.myVal.ptr;
    break;
  case LDOM_Integer:
    myVal.i = anOther.myVal.i;
  default: ;
  }
  return * this;
}

//=======================================================================
//function : equals
//purpose  : Compare two strings by content
//=======================================================================

Standard_Boolean LDOMBasicString::equals (const LDOMBasicString& anOther) const
{
  Standard_Boolean aResult = Standard_False;
  switch (myType)
  {
  case LDOM_NULL:
    return (anOther == NULL);
  case LDOM_Integer:
    switch (anOther.Type())
    {
    case LDOM_Integer:
      return (myVal.i == anOther.myVal.i);
    case LDOM_AsciiFree:
    case LDOM_AsciiDoc:
    case LDOM_AsciiDocClear:
    case LDOM_AsciiHashed:
      {
        long aLongOther = strtol ((const char *) anOther.myVal.ptr, NULL, 10);
        return (errno == 0 && aLongOther == long(myVal.i));
      }
    case LDOM_NULL:
    default:
      ;
    }
    break;
  default:
    switch (anOther.Type())
    {
    case LDOM_Integer:
      {
        long aLong = strtol ((const char *) myVal.ptr, NULL, 10);
        return (errno == 0 && aLong == long(anOther.myVal.i));
      }
    case LDOM_AsciiFree:
    case LDOM_AsciiDoc:
    case LDOM_AsciiDocClear:
    case LDOM_AsciiHashed:
      return (strcmp ((const char *) myVal.ptr,
                      (const char *) anOther.myVal.ptr) == 0);
    case LDOM_NULL:
    default:
      ;
    }
  }
  return aResult;
}

//=======================================================================
//function : operator TCollection_AsciiString
//purpose  : 
//=======================================================================

LDOMBasicString::operator TCollection_AsciiString () const
{
  switch (myType) {
  case LDOM_Integer:
    return TCollection_AsciiString (myVal.i);
  case LDOM_AsciiFree:
  case LDOM_AsciiDoc:
  case LDOM_AsciiDocClear:
  case LDOM_AsciiHashed:
    return TCollection_AsciiString (Standard_CString(myVal.ptr));
  default: ;
  }
  return TCollection_AsciiString ();
}

//=======================================================================
//function : operator TCollection_ExtendedString
//purpose  : 
//=======================================================================

LDOMBasicString::operator TCollection_ExtendedString () const
{
  switch (myType) {
  case LDOM_Integer:
    return TCollection_ExtendedString (myVal.i);
  case LDOM_AsciiFree:
  case LDOM_AsciiDoc:
  case LDOM_AsciiDocClear:
  case LDOM_AsciiHashed:
  {
    char buf[6] = {'\0','\0','\0','\0','\0','\0'};
    const long aUnicodeHeader = 0xfeff;
    Standard_CString ptr = Standard_CString (myVal.ptr);
    errno = 0;
    // Check if ptr is ascii string
    if (ptr[0] != '#' || ptr[1] != '#')
      return TCollection_ExtendedString (ptr);
    buf[0] = ptr[2];
    buf[1] = ptr[3];
    buf[2] = ptr[4];
    buf[3] = ptr[5];
    if (strtol (&buf[0], NULL, 16) != aUnicodeHeader)
      return TCollection_ExtendedString (ptr);

    // convert Unicode to Extended String
    ptr += 2;
    Standard_Size aLength = (strlen(ptr) / 4), j = 0;
    Standard_ExtCharacter * aResult = new Standard_ExtCharacter[aLength--];
    while (aLength--) {
      ptr += 4;
      buf[0] = ptr[0];
      buf[1] = ptr[1];
      buf[2] = ptr[2];
      buf[3] = ptr[3];
      aResult[j++] = Standard_ExtCharacter (strtol (&buf[0], NULL, 16));
      if (errno) {
        delete [] aResult;
        return TCollection_ExtendedString();
      }
    }
    aResult[j] = 0;
    TCollection_ExtendedString aResultStr (aResult);
    delete [] aResult;
    return aResultStr;
  }
  default: ;
  }
  return TCollection_ExtendedString();
}

//=======================================================================
//function : GetInteger
//purpose  : Conversion to Integer
//=======================================================================

Standard_Boolean LDOMBasicString::GetInteger (Standard_Integer& aResult) const
{
  switch (myType) {
  case LDOM_Integer:
    aResult = myVal.i;
    break;
  case LDOM_AsciiFree:
  case LDOM_AsciiDoc:
  case LDOM_AsciiDocClear:
  case LDOM_AsciiHashed:
    {
      char * ptr;
      long aValue = strtol ((const char *)myVal.ptr, &ptr, 10);
      if (ptr == myVal.ptr || errno == ERANGE || errno == EINVAL)
        return Standard_False;
      aResult = Standard_Integer (aValue);
      break;
    }
  default:
    return Standard_False;
  }
  return Standard_True;
}

#ifdef OCCT_DEBUG
#ifndef _MSC_VER
//=======================================================================
// Debug Function for DBX: use "print -p <Variable> or pp <Variable>"
//=======================================================================
#include <LDOM_OSStream.hxx>
#define FLITERAL 0x10
char * db_pretty_print (const LDOMBasicString * aString, int fl, char *)
{
  LDOM_OSStream out (128);
  const char * str;
  switch (aString -> myType) {
  case LDOMBasicString::LDOM_Integer:
    if ((fl & FLITERAL) == 0)  out << "LDOM_Integer: ";
    out << '\"' << aString -> myVal.i << '\"'; goto finis;
  case LDOMBasicString::LDOM_AsciiFree:
    if ((fl & FLITERAL) == 0)  out << "LDOM_AsciiFree: ";
    break;
  case LDOMBasicString::LDOM_AsciiDoc:
    if ((fl & FLITERAL) == 0)  out << "LDOM_AsciiDoc: ";
    break;
  case LDOMBasicString::LDOM_AsciiDocClear:
    if ((fl & FLITERAL) == 0)  out << "LDOM_AsciiDocClear: ";
    break;
  case LDOMBasicString::LDOM_AsciiHashed:
    if ((fl & FLITERAL) == 0)  out << "LDOM_AsciiHashed: ";
    break;
  default:
    out << "Unknown type";
  }
  str = (const char *) aString -> myVal.ptr;
  out << '\"';
  if (strlen (str) > 512)
    out.rdbuf() -> sputn (str, 512);
  else
    out << str;
  out << '\"';
 finis:
  out << std::ends;
  return (char *)out.str();
}
#endif
#endif
Commit	Line	Data
b311480e	1	// Created on: 2001-06-26
b311480e	2	// Created by: Alexander GRIGORIEV
973c2be1	3	// Copyright (c) 2001-2014 OPEN CASCADE SAS
b311480e	4	//
973c2be1	5	// This file is part of Open CASCADE Technology software library.
b311480e	6	//
d5f74e42	7	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	8	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	9	// by the Free Software Foundation, with special exception defined in the file
	10	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	11	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	12	//
973c2be1	13	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	14	// commercial license or contractual agreement.
7fd59977	15
	16	#include <LDOMBasicString.hxx>
	17	#include <LDOM_MemManager.hxx>
	18	#include <TCollection_AsciiString.hxx>
	19	#include <TCollection_ExtendedString.hxx>
	20	#include <errno.h>
	21
	22	//=======================================================================
	23	//function : LDOMString
	24	//purpose : Create a free string (not connected to any type of container)
	25	//=======================================================================
	26
	27	LDOMBasicString::LDOMBasicString (const char * aValue)
	28	{
	29	if (aValue == NULL /\|\| aValue[0] == '\0'/) {
	30	myType = LDOM_NULL;
	31	myVal.ptr = NULL;
	32	} else {
	33	myType = LDOM_AsciiFree;
60be1f9b	34	Standard_Size aLen = strlen (aValue) + 1;
7fd59977	35	myVal.ptr = new char [aLen];
	36	memcpy (myVal.ptr, aValue, aLen);
	37	}
	38	}
	39
	40	//=======================================================================
	41	//function : LDOMString
	42	//purpose : Create an Ascii string managed by LDOM_Document
	43	//=======================================================================
	44
	45	LDOMBasicString::LDOMBasicString (const char * aValue,
	46	const Handle(LDOM_MemManager)& aDoc)
	47	{
	48	if (aValue == NULL /\|\| aValue[0] == '\0'/) {
	49	myType = LDOM_NULL;
	50	myVal.ptr = NULL;
	51	} else {
	52	myType = LDOM_AsciiDoc;
60be1f9b	53	Standard_Integer aLen = (Standard_Integer) strlen (aValue) + 1;
7fd59977	54	myVal.ptr = aDoc -> Allocate (aLen);
	55	memcpy (myVal.ptr, aValue, aLen);
	56	}
	57	}
	58
	59	//=======================================================================
	60	//function : LDOMString
	61	//purpose : Create an Ascii string managed by LDOM_Document
	62	//=======================================================================
	63
	64	LDOMBasicString::LDOMBasicString (const char * aValue,
	65	const Standard_Integer aLen,
	66	const Handle(LDOM_MemManager)& aDoc)
	67	{
	68	if (aValue == NULL \|\| aLen == 0) {
	69	myType = LDOM_NULL;
	70	myVal.ptr = NULL;
	71	} else {
	72	myType = LDOM_AsciiDoc;
	73	myVal.ptr = aDoc -> Allocate (aLen + 1);
	74	memcpy (myVal.ptr, aValue, aLen);
	75	((char *)myVal.ptr)[aLen] = '\0';
	76	}
	77	}
	78
	79	//=======================================================================
	80	//function : LDOMBasicString
	81	//purpose : Copy constructor
	82	//=======================================================================
	83
	84	LDOMBasicString::LDOMBasicString (const LDOMBasicString& anOther)
	85	: myType (anOther.Type())
	86	{
	87	switch (myType) {
	88	case LDOM_AsciiFree:
	89	if (anOther.myVal.ptr) {
60be1f9b	90	Standard_Size aLen = strlen ((const char *)anOther.myVal.ptr) + 1;
7fd59977	91	myVal.ptr = new char [aLen];
	92	memcpy (myVal.ptr, anOther.myVal.ptr, aLen);
	93	break;
	94	}
b1811c1d	95	Standard_FALLTHROUGH
7fd59977	96	case LDOM_AsciiDoc:
	97	case LDOM_AsciiDocClear:
	98	case LDOM_AsciiHashed:
	99	myVal.ptr = anOther.myVal.ptr;
	100	break;
	101	case LDOM_Integer:
	102	myVal.i = anOther.myVal.i;
	103	default: ;
	104	}
	105	}
	106
	107	//=======================================================================
	108	//function : ~LDOMString()
	109	//purpose : Destructor
	110	//=======================================================================
	111
	112	LDOMBasicString::~LDOMBasicString ()
	113	{
	114	if (myType == LDOM_AsciiFree) {
	115	if (myVal.ptr)
	116	delete [] (char *) myVal.ptr;
	117	}
	118	}
	119
	120	//=======================================================================
	121	//function : operator =
	122	//purpose : Assignment to NULL
	123	//=======================================================================
	124
	125	LDOMBasicString& LDOMBasicString::operator = (const LDOM_NullPtr *)
	126	{
	127	if (myType == LDOM_AsciiFree && myVal.ptr)
	128	delete [] (char *) myVal.ptr;
	129	myType = LDOM_NULL;
	130	myVal.ptr = NULL;
	131	return * this;
	132	}
	133
	134	//=======================================================================
	135	//function : operator =
	136	//purpose : Assignment
	137	//=======================================================================
	138
	139	LDOMBasicString& LDOMBasicString::operator = (const LDOMBasicString& anOther)
	140	{
	141	if (myType == LDOM_AsciiFree && myVal.ptr)
	142	delete [] (char *) myVal.ptr;
	143	myType = anOther.Type();
	144	switch (myType) {
	145	case LDOM_AsciiFree:
	146	if (anOther.myVal.ptr) {
60be1f9b	147	Standard_Size aLen = strlen ((const char *)anOther.myVal.ptr) + 1;
7fd59977	148	myVal.ptr = new char [aLen];
	149	memcpy (myVal.ptr, anOther.myVal.ptr, aLen);
	150	break;
	151	}
b1811c1d	152	Standard_FALLTHROUGH
7fd59977	153	case LDOM_AsciiDoc:
	154	case LDOM_AsciiDocClear:
	155	case LDOM_AsciiHashed:
	156	myVal.ptr = anOther.myVal.ptr;
	157	break;
	158	case LDOM_Integer:
	159	myVal.i = anOther.myVal.i;
	160	default: ;
	161	}
	162	return * this;
	163	}
	164
	165	//=======================================================================
	166	//function : equals
	167	//purpose : Compare two strings by content
	168	//=======================================================================
	169
	170	Standard_Boolean LDOMBasicString::equals (const LDOMBasicString& anOther) const
	171	{
	172	Standard_Boolean aResult = Standard_False;
	173	switch (myType)
	174	{
	175	case LDOM_NULL:
	176	return (anOther == NULL);
	177	case LDOM_Integer:
	178	switch (anOther.Type())
	179	{
	180	case LDOM_Integer:
	181	return (myVal.i == anOther.myVal.i);
	182	case LDOM_AsciiFree:
	183	case LDOM_AsciiDoc:
	184	case LDOM_AsciiDocClear:
	185	case LDOM_AsciiHashed:
	186	{
	187	long aLongOther = strtol ((const char *) anOther.myVal.ptr, NULL, 10);
	188	return (errno == 0 && aLongOther == long(myVal.i));
	189	}
	190	case LDOM_NULL:
	191	default:
	192	;
	193	}
	194	break;
	195	default:
	196	switch (anOther.Type())
	197	{
	198	case LDOM_Integer:
	199	{
	200	long aLong = strtol ((const char *) myVal.ptr, NULL, 10);
	201	return (errno == 0 && aLong == long(anOther.myVal.i));
	202	}
	203	case LDOM_AsciiFree:
	204	case LDOM_AsciiDoc:
	205	case LDOM_AsciiDocClear:
	206	case LDOM_AsciiHashed:
	207	return (strcmp ((const char *) myVal.ptr,
	208	(const char *) anOther.myVal.ptr) == 0);
	209	case LDOM_NULL:
	210	default:
	211	;
	212	}
	213	}
	214	return aResult;
	215	}
	216
217	//=======================================================================
218	//function : operator TCollection_AsciiString
219	//purpose :
220	//=======================================================================
221
222	LDOMBasicString::operator TCollection_AsciiString () const
223	{
224	switch (myType) {
225	case LDOM_Integer:
226	return TCollection_AsciiString (myVal.i);
227	case LDOM_AsciiFree:
228	case LDOM_AsciiDoc:
229	case LDOM_AsciiDocClear:
230	case LDOM_AsciiHashed:
231	return TCollection_AsciiString (Standard_CString(myVal.ptr));
232	default: ;
233	}
234	return TCollection_AsciiString ();
235	}
236
237	//=======================================================================
238	//function : operator TCollection_ExtendedString
239	//purpose :
240	//=======================================================================
241
242	LDOMBasicString::operator TCollection_ExtendedString () const
243	{
244	switch (myType) {
245	case LDOM_Integer:
246	return TCollection_ExtendedString (myVal.i);
247	case LDOM_AsciiFree:
248	case LDOM_AsciiDoc:
249	case LDOM_AsciiDocClear:
250	case LDOM_AsciiHashed:
251	{
252	char buf[6] = {'\0','\0','\0','\0','\0','\0'};
253	const long aUnicodeHeader = 0xfeff;
254	Standard_CString ptr = Standard_CString (myVal.ptr);
255	errno = 0;
256	// Check if ptr is ascii string
257	if (ptr[0] != '#' \|\| ptr[1] != '#')
258	return TCollection_ExtendedString (ptr);
259	buf[0] = ptr[2];
260	buf[1] = ptr[3];
261	buf[2] = ptr[4];
262	buf[3] = ptr[5];
263	if (strtol (&buf[0], NULL, 16) != aUnicodeHeader)
264	return TCollection_ExtendedString (ptr);
265
266	// convert Unicode to Extended String
267	ptr += 2;
60be1f9b	268	Standard_Size aLength = (strlen(ptr) / 4), j = 0;
7fd59977	269	Standard_ExtCharacter * aResult = new Standard_ExtCharacter[aLength--];
	270	while (aLength--) {
	271	ptr += 4;
	272	buf[0] = ptr[0];
	273	buf[1] = ptr[1];
	274	buf[2] = ptr[2];
	275	buf[3] = ptr[3];
	276	aResult[j++] = Standard_ExtCharacter (strtol (&buf[0], NULL, 16));
	277	if (errno) {
	278	delete [] aResult;
	279	return TCollection_ExtendedString();
	280	}
	281	}
	282	aResult[j] = 0;
	283	TCollection_ExtendedString aResultStr (aResult);
	284	delete [] aResult;
	285	return aResultStr;
	286	}
	287	default: ;
	288	}
	289	return TCollection_ExtendedString();
	290	}
	291
	292	//=======================================================================
	293	//function : GetInteger
	294	//purpose : Conversion to Integer
	295	//=======================================================================
	296
	297	Standard_Boolean LDOMBasicString::GetInteger (Standard_Integer& aResult) const
	298	{
	299	switch (myType) {
	300	case LDOM_Integer:
	301	aResult = myVal.i;
	302	break;
	303	case LDOM_AsciiFree:
	304	case LDOM_AsciiDoc:
	305	case LDOM_AsciiDocClear:
	306	case LDOM_AsciiHashed:
	307	{
	308	char * ptr;
	309	long aValue = strtol ((const char *)myVal.ptr, &ptr, 10);
	310	if (ptr == myVal.ptr \|\| errno == ERANGE \|\| errno == EINVAL)
	311	return Standard_False;
	312	aResult = Standard_Integer (aValue);
	313	break;
	314	}
	315	default:
	316	return Standard_False;
	317	}
	318	return Standard_True;
	319	}
	320
0797d9d3	321	#ifdef OCCT_DEBUG
57c28b61	322	#ifndef _MSC_VER
7fd59977	323	//=======================================================================
	324	// Debug Function for DBX: use "print -p <Variable> or pp <Variable>"
	325	//=======================================================================
	326	#include <LDOM_OSStream.hxx>
	327	#define FLITERAL 0x10
	328	char * db_pretty_print (const LDOMBasicString * aString, int fl, char *)
	329	{
	330	LDOM_OSStream out (128);
	331	const char * str;
	332	switch (aString -> myType) {
	333	case LDOMBasicString::LDOM_Integer:
	334	if ((fl & FLITERAL) == 0) out << "LDOM_Integer: ";
	335	out << '\"' << aString -> myVal.i << '\"'; goto finis;
	336	case LDOMBasicString::LDOM_AsciiFree:
	337	if ((fl & FLITERAL) == 0) out << "LDOM_AsciiFree: ";
	338	break;
	339	case LDOMBasicString::LDOM_AsciiDoc:
	340	if ((fl & FLITERAL) == 0) out << "LDOM_AsciiDoc: ";
	341	break;
	342	case LDOMBasicString::LDOM_AsciiDocClear:
	343	if ((fl & FLITERAL) == 0) out << "LDOM_AsciiDocClear: ";
	344	break;
	345	case LDOMBasicString::LDOM_AsciiHashed:
	346	if ((fl & FLITERAL) == 0) out << "LDOM_AsciiHashed: ";
	347	break;
	348	default:
	349	out << "Unknown type";
	350	}
	351	str = (const char *) aString -> myVal.ptr;
	352	out << '\"';
	353	if (strlen (str) > 512)
	354	out.rdbuf() -> sputn (str, 512);
	355	else
	356	out << str;
	357	out << '\"';
	358	finis:
04232180	359	out << std::ends;
7fd59977	360	return (char *)out.str();
	361	}
	362	#endif
	363	#endif