Пример #1
0
uint64_t CECTag::GetInt() const
{
	if (m_tagData == NULL) {
		// Empty tag - This is NOT an error.
		EC_ASSERT(m_dataType == EC_TAGTYPE_UNKNOWN);
		return 0;
	}

	switch (m_dataType) {
		case EC_TAGTYPE_UINT8:
			return PeekUInt8(m_tagData);
		case EC_TAGTYPE_UINT16:
			return ENDIAN_NTOHS( RawPeekUInt16( m_tagData ) );
		case EC_TAGTYPE_UINT32:
			return ENDIAN_NTOHL( RawPeekUInt32( m_tagData ) );
		case EC_TAGTYPE_UINT64:
			return ENDIAN_NTOHLL( RawPeekUInt64( m_tagData ) );
		case EC_TAGTYPE_UNKNOWN:
			// Empty tag - This is NOT an error.
			return 0;
		default:
			EC_ASSERT(0);
			return 0;
	}
}
Пример #2
0
std::string CECTag::GetStringDataSTL() const
{
	if (m_dataType != EC_TAGTYPE_STRING) {
		EC_ASSERT(m_dataType == EC_TAGTYPE_UNKNOWN);
		return std::string();
	} else if (m_tagData == NULL) {
		EC_ASSERT(false);
		return std::string();
	}

	return std::string(m_tagData);
}
Пример #3
0
static EC_OBJ string_setitem( EC_OBJ obj, EC_OBJ index, EC_OBJ value )
{
	if (! EC_INUMP(index))
	{
		/* TODO: Throw an exception */
		EC_ASSERT( FALSE );
		return Ec_ERROR;
	}

	if (! EC_CHARP(value))
	{
		/* TODO: Throw an exception */
		EC_ASSERT( FALSE );
		return Ec_ERROR;
	}

	if (EC_INUM(index) >= EC_USTRLEN(obj))
	{
		/* expand the string */

		EcInt newlen, i;
		char  *newdata;

		newlen  = EC_INUM(index) + 1;
		newdata = ec_realloc( EC_USTRDATA(obj), newlen + 1 );
		if (! newdata)
			return EcMemoryError();

		for (i = EC_USTRLEN(obj); i < newlen; i++)
			newdata[i] = '\0';
		newdata[newlen] = '\0';

		EC_USTRDATA(obj) = newdata;
		EC_USTRLEN(obj) = newlen;
	}

	if ((EC_INUM(index) < 0) || (EC_INUM(index) >= EC_USTRLEN(obj)))
	{
		ec_string ds;

		ec_string_init( &ds, NULL );
		ec_sprintf( &ds, "Index %ld out of bounds for object %w", EC_INUM(index), obj );

		EcMakeExceptionWithArgs( EcIndexErrorClass,
								 ec_strdata( &ds ), 2,
								 index, obj );
		ec_string_cleanup( &ds );
		return Ec_ERROR;
	}

	EC_USTRDATA(obj)[EC_INUM(index)] = EC_CHAR(value);
	return obj;
}
Пример #4
0
CMD4Hash CECTag::GetMD4Data() const
{
	if (m_dataType != EC_TAGTYPE_HASH16) {
		EC_ASSERT(m_dataType == EC_TAGTYPE_UNKNOWN);
		return CMD4Hash();
	}

	EC_ASSERT(m_tagData != NULL);

	// Doesn't matter if m_tagData is NULL in CMD4Hash(),
	// that'll just result in an empty hash.
	return CMD4Hash((const unsigned char *)m_tagData);
}
Пример #5
0
/**
 * Returns an EC_IPv4_t class.
 *
 * This function takes care of the endianness of the port number.
 *
 * @return EC_IPv4_t class.
 *
 * @see CECTag(ec_tagname_t, const EC_IPv4_t&)
 */
EC_IPv4_t CECTag::GetIPv4Data() const
{
	EC_IPv4_t p(0, 0);

	if (m_dataType != EC_TAGTYPE_IPV4) {
		EC_ASSERT(m_dataType == EC_TAGTYPE_UNKNOWN);
	} else if (m_tagData == NULL) {
		EC_ASSERT(false);
	} else {
		RawPokeUInt32( p.m_ip, RawPeekUInt32( reinterpret_cast<EC_IPv4_t *>(m_tagData)->m_ip ) );
		p.m_port = ENDIAN_NTOHS(reinterpret_cast<EC_IPv4_t *>(m_tagData)->m_port);
	}

	return p;
}
Пример #6
0
/* Private */

static EC_OBJ ustring_copy( EC_OBJ obj, EcCopyType type )
{
	EC_ASSERT( EC_USTRINGP(obj) );

	return EcMakeUString( EC_USTRDATA(obj), EC_USTRLEN(obj) , EcTrue );
}

static void ustring_mark( EC_OBJ obj )
{
	EC_ASSERT( EC_USTRINGP(obj) );
}

static void ustring_free( EC_OBJ obj )
{
	EC_ASSERT( EC_USTRINGP(obj) );

	ec_free( EC_USTRDATA(obj) );
	EC_USTRDATA(obj) = NULL;
	EC_USTRLEN(obj) = 0;
}

static EcInt ustring_print( ec_string *str, EC_OBJ obj, EcBool detailed )
{
	EcInt res = 0;
	EC_ASSERT( EC_USTRINGP(obj) );

	{
		ec_strcat( str, "<unicode string>", sizeof("<unicode string>") - 1 );
		res += sizeof("<unicode string>") - 1;
	}
	return res;
}

#if 0 /* unimplemented */
static EC_OBJ ustring_getitem( EC_OBJ obj, EC_OBJ index )
{
	if (! EC_INUMP(index))
	{
		/* TODO: Throw an exception */
		EC_ASSERT( FALSE );
		return Ec_ERROR;
	}

	if ((EC_INUM(index) < 0) || (EC_INUM(index) >= EC_USTRLEN(obj)))
	{
		ec_string ds;

		ec_string_init( &ds, NULL );
		ec_sprintf( &ds, "Index %ld out of bounds for object %w", EC_INUM(index), obj );

		EcMakeExceptionWithArgs( EcIndexErrorClass,
								 ec_strdata( &ds ), 2,
								 index, obj );
		ec_string_cleanup( &ds );
		return Ec_ERROR;
	}

	return EcMakeUChar( EC_USTRDATA(obj)[EC_INUM(index)] );
}
Пример #7
0
/**
 * Returns a double value.
 *
 * @note The returned value is what we get by converting the string form
 * of the number to a double.
 *
 * @return The double value of the tag.
 *
 * @see CECTag(ec_tagname_t, double)
 */
double CECTag::GetDoubleData(void) const
{
	if (m_dataType != EC_TAGTYPE_DOUBLE) {
		EC_ASSERT(m_dataType == EC_TAGTYPE_UNKNOWN);
		return 0;
	} else if (m_tagData == NULL) {
		EC_ASSERT(false);
		return 0;
	}

	std::istringstream double_str(m_tagData);

	double data;
	double_str >> data;
	return data;
}
Пример #8
0
static void ustring_free( EC_OBJ obj )
{
	EC_ASSERT( EC_USTRINGP(obj) );

	ec_free( EC_USTRDATA(obj) );
	EC_USTRDATA(obj) = NULL;
	EC_USTRLEN(obj) = 0;
}
Пример #9
0
static EC_OBJ ustring_radd( EC_OBJ obj1, EC_OBJ obj2 )
{
	/* ec_string str; */
	EC_OBJ    res;
	EcInt     len;

	if (! EC_USTRINGP(obj2))
		return EcTypeError( EC_NIL, EC_NIL, 2, tc_string, obj2, TRUE, "string radd" );

	EC_ASSERT( EC_USTRINGP(obj1) );
	EC_ASSERT( EC_USTRINGP(obj2) );

	len = EC_USTRLEN(obj1) + EC_USTRLEN(obj2);
	res = EcMakeUString( EC_USTRDATA(obj2), len , EcTrue );
	u_strcat(EC_USTRDATA(res), EC_USTRDATA(obj1) );
	EC_USTRLEN(res) = len;

	return res;
}
Пример #10
0
bool CECTag::AssignIfExist(ec_tagname_t tagname, uint8_t &target) const
{
	const CECTag *tag = GetTagByName(tagname);
	if (tag) {
		EC_ASSERT((tag->GetType() == EC_TAGTYPE_UINT8) || (m_dataType == EC_TAGTYPE_UNKNOWN));
		target = tag->GetInt();
		return true;
	}
	return false;
}
Пример #11
0
static EcInt ustring_print( ec_string *str, EC_OBJ obj, EcBool detailed )
{
	EcInt res = 0;
	EC_ASSERT( EC_USTRINGP(obj) );

	{
		ec_strcat( str, "<unicode string>", sizeof("<unicode string>") - 1 );
		res += sizeof("<unicode string>") - 1;
	}
	return res;
}
Пример #12
0
/**
 * Creates a new CECTag instance from the given data
 *
 * @param name	 TAG name
 * @param length length of data buffer
 * @param data	 TAG data
 *
 */
CECTag::CECTag(ec_tagname_t name, unsigned int length, const void *data) : m_tagName(name)
{
	if (data) {
		m_dataLen = length;
		NewData();
		memcpy(m_tagData, data, m_dataLen);
	} else {
		EC_ASSERT(length == 0);
		m_dataLen = 0;
		m_tagData = NULL;
	}
	m_dataType = EC_TAGTYPE_CUSTOM;
}
Пример #13
0
uint8_t CECTag::AssignIfExist(ec_tagname_t tagname, uint8_t *target) const
{
	uint8_t ret = 0;
	const CECTag *tag = GetTagByName(tagname);
	if (tag) {
		EC_ASSERT((tag->GetType() == EC_TAGTYPE_UINT8) || (m_dataType == EC_TAGTYPE_UNKNOWN));
		ret = tag->GetInt();
		if (target) {
			*target = ret;
		}
	}
	return ret;
}
Пример #14
0
static EC_OBJ string_int( EC_OBJ obj )
{
	EcInt   val;
	char   *endptr;

	EC_ASSERT( EC_USTRINGP(obj) );

	val = strtol( EC_USTRDATA(obj), &endptr, 0 );
	if (((val == LONG_MIN) ||
		 (val == LONG_MAX)) &&
		(errno == ERANGE))
		return EcTypeError( EC_NIL, EC_NIL, 1, tc_none, obj, TRUE, "string int: undeflow or overflow" );
	if (endptr == EC_USTRDATA(obj))
		return EcTypeError( EC_NIL, EC_NIL, 1, tc_none, obj, TRUE, "string int: bad integer number" );

	return EcMakeInt( val );
}
Пример #15
0
static EC_OBJ string_float( EC_OBJ obj )
{
	EcFloat val;
	char   *endptr;

	EC_ASSERT( EC_USTRINGP(obj) );

	val = strtod( EC_USTRDATA(obj), &endptr );
	if (((val == HUGE_VAL) ||
		 (val == -HUGE_VAL)) &&
		(errno == ERANGE))
		return EcTypeError( EC_NIL, EC_NIL, 1, tc_none, obj, TRUE, "string float: undeflow or overflow" );
	if (endptr == EC_USTRDATA(obj))
		return EcTypeError( EC_NIL, EC_NIL, 1, tc_none, obj, TRUE, "string float: bad decimal number" );

	return EcMakeFloat( val );
}
Пример #16
0
static EC_OBJ ustring_add( EC_OBJ obj1, EC_OBJ obj2 )
{
	/* ec_string str; */
	EC_OBJ    res;
	EcInt     len;

	/* add chars later */
	if (/* (! EC_CHARP(obj2)) && */(! EC_USTRINGP(obj2)))
		return EcTypeError( EC_NIL, EC_NIL, 2, tc_none, obj2, TRUE, "string add" );

	EC_ASSERT( EC_USTRINGP(obj1) );

	len = EC_USTRLEN(obj1) + EC_USTRLEN(obj2);
	res = EcMakeUString( EC_USTRDATA(obj1), len , EcTrue );
	u_strcat(EC_USTRDATA(res), EC_USTRDATA(obj2) );
	EC_USTRLEN(res) = len;

	return res;
}
Пример #17
0
static EC_OBJ ustring_mul( EC_OBJ obj1, EC_OBJ obj2 )
{
	ec_string str;
	EC_OBJ    res;
	EcInt     i;

	if (! EC_INUMP(obj2))
		return EcTypeError( EC_NIL, EC_NIL, 2, tc_inum, obj2, TRUE, "string mul" );

	EC_ASSERT( EC_USTRINGP(obj1) );

	ec_string_init( &str, NULL );
	for (i = 0; i < EC_INUM(obj2); i++)
		ec_strcat( &str, EC_USTRDATA(obj1), EC_USTRLEN(obj1) );
	res = EcMakeString( ec_strdata( &str ), ec_strlen( &str ) );
	ec_string_cleanup( &str );

	return res;
}
Пример #18
0
static EC_OBJ string_promote( EC_OBJ obj1, EC_OBJ obj2 )
{
	ec_string str;
	EC_OBJ    repr2;
	EC_OBJ    res;

	EC_ASSERT( EC_USTRINGP(obj1 ) );

	ec_string_init( &str, NULL );
	ec_sprintf( &str, "%w", obj2 );
	repr2 = EcMakeString( ec_strdata( &str ), ec_strlen( &str ) );
	ec_string_cleanup( &str );

	res = EcMakeArray( 2 );
	if (EC_ERRORP(res)) return res;

	EcArrayPush( res, obj1 );
	EcArrayPush( res, repr2 );
	return res;
}
Пример #19
0
static EC_OBJ string_delitem( EC_OBJ obj, EC_OBJ index )
{
	EcInt idx;

	if (! EC_INUMP(index))
	{
		/* TODO: Throw an exception */
		EC_ASSERT( FALSE );
		return Ec_ERROR;
	}

	if ((EC_INUM(index) < 0) || (EC_INUM(index) >= EC_USTRLEN(obj)))
	{
		ec_string ds;

		ec_string_init( &ds, NULL );
		ec_sprintf( &ds, "Index %ld out of bounds for object %w", EC_INUM(index), obj );

		EcMakeExceptionWithArgs( EcIndexErrorClass,
								 ec_strdata( &ds ), 2,
								 index, obj );
		ec_string_cleanup( &ds );
		return Ec_ERROR;
	}

	idx = EC_INUM(index);
	if (idx < EC_USTRLEN(obj) - 1)
	{
		memcpy( EC_USTRDATA(obj) + idx, EC_USTRDATA(obj) + idx + 1, EC_USTRLEN(obj) - idx - 1 );
		EC_USTRLEN(obj) -= 1;
	}
	else
	{
		EC_USTRDATA(obj)[idx] = '\0';							/* unnecessary */
		EC_USTRLEN(obj) -= 1;
	}

	return obj;
}
Пример #20
0
bool CECTag::WriteTag(CECSocket& socket) const
{
	ec_tagname_t tmp_tagName = (m_tagName << 1) | (m_tagList.empty() ? 0 : 1);
	ec_tagtype_t type = m_dataType;
	ec_taglen_t tagLen = GetTagLen();
	EC_ASSERT(type != EC_TAGTYPE_UNKNOWN);

	if (!socket.WriteNumber(&tmp_tagName, sizeof(ec_tagname_t))) return false;
	if (!socket.WriteNumber(&type, sizeof(ec_tagtype_t))) return false;
	if (!socket.WriteNumber(&tagLen, sizeof(ec_taglen_t))) return false;

	if (!m_tagList.empty()) {
		if (!WriteChildren(socket)) return false;
	}

	if (m_dataLen > 0) {
		if (m_tagData != NULL) {	// This is here only to make sure everything, it should not be NULL at this point
			if (!socket.WriteBuffer(m_tagData, m_dataLen)) return false;
		}
	}

	return true;
}
Пример #21
0
EC_OBJ ec_unicode_init( void )
{
	EC_OBJ pkg;

	EcSequenceCallbacks sequence_cb = {
		/* getitem */		NULL /* ustring_getitem */,
		/* setitem */		NULL /* ustring_setitem */,
		/* delitem */		NULL /* ustring_delitem */,
		/* length  */		ustring_length
	};

	EcNumericCallbacks numeric_cb = {
		/* promote */		NULL /* ustring_promote */,
		/* add     */		ustring_add,
		/* radd    */		ustring_radd,
		/* sub     */		NULL,
		/* rsub    */		NULL,
		/* mul     */		NULL /* ustring_mul */,
		/* rmul    */		NULL,
		/* div     */		NULL,
		/* rdiv    */		NULL,
		/* mod     */		NULL,
		/* rmod    */		NULL,
		/* pow     */		NULL,
		/* rpow    */		NULL,
		/* lshift  */		NULL,
		/* rlshift */		NULL,
		/* rshift  */		NULL,
		/* rrshift */		NULL,
		/* and     */		NULL,
		/* rand    */		NULL,
		/* or      */		NULL,
		/* ror     */		NULL,
		/* xor     */		NULL,
		/* rxor    */		NULL,
		/* neg     */		NULL,
		/* pos     */		NULL,
		/* abs     */		NULL,
		/* invert  */		NULL,
		/* int     */		NULL /* ustring_int */,
		/* float   */		NULL /* ustring_float */,
		/* true    */		ustring_true
	};

	EcTypespec ustringspec = {
		/* type    */		0,
		/* name    */		"ustring",

		/* copy    */		ustring_copy,

		/* mark    */		ustring_mark,
		/* free    */		ustring_free,
		/* print   */		ustring_print,

		/* hash    */		ustring_hash,
		/* compare */		ustring_compare,

		/* check   */		NULL,

		/* sequence */      &sequence_cb,
		/* numeric  */      &numeric_cb
	};

	tc_ustring = EcAddType( &ustringspec );
	EC_ASSERT (tc_ustring != 0);

	/* Register package */
	pkg = EcPackageIntroduce( "unicode" );

	EcAddPrimitive( "unicode.utf8_to_uc", EcUnicode_UTF8ToUnicode );
	EcAddPrimitive( "unicode.uc_to_utf8", EcUnicode_UnicodeToUTF8 );

	return pkg;
}
Пример #22
0
static void ustring_mark( EC_OBJ obj )
{
	EC_ASSERT( EC_USTRINGP(obj) );
}
Пример #23
0
static EC_OBJ ustring_copy( EC_OBJ obj, EcCopyType type )
{
	EC_ASSERT( EC_USTRINGP(obj) );

	return EcMakeUString( EC_USTRDATA(obj), EC_USTRLEN(obj) , EcTrue );
}
Пример #24
0
static EcUInt ustring_hash( EC_OBJ obj, EcInt recur )
{
	EC_ASSERT( EC_USTRINGP(obj) );

	return ec_hash_pjw_string( (char *)EC_USTRDATA(obj) );
}