Home | History | Annotate | Download | only in b_BasicEm
      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/ComplexArr.h"
     21 
     22 /* ------------------------------------------------------------------------- */
     23 
     24 /* ========================================================================= */
     25 /*                                                                           */
     26 /* ---- \ghd{ auxiliary functions } ---------------------------------------- */
     27 /*                                                                           */
     28 /* ========================================================================= */
     29 
     30 /* ------------------------------------------------------------------------- */
     31 
     32 /* ========================================================================= */
     33 /*                                                                           */
     34 /* ---- \ghd{ constructor / destructor } ----------------------------------- */
     35 /*                                                                           */
     36 /* ========================================================================= */
     37 
     38 /* ------------------------------------------------------------------------- */
     39 
     40 void bbs_ComplexArr_init( struct bbs_Context* cpA,
     41 						  struct bbs_ComplexArr* ptrA )
     42 {
     43 	ptrA->arrPtrE = NULL;
     44 	ptrA->sizeE = 0;
     45 	ptrA->allocatedSizeE = 0;
     46 	ptrA->mspE = NULL;
     47 }
     48 
     49 /* ------------------------------------------------------------------------- */
     50 
     51 void bbs_ComplexArr_exit( struct bbs_Context* cpA,
     52 						  struct bbs_ComplexArr* ptrA )
     53 {
     54 	bbs_MemSeg_free( cpA, ptrA->mspE, ptrA->arrPtrE );
     55 	ptrA->arrPtrE = NULL;
     56 	ptrA->mspE = NULL;
     57 	ptrA->sizeE = 0;
     58 	ptrA->allocatedSizeE = 0;
     59 }
     60 
     61 /* ------------------------------------------------------------------------- */
     62 
     63 /* ========================================================================= */
     64 /*                                                                           */
     65 /* ---- \ghd{ operators } -------------------------------------------------- */
     66 /*                                                                           */
     67 /* ========================================================================= */
     68 
     69 /* ------------------------------------------------------------------------- */
     70 
     71 void bbs_ComplexArr_copy( struct bbs_Context* cpA,
     72 						  struct bbs_ComplexArr* ptrA,
     73 						  const struct bbs_ComplexArr* srcPtrA )
     74 {
     75 #ifdef DEBUG1
     76 	if( ptrA->allocatedSizeE < srcPtrA->allocatedSizeE )
     77 	{
     78 		bbs_ERROR0( "void bbs_ComplexArr_copy( ... ):\n"
     79 				   "Unsufficient allocated memory in destination array." );
     80 		return;
     81 	}
     82 #endif
     83 	bbs_ComplexArr_size( cpA, ptrA, srcPtrA->sizeE );
     84 	bbs_memcpy32( ptrA->arrPtrE, srcPtrA->arrPtrE, srcPtrA->sizeE * bbs_SIZEOF32( struct bbs_Complex ) );
     85 }
     86 
     87 /* ------------------------------------------------------------------------- */
     88 
     89 flag bbs_ComplexArr_equal( struct bbs_Context* cpA,
     90 						   const struct bbs_ComplexArr* ptrA,
     91 						   const struct bbs_ComplexArr* srcPtrA )
     92 {
     93 	uint32 iL;
     94 	const struct bbs_Complex* ptr1L = ptrA->arrPtrE;
     95 	const struct bbs_Complex* ptr2L = srcPtrA->arrPtrE;
     96 	if( ptrA->sizeE != srcPtrA->sizeE ) return FALSE;
     97 	for( iL = ptrA->sizeE; iL > 0; iL-- )
     98 	{
     99 		if( !bbs_Complex_equal( *ptr1L, *ptr2L ) ) return FALSE;
    100 	}
    101 	return TRUE;
    102 }
    103 
    104 /* ------------------------------------------------------------------------- */
    105 
    106 /* ========================================================================= */
    107 /*                                                                           */
    108 /* ---- \ghd{ query functions } -------------------------------------------- */
    109 /*                                                                           */
    110 /* ========================================================================= */
    111 
    112 /* ------------------------------------------------------------------------- */
    113 
    114 uint32 bbs_ComplexArr_heapSize( struct bbs_Context* cpA,
    115 							    const struct bbs_ComplexArr* ptrA,
    116 								uint32 sizeA )
    117 {
    118 	return sizeA * bbs_SIZEOF16( struct bbs_Complex ) + bbs_MEM_BLOCK_OVERHD;
    119 }
    120 
    121 /* ------------------------------------------------------------------------- */
    122 
    123 /* ========================================================================= */
    124 /*                                                                           */
    125 /* ---- \ghd{ modify functions } ------------------------------------------- */
    126 /*                                                                           */
    127 /* ========================================================================= */
    128 
    129 /* ------------------------------------------------------------------------- */
    130 
    131 void bbs_ComplexArr_create( struct bbs_Context* cpA,
    132 						    struct bbs_ComplexArr* ptrA,
    133 						    uint32 sizeA,
    134 							struct bbs_MemSeg* mspA )
    135 {
    136 	if( bbs_Context_error( cpA ) ) return;
    137 	if( ptrA->arrPtrE != 0 )
    138 	{
    139 		bbs_ComplexArr_size( cpA, ptrA, sizeA );
    140 	}
    141 	else
    142 	{
    143 		ptrA->arrPtrE = bbs_MemSeg_alloc( cpA, mspA, sizeA * bbs_SIZEOF16( struct bbs_Complex ) );
    144 		if( bbs_Context_error( cpA ) ) return;
    145 		ptrA->allocatedSizeE = sizeA;
    146 		ptrA->sizeE = sizeA;
    147 		if( !mspA->sharedE ) ptrA->mspE = mspA;
    148 	}
    149 }
    150 
    151 /* ------------------------------------------------------------------------- */
    152 
    153 void bbs_ComplexArr_size( struct bbs_Context* cpA,
    154 						  struct bbs_ComplexArr* ptrA,
    155 						  uint32 sizeA )
    156 {
    157 	if( ptrA->allocatedSizeE < sizeA )
    158 	{
    159 		bbs_ERROR1( "void bbs_ComplexArr_size( struct bbs_ComplexArr*, uint32 sizeA ):\n"
    160 				   "Unsufficient allocated memory (allocatedSizeE = '%i')",
    161 				   ptrA->allocatedSizeE );
    162 		return;
    163 	}
    164 	ptrA->sizeE = sizeA;
    165 }
    166 
    167 /* ------------------------------------------------------------------------- */
    168 
    169 /* ========================================================================= */
    170 /*                                                                           */
    171 /* ---- \ghd{ I/O } -------------------------------------------------------- */
    172 /*                                                                           */
    173 /* ========================================================================= */
    174 
    175 /* ------------------------------------------------------------------------- */
    176 
    177 uint32 bbs_ComplexArr_memSize( struct bbs_Context* cpA,
    178 							   const struct bbs_ComplexArr* ptrA )
    179 
    180 {
    181 	return	bbs_SIZEOF16( uint32 ) + bbs_SIZEOF16( ptrA->sizeE ) +
    182 	 						ptrA->sizeE * bbs_SIZEOF16( struct bbs_Complex );
    183 }
    184 
    185 /* ------------------------------------------------------------------------- */
    186 
    187 uint32 bbs_ComplexArr_memWrite( struct bbs_Context* cpA,
    188 							    const struct bbs_ComplexArr* ptrA,
    189 								uint16* memPtrA )
    190 {
    191 	uint32 memSizeL = bbs_ComplexArr_memSize( cpA, ptrA );
    192 	memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
    193 	memPtrA += bbs_memWrite32( &ptrA->sizeE, memPtrA );
    194 	memPtrA += bbs_memWrite16Arr( cpA, ptrA->arrPtrE, ptrA->sizeE * 2, memPtrA );
    195 	return memSizeL;
    196 }
    197 
    198 /* ------------------------------------------------------------------------- */
    199 
    200 uint32 bbs_ComplexArr_memRead( struct bbs_Context* cpA,
    201 							   struct bbs_ComplexArr* ptrA,
    202 							   const uint16* memPtrA,
    203 							   struct bbs_MemSeg* mspA )
    204 {
    205 	uint32 memSizeL, sizeL;
    206 	if( bbs_Context_error( cpA ) ) return 0;
    207 	memPtrA += bbs_memRead32( &memSizeL, memPtrA );
    208 	memPtrA += bbs_memRead32( &sizeL, memPtrA );
    209 	bbs_ComplexArr_create( cpA, ptrA, sizeL, mspA );
    210 	memPtrA += bbs_memRead16Arr( cpA, ptrA->arrPtrE, ptrA->sizeE * 2, memPtrA );
    211 
    212 	if( memSizeL != bbs_ComplexArr_memSize( cpA, ptrA ) )
    213 	{
    214 		bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bbs_ComplexArr_memRead( const struct bbs_ComplexArr* ptrA, const void* memPtrA ):\n"
    215                    "size mismatch" );
    216 		return 0;
    217 	}
    218 	return memSizeL;
    219 }
    220 
    221 /* ------------------------------------------------------------------------- */
    222 
    223 /* ========================================================================= */
    224 /*                                                                           */
    225 /* ---- \ghd{ exec functions } --------------------------------------------- */
    226 /*                                                                           */
    227 /* ========================================================================= */
    228 
    229 /* ------------------------------------------------------------------------- */
    230 
    231 /* ========================================================================= */
    232 
    233 
    234