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 40void 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 51void 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 71void 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 89flag 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 114uint32 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 131void 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 153void 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 177uint32 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 187uint32 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 200uint32 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