Navigation

← Previous Changeset
Next Changeset →

Changeset 447

Timestamp:

08/08/07 04:40:40 (1 year ago)

Author:

krobillard

Message:

ur_makeBinary() now takes pointer argument.

Files:

branches/thune/thread_safe/encoding.c (modified) (2 diffs)
branches/thune/thread_safe/eval.c (modified) (2 diffs)
branches/thune/thread_safe/files.c (modified) (4 diffs)
branches/thune/thread_safe/make.c (modified) (10 diffs)
branches/thune/thread_safe/net.c (modified) (1 diff)
branches/thune/thread_safe/series.c (modified) (2 diffs)
branches/thune/thread_safe/thread.c (modified) (2 diffs)
branches/thune/thread_safe/tokenize.c (modified) (1 diff)
branches/thune/thread_safe/unix/os.c (modified) (1 diff)
branches/thune/thread_safe/urlan.c (modified) (1 diff)
branches/thune/thread_safe/urlan.h (modified) (3 diffs)
branches/thune/thread_safe/win32/os.c (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

branches/thune/thread_safe/encoding.c

r387	r447
87	87	case UR_ENC_UTF16:
88	88	count >>= 1;
89		strN = ur_makeBinary( count );
90		bin = ur_binPtr( strN );
	89	strN = ur_makeBinary( count, &bin );
91	90	bin->used = copyUtf16ToAscii( bin->ptr.c,
92	91	(uint16_t*) cpA, count );
…	…
114	113	{
115	114	case UR_ENC_ASCII:
116		strN = ur_makeBinary( count * 2 );
117		bin = ur_binPtr( strN );
	115	strN = ur_makeBinary( count * 2, &bin );
118	116	bin->used = copyAsciiToUtf16( bin->ptr.u16,
119	117	cpA, count );

branches/thune/thread_safe/eval.c

r442	r447
1242	1242	UString* str;
1243	1243
1244		binN = ur_makeBinary( 0 );
1245		str = ur_binPtr( binN );
	1244	binN = ur_makeBinary( 0, &str );
1246	1245
1247	1246	ur_toStr( val, str, 0 );
…	…
1644	1643	if( ! ur_is(tos, UT_STRING) )
1645	1644	{
1646		UIndex strN = ur_makeBinary( 0 );
1647		ur_toStrNatural( ut, tos, ur_binPtr(strN), 0 );
	1645	UString* bin;
	1646	UIndex strN = ur_makeBinary( 0, &bin );
	1647	ur_toStrNatural( ut, tos, bin, 0 );
1648	1648	ur_initString(tos, strN, 0);
1649	1649	}

branches/thune/thread_safe/files.c

r439	r447
386	386	}
387	387
388		binN = ur_makeBinary( size /+ OR_CTERM_LEN/ );
389		buf = ur_binPtr( binN );
	388	binN = ur_makeBinary( size /+ OR_CTERM_LEN/, &buf );
390	389
391	390	fp = fileOpen( fn, FILE_READ_BINARY );
…	…
669	668	blen = len + (len / 99) + 600;
670	669
671		binN = ur_makeBinary( blen /+ 4/ );
672		bin = ur_binPtr( binN );
	670	binN = ur_makeBinary( blen /+ 4/, &bin );
673	671
674	672	if( len > 0 )
…	…
725	723	strm.avail_in = len;
726	724
727		strN = ur_makeBinary( (len < BUF_LOW) ? BUF_LOW : len );
728		str = ur_binPtr(strN);
	725	strN = ur_makeBinary( (len < BUF_LOW) ? BUF_LOW : len, &str );
729	726	strm.next_out = str->ptr.c;
730	727	strm.avail_out = str->avail;
…	…
825	822	UBinary* bin;
826	823
827		binN = ur_makeBinary( 20 );
828		bin = ur_binPtr( binN );
	824	binN = ur_makeBinary( 20, &bin );
829	825	bin->used = 20;
830	826

branches/thune/thread_safe/make.c

r445	r447
115	115	Size is the number of bytes to reserve. Used is set to 0.
116	116	*/
117		UIndex ur_makeBinaryT( UThread* ut, int size )
	117	UIndex ur_makeBinaryT( UThread* ut, int size, UBinary** binPtr )
118	118	{
119	119	UBinary* ptr;
…	…
148	148
149	149	ur_arrayInit( ptr, sizeof(char), size );
	150	if( binPtr )
	151	*binPtr = ptr;
150	152	return ur_binN( ptr );
151	153	}
…	…
167	169
168	170	size = cpB - cpA;
169		binN = ur_makeBinary( size );
	171	binN = ur_makeBinary( size, &bin );
170	172	if( size )
171	173	{
172		~~bin = ur_binPtr( binN );~~
173	174	memCpy( bin->ptr.b, cpA, size );
174	175	bin->used = size;
…	…
627	628	if( len == 0 )
628	629	{
629		return ur_makeBinary( 0 );
	630	return ur_makeBinary( 0, 0 );
630	631	}
631	632
…	…
638	639	}
639	640
640		strN = ur_makeBinary( len + UR_CTERM_LEN );
641		str = ur_binPtr( strN );
	641	strN = ur_makeBinary( len + UR_CTERM_LEN, &str );
642	642
643	643	cp = txt;
…	…
685	685	UArray* bin;
686	686
687		binN = ur_makeBinary( size * sizeof(int32_t) );
688		bin = ur_binPtr( binN );
	687	binN = ur_makeBinary( size * sizeof(int32_t), &bin );
689	688	bin->avail /= sizeof(int32_t);
690	689
…	…
903	902	bits = bin->ptr.b;
904	903
905		binN = ur_makeBinary( bin->used );
906		bin = ur_binPtr( binN );
	904	binN = ur_makeBinary( bin->used, &bin );
907	905	bin->used = len;
908	906	memCpy( bin->ptr.b, bits, len );
…	…
914	912	}
915	913
916		binN = ur_makeBinary( len );
917		bin = ur_binPtr( binN );
	914	binN = ur_makeBinary( len, &bin );
918	915	bin->used = len;
919	916	bits = bin->ptr.b;
…	…
1615	1612
1616	1613	case UT_BINARY:
	1614	{
	1615	UIndex binN;
	1616	UBinary* bin;
	1617
1617	1618	if( ur_is(tos, UT_INT) )
1618	1619	{
1619		UIndex binN;
1620		binN = ur_makeBinary( ur_int(tos) );
	1620	binN = ur_makeBinary( ur_int(tos), &bin );
1621	1621
1622	1622	if( argc == 2 )
1623	1623	{
1624		~~UBinary* bin = ur_binPtr( binN );~~
1625	1624	int32_t n = ur_int( ur_s_prev(tos) );
1626	1625	bin->used = ur_int(tos);
…	…
1647	1646	}
1648	1647	}
1649
1650		ur_initType(res, UT_BINARY);
1651		ur_setSeries(res, binN, 0);
	1648	goto init_bin;
1652	1649	}
1653	1650	else if( ur_stringSlice(ut, tos, &spA, &spB) )
1654	1651	{
1655		UIndex binN;
1656		binN = ur_makeBinary( 0 );
	1652	binN = ur_makeBinary( 0, &bin );
1657	1653	if( spA )
1658		ur_readBinary( ur_binPtr( binN ), spA, spB );
1659		ur_initType(res, UT_BINARY);
1660		ur_setSeries(res, binN, 0);
1661		}
	1654	ur_readBinary( bin, spA, spB );
	1655	init_bin:
	1656	ur_initBinary(res, binN, 0);
	1657	}
	1658	}
1662	1659	break;
1663	1660
1664	1661	case UT_STRING:
	1662	{
	1663	UIndex binN;
	1664
1665	1665	if( ur_is(tos, UT_INT) )
1666	1666	{
1667		UIndex binN;
1668		binN = ur_makeBinary( ur_int(tos) );
1669		ur_initType(res, UT_STRING);
1670		//ur_setEncoding(res, UR_ENC_ASCII);
1671		ur_setSeries(res, binN, 0);
	1667	binN = ur_makeBinary( ur_int(tos), 0 );
	1668	goto init_str;
1672	1669	}
1673	1670	else if( ur_is(tos, UT_BLOCK) )
1674	1671	{
1675		~~UIndex binN;~~
1676	1672	UString* str;
1677
1678		binN = ur_makeBinary(0);
1679		str = ur_binPtr(binN);
1680
	1673	binN = ur_makeBinary(0, &str);
1681	1674	ur_toStr( tos, str, 0 );
1682
1683		ur_initType(res, UT_STRING);
1684		//ur_setEncoding(res, UR_ENC_ASCII);
1685		ur_setSeries(res, binN, 0);
	1675	goto init_str;
1686	1676	}
1687	1677	else if( ur_stringSlice(ut, tos, &spA, &spB) )
1688	1678	{
1689		~~UIndex binN;~~
1690
1691	1679	if( spA )
1692	1680	binN = ur_makeString( spA, spB - spA );
1693	1681	else
1694		binN = ur_makeBinary( 0 );
1695
1696		ur_initType(res, UT_STRING);
1697		//ur_setEncoding(res, UR_ENC_ASCII);
1698		ur_setSeries(res, binN, 0);
1699		}
	1682	binN = ur_makeBinary( 0, 0 );
	1683	init_str:
	1684	ur_initString( res, binN, 0 );
	1685	}
	1686	}
1700	1687	break;
1701	1688

branches/thune/thread_safe/net.c

r389	r447
258	258	{
259	259	UIndex binN;
	260	UBinary* bin;
260	261
261	262	ur_initType(val, UT_INT); // SV_FD
262	263	ur_int(val) = socket;
263	264
264		binN = ur_makeBinary( sizeof(struct sockaddr) );
	265	binN = ur_makeBinary( sizeof(struct sockaddr), &bin );
265	266	if( spec )
266	267	{
267		~~UBinary* bin = ur_binPtr( binN );~~
268	268	bin->used = sizeof(addr);
269	269	memCpy( bin->ptr.v, &addr, sizeof(addr) );

branches/thune/thread_safe/series.c

r446	r447
2245	2245	{
2246	2246	UBinary* orig;
	2247	UBinary* copy;
2247	2248	UIndex copyN;
2248	2249	int len;
…	…
2255	2256	len = part;
2256	2257
2257		copyN = ur_makeBinary( len * elemSize );
	2258	copyN = ur_makeBinary( len * elemSize, &copy );
2258	2259	if( len > 0 )
2259	2260	{
2260		~~UBinary* copy = ur_binPtr( copyN );~~
2261	2261	memCpy( copy->ptr.b,
2262	2262	orig->ptr.b + (val->series.it * elemSize),

branches/thune/thread_safe/thread.c

r431	r447
71	71
72	72	{
73		UIndex binN = ur_makeBinary( 0 );
	73	UIndex binN = ur_makeBinary( 0, 0 );
74	74	assert( binN == BIN_THREAD_TMP );
75	75	//ur_hold( ut, UT_BINARY, binN ); // Hardcoded in recycle
…	…
238	238	//(void) exceptionType;
239	239
240		strN = ur_makeBinary( MAX_ERR_LEN );
241		str = ur_binPtr( strN );
	240	strN = ur_makeBinary( MAX_ERR_LEN, &str );
242	241
243	242	va_start( arg, fmt );

branches/thune/thread_safe/tokenize.c

r442	r447
839	839	if( ch == '}' )
840	840	{
	841	UBinary* bin;
	842
841	843	if( tn & 1 )
842	844	goto binary_err;
843	845
844		tn = ur_makeBinary( 0 );
845		ur_readBinary( ~~ur_binPtr(tn)~~, token + 2, it );
	846	tn = ur_makeBinary( 0, &bin );
	847	ur_readBinary( bin, token + 2, it );
846	848
847	849	cell = ur_appendCell( BLOCK, UT_BINARY );

branches/thune/thread_safe/unix/os.c

r432	r447
73	73	assert( len > 0 );
74	74
75		binN = ur_makeBinary( len + 1 );
76		str = ur_binPtr( binN );
	75	binN = ur_makeBinary( len + 1, &str );
77	76	str->used = len;
78	77	memCpy( str->ptr.c, tmp, len );

branches/thune/thread_safe/urlan.c

r442	r447
668	668	ur_pushContext( ut, (UCell*) &ur_thrGlobal );
669	669
670		ur_makeBinary( 0 ); // 0 - BIN_THREAD_TMP
	670	ur_makeBinary( 0, 0 ); // 0 - BIN_THREAD_TMP
671	671	}
672	672

branches/thune/thread_safe/urlan.h

r442	r447
548	548	UCell* ur_makePort( UThread, UPortDevice dev, UCell* res );
549	549	UIndex ur_makeBlockT( UThread, int size, UBlock* ptr );
550		UIndex ur_makeBinaryT( UThread*, int size );
	550	UIndex ur_makeBinaryT( UThread, int size, UBinary* ptr );
551	551	UIndex ur_makeBinaryFrom( UThread, const UCell );
552	552	UIndex ur_makeStringT( UThread, const char txt, int len );
…	…
615	615
616	616	#define ur_makeBlock(size) ur_makeBlockT(ut,size,0)
617		#define ur_makeBinary(size~~) ur_makeBinaryT(ut,size~~)
	617	#define ur_makeBinary(size,ptr) ur_makeBinaryT(ut,size,ptr)
618	618	#define ur_makeString(txt,len) ur_makeStringT(ut,txt,len)
619	619	#define ur_makeVector(size,ptr) ur_makeVectorT(ut,size,ptr)
…	…
664	664
665	665	#define ur_setSeries(c,sn,sit) \
666		(c)->series.n = sn; \
667		(c)->series.it = sit
	666	(c)->series.n = sn; \
	667	(c)->series.it = sit;
668	668
669	669	#define ur_bindType(c) (c->word.flags & UR_FLAG_BIND_MASK)

branches/thune/thread_safe/win32/os.c

r439	r447
68	68	assert( len > 0 );
69	69
70		binN = ur_makeBinary( len + 1 );
71		str = ur_binPtr( binN );
	70	binN = ur_makeBinary( len + 1, &str );
72	71	str->used = len;
73	72	memCpy( str->ptr.c, tmp, len );

Navigation

Changeset 447

Legend:

Download in other formats: