1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/* ---- includes ----------------------------------------------------------- */
18
19#include "b_BasicEm/Functions.h"
20#include "b_BasicEm/Int16Arr.h"
21
22#ifndef bbs_TYPES_64_AVAILABLE
23#include <stdint.h>
24#endif
25
26/* ------------------------------------------------------------------------- */
27
28/* ========================================================================= */
29/*                                                                           */
30/* ---- \ghd{ auxiliary functions } ---------------------------------------- */
31/*                                                                           */
32/* ========================================================================= */
33
34/* ------------------------------------------------------------------------- */
35
36/* ========================================================================= */
37/*                                                                           */
38/* ---- \ghd{ constructor / destructor } ----------------------------------- */
39/*                                                                           */
40/* ========================================================================= */
41
42/* ------------------------------------------------------------------------- */
43
44void bbs_Int16Arr_init( struct bbs_Context* cpA,
45					    struct bbs_Int16Arr* ptrA )
46{
47	ptrA->arrPtrE = NULL;
48	ptrA->sizeE = 0;
49	ptrA->allocatedSizeE = 0;
50	ptrA->mspE = NULL;
51}
52
53/* ------------------------------------------------------------------------- */
54
55void bbs_Int16Arr_exit( struct bbs_Context* cpA,
56					    struct bbs_Int16Arr* ptrA )
57{
58	bbs_MemSeg_free( cpA, ptrA->mspE, ptrA->arrPtrE );
59	ptrA->arrPtrE = NULL;
60	ptrA->mspE = NULL;
61	ptrA->sizeE = 0;
62	ptrA->allocatedSizeE = 0;
63}
64
65/* ------------------------------------------------------------------------- */
66
67/* ========================================================================= */
68/*                                                                           */
69/* ---- \ghd{ operators } -------------------------------------------------- */
70/*                                                                           */
71/* ========================================================================= */
72
73/* ------------------------------------------------------------------------- */
74
75void bbs_Int16Arr_copy( struct bbs_Context* cpA,
76					    struct bbs_Int16Arr* ptrA,
77						const struct bbs_Int16Arr* srcPtrA )
78{
79#ifdef DEBUG1
80	if( ptrA->allocatedSizeE < srcPtrA->sizeE )
81	{
82		bbs_ERROR0( "void bbs_Int16Arr_copy(...):\n"
83				   "Insufficient allocated memory in destination array." );
84		return;
85	}
86#endif
87	bbs_Int16Arr_size( cpA, ptrA, srcPtrA->sizeE );
88	bbs_memcpy16( ptrA->arrPtrE, srcPtrA->arrPtrE, srcPtrA->sizeE * bbs_SIZEOF16( int16 ) );
89}
90
91/* ------------------------------------------------------------------------- */
92
93flag bbs_Int16Arr_equal( struct bbs_Context* cpA,
94						 const struct bbs_Int16Arr* ptrA,
95						 const struct bbs_Int16Arr* srcPtrA )
96{
97	uint32 iL;
98	const int16* ptr1L = ptrA->arrPtrE;
99	const int16* ptr2L = srcPtrA->arrPtrE;
100	if( ptrA->sizeE != srcPtrA->sizeE ) return FALSE;
101	for( iL = ptrA->sizeE; iL > 0; iL-- )
102	{
103		if( *ptr1L++ != *ptr2L++ ) return FALSE;
104	}
105	return TRUE;
106}
107
108/* ------------------------------------------------------------------------- */
109
110/* ========================================================================= */
111/*                                                                           */
112/* ---- \ghd{ query functions } -------------------------------------------- */
113/*                                                                           */
114/* ========================================================================= */
115
116/* ------------------------------------------------------------------------- */
117
118uint32 bbs_Int16Arr_heapSize( struct bbs_Context* cpA,
119							  const struct bbs_Int16Arr* ptrA,
120							  uint32 sizeA )
121{
122	return sizeA * bbs_SIZEOF16( int16 ) + bbs_MEM_BLOCK_OVERHD;
123}
124
125/* ------------------------------------------------------------------------- */
126
127/* ========================================================================= */
128/*                                                                           */
129/* ---- \ghd{ modify functions } ------------------------------------------- */
130/*                                                                           */
131/* ========================================================================= */
132
133/* ------------------------------------------------------------------------- */
134
135void bbs_Int16Arr_create( struct bbs_Context* cpA,
136						  struct bbs_Int16Arr* ptrA,
137						  uint32 sizeA,
138						  struct bbs_MemSeg* mspA )
139{
140	if( bbs_Context_error( cpA ) ) return;
141	if( ptrA->sizeE == sizeA ) return;
142	if( ptrA->arrPtrE != 0 )
143	{
144		bbs_Int16Arr_size( cpA, ptrA, sizeA );
145	}
146	else
147	{
148		ptrA->arrPtrE = bbs_MemSeg_alloc( cpA, mspA, sizeA * bbs_SIZEOF16( int16 ) );
149		if( bbs_Context_error( cpA ) ) return;
150		ptrA->allocatedSizeE = sizeA;
151		ptrA->sizeE = sizeA;
152		if( !mspA->sharedE ) ptrA->mspE = mspA;
153	}
154}
155
156/* ------------------------------------------------------------------------- */
157
158void bbs_Int16Arr_createAligned( struct bbs_Context* cpA,
159								 struct bbs_Int16Arr* ptrA,
160								 uint32 sizeA,
161								 struct bbs_MemSeg* mspA,
162								 struct bbs_Int16Arr* allocPtrA,
163								 uint32 alignBytesA )
164{
165	/* allocate extra memory for alignment */
166	bbs_Int16Arr_create( cpA, allocPtrA, sizeA + ( ( alignBytesA - 1 ) >> 1 ), mspA );
167
168	/* set members of ptrA */
169	ptrA->mspE = 0; /* no own allocated memory */
170	ptrA->sizeE = sizeA;
171	ptrA->allocatedSizeE = ptrA->sizeE;
172	ptrA->arrPtrE = allocPtrA->arrPtrE;
173
174#if defined( WIN32 ) || defined( _WIN32_WCE )
175	/* disable warning "pointer truncation...": */
176	#pragma warning( disable : 4311 )
177#endif
178
179
180	/* align memory */
181#ifdef bbs_TYPES_64_AVAILABLE
182
183	while( ( ( ( uint64 ) ptrA->arrPtrE ) & ( alignBytesA - 1 ) ) )
184	{
185		ptrA->arrPtrE++;
186	}
187#else
188	while( ( ( ( uintptr_t ) ptrA->arrPtrE ) & ( alignBytesA - 1 ) ) )
189	{
190		ptrA->arrPtrE++;
191	}
192#endif
193
194}
195
196/* ------------------------------------------------------------------------- */
197
198void bbs_Int16Arr_size( struct bbs_Context* cpA,
199					    struct bbs_Int16Arr* ptrA,
200						uint32 sizeA )
201{
202	if( ptrA->allocatedSizeE < sizeA )
203	{
204		bbs_ERROR1( "void bbs_Int16Arr_size( struct bbs_Int16Arr*, uint32 sizeA ):\n"
205				   "Unsufficient allocated memory (allocatedSizeE = '%i')",
206				   ptrA->allocatedSizeE );
207		return;
208	}
209	ptrA->sizeE = sizeA;
210}
211
212/* ------------------------------------------------------------------------- */
213
214/* ========================================================================= */
215/*                                                                           */
216/* ---- \ghd{ I/O } -------------------------------------------------------- */
217/*                                                                           */
218/* ========================================================================= */
219
220/* ------------------------------------------------------------------------- */
221
222uint32 bbs_Int16Arr_memSize( struct bbs_Context* cpA,
223							 const struct bbs_Int16Arr* ptrA )
224{
225	return bbs_SIZEOF16( uint32 ) + bbs_SIZEOF16( ptrA->sizeE ) +
226										ptrA->sizeE * bbs_SIZEOF16( int16 );
227}
228
229/* ------------------------------------------------------------------------- */
230
231uint32 bbs_Int16Arr_memWrite( struct bbs_Context* cpA,
232							  const struct bbs_Int16Arr* ptrA,
233							  uint16* memPtrA )
234{
235	uint32 memSizeL = bbs_Int16Arr_memSize( cpA, ptrA );
236	memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
237	memPtrA += bbs_memWrite32( &ptrA->sizeE, memPtrA );
238	memPtrA += bbs_memWrite16Arr( cpA, ptrA->arrPtrE, ptrA->sizeE, memPtrA );
239	return memSizeL;
240}
241
242/* ------------------------------------------------------------------------- */
243
244uint32 bbs_Int16Arr_memRead( struct bbs_Context* cpA,
245							 struct bbs_Int16Arr* ptrA,
246							 const uint16* memPtrA,
247							 struct bbs_MemSeg* mspA )
248{
249	uint32 memSizeL, sizeL;
250	if( bbs_Context_error( cpA ) ) return 0;
251	memPtrA += bbs_memRead32( &memSizeL, memPtrA );
252	memPtrA += bbs_memRead32( &sizeL, memPtrA );
253	bbs_Int16Arr_create( cpA, ptrA, sizeL, mspA );
254	memPtrA += bbs_memRead16Arr( cpA, ptrA->arrPtrE, ptrA->sizeE, memPtrA );
255
256	if( memSizeL != bbs_Int16Arr_memSize( cpA, ptrA ) )
257	{
258		bbs_ERR0( bbs_ERR_CORRUPT_DATA,
259				  "uint32 bbs_Int16Arr_memRead( const struct bbs_Int16Arr*, const uint16* ):\n"
260                  "size mismatch" );
261		return 0;
262	}
263	return memSizeL;
264}
265
266/* ------------------------------------------------------------------------- */
267
268/* ========================================================================= */
269/*                                                                           */
270/* ---- \ghd{ exec functions } --------------------------------------------- */
271/*                                                                           */
272/* ========================================================================= */
273
274/* ------------------------------------------------------------------------- */
275
276void bbs_Int16Arr_fill( struct bbs_Context* cpA,
277					    struct bbs_Int16Arr* ptrA,
278						int16 valA )
279{
280	uint32 iL;
281	for( iL = 0; iL < ptrA->sizeE; iL++ )
282	{
283		ptrA->arrPtrE[ iL ] = valA;
284	}
285}
286
287/* ------------------------------------------------------------------------- */
288
289/* ========================================================================= */
290
291
292